transpile: get expected types for direct function calls from decl

Author: fw-immunant

c2rust-transpile/src/translator/mod.rs

@@ -3776,6 +3776,31 @@ impl<'c> Translation<'c> {
                     Some(CTypeKind::Function(_, _, is_variadic, _, _)) => *is_variadic,
                     _ => false,
                 };
+                // Extract type from function declaraction for direct function calls.
+                let extract_direct_call_arg_tys = || -> Option<Vec<CQualTypeId>> {
+                    use CastKind::FunctionToPointerDecay;
+                    if let CExprKind::ImplicitCast(_, fexp, FunctionToPointerDecay, _, _) =
+                        self.ast_context[func].kind
+                    {
+                        if let CExprKind::DeclRef(_ty, decl_id, _rv) = &self.ast_context[fexp].kind
+                        {
+                            if let CDeclKind::Function { parameters, .. } =
+                                &self.ast_context.index(*decl_id).kind
+                            {
+                                let mut param_tys = vec![];
+                                for p in parameters {
+                                    match self.ast_context.index(*p).kind {
+                                        CDeclKind::Variable { typ, .. } => param_tys.push(typ),
+                                        _ => return None,
+                                    }
+                                }
+                                return Some(param_tys);
+                            }
+                        }
+                    }
+                    None
+                };
+                let arg_tys = extract_direct_call_arg_tys();
                 let func = match self.ast_context[func].kind {
                     // Direct function call
                     CExprKind::ImplicitCast(_, fexp, CastKind::FunctionToPointerDecay, _, _)
@@ -3836,7 +3861,13 @@ impl<'c> Translation<'c> {
                     // We want to decay refs only when function is variadic
                     ctx.decay_ref = DecayRef::from(is_variadic);
 
-                    let args = self.convert_exprs(ctx.used(), args, None)?;
+                    let arg_tys = if let (false, Some(arg_tys)) = (is_variadic, &arg_tys) {
+                        assert!(arg_tys.len() == args.len());
+                        Some(arg_tys.as_slice())
+                    } else {
+                        None
+                    };
+                    let args = self.convert_exprs(ctx.used(), args, arg_tys)?;
 
                     let res: TranslationResult<_> = Ok(args.map(|args| mk().call_expr(func, args)));
                     res