Place impl restriction behind feature gate

Author: jhpratt

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -515,6 +515,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(where_clause_attrs, "attributes in `where` clause are unstable");
     gate_all!(super_let, "`super let` is experimental");
     gate_all!(frontmatter, "frontmatters are experimental");
+    gate_all!(impl_restriction, "impl restrictions are experimental");
 
     if !visitor.features.never_patterns() {
         if let Some(spans) = spans.get(&sym::never_patterns) {

compiler/rustc_feature/src/unstable.rs

@@ -532,6 +532,8 @@ declare_features! (
     (unstable, half_open_range_patterns_in_slices, "1.66.0", Some(67264)),
     /// Allows `if let` guard in match arms.
     (unstable, if_let_guard, "1.47.0", Some(51114)),
+    /// Allows `impl(crate) trait Foo` restrictions
+    (unstable, impl_restriction, "CURRENT_RUSTC_VERSION", Some(105077)),
     /// Allows `impl Trait` to be used inside associated types (RFC 2515).
     (unstable, impl_trait_in_assoc_type, "1.70.0", Some(63063)),
     /// Allows `impl Trait` in bindings (`let`).

compiler/rustc_parse/src/parser/item.rs

@@ -925,8 +925,13 @@ impl<'a> Parser<'a> {
 
     /// Parses `[ impl(in path) ]? unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
     fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemKind> {
-        let impl_restriction =
-            self.parse_restriction(exp!(Impl), "implementable", "impl", FollowedByType::No)?;
+        let impl_restriction = self.parse_restriction(
+            exp!(Impl),
+            Some(sym::impl_restriction),
+            "implementable",
+            "impl",
+            FollowedByType::No,
+        )?;
         let safety = self.parse_safety(Case::Sensitive);
         // Parse optional `auto` prefix.
         let is_auto = if self.eat_keyword(exp!(Auto)) {

compiler/rustc_parse/src/parser/mod.rs

@@ -1520,6 +1520,7 @@ impl<'a> Parser<'a> {
     fn parse_restriction(
         &mut self,
         kw: ExpKeywordPair,
+        feature_gate: Option<Symbol>,
         action: &'static str,
         description: &'static str,
         fbt: FollowedByType,
@@ -1531,6 +1532,13 @@ impl<'a> Parser<'a> {
             return Ok(Restriction::implied().with_span(self.token.span.shrink_to_lo()));
         }
 
+        let gate = |span| {
+            if let Some(feature_gate) = feature_gate {
+                self.psess.gated_spans.gate(feature_gate, span);
+            }
+            span
+        };
+
         let lo = self.prev_token.span;
 
         if self.check(exp!(OpenParen)) {
@@ -1545,16 +1553,16 @@ impl<'a> Parser<'a> {
                 let path = self.parse_path(PathStyle::Mod)?; // `path`
                 self.expect(exp!(CloseParen))?; // `)`
                 return Ok(Restriction::restricted(P(path), ast::DUMMY_NODE_ID, false)
-                    .with_span(lo.to(self.prev_token.span)));
+                    .with_span(gate(lo.to(self.prev_token.span))));
             } else if self.look_ahead(2, |t| t == &TokenKind::CloseParen)
                 && self.is_keyword_ahead(1, &[kw::Crate, kw::Super, kw::SelfLower])
             {
                 // Parse `kw(crate)`, `kw(self)`, or `kw(super)`.
                 self.bump(); // `(`
                 let path = self.parse_path(PathStyle::Mod)?; // `crate`/`super`/`self`
                 self.expect(exp!(CloseParen))?; // `)`
-                return Ok(Restriction::restricted(P(path), ast::DUMMY_NODE_ID, false)
-                    .with_span(lo.to(self.prev_token.span)));
+                return Ok(Restriction::restricted(P(path), ast::DUMMY_NODE_ID, true)
+                    .with_span(gate(lo.to(self.prev_token.span))));
             } else if let FollowedByType::No = fbt {
                 // Provide this diagnostic if a type cannot follow;
                 // in particular, if this is not a tuple struct.
@@ -1563,7 +1571,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(Restriction::unrestricted().with_span(lo))
+        Ok(Restriction::unrestricted().with_span(gate(lo)))
     }
 
     /// Recovery for e.g. `kw(something) fn ...` or `struct X { kw(something) y: Z }`

compiler/rustc_span/src/symbol.rs

@@ -1150,6 +1150,7 @@ symbols! {
         ignore,
         impl_header_lifetime_elision,
         impl_lint_pass,
+        impl_restriction,
         impl_trait_in_assoc_type,
         impl_trait_in_bindings,
         impl_trait_in_fn_trait_return,

tests/ui/restrictions/feature-gate-impl-restriction.rs

@@ -0,0 +1,11 @@
+//@ compile-flags: --crate-type=lib
+//@ revisions: with_gate without_gate
+//@[with_gate] check-pass
+
+#![cfg_attr(with_gate, feature(impl_restriction))]
+
+pub impl(crate) trait Bar {} //[without_gate]~ ERROR
+
+mod foo {
+    pub impl(in crate::foo) trait Baz {} //[without_gate]~ ERROR
+}

tests/ui/restrictions/feature-gate-impl-restriction.without_gate.stderr

@@ -0,0 +1,23 @@
+error[E0658]: impl restrictions are experimental
+  --> $DIR/feature-gate-impl-restriction.rs:7:5
+   |
+LL | pub impl(crate) trait Bar {}
+   |     ^^^^^^^^^^^
+   |
+   = note: see issue #105077 <https://github.com/rust-lang/rust/issues/105077> for more information
+   = help: add `#![feature(impl_restriction)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: impl restrictions are experimental
+  --> $DIR/feature-gate-impl-restriction.rs:10:9
+   |
+LL |     pub impl(in crate::foo) trait Baz {}
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #105077 <https://github.com/rust-lang/rust/issues/105077> for more information
+   = help: add `#![feature(impl_restriction)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.