Allow .. in struct expressions on the LHS of assignments

Author: fanzier

compiler/rustc_ast_lowering/src/expr.rs

@@ -872,7 +872,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // Return early in case of an ordinary assignment.
         let is_ordinary = match &lhs.kind {
             ExprKind::Array(..)
-            | ExprKind::Struct(_, _, None)
+            | ExprKind::Struct(..)
             | ExprKind::Tup(..)
             | ExprKind::Underscore => false,
             ExprKind::Call(callee, ..) => {
@@ -980,8 +980,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
             }
             // structs:
-            // FIXME: support `..` here, requires changes to the parser
-            ExprKind::Struct(path, fields, None) => {
+            ExprKind::Struct(path, fields, base) => {
                 let field_pats = self.arena.alloc_from_iter(fields.iter().map(|f| {
                     let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments);
                     hir::FieldPat {
@@ -999,7 +998,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ParamMode::Optional,
                     ImplTraitContext::disallowed(),
                 );
-                let struct_pat = hir::PatKind::Struct(qpath, field_pats, false);
+                let fields_omitted = match base {
+                    None => false,
+                    Some(e) => {
+                        match e.kind {
+                            ExprKind::Underscore => {}
+                            _ => self
+                                .sess
+                                .struct_span_err(e.span, "base expression not allowed here")
+                                .span_suggestion(
+                                    e.span,
+                                    "consider removing this",
+                                    String::new(),
+                                    rustc_errors::Applicability::MachineApplicable,
+                                )
+                                .emit(),
+                        }
+                        true
+                    }
+                };
+                let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
                 return self.pat(lhs.span, struct_pat);
             }
             // tuples:

compiler/rustc_parse/src/parser/expr.rs

@@ -2104,6 +2104,16 @@ impl<'a> Parser<'a> {
         while self.token != token::CloseDelim(token::Brace) {
             if self.eat(&token::DotDot) {
                 let exp_span = self.prev_token.span;
+                // If the struct ends in `.. }`, treat it like `.. _ }`.
+                // AST lowering will then report an error if it's not on the LHS of an assignment.
+                if self.token == token::CloseDelim(token::Brace) {
+                    base = Some(self.mk_expr(
+                        self.prev_token.span,
+                        ExprKind::Underscore,
+                        AttrVec::new(),
+                    ));
+                    break;
+                }
                 match self.parse_expr() {
                     Ok(e) => base = Some(e),
                     Err(mut e) if recover => {

src/test/ui/destructuring-assignment/note-unsupported.rs

@@ -17,7 +17,8 @@ fn main() {
     S { x: a, y: b } += s; //~ ERROR invalid left-hand side of assignment
     //~| ERROR binary assignment operation `+=` cannot be applied
 
-    S { x: a, ..s } = S { x: 3, y: 4 }; //~ ERROR invalid left-hand side of assignment
+    S { x: a, ..s } = S { x: 3, y: 4 }; //~ ERROR base expression not allowed
+    //~| ERROR destructuring assignments are unstable
 
     let c = 3;
 

src/test/ui/destructuring-assignment/note-unsupported.stderr

@@ -1,3 +1,9 @@
+error: base expression not allowed here
+  --> $DIR/note-unsupported.rs:20:17
+   |
+LL |     S { x: a, ..s } = S { x: 3, y: 4 };
+   |                 ^ help: consider removing this
+
 error[E0658]: destructuring assignments are unstable
   --> $DIR/note-unsupported.rs:6:12
    |
@@ -81,16 +87,19 @@ LL |     S { x: a, y: b } += s;
    |     |
    |     cannot assign to this expression
 
-error[E0070]: invalid left-hand side of assignment
+error[E0658]: destructuring assignments are unstable
   --> $DIR/note-unsupported.rs:20:21
    |
 LL |     S { x: a, ..s } = S { x: 3, y: 4 };
    |     --------------- ^
    |     |
    |     cannot assign to this expression
+   |
+   = note: see issue #372 <https://github.com/rust-lang/rust/issues/372> for more information
+   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
 
 error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:24:17
+  --> $DIR/note-unsupported.rs:25:17
    |
 LL |     ((a, b), c) = ((3, 4), 5);
    |     ----------- ^
@@ -100,7 +109,7 @@ LL |     ((a, b), c) = ((3, 4), 5);
    = note: see issue #372 <https://github.com/rust-lang/rust/issues/372> for more information
    = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-Some errors have detailed explanations: E0067, E0070, E0368, E0658.
+Some errors have detailed explanations: E0067, E0368, E0658.
 For more information about an error, try `rustc --explain E0067`.

src/test/ui/destructuring-assignment/struct_destructure.rs

@@ -14,4 +14,6 @@ fn main() {
     assert_eq!((a,b), (2,1));
     Struct { a: _, b } = Struct { a: 1, b: 2 };
     assert_eq!((a,b), (2,2));
+    Struct { a, .. } = Struct { a: 1, b: 3};
+    assert_eq!((a,b), (1,2));
 }

src/test/ui/destructuring-assignment/struct_destructure_fail.rs

@@ -7,7 +7,9 @@ struct Struct<S, T> {
 fn main() {
     let (mut a, b);
     let mut c;
+    let d = Struct { a: 0, b: 1 };
     Struct { a, b, c } = Struct { a: 0, b: 1 }; //~ ERROR does not have a field named `c`
     Struct { a, _ } = Struct { a: 1, b: 2 }; //~ ERROR pattern does not mention field `b`
     //~| ERROR expected identifier, found reserved identifier `_`
+    Struct { a, ..d } = Struct { a: 1, b: 2 }; //~ ERROR base expression not allowed here
 }

src/test/ui/destructuring-assignment/struct_destructure_fail.stderr

@@ -1,24 +1,30 @@
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/struct_destructure_fail.rs:11:17
+  --> $DIR/struct_destructure_fail.rs:12:17
    |
 LL |     Struct { a, _ } = Struct { a: 1, b: 2 };
    |     ------      ^ expected identifier, found reserved identifier
    |     |
    |     while parsing this struct
 
+error: base expression not allowed here
+  --> $DIR/struct_destructure_fail.rs:14:19
+   |
+LL |     Struct { a, ..d } = Struct { a: 1, b: 2 };
+   |                   ^ help: consider removing this
+
 error[E0026]: struct `Struct` does not have a field named `c`
-  --> $DIR/struct_destructure_fail.rs:10:20
+  --> $DIR/struct_destructure_fail.rs:11:20
    |
 LL |     Struct { a, b, c } = Struct { a: 0, b: 1 };
    |                    ^ struct `Struct` does not have this field
 
 error[E0027]: pattern does not mention field `b`
-  --> $DIR/struct_destructure_fail.rs:11:5
+  --> $DIR/struct_destructure_fail.rs:12:5
    |
 LL |     Struct { a, _ } = Struct { a: 1, b: 2 };
    |     ^^^^^^^^^^^^^^^ missing field `b`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0026, E0027.
 For more information about an error, try `rustc --explain E0026`.