Started working on implicit integer conversions for C code

Author: IsaacShelton

src/c/implicit_conversions/mod.rs

@@ -0,0 +1,84 @@
+use crate::{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,
+    FixedInt(BitUnits),
+}
+
+impl IntegerRank {
+    pub fn compare_for_target(left: Self, right: Self, target: &Target) -> Ordering {
+        let left_precision = left.precision(target);
+        let right_precision = right.precision(target);
+        left_precision.cmp(&right_precision)
+    }
+
+    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 => {
+                IntegerPrecision::flexible(target.longlong_layout().width.to_bits())
+            }
+            IntegerRank::FixedInt(bits) => IntegerPrecision::fixed(*bits),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, IsVariant)]
+pub enum IntegerPrecision {
+    Boolean,
+    Normal { bits: BitUnits, flexible: bool },
+}
+
+impl IntegerPrecision {
+    pub fn boolean() -> Self {
+        Self::Boolean
+    }
+    pub fn flexible(bits: BitUnits) -> Self {
+        Self::Normal {
+            bits,
+            flexible: true,
+        }
+    }
+
+    pub fn fixed(bits: BitUnits) -> Self {
+        Self::Normal {
+            bits,
+            flexible: false,
+        }
+    }
+}
+
+impl Ord for IntegerPrecision {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self {
+            IntegerPrecision::Boolean => other
+                .is_normal()
+                .then_some(Ordering::Less)
+                .unwrap_or(Ordering::Equal),
+            IntegerPrecision::Normal { bits, flexible } => {
+                let IntegerPrecision::Normal {
+                    bits: other_bits,
+                    flexible: other_flexible,
+                } = other
+                else {
+                    return Ordering::Greater;
+                };
+
+                bits.cmp(other_bits)
+                    .then_with(|| flexible.cmp(other_flexible))
+            }
+        }
+    }
+}

src/c/mod.rs

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

src/c/parser/expr.rs

@@ -248,7 +248,6 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
                 return Ok(ExprKind::Dereference(Box::new(inner)).at(source));
             }
             CTokenKind::Punctuator(Punctuator::Add) => {
-                // Is this a no-op?
                 self.input.advance();
                 let inner = self.parse_expr_primary()?;
                 return Ok(inner);

src/c/translate/expr/mod.rs

@@ -33,6 +33,9 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
             let left = translate_expr(ctx, &operation.left)?;
             let right = translate_expr(ctx, &operation.right)?;
 
+            // TODO: Perfrom usual arithmetic conversions or integer promotions depending on
+            // operator
+            // TODO: Array-to-Pointer and Function-to-Pointer conversions may also apply
             let operator: ast::BinaryOperator = match operation.operator {
                 BinaryOperator::LogicalOr => ast::ShortCircuitingBinaryOperator::Or.into(),
                 BinaryOperator::LogicalAnd => ast::ShortCircuitingBinaryOperator::And.into(),
@@ -113,12 +116,16 @@ pub fn translate_expr(ctx: &mut TranslateCtx, expr: &Expr) -> Result<ast::Expr,
             }))
             .at(expr.source)
         }
-        ExprKind::Negate(inner) => ast::ExprKind::UnaryOperation(Box::new(ast::UnaryOperation {
-            operator: ast::UnaryOperator::Math(ast::UnaryMathOperator::Negate),
-            inner: translate_expr(ctx, inner)?,
-        }))
-        .at(expr.source),
+        ExprKind::Negate(inner) => {
+            // TODO: Perform integer promotion
+            ast::ExprKind::UnaryOperation(Box::new(ast::UnaryOperation {
+                operator: ast::UnaryOperator::Math(ast::UnaryMathOperator::Negate),
+                inner: translate_expr(ctx, inner)?,
+            }))
+            .at(expr.source)
+        }
         ExprKind::BitComplement(inner) => {
+            // TODO: Perform integer promotion
             ast::ExprKind::UnaryOperation(Box::new(ast::UnaryOperation {
                 operator: ast::UnaryOperator::Math(ast::UnaryMathOperator::BitComplement),
                 inner: translate_expr(ctx, inner)?,