`#[splat]` is allowed in closures and does nothing.

[theemathas]

This code probably shouldn't compile, but it does.

#![feature(splat)]
#![expect(incomplete_features)]

fn main() {
    (|#[splat] x: i32| {
        println!("{x}");
    })(1);
}

cc @teor2345

Meta

Reproducible on the playground with version 1.98.0-nightly (2026-06-29 096694416a4184070914)

[teor2345]

This definitely shouldn't work, it only typechecks due to the hidden tuple in the closure Fn trait call.

I wonder if we should ban all splats within closures, even if they are applied to a tuple type or the Tuple trait?
This was an open question that we didn't get to as part of the initial impl.

[theemathas]

#[splat] self: Self also results in some strange compiler behavior, especially in an extern "rust-call" method.

[teor2345]

#[splat] self: Self also results in some strange compiler behavior,

I'd expect splatting self to work, regardless of how the arguments are declared. Do you have an example?

especially in an extern "rust-call" method.

This should probably be banned along with the closure ban, because it's the internal implementation of closures.

[theemathas]

This compiles:

#![feature(splat)]
#![expect(incomplete_features)]

trait Trait {
    fn method(#[splat] self: Self);
}

impl Trait for (i32, i64) {
    fn method(#[splat] self: Self) {
        println!("{self:?}");
    }
}

fn main() {
    (1_i32, 2_i64).method();
    Trait::method(3_i32, 4_i64);
}

This compiles:

#![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);
}

impl Trait for (i32, i64) {
    extern "rust-call" fn method(#[splat] self: Self) {
        println!("{self:?}");
    }
}

fn main() {
    (1_i32, 2_i64).method();
    // Delete the below line to make it not compile.
    // Trait::method(3_i32, 4_i64);
}

[teor2345]

I think the first is fine, the second is probably something we should reject until we decide semantics.