Extract splatted typeck into a fn and cleanup error handling

fixup! Impl HIR typeck for #[splat]

Author: teor2345

compiler/rustc_hir_typeck/src/callee.rs

@@ -601,8 +601,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             fn_sig.output(),
             expected,
             arg_exprs,
-            fn_sig.fn_sig_kind,
-            TupleArgumentsFlag::NotCallOper,
+            fn_sig.fn_sig_kind.c_variadic(),
+            TupleArgumentsFlag::with_fn_sig_kind(fn_sig.fn_sig_kind, false),
             def_id,
             callee_generic_args,
         );
@@ -915,8 +915,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             fn_sig.output(),
             expected,
             arg_exprs,
-            fn_sig.fn_sig_kind,
-            TupleArgumentsFlag::TupleAllCallArgs,
+            fn_sig.fn_sig_kind.c_variadic(),
+            TupleArgumentsFlag::rust_fn_trait_call(),
             Some(closure_def_id.to_def_id()),
             None,
         );
@@ -1002,8 +1002,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             method.sig.output(),
             expected,
             arg_exprs,
-            method.sig.fn_sig_kind,
-            TupleArgumentsFlag::TupleAllCallArgs,
+            method.sig.fn_sig_kind.c_variadic(),
+            TupleArgumentsFlag::rust_fn_trait_call(),
             Some(method.def_id),
             None,
         );

compiler/rustc_hir_typeck/src/expr.rs

@@ -28,9 +28,7 @@ use rustc_infer::infer::{self, DefineOpaqueTypes, InferOk, RegionVariableOrigin}
 use rustc_infer::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::{
-    self, AdtKind, FnSigKind, GenericArgsRef, Ty, TypeVisitableExt, Unnormalized,
-};
+use rustc_middle::ty::{self, AdtKind, GenericArgsRef, Ty, TypeVisitableExt, Unnormalized};
 use rustc_middle::{bug, span_bug};
 use rustc_session::errors::{ExprParenthesesNeeded, feature_err};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -1468,17 +1466,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Handle splatted method arguments
                 // self is already handled as `rcvr`, so it's never splatted here
                 let method_inputs = &method.sig.inputs()[1..];
-                let method_fn_sig_kind = if let Some(splatted_arg_index) =
-                    method.sig.fn_sig_kind.splatted()
-                {
-                    method
-                        .sig
-                        .fn_sig_kind
-                        .set_splatted(Some(splatted_arg_index.strict_sub(1)), method_inputs.len())
-                        .unwrap()
-                } else {
-                    method.sig.fn_sig_kind
-                };
+                let method_tuple_args_flag =
+                    TupleArgumentsFlag::with_fn_sig_kind(method.sig.fn_sig_kind, true);
 
                 self.check_argument_types(
                     segment.ident.span,
@@ -1487,8 +1476,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     method.sig.output(),
                     expected,
                     args,
-                    method_fn_sig_kind,
-                    TupleArgumentsFlag::NotCallOper,
+                    method.sig.fn_sig_kind.c_variadic(),
+                    method_tuple_args_flag,
                     Some(method.def_id),
                     Some(method.args),
                 );
@@ -1510,9 +1499,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     err_output,
                     NoExpectation,
                     args,
-                    // Avoid spurious unsafe errors by using a safe dummy sig
-                    FnSigKind::dummy(),
-                    TupleArgumentsFlag::NotCallOper,
+                    false,
+                    TupleArgumentsFlag::DontTupleArgs,
                     None,
                     Some(GenericArgsRef::default()),
                 );