Ban splat on closures and rust-call

teor2345 · teor2345 · commit 83fe45c86083 · 2026-07-03T16:29:46.000+10:00
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -45,6 +45,39 @@ enum SelfSemantic {
     No,
 }
 
+/// Is `#[splat]` allowed semantically in a function or closure?
+/// Only applies to the function kind and header, the parameters are checked elsewhere.
+enum SplatSemantic {
+    Yes,
+    NoClosures(Span),
+    NoRustCall(Span),
+}
+
+impl SplatSemantic {
+    /// Returns if splatting is semantically allowed for the given `FnKind`,
+    /// Only checks the function kind and header, not the parameters.
+    fn from_fn_kind(fk: &FnKind<'_>) -> Self {
+        match fk {
+            FnKind::Fn(_, _, f) => Self::from_extern(f.sig.header.ext),
+            // Splatting closures is banned, because closure arguments are already de-tupled.
+            FnKind::Closure(_, _, _, expr) => SplatSemantic::NoClosures(expr.span),
+        }
+    }
+
+    fn from_extern(ext: Extern) -> Self {
+        match ext {
+            Extern::None => SplatSemantic::Yes,
+            // FIXME(splat): should splatting extern "C" or other ABIs be allowed?
+            Extern::Implicit(_) => SplatSemantic::Yes,
+            // For now, splatting rust-call is banned, because it already de-tuples args.
+            Extern::Explicit(abi_str, span) if abi_str.symbol_unescaped.as_str() == "rust-call" => {
+                SplatSemantic::NoRustCall(span)
+            }
+            Extern::Explicit(_abi_str, _span) => SplatSemantic::Yes,
+        }
+    }
+}
+
 enum TraitOrImpl {
     Trait { vis: Span, constness: Const },
     TraitImpl { constness: Const, polarity: ImplPolarity, trait_ref_span: Span },
@@ -350,10 +383,15 @@ impl<'a> AstValidator<'a> {
         });
     }
 
-    fn check_fn_decl(&self, fn_decl: &FnDecl, self_semantic: SelfSemantic) {
+    fn check_fn_decl(
+        &self,
+        fn_decl: &FnDecl,
+        self_semantic: SelfSemantic,
+        splat_semantic: SplatSemantic,
+    ) {
         self.check_decl_num_args(fn_decl);
         let c_variadic_span = self.check_decl_cvariadic_pos(fn_decl);
-        self.check_decl_splatting(fn_decl, c_variadic_span);
+        self.check_decl_splatting(fn_decl, c_variadic_span, splat_semantic);
         self.check_decl_attrs(fn_decl);
         self.check_decl_self_param(fn_decl, self_semantic);
     }
@@ -399,8 +437,13 @@ impl<'a> AstValidator<'a> {
     /// Emits an error if a function declaration has more than one splatted argument, with a
     /// C-variadic parameter, or a splat at an unsupported index (for performance).
     /// Example: `fn foo(#[splat] x: (), #[splat] y: ())` will emit an error.
-    fn check_decl_splatting(&self, fn_decl: &FnDecl, c_variadic_span: Option<Span>) {
-        let (splatted_arg_indexes, mut splatted_spans): (Vec<u16>, Vec<Span>) = fn_decl
+    fn check_decl_splatting(
+        &self,
+        fn_decl: &FnDecl,
+        c_variadic_span: Option<Span>,
+        splat_semantic: SplatSemantic,
+    ) {
+        let (splatted_arg_indexes, splatted_spans): (Vec<u16>, Vec<Span>) = fn_decl
             .inputs
             .iter()
             .enumerate()
@@ -433,9 +476,28 @@ impl<'a> AstValidator<'a> {
         if let Some(c_variadic_span) = c_variadic_span
             && !splatted_spans.is_empty()
         {
+            let mut splatted_spans = splatted_spans.clone();
             splatted_spans.push(c_variadic_span);
             self.dcx().emit_err(diagnostics::CVarArgsAndSplat { spans: splatted_spans });
         }
+
+        if !splatted_arg_indexes.is_empty() {
+            match splat_semantic {
+                SplatSemantic::NoClosures(closure_span) => {
+                    let mut splatted_spans = splatted_spans.clone();
+                    splatted_spans.push(closure_span);
+                    self.dcx()
+                        .emit_err(diagnostics::SplatNotAllowedOnClosures { spans: splatted_spans });
+                }
+                SplatSemantic::NoRustCall(abi_span) => {
+                    let mut splatted_spans = splatted_spans;
+                    splatted_spans.push(abi_span);
+                    self.dcx()
+                        .emit_err(diagnostics::SplatNotAllowedOnRustCall { spans: splatted_spans });
+                }
+                SplatSemantic::Yes => {}
+            }
+        }
     }
 
     fn check_decl_attrs(&self, fn_decl: &FnDecl) {
@@ -1055,7 +1117,11 @@ impl<'a> AstValidator<'a> {
         match &ty.kind {
             TyKind::FnPtr(bfty) => {
                 self.check_fn_ptr_safety(bfty.decl_span, bfty.safety);
-                self.check_fn_decl(&bfty.decl, SelfSemantic::No);
+                self.check_fn_decl(
+                    &bfty.decl,
+                    SelfSemantic::No,
+                    SplatSemantic::from_extern(bfty.ext),
+                );
                 Self::check_decl_no_pat(&bfty.decl, |span, _, _| {
                     self.dcx().emit_err(diagnostics::PatternFnPointer { span });
                 });
@@ -1746,7 +1812,8 @@ impl Visitor<'_> for AstValidator<'_> {
             Some(FnCtxt::Assoc(_)) => SelfSemantic::Yes,
             _ => SelfSemantic::No,
         };
-        self.check_fn_decl(fk.decl(), self_semantic);
+        let splat_semantic = SplatSemantic::from_fn_kind(&fk);
+        self.check_fn_decl(fk.decl(), self_semantic, splat_semantic);
 
         if let Some(&FnHeader { safety, .. }) = fk.header() {
             self.check_item_safety(span, safety);
diff --git a/compiler/rustc_ast_passes/src/diagnostics.rs b/compiler/rustc_ast_passes/src/diagnostics.rs
@@ -150,6 +150,22 @@ pub(crate) struct CVarArgsAndSplat {
     pub spans: Vec<Span>,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[splat]` is not allowed on closures")]
+#[help("remove `#[splat]` or turn the closure into a function")]
+pub(crate) struct SplatNotAllowedOnClosures {
+    #[primary_span]
+    pub spans: Vec<Span>,
+}
+
+#[derive(Diagnostic)]
+#[diag("`#[splat]` is not allowed on functions with the `rust-call` ABI")]
+#[help("remove `#[splat]` or change the ABI")]
+pub(crate) struct SplatNotAllowedOnRustCall {
+    #[primary_span]
+    pub spans: Vec<Span>,
+}
+
 #[derive(Diagnostic)]
 #[diag("documentation comments cannot be applied to function parameters")]
 pub(crate) struct FnParamDocComment {
diff --git a/tests/ui/splat/reject-closure-issue-158605.rs b/tests/ui/splat/reject-closure-issue-158605.rs
@@ -0,0 +1,30 @@
+//! Checks that closures and rust-call functions can't be splatted.
+//! This should be rejected until we decide on sensible semantics.
+
+#![feature(splat, unboxed_closures, tuple_trait)]
+#![expect(incomplete_features)]
+
+use std::marker::Tuple;
+
+trait Trait: Tuple + Sized {
+    extern "rust-call" fn method(#[splat] self: Self);
+    //~^ ERROR: `#[splat]` is not allowed on functions with the `rust-call` ABI
+}
+
+impl Trait for (i32, i64) {
+    extern "rust-call" fn method(#[splat] self: Self) {
+        //~^ ERROR: `#[splat]` is not allowed on functions with the `rust-call` ABI
+        println!("{self:?}");
+    }
+}
+
+fn main() {
+    (|#[splat] x: i32| {
+        //~^ ERROR `#[splat]` is not allowed on closures
+        println!("{x}");
+    })(1);
+
+    (1_i32, 2_i64).method();
+    Trait::method(3_i32, 4_i64);
+    //~^ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+}
diff --git a/tests/ui/splat/reject-closure-issue-158605.stderr b/tests/ui/splat/reject-closure-issue-158605.stderr
@@ -0,0 +1,36 @@
+error: `#[splat]` is not allowed on functions with the `rust-call` ABI
+  --> $DIR/reject-closure-issue-158605.rs:10:5
+   |
+LL |     extern "rust-call" fn method(#[splat] self: Self);
+   |     ^^^^^^^^^^^^^^^^^^                    ^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed on functions with the `rust-call` ABI
+  --> $DIR/reject-closure-issue-158605.rs:15:5
+   |
+LL |     extern "rust-call" fn method(#[splat] self: Self) {
+   |     ^^^^^^^^^^^^^^^^^^                    ^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed on closures
+  --> $DIR/reject-closure-issue-158605.rs:22:7
+   |
+LL |       (|#[splat] x: i32| {
+   |  _______^^^^^^^^^^^^^^^__^
+LL | |
+LL | |         println!("{x}");
+LL | |     })(1);
+   | |_____^
+   |
+   = help: remove `#[splat]` or turn the closure into a function
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/reject-closure-issue-158605.rs:28:26
+   |
+LL |     Trait::method(3_i32, 4_i64);
+   |                          ^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/splat/splat-fn-ptr-cast.rs b/tests/ui/splat/splat-fn-ptr-cast.rs
@@ -8,9 +8,9 @@
 fn main() {
     // Bug #158603 regression test variants
     #[rustfmt::skip]
-    let _x: fn(#[splat] (i32,)) = None.unwrap();
+    let _x: fn(#[splat] (f32,)) = None.unwrap();
     // FIXME(splat): causes an ICE until #158603 is fixed
-    //x(1);
+    //x(1.0);
 
     let x: fn((i32,)) = None.unwrap();
     x((1,));
diff --git a/tests/ui/splat/splat-fn-ptr-cast.stderr b/tests/ui/splat/splat-fn-ptr-cast.stderr
diff --git a/tests/ui/splat/splat-fn-ptr-rust-call.rs b/tests/ui/splat/splat-fn-ptr-rust-call.rs
@@ -0,0 +1,18 @@
+//! Test using `#[splat]` on tuple arguments of pointers to "rust-call" functions.
+//! Currently ICEs at a later stage, but AST validation should catch it earlier.
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+#![feature(unboxed_closures)]
+
+extern "rust-call" fn f(#[splat] _: ()) {} //~ ERROR `#[splat]` is not allowed on functions with the `rust-call` ABI
+
+fn main() {
+    // FIXME(rustfmt): the attribute gets deleted by rustfmt
+    #[rustfmt::skip]
+    let f2: extern "rust-call" fn(#[splat] ()) = f; //~ ERROR `#[splat]` is not allowed on functions with the `rust-call` ABI
+    // These errors could be confusing, but they're useful if the user meant to use "rust-call"
+    // instead of #[splat]
+    f(); //~ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+    f2(); //~ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+}
diff --git a/tests/ui/splat/splat-fn-ptr-rust-call.stderr b/tests/ui/splat/splat-fn-ptr-rust-call.stderr
@@ -0,0 +1,30 @@
+error: `#[splat]` is not allowed on functions with the `rust-call` ABI
+  --> $DIR/splat-fn-ptr-rust-call.rs:8:1
+   |
+LL | extern "rust-call" fn f(#[splat] _: ()) {}
+   | ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed on functions with the `rust-call` ABI
+  --> $DIR/splat-fn-ptr-rust-call.rs:13:13
+   |
+LL |     let f2: extern "rust-call" fn(#[splat] ()) = f;
+   |             ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/splat-fn-ptr-rust-call.rs:16:5
+   |
+LL |     f();
+   |     ^^^
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/splat-fn-ptr-rust-call.rs:17:5
+   |
+LL |     f2();
+   |     ^^^^
+
+error: aborting due to 4 previous errors
+
