1 //! This crate is responsible for the part of name resolution that doesn't require type checker.
3 //! Module structure of the crate is built here.
4 //! Paths in macros, imports, expressions, types, patterns are resolved here.
5 //! Label and lifetime names are resolved here as well.
7 //! Type-relative name resolution (methods, fields, associated items) happens in `rustc_typeck`.
9 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
10 #![feature(assert_matches)]
11 #![feature(box_patterns)]
12 #![feature(drain_filter)]
13 #![feature(if_let_guard)]
14 #![feature(iter_intersperse)]
15 #![feature(let_chains)]
16 #![cfg_attr(bootstrap, feature(let_else))]
17 #![feature(never_type)]
18 #![recursion_limit = "256"]
19 #![allow(rustdoc::private_intra_doc_links)]
20 #![allow(rustc::potential_query_instability)]
25 pub use rustc_hir
::def
::{Namespace, PerNS}
;
27 use rustc_arena
::{DroplessArena, TypedArena}
;
28 use rustc_ast
::node_id
::NodeMap
;
29 use rustc_ast
::{self as ast, NodeId, CRATE_NODE_ID}
;
30 use rustc_ast
::{AngleBracketedArg, Crate, Expr, ExprKind, GenericArg, GenericArgs, LitKind, Path}
;
31 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}
;
32 use rustc_data_structures
::intern
::Interned
;
33 use rustc_data_structures
::sync
::Lrc
;
34 use rustc_errors
::{Applicability, DiagnosticBuilder, ErrorGuaranteed}
;
35 use rustc_expand
::base
::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind}
;
36 use rustc_hir
::def
::Namespace
::*;
37 use rustc_hir
::def
::{self, CtorOf, DefKind, LifetimeRes, PartialRes}
;
38 use rustc_hir
::def_id
::{CrateNum, DefId, DefIdMap, LocalDefId}
;
39 use rustc_hir
::def_id
::{CRATE_DEF_ID, LOCAL_CRATE}
;
40 use rustc_hir
::definitions
::{DefPathData, Definitions}
;
41 use rustc_hir
::TraitCandidate
;
42 use rustc_index
::vec
::IndexVec
;
43 use rustc_metadata
::creader
::{CStore, CrateLoader}
;
44 use rustc_middle
::metadata
::ModChild
;
45 use rustc_middle
::middle
::privacy
::AccessLevels
;
46 use rustc_middle
::span_bug
;
47 use rustc_middle
::ty
::query
::Providers
;
48 use rustc_middle
::ty
::{self, DefIdTree, MainDefinition, RegisteredTools, ResolverOutputs}
;
49 use rustc_query_system
::ich
::StableHashingContext
;
50 use rustc_session
::cstore
::{CrateStore, CrateStoreDyn, MetadataLoaderDyn}
;
51 use rustc_session
::lint
::LintBuffer
;
52 use rustc_session
::Session
;
53 use rustc_span
::hygiene
::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency}
;
54 use rustc_span
::source_map
::Spanned
;
55 use rustc_span
::symbol
::{kw, sym, Ident, Symbol}
;
56 use rustc_span
::{Span, DUMMY_SP}
;
58 use smallvec
::{smallvec, SmallVec}
;
59 use std
::cell
::{Cell, RefCell}
;
60 use std
::collections
::BTreeSet
;
63 use diagnostics
::{ImportSuggestion, LabelSuggestion, Suggestion}
;
64 use imports
::{Import, ImportKind, ImportResolver, NameResolution}
;
65 use late
::{HasGenericParams, PathSource, PatternSource}
;
66 use macros
::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef}
;
68 use crate::access_levels
::AccessLevelsVisitor
;
70 type Res
= def
::Res
<NodeId
>;
73 mod build_reduced_graph
;
87 #[derive(Copy, Clone, PartialEq, Debug)]
88 pub enum Determinacy
{
94 fn determined(determined
: bool
) -> Determinacy
{
95 if determined { Determinacy::Determined }
else { Determinacy::Undetermined }
99 /// A specific scope in which a name can be looked up.
100 /// This enum is currently used only for early resolution (imports and macros),
101 /// but not for late resolution yet.
102 #[derive(Clone, Copy)]
104 DeriveHelpers(LocalExpnId
),
106 MacroRules(MacroRulesScopeRef
<'a
>),
108 // The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
109 // lint if it should be reported.
110 Module(Module
<'a
>, Option
<NodeId
>),
119 /// Names from different contexts may want to visit different subsets of all specific scopes
120 /// with different restrictions when looking up the resolution.
121 /// This enum is currently used only for early resolution (imports and macros),
122 /// but not for late resolution yet.
123 #[derive(Clone, Copy)]
125 /// All scopes with the given namespace.
126 All(Namespace
, /*is_import*/ bool
),
127 /// Crate root, then extern prelude (used for mixed 2015-2018 mode in macros).
128 AbsolutePath(Namespace
),
129 /// All scopes with macro namespace and the given macro kind restriction.
131 /// All scopes with the given namespace, used for partially performing late resolution.
132 /// The node id enables lints and is used for reporting them.
133 Late(Namespace
, Module
<'a
>, Option
<NodeId
>),
136 /// Everything you need to know about a name's location to resolve it.
137 /// Serves as a starting point for the scope visitor.
138 /// This struct is currently used only for early resolution (imports and macros),
139 /// but not for late resolution yet.
140 #[derive(Clone, Copy, Debug)]
141 pub struct ParentScope
<'a
> {
142 pub module
: Module
<'a
>,
143 expansion
: LocalExpnId
,
144 pub macro_rules
: MacroRulesScopeRef
<'a
>,
145 derives
: &'a
[ast
::Path
],
148 impl<'a
> ParentScope
<'a
> {
149 /// Creates a parent scope with the passed argument used as the module scope component,
150 /// and other scope components set to default empty values.
151 pub fn module(module
: Module
<'a
>, resolver
: &Resolver
<'a
>) -> ParentScope
<'a
> {
154 expansion
: LocalExpnId
::ROOT
,
155 macro_rules
: resolver
.arenas
.alloc_macro_rules_scope(MacroRulesScope
::Empty
),
161 #[derive(Copy, Debug, Clone)]
162 enum ImplTraitContext
{
164 Universal(LocalDefId
),
167 struct BindingError
{
169 origin
: BTreeSet
<Span
>,
170 target
: BTreeSet
<Span
>,
174 enum ResolutionError
<'a
> {
175 /// Error E0401: can't use type or const parameters from outer function.
176 GenericParamsFromOuterFunction(Res
, HasGenericParams
),
177 /// Error E0403: the name is already used for a type or const parameter in this generic
179 NameAlreadyUsedInParameterList(Symbol
, Span
),
180 /// Error E0407: method is not a member of trait.
181 MethodNotMemberOfTrait(Ident
, String
, Option
<Symbol
>),
182 /// Error E0437: type is not a member of trait.
183 TypeNotMemberOfTrait(Ident
, String
, Option
<Symbol
>),
184 /// Error E0438: const is not a member of trait.
185 ConstNotMemberOfTrait(Ident
, String
, Option
<Symbol
>),
186 /// Error E0408: variable `{}` is not bound in all patterns.
187 VariableNotBoundInPattern(BindingError
, ParentScope
<'a
>),
188 /// Error E0409: variable `{}` is bound in inconsistent ways within the same match arm.
189 VariableBoundWithDifferentMode(Symbol
, Span
),
190 /// Error E0415: identifier is bound more than once in this parameter list.
191 IdentifierBoundMoreThanOnceInParameterList(Symbol
),
192 /// Error E0416: identifier is bound more than once in the same pattern.
193 IdentifierBoundMoreThanOnceInSamePattern(Symbol
),
194 /// Error E0426: use of undeclared label.
195 UndeclaredLabel { name: Symbol, suggestion: Option<LabelSuggestion> }
,
196 /// Error E0429: `self` imports are only allowed within a `{ }` list.
197 SelfImportsOnlyAllowedWithin { root: bool, span_with_rename: Span }
,
198 /// Error E0430: `self` import can only appear once in the list.
199 SelfImportCanOnlyAppearOnceInTheList
,
200 /// Error E0431: `self` import can only appear in an import list with a non-empty prefix.
201 SelfImportOnlyInImportListWithNonEmptyPrefix
,
202 /// Error E0433: failed to resolve.
203 FailedToResolve { label: String, suggestion: Option<Suggestion> }
,
204 /// Error E0434: can't capture dynamic environment in a fn item.
205 CannotCaptureDynamicEnvironmentInFnItem
,
206 /// Error E0435: attempt to use a non-constant value in a constant.
207 AttemptToUseNonConstantValueInConstant(
209 /* suggestion */ &'
static str,
210 /* current */ &'
static str,
212 /// Error E0530: `X` bindings cannot shadow `Y`s.
213 BindingShadowsSomethingUnacceptable
{
214 shadowing_binding
: PatternSource
,
216 participle
: &'
static str,
217 article
: &'
static str,
218 shadowed_binding
: Res
,
219 shadowed_binding_span
: Span
,
221 /// Error E0128: generic parameters with a default cannot use forward-declared identifiers.
222 ForwardDeclaredGenericParam
,
223 /// ERROR E0770: the type of const parameters must not depend on other generic parameters.
224 ParamInTyOfConstParam(Symbol
),
225 /// generic parameters must not be used inside const evaluations.
227 /// This error is only emitted when using `min_const_generics`.
228 ParamInNonTrivialAnonConst { name: Symbol, is_type: bool }
,
229 /// Error E0735: generic parameters with a default cannot use `Self`
230 SelfInGenericParamDefault
,
231 /// Error E0767: use of unreachable label
232 UnreachableLabel { name: Symbol, definition_span: Span, suggestion: Option<LabelSuggestion> }
,
233 /// Error E0323, E0324, E0325: mismatch between trait item and impl item.
238 trait_item_span
: Span
,
239 code
: rustc_errors
::DiagnosticId
,
241 /// Inline asm `sym` operand must refer to a `fn` or `static`.
245 enum VisResolutionError
<'a
> {
246 Relative2018(Span
, &'a ast
::Path
),
248 FailedToResolve(Span
, String
, Option
<Suggestion
>),
249 ExpectedFound(Span
, String
, Res
),
254 /// A minimal representation of a path segment. We use this in resolve because we synthesize 'path
255 /// segments' which don't have the rest of an AST or HIR `PathSegment`.
256 #[derive(Clone, Copy, Debug)]
260 /// Signals whether this `PathSegment` has generic arguments. Used to avoid providing
261 /// nonsensical suggestions.
262 has_generic_args
: bool
,
263 /// Signals whether this `PathSegment` has lifetime arguments.
264 has_lifetime_args
: bool
,
269 fn from_path(path
: &Path
) -> Vec
<Segment
> {
270 path
.segments
.iter().map(|s
| s
.into()).collect()
273 fn from_ident(ident
: Ident
) -> Segment
{
277 has_generic_args
: false,
278 has_lifetime_args
: false,
283 fn from_ident_and_id(ident
: Ident
, id
: NodeId
) -> Segment
{
287 has_generic_args
: false,
288 has_lifetime_args
: false,
293 fn names_to_string(segments
: &[Segment
]) -> String
{
294 names_to_string(&segments
.iter().map(|seg
| seg
.ident
.name
).collect
::<Vec
<_
>>())
298 impl<'a
> From
<&'a ast
::PathSegment
> for Segment
{
299 fn from(seg
: &'a ast
::PathSegment
) -> Segment
{
300 let has_generic_args
= seg
.args
.is_some();
301 let (args_span
, has_lifetime_args
) = if let Some(args
) = seg
.args
.as_deref() {
303 GenericArgs
::AngleBracketed(args
) => {
304 let found_lifetimes
= args
307 .any(|arg
| matches
!(arg
, AngleBracketedArg
::Arg(GenericArg
::Lifetime(_
))));
308 (args
.span
, found_lifetimes
)
310 GenericArgs
::Parenthesized(args
) => (args
.span
, true),
325 /// An intermediate resolution result.
327 /// This refers to the thing referred by a name. The difference between `Res` and `Item` is that
328 /// items are visible in their whole block, while `Res`es only from the place they are defined
331 enum LexicalScopeBinding
<'a
> {
332 Item(&'a NameBinding
<'a
>),
336 impl<'a
> LexicalScopeBinding
<'a
> {
337 fn res(self) -> Res
{
339 LexicalScopeBinding
::Item(binding
) => binding
.res(),
340 LexicalScopeBinding
::Res(res
) => res
,
345 #[derive(Copy, Clone, Debug)]
346 enum ModuleOrUniformRoot
<'a
> {
350 /// Virtual module that denotes resolution in crate root with fallback to extern prelude.
351 CrateRootAndExternPrelude
,
353 /// Virtual module that denotes resolution in extern prelude.
354 /// Used for paths starting with `::` on 2018 edition.
357 /// Virtual module that denotes resolution in current scope.
358 /// Used only for resolving single-segment imports. The reason it exists is that import paths
359 /// are always split into two parts, the first of which should be some kind of module.
363 impl ModuleOrUniformRoot
<'_
> {
364 fn same_def(lhs
: Self, rhs
: Self) -> bool
{
366 (ModuleOrUniformRoot
::Module(lhs
), ModuleOrUniformRoot
::Module(rhs
)) => {
370 ModuleOrUniformRoot
::CrateRootAndExternPrelude
,
371 ModuleOrUniformRoot
::CrateRootAndExternPrelude
,
373 | (ModuleOrUniformRoot
::ExternPrelude
, ModuleOrUniformRoot
::ExternPrelude
)
374 | (ModuleOrUniformRoot
::CurrentScope
, ModuleOrUniformRoot
::CurrentScope
) => true,
380 #[derive(Clone, Debug)]
381 enum PathResult
<'a
> {
382 Module(ModuleOrUniformRoot
<'a
>),
383 NonModule(PartialRes
),
388 suggestion
: Option
<Suggestion
>,
389 is_error_from_last_segment
: bool
,
393 impl<'a
> PathResult
<'a
> {
396 is_error_from_last_segment
: bool
,
398 label_and_suggestion
: impl FnOnce() -> (String
, Option
<Suggestion
>),
399 ) -> PathResult
<'a
> {
400 let (label
, suggestion
) =
401 if finalize { label_and_suggestion() }
else { (String::new(), None) }
;
402 PathResult
::Failed { span, label, suggestion, is_error_from_last_segment }
408 /// An anonymous module; e.g., just a block.
413 /// { // This is an anonymous module
414 /// f(); // This resolves to (2) as we are inside the block.
417 /// f(); // Resolves to (1)
421 /// Any module with a name.
425 /// * A normal module – either `mod from_file;` or `mod from_block { }` –
426 /// or the crate root (which is conceptually a top-level module).
427 /// Note that the crate root's [name][Self::name] will be [`kw::Empty`].
428 /// * A trait or an enum (it implicitly contains associated types, methods and variant
430 Def(DefKind
, DefId
, Symbol
),
434 /// Get name of the module.
435 pub fn name(&self) -> Option
<Symbol
> {
437 ModuleKind
::Block
=> None
,
438 ModuleKind
::Def(.., name
) => Some(*name
),
443 /// A key that identifies a binding in a given `Module`.
445 /// Multiple bindings in the same module can have the same key (in a valid
446 /// program) if all but one of them come from glob imports.
447 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
449 /// The identifier for the binding, always the `normalize_to_macros_2_0` version of the
453 /// 0 if ident is not `_`, otherwise a value that's unique to the specific
454 /// `_` in the expanded AST that introduced this binding.
458 type Resolutions
<'a
> = RefCell
<FxIndexMap
<BindingKey
, &'a RefCell
<NameResolution
<'a
>>>>;
460 /// One node in the tree of modules.
462 /// Note that a "module" in resolve is broader than a `mod` that you declare in Rust code. It may be one of these:
465 /// * crate root (aka, top-level anonymous module)
468 /// * curly-braced block with statements
470 /// You can use [`ModuleData::kind`] to determine the kind of module this is.
471 pub struct ModuleData
<'a
> {
472 /// The direct parent module (it may not be a `mod`, however).
473 parent
: Option
<Module
<'a
>>,
474 /// What kind of module this is, because this may not be a `mod`.
477 /// Mapping between names and their (possibly in-progress) resolutions in this module.
478 /// Resolutions in modules from other crates are not populated until accessed.
479 lazy_resolutions
: Resolutions
<'a
>,
480 /// True if this is a module from other crate that needs to be populated on access.
481 populate_on_access
: Cell
<bool
>,
483 /// Macro invocations that can expand into items in this module.
484 unexpanded_invocations
: RefCell
<FxHashSet
<LocalExpnId
>>,
486 /// Whether `#[no_implicit_prelude]` is active.
487 no_implicit_prelude
: bool
,
489 glob_importers
: RefCell
<Vec
<&'a Import
<'a
>>>,
490 globs
: RefCell
<Vec
<&'a Import
<'a
>>>,
492 /// Used to memoize the traits in this module for faster searches through all traits in scope.
493 traits
: RefCell
<Option
<Box
<[(Ident
, &'a NameBinding
<'a
>)]>>>,
495 /// Span of the module itself. Used for error reporting.
501 type Module
<'a
> = &'a ModuleData
<'a
>;
503 impl<'a
> ModuleData
<'a
> {
505 parent
: Option
<Module
<'a
>>,
509 no_implicit_prelude
: bool
,
511 let is_foreign
= match kind
{
512 ModuleKind
::Def(_
, def_id
, _
) => !def_id
.is_local(),
513 ModuleKind
::Block
=> false,
518 lazy_resolutions
: Default
::default(),
519 populate_on_access
: Cell
::new(is_foreign
),
520 unexpanded_invocations
: Default
::default(),
522 glob_importers
: RefCell
::new(Vec
::new()),
523 globs
: RefCell
::new(Vec
::new()),
524 traits
: RefCell
::new(None
),
530 fn for_each_child
<R
, F
>(&'a
self, resolver
: &mut R
, mut f
: F
)
532 R
: AsMut
<Resolver
<'a
>>,
533 F
: FnMut(&mut R
, Ident
, Namespace
, &'a NameBinding
<'a
>),
535 for (key
, name_resolution
) in resolver
.as_mut().resolutions(self).borrow().iter() {
536 if let Some(binding
) = name_resolution
.borrow().binding
{
537 f(resolver
, key
.ident
, key
.ns
, binding
);
542 /// This modifies `self` in place. The traits will be stored in `self.traits`.
543 fn ensure_traits
<R
>(&'a
self, resolver
: &mut R
)
545 R
: AsMut
<Resolver
<'a
>>,
547 let mut traits
= self.traits
.borrow_mut();
548 if traits
.is_none() {
549 let mut collected_traits
= Vec
::new();
550 self.for_each_child(resolver
, |_
, name
, ns
, binding
| {
554 if let Res
::Def(DefKind
::Trait
| DefKind
::TraitAlias
, _
) = binding
.res() {
555 collected_traits
.push((name
, binding
))
558 *traits
= Some(collected_traits
.into_boxed_slice());
562 fn res(&self) -> Option
<Res
> {
564 ModuleKind
::Def(kind
, def_id
, _
) => Some(Res
::Def(kind
, def_id
)),
569 // Public for rustdoc.
570 pub fn def_id(&self) -> DefId
{
571 self.opt_def_id().expect("`ModuleData::def_id` is called on a block module")
574 fn opt_def_id(&self) -> Option
<DefId
> {
576 ModuleKind
::Def(_
, def_id
, _
) => Some(def_id
),
581 // `self` resolves to the first module ancestor that `is_normal`.
582 fn is_normal(&self) -> bool
{
583 matches
!(self.kind
, ModuleKind
::Def(DefKind
::Mod
, _
, _
))
586 fn is_trait(&self) -> bool
{
587 matches
!(self.kind
, ModuleKind
::Def(DefKind
::Trait
, _
, _
))
590 fn nearest_item_scope(&'a
self) -> Module
<'a
> {
592 ModuleKind
::Def(DefKind
::Enum
| DefKind
::Trait
, ..) => {
593 self.parent
.expect("enum or trait module without a parent")
599 /// The [`DefId`] of the nearest `mod` item ancestor (which may be this module).
600 /// This may be the crate root.
601 fn nearest_parent_mod(&self) -> DefId
{
603 ModuleKind
::Def(DefKind
::Mod
, def_id
, _
) => def_id
,
604 _
=> self.parent
.expect("non-root module without parent").nearest_parent_mod(),
608 fn is_ancestor_of(&self, mut other
: &Self) -> bool
{
609 while !ptr
::eq(self, other
) {
610 if let Some(parent
) = other
.parent
{
620 impl<'a
> fmt
::Debug
for ModuleData
<'a
> {
621 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
622 write
!(f
, "{:?}", self.res())
626 /// Records a possibly-private value, type, or module definition.
627 #[derive(Clone, Debug)]
628 pub struct NameBinding
<'a
> {
629 kind
: NameBindingKind
<'a
>,
630 ambiguity
: Option
<(&'a NameBinding
<'a
>, AmbiguityKind
)>,
631 expansion
: LocalExpnId
,
633 vis
: ty
::Visibility
<DefId
>,
636 pub trait ToNameBinding
<'a
> {
637 fn to_name_binding(self, arenas
: &'a ResolverArenas
<'a
>) -> &'a NameBinding
<'a
>;
640 impl<'a
> ToNameBinding
<'a
> for &'a NameBinding
<'a
> {
641 fn to_name_binding(self, _
: &'a ResolverArenas
<'a
>) -> &'a NameBinding
<'a
> {
646 #[derive(Clone, Debug)]
647 enum NameBindingKind
<'a
> {
648 Res(Res
, /* is_macro_export */ bool
),
650 Import { binding: &'a NameBinding<'a>, import: &'a Import<'a>, used: Cell<bool> }
,
653 impl<'a
> NameBindingKind
<'a
> {
654 /// Is this a name binding of an import?
655 fn is_import(&self) -> bool
{
656 matches
!(*self, NameBindingKind
::Import { .. }
)
660 struct PrivacyError
<'a
> {
662 binding
: &'a NameBinding
<'a
>,
666 struct UseError
<'a
> {
667 err
: DiagnosticBuilder
<'a
, ErrorGuaranteed
>,
668 /// Candidates which user could `use` to access the missing type.
669 candidates
: Vec
<ImportSuggestion
>,
670 /// The `DefId` of the module to place the use-statements in.
672 /// Whether the diagnostic should say "instead" (as in `consider importing ... instead`).
674 /// Extra free-form suggestion.
675 suggestion
: Option
<(Span
, &'
static str, String
, Applicability
)>,
676 /// Path `Segment`s at the place of use that failed. Used for accurate suggestion after telling
677 /// the user to import the item directly.
681 #[derive(Clone, Copy, PartialEq, Debug)]
686 MacroRulesVsModularized
,
694 fn descr(self) -> &'
static str {
696 AmbiguityKind
::Import
=> "multiple potential import sources",
697 AmbiguityKind
::BuiltinAttr
=> "a name conflict with a builtin attribute",
698 AmbiguityKind
::DeriveHelper
=> "a name conflict with a derive helper attribute",
699 AmbiguityKind
::MacroRulesVsModularized
=> {
700 "a conflict between a `macro_rules` name and a non-`macro_rules` name from another module"
702 AmbiguityKind
::GlobVsOuter
=> {
703 "a conflict between a name from a glob import and an outer scope during import or macro resolution"
705 AmbiguityKind
::GlobVsGlob
=> "multiple glob imports of a name in the same module",
706 AmbiguityKind
::GlobVsExpanded
=> {
707 "a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution"
709 AmbiguityKind
::MoreExpandedVsOuter
=> {
710 "a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution"
716 /// Miscellaneous bits of metadata for better ambiguity error reporting.
717 #[derive(Clone, Copy, PartialEq)]
718 enum AmbiguityErrorMisc
{
725 struct AmbiguityError
<'a
> {
728 b1
: &'a NameBinding
<'a
>,
729 b2
: &'a NameBinding
<'a
>,
730 misc1
: AmbiguityErrorMisc
,
731 misc2
: AmbiguityErrorMisc
,
734 impl<'a
> NameBinding
<'a
> {
735 fn module(&self) -> Option
<Module
<'a
>> {
737 NameBindingKind
::Module(module
) => Some(module
),
738 NameBindingKind
::Import { binding, .. }
=> binding
.module(),
743 fn res(&self) -> Res
{
745 NameBindingKind
::Res(res
, _
) => res
,
746 NameBindingKind
::Module(module
) => module
.res().unwrap(),
747 NameBindingKind
::Import { binding, .. }
=> binding
.res(),
751 fn is_ambiguity(&self) -> bool
{
752 self.ambiguity
.is_some()
754 NameBindingKind
::Import { binding, .. }
=> binding
.is_ambiguity(),
759 fn is_possibly_imported_variant(&self) -> bool
{
761 NameBindingKind
::Import { binding, .. }
=> binding
.is_possibly_imported_variant(),
762 NameBindingKind
::Res(
763 Res
::Def(DefKind
::Variant
| DefKind
::Ctor(CtorOf
::Variant
, ..), _
),
766 NameBindingKind
::Res(..) | NameBindingKind
::Module(..) => false,
770 fn is_extern_crate(&self) -> bool
{
772 NameBindingKind
::Import
{
773 import
: &Import { kind: ImportKind::ExternCrate { .. }
, .. },
776 NameBindingKind
::Module(&ModuleData
{
777 kind
: ModuleKind
::Def(DefKind
::Mod
, def_id
, _
),
779 }) => def_id
.is_crate_root(),
784 fn is_import(&self) -> bool
{
785 matches
!(self.kind
, NameBindingKind
::Import { .. }
)
788 fn is_glob_import(&self) -> bool
{
790 NameBindingKind
::Import { import, .. }
=> import
.is_glob(),
795 fn is_importable(&self) -> bool
{
798 Res
::Def(DefKind
::AssocConst
| DefKind
::AssocFn
| DefKind
::AssocTy
, _
)
802 fn macro_kind(&self) -> Option
<MacroKind
> {
803 self.res().macro_kind()
806 // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
807 // at some expansion round `max(invoc, binding)` when they both emerged from macros.
808 // Then this function returns `true` if `self` may emerge from a macro *after* that
809 // in some later round and screw up our previously found resolution.
810 // See more detailed explanation in
811 // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
814 invoc_parent_expansion
: LocalExpnId
,
815 binding
: &NameBinding
<'_
>,
817 // self > max(invoc, binding) => !(self <= invoc || self <= binding)
818 // Expansions are partially ordered, so "may appear after" is an inversion of
819 // "certainly appears before or simultaneously" and includes unordered cases.
820 let self_parent_expansion
= self.expansion
;
821 let other_parent_expansion
= binding
.expansion
;
822 let certainly_before_other_or_simultaneously
=
823 other_parent_expansion
.is_descendant_of(self_parent_expansion
);
824 let certainly_before_invoc_or_simultaneously
=
825 invoc_parent_expansion
.is_descendant_of(self_parent_expansion
);
826 !(certainly_before_other_or_simultaneously
|| certainly_before_invoc_or_simultaneously
)
830 #[derive(Default, Clone)]
831 pub struct ExternPreludeEntry
<'a
> {
832 extern_crate_item
: Option
<&'a NameBinding
<'a
>>,
833 pub introduced_by_item
: bool
,
836 /// Used for better errors for E0773
837 enum BuiltinMacroState
{
838 NotYetSeen(SyntaxExtensionKind
),
843 resolutions
: DeriveResolutions
,
844 helper_attrs
: Vec
<(usize, Ident
)>,
845 has_derive_copy
: bool
,
850 ext
: Lrc
<SyntaxExtension
>,
854 /// The main resolver class.
856 /// This is the visitor that walks the whole crate.
857 pub struct Resolver
<'a
> {
858 session
: &'a Session
,
860 definitions
: Definitions
,
861 /// Item with a given `LocalDefId` was defined during macro expansion with ID `ExpnId`.
862 expn_that_defined
: FxHashMap
<LocalDefId
, ExpnId
>,
863 /// Reference span for definitions.
864 source_span
: IndexVec
<LocalDefId
, Span
>,
866 graph_root
: Module
<'a
>,
868 prelude
: Option
<Module
<'a
>>,
869 extern_prelude
: FxHashMap
<Ident
, ExternPreludeEntry
<'a
>>,
871 /// N.B., this is used only for better diagnostics, not name resolution itself.
872 has_self
: FxHashSet
<DefId
>,
874 /// Names of fields of an item `DefId` accessible with dot syntax.
875 /// Used for hints during error reporting.
876 field_names
: FxHashMap
<DefId
, Vec
<Spanned
<Symbol
>>>,
878 /// All imports known to succeed or fail.
879 determined_imports
: Vec
<&'a Import
<'a
>>,
881 /// All non-determined imports.
882 indeterminate_imports
: Vec
<&'a Import
<'a
>>,
884 // Spans for local variables found during pattern resolution.
885 // Used for suggestions during error reporting.
886 pat_span_map
: NodeMap
<Span
>,
888 /// Resolutions for nodes that have a single resolution.
889 partial_res_map
: NodeMap
<PartialRes
>,
890 /// Resolutions for import nodes, which have multiple resolutions in different namespaces.
891 import_res_map
: NodeMap
<PerNS
<Option
<Res
>>>,
892 /// Resolutions for labels (node IDs of their corresponding blocks or loops).
893 label_res_map
: NodeMap
<NodeId
>,
894 /// Resolutions for lifetimes.
895 lifetimes_res_map
: NodeMap
<LifetimeRes
>,
896 /// Lifetime parameters that lowering will have to introduce.
897 extra_lifetime_params_map
: NodeMap
<Vec
<(Ident
, NodeId
, LifetimeRes
)>>,
899 /// `CrateNum` resolutions of `extern crate` items.
900 extern_crate_map
: FxHashMap
<LocalDefId
, CrateNum
>,
901 reexport_map
: FxHashMap
<LocalDefId
, Vec
<ModChild
>>,
902 trait_map
: NodeMap
<Vec
<TraitCandidate
>>,
904 /// A map from nodes to anonymous modules.
905 /// Anonymous modules are pseudo-modules that are implicitly created around items
906 /// contained within blocks.
908 /// For example, if we have this:
916 /// There will be an anonymous module created around `g` with the ID of the
917 /// entry block for `f`.
918 block_map
: NodeMap
<Module
<'a
>>,
919 /// A fake module that contains no definition and no prelude. Used so that
920 /// some AST passes can generate identifiers that only resolve to local or
922 empty_module
: Module
<'a
>,
923 module_map
: FxHashMap
<DefId
, Module
<'a
>>,
924 binding_parent_modules
: FxHashMap
<Interned
<'a
, NameBinding
<'a
>>, Module
<'a
>>,
925 underscore_disambiguator
: u32,
927 /// Maps glob imports to the names of items actually imported.
928 glob_map
: FxHashMap
<LocalDefId
, FxHashSet
<Symbol
>>,
929 /// Visibilities in "lowered" form, for all entities that have them.
930 visibilities
: FxHashMap
<LocalDefId
, ty
::Visibility
>,
931 has_pub_restricted
: bool
,
932 used_imports
: FxHashSet
<NodeId
>,
933 maybe_unused_trait_imports
: FxIndexSet
<LocalDefId
>,
934 maybe_unused_extern_crates
: Vec
<(LocalDefId
, Span
)>,
936 /// Privacy errors are delayed until the end in order to deduplicate them.
937 privacy_errors
: Vec
<PrivacyError
<'a
>>,
938 /// Ambiguity errors are delayed for deduplication.
939 ambiguity_errors
: Vec
<AmbiguityError
<'a
>>,
940 /// `use` injections are delayed for better placement and deduplication.
941 use_injections
: Vec
<UseError
<'a
>>,
942 /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
943 macro_expanded_macro_export_errors
: BTreeSet
<(Span
, Span
)>,
945 arenas
: &'a ResolverArenas
<'a
>,
946 dummy_binding
: &'a NameBinding
<'a
>,
948 crate_loader
: CrateLoader
<'a
>,
949 macro_names
: FxHashSet
<Ident
>,
950 builtin_macros
: FxHashMap
<Symbol
, BuiltinMacroState
>,
951 /// A small map keeping true kinds of built-in macros that appear to be fn-like on
952 /// the surface (`macro` items in libcore), but are actually attributes or derives.
953 builtin_macro_kinds
: FxHashMap
<LocalDefId
, MacroKind
>,
954 registered_tools
: RegisteredTools
,
955 macro_use_prelude
: FxHashMap
<Symbol
, &'a NameBinding
<'a
>>,
956 macro_map
: FxHashMap
<DefId
, MacroData
>,
957 dummy_ext_bang
: Lrc
<SyntaxExtension
>,
958 dummy_ext_derive
: Lrc
<SyntaxExtension
>,
959 non_macro_attr
: Lrc
<SyntaxExtension
>,
960 local_macro_def_scopes
: FxHashMap
<LocalDefId
, Module
<'a
>>,
961 ast_transform_scopes
: FxHashMap
<LocalExpnId
, Module
<'a
>>,
962 unused_macros
: FxHashMap
<LocalDefId
, (NodeId
, Ident
)>,
963 unused_macro_rules
: FxHashMap
<(LocalDefId
, usize), (Ident
, Span
)>,
964 proc_macro_stubs
: FxHashSet
<LocalDefId
>,
965 /// Traces collected during macro resolution and validated when it's complete.
966 single_segment_macro_resolutions
:
967 Vec
<(Ident
, MacroKind
, ParentScope
<'a
>, Option
<&'a NameBinding
<'a
>>)>,
968 multi_segment_macro_resolutions
:
969 Vec
<(Vec
<Segment
>, Span
, MacroKind
, ParentScope
<'a
>, Option
<Res
>)>,
970 builtin_attrs
: Vec
<(Ident
, ParentScope
<'a
>)>,
971 /// `derive(Copy)` marks items they are applied to so they are treated specially later.
972 /// Derive macros cannot modify the item themselves and have to store the markers in the global
973 /// context, so they attach the markers to derive container IDs using this resolver table.
974 containers_deriving_copy
: FxHashSet
<LocalExpnId
>,
975 /// Parent scopes in which the macros were invoked.
976 /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
977 invocation_parent_scopes
: FxHashMap
<LocalExpnId
, ParentScope
<'a
>>,
978 /// `macro_rules` scopes *produced* by expanding the macro invocations,
979 /// include all the `macro_rules` items and other invocations generated by them.
980 output_macro_rules_scopes
: FxHashMap
<LocalExpnId
, MacroRulesScopeRef
<'a
>>,
981 /// `macro_rules` scopes produced by `macro_rules` item definitions.
982 macro_rules_scopes
: FxHashMap
<LocalDefId
, MacroRulesScopeRef
<'a
>>,
983 /// Helper attributes that are in scope for the given expansion.
984 helper_attrs
: FxHashMap
<LocalExpnId
, Vec
<Ident
>>,
985 /// Ready or in-progress results of resolving paths inside the `#[derive(...)]` attribute
986 /// with the given `ExpnId`.
987 derive_data
: FxHashMap
<LocalExpnId
, DeriveData
>,
989 /// Avoid duplicated errors for "name already defined".
990 name_already_seen
: FxHashMap
<Symbol
, Span
>,
992 potentially_unused_imports
: Vec
<&'a Import
<'a
>>,
994 /// Table for mapping struct IDs into struct constructor IDs,
995 /// it's not used during normal resolution, only for better error reporting.
996 /// Also includes of list of each fields visibility
997 struct_constructors
: DefIdMap
<(Res
, ty
::Visibility
<DefId
>, Vec
<ty
::Visibility
<DefId
>>)>,
999 /// Features enabled for this crate.
1000 active_features
: FxHashSet
<Symbol
>,
1002 lint_buffer
: LintBuffer
,
1004 next_node_id
: NodeId
,
1006 node_id_to_def_id
: FxHashMap
<ast
::NodeId
, LocalDefId
>,
1007 def_id_to_node_id
: IndexVec
<LocalDefId
, ast
::NodeId
>,
1009 /// Indices of unnamed struct or variant fields with unresolved attributes.
1010 placeholder_field_indices
: FxHashMap
<NodeId
, usize>,
1011 /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
1012 /// we know what parent node that fragment should be attached to thanks to this table,
1013 /// and how the `impl Trait` fragments were introduced.
1014 invocation_parents
: FxHashMap
<LocalExpnId
, (LocalDefId
, ImplTraitContext
)>,
1016 /// Some way to know that we are in a *trait* impl in `visit_assoc_item`.
1017 /// FIXME: Replace with a more general AST map (together with some other fields).
1018 trait_impl_items
: FxHashSet
<LocalDefId
>,
1020 legacy_const_generic_args
: FxHashMap
<DefId
, Option
<Vec
<usize>>>,
1021 /// Amount of lifetime parameters for each item in the crate.
1022 item_generics_num_lifetimes
: FxHashMap
<LocalDefId
, usize>,
1024 main_def
: Option
<MainDefinition
>,
1025 trait_impls
: FxIndexMap
<DefId
, Vec
<LocalDefId
>>,
1026 /// A list of proc macro LocalDefIds, written out in the order in which
1027 /// they are declared in the static array generated by proc_macro_harness.
1028 proc_macros
: Vec
<NodeId
>,
1029 confused_type_with_std_module
: FxHashMap
<Span
, Span
>,
1031 access_levels
: AccessLevels
,
1034 /// Nothing really interesting here; it just provides memory for the rest of the crate.
1036 pub struct ResolverArenas
<'a
> {
1037 modules
: TypedArena
<ModuleData
<'a
>>,
1038 local_modules
: RefCell
<Vec
<Module
<'a
>>>,
1039 imports
: TypedArena
<Import
<'a
>>,
1040 name_resolutions
: TypedArena
<RefCell
<NameResolution
<'a
>>>,
1041 ast_paths
: TypedArena
<ast
::Path
>,
1042 dropless
: DroplessArena
,
1045 impl<'a
> ResolverArenas
<'a
> {
1048 parent
: Option
<Module
<'a
>>,
1052 no_implicit_prelude
: bool
,
1053 module_map
: &mut FxHashMap
<DefId
, Module
<'a
>>,
1056 self.modules
.alloc(ModuleData
::new(parent
, kind
, expn_id
, span
, no_implicit_prelude
));
1057 let def_id
= module
.opt_def_id();
1058 if def_id
.map_or(true, |def_id
| def_id
.is_local()) {
1059 self.local_modules
.borrow_mut().push(module
);
1061 if let Some(def_id
) = def_id
{
1062 module_map
.insert(def_id
, module
);
1066 fn local_modules(&'a
self) -> std
::cell
::Ref
<'a
, Vec
<Module
<'a
>>> {
1067 self.local_modules
.borrow()
1069 fn alloc_name_binding(&'a
self, name_binding
: NameBinding
<'a
>) -> &'a NameBinding
<'a
> {
1070 self.dropless
.alloc(name_binding
)
1072 fn alloc_import(&'a
self, import
: Import
<'a
>) -> &'a Import
<'_
> {
1073 self.imports
.alloc(import
)
1075 fn alloc_name_resolution(&'a
self) -> &'a RefCell
<NameResolution
<'a
>> {
1076 self.name_resolutions
.alloc(Default
::default())
1078 fn alloc_macro_rules_scope(&'a
self, scope
: MacroRulesScope
<'a
>) -> MacroRulesScopeRef
<'a
> {
1079 Interned
::new_unchecked(self.dropless
.alloc(Cell
::new(scope
)))
1081 fn alloc_macro_rules_binding(
1083 binding
: MacroRulesBinding
<'a
>,
1084 ) -> &'a MacroRulesBinding
<'a
> {
1085 self.dropless
.alloc(binding
)
1087 fn alloc_ast_paths(&'a
self, paths
: &[ast
::Path
]) -> &'a
[ast
::Path
] {
1088 self.ast_paths
.alloc_from_iter(paths
.iter().cloned())
1090 fn alloc_pattern_spans(&'a
self, spans
: impl Iterator
<Item
= Span
>) -> &'a
[Span
] {
1091 self.dropless
.alloc_from_iter(spans
)
1095 impl<'a
> AsMut
<Resolver
<'a
>> for Resolver
<'a
> {
1096 fn as_mut(&mut self) -> &mut Resolver
<'a
> {
1101 impl<'a
, 'b
> DefIdTree
for &'a Resolver
<'b
> {
1103 fn opt_parent(self, id
: DefId
) -> Option
<DefId
> {
1104 match id
.as_local() {
1105 Some(id
) => self.definitions
.def_key(id
).parent
,
1106 None
=> self.cstore().def_key(id
).parent
,
1108 .map(|index
| DefId { index, ..id }
)
1113 fn opt_local_def_id(&self, node
: NodeId
) -> Option
<LocalDefId
> {
1114 self.node_id_to_def_id
.get(&node
).copied()
1117 pub fn local_def_id(&self, node
: NodeId
) -> LocalDefId
{
1118 self.opt_local_def_id(node
).unwrap_or_else(|| panic
!("no entry for node id: `{:?}`", node
))
1121 /// Adds a definition with a parent definition.
1125 node_id
: ast
::NodeId
,
1131 !self.node_id_to_def_id
.contains_key(&node_id
),
1132 "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
1135 self.definitions
.def_key(self.node_id_to_def_id
[&node_id
]),
1138 let def_id
= self.definitions
.create_def(parent
, data
);
1140 // Create the definition.
1141 if expn_id
!= ExpnId
::root() {
1142 self.expn_that_defined
.insert(def_id
, expn_id
);
1145 // A relative span's parent must be an absolute span.
1146 debug_assert_eq
!(span
.data_untracked().parent
, None
);
1147 let _id
= self.source_span
.push(span
);
1148 debug_assert_eq
!(_id
, def_id
);
1150 // Some things for which we allocate `LocalDefId`s don't correspond to
1151 // anything in the AST, so they don't have a `NodeId`. For these cases
1152 // we don't need a mapping from `NodeId` to `LocalDefId`.
1153 if node_id
!= ast
::DUMMY_NODE_ID
{
1154 debug
!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id
, node_id
);
1155 self.node_id_to_def_id
.insert(node_id
, def_id
);
1157 assert_eq
!(self.def_id_to_node_id
.push(node_id
), def_id
);
1162 fn item_generics_num_lifetimes(&self, def_id
: DefId
) -> usize {
1163 if let Some(def_id
) = def_id
.as_local() {
1164 self.item_generics_num_lifetimes
[&def_id
]
1166 self.cstore().item_generics_num_lifetimes(def_id
, self.session
)
1171 impl<'a
> Resolver
<'a
> {
1173 session
: &'a Session
,
1176 metadata_loader
: Box
<MetadataLoaderDyn
>,
1177 arenas
: &'a ResolverArenas
<'a
>,
1179 let root_def_id
= CRATE_DEF_ID
.to_def_id();
1180 let mut module_map
= FxHashMap
::default();
1181 let graph_root
= arenas
.new_module(
1183 ModuleKind
::Def(DefKind
::Mod
, root_def_id
, kw
::Empty
),
1185 krate
.spans
.inner_span
,
1186 session
.contains_name(&krate
.attrs
, sym
::no_implicit_prelude
),
1189 let empty_module
= arenas
.new_module(
1191 ModuleKind
::Def(DefKind
::Mod
, root_def_id
, kw
::Empty
),
1195 &mut FxHashMap
::default(),
1198 let definitions
= Definitions
::new(session
.local_stable_crate_id());
1200 let mut visibilities
= FxHashMap
::default();
1201 visibilities
.insert(CRATE_DEF_ID
, ty
::Visibility
::Public
);
1203 let mut def_id_to_node_id
= IndexVec
::default();
1204 assert_eq
!(def_id_to_node_id
.push(CRATE_NODE_ID
), CRATE_DEF_ID
);
1205 let mut node_id_to_def_id
= FxHashMap
::default();
1206 node_id_to_def_id
.insert(CRATE_NODE_ID
, CRATE_DEF_ID
);
1208 let mut invocation_parents
= FxHashMap
::default();
1209 invocation_parents
.insert(LocalExpnId
::ROOT
, (CRATE_DEF_ID
, ImplTraitContext
::Existential
));
1211 let mut source_span
= IndexVec
::default();
1212 let _id
= source_span
.push(krate
.spans
.inner_span
);
1213 debug_assert_eq
!(_id
, CRATE_DEF_ID
);
1215 let mut extern_prelude
: FxHashMap
<Ident
, ExternPreludeEntry
<'_
>> = session
1219 .filter(|(_
, entry
)| entry
.add_prelude
)
1220 .map(|(name
, _
)| (Ident
::from_str(name
), Default
::default()))
1223 if !session
.contains_name(&krate
.attrs
, sym
::no_core
) {
1224 extern_prelude
.insert(Ident
::with_dummy_span(sym
::core
), Default
::default());
1225 if !session
.contains_name(&krate
.attrs
, sym
::no_std
) {
1226 extern_prelude
.insert(Ident
::with_dummy_span(sym
::std
), Default
::default());
1230 let registered_tools
= macros
::registered_tools(session
, &krate
.attrs
);
1232 let features
= session
.features_untracked();
1234 let mut resolver
= Resolver
{
1238 expn_that_defined
: Default
::default(),
1241 // The outermost module has def ID 0; this is not reflected in the
1247 has_self
: FxHashSet
::default(),
1248 field_names
: FxHashMap
::default(),
1250 determined_imports
: Vec
::new(),
1251 indeterminate_imports
: Vec
::new(),
1253 pat_span_map
: Default
::default(),
1254 partial_res_map
: Default
::default(),
1255 import_res_map
: Default
::default(),
1256 label_res_map
: Default
::default(),
1257 lifetimes_res_map
: Default
::default(),
1258 extra_lifetime_params_map
: Default
::default(),
1259 extern_crate_map
: Default
::default(),
1260 reexport_map
: FxHashMap
::default(),
1261 trait_map
: NodeMap
::default(),
1262 underscore_disambiguator
: 0,
1265 block_map
: Default
::default(),
1266 binding_parent_modules
: FxHashMap
::default(),
1267 ast_transform_scopes
: FxHashMap
::default(),
1269 glob_map
: Default
::default(),
1271 has_pub_restricted
: false,
1272 used_imports
: FxHashSet
::default(),
1273 maybe_unused_trait_imports
: Default
::default(),
1274 maybe_unused_extern_crates
: Vec
::new(),
1276 privacy_errors
: Vec
::new(),
1277 ambiguity_errors
: Vec
::new(),
1278 use_injections
: Vec
::new(),
1279 macro_expanded_macro_export_errors
: BTreeSet
::new(),
1282 dummy_binding
: arenas
.alloc_name_binding(NameBinding
{
1283 kind
: NameBindingKind
::Res(Res
::Err
, false),
1285 expansion
: LocalExpnId
::ROOT
,
1287 vis
: ty
::Visibility
::Public
,
1290 crate_loader
: CrateLoader
::new(session
, metadata_loader
, crate_name
),
1291 macro_names
: FxHashSet
::default(),
1292 builtin_macros
: Default
::default(),
1293 builtin_macro_kinds
: Default
::default(),
1295 macro_use_prelude
: FxHashMap
::default(),
1296 macro_map
: FxHashMap
::default(),
1297 dummy_ext_bang
: Lrc
::new(SyntaxExtension
::dummy_bang(session
.edition())),
1298 dummy_ext_derive
: Lrc
::new(SyntaxExtension
::dummy_derive(session
.edition())),
1299 non_macro_attr
: Lrc
::new(SyntaxExtension
::non_macro_attr(session
.edition())),
1300 invocation_parent_scopes
: Default
::default(),
1301 output_macro_rules_scopes
: Default
::default(),
1302 macro_rules_scopes
: Default
::default(),
1303 helper_attrs
: Default
::default(),
1304 derive_data
: Default
::default(),
1305 local_macro_def_scopes
: FxHashMap
::default(),
1306 name_already_seen
: FxHashMap
::default(),
1307 potentially_unused_imports
: Vec
::new(),
1308 struct_constructors
: Default
::default(),
1309 unused_macros
: Default
::default(),
1310 unused_macro_rules
: Default
::default(),
1311 proc_macro_stubs
: Default
::default(),
1312 single_segment_macro_resolutions
: Default
::default(),
1313 multi_segment_macro_resolutions
: Default
::default(),
1314 builtin_attrs
: Default
::default(),
1315 containers_deriving_copy
: Default
::default(),
1316 active_features
: features
1317 .declared_lib_features
1319 .map(|(feat
, ..)| *feat
)
1320 .chain(features
.declared_lang_features
.iter().map(|(feat
, ..)| *feat
))
1322 lint_buffer
: LintBuffer
::default(),
1323 next_node_id
: CRATE_NODE_ID
,
1326 placeholder_field_indices
: Default
::default(),
1328 trait_impl_items
: Default
::default(),
1329 legacy_const_generic_args
: Default
::default(),
1330 item_generics_num_lifetimes
: Default
::default(),
1331 main_def
: Default
::default(),
1332 trait_impls
: Default
::default(),
1333 proc_macros
: Default
::default(),
1334 confused_type_with_std_module
: Default
::default(),
1335 access_levels
: Default
::default(),
1338 let root_parent_scope
= ParentScope
::module(graph_root
, &resolver
);
1339 resolver
.invocation_parent_scopes
.insert(LocalExpnId
::ROOT
, root_parent_scope
);
1346 parent
: Option
<Module
<'a
>>,
1350 no_implicit_prelude
: bool
,
1352 let module_map
= &mut self.module_map
;
1353 self.arenas
.new_module(parent
, kind
, expn_id
, span
, no_implicit_prelude
, module_map
)
1356 pub fn next_node_id(&mut self) -> NodeId
{
1357 let start
= self.next_node_id
;
1358 let next
= start
.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
1359 self.next_node_id
= ast
::NodeId
::from_u32(next
);
1363 pub fn next_node_ids(&mut self, count
: usize) -> std
::ops
::Range
<NodeId
> {
1364 let start
= self.next_node_id
;
1365 let end
= start
.as_usize().checked_add(count
).expect("input too large; ran out of NodeIds");
1366 self.next_node_id
= ast
::NodeId
::from_usize(end
);
1367 start
..self.next_node_id
1370 pub fn lint_buffer(&mut self) -> &mut LintBuffer
{
1371 &mut self.lint_buffer
1374 pub fn arenas() -> ResolverArenas
<'a
> {
1378 pub fn into_outputs(
1380 ) -> (Definitions
, Box
<CrateStoreDyn
>, ResolverOutputs
, ty
::ResolverAstLowering
) {
1381 let proc_macros
= self.proc_macros
.iter().map(|id
| self.local_def_id(*id
)).collect();
1382 let definitions
= self.definitions
;
1383 let cstore
= Box
::new(self.crate_loader
.into_cstore());
1384 let source_span
= self.source_span
;
1385 let expn_that_defined
= self.expn_that_defined
;
1386 let visibilities
= self.visibilities
;
1387 let has_pub_restricted
= self.has_pub_restricted
;
1388 let extern_crate_map
= self.extern_crate_map
;
1389 let reexport_map
= self.reexport_map
;
1390 let maybe_unused_trait_imports
= self.maybe_unused_trait_imports
;
1391 let maybe_unused_extern_crates
= self.maybe_unused_extern_crates
;
1392 let glob_map
= self.glob_map
;
1393 let main_def
= self.main_def
;
1394 let confused_type_with_std_module
= self.confused_type_with_std_module
;
1395 let access_levels
= self.access_levels
;
1396 let resolutions
= ResolverOutputs
{
1405 maybe_unused_trait_imports
,
1406 maybe_unused_extern_crates
,
1407 extern_prelude
: self
1410 .map(|(ident
, entry
)| (ident
.name
, entry
.introduced_by_item
))
1413 trait_impls
: self.trait_impls
,
1415 confused_type_with_std_module
,
1416 registered_tools
: self.registered_tools
,
1418 let resolutions_lowering
= ty
::ResolverAstLowering
{
1419 legacy_const_generic_args
: self.legacy_const_generic_args
,
1420 partial_res_map
: self.partial_res_map
,
1421 import_res_map
: self.import_res_map
,
1422 label_res_map
: self.label_res_map
,
1423 lifetimes_res_map
: self.lifetimes_res_map
,
1424 extra_lifetime_params_map
: self.extra_lifetime_params_map
,
1425 next_node_id
: self.next_node_id
,
1426 node_id_to_def_id
: self.node_id_to_def_id
,
1427 def_id_to_node_id
: self.def_id_to_node_id
,
1428 trait_map
: self.trait_map
,
1429 builtin_macro_kinds
: self.builtin_macro_kinds
,
1431 (definitions
, cstore
, resolutions
, resolutions_lowering
)
1434 pub fn clone_outputs(
1436 ) -> (Definitions
, Box
<CrateStoreDyn
>, ResolverOutputs
, ty
::ResolverAstLowering
) {
1437 let proc_macros
= self.proc_macros
.iter().map(|id
| self.local_def_id(*id
)).collect();
1438 let definitions
= self.definitions
.clone();
1439 let cstore
= Box
::new(self.cstore().clone());
1440 let resolutions
= ResolverOutputs
{
1441 source_span
: self.source_span
.clone(),
1442 expn_that_defined
: self.expn_that_defined
.clone(),
1443 visibilities
: self.visibilities
.clone(),
1444 has_pub_restricted
: self.has_pub_restricted
,
1445 extern_crate_map
: self.extern_crate_map
.clone(),
1446 reexport_map
: self.reexport_map
.clone(),
1447 glob_map
: self.glob_map
.clone(),
1448 maybe_unused_trait_imports
: self.maybe_unused_trait_imports
.clone(),
1449 maybe_unused_extern_crates
: self.maybe_unused_extern_crates
.clone(),
1450 extern_prelude
: self
1453 .map(|(ident
, entry
)| (ident
.name
, entry
.introduced_by_item
))
1455 main_def
: self.main_def
,
1456 trait_impls
: self.trait_impls
.clone(),
1458 confused_type_with_std_module
: self.confused_type_with_std_module
.clone(),
1459 registered_tools
: self.registered_tools
.clone(),
1460 access_levels
: self.access_levels
.clone(),
1462 let resolutions_lowering
= ty
::ResolverAstLowering
{
1463 legacy_const_generic_args
: self.legacy_const_generic_args
.clone(),
1464 partial_res_map
: self.partial_res_map
.clone(),
1465 import_res_map
: self.import_res_map
.clone(),
1466 label_res_map
: self.label_res_map
.clone(),
1467 lifetimes_res_map
: self.lifetimes_res_map
.clone(),
1468 extra_lifetime_params_map
: self.extra_lifetime_params_map
.clone(),
1469 next_node_id
: self.next_node_id
.clone(),
1470 node_id_to_def_id
: self.node_id_to_def_id
.clone(),
1471 def_id_to_node_id
: self.def_id_to_node_id
.clone(),
1472 trait_map
: self.trait_map
.clone(),
1473 builtin_macro_kinds
: self.builtin_macro_kinds
.clone(),
1475 (definitions
, cstore
, resolutions
, resolutions_lowering
)
1478 fn create_stable_hashing_context(&self) -> StableHashingContext
<'_
> {
1479 StableHashingContext
::new(
1482 self.crate_loader
.cstore(),
1487 pub fn cstore(&self) -> &CStore
{
1488 self.crate_loader
.cstore()
1491 fn dummy_ext(&self, macro_kind
: MacroKind
) -> Lrc
<SyntaxExtension
> {
1493 MacroKind
::Bang
=> self.dummy_ext_bang
.clone(),
1494 MacroKind
::Derive
=> self.dummy_ext_derive
.clone(),
1495 MacroKind
::Attr
=> self.non_macro_attr
.clone(),
1499 /// Runs the function on each namespace.
1500 fn per_ns
<F
: FnMut(&mut Self, Namespace
)>(&mut self, mut f
: F
) {
1506 fn is_builtin_macro(&mut self, res
: Res
) -> bool
{
1507 self.get_macro(res
).map_or(false, |macro_data
| macro_data
.ext
.builtin_name
.is_some())
1510 fn macro_def(&self, mut ctxt
: SyntaxContext
) -> DefId
{
1512 match ctxt
.outer_expn_data().macro_def_id
{
1513 Some(def_id
) => return def_id
,
1514 None
=> ctxt
.remove_mark(),
1519 /// Entry point to crate resolution.
1520 pub fn resolve_crate(&mut self, krate
: &Crate
) {
1521 self.session
.time("resolve_crate", || {
1522 self.session
.time("finalize_imports", || ImportResolver { r: self }
.finalize_imports());
1523 self.session
.time("resolve_access_levels", || {
1524 AccessLevelsVisitor
::compute_access_levels(self, krate
)
1526 self.session
.time("finalize_macro_resolutions", || self.finalize_macro_resolutions());
1527 self.session
.time("late_resolve_crate", || self.late_resolve_crate(krate
));
1528 self.session
.time("resolve_main", || self.resolve_main());
1529 self.session
.time("resolve_check_unused", || self.check_unused(krate
));
1530 self.session
.time("resolve_report_errors", || self.report_errors(krate
));
1531 self.session
.time("resolve_postprocess", || self.crate_loader
.postprocess(krate
));
1535 pub fn traits_in_scope(
1537 current_trait
: Option
<Module
<'a
>>,
1538 parent_scope
: &ParentScope
<'a
>,
1539 ctxt
: SyntaxContext
,
1540 assoc_item
: Option
<(Symbol
, Namespace
)>,
1541 ) -> Vec
<TraitCandidate
> {
1542 let mut found_traits
= Vec
::new();
1544 if let Some(module
) = current_trait
{
1545 if self.trait_may_have_item(Some(module
), assoc_item
) {
1546 let def_id
= module
.def_id();
1547 found_traits
.push(TraitCandidate { def_id, import_ids: smallvec![] }
);
1551 self.visit_scopes(ScopeSet
::All(TypeNS
, false), parent_scope
, ctxt
, |this
, scope
, _
, _
| {
1553 Scope
::Module(module
, _
) => {
1554 this
.traits_in_module(module
, assoc_item
, &mut found_traits
);
1556 Scope
::StdLibPrelude
=> {
1557 if let Some(module
) = this
.prelude
{
1558 this
.traits_in_module(module
, assoc_item
, &mut found_traits
);
1561 Scope
::ExternPrelude
| Scope
::ToolPrelude
| Scope
::BuiltinTypes
=> {}
1562 _
=> unreachable
!(),
1570 fn traits_in_module(
1573 assoc_item
: Option
<(Symbol
, Namespace
)>,
1574 found_traits
: &mut Vec
<TraitCandidate
>,
1576 module
.ensure_traits(self);
1577 let traits
= module
.traits
.borrow();
1578 for (trait_name
, trait_binding
) in traits
.as_ref().unwrap().iter() {
1579 if self.trait_may_have_item(trait_binding
.module(), assoc_item
) {
1580 let def_id
= trait_binding
.res().def_id();
1581 let import_ids
= self.find_transitive_imports(&trait_binding
.kind
, *trait_name
);
1582 found_traits
.push(TraitCandidate { def_id, import_ids }
);
1587 // List of traits in scope is pruned on best effort basis. We reject traits not having an
1588 // associated item with the given name and namespace (if specified). This is a conservative
1589 // optimization, proper hygienic type-based resolution of associated items is done in typeck.
1590 // We don't reject trait aliases (`trait_module == None`) because we don't have access to their
1591 // associated items.
1592 fn trait_may_have_item(
1594 trait_module
: Option
<Module
<'a
>>,
1595 assoc_item
: Option
<(Symbol
, Namespace
)>,
1597 match (trait_module
, assoc_item
) {
1598 (Some(trait_module
), Some((name
, ns
))) => {
1599 self.resolutions(trait_module
).borrow().iter().any(|resolution
| {
1600 let (&BindingKey { ident: assoc_ident, ns: assoc_ns, .. }
, _
) = resolution
;
1601 assoc_ns
== ns
&& assoc_ident
.name
== name
1608 fn find_transitive_imports(
1610 mut kind
: &NameBindingKind
<'_
>,
1612 ) -> SmallVec
<[LocalDefId
; 1]> {
1613 let mut import_ids
= smallvec
![];
1614 while let NameBindingKind
::Import { import, binding, .. }
= kind
{
1615 let id
= self.local_def_id(import
.id
);
1616 self.maybe_unused_trait_imports
.insert(id
);
1617 self.add_to_glob_map(&import
, trait_name
);
1618 import_ids
.push(id
);
1619 kind
= &binding
.kind
;
1624 fn new_key(&mut self, ident
: Ident
, ns
: Namespace
) -> BindingKey
{
1625 let ident
= ident
.normalize_to_macros_2_0();
1626 let disambiguator
= if ident
.name
== kw
::Underscore
{
1627 self.underscore_disambiguator
+= 1;
1628 self.underscore_disambiguator
1632 BindingKey { ident, ns, disambiguator }
1635 fn resolutions(&mut self, module
: Module
<'a
>) -> &'a Resolutions
<'a
> {
1636 if module
.populate_on_access
.get() {
1637 module
.populate_on_access
.set(false);
1638 self.build_reduced_graph_external(module
);
1640 &module
.lazy_resolutions
1647 ) -> &'a RefCell
<NameResolution
<'a
>> {
1649 .resolutions(module
)
1652 .or_insert_with(|| self.arenas
.alloc_name_resolution())
1658 used_binding
: &'a NameBinding
<'a
>,
1659 is_lexical_scope
: bool
,
1661 if let Some((b2
, kind
)) = used_binding
.ambiguity
{
1662 self.ambiguity_errors
.push(AmbiguityError
{
1667 misc1
: AmbiguityErrorMisc
::None
,
1668 misc2
: AmbiguityErrorMisc
::None
,
1671 if let NameBindingKind
::Import { import, binding, ref used }
= used_binding
.kind
{
1672 // Avoid marking `extern crate` items that refer to a name from extern prelude,
1673 // but not introduce it, as used if they are accessed from lexical scope.
1674 if is_lexical_scope
{
1675 if let Some(entry
) = self.extern_prelude
.get(&ident
.normalize_to_macros_2_0()) {
1676 if let Some(crate_item
) = entry
.extern_crate_item
{
1677 if ptr
::eq(used_binding
, crate_item
) && !entry
.introduced_by_item
{
1684 import
.used
.set(true);
1685 self.used_imports
.insert(import
.id
);
1686 self.add_to_glob_map(&import
, ident
);
1687 self.record_use(ident
, binding
, false);
1692 fn add_to_glob_map(&mut self, import
: &Import
<'_
>, ident
: Ident
) {
1693 if import
.is_glob() {
1694 let def_id
= self.local_def_id(import
.id
);
1695 self.glob_map
.entry(def_id
).or_default().insert(ident
.name
);
1699 fn resolve_crate_root(&mut self, ident
: Ident
) -> Module
<'a
> {
1700 debug
!("resolve_crate_root({:?})", ident
);
1701 let mut ctxt
= ident
.span
.ctxt();
1702 let mark
= if ident
.name
== kw
::DollarCrate
{
1703 // When resolving `$crate` from a `macro_rules!` invoked in a `macro`,
1704 // we don't want to pretend that the `macro_rules!` definition is in the `macro`
1705 // as described in `SyntaxContext::apply_mark`, so we ignore prepended opaque marks.
1706 // FIXME: This is only a guess and it doesn't work correctly for `macro_rules!`
1707 // definitions actually produced by `macro` and `macro` definitions produced by
1708 // `macro_rules!`, but at least such configurations are not stable yet.
1709 ctxt
= ctxt
.normalize_to_macro_rules();
1711 "resolve_crate_root: marks={:?}",
1712 ctxt
.marks().into_iter().map(|(i
, t
)| (i
.expn_data(), t
)).collect
::<Vec
<_
>>()
1714 let mut iter
= ctxt
.marks().into_iter().rev().peekable();
1715 let mut result
= None
;
1716 // Find the last opaque mark from the end if it exists.
1717 while let Some(&(mark
, transparency
)) = iter
.peek() {
1718 if transparency
== Transparency
::Opaque
{
1719 result
= Some(mark
);
1726 "resolve_crate_root: found opaque mark {:?} {:?}",
1728 result
.map(|r
| r
.expn_data())
1730 // Then find the last semi-transparent mark from the end if it exists.
1731 for (mark
, transparency
) in iter
{
1732 if transparency
== Transparency
::SemiTransparent
{
1733 result
= Some(mark
);
1739 "resolve_crate_root: found semi-transparent mark {:?} {:?}",
1741 result
.map(|r
| r
.expn_data())
1745 debug
!("resolve_crate_root: not DollarCrate");
1746 ctxt
= ctxt
.normalize_to_macros_2_0();
1747 ctxt
.adjust(ExpnId
::root())
1749 let module
= match mark
{
1750 Some(def
) => self.expn_def_scope(def
),
1753 "resolve_crate_root({:?}): found no mark (ident.span = {:?})",
1756 return self.graph_root
;
1759 let module
= self.expect_module(
1760 module
.opt_def_id().map_or(LOCAL_CRATE
, |def_id
| def_id
.krate
).as_def_id(),
1763 "resolve_crate_root({:?}): got module {:?} ({:?}) (ident.span = {:?})",
1772 fn resolve_self(&mut self, ctxt
: &mut SyntaxContext
, module
: Module
<'a
>) -> Module
<'a
> {
1773 let mut module
= self.expect_module(module
.nearest_parent_mod());
1774 while module
.span
.ctxt().normalize_to_macros_2_0() != *ctxt
{
1775 let parent
= module
.parent
.unwrap_or_else(|| self.expn_def_scope(ctxt
.remove_mark()));
1776 module
= self.expect_module(parent
.nearest_parent_mod());
1781 fn record_partial_res(&mut self, node_id
: NodeId
, resolution
: PartialRes
) {
1782 debug
!("(recording res) recording {:?} for {}", resolution
, node_id
);
1783 if let Some(prev_res
) = self.partial_res_map
.insert(node_id
, resolution
) {
1784 panic
!("path resolved multiple times ({:?} before, {:?} now)", prev_res
, resolution
);
1788 fn record_pat_span(&mut self, node
: NodeId
, span
: Span
) {
1789 debug
!("(recording pat) recording {:?} for {:?}", node
, span
);
1790 self.pat_span_map
.insert(node
, span
);
1793 fn is_accessible_from(
1795 vis
: ty
::Visibility
<impl Into
<DefId
>>,
1798 vis
.is_accessible_from(module
.nearest_parent_mod(), self)
1801 fn set_binding_parent_module(&mut self, binding
: &'a NameBinding
<'a
>, module
: Module
<'a
>) {
1802 if let Some(old_module
) =
1803 self.binding_parent_modules
.insert(Interned
::new_unchecked(binding
), module
)
1805 if !ptr
::eq(module
, old_module
) {
1806 span_bug
!(binding
.span
, "parent module is reset for binding");
1811 fn disambiguate_macro_rules_vs_modularized(
1813 macro_rules
: &'a NameBinding
<'a
>,
1814 modularized
: &'a NameBinding
<'a
>,
1816 // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
1817 // is disambiguated to mitigate regressions from macro modularization.
1818 // Scoping for `macro_rules` behaves like scoping for `let` at module level, in general.
1820 self.binding_parent_modules
.get(&Interned
::new_unchecked(macro_rules
)),
1821 self.binding_parent_modules
.get(&Interned
::new_unchecked(modularized
)),
1823 (Some(macro_rules
), Some(modularized
)) => {
1824 macro_rules
.nearest_parent_mod() == modularized
.nearest_parent_mod()
1825 && modularized
.is_ancestor_of(macro_rules
)
1831 fn extern_prelude_get(&mut self, ident
: Ident
, finalize
: bool
) -> Option
<&'a NameBinding
<'a
>> {
1832 if ident
.is_path_segment_keyword() {
1833 // Make sure `self`, `super` etc produce an error when passed to here.
1836 self.extern_prelude
.get(&ident
.normalize_to_macros_2_0()).cloned().and_then(|entry
| {
1837 if let Some(binding
) = entry
.extern_crate_item
{
1838 if finalize
&& entry
.introduced_by_item
{
1839 self.record_use(ident
, binding
, false);
1843 let crate_id
= if finalize
{
1844 let Some(crate_id
) =
1845 self.crate_loader
.process_path_extern(ident
.name
, ident
.span
) else { return Some(self.dummy_binding); }
;
1848 self.crate_loader
.maybe_process_path_extern(ident
.name
)?
1850 let crate_root
= self.expect_module(crate_id
.as_def_id());
1851 let vis
= ty
::Visibility
::<LocalDefId
>::Public
;
1852 Some((crate_root
, vis
, DUMMY_SP
, LocalExpnId
::ROOT
).to_name_binding(self.arenas
))
1857 /// Rustdoc uses this to resolve doc link paths in a recoverable way. `PathResult<'a>`
1858 /// isn't something that can be returned because it can't be made to live that long,
1859 /// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
1860 /// just that an error occurred.
1861 pub fn resolve_rustdoc_path(
1865 mut parent_scope
: ParentScope
<'a
>,
1868 Vec
::from_iter(path_str
.split("::").map(Ident
::from_str
).map(Segment
::from_ident
));
1869 if let Some(segment
) = segments
.first_mut() {
1870 if segment
.ident
.name
== kw
::Crate
{
1871 // FIXME: `resolve_path` always resolves `crate` to the current crate root, but
1872 // rustdoc wants it to resolve to the `parent_scope`'s crate root. This trick of
1873 // replacing `crate` with `self` and changing the current module should achieve
1875 segment
.ident
.name
= kw
::SelfLower
;
1876 parent_scope
.module
=
1877 self.expect_module(parent_scope
.module
.def_id().krate
.as_def_id());
1878 } else if segment
.ident
.name
== kw
::Empty
{
1879 segment
.ident
.name
= kw
::PathRoot
;
1883 match self.maybe_resolve_path(&segments
, Some(ns
), &parent_scope
) {
1884 PathResult
::Module(ModuleOrUniformRoot
::Module(module
)) => Some(module
.res().unwrap()),
1885 PathResult
::NonModule(path_res
) if path_res
.unresolved_segments() == 0 => {
1886 Some(path_res
.base_res())
1888 PathResult
::Module(ModuleOrUniformRoot
::ExternPrelude
)
1889 | PathResult
::NonModule(..)
1890 | PathResult
::Failed { .. }
=> None
,
1891 PathResult
::Module(..) | PathResult
::Indeterminate
=> unreachable
!(),
1896 /// For local modules returns only reexports, for external modules returns all children.
1897 pub fn module_children_or_reexports(&self, def_id
: DefId
) -> Vec
<ModChild
> {
1898 if let Some(def_id
) = def_id
.as_local() {
1899 self.reexport_map
.get(&def_id
).cloned().unwrap_or_default()
1901 self.cstore().module_children_untracked(def_id
, self.session
)
1906 pub fn macro_rules_scope(&self, def_id
: LocalDefId
) -> (MacroRulesScopeRef
<'a
>, Res
) {
1907 let scope
= *self.macro_rules_scopes
.get(&def_id
).expect("not a `macro_rules` item");
1909 MacroRulesScope
::Binding(mb
) => (scope
, mb
.binding
.res()),
1910 _
=> unreachable
!(),
1914 /// Retrieves the span of the given `DefId` if `DefId` is in the local crate.
1916 pub fn opt_span(&self, def_id
: DefId
) -> Option
<Span
> {
1917 def_id
.as_local().map(|def_id
| self.source_span
[def_id
])
1920 /// Retrieves the name of the given `DefId`.
1922 pub fn opt_name(&self, def_id
: DefId
) -> Option
<Symbol
> {
1923 let def_key
= match def_id
.as_local() {
1924 Some(def_id
) => self.definitions
.def_key(def_id
),
1925 None
=> self.cstore().def_key(def_id
),
1927 def_key
.get_opt_name()
1930 /// Checks if an expression refers to a function marked with
1931 /// `#[rustc_legacy_const_generics]` and returns the argument index list
1932 /// from the attribute.
1933 pub fn legacy_const_generic_args(&mut self, expr
: &Expr
) -> Option
<Vec
<usize>> {
1934 if let ExprKind
::Path(None
, path
) = &expr
.kind
{
1935 // Don't perform legacy const generics rewriting if the path already
1936 // has generic arguments.
1937 if path
.segments
.last().unwrap().args
.is_some() {
1941 let partial_res
= self.partial_res_map
.get(&expr
.id
)?
;
1942 if partial_res
.unresolved_segments() != 0 {
1946 if let Res
::Def(def
::DefKind
::Fn
, def_id
) = partial_res
.base_res() {
1947 // We only support cross-crate argument rewriting. Uses
1948 // within the same crate should be updated to use the new
1949 // const generics style.
1950 if def_id
.is_local() {
1954 if let Some(v
) = self.legacy_const_generic_args
.get(&def_id
) {
1960 .item_attrs_untracked(def_id
, self.session
)
1961 .find(|a
| a
.has_name(sym
::rustc_legacy_const_generics
))?
;
1962 let mut ret
= Vec
::new();
1963 for meta
in attr
.meta_item_list()?
{
1964 match meta
.literal()?
.kind
{
1965 LitKind
::Int(a
, _
) => ret
.push(a
as usize),
1966 _
=> panic
!("invalid arg index"),
1969 // Cache the lookup to avoid parsing attributes for an item multiple times.
1970 self.legacy_const_generic_args
.insert(def_id
, Some(ret
.clone()));
1977 fn resolve_main(&mut self) {
1978 let module
= self.graph_root
;
1979 let ident
= Ident
::with_dummy_span(sym
::main
);
1980 let parent_scope
= &ParentScope
::module(module
, self);
1982 let Ok(name_binding
) = self.maybe_resolve_ident_in_module(
1983 ModuleOrUniformRoot
::Module(module
),
1991 let res
= name_binding
.res();
1992 let is_import
= name_binding
.is_import();
1993 let span
= name_binding
.span
;
1994 if let Res
::Def(DefKind
::Fn
, _
) = res
{
1995 self.record_use(ident
, name_binding
, false);
1997 self.main_def
= Some(MainDefinition { res, is_import, span }
);
2000 // Items that go to reexport table encoded to metadata and visible through it to other crates.
2001 fn is_reexport(&self, binding
: &NameBinding
<'a
>) -> Option
<def
::Res
<!>> {
2002 // FIXME: Consider changing the binding inserted by `#[macro_export] macro_rules`
2003 // into the crate root to actual `NameBindingKind::Import`.
2004 if binding
.is_import()
2005 || matches
!(binding
.kind
, NameBindingKind
::Res(_
, _is_macro_export @
true))
2007 let res
= binding
.res().expect_non_local();
2008 // Ambiguous imports are treated as errors at this point and are
2009 // not exposed to other crates (see #36837 for more details).
2010 if res
!= def
::Res
::Err
&& !binding
.is_ambiguity() {
2019 fn names_to_string(names
: &[Symbol
]) -> String
{
2020 let mut result
= String
::new();
2021 for (i
, name
) in names
.iter().filter(|name
| **name
!= kw
::PathRoot
).enumerate() {
2023 result
.push_str("::");
2025 if Ident
::with_dummy_span(*name
).is_raw_guess() {
2026 result
.push_str("r#");
2028 result
.push_str(name
.as_str());
2033 fn path_names_to_string(path
: &Path
) -> String
{
2034 names_to_string(&path
.segments
.iter().map(|seg
| seg
.ident
.name
).collect
::<Vec
<_
>>())
2037 /// A somewhat inefficient routine to obtain the name of a module.
2038 fn module_to_string(module
: Module
<'_
>) -> Option
<String
> {
2039 let mut names
= Vec
::new();
2041 fn collect_mod(names
: &mut Vec
<Symbol
>, module
: Module
<'_
>) {
2042 if let ModuleKind
::Def(.., name
) = module
.kind
{
2043 if let Some(parent
) = module
.parent
{
2045 collect_mod(names
, parent
);
2048 names
.push(Symbol
::intern("<opaque>"));
2049 collect_mod(names
, module
.parent
.unwrap());
2052 collect_mod(&mut names
, module
);
2054 if names
.is_empty() {
2058 Some(names_to_string(&names
))
2061 #[derive(Copy, Clone, Debug)]
2063 /// Node ID for linting.
2065 /// Span of the whole path or some its characteristic fragment.
2066 /// E.g. span of `b` in `foo::{a, b, c}`, or full span for regular paths.
2068 /// Span of the path start, suitable for prepending something to to it.
2069 /// E.g. span of `foo` in `foo::{a, b, c}`, or full span for regular paths.
2071 /// Whether to report privacy errors or silently return "no resolution" for them,
2072 /// similarly to speculative resolution.
2073 report_private
: bool
,
2077 fn new(node_id
: NodeId
, path_span
: Span
) -> Finalize
{
2078 Finalize
::with_root_span(node_id
, path_span
, path_span
)
2081 fn with_root_span(node_id
: NodeId
, path_span
: Span
, root_span
: Span
) -> Finalize
{
2082 Finalize { node_id, path_span, root_span, report_private: true }
2086 pub fn provide(providers
: &mut Providers
) {
2087 late
::lifetimes
::provide(providers
);