transpile: In convert_subtraction, only cast if types differ

Author: Rua

c2rust-transpile/src/translator/operators.rs

@@ -66,8 +66,6 @@ impl<'c> Translation<'c> {
                     ctx = ctx.decay_ref();
                 }
 
-                let ty = self.convert_type(expr_type_id.ctype)?;
-
                 let lhs_kind = &self.ast_context.index_unwrap_parens(lhs).kind;
                 let mut lhs_type_id = lhs_kind.get_qual_type().ok_or_else(|| {
                     format_translation_err!(
@@ -175,8 +173,7 @@ impl<'c> Translation<'c> {
                     lhs_val.zip(rhs_val).and_then_try(|(lhs_val, rhs_val)| {
                         self.convert_binary_operator(
                             op,
-                            ty,
-                            expr_type_id.ctype,
+                            expr_type_id,
                             lhs_type_id,
                             rhs_type_id,
                             lhs_val,
@@ -221,12 +218,10 @@ impl<'c> Translation<'c> {
                 None,
             )?;
 
-            let ty = self.convert_type(compute_res_type_id.ctype)?;
             let val = lhs.and_then_try(|lhs| {
                 self.convert_binary_operator(
                     bin_op,
-                    ty,
-                    compute_res_type_id.ctype,
+                    compute_res_type_id,
                     compute_lhs_type_id,
                     rhs_type_id,
                     lhs,
@@ -433,12 +428,10 @@ impl<'c> Translation<'c> {
                         None,
                     )?;
 
-                    let ty = self.convert_type(result_type_id.ctype)?;
                     let val = lhs.and_then_try(|lhs|
                         self.convert_binary_operator(
                             op,
-                            ty,
-                            result_type_id.ctype,
+                            result_type_id,
                             expr_or_comp_type_id,
                             rhs_type_id,
                             lhs,
@@ -514,22 +507,23 @@ impl<'c> Translation<'c> {
     fn convert_binary_operator(
         &self,
         op: CBinOp,
-        ty: Box<Type>,
-        ctype: CTypeId,
+        result_type_id: CQualTypeId,
         lhs_type: CQualTypeId,
         rhs_type: CQualTypeId,
         lhs: Box<Expr>,
         rhs: Box<Expr>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         let is_unsigned_integral_type = self
             .ast_context
-            .resolve_type(ctype)
+            .resolve_type(result_type_id.ctype)
             .kind
             .is_unsigned_integral_type();
 
         Ok(WithStmts::new_val(match op {
             CBinOp::Add => return self.convert_addition(lhs_type, rhs_type, lhs, rhs),
-            CBinOp::Subtract => return self.convert_subtraction(ty, lhs_type, rhs_type, lhs, rhs),
+            CBinOp::Subtract => {
+                return self.convert_subtraction(result_type_id, lhs_type, rhs_type, lhs, rhs)
+            }
 
             op if op.is_arithmetic() && is_unsigned_integral_type => {
                 mk().method_call_expr(lhs, op.wrapping_method(), vec![rhs])
@@ -576,7 +570,7 @@ impl<'c> Translation<'c> {
 
     fn convert_subtraction(
         &self,
-        ty: Box<Type>,
+        result_type_id: CQualTypeId,
         lhs_type_id: CQualTypeId,
         rhs_type_id: CQualTypeId,
         lhs: Box<Expr>,
@@ -593,7 +587,14 @@ impl<'c> Translation<'c> {
                 offset = mk().binary_expr(BinOp::Div(Default::default()), offset, div);
             }
 
-            Ok(WithStmts::new_val(mk().cast_expr(offset, ty)).set_unsafe())
+            let expr_type_kind = &self.ast_context.resolve_type(result_type_id.ctype).kind;
+
+            if !matches!(expr_type_kind, CTypeKind::PtrDiff) {
+                let type_rs = self.convert_type(result_type_id.ctype)?;
+                offset = mk().cast_expr(offset, type_rs);
+            }
+
+            Ok(WithStmts::new_val(offset).set_unsafe())
         } else if let &CTypeKind::Pointer(pointee) = lhs_type {
             Ok(self.convert_pointer_offset(lhs, rhs, pointee.ctype, true, false))
         } else if lhs_type.is_unsigned_integral_type() {

c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2021.clang15.snap

@@ -89,7 +89,7 @@ pub unsafe extern "C" fn pointer_arithmetic() {
     let mut i2: [::core::ffi::c_int; 2] = [10 as ::core::ffi::c_int, 11 as ::core::ffi::c_int];
     let mut p1: *mut ::core::ffi::c_int = &raw mut i1 as *mut ::core::ffi::c_int;
     let mut p2: *mut ::core::ffi::c_int = &raw mut i2 as *mut ::core::ffi::c_int;
-    let mut diff: ptrdiff_t = p1.offset_from(p2) as ptrdiff_t;
+    let mut diff: ptrdiff_t = p1.offset_from(p2);
     let mut diff_int: ::core::ffi::c_int =
         p1.offset_from(p2) as ::core::ffi::c_long as ::core::ffi::c_int;
 }

c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.2024.clang15.snap

@@ -89,7 +89,7 @@ pub unsafe extern "C" fn pointer_arithmetic() {
     let mut i2: [::core::ffi::c_int; 2] = [10 as ::core::ffi::c_int, 11 as ::core::ffi::c_int];
     let mut p1: *mut ::core::ffi::c_int = &raw mut i1 as *mut ::core::ffi::c_int;
     let mut p2: *mut ::core::ffi::c_int = &raw mut i2 as *mut ::core::ffi::c_int;
-    let mut diff: ptrdiff_t = p1.offset_from(p2) as ptrdiff_t;
+    let mut diff: ptrdiff_t = p1.offset_from(p2);
     let mut diff_int: ::core::ffi::c_int =
         p1.offset_from(p2) as ::core::ffi::c_long as ::core::ffi::c_int;
 }