Introduce #![feature(bindings_after_at)].

Under the gate, `x @ Some(y)` is allowed.
This is subject to various restrictions for soundness.

Author: Centril

src/librustc_feature/active.rs

@@ -539,6 +539,10 @@ declare_features! (
     /// Allows the use of `loop` and `while` in constants.
     (active, const_loop, "1.41.0", Some(52000), None),
 
+    /// Allows bindings in the subpattern of a binding pattern.
+    /// For example, you can write `x @ Some(y)`.
+    (active, bindings_after_at, "1.41.0", Some(65490), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------
@@ -554,4 +558,5 @@ pub const INCOMPLETE_FEATURES: &[Symbol] = &[
     sym::or_patterns,
     sym::let_chains,
     sym::raw_dylib,
+    sym::bindings_after_at,
 ];

src/librustc_mir/hair/pattern/check_match.rs

@@ -4,23 +4,22 @@ use super::_match::{expand_pattern, is_useful, MatchCheckCtxt, Matrix, PatStack}
 
 use super::{PatCtxt, PatKind, PatternError};
 
-use rustc::lint;
-use rustc::session::Session;
-use rustc::ty::subst::{InternalSubsts, SubstsRef};
-use rustc::ty::{self, Ty, TyCtxt};
-use rustc_errors::{Applicability, DiagnosticBuilder};
-
 use rustc::hir::def::*;
 use rustc::hir::def_id::DefId;
 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc::hir::HirId;
 use rustc::hir::{self, Pat};
-
-use std::slice;
-
+use rustc::lint;
+use rustc::session::Session;
+use rustc::ty::subst::{InternalSubsts, SubstsRef};
+use rustc::ty::{self, Ty, TyCtxt};
+use rustc_error_codes::*;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use syntax::feature_gate::feature_err;
+use syntax_pos::symbol::sym;
 use syntax_pos::{MultiSpan, Span};
 
-use rustc_error_codes::*;
+use std::slice;
 
 crate fn check_match(tcx: TyCtxt<'_>, def_id: DefId) {
     let body_id = match tcx.hir().as_local_hir_id(def_id) {
@@ -123,7 +122,9 @@ impl PatCtxt<'_, '_> {
 impl<'tcx> MatchVisitor<'_, 'tcx> {
     fn check_patterns(&mut self, has_guard: bool, pat: &Pat) {
         check_legality_of_move_bindings(self, has_guard, pat);
-        check_legality_of_bindings_in_at_patterns(self, pat);
+        if !self.tcx.features().bindings_after_at {
+            check_legality_of_bindings_in_at_patterns(self, pat);
+        }
     }
 
     fn check_match(&mut self, scrut: &hir::Expr, arms: &'tcx [hir::Arm], source: hir::MatchSource) {
@@ -656,13 +657,12 @@ impl<'v> Visitor<'v> for AtBindingPatternVisitor<'_, '_, '_> {
         match pat.kind {
             hir::PatKind::Binding(.., ref subpat) => {
                 if !self.bindings_allowed {
-                    struct_span_err!(
-                        self.cx.tcx.sess,
+                    feature_err(
+                        &self.cx.tcx.sess.parse_sess,
+                        sym::bindings_after_at,
                         pat.span,
-                        E0303,
-                        "pattern bindings are not allowed after an `@`"
+                        "pattern bindings after an `@` are unstable",
                     )
-                    .span_label(pat.span, "not allowed after `@`")
                     .emit();
                 }
 

src/librustc_parse/parser/pat.rs

@@ -406,6 +406,7 @@ impl<'a> Parser<'a> {
         if let PatKind::Ident(_, _, ref mut sub @ None) = rhs.kind {
             // The user inverted the order, so help them fix that.
             let mut applicability = Applicability::MachineApplicable;
+            // FIXME(bindings_after_at): Remove this code when stabilizing the feature.
             lhs.walk(&mut |p| match p.kind {
                 // `check_match` is unhappy if the subpattern has a binding anywhere.
                 PatKind::Ident(..) => {

src/libsyntax_pos/symbol.rs

@@ -165,6 +165,7 @@ symbols! {
         bench,
         bin,
         bind_by_move_pattern_guards,
+        bindings_after_at,
         block,
         bool,
         borrowck_graphviz_postflow,

src/test/ui/error-codes/E0007.rs

@@ -1,9 +1,11 @@
+#![feature(bindings_after_at)]
+//~^ WARN the feature `bindings_after_at` is incomplete and may cause the compiler to crash
+
 fn main() {
     let x = Some("s".to_string());
     match x {
         op_string @ Some(s) => {},
         //~^ ERROR E0007
-        //~| ERROR E0303
         //~| ERROR E0382
         None => {},
     }

src/test/ui/error-codes/E0007.stderr

@@ -1,17 +1,19 @@
-error[E0007]: cannot bind by-move with sub-bindings
-  --> $DIR/E0007.rs:4:9
+warning: the feature `bindings_after_at` is incomplete and may cause the compiler to crash
+  --> $DIR/E0007.rs:1:12
    |
-LL |         op_string @ Some(s) => {},
-   |         ^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+LL | #![feature(bindings_after_at)]
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
 
-error[E0303]: pattern bindings are not allowed after an `@`
-  --> $DIR/E0007.rs:4:26
+error[E0007]: cannot bind by-move with sub-bindings
+  --> $DIR/E0007.rs:7:9
    |
 LL |         op_string @ Some(s) => {},
-   |                          ^ not allowed after `@`
+   |         ^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
 
 error[E0382]: use of moved value
-  --> $DIR/E0007.rs:4:26
+  --> $DIR/E0007.rs:7:26
    |
 LL |     let x = Some("s".to_string());
    |         - move occurs because `x` has type `std::option::Option<std::string::String>`, which does not implement the `Copy` trait
@@ -22,7 +24,7 @@ LL |         op_string @ Some(s) => {},
    |         |                value used here after move
    |         value moved here
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0007, E0303, E0382.
+Some errors have detailed explanations: E0007, E0382.
 For more information about an error, try `rustc --explain E0007`.

src/test/ui/error-codes/E0303.rs

@@ -0,0 +1,12 @@
+#![feature(bindings_after_at)]
+//~^ WARN the feature `bindings_after_at` is incomplete and may cause the compiler to crash
+
+struct X { x: () }
+
+fn main() {
+    let x = Some(X { x: () });
+    match x {
+        Some(ref _y @ _z) => { }, //~ ERROR cannot bind by-move and by-ref in the same pattern
+        None => panic!()
+    }
+}

src/test/ui/error-codes/E0303.stderr

@@ -0,0 +1,20 @@
+warning: the feature `bindings_after_at` is incomplete and may cause the compiler to crash
+  --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:1:12
+   |
+LL | #![feature(bindings_after_at)]
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+
+error[E0009]: cannot bind by-move and by-ref in the same pattern
+  --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:9:23
+   |
+LL |         Some(ref _y @ _z) => { },
+   |              ---------^^
+   |              |        |
+   |              |        by-move pattern here
+   |              both by-ref and by-move used
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0009`.