From 2e64bb2d37d5f15113e0a7199cd684504c6b8de7 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 17:18:08 +0200
Subject: syntax: reject `trait Foo: Bar = Baz;`.

Add test for rejecting `trait A: B1 = B2;`.
Also test rejection of `trait A: = B;`.
---
 src/libsyntax/parse/parser/item.rs | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs
index 73bd80e2a21..01dc0c21d4d 100644
--- a/src/libsyntax/parse/parser/item.rs
+++ b/src/libsyntax/parse/parser/item.rs
@@ -211,7 +211,7 @@ impl<'a> Parser<'a> {
         {
             // UNSAFE TRAIT ITEM
             self.bump(); // `unsafe`
-            let info = self.parse_item_trait(Unsafety::Unsafe)?;
+            let info = self.parse_item_trait(lo, Unsafety::Unsafe)?;
             return self.mk_item_with_info(attrs, lo, vis, info);
         }
 
@@ -289,7 +289,7 @@ impl<'a> Parser<'a> {
                 && self.is_keyword_ahead(1, &[kw::Trait]))
         {
             // TRAIT ITEM
-            let info = self.parse_item_trait(Unsafety::Normal)?;
+            let info = self.parse_item_trait(lo, Unsafety::Normal)?;
             return self.mk_item_with_info(attrs, lo, vis, info);
         }
 
@@ -780,7 +780,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses `auto? trait Foo { ... }` or `trait Foo = Bar;`.
-    fn parse_item_trait(&mut self, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
+    fn parse_item_trait(&mut self, lo: Span, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
         // Parse optional `auto` prefix.
         let is_auto = if self.eat_keyword(kw::Auto) {
             IsAuto::Yes
@@ -793,29 +793,41 @@ impl<'a> Parser<'a> {
         let mut tps = self.parse_generics()?;
 
         // Parse optional colon and supertrait bounds.
-        let bounds = if self.eat(&token::Colon) {
+        let had_colon = self.eat(&token::Colon);
+        let span_at_colon = self.prev_span;
+        let bounds = if had_colon {
             self.parse_generic_bounds(Some(self.prev_span))?
         } else {
             Vec::new()
         };
 
+        let span_before_eq = self.prev_span;
         if self.eat(&token::Eq) {
             // It's a trait alias.
+            if had_colon {
+                let span = span_at_colon.to(span_before_eq);
+                self.struct_span_err(span, "bounds are not allowed on trait aliases")
+                    .emit();
+            }
+
             let bounds = self.parse_generic_bounds(None)?;
             tps.where_clause = self.parse_where_clause()?;
             self.expect(&token::Semi)?;
+
+            let whole_span = lo.to(self.prev_span);
             if is_auto == IsAuto::Yes {
                 let msg = "trait aliases cannot be `auto`";
-                self.struct_span_err(self.prev_span, msg)
-                    .span_label(self.prev_span, msg)
+                self.struct_span_err(whole_span, msg)
+                    .span_label(whole_span, msg)
                     .emit();
             }
             if unsafety != Unsafety::Normal {
                 let msg = "trait aliases cannot be `unsafe`";
-                self.struct_span_err(self.prev_span, msg)
-                    .span_label(self.prev_span, msg)
+                self.struct_span_err(whole_span, msg)
+                    .span_label(whole_span, msg)
                     .emit();
             }
+
             Ok((ident, ItemKind::TraitAlias(tps, bounds), None))
         } else {
             // It's a normal trait.
-- 
cgit 1.4.1-3-g733a5


From 2d182b82ce5ecfe8090ba3d4e78f1cd72c072ef1 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 17:40:50 +0200
Subject: pre-expansion gate trait_alias.

---
 src/libsyntax/feature_gate/check.rs                       | 10 +---------
 src/libsyntax/parse/parser/item.rs                        |  2 ++
 src/libsyntax/sess.rs                                     |  2 ++
 src/test/ui/feature-gates/feature-gate-trait-alias.rs     |  9 +++++++++
 src/test/ui/feature-gates/feature-gate-trait-alias.stderr | 11 ++++++++++-
 5 files changed, 24 insertions(+), 10 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 172511f0f09..97172691a11 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -423,15 +423,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                    "auto traits are experimental and possibly buggy");
             }
 
-            ast::ItemKind::TraitAlias(..) => {
-                gate_feature_post!(
-                    &self,
-                    trait_alias,
-                    i.span,
-                    "trait aliases are experimental"
-                );
-            }
-
             ast::ItemKind::MacroDef(ast::MacroDef { legacy: false, .. }) => {
                 let msg = "`macro` is experimental";
                 gate_feature_post!(&self, decl_macro, i.span, msg);
@@ -867,6 +858,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(yields, generators, "yield syntax is experimental");
     gate_all!(or_patterns, "or-patterns syntax is experimental");
     gate_all!(const_extern_fn, "`const extern fn` definitions are unstable");
+    gate_all!(trait_alias, "trait aliases are experimental");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs
index 01dc0c21d4d..c5498236da1 100644
--- a/src/libsyntax/parse/parser/item.rs
+++ b/src/libsyntax/parse/parser/item.rs
@@ -828,6 +828,8 @@ impl<'a> Parser<'a> {
                     .emit();
             }
 
+            self.sess.gated_spans.trait_alias.borrow_mut().push(whole_span);
+
             Ok((ident, ItemKind::TraitAlias(tps, bounds), None))
         } else {
             // It's a normal trait.
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index e49d3954f8e..b48b2b494c8 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -30,6 +30,8 @@ crate struct GatedSpans {
     crate or_patterns: Lock<Vec<Span>>,
     /// Spans collected for gating `const_extern_fn`, e.g. `const extern fn foo`.
     crate const_extern_fn: Lock<Vec<Span>>,
+    /// Spans collected for gating `trait_alias`, e.g. `trait Foo = Ord + Eq;`.
+    pub trait_alias: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-trait-alias.rs b/src/test/ui/feature-gates/feature-gate-trait-alias.rs
index 819085addda..4b94d7d6d3b 100644
--- a/src/test/ui/feature-gates/feature-gate-trait-alias.rs
+++ b/src/test/ui/feature-gates/feature-gate-trait-alias.rs
@@ -1,4 +1,13 @@
 trait Foo = Default;
 //~^ ERROR trait aliases are experimental
 
+macro_rules! accept_item {
+    ($i:item) => {}
+}
+
+accept_item! {
+    trait Foo = Ord + Eq;
+    //~^ ERROR trait aliases are experimental
+}
+
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-trait-alias.stderr b/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
index 9250e27d158..b1bf6ad3491 100644
--- a/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
+++ b/src/test/ui/feature-gates/feature-gate-trait-alias.stderr
@@ -7,6 +7,15 @@ LL | trait Foo = Default;
    = note: for more information, see https://github.com/rust-lang/rust/issues/41517
    = help: add `#![feature(trait_alias)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error[E0658]: trait aliases are experimental
+  --> $DIR/feature-gate-trait-alias.rs:9:5
+   |
+LL |     trait Foo = Ord + Eq;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/41517
+   = help: add `#![feature(trait_alias)]` to the crate attributes to enable
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From c17a1fd7d0ef0f1f546445d0c8bdb11be55e4be7 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 18:05:26 +0200
Subject: pre-expansion gate associated_type_bounds

---
 src/libsyntax/feature_gate/check.rs                      | 16 ++--------------
 src/libsyntax/parse/parser/path.rs                       | 12 ++++++++++--
 src/libsyntax/sess.rs                                    |  2 ++
 .../feature-gates/feature-gate-associated_type_bounds.rs |  4 ++++
 .../feature-gate-associated_type_bounds.stderr           | 11 ++++++++++-
 5 files changed, 28 insertions(+), 17 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 97172691a11..43a3f45bb06 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -3,10 +3,7 @@ use super::accepted::ACCEPTED_FEATURES;
 use super::removed::{REMOVED_FEATURES, STABLE_REMOVED_FEATURES};
 use super::builtin_attrs::{AttributeGate, BUILTIN_ATTRIBUTE_MAP};
 
-use crate::ast::{
-    self, AssocTyConstraint, AssocTyConstraintKind, NodeId, GenericParam, GenericParamKind,
-    PatKind, RangeEnd, VariantData,
-};
+use crate::ast::{self, NodeId, GenericParam, GenericParamKind, PatKind, RangeEnd, VariantData};
 use crate::attr::{self, check_builtin_attribute};
 use crate::source_map::Spanned;
 use crate::edition::{ALL_EDITIONS, Edition};
@@ -584,16 +581,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_generic_param(self, param)
     }
 
-    fn visit_assoc_ty_constraint(&mut self, constraint: &'a AssocTyConstraint) {
-        match constraint.kind {
-            AssocTyConstraintKind::Bound { .. } =>
-                gate_feature_post!(&self, associated_type_bounds, constraint.span,
-                    "associated type bounds are unstable"),
-            _ => {}
-        }
-        visit::walk_assoc_ty_constraint(self, constraint)
-    }
-
     fn visit_trait_item(&mut self, ti: &'a ast::TraitItem) {
         match ti.kind {
             ast::TraitItemKind::Method(ref sig, ref block) => {
@@ -859,6 +846,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(or_patterns, "or-patterns syntax is experimental");
     gate_all!(const_extern_fn, "`const extern fn` definitions are unstable");
     gate_all!(trait_alias, "trait aliases are experimental");
+    gate_all!(associated_type_bounds, "associated type bounds are unstable");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/path.rs b/src/libsyntax/parse/parser/path.rs
index 639d61a2b5c..77709a22953 100644
--- a/src/libsyntax/parse/parser/path.rs
+++ b/src/libsyntax/parse/parser/path.rs
@@ -404,8 +404,9 @@ impl<'a> Parser<'a> {
                 // Parse lifetime argument.
                 args.push(GenericArg::Lifetime(self.expect_lifetime()));
                 misplaced_assoc_ty_constraints.append(&mut assoc_ty_constraints);
-            } else if self.check_ident() && self.look_ahead(1,
-                    |t| t == &token::Eq || t == &token::Colon) {
+            } else if self.check_ident()
+                && self.look_ahead(1, |t| t == &token::Eq || t == &token::Colon)
+            {
                 // Parse associated type constraint.
                 let lo = self.token.span;
                 let ident = self.parse_ident()?;
@@ -420,7 +421,14 @@ impl<'a> Parser<'a> {
                 } else {
                     unreachable!();
                 };
+
                 let span = lo.to(self.prev_span);
+
+                // Gate associated type bounds, e.g., `Iterator<Item: Ord>`.
+                if let AssocTyConstraintKind::Bound { .. } = kind {
+                    self.sess.gated_spans.associated_type_bounds.borrow_mut().push(span);
+                }
+
                 constraints.push(AssocTyConstraint {
                     id: ast::DUMMY_NODE_ID,
                     ident,
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index b48b2b494c8..13f89c3720b 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -32,6 +32,8 @@ crate struct GatedSpans {
     crate const_extern_fn: Lock<Vec<Span>>,
     /// Spans collected for gating `trait_alias`, e.g. `trait Foo = Ord + Eq;`.
     pub trait_alias: Lock<Vec<Span>>,
+    /// Spans collected for gating `associated_type_bounds`, e.g. `Iterator<Item: Ord>`.
+    pub associated_type_bounds: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-associated_type_bounds.rs b/src/test/ui/feature-gates/feature-gate-associated_type_bounds.rs
index 0faa9090f4e..00737d8428b 100644
--- a/src/test/ui/feature-gates/feature-gate-associated_type_bounds.rs
+++ b/src/test/ui/feature-gates/feature-gate-associated_type_bounds.rs
@@ -70,3 +70,7 @@ fn main() {
     // FIXME: uncomment when `impl_trait_in_bindings` feature is fixed.
     // let _: &dyn Tr1<As1: Copy> = &S1;
 }
+
+macro_rules! accept_path { ($p:path) => {} }
+accept_path!(Iterator<Item: Ord>);
+//~^ ERROR associated type bounds are unstable
diff --git a/src/test/ui/feature-gates/feature-gate-associated_type_bounds.stderr b/src/test/ui/feature-gates/feature-gate-associated_type_bounds.stderr
index 84af2a0163a..a7ab7614d7b 100644
--- a/src/test/ui/feature-gates/feature-gate-associated_type_bounds.stderr
+++ b/src/test/ui/feature-gates/feature-gate-associated_type_bounds.stderr
@@ -115,6 +115,15 @@ LL |     let _: impl Tr1<As1: Copy> = S1;
    = note: for more information, see https://github.com/rust-lang/rust/issues/52662
    = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
 
+error[E0658]: associated type bounds are unstable
+  --> $DIR/feature-gate-associated_type_bounds.rs:75:23
+   |
+LL | accept_path!(Iterator<Item: Ord>);
+   |                       ^^^^^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/52662
+   = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
+
 error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
   --> $DIR/feature-gate-associated_type_bounds.rs:54:14
    |
@@ -139,7 +148,7 @@ LL |     let _: impl Tr1<As1: Copy> = S1;
    |
    = help: add `#![feature(impl_trait_in_bindings)]` to the crate attributes to enable
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
 Some errors have detailed explanations: E0562, E0658.
 For more information about an error, try `rustc --explain E0562`.
-- 
cgit 1.4.1-3-g733a5


From 49cbfa1a6f6469ddbc0e88161e52104cc87aea9b Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 18:58:17 +0200
Subject: pre-expansion gate const_generics

---
 src/libsyntax/feature_gate/check.rs                   | 13 ++-----------
 src/libsyntax/parse/parser/generics.rs                |  4 ++++
 src/libsyntax/sess.rs                                 |  2 ++
 .../const-param-in-trait-ungated.stderr               |  4 ++--
 ...st-param-type-depends-on-type-param-ungated.stderr |  4 ++--
 src/test/ui/const-generics/issues/issue-60263.stderr  |  4 ++--
 .../feature-gate-const_generics-ptr.stderr            |  8 ++++----
 .../ui/feature-gates/feature-gate-const_generics.rs   |  5 +++++
 .../feature-gates/feature-gate-const_generics.stderr  | 19 ++++++++++++++-----
 9 files changed, 37 insertions(+), 26 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 58610d8db7e..282b5ae2193 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -3,7 +3,7 @@ use super::accepted::ACCEPTED_FEATURES;
 use super::removed::{REMOVED_FEATURES, STABLE_REMOVED_FEATURES};
 use super::builtin_attrs::{AttributeGate, BUILTIN_ATTRIBUTE_MAP};
 
-use crate::ast::{self, NodeId, GenericParam, GenericParamKind, PatKind, RangeEnd, VariantData};
+use crate::ast::{self, NodeId, PatKind, RangeEnd, VariantData};
 use crate::attr::{self, check_builtin_attribute};
 use crate::source_map::Spanned;
 use crate::edition::{ALL_EDITIONS, Edition};
@@ -571,16 +571,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_fn(self, fn_kind, fn_decl, span)
     }
 
-    fn visit_generic_param(&mut self, param: &'a GenericParam) {
-        match param.kind {
-            GenericParamKind::Const { .. } =>
-                gate_feature_post!(&self, const_generics, param.ident.span,
-                    "const generics are unstable"),
-            _ => {}
-        }
-        visit::walk_generic_param(self, param)
-    }
-
     fn visit_trait_item(&mut self, ti: &'a ast::TraitItem) {
         match ti.kind {
             ast::TraitItemKind::Method(ref sig, ref block) => {
@@ -840,6 +830,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(trait_alias, "trait aliases are experimental");
     gate_all!(associated_type_bounds, "associated type bounds are unstable");
     gate_all!(crate_visibility_modifier, "`crate` visibility modifier is experimental");
+    gate_all!(const_generics, "const generics are unstable");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/generics.rs b/src/libsyntax/parse/parser/generics.rs
index bfcb0042a75..51caae69c86 100644
--- a/src/libsyntax/parse/parser/generics.rs
+++ b/src/libsyntax/parse/parser/generics.rs
@@ -55,11 +55,15 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_const_param(&mut self, preceding_attrs: Vec<Attribute>) -> PResult<'a, GenericParam> {
+        let lo = self.token.span;
+
         self.expect_keyword(kw::Const)?;
         let ident = self.parse_ident()?;
         self.expect(&token::Colon)?;
         let ty = self.parse_ty()?;
 
+        self.sess.gated_spans.const_generics.borrow_mut().push(lo.to(self.prev_span));
+
         Ok(GenericParam {
             ident,
             id: ast::DUMMY_NODE_ID,
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index 58a2f89aca9..3d2051b4c78 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -36,6 +36,8 @@ crate struct GatedSpans {
     pub associated_type_bounds: Lock<Vec<Span>>,
     /// Spans collected for gating `crate_visibility_modifier`, e.g. `crate fn`.
     pub crate_visibility_modifier: Lock<Vec<Span>>,
+    /// Spans collected for gating `const_generics`, e.g. `const N: usize`.
+    pub const_generics: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/const-generics/const-param-in-trait-ungated.stderr b/src/test/ui/const-generics/const-param-in-trait-ungated.stderr
index cfb1f8b581c..330c93e83b5 100644
--- a/src/test/ui/const-generics/const-param-in-trait-ungated.stderr
+++ b/src/test/ui/const-generics/const-param-in-trait-ungated.stderr
@@ -1,8 +1,8 @@
 error[E0658]: const generics are unstable
-  --> $DIR/const-param-in-trait-ungated.rs:1:19
+  --> $DIR/const-param-in-trait-ungated.rs:1:13
    |
 LL | trait Trait<const T: ()> {}
-   |                   ^
+   |             ^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
diff --git a/src/test/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr b/src/test/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
index c659074a091..969f35bdaa3 100644
--- a/src/test/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
+++ b/src/test/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
@@ -5,10 +5,10 @@ LL | struct B<T, const N: T>(PhantomData<[T; N]>);
    |                      ^ const parameter depends on type parameter
 
 error[E0658]: const generics are unstable
-  --> $DIR/const-param-type-depends-on-type-param-ungated.rs:3:19
+  --> $DIR/const-param-type-depends-on-type-param-ungated.rs:3:13
    |
 LL | struct B<T, const N: T>(PhantomData<[T; N]>);
-   |                   ^
+   |             ^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
diff --git a/src/test/ui/const-generics/issues/issue-60263.stderr b/src/test/ui/const-generics/issues/issue-60263.stderr
index fe7b6fdb190..5223c8c5137 100644
--- a/src/test/ui/const-generics/issues/issue-60263.stderr
+++ b/src/test/ui/const-generics/issues/issue-60263.stderr
@@ -1,8 +1,8 @@
 error[E0658]: const generics are unstable
-  --> $DIR/issue-60263.rs:1:16
+  --> $DIR/issue-60263.rs:1:10
    |
 LL | struct B<const I: u8>;
-   |                ^
+   |          ^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
diff --git a/src/test/ui/feature-gates/feature-gate-const_generics-ptr.stderr b/src/test/ui/feature-gates/feature-gate-const_generics-ptr.stderr
index 935f84b9163..790bc33e268 100644
--- a/src/test/ui/feature-gates/feature-gate-const_generics-ptr.stderr
+++ b/src/test/ui/feature-gates/feature-gate-const_generics-ptr.stderr
@@ -1,17 +1,17 @@
 error[E0658]: const generics are unstable
-  --> $DIR/feature-gate-const_generics-ptr.rs:1:22
+  --> $DIR/feature-gate-const_generics-ptr.rs:1:16
    |
 LL | struct ConstFn<const F: fn()>;
-   |                      ^
+   |                ^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
 
 error[E0658]: const generics are unstable
-  --> $DIR/feature-gate-const_generics-ptr.rs:5:23
+  --> $DIR/feature-gate-const_generics-ptr.rs:5:17
    |
 LL | struct ConstPtr<const P: *const u32>;
-   |                       ^
+   |                 ^^^^^^^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
diff --git a/src/test/ui/feature-gates/feature-gate-const_generics.rs b/src/test/ui/feature-gates/feature-gate-const_generics.rs
index fe1ded1c4bb..0adc9902a69 100644
--- a/src/test/ui/feature-gates/feature-gate-const_generics.rs
+++ b/src/test/ui/feature-gates/feature-gate-const_generics.rs
@@ -2,4 +2,9 @@ fn foo<const X: ()>() {} //~ ERROR const generics are unstable
 
 struct Foo<const X: usize>([(); X]); //~ ERROR const generics are unstable
 
+macro_rules! accept_item { ($i:item) => {} }
+accept_item! {
+    impl<const X: ()> A {} //~ ERROR const generics are unstable
+}
+
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-const_generics.stderr b/src/test/ui/feature-gates/feature-gate-const_generics.stderr
index 468e9c31d37..f0154ed289f 100644
--- a/src/test/ui/feature-gates/feature-gate-const_generics.stderr
+++ b/src/test/ui/feature-gates/feature-gate-const_generics.stderr
@@ -1,21 +1,30 @@
 error[E0658]: const generics are unstable
-  --> $DIR/feature-gate-const_generics.rs:1:14
+  --> $DIR/feature-gate-const_generics.rs:1:8
    |
 LL | fn foo<const X: ()>() {}
-   |              ^
+   |        ^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
 
 error[E0658]: const generics are unstable
-  --> $DIR/feature-gate-const_generics.rs:3:18
+  --> $DIR/feature-gate-const_generics.rs:3:12
    |
 LL | struct Foo<const X: usize>([(); X]);
-   |                  ^
+   |            ^^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/44580
    = help: add `#![feature(const_generics)]` to the crate attributes to enable
 
-error: aborting due to 2 previous errors
+error[E0658]: const generics are unstable
+  --> $DIR/feature-gate-const_generics.rs:7:10
+   |
+LL |     impl<const X: ()> A {}
+   |          ^^^^^^^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/44580
+   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From 1f470ceac2202ecffe8a15acc1139edb9ad4a03b Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 19:18:41 +0200
Subject: pre-expansion gate decl_macro

---
 src/libstd/lib.rs                                        |  3 ++-
 src/libsyntax/feature_gate/check.rs                      |  6 +-----
 src/libsyntax/parse/parser/item.rs                       |  5 +++++
 src/libsyntax/sess.rs                                    |  2 ++
 src/test/ui/feature-gates/feature-gate-decl_macro.rs     |  4 ++++
 src/test/ui/feature-gates/feature-gate-decl_macro.stderr | 11 ++++++++++-
 6 files changed, 24 insertions(+), 7 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 93d3e4ea3df..8fbb449d88c 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -220,7 +220,7 @@
 
 #![cfg_attr(test, feature(print_internals, set_stdio, update_panic_count))]
 #![cfg_attr(all(target_vendor = "fortanix", target_env = "sgx"),
-            feature(slice_index_methods, decl_macro, coerce_unsized,
+            feature(slice_index_methods, coerce_unsized,
                     sgx_platform, ptr_wrapping_offset_from))]
 #![cfg_attr(all(test, target_vendor = "fortanix", target_env = "sgx"),
             feature(fixed_size_array, maybe_uninit_extra))]
@@ -251,6 +251,7 @@
 #![feature(container_error_extra)]
 #![feature(core_intrinsics)]
 #![feature(custom_test_frameworks)]
+#![feature(decl_macro)]
 #![feature(doc_alias)]
 #![feature(doc_cfg)]
 #![feature(doc_keyword)]
diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 282b5ae2193..9882db4e3f3 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -420,11 +420,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                    "auto traits are experimental and possibly buggy");
             }
 
-            ast::ItemKind::MacroDef(ast::MacroDef { legacy: false, .. }) => {
-                let msg = "`macro` is experimental";
-                gate_feature_post!(&self, decl_macro, i.span, msg);
-            }
-
             ast::ItemKind::OpaqueTy(..) => {
                 gate_feature_post!(
                     &self,
@@ -831,6 +826,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(associated_type_bounds, "associated type bounds are unstable");
     gate_all!(crate_visibility_modifier, "`crate` visibility modifier is experimental");
     gate_all!(const_generics, "const generics are unstable");
+    gate_all!(decl_macro, "`macro` is experimental");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs
index c5498236da1..95bddb5afdd 100644
--- a/src/libsyntax/parse/parser/item.rs
+++ b/src/libsyntax/parse/parser/item.rs
@@ -1706,6 +1706,11 @@ impl<'a> Parser<'a> {
         };
 
         let span = lo.to(self.prev_span);
+
+        if !def.legacy {
+            self.sess.gated_spans.decl_macro.borrow_mut().push(span);
+        }
+
         Ok(Some(self.mk_item(span, ident, ItemKind::MacroDef(def), vis.clone(), attrs.to_vec())))
     }
 
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index 3d2051b4c78..30aeff752ec 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -38,6 +38,8 @@ crate struct GatedSpans {
     pub crate_visibility_modifier: Lock<Vec<Span>>,
     /// Spans collected for gating `const_generics`, e.g. `const N: usize`.
     pub const_generics: Lock<Vec<Span>>,
+    /// Spans collected for gating `decl_macro`, e.g. `macro m() {}`.
+    pub decl_macro: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-decl_macro.rs b/src/test/ui/feature-gates/feature-gate-decl_macro.rs
index d002c5dbbd2..b208a047481 100644
--- a/src/test/ui/feature-gates/feature-gate-decl_macro.rs
+++ b/src/test/ui/feature-gates/feature-gate-decl_macro.rs
@@ -2,4 +2,8 @@
 
 macro m() {} //~ ERROR `macro` is experimental
 
+macro_rules! accept_item { ($i:item) => {} }
+accept_item! {
+    macro m() {} //~ ERROR `macro` is experimental
+}
 fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-decl_macro.stderr b/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
index 905a1b15310..c6690ebd4d9 100644
--- a/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
+++ b/src/test/ui/feature-gates/feature-gate-decl_macro.stderr
@@ -7,6 +7,15 @@ LL | macro m() {}
    = note: for more information, see https://github.com/rust-lang/rust/issues/39412
    = help: add `#![feature(decl_macro)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error[E0658]: `macro` is experimental
+  --> $DIR/feature-gate-decl_macro.rs:7:5
+   |
+LL |     macro m() {}
+   |     ^^^^^^^^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/39412
+   = help: add `#![feature(decl_macro)]` to the crate attributes to enable
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From 2aff6b36d7ed5c25700669a92b4a43200ee0fe6b Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 19:49:54 +0200
Subject: pre-expansion gate box_patterns

---
 src/libsyntax/feature_gate/check.rs                      | 16 ++--------------
 src/libsyntax/parse/parser/pat.rs                        |  4 +++-
 src/libsyntax/sess.rs                                    |  2 ++
 src/test/ui/feature-gates/feature-gate-box_patterns.rs   |  3 +++
 .../ui/feature-gates/feature-gate-box_patterns.stderr    | 11 ++++++++++-
 src/test/ui/or-patterns/or-patterns-syntactic-pass.rs    |  1 +
 src/test/ui/pattern/rest-pat-syntactic.rs                |  2 ++
 7 files changed, 23 insertions(+), 16 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 9882db4e3f3..7c4668122a4 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -510,10 +510,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_expr(self, e)
     }
 
-    fn visit_arm(&mut self, arm: &'a ast::Arm) {
-        visit::walk_arm(self, arm)
-    }
-
     fn visit_pat(&mut self, pattern: &'a ast::Pat) {
         match &pattern.kind {
             PatKind::Slice(pats) => {
@@ -533,11 +529,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                     }
                 }
             }
-            PatKind::Box(..) => {
-                gate_feature_post!(&self, box_patterns,
-                                  pattern.span,
-                                  "box pattern syntax is experimental");
-            }
             PatKind::Range(_, _, Spanned { node: RangeEnd::Excluded, .. }) => {
                 gate_feature_post!(&self, exclusive_range_pattern, pattern.span,
                                    "exclusive range pattern syntax is experimental");
@@ -547,11 +538,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_pat(self, pattern)
     }
 
-    fn visit_fn(&mut self,
-                fn_kind: FnKind<'a>,
-                fn_decl: &'a ast::FnDecl,
-                span: Span,
-                _node_id: NodeId) {
+    fn visit_fn(&mut self, fn_kind: FnKind<'a>, fn_decl: &'a ast::FnDecl, span: Span, _: NodeId) {
         if let Some(header) = fn_kind.header() {
             // Stability of const fn methods are covered in
             // `visit_trait_item` and `visit_impl_item` below; this is
@@ -827,6 +814,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(crate_visibility_modifier, "`crate` visibility modifier is experimental");
     gate_all!(const_generics, "const generics are unstable");
     gate_all!(decl_macro, "`macro` is experimental");
+    gate_all!(box_patterns, "box pattern syntax is experimental");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/pat.rs b/src/libsyntax/parse/parser/pat.rs
index af795e51792..5374671d4b8 100644
--- a/src/libsyntax/parse/parser/pat.rs
+++ b/src/libsyntax/parse/parser/pat.rs
@@ -324,7 +324,9 @@ impl<'a> Parser<'a> {
                 self.parse_pat_ident(BindingMode::ByRef(mutbl))?
             } else if self.eat_keyword(kw::Box) {
                 // Parse `box pat`
-                PatKind::Box(self.parse_pat_with_range_pat(false, None)?)
+                let pat = self.parse_pat_with_range_pat(false, None)?;
+                self.sess.gated_spans.box_patterns.borrow_mut().push(lo.to(self.prev_span));
+                PatKind::Box(pat)
             } else if self.can_be_ident_pat() {
                 // Parse `ident @ pat`
                 // This can give false positives and parse nullary enums,
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index 30aeff752ec..c8e60be1db9 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -40,6 +40,8 @@ crate struct GatedSpans {
     pub const_generics: Lock<Vec<Span>>,
     /// Spans collected for gating `decl_macro`, e.g. `macro m() {}`.
     pub decl_macro: Lock<Vec<Span>>,
+    /// Spans collected for gating `box_patterns`, e.g. `box 0`.
+    pub box_patterns: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-box_patterns.rs b/src/test/ui/feature-gates/feature-gate-box_patterns.rs
index 8bec16a974e..c5b926d5af2 100644
--- a/src/test/ui/feature-gates/feature-gate-box_patterns.rs
+++ b/src/test/ui/feature-gates/feature-gate-box_patterns.rs
@@ -2,3 +2,6 @@ fn main() {
     let box x = Box::new('c'); //~ ERROR box pattern syntax is experimental
     println!("x: {}", x);
 }
+
+macro_rules! accept_pat { ($p:pat) => {} }
+accept_pat!(box 0); //~ ERROR box pattern syntax is experimental
diff --git a/src/test/ui/feature-gates/feature-gate-box_patterns.stderr b/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
index d2dafe93a86..1e47bd41e88 100644
--- a/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
+++ b/src/test/ui/feature-gates/feature-gate-box_patterns.stderr
@@ -7,6 +7,15 @@ LL |     let box x = Box::new('c');
    = note: for more information, see https://github.com/rust-lang/rust/issues/29641
    = help: add `#![feature(box_patterns)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error[E0658]: box pattern syntax is experimental
+  --> $DIR/feature-gate-box_patterns.rs:7:13
+   |
+LL | accept_pat!(box 0);
+   |             ^^^^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/29641
+   = help: add `#![feature(box_patterns)]` to the crate attributes to enable
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/or-patterns/or-patterns-syntactic-pass.rs b/src/test/ui/or-patterns/or-patterns-syntactic-pass.rs
index 5fe72caf9c1..9667711242c 100644
--- a/src/test/ui/or-patterns/or-patterns-syntactic-pass.rs
+++ b/src/test/ui/or-patterns/or-patterns-syntactic-pass.rs
@@ -4,6 +4,7 @@
 // check-pass
 
 #![feature(or_patterns)]
+#![feature(box_patterns)]
 
 fn main() {}
 
diff --git a/src/test/ui/pattern/rest-pat-syntactic.rs b/src/test/ui/pattern/rest-pat-syntactic.rs
index 9656a0b5de9..45b31f61253 100644
--- a/src/test/ui/pattern/rest-pat-syntactic.rs
+++ b/src/test/ui/pattern/rest-pat-syntactic.rs
@@ -3,6 +3,8 @@
 
 // check-pass
 
+#![feature(box_patterns)]
+
 fn main() {}
 
 macro_rules! accept_pat {
-- 
cgit 1.4.1-3-g733a5


From 665a876e307933c6480a6c55a3e38e88937aff2c Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 20:11:00 +0200
Subject: pre-expansion gate exclusive_range_pattern

---
 src/libsyntax/feature_gate/check.rs                      |  8 ++------
 src/libsyntax/parse/parser/pat.rs                        |  9 +++++++--
 src/libsyntax/sess.rs                                    |  2 ++
 .../feature-gate-exclusive-range-pattern.rs              |  6 +++++-
 .../feature-gate-exclusive-range-pattern.stderr          | 15 ++++++++++++---
 src/test/ui/parser/pat-tuple-4.rs                        |  1 -
 src/test/ui/parser/pat-tuple-4.stderr                    | 16 +++-------------
 src/test/ui/parser/pat-tuple-5.stderr                    |  4 ++--
 8 files changed, 33 insertions(+), 28 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 7c4668122a4..0b4289b139f 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -3,9 +3,8 @@ use super::accepted::ACCEPTED_FEATURES;
 use super::removed::{REMOVED_FEATURES, STABLE_REMOVED_FEATURES};
 use super::builtin_attrs::{AttributeGate, BUILTIN_ATTRIBUTE_MAP};
 
-use crate::ast::{self, NodeId, PatKind, RangeEnd, VariantData};
+use crate::ast::{self, NodeId, PatKind, VariantData};
 use crate::attr::{self, check_builtin_attribute};
-use crate::source_map::Spanned;
 use crate::edition::{ALL_EDITIONS, Edition};
 use crate::visit::{self, FnKind, Visitor};
 use crate::parse::token;
@@ -529,10 +528,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                     }
                 }
             }
-            PatKind::Range(_, _, Spanned { node: RangeEnd::Excluded, .. }) => {
-                gate_feature_post!(&self, exclusive_range_pattern, pattern.span,
-                                   "exclusive range pattern syntax is experimental");
-            }
             _ => {}
         }
         visit::walk_pat(self, pattern)
@@ -815,6 +810,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(const_generics, "const generics are unstable");
     gate_all!(decl_macro, "`macro` is experimental");
     gate_all!(box_patterns, "box pattern syntax is experimental");
+    gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/pat.rs b/src/libsyntax/parse/parser/pat.rs
index 5374671d4b8..969d5dd8374 100644
--- a/src/libsyntax/parse/parser/pat.rs
+++ b/src/libsyntax/parse/parser/pat.rs
@@ -611,6 +611,11 @@ impl<'a> Parser<'a> {
         Ok(PatKind::Mac(mac))
     }
 
+    fn excluded_range_end(&self, span: Span) -> RangeEnd {
+        self.sess.gated_spans.exclusive_range_pattern.borrow_mut().push(span);
+        RangeEnd::Excluded
+    }
+
     /// Parse a range pattern `$path $form $end?` where `$form = ".." | "..." | "..=" ;`.
     /// The `$path` has already been parsed and the next token is the `$form`.
     fn parse_pat_range_starting_with_path(
@@ -620,7 +625,7 @@ impl<'a> Parser<'a> {
         path: Path
     ) -> PResult<'a, PatKind> {
         let (end_kind, form) = match self.token.kind {
-            token::DotDot => (RangeEnd::Excluded, ".."),
+            token::DotDot => (self.excluded_range_end(self.token.span), ".."),
             token::DotDotDot => (RangeEnd::Included(RangeSyntax::DotDotDot), "..."),
             token::DotDotEq => (RangeEnd::Included(RangeSyntax::DotDotEq), "..="),
             _ => panic!("can only parse `..`/`...`/`..=` for ranges (checked above)"),
@@ -643,7 +648,7 @@ impl<'a> Parser<'a> {
         } else if self.eat(&token::DotDotEq) {
             (RangeEnd::Included(RangeSyntax::DotDotEq), "..=")
         } else if self.eat(&token::DotDot) {
-            (RangeEnd::Excluded, "..")
+            (self.excluded_range_end(op_span), "..")
         } else {
             panic!("impossible case: we already matched on a range-operator token")
         };
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index c8e60be1db9..09331924c60 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -42,6 +42,8 @@ crate struct GatedSpans {
     pub decl_macro: Lock<Vec<Span>>,
     /// Spans collected for gating `box_patterns`, e.g. `box 0`.
     pub box_patterns: Lock<Vec<Span>>,
+    /// Spans collected for gating `exclusive_range_pattern`, e.g. `0..2`.
+    pub exclusive_range_pattern: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.rs b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.rs
index ded08b93fe8..594ec73fe26 100644
--- a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.rs
+++ b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.rs
@@ -1,6 +1,10 @@
-pub fn main() {
+#[cfg(FALSE)]
+fn foo() {
     match 22 {
         0 .. 3 => {} //~ ERROR exclusive range pattern syntax is experimental
+        PATH .. 3 => {} //~ ERROR exclusive range pattern syntax is experimental
         _ => {}
     }
 }
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
index ee20408d178..075fdbed90d 100644
--- a/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
+++ b/src/test/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
@@ -1,12 +1,21 @@
 error[E0658]: exclusive range pattern syntax is experimental
-  --> $DIR/feature-gate-exclusive-range-pattern.rs:3:9
+  --> $DIR/feature-gate-exclusive-range-pattern.rs:4:11
    |
 LL |         0 .. 3 => {}
-   |         ^^^^^^
+   |           ^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/37854
    = help: add `#![feature(exclusive_range_pattern)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error[E0658]: exclusive range pattern syntax is experimental
+  --> $DIR/feature-gate-exclusive-range-pattern.rs:5:14
+   |
+LL |         PATH .. 3 => {}
+   |              ^^
+   |
+   = note: for more information, see https://github.com/rust-lang/rust/issues/37854
+   = help: add `#![feature(exclusive_range_pattern)]` to the crate attributes to enable
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/parser/pat-tuple-4.rs b/src/test/ui/parser/pat-tuple-4.rs
index 2f03160430a..6b8c146949a 100644
--- a/src/test/ui/parser/pat-tuple-4.rs
+++ b/src/test/ui/parser/pat-tuple-4.rs
@@ -4,7 +4,6 @@ fn main() {
     match 0 {
         (.. PAT) => {}
         //~^ ERROR `..X` range patterns are not supported
-        //~| ERROR exclusive range pattern syntax is experimental
     }
 }
 
diff --git a/src/test/ui/parser/pat-tuple-4.stderr b/src/test/ui/parser/pat-tuple-4.stderr
index af3ecce1846..1962dc4ff20 100644
--- a/src/test/ui/parser/pat-tuple-4.stderr
+++ b/src/test/ui/parser/pat-tuple-4.stderr
@@ -4,17 +4,8 @@ error: `..X` range patterns are not supported
 LL |         (.. PAT) => {}
    |          ^^^^^^ help: try using the minimum value for the type: `MIN..PAT`
 
-error[E0658]: exclusive range pattern syntax is experimental
-  --> $DIR/pat-tuple-4.rs:5:10
-   |
-LL |         (.. PAT) => {}
-   |          ^^^^^^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/37854
-   = help: add `#![feature(exclusive_range_pattern)]` to the crate attributes to enable
-
 error[E0308]: mismatched types
-  --> $DIR/pat-tuple-4.rs:11:30
+  --> $DIR/pat-tuple-4.rs:10:30
    |
 LL | const RECOVERY_WITNESS: () = 0;
    |                              ^ expected (), found integer
@@ -22,7 +13,6 @@ LL | const RECOVERY_WITNESS: () = 0;
    = note: expected type `()`
               found type `{integer}`
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0308, E0658.
-For more information about an error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/parser/pat-tuple-5.stderr b/src/test/ui/parser/pat-tuple-5.stderr
index 09ebdc29a21..17155b4dd49 100644
--- a/src/test/ui/parser/pat-tuple-5.stderr
+++ b/src/test/ui/parser/pat-tuple-5.stderr
@@ -5,10 +5,10 @@ LL |         (PAT ..) => {}
    |          ^^^^^^ help: try using the maximum value for the type: `PAT..MAX`
 
 error[E0658]: exclusive range pattern syntax is experimental
-  --> $DIR/pat-tuple-5.rs:5:10
+  --> $DIR/pat-tuple-5.rs:5:14
    |
 LL |         (PAT ..) => {}
-   |          ^^^^^^
+   |              ^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/37854
    = help: add `#![feature(exclusive_range_pattern)]` to the crate attributes to enable
-- 
cgit 1.4.1-3-g733a5


From 1935ba658c576f14397c2c7a26a6642cf08f26a6 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 23:09:17 +0200
Subject: pre-expansion gate try_blocks

---
 src/libsyntax/feature_gate/check.rs                      | 4 +---
 src/libsyntax/parse/parser/expr.rs                       | 4 +++-
 src/libsyntax/sess.rs                                    | 2 ++
 src/test/ui/feature-gates/feature-gate-try_blocks.rs     | 7 +++++--
 src/test/ui/feature-gates/feature-gate-try_blocks.stderr | 4 ++--
 5 files changed, 13 insertions(+), 8 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 0b4289b139f..31fae7863fb 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -495,9 +495,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                        "type ascription is experimental");
                 }
             }
-            ast::ExprKind::TryBlock(_) => {
-                gate_feature_post!(&self, try_blocks, e.span, "`try` expression is experimental");
-            }
             ast::ExprKind::Block(_, opt_label) => {
                 if let Some(label) = opt_label {
                     gate_feature_post!(&self, label_break_value, label.ident.span,
@@ -811,6 +808,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(decl_macro, "`macro` is experimental");
     gate_all!(box_patterns, "box pattern syntax is experimental");
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
+    gate_all!(try_blocks, "`try` blocks are unstable");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index 67a530ec683..2e34422b918 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -1646,7 +1646,9 @@ impl<'a> Parser<'a> {
             error.emit();
             Err(error)
         } else {
-            Ok(self.mk_expr(span_lo.to(body.span), ExprKind::TryBlock(body), attrs))
+            let span = span_lo.to(body.span);
+            self.sess.gated_spans.try_blocks.borrow_mut().push(span);
+            Ok(self.mk_expr(span, ExprKind::TryBlock(body), attrs))
         }
     }
 
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index 09331924c60..3582d897272 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -44,6 +44,8 @@ crate struct GatedSpans {
     pub box_patterns: Lock<Vec<Span>>,
     /// Spans collected for gating `exclusive_range_pattern`, e.g. `0..2`.
     pub exclusive_range_pattern: Lock<Vec<Span>>,
+    /// Spans collected for gating `try_blocks`, e.g. `try { a? + b? }`.
+    pub try_blocks: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-try_blocks.rs b/src/test/ui/feature-gates/feature-gate-try_blocks.rs
index 06cadd82c07..b451ba84a15 100644
--- a/src/test/ui/feature-gates/feature-gate-try_blocks.rs
+++ b/src/test/ui/feature-gates/feature-gate-try_blocks.rs
@@ -1,9 +1,12 @@
 // compile-flags: --edition 2018
 
-pub fn main() {
-    let try_result: Option<_> = try { //~ ERROR `try` expression is experimental
+#[cfg(FALSE)]
+fn foo() {
+    let try_result: Option<_> = try { //~ ERROR `try` blocks are unstable
         let x = 5;
         x
     };
     assert_eq!(try_result, Some(5));
 }
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-try_blocks.stderr b/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
index 565f3610a2e..44a7d9b9043 100644
--- a/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
+++ b/src/test/ui/feature-gates/feature-gate-try_blocks.stderr
@@ -1,5 +1,5 @@
-error[E0658]: `try` expression is experimental
-  --> $DIR/feature-gate-try_blocks.rs:4:33
+error[E0658]: `try` blocks are unstable
+  --> $DIR/feature-gate-try_blocks.rs:5:33
    |
 LL |       let try_result: Option<_> = try {
    |  _________________________________^
-- 
cgit 1.4.1-3-g733a5


From 137ded8ab1edf5112c45e0b6854272ae2e9d3a6d Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 21 Sep 2019 23:54:05 +0200
Subject: pre-expansion gate label_break_value

---
 src/libsyntax/feature_gate/check.rs                             | 7 +------
 src/libsyntax/parse/parser/expr.rs                              | 4 ++++
 src/libsyntax/sess.rs                                           | 2 ++
 src/test/ui/feature-gates/feature-gate-label_break_value.rs     | 5 ++++-
 src/test/ui/feature-gates/feature-gate-label_break_value.stderr | 2 +-
 5 files changed, 12 insertions(+), 8 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index ab8781feef0..4e273fc9374 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -514,12 +514,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                        "type ascription is experimental");
                 }
             }
-            ast::ExprKind::Block(_, opt_label) => {
-                if let Some(label) = opt_label {
-                    gate_feature_post!(&self, label_break_value, label.ident.span,
-                                    "labels on blocks are unstable");
-                }
-            }
             _ => {}
         }
         visit::walk_expr(self, e)
@@ -814,6 +808,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(box_patterns, "box pattern syntax is experimental");
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
     gate_all!(try_blocks, "`try` blocks are unstable");
+    gate_all!(label_break_value, "labels on blocks are unstable");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index 2e34422b918..395f3a3a4df 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -1260,6 +1260,10 @@ impl<'a> Parser<'a> {
         blk_mode: BlockCheckMode,
         outer_attrs: ThinVec<Attribute>,
     ) -> PResult<'a, P<Expr>> {
+        if let Some(label) = opt_label {
+            self.sess.gated_spans.label_break_value.borrow_mut().push(label.ident.span);
+        }
+
         self.expect(&token::OpenDelim(token::Brace))?;
 
         let mut attrs = outer_attrs;
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index 3582d897272..ac6be3036ce 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -46,6 +46,8 @@ crate struct GatedSpans {
     pub exclusive_range_pattern: Lock<Vec<Span>>,
     /// Spans collected for gating `try_blocks`, e.g. `try { a? + b? }`.
     pub try_blocks: Lock<Vec<Span>>,
+    /// Spans collected for gating `label_break_value`, e.g. `'label: { ... }`.
+    pub label_break_value: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-label_break_value.rs b/src/test/ui/feature-gates/feature-gate-label_break_value.rs
index 6fc38f45517..8d7ecd27b45 100644
--- a/src/test/ui/feature-gates/feature-gate-label_break_value.rs
+++ b/src/test/ui/feature-gates/feature-gate-label_break_value.rs
@@ -1,5 +1,8 @@
-pub fn main() {
+#[cfg(FALSE)]
+pub fn foo() {
     'a: { //~ ERROR labels on blocks are unstable
         break 'a;
     }
 }
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-label_break_value.stderr b/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
index a417e0eec22..6a861d3e04f 100644
--- a/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
+++ b/src/test/ui/feature-gates/feature-gate-label_break_value.stderr
@@ -1,5 +1,5 @@
 error[E0658]: labels on blocks are unstable
-  --> $DIR/feature-gate-label_break_value.rs:2:5
+  --> $DIR/feature-gate-label_break_value.rs:3:5
    |
 LL |     'a: {
    |     ^^
-- 
cgit 1.4.1-3-g733a5


From e4ed8865786a787a7b0c045f7674569b6be0e9bc Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sun, 22 Sep 2019 00:06:51 +0200
Subject: pre-expansion gate box_syntax

---
 src/libsyntax/feature_gate/check.rs                      | 7 +------
 src/libsyntax/parse/parser/expr.rs                       | 4 +++-
 src/libsyntax/sess.rs                                    | 2 ++
 src/test/ui/feature-gates/feature-gate-box_syntax.rs     | 5 ++++-
 src/test/ui/feature-gates/feature-gate-box_syntax.stderr | 2 +-
 5 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 4e273fc9374..7243f5c0320 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -153,9 +153,6 @@ fn leveled_feature_err<'a, S: Into<MultiSpan>>(
 
 }
 
-const EXPLAIN_BOX_SYNTAX: &str =
-    "box expression syntax is experimental; you can call `Box::new` instead";
-
 pub const EXPLAIN_STMT_ATTR_SYNTAX: &str =
     "attributes on expressions are experimental";
 
@@ -503,9 +500,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
 
     fn visit_expr(&mut self, e: &'a ast::Expr) {
         match e.kind {
-            ast::ExprKind::Box(_) => {
-                gate_feature_post!(&self, box_syntax, e.span, EXPLAIN_BOX_SYNTAX);
-            }
             ast::ExprKind::Type(..) => {
                 // To avoid noise about type ascription in common syntax errors, only emit if it
                 // is the *only* error.
@@ -809,6 +803,7 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
     gate_all!(try_blocks, "`try` blocks are unstable");
     gate_all!(label_break_value, "labels on blocks are unstable");
+    gate_all!(box_syntax, "box expression syntax is experimental; you can call `Box::new` instead");
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index 395f3a3a4df..e7dd15654d8 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -453,7 +453,9 @@ impl<'a> Parser<'a> {
                 self.bump();
                 let e = self.parse_prefix_expr(None);
                 let (span, e) = self.interpolated_or_expr_span(e)?;
-                (lo.to(span), ExprKind::Box(e))
+                let span = lo.to(span);
+                self.sess.gated_spans.box_syntax.borrow_mut().push(span);
+                (span, ExprKind::Box(e))
             }
             token::Ident(..) if self.token.is_ident_named(sym::not) => {
                 // `not` is just an ordinary identifier in Rust-the-language,
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index ac6be3036ce..febaa714775 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -48,6 +48,8 @@ crate struct GatedSpans {
     pub try_blocks: Lock<Vec<Span>>,
     /// Spans collected for gating `label_break_value`, e.g. `'label: { ... }`.
     pub label_break_value: Lock<Vec<Span>>,
+    /// Spans collected for gating `box_syntax`, e.g. `box $expr`.
+    pub box_syntax: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-box_syntax.rs b/src/test/ui/feature-gates/feature-gate-box_syntax.rs
index 778660cc0b5..c23953a9e09 100644
--- a/src/test/ui/feature-gates/feature-gate-box_syntax.rs
+++ b/src/test/ui/feature-gates/feature-gate-box_syntax.rs
@@ -1,6 +1,9 @@
 // Test that the use of the box syntax is gated by `box_syntax` feature gate.
 
-fn main() {
+#[cfg(FALSE)]
+fn foo() {
     let x = box 3;
     //~^ ERROR box expression syntax is experimental; you can call `Box::new` instead
 }
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-box_syntax.stderr b/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
index 61b0534d2dc..cbafa502577 100644
--- a/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
+++ b/src/test/ui/feature-gates/feature-gate-box_syntax.stderr
@@ -1,5 +1,5 @@
 error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
-  --> $DIR/feature-gate-box_syntax.rs:4:13
+  --> $DIR/feature-gate-box_syntax.rs:5:13
    |
 LL |     let x = box 3;
    |             ^^^^^
-- 
cgit 1.4.1-3-g733a5


From 15a6c09b6e8a977f2c6f5a73de01a20d00b37930 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sun, 22 Sep 2019 00:19:02 +0200
Subject: pre-expansion gate type_ascription

---
 src/libsyntax/feature_gate/check.rs                 | 21 ++++++---------------
 src/libsyntax/parse/parser/expr.rs                  |  1 +
 src/libsyntax/sess.rs                               |  2 ++
 .../feature-gates/feature-gate-type_ascription.rs   |  5 ++++-
 .../feature-gate-type_ascription.stderr             |  2 +-
 5 files changed, 14 insertions(+), 17 deletions(-)

(limited to 'src/libsyntax/parse/parser')

diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index 7243f5c0320..502b1c0f743 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -498,21 +498,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         }
     }
 
-    fn visit_expr(&mut self, e: &'a ast::Expr) {
-        match e.kind {
-            ast::ExprKind::Type(..) => {
-                // To avoid noise about type ascription in common syntax errors, only emit if it
-                // is the *only* error.
-                if self.parse_sess.span_diagnostic.err_count() == 0 {
-                    gate_feature_post!(&self, type_ascription, e.span,
-                                       "type ascription is experimental");
-                }
-            }
-            _ => {}
-        }
-        visit::walk_expr(self, e)
-    }
-
     fn visit_pat(&mut self, pattern: &'a ast::Pat) {
         match &pattern.kind {
             PatKind::Slice(pats) => {
@@ -805,6 +790,12 @@ pub fn check_crate(krate: &ast::Crate,
     gate_all!(label_break_value, "labels on blocks are unstable");
     gate_all!(box_syntax, "box expression syntax is experimental; you can call `Box::new` instead");
 
+    // To avoid noise about type ascription in common syntax errors,
+    // only emit if it is the *only* error. (Also check it last.)
+    if parse_sess.span_diagnostic.err_count() == 0 {
+        gate_all!(type_ascription, "type ascription is experimental");
+    }
+
     visit::walk_crate(&mut visitor, krate);
 }
 
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index e7dd15654d8..97b1092452a 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -252,6 +252,7 @@ impl<'a> Parser<'a> {
                 self.last_type_ascription = Some((self.prev_span, maybe_path));
 
                 lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Type)?;
+                self.sess.gated_spans.type_ascription.borrow_mut().push(lhs.span);
                 continue
             } else if op == AssocOp::DotDot || op == AssocOp::DotDotEq {
                 // If we didn’t have to handle `x..`/`x..=`, it would be pretty easy to
diff --git a/src/libsyntax/sess.rs b/src/libsyntax/sess.rs
index febaa714775..28a0868d5dd 100644
--- a/src/libsyntax/sess.rs
+++ b/src/libsyntax/sess.rs
@@ -50,6 +50,8 @@ crate struct GatedSpans {
     pub label_break_value: Lock<Vec<Span>>,
     /// Spans collected for gating `box_syntax`, e.g. `box $expr`.
     pub box_syntax: Lock<Vec<Span>>,
+    /// Spans collected for gating `type_ascription`, e.g. `42: usize`.
+    pub type_ascription: Lock<Vec<Span>>,
 }
 
 /// Info about a parsing session.
diff --git a/src/test/ui/feature-gates/feature-gate-type_ascription.rs b/src/test/ui/feature-gates/feature-gate-type_ascription.rs
index 7a597157300..655891d802c 100644
--- a/src/test/ui/feature-gates/feature-gate-type_ascription.rs
+++ b/src/test/ui/feature-gates/feature-gate-type_ascription.rs
@@ -1,5 +1,8 @@
 // Type ascription is unstable
 
-fn main() {
+#[cfg(FALSE)]
+fn foo() {
     let a = 10: u8; //~ ERROR type ascription is experimental
 }
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-type_ascription.stderr b/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
index 83f95529f0d..d63d624c6c1 100644
--- a/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
+++ b/src/test/ui/feature-gates/feature-gate-type_ascription.stderr
@@ -1,5 +1,5 @@
 error[E0658]: type ascription is experimental
-  --> $DIR/feature-gate-type_ascription.rs:4:13
+  --> $DIR/feature-gate-type_ascription.rs:5:13
    |
 LL |     let a = 10: u8;
    |             ^^^^^^
-- 
cgit 1.4.1-3-g733a5