diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 16fd8cccc89..45549800712 100644 --- 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 index ef7248efda8..0159b8c5bb4 100644 --- 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; diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index edb1a4fdd43..8d95025d02b 100644 --- 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; @@ -106,6 +106,28 @@ 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), @@ -113,6 +135,18 @@ enum ScopeSet { 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, +} + #[derive(Eq)] struct BindingError { name: Name, diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index 1a4066e7a7d..3d10859bf18 100644 --- 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, -} - // 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 index fb8f97d81a3..14622fd9f91 100644 --- 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;