Parse impl restriction on trait definitions

Author: jhpratt

compiler/rustc_ast/src/ast.rs

@@ -3530,6 +3530,7 @@ impl Default for FnHeader {
 
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Trait {
+    pub impl_restriction: Restriction,
     pub safety: Safety,
     pub is_auto: IsAuto,
     pub ident: Ident,

compiler/rustc_ast/src/visit.rs

@@ -557,7 +557,16 @@ macro_rules! common_visitor_and_walkers {
                             <V as Visitor<$lt>>::Result::output()
                         )?
                     }
-                    ItemKind::Trait(box Trait { safety, is_auto: _, ident, generics, bounds, items }) => {
+                    ItemKind::Trait(box Trait {
+                        impl_restriction,
+                        safety,
+                        is_auto: _,
+                        ident,
+                        generics,
+                        bounds,
+                        items,
+                    }) => {
+                        try_visit!(vis.visit_restriction(impl_restriction));
                         try_visit!(visit_safety(vis, safety));
                         try_visit!(vis.visit_ident(ident));
                         try_visit!(vis.visit_generics(generics));

compiler/rustc_ast_lowering/src/item.rs

@@ -415,7 +415,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     items: new_impl_items,
                 }))
             }
-            ItemKind::Trait(box Trait { is_auto, safety, ident, generics, bounds, items }) => {
+            ItemKind::Trait(box Trait {
+                impl_restriction: _,
+                is_auto,
+                safety,
+                ident,
+                generics,
+                bounds,
+                items,
+            }) => {
                 let ident = self.lower_ident(*ident);
                 let (generics, (safety, items, bounds)) = self.lower_generics(
                     generics,

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -357,6 +357,7 @@ impl<'a> State<'a> {
                 self.bclose(item.span, empty, cb);
             }
             ast::ItemKind::Trait(box ast::Trait {
+                impl_restriction,
                 safety,
                 is_auto,
                 ident,
@@ -366,6 +367,7 @@ impl<'a> State<'a> {
             }) => {
                 let (cb, ib) = self.head("");
                 self.print_visibility(&item.vis);
+                self.print_restriction("impl", impl_restriction);
                 self.print_safety(*safety);
                 self.print_is_auto(*is_auto);
                 self.word_nbsp("trait");

compiler/rustc_parse/messages.ftl

@@ -377,6 +377,13 @@ parse_inclusive_range_no_end = inclusive range with no end
 parse_incorrect_parens_trait_bounds = incorrect parentheses around trait bounds
 parse_incorrect_parens_trait_bounds_sugg = fix the parentheses
 
+parse_incorrect_restriction = incorrect {$noun} restriction
+    .help = some possible {$noun} restrictions are:
+            `{$keyword}(crate)`: {$adjective} only in the current crate
+            `{$keyword}(super)`: {$adjective} only in the current module's parent
+            `{$keyword}(in path::to::module)`: {$adjective} only in the specified path
+    .suggestion = make this {$adjective} only to module `{$inner_str}` with `in`
+
 parse_incorrect_semicolon =
     expected item, found `;`
     .suggestion = remove this semicolon
@@ -853,6 +860,7 @@ parse_trailing_vert_not_allowed = a trailing `|` is not allowed in an or-pattern
 parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto`
 parse_trait_alias_cannot_be_unsafe = trait aliases cannot be `unsafe`
 
+parse_trait_alias_cannot_have_impl_restriction = trait alias cannot have `impl` restriction
 parse_transpose_dyn_or_impl = `for<...>` expected after `{$kw}`, not before
     .suggestion = move `{$kw}` before the `for<...>`
 

compiler/rustc_parse/src/errors.rs

@@ -1041,6 +1041,19 @@ pub(crate) struct IncorrectVisibilityRestriction {
     pub inner_str: String,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_incorrect_restriction, code = E0704)]
+#[help]
+pub(crate) struct IncorrectRestriction<'kw> {
+    #[primary_span]
+    #[suggestion(code = "in {inner_str}", applicability = "machine-applicable", style = "verbose")]
+    pub span: Span,
+    pub inner_str: String,
+    pub keyword: &'kw str,
+    pub adjective: &'static str,
+    pub noun: &'static str,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_assignment_else_not_allowed)]
 pub(crate) struct AssignmentElseNotAllowed {
@@ -1946,6 +1959,16 @@ pub(crate) struct BoundsNotAllowedOnTraitAliases {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_trait_alias_cannot_have_impl_restriction)]
+pub(crate) struct TraitAliasCannotHaveImplRestriction {
+    #[primary_span]
+    #[label(parse_trait_alias_cannot_have_impl_restriction)]
+    pub span: Span,
+    #[suggestion(code = "", applicability = "machine-applicable", style = "short")]
+    pub restriction: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_trait_alias_cannot_be_auto)]
 pub(crate) struct TraitAliasCannotBeAuto {

compiler/rustc_parse/src/parser/item.rs

@@ -262,7 +262,7 @@ impl<'a> Parser<'a> {
                     define_opaque: None,
                 }))
             }
-        } else if self.check_keyword(exp!(Trait)) || self.check_auto_or_unsafe_trait_item() {
+        } else if self.check_keyword(exp!(Trait)) || self.check_trait_item_with_modifiers() {
             // TRAIT ITEM
             self.parse_item_trait(attrs, lo)?
         } else if self.check_keyword(exp!(Impl))
@@ -373,7 +373,7 @@ impl<'a> Parser<'a> {
     pub(super) fn is_path_start_item(&mut self) -> bool {
         self.is_kw_followed_by_ident(kw::Union) // no: `union::b`, yes: `union U { .. }`
         || self.is_reuse_path_item()
-        || self.check_auto_or_unsafe_trait_item() // no: `auto::b`, yes: `auto trait X { .. }`
+        || self.check_trait_item_with_modifiers() // no: `auto::b`, yes: `auto trait X { .. }`
         || self.is_async_fn() // no(2015): `async::b`, yes: `async fn`
         || matches!(self.is_macro_rules_item(), IsMacroRulesItem::Yes{..}) // no: `macro_rules::b`, yes: `macro_rules! mac`
     }
@@ -872,16 +872,67 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Is this an `(unsafe auto? | auto) trait` item?
-    fn check_auto_or_unsafe_trait_item(&mut self) -> bool {
-        // auto trait
-        self.check_keyword(exp!(Auto)) && self.is_keyword_ahead(1, &[kw::Trait])
-            // unsafe auto trait
-            || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Trait, kw::Auto])
+    /// Is this an `[ impl(in path) ]? unsafe? auto? trait` item?
+    fn check_trait_item_with_modifiers(&mut self) -> bool {
+        let current_token = TokenTree::Token(self.token.clone(), self.token_spacing);
+        let look_ahead = |index| match index {
+            0 => Some(&current_token),
+            _ => self.token_cursor.curr.look_ahead(index - 1),
+        };
+
+        let mut has_impl_restriction = false;
+        let mut has_unsafe = false;
+        let mut has_auto = false;
+        let mut has_trait = false;
+
+        let mut index = 0;
+
+        if let Some(TokenTree::Token(token, _)) = look_ahead(index)
+            && token.is_keyword(kw::Impl)
+        {
+            has_impl_restriction = true;
+            index += 1;
+        }
+        // impl restrictions require parens, but we enforce this later.
+        if has_impl_restriction
+            && matches!(
+                look_ahead(index),
+                Some(TokenTree::Delimited(_, _, Delimiter::Parenthesis, _))
+            )
+        {
+            index += 1;
+        }
+        if let Some(TokenTree::Token(token, _)) = look_ahead(index)
+            && token.is_keyword(kw::Unsafe)
+        {
+            has_unsafe = true;
+            index += 1;
+        }
+        if let Some(TokenTree::Token(token, _)) = look_ahead(index)
+            && token.is_keyword(kw::Auto)
+        {
+            has_auto = true;
+            index += 1;
+        }
+        if let Some(TokenTree::Token(token, _)) = look_ahead(index)
+            && token.is_keyword(kw::Trait)
+        {
+            has_trait = true;
+        }
+
+        let ret = (has_impl_restriction || has_unsafe || has_auto) && has_trait;
+        if !ret {
+            self.expected_token_types.insert(exp!(Impl).token_type);
+            self.expected_token_types.insert(exp!(Unsafe).token_type);
+            self.expected_token_types.insert(exp!(Auto).token_type);
+        }
+        ret
     }
 
-    /// Parses `unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
+    /// 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 safety = self.parse_safety(Case::Sensitive);
         // Parse optional `auto` prefix.
         let is_auto = if self.eat_keyword(exp!(Auto)) {
@@ -913,6 +964,12 @@ impl<'a> Parser<'a> {
             self.expect_semi()?;
 
             let whole_span = lo.to(self.prev_token.span);
+            if !matches!(impl_restriction.kind, RestrictionKind::Implied) {
+                self.dcx().emit_err(errors::TraitAliasCannotHaveImplRestriction {
+                    span: whole_span,
+                    restriction: impl_restriction.span,
+                });
+            }
             if is_auto == IsAuto::Yes {
                 self.dcx().emit_err(errors::TraitAliasCannotBeAuto { span: whole_span });
             }
@@ -927,7 +984,15 @@ impl<'a> Parser<'a> {
             // It's a normal trait.
             generics.where_clause = self.parse_where_clause()?;
             let items = self.parse_item_list(attrs, |p| p.parse_trait_item(ForceCollect::No))?;
-            Ok(ItemKind::Trait(Box::new(Trait { is_auto, safety, ident, generics, bounds, items })))
+            Ok(ItemKind::Trait(Box::new(Trait {
+                impl_restriction,
+                is_auto,
+                safety,
+                ident,
+                generics,
+                bounds,
+                items,
+            })))
         }
     }
 

compiler/rustc_parse/src/parser/mod.rs

@@ -31,8 +31,8 @@ use rustc_ast::tokenstream::{
 use rustc_ast::util::case::Case;
 use rustc_ast::{
     self as ast, AnonConst, AttrArgs, AttrId, ByRef, Const, CoroutineKind, DUMMY_NODE_ID,
-    DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, Safety, StrLit,
-    Visibility, VisibilityKind,
+    DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, Restriction,
+    Safety, StrLit, Visibility, VisibilityKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
@@ -45,7 +45,9 @@ use token_type::TokenTypeSet;
 pub use token_type::{ExpKeywordPair, ExpTokenPair, TokenType};
 use tracing::debug;
 
-use crate::errors::{self, IncorrectVisibilityRestriction, NonStringAbiLiteral};
+use crate::errors::{
+    self, IncorrectRestriction, IncorrectVisibilityRestriction, NonStringAbiLiteral,
+};
 use crate::exp;
 
 #[cfg(test)]
@@ -1514,6 +1516,80 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 
+    /// Parses `kw`, `kw(in path)` plus shortcuts `kw(crate)` for `kw(in crate)`, `kw(self)` for
+    /// `kw(in self)` and `kw(super)` for `kw(in super)`.
+    fn parse_restriction(
+        &mut self,
+        kw: ExpKeywordPair,
+        action: &'static str,
+        description: &'static str,
+        fbt: FollowedByType,
+    ) -> PResult<'a, Restriction> {
+        if !self.eat_keyword(kw) {
+            // We need a span, but there's inherently no keyword to grab a span from for an implied
+            // restriction. An empty span at the beginning of the current token is a reasonable
+            // fallback.
+            return Ok(Restriction::implied().with_span(self.token.span.shrink_to_lo()));
+        }
+
+        let lo = self.prev_token.span;
+
+        if self.check(exp!(OpenParen)) {
+            // We don't `self.bump()` the `(` yet because this might be a struct definition where
+            // `()` or a tuple might be allowed. For example, `struct Struct(kw (), kw (usize));`.
+            // Because of this, we only `bump` the `(` if we're assured it is appropriate to do so
+            // by the following tokens.
+            if self.is_keyword_ahead(1, &[kw::In]) {
+                // Parse `kw(in path)`.
+                self.bump(); // `(`
+                self.bump(); // `in`
+                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)));
+            } 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)));
+            } else if let FollowedByType::No = fbt {
+                // Provide this diagnostic if a type cannot follow;
+                // in particular, if this is not a tuple struct.
+                self.recover_incorrect_restriction(kw.kw.as_str(), action, description)?;
+                // Emit diagnostic, but continue unrestricted.
+            }
+        }
+
+        Ok(Restriction::unrestricted().with_span(lo))
+    }
+
+    /// Recovery for e.g. `kw(something) fn ...` or `struct X { kw(something) y: Z }`
+    fn recover_incorrect_restriction<'kw>(
+        &mut self,
+        kw: &'kw str,
+        action: &'static str,
+        description: &'static str,
+    ) -> PResult<'a, ()> {
+        self.bump(); // `(`
+        let path = self.parse_path(PathStyle::Mod)?;
+        self.expect(exp!(CloseParen))?; // `)`
+
+        let path_str = pprust::path_to_string(&path);
+        self.dcx().emit_err(IncorrectRestriction {
+            span: path.span,
+            inner_str: path_str,
+            keyword: kw,
+            adjective: action,
+            noun: description,
+        });
+
+        Ok(())
+    }
+
     /// Parses `extern string_literal?`.
     fn parse_extern(&mut self, case: Case) -> Extern {
         if self.eat_keyword_case(exp!(Extern), case) {

src/tools/clippy/clippy_utils/src/ast_utils/mod.rs

@@ -444,6 +444,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
         },
         (
             Trait(box ast::Trait {
+                impl_restriction: _, // does not affect item kind
                 is_auto: la,
                 safety: lu,
                 ident: li,
@@ -452,6 +453,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 items: lis,
             }),
             Trait(box ast::Trait {
+                impl_restriction: _, // does not affect item kind
                 is_auto: ra,
                 safety: ru,
                 ident: ri,

src/tools/rustfmt/src/items.rs

@@ -1172,6 +1172,7 @@ pub(crate) fn format_trait(
         unreachable!();
     };
     let ast::Trait {
+        impl_restriction: _,
         is_auto,
         safety,
         ident,