use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver};
use macros::{LegacyBinding, LegacyScope};
+use rustc_error_codes::*;
+
type Res = def::Res<NodeId>;
-pub mod error_codes;
mod diagnostics;
mod late;
mod macros;
mod build_reduced_graph;
mod resolve_imports;
-const KNOWN_TOOLS: &[Name] = &[sym::clippy, sym::rustfmt];
-
enum Weak {
Yes,
No,
/// but not for late resolution yet.
#[derive(Clone, Copy)]
enum Scope<'a> {
- DeriveHelpers,
+ DeriveHelpersCompat,
MacroRules(LegacyScope<'a>),
CrateRoot,
Module(Module<'a>),
+ RegisteredAttrs,
MacroUsePrelude,
BuiltinAttrs,
LegacyPluginHelpers,
Import,
BuiltinAttr,
DeriveHelper,
- LegacyHelperVsPrelude,
LegacyVsModern,
GlobVsOuter,
GlobVsGlob,
"built-in attribute vs any other name",
AmbiguityKind::DeriveHelper =>
"derive helper attribute vs any other name",
- AmbiguityKind::LegacyHelperVsPrelude =>
- "legacy plugin helper attribute vs name from prelude",
AmbiguityKind::LegacyVsModern =>
"`macro_rules` vs non-`macro_rules` from other module",
AmbiguityKind::GlobVsOuter =>
crate_loader: CrateLoader<'a>,
macro_names: FxHashSet<Ident>,
builtin_macros: FxHashMap<Name, SyntaxExtension>,
+ registered_attrs: FxHashSet<Ident>,
+ registered_tools: FxHashSet<Ident>,
macro_use_prelude: FxHashMap<Name, &'a NameBinding<'a>>,
all_macros: FxHashMap<Name, Res>,
macro_map: FxHashMap<DefId, Lrc<SyntaxExtension>>,
}
}
+ let (registered_attrs, registered_tools) =
+ macros::registered_attrs_and_tools(session, &krate.attrs);
+
let mut invocation_parent_scopes = FxHashMap::default();
invocation_parent_scopes.insert(ExpnId::root(), ParentScope::module(graph_root));
crate_loader: CrateLoader::new(session, metadata_loader, crate_name),
macro_names: FxHashSet::default(),
builtin_macros: Default::default(),
+ registered_attrs,
+ registered_tools,
macro_use_prelude: FxHashMap::default(),
all_macros: FxHashMap::default(),
macro_map: FxHashMap::default(),
let mut scope = match ns {
_ if is_absolute_path => Scope::CrateRoot,
TypeNS | ValueNS => Scope::Module(module),
- MacroNS => Scope::DeriveHelpers,
+ MacroNS => Scope::DeriveHelpersCompat,
};
let mut ident = ident.modern();
let mut use_prelude = !module.no_implicit_prelude;
loop {
let visit = match scope {
- Scope::DeriveHelpers => true,
+ Scope::DeriveHelpersCompat => true,
Scope::MacroRules(..) => true,
Scope::CrateRoot => true,
Scope::Module(..) => true,
+ Scope::RegisteredAttrs => use_prelude,
Scope::MacroUsePrelude => use_prelude || rust_2015,
Scope::BuiltinAttrs => true,
Scope::LegacyPluginHelpers => use_prelude || rust_2015,
}
scope = match scope {
- Scope::DeriveHelpers =>
+ Scope::DeriveHelpersCompat =>
Scope::MacroRules(parent_scope.legacy),
Scope::MacroRules(legacy_scope) => match legacy_scope {
LegacyScope::Binding(binding) => Scope::MacroRules(
match ns {
TypeNS => Scope::ExternPrelude,
ValueNS => Scope::StdLibPrelude,
- MacroNS => Scope::MacroUsePrelude,
+ MacroNS => Scope::RegisteredAttrs,
}
}
}
}
+ Scope::RegisteredAttrs => Scope::MacroUsePrelude,
Scope::MacroUsePrelude => Scope::StdLibPrelude,
Scope::BuiltinAttrs => Scope::LegacyPluginHelpers,
Scope::LegacyPluginHelpers => break, // nowhere else to search
if let Some(binding) = self.extern_prelude_get(ident, !record_used) {
return Some(LexicalScopeBinding::Item(binding));
}
- }
- if ns == TypeNS && KNOWN_TOOLS.contains(&ident.name) {
- let binding = (Res::ToolMod, ty::Visibility::Public,
- DUMMY_SP, ExpnId::root()).to_name_binding(self.arenas);
- return Some(LexicalScopeBinding::Item(binding));
+ if let Some(ident) = self.registered_tools.get(&ident) {
+ let binding = (Res::ToolMod, ty::Visibility::Public,
+ ident.span, ExpnId::root()).to_name_binding(self.arenas);
+ return Some(LexicalScopeBinding::Item(binding));
+ }
}
if let Some(prelude) = self.prelude {
if let Ok(binding) = self.resolve_ident_in_module_unadjusted(