transpile: Avoid some identity transmutes for function pointers (#1510)

I noticed that in some cases, a transmute would be added between a K&R
style function declaration using `()` as the parameters, and a full type
with `(void)` as the parameters. Since both of those are translated to
the same Rust type, you'd end up with pointless transmute. This PR gates
the transmute to only happen if the two Rust types actually differ.

Author: kkysen

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);