Inline check_method_argument_types to get rid of TupleArgumentsFlag arg

Author: compiler-errors

compiler/rustc_hir_typeck/src/callee.rs

@@ -902,19 +902,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         call_expr: &'tcx hir::Expr<'tcx>,
         arg_exprs: &'tcx [hir::Expr<'tcx>],
         expected: Expectation<'tcx>,
-        method_callee: MethodCallee<'tcx>,
+        method: MethodCallee<'tcx>,
     ) -> Ty<'tcx> {
-        let output_type = self.check_method_argument_types(
+        self.check_argument_types(
             call_expr.span,
             call_expr,
-            Ok(method_callee),
+            &method.sig.inputs()[1..],
+            method.sig.output(),
+            expected,
             arg_exprs,
+            method.sig.c_variadic,
             TupleArgumentsFlag::TupleArguments,
-            expected,
+            Some(method.def_id),
         );
 
-        self.write_method_call_and_enforce_effects(call_expr.hir_id, call_expr.span, method_callee);
-        output_type
+        self.write_method_call_and_enforce_effects(call_expr.hir_id, call_expr.span, method);
+
+        method.sig.output()
     }
 }
 

compiler/rustc_hir_typeck/src/expr.rs

@@ -40,7 +40,6 @@ use tracing::{debug, instrument, trace};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use crate::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExpectation};
-use crate::TupleArgumentsFlag::DontTupleArguments;
 use crate::coercion::{CoerceMany, DynamicCoerceMany};
 use crate::errors::{
     AddressOfTemporaryTaken, BaseExpressionDoubleDot, BaseExpressionDoubleDotAddExpr,
@@ -1605,14 +1604,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         // Call the generic checker.
-        self.check_method_argument_types(
-            segment.ident.span,
-            expr,
-            method,
-            args,
-            DontTupleArguments,
-            expected,
-        )
+        self.check_method_argument_types(segment.ident.span, expr, method, args, expected)
     }
 
     /// Checks use `x.use`.

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -133,7 +133,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expr: &'tcx hir::Expr<'tcx>,
         method: Result<MethodCallee<'tcx>, ErrorGuaranteed>,
         args_no_rcvr: &'tcx [hir::Expr<'tcx>],
-        tuple_arguments: TupleArgumentsFlag,
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         let has_error = match method {
@@ -147,11 +146,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             );
             let err_output = Ty::new_error(self.tcx, guar);
 
-            let err_inputs = match tuple_arguments {
-                DontTupleArguments => err_inputs,
-                TupleArguments => vec![Ty::new_tup(self.tcx, &err_inputs)],
-            };
-
             self.check_argument_types(
                 sp,
                 expr,
@@ -160,7 +154,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 NoExpectation,
                 args_no_rcvr,
                 false,
-                tuple_arguments,
+                TupleArgumentsFlag::DontTupleArguments,
                 method.ok().map(|method| method.def_id),
             );
             return err_output;
@@ -175,7 +169,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             expected,
             args_no_rcvr,
             method.sig.c_variadic,
-            tuple_arguments,
+            TupleArgumentsFlag::DontTupleArguments,
             Some(method.def_id),
         );