Handle splatted empty tuples and simplify the code

Author: teor2345

compiler/rustc_hir_typeck/src/callee.rs

@@ -1048,14 +1048,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             expected,
             arg_exprs,
             fn_sig.c_variadic,
-            TupleArgumentsFlag::TupleSplattedArguments {
-                splatted_arg_index: fn_sig
-                    .splatted_arg_index()
-                    .expect("must have a splatted argument"),
-            },
+            TupleArgumentsFlag::TupleSplattedArguments,
             def_id,
         );
 
+        // FIXME(splat): is splatting incompatible with RustCall?
         if fn_sig.abi == rustc_abi::ExternAbi::RustCall {
             let sp = arg_exprs.last().map_or(call_expr.span, |expr| expr.span);
             self.dcx().emit_err(errors::RustCallIncorrectArgs { span: sp });

compiler/rustc_hir_typeck/src/expr.rs

@@ -1483,17 +1483,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.write_method_call_and_enforce_effects(expr.hir_id, expr.span, method);
 
                 // Handle splatted method arguments
-                let tuple_arguments =
-                    if let Some(meth_splatted_arg) = method.sig.splatted_arg_index() {
-                        // self is already handled as `rcvr`
-                        TupleArgumentsFlag::TupleSplattedArguments {
-                            splatted_arg_index: meth_splatted_arg
-                                .checked_sub(1)
-                                .expect("missing splatted arg or self in method call"),
-                        }
-                    } else {
-                        TupleArgumentsFlag::DontTupleArguments
-                    };
+                let tuple_arguments = if method.sig.splatted {
+                    // self is already handled as `rcvr`, so it's never splatted here
+                    TupleArgumentsFlag::TupleSplattedArguments
+                } else {
+                    TupleArgumentsFlag::DontTupleArguments
+                };
 
                 self.check_argument_types(
                     segment.ident.span,

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -286,15 +286,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut err_code = E0061;
 
         // If the arguments should be wrapped in a tuple (ex: closures, splats), unwrap them here
-        let (formal_input_tys, expected_input_tys) = if let Some(tupled_arg_index) =
-            tuple_arguments.tupled_argument_position()
-        {
-            let tupled_arg_index = usize::from(tupled_arg_index);
-            assert_eq!(
-                Some(tupled_arg_index),
-                formal_input_tys.len().checked_sub(1),
-                "only trailing tupled arguments are implemented",
-            );
+        let (formal_input_tys, expected_input_tys) = if tuple_arguments.last_argument_is_tupled() {
+            // An empty argument list should be a single unit type argument in the callee.
+            // The Fn* traits ensure this by construction, and `#[splat]` can only be applied to an actual argument.
+            let tupled_arg_index =
+                formal_input_tys.len().checked_sub(1).expect("must have a tuple argument");
             // Keep the type variable if the argument is splatted, so we can force it to be a tuple later.
             let tuple_type = if tuple_arguments.is_splatted() {
                 let tuple_type = self

compiler/rustc_hir_typeck/src/lib.rs

@@ -638,16 +638,19 @@ enum TupleArgumentsFlag {
     DontTupleArguments,
     /// All arguments are tupled before typechecking.
     TupleAllArguments,
-    /// Only the splatted arguments are tupled before typechecking.
-    TupleSplattedArguments { splatted_arg_index: u16 },
+    /// Only the splatted final argument is tupled before typechecking.
+    TupleSplattedArguments,
 }
 
 impl TupleArgumentsFlag {
-    fn tupled_argument_position(&self) -> Option<u16> {
+    // Is the last argument in the callee tupled?
+    fn last_argument_is_tupled(&self) -> bool {
         match self {
-            Self::DontTupleArguments => None,
-            Self::TupleAllArguments => Some(0),
-            Self::TupleSplattedArguments { splatted_arg_index } => Some(*splatted_arg_index),
+            Self::DontTupleArguments => false,
+            // The callee always has a single tuple argument.
+            Self::TupleAllArguments => true,
+            // The last argument of the callee is a splatted tuple in the caller.
+            Self::TupleSplattedArguments { .. } => true,
         }
     }
 

compiler/rustc_type_ir/src/ty_kind.rs

@@ -777,14 +777,6 @@ impl<I: Interner> FnSig<I> {
         let FnSig { safety, abi, c_variadic, .. } = self;
         !c_variadic && safety.is_safe() && abi.is_rust()
     }
-
-    pub fn splatted_arg_index(self) -> Option<u16> {
-        // A function with no inputs behaves the same regardless of splatting.
-        let last_index = self.inputs().len().checked_sub(1)?;
-
-        debug_assert!(last_index <= u16::MAX as usize);
-        self.splatted.then_some(last_index as u16)
-    }
 }
 
 impl<I: Interner> ty::Binder<I, FnSig<I>> {
@@ -852,16 +844,20 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
 
         write!(f, "fn(")?;
         let inputs = sig.inputs();
-        let splatted_arg_index = sig.splatted_arg_index();
+        // Always the last argument.
+        let splatted_arg_index = self.splatted.then(|| inputs.len().checked_sub(1)).flatten();
         for (i, ty) in inputs.iter().enumerate() {
             if i > 0 {
                 write!(f, ", ")?;
             }
-            if splatted_arg_index == Some(i as u16) {
+            if splatted_arg_index == Some(i) {
                 write!(f, "#[splat] ")?;
             }
             write!(f, "{ty:?}")?;
         }
+        if self.splatted && inputs.is_empty() {
+            write!(f, "#[splat] ()")?;
+        }
         if *c_variadic {
             if inputs.is_empty() {
                 write!(f, "...")?;

tests/ui/splat/splat-overload-at-home.rs

@@ -35,8 +35,7 @@ impl Foo {
 fn main() {
     let foo = Foo;
 
-    // FIXME(splat): incorrectly assumes that splat must have one or more arguments to tuple
-    //foo.method::<()>();
+    foo.method::<()>(); //~ ERROR broken MIR
 
     // FIXME(splat): generic tuple trait implementers should work without explicit tuple type parameters.
     // actually modify the argument list during typeck, to avoid "broken MIR" errors

tests/ui/splat/splat-tuple.rs

@@ -95,6 +95,5 @@ fn main() {
     // FIXME(splat): generic tuple trait implementers should work without explicit tuple type parameters.
     splat_generic_tuple::<(u32, i8)>(1u32, 2i8);
 
-    // FIXME(splat): incorrectly assumes that splat must have one or more arguments to tuple
-    //splat_generic_tuple::<()>();
+    splat_generic_tuple::<()>();
 }