Diagnostics for @ .. idiom use in tuple and tuple struct patterns is incorrect

[chrissimpkins]

@estebank and I are working on diagnostics for the @ .. rest idiom in slice patterns (#72534) and came across this issue when an attempt is made to use it in tuples and tuple structs.

IIUC, this is allowed:

tuple (playground)

fn main() {
    let x = (1, 2, 3);
    match x {
        (_a, ..) => {}
        _ => {}
    }
}

tuple struct (playground)

struct Binder(i32, i32, i32);

fn main() {
    let x = Binder(1, 2, 3);
    match x {
        Binder(_a, ..) => {}
        _ => {}
    }
}

and this is not allowed (note the addition of [id] @):

tuple (playground)

fn main() {
    let x = (1, 2, 3);
    match x {
        (_a, _x @ ..) => {}
        _ => {}
    }
}

tuple struct (playground)

struct Binder(i32, i32, i32);

fn main() {
    let x = Binder(1, 2, 3);
    match x {
        Binder(_a, _x @ ..) => {}
        _ => {}
    }
}

The error messages for the tuple and tuple struct cases include the following incorrect information:

error: .. patterns are not allowed here

This should state that the @ .. id binding to rest is not allowed. .. patterns are allowed.

note: only allowed in tuple, tuple struct, and slice patterns

@ .. is only allowed in slice patterns, not in tuple or tuple struct patterns. This should state that the idiom is only allowed in slice patterns.

[chrissimpkins]

librustc_ast_lowering appears to be the site of the .. check:

rust/src/librustc_ast_lowering/pat.rs

Lines 78 to 80 in f93bb2a

	PatKind::Rest => {
	// If we reach here the `..` pattern is not semantically allowed.
	self.ban_illegal_rest_pat(p.span)

This LoweringContext method is called:

rust/src/librustc_ast_lowering/pat.rs

Lines 255 to 266 in f93bb2a

	/// Used to ban the `..` pattern in places it shouldn't be semantically.
	fn ban_illegal_rest_pat(&self, sp: Span) -> hir::PatKind<'hir> {
	self.diagnostic()
	.struct_span_err(sp, "`..` patterns are not allowed here")
	.note("only allowed in tuple, tuple struct, and slice patterns")
	.emit();
	// We're not in a list context so `..` can be reasonably treated
	// as `_` because it should always be valid and roughly matches the
	// intent of `..` (notice that the rest of a single slot is that slot).
	hir::PatKind::Wild
	}

[leonardo-m]

Perhaps it's worth supporting "tuple slicing" pattern too in Rust:

(a, xs @ ..) => {}

[estebank]

@leonardo-m that would implicitly create a tuple for xs (or a slice?). I don't think it'd be a good addition. We already support (a, ..), which is much more useful in my eyes.

[leonardo-m]

That syntax is meant to produce a shorter tuple xs with the omission of the first item of the tuple. lf you think it's an useless idea then let's ignore it :)

[chrissimpkins]

@rustbot claim

[chrissimpkins]

#72677