transpile: handle fiddly cases around function casts

Author: fw-immunant

c2rust-transpile/src/c_ast/conversion.rs

@@ -480,6 +480,30 @@ impl ConversionContext {
             self.visit_node(untyped_context, node_id, new_id, expected_ty)
         }
 
+        // Function declarations' types look through typedefs, but we want to use the types with
+        // typedefs intact in some cases during translation. To ensure that these types exist in the
+        // `TypedAstContext`, iterate over all function decls, compute their adjusted type using
+        // argument types from arg declarations, and then ensure the existence of both this type and
+        // the type of pointers to it.
+        for (_decl_id, located_kind) in self.typed_context.c_decls.iter() {
+            if let kind @ CDeclKind::Function { .. } = &located_kind.kind {
+                let new_kind = self.typed_context.fn_decl_ty_with_declared_args(kind);
+                if self.typed_context.type_for_kind(&new_kind).is_none() {
+                    // Create and insert fn type
+                    let new_id = CTypeId(self.id_mapper.fresh_id());
+                    self.typed_context
+                        .c_types
+                        .insert(new_id, not_located(new_kind));
+                    // Create and insert fn ptr type
+                    let ptr_kind = CTypeKind::Pointer(CQualTypeId::new(new_id));
+                    let ptr_id = CTypeId(self.id_mapper.fresh_id());
+                    self.typed_context
+                        .c_types
+                        .insert(ptr_id, not_located(ptr_kind));
+                }
+            }
+        }
+
         // Invert the macro invocations to get a list of macro expansion expressions
         for (expr_id, macro_ids) in &self.typed_context.macro_invocations {
             for mac_id in macro_ids {

c2rust-transpile/src/c_ast/mod.rs

@@ -519,6 +519,44 @@ impl TypedAstContext {
         return Some(param_tys);
     }
 
+    /// Return the most precise possible CTypeKind for the given function declaration.
+    /// Specifically, ensures that arguments' types are not resolved to underlying types if they were
+    /// declared as typedefs, but returned as those typedefs.
+    ///
+    /// The passed CDeclId must refer to a function declaration.
+    pub fn fn_decl_ty_with_declared_args(&self, func_decl: &CDeclKind) -> CTypeKind {
+        if let CDeclKind::Function {
+            typ, parameters, ..
+        } = func_decl
+        {
+            let typ = self.resolve_type_id(*typ);
+            let decl_arg_tys = self.tys_of_params(parameters).unwrap();
+            let typ_kind = &self[typ].kind;
+            if let &CTypeKind::Function(ret, ref _arg_tys, a, b, c) = typ_kind {
+                return CTypeKind::Function(ret, decl_arg_tys, a, b, c);
+            }
+            panic!("expected {typ:?} to be CTypeKind::Function, but it was {typ_kind:?}")
+        }
+        panic!("expected a CDeclKind::Function, but passed {func_decl:?}")
+    }
+
+    /// Return the most id of the most precise possible type for the function referenced by the
+    /// given expression.
+    pub fn function_declref_ty_with_declared_args(
+        &self,
+        func_expr: CExprId,
+    ) -> Option<CQualTypeId> {
+        if let Some(func_decl @ CDeclKind::Function { .. }) = self.function_declref_decl(func_expr)
+        {
+            let kind_with_declared_args = self.fn_decl_ty_with_declared_args(func_decl);
+            let specific_typ = self
+                .type_for_kind(&kind_with_declared_args)
+                .expect(&format!("no type for kind {kind_with_declared_args:?}"));
+            return Some(CQualTypeId::new(specific_typ));
+        }
+        None
+    }
+
     /// Pessimistically try to check if an expression has side effects. If it does, or we can't tell
     /// that it doesn't, return `false`.
     pub fn is_expr_pure(&self, expr: CExprId) -> bool {

c2rust-transpile/src/translator/mod.rs

@@ -3408,7 +3408,20 @@ impl<'c> Translation<'c> {
                             val = transmute_expr(actual_ty, ty, val);
                             set_unsafe = true;
                         } else {
-                            val = mk().cast_expr(val, ty);
+                            let decl_kind = &self.ast_context[decl_id].kind;
+                            let kind_with_declared_args =
+                                self.ast_context.fn_decl_ty_with_declared_args(decl_kind);
+
+                            if let Some(ty) = self
+                                .ast_context
+                                .type_for_kind(&kind_with_declared_args)
+                                .map(CQualTypeId::new)
+                            {
+                                let ty = self.convert_type(ty.ctype)?;
+                                val = mk().cast_expr(val, ty);
+                            } else {
+                                val = mk().cast_expr(val, ty);
+                            }
                         }
                     }
                 }
@@ -3514,17 +3527,46 @@ impl<'c> Translation<'c> {
                     _ => {}
                 }
 
-                let source_ty = self.ast_context[expr]
+                let mut source_ty = self.ast_context[expr]
                     .kind
                     .get_qual_type()
                     .ok_or_else(|| format_err!("bad source type"))?;
 
                 let val = if is_explicit {
+                    // If we're casting a function, look for its declared ty to use as a more
+                    // precise source type. The AST node's type will not preserve typedef arg types
+                    // but the function's declaration will.
+                    if let Some(func_decl) = self.ast_context.function_declref_decl(expr) {
+                        let kind_with_declared_args =
+                            self.ast_context.fn_decl_ty_with_declared_args(func_decl);
+                        let func_ty = self
+                            .ast_context
+                            .type_for_kind(&kind_with_declared_args)
+                            .expect(&format!("no type for kind {kind_with_declared_args:?}"));
+                        let func_ptr_ty = self
+                            .ast_context
+                            .type_for_kind(&CTypeKind::Pointer(CQualTypeId::new(func_ty)))
+                            .expect(&format!("no type for kind {kind_with_declared_args:?}"));
+
+                        source_ty = CQualTypeId::new(func_ptr_ty);
+                    }
+
                     let stmts = self.compute_variable_array_sizes(ctx, ty.ctype)?;
                     let mut val = self.convert_expr(ctx, expr, None)?;
                     val.prepend_stmts(stmts);
                     val
                 } else {
+                    // Cast the return types of functions whose return types are synthetic.
+                    if let Some(func_decl) = self.ast_context.function_declref_decl(expr) {
+                        let kind_with_declared_args =
+                            self.ast_context.fn_decl_ty_with_declared_args(func_decl);
+                        let func_ty = self
+                            .ast_context
+                            .type_for_kind(&kind_with_declared_args)
+                            .expect(&format!("no type for kind {kind_with_declared_args:?}"));
+                        source_ty = CQualTypeId::new(func_ty);
+                    }
+
                     // In general, if we are casting the result of an expression, then the inner
                     // expression should be translated to whatever type it normally would.
                     // But for literals, if we don't absolutely have to cast, we would rather the
@@ -3537,7 +3579,13 @@ impl<'c> Translation<'c> {
                             return self.convert_expr(ctx, expr, override_ty);
                         }
                     }
-                    self.convert_expr(ctx, expr, None)?
+                    if kind == CastKind::LValueToRValue
+                        && Some(source_ty.ctype) != override_ty.map(|x| x.ctype)
+                    {
+                        self.convert_expr(ctx, expr, override_ty)?
+                    } else {
+                        self.convert_expr(ctx, expr, None)?
+                    }
                 };
                 // Shuffle Vector "function" builtins will add a cast to the output of the
                 // builtin call which is unnecessary for translation purposes