Lower impl restriction to rustc_middle

Author: jhpratt

compiler/rustc_middle/src/hir/map.rs

@@ -1179,14 +1179,15 @@ pub(super) fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
         }
         tcx.sess.opts.dep_tracking_hash(true).hash_stable(&mut hcx, &mut stable_hasher);
         tcx.stable_crate_id(LOCAL_CRATE).hash_stable(&mut hcx, &mut stable_hasher);
-        // Hash visibility information since it does not appear in HIR.
+        // Hash visibility and restriction information since it does not appear in HIR.
         // FIXME: Figure out how to remove `visibilities_for_hashing` by hashing visibilities on
         // the fly in the resolver, storing only their accumulated hash in `ResolverGlobalCtxt`,
         // and combining it with other hashes here.
         resolutions.visibilities_for_hashing.hash_stable(&mut hcx, &mut stable_hasher);
         with_metavar_spans(|mspans| {
             mspans.freeze_and_get_read_spans().hash_stable(&mut hcx, &mut stable_hasher);
         });
+        resolutions.impl_restrictions.hash_stable(&mut hcx, &mut stable_hasher);
         stable_hasher.finish()
     });
 

compiler/rustc_middle/src/ty/mod.rs

@@ -178,6 +178,7 @@ pub struct ResolverOutputs {
 #[derive(Debug)]
 pub struct ResolverGlobalCtxt {
     pub visibilities_for_hashing: Vec<(LocalDefId, Visibility)>,
+    pub impl_restrictions: FxIndexMap<LocalDefId, Restriction>,
     /// Item with a given `LocalDefId` was defined during macro expansion with ID `ExpnId`.
     pub expn_that_defined: FxHashMap<LocalDefId, ExpnId>,
     pub effective_visibilities: EffectiveVisibilities,
@@ -322,6 +323,35 @@ impl Visibility {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, Encodable, Decodable, HashStable)]
+pub enum Restriction {
+    /// The restriction does not affect the item.
+    Unrestricted,
+    /// The restriction only applies outside of this path.
+    Restricted(DefId, Span),
+}
+
+impl Restriction {
+    /// Returns `true` if the behavior is allowed/unrestricted in the given module. A value of
+    /// `false` indicates that the behavior is prohibited.
+    pub fn is_allowed_in(self, module: DefId, tcx: TyCtxt<'_>) -> bool {
+        let restricted_to = match self {
+            Restriction::Unrestricted => return true,
+            Restriction::Restricted(module, _) => module,
+        };
+
+        tcx.is_descendant_of(module, restricted_to.into())
+    }
+
+    /// Obtain the [`Span`] of the restriction. If unrestricted, an empty span is returned.
+    pub fn span(&self) -> Span {
+        match self {
+            Restriction::Unrestricted => DUMMY_SP,
+            Restriction::Restricted(_, span) => *span,
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, TyEncodable, TyDecodable, HashStable)]
 #[derive(TypeFoldable, TypeVisitable)]
 pub struct ClosureSizeProfileData<'tcx> {

compiler/rustc_resolve/messages.ftl

@@ -353,6 +353,16 @@ resolve_remove_surrounding_derive =
 
 resolve_remove_unnecessary_import = remove unnecessary import
 
+resolve_restriction_ancestor_only = restrictions can only be restricted to ancestor modules
+
+resolve_restriction_indeterminate = cannot determine resolution for the restriction
+
+resolve_restriction_module_only = restriction must resolve to a module
+
+resolve_restriction_relative_2018 =
+    relative paths are not supported in restrictions in 2018 edition or later
+    .suggestion = try
+
 resolve_self_import_can_only_appear_once_in_the_list =
     `self` import can only appear once in an import list
     .label = can only appear once in an import list

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -33,8 +33,8 @@ use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
     BindingKey, Determinacy, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind,
     ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
-    ResolutionError, Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError,
-    errors,
+    ResolutionError, Resolver, ResolverArenas, RestrictionResolutionError, Segment, ToNameBinding,
+    Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -322,9 +322,9 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 })
             }
             ast::VisibilityKind::Restricted { ref path, id, .. } => {
-                // For visibilities we are not ready to provide correct implementation of "uniform
+                // For restrictions we are not ready to provide correct implementation of "uniform
                 // paths" right now, so on 2018 edition we only allow module-relative paths for now.
-                // On 2015 edition visibilities are resolved as crate-relative by default,
+                // On 2015 edition restrictions are resolved as crate-relative by default,
                 // so we are prepending a root segment if necessary.
                 let ident = path.segments.get(0).expect("empty path in visibility").ident;
                 let crate_root = if ident.is_path_segment_keyword() {
@@ -406,6 +406,97 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.r.field_names.insert(def_id, fields);
     }
 
+    fn resolve_restriction(&mut self, restriction: &ast::Restriction) -> ty::Restriction {
+        self.try_resolve_restriction(restriction, true).unwrap_or_else(|err| {
+            self.r.report_restriction_error(err);
+            ty::Restriction::Unrestricted
+        })
+    }
+
+    fn try_resolve_restriction<'ast>(
+        &mut self,
+        restriction: &'ast ast::Restriction,
+        finalize: bool,
+    ) -> Result<ty::Restriction, RestrictionResolutionError<'ast>> {
+        let parent_scope = &self.parent_scope;
+        match restriction.kind {
+            // If the restriction is implied, it has no effect when the item is otherwise visible.
+            ast::RestrictionKind::Unrestricted | ast::RestrictionKind::Implied => {
+                Ok(ty::Restriction::Unrestricted)
+            }
+            ast::RestrictionKind::Restricted { ref path, id, shorthand: _ } => {
+                // For restrictions we are not ready to provide correct implementation of "uniform
+                // paths" right now, so on 2018 edition we only allow module-relative paths for now.
+                // On 2015 edition visibilities are resolved as crate-relative by default,
+                // so we are prepending a root segment if necessary.
+                let ident = path.segments.get(0).expect("empty path in restriction").ident;
+                let crate_root = if ident.is_path_segment_keyword() {
+                    None
+                } else if ident.span.is_rust_2015() {
+                    Some(Segment::from_ident(Ident::new(
+                        kw::PathRoot,
+                        path.span.shrink_to_lo().with_ctxt(ident.span.ctxt()),
+                    )))
+                } else {
+                    return Err(RestrictionResolutionError::Relative2018(ident.span, path));
+                };
+
+                let segments = crate_root
+                    .into_iter()
+                    .chain(path.segments.iter().map(|seg| seg.into()))
+                    .collect::<Vec<_>>();
+                let expected_found_error = |res| {
+                    Err(RestrictionResolutionError::ExpectedFound(
+                        path.span,
+                        Segment::names_to_string(&segments),
+                        res,
+                    ))
+                };
+                match self.r.resolve_path(
+                    &segments,
+                    Some(TypeNS),
+                    parent_scope,
+                    finalize.then(|| Finalize::new(id, path.span)),
+                    None,
+                    None,
+                ) {
+                    PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
+                        let res = module.res().expect("restriction resolved to unnamed block");
+                        if finalize {
+                            self.r.record_partial_res(id, PartialRes::new(res));
+                        }
+                        if module.is_normal() {
+                            if res == Res::Err {
+                                Ok(ty::Restriction::Unrestricted)
+                            } else {
+                                let vis = ty::Visibility::Restricted(res.def_id());
+                                if self.r.is_accessible_from(vis, parent_scope.module) {
+                                    Ok(ty::Restriction::Restricted(res.def_id(), restriction.span))
+                                } else {
+                                    Err(RestrictionResolutionError::AncestorOnly(path.span))
+                                }
+                            }
+                        } else {
+                            expected_found_error(res)
+                        }
+                    }
+                    PathResult::Module(..) => {
+                        Err(RestrictionResolutionError::ModuleOnly(path.span))
+                    }
+                    PathResult::NonModule(partial_res) => {
+                        expected_found_error(partial_res.base_res())
+                    }
+                    PathResult::Failed { span, label, suggestion, .. } => {
+                        Err(RestrictionResolutionError::FailedToResolve(span, label, suggestion))
+                    }
+                    PathResult::Indeterminate => {
+                        Err(RestrictionResolutionError::Indeterminate(path.span))
+                    }
+                }
+            }
+        }
+    }
+
     fn insert_field_visibilities_local(&mut self, def_id: DefId, fields: &[ast::FieldDef]) {
         let field_vis = fields
             .iter()
@@ -809,8 +900,21 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             ItemKind::TyAlias(box TyAlias { ident, .. }) | ItemKind::TraitAlias(ident, ..) => {
                 self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
             }
+            ItemKind::Trait(box ast::Trait { ident, ref impl_restriction, .. }) => {
+                let impl_restriction = self.resolve_restriction(impl_restriction);
+                self.r.impl_restrictions.insert(local_def_id, impl_restriction);
 
-            ItemKind::Enum(ident, _, _) | ItemKind::Trait(box ast::Trait { ident, .. }) => {
+                let module = self.r.new_module(
+                    Some(parent),
+                    ModuleKind::Def(def_kind, def_id, Some(ident.name)),
+                    expansion.to_expn_id(),
+                    item.span,
+                    parent.no_implicit_prelude,
+                );
+                self.r.define(parent, ident, TypeNS, (module, vis, sp, expansion));
+                self.parent_scope.module = module;
+            }
+            ItemKind::Enum(ident, _, _) => {
                 let module = self.r.new_module(
                     Some(parent),
                     ModuleKind::Def(def_kind, def_id, Some(ident.name)),

compiler/rustc_resolve/src/diagnostics.rs

@@ -46,8 +46,8 @@ use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, BindingKey, Finalize,
     ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope, Module,
     ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
-    PrivacyError, ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used,
-    VisResolutionError, errors as errs, path_names_to_string,
+    PrivacyError, ResolutionError, Resolver, RestrictionResolutionError, Scope, ScopeSet, Segment,
+    UseError, Used, VisResolutionError, errors as errs, path_names_to_string,
 };
 
 type Res = def::Res<ast::NodeId>;
@@ -1018,6 +1018,46 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         .emit()
     }
 
+    pub(crate) fn report_restriction_error(
+        &mut self,
+        resolution_error: RestrictionResolutionError<'_>,
+    ) -> ErrorGuaranteed {
+        match resolution_error {
+            RestrictionResolutionError::Relative2018(span, path) => {
+                self.dcx().create_err(errs::RestrictionRelative2018 {
+                    span,
+                    path_span: path.span,
+                    // intentionally converting to String, as the text would also be used as
+                    // in suggestion context
+                    path_str: pprust::path_to_string(&path),
+                })
+            }
+            RestrictionResolutionError::AncestorOnly(span) => {
+                self.dcx().create_err(errs::RestrictionAncestorOnly(span))
+            }
+            RestrictionResolutionError::FailedToResolve(span, label, suggestion) => self
+                .into_struct_error(
+                    span,
+                    ResolutionError::FailedToResolve {
+                        segment: None,
+                        label,
+                        suggestion,
+                        module: None,
+                    },
+                ),
+            RestrictionResolutionError::ExpectedFound(span, path_str, res) => {
+                self.dcx().create_err(errs::ExpectedModuleFound { span, res, path_str })
+            }
+            RestrictionResolutionError::Indeterminate(span) => {
+                self.dcx().create_err(errs::RestrictionIndeterminate(span))
+            }
+            RestrictionResolutionError::ModuleOnly(span) => {
+                self.dcx().create_err(errs::RestrictionModuleOnly(span))
+            }
+        }
+        .emit()
+    }
+
     /// Lookup typo candidate in scope for a macro or import.
     fn early_lookup_typo_candidate(
         &mut self,

compiler/rustc_resolve/src/errors.rs

@@ -1244,3 +1244,25 @@ pub(crate) struct TraitImplMismatch {
     #[label(resolve_trait_impl_mismatch_label_item)]
     pub(crate) trait_item_span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(resolve_restriction_relative_2018)]
+pub(crate) struct RestrictionRelative2018 {
+    #[primary_span]
+    pub(crate) span: Span,
+    #[suggestion(code = "crate::{path_str}", applicability = "maybe-incorrect")]
+    pub(crate) path_span: Span,
+    pub(crate) path_str: String,
+}
+
+#[derive(Diagnostic)]
+#[diag(resolve_restriction_ancestor_only, code = E0742)]
+pub(crate) struct RestrictionAncestorOnly(#[primary_span] pub(crate) Span);
+
+#[derive(Diagnostic)]
+#[diag(resolve_restriction_indeterminate, code = E0578)]
+pub(crate) struct RestrictionIndeterminate(#[primary_span] pub(crate) Span);
+
+#[derive(Diagnostic)]
+#[diag(resolve_restriction_module_only)]
+pub(crate) struct RestrictionModuleOnly(#[primary_span] pub(crate) Span);

compiler/rustc_resolve/src/lib.rs

@@ -321,6 +321,15 @@ enum VisResolutionError<'a> {
     ModuleOnly(Span),
 }
 
+enum RestrictionResolutionError<'a> {
+    Relative2018(Span, &'a ast::Path),
+    AncestorOnly(Span),
+    FailedToResolve(Span, String, Option<Suggestion>),
+    ExpectedFound(Span, String, Res),
+    Indeterminate(Span),
+    ModuleOnly(Span),
+}
+
 /// A minimal representation of a path segment. We use this in resolve because we synthesize 'path
 /// segments' which don't have the rest of an AST or HIR `PathSegment`.
 #[derive(Clone, Copy, Debug)]
@@ -1101,6 +1110,7 @@ pub struct Resolver<'ra, 'tcx> {
     glob_map: FxIndexMap<LocalDefId, FxIndexSet<Symbol>>,
     glob_error: Option<ErrorGuaranteed>,
     visibilities_for_hashing: Vec<(LocalDefId, ty::Visibility)>,
+    impl_restrictions: FxIndexMap<LocalDefId, ty::Restriction>,
     used_imports: FxHashSet<NodeId>,
     maybe_unused_trait_imports: FxIndexSet<LocalDefId>,
 
@@ -1492,6 +1502,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             glob_map: Default::default(),
             glob_error: None,
             visibilities_for_hashing: Default::default(),
+            impl_restrictions: Default::default(),
             used_imports: FxHashSet::default(),
             maybe_unused_trait_imports: Default::default(),
 
@@ -1661,6 +1672,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let global_ctxt = ResolverGlobalCtxt {
             expn_that_defined,
             visibilities_for_hashing: self.visibilities_for_hashing,
+            impl_restrictions: self.impl_restrictions,
             effective_visibilities,
             extern_crate_map,
             module_children: self.module_children,