1 // ignore-tidy-filelength
3 //! This crate is responsible for the part of name resolution that doesn't require type checker.
5 //! Module structure of the crate is built here.
6 //! Paths in macros, imports, expressions, types, patterns are resolved here.
7 //! Label and lifetime names are resolved here as well.
9 //! Type-relative name resolution (methods, fields, associated items) happens in `librustc_typeck`.
11 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
12 #![feature(bool_to_option)]
13 #![feature(crate_visibility_modifier)]
15 #![feature(or_patterns)]
16 #![recursion_limit = "256"]
18 pub use rustc_hir
::def
::{Namespace, PerNS}
;
22 use rustc_arena
::TypedArena
;
23 use rustc_ast
::node_id
::NodeMap
;
24 use rustc_ast
::unwrap_or
;
25 use rustc_ast
::visit
::{self, Visitor}
;
26 use rustc_ast
::{self as ast, FloatTy, IntTy, NodeId, UintTy}
;
27 use rustc_ast
::{Crate, CRATE_NODE_ID}
;
28 use rustc_ast
::{ItemKind, Path}
;
29 use rustc_ast_lowering
::ResolverAstLowering
;
30 use rustc_ast_pretty
::pprust
;
31 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet, FxIndexMap}
;
32 use rustc_data_structures
::ptr_key
::PtrKey
;
33 use rustc_data_structures
::sync
::Lrc
;
34 use rustc_errors
::{struct_span_err, Applicability, DiagnosticBuilder}
;
35 use rustc_expand
::base
::SyntaxExtension
;
36 use rustc_hir
::def
::Namespace
::*;
37 use rustc_hir
::def
::{self, CtorOf, DefKind, NonMacroAttrKind, PartialRes}
;
38 use rustc_hir
::def_id
::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX}
;
39 use rustc_hir
::definitions
::{DefKey, DefPathData, Definitions}
;
40 use rustc_hir
::PrimTy
::{self, Bool, Char, Float, Int, Str, Uint}
;
41 use rustc_hir
::TraitCandidate
;
42 use rustc_index
::vec
::IndexVec
;
43 use rustc_metadata
::creader
::{CStore, CrateLoader}
;
44 use rustc_middle
::hir
::exports
::ExportMap
;
45 use rustc_middle
::middle
::cstore
::{CrateStore, MetadataLoaderDyn}
;
46 use rustc_middle
::ty
::query
::Providers
;
47 use rustc_middle
::ty
::{self, DefIdTree, ResolverOutputs}
;
48 use rustc_middle
::{bug, span_bug}
;
49 use rustc_session
::lint
;
50 use rustc_session
::lint
::{BuiltinLintDiagnostics, LintBuffer}
;
51 use rustc_session
::Session
;
52 use rustc_span
::hygiene
::{ExpnId, ExpnKind, MacroKind, SyntaxContext, Transparency}
;
53 use rustc_span
::source_map
::Spanned
;
54 use rustc_span
::symbol
::{kw, sym, Ident, Symbol}
;
55 use rustc_span
::{Span, DUMMY_SP}
;
57 use smallvec
::{smallvec, SmallVec}
;
58 use std
::cell
::{Cell, RefCell}
;
59 use std
::collections
::BTreeSet
;
60 use std
::{cmp, fmt, iter, ptr}
;
63 use diagnostics
::{extend_span_to_previous_binding, find_span_of_binding_until_next_binding}
;
64 use diagnostics
::{ImportSuggestion, LabelSuggestion, Suggestion}
;
65 use imports
::{Import, ImportKind, ImportResolver, NameResolution}
;
66 use late
::{HasGenericParams, PathSource, Rib, RibKind::*}
;
67 use macros
::{MacroRulesBinding, MacroRulesScope}
;
69 type Res
= def
::Res
<NodeId
>;
71 mod build_reduced_graph
;
84 #[derive(Copy, Clone, PartialEq, Debug)]
85 pub enum Determinacy
{
91 fn determined(determined
: bool
) -> Determinacy
{
92 if determined { Determinacy::Determined }
else { Determinacy::Undetermined }
96 /// A specific scope in which a name can be looked up.
97 /// This enum is currently used only for early resolution (imports and macros),
98 /// but not for late resolution yet.
99 #[derive(Clone, Copy)]
101 DeriveHelpers(ExpnId
),
103 MacroRules(MacroRulesScope
<'a
>),
115 /// Names from different contexts may want to visit different subsets of all specific scopes
116 /// with different restrictions when looking up the resolution.
117 /// This enum is currently used only for early resolution (imports and macros),
118 /// but not for late resolution yet.
120 /// All scopes with the given namespace.
121 All(Namespace
, /*is_import*/ bool
),
122 /// Crate root, then extern prelude (used for mixed 2015-2018 mode in macros).
123 AbsolutePath(Namespace
),
124 /// All scopes with macro namespace and the given macro kind restriction.
128 /// Everything you need to know about a name's location to resolve it.
129 /// Serves as a starting point for the scope visitor.
130 /// This struct is currently used only for early resolution (imports and macros),
131 /// but not for late resolution yet.
132 #[derive(Clone, Copy, Debug)]
133 pub struct ParentScope
<'a
> {
136 macro_rules
: MacroRulesScope
<'a
>,
137 derives
: &'a
[ast
::Path
],
140 impl<'a
> ParentScope
<'a
> {
141 /// Creates a parent scope with the passed argument used as the module scope component,
142 /// and other scope components set to default empty values.
143 pub fn module(module
: Module
<'a
>) -> ParentScope
<'a
> {
146 expansion
: ExpnId
::root(),
147 macro_rules
: MacroRulesScope
::Empty
,
154 struct BindingError
{
156 origin
: BTreeSet
<Span
>,
157 target
: BTreeSet
<Span
>,
161 impl PartialOrd
for BindingError
{
162 fn partial_cmp(&self, other
: &BindingError
) -> Option
<cmp
::Ordering
> {
163 Some(self.cmp(other
))
167 impl PartialEq
for BindingError
{
168 fn eq(&self, other
: &BindingError
) -> bool
{
169 self.name
== other
.name
173 impl Ord
for BindingError
{
174 fn cmp(&self, other
: &BindingError
) -> cmp
::Ordering
{
175 self.name
.cmp(&other
.name
)
179 enum ResolutionError
<'a
> {
180 /// Error E0401: can't use type or const parameters from outer function.
181 GenericParamsFromOuterFunction(Res
, HasGenericParams
),
182 /// Error E0403: the name is already used for a type or const parameter in this generic
184 NameAlreadyUsedInParameterList(Symbol
, Span
),
185 /// Error E0407: method is not a member of trait.
186 MethodNotMemberOfTrait(Symbol
, &'a
str),
187 /// Error E0437: type is not a member of trait.
188 TypeNotMemberOfTrait(Symbol
, &'a
str),
189 /// Error E0438: const is not a member of trait.
190 ConstNotMemberOfTrait(Symbol
, &'a
str),
191 /// Error E0408: variable `{}` is not bound in all patterns.
192 VariableNotBoundInPattern(&'a BindingError
),
193 /// Error E0409: variable `{}` is bound in inconsistent ways within the same match arm.
194 VariableBoundWithDifferentMode(Symbol
, Span
),
195 /// Error E0415: identifier is bound more than once in this parameter list.
196 IdentifierBoundMoreThanOnceInParameterList(Symbol
),
197 /// Error E0416: identifier is bound more than once in the same pattern.
198 IdentifierBoundMoreThanOnceInSamePattern(Symbol
),
199 /// Error E0426: use of undeclared label.
200 UndeclaredLabel { name: Symbol, suggestion: Option<LabelSuggestion> }
,
201 /// Error E0429: `self` imports are only allowed within a `{ }` list.
202 SelfImportsOnlyAllowedWithin { root: bool, span_with_rename: Span }
,
203 /// Error E0430: `self` import can only appear once in the list.
204 SelfImportCanOnlyAppearOnceInTheList
,
205 /// Error E0431: `self` import can only appear in an import list with a non-empty prefix.
206 SelfImportOnlyInImportListWithNonEmptyPrefix
,
207 /// Error E0433: failed to resolve.
208 FailedToResolve { label: String, suggestion: Option<Suggestion> }
,
209 /// Error E0434: can't capture dynamic environment in a fn item.
210 CannotCaptureDynamicEnvironmentInFnItem
,
211 /// Error E0435: attempt to use a non-constant value in a constant.
212 AttemptToUseNonConstantValueInConstant
,
213 /// Error E0530: `X` bindings cannot shadow `Y`s.
214 BindingShadowsSomethingUnacceptable(&'
static str, Symbol
, &'a NameBinding
<'a
>),
215 /// Error E0128: type parameters with a default cannot use forward-declared identifiers.
216 ForwardDeclaredTyParam
, // FIXME(const_generics:defaults)
217 /// ERROR E0770: the type of const parameters must not depend on other generic parameters.
218 ParamInTyOfConstParam(Symbol
),
219 /// constant values inside of type parameter defaults must not depend on generic parameters.
220 ParamInAnonConstInTyDefault(Symbol
),
221 /// generic parameters must not be used inside of non trivial constant values.
223 /// This error is only emitted when using `min_const_generics`.
224 ParamInNonTrivialAnonConst { name: Symbol, is_type: bool }
,
225 /// Error E0735: type parameters with a default cannot use `Self`
226 SelfInTyParamDefault
,
227 /// Error E0767: use of unreachable label
228 UnreachableLabel { name: Symbol, definition_span: Span, suggestion: Option<LabelSuggestion> }
,
231 enum VisResolutionError
<'a
> {
232 Relative2018(Span
, &'a ast
::Path
),
234 FailedToResolve(Span
, String
, Option
<Suggestion
>),
235 ExpectedFound(Span
, String
, Res
),
240 /// A minimal representation of a path segment. We use this in resolve because we synthesize 'path
241 /// segments' which don't have the rest of an AST or HIR `PathSegment`.
242 #[derive(Clone, Copy, Debug)]
246 /// Signals whether this `PathSegment` has generic arguments. Used to avoid providing
247 /// nonsensical suggestions.
248 has_generic_args
: bool
,
252 fn from_path(path
: &Path
) -> Vec
<Segment
> {
253 path
.segments
.iter().map(|s
| s
.into()).collect()
256 fn from_ident(ident
: Ident
) -> Segment
{
257 Segment { ident, id: None, has_generic_args: false }
260 fn names_to_string(segments
: &[Segment
]) -> String
{
261 names_to_string(&segments
.iter().map(|seg
| seg
.ident
.name
).collect
::<Vec
<_
>>())
265 impl<'a
> From
<&'a ast
::PathSegment
> for Segment
{
266 fn from(seg
: &'a ast
::PathSegment
) -> Segment
{
267 Segment { ident: seg.ident, id: Some(seg.id), has_generic_args: seg.args.is_some() }
271 struct UsePlacementFinder
{
272 target_module
: NodeId
,
277 impl UsePlacementFinder
{
278 fn check(krate
: &Crate
, target_module
: NodeId
) -> (Option
<Span
>, bool
) {
279 let mut finder
= UsePlacementFinder { target_module, span: None, found_use: false }
;
280 visit
::walk_crate(&mut finder
, krate
);
281 (finder
.span
, finder
.found_use
)
285 impl<'tcx
> Visitor
<'tcx
> for UsePlacementFinder
{
288 module
: &'tcx ast
::Mod
,
290 _
: &[ast
::Attribute
],
293 if self.span
.is_some() {
296 if node_id
!= self.target_module
{
297 visit
::walk_mod(self, module
);
300 // find a use statement
301 for item
in &module
.items
{
303 ItemKind
::Use(..) => {
304 // don't suggest placing a use before the prelude
305 // import or other generated ones
306 if !item
.span
.from_expansion() {
307 self.span
= Some(item
.span
.shrink_to_lo());
308 self.found_use
= true;
312 // don't place use before extern crate
313 ItemKind
::ExternCrate(_
) => {}
314 // but place them before the first other item
316 if self.span
.map_or(true, |span
| item
.span
< span
) {
317 if !item
.span
.from_expansion() {
318 // don't insert between attributes and an item
319 if item
.attrs
.is_empty() {
320 self.span
= Some(item
.span
.shrink_to_lo());
322 // find the first attribute on the item
323 for attr
in &item
.attrs
{
324 if self.span
.map_or(true, |span
| attr
.span
< span
) {
325 self.span
= Some(attr
.span
.shrink_to_lo());
337 /// An intermediate resolution result.
339 /// This refers to the thing referred by a name. The difference between `Res` and `Item` is that
340 /// items are visible in their whole block, while `Res`es only from the place they are defined
343 enum LexicalScopeBinding
<'a
> {
344 Item(&'a NameBinding
<'a
>),
348 impl<'a
> LexicalScopeBinding
<'a
> {
349 fn res(self) -> Res
{
351 LexicalScopeBinding
::Item(binding
) => binding
.res(),
352 LexicalScopeBinding
::Res(res
) => res
,
357 #[derive(Copy, Clone, Debug)]
358 enum ModuleOrUniformRoot
<'a
> {
362 /// Virtual module that denotes resolution in crate root with fallback to extern prelude.
363 CrateRootAndExternPrelude
,
365 /// Virtual module that denotes resolution in extern prelude.
366 /// Used for paths starting with `::` on 2018 edition.
369 /// Virtual module that denotes resolution in current scope.
370 /// Used only for resolving single-segment imports. The reason it exists is that import paths
371 /// are always split into two parts, the first of which should be some kind of module.
375 impl ModuleOrUniformRoot
<'_
> {
376 fn same_def(lhs
: Self, rhs
: Self) -> bool
{
378 (ModuleOrUniformRoot
::Module(lhs
), ModuleOrUniformRoot
::Module(rhs
)) => {
379 lhs
.def_id() == rhs
.def_id()
382 ModuleOrUniformRoot
::CrateRootAndExternPrelude
,
383 ModuleOrUniformRoot
::CrateRootAndExternPrelude
,
385 | (ModuleOrUniformRoot
::ExternPrelude
, ModuleOrUniformRoot
::ExternPrelude
)
386 | (ModuleOrUniformRoot
::CurrentScope
, ModuleOrUniformRoot
::CurrentScope
) => true,
392 #[derive(Clone, Debug)]
393 enum PathResult
<'a
> {
394 Module(ModuleOrUniformRoot
<'a
>),
395 NonModule(PartialRes
),
400 suggestion
: Option
<Suggestion
>,
401 is_error_from_last_segment
: bool
,
406 /// An anonymous module; e.g., just a block.
411 /// { // This is an anonymous module
412 /// f(); // This resolves to (2) as we are inside the block.
415 /// f(); // Resolves to (1)
419 /// Any module with a name.
423 /// * A normal module ‒ either `mod from_file;` or `mod from_block { }`.
424 /// * A trait or an enum (it implicitly contains associated types, methods and variant
426 Def(DefKind
, DefId
, Symbol
),
430 /// Get name of the module.
431 pub fn name(&self) -> Option
<Symbol
> {
433 ModuleKind
::Block(..) => None
,
434 ModuleKind
::Def(.., name
) => Some(*name
),
439 /// A key that identifies a binding in a given `Module`.
441 /// Multiple bindings in the same module can have the same key (in a valid
442 /// program) if all but one of them come from glob imports.
443 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
445 /// The identifier for the binding, aways the `normalize_to_macros_2_0` version of the
449 /// 0 if ident is not `_`, otherwise a value that's unique to the specific
450 /// `_` in the expanded AST that introduced this binding.
454 type Resolutions
<'a
> = RefCell
<FxIndexMap
<BindingKey
, &'a RefCell
<NameResolution
<'a
>>>>;
456 /// One node in the tree of modules.
457 pub struct ModuleData
<'a
> {
458 parent
: Option
<Module
<'a
>>,
461 // The def id of the closest normal module (`mod`) ancestor (including this module).
462 normal_ancestor_id
: DefId
,
464 // Mapping between names and their (possibly in-progress) resolutions in this module.
465 // Resolutions in modules from other crates are not populated until accessed.
466 lazy_resolutions
: Resolutions
<'a
>,
467 // True if this is a module from other crate that needs to be populated on access.
468 populate_on_access
: Cell
<bool
>,
470 // Macro invocations that can expand into items in this module.
471 unexpanded_invocations
: RefCell
<FxHashSet
<ExpnId
>>,
473 no_implicit_prelude
: bool
,
475 glob_importers
: RefCell
<Vec
<&'a Import
<'a
>>>,
476 globs
: RefCell
<Vec
<&'a Import
<'a
>>>,
478 // Used to memoize the traits in this module for faster searches through all traits in scope.
479 traits
: RefCell
<Option
<Box
<[(Ident
, &'a NameBinding
<'a
>)]>>>,
481 /// Span of the module itself. Used for error reporting.
487 type Module
<'a
> = &'a ModuleData
<'a
>;
489 impl<'a
> ModuleData
<'a
> {
491 parent
: Option
<Module
<'a
>>,
493 normal_ancestor_id
: DefId
,
501 lazy_resolutions
: Default
::default(),
502 populate_on_access
: Cell
::new(!normal_ancestor_id
.is_local()),
503 unexpanded_invocations
: Default
::default(),
504 no_implicit_prelude
: false,
505 glob_importers
: RefCell
::new(Vec
::new()),
506 globs
: RefCell
::new(Vec
::new()),
507 traits
: RefCell
::new(None
),
513 fn for_each_child
<R
, F
>(&'a
self, resolver
: &mut R
, mut f
: F
)
515 R
: AsMut
<Resolver
<'a
>>,
516 F
: FnMut(&mut R
, Ident
, Namespace
, &'a NameBinding
<'a
>),
518 for (key
, name_resolution
) in resolver
.as_mut().resolutions(self).borrow().iter() {
519 if let Some(binding
) = name_resolution
.borrow().binding
{
520 f(resolver
, key
.ident
, key
.ns
, binding
);
525 /// This modifies `self` in place. The traits will be stored in `self.traits`.
526 fn ensure_traits
<R
>(&'a
self, resolver
: &mut R
)
528 R
: AsMut
<Resolver
<'a
>>,
530 let mut traits
= self.traits
.borrow_mut();
531 if traits
.is_none() {
532 let mut collected_traits
= Vec
::new();
533 self.for_each_child(resolver
, |_
, name
, ns
, binding
| {
537 if let Res
::Def(DefKind
::Trait
| DefKind
::TraitAlias
, _
) = binding
.res() {
538 collected_traits
.push((name
, binding
))
541 *traits
= Some(collected_traits
.into_boxed_slice());
545 fn res(&self) -> Option
<Res
> {
547 ModuleKind
::Def(kind
, def_id
, _
) => Some(Res
::Def(kind
, def_id
)),
552 fn def_id(&self) -> Option
<DefId
> {
554 ModuleKind
::Def(_
, def_id
, _
) => Some(def_id
),
559 // `self` resolves to the first module ancestor that `is_normal`.
560 fn is_normal(&self) -> bool
{
562 ModuleKind
::Def(DefKind
::Mod
, _
, _
) => true,
567 fn is_trait(&self) -> bool
{
569 ModuleKind
::Def(DefKind
::Trait
, _
, _
) => true,
574 fn nearest_item_scope(&'a
self) -> Module
<'a
> {
576 ModuleKind
::Def(DefKind
::Enum
| DefKind
::Trait
, ..) => {
577 self.parent
.expect("enum or trait module without a parent")
583 fn is_ancestor_of(&self, mut other
: &Self) -> bool
{
584 while !ptr
::eq(self, other
) {
585 if let Some(parent
) = other
.parent
{
595 impl<'a
> fmt
::Debug
for ModuleData
<'a
> {
596 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
597 write
!(f
, "{:?}", self.res())
601 /// Records a possibly-private value, type, or module definition.
602 #[derive(Clone, Debug)]
603 pub struct NameBinding
<'a
> {
604 kind
: NameBindingKind
<'a
>,
605 ambiguity
: Option
<(&'a NameBinding
<'a
>, AmbiguityKind
)>,
611 pub trait ToNameBinding
<'a
> {
612 fn to_name_binding(self, arenas
: &'a ResolverArenas
<'a
>) -> &'a NameBinding
<'a
>;
615 impl<'a
> ToNameBinding
<'a
> for &'a NameBinding
<'a
> {
616 fn to_name_binding(self, _
: &'a ResolverArenas
<'a
>) -> &'a NameBinding
<'a
> {
621 #[derive(Clone, Debug)]
622 enum NameBindingKind
<'a
> {
623 Res(Res
, /* is_macro_export */ bool
),
625 Import { binding: &'a NameBinding<'a>, import: &'a Import<'a>, used: Cell<bool> }
,
628 impl<'a
> NameBindingKind
<'a
> {
629 /// Is this a name binding of a import?
630 fn is_import(&self) -> bool
{
632 NameBindingKind
::Import { .. }
=> true,
638 struct PrivacyError
<'a
> {
640 binding
: &'a NameBinding
<'a
>,
644 struct UseError
<'a
> {
645 err
: DiagnosticBuilder
<'a
>,
646 /// Candidates which user could `use` to access the missing type.
647 candidates
: Vec
<ImportSuggestion
>,
648 /// The `DefId` of the module to place the use-statements in.
650 /// Whether the diagnostic should say "instead" (as in `consider importing ... instead`).
652 /// Extra free-form suggestion.
653 suggestion
: Option
<(Span
, &'
static str, String
, Applicability
)>,
656 #[derive(Clone, Copy, PartialEq, Debug)]
661 MacroRulesVsModularized
,
669 fn descr(self) -> &'
static str {
671 AmbiguityKind
::Import
=> "name vs any other name during import resolution",
672 AmbiguityKind
::BuiltinAttr
=> "built-in attribute vs any other name",
673 AmbiguityKind
::DeriveHelper
=> "derive helper attribute vs any other name",
674 AmbiguityKind
::MacroRulesVsModularized
=> {
675 "`macro_rules` vs non-`macro_rules` from other module"
677 AmbiguityKind
::GlobVsOuter
=> {
678 "glob import vs any other name from outer scope during import/macro resolution"
680 AmbiguityKind
::GlobVsGlob
=> "glob import vs glob import in the same module",
681 AmbiguityKind
::GlobVsExpanded
=> {
682 "glob import vs macro-expanded name in the same \
683 module during import/macro resolution"
685 AmbiguityKind
::MoreExpandedVsOuter
=> {
686 "macro-expanded name vs less macro-expanded name \
687 from outer scope during import/macro resolution"
693 /// Miscellaneous bits of metadata for better ambiguity error reporting.
694 #[derive(Clone, Copy, PartialEq)]
695 enum AmbiguityErrorMisc
{
702 struct AmbiguityError
<'a
> {
705 b1
: &'a NameBinding
<'a
>,
706 b2
: &'a NameBinding
<'a
>,
707 misc1
: AmbiguityErrorMisc
,
708 misc2
: AmbiguityErrorMisc
,
711 impl<'a
> NameBinding
<'a
> {
712 fn module(&self) -> Option
<Module
<'a
>> {
714 NameBindingKind
::Module(module
) => Some(module
),
715 NameBindingKind
::Import { binding, .. }
=> binding
.module(),
720 fn res(&self) -> Res
{
722 NameBindingKind
::Res(res
, _
) => res
,
723 NameBindingKind
::Module(module
) => module
.res().unwrap(),
724 NameBindingKind
::Import { binding, .. }
=> binding
.res(),
728 fn is_ambiguity(&self) -> bool
{
729 self.ambiguity
.is_some()
731 NameBindingKind
::Import { binding, .. }
=> binding
.is_ambiguity(),
736 fn is_possibly_imported_variant(&self) -> bool
{
738 NameBindingKind
::Import { binding, .. }
=> binding
.is_possibly_imported_variant(),
739 _
=> self.is_variant(),
743 // We sometimes need to treat variants as `pub` for backwards compatibility.
744 fn pseudo_vis(&self) -> ty
::Visibility
{
745 if self.is_variant() && self.res().def_id().is_local() {
746 ty
::Visibility
::Public
752 fn is_variant(&self) -> bool
{
754 NameBindingKind
::Res(
755 Res
::Def(DefKind
::Variant
| DefKind
::Ctor(CtorOf
::Variant
, ..), _
),
762 fn is_extern_crate(&self) -> bool
{
764 NameBindingKind
::Import
{
765 import
: &Import { kind: ImportKind::ExternCrate { .. }
, .. },
768 NameBindingKind
::Module(&ModuleData
{
769 kind
: ModuleKind
::Def(DefKind
::Mod
, def_id
, _
),
771 }) => def_id
.index
== CRATE_DEF_INDEX
,
776 fn is_import(&self) -> bool
{
778 NameBindingKind
::Import { .. }
=> true,
783 fn is_glob_import(&self) -> bool
{
785 NameBindingKind
::Import { import, .. }
=> import
.is_glob(),
790 fn is_importable(&self) -> bool
{
792 Res
::Def(DefKind
::AssocConst
| DefKind
::AssocFn
| DefKind
::AssocTy
, _
) => false,
797 fn is_macro_def(&self) -> bool
{
799 NameBindingKind
::Res(Res
::Def(DefKind
::Macro(..), _
), _
) => true,
804 fn macro_kind(&self) -> Option
<MacroKind
> {
805 self.res().macro_kind()
808 // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
809 // at some expansion round `max(invoc, binding)` when they both emerged from macros.
810 // Then this function returns `true` if `self` may emerge from a macro *after* that
811 // in some later round and screw up our previously found resolution.
812 // See more detailed explanation in
813 // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
814 fn may_appear_after(&self, invoc_parent_expansion
: ExpnId
, binding
: &NameBinding
<'_
>) -> bool
{
815 // self > max(invoc, binding) => !(self <= invoc || self <= binding)
816 // Expansions are partially ordered, so "may appear after" is an inversion of
817 // "certainly appears before or simultaneously" and includes unordered cases.
818 let self_parent_expansion
= self.expansion
;
819 let other_parent_expansion
= binding
.expansion
;
820 let certainly_before_other_or_simultaneously
=
821 other_parent_expansion
.is_descendant_of(self_parent_expansion
);
822 let certainly_before_invoc_or_simultaneously
=
823 invoc_parent_expansion
.is_descendant_of(self_parent_expansion
);
824 !(certainly_before_other_or_simultaneously
|| certainly_before_invoc_or_simultaneously
)
828 /// Interns the names of the primitive types.
830 /// All other types are defined somewhere and possibly imported, but the primitive ones need
831 /// special handling, since they have no place of origin.
832 struct PrimitiveTypeTable
{
833 primitive_types
: FxHashMap
<Symbol
, PrimTy
>,
836 impl PrimitiveTypeTable
{
837 fn new() -> PrimitiveTypeTable
{
838 let mut table
= FxHashMap
::default();
840 table
.insert(sym
::bool
, Bool
);
841 table
.insert(sym
::char, Char
);
842 table
.insert(sym
::f32, Float(FloatTy
::F32
));
843 table
.insert(sym
::f64, Float(FloatTy
::F64
));
844 table
.insert(sym
::isize, Int(IntTy
::Isize
));
845 table
.insert(sym
::i8, Int(IntTy
::I8
));
846 table
.insert(sym
::i16, Int(IntTy
::I16
));
847 table
.insert(sym
::i32, Int(IntTy
::I32
));
848 table
.insert(sym
::i64, Int(IntTy
::I64
));
849 table
.insert(sym
::i128
, Int(IntTy
::I128
));
850 table
.insert(sym
::str, Str
);
851 table
.insert(sym
::usize, Uint(UintTy
::Usize
));
852 table
.insert(sym
::u8, Uint(UintTy
::U8
));
853 table
.insert(sym
::u16, Uint(UintTy
::U16
));
854 table
.insert(sym
::u32, Uint(UintTy
::U32
));
855 table
.insert(sym
::u64, Uint(UintTy
::U64
));
856 table
.insert(sym
::u128
, Uint(UintTy
::U128
));
857 Self { primitive_types: table }
861 #[derive(Debug, Default, Clone)]
862 pub struct ExternPreludeEntry
<'a
> {
863 extern_crate_item
: Option
<&'a NameBinding
<'a
>>,
864 pub introduced_by_item
: bool
,
867 /// Used for better errors for E0773
868 enum BuiltinMacroState
{
869 NotYetSeen(SyntaxExtension
),
873 /// The main resolver class.
875 /// This is the visitor that walks the whole crate.
876 pub struct Resolver
<'a
> {
877 session
: &'a Session
,
879 definitions
: Definitions
,
881 graph_root
: Module
<'a
>,
883 prelude
: Option
<Module
<'a
>>,
884 extern_prelude
: FxHashMap
<Ident
, ExternPreludeEntry
<'a
>>,
886 /// N.B., this is used only for better diagnostics, not name resolution itself.
887 has_self
: FxHashSet
<DefId
>,
889 /// Names of fields of an item `DefId` accessible with dot syntax.
890 /// Used for hints during error reporting.
891 field_names
: FxHashMap
<DefId
, Vec
<Spanned
<Symbol
>>>,
893 /// All imports known to succeed or fail.
894 determined_imports
: Vec
<&'a Import
<'a
>>,
896 /// All non-determined imports.
897 indeterminate_imports
: Vec
<&'a Import
<'a
>>,
899 /// FIXME: Refactor things so that these fields are passed through arguments and not resolver.
900 /// We are resolving a last import segment during import validation.
901 last_import_segment
: bool
,
902 /// This binding should be ignored during in-module resolution, so that we don't get
903 /// "self-confirming" import resolutions during import validation.
904 unusable_binding
: Option
<&'a NameBinding
<'a
>>,
906 /// The idents for the primitive types.
907 primitive_type_table
: PrimitiveTypeTable
,
909 /// Resolutions for nodes that have a single resolution.
910 partial_res_map
: NodeMap
<PartialRes
>,
911 /// Resolutions for import nodes, which have multiple resolutions in different namespaces.
912 import_res_map
: NodeMap
<PerNS
<Option
<Res
>>>,
913 /// Resolutions for labels (node IDs of their corresponding blocks or loops).
914 label_res_map
: NodeMap
<NodeId
>,
916 /// `CrateNum` resolutions of `extern crate` items.
917 extern_crate_map
: FxHashMap
<LocalDefId
, CrateNum
>,
918 export_map
: ExportMap
<LocalDefId
>,
919 trait_map
: NodeMap
<Vec
<TraitCandidate
>>,
921 /// A map from nodes to anonymous modules.
922 /// Anonymous modules are pseudo-modules that are implicitly created around items
923 /// contained within blocks.
925 /// For example, if we have this:
933 /// There will be an anonymous module created around `g` with the ID of the
934 /// entry block for `f`.
935 block_map
: NodeMap
<Module
<'a
>>,
936 /// A fake module that contains no definition and no prelude. Used so that
937 /// some AST passes can generate identifiers that only resolve to local or
939 empty_module
: Module
<'a
>,
940 module_map
: FxHashMap
<LocalDefId
, Module
<'a
>>,
941 extern_module_map
: FxHashMap
<DefId
, Module
<'a
>>,
942 binding_parent_modules
: FxHashMap
<PtrKey
<'a
, NameBinding
<'a
>>, Module
<'a
>>,
943 underscore_disambiguator
: u32,
945 /// Maps glob imports to the names of items actually imported.
946 glob_map
: FxHashMap
<LocalDefId
, FxHashSet
<Symbol
>>,
948 used_imports
: FxHashSet
<(NodeId
, Namespace
)>,
949 maybe_unused_trait_imports
: FxHashSet
<LocalDefId
>,
950 maybe_unused_extern_crates
: Vec
<(LocalDefId
, Span
)>,
952 /// Privacy errors are delayed until the end in order to deduplicate them.
953 privacy_errors
: Vec
<PrivacyError
<'a
>>,
954 /// Ambiguity errors are delayed for deduplication.
955 ambiguity_errors
: Vec
<AmbiguityError
<'a
>>,
956 /// `use` injections are delayed for better placement and deduplication.
957 use_injections
: Vec
<UseError
<'a
>>,
958 /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
959 macro_expanded_macro_export_errors
: BTreeSet
<(Span
, Span
)>,
961 arenas
: &'a ResolverArenas
<'a
>,
962 dummy_binding
: &'a NameBinding
<'a
>,
964 crate_loader
: CrateLoader
<'a
>,
965 macro_names
: FxHashSet
<Ident
>,
966 builtin_macros
: FxHashMap
<Symbol
, BuiltinMacroState
>,
967 registered_attrs
: FxHashSet
<Ident
>,
968 registered_tools
: FxHashSet
<Ident
>,
969 macro_use_prelude
: FxHashMap
<Symbol
, &'a NameBinding
<'a
>>,
970 all_macros
: FxHashMap
<Symbol
, Res
>,
971 macro_map
: FxHashMap
<DefId
, Lrc
<SyntaxExtension
>>,
972 dummy_ext_bang
: Lrc
<SyntaxExtension
>,
973 dummy_ext_derive
: Lrc
<SyntaxExtension
>,
974 non_macro_attrs
: [Lrc
<SyntaxExtension
>; 2],
975 local_macro_def_scopes
: FxHashMap
<LocalDefId
, Module
<'a
>>,
976 ast_transform_scopes
: FxHashMap
<ExpnId
, Module
<'a
>>,
977 unused_macros
: FxHashMap
<LocalDefId
, (NodeId
, Span
)>,
978 proc_macro_stubs
: FxHashSet
<LocalDefId
>,
979 /// Traces collected during macro resolution and validated when it's complete.
980 single_segment_macro_resolutions
:
981 Vec
<(Ident
, MacroKind
, ParentScope
<'a
>, Option
<&'a NameBinding
<'a
>>)>,
982 multi_segment_macro_resolutions
:
983 Vec
<(Vec
<Segment
>, Span
, MacroKind
, ParentScope
<'a
>, Option
<Res
>)>,
984 builtin_attrs
: Vec
<(Ident
, ParentScope
<'a
>)>,
985 /// `derive(Copy)` marks items they are applied to so they are treated specially later.
986 /// Derive macros cannot modify the item themselves and have to store the markers in the global
987 /// context, so they attach the markers to derive container IDs using this resolver table.
988 containers_deriving_copy
: FxHashSet
<ExpnId
>,
989 /// Parent scopes in which the macros were invoked.
990 /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
991 invocation_parent_scopes
: FxHashMap
<ExpnId
, ParentScope
<'a
>>,
992 /// `macro_rules` scopes *produced* by expanding the macro invocations,
993 /// include all the `macro_rules` items and other invocations generated by them.
994 output_macro_rules_scopes
: FxHashMap
<ExpnId
, MacroRulesScope
<'a
>>,
995 /// Helper attributes that are in scope for the given expansion.
996 helper_attrs
: FxHashMap
<ExpnId
, Vec
<Ident
>>,
998 /// Avoid duplicated errors for "name already defined".
999 name_already_seen
: FxHashMap
<Symbol
, Span
>,
1001 potentially_unused_imports
: Vec
<&'a Import
<'a
>>,
1003 /// Table for mapping struct IDs into struct constructor IDs,
1004 /// it's not used during normal resolution, only for better error reporting.
1005 /// Also includes of list of each fields visibility
1006 struct_constructors
: DefIdMap
<(Res
, ty
::Visibility
, Vec
<ty
::Visibility
>)>,
1008 /// Features enabled for this crate.
1009 active_features
: FxHashSet
<Symbol
>,
1011 /// Stores enum visibilities to properly build a reduced graph
1012 /// when visiting the correspondent variants.
1013 variant_vis
: DefIdMap
<ty
::Visibility
>,
1015 lint_buffer
: LintBuffer
,
1017 next_node_id
: NodeId
,
1019 def_id_to_span
: IndexVec
<LocalDefId
, Span
>,
1021 node_id_to_def_id
: FxHashMap
<ast
::NodeId
, LocalDefId
>,
1022 def_id_to_node_id
: IndexVec
<LocalDefId
, ast
::NodeId
>,
1024 /// Indices of unnamed struct or variant fields with unresolved attributes.
1025 placeholder_field_indices
: FxHashMap
<NodeId
, usize>,
1026 /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
1027 /// we know what parent node that fragment should be attached to thanks to this table.
1028 invocation_parents
: FxHashMap
<ExpnId
, LocalDefId
>,
1030 next_disambiguator
: FxHashMap
<(LocalDefId
, DefPathData
), u32>,
1033 /// Nothing really interesting here; it just provides memory for the rest of the crate.
1035 pub struct ResolverArenas
<'a
> {
1036 modules
: TypedArena
<ModuleData
<'a
>>,
1037 local_modules
: RefCell
<Vec
<Module
<'a
>>>,
1038 name_bindings
: TypedArena
<NameBinding
<'a
>>,
1039 imports
: TypedArena
<Import
<'a
>>,
1040 name_resolutions
: TypedArena
<RefCell
<NameResolution
<'a
>>>,
1041 macro_rules_bindings
: TypedArena
<MacroRulesBinding
<'a
>>,
1042 ast_paths
: TypedArena
<ast
::Path
>,
1043 pattern_spans
: TypedArena
<Span
>,
1046 impl<'a
> ResolverArenas
<'a
> {
1047 fn alloc_module(&'a
self, module
: ModuleData
<'a
>) -> Module
<'a
> {
1048 let module
= self.modules
.alloc(module
);
1049 if module
.def_id().map(|def_id
| def_id
.is_local()).unwrap_or(true) {
1050 self.local_modules
.borrow_mut().push(module
);
1054 fn local_modules(&'a
self) -> std
::cell
::Ref
<'a
, Vec
<Module
<'a
>>> {
1055 self.local_modules
.borrow()
1057 fn alloc_name_binding(&'a
self, name_binding
: NameBinding
<'a
>) -> &'a NameBinding
<'a
> {
1058 self.name_bindings
.alloc(name_binding
)
1060 fn alloc_import(&'a
self, import
: Import
<'a
>) -> &'a Import
<'_
> {
1061 self.imports
.alloc(import
)
1063 fn alloc_name_resolution(&'a
self) -> &'a RefCell
<NameResolution
<'a
>> {
1064 self.name_resolutions
.alloc(Default
::default())
1066 fn alloc_macro_rules_binding(
1068 binding
: MacroRulesBinding
<'a
>,
1069 ) -> &'a MacroRulesBinding
<'a
> {
1070 self.macro_rules_bindings
.alloc(binding
)
1072 fn alloc_ast_paths(&'a
self, paths
: &[ast
::Path
]) -> &'a
[ast
::Path
] {
1073 self.ast_paths
.alloc_from_iter(paths
.iter().cloned())
1075 fn alloc_pattern_spans(&'a
self, spans
: impl Iterator
<Item
= Span
>) -> &'a
[Span
] {
1076 self.pattern_spans
.alloc_from_iter(spans
)
1080 impl<'a
> AsMut
<Resolver
<'a
>> for Resolver
<'a
> {
1081 fn as_mut(&mut self) -> &mut Resolver
<'a
> {
1086 impl<'a
, 'b
> DefIdTree
for &'a Resolver
<'b
> {
1087 fn parent(self, id
: DefId
) -> Option
<DefId
> {
1088 match id
.as_local() {
1089 Some(id
) => self.definitions
.def_key(id
).parent
,
1090 None
=> self.cstore().def_key(id
).parent
,
1092 .map(|index
| DefId { index, ..id }
)
1096 /// This interface is used through the AST→HIR step, to embed full paths into the HIR. After that
1097 /// the resolver is no longer needed as all the relevant information is inline.
1098 impl ResolverAstLowering
for Resolver
<'_
> {
1099 fn def_key(&mut self, id
: DefId
) -> DefKey
{
1100 if let Some(id
) = id
.as_local() {
1101 self.definitions().def_key(id
)
1103 self.cstore().def_key(id
)
1107 fn item_generics_num_lifetimes(&self, def_id
: DefId
, sess
: &Session
) -> usize {
1108 self.cstore().item_generics_num_lifetimes(def_id
, sess
)
1111 fn get_partial_res(&mut self, id
: NodeId
) -> Option
<PartialRes
> {
1112 self.partial_res_map
.get(&id
).cloned()
1115 fn get_import_res(&mut self, id
: NodeId
) -> PerNS
<Option
<Res
>> {
1116 self.import_res_map
.get(&id
).cloned().unwrap_or_default()
1119 fn get_label_res(&mut self, id
: NodeId
) -> Option
<NodeId
> {
1120 self.label_res_map
.get(&id
).cloned()
1123 fn definitions(&mut self) -> &mut Definitions
{
1124 &mut self.definitions
1127 fn lint_buffer(&mut self) -> &mut LintBuffer
{
1128 &mut self.lint_buffer
1131 fn next_node_id(&mut self) -> NodeId
{
1135 fn trait_map(&self) -> &NodeMap
<Vec
<TraitCandidate
>> {
1139 fn opt_local_def_id(&self, node
: NodeId
) -> Option
<LocalDefId
> {
1140 self.node_id_to_def_id
.get(&node
).copied()
1143 fn local_def_id(&self, node
: NodeId
) -> LocalDefId
{
1144 self.opt_local_def_id(node
).unwrap_or_else(|| panic
!("no entry for node id: `{:?}`", node
))
1147 /// Adds a definition with a parent definition.
1151 node_id
: ast
::NodeId
,
1157 !self.node_id_to_def_id
.contains_key(&node_id
),
1158 "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
1161 self.definitions
.def_key(self.node_id_to_def_id
[&node_id
]),
1164 // Find the next free disambiguator for this key.
1165 let next_disambiguator
= &mut self.next_disambiguator
;
1166 let next_disambiguator
= |parent
, data
| {
1167 let next_disamb
= next_disambiguator
.entry((parent
, data
)).or_insert(0);
1168 let disambiguator
= *next_disamb
;
1169 *next_disamb
= next_disamb
.checked_add(1).expect("disambiguator overflow");
1173 let def_id
= self.definitions
.create_def(parent
, data
, expn_id
, next_disambiguator
);
1175 assert_eq
!(self.def_id_to_span
.push(span
), def_id
);
1177 // Some things for which we allocate `LocalDefId`s don't correspond to
1178 // anything in the AST, so they don't have a `NodeId`. For these cases
1179 // we don't need a mapping from `NodeId` to `LocalDefId`.
1180 if node_id
!= ast
::DUMMY_NODE_ID
{
1181 debug
!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id
, node_id
);
1182 self.node_id_to_def_id
.insert(node_id
, def_id
);
1184 assert_eq
!(self.def_id_to_node_id
.push(node_id
), def_id
);
1190 impl<'a
> Resolver
<'a
> {
1192 session
: &'a Session
,
1195 metadata_loader
: &'a MetadataLoaderDyn
,
1196 arenas
: &'a ResolverArenas
<'a
>,
1198 let root_def_id
= DefId
::local(CRATE_DEF_INDEX
);
1199 let root_module_kind
= ModuleKind
::Def(DefKind
::Mod
, root_def_id
, kw
::Invalid
);
1200 let graph_root
= arenas
.alloc_module(ModuleData
{
1201 no_implicit_prelude
: session
.contains_name(&krate
.attrs
, sym
::no_implicit_prelude
),
1202 ..ModuleData
::new(None
, root_module_kind
, root_def_id
, ExpnId
::root(), krate
.span
)
1204 let empty_module_kind
= ModuleKind
::Def(DefKind
::Mod
, root_def_id
, kw
::Invalid
);
1205 let empty_module
= arenas
.alloc_module(ModuleData
{
1206 no_implicit_prelude
: true,
1215 let mut module_map
= FxHashMap
::default();
1216 module_map
.insert(LocalDefId { local_def_index: CRATE_DEF_INDEX }
, graph_root
);
1218 let definitions
= Definitions
::new(crate_name
, session
.local_crate_disambiguator());
1219 let root
= definitions
.get_root_def();
1221 let mut def_id_to_span
= IndexVec
::default();
1222 assert_eq
!(def_id_to_span
.push(rustc_span
::DUMMY_SP
), root
);
1223 let mut def_id_to_node_id
= IndexVec
::default();
1224 assert_eq
!(def_id_to_node_id
.push(CRATE_NODE_ID
), root
);
1225 let mut node_id_to_def_id
= FxHashMap
::default();
1226 node_id_to_def_id
.insert(CRATE_NODE_ID
, root
);
1228 let mut invocation_parents
= FxHashMap
::default();
1229 invocation_parents
.insert(ExpnId
::root(), root
);
1231 let mut extern_prelude
: FxHashMap
<Ident
, ExternPreludeEntry
<'_
>> = session
1235 .filter(|(_
, entry
)| entry
.add_prelude
)
1236 .map(|(name
, _
)| (Ident
::from_str(name
), Default
::default()))
1239 if !session
.contains_name(&krate
.attrs
, sym
::no_core
) {
1240 extern_prelude
.insert(Ident
::with_dummy_span(sym
::core
), Default
::default());
1241 if !session
.contains_name(&krate
.attrs
, sym
::no_std
) {
1242 extern_prelude
.insert(Ident
::with_dummy_span(sym
::std
), Default
::default());
1243 if session
.rust_2018() {
1244 extern_prelude
.insert(Ident
::with_dummy_span(sym
::meta
), Default
::default());
1249 let (registered_attrs
, registered_tools
) =
1250 macros
::registered_attrs_and_tools(session
, &krate
.attrs
);
1252 let mut invocation_parent_scopes
= FxHashMap
::default();
1253 invocation_parent_scopes
.insert(ExpnId
::root(), ParentScope
::module(graph_root
));
1255 let features
= session
.features_untracked();
1256 let non_macro_attr
=
1257 |mark_used
| Lrc
::new(SyntaxExtension
::non_macro_attr(mark_used
, session
.edition()));
1264 // The outermost module has def ID 0; this is not reflected in the
1270 has_self
: FxHashSet
::default(),
1271 field_names
: FxHashMap
::default(),
1273 determined_imports
: Vec
::new(),
1274 indeterminate_imports
: Vec
::new(),
1276 last_import_segment
: false,
1277 unusable_binding
: None
,
1279 primitive_type_table
: PrimitiveTypeTable
::new(),
1281 partial_res_map
: Default
::default(),
1282 import_res_map
: Default
::default(),
1283 label_res_map
: Default
::default(),
1284 extern_crate_map
: Default
::default(),
1285 export_map
: FxHashMap
::default(),
1286 trait_map
: Default
::default(),
1287 underscore_disambiguator
: 0,
1290 block_map
: Default
::default(),
1291 extern_module_map
: FxHashMap
::default(),
1292 binding_parent_modules
: FxHashMap
::default(),
1293 ast_transform_scopes
: FxHashMap
::default(),
1295 glob_map
: Default
::default(),
1297 used_imports
: FxHashSet
::default(),
1298 maybe_unused_trait_imports
: Default
::default(),
1299 maybe_unused_extern_crates
: Vec
::new(),
1301 privacy_errors
: Vec
::new(),
1302 ambiguity_errors
: Vec
::new(),
1303 use_injections
: Vec
::new(),
1304 macro_expanded_macro_export_errors
: BTreeSet
::new(),
1307 dummy_binding
: arenas
.alloc_name_binding(NameBinding
{
1308 kind
: NameBindingKind
::Res(Res
::Err
, false),
1310 expansion
: ExpnId
::root(),
1312 vis
: ty
::Visibility
::Public
,
1315 crate_loader
: CrateLoader
::new(session
, metadata_loader
, crate_name
),
1316 macro_names
: FxHashSet
::default(),
1317 builtin_macros
: Default
::default(),
1320 macro_use_prelude
: FxHashMap
::default(),
1321 all_macros
: FxHashMap
::default(),
1322 macro_map
: FxHashMap
::default(),
1323 dummy_ext_bang
: Lrc
::new(SyntaxExtension
::dummy_bang(session
.edition())),
1324 dummy_ext_derive
: Lrc
::new(SyntaxExtension
::dummy_derive(session
.edition())),
1325 non_macro_attrs
: [non_macro_attr(false), non_macro_attr(true)],
1326 invocation_parent_scopes
,
1327 output_macro_rules_scopes
: Default
::default(),
1328 helper_attrs
: Default
::default(),
1329 local_macro_def_scopes
: FxHashMap
::default(),
1330 name_already_seen
: FxHashMap
::default(),
1331 potentially_unused_imports
: Vec
::new(),
1332 struct_constructors
: Default
::default(),
1333 unused_macros
: Default
::default(),
1334 proc_macro_stubs
: Default
::default(),
1335 single_segment_macro_resolutions
: Default
::default(),
1336 multi_segment_macro_resolutions
: Default
::default(),
1337 builtin_attrs
: Default
::default(),
1338 containers_deriving_copy
: Default
::default(),
1339 active_features
: features
1340 .declared_lib_features
1342 .map(|(feat
, ..)| *feat
)
1343 .chain(features
.declared_lang_features
.iter().map(|(feat
, ..)| *feat
))
1345 variant_vis
: Default
::default(),
1346 lint_buffer
: LintBuffer
::default(),
1347 next_node_id
: NodeId
::from_u32(1),
1351 placeholder_field_indices
: Default
::default(),
1353 next_disambiguator
: Default
::default(),
1357 pub fn next_node_id(&mut self) -> NodeId
{
1362 .expect("input too large; ran out of NodeIds");
1363 self.next_node_id
= ast
::NodeId
::from_usize(next
);
1367 pub fn lint_buffer(&mut self) -> &mut LintBuffer
{
1368 &mut self.lint_buffer
1371 pub fn arenas() -> ResolverArenas
<'a
> {
1375 pub fn into_outputs(self) -> ResolverOutputs
{
1376 let definitions
= self.definitions
;
1377 let extern_crate_map
= self.extern_crate_map
;
1378 let export_map
= self.export_map
;
1379 let maybe_unused_trait_imports
= self.maybe_unused_trait_imports
;
1380 let maybe_unused_extern_crates
= self.maybe_unused_extern_crates
;
1381 let glob_map
= self.glob_map
;
1383 definitions
: definitions
,
1384 cstore
: Box
::new(self.crate_loader
.into_cstore()),
1388 maybe_unused_trait_imports
,
1389 maybe_unused_extern_crates
,
1390 extern_prelude
: self
1393 .map(|(ident
, entry
)| (ident
.name
, entry
.introduced_by_item
))
1398 pub fn clone_outputs(&self) -> ResolverOutputs
{
1400 definitions
: self.definitions
.clone(),
1401 cstore
: Box
::new(self.cstore().clone()),
1402 extern_crate_map
: self.extern_crate_map
.clone(),
1403 export_map
: self.export_map
.clone(),
1404 glob_map
: self.glob_map
.clone(),
1405 maybe_unused_trait_imports
: self.maybe_unused_trait_imports
.clone(),
1406 maybe_unused_extern_crates
: self.maybe_unused_extern_crates
.clone(),
1407 extern_prelude
: self
1410 .map(|(ident
, entry
)| (ident
.name
, entry
.introduced_by_item
))
1415 pub fn cstore(&self) -> &CStore
{
1416 self.crate_loader
.cstore()
1419 fn non_macro_attr(&self, mark_used
: bool
) -> Lrc
<SyntaxExtension
> {
1420 self.non_macro_attrs
[mark_used
as usize].clone()
1423 fn dummy_ext(&self, macro_kind
: MacroKind
) -> Lrc
<SyntaxExtension
> {
1425 MacroKind
::Bang
=> self.dummy_ext_bang
.clone(),
1426 MacroKind
::Derive
=> self.dummy_ext_derive
.clone(),
1427 MacroKind
::Attr
=> self.non_macro_attr(true),
1431 /// Runs the function on each namespace.
1432 fn per_ns
<F
: FnMut(&mut Self, Namespace
)>(&mut self, mut f
: F
) {
1438 fn is_builtin_macro(&mut self, res
: Res
) -> bool
{
1439 self.get_macro(res
).map_or(false, |ext
| ext
.is_builtin
)
1442 fn macro_def(&self, mut ctxt
: SyntaxContext
) -> DefId
{
1444 match ctxt
.outer_expn().expn_data().macro_def_id
{
1445 Some(def_id
) => return def_id
,
1446 None
=> ctxt
.remove_mark(),
1451 /// Entry point to crate resolution.
1452 pub fn resolve_crate(&mut self, krate
: &Crate
) {
1453 let _prof_timer
= self.session
.prof
.generic_activity("resolve_crate");
1455 ImportResolver { r: self }
.finalize_imports();
1456 self.finalize_macro_resolutions();
1458 self.late_resolve_crate(krate
);
1460 self.check_unused(krate
);
1461 self.report_errors(krate
);
1462 self.crate_loader
.postprocess(krate
);
1465 fn get_traits_in_module_containing_item(
1470 found_traits
: &mut Vec
<TraitCandidate
>,
1471 parent_scope
: &ParentScope
<'a
>,
1473 assert
!(ns
== TypeNS
|| ns
== ValueNS
);
1474 module
.ensure_traits(self);
1475 let traits
= module
.traits
.borrow();
1477 for &(trait_name
, binding
) in traits
.as_ref().unwrap().iter() {
1478 // Traits have pseudo-modules that can be used to search for the given ident.
1479 if let Some(module
) = binding
.module() {
1480 let mut ident
= ident
;
1481 if ident
.span
.glob_adjust(module
.expansion
, binding
.span
).is_none() {
1485 .resolve_ident_in_module_unadjusted(
1486 ModuleOrUniformRoot
::Module(module
),
1495 let import_ids
= self.find_transitive_imports(&binding
.kind
, trait_name
);
1496 let trait_def_id
= module
.def_id().unwrap();
1497 found_traits
.push(TraitCandidate { def_id: trait_def_id, import_ids }
);
1499 } else if let Res
::Def(DefKind
::TraitAlias
, _
) = binding
.res() {
1500 // For now, just treat all trait aliases as possible candidates, since we don't
1501 // know if the ident is somewhere in the transitive bounds.
1502 let import_ids
= self.find_transitive_imports(&binding
.kind
, trait_name
);
1503 let trait_def_id
= binding
.res().def_id();
1504 found_traits
.push(TraitCandidate { def_id: trait_def_id, import_ids }
);
1506 bug
!("candidate is not trait or trait alias?")
1511 fn find_transitive_imports(
1513 mut kind
: &NameBindingKind
<'_
>,
1515 ) -> SmallVec
<[LocalDefId
; 1]> {
1516 let mut import_ids
= smallvec
![];
1517 while let NameBindingKind
::Import { import, binding, .. }
= kind
{
1518 let id
= self.local_def_id(import
.id
);
1519 self.maybe_unused_trait_imports
.insert(id
);
1520 self.add_to_glob_map(&import
, trait_name
);
1521 import_ids
.push(id
);
1522 kind
= &binding
.kind
;
1531 normal_ancestor_id
: DefId
,
1535 let module
= ModuleData
::new(Some(parent
), kind
, normal_ancestor_id
, expn_id
, span
);
1536 self.arenas
.alloc_module(module
)
1539 fn new_key(&mut self, ident
: Ident
, ns
: Namespace
) -> BindingKey
{
1540 let ident
= ident
.normalize_to_macros_2_0();
1541 let disambiguator
= if ident
.name
== kw
::Underscore
{
1542 self.underscore_disambiguator
+= 1;
1543 self.underscore_disambiguator
1547 BindingKey { ident, ns, disambiguator }
1550 fn resolutions(&mut self, module
: Module
<'a
>) -> &'a Resolutions
<'a
> {
1551 if module
.populate_on_access
.get() {
1552 module
.populate_on_access
.set(false);
1553 self.build_reduced_graph_external(module
);
1555 &module
.lazy_resolutions
1562 ) -> &'a RefCell
<NameResolution
<'a
>> {
1564 .resolutions(module
)
1567 .or_insert_with(|| self.arenas
.alloc_name_resolution())
1574 used_binding
: &'a NameBinding
<'a
>,
1575 is_lexical_scope
: bool
,
1577 if let Some((b2
, kind
)) = used_binding
.ambiguity
{
1578 self.ambiguity_errors
.push(AmbiguityError
{
1583 misc1
: AmbiguityErrorMisc
::None
,
1584 misc2
: AmbiguityErrorMisc
::None
,
1587 if let NameBindingKind
::Import { import, binding, ref used }
= used_binding
.kind
{
1588 // Avoid marking `extern crate` items that refer to a name from extern prelude,
1589 // but not introduce it, as used if they are accessed from lexical scope.
1590 if is_lexical_scope
{
1591 if let Some(entry
) = self.extern_prelude
.get(&ident
.normalize_to_macros_2_0()) {
1592 if let Some(crate_item
) = entry
.extern_crate_item
{
1593 if ptr
::eq(used_binding
, crate_item
) && !entry
.introduced_by_item
{
1600 import
.used
.set(true);
1601 self.used_imports
.insert((import
.id
, ns
));
1602 self.add_to_glob_map(&import
, ident
);
1603 self.record_use(ident
, ns
, binding
, false);
1608 fn add_to_glob_map(&mut self, import
: &Import
<'_
>, ident
: Ident
) {
1609 if import
.is_glob() {
1610 let def_id
= self.local_def_id(import
.id
);
1611 self.glob_map
.entry(def_id
).or_default().insert(ident
.name
);
1615 /// A generic scope visitor.
1616 /// Visits scopes in order to resolve some identifier in them or perform other actions.
1617 /// If the callback returns `Some` result, we stop visiting scopes and return it.
1620 scope_set
: ScopeSet
,
1621 parent_scope
: &ParentScope
<'a
>,
1623 mut visitor
: impl FnMut(&mut Self, Scope
<'a
>, /*use_prelude*/ bool
, Ident
) -> Option
<T
>,
1625 // General principles:
1626 // 1. Not controlled (user-defined) names should have higher priority than controlled names
1627 // built into the language or standard library. This way we can add new names into the
1628 // language or standard library without breaking user code.
1629 // 2. "Closed set" below means new names cannot appear after the current resolution attempt.
1630 // Places to search (in order of decreasing priority):
1632 // 1. FIXME: Ribs (type parameters), there's no necessary infrastructure yet
1633 // (open set, not controlled).
1634 // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1635 // (open, not controlled).
1636 // 3. Extern prelude (open, the open part is from macro expansions, not controlled).
1637 // 4. Tool modules (closed, controlled right now, but not in the future).
1638 // 5. Standard library prelude (de-facto closed, controlled).
1639 // 6. Language prelude (closed, controlled).
1641 // 1. FIXME: Ribs (local variables), there's no necessary infrastructure yet
1642 // (open set, not controlled).
1643 // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1644 // (open, not controlled).
1645 // 3. Standard library prelude (de-facto closed, controlled).
1647 // 1-3. Derive helpers (open, not controlled). All ambiguities with other names
1648 // are currently reported as errors. They should be higher in priority than preludes
1649 // and probably even names in modules according to the "general principles" above. They
1650 // also should be subject to restricted shadowing because are effectively produced by
1651 // derives (you need to resolve the derive first to add helpers into scope), but they
1652 // should be available before the derive is expanded for compatibility.
1653 // It's mess in general, so we are being conservative for now.
1654 // 1-3. `macro_rules` (open, not controlled), loop through `macro_rules` scopes. Have higher
1655 // priority than prelude macros, but create ambiguities with macros in modules.
1656 // 1-3. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1657 // (open, not controlled). Have higher priority than prelude macros, but create
1658 // ambiguities with `macro_rules`.
1659 // 4. `macro_use` prelude (open, the open part is from macro expansions, not controlled).
1660 // 4a. User-defined prelude from macro-use
1661 // (open, the open part is from macro expansions, not controlled).
1662 // 4b. "Standard library prelude" part implemented through `macro-use` (closed, controlled).
1663 // 4c. Standard library prelude (de-facto closed, controlled).
1664 // 6. Language prelude: builtin attributes (closed, controlled).
1666 let rust_2015
= ident
.span
.rust_2015();
1667 let (ns
, macro_kind
, is_absolute_path
) = match scope_set
{
1668 ScopeSet
::All(ns
, _
) => (ns
, None
, false),
1669 ScopeSet
::AbsolutePath(ns
) => (ns
, None
, true),
1670 ScopeSet
::Macro(macro_kind
) => (MacroNS
, Some(macro_kind
), false),
1672 // Jump out of trait or enum modules, they do not act as scopes.
1673 let module
= parent_scope
.module
.nearest_item_scope();
1674 let mut scope
= match ns
{
1675 _
if is_absolute_path
=> Scope
::CrateRoot
,
1676 TypeNS
| ValueNS
=> Scope
::Module(module
),
1677 MacroNS
=> Scope
::DeriveHelpers(parent_scope
.expansion
),
1679 let mut ident
= ident
.normalize_to_macros_2_0();
1680 let mut use_prelude
= !module
.no_implicit_prelude
;
1683 let visit
= match scope
{
1684 // Derive helpers are not in scope when resolving derives in the same container.
1685 Scope
::DeriveHelpers(expn_id
) => {
1686 !(expn_id
== parent_scope
.expansion
&& macro_kind
== Some(MacroKind
::Derive
))
1688 Scope
::DeriveHelpersCompat
=> true,
1689 Scope
::MacroRules(..) => true,
1690 Scope
::CrateRoot
=> true,
1691 Scope
::Module(..) => true,
1692 Scope
::RegisteredAttrs
=> use_prelude
,
1693 Scope
::MacroUsePrelude
=> use_prelude
|| rust_2015
,
1694 Scope
::BuiltinAttrs
=> true,
1695 Scope
::ExternPrelude
=> use_prelude
|| is_absolute_path
,
1696 Scope
::ToolPrelude
=> use_prelude
,
1697 Scope
::StdLibPrelude
=> use_prelude
|| ns
== MacroNS
,
1698 Scope
::BuiltinTypes
=> true,
1702 if let break_result @
Some(..) = visitor(self, scope
, use_prelude
, ident
) {
1703 return break_result
;
1707 scope
= match scope
{
1708 Scope
::DeriveHelpers(expn_id
) if expn_id
!= ExpnId
::root() => {
1709 // Derive helpers are not visible to code generated by bang or derive macros.
1710 let expn_data
= expn_id
.expn_data();
1711 match expn_data
.kind
{
1713 | ExpnKind
::Macro(MacroKind
::Bang
| MacroKind
::Derive
, _
) => {
1714 Scope
::DeriveHelpersCompat
1716 _
=> Scope
::DeriveHelpers(expn_data
.parent
),
1719 Scope
::DeriveHelpers(..) => Scope
::DeriveHelpersCompat
,
1720 Scope
::DeriveHelpersCompat
=> Scope
::MacroRules(parent_scope
.macro_rules
),
1721 Scope
::MacroRules(macro_rules_scope
) => match macro_rules_scope
{
1722 MacroRulesScope
::Binding(binding
) => {
1723 Scope
::MacroRules(binding
.parent_macro_rules_scope
)
1725 MacroRulesScope
::Invocation(invoc_id
) => Scope
::MacroRules(
1726 self.output_macro_rules_scopes
1729 .unwrap_or(self.invocation_parent_scopes
[&invoc_id
].macro_rules
),
1731 MacroRulesScope
::Empty
=> Scope
::Module(module
),
1733 Scope
::CrateRoot
=> match ns
{
1735 ident
.span
.adjust(ExpnId
::root());
1736 Scope
::ExternPrelude
1738 ValueNS
| MacroNS
=> break,
1740 Scope
::Module(module
) => {
1741 use_prelude
= !module
.no_implicit_prelude
;
1742 match self.hygienic_lexical_parent(module
, &mut ident
.span
) {
1743 Some(parent_module
) => Scope
::Module(parent_module
),
1745 ident
.span
.adjust(ExpnId
::root());
1747 TypeNS
=> Scope
::ExternPrelude
,
1748 ValueNS
=> Scope
::StdLibPrelude
,
1749 MacroNS
=> Scope
::RegisteredAttrs
,
1754 Scope
::RegisteredAttrs
=> Scope
::MacroUsePrelude
,
1755 Scope
::MacroUsePrelude
=> Scope
::StdLibPrelude
,
1756 Scope
::BuiltinAttrs
=> break, // nowhere else to search
1757 Scope
::ExternPrelude
if is_absolute_path
=> break,
1758 Scope
::ExternPrelude
=> Scope
::ToolPrelude
,
1759 Scope
::ToolPrelude
=> Scope
::StdLibPrelude
,
1760 Scope
::StdLibPrelude
=> match ns
{
1761 TypeNS
=> Scope
::BuiltinTypes
,
1762 ValueNS
=> break, // nowhere else to search
1763 MacroNS
=> Scope
::BuiltinAttrs
,
1765 Scope
::BuiltinTypes
=> break, // nowhere else to search
1772 /// This resolves the identifier `ident` in the namespace `ns` in the current lexical scope.
1773 /// More specifically, we proceed up the hierarchy of scopes and return the binding for
1774 /// `ident` in the first scope that defines it (or None if no scopes define it).
1776 /// A block's items are above its local variables in the scope hierarchy, regardless of where
1777 /// the items are defined in the block. For example,
1780 /// g(); // Since there are no local variables in scope yet, this resolves to the item.
1783 /// g(); // This resolves to the local variable `g` since it shadows the item.
1787 /// Invariant: This must only be called during main resolution, not during
1788 /// import resolution.
1789 fn resolve_ident_in_lexical_scope(
1793 parent_scope
: &ParentScope
<'a
>,
1794 record_used_id
: Option
<NodeId
>,
1797 ) -> Option
<LexicalScopeBinding
<'a
>> {
1798 assert
!(ns
== TypeNS
|| ns
== ValueNS
);
1799 if ident
.name
== kw
::Invalid
{
1800 return Some(LexicalScopeBinding
::Res(Res
::Err
));
1802 let (general_span
, normalized_span
) = if ident
.name
== kw
::SelfUpper
{
1803 // FIXME(jseyfried) improve `Self` hygiene
1804 let empty_span
= ident
.span
.with_ctxt(SyntaxContext
::root());
1805 (empty_span
, empty_span
)
1806 } else if ns
== TypeNS
{
1807 let normalized_span
= ident
.span
.normalize_to_macros_2_0();
1808 (normalized_span
, normalized_span
)
1810 (ident
.span
.normalize_to_macro_rules(), ident
.span
.normalize_to_macros_2_0())
1812 ident
.span
= general_span
;
1813 let normalized_ident
= Ident { span: normalized_span, ..ident }
;
1815 // Walk backwards up the ribs in scope.
1816 let record_used
= record_used_id
.is_some();
1817 let mut module
= self.graph_root
;
1818 for i
in (0..ribs
.len()).rev() {
1819 debug
!("walk rib\n{:?}", ribs
[i
].bindings
);
1820 // Use the rib kind to determine whether we are resolving parameters
1821 // (macro 2.0 hygiene) or local variables (`macro_rules` hygiene).
1822 let rib_ident
= if ribs
[i
].kind
.contains_params() { normalized_ident }
else { ident }
;
1823 if let Some(res
) = ribs
[i
].bindings
.get(&rib_ident
).cloned() {
1824 // The ident resolves to a type parameter or local variable.
1825 return Some(LexicalScopeBinding
::Res(self.validate_res_from_ribs(
1835 module
= match ribs
[i
].kind
{
1836 ModuleRibKind(module
) => module
,
1837 MacroDefinition(def
) if def
== self.macro_def(ident
.span
.ctxt()) => {
1838 // If an invocation of this macro created `ident`, give up on `ident`
1839 // and switch to `ident`'s source from the macro definition.
1840 ident
.span
.remove_mark();
1846 let item
= self.resolve_ident_in_module_unadjusted(
1847 ModuleOrUniformRoot
::Module(module
),
1854 if let Ok(binding
) = item
{
1855 // The ident resolves to an item.
1856 return Some(LexicalScopeBinding
::Item(binding
));
1860 ModuleKind
::Block(..) => {}
// We can see through blocks
1865 ident
= normalized_ident
;
1866 let mut poisoned
= None
;
1868 let opt_module
= if let Some(node_id
) = record_used_id
{
1869 self.hygienic_lexical_parent_with_compatibility_fallback(
1876 self.hygienic_lexical_parent(module
, &mut ident
.span
)
1878 module
= unwrap_or
!(opt_module
, break);
1879 let adjusted_parent_scope
= &ParentScope { module, ..*parent_scope }
;
1880 let result
= self.resolve_ident_in_module_unadjusted(
1881 ModuleOrUniformRoot
::Module(module
),
1884 adjusted_parent_scope
,
1891 if let Some(node_id
) = poisoned
{
1892 self.lint_buffer
.buffer_lint_with_diagnostic(
1893 lint
::builtin
::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK
,
1896 &format
!("cannot find {} `{}` in this scope", ns
.descr(), ident
),
1897 BuiltinLintDiagnostics
::ProcMacroDeriveResolutionFallback(ident
.span
),
1900 return Some(LexicalScopeBinding
::Item(binding
));
1902 Err(Determined
) => continue,
1903 Err(Undetermined
) => {
1904 span_bug
!(ident
.span
, "undetermined resolution during main resolution pass")
1909 if !module
.no_implicit_prelude
{
1910 ident
.span
.adjust(ExpnId
::root());
1912 if let Some(binding
) = self.extern_prelude_get(ident
, !record_used
) {
1913 return Some(LexicalScopeBinding
::Item(binding
));
1915 if let Some(ident
) = self.registered_tools
.get(&ident
) {
1917 (Res
::ToolMod
, ty
::Visibility
::Public
, ident
.span
, ExpnId
::root())
1918 .to_name_binding(self.arenas
);
1919 return Some(LexicalScopeBinding
::Item(binding
));
1922 if let Some(prelude
) = self.prelude
{
1923 if let Ok(binding
) = self.resolve_ident_in_module_unadjusted(
1924 ModuleOrUniformRoot
::Module(prelude
),
1931 return Some(LexicalScopeBinding
::Item(binding
));
1937 if let Some(prim_ty
) = self.primitive_type_table
.primitive_types
.get(&ident
.name
) {
1939 (Res
::PrimTy(*prim_ty
), ty
::Visibility
::Public
, DUMMY_SP
, ExpnId
::root())
1940 .to_name_binding(self.arenas
);
1941 return Some(LexicalScopeBinding
::Item(binding
));
1948 fn hygienic_lexical_parent(
1952 ) -> Option
<Module
<'a
>> {
1953 if !module
.expansion
.outer_expn_is_descendant_of(span
.ctxt()) {
1954 return Some(self.macro_def_scope(span
.remove_mark()));
1957 if let ModuleKind
::Block(..) = module
.kind
{
1958 return Some(module
.parent
.unwrap().nearest_item_scope());
1964 fn hygienic_lexical_parent_with_compatibility_fallback(
1969 poisoned
: &mut Option
<NodeId
>,
1970 ) -> Option
<Module
<'a
>> {
1971 if let module @
Some(..) = self.hygienic_lexical_parent(module
, span
) {
1975 // We need to support the next case under a deprecation warning
1978 // ---- begin: this comes from a proc macro derive
1979 // mod implementation_details {
1980 // // Note that `MyStruct` is not in scope here.
1981 // impl SomeTrait for MyStruct { ... }
1985 // So we have to fall back to the module's parent during lexical resolution in this case.
1986 if let Some(parent
) = module
.parent
{
1987 // Inner module is inside the macro, parent module is outside of the macro.
1988 if module
.expansion
!= parent
.expansion
1989 && module
.expansion
.is_descendant_of(parent
.expansion
)
1991 // The macro is a proc macro derive
1992 if let Some(def_id
) = module
.expansion
.expn_data().macro_def_id
{
1993 if let Some(ext
) = self.get_macro_by_def_id(def_id
) {
1994 if !ext
.is_builtin
&& ext
.macro_kind() == MacroKind
::Derive
{
1995 if parent
.expansion
.outer_expn_is_descendant_of(span
.ctxt()) {
1996 *poisoned
= Some(node_id
);
1997 return module
.parent
;
2008 fn resolve_ident_in_module(
2010 module
: ModuleOrUniformRoot
<'a
>,
2013 parent_scope
: &ParentScope
<'a
>,
2016 ) -> Result
<&'a NameBinding
<'a
>, Determinacy
> {
2017 self.resolve_ident_in_module_ext(module
, ident
, ns
, parent_scope
, record_used
, path_span
)
2018 .map_err(|(determinacy
, _
)| determinacy
)
2021 fn resolve_ident_in_module_ext(
2023 module
: ModuleOrUniformRoot
<'a
>,
2026 parent_scope
: &ParentScope
<'a
>,
2029 ) -> Result
<&'a NameBinding
<'a
>, (Determinacy
, Weak
)> {
2030 let tmp_parent_scope
;
2031 let mut adjusted_parent_scope
= parent_scope
;
2033 ModuleOrUniformRoot
::Module(m
) => {
2034 if let Some(def
) = ident
.span
.normalize_to_macros_2_0_and_adjust(m
.expansion
) {
2036 ParentScope { module: self.macro_def_scope(def), ..*parent_scope }
;
2037 adjusted_parent_scope
= &tmp_parent_scope
;
2040 ModuleOrUniformRoot
::ExternPrelude
=> {
2041 ident
.span
.normalize_to_macros_2_0_and_adjust(ExpnId
::root());
2043 ModuleOrUniformRoot
::CrateRootAndExternPrelude
| ModuleOrUniformRoot
::CurrentScope
=> {
2047 self.resolve_ident_in_module_unadjusted_ext(
2051 adjusted_parent_scope
,
2058 fn resolve_crate_root(&mut self, ident
: Ident
) -> Module
<'a
> {
2059 debug
!("resolve_crate_root({:?})", ident
);
2060 let mut ctxt
= ident
.span
.ctxt();
2061 let mark
= if ident
.name
== kw
::DollarCrate
{
2062 // When resolving `$crate` from a `macro_rules!` invoked in a `macro`,
2063 // we don't want to pretend that the `macro_rules!` definition is in the `macro`
2064 // as described in `SyntaxContext::apply_mark`, so we ignore prepended opaque marks.
2065 // FIXME: This is only a guess and it doesn't work correctly for `macro_rules!`
2066 // definitions actually produced by `macro` and `macro` definitions produced by
2067 // `macro_rules!`, but at least such configurations are not stable yet.
2068 ctxt
= ctxt
.normalize_to_macro_rules();
2070 "resolve_crate_root: marks={:?}",
2071 ctxt
.marks().into_iter().map(|(i
, t
)| (i
.expn_data(), t
)).collect
::<Vec
<_
>>()
2073 let mut iter
= ctxt
.marks().into_iter().rev().peekable();
2074 let mut result
= None
;
2075 // Find the last opaque mark from the end if it exists.
2076 while let Some(&(mark
, transparency
)) = iter
.peek() {
2077 if transparency
== Transparency
::Opaque
{
2078 result
= Some(mark
);
2085 "resolve_crate_root: found opaque mark {:?} {:?}",
2087 result
.map(|r
| r
.expn_data())
2089 // Then find the last semi-transparent mark from the end if it exists.
2090 for (mark
, transparency
) in iter
{
2091 if transparency
== Transparency
::SemiTransparent
{
2092 result
= Some(mark
);
2098 "resolve_crate_root: found semi-transparent mark {:?} {:?}",
2100 result
.map(|r
| r
.expn_data())
2104 debug
!("resolve_crate_root: not DollarCrate");
2105 ctxt
= ctxt
.normalize_to_macros_2_0();
2106 ctxt
.adjust(ExpnId
::root())
2108 let module
= match mark
{
2109 Some(def
) => self.macro_def_scope(def
),
2112 "resolve_crate_root({:?}): found no mark (ident.span = {:?})",
2115 return self.graph_root
;
2118 let module
= self.get_module(DefId { index: CRATE_DEF_INDEX, ..module.normal_ancestor_id }
);
2120 "resolve_crate_root({:?}): got module {:?} ({:?}) (ident.span = {:?})",
2129 fn resolve_self(&mut self, ctxt
: &mut SyntaxContext
, module
: Module
<'a
>) -> Module
<'a
> {
2130 let mut module
= self.get_module(module
.normal_ancestor_id
);
2131 while module
.span
.ctxt().normalize_to_macros_2_0() != *ctxt
{
2132 let parent
= module
.parent
.unwrap_or_else(|| self.macro_def_scope(ctxt
.remove_mark()));
2133 module
= self.get_module(parent
.normal_ancestor_id
);
2141 opt_ns
: Option
<Namespace
>, // `None` indicates a module path in import
2142 parent_scope
: &ParentScope
<'a
>,
2145 crate_lint
: CrateLint
,
2146 ) -> PathResult
<'a
> {
2147 self.resolve_path_with_ribs(
2158 fn resolve_path_with_ribs(
2161 opt_ns
: Option
<Namespace
>, // `None` indicates a module path in import
2162 parent_scope
: &ParentScope
<'a
>,
2165 crate_lint
: CrateLint
,
2166 ribs
: Option
<&PerNS
<Vec
<Rib
<'a
>>>>,
2167 ) -> PathResult
<'a
> {
2168 let mut module
= None
;
2169 let mut allow_super
= true;
2170 let mut second_binding
= None
;
2173 "resolve_path(path={:?}, opt_ns={:?}, record_used={:?}, \
2174 path_span={:?}, crate_lint={:?})",
2175 path
, opt_ns
, record_used
, path_span
, crate_lint
,
2178 for (i
, &Segment { ident, id, has_generic_args: _ }
) in path
.iter().enumerate() {
2179 debug
!("resolve_path ident {} {:?} {:?}", i
, ident
, id
);
2180 let record_segment_res
= |this
: &mut Self, res
| {
2182 if let Some(id
) = id
{
2183 if !this
.partial_res_map
.contains_key(&id
) {
2184 assert
!(id
!= ast
::DUMMY_NODE_ID
, "Trying to resolve dummy id");
2185 this
.record_partial_res(id
, PartialRes
::new(res
));
2191 let is_last
= i
== path
.len() - 1;
2192 let ns
= if is_last { opt_ns.unwrap_or(TypeNS) }
else { TypeNS }
;
2193 let name
= ident
.name
;
2195 allow_super
&= ns
== TypeNS
&& (name
== kw
::SelfLower
|| name
== kw
::Super
);
2198 if allow_super
&& name
== kw
::Super
{
2199 let mut ctxt
= ident
.span
.ctxt().normalize_to_macros_2_0();
2200 let self_module
= match i
{
2201 0 => Some(self.resolve_self(&mut ctxt
, parent_scope
.module
)),
2203 Some(ModuleOrUniformRoot
::Module(module
)) => Some(module
),
2207 if let Some(self_module
) = self_module
{
2208 if let Some(parent
) = self_module
.parent
{
2209 module
= Some(ModuleOrUniformRoot
::Module(
2210 self.resolve_self(&mut ctxt
, parent
),
2215 let msg
= "there are too many leading `super` keywords".to_string();
2216 return PathResult
::Failed
{
2220 is_error_from_last_segment
: false,
2224 if name
== kw
::SelfLower
{
2225 let mut ctxt
= ident
.span
.ctxt().normalize_to_macros_2_0();
2226 module
= Some(ModuleOrUniformRoot
::Module(
2227 self.resolve_self(&mut ctxt
, parent_scope
.module
),
2231 if name
== kw
::PathRoot
&& ident
.span
.rust_2018() {
2232 module
= Some(ModuleOrUniformRoot
::ExternPrelude
);
2235 if name
== kw
::PathRoot
&& ident
.span
.rust_2015() && self.session
.rust_2018() {
2236 // `::a::b` from 2015 macro on 2018 global edition
2237 module
= Some(ModuleOrUniformRoot
::CrateRootAndExternPrelude
);
2240 if name
== kw
::PathRoot
|| name
== kw
::Crate
|| name
== kw
::DollarCrate
{
2241 // `::a::b`, `crate::a::b` or `$crate::a::b`
2242 module
= Some(ModuleOrUniformRoot
::Module(self.resolve_crate_root(ident
)));
2248 // Report special messages for path segment keywords in wrong positions.
2249 if ident
.is_path_segment_keyword() && i
!= 0 {
2250 let name_str
= if name
== kw
::PathRoot
{
2251 "crate root".to_string()
2253 format
!("`{}`", name
)
2255 let label
= if i
== 1 && path
[0].ident
.name
== kw
::PathRoot
{
2256 format
!("global paths cannot start with {}", name_str
)
2258 format
!("{} in paths can only be used in start position", name_str
)
2260 return PathResult
::Failed
{
2264 is_error_from_last_segment
: false,
2268 enum FindBindingResult
<'a
> {
2269 Binding(Result
<&'a NameBinding
<'a
>, Determinacy
>),
2270 PathResult(PathResult
<'a
>),
2272 let find_binding_in_ns
= |this
: &mut Self, ns
| {
2273 let binding
= if let Some(module
) = module
{
2274 this
.resolve_ident_in_module(
2282 } else if ribs
.is_none() || opt_ns
.is_none() || opt_ns
== Some(MacroNS
) {
2283 let scopes
= ScopeSet
::All(ns
, opt_ns
.is_none());
2284 this
.early_resolve_ident_in_lexical_scope(
2293 let record_used_id
= if record_used
{
2294 crate_lint
.node_id().or(Some(CRATE_NODE_ID
))
2298 match this
.resolve_ident_in_lexical_scope(
2306 // we found a locally-imported or available item/module
2307 Some(LexicalScopeBinding
::Item(binding
)) => Ok(binding
),
2308 // we found a local variable or type param
2309 Some(LexicalScopeBinding
::Res(res
))
2310 if opt_ns
== Some(TypeNS
) || opt_ns
== Some(ValueNS
) =>
2312 record_segment_res(this
, res
);
2313 return FindBindingResult
::PathResult(PathResult
::NonModule(
2314 PartialRes
::with_unresolved_segments(res
, path
.len() - 1),
2317 _
=> Err(Determinacy
::determined(record_used
)),
2320 FindBindingResult
::Binding(binding
)
2322 let binding
= match find_binding_in_ns(self, ns
) {
2323 FindBindingResult
::PathResult(x
) => return x
,
2324 FindBindingResult
::Binding(binding
) => binding
,
2329 second_binding
= Some(binding
);
2331 let res
= binding
.res();
2332 let maybe_assoc
= opt_ns
!= Some(MacroNS
) && PathSource
::Type
.is_expected(res
);
2333 if let Some(next_module
) = binding
.module() {
2334 module
= Some(ModuleOrUniformRoot
::Module(next_module
));
2335 record_segment_res(self, res
);
2336 } else if res
== Res
::ToolMod
&& i
+ 1 != path
.len() {
2337 if binding
.is_import() {
2341 "cannot use a tool module through an import",
2343 .span_note(binding
.span
, "the tool module imported here")
2346 let res
= Res
::NonMacroAttr(NonMacroAttrKind
::Tool
);
2347 return PathResult
::NonModule(PartialRes
::new(res
));
2348 } else if res
== Res
::Err
{
2349 return PathResult
::NonModule(PartialRes
::new(Res
::Err
));
2350 } else if opt_ns
.is_some() && (is_last
|| maybe_assoc
) {
2351 self.lint_if_path_starts_with_module(
2357 return PathResult
::NonModule(PartialRes
::with_unresolved_segments(
2362 let label
= format
!(
2363 "`{}` is {} {}, not a module",
2369 return PathResult
::Failed
{
2373 is_error_from_last_segment
: is_last
,
2377 Err(Undetermined
) => return PathResult
::Indeterminate
,
2378 Err(Determined
) => {
2379 if let Some(ModuleOrUniformRoot
::Module(module
)) = module
{
2380 if opt_ns
.is_some() && !module
.is_normal() {
2381 return PathResult
::NonModule(PartialRes
::with_unresolved_segments(
2382 module
.res().unwrap(),
2387 let module_res
= match module
{
2388 Some(ModuleOrUniformRoot
::Module(module
)) => module
.res(),
2391 let (label
, suggestion
) = if module_res
== self.graph_root
.res() {
2392 let is_mod
= |res
| match res
{
2393 Res
::Def(DefKind
::Mod
, _
) => true,
2396 // Don't look up import candidates if this is a speculative resolve
2397 let mut candidates
= if record_used
{
2398 self.lookup_import_candidates(ident
, TypeNS
, parent_scope
, is_mod
)
2402 candidates
.sort_by_cached_key(|c
| {
2403 (c
.path
.segments
.len(), pprust
::path_to_string(&c
.path
))
2405 if let Some(candidate
) = candidates
.get(0) {
2407 String
::from("unresolved import"),
2409 vec
![(ident
.span
, pprust
::path_to_string(&candidate
.path
))],
2410 String
::from("a similar path exists"),
2411 Applicability
::MaybeIncorrect
,
2415 (format
!("maybe a missing crate `{}`?", ident
), None
)
2420 .with(|n
| n
.chars().next().map_or(false, |c
| c
.is_ascii_uppercase()))
2422 (format
!("use of undeclared type `{}`", ident
), None
)
2424 (format
!("use of undeclared crate or module `{}`", ident
), None
)
2428 format
!("could not find `{}` in `{}`", ident
, path
[i
- 1].ident
);
2429 if ns
== TypeNS
|| ns
== ValueNS
{
2430 let ns_to_try
= if ns
== TypeNS { ValueNS }
else { TypeNS }
;
2431 if let FindBindingResult
::Binding(Ok(binding
)) =
2432 find_binding_in_ns(self, ns_to_try
)
2434 let mut found
= |what
| {
2436 "expected {}, found {} `{}` in `{}`",
2443 if binding
.module().is_some() {
2446 match binding
.res() {
2447 def
::Res
::<NodeId
>::Def(kind
, id
) => found(kind
.descr(id
)),
2448 _
=> found(ns_to_try
.descr()),
2455 return PathResult
::Failed
{
2459 is_error_from_last_segment
: is_last
,
2465 self.lint_if_path_starts_with_module(crate_lint
, path
, path_span
, second_binding
);
2467 PathResult
::Module(match module
{
2468 Some(module
) => module
,
2469 None
if path
.is_empty() => ModuleOrUniformRoot
::CurrentScope
,
2470 _
=> span_bug
!(path_span
, "resolve_path: non-empty path `{:?}` has no module", path
),
2474 fn lint_if_path_starts_with_module(
2476 crate_lint
: CrateLint
,
2479 second_binding
: Option
<&NameBinding
<'_
>>,
2481 let (diag_id
, diag_span
) = match crate_lint
{
2482 CrateLint
::No
=> return,
2483 CrateLint
::SimplePath(id
) => (id
, path_span
),
2484 CrateLint
::UsePath { root_id, root_span }
=> (root_id
, root_span
),
2485 CrateLint
::QPathTrait { qpath_id, qpath_span }
=> (qpath_id
, qpath_span
),
2488 let first_name
= match path
.get(0) {
2489 // In the 2018 edition this lint is a hard error, so nothing to do
2490 Some(seg
) if seg
.ident
.span
.rust_2015() && self.session
.rust_2015() => seg
.ident
.name
,
2494 // We're only interested in `use` paths which should start with
2495 // `{{root}}` currently.
2496 if first_name
!= kw
::PathRoot
{
2501 // If this import looks like `crate::...` it's already good
2502 Some(Segment { ident, .. }
) if ident
.name
== kw
::Crate
=> return,
2503 // Otherwise go below to see if it's an extern crate
2505 // If the path has length one (and it's `PathRoot` most likely)
2506 // then we don't know whether we're gonna be importing a crate or an
2507 // item in our crate. Defer this lint to elsewhere
2511 // If the first element of our path was actually resolved to an
2512 // `ExternCrate` (also used for `crate::...`) then no need to issue a
2513 // warning, this looks all good!
2514 if let Some(binding
) = second_binding
{
2515 if let NameBindingKind
::Import { import, .. }
= binding
.kind
{
2516 // Careful: we still want to rewrite paths from renamed extern crates.
2517 if let ImportKind
::ExternCrate { source: None, .. }
= import
.kind
{
2523 let diag
= BuiltinLintDiagnostics
::AbsPathWithModule(diag_span
);
2524 self.lint_buffer
.buffer_lint_with_diagnostic(
2525 lint
::builtin
::ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE
,
2528 "absolute paths must start with `self`, `super`, \
2529 `crate`, or an external crate name in the 2018 edition",
2534 // Validate a local resolution (from ribs).
2535 fn validate_res_from_ribs(
2542 all_ribs
: &[Rib
<'a
>],
2544 debug
!("validate_res_from_ribs({:?})", res
);
2545 let ribs
= &all_ribs
[rib_index
+ 1..];
2547 // An invalid forward use of a type parameter from a previous default.
2548 if let ForwardTyParamBanRibKind
= all_ribs
[rib_index
].kind
{
2550 let res_error
= if rib_ident
.name
== kw
::SelfUpper
{
2551 ResolutionError
::SelfInTyParamDefault
2553 ResolutionError
::ForwardDeclaredTyParam
2555 self.report_error(span
, res_error
);
2557 assert_eq
!(res
, Res
::Err
);
2563 use ResolutionError
::*;
2564 let mut res_err
= None
;
2569 | ClosureOrAsyncRibKind
2571 | MacroDefinition(..)
2572 | ForwardTyParamBanRibKind
=> {
2573 // Nothing to do. Continue.
2575 ItemRibKind(_
) | FnItemRibKind
| AssocItemRibKind
=> {
2576 // This was an attempt to access an upvar inside a
2577 // named function item. This is not allowed, so we
2580 // We don't immediately trigger a resolve error, because
2581 // we want certain other resolution errors (namely those
2582 // emitted for `ConstantItemRibKind` below) to take
2584 res_err
= Some(CannotCaptureDynamicEnvironmentInFnItem
);
2587 ConstantItemRibKind(_
) => {
2588 // Still doesn't deal with upvars
2590 self.report_error(span
, AttemptToUseNonConstantValueInConstant
);
2594 ConstParamTyRibKind
=> {
2596 self.report_error(span
, ParamInTyOfConstParam(rib_ident
.name
));
2602 if let Some(res_err
) = res_err
{
2603 self.report_error(span
, res_err
);
2607 Res
::Def(DefKind
::TyParam
, _
) | Res
::SelfTy(..) => {
2608 let mut in_ty_param_default
= false;
2610 let has_generic_params
= match rib
.kind
{
2612 | ClosureOrAsyncRibKind
2615 | MacroDefinition(..) => {
2616 // Nothing to do. Continue.
2620 // We only forbid constant items if we are inside of type defaults,
2621 // for example `struct Foo<T, U = [u8; std::mem::size_of::<T>()]>`
2622 ForwardTyParamBanRibKind
=> {
2623 in_ty_param_default
= true;
2626 ConstantItemRibKind(trivial
) => {
2627 // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
2628 if !trivial
&& self.session
.features_untracked().min_const_generics
{
2629 // HACK(min_const_generics): If we encounter `Self` in an anonymous constant
2630 // we can't easily tell if it's generic at this stage, so we instead remember
2631 // this and then enforce the self type to be concrete later on.
2632 if let Res
::SelfTy(trait_def
, Some((impl_def
, _
))) = res
{
2633 res
= Res
::SelfTy(trait_def
, Some((impl_def
, true)));
2638 ResolutionError
::ParamInNonTrivialAnonConst
{
2639 name
: rib_ident
.name
,
2648 if in_ty_param_default
{
2652 ResolutionError
::ParamInAnonConstInTyDefault(
2663 // This was an attempt to use a type parameter outside its scope.
2664 ItemRibKind(has_generic_params
) => has_generic_params
,
2665 FnItemRibKind
=> HasGenericParams
::Yes
,
2666 ConstParamTyRibKind
=> {
2670 ResolutionError
::ParamInTyOfConstParam(rib_ident
.name
),
2680 ResolutionError
::GenericParamsFromOuterFunction(
2689 Res
::Def(DefKind
::ConstParam
, _
) => {
2690 let mut ribs
= ribs
.iter().peekable();
2691 if let Some(Rib { kind: FnItemRibKind, .. }
) = ribs
.peek() {
2692 // When declaring const parameters inside function signatures, the first rib
2693 // is always a `FnItemRibKind`. In this case, we can skip it, to avoid it
2694 // (spuriously) conflicting with the const param.
2698 let mut in_ty_param_default
= false;
2700 let has_generic_params
= match rib
.kind
{
2702 | ClosureOrAsyncRibKind
2705 | MacroDefinition(..) => continue,
2707 // We only forbid constant items if we are inside of type defaults,
2708 // for example `struct Foo<T, U = [u8; std::mem::size_of::<T>()]>`
2709 ForwardTyParamBanRibKind
=> {
2710 in_ty_param_default
= true;
2713 ConstantItemRibKind(trivial
) => {
2714 // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
2715 if !trivial
&& self.session
.features_untracked().min_const_generics
{
2719 ResolutionError
::ParamInNonTrivialAnonConst
{
2720 name
: rib_ident
.name
,
2728 if in_ty_param_default
{
2732 ResolutionError
::ParamInAnonConstInTyDefault(
2743 ItemRibKind(has_generic_params
) => has_generic_params
,
2744 FnItemRibKind
=> HasGenericParams
::Yes
,
2745 ConstParamTyRibKind
=> {
2749 ResolutionError
::ParamInTyOfConstParam(rib_ident
.name
),
2756 // This was an attempt to use a const parameter outside its scope.
2760 ResolutionError
::GenericParamsFromOuterFunction(
2774 fn record_partial_res(&mut self, node_id
: NodeId
, resolution
: PartialRes
) {
2775 debug
!("(recording res) recording {:?} for {}", resolution
, node_id
);
2776 if let Some(prev_res
) = self.partial_res_map
.insert(node_id
, resolution
) {
2777 panic
!("path resolved multiple times ({:?} before, {:?} now)", prev_res
, resolution
);
2781 fn is_accessible_from(&self, vis
: ty
::Visibility
, module
: Module
<'a
>) -> bool
{
2782 vis
.is_accessible_from(module
.normal_ancestor_id
, self)
2785 fn set_binding_parent_module(&mut self, binding
: &'a NameBinding
<'a
>, module
: Module
<'a
>) {
2786 if let Some(old_module
) = self.binding_parent_modules
.insert(PtrKey(binding
), module
) {
2787 if !ptr
::eq(module
, old_module
) {
2788 span_bug
!(binding
.span
, "parent module is reset for binding");
2793 fn disambiguate_macro_rules_vs_modularized(
2795 macro_rules
: &'a NameBinding
<'a
>,
2796 modularized
: &'a NameBinding
<'a
>,
2798 // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
2799 // is disambiguated to mitigate regressions from macro modularization.
2800 // Scoping for `macro_rules` behaves like scoping for `let` at module level, in general.
2802 self.binding_parent_modules
.get(&PtrKey(macro_rules
)),
2803 self.binding_parent_modules
.get(&PtrKey(modularized
)),
2805 (Some(macro_rules
), Some(modularized
)) => {
2806 macro_rules
.normal_ancestor_id
== modularized
.normal_ancestor_id
2807 && modularized
.is_ancestor_of(macro_rules
)
2813 fn report_errors(&mut self, krate
: &Crate
) {
2814 self.report_with_use_injections(krate
);
2816 for &(span_use
, span_def
) in &self.macro_expanded_macro_export_errors
{
2817 let msg
= "macro-expanded `macro_export` macros from the current crate \
2818 cannot be referred to by absolute paths";
2819 self.lint_buffer
.buffer_lint_with_diagnostic(
2820 lint
::builtin
::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS
,
2824 BuiltinLintDiagnostics
::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def
),
2828 for ambiguity_error
in &self.ambiguity_errors
{
2829 self.report_ambiguity_error(ambiguity_error
);
2832 let mut reported_spans
= FxHashSet
::default();
2833 for error
in &self.privacy_errors
{
2834 if reported_spans
.insert(error
.dedup_span
) {
2835 self.report_privacy_error(error
);
2840 fn report_with_use_injections(&mut self, krate
: &Crate
) {
2841 for UseError { mut err, candidates, def_id, instead, suggestion }
in
2842 self.use_injections
.drain(..)
2844 let (span
, found_use
) = if let Some(def_id
) = def_id
.as_local() {
2845 UsePlacementFinder
::check(krate
, self.def_id_to_node_id
[def_id
])
2849 if !candidates
.is_empty() {
2850 diagnostics
::show_candidates(&mut err
, span
, &candidates
, instead
, found_use
);
2851 } else if let Some((span
, msg
, sugg
, appl
)) = suggestion
{
2852 err
.span_suggestion(span
, msg
, sugg
, appl
);
2858 fn report_conflict
<'b
>(
2863 new_binding
: &NameBinding
<'b
>,
2864 old_binding
: &NameBinding
<'b
>,
2866 // Error on the second of two conflicting names
2867 if old_binding
.span
.lo() > new_binding
.span
.lo() {
2868 return self.report_conflict(parent
, ident
, ns
, old_binding
, new_binding
);
2871 let container
= match parent
.kind
{
2872 ModuleKind
::Def(kind
, _
, _
) => kind
.descr(parent
.def_id().unwrap()),
2873 ModuleKind
::Block(..) => "block",
2876 let old_noun
= match old_binding
.is_import() {
2878 false => "definition",
2881 let new_participle
= match new_binding
.is_import() {
2887 (ident
.name
, self.session
.source_map().guess_head_span(new_binding
.span
));
2889 if let Some(s
) = self.name_already_seen
.get(&name
) {
2895 let old_kind
= match (ns
, old_binding
.module()) {
2896 (ValueNS
, _
) => "value",
2897 (MacroNS
, _
) => "macro",
2898 (TypeNS
, _
) if old_binding
.is_extern_crate() => "extern crate",
2899 (TypeNS
, Some(module
)) if module
.is_normal() => "module",
2900 (TypeNS
, Some(module
)) if module
.is_trait() => "trait",
2901 (TypeNS
, _
) => "type",
2904 let msg
= format
!("the name `{}` is defined multiple times", name
);
2906 let mut err
= match (old_binding
.is_extern_crate(), new_binding
.is_extern_crate()) {
2907 (true, true) => struct_span_err
!(self.session
, span
, E0259
, "{}", msg
),
2908 (true, _
) | (_
, true) => match new_binding
.is_import() && old_binding
.is_import() {
2909 true => struct_span_err
!(self.session
, span
, E0254
, "{}", msg
),
2910 false => struct_span_err
!(self.session
, span
, E0260
, "{}", msg
),
2912 _
=> match (old_binding
.is_import(), new_binding
.is_import()) {
2913 (false, false) => struct_span_err
!(self.session
, span
, E0428
, "{}", msg
),
2914 (true, true) => struct_span_err
!(self.session
, span
, E0252
, "{}", msg
),
2915 _
=> struct_span_err
!(self.session
, span
, E0255
, "{}", msg
),
2920 "`{}` must be defined only once in the {} namespace of this {}",
2926 err
.span_label(span
, format
!("`{}` re{} here", name
, new_participle
));
2928 self.session
.source_map().guess_head_span(old_binding
.span
),
2929 format
!("previous {} of the {} `{}` here", old_noun
, old_kind
, name
),
2932 // See https://github.com/rust-lang/rust/issues/32354
2933 use NameBindingKind
::Import
;
2934 let import
= match (&new_binding
.kind
, &old_binding
.kind
) {
2935 // If there are two imports where one or both have attributes then prefer removing the
2936 // import without attributes.
2937 (Import { import: new, .. }
, Import { import: old, .. }
)
2939 !new_binding
.span
.is_dummy()
2940 && !old_binding
.span
.is_dummy()
2941 && (new
.has_attributes
|| old
.has_attributes
)
2944 if old
.has_attributes
{
2945 Some((new
, new_binding
.span
, true))
2947 Some((old
, old_binding
.span
, true))
2950 // Otherwise prioritize the new binding.
2951 (Import { import, .. }
, other
) if !new_binding
.span
.is_dummy() => {
2952 Some((import
, new_binding
.span
, other
.is_import()))
2954 (other
, Import { import, .. }
) if !old_binding
.span
.is_dummy() => {
2955 Some((import
, old_binding
.span
, other
.is_import()))
2960 // Check if the target of the use for both bindings is the same.
2961 let duplicate
= new_binding
.res().opt_def_id() == old_binding
.res().opt_def_id();
2962 let has_dummy_span
= new_binding
.span
.is_dummy() || old_binding
.span
.is_dummy();
2964 self.extern_prelude
.get(&ident
).map(|entry
| entry
.introduced_by_item
).unwrap_or(true);
2965 // Only suggest removing an import if both bindings are to the same def, if both spans
2966 // aren't dummy spans. Further, if both bindings are imports, then the ident must have
2967 // been introduced by a item.
2968 let should_remove_import
= duplicate
2970 && ((new_binding
.is_extern_crate() || old_binding
.is_extern_crate()) || from_item
);
2973 Some((import
, span
, true)) if should_remove_import
&& import
.is_nested() => {
2974 self.add_suggestion_for_duplicate_nested_use(&mut err
, import
, span
)
2976 Some((import
, _
, true)) if should_remove_import
&& !import
.is_glob() => {
2977 // Simple case - remove the entire import. Due to the above match arm, this can
2978 // only be a single use so just remove it entirely.
2979 err
.tool_only_span_suggestion(
2980 import
.use_span_with_attributes
,
2981 "remove unnecessary import",
2983 Applicability
::MaybeIncorrect
,
2986 Some((import
, span
, _
)) => {
2987 self.add_suggestion_for_rename_of_use(&mut err
, name
, import
, span
)
2993 self.name_already_seen
.insert(name
, span
);
2996 /// This function adds a suggestion to change the binding name of a new import that conflicts
2997 /// with an existing import.
2999 /// ```text,ignore (diagnostic)
3000 /// help: you can use `as` to change the binding name of the import
3002 /// LL | use foo::bar as other_bar;
3003 /// | ^^^^^^^^^^^^^^^^^^^^^
3005 fn add_suggestion_for_rename_of_use(
3007 err
: &mut DiagnosticBuilder
<'_
>,
3009 import
: &Import
<'_
>,
3012 let suggested_name
= if name
.as_str().chars().next().unwrap().is_uppercase() {
3013 format
!("Other{}", name
)
3015 format
!("other_{}", name
)
3018 let mut suggestion
= None
;
3020 ImportKind
::Single { type_ns_only: true, .. }
=> {
3021 suggestion
= Some(format
!("self as {}", suggested_name
))
3023 ImportKind
::Single { source, .. }
=> {
3025 source
.span
.hi().0.checked_sub(binding_span
.lo().0).map(|pos
| pos
as usize)
3027 if let Ok(snippet
) = self.session
.source_map().span_to_snippet(binding_span
) {
3028 if pos
<= snippet
.len() {
3029 suggestion
= Some(format
!(
3033 if snippet
.ends_with('
;'
) { ";" }
else { "" }
3039 ImportKind
::ExternCrate { source, target, .. }
=> {
3040 suggestion
= Some(format
!(
3041 "extern crate {} as {};",
3042 source
.unwrap_or(target
.name
),
3046 _
=> unreachable
!(),
3049 let rename_msg
= "you can use `as` to change the binding name of the import";
3050 if let Some(suggestion
) = suggestion
{
3051 err
.span_suggestion(
3055 Applicability
::MaybeIncorrect
,
3058 err
.span_label(binding_span
, rename_msg
);
3062 /// This function adds a suggestion to remove a unnecessary binding from an import that is
3063 /// nested. In the following example, this function will be invoked to remove the `a` binding
3064 /// in the second use statement:
3066 /// ```ignore (diagnostic)
3067 /// use issue_52891::a;
3068 /// use issue_52891::{d, a, e};
3071 /// The following suggestion will be added:
3073 /// ```ignore (diagnostic)
3074 /// use issue_52891::{d, a, e};
3075 /// ^-- help: remove unnecessary import
3078 /// If the nested use contains only one import then the suggestion will remove the entire
3081 /// It is expected that the provided import is nested - this isn't checked by the
3082 /// function. If this invariant is not upheld, this function's behaviour will be unexpected
3083 /// as characters expected by span manipulations won't be present.
3084 fn add_suggestion_for_duplicate_nested_use(
3086 err
: &mut DiagnosticBuilder
<'_
>,
3087 import
: &Import
<'_
>,
3090 assert
!(import
.is_nested());
3091 let message
= "remove unnecessary import";
3093 // Two examples will be used to illustrate the span manipulations we're doing:
3095 // - Given `use issue_52891::{d, a, e};` where `a` is a duplicate then `binding_span` is
3096 // `a` and `import.use_span` is `issue_52891::{d, a, e};`.
3097 // - Given `use issue_52891::{d, e, a};` where `a` is a duplicate then `binding_span` is
3098 // `a` and `import.use_span` is `issue_52891::{d, e, a};`.
3100 let (found_closing_brace
, span
) =
3101 find_span_of_binding_until_next_binding(self.session
, binding_span
, import
.use_span
);
3103 // If there was a closing brace then identify the span to remove any trailing commas from
3104 // previous imports.
3105 if found_closing_brace
{
3106 if let Some(span
) = extend_span_to_previous_binding(self.session
, span
) {
3107 err
.tool_only_span_suggestion(
3111 Applicability
::MaybeIncorrect
,
3114 // Remove the entire line if we cannot extend the span back, this indicates a
3115 // `issue_52891::{self}` case.
3116 err
.span_suggestion(
3117 import
.use_span_with_attributes
,
3120 Applicability
::MaybeIncorrect
,
3127 err
.span_suggestion(span
, message
, String
::new(), Applicability
::MachineApplicable
);
3130 fn extern_prelude_get(
3134 ) -> Option
<&'a NameBinding
<'a
>> {
3135 if ident
.is_path_segment_keyword() {
3136 // Make sure `self`, `super` etc produce an error when passed to here.
3139 self.extern_prelude
.get(&ident
.normalize_to_macros_2_0()).cloned().and_then(|entry
| {
3140 if let Some(binding
) = entry
.extern_crate_item
{
3141 if !speculative
&& entry
.introduced_by_item
{
3142 self.record_use(ident
, TypeNS
, binding
, false);
3146 let crate_id
= if !speculative
{
3147 self.crate_loader
.process_path_extern(ident
.name
, ident
.span
)
3149 self.crate_loader
.maybe_process_path_extern(ident
.name
)?
3151 let crate_root
= self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX }
);
3153 (crate_root
, ty
::Visibility
::Public
, DUMMY_SP
, ExpnId
::root())
3154 .to_name_binding(self.arenas
),
3160 /// This is equivalent to `get_traits_in_module_containing_item`, but without filtering by the associated item.
3162 /// This is used by rustdoc for intra-doc links.
3163 pub fn traits_in_scope(&mut self, module_id
: DefId
) -> Vec
<TraitCandidate
> {
3164 let module
= self.get_module(module_id
);
3165 module
.ensure_traits(self);
3166 let traits
= module
.traits
.borrow();
3168 |this
: &mut Self, &(trait_name
, binding
): &(Ident
, &NameBinding
<'_
>)| TraitCandidate
{
3169 def_id
: binding
.res().def_id(),
3170 import_ids
: this
.find_transitive_imports(&binding
.kind
, trait_name
),
3173 let mut candidates
: Vec
<_
> =
3174 traits
.as_ref().unwrap().iter().map(|x
| to_candidate(self, x
)).collect();
3176 if let Some(prelude
) = self.prelude
{
3177 if !module
.no_implicit_prelude
{
3178 prelude
.ensure_traits(self);
3180 prelude
.traits
.borrow().as_ref().unwrap().iter().map(|x
| to_candidate(self, x
)),
3188 /// Rustdoc uses this to resolve things in a recoverable way. `ResolutionError<'a>`
3189 /// isn't something that can be returned because it can't be made to live that long,
3190 /// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
3191 /// just that an error occurred.
3192 // FIXME(Manishearth): intra-doc links won't get warned of epoch changes.
3193 pub fn resolve_str_path_error(
3199 ) -> Result
<(ast
::Path
, Res
), ()> {
3200 let path
= if path_str
.starts_with("::") {
3203 segments
: iter
::once(Ident
::with_dummy_span(kw
::PathRoot
))
3204 .chain(path_str
.split("::").skip(1).map(Ident
::from_str
))
3205 .map(|i
| self.new_ast_path_segment(i
))
3214 .map(Ident
::from_str
)
3215 .map(|i
| self.new_ast_path_segment(i
))
3220 let module
= self.get_module(module_id
);
3221 let parent_scope
= &ParentScope
::module(module
);
3222 let res
= self.resolve_ast_path(&path
, ns
, parent_scope
).map_err(|_
| ())?
;
3226 // Resolve a path passed from rustdoc or HIR lowering.
3227 fn resolve_ast_path(
3231 parent_scope
: &ParentScope
<'a
>,
3232 ) -> Result
<Res
, (Span
, ResolutionError
<'a
>)> {
3233 match self.resolve_path(
3234 &Segment
::from_path(path
),
3241 PathResult
::Module(ModuleOrUniformRoot
::Module(module
)) => Ok(module
.res().unwrap()),
3242 PathResult
::NonModule(path_res
) if path_res
.unresolved_segments() == 0 => {
3243 Ok(path_res
.base_res())
3245 PathResult
::NonModule(..) => Err((
3247 ResolutionError
::FailedToResolve
{
3248 label
: String
::from("type-relative paths are not supported in this context"),
3252 PathResult
::Module(..) | PathResult
::Indeterminate
=> unreachable
!(),
3253 PathResult
::Failed { span, label, suggestion, .. }
=> {
3254 Err((span
, ResolutionError
::FailedToResolve { label, suggestion }
))
3259 fn new_ast_path_segment(&mut self, ident
: Ident
) -> ast
::PathSegment
{
3260 let mut seg
= ast
::PathSegment
::from_ident(ident
);
3261 seg
.id
= self.next_node_id();
3266 pub fn graph_root(&self) -> Module
<'a
> {
3271 pub fn all_macros(&self) -> &FxHashMap
<Symbol
, Res
> {
3275 /// Retrieves the span of the given `DefId` if `DefId` is in the local crate.
3277 pub fn opt_span(&self, def_id
: DefId
) -> Option
<Span
> {
3278 if let Some(def_id
) = def_id
.as_local() { Some(self.def_id_to_span[def_id]) }
else { None }
3282 fn names_to_string(names
: &[Symbol
]) -> String
{
3283 let mut result
= String
::new();
3284 for (i
, name
) in names
.iter().filter(|name
| **name
!= kw
::PathRoot
).enumerate() {
3286 result
.push_str("::");
3288 if Ident
::with_dummy_span(*name
).is_raw_guess() {
3289 result
.push_str("r#");
3291 result
.push_str(&name
.as_str());
3296 fn path_names_to_string(path
: &Path
) -> String
{
3297 names_to_string(&path
.segments
.iter().map(|seg
| seg
.ident
.name
).collect
::<Vec
<_
>>())
3300 /// A somewhat inefficient routine to obtain the name of a module.
3301 fn module_to_string(module
: Module
<'_
>) -> Option
<String
> {
3302 let mut names
= Vec
::new();
3304 fn collect_mod(names
: &mut Vec
<Symbol
>, module
: Module
<'_
>) {
3305 if let ModuleKind
::Def(.., name
) = module
.kind
{
3306 if let Some(parent
) = module
.parent
{
3308 collect_mod(names
, parent
);
3311 names
.push(Symbol
::intern("<opaque>"));
3312 collect_mod(names
, module
.parent
.unwrap());
3315 collect_mod(&mut names
, module
);
3317 if names
.is_empty() {
3321 Some(names_to_string(&names
))
3324 #[derive(Copy, Clone, Debug)]
3326 /// Do not issue the lint.
3329 /// This lint applies to some arbitrary path; e.g., `impl ::foo::Bar`.
3330 /// In this case, we can take the span of that path.
3333 /// This lint comes from a `use` statement. In this case, what we
3334 /// care about really is the *root* `use` statement; e.g., if we
3335 /// have nested things like `use a::{b, c}`, we care about the
3337 UsePath { root_id: NodeId, root_span: Span }
,
3339 /// This is the "trait item" from a fully qualified path. For example,
3340 /// we might be resolving `X::Y::Z` from a path like `<T as X::Y>::Z`.
3341 /// The `path_span` is the span of the to the trait itself (`X::Y`).
3342 QPathTrait { qpath_id: NodeId, qpath_span: Span }
,
3346 fn node_id(&self) -> Option
<NodeId
> {
3348 CrateLint
::No
=> None
,
3349 CrateLint
::SimplePath(id
)
3350 | CrateLint
::UsePath { root_id: id, .. }
3351 | CrateLint
::QPathTrait { qpath_id: id, .. }
=> Some(id
),
3356 pub fn provide(providers
: &mut Providers
) {
3357 late
::lifetimes
::provide(providers
);