Extract visit_scopes for Resolver and SmartResolver.

Author: LorrensP-2158466

compiler/rustc_resolve/src/diagnostics.rs

@@ -39,6 +39,7 @@ use crate::errors::{
     ExplicitUnsafeTraits, MacroDefinedLater, MacroRulesNot, MacroSuggMovePosition,
     MaybeMissingMacroRulesName,
 };
+use crate::ident::ScopeVisitor as _;
 use crate::imports::{Import, ImportKind};
 use crate::late::{PatternSource, Rib};
 use crate::{

compiler/rustc_resolve/src/ident.rs

@@ -40,12 +40,15 @@ enum Shadowing {
     Unrestricted,
 }
 
-impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
+pub(crate) trait ScopeVisitor<'ra, 'tcx>
+where
+    Self: AsRef<Resolver<'ra, 'tcx>> + Sized,
+{
     /// A generic scope visitor.
     /// Visits scopes in order to resolve some identifier in them or perform other actions.
     /// If the callback returns `Some` result, we stop visiting scopes and return it.
-    pub(crate) fn visit_scopes<T>(
-        &mut self,
+    fn visit_scopes<T>(
+        mut self,
         scope_set: ScopeSet<'ra>,
         parent_scope: &ParentScope<'ra>,
         ctxt: SyntaxContext,
@@ -127,7 +130,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     // As another consequence of this optimization visitors never observe invocation
                     // scopes for macros that were already expanded.
                     while let MacroRulesScope::Invocation(invoc_id) = macro_rules_scope.get() {
-                        if let Some(next_scope) = self.output_macro_rules_scopes.get(&invoc_id) {
+                        if let Some(next_scope) =
+                            self.as_ref().output_macro_rules_scopes.get(&invoc_id)
+                        {
                             macro_rules_scope.set(next_scope.get());
                         } else {
                             break;
@@ -146,7 +151,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             if visit {
                 let use_prelude = if use_prelude { UsePrelude::Yes } else { UsePrelude::No };
-                if let break_result @ Some(..) = visitor(self, scope, use_prelude, ctxt) {
+                if let break_result @ Some(..) = visitor(&mut self, scope, use_prelude, ctxt) {
                     return break_result;
                 }
             }
@@ -169,9 +174,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     MacroRulesScope::Binding(binding) => {
                         Scope::MacroRules(binding.parent_macro_rules_scope)
                     }
-                    MacroRulesScope::Invocation(invoc_id) => {
-                        Scope::MacroRules(self.invocation_parent_scopes[&invoc_id].macro_rules)
-                    }
+                    MacroRulesScope::Invocation(invoc_id) => Scope::MacroRules(
+                        self.as_ref().invocation_parent_scopes[&invoc_id].macro_rules,
+                    ),
                     MacroRulesScope::Empty => Scope::Module(module, None),
                 },
                 Scope::Module(..) if module_and_extern_prelude => match ns {
@@ -187,7 +192,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         ScopeSet::Late(.., lint_id) => lint_id,
                         _ => None,
                     };
-                    match self.hygienic_lexical_parent(module, &mut ctxt, derive_fallback_lint_id) {
+                    match self.as_ref().hygienic_lexical_parent(
+                        module,
+                        &mut ctxt,
+                        derive_fallback_lint_id,
+                    ) {
                         Some((parent_module, lint_id)) => {
                             Scope::Module(parent_module, lint_id.or(prev_lint_id))
                         }
@@ -217,7 +226,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         None
     }
+}
+
+impl<'ra, 'tcx> ScopeVisitor<'ra, 'tcx> for &mut Resolver<'ra, 'tcx> {}
+impl<'r, 'ra, 'tcx> ScopeVisitor<'ra, 'tcx> for SmartResolver<'r, 'ra, 'tcx> {}
 
+impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn hygienic_lexical_parent(
         &self,
         module: Module<'ra>,
@@ -421,183 +435,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 }
 
 impl<'r, 'ra, 'tcx> SmartResolver<'r, 'ra, 'tcx> {
-    /// A generic scope visitor.
-    /// Visits scopes in order to resolve some identifier in them or perform other actions.
-    /// If the callback returns `Some` result, we stop visiting scopes and return it.
-    pub(crate) fn visit_scopes<T>(
-        mut self,
-        scope_set: ScopeSet<'ra>,
-        parent_scope: &ParentScope<'ra>,
-        ctxt: SyntaxContext,
-        mut visitor: impl FnMut(&mut Self, Scope<'ra>, UsePrelude, SyntaxContext) -> Option<T>,
-    ) -> Option<T> {
-        // General principles:
-        // 1. Not controlled (user-defined) names should have higher priority than controlled names
-        //    built into the language or standard library. This way we can add new names into the
-        //    language or standard library without breaking user code.
-        // 2. "Closed set" below means new names cannot appear after the current resolution attempt.
-        // Places to search (in order of decreasing priority):
-        // (Type NS)
-        // 1. FIXME: Ribs (type parameters), there's no necessary infrastructure yet
-        //    (open set, not controlled).
-        // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
-        //    (open, not controlled).
-        // 3. Extern prelude (open, the open part is from macro expansions, not controlled).
-        // 4. Tool modules (closed, controlled right now, but not in the future).
-        // 5. Standard library prelude (de-facto closed, controlled).
-        // 6. Language prelude (closed, controlled).
-        // (Value NS)
-        // 1. FIXME: Ribs (local variables), there's no necessary infrastructure yet
-        //    (open set, not controlled).
-        // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
-        //    (open, not controlled).
-        // 3. Standard library prelude (de-facto closed, controlled).
-        // (Macro NS)
-        // 1-3. Derive helpers (open, not controlled). All ambiguities with other names
-        //    are currently reported as errors. They should be higher in priority than preludes
-        //    and probably even names in modules according to the "general principles" above. They
-        //    also should be subject to restricted shadowing because are effectively produced by
-        //    derives (you need to resolve the derive first to add helpers into scope), but they
-        //    should be available before the derive is expanded for compatibility.
-        //    It's mess in general, so we are being conservative for now.
-        // 1-3. `macro_rules` (open, not controlled), loop through `macro_rules` scopes. Have higher
-        //    priority than prelude macros, but create ambiguities with macros in modules.
-        // 1-3. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
-        //    (open, not controlled). Have higher priority than prelude macros, but create
-        //    ambiguities with `macro_rules`.
-        // 4. `macro_use` prelude (open, the open part is from macro expansions, not controlled).
-        // 4a. User-defined prelude from macro-use
-        //    (open, the open part is from macro expansions, not controlled).
-        // 4b. "Standard library prelude" part implemented through `macro-use` (closed, controlled).
-        // 4c. Standard library prelude (de-facto closed, controlled).
-        // 6. Language prelude: builtin attributes (closed, controlled).
-
-        let rust_2015 = ctxt.edition().is_rust_2015();
-        let (ns, macro_kind) = match scope_set {
-            ScopeSet::All(ns)
-            | ScopeSet::ModuleAndExternPrelude(ns, _)
-            | ScopeSet::Late(ns, ..) => (ns, None),
-            ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind)),
-        };
-        let module = match scope_set {
-            // Start with the specified module.
-            ScopeSet::Late(_, module, _) | ScopeSet::ModuleAndExternPrelude(_, module) => module,
-            // Jump out of trait or enum modules, they do not act as scopes.
-            _ => parent_scope.module.nearest_item_scope(),
-        };
-        let module_and_extern_prelude = matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..));
-        let mut scope = match ns {
-            _ if module_and_extern_prelude => Scope::Module(module, None),
-            TypeNS | ValueNS => Scope::Module(module, None),
-            MacroNS => Scope::DeriveHelpers(parent_scope.expansion),
-        };
-        let mut ctxt = ctxt.normalize_to_macros_2_0();
-        let mut use_prelude = !module.no_implicit_prelude;
-
-        loop {
-            let visit = match scope {
-                // Derive helpers are not in scope when resolving derives in the same container.
-                Scope::DeriveHelpers(expn_id) => {
-                    !(expn_id == parent_scope.expansion && macro_kind == Some(MacroKind::Derive))
-                }
-                Scope::DeriveHelpersCompat => true,
-                Scope::MacroRules(macro_rules_scope) => {
-                    // Use "path compression" on `macro_rules` scope chains. This is an optimization
-                    // used to avoid long scope chains, see the comments on `MacroRulesScopeRef`.
-                    // As another consequence of this optimization visitors never observe invocation
-                    // scopes for macros that were already expanded.
-                    while let MacroRulesScope::Invocation(invoc_id) = macro_rules_scope.get() {
-                        if let Some(next_scope) = self.output_macro_rules_scopes.get(&invoc_id) {
-                            macro_rules_scope.set(next_scope.get());
-                        } else {
-                            break;
-                        }
-                    }
-                    true
-                }
-                Scope::Module(..) => true,
-                Scope::MacroUsePrelude => use_prelude || rust_2015,
-                Scope::BuiltinAttrs => true,
-                Scope::ExternPrelude => use_prelude || module_and_extern_prelude,
-                Scope::ToolPrelude => use_prelude,
-                Scope::StdLibPrelude => use_prelude || ns == MacroNS,
-                Scope::BuiltinTypes => true,
-            };
-
-            if visit {
-                let use_prelude = if use_prelude { UsePrelude::Yes } else { UsePrelude::No };
-                if let break_result @ Some(..) = visitor(&mut self, scope, use_prelude, ctxt) {
-                    return break_result;
-                }
-            }
-
-            scope = match scope {
-                Scope::DeriveHelpers(LocalExpnId::ROOT) => Scope::DeriveHelpersCompat,
-                Scope::DeriveHelpers(expn_id) => {
-                    // Derive helpers are not visible to code generated by bang or derive macros.
-                    let expn_data = expn_id.expn_data();
-                    match expn_data.kind {
-                        ExpnKind::Root
-                        | ExpnKind::Macro(MacroKind::Bang | MacroKind::Derive, _) => {
-                            Scope::DeriveHelpersCompat
-                        }
-                        _ => Scope::DeriveHelpers(expn_data.parent.expect_local()),
-                    }
-                }
-                Scope::DeriveHelpersCompat => Scope::MacroRules(parent_scope.macro_rules),
-                Scope::MacroRules(macro_rules_scope) => match macro_rules_scope.get() {
-                    MacroRulesScope::Binding(binding) => {
-                        Scope::MacroRules(binding.parent_macro_rules_scope)
-                    }
-                    MacroRulesScope::Invocation(invoc_id) => {
-                        Scope::MacroRules(self.invocation_parent_scopes[&invoc_id].macro_rules)
-                    }
-                    MacroRulesScope::Empty => Scope::Module(module, None),
-                },
-                Scope::Module(..) if module_and_extern_prelude => match ns {
-                    TypeNS => {
-                        ctxt.adjust(ExpnId::root());
-                        Scope::ExternPrelude
-                    }
-                    ValueNS | MacroNS => break,
-                },
-                Scope::Module(module, prev_lint_id) => {
-                    use_prelude = !module.no_implicit_prelude;
-                    let derive_fallback_lint_id = match scope_set {
-                        ScopeSet::Late(.., lint_id) => lint_id,
-                        _ => None,
-                    };
-                    match self.hygienic_lexical_parent(module, &mut ctxt, derive_fallback_lint_id) {
-                        Some((parent_module, lint_id)) => {
-                            Scope::Module(parent_module, lint_id.or(prev_lint_id))
-                        }
-                        None => {
-                            ctxt.adjust(ExpnId::root());
-                            match ns {
-                                TypeNS => Scope::ExternPrelude,
-                                ValueNS => Scope::StdLibPrelude,
-                                MacroNS => Scope::MacroUsePrelude,
-                            }
-                        }
-                    }
-                }
-                Scope::MacroUsePrelude => Scope::StdLibPrelude,
-                Scope::BuiltinAttrs => break, // nowhere else to search
-                Scope::ExternPrelude if module_and_extern_prelude => break,
-                Scope::ExternPrelude => Scope::ToolPrelude,
-                Scope::ToolPrelude => Scope::StdLibPrelude,
-                Scope::StdLibPrelude => match ns {
-                    TypeNS => Scope::BuiltinTypes,
-                    ValueNS => break, // nowhere else to search
-                    MacroNS => Scope::BuiltinAttrs,
-                },
-                Scope::BuiltinTypes => break, // nowhere else to search
-            };
-        }
-
-        None
-    }
-
     /// This resolves the identifier `ident` in the namespace `ns` in the current lexical scope.
     /// More specifically, we proceed up the hierarchy of scopes and return the binding for
     /// `ident` in the first scope that defines it (or None if no scopes define it).

compiler/rustc_resolve/src/lib.rs

@@ -92,6 +92,8 @@ pub mod rustdoc;
 
 pub use macros::registered_tools_ast;
 
+use crate::ident::ScopeVisitor as _;
+
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 #[derive(Debug)]