Implemented C integer promotion for systems with 16-bit short and 32-bit int

Author: IsaacShelton

src/asg/datatype/kind/mod.rs

@@ -6,7 +6,6 @@ use super::Type;
 use crate::{
     asg::{human_name::HumanName, Asg, EnumRef, StructRef, TraitRef, TypeAliasRef},
     ast::{fmt_c_integer, CInteger, FloatSize, IntegerBits, IntegerSign},
-    c::implicit_conversions::IntegerRank,
     source_files::Source,
     target::Target,
 };
@@ -78,17 +77,6 @@ impl TypeKind {
         }
     }
 
-    pub fn integer_rank(&self) -> Option<IntegerRank> {
-        match self {
-            TypeKind::Boolean => Some(IntegerRank::Bool),
-            TypeKind::Integer(integer_bits, _) => Some(IntegerRank::Fixed(integer_bits.bits())),
-            TypeKind::CInteger(c_integer, _) => Some(IntegerRank::Flexible(*c_integer)),
-            TypeKind::SizeInteger(_) => Some(IntegerRank::Size),
-            TypeKind::IntegerLiteral(_) => Some(IntegerRank::Flexible(CInteger::Int)),
-            _ => None,
-        }
-    }
-
     pub fn sign(&self, target: Option<&Target>) -> Option<IntegerSign> {
         match self {
             TypeKind::Boolean => Some(IntegerSign::Unsigned),

src/asg/datatype/mod.rs

@@ -1,6 +1,6 @@
 pub mod kind;
 
-use crate::{c::implicit_conversions::IntegerRank, source_files::Source};
+use crate::source_files::Source;
 use core::hash::Hash;
 pub use kind::*;
 use std::fmt::Display;
@@ -28,10 +28,6 @@ impl Type {
     pub fn is_ambiguous(&self) -> bool {
         self.kind.is_ambiguous()
     }
-
-    pub fn integer_rank(self: &Type) -> Option<IntegerRank> {
-        self.kind.integer_rank()
-    }
 }
 
 impl PartialEq for Type {

src/c/implicit_conversions/mod.rs

@@ -1,6 +1,5 @@
 pub mod ast;
 pub mod encoding;
-pub mod implicit_conversions;
 pub mod lexer;
 pub mod parser;
 pub mod preprocessor;

src/c/mod.rs

@@ -12,6 +12,7 @@ use self::error::LowerError;
 use crate::{
     asg::Asg,
     cli::BuildOptions,
+    data_units::ByteUnits,
     ir::{self},
     resolve::PolyRecipe,
 };
@@ -22,6 +23,18 @@ use structure::lower_struct;
 pub fn lower<'a>(options: &BuildOptions, asg: &Asg) -> Result<ir::Module, LowerError> {
     let mut ir_module = ir::Module::new(options.target.clone());
 
+    assert_eq!(
+        ir_module.target.short_layout().width,
+        ByteUnits::of(2),
+        "This target is not supported. Adept currently assumes that shorts are 16-bit integers (for integer promotion rules). Which does not hold for this target."
+    );
+
+    assert_eq!(
+        ir_module.target.int_layout().width,
+        ByteUnits::of(4),
+        "This target is not supported. Adept currently assumes that ints are 32-bit integers (for integer promotion rules). Which does not hold for this target."
+    );
+
     for (struct_ref, structure) in asg.structs.iter() {
         lower_struct(&mut ir_module, struct_ref, structure, asg)?;
     }

src/lower/mod.rs

@@ -25,11 +25,12 @@ use super::{
     Initialized, ResolveTypeCtx,
 };
 use crate::{
-    asg::{self, Asg, Expr, ExprKind, FuncRef, StructRef, TypeKind, TypedExpr},
+    asg::{self, Asg, Cast, CastFrom, Expr, ExprKind, FuncRef, StructRef, TypeKind, TypedExpr},
     ast::{
         self, CInteger, CIntegerAssumptions, ConformBehavior, IntegerKnown, Language, Settings,
         UnaryOperator,
     },
+    data_units::BitUnits,
     ir::IntegerSign,
     resolve::{
         error::ResolveErrorKind,
@@ -447,6 +448,8 @@ pub fn resolve_expr(
             asg::ExprKind::Continue.at(source),
         )),
         ast::ExprKind::IntegerPromote(value) => {
+            // NOTE: Since this expression comes from C, there
+            // should not be any untyped literals.
             let inner = resolve_expr(
                 ctx,
                 value,
@@ -455,19 +458,59 @@ pub fn resolve_expr(
                 ResolveExprMode::RequireValue,
             )?;
 
-            let rank = inner.ty.integer_rank();
+            // WARNING: For now, we assume that shorts are 16 bits and ints are 32 bits
+            // since this is the case for the vast majority of systems.
+            // Targets where this does not hold will not be supported for now.
+            // If we do wish to support them in the future,
+            // We will probably need to add new types such as promoted<T> and arith<A, B>
+            // to represent the possible result types on non-conformant architectures.
 
-            // After promotion, types will either be int, unsigned int, or the same
-            // Maybe we express this type as promoted<T>
-            // And then for combined
-            // a + b
-            // and other arithmetic expressions, the
-            // result could be a separate type like usual_arithmetic<promoted<ushort>,
-            // promoted<char>>
-            // I think we just need to be careful of the sign from promoted unsigned shorts.
+            let promoted_type = match &inner.ty.kind {
+                TypeKind::Boolean => {
+                    Some(TypeKind::CInteger(CInteger::Int, Some(IntegerSign::Signed)))
+                }
+                TypeKind::Integer(bits, sign) => {
+                    if bits.bits() < BitUnits::of(32) {
+                        Some(TypeKind::CInteger(CInteger::Int, Some(IntegerSign::Signed)))
+                    } else if bits.bits() == BitUnits::of(32) {
+                        Some(TypeKind::CInteger(CInteger::Int, Some(*sign)))
+                    } else {
+                        None
+                    }
+                }
+                TypeKind::CInteger(c_integer, _) => match c_integer {
+                    CInteger::Char | CInteger::Short => {
+                        Some(TypeKind::CInteger(CInteger::Int, Some(IntegerSign::Signed)))
+                    }
+                    CInteger::Int | CInteger::Long | CInteger::LongLong => None,
+                },
+                TypeKind::SizeInteger(_) => {
+                    // We will treat size integers as if they don't get promoted
+                    None
+                }
+                TypeKind::IntegerLiteral(_) => {
+                    panic!("Cannot integer promote untyped integer literal. This should never happen since untyped integer literals do not exist in C.")
+                }
+                _ => None,
+            };
+
+            if let Some(promoted_type) = promoted_type {
+                let promoted_type = promoted_type.at(ast_expr.source);
+
+                return Ok(TypedExpr::new(
+                    promoted_type.clone(),
+                    ExprKind::IntegerCast(Box::new(CastFrom {
+                        cast: Cast {
+                            target_type: promoted_type,
+                            value: inner.expr,
+                        },
+                        from_type: inner.ty,
+                    }))
+                    .at(ast_expr.source),
+                ));
+            }
 
-            Ok(todo!("integer promote expression - {:?}", rank))
-            // Ok(TypedExpr::new())
+            return Ok(inner);
         }
     }?;