transpile: Special case mixed operand types for complex arithmetic

Author: Rua

c2rust-transpile/src/c_ast/conversion.rs

@@ -472,6 +472,12 @@ impl ConversionContext {
             self.add_type(new_id, not_located(rust_type_kind));
             self.processed_nodes
                 .insert(new_id, self::node_types::OTHER_TYPE);
+
+            let complex_kind = CTypeKind::Complex(CTypeId(new_id));
+            let new_id = self.id_mapper.fresh_id();
+            self.add_type(new_id, not_located(complex_kind));
+            self.processed_nodes
+                .insert(new_id, self::node_types::OTHER_TYPE);
         }
 
         // Continue popping Clang nodes off of the stack of nodes we have promised to visit

c2rust-transpile/src/c_ast/mod.rs

@@ -1347,7 +1347,7 @@ impl TypedAstContext {
                             None
                         }
                     }
-                    CExprKind::Binary(_ty, op, lhs, rhs, _, _) => {
+                    CExprKind::Binary(result_type_id, op, lhs, rhs, _, _) => {
                         let lhs_type_id =
                             self.ast_context.c_exprs[&lhs].kind.get_qual_type().unwrap();
                         let rhs_type_id =
@@ -1361,11 +1361,28 @@ impl TypedAstContext {
                         }
 
                         if op.all_types_same() {
-                            if CTypeKind::PULLBACK_KINDS.contains(lhs_type_kind) {
-                                Some(lhs_type_id)
-                            } else {
-                                Some(rhs_type_id)
+                            let result_type_kind =
+                                &self.ast_context.resolve_type(result_type_id.ctype).kind;
+
+                            let mut result_type_id =
+                                if CTypeKind::PULLBACK_KINDS.contains(lhs_type_kind) {
+                                    lhs_type_id
+                                } else {
+                                    rhs_type_id
+                                };
+
+                            // For complex arithmetic, complex and real values can be mixed.
+                            // See if a `Complex` version of the new result type exists.
+                            if matches!(result_type_kind, CTypeKind::Complex(..)) {
+                                let new_result_type_kind = CTypeKind::Complex(result_type_id.ctype);
+                                let new_type_id = self
+                                    .ast_context
+                                    .type_for_kind(&new_result_type_kind)
+                                    .unwrap();
+                                result_type_id.ctype = new_type_id;
                             }
+
+                            Some(result_type_id)
                         } else if op.is_bitshift() {
                             Some(lhs_type_id)
                         } else {

c2rust-transpile/src/translator/operators.rs

@@ -97,6 +97,19 @@ impl<'c> Translation<'c> {
                         // Ops like division and bitxor accept inputs of their expected result type.
                         lhs_type_id.ctype = expr_type_id.ctype;
                         rhs_type_id.ctype = expr_type_id.ctype;
+
+                        // For complex arithmetic, complex and real values can be mixed.
+                        let expr_type_kind =
+                            &self.ast_context.resolve_type(expr_type_id.ctype).kind;
+                        if let &CTypeKind::Complex(result_scalar_type_id) = expr_type_kind {
+                            if !matches!(lhs_type_kind, CTypeKind::Complex(..)) {
+                                lhs_type_id.ctype = result_scalar_type_id;
+                            }
+
+                            if !matches!(rhs_type_kind, CTypeKind::Complex(..)) {
+                                rhs_type_id.ctype = result_scalar_type_id;
+                            }
+                        }
                     } else if op.input_types_same() && lhs_type_kind != rhs_type_kind {
                         // Ops like comparisons require argument types to match, but the result type
                         // doesn't inform us what type to choose. Select a synthetic definition of a
@@ -288,7 +301,14 @@ impl<'c> Translation<'c> {
             {
                 // If the rhs must match the lhs but doesn't, add a cast.
                 // For compound assignment, use the compute type; for regular assignment, use lhs type.
-                let target_type_id = compute_lhs_type_id.unwrap_or(lhs_type_id);
+                let mut target_type_id = compute_lhs_type_id.unwrap_or(lhs_type_id);
+
+                // For complex arithmetic, complex and real values can be mixed.
+                if let &CTypeKind::Complex(lhs_scalar_type_id) = lhs_type_kind {
+                    if !matches!(rhs_type_kind, CTypeKind::Complex(..)) {
+                        target_type_id.ctype = lhs_scalar_type_id;
+                    }
+                }
 
                 rhs_rs = self.convert_cast(
                     ctx.used(),