Started working on C integer promotions

Author: IsaacShelton

src/asg/datatype/kind/mod.rs

@@ -6,6 +6,7 @@ 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,
 };
@@ -77,6 +78,17 @@ 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::source_files::Source;
+use crate::{c::implicit_conversions::IntegerRank, source_files::Source};
 use core::hash::Hash;
 pub use kind::*;
 use std::fmt::Display;
@@ -28,6 +28,10 @@ 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/ast/expr/kind.rs

@@ -38,6 +38,7 @@ pub enum ExprKind {
     InterpreterSyscall(Box<InterpreterSyscall>),
     Break,
     Continue,
+    IntegerPromote(Box<Expr>),
 }
 
 impl ExprKind {

src/c/ast/expr.rs

@@ -46,6 +46,7 @@ pub enum ExprKind {
     Call(Box<Expr>, Vec<Expr>),
     SizeOf(ast::Type),
     SizeOfValue(Box<Expr>),
+    IntegerPromote(Box<Expr>),
 }
 
 impl ExprKind {

src/c/implicit_conversions/mod.rs

@@ -1,17 +1,13 @@
-use crate::{data_units::BitUnits, target::Target};
+use crate::{ast::CInteger, data_units::BitUnits, target::Target};
 use derive_more::IsVariant;
 use std::cmp::Ordering;
 
 #[derive(Copy, Clone, Debug)]
 pub enum IntegerRank {
     Bool,
-    Char,
-    Short,
-    Int,
-    Long,
-    LongLong,
+    Flexible(CInteger),
     Size,
-    FixedInt(BitUnits),
+    Fixed(BitUnits),
 }
 
 impl IntegerRank {
@@ -22,19 +18,27 @@ impl IntegerRank {
     pub fn precision(&self, target: &Target) -> IntegerPrecision {
         match self {
             IntegerRank::Bool => IntegerPrecision::boolean(),
-            IntegerRank::Char => IntegerPrecision::flexible(target.char_layout().width.to_bits()),
-            IntegerRank::Short => IntegerPrecision::flexible(target.short_layout().width.to_bits()),
-            IntegerRank::Int => IntegerPrecision::flexible(target.int_layout().width.to_bits()),
-            IntegerRank::Long => IntegerPrecision::flexible(target.long_layout().width.to_bits()),
-            IntegerRank::LongLong => {
+            IntegerRank::Flexible(CInteger::Char) => {
+                IntegerPrecision::flexible(target.char_layout().width.to_bits())
+            }
+            IntegerRank::Flexible(CInteger::Short) => {
+                IntegerPrecision::flexible(target.short_layout().width.to_bits())
+            }
+            IntegerRank::Flexible(CInteger::Int) => {
+                IntegerPrecision::flexible(target.int_layout().width.to_bits())
+            }
+            IntegerRank::Flexible(CInteger::Long) => {
+                IntegerPrecision::flexible(target.long_layout().width.to_bits())
+            }
+            IntegerRank::Flexible(CInteger::LongLong) => {
                 IntegerPrecision::flexible(target.longlong_layout().width.to_bits())
             }
             IntegerRank::Size => {
                 // This means that size types have the same effective rank as the type they would
                 // be in C for this target.
                 IntegerPrecision::flexible(target.size_layout().width.to_bits())
             }
-            IntegerRank::FixedInt(bits) => IntegerPrecision::fixed(*bits),
+            IntegerRank::Fixed(bits) => IntegerPrecision::fixed(*bits),
         }
     }
 }

src/c/parser/expr.rs

@@ -250,7 +250,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
             CTokenKind::Punctuator(Punctuator::Add) => {
                 self.input.advance();
                 let inner = self.parse_expr_primary()?;
-                return Ok(inner);
+                return Ok(ExprKind::IntegerPromote(Box::new(inner)).at(source));
             }
             CTokenKind::Punctuator(Punctuator::Subtract) => {
                 self.input.advance();

src/c/translate/eval.rs

@@ -50,7 +50,8 @@ pub fn evaluate_to_const_integer(expr: &Expr) -> Result<BigInt, ParseError> {
         | ExprKind::Not(_)
         | ExprKind::Call(_, _)
         | ExprKind::SizeOf(_)
-        | ExprKind::SizeOfValue(_) => (),
+        | ExprKind::SizeOfValue(_)
+        | ExprKind::IntegerPromote(_) => (),
     }
 
     Err(ParseErrorKind::MustBeConstantInteger.at(expr.source))

src/c/translate/expr/mod.rs

@@ -163,8 +163,10 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
         }
         ExprKind::SizeOf(ty) => ast::ExprKind::SizeOf(Box::new(ty.clone())).at(expr.source),
         ExprKind::SizeOfValue(value) => {
-            let inner = translate_expr(ctx, value)?;
-            ast::ExprKind::SizeOfValue(Box::new(inner)).at(expr.source)
+            ast::ExprKind::SizeOfValue(Box::new(translate_expr(ctx, value)?)).at(expr.source)
+        }
+        ExprKind::IntegerPromote(value) => {
+            ast::ExprKind::IntegerPromote(Box::new(translate_expr(ctx, value)?)).at(expr.source)
         }
     })
 }

src/resolve/expr/mod.rs

@@ -446,6 +446,29 @@ pub fn resolve_expr(
             asg::TypeKind::Never.at(source),
             asg::ExprKind::Continue.at(source),
         )),
+        ast::ExprKind::IntegerPromote(value) => {
+            let inner = resolve_expr(
+                ctx,
+                value,
+                None,
+                Initialized::AllowUninitialized,
+                ResolveExprMode::RequireValue,
+            )?;
+
+            let rank = inner.ty.integer_rank();
+
+            // 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.
+
+            Ok(todo!("integer promote expression - {:?}", rank))
+            // Ok(TypedExpr::new())
+        }
     }?;
 
     match initialized {