transpile: Avoid some identity transmutes for function pointers

Author: Rua

c2rust-transpile/src/translator/mod.rs

@@ -3495,12 +3495,14 @@ impl<'c> Translation<'c> {
                                 parameters,
                             )?;
                         if let Some(actual_ty) = actual_ty {
-                            // If we're casting a concrete function to
-                            // a K&R function pointer type, use transmute
-                            self.import_type(qual_ty.ctype);
+                            if actual_ty != ty {
+                                // If we're casting a concrete function to
+                                // a K&R function pointer type, use transmute
+                                self.import_type(qual_ty.ctype);
 
-                            val = transmute_expr(actual_ty, ty, val);
-                            set_unsafe = true;
+                                val = transmute_expr(actual_ty, ty, val);
+                                set_unsafe = true;
+                            }
                         } else {
                             let decl_kind = &self.ast_context[decl_id].kind;
                             let kind_with_declared_args =
@@ -4406,21 +4408,35 @@ impl<'c> Translation<'c> {
 
         match kind {
             CastKind::BitCast | CastKind::NoOp => {
-                val.and_then(|x| {
-                    if self.ast_context.is_function_pointer(target_cty.ctype)
-                        || self.ast_context.is_function_pointer(source_cty.ctype)
-                    {
-                        let source_ty = self.convert_type(source_cty.ctype)?;
-                        let target_ty = self.convert_type(target_cty.ctype)?;
+                if self.ast_context.is_function_pointer(target_cty.ctype)
+                    || self.ast_context.is_function_pointer(source_cty.ctype)
+                {
+                    let source_ty = self
+                        .type_converter
+                        .borrow_mut()
+                        .convert(&self.ast_context, source_cty.ctype)?;
+                    let target_ty = self
+                        .type_converter
+                        .borrow_mut()
+                        .convert(&self.ast_context, target_cty.ctype)?;
+
+                    if source_ty == target_ty {
+                        return Ok(val);
+                    }
+
+                    self.import_type(source_cty.ctype);
+                    self.import_type(target_cty.ctype);
+
+                    val.and_then(|val| {
                         Ok(WithStmts::new_unsafe_val(transmute_expr(
-                            source_ty, target_ty, x,
+                            source_ty, target_ty, val,
                         )))
-                    } else {
-                        // Normal case
-                        let target_ty = self.convert_type(target_cty.ctype)?;
-                        Ok(WithStmts::new_val(mk().cast_expr(x, target_ty)))
-                    }
-                })
+                    })
+                } else {
+                    // Normal case
+                    let target_ty = self.convert_type(target_cty.ctype)?;
+                    Ok(val.map(|val| mk().cast_expr(val, target_ty)))
+                }
             }
 
             CastKind::IntegralToPointer

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

@@ -44,10 +44,8 @@ pub unsafe extern "C" fn unary_with_side_effect() {
     side_effect();
     !side_effect();
     (side_effect() == 0) as ::core::ffi::c_int;
-    (b"\0" as *const u8 as *const ::core::ffi::c_char).offset(::core::mem::transmute::<
-        unsafe extern "C" fn() -> ::core::ffi::c_int,
-        unsafe extern "C" fn() -> ::core::ffi::c_int,
-    >(side_effect)() as isize) as *const ::core::ffi::c_char;
+    (b"\0" as *const u8 as *const ::core::ffi::c_char).offset(side_effect() as isize)
+        as *const ::core::ffi::c_char;
     *arr[side_effect() as usize];
     arr[side_effect() as usize] = arr[side_effect() as usize].offset(1);
     arr[side_effect() as usize] = arr[side_effect() as usize].offset(-1);