Ban splat on closures and rust-call, add extra tests

Author: teor2345

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -45,6 +45,13 @@ enum SelfSemantic {
     No,
 }
 
+/// Is `#[splat]` allowed semantically on a parameter of a `FnDecl`?
+enum SplatSemantic {
+    Yes,
+    NoClosures(Span),
+    NoRustCall(Span),
+}
+
 enum TraitOrImpl {
     Trait { vis: Span, constness: Const },
     TraitImpl { constness: Const, polarity: ImplPolarity, trait_ref_span: Span },
@@ -350,10 +357,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 +411,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 +450,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 +1091,7 @@ 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::Yes);
                 Self::check_decl_no_pat(&bfty.decl, |span, _, _| {
                     self.dcx().emit_err(diagnostics::PatternFnPointer { span });
                 });
@@ -1746,7 +1782,24 @@ impl Visitor<'_> for AstValidator<'_> {
             Some(FnCtxt::Assoc(_)) => SelfSemantic::Yes,
             _ => SelfSemantic::No,
         };
-        self.check_fn_decl(fk.decl(), self_semantic);
+        let splat_semantic = match fk {
+            FnKind::Fn(_, _, _) => match fk.header().unwrap().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,
+            },
+            // Splatting closures is banned, because closure arguments are already de-tupled.
+            FnKind::Closure(_, _, _, expr) => SplatSemantic::NoClosures(expr.span),
+        };
+
+        self.check_fn_decl(fk.decl(), self_semantic, splat_semantic);
 
         if let Some(&FnHeader { safety, .. }) = fk.header() {
             self.check_item_safety(span, safety);

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 {

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
+}

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
+

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,));