Stabilize destructuring_assignment

2025-01-20 11:43:04 +00:00 · 2021-11-03 02:50:57 -04:00 · 2021-11-03 02:50:57 -04:00 · d95f749f14
commit d95f749f14
parent d594910a2d
49 changed files with 64 additions and 383 deletions
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@ -9,7 +9,6 @@ use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::definitions::DefPathData;
-use rustc_session::parse::feature_err;
 use rustc_span::hygiene::ExpnId;
 use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
 use rustc_span::symbol::{sym, Ident, Symbol};
@ -930,24 +929,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                self.lower_span(eq_sign_span),
            );
        }
-        if !self.sess.features_untracked().destructuring_assignment {
-            let mut err = feature_err(
-                &self.sess.parse_sess,
-                sym::destructuring_assignment,
-                eq_sign_span,
-                "destructuring assignments are unstable",
-            );
-            err.span_label(lhs.span, "cannot assign to this expression");
-            if self.is_in_loop_condition {
-                err.span_suggestion_verbose(
-                    lhs.span.shrink_to_lo(),
-                    "you might have meant to use pattern destructuring",
-                    "let ".to_string(),
-                    rustc_errors::Applicability::MachineApplicable,
-                );
-            }
-            err.emit();
-        }

        let mut assignments = vec![];

--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@ -724,11 +724,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
    gate_all!(half_open_range_patterns, "half-open range patterns are unstable");
    gate_all!(inline_const, "inline-const is experimental");
    gate_all!(inline_const_pat, "inline-const in pattern position is experimental");
-    if sess.parse_sess.span_diagnostic.err_count() == 0 {
-        // Errors for `destructuring_assignment` can get quite noisy, especially where `_` is
-        // involved, so we only emit errors where there are no other parsing errors.
-        gate_all!(destructuring_assignment, "destructuring assignments are unstable");
-    }

    // All uses of `gate_all!` below this point were added in #65742,
    // and subsequently disabled (with the non-early gating readded).
--- a/compiler/rustc_expand/src/lib.rs
+++ b/compiler/rustc_expand/src/lib.rs
@ -1,6 +1,6 @@
 #![feature(crate_visibility_modifier)]
 #![feature(decl_macro)]
-#![feature(destructuring_assignment)]
+#![cfg_attr(bootstrap, feature(destructuring_assignment))]
 #![feature(if_let_guard)]
 #![feature(iter_zip)]
 #![feature(let_else)]
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@ -114,6 +114,8 @@ declare_features! (
    (accepted, default_type_params, "1.0.0", None, None),
    /// Allows `#[deprecated]` attribute.
    (accepted, deprecated, "1.9.0", Some(29935), None),
+    /// Allows the use of destructuring assignments.
+    (accepted, destructuring_assignment, "1.59.0", Some(71126), None),
    /// Allows `#[doc(alias = "...")]`.
    (accepted, doc_alias, "1.48.0", Some(50146), None),
    /// Allows `..` in tuple (struct) patterns.
--- a/compiler/rustc_feature/src/active.rs
+++ b/compiler/rustc_feature/src/active.rs
@ -356,8 +356,6 @@ declare_features! (
    (active, default_type_parameter_fallback, "1.3.0", Some(27336), None),
    /// Allows `#[derive(Default)]` and `#[default]` on enums.
    (active, derive_default_enum, "1.56.0", Some(86985), None),
-    /// Allows the use of destructuring assignments.
-    (active, destructuring_assignment, "1.49.0", Some(71126), None),
    /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
    (active, doc_auto_cfg, "1.58.0", Some(43781), None),
    /// Allows `#[doc(cfg(...))]`.
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@ -1297,7 +1297,6 @@ impl<'a> Parser<'a> {
        } else if self.eat_keyword(kw::Let) {
            self.parse_let_expr(attrs)
        } else if self.eat_keyword(kw::Underscore) {
-            self.sess.gated_spans.gate(sym::destructuring_assignment, self.prev_token.span);
            Ok(self.mk_expr(self.prev_token.span, ExprKind::Underscore, attrs))
        } else if !self.unclosed_delims.is_empty() && self.check(&token::Semi) {
            // Don't complain about bare semicolons after unclosed braces
@ -2620,7 +2619,6 @@ impl<'a> Parser<'a> {
                let exp_span = self.prev_token.span;
                // We permit `.. }` on the left-hand side of a destructuring assignment.
                if self.check(&token::CloseDelim(close_delim)) {
-                    self.sess.gated_spans.gate(sym::destructuring_assignment, self.prev_token.span);
                    base = ast::StructRest::Rest(self.prev_token.span.shrink_to_hi());
                    break;
                }
--- a/compiler/rustc_typeck/src/check/expr.rs
+++ b/compiler/rustc_typeck/src/check/expr.rs
@ -877,11 +877,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                        "let ".to_string(),
                        Applicability::MachineApplicable,
                    );
-                    if !self.sess().features_untracked().destructuring_assignment {
-                        // We already emit an E0658 with a suggestion for `while let`, this is
-                        // redundant output.
-                        err.delay_as_bug();
-                    }
                    break;
                }
                hir::Node::Item(_)
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@ -137,7 +137,7 @@
 #![feature(cfg_target_has_atomic)]
 #![feature(const_fn_trait_bound)]
 #![feature(const_trait_impl)]
-#![feature(destructuring_assignment)]
+#![cfg_attr(bootstrap, feature(destructuring_assignment))]
 #![feature(dropck_eyepatch)]
 #![feature(exclusive_range_pattern)]
 #![feature(fundamental)]
--- a/src/test/ui/associated-types/associated-type-destructuring-assignment.rs
+++ b/src/test/ui/associated-types/associated-type-destructuring-assignment.rs
@ -1,6 +1,5 @@
 // check-pass

-#![feature(destructuring_assignment)]
 #![feature(more_qualified_paths)]

 enum E { V() }
--- a/src/test/ui/cross/cross-file-errors/main.rs
+++ b/src/test/ui/cross/cross-file-errors/main.rs
@ -4,5 +4,4 @@ mod underscore;
 fn main() {
    underscore!();
    //~^ ERROR `_` can only be used on the left-hand side of an assignment
-    //~| ERROR destructuring assignments are unstable
 }
--- a/src/test/ui/cross/cross-file-errors/main.stderr
+++ b/src/test/ui/cross/cross-file-errors/main.stderr
@ -1,18 +1,3 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/underscore.rs:8:9
-   |
-LL |         _
-   |         ^
-   |
-  ::: $DIR/main.rs:5:5
-   |
-LL |     underscore!();
-   |     ------------- in this macro invocation
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-   = note: this error originates in the macro `underscore` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: in expressions, `_` can only be used on the left-hand side of an assignment
  --> $DIR/underscore.rs:8:9
   |
@ -26,6 +11,5 @@ LL |     underscore!();
   |
   = note: this error originates in the macro `underscore` (in Nightly builds, run with -Z macro-backtrace for more info)

-error: aborting due to 2 previous errors
+error: aborting due to previous error

-For more information about this error, try `rustc --explain E0658`.
--- a/src/test/ui/destructuring-assignment/bad-expr-lhs.rs
+++ b/src/test/ui/destructuring-assignment/bad-expr-lhs.rs
@ -1,12 +1,9 @@
 fn main() {
    1 = 2; //~ ERROR invalid left-hand side of assignment
    1 += 2; //~ ERROR invalid left-hand side of assignment
-    (1, 2) = (3, 4); //~ ERROR destructuring assignments are unstable
+    (1, 2) = (3, 4);
+    //~^ ERROR invalid left-hand side of assignment
    //~| ERROR invalid left-hand side of assignment
-    //~| ERROR invalid left-hand side of assignment
-
-    let (a, b) = (1, 2);
-    (a, b) = (3, 4); //~ ERROR destructuring assignments are unstable

    None = Some(3); //~ ERROR invalid left-hand side of assignment
 }
--- a/src/test/ui/destructuring-assignment/bad-expr-lhs.stderr
+++ b/src/test/ui/destructuring-assignment/bad-expr-lhs.stderr
@ -1,25 +1,3 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/bad-expr-lhs.rs:4:12
-   |
-LL |     (1, 2) = (3, 4);
-   |     ------ ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/bad-expr-lhs.rs:9:12
-   |
-LL |     (a, b) = (3, 4);
-   |     ------ ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 error[E0070]: invalid left-hand side of assignment
  --> $DIR/bad-expr-lhs.rs:2:7
   |
@ -53,14 +31,14 @@ LL |     (1, 2) = (3, 4);
   |         cannot assign to this expression

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/bad-expr-lhs.rs:11:10
+  --> $DIR/bad-expr-lhs.rs:8:10
   |
 LL |     None = Some(3);
   |     ---- ^
   |     |
   |     cannot assign to this expression

-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors

-Some errors have detailed explanations: E0067, E0070, E0658.
+Some errors have detailed explanations: E0067, E0070.
 For more information about an error, try `rustc --explain E0067`.
--- a/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.rs
+++ b/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.rs
@ -1,5 +1,3 @@
-#![feature(destructuring_assignment)]
-
 fn main() {
    let mut x = &0;
    let mut y = &0;
--- a/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
+++ b/src/test/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/default-match-bindings-forbidden.rs:6:5
+  --> $DIR/default-match-bindings-forbidden.rs:4:5
   |
 LL |     (x, y) = &(1, 2);
   |     ^^^^^^   ------- this expression has type `&({integer}, {integer})`
--- a/src/test/ui/destructuring-assignment/drop-order.rs
+++ b/src/test/ui/destructuring-assignment/drop-order.rs
@ -2,7 +2,6 @@

 //! Test that let bindings and destructuring assignments have consistent drop orders

-#![feature(destructuring_assignment)]
 #![allow(unused_variables, unused_assignments)]

 use std::cell::RefCell;
--- a/src/test/ui/destructuring-assignment/nested_destructure.rs
+++ b/src/test/ui/destructuring-assignment/nested_destructure.rs
@ -1,7 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
-
 struct Struct<S, T> {
    a: S,
    b: T,
--- a/src/test/ui/destructuring-assignment/note-unsupported.rs
+++ b/src/test/ui/destructuring-assignment/note-unsupported.rs
@ -3,25 +3,20 @@ struct S { x: u8, y: u8 }
 fn main() {
    let (a, b) = (1, 2);

-    (a, b) = (3, 4); //~ ERROR destructuring assignments are unstable
+    (a, b) = (3, 4);
    (a, b) += (3, 4); //~ ERROR invalid left-hand side of assignment
    //~| ERROR binary assignment operation `+=` cannot be applied

-    [a, b] = [3, 4]; //~ ERROR destructuring assignments are unstable
+    [a, b] = [3, 4];
    [a, b] += [3, 4]; //~ ERROR invalid left-hand side of assignment
    //~| ERROR binary assignment operation `+=` cannot be applied

    let s = S { x: 3, y: 4 };

-    S { x: a, y: b } = s; //~ ERROR destructuring assignments are unstable
+    S { x: a, y: b } = s;
    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 functional record updates are not allowed in destructuring assignments
-    //~| ERROR destructuring assignments are unstable
-
-    let c = 3;
-
-    ((a, b), c) = ((3, 4), 5); //~ ERROR destructuring assignments are unstable
 }
--- a/src/test/ui/destructuring-assignment/note-unsupported.stderr
+++ b/src/test/ui/destructuring-assignment/note-unsupported.stderr
@ -1,64 +1,9 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:6:12
-   |
-LL |     (a, b) = (3, 4);
-   |     ------ ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:10:12
-   |
-LL |     [a, b] = [3, 4];
-   |     ------ ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:16:22
-   |
-LL |     S { x: a, y: b } = s;
-   |     ---------------- ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-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 #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 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 the trailing pattern

-error[E0658]: destructuring assignments are unstable
-  --> $DIR/note-unsupported.rs:26:17
-   |
-LL |     ((a, b), c) = ((3, 4), 5);
-   |     ----------- ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 error[E0368]: binary assignment operation `+=` cannot be applied to type `({integer}, {integer})`
  --> $DIR/note-unsupported.rs:7:5
   |
@ -124,7 +69,7 @@ LL |     S { x: a, y: b } += s;
   |     |
   |     cannot assign to this expression

-error: aborting due to 12 previous errors
+error: aborting due to 7 previous errors

-Some errors have detailed explanations: E0067, E0368, E0658.
+Some errors have detailed explanations: E0067, E0368.
 For more information about an error, try `rustc --explain E0067`.
--- a/src/test/ui/destructuring-assignment/slice_destructure.rs
+++ b/src/test/ui/destructuring-assignment/slice_destructure.rs
@ -1,7 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
-
 fn main() {
  let (mut a, mut b);
  [a, b] = [0, 1];
--- a/src/test/ui/destructuring-assignment/slice_destructure_fail.rs
+++ b/src/test/ui/destructuring-assignment/slice_destructure_fail.rs
@ -1,5 +1,3 @@
-#![feature(destructuring_assignment)]
-
 fn main() {
  let (mut a, mut b);
  [a, .., b, ..] = [0, 1]; //~ ERROR `..` can only be used once per slice pattern
--- a/src/test/ui/destructuring-assignment/slice_destructure_fail.stderr
+++ b/src/test/ui/destructuring-assignment/slice_destructure_fail.stderr
@ -1,5 +1,5 @@
 error: `..` can only be used once per slice pattern
-  --> $DIR/slice_destructure_fail.rs:5:14
+  --> $DIR/slice_destructure_fail.rs:3:14
   |
 LL |   [a, .., b, ..] = [0, 1];
   |       --     ^^ can only be used once per slice pattern
@ -7,13 +7,13 @@ LL |   [a, .., b, ..] = [0, 1];
   |       previously used here

 error[E0527]: pattern requires 3 elements but array has 2
-  --> $DIR/slice_destructure_fail.rs:6:3
+  --> $DIR/slice_destructure_fail.rs:4:3
   |
 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
+  --> $DIR/slice_destructure_fail.rs:5:3
   |
 LL |   [_] = [1, 2];
   |   ^^^ expected 2 elements
--- a/src/test/ui/destructuring-assignment/struct_destructure.rs
+++ b/src/test/ui/destructuring-assignment/struct_destructure.rs
@ -1,6 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
 struct Struct<S, T> {
    a: S,
    b: T,
--- a/src/test/ui/destructuring-assignment/struct_destructure_fail.rs
+++ b/src/test/ui/destructuring-assignment/struct_destructure_fail.rs
@ -1,4 +1,3 @@
-#![feature(destructuring_assignment)]
 struct Struct<S, T> {
    a: S,
    b: T,
--- a/src/test/ui/destructuring-assignment/struct_destructure_fail.stderr
+++ b/src/test/ui/destructuring-assignment/struct_destructure_fail.stderr
@ -1,5 +1,5 @@
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/struct_destructure_fail.rs:12:17
+  --> $DIR/struct_destructure_fail.rs:11:17
   |
 LL |     Struct { a, _ } = Struct { a: 1, b: 2 };
   |     ------      ^ expected identifier, found reserved identifier
@ -7,25 +7,25 @@ LL |     Struct { a, _ } = Struct { a: 1, b: 2 };
   |     while parsing this struct

 error: functional record updates are not allowed in destructuring assignments
-  --> $DIR/struct_destructure_fail.rs:14:19
+  --> $DIR/struct_destructure_fail.rs:13:19
   |
 LL |     Struct { a, ..d } = Struct { a: 1, b: 2 };
   |                   ^ help: consider removing the trailing pattern

 error: base expression required after `..`
-  --> $DIR/struct_destructure_fail.rs:16:19
+  --> $DIR/struct_destructure_fail.rs:15:19
   |
 LL |     Struct { a, .. };
   |                   ^ add a base expression here

 error[E0026]: struct `Struct` does not have a field named `c`
-  --> $DIR/struct_destructure_fail.rs:11:20
+  --> $DIR/struct_destructure_fail.rs:10: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:12:5
+  --> $DIR/struct_destructure_fail.rs:11:5
   |
 LL |     Struct { a, _ } = Struct { a: 1, b: 2 };
   |     ^^^^^^^^^^^^^^^ missing field `b`
--- a/src/test/ui/destructuring-assignment/tuple_destructure.rs
+++ b/src/test/ui/destructuring-assignment/tuple_destructure.rs
@ -1,7 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
-
 fn main() {
    let (mut a, mut b);
    (a, b) = (0, 1);
--- a/src/test/ui/destructuring-assignment/tuple_destructure_fail.rs
+++ b/src/test/ui/destructuring-assignment/tuple_destructure_fail.rs
@ -1,5 +1,3 @@
-#![feature(destructuring_assignment)]
-
 const C: i32 = 1;

 fn main() {
--- a/src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr
+++ b/src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr
@ -1,5 +1,5 @@
 error: `..` can only be used once per tuple pattern
-  --> $DIR/tuple_destructure_fail.rs:7:16
+  --> $DIR/tuple_destructure_fail.rs:5:16
   |
 LL |     (a, .., b, ..) = (0, 1);
   |         --     ^^ can only be used once per tuple pattern
@ -7,7 +7,7 @@ LL |     (a, .., b, ..) = (0, 1);
   |         previously used here

 error[E0308]: mismatched types
-  --> $DIR/tuple_destructure_fail.rs:8:5
+  --> $DIR/tuple_destructure_fail.rs:6:5
   |
 LL |     (a, a, b) = (1, 2);
   |     ^^^^^^^^^   ------ this expression has type `({integer}, {integer})`
@ -18,7 +18,7 @@ LL |     (a, a, b) = (1, 2);
             found tuple `(_, _, _)`

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/tuple_destructure_fail.rs:9:13
+  --> $DIR/tuple_destructure_fail.rs:7:13
   |
 LL |     (C, ..) = (0,1);
   |      -      ^
@ -26,7 +26,7 @@ LL |     (C, ..) = (0,1);
   |      cannot assign to this expression

 error[E0308]: mismatched types
-  --> $DIR/tuple_destructure_fail.rs:10:5
+  --> $DIR/tuple_destructure_fail.rs:8:5
   |
 LL |     (_,) = (1, 2);
   |     ^^^^   ------ this expression has type `({integer}, {integer})`
--- a/src/test/ui/destructuring-assignment/tuple_struct_destructure.rs
+++ b/src/test/ui/destructuring-assignment/tuple_struct_destructure.rs
@ -1,7 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
-
 struct TupleStruct<S, T>(S, T);

 impl<S, T> TupleStruct<S, T> {
--- a/src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.rs
+++ b/src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.rs
@ -1,5 +1,3 @@
-#![feature(destructuring_assignment)]
-
 struct TupleStruct<S, T>(S, T);

 enum Enum<S, T> {
--- a/src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.stderr
+++ b/src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.stderr
@ -1,5 +1,5 @@
 error: `..` can only be used once per tuple struct or variant pattern
-  --> $DIR/tuple_struct_destructure_fail.rs:25:27
+  --> $DIR/tuple_struct_destructure_fail.rs:23:27
   |
 LL |     TupleStruct(a, .., b, ..) = TupleStruct(0, 1);
   |                    --     ^^ can only be used once per tuple struct or variant pattern
@ -7,7 +7,7 @@ LL |     TupleStruct(a, .., b, ..) = TupleStruct(0, 1);
   |                    previously used here

 error: `..` can only be used once per tuple struct or variant pattern
-  --> $DIR/tuple_struct_destructure_fail.rs:27:35
+  --> $DIR/tuple_struct_destructure_fail.rs:25:35
   |
 LL |     Enum::SingleVariant(a, .., b, ..) = Enum::SingleVariant(0, 1);
   |                            --     ^^ can only be used once per tuple struct or variant pattern
@ -15,7 +15,7 @@ LL |     Enum::SingleVariant(a, .., b, ..) = Enum::SingleVariant(0, 1);
   |                            previously used here

 error[E0023]: this pattern has 3 fields, but the corresponding tuple struct has 2 fields
-  --> $DIR/tuple_struct_destructure_fail.rs:30:17
+  --> $DIR/tuple_struct_destructure_fail.rs:28:17
   |
 LL | struct TupleStruct<S, T>(S, T);
   |                          -  - tuple struct has 2 fields
@ -24,7 +24,7 @@ LL |     TupleStruct(a, a, b) = TupleStruct(1, 2);
   |                 ^  ^  ^ expected 2 fields, found 3

 error[E0023]: this pattern has 1 field, but the corresponding tuple struct has 2 fields
-  --> $DIR/tuple_struct_destructure_fail.rs:32:17
+  --> $DIR/tuple_struct_destructure_fail.rs:30:17
   |
 LL | struct TupleStruct<S, T>(S, T);
   |                          -  - tuple struct has 2 fields
@ -42,7 +42,7 @@ LL |     TupleStruct(..) = TupleStruct(1, 2);
   |                 ~~

 error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
-  --> $DIR/tuple_struct_destructure_fail.rs:34:25
+  --> $DIR/tuple_struct_destructure_fail.rs:32:25
   |
 LL |     SingleVariant(S, T)
   |                   -  - tuple variant has 2 fields
@ -51,7 +51,7 @@ LL |     Enum::SingleVariant(a, a, b) = Enum::SingleVariant(1, 2);
   |                         ^  ^  ^ expected 2 fields, found 3

 error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
-  --> $DIR/tuple_struct_destructure_fail.rs:36:25
+  --> $DIR/tuple_struct_destructure_fail.rs:34:25
   |
 LL |     SingleVariant(S, T)
   |                   -  - tuple variant has 2 fields
@ -69,7 +69,7 @@ LL |     Enum::SingleVariant(..) = Enum::SingleVariant(1, 2);
   |                         ~~

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/tuple_struct_destructure_fail.rs:40:12
+  --> $DIR/tuple_struct_destructure_fail.rs:38:12
   |
 LL |     test() = TupleStruct(0, 0);
   |     ------ ^
@ -77,7 +77,7 @@ LL |     test() = TupleStruct(0, 0);
   |     cannot assign to this expression

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/tuple_struct_destructure_fail.rs:42:14
+  --> $DIR/tuple_struct_destructure_fail.rs:40:14
   |
 LL |     (test)() = TupleStruct(0, 0);
   |     -------- ^
@ -85,7 +85,7 @@ LL |     (test)() = TupleStruct(0, 0);
   |     cannot assign to this expression

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/tuple_struct_destructure_fail.rs:44:38
+  --> $DIR/tuple_struct_destructure_fail.rs:42:38
   |
 LL |     <Alias::<isize> as Test>::test() = TupleStruct(0, 0);
   |     -------------------------------- ^
--- a/src/test/ui/destructuring-assignment/underscore-range-expr-gating.rs
+++ b/src/test/ui/destructuring-assignment/underscore-range-expr-gating.rs
@ -1,10 +0,0 @@
-fn main() {}
-
-struct S { x : u32 }
-
-#[cfg(FALSE)]
-fn foo() {
-    _; //~ ERROR destructuring assignments are unstable
-
-    S { x: 5, .. }; //~ ERROR destructuring assignments are unstable
-}
--- a/src/test/ui/destructuring-assignment/underscore-range-expr-gating.stderr
+++ b/src/test/ui/destructuring-assignment/underscore-range-expr-gating.stderr
@ -1,21 +0,0 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/underscore-range-expr-gating.rs:7:5
-   |
-LL |     _;
-   |     ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/underscore-range-expr-gating.rs:9:15
-   |
-LL |     S { x: 5, .. };
-   |               ^^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
--- a/src/test/ui/destructuring-assignment/warn-unused-duplication.rs
+++ b/src/test/ui/destructuring-assignment/warn-unused-duplication.rs
@ -1,7 +1,5 @@
 // run-pass

-#![feature(destructuring_assignment)]
-
 #![warn(unused_assignments)]

 fn main() {
--- a/src/test/ui/destructuring-assignment/warn-unused-duplication.stderr
+++ b/src/test/ui/destructuring-assignment/warn-unused-duplication.stderr
@ -1,11 +1,11 @@
 warning: value assigned to `a` is never read
-  --> $DIR/warn-unused-duplication.rs:11:6
+  --> $DIR/warn-unused-duplication.rs:9:6
   |
 LL |     (a, a) = (0, 1);
   |      ^
   |
 note: the lint level is defined here
-  --> $DIR/warn-unused-duplication.rs:5:9
+  --> $DIR/warn-unused-duplication.rs:3:9
   |
 LL | #![warn(unused_assignments)]
   |         ^^^^^^^^^^^^^^^^^^
--- a/src/test/ui/feature-gates/feature-gate-destructuring_assignment.rs
+++ b/src/test/ui/feature-gates/feature-gate-destructuring_assignment.rs
@ -1,4 +0,0 @@
-fn main() {
-    let (a, b) = (0, 1);
-    (a, b) = (2, 3); //~ ERROR destructuring assignments are unstable
-}
--- a/src/test/ui/feature-gates/feature-gate-destructuring_assignment.stderr
+++ b/src/test/ui/feature-gates/feature-gate-destructuring_assignment.stderr
@ -1,14 +0,0 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/feature-gate-destructuring_assignment.rs:3:12
-   |
-LL |     (a, b) = (2, 3);
-   |     ------ ^
-   |     |
-   |     cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
--- a/src/test/ui/issues/issue-77218/issue-77218-2.fixed
+++ b/src/test/ui/issues/issue-77218/issue-77218-2.fixed
@ -1,5 +1,4 @@
 // run-rustfix
-#![feature(destructuring_assignment)]
 fn main() {
    let value = [7u8];
    while let Some(0) = value.get(0) { //~ ERROR invalid left-hand side of assignment
--- a/src/test/ui/issues/issue-77218/issue-77218-2.rs
+++ b/src/test/ui/issues/issue-77218/issue-77218-2.rs
@ -1,5 +1,4 @@
 // run-rustfix
-#![feature(destructuring_assignment)]
 fn main() {
    let value = [7u8];
    while Some(0) = value.get(0) { //~ ERROR invalid left-hand side of assignment
--- a/src/test/ui/issues/issue-77218/issue-77218-2.stderr
+++ b/src/test/ui/issues/issue-77218/issue-77218-2.stderr
@ -1,5 +1,5 @@
 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/issue-77218-2.rs:5:19
+  --> $DIR/issue-77218-2.rs:4:19
   |
 LL |     while Some(0) = value.get(0) {
   |                -  ^
--- a/src/test/ui/issues/issue-77218/issue-77218.fixed
+++ b/src/test/ui/issues/issue-77218/issue-77218.fixed
@ -1,6 +1,5 @@
 // run-rustfix
 fn main() {
    let value = [7u8];
-    while let Some(0) = value.get(0) { //~ ERROR destructuring assignments are unstable
-    }
+    while let Some(0) = value.get(0) {} //~ ERROR invalid left-hand side of assignment
 }
--- a/src/test/ui/issues/issue-77218/issue-77218.rs
+++ b/src/test/ui/issues/issue-77218/issue-77218.rs
@ -1,6 +1,5 @@
 // run-rustfix
 fn main() {
    let value = [7u8];
-    while Some(0) = value.get(0) { //~ ERROR destructuring assignments are unstable
-    }
+    while Some(0) = value.get(0) {} //~ ERROR invalid left-hand side of assignment
 }
--- a/src/test/ui/issues/issue-77218/issue-77218.stderr
+++ b/src/test/ui/issues/issue-77218/issue-77218.stderr
@ -1,18 +1,16 @@
-error[E0658]: destructuring assignments are unstable
+error[E0070]: invalid left-hand side of assignment
  --> $DIR/issue-77218.rs:4:19
   |
-LL |     while Some(0) = value.get(0) {
-   |           ------- ^
-   |           |
-   |           cannot assign to this expression
+LL |     while Some(0) = value.get(0) {}
+   |                -  ^
+   |                |
+   |                cannot assign to this expression
   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
 help: you might have meant to use pattern destructuring
   |
-LL |     while let Some(0) = value.get(0) {
+LL |     while let Some(0) = value.get(0) {}
   |           +++

 error: aborting due to previous error

-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0070`.
--- a/src/test/ui/suggestions/fn-or-tuple-struct-with-underscore-args.rs
+++ b/src/test/ui/suggestions/fn-or-tuple-struct-with-underscore-args.rs
@ -10,16 +10,10 @@ fn main() {
    let _: usize = foo(_, _);
    //~^ ERROR `_` can only be used on the left-hand side of an assignment
    //~| ERROR `_` can only be used on the left-hand side of an assignment
-    //~| ERROR destructuring assignments are unstable
-    //~| ERROR destructuring assignments are unstable
    let _: S = S(_, _);
    //~^ ERROR `_` can only be used on the left-hand side of an assignment
    //~| ERROR `_` can only be used on the left-hand side of an assignment
-    //~| ERROR destructuring assignments are unstable
-    //~| ERROR destructuring assignments are unstable
    let _: usize = T::baz(_, _);
    //~^ ERROR `_` can only be used on the left-hand side of an assignment
    //~| ERROR `_` can only be used on the left-hand side of an assignment
-    //~| ERROR destructuring assignments are unstable
-    //~| ERROR destructuring assignments are unstable
 }
--- a/src/test/ui/suggestions/fn-or-tuple-struct-with-underscore-args.stderr
+++ b/src/test/ui/suggestions/fn-or-tuple-struct-with-underscore-args.stderr
@ -1,57 +1,3 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:10:24
-   |
-LL |     let _: usize = foo(_, _);
-   |                        ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:10:27
-   |
-LL |     let _: usize = foo(_, _);
-   |                           ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:15:18
-   |
-LL |     let _: S = S(_, _);
-   |                  ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:15:21
-   |
-LL |     let _: S = S(_, _);
-   |                     ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:20:27
-   |
-LL |     let _: usize = T::baz(_, _);
-   |                           ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:20:30
-   |
-LL |     let _: usize = T::baz(_, _);
-   |                              ^
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 error: in expressions, `_` can only be used on the left-hand side of an assignment
  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:10:24
   |
@ -65,29 +11,28 @@ LL |     let _: usize = foo(_, _);
   |                           ^ `_` not allowed here

 error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:15:18
+  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:13:18
   |
 LL |     let _: S = S(_, _);
   |                  ^ `_` not allowed here

 error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:15:21
+  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:13:21
   |
 LL |     let _: S = S(_, _);
   |                     ^ `_` not allowed here

 error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:20:27
+  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:16:27
   |
 LL |     let _: usize = T::baz(_, _);
   |                           ^ `_` not allowed here

 error: in expressions, `_` can only be used on the left-hand side of an assignment
-  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:20:30
+  --> $DIR/fn-or-tuple-struct-with-underscore-args.rs:16:30
   |
 LL |     let _: usize = T::baz(_, _);
   |                              ^ `_` not allowed here

-error: aborting due to 12 previous errors
+error: aborting due to 6 previous errors

-For more information about this error, try `rustc --explain E0658`.
--- a/src/test/ui/suggestions/if-let-typo.rs
+++ b/src/test/ui/suggestions/if-let-typo.rs
@ -3,12 +3,9 @@ fn main() {
    let bar = None;
    if Some(x) = foo {} //~ ERROR cannot find value `x` in this scope
    //~^ ERROR mismatched types
-    //~^^ ERROR destructuring assignments are unstable
    if Some(foo) = bar {} //~ ERROR mismatched types
-    //~^ ERROR destructuring assignments are unstable
    if 3 = foo {} //~ ERROR mismatched types
    if Some(3) = foo {} //~ ERROR mismatched types
-    //~^ ERROR destructuring assignments are unstable
-    //~^^ ERROR invalid left-hand side of assignment
+    //~^ ERROR invalid left-hand side of assignment
    if x = 5 {}  //~ ERROR cannot find value `x` in this scope
 }
--- a/src/test/ui/suggestions/if-let-typo.stderr
+++ b/src/test/ui/suggestions/if-let-typo.stderr
@ -10,7 +10,7 @@ LL |     if let Some(x) = foo {}
   |        +++

 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/if-let-typo.rs:13:8
+  --> $DIR/if-let-typo.rs:10:8
   |
 LL |     if x = 5 {}
   |        ^ not found in this scope
@ -20,39 +20,6 @@ help: you might have meant to use pattern matching
 LL |     if let x = 5 {}
   |        +++

-error[E0658]: destructuring assignments are unstable
-  --> $DIR/if-let-typo.rs:4:16
-   |
-LL |     if Some(x) = foo {}
-   |        ------- ^
-   |        |
-   |        cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/if-let-typo.rs:7:18
-   |
-LL |     if Some(foo) = bar {}
-   |        --------- ^
-   |        |
-   |        cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/if-let-typo.rs:10:16
-   |
-LL |     if Some(3) = foo {}
-   |        ------- ^
-   |        |
-   |        cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 error[E0308]: mismatched types
  --> $DIR/if-let-typo.rs:4:8
   |
@ -60,19 +27,19 @@ LL |     if Some(x) = foo {}
   |        ^^^^^^^^^^^^^ expected `bool`, found `()`

 error[E0308]: mismatched types
-  --> $DIR/if-let-typo.rs:7:8
+  --> $DIR/if-let-typo.rs:6:8
   |
 LL |     if Some(foo) = bar {}
   |        ^^^^^^^^^^^^^^^ expected `bool`, found `()`

 error[E0308]: mismatched types
-  --> $DIR/if-let-typo.rs:9:8
+  --> $DIR/if-let-typo.rs:7:8
   |
 LL |     if 3 = foo {}
   |        ^^^^^^^ expected `bool`, found `()`

 error[E0070]: invalid left-hand side of assignment
-  --> $DIR/if-let-typo.rs:10:16
+  --> $DIR/if-let-typo.rs:8:16
   |
 LL |     if Some(3) = foo {}
   |             -  ^
@ -80,12 +47,12 @@ LL |     if Some(3) = foo {}
   |             cannot assign to this expression

 error[E0308]: mismatched types
-  --> $DIR/if-let-typo.rs:10:8
+  --> $DIR/if-let-typo.rs:8:8
   |
 LL |     if Some(3) = foo {}
   |        ^^^^^^^^^^^^^ expected `bool`, found `()`

-error: aborting due to 10 previous errors
+error: aborting due to 7 previous errors

-Some errors have detailed explanations: E0070, E0308, E0425, E0658.
+Some errors have detailed explanations: E0070, E0308, E0425.
 For more information about an error, try `rustc --explain E0070`.
--- a/src/test/ui/weird-exprs.rs
+++ b/src/test/ui/weird-exprs.rs
@ -1,7 +1,6 @@
 // run-pass

 #![feature(generators)]
-#![feature(destructuring_assignment)]

 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
--- a/src/tools/clippy/tests/ui/crashes/ice-6250.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-6250.stderr
@ -1,14 +1,3 @@
-error[E0658]: destructuring assignments are unstable
-  --> $DIR/ice-6250.rs:12:25
-   |
-LL |         Some(reference) = cache.data.get(key) {
-   |         --------------- ^
-   |         |
-   |         cannot assign to this expression
-   |
-   = note: see issue #71126 <https://github.com/rust-lang/rust/issues/71126> for more information
-   = help: add `#![feature(destructuring_assignment)]` to the crate attributes to enable
-
 error[E0601]: `main` function not found in crate `ice_6250`
  --> $DIR/ice-6250.rs:4:1
   |
@ -41,7 +30,7 @@ error[E0308]: mismatched types
 LL |         Some(reference) = cache.data.get(key) {
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`

-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors

-Some errors have detailed explanations: E0308, E0601, E0658.
+Some errors have detailed explanations: E0308, E0601.
 For more information about an error, try `rustc --explain E0308`.