resolve: Rename WhereToResolve into Scope

petrochenkov · petrochenkov · commit b302f62cbc63 · 2019-07-18T13:42:44.000+03:00
Also move it into the crate root, it's no longer used for macros only
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
@@ -3,11 +3,11 @@
 //! Here we build the "reduced graph": the graph of the module tree without
 //! any imports resolved.
 
-use crate::macros::{InvocationData, ParentScope, LegacyScope};
+use crate::macros::{InvocationData, LegacyScope};
 use crate::resolve_imports::ImportDirective;
 use crate::resolve_imports::ImportDirectiveSubclass::{self, GlobImport, SingleImport};
 use crate::{Module, ModuleData, ModuleKind, NameBinding, NameBindingKind, Segment, ToNameBinding};
-use crate::{ModuleOrUniformRoot, PerNS, Resolver, ResolverArenas, ExternPreludeEntry};
+use crate::{ModuleOrUniformRoot, ParentScope, PerNS, Resolver, ResolverArenas, ExternPreludeEntry};
 use crate::Namespace::{self, TypeNS, ValueNS, MacroNS};
 use crate::{resolve_error, resolve_struct_error, ResolutionError, Determinacy};
 
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
@@ -16,11 +16,10 @@ use syntax::symbol::{Symbol, kw};
 use syntax::util::lev_distance::find_best_match_for_name;
 use syntax_pos::{BytePos, Span};
 
-use crate::macros::ParentScope;
 use crate::resolve_imports::{ImportDirective, ImportDirectiveSubclass, ImportResolver};
 use crate::{is_self_type, is_self_value, path_names_to_string};
 use crate::{CrateLint, Module, ModuleKind, ModuleOrUniformRoot};
-use crate::{PathResult, PathSource, Resolver, RibKind, Segment};
+use crate::{PathResult, PathSource, ParentScope, Resolver, RibKind, Segment};
 
 type Res = def::Res<ast::NodeId>;
 
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -72,7 +72,7 @@ use smallvec::SmallVec;
 use diagnostics::{Suggestion, ImportSuggestion};
 use diagnostics::{find_span_of_binding_until_next_binding, extend_span_to_previous_binding};
 use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver};
-use macros::{InvocationData, LegacyBinding, ParentScope};
+use macros::{InvocationData, LegacyBinding, LegacyScope};
 
 type Res = def::Res<NodeId>;
 
@@ -106,13 +106,47 @@ impl Determinacy {
     }
 }
 
+/// A specific scope in which a name can be looked up.
+/// This enum is currently used only for early resolution (imports and macros),
+/// but not for late resolution yet.
+enum Scope<'a> {
+    DeriveHelpers,
+    MacroRules(LegacyScope<'a>),
+    CrateRoot,
+    Module(Module<'a>),
+    MacroUsePrelude,
+    BuiltinMacros,
+    BuiltinAttrs,
+    LegacyPluginHelpers,
+    ExternPrelude,
+    ToolPrelude,
+    StdLibPrelude,
+    BuiltinTypes,
+}
+
+/// Names from different contexts may want to visit different subsets of all specific scopes
+/// with different restrictions when looking up the resolution.
+/// This enum is currently used only for early resolution (imports and macros),
+/// but not for late resolution yet.
 enum ScopeSet {
     Import(Namespace),
     AbsolutePath(Namespace),
     Macro(MacroKind),
     Module,
 }
 
+/// Everything you need to know about a name's location to resolve it.
+/// Serves as a starting point for the scope visitor.
+/// This struct is currently used only for early resolution (imports and macros),
+/// but not for late resolution yet.
+#[derive(Clone, Debug)]
+pub struct ParentScope<'a> {
+    module: Module<'a>,
+    expansion: Mark,
+    legacy: LegacyScope<'a>,
+    derives: Vec<ast::Path>,
+}
+
 #[derive(Eq)]
 struct BindingError {
     name: Name,
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
@@ -1,5 +1,5 @@
 use crate::{AmbiguityError, AmbiguityKind, AmbiguityErrorMisc, Determinacy};
-use crate::{CrateLint, Resolver, ResolutionError, ScopeSet, Weak};
+use crate::{CrateLint, Resolver, ResolutionError, Scope, ScopeSet, ParentScope, Weak};
 use crate::{Module, ModuleKind, NameBinding, NameBindingKind, PathResult, Segment, ToNameBinding};
 use crate::{is_known_tool, resolve_error};
 use crate::ModuleOrUniformRoot;
@@ -79,15 +79,6 @@ pub enum LegacyScope<'a> {
     Invocation(&'a InvocationData<'a>),
 }
 
-/// Everything you need to resolve a macro or import path.
-#[derive(Clone, Debug)]
-pub struct ParentScope<'a> {
-    crate module: Module<'a>,
-    crate expansion: Mark,
-    crate legacy: LegacyScope<'a>,
-    crate derives: Vec<ast::Path>,
-}
-
 // Macro namespace is separated into two sub-namespaces, one for bang macros and
 // one for attribute-like macros (attributes, derives).
 // We ignore resolutions from one sub-namespace when searching names in scope for another.
@@ -474,21 +465,6 @@ impl<'a> Resolver<'a> {
         //    but introduced by legacy plugins using `register_attribute`. Priority is somewhere
         //    in prelude, not sure where exactly (creates ambiguities with any other prelude names).
 
-        enum WhereToResolve<'a> {
-            DeriveHelpers,
-            MacroRules(LegacyScope<'a>),
-            CrateRoot,
-            Module(Module<'a>),
-            MacroUsePrelude,
-            BuiltinMacros,
-            BuiltinAttrs,
-            LegacyPluginHelpers,
-            ExternPrelude,
-            ToolPrelude,
-            StdLibPrelude,
-            BuiltinTypes,
-        }
-
         bitflags::bitflags! {
             struct Flags: u8 {
                 const MACRO_RULES        = 1 << 0;
@@ -530,15 +506,15 @@ impl<'a> Resolver<'a> {
             ScopeSet::Module => (TypeNS, None, false, false),
         };
         let mut where_to_resolve = match ns {
-            _ if is_absolute_path => WhereToResolve::CrateRoot,
-            TypeNS | ValueNS => WhereToResolve::Module(parent_scope.module),
-            MacroNS => WhereToResolve::DeriveHelpers,
+            _ if is_absolute_path => Scope::CrateRoot,
+            TypeNS | ValueNS => Scope::Module(parent_scope.module),
+            MacroNS => Scope::DeriveHelpers,
         };
         let mut use_prelude = !parent_scope.module.no_implicit_prelude;
         let mut determinacy = Determinacy::Determined;
         loop {
             let result = match where_to_resolve {
-                WhereToResolve::DeriveHelpers => {
+                Scope::DeriveHelpers => {
                     let mut result = Err(Determinacy::Determined);
                     for derive in &parent_scope.derives {
                         let parent_scope = ParentScope { derives: Vec::new(), ..*parent_scope };
@@ -558,14 +534,14 @@ impl<'a> Resolver<'a> {
                     }
                     result
                 }
-                WhereToResolve::MacroRules(legacy_scope) => match legacy_scope {
+                Scope::MacroRules(legacy_scope) => match legacy_scope {
                     LegacyScope::Binding(legacy_binding) if ident == legacy_binding.ident =>
                         Ok((legacy_binding.binding, Flags::MACRO_RULES)),
                     LegacyScope::Invocation(invoc) if invoc.output_legacy_scope.get().is_none() =>
                         Err(Determinacy::Undetermined),
                     _ => Err(Determinacy::Determined),
                 }
-                WhereToResolve::CrateRoot => {
+                Scope::CrateRoot => {
                     let root_ident = Ident::new(kw::PathRoot, orig_ident.span);
                     let root_module = self.resolve_crate_root(root_ident);
                     let binding = self.resolve_ident_in_module_ext(
@@ -585,7 +561,7 @@ impl<'a> Resolver<'a> {
                         Err((Determinacy::Determined, _)) => Err(Determinacy::Determined),
                     }
                 }
-                WhereToResolve::Module(module) => {
+                Scope::Module(module) => {
                     let orig_current_module = mem::replace(&mut self.current_module, module);
                     let binding = self.resolve_ident_in_module_unadjusted_ext(
                         ModuleOrUniformRoot::Module(module),
@@ -615,7 +591,7 @@ impl<'a> Resolver<'a> {
                         Err((Determinacy::Determined, _)) => Err(Determinacy::Determined),
                     }
                 }
-                WhereToResolve::MacroUsePrelude => {
+                Scope::MacroUsePrelude => {
                     if use_prelude || rust_2015 {
                         match self.macro_use_prelude.get(&ident.name).cloned() {
                             Some(binding) =>
@@ -628,13 +604,13 @@ impl<'a> Resolver<'a> {
                         Err(Determinacy::Determined)
                     }
                 }
-                WhereToResolve::BuiltinMacros => {
+                Scope::BuiltinMacros => {
                     match self.builtin_macros.get(&ident.name).cloned() {
                         Some(binding) => Ok((binding, Flags::PRELUDE)),
                         None => Err(Determinacy::Determined),
                     }
                 }
-                WhereToResolve::BuiltinAttrs => {
+                Scope::BuiltinAttrs => {
                     if is_builtin_attr_name(ident.name) {
                         let binding = (Res::NonMacroAttr(NonMacroAttrKind::Builtin),
                                        ty::Visibility::Public, DUMMY_SP, Mark::root())
@@ -644,7 +620,7 @@ impl<'a> Resolver<'a> {
                         Err(Determinacy::Determined)
                     }
                 }
-                WhereToResolve::LegacyPluginHelpers => {
+                Scope::LegacyPluginHelpers => {
                     if (use_prelude || rust_2015) &&
                        self.session.plugin_attributes.borrow().iter()
                                                      .any(|(name, _)| ident.name == *name) {
@@ -656,7 +632,7 @@ impl<'a> Resolver<'a> {
                         Err(Determinacy::Determined)
                     }
                 }
-                WhereToResolve::ExternPrelude => {
+                Scope::ExternPrelude => {
                     if use_prelude || is_absolute_path {
                         match self.extern_prelude_get(ident, !record_used) {
                             Some(binding) => Ok((binding, Flags::PRELUDE)),
@@ -668,7 +644,7 @@ impl<'a> Resolver<'a> {
                         Err(Determinacy::Determined)
                     }
                 }
-                WhereToResolve::ToolPrelude => {
+                Scope::ToolPrelude => {
                     if use_prelude && is_known_tool(ident.name) {
                         let binding = (Res::ToolMod, ty::Visibility::Public,
                                        DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
@@ -677,7 +653,7 @@ impl<'a> Resolver<'a> {
                         Err(Determinacy::Determined)
                     }
                 }
-                WhereToResolve::StdLibPrelude => {
+                Scope::StdLibPrelude => {
                     let mut result = Err(Determinacy::Determined);
                     if use_prelude {
                         if let Some(prelude) = self.prelude {
@@ -694,7 +670,7 @@ impl<'a> Resolver<'a> {
                     }
                     result
                 }
-                WhereToResolve::BuiltinTypes => {
+                Scope::BuiltinTypes => {
                     match self.primitive_type_table.primitive_types.get(&ident.name).cloned() {
                         Some(prim_ty) => {
                             let binding = (Res::PrimTy(prim_ty), ty::Visibility::Public,
@@ -780,51 +756,51 @@ impl<'a> Resolver<'a> {
             }
 
             where_to_resolve = match where_to_resolve {
-                WhereToResolve::DeriveHelpers =>
-                    WhereToResolve::MacroRules(parent_scope.legacy),
-                WhereToResolve::MacroRules(legacy_scope) => match legacy_scope {
-                    LegacyScope::Binding(binding) => WhereToResolve::MacroRules(
+                Scope::DeriveHelpers =>
+                    Scope::MacroRules(parent_scope.legacy),
+                Scope::MacroRules(legacy_scope) => match legacy_scope {
+                    LegacyScope::Binding(binding) => Scope::MacroRules(
                         binding.parent_legacy_scope
                     ),
-                    LegacyScope::Invocation(invoc) => WhereToResolve::MacroRules(
+                    LegacyScope::Invocation(invoc) => Scope::MacroRules(
                         invoc.output_legacy_scope.get().unwrap_or(invoc.parent_legacy_scope)
                     ),
-                    LegacyScope::Empty => WhereToResolve::Module(parent_scope.module),
+                    LegacyScope::Empty => Scope::Module(parent_scope.module),
                 }
-                WhereToResolve::CrateRoot => match ns {
+                Scope::CrateRoot => match ns {
                     TypeNS => {
                         ident.span.adjust(Mark::root());
-                        WhereToResolve::ExternPrelude
+                        Scope::ExternPrelude
                     }
                     ValueNS | MacroNS => break,
                 }
-                WhereToResolve::Module(module) => {
+                Scope::Module(module) => {
                     match self.hygienic_lexical_parent(module, &mut ident.span) {
-                        Some(parent_module) => WhereToResolve::Module(parent_module),
+                        Some(parent_module) => Scope::Module(parent_module),
                         None => {
                             ident.span.adjust(Mark::root());
                             use_prelude = !module.no_implicit_prelude;
                             match ns {
-                                TypeNS => WhereToResolve::ExternPrelude,
-                                ValueNS => WhereToResolve::StdLibPrelude,
-                                MacroNS => WhereToResolve::MacroUsePrelude,
+                                TypeNS => Scope::ExternPrelude,
+                                ValueNS => Scope::StdLibPrelude,
+                                MacroNS => Scope::MacroUsePrelude,
                             }
                         }
                     }
                 }
-                WhereToResolve::MacroUsePrelude => WhereToResolve::StdLibPrelude,
-                WhereToResolve::BuiltinMacros => WhereToResolve::BuiltinAttrs,
-                WhereToResolve::BuiltinAttrs => WhereToResolve::LegacyPluginHelpers,
-                WhereToResolve::LegacyPluginHelpers => break, // nowhere else to search
-                WhereToResolve::ExternPrelude if is_absolute_path => break,
-                WhereToResolve::ExternPrelude => WhereToResolve::ToolPrelude,
-                WhereToResolve::ToolPrelude => WhereToResolve::StdLibPrelude,
-                WhereToResolve::StdLibPrelude => match ns {
-                    TypeNS => WhereToResolve::BuiltinTypes,
+                Scope::MacroUsePrelude => Scope::StdLibPrelude,
+                Scope::BuiltinMacros => Scope::BuiltinAttrs,
+                Scope::BuiltinAttrs => Scope::LegacyPluginHelpers,
+                Scope::LegacyPluginHelpers => break, // nowhere else to search
+                Scope::ExternPrelude if is_absolute_path => break,
+                Scope::ExternPrelude => Scope::ToolPrelude,
+                Scope::ToolPrelude => Scope::StdLibPrelude,
+                Scope::StdLibPrelude => match ns {
+                    TypeNS => Scope::BuiltinTypes,
                     ValueNS => break, // nowhere else to search
-                    MacroNS => WhereToResolve::BuiltinMacros,
+                    MacroNS => Scope::BuiltinMacros,
                 }
-                WhereToResolve::BuiltinTypes => break, // nowhere else to search
+                Scope::BuiltinTypes => break, // nowhere else to search
             };
 
             continue;
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
@@ -1,7 +1,7 @@
 use ImportDirectiveSubclass::*;
 
 use crate::{AmbiguityError, AmbiguityKind, AmbiguityErrorMisc};
-use crate::{CrateLint, Module, ModuleOrUniformRoot, PerNS, ScopeSet, Weak};
+use crate::{CrateLint, Module, ModuleOrUniformRoot, PerNS, ScopeSet, ParentScope, Weak};
 use crate::Determinacy::{self, *};
 use crate::Namespace::{self, TypeNS, MacroNS};
 use crate::{NameBinding, NameBindingKind, ToNameBinding, PathResult, PrivacyError};
@@ -10,7 +10,6 @@ use crate::{names_to_string, module_to_string};
 use crate::{resolve_error, ResolutionError};
 use crate::ModuleKind;
 use crate::diagnostics::Suggestion;
-use crate::macros::ParentScope;
 
 use errors::Applicability;
 
