Assignee expressions can contain rest-patterns.

[theemathas]

See also #2209 for more on assignee expressions.

The following two code snippets compile:

struct Thing { _field: i32 }

fn main() {
    Thing { .. } = Thing { _field: 1 };
}

macro_rules! foo {
    ($x:expr) => {}
}

foo!(Thing { .. });

This implies that Thing { .. } is an expression. In particular, since it's valid on the lhs of an assignment expression, Thing { .. } must be an assignee expression.

An assignee expression can be a struct expression. However, struct expressions cannot contain rest-patterns. Therefore, according to the reference, Thing { .. } cannot be an assignee expression.

Thus, either the compiler or the reference is wrong. I think the reference should be somehow amended to match the compiler.

Similar issues affect rest-patterns in tuples ((x, y, ..)), in slices ([x, y, ..]), and in call expressions (tuple structs; Thing(x, y, ..)).

---

To make things worse, as pointed out by @kpreid, the Thing { .. } syntax is also currently legal in nightly as syntax for default field values. For example, the following code compiles:

#![feature(default_field_values)]
struct Foo {
    x: i32 = 0,
}
fn main() {
    // creates a struct with default field values, then assigns it to a rest-pattern
    Foo { .. } = Foo { .. };
    // creates two structs with default field values, then assigns one to another
    *&mut Foo { .. } = Foo { .. };
}

I don't know how to specify a disambiguation rule between default field values vs rest-patterns in assignee expressions.

[ehuss]

Thanks for pointing this out. Looks like I just missed .. in #1116.

[theemathas]

Actually, we also need some kind of disambiguation rule for existing syntax, to figure out whether .. is a rest-pattern or a full-range literal.

fn main() {
    println!("{:?}", [..] == *(&[.., ..] as &[_]));  // prints "false"
    println!("{:?}", [..] =  *(&[.., ..] as &[_]));  // prints "()"
}

[theemathas]

Actually, the compiler seems to already not be doing very well at disambiguating....

fn main() {
    let my_range = .. as std::ops::RangeFull;
}

error: expected one of `;` or `else`, found keyword `as`
 --> src/main.rs:2:23
  |
2 |     let my_range = .. as std::ops::RangeFull;
  |                       ^^ expected one of `;` or `else`

[ehuss]

I suspect there can't be a disambiguation for .. in assignment at the AST level. The compiler seems to treat it as a Range, and then later converts it to a pattern (roughly in destructure_sequence).

Actually, the compiler seems to already not be doing very well at disambiguating....

That looks like it's just due to precedence. Range expressions have some very particular precedence requirements. In that example, wrapping in parentheses (..) fixes it.

[theemathas]

This implies that the rest-pattern check happens after macro expansion. For example, the following code compiles:

macro_rules! foo {
    () => { .. }
}

fn main() {
    let (x, foo!()) = (2,);
}

[theemathas]

Actually, here's some really strange macro behavior:

#![expect(unused)]

macro_rules! make_expr {
    ($x:expr) => { $x }
}

fn works() {
    let x;
    (x, make_expr!(..)) = (2,);
}

fn fails() {
    let (x, make_expr!(..)) = (2,);
}

Error output

error: arbitrary expressions aren't allowed in patterns
  --> src/lib.rs:13:24
   |
13 |     let (x, make_expr!(..)) = (2,);
   |                        ^^
   |
   = note: the `expr` fragment specifier forces the metavariable's content to be an expression

error[E0308]: mismatched types
  --> src/lib.rs:13:9
   |
13 |     let (x, make_expr!(..)) = (2,);
   |         ^^^^^^^^^^^^^^^^^^^   ---- this expression has type `({integer},)`
   |         |
   |         expected a tuple with 1 element, found one with 2 elements
   |
   = note: expected tuple `({integer},)`
              found tuple `(_, _)`

For more information about this error, try `rustc --explain E0308`.

#![expect(unused)]

macro_rules! make_pat {
    ($x:pat) => { $x }
}

fn fails() {
    let x;
    (x, make_pat!(..)) = (2,);
}

fn works() {
    let (x, make_pat!(..)) = (2,);
}

Error output

error: expected expression, found `pat` metavariable
 --> src/lib.rs:4:19
  |
4 |     ($x:pat) => { $x }
  |                   ^^ expected expression
...
9 |     (x, make_pat!(..)) = (2,);
  |         ------------- in this macro invocation
  |
  = note: this error originates in the macro `make_pat` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
 --> src/lib.rs:9:5
  |
9 |     (x, make_pat!(..)) = (2,);
  |     ^^^^^^^^^^^^^^^^^^   ---- this expression has type `({integer},)`
  |     |
  |     expected a tuple with 1 element, found one with 2 elements
  |
  = note: expected tuple `({integer},)`
             found tuple `(_, _)`

For more information about this error, try `rustc --explain E0308`.