bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

resolve: Scope visiting doesn't need an Ident

Browse source
This commit is contained in:
Vadim Petrochenkov 2021-01-07 15:23:25 +03:00
parent bf5f30684a
commit 3ff866ed7c
6 changed files with 90 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

47
compiler/rustc_resolve/src/lib.rs
View file

@ -50,6 +50,7 @@ use rustc_middle::{bug, span_bug};
use rustc_session::lint;
use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
use rustc_session::Session;
use rustc_span::edition::Edition;
use rustc_span::hygiene::{ExpnId, ExpnKind, MacroKind, SyntaxContext, Transparency};
use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
@ -759,10 +760,13 @@ impl<'a> NameBinding<'a> {
}
fn is_variant(&self) -> bool {
matches!(self.kind, NameBindingKind::Res(
matches!(
self.kind,
NameBindingKind::Res(
Res::Def(DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..), _),
_,
))
)
)
}
fn is_extern_crate(&self) -> bool {
@ -1626,8 +1630,13 @@ impl<'a> Resolver<'a> {
&mut self,
scope_set: ScopeSet,
parent_scope: &ParentScope<'a>,
ident: Ident,
mut visitor: impl FnMut(&mut Self, Scope<'a>, /*use_prelude*/ bool, Ident) -> Option<T>,
ctxt: SyntaxContext,
mut visitor: impl FnMut(
&mut Self,
Scope<'a>,
/*use_prelude*/ bool,
SyntaxContext,
) -> Option<T>,
) -> Option<T> {
// General principles:
// 1. Not controlled (user-defined) names should have higher priority than controlled names
@ -1670,7 +1679,7 @@ impl<'a> Resolver<'a> {
// 4c. Standard library prelude (de-facto closed, controlled).
// 6. Language prelude: builtin attributes (closed, controlled).
let rust_2015 = ident.span.rust_2015();
let rust_2015 = ctxt.edition() == Edition::Edition2015;
let (ns, macro_kind, is_absolute_path) = match scope_set {
ScopeSet::All(ns, _) => (ns, None, false),
ScopeSet::AbsolutePath(ns) => (ns, None, true),
@ -1683,7 +1692,7 @@ impl<'a> Resolver<'a> {
TypeNS | ValueNS => Scope::Module(module),
MacroNS => Scope::DeriveHelpers(parent_scope.expansion),
};
let mut ident = ident.normalize_to_macros_2_0();
let mut ctxt = ctxt.normalize_to_macros_2_0();
let mut use_prelude = !module.no_implicit_prelude;
loop {
@ -1719,7 +1728,7 @@ impl<'a> Resolver<'a> {
};
if visit {
if let break_result @ Some(..) = visitor(self, scope, use_prelude, ident) {
if let break_result @ Some(..) = visitor(self, scope, use_prelude, ctxt) {
return break_result;
}
}
@ -1749,17 +1758,17 @@ impl<'a> Resolver<'a> {
},
Scope::CrateRoot => match ns {
TypeNS => {
ident.span.adjust(ExpnId::root());
ctxt.adjust(ExpnId::root());
Scope::ExternPrelude
}
ValueNS | MacroNS => break,
},
Scope::Module(module) => {
use_prelude = !module.no_implicit_prelude;
match self.hygienic_lexical_parent(module, &mut ident.span) {
match self.hygienic_lexical_parent(module, &mut ctxt) {
Some(parent_module) => Scope::Module(parent_module),
None => {
ident.span.adjust(ExpnId::root());
ctxt.adjust(ExpnId::root());
match ns {
TypeNS => Scope::ExternPrelude,
ValueNS => Scope::StdLibPrelude,
@ -1882,16 +1891,18 @@ impl<'a> Resolver<'a> {
ident = normalized_ident;
let mut poisoned = None;
loop {
let mut span_data = ident.span.data();
let opt_module = if let Some(node_id) = record_used_id {
self.hygienic_lexical_parent_with_compatibility_fallback(
module,
&mut ident.span,
&mut span_data.ctxt,
node_id,
&mut poisoned,
)
} else {
self.hygienic_lexical_parent(module, &mut ident.span)
self.hygienic_lexical_parent(module, &mut span_data.ctxt)
};
ident.span = span_data.span();
module = unwrap_or!(opt_module, break);
let adjusted_parent_scope = &ParentScope { module, ..*parent_scope };
let result = self.resolve_ident_in_module_unadjusted(
@ -1965,10 +1976,10 @@ impl<'a> Resolver<'a> {
fn hygienic_lexical_parent(
&mut self,
module: Module<'a>,
span: &mut Span,
ctxt: &mut SyntaxContext,
) -> Option<Module<'a>> {
if !module.expansion.outer_expn_is_descendant_of(span.ctxt()) {
return Some(self.macro_def_scope(span.remove_mark()));
if !module.expansion.outer_expn_is_descendant_of(*ctxt) {
return Some(self.macro_def_scope(ctxt.remove_mark()));
}
if let ModuleKind::Block(..) = module.kind {
@ -1981,11 +1992,11 @@ impl<'a> Resolver<'a> {
fn hygienic_lexical_parent_with_compatibility_fallback(
&mut self,
module: Module<'a>,
span: &mut Span,
ctxt: &mut SyntaxContext,
node_id: NodeId,
poisoned: &mut Option<NodeId>,
) -> Option<Module<'a>> {
if let module @ Some(..) = self.hygienic_lexical_parent(module, span) {
if let module @ Some(..) = self.hygienic_lexical_parent(module, ctxt) {
return module;
}
@ -2010,7 +2021,7 @@ impl<'a> Resolver<'a> {
let ext = self.get_macro_by_def_id(def_id);
if !ext.is_builtin
&& ext.macro_kind() == MacroKind::Derive
&& parent.expansion.outer_expn_is_descendant_of(span.ctxt())
&& parent.expansion.outer_expn_is_descendant_of(*ctxt)
{
*poisoned = Some(node_id);
return module.parent;