Adjust comments and diagnostics

Author: varkor

compiler/rustc_ast/src/ast.rs

@@ -1313,9 +1313,9 @@ pub enum ExprKind {
     Field(P<Expr>, Ident),
     /// An indexing operation (e.g., `foo[2]`).
     Index(P<Expr>, P<Expr>),
-    /// A range (e.g., `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
+    /// A range (e.g., `1..2`, `1..`, `..2`, `1..=2`, `..=2`; and `..` in destructuring assingment).
     Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits),
-    /// An underscore.
+    /// An underscore, used in destructuring assignment to ignore a value.
     Underscore,
 
     /// Variable reference, possibly containing `::` and/or type

compiler/rustc_ast_lowering/src/expr.rs

@@ -861,7 +861,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     /// Destructure the LHS of complex assignments.
-    /// For instance, lower `(a,b) = t` to `{ let (lhs1,lhs2) = t; a = lhs1; b = lhs2; }`.
+    /// For instance, lower `(a, b) = t` to `{ let (lhs1, lhs2) = t; a = lhs1; b = lhs2; }`.
     fn lower_expr_assign(
         &mut self,
         lhs: &Expr,
@@ -902,13 +902,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
             return hir::ExprKind::Assign(self.lower_expr(lhs), self.lower_expr(rhs), eq_sign_span);
         }
 
-        let mut assignments = Vec::new();
+        let mut assignments = vec![];
 
-        // The LHS becomes a pattern: `(lhs1, lhs2)`
+        // The LHS becomes a pattern: `(lhs1, lhs2)`.
         let pat = self.destructure_assign(lhs, eq_sign_span, &mut assignments);
         let rhs = self.lower_expr(rhs);
 
-        // Introduce a let for destructuring: `let (lhs1,lhs2) = t`.
+        // Introduce a `let` for destructuring: `let (lhs1, lhs2) = t`.
         let destructure_let = self.stmt_let_pat(
             ThinVec::new(),
             whole_span,
@@ -927,18 +927,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     /// Convert the LHS of a destructuring assignment to a pattern.
-    /// Along the way, introduce additional assignments in the parameter assignments.
+    /// Each sub-assignment is recorded in `assignments`.
     fn destructure_assign(
         &mut self,
         lhs: &Expr,
         eq_sign_span: Span,
         assignments: &mut Vec<hir::Stmt<'hir>>,
     ) -> &'hir hir::Pat<'hir> {
         match &lhs.kind {
+            // Underscore pattern.
             ExprKind::Underscore => {
                 return self.pat(lhs.span, hir::PatKind::Wild);
             }
-            // slices:
+            // Slice patterns.
             ExprKind::Array(elements) => {
                 let (pats, rest) =
                     self.destructure_sequence(elements, "slice", eq_sign_span, assignments);
@@ -950,7 +951,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 };
                 return self.pat(lhs.span, slice_pat);
             }
-            // tuple structs:
+            // Tuple structs.
             ExprKind::Call(callee, args) => {
                 if let ExprKind::Path(qself, path) = &callee.kind {
                     let (pats, rest) =
@@ -979,7 +980,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     }
                 }
             }
-            // structs:
+            // Structs.
             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);
@@ -1005,10 +1006,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ExprKind::Underscore => {}
                             _ => self
                                 .sess
-                                .struct_span_err(e.span, "base expression not allowed here")
+                                .struct_span_err(
+                                    e.span,
+                                    "functional record updates are not allowed in destructuring \
+                                     assignments",
+                                )
                                 .span_suggestion(
                                     e.span,
-                                    "consider removing this",
+                                    "consider removing the trailing pattern",
                                     String::new(),
                                     rustc_errors::Applicability::MachineApplicable,
                                 )
@@ -1020,7 +1025,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
                 return self.pat(lhs.span, struct_pat);
             }
-            // tuples:
+            // Tuples.
             ExprKind::Tup(elements) => {
                 let (pats, rest) =
                     self.destructure_sequence(elements, "tuple", eq_sign_span, assignments);
@@ -1041,8 +1046,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     /// Destructure a sequence of expressions occurring on the LHS of an assignment.
     /// Such a sequence occurs in a tuple (struct)/slice.
-    /// Return a sequence of corresponding patterns and the index and span of `..`, if any.
-    /// Along the way, introduce additional assignments in the parameter `assignments`.
+    /// Return a sequence of corresponding patterns, and the index and the span of `..` if it
+    /// exists.
+    /// Each sub-assignment is recorded in `assignments`.
     fn destructure_sequence(
         &mut self,
         elements: &[AstP<Expr>],

compiler/rustc_feature/src/active.rs

@@ -611,6 +611,8 @@ declare_features! (
     (active, unsized_fn_params, "1.49.0", Some(48055), None),
 
     /// Allows the use of destructuring assignments.
+    /// The current issue reference refers to the rust-lang/rfcs issue. This will be changed to a
+    /// valid rust-lang/rust issue when the accompanying RFC is accepted.
     (active, destructuring_assignment, "1.49.0", Some(372), None),
 
     // -------------------------------------------------------------------------

compiler/rustc_hir/src/hir.rs

@@ -1680,8 +1680,8 @@ pub enum LocalSource {
     AsyncFn,
     /// A desugared `<expr>.await`.
     AwaitDesugar,
-    /// A desugared expr = expr where the LHS is a tuple, struct or array.
-    /// The span is for the `=` sign.
+    /// A desugared `expr = expr`, where the LHS is a tuple, struct or array.
+    /// The span is that of the `=` sign.
     AssignDesugar(Span),
 }
 

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 base expression not allowed
+    S { x: a, ..s } = S { x: 3, y: 4 };
+    //~^ ERROR functional record updates are not allowed in destructuring assignments
     //~| ERROR destructuring assignments are unstable
 
     let c = 3;

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

@@ -1,8 +1,8 @@
-error: base expression not allowed here
+error: functional record updates are not allowed in destructuring assignments
   --> $DIR/note-unsupported.rs:20:17
    |
 LL |     S { x: a, ..s } = S { x: 3, y: 4 };
-   |                 ^ help: consider removing this
+   |                 ^ help: consider removing the trailing pattern
 
 error[E0658]: destructuring assignments are unstable
   --> $DIR/note-unsupported.rs:6:12
@@ -99,7 +99,7 @@ LL |     S { x: a, ..s } = S { x: 3, y: 4 };
    = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
 
 error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:25:17
+  --> $DIR/note-unsupported.rs:26:17
    |
 LL |     ((a, b), c) = ((3, 4), 5);
    |     ----------- ^

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

@@ -5,9 +5,11 @@
 fn main() {
   let (mut a, mut b);
   [a, b] = [0, 1];
-  assert_eq!((a,b), (0,1));
-  [a, .., b] = [1,2];
-  assert_eq!((a,b), (1,2));
-  [_, a] = [1,2];
-  assert_eq!((a,b), (2,2));
+  assert_eq!((a, b), (0, 1));
+  let c;
+  [a, .., b, c] = [1, 2, 3, 4, 5];
+  assert_eq!((a, b, c), (1, 4, 5));
+  [_, a, _] = [1, 2, 3];
+  assert_eq!((a, b), (2, 4));
+  [..] = [1, 2, 3];
 }

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

@@ -3,6 +3,6 @@
 fn main() {
   let (mut a, mut b);
   [a, .., b, ..] = [0, 1]; //~ ERROR `..` can only be used once per slice pattern
-  [a, a, b] = [1,2]; //~ ERROR pattern requires 3 elements but array has 2
-  [_] = [1,2]; //~ ERROR pattern requires 1 element but array has 2
+  [a, a, b] = [1, 2]; //~ ERROR pattern requires 3 elements but array has 2
+  [_] = [1, 2]; //~ ERROR pattern requires 1 element but array has 2
 }

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

@@ -9,13 +9,13 @@ LL |   [a, .., b, ..] = [0, 1];
 error[E0527]: pattern requires 3 elements but array has 2
   --> $DIR/slice_destructure_fail.rs:6:3
    |
-LL |   [a, a, b] = [1,2];
+LL |   [a, a, b] = [1, 2];
    |   ^^^^^^^^^ expected 2 elements
 
 error[E0527]: pattern requires 1 element but array has 2
   --> $DIR/slice_destructure_fail.rs:7:3
    |
-LL |   [_] = [1,2];
+LL |   [_] = [1, 2];
    |   ^^^ expected 2 elements
 
 error: aborting due to 3 previous errors

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

@@ -10,10 +10,12 @@ fn main() {
     let (mut a, mut b);
     Struct { a, b } = Struct { a: 0, b: 1 };
     assert_eq!((a, b), (0, 1));
-    Struct { a: b, b: a }  = Struct { a: 1, b: 2};
-    assert_eq!((a,b), (2,1));
+    Struct { a: b, b: a }  = Struct { a: 1, b: 2 };
+    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));
+    assert_eq!((a, b), (2, 2));
+    Struct { a, .. } = Struct { a: 1, b: 3 };
+    assert_eq!((a, b), (1, 2));
+    Struct { .. } = Struct { a: 1, b: 4 };
+    assert_eq!((a, b), (1, 2));
 }