transpile: use expected types when translating binary operators

Author: fw-immunant

c2rust-transpile/src/c_ast/mod.rs

@@ -1383,6 +1383,24 @@ impl BinOp {
             Comma => ", ",
         }
     }
+
+    /// Does the rust equivalent of this operator have type (T, T) -> T?
+    pub fn all_types_same(&self) -> bool {
+        use BinOp::*;
+        match self {
+            Multiply => true,
+            Divide => true,
+            Modulus => true,
+            Add => true,
+            Subtract => true,
+            ShiftLeft => true,
+            ShiftRight => true,
+            BitAnd => true,
+            BitXor => true,
+            BitOr => true,
+            _ => false,
+        }
+    }
 }
 
 impl Display for BinOp {

c2rust-transpile/src/translator/mod.rs

@@ -3520,10 +3520,17 @@ impl<'c> Translation<'c> {
                 if self.casting_simd_builtin_call(expr, is_explicit, kind) {
                     return Ok(val);
                 }
+
+                let target_ty = if kind == CastKind::ArrayToPointerDecay {
+                    ty
+                } else {
+                    override_ty.unwrap_or(ty)
+                };
+
                 self.convert_cast(
                     ctx,
                     source_ty,
-                    ty,
+                    target_ty,
                     val,
                     Some(expr),
                     Some(kind),
@@ -3612,7 +3619,15 @@ impl<'c> Translation<'c> {
             }
 
             Binary(type_id, op, lhs, rhs, opt_lhs_type_id, opt_res_type_id) => self
-                .convert_binary_expr(ctx, type_id, op, lhs, rhs, opt_lhs_type_id, opt_res_type_id)
+                .convert_binary_expr(
+                    ctx,
+                    override_ty.unwrap_or(type_id),
+                    op,
+                    lhs,
+                    rhs,
+                    opt_lhs_type_id,
+                    opt_res_type_id,
+                )
                 .map_err(|e| e.add_loc(self.ast_context.display_loc(src_loc))),
 
             ArraySubscript(_, ref lhs, ref rhs, _) => {

c2rust-transpile/src/translator/operators.rs

@@ -104,25 +104,32 @@ impl<'c> Translation<'c> {
 
                 let ty = self.convert_type(type_id.ctype)?;
 
-                let lhs_type_id = self
-                    .ast_context
-                    .index(lhs)
-                    .kind
-                    .get_qual_type()
-                    .ok_or_else(|| {
-                        format_translation_err!(
-                            self.ast_context.display_loc(lhs_loc),
-                            "bad lhs type for assignment"
-                        )
-                    })?;
+                let lhs_kind = &self.ast_context.index(lhs).kind;
+                let mut lhs_type_id = lhs_kind.get_qual_type().ok_or_else(|| {
+                    format_translation_err!(
+                        self.ast_context.display_loc(lhs_loc),
+                        "bad lhs type for assignment"
+                    )
+                })?;
                 let rhs_kind = &self.ast_context.index(rhs).kind;
-                let rhs_type_id = rhs_kind.get_qual_type().ok_or_else(|| {
+                let mut rhs_type_id = rhs_kind.get_qual_type().ok_or_else(|| {
                     format_translation_err!(
                         self.ast_context.display_loc(rhs_loc),
                         "bad rhs type for assignment"
                     )
                 })?;
 
+                // If this is an operation like addition or bitxor that (for rust built-ins) accepts
+                // and produces values all of the same type, then propagate our expected type down
+                // to the translation of our argument expressions.
+                if op.all_types_same()
+                    && !self.ast_context.index(lhs_type_id.ctype).kind.is_pointer()
+                    && !self.ast_context.index(rhs_type_id.ctype).kind.is_pointer()
+                {
+                    lhs_type_id = type_id;
+                    rhs_type_id = type_id;
+                }
+
                 if ctx.is_unused() {
                     Ok(self
                         .convert_expr(ctx, lhs, Some(lhs_type_id))?