1 // ignore-tidy-filelength
2
3 //! This crate is responsible for the part of name resolution that doesn't require type checker.
4 //!
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.
8 //!
9 //! Type-relative name resolution (methods, fields, associated items) happens in `rustc_typeck`.
10
11 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
12 #![feature(box_patterns)]
13 #![feature(drain_filter)]
14 #![feature(bool_to_option)]
15 #![feature(crate_visibility_modifier)]
16 #![cfg_attr(bootstrap, feature(format_args_capture))]
17 #![feature(iter_zip)]
18 #![feature(let_else)]
19 #![feature(never_type)]
20 #![feature(nll)]
21 #![recursion_limit = "256"]
22 #![allow(rustdoc::private_intra_doc_links)]
23
24 #[macro_use]
25 extern crate tracing;
26
27 pub use rustc_hir::def::{Namespace, PerNS};
28
29 use Determinacy::*;
30
31 use rustc_arena::{DroplessArena, TypedArena};
32 use rustc_ast::node_id::NodeMap;
33 use rustc_ast::ptr::P;
34 use rustc_ast::visit::{self, Visitor};
35 use rustc_ast::{self as ast, NodeId};
36 use rustc_ast::{Crate, CRATE_NODE_ID};
37 use rustc_ast::{Expr, ExprKind, LitKind};
38 use rustc_ast::{ItemKind, ModKind, Path};
39 use rustc_ast_lowering::ResolverAstLowering;
40 use rustc_ast_pretty::pprust;
41 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
42 use rustc_data_structures::ptr_key::PtrKey;
43 use rustc_data_structures::sync::Lrc;
44 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
45 use rustc_expand::base::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind};
46 use rustc_hir::def::Namespace::*;
47 use rustc_hir::def::{self, CtorOf, DefKind, NonMacroAttrKind, PartialRes};
48 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefPathHash, LocalDefId};
49 use rustc_hir::def_id::{CRATE_DEF_ID, CRATE_DEF_INDEX, LOCAL_CRATE};
50 use rustc_hir::definitions::{DefKey, DefPathData, Definitions};
51 use rustc_hir::TraitCandidate;
52 use rustc_index::vec::IndexVec;
53 use rustc_metadata::creader::{CStore, CrateLoader};
54 use rustc_middle::hir::exports::ExportMap;
55 use rustc_middle::span_bug;
56 use rustc_middle::ty::query::Providers;
57 use rustc_middle::ty::{self, DefIdTree, MainDefinition, ResolverOutputs};
58 use rustc_query_system::ich::StableHashingContext;
59 use rustc_session::cstore::{CrateStore, MetadataLoaderDyn};
60 use rustc_session::lint;
61 use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
62 use rustc_session::Session;
63 use rustc_span::edition::Edition;
64 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext, Transparency};
65 use rustc_span::source_map::Spanned;
66 use rustc_span::symbol::{kw, sym, Ident, Symbol};
67 use rustc_span::{Span, DUMMY_SP};
68
69 use smallvec::{smallvec, SmallVec};
70 use std::cell::{Cell, RefCell};
71 use std::collections::{BTreeMap, BTreeSet};
72 use std::ops::ControlFlow;
73 use std::{cmp, fmt, iter, ptr};
74 use tracing::debug;
75
76 use diagnostics::{extend_span_to_previous_binding, find_span_of_binding_until_next_binding};
77 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
78 use imports::{Import, ImportKind, ImportResolver, NameResolution};
79 use late::{ConstantItemKind, HasGenericParams, PathSource, Rib, RibKind::*};
80 use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
81
82 type Res = def::Res<NodeId>;
83
84 mod build_reduced_graph;
85 mod check_unused;
86 mod def_collector;
87 mod diagnostics;
88 mod imports;
89 mod late;
90 mod macros;
91
92 enum Weak {
93 Yes,
94 No,
95 }
96
97 #[derive(Copy, Clone, PartialEq, Debug)]
98 pub enum Determinacy {
99 Determined,
100 Undetermined,
101 }
102
103 impl Determinacy {
determined(determined: bool) -> Determinacy104 fn determined(determined: bool) -> Determinacy {
105 if determined { Determinacy::Determined } else { Determinacy::Undetermined }
106 }
107 }
108
109 /// A specific scope in which a name can be looked up.
110 /// This enum is currently used only for early resolution (imports and macros),
111 /// but not for late resolution yet.
112 #[derive(Clone, Copy)]
113 enum Scope<'a> {
114 DeriveHelpers(LocalExpnId),
115 DeriveHelpersCompat,
116 MacroRules(MacroRulesScopeRef<'a>),
117 CrateRoot,
118 // The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
119 // lint if it should be reported.
120 Module(Module<'a>, Option<NodeId>),
121 RegisteredAttrs,
122 MacroUsePrelude,
123 BuiltinAttrs,
124 ExternPrelude,
125 ToolPrelude,
126 StdLibPrelude,
127 BuiltinTypes,
128 }
129
130 /// Names from different contexts may want to visit different subsets of all specific scopes
131 /// with different restrictions when looking up the resolution.
132 /// This enum is currently used only for early resolution (imports and macros),
133 /// but not for late resolution yet.
134 #[derive(Clone, Copy)]
135 enum ScopeSet<'a> {
136 /// All scopes with the given namespace.
137 All(Namespace, /*is_import*/ bool),
138 /// Crate root, then extern prelude (used for mixed 2015-2018 mode in macros).
139 AbsolutePath(Namespace),
140 /// All scopes with macro namespace and the given macro kind restriction.
141 Macro(MacroKind),
142 /// All scopes with the given namespace, used for partially performing late resolution.
143 /// The node id enables lints and is used for reporting them.
144 Late(Namespace, Module<'a>, Option<NodeId>),
145 }
146
147 /// Everything you need to know about a name's location to resolve it.
148 /// Serves as a starting point for the scope visitor.
149 /// This struct is currently used only for early resolution (imports and macros),
150 /// but not for late resolution yet.
151 #[derive(Clone, Copy, Debug)]
152 pub struct ParentScope<'a> {
153 module: Module<'a>,
154 expansion: LocalExpnId,
155 macro_rules: MacroRulesScopeRef<'a>,
156 derives: &'a [ast::Path],
157 }
158
159 impl<'a> ParentScope<'a> {
160 /// Creates a parent scope with the passed argument used as the module scope component,
161 /// and other scope components set to default empty values.
module(module: Module<'a>, resolver: &Resolver<'a>) -> ParentScope<'a>162 pub fn module(module: Module<'a>, resolver: &Resolver<'a>) -> ParentScope<'a> {
163 ParentScope {
164 module,
165 expansion: LocalExpnId::ROOT,
166 macro_rules: resolver.arenas.alloc_macro_rules_scope(MacroRulesScope::Empty),
167 derives: &[],
168 }
169 }
170 }
171
172 #[derive(Copy, Debug, Clone)]
173 enum ImplTraitContext {
174 Existential,
175 Universal(LocalDefId),
176 }
177
178 #[derive(Eq)]
179 struct BindingError {
180 name: Symbol,
181 origin: BTreeSet<Span>,
182 target: BTreeSet<Span>,
183 could_be_path: bool,
184 }
185
186 impl PartialOrd for BindingError {
partial_cmp(&self, other: &BindingError) -> Option<cmp::Ordering>187 fn partial_cmp(&self, other: &BindingError) -> Option<cmp::Ordering> {
188 Some(self.cmp(other))
189 }
190 }
191
192 impl PartialEq for BindingError {
eq(&self, other: &BindingError) -> bool193 fn eq(&self, other: &BindingError) -> bool {
194 self.name == other.name
195 }
196 }
197
198 impl Ord for BindingError {
cmp(&self, other: &BindingError) -> cmp::Ordering199 fn cmp(&self, other: &BindingError) -> cmp::Ordering {
200 self.name.cmp(&other.name)
201 }
202 }
203
204 enum ResolutionError<'a> {
205 /// Error E0401: can't use type or const parameters from outer function.
206 GenericParamsFromOuterFunction(Res, HasGenericParams),
207 /// Error E0403: the name is already used for a type or const parameter in this generic
208 /// parameter list.
209 NameAlreadyUsedInParameterList(Symbol, Span),
210 /// Error E0407: method is not a member of trait.
211 MethodNotMemberOfTrait(Ident, &'a str, Option<Symbol>),
212 /// Error E0437: type is not a member of trait.
213 TypeNotMemberOfTrait(Ident, &'a str, Option<Symbol>),
214 /// Error E0438: const is not a member of trait.
215 ConstNotMemberOfTrait(Ident, &'a str, Option<Symbol>),
216 /// Error E0408: variable `{}` is not bound in all patterns.
217 VariableNotBoundInPattern(&'a BindingError),
218 /// Error E0409: variable `{}` is bound in inconsistent ways within the same match arm.
219 VariableBoundWithDifferentMode(Symbol, Span),
220 /// Error E0415: identifier is bound more than once in this parameter list.
221 IdentifierBoundMoreThanOnceInParameterList(Symbol),
222 /// Error E0416: identifier is bound more than once in the same pattern.
223 IdentifierBoundMoreThanOnceInSamePattern(Symbol),
224 /// Error E0426: use of undeclared label.
225 UndeclaredLabel { name: Symbol, suggestion: Option<LabelSuggestion> },
226 /// Error E0429: `self` imports are only allowed within a `{ }` list.
227 SelfImportsOnlyAllowedWithin { root: bool, span_with_rename: Span },
228 /// Error E0430: `self` import can only appear once in the list.
229 SelfImportCanOnlyAppearOnceInTheList,
230 /// Error E0431: `self` import can only appear in an import list with a non-empty prefix.
231 SelfImportOnlyInImportListWithNonEmptyPrefix,
232 /// Error E0433: failed to resolve.
233 FailedToResolve { label: String, suggestion: Option<Suggestion> },
234 /// Error E0434: can't capture dynamic environment in a fn item.
235 CannotCaptureDynamicEnvironmentInFnItem,
236 /// Error E0435: attempt to use a non-constant value in a constant.
237 AttemptToUseNonConstantValueInConstant(
238 Ident,
239 /* suggestion */ &'static str,
240 /* current */ &'static str,
241 ),
242 /// Error E0530: `X` bindings cannot shadow `Y`s.
243 BindingShadowsSomethingUnacceptable {
244 shadowing_binding_descr: &'static str,
245 name: Symbol,
246 participle: &'static str,
247 article: &'static str,
248 shadowed_binding_descr: &'static str,
249 shadowed_binding_span: Span,
250 },
251 /// Error E0128: generic parameters with a default cannot use forward-declared identifiers.
252 ForwardDeclaredGenericParam,
253 /// ERROR E0770: the type of const parameters must not depend on other generic parameters.
254 ParamInTyOfConstParam(Symbol),
255 /// generic parameters must not be used inside const evaluations.
256 ///
257 /// This error is only emitted when using `min_const_generics`.
258 ParamInNonTrivialAnonConst { name: Symbol, is_type: bool },
259 /// Error E0735: generic parameters with a default cannot use `Self`
260 SelfInGenericParamDefault,
261 /// Error E0767: use of unreachable label
262 UnreachableLabel { name: Symbol, definition_span: Span, suggestion: Option<LabelSuggestion> },
263 }
264
265 enum VisResolutionError<'a> {
266 Relative2018(Span, &'a ast::Path),
267 AncestorOnly(Span),
268 FailedToResolve(Span, String, Option<Suggestion>),
269 ExpectedFound(Span, String, Res),
270 Indeterminate(Span),
271 ModuleOnly(Span),
272 }
273
274 /// A minimal representation of a path segment. We use this in resolve because we synthesize 'path
275 /// segments' which don't have the rest of an AST or HIR `PathSegment`.
276 #[derive(Clone, Copy, Debug)]
277 pub struct Segment {
278 ident: Ident,
279 id: Option<NodeId>,
280 /// Signals whether this `PathSegment` has generic arguments. Used to avoid providing
281 /// nonsensical suggestions.
282 has_generic_args: bool,
283 }
284
285 impl Segment {
from_path(path: &Path) -> Vec<Segment>286 fn from_path(path: &Path) -> Vec<Segment> {
287 path.segments.iter().map(|s| s.into()).collect()
288 }
289
from_ident(ident: Ident) -> Segment290 fn from_ident(ident: Ident) -> Segment {
291 Segment { ident, id: None, has_generic_args: false }
292 }
293
names_to_string(segments: &[Segment]) -> String294 fn names_to_string(segments: &[Segment]) -> String {
295 names_to_string(&segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>())
296 }
297 }
298
299 impl<'a> From<&'a ast::PathSegment> for Segment {
from(seg: &'a ast::PathSegment) -> Segment300 fn from(seg: &'a ast::PathSegment) -> Segment {
301 Segment { ident: seg.ident, id: Some(seg.id), has_generic_args: seg.args.is_some() }
302 }
303 }
304
305 struct UsePlacementFinder {
306 target_module: NodeId,
307 span: Option<Span>,
308 found_use: bool,
309 }
310
311 impl UsePlacementFinder {
check(krate: &Crate, target_module: NodeId) -> (Option<Span>, bool)312 fn check(krate: &Crate, target_module: NodeId) -> (Option<Span>, bool) {
313 let mut finder = UsePlacementFinder { target_module, span: None, found_use: false };
314 if let ControlFlow::Continue(..) = finder.check_mod(&krate.items, CRATE_NODE_ID) {
315 visit::walk_crate(&mut finder, krate);
316 }
317 (finder.span, finder.found_use)
318 }
319
check_mod(&mut self, items: &[P<ast::Item>], node_id: NodeId) -> ControlFlow<()>320 fn check_mod(&mut self, items: &[P<ast::Item>], node_id: NodeId) -> ControlFlow<()> {
321 if self.span.is_some() {
322 return ControlFlow::Break(());
323 }
324 if node_id != self.target_module {
325 return ControlFlow::Continue(());
326 }
327 // find a use statement
328 for item in items {
329 match item.kind {
330 ItemKind::Use(..) => {
331 // don't suggest placing a use before the prelude
332 // import or other generated ones
333 if !item.span.from_expansion() {
334 self.span = Some(item.span.shrink_to_lo());
335 self.found_use = true;
336 return ControlFlow::Break(());
337 }
338 }
339 // don't place use before extern crate
340 ItemKind::ExternCrate(_) => {}
341 // but place them before the first other item
342 _ => {
343 if self.span.map_or(true, |span| item.span < span)
344 && !item.span.from_expansion()
345 {
346 self.span = Some(item.span.shrink_to_lo());
347 // don't insert between attributes and an item
348 // find the first attribute on the item
349 // FIXME: This is broken for active attributes.
350 for attr in &item.attrs {
351 if !attr.span.is_dummy()
352 && self.span.map_or(true, |span| attr.span < span)
353 {
354 self.span = Some(attr.span.shrink_to_lo());
355 }
356 }
357 }
358 }
359 }
360 }
361 ControlFlow::Continue(())
362 }
363 }
364
365 impl<'tcx> Visitor<'tcx> for UsePlacementFinder {
visit_item(&mut self, item: &'tcx ast::Item)366 fn visit_item(&mut self, item: &'tcx ast::Item) {
367 if let ItemKind::Mod(_, ModKind::Loaded(items, ..)) = &item.kind {
368 if let ControlFlow::Break(..) = self.check_mod(items, item.id) {
369 return;
370 }
371 }
372 visit::walk_item(self, item);
373 }
374 }
375
376 /// An intermediate resolution result.
377 ///
378 /// This refers to the thing referred by a name. The difference between `Res` and `Item` is that
379 /// items are visible in their whole block, while `Res`es only from the place they are defined
380 /// forward.
381 #[derive(Debug)]
382 enum LexicalScopeBinding<'a> {
383 Item(&'a NameBinding<'a>),
384 Res(Res),
385 }
386
387 impl<'a> LexicalScopeBinding<'a> {
res(self) -> Res388 fn res(self) -> Res {
389 match self {
390 LexicalScopeBinding::Item(binding) => binding.res(),
391 LexicalScopeBinding::Res(res) => res,
392 }
393 }
394 }
395
396 #[derive(Copy, Clone, Debug)]
397 enum ModuleOrUniformRoot<'a> {
398 /// Regular module.
399 Module(Module<'a>),
400
401 /// Virtual module that denotes resolution in crate root with fallback to extern prelude.
402 CrateRootAndExternPrelude,
403
404 /// Virtual module that denotes resolution in extern prelude.
405 /// Used for paths starting with `::` on 2018 edition.
406 ExternPrelude,
407
408 /// Virtual module that denotes resolution in current scope.
409 /// Used only for resolving single-segment imports. The reason it exists is that import paths
410 /// are always split into two parts, the first of which should be some kind of module.
411 CurrentScope,
412 }
413
414 impl ModuleOrUniformRoot<'_> {
same_def(lhs: Self, rhs: Self) -> bool415 fn same_def(lhs: Self, rhs: Self) -> bool {
416 match (lhs, rhs) {
417 (ModuleOrUniformRoot::Module(lhs), ModuleOrUniformRoot::Module(rhs)) => {
418 ptr::eq(lhs, rhs)
419 }
420 (
421 ModuleOrUniformRoot::CrateRootAndExternPrelude,
422 ModuleOrUniformRoot::CrateRootAndExternPrelude,
423 )
424 | (ModuleOrUniformRoot::ExternPrelude, ModuleOrUniformRoot::ExternPrelude)
425 | (ModuleOrUniformRoot::CurrentScope, ModuleOrUniformRoot::CurrentScope) => true,
426 _ => false,
427 }
428 }
429 }
430
431 #[derive(Clone, Debug)]
432 enum PathResult<'a> {
433 Module(ModuleOrUniformRoot<'a>),
434 NonModule(PartialRes),
435 Indeterminate,
436 Failed {
437 span: Span,
438 label: String,
439 suggestion: Option<Suggestion>,
440 is_error_from_last_segment: bool,
441 },
442 }
443
444 #[derive(Debug)]
445 enum ModuleKind {
446 /// An anonymous module; e.g., just a block.
447 ///
448 /// ```
449 /// fn main() {
450 /// fn f() {} // (1)
451 /// { // This is an anonymous module
452 /// f(); // This resolves to (2) as we are inside the block.
453 /// fn f() {} // (2)
454 /// }
455 /// f(); // Resolves to (1)
456 /// }
457 /// ```
458 Block(NodeId),
459 /// Any module with a name.
460 ///
461 /// This could be:
462 ///
463 /// * A normal module – either `mod from_file;` or `mod from_block { }` –
464 /// or the crate root (which is conceptually a top-level module).
465 /// Note that the crate root's [name][Self::name] will be [`kw::Empty`].
466 /// * A trait or an enum (it implicitly contains associated types, methods and variant
467 /// constructors).
468 Def(DefKind, DefId, Symbol),
469 }
470
471 impl ModuleKind {
472 /// Get name of the module.
name(&self) -> Option<Symbol>473 pub fn name(&self) -> Option<Symbol> {
474 match self {
475 ModuleKind::Block(..) => None,
476 ModuleKind::Def(.., name) => Some(*name),
477 }
478 }
479 }
480
481 /// A key that identifies a binding in a given `Module`.
482 ///
483 /// Multiple bindings in the same module can have the same key (in a valid
484 /// program) if all but one of them come from glob imports.
485 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
486 struct BindingKey {
487 /// The identifier for the binding, aways the `normalize_to_macros_2_0` version of the
488 /// identifier.
489 ident: Ident,
490 ns: Namespace,
491 /// 0 if ident is not `_`, otherwise a value that's unique to the specific
492 /// `_` in the expanded AST that introduced this binding.
493 disambiguator: u32,
494 }
495
496 type Resolutions<'a> = RefCell<FxIndexMap<BindingKey, &'a RefCell<NameResolution<'a>>>>;
497
498 /// One node in the tree of modules.
499 ///
500 /// Note that a "module" in resolve is broader than a `mod` that you declare in Rust code. It may be one of these:
501 ///
502 /// * `mod`
503 /// * crate root (aka, top-level anonymous module)
504 /// * `enum`
505 /// * `trait`
506 /// * curly-braced block with statements
507 ///
508 /// You can use [`ModuleData::kind`] to determine the kind of module this is.
509 pub struct ModuleData<'a> {
510 /// The direct parent module (it may not be a `mod`, however).
511 parent: Option<Module<'a>>,
512 /// What kind of module this is, because this may not be a `mod`.
513 kind: ModuleKind,
514
515 /// Mapping between names and their (possibly in-progress) resolutions in this module.
516 /// Resolutions in modules from other crates are not populated until accessed.
517 lazy_resolutions: Resolutions<'a>,
518 /// True if this is a module from other crate that needs to be populated on access.
519 populate_on_access: Cell<bool>,
520
521 /// Macro invocations that can expand into items in this module.
522 unexpanded_invocations: RefCell<FxHashSet<LocalExpnId>>,
523
524 /// Whether `#[no_implicit_prelude]` is active.
525 no_implicit_prelude: bool,
526
527 glob_importers: RefCell<Vec<&'a Import<'a>>>,
528 globs: RefCell<Vec<&'a Import<'a>>>,
529
530 /// Used to memoize the traits in this module for faster searches through all traits in scope.
531 traits: RefCell<Option<Box<[(Ident, &'a NameBinding<'a>)]>>>,
532
533 /// Span of the module itself. Used for error reporting.
534 span: Span,
535
536 expansion: ExpnId,
537 }
538
539 type Module<'a> = &'a ModuleData<'a>;
540
541 impl<'a> ModuleData<'a> {
new( parent: Option<Module<'a>>, kind: ModuleKind, expansion: ExpnId, span: Span, no_implicit_prelude: bool, ) -> Self542 fn new(
543 parent: Option<Module<'a>>,
544 kind: ModuleKind,
545 expansion: ExpnId,
546 span: Span,
547 no_implicit_prelude: bool,
548 ) -> Self {
549 let is_foreign = match kind {
550 ModuleKind::Def(_, def_id, _) => !def_id.is_local(),
551 ModuleKind::Block(_) => false,
552 };
553 ModuleData {
554 parent,
555 kind,
556 lazy_resolutions: Default::default(),
557 populate_on_access: Cell::new(is_foreign),
558 unexpanded_invocations: Default::default(),
559 no_implicit_prelude,
560 glob_importers: RefCell::new(Vec::new()),
561 globs: RefCell::new(Vec::new()),
562 traits: RefCell::new(None),
563 span,
564 expansion,
565 }
566 }
567
for_each_child<R, F>(&'a self, resolver: &mut R, mut f: F) where R: AsMut<Resolver<'a>>, F: FnMut(&mut R, Ident, Namespace, &'a NameBinding<'a>),568 fn for_each_child<R, F>(&'a self, resolver: &mut R, mut f: F)
569 where
570 R: AsMut<Resolver<'a>>,
571 F: FnMut(&mut R, Ident, Namespace, &'a NameBinding<'a>),
572 {
573 for (key, name_resolution) in resolver.as_mut().resolutions(self).borrow().iter() {
574 if let Some(binding) = name_resolution.borrow().binding {
575 f(resolver, key.ident, key.ns, binding);
576 }
577 }
578 }
579
580 /// This modifies `self` in place. The traits will be stored in `self.traits`.
ensure_traits<R>(&'a self, resolver: &mut R) where R: AsMut<Resolver<'a>>,581 fn ensure_traits<R>(&'a self, resolver: &mut R)
582 where
583 R: AsMut<Resolver<'a>>,
584 {
585 let mut traits = self.traits.borrow_mut();
586 if traits.is_none() {
587 let mut collected_traits = Vec::new();
588 self.for_each_child(resolver, |_, name, ns, binding| {
589 if ns != TypeNS {
590 return;
591 }
592 if let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = binding.res() {
593 collected_traits.push((name, binding))
594 }
595 });
596 *traits = Some(collected_traits.into_boxed_slice());
597 }
598 }
599
res(&self) -> Option<Res>600 fn res(&self) -> Option<Res> {
601 match self.kind {
602 ModuleKind::Def(kind, def_id, _) => Some(Res::Def(kind, def_id)),
603 _ => None,
604 }
605 }
606
def_id(&self) -> DefId607 fn def_id(&self) -> DefId {
608 self.opt_def_id().expect("`ModuleData::def_id` is called on a block module")
609 }
610
opt_def_id(&self) -> Option<DefId>611 fn opt_def_id(&self) -> Option<DefId> {
612 match self.kind {
613 ModuleKind::Def(_, def_id, _) => Some(def_id),
614 _ => None,
615 }
616 }
617
618 // `self` resolves to the first module ancestor that `is_normal`.
is_normal(&self) -> bool619 fn is_normal(&self) -> bool {
620 matches!(self.kind, ModuleKind::Def(DefKind::Mod, _, _))
621 }
622
is_trait(&self) -> bool623 fn is_trait(&self) -> bool {
624 matches!(self.kind, ModuleKind::Def(DefKind::Trait, _, _))
625 }
626
nearest_item_scope(&'a self) -> Module<'a>627 fn nearest_item_scope(&'a self) -> Module<'a> {
628 match self.kind {
629 ModuleKind::Def(DefKind::Enum | DefKind::Trait, ..) => {
630 self.parent.expect("enum or trait module without a parent")
631 }
632 _ => self,
633 }
634 }
635
636 /// The [`DefId`] of the nearest `mod` item ancestor (which may be this module).
637 /// This may be the crate root.
nearest_parent_mod(&self) -> DefId638 fn nearest_parent_mod(&self) -> DefId {
639 match self.kind {
640 ModuleKind::Def(DefKind::Mod, def_id, _) => def_id,
641 _ => self.parent.expect("non-root module without parent").nearest_parent_mod(),
642 }
643 }
644
is_ancestor_of(&self, mut other: &Self) -> bool645 fn is_ancestor_of(&self, mut other: &Self) -> bool {
646 while !ptr::eq(self, other) {
647 if let Some(parent) = other.parent {
648 other = parent;
649 } else {
650 return false;
651 }
652 }
653 true
654 }
655 }
656
657 impl<'a> fmt::Debug for ModuleData<'a> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result658 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
659 write!(f, "{:?}", self.res())
660 }
661 }
662
663 /// Records a possibly-private value, type, or module definition.
664 #[derive(Clone, Debug)]
665 pub struct NameBinding<'a> {
666 kind: NameBindingKind<'a>,
667 ambiguity: Option<(&'a NameBinding<'a>, AmbiguityKind)>,
668 expansion: LocalExpnId,
669 span: Span,
670 vis: ty::Visibility,
671 }
672
673 pub trait ToNameBinding<'a> {
to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a>674 fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a>;
675 }
676
677 impl<'a> ToNameBinding<'a> for &'a NameBinding<'a> {
to_name_binding(self, _: &'a ResolverArenas<'a>) -> &'a NameBinding<'a>678 fn to_name_binding(self, _: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
679 self
680 }
681 }
682
683 #[derive(Clone, Debug)]
684 enum NameBindingKind<'a> {
685 Res(Res, /* is_macro_export */ bool),
686 Module(Module<'a>),
687 Import { binding: &'a NameBinding<'a>, import: &'a Import<'a>, used: Cell<bool> },
688 }
689
690 impl<'a> NameBindingKind<'a> {
691 /// Is this a name binding of an import?
is_import(&self) -> bool692 fn is_import(&self) -> bool {
693 matches!(*self, NameBindingKind::Import { .. })
694 }
695 }
696
697 struct PrivacyError<'a> {
698 ident: Ident,
699 binding: &'a NameBinding<'a>,
700 dedup_span: Span,
701 }
702
703 struct UseError<'a> {
704 err: DiagnosticBuilder<'a>,
705 /// Candidates which user could `use` to access the missing type.
706 candidates: Vec<ImportSuggestion>,
707 /// The `DefId` of the module to place the use-statements in.
708 def_id: DefId,
709 /// Whether the diagnostic should say "instead" (as in `consider importing ... instead`).
710 instead: bool,
711 /// Extra free-form suggestion.
712 suggestion: Option<(Span, &'static str, String, Applicability)>,
713 }
714
715 #[derive(Clone, Copy, PartialEq, Debug)]
716 enum AmbiguityKind {
717 Import,
718 BuiltinAttr,
719 DeriveHelper,
720 MacroRulesVsModularized,
721 GlobVsOuter,
722 GlobVsGlob,
723 GlobVsExpanded,
724 MoreExpandedVsOuter,
725 }
726
727 impl AmbiguityKind {
descr(self) -> &'static str728 fn descr(self) -> &'static str {
729 match self {
730 AmbiguityKind::Import => "multiple potential import sources",
731 AmbiguityKind::BuiltinAttr => "a name conflict with a builtin attribute",
732 AmbiguityKind::DeriveHelper => "a name conflict with a derive helper attribute",
733 AmbiguityKind::MacroRulesVsModularized => {
734 "a conflict between a `macro_rules` name and a non-`macro_rules` name from another module"
735 }
736 AmbiguityKind::GlobVsOuter => {
737 "a conflict between a name from a glob import and an outer scope during import or macro resolution"
738 }
739 AmbiguityKind::GlobVsGlob => "multiple glob imports of a name in the same module",
740 AmbiguityKind::GlobVsExpanded => {
741 "a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution"
742 }
743 AmbiguityKind::MoreExpandedVsOuter => {
744 "a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution"
745 }
746 }
747 }
748 }
749
750 /// Miscellaneous bits of metadata for better ambiguity error reporting.
751 #[derive(Clone, Copy, PartialEq)]
752 enum AmbiguityErrorMisc {
753 SuggestCrate,
754 SuggestSelf,
755 FromPrelude,
756 None,
757 }
758
759 struct AmbiguityError<'a> {
760 kind: AmbiguityKind,
761 ident: Ident,
762 b1: &'a NameBinding<'a>,
763 b2: &'a NameBinding<'a>,
764 misc1: AmbiguityErrorMisc,
765 misc2: AmbiguityErrorMisc,
766 }
767
768 impl<'a> NameBinding<'a> {
module(&self) -> Option<Module<'a>>769 fn module(&self) -> Option<Module<'a>> {
770 match self.kind {
771 NameBindingKind::Module(module) => Some(module),
772 NameBindingKind::Import { binding, .. } => binding.module(),
773 _ => None,
774 }
775 }
776
res(&self) -> Res777 fn res(&self) -> Res {
778 match self.kind {
779 NameBindingKind::Res(res, _) => res,
780 NameBindingKind::Module(module) => module.res().unwrap(),
781 NameBindingKind::Import { binding, .. } => binding.res(),
782 }
783 }
784
is_ambiguity(&self) -> bool785 fn is_ambiguity(&self) -> bool {
786 self.ambiguity.is_some()
787 || match self.kind {
788 NameBindingKind::Import { binding, .. } => binding.is_ambiguity(),
789 _ => false,
790 }
791 }
792
is_possibly_imported_variant(&self) -> bool793 fn is_possibly_imported_variant(&self) -> bool {
794 match self.kind {
795 NameBindingKind::Import { binding, .. } => binding.is_possibly_imported_variant(),
796 NameBindingKind::Res(
797 Res::Def(DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..), _),
798 _,
799 ) => true,
800 NameBindingKind::Res(..) | NameBindingKind::Module(..) => false,
801 }
802 }
803
is_extern_crate(&self) -> bool804 fn is_extern_crate(&self) -> bool {
805 match self.kind {
806 NameBindingKind::Import {
807 import: &Import { kind: ImportKind::ExternCrate { .. }, .. },
808 ..
809 } => true,
810 NameBindingKind::Module(&ModuleData {
811 kind: ModuleKind::Def(DefKind::Mod, def_id, _),
812 ..
813 }) => def_id.index == CRATE_DEF_INDEX,
814 _ => false,
815 }
816 }
817
is_import(&self) -> bool818 fn is_import(&self) -> bool {
819 matches!(self.kind, NameBindingKind::Import { .. })
820 }
821
is_glob_import(&self) -> bool822 fn is_glob_import(&self) -> bool {
823 match self.kind {
824 NameBindingKind::Import { import, .. } => import.is_glob(),
825 _ => false,
826 }
827 }
828
is_importable(&self) -> bool829 fn is_importable(&self) -> bool {
830 !matches!(
831 self.res(),
832 Res::Def(DefKind::AssocConst | DefKind::AssocFn | DefKind::AssocTy, _)
833 )
834 }
835
is_macro_def(&self) -> bool836 fn is_macro_def(&self) -> bool {
837 matches!(self.kind, NameBindingKind::Res(Res::Def(DefKind::Macro(..), _), _))
838 }
839
macro_kind(&self) -> Option<MacroKind>840 fn macro_kind(&self) -> Option<MacroKind> {
841 self.res().macro_kind()
842 }
843
844 // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
845 // at some expansion round `max(invoc, binding)` when they both emerged from macros.
846 // Then this function returns `true` if `self` may emerge from a macro *after* that
847 // in some later round and screw up our previously found resolution.
848 // See more detailed explanation in
849 // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
may_appear_after( &self, invoc_parent_expansion: LocalExpnId, binding: &NameBinding<'_>, ) -> bool850 fn may_appear_after(
851 &self,
852 invoc_parent_expansion: LocalExpnId,
853 binding: &NameBinding<'_>,
854 ) -> bool {
855 // self > max(invoc, binding) => !(self <= invoc || self <= binding)
856 // Expansions are partially ordered, so "may appear after" is an inversion of
857 // "certainly appears before or simultaneously" and includes unordered cases.
858 let self_parent_expansion = self.expansion;
859 let other_parent_expansion = binding.expansion;
860 let certainly_before_other_or_simultaneously =
861 other_parent_expansion.is_descendant_of(self_parent_expansion);
862 let certainly_before_invoc_or_simultaneously =
863 invoc_parent_expansion.is_descendant_of(self_parent_expansion);
864 !(certainly_before_other_or_simultaneously || certainly_before_invoc_or_simultaneously)
865 }
866 }
867
868 #[derive(Debug, Default, Clone)]
869 pub struct ExternPreludeEntry<'a> {
870 extern_crate_item: Option<&'a NameBinding<'a>>,
871 pub introduced_by_item: bool,
872 }
873
874 /// Used for better errors for E0773
875 enum BuiltinMacroState {
876 NotYetSeen(SyntaxExtensionKind),
877 AlreadySeen(Span),
878 }
879
880 struct DeriveData {
881 resolutions: DeriveResolutions,
882 helper_attrs: Vec<(usize, Ident)>,
883 has_derive_copy: bool,
884 }
885
886 /// The main resolver class.
887 ///
888 /// This is the visitor that walks the whole crate.
889 pub struct Resolver<'a> {
890 session: &'a Session,
891
892 definitions: Definitions,
893
894 graph_root: Module<'a>,
895
896 prelude: Option<Module<'a>>,
897 extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>,
898
899 /// N.B., this is used only for better diagnostics, not name resolution itself.
900 has_self: FxHashSet<DefId>,
901
902 /// Names of fields of an item `DefId` accessible with dot syntax.
903 /// Used for hints during error reporting.
904 field_names: FxHashMap<DefId, Vec<Spanned<Symbol>>>,
905
906 /// All imports known to succeed or fail.
907 determined_imports: Vec<&'a Import<'a>>,
908
909 /// All non-determined imports.
910 indeterminate_imports: Vec<&'a Import<'a>>,
911
912 /// FIXME: Refactor things so that these fields are passed through arguments and not resolver.
913 /// We are resolving a last import segment during import validation.
914 last_import_segment: bool,
915 /// This binding should be ignored during in-module resolution, so that we don't get
916 /// "self-confirming" import resolutions during import validation.
917 unusable_binding: Option<&'a NameBinding<'a>>,
918
919 // Spans for local variables found during pattern resolution.
920 // Used for suggestions during error reporting.
921 pat_span_map: NodeMap<Span>,
922
923 /// Resolutions for nodes that have a single resolution.
924 partial_res_map: NodeMap<PartialRes>,
925 /// Resolutions for import nodes, which have multiple resolutions in different namespaces.
926 import_res_map: NodeMap<PerNS<Option<Res>>>,
927 /// Resolutions for labels (node IDs of their corresponding blocks or loops).
928 label_res_map: NodeMap<NodeId>,
929
930 /// `CrateNum` resolutions of `extern crate` items.
931 extern_crate_map: FxHashMap<LocalDefId, CrateNum>,
932 export_map: ExportMap,
933 trait_map: NodeMap<Vec<TraitCandidate>>,
934
935 /// A map from nodes to anonymous modules.
936 /// Anonymous modules are pseudo-modules that are implicitly created around items
937 /// contained within blocks.
938 ///
939 /// For example, if we have this:
940 ///
941 /// fn f() {
942 /// fn g() {
943 /// ...
944 /// }
945 /// }
946 ///
947 /// There will be an anonymous module created around `g` with the ID of the
948 /// entry block for `f`.
949 block_map: NodeMap<Module<'a>>,
950 /// A fake module that contains no definition and no prelude. Used so that
951 /// some AST passes can generate identifiers that only resolve to local or
952 /// language items.
953 empty_module: Module<'a>,
954 module_map: FxHashMap<DefId, Module<'a>>,
955 binding_parent_modules: FxHashMap<PtrKey<'a, NameBinding<'a>>, Module<'a>>,
956 underscore_disambiguator: u32,
957
958 /// Maps glob imports to the names of items actually imported.
959 glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,
960 /// Visibilities in "lowered" form, for all entities that have them.
961 visibilities: FxHashMap<LocalDefId, ty::Visibility>,
962 used_imports: FxHashSet<NodeId>,
963 maybe_unused_trait_imports: FxHashSet<LocalDefId>,
964 maybe_unused_extern_crates: Vec<(LocalDefId, Span)>,
965
966 /// Privacy errors are delayed until the end in order to deduplicate them.
967 privacy_errors: Vec<PrivacyError<'a>>,
968 /// Ambiguity errors are delayed for deduplication.
969 ambiguity_errors: Vec<AmbiguityError<'a>>,
970 /// `use` injections are delayed for better placement and deduplication.
971 use_injections: Vec<UseError<'a>>,
972 /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
973 macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>,
974
975 arenas: &'a ResolverArenas<'a>,
976 dummy_binding: &'a NameBinding<'a>,
977
978 crate_loader: CrateLoader<'a>,
979 macro_names: FxHashSet<Ident>,
980 builtin_macros: FxHashMap<Symbol, BuiltinMacroState>,
981 registered_attrs: FxHashSet<Ident>,
982 registered_tools: FxHashSet<Ident>,
983 macro_use_prelude: FxHashMap<Symbol, &'a NameBinding<'a>>,
984 all_macros: FxHashMap<Symbol, Res>,
985 macro_map: FxHashMap<DefId, Lrc<SyntaxExtension>>,
986 dummy_ext_bang: Lrc<SyntaxExtension>,
987 dummy_ext_derive: Lrc<SyntaxExtension>,
988 non_macro_attr: Lrc<SyntaxExtension>,
989 local_macro_def_scopes: FxHashMap<LocalDefId, Module<'a>>,
990 ast_transform_scopes: FxHashMap<LocalExpnId, Module<'a>>,
991 unused_macros: FxHashMap<LocalDefId, (NodeId, Ident)>,
992 proc_macro_stubs: FxHashSet<LocalDefId>,
993 /// Traces collected during macro resolution and validated when it's complete.
994 single_segment_macro_resolutions:
995 Vec<(Ident, MacroKind, ParentScope<'a>, Option<&'a NameBinding<'a>>)>,
996 multi_segment_macro_resolutions:
997 Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'a>, Option<Res>)>,
998 builtin_attrs: Vec<(Ident, ParentScope<'a>)>,
999 /// `derive(Copy)` marks items they are applied to so they are treated specially later.
1000 /// Derive macros cannot modify the item themselves and have to store the markers in the global
1001 /// context, so they attach the markers to derive container IDs using this resolver table.
1002 containers_deriving_copy: FxHashSet<LocalExpnId>,
1003 /// Parent scopes in which the macros were invoked.
1004 /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
1005 invocation_parent_scopes: FxHashMap<LocalExpnId, ParentScope<'a>>,
1006 /// `macro_rules` scopes *produced* by expanding the macro invocations,
1007 /// include all the `macro_rules` items and other invocations generated by them.
1008 output_macro_rules_scopes: FxHashMap<LocalExpnId, MacroRulesScopeRef<'a>>,
1009 /// Helper attributes that are in scope for the given expansion.
1010 helper_attrs: FxHashMap<LocalExpnId, Vec<Ident>>,
1011 /// Ready or in-progress results of resolving paths inside the `#[derive(...)]` attribute
1012 /// with the given `ExpnId`.
1013 derive_data: FxHashMap<LocalExpnId, DeriveData>,
1014
1015 /// Avoid duplicated errors for "name already defined".
1016 name_already_seen: FxHashMap<Symbol, Span>,
1017
1018 potentially_unused_imports: Vec<&'a Import<'a>>,
1019
1020 /// Table for mapping struct IDs into struct constructor IDs,
1021 /// it's not used during normal resolution, only for better error reporting.
1022 /// Also includes of list of each fields visibility
1023 struct_constructors: DefIdMap<(Res, ty::Visibility, Vec<ty::Visibility>)>,
1024
1025 /// Features enabled for this crate.
1026 active_features: FxHashSet<Symbol>,
1027
1028 lint_buffer: LintBuffer,
1029
1030 next_node_id: NodeId,
1031
1032 node_id_to_def_id: FxHashMap<ast::NodeId, LocalDefId>,
1033 def_id_to_node_id: IndexVec<LocalDefId, ast::NodeId>,
1034
1035 /// Indices of unnamed struct or variant fields with unresolved attributes.
1036 placeholder_field_indices: FxHashMap<NodeId, usize>,
1037 /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
1038 /// we know what parent node that fragment should be attached to thanks to this table,
1039 /// and how the `impl Trait` fragments were introduced.
1040 invocation_parents: FxHashMap<LocalExpnId, (LocalDefId, ImplTraitContext)>,
1041
1042 next_disambiguator: FxHashMap<(LocalDefId, DefPathData), u32>,
1043 /// Some way to know that we are in a *trait* impl in `visit_assoc_item`.
1044 /// FIXME: Replace with a more general AST map (together with some other fields).
1045 trait_impl_items: FxHashSet<LocalDefId>,
1046
1047 legacy_const_generic_args: FxHashMap<DefId, Option<Vec<usize>>>,
1048 /// Amount of lifetime parameters for each item in the crate.
1049 item_generics_num_lifetimes: FxHashMap<LocalDefId, usize>,
1050
1051 main_def: Option<MainDefinition>,
1052 trait_impls: BTreeMap<DefId, Vec<LocalDefId>>,
1053 /// A list of proc macro LocalDefIds, written out in the order in which
1054 /// they are declared in the static array generated by proc_macro_harness.
1055 proc_macros: Vec<NodeId>,
1056 confused_type_with_std_module: FxHashMap<Span, Span>,
1057 }
1058
1059 /// Nothing really interesting here; it just provides memory for the rest of the crate.
1060 #[derive(Default)]
1061 pub struct ResolverArenas<'a> {
1062 modules: TypedArena<ModuleData<'a>>,
1063 local_modules: RefCell<Vec<Module<'a>>>,
1064 imports: TypedArena<Import<'a>>,
1065 name_resolutions: TypedArena<RefCell<NameResolution<'a>>>,
1066 ast_paths: TypedArena<ast::Path>,
1067 dropless: DroplessArena,
1068 }
1069
1070 impl<'a> ResolverArenas<'a> {
new_module( &'a self, parent: Option<Module<'a>>, kind: ModuleKind, expn_id: ExpnId, span: Span, no_implicit_prelude: bool, module_map: &mut FxHashMap<DefId, Module<'a>>, ) -> Module<'a>1071 fn new_module(
1072 &'a self,
1073 parent: Option<Module<'a>>,
1074 kind: ModuleKind,
1075 expn_id: ExpnId,
1076 span: Span,
1077 no_implicit_prelude: bool,
1078 module_map: &mut FxHashMap<DefId, Module<'a>>,
1079 ) -> Module<'a> {
1080 let module =
1081 self.modules.alloc(ModuleData::new(parent, kind, expn_id, span, no_implicit_prelude));
1082 let def_id = module.opt_def_id();
1083 if def_id.map_or(true, |def_id| def_id.is_local()) {
1084 self.local_modules.borrow_mut().push(module);
1085 }
1086 if let Some(def_id) = def_id {
1087 module_map.insert(def_id, module);
1088 }
1089 module
1090 }
local_modules(&'a self) -> std::cell::Ref<'a, Vec<Module<'a>>>1091 fn local_modules(&'a self) -> std::cell::Ref<'a, Vec<Module<'a>>> {
1092 self.local_modules.borrow()
1093 }
alloc_name_binding(&'a self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a>1094 fn alloc_name_binding(&'a self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a> {
1095 self.dropless.alloc(name_binding)
1096 }
alloc_import(&'a self, import: Import<'a>) -> &'a Import<'_>1097 fn alloc_import(&'a self, import: Import<'a>) -> &'a Import<'_> {
1098 self.imports.alloc(import)
1099 }
alloc_name_resolution(&'a self) -> &'a RefCell<NameResolution<'a>>1100 fn alloc_name_resolution(&'a self) -> &'a RefCell<NameResolution<'a>> {
1101 self.name_resolutions.alloc(Default::default())
1102 }
alloc_macro_rules_scope(&'a self, scope: MacroRulesScope<'a>) -> MacroRulesScopeRef<'a>1103 fn alloc_macro_rules_scope(&'a self, scope: MacroRulesScope<'a>) -> MacroRulesScopeRef<'a> {
1104 PtrKey(self.dropless.alloc(Cell::new(scope)))
1105 }
alloc_macro_rules_binding( &'a self, binding: MacroRulesBinding<'a>, ) -> &'a MacroRulesBinding<'a>1106 fn alloc_macro_rules_binding(
1107 &'a self,
1108 binding: MacroRulesBinding<'a>,
1109 ) -> &'a MacroRulesBinding<'a> {
1110 self.dropless.alloc(binding)
1111 }
alloc_ast_paths(&'a self, paths: &[ast::Path]) -> &'a [ast::Path]1112 fn alloc_ast_paths(&'a self, paths: &[ast::Path]) -> &'a [ast::Path] {
1113 self.ast_paths.alloc_from_iter(paths.iter().cloned())
1114 }
alloc_pattern_spans(&'a self, spans: impl Iterator<Item = Span>) -> &'a [Span]1115 fn alloc_pattern_spans(&'a self, spans: impl Iterator<Item = Span>) -> &'a [Span] {
1116 self.dropless.alloc_from_iter(spans)
1117 }
1118 }
1119
1120 impl<'a> AsMut<Resolver<'a>> for Resolver<'a> {
as_mut(&mut self) -> &mut Resolver<'a>1121 fn as_mut(&mut self) -> &mut Resolver<'a> {
1122 self
1123 }
1124 }
1125
1126 impl<'a, 'b> DefIdTree for &'a Resolver<'b> {
parent(self, id: DefId) -> Option<DefId>1127 fn parent(self, id: DefId) -> Option<DefId> {
1128 match id.as_local() {
1129 Some(id) => self.definitions.def_key(id).parent,
1130 None => self.cstore().def_key(id).parent,
1131 }
1132 .map(|index| DefId { index, ..id })
1133 }
1134 }
1135
1136 /// This interface is used through the AST→HIR step, to embed full paths into the HIR. After that
1137 /// the resolver is no longer needed as all the relevant information is inline.
1138 impl ResolverAstLowering for Resolver<'_> {
def_key(&mut self, id: DefId) -> DefKey1139 fn def_key(&mut self, id: DefId) -> DefKey {
1140 if let Some(id) = id.as_local() {
1141 self.definitions().def_key(id)
1142 } else {
1143 self.cstore().def_key(id)
1144 }
1145 }
1146
1147 #[inline]
def_span(&self, id: LocalDefId) -> Span1148 fn def_span(&self, id: LocalDefId) -> Span {
1149 self.definitions.def_span(id)
1150 }
1151
item_generics_num_lifetimes(&self, def_id: DefId) -> usize1152 fn item_generics_num_lifetimes(&self, def_id: DefId) -> usize {
1153 if let Some(def_id) = def_id.as_local() {
1154 self.item_generics_num_lifetimes[&def_id]
1155 } else {
1156 self.cstore().item_generics_num_lifetimes(def_id, self.session)
1157 }
1158 }
1159
legacy_const_generic_args(&mut self, expr: &Expr) -> Option<Vec<usize>>1160 fn legacy_const_generic_args(&mut self, expr: &Expr) -> Option<Vec<usize>> {
1161 self.legacy_const_generic_args(expr)
1162 }
1163
get_partial_res(&self, id: NodeId) -> Option<PartialRes>1164 fn get_partial_res(&self, id: NodeId) -> Option<PartialRes> {
1165 self.partial_res_map.get(&id).cloned()
1166 }
1167
get_import_res(&mut self, id: NodeId) -> PerNS<Option<Res>>1168 fn get_import_res(&mut self, id: NodeId) -> PerNS<Option<Res>> {
1169 self.import_res_map.get(&id).cloned().unwrap_or_default()
1170 }
1171
get_label_res(&mut self, id: NodeId) -> Option<NodeId>1172 fn get_label_res(&mut self, id: NodeId) -> Option<NodeId> {
1173 self.label_res_map.get(&id).cloned()
1174 }
1175
definitions(&mut self) -> &mut Definitions1176 fn definitions(&mut self) -> &mut Definitions {
1177 &mut self.definitions
1178 }
1179
create_stable_hashing_context(&self) -> StableHashingContext<'_>1180 fn create_stable_hashing_context(&self) -> StableHashingContext<'_> {
1181 StableHashingContext::new(self.session, &self.definitions, self.crate_loader.cstore())
1182 }
1183
lint_buffer(&mut self) -> &mut LintBuffer1184 fn lint_buffer(&mut self) -> &mut LintBuffer {
1185 &mut self.lint_buffer
1186 }
1187
next_node_id(&mut self) -> NodeId1188 fn next_node_id(&mut self) -> NodeId {
1189 self.next_node_id()
1190 }
1191
take_trait_map(&mut self, node: NodeId) -> Option<Vec<TraitCandidate>>1192 fn take_trait_map(&mut self, node: NodeId) -> Option<Vec<TraitCandidate>> {
1193 self.trait_map.remove(&node)
1194 }
1195
opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>1196 fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
1197 self.node_id_to_def_id.get(&node).copied()
1198 }
1199
local_def_id(&self, node: NodeId) -> LocalDefId1200 fn local_def_id(&self, node: NodeId) -> LocalDefId {
1201 self.opt_local_def_id(node).unwrap_or_else(|| panic!("no entry for node id: `{:?}`", node))
1202 }
1203
def_path_hash(&self, def_id: DefId) -> DefPathHash1204 fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
1205 match def_id.as_local() {
1206 Some(def_id) => self.definitions.def_path_hash(def_id),
1207 None => self.cstore().def_path_hash(def_id),
1208 }
1209 }
1210
1211 /// Adds a definition with a parent definition.
create_def( &mut self, parent: LocalDefId, node_id: ast::NodeId, data: DefPathData, expn_id: ExpnId, span: Span, ) -> LocalDefId1212 fn create_def(
1213 &mut self,
1214 parent: LocalDefId,
1215 node_id: ast::NodeId,
1216 data: DefPathData,
1217 expn_id: ExpnId,
1218 span: Span,
1219 ) -> LocalDefId {
1220 assert!(
1221 !self.node_id_to_def_id.contains_key(&node_id),
1222 "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
1223 node_id,
1224 data,
1225 self.definitions.def_key(self.node_id_to_def_id[&node_id]),
1226 );
1227
1228 // Find the next free disambiguator for this key.
1229 let next_disambiguator = &mut self.next_disambiguator;
1230 let next_disambiguator = |parent, data| {
1231 let next_disamb = next_disambiguator.entry((parent, data)).or_insert(0);
1232 let disambiguator = *next_disamb;
1233 *next_disamb = next_disamb.checked_add(1).expect("disambiguator overflow");
1234 disambiguator
1235 };
1236
1237 let def_id = self.definitions.create_def(parent, data, expn_id, next_disambiguator, span);
1238
1239 // Some things for which we allocate `LocalDefId`s don't correspond to
1240 // anything in the AST, so they don't have a `NodeId`. For these cases
1241 // we don't need a mapping from `NodeId` to `LocalDefId`.
1242 if node_id != ast::DUMMY_NODE_ID {
1243 debug!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id, node_id);
1244 self.node_id_to_def_id.insert(node_id, def_id);
1245 }
1246 assert_eq!(self.def_id_to_node_id.push(node_id), def_id);
1247
1248 def_id
1249 }
1250 }
1251
1252 impl<'a> Resolver<'a> {
new( session: &'a Session, krate: &Crate, crate_name: &str, metadata_loader: Box<MetadataLoaderDyn>, arenas: &'a ResolverArenas<'a>, ) -> Resolver<'a>1253 pub fn new(
1254 session: &'a Session,
1255 krate: &Crate,
1256 crate_name: &str,
1257 metadata_loader: Box<MetadataLoaderDyn>,
1258 arenas: &'a ResolverArenas<'a>,
1259 ) -> Resolver<'a> {
1260 let root_def_id = CRATE_DEF_ID.to_def_id();
1261 let mut module_map = FxHashMap::default();
1262 let graph_root = arenas.new_module(
1263 None,
1264 ModuleKind::Def(DefKind::Mod, root_def_id, kw::Empty),
1265 ExpnId::root(),
1266 krate.span,
1267 session.contains_name(&krate.attrs, sym::no_implicit_prelude),
1268 &mut module_map,
1269 );
1270 let empty_module = arenas.new_module(
1271 None,
1272 ModuleKind::Def(DefKind::Mod, root_def_id, kw::Empty),
1273 ExpnId::root(),
1274 DUMMY_SP,
1275 true,
1276 &mut FxHashMap::default(),
1277 );
1278
1279 let definitions = Definitions::new(session.local_stable_crate_id(), krate.span);
1280 let root = definitions.get_root_def();
1281
1282 let mut visibilities = FxHashMap::default();
1283 visibilities.insert(CRATE_DEF_ID, ty::Visibility::Public);
1284
1285 let mut def_id_to_node_id = IndexVec::default();
1286 assert_eq!(def_id_to_node_id.push(CRATE_NODE_ID), root);
1287 let mut node_id_to_def_id = FxHashMap::default();
1288 node_id_to_def_id.insert(CRATE_NODE_ID, root);
1289
1290 let mut invocation_parents = FxHashMap::default();
1291 invocation_parents.insert(LocalExpnId::ROOT, (root, ImplTraitContext::Existential));
1292
1293 let mut extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'_>> = session
1294 .opts
1295 .externs
1296 .iter()
1297 .filter(|(_, entry)| entry.add_prelude)
1298 .map(|(name, _)| (Ident::from_str(name), Default::default()))
1299 .collect();
1300
1301 if !session.contains_name(&krate.attrs, sym::no_core) {
1302 extern_prelude.insert(Ident::with_dummy_span(sym::core), Default::default());
1303 if !session.contains_name(&krate.attrs, sym::no_std) {
1304 extern_prelude.insert(Ident::with_dummy_span(sym::std), Default::default());
1305 }
1306 }
1307
1308 let (registered_attrs, registered_tools) =
1309 macros::registered_attrs_and_tools(session, &krate.attrs);
1310
1311 let features = session.features_untracked();
1312
1313 let mut resolver = Resolver {
1314 session,
1315
1316 definitions,
1317
1318 // The outermost module has def ID 0; this is not reflected in the
1319 // AST.
1320 graph_root,
1321 prelude: None,
1322 extern_prelude,
1323
1324 has_self: FxHashSet::default(),
1325 field_names: FxHashMap::default(),
1326
1327 determined_imports: Vec::new(),
1328 indeterminate_imports: Vec::new(),
1329
1330 last_import_segment: false,
1331 unusable_binding: None,
1332
1333 pat_span_map: Default::default(),
1334 partial_res_map: Default::default(),
1335 import_res_map: Default::default(),
1336 label_res_map: Default::default(),
1337 extern_crate_map: Default::default(),
1338 export_map: FxHashMap::default(),
1339 trait_map: NodeMap::default(),
1340 underscore_disambiguator: 0,
1341 empty_module,
1342 module_map,
1343 block_map: Default::default(),
1344 binding_parent_modules: FxHashMap::default(),
1345 ast_transform_scopes: FxHashMap::default(),
1346
1347 glob_map: Default::default(),
1348 visibilities,
1349 used_imports: FxHashSet::default(),
1350 maybe_unused_trait_imports: Default::default(),
1351 maybe_unused_extern_crates: Vec::new(),
1352
1353 privacy_errors: Vec::new(),
1354 ambiguity_errors: Vec::new(),
1355 use_injections: Vec::new(),
1356 macro_expanded_macro_export_errors: BTreeSet::new(),
1357
1358 arenas,
1359 dummy_binding: arenas.alloc_name_binding(NameBinding {
1360 kind: NameBindingKind::Res(Res::Err, false),
1361 ambiguity: None,
1362 expansion: LocalExpnId::ROOT,
1363 span: DUMMY_SP,
1364 vis: ty::Visibility::Public,
1365 }),
1366
1367 crate_loader: CrateLoader::new(session, metadata_loader, crate_name),
1368 macro_names: FxHashSet::default(),
1369 builtin_macros: Default::default(),
1370 registered_attrs,
1371 registered_tools,
1372 macro_use_prelude: FxHashMap::default(),
1373 all_macros: FxHashMap::default(),
1374 macro_map: FxHashMap::default(),
1375 dummy_ext_bang: Lrc::new(SyntaxExtension::dummy_bang(session.edition())),
1376 dummy_ext_derive: Lrc::new(SyntaxExtension::dummy_derive(session.edition())),
1377 non_macro_attr: Lrc::new(SyntaxExtension::non_macro_attr(session.edition())),
1378 invocation_parent_scopes: Default::default(),
1379 output_macro_rules_scopes: Default::default(),
1380 helper_attrs: Default::default(),
1381 derive_data: Default::default(),
1382 local_macro_def_scopes: FxHashMap::default(),
1383 name_already_seen: FxHashMap::default(),
1384 potentially_unused_imports: Vec::new(),
1385 struct_constructors: Default::default(),
1386 unused_macros: Default::default(),
1387 proc_macro_stubs: Default::default(),
1388 single_segment_macro_resolutions: Default::default(),
1389 multi_segment_macro_resolutions: Default::default(),
1390 builtin_attrs: Default::default(),
1391 containers_deriving_copy: Default::default(),
1392 active_features: features
1393 .declared_lib_features
1394 .iter()
1395 .map(|(feat, ..)| *feat)
1396 .chain(features.declared_lang_features.iter().map(|(feat, ..)| *feat))
1397 .collect(),
1398 lint_buffer: LintBuffer::default(),
1399 next_node_id: NodeId::from_u32(1),
1400 node_id_to_def_id,
1401 def_id_to_node_id,
1402 placeholder_field_indices: Default::default(),
1403 invocation_parents,
1404 next_disambiguator: Default::default(),
1405 trait_impl_items: Default::default(),
1406 legacy_const_generic_args: Default::default(),
1407 item_generics_num_lifetimes: Default::default(),
1408 main_def: Default::default(),
1409 trait_impls: Default::default(),
1410 proc_macros: Default::default(),
1411 confused_type_with_std_module: Default::default(),
1412 };
1413
1414 let root_parent_scope = ParentScope::module(graph_root, &resolver);
1415 resolver.invocation_parent_scopes.insert(LocalExpnId::ROOT, root_parent_scope);
1416
1417 resolver
1418 }
1419
new_module( &mut self, parent: Option<Module<'a>>, kind: ModuleKind, expn_id: ExpnId, span: Span, no_implicit_prelude: bool, ) -> Module<'a>1420 fn new_module(
1421 &mut self,
1422 parent: Option<Module<'a>>,
1423 kind: ModuleKind,
1424 expn_id: ExpnId,
1425 span: Span,
1426 no_implicit_prelude: bool,
1427 ) -> Module<'a> {
1428 let module_map = &mut self.module_map;
1429 self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude, module_map)
1430 }
1431
next_node_id(&mut self) -> NodeId1432 pub fn next_node_id(&mut self) -> NodeId {
1433 let next = self
1434 .next_node_id
1435 .as_usize()
1436 .checked_add(1)
1437 .expect("input too large; ran out of NodeIds");
1438 self.next_node_id = ast::NodeId::from_usize(next);
1439 self.next_node_id
1440 }
1441
lint_buffer(&mut self) -> &mut LintBuffer1442 pub fn lint_buffer(&mut self) -> &mut LintBuffer {
1443 &mut self.lint_buffer
1444 }
1445
arenas() -> ResolverArenas<'a>1446 pub fn arenas() -> ResolverArenas<'a> {
1447 Default::default()
1448 }
1449
into_outputs(self) -> ResolverOutputs1450 pub fn into_outputs(self) -> ResolverOutputs {
1451 let proc_macros = self.proc_macros.iter().map(|id| self.local_def_id(*id)).collect();
1452 let definitions = self.definitions;
1453 let visibilities = self.visibilities;
1454 let extern_crate_map = self.extern_crate_map;
1455 let export_map = self.export_map;
1456 let maybe_unused_trait_imports = self.maybe_unused_trait_imports;
1457 let maybe_unused_extern_crates = self.maybe_unused_extern_crates;
1458 let glob_map = self.glob_map;
1459 let main_def = self.main_def;
1460 let confused_type_with_std_module = self.confused_type_with_std_module;
1461 ResolverOutputs {
1462 definitions,
1463 cstore: Box::new(self.crate_loader.into_cstore()),
1464 visibilities,
1465 extern_crate_map,
1466 export_map,
1467 glob_map,
1468 maybe_unused_trait_imports,
1469 maybe_unused_extern_crates,
1470 extern_prelude: self
1471 .extern_prelude
1472 .iter()
1473 .map(|(ident, entry)| (ident.name, entry.introduced_by_item))
1474 .collect(),
1475 main_def,
1476 trait_impls: self.trait_impls,
1477 proc_macros,
1478 confused_type_with_std_module,
1479 }
1480 }
1481
clone_outputs(&self) -> ResolverOutputs1482 pub fn clone_outputs(&self) -> ResolverOutputs {
1483 let proc_macros = self.proc_macros.iter().map(|id| self.local_def_id(*id)).collect();
1484 ResolverOutputs {
1485 definitions: self.definitions.clone(),
1486 cstore: Box::new(self.cstore().clone()),
1487 visibilities: self.visibilities.clone(),
1488 extern_crate_map: self.extern_crate_map.clone(),
1489 export_map: self.export_map.clone(),
1490 glob_map: self.glob_map.clone(),
1491 maybe_unused_trait_imports: self.maybe_unused_trait_imports.clone(),
1492 maybe_unused_extern_crates: self.maybe_unused_extern_crates.clone(),
1493 extern_prelude: self
1494 .extern_prelude
1495 .iter()
1496 .map(|(ident, entry)| (ident.name, entry.introduced_by_item))
1497 .collect(),
1498 main_def: self.main_def,
1499 trait_impls: self.trait_impls.clone(),
1500 proc_macros,
1501 confused_type_with_std_module: self.confused_type_with_std_module.clone(),
1502 }
1503 }
1504
cstore(&self) -> &CStore1505 pub fn cstore(&self) -> &CStore {
1506 self.crate_loader.cstore()
1507 }
1508
dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension>1509 fn dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension> {
1510 match macro_kind {
1511 MacroKind::Bang => self.dummy_ext_bang.clone(),
1512 MacroKind::Derive => self.dummy_ext_derive.clone(),
1513 MacroKind::Attr => self.non_macro_attr.clone(),
1514 }
1515 }
1516
1517 /// Runs the function on each namespace.
per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, mut f: F)1518 fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, mut f: F) {
1519 f(self, TypeNS);
1520 f(self, ValueNS);
1521 f(self, MacroNS);
1522 }
1523
is_builtin_macro(&mut self, res: Res) -> bool1524 fn is_builtin_macro(&mut self, res: Res) -> bool {
1525 self.get_macro(res).map_or(false, |ext| ext.builtin_name.is_some())
1526 }
1527
macro_def(&self, mut ctxt: SyntaxContext) -> DefId1528 fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId {
1529 loop {
1530 match ctxt.outer_expn_data().macro_def_id {
1531 Some(def_id) => return def_id,
1532 None => ctxt.remove_mark(),
1533 };
1534 }
1535 }
1536
1537 /// Entry point to crate resolution.
resolve_crate(&mut self, krate: &Crate)1538 pub fn resolve_crate(&mut self, krate: &Crate) {
1539 self.session.time("resolve_crate", || {
1540 self.session.time("finalize_imports", || ImportResolver { r: self }.finalize_imports());
1541 self.session.time("finalize_macro_resolutions", || self.finalize_macro_resolutions());
1542 self.session.time("late_resolve_crate", || self.late_resolve_crate(krate));
1543 self.session.time("resolve_main", || self.resolve_main());
1544 self.session.time("resolve_check_unused", || self.check_unused(krate));
1545 self.session.time("resolve_report_errors", || self.report_errors(krate));
1546 self.session.time("resolve_postprocess", || self.crate_loader.postprocess(krate));
1547 });
1548 }
1549
traits_in_scope( &mut self, current_trait: Option<Module<'a>>, parent_scope: &ParentScope<'a>, ctxt: SyntaxContext, assoc_item: Option<(Symbol, Namespace)>, ) -> Vec<TraitCandidate>1550 pub fn traits_in_scope(
1551 &mut self,
1552 current_trait: Option<Module<'a>>,
1553 parent_scope: &ParentScope<'a>,
1554 ctxt: SyntaxContext,
1555 assoc_item: Option<(Symbol, Namespace)>,
1556 ) -> Vec<TraitCandidate> {
1557 let mut found_traits = Vec::new();
1558
1559 if let Some(module) = current_trait {
1560 if self.trait_may_have_item(Some(module), assoc_item) {
1561 let def_id = module.def_id();
1562 found_traits.push(TraitCandidate { def_id, import_ids: smallvec![] });
1563 }
1564 }
1565
1566 self.visit_scopes(ScopeSet::All(TypeNS, false), parent_scope, ctxt, |this, scope, _, _| {
1567 match scope {
1568 Scope::Module(module, _) => {
1569 this.traits_in_module(module, assoc_item, &mut found_traits);
1570 }
1571 Scope::StdLibPrelude => {
1572 if let Some(module) = this.prelude {
1573 this.traits_in_module(module, assoc_item, &mut found_traits);
1574 }
1575 }
1576 Scope::ExternPrelude | Scope::ToolPrelude | Scope::BuiltinTypes => {}
1577 _ => unreachable!(),
1578 }
1579 None::<()>
1580 });
1581
1582 found_traits
1583 }
1584
traits_in_module( &mut self, module: Module<'a>, assoc_item: Option<(Symbol, Namespace)>, found_traits: &mut Vec<TraitCandidate>, )1585 fn traits_in_module(
1586 &mut self,
1587 module: Module<'a>,
1588 assoc_item: Option<(Symbol, Namespace)>,
1589 found_traits: &mut Vec<TraitCandidate>,
1590 ) {
1591 module.ensure_traits(self);
1592 let traits = module.traits.borrow();
1593 for (trait_name, trait_binding) in traits.as_ref().unwrap().iter() {
1594 if self.trait_may_have_item(trait_binding.module(), assoc_item) {
1595 let def_id = trait_binding.res().def_id();
1596 let import_ids = self.find_transitive_imports(&trait_binding.kind, *trait_name);
1597 found_traits.push(TraitCandidate { def_id, import_ids });
1598 }
1599 }
1600 }
1601
1602 // List of traits in scope is pruned on best effort basis. We reject traits not having an
1603 // associated item with the given name and namespace (if specified). This is a conservative
1604 // optimization, proper hygienic type-based resolution of associated items is done in typeck.
1605 // We don't reject trait aliases (`trait_module == None`) because we don't have access to their
1606 // associated items.
trait_may_have_item( &mut self, trait_module: Option<Module<'a>>, assoc_item: Option<(Symbol, Namespace)>, ) -> bool1607 fn trait_may_have_item(
1608 &mut self,
1609 trait_module: Option<Module<'a>>,
1610 assoc_item: Option<(Symbol, Namespace)>,
1611 ) -> bool {
1612 match (trait_module, assoc_item) {
1613 (Some(trait_module), Some((name, ns))) => {
1614 self.resolutions(trait_module).borrow().iter().any(|resolution| {
1615 let (&BindingKey { ident: assoc_ident, ns: assoc_ns, .. }, _) = resolution;
1616 assoc_ns == ns && assoc_ident.name == name
1617 })
1618 }
1619 _ => true,
1620 }
1621 }
1622
find_transitive_imports( &mut self, mut kind: &NameBindingKind<'_>, trait_name: Ident, ) -> SmallVec<[LocalDefId; 1]>1623 fn find_transitive_imports(
1624 &mut self,
1625 mut kind: &NameBindingKind<'_>,
1626 trait_name: Ident,
1627 ) -> SmallVec<[LocalDefId; 1]> {
1628 let mut import_ids = smallvec![];
1629 while let NameBindingKind::Import { import, binding, .. } = kind {
1630 let id = self.local_def_id(import.id);
1631 self.maybe_unused_trait_imports.insert(id);
1632 self.add_to_glob_map(&import, trait_name);
1633 import_ids.push(id);
1634 kind = &binding.kind;
1635 }
1636 import_ids
1637 }
1638
new_key(&mut self, ident: Ident, ns: Namespace) -> BindingKey1639 fn new_key(&mut self, ident: Ident, ns: Namespace) -> BindingKey {
1640 let ident = ident.normalize_to_macros_2_0();
1641 let disambiguator = if ident.name == kw::Underscore {
1642 self.underscore_disambiguator += 1;
1643 self.underscore_disambiguator
1644 } else {
1645 0
1646 };
1647 BindingKey { ident, ns, disambiguator }
1648 }
1649
resolutions(&mut self, module: Module<'a>) -> &'a Resolutions<'a>1650 fn resolutions(&mut self, module: Module<'a>) -> &'a Resolutions<'a> {
1651 if module.populate_on_access.get() {
1652 module.populate_on_access.set(false);
1653 self.build_reduced_graph_external(module);
1654 }
1655 &module.lazy_resolutions
1656 }
1657
resolution( &mut self, module: Module<'a>, key: BindingKey, ) -> &'a RefCell<NameResolution<'a>>1658 fn resolution(
1659 &mut self,
1660 module: Module<'a>,
1661 key: BindingKey,
1662 ) -> &'a RefCell<NameResolution<'a>> {
1663 *self
1664 .resolutions(module)
1665 .borrow_mut()
1666 .entry(key)
1667 .or_insert_with(|| self.arenas.alloc_name_resolution())
1668 }
1669
record_use( &mut self, ident: Ident, used_binding: &'a NameBinding<'a>, is_lexical_scope: bool, )1670 fn record_use(
1671 &mut self,
1672 ident: Ident,
1673 used_binding: &'a NameBinding<'a>,
1674 is_lexical_scope: bool,
1675 ) {
1676 if let Some((b2, kind)) = used_binding.ambiguity {
1677 self.ambiguity_errors.push(AmbiguityError {
1678 kind,
1679 ident,
1680 b1: used_binding,
1681 b2,
1682 misc1: AmbiguityErrorMisc::None,
1683 misc2: AmbiguityErrorMisc::None,
1684 });
1685 }
1686 if let NameBindingKind::Import { import, binding, ref used } = used_binding.kind {
1687 // Avoid marking `extern crate` items that refer to a name from extern prelude,
1688 // but not introduce it, as used if they are accessed from lexical scope.
1689 if is_lexical_scope {
1690 if let Some(entry) = self.extern_prelude.get(&ident.normalize_to_macros_2_0()) {
1691 if let Some(crate_item) = entry.extern_crate_item {
1692 if ptr::eq(used_binding, crate_item) && !entry.introduced_by_item {
1693 return;
1694 }
1695 }
1696 }
1697 }
1698 used.set(true);
1699 import.used.set(true);
1700 self.used_imports.insert(import.id);
1701 self.add_to_glob_map(&import, ident);
1702 self.record_use(ident, binding, false);
1703 }
1704 }
1705
1706 #[inline]
add_to_glob_map(&mut self, import: &Import<'_>, ident: Ident)1707 fn add_to_glob_map(&mut self, import: &Import<'_>, ident: Ident) {
1708 if import.is_glob() {
1709 let def_id = self.local_def_id(import.id);
1710 self.glob_map.entry(def_id).or_default().insert(ident.name);
1711 }
1712 }
1713
1714 /// A generic scope visitor.
1715 /// Visits scopes in order to resolve some identifier in them or perform other actions.
1716 /// If the callback returns `Some` result, we stop visiting scopes and return it.
visit_scopes<T>( &mut self, scope_set: ScopeSet<'a>, parent_scope: &ParentScope<'a>, ctxt: SyntaxContext, mut visitor: impl FnMut( &mut Self, Scope<'a>, bool, SyntaxContext, ) -> Option<T>, ) -> Option<T>1717 fn visit_scopes<T>(
1718 &mut self,
1719 scope_set: ScopeSet<'a>,
1720 parent_scope: &ParentScope<'a>,
1721 ctxt: SyntaxContext,
1722 mut visitor: impl FnMut(
1723 &mut Self,
1724 Scope<'a>,
1725 /*use_prelude*/ bool,
1726 SyntaxContext,
1727 ) -> Option<T>,
1728 ) -> Option<T> {
1729 // General principles:
1730 // 1. Not controlled (user-defined) names should have higher priority than controlled names
1731 // built into the language or standard library. This way we can add new names into the
1732 // language or standard library without breaking user code.
1733 // 2. "Closed set" below means new names cannot appear after the current resolution attempt.
1734 // Places to search (in order of decreasing priority):
1735 // (Type NS)
1736 // 1. FIXME: Ribs (type parameters), there's no necessary infrastructure yet
1737 // (open set, not controlled).
1738 // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1739 // (open, not controlled).
1740 // 3. Extern prelude (open, the open part is from macro expansions, not controlled).
1741 // 4. Tool modules (closed, controlled right now, but not in the future).
1742 // 5. Standard library prelude (de-facto closed, controlled).
1743 // 6. Language prelude (closed, controlled).
1744 // (Value NS)
1745 // 1. FIXME: Ribs (local variables), there's no necessary infrastructure yet
1746 // (open set, not controlled).
1747 // 2. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1748 // (open, not controlled).
1749 // 3. Standard library prelude (de-facto closed, controlled).
1750 // (Macro NS)
1751 // 1-3. Derive helpers (open, not controlled). All ambiguities with other names
1752 // are currently reported as errors. They should be higher in priority than preludes
1753 // and probably even names in modules according to the "general principles" above. They
1754 // also should be subject to restricted shadowing because are effectively produced by
1755 // derives (you need to resolve the derive first to add helpers into scope), but they
1756 // should be available before the derive is expanded for compatibility.
1757 // It's mess in general, so we are being conservative for now.
1758 // 1-3. `macro_rules` (open, not controlled), loop through `macro_rules` scopes. Have higher
1759 // priority than prelude macros, but create ambiguities with macros in modules.
1760 // 1-3. Names in modules (both normal `mod`ules and blocks), loop through hygienic parents
1761 // (open, not controlled). Have higher priority than prelude macros, but create
1762 // ambiguities with `macro_rules`.
1763 // 4. `macro_use` prelude (open, the open part is from macro expansions, not controlled).
1764 // 4a. User-defined prelude from macro-use
1765 // (open, the open part is from macro expansions, not controlled).
1766 // 4b. "Standard library prelude" part implemented through `macro-use` (closed, controlled).
1767 // 4c. Standard library prelude (de-facto closed, controlled).
1768 // 6. Language prelude: builtin attributes (closed, controlled).
1769
1770 let rust_2015 = ctxt.edition() == Edition::Edition2015;
1771 let (ns, macro_kind, is_absolute_path) = match scope_set {
1772 ScopeSet::All(ns, _) => (ns, None, false),
1773 ScopeSet::AbsolutePath(ns) => (ns, None, true),
1774 ScopeSet::Macro(macro_kind) => (MacroNS, Some(macro_kind), false),
1775 ScopeSet::Late(ns, ..) => (ns, None, false),
1776 };
1777 let module = match scope_set {
1778 // Start with the specified module.
1779 ScopeSet::Late(_, module, _) => module,
1780 // Jump out of trait or enum modules, they do not act as scopes.
1781 _ => parent_scope.module.nearest_item_scope(),
1782 };
1783 let mut scope = match ns {
1784 _ if is_absolute_path => Scope::CrateRoot,
1785 TypeNS | ValueNS => Scope::Module(module, None),
1786 MacroNS => Scope::DeriveHelpers(parent_scope.expansion),
1787 };
1788 let mut ctxt = ctxt.normalize_to_macros_2_0();
1789 let mut use_prelude = !module.no_implicit_prelude;
1790
1791 loop {
1792 let visit = match scope {
1793 // Derive helpers are not in scope when resolving derives in the same container.
1794 Scope::DeriveHelpers(expn_id) => {
1795 !(expn_id == parent_scope.expansion && macro_kind == Some(MacroKind::Derive))
1796 }
1797 Scope::DeriveHelpersCompat => true,
1798 Scope::MacroRules(macro_rules_scope) => {
1799 // Use "path compression" on `macro_rules` scope chains. This is an optimization
1800 // used to avoid long scope chains, see the comments on `MacroRulesScopeRef`.
1801 // As another consequence of this optimization visitors never observe invocation
1802 // scopes for macros that were already expanded.
1803 while let MacroRulesScope::Invocation(invoc_id) = macro_rules_scope.get() {
1804 if let Some(next_scope) = self.output_macro_rules_scopes.get(&invoc_id) {
1805 macro_rules_scope.set(next_scope.get());
1806 } else {
1807 break;
1808 }
1809 }
1810 true
1811 }
1812 Scope::CrateRoot => true,
1813 Scope::Module(..) => true,
1814 Scope::RegisteredAttrs => use_prelude,
1815 Scope::MacroUsePrelude => use_prelude || rust_2015,
1816 Scope::BuiltinAttrs => true,
1817 Scope::ExternPrelude => use_prelude || is_absolute_path,
1818 Scope::ToolPrelude => use_prelude,
1819 Scope::StdLibPrelude => use_prelude || ns == MacroNS,
1820 Scope::BuiltinTypes => true,
1821 };
1822
1823 if visit {
1824 if let break_result @ Some(..) = visitor(self, scope, use_prelude, ctxt) {
1825 return break_result;
1826 }
1827 }
1828
1829 scope = match scope {
1830 Scope::DeriveHelpers(LocalExpnId::ROOT) => Scope::DeriveHelpersCompat,
1831 Scope::DeriveHelpers(expn_id) => {
1832 // Derive helpers are not visible to code generated by bang or derive macros.
1833 let expn_data = expn_id.expn_data();
1834 match expn_data.kind {
1835 ExpnKind::Root
1836 | ExpnKind::Macro(MacroKind::Bang | MacroKind::Derive, _) => {
1837 Scope::DeriveHelpersCompat
1838 }
1839 _ => Scope::DeriveHelpers(expn_data.parent.expect_local()),
1840 }
1841 }
1842 Scope::DeriveHelpersCompat => Scope::MacroRules(parent_scope.macro_rules),
1843 Scope::MacroRules(macro_rules_scope) => match macro_rules_scope.get() {
1844 MacroRulesScope::Binding(binding) => {
1845 Scope::MacroRules(binding.parent_macro_rules_scope)
1846 }
1847 MacroRulesScope::Invocation(invoc_id) => {
1848 Scope::MacroRules(self.invocation_parent_scopes[&invoc_id].macro_rules)
1849 }
1850 MacroRulesScope::Empty => Scope::Module(module, None),
1851 },
1852 Scope::CrateRoot => match ns {
1853 TypeNS => {
1854 ctxt.adjust(ExpnId::root());
1855 Scope::ExternPrelude
1856 }
1857 ValueNS | MacroNS => break,
1858 },
1859 Scope::Module(module, prev_lint_id) => {
1860 use_prelude = !module.no_implicit_prelude;
1861 let derive_fallback_lint_id = match scope_set {
1862 ScopeSet::Late(.., lint_id) => lint_id,
1863 _ => None,
1864 };
1865 match self.hygienic_lexical_parent(module, &mut ctxt, derive_fallback_lint_id) {
1866 Some((parent_module, lint_id)) => {
1867 Scope::Module(parent_module, lint_id.or(prev_lint_id))
1868 }
1869 None => {
1870 ctxt.adjust(ExpnId::root());
1871 match ns {
1872 TypeNS => Scope::ExternPrelude,
1873 ValueNS => Scope::StdLibPrelude,
1874 MacroNS => Scope::RegisteredAttrs,
1875 }
1876 }
1877 }
1878 }
1879 Scope::RegisteredAttrs => Scope::MacroUsePrelude,
1880 Scope::MacroUsePrelude => Scope::StdLibPrelude,
1881 Scope::BuiltinAttrs => break, // nowhere else to search
1882 Scope::ExternPrelude if is_absolute_path => break,
1883 Scope::ExternPrelude => Scope::ToolPrelude,
1884 Scope::ToolPrelude => Scope::StdLibPrelude,
1885 Scope::StdLibPrelude => match ns {
1886 TypeNS => Scope::BuiltinTypes,
1887 ValueNS => break, // nowhere else to search
1888 MacroNS => Scope::BuiltinAttrs,
1889 },
1890 Scope::BuiltinTypes => break, // nowhere else to search
1891 };
1892 }
1893
1894 None
1895 }
1896
1897 /// This resolves the identifier `ident` in the namespace `ns` in the current lexical scope.
1898 /// More specifically, we proceed up the hierarchy of scopes and return the binding for
1899 /// `ident` in the first scope that defines it (or None if no scopes define it).
1900 ///
1901 /// A block's items are above its local variables in the scope hierarchy, regardless of where
1902 /// the items are defined in the block. For example,
1903 /// ```rust
1904 /// fn f() {
1905 /// g(); // Since there are no local variables in scope yet, this resolves to the item.
1906 /// let g = || {};
1907 /// fn g() {}
1908 /// g(); // This resolves to the local variable `g` since it shadows the item.
1909 /// }
1910 /// ```
1911 ///
1912 /// Invariant: This must only be called during main resolution, not during
1913 /// import resolution.
resolve_ident_in_lexical_scope( &mut self, mut ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, record_used_id: Option<NodeId>, path_span: Span, ribs: &[Rib<'a>], ) -> Option<LexicalScopeBinding<'a>>1914 fn resolve_ident_in_lexical_scope(
1915 &mut self,
1916 mut ident: Ident,
1917 ns: Namespace,
1918 parent_scope: &ParentScope<'a>,
1919 record_used_id: Option<NodeId>,
1920 path_span: Span,
1921 ribs: &[Rib<'a>],
1922 ) -> Option<LexicalScopeBinding<'a>> {
1923 assert!(ns == TypeNS || ns == ValueNS);
1924 let orig_ident = ident;
1925 if ident.name == kw::Empty {
1926 return Some(LexicalScopeBinding::Res(Res::Err));
1927 }
1928 let (general_span, normalized_span) = if ident.name == kw::SelfUpper {
1929 // FIXME(jseyfried) improve `Self` hygiene
1930 let empty_span = ident.span.with_ctxt(SyntaxContext::root());
1931 (empty_span, empty_span)
1932 } else if ns == TypeNS {
1933 let normalized_span = ident.span.normalize_to_macros_2_0();
1934 (normalized_span, normalized_span)
1935 } else {
1936 (ident.span.normalize_to_macro_rules(), ident.span.normalize_to_macros_2_0())
1937 };
1938 ident.span = general_span;
1939 let normalized_ident = Ident { span: normalized_span, ..ident };
1940
1941 // Walk backwards up the ribs in scope.
1942 let record_used = record_used_id.is_some();
1943 let mut module = self.graph_root;
1944 for i in (0..ribs.len()).rev() {
1945 debug!("walk rib\n{:?}", ribs[i].bindings);
1946 // Use the rib kind to determine whether we are resolving parameters
1947 // (macro 2.0 hygiene) or local variables (`macro_rules` hygiene).
1948 let rib_ident = if ribs[i].kind.contains_params() { normalized_ident } else { ident };
1949 if let Some((original_rib_ident_def, res)) = ribs[i].bindings.get_key_value(&rib_ident)
1950 {
1951 // The ident resolves to a type parameter or local variable.
1952 return Some(LexicalScopeBinding::Res(self.validate_res_from_ribs(
1953 i,
1954 rib_ident,
1955 *res,
1956 record_used,
1957 path_span,
1958 *original_rib_ident_def,
1959 ribs,
1960 )));
1961 }
1962
1963 module = match ribs[i].kind {
1964 ModuleRibKind(module) => module,
1965 MacroDefinition(def) if def == self.macro_def(ident.span.ctxt()) => {
1966 // If an invocation of this macro created `ident`, give up on `ident`
1967 // and switch to `ident`'s source from the macro definition.
1968 ident.span.remove_mark();
1969 continue;
1970 }
1971 _ => continue,
1972 };
1973
1974 match module.kind {
1975 ModuleKind::Block(..) => {} // We can see through blocks
1976 _ => break,
1977 }
1978
1979 let item = self.resolve_ident_in_module_unadjusted(
1980 ModuleOrUniformRoot::Module(module),
1981 ident,
1982 ns,
1983 parent_scope,
1984 record_used,
1985 path_span,
1986 );
1987 if let Ok(binding) = item {
1988 // The ident resolves to an item.
1989 return Some(LexicalScopeBinding::Item(binding));
1990 }
1991 }
1992 self.early_resolve_ident_in_lexical_scope(
1993 orig_ident,
1994 ScopeSet::Late(ns, module, record_used_id),
1995 parent_scope,
1996 record_used,
1997 record_used,
1998 path_span,
1999 )
2000 .ok()
2001 .map(LexicalScopeBinding::Item)
2002 }
2003
hygienic_lexical_parent( &mut self, module: Module<'a>, ctxt: &mut SyntaxContext, derive_fallback_lint_id: Option<NodeId>, ) -> Option<(Module<'a>, Option<NodeId>)>2004 fn hygienic_lexical_parent(
2005 &mut self,
2006 module: Module<'a>,
2007 ctxt: &mut SyntaxContext,
2008 derive_fallback_lint_id: Option<NodeId>,
2009 ) -> Option<(Module<'a>, Option<NodeId>)> {
2010 if !module.expansion.outer_expn_is_descendant_of(*ctxt) {
2011 return Some((self.expn_def_scope(ctxt.remove_mark()), None));
2012 }
2013
2014 if let ModuleKind::Block(..) = module.kind {
2015 return Some((module.parent.unwrap().nearest_item_scope(), None));
2016 }
2017
2018 // We need to support the next case under a deprecation warning
2019 // ```
2020 // struct MyStruct;
2021 // ---- begin: this comes from a proc macro derive
2022 // mod implementation_details {
2023 // // Note that `MyStruct` is not in scope here.
2024 // impl SomeTrait for MyStruct { ... }
2025 // }
2026 // ---- end
2027 // ```
2028 // So we have to fall back to the module's parent during lexical resolution in this case.
2029 if derive_fallback_lint_id.is_some() {
2030 if let Some(parent) = module.parent {
2031 // Inner module is inside the macro, parent module is outside of the macro.
2032 if module.expansion != parent.expansion
2033 && module.expansion.is_descendant_of(parent.expansion)
2034 {
2035 // The macro is a proc macro derive
2036 if let Some(def_id) = module.expansion.expn_data().macro_def_id {
2037 let ext = self.get_macro_by_def_id(def_id);
2038 if ext.builtin_name.is_none()
2039 && ext.macro_kind() == MacroKind::Derive
2040 && parent.expansion.outer_expn_is_descendant_of(*ctxt)
2041 {
2042 return Some((parent, derive_fallback_lint_id));
2043 }
2044 }
2045 }
2046 }
2047 }
2048
2049 None
2050 }
2051
resolve_ident_in_module( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, record_used: bool, path_span: Span, ) -> Result<&'a NameBinding<'a>, Determinacy>2052 fn resolve_ident_in_module(
2053 &mut self,
2054 module: ModuleOrUniformRoot<'a>,
2055 ident: Ident,
2056 ns: Namespace,
2057 parent_scope: &ParentScope<'a>,
2058 record_used: bool,
2059 path_span: Span,
2060 ) -> Result<&'a NameBinding<'a>, Determinacy> {
2061 self.resolve_ident_in_module_ext(module, ident, ns, parent_scope, record_used, path_span)
2062 .map_err(|(determinacy, _)| determinacy)
2063 }
2064
resolve_ident_in_module_ext( &mut self, module: ModuleOrUniformRoot<'a>, mut ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, record_used: bool, path_span: Span, ) -> Result<&'a NameBinding<'a>, (Determinacy, Weak)>2065 fn resolve_ident_in_module_ext(
2066 &mut self,
2067 module: ModuleOrUniformRoot<'a>,
2068 mut ident: Ident,
2069 ns: Namespace,
2070 parent_scope: &ParentScope<'a>,
2071 record_used: bool,
2072 path_span: Span,
2073 ) -> Result<&'a NameBinding<'a>, (Determinacy, Weak)> {
2074 let tmp_parent_scope;
2075 let mut adjusted_parent_scope = parent_scope;
2076 match module {
2077 ModuleOrUniformRoot::Module(m) => {
2078 if let Some(def) = ident.span.normalize_to_macros_2_0_and_adjust(m.expansion) {
2079 tmp_parent_scope =
2080 ParentScope { module: self.expn_def_scope(def), ..*parent_scope };
2081 adjusted_parent_scope = &tmp_parent_scope;
2082 }
2083 }
2084 ModuleOrUniformRoot::ExternPrelude => {
2085 ident.span.normalize_to_macros_2_0_and_adjust(ExpnId::root());
2086 }
2087 ModuleOrUniformRoot::CrateRootAndExternPrelude | ModuleOrUniformRoot::CurrentScope => {
2088 // No adjustments
2089 }
2090 }
2091 self.resolve_ident_in_module_unadjusted_ext(
2092 module,
2093 ident,
2094 ns,
2095 adjusted_parent_scope,
2096 false,
2097 record_used,
2098 path_span,
2099 )
2100 }
2101
resolve_crate_root(&mut self, ident: Ident) -> Module<'a>2102 fn resolve_crate_root(&mut self, ident: Ident) -> Module<'a> {
2103 debug!("resolve_crate_root({:?})", ident);
2104 let mut ctxt = ident.span.ctxt();
2105 let mark = if ident.name == kw::DollarCrate {
2106 // When resolving `$crate` from a `macro_rules!` invoked in a `macro`,
2107 // we don't want to pretend that the `macro_rules!` definition is in the `macro`
2108 // as described in `SyntaxContext::apply_mark`, so we ignore prepended opaque marks.
2109 // FIXME: This is only a guess and it doesn't work correctly for `macro_rules!`
2110 // definitions actually produced by `macro` and `macro` definitions produced by
2111 // `macro_rules!`, but at least such configurations are not stable yet.
2112 ctxt = ctxt.normalize_to_macro_rules();
2113 debug!(
2114 "resolve_crate_root: marks={:?}",
2115 ctxt.marks().into_iter().map(|(i, t)| (i.expn_data(), t)).collect::<Vec<_>>()
2116 );
2117 let mut iter = ctxt.marks().into_iter().rev().peekable();
2118 let mut result = None;
2119 // Find the last opaque mark from the end if it exists.
2120 while let Some(&(mark, transparency)) = iter.peek() {
2121 if transparency == Transparency::Opaque {
2122 result = Some(mark);
2123 iter.next();
2124 } else {
2125 break;
2126 }
2127 }
2128 debug!(
2129 "resolve_crate_root: found opaque mark {:?} {:?}",
2130 result,
2131 result.map(|r| r.expn_data())
2132 );
2133 // Then find the last semi-transparent mark from the end if it exists.
2134 for (mark, transparency) in iter {
2135 if transparency == Transparency::SemiTransparent {
2136 result = Some(mark);
2137 } else {
2138 break;
2139 }
2140 }
2141 debug!(
2142 "resolve_crate_root: found semi-transparent mark {:?} {:?}",
2143 result,
2144 result.map(|r| r.expn_data())
2145 );
2146 result
2147 } else {
2148 debug!("resolve_crate_root: not DollarCrate");
2149 ctxt = ctxt.normalize_to_macros_2_0();
2150 ctxt.adjust(ExpnId::root())
2151 };
2152 let module = match mark {
2153 Some(def) => self.expn_def_scope(def),
2154 None => {
2155 debug!(
2156 "resolve_crate_root({:?}): found no mark (ident.span = {:?})",
2157 ident, ident.span
2158 );
2159 return self.graph_root;
2160 }
2161 };
2162 let module = self.expect_module(
2163 module.opt_def_id().map_or(LOCAL_CRATE, |def_id| def_id.krate).as_def_id(),
2164 );
2165 debug!(
2166 "resolve_crate_root({:?}): got module {:?} ({:?}) (ident.span = {:?})",
2167 ident,
2168 module,
2169 module.kind.name(),
2170 ident.span
2171 );
2172 module
2173 }
2174
resolve_self(&mut self, ctxt: &mut SyntaxContext, module: Module<'a>) -> Module<'a>2175 fn resolve_self(&mut self, ctxt: &mut SyntaxContext, module: Module<'a>) -> Module<'a> {
2176 let mut module = self.expect_module(module.nearest_parent_mod());
2177 while module.span.ctxt().normalize_to_macros_2_0() != *ctxt {
2178 let parent = module.parent.unwrap_or_else(|| self.expn_def_scope(ctxt.remove_mark()));
2179 module = self.expect_module(parent.nearest_parent_mod());
2180 }
2181 module
2182 }
2183
resolve_path( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a>, record_used: bool, path_span: Span, crate_lint: CrateLint, ) -> PathResult<'a>2184 fn resolve_path(
2185 &mut self,
2186 path: &[Segment],
2187 opt_ns: Option<Namespace>, // `None` indicates a module path in import
2188 parent_scope: &ParentScope<'a>,
2189 record_used: bool,
2190 path_span: Span,
2191 crate_lint: CrateLint,
2192 ) -> PathResult<'a> {
2193 self.resolve_path_with_ribs(
2194 path,
2195 opt_ns,
2196 parent_scope,
2197 record_used,
2198 path_span,
2199 crate_lint,
2200 None,
2201 )
2202 }
2203
resolve_path_with_ribs( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a>, record_used: bool, path_span: Span, crate_lint: CrateLint, ribs: Option<&PerNS<Vec<Rib<'a>>>>, ) -> PathResult<'a>2204 fn resolve_path_with_ribs(
2205 &mut self,
2206 path: &[Segment],
2207 opt_ns: Option<Namespace>, // `None` indicates a module path in import
2208 parent_scope: &ParentScope<'a>,
2209 record_used: bool,
2210 path_span: Span,
2211 crate_lint: CrateLint,
2212 ribs: Option<&PerNS<Vec<Rib<'a>>>>,
2213 ) -> PathResult<'a> {
2214 let mut module = None;
2215 let mut allow_super = true;
2216 let mut second_binding = None;
2217
2218 debug!(
2219 "resolve_path(path={:?}, opt_ns={:?}, record_used={:?}, \
2220 path_span={:?}, crate_lint={:?})",
2221 path, opt_ns, record_used, path_span, crate_lint,
2222 );
2223
2224 for (i, &Segment { ident, id, has_generic_args: _ }) in path.iter().enumerate() {
2225 debug!("resolve_path ident {} {:?} {:?}", i, ident, id);
2226 let record_segment_res = |this: &mut Self, res| {
2227 if record_used {
2228 if let Some(id) = id {
2229 if !this.partial_res_map.contains_key(&id) {
2230 assert!(id != ast::DUMMY_NODE_ID, "Trying to resolve dummy id");
2231 this.record_partial_res(id, PartialRes::new(res));
2232 }
2233 }
2234 }
2235 };
2236
2237 let is_last = i == path.len() - 1;
2238 let ns = if is_last { opt_ns.unwrap_or(TypeNS) } else { TypeNS };
2239 let name = ident.name;
2240
2241 allow_super &= ns == TypeNS && (name == kw::SelfLower || name == kw::Super);
2242
2243 if ns == TypeNS {
2244 if allow_super && name == kw::Super {
2245 let mut ctxt = ident.span.ctxt().normalize_to_macros_2_0();
2246 let self_module = match i {
2247 0 => Some(self.resolve_self(&mut ctxt, parent_scope.module)),
2248 _ => match module {
2249 Some(ModuleOrUniformRoot::Module(module)) => Some(module),
2250 _ => None,
2251 },
2252 };
2253 if let Some(self_module) = self_module {
2254 if let Some(parent) = self_module.parent {
2255 module = Some(ModuleOrUniformRoot::Module(
2256 self.resolve_self(&mut ctxt, parent),
2257 ));
2258 continue;
2259 }
2260 }
2261 let msg = "there are too many leading `super` keywords".to_string();
2262 return PathResult::Failed {
2263 span: ident.span,
2264 label: msg,
2265 suggestion: None,
2266 is_error_from_last_segment: false,
2267 };
2268 }
2269 if i == 0 {
2270 if name == kw::SelfLower {
2271 let mut ctxt = ident.span.ctxt().normalize_to_macros_2_0();
2272 module = Some(ModuleOrUniformRoot::Module(
2273 self.resolve_self(&mut ctxt, parent_scope.module),
2274 ));
2275 continue;
2276 }
2277 if name == kw::PathRoot && ident.span.rust_2018() {
2278 module = Some(ModuleOrUniformRoot::ExternPrelude);
2279 continue;
2280 }
2281 if name == kw::PathRoot && ident.span.rust_2015() && self.session.rust_2018() {
2282 // `::a::b` from 2015 macro on 2018 global edition
2283 module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude);
2284 continue;
2285 }
2286 if name == kw::PathRoot || name == kw::Crate || name == kw::DollarCrate {
2287 // `::a::b`, `crate::a::b` or `$crate::a::b`
2288 module = Some(ModuleOrUniformRoot::Module(self.resolve_crate_root(ident)));
2289 continue;
2290 }
2291 }
2292 }
2293
2294 // Report special messages for path segment keywords in wrong positions.
2295 if ident.is_path_segment_keyword() && i != 0 {
2296 let name_str = if name == kw::PathRoot {
2297 "crate root".to_string()
2298 } else {
2299 format!("`{}`", name)
2300 };
2301 let label = if i == 1 && path[0].ident.name == kw::PathRoot {
2302 format!("global paths cannot start with {}", name_str)
2303 } else {
2304 format!("{} in paths can only be used in start position", name_str)
2305 };
2306 return PathResult::Failed {
2307 span: ident.span,
2308 label,
2309 suggestion: None,
2310 is_error_from_last_segment: false,
2311 };
2312 }
2313
2314 enum FindBindingResult<'a> {
2315 Binding(Result<&'a NameBinding<'a>, Determinacy>),
2316 PathResult(PathResult<'a>),
2317 }
2318 let find_binding_in_ns = |this: &mut Self, ns| {
2319 let binding = if let Some(module) = module {
2320 this.resolve_ident_in_module(
2321 module,
2322 ident,
2323 ns,
2324 parent_scope,
2325 record_used,
2326 path_span,
2327 )
2328 } else if ribs.is_none() || opt_ns.is_none() || opt_ns == Some(MacroNS) {
2329 let scopes = ScopeSet::All(ns, opt_ns.is_none());
2330 this.early_resolve_ident_in_lexical_scope(
2331 ident,
2332 scopes,
2333 parent_scope,
2334 record_used,
2335 record_used,
2336 path_span,
2337 )
2338 } else {
2339 let record_used_id = if record_used {
2340 crate_lint.node_id().or(Some(CRATE_NODE_ID))
2341 } else {
2342 None
2343 };
2344 match this.resolve_ident_in_lexical_scope(
2345 ident,
2346 ns,
2347 parent_scope,
2348 record_used_id,
2349 path_span,
2350 &ribs.unwrap()[ns],
2351 ) {
2352 // we found a locally-imported or available item/module
2353 Some(LexicalScopeBinding::Item(binding)) => Ok(binding),
2354 // we found a local variable or type param
2355 Some(LexicalScopeBinding::Res(res))
2356 if opt_ns == Some(TypeNS) || opt_ns == Some(ValueNS) =>
2357 {
2358 record_segment_res(this, res);
2359 return FindBindingResult::PathResult(PathResult::NonModule(
2360 PartialRes::with_unresolved_segments(res, path.len() - 1),
2361 ));
2362 }
2363 _ => Err(Determinacy::determined(record_used)),
2364 }
2365 };
2366 FindBindingResult::Binding(binding)
2367 };
2368 let binding = match find_binding_in_ns(self, ns) {
2369 FindBindingResult::PathResult(x) => return x,
2370 FindBindingResult::Binding(binding) => binding,
2371 };
2372 match binding {
2373 Ok(binding) => {
2374 if i == 1 {
2375 second_binding = Some(binding);
2376 }
2377 let res = binding.res();
2378 let maybe_assoc = opt_ns != Some(MacroNS) && PathSource::Type.is_expected(res);
2379 if let Some(next_module) = binding.module() {
2380 module = Some(ModuleOrUniformRoot::Module(next_module));
2381 record_segment_res(self, res);
2382 } else if res == Res::ToolMod && i + 1 != path.len() {
2383 if binding.is_import() {
2384 self.session
2385 .struct_span_err(
2386 ident.span,
2387 "cannot use a tool module through an import",
2388 )
2389 .span_note(binding.span, "the tool module imported here")
2390 .emit();
2391 }
2392 let res = Res::NonMacroAttr(NonMacroAttrKind::Tool);
2393 return PathResult::NonModule(PartialRes::new(res));
2394 } else if res == Res::Err {
2395 return PathResult::NonModule(PartialRes::new(Res::Err));
2396 } else if opt_ns.is_some() && (is_last || maybe_assoc) {
2397 self.lint_if_path_starts_with_module(
2398 crate_lint,
2399 path,
2400 path_span,
2401 second_binding,
2402 );
2403 return PathResult::NonModule(PartialRes::with_unresolved_segments(
2404 res,
2405 path.len() - i - 1,
2406 ));
2407 } else {
2408 let label = format!(
2409 "`{}` is {} {}, not a module",
2410 ident,
2411 res.article(),
2412 res.descr(),
2413 );
2414
2415 return PathResult::Failed {
2416 span: ident.span,
2417 label,
2418 suggestion: None,
2419 is_error_from_last_segment: is_last,
2420 };
2421 }
2422 }
2423 Err(Undetermined) => return PathResult::Indeterminate,
2424 Err(Determined) => {
2425 if let Some(ModuleOrUniformRoot::Module(module)) = module {
2426 if opt_ns.is_some() && !module.is_normal() {
2427 return PathResult::NonModule(PartialRes::with_unresolved_segments(
2428 module.res().unwrap(),
2429 path.len() - i,
2430 ));
2431 }
2432 }
2433 let module_res = match module {
2434 Some(ModuleOrUniformRoot::Module(module)) => module.res(),
2435 _ => None,
2436 };
2437 let (label, suggestion) = if module_res == self.graph_root.res() {
2438 let is_mod = |res| matches!(res, Res::Def(DefKind::Mod, _));
2439 // Don't look up import candidates if this is a speculative resolve
2440 let mut candidates = if record_used {
2441 self.lookup_import_candidates(ident, TypeNS, parent_scope, is_mod)
2442 } else {
2443 Vec::new()
2444 };
2445 candidates.sort_by_cached_key(|c| {
2446 (c.path.segments.len(), pprust::path_to_string(&c.path))
2447 });
2448 if let Some(candidate) = candidates.get(0) {
2449 (
2450 String::from("unresolved import"),
2451 Some((
2452 vec![(ident.span, pprust::path_to_string(&candidate.path))],
2453 String::from("a similar path exists"),
2454 Applicability::MaybeIncorrect,
2455 )),
2456 )
2457 } else if self.session.edition() == Edition::Edition2015 {
2458 (format!("maybe a missing crate `{}`?", ident), None)
2459 } else {
2460 (format!("could not find `{}` in the crate root", ident), None)
2461 }
2462 } else if i == 0 {
2463 if ident
2464 .name
2465 .as_str()
2466 .chars()
2467 .next()
2468 .map_or(false, |c| c.is_ascii_uppercase())
2469 {
2470 // Check whether the name refers to an item in the value namespace.
2471 let suggestion = if ribs.is_some() {
2472 let match_span = match self.resolve_ident_in_lexical_scope(
2473 ident,
2474 ValueNS,
2475 parent_scope,
2476 None,
2477 path_span,
2478 &ribs.unwrap()[ValueNS],
2479 ) {
2480 // Name matches a local variable. For example:
2481 // ```
2482 // fn f() {
2483 // let Foo: &str = "";
2484 // println!("{}", Foo::Bar); // Name refers to local
2485 // // variable `Foo`.
2486 // }
2487 // ```
2488 Some(LexicalScopeBinding::Res(Res::Local(id))) => {
2489 Some(*self.pat_span_map.get(&id).unwrap())
2490 }
2491
2492 // Name matches item from a local name binding
2493 // created by `use` declaration. For example:
2494 // ```
2495 // pub Foo: &str = "";
2496 //
2497 // mod submod {
2498 // use super::Foo;
2499 // println!("{}", Foo::Bar); // Name refers to local
2500 // // binding `Foo`.
2501 // }
2502 // ```
2503 Some(LexicalScopeBinding::Item(name_binding)) => {
2504 Some(name_binding.span)
2505 }
2506 _ => None,
2507 };
2508
2509 if let Some(span) = match_span {
2510 Some((
2511 vec![(span, String::from(""))],
2512 format!("`{}` is defined here, but is not a type", ident),
2513 Applicability::MaybeIncorrect,
2514 ))
2515 } else {
2516 None
2517 }
2518 } else {
2519 None
2520 };
2521
2522 (format!("use of undeclared type `{}`", ident), suggestion)
2523 } else {
2524 (
2525 format!("use of undeclared crate or module `{}`", ident),
2526 if ident.name == sym::alloc {
2527 Some((
2528 vec![],
2529 String::from(
2530 "add `extern crate alloc` to use the `alloc` crate",
2531 ),
2532 Applicability::MaybeIncorrect,
2533 ))
2534 } else {
2535 self.find_similarly_named_module_or_crate(
2536 ident.name,
2537 &parent_scope.module,
2538 )
2539 .map(|sugg| {
2540 (
2541 vec![(ident.span, sugg.to_string())],
2542 String::from(
2543 "there is a crate or module with a similar name",
2544 ),
2545 Applicability::MaybeIncorrect,
2546 )
2547 })
2548 },
2549 )
2550 }
2551 } else {
2552 let parent = path[i - 1].ident.name;
2553 let parent = match parent {
2554 // ::foo is mounted at the crate root for 2015, and is the extern
2555 // prelude for 2018+
2556 kw::PathRoot if self.session.edition() > Edition::Edition2015 => {
2557 "the list of imported crates".to_owned()
2558 }
2559 kw::PathRoot | kw::Crate => "the crate root".to_owned(),
2560 _ => {
2561 format!("`{}`", parent)
2562 }
2563 };
2564
2565 let mut msg = format!("could not find `{}` in {}", ident, parent);
2566 if ns == TypeNS || ns == ValueNS {
2567 let ns_to_try = if ns == TypeNS { ValueNS } else { TypeNS };
2568 if let FindBindingResult::Binding(Ok(binding)) =
2569 find_binding_in_ns(self, ns_to_try)
2570 {
2571 let mut found = |what| {
2572 msg = format!(
2573 "expected {}, found {} `{}` in {}",
2574 ns.descr(),
2575 what,
2576 ident,
2577 parent
2578 )
2579 };
2580 if binding.module().is_some() {
2581 found("module")
2582 } else {
2583 match binding.res() {
2584 def::Res::<NodeId>::Def(kind, id) => found(kind.descr(id)),
2585 _ => found(ns_to_try.descr()),
2586 }
2587 }
2588 };
2589 }
2590 (msg, None)
2591 };
2592 return PathResult::Failed {
2593 span: ident.span,
2594 label,
2595 suggestion,
2596 is_error_from_last_segment: is_last,
2597 };
2598 }
2599 }
2600 }
2601
2602 self.lint_if_path_starts_with_module(crate_lint, path, path_span, second_binding);
2603
2604 PathResult::Module(match module {
2605 Some(module) => module,
2606 None if path.is_empty() => ModuleOrUniformRoot::CurrentScope,
2607 _ => span_bug!(path_span, "resolve_path: non-empty path `{:?}` has no module", path),
2608 })
2609 }
2610
lint_if_path_starts_with_module( &mut self, crate_lint: CrateLint, path: &[Segment], path_span: Span, second_binding: Option<&NameBinding<'_>>, )2611 fn lint_if_path_starts_with_module(
2612 &mut self,
2613 crate_lint: CrateLint,
2614 path: &[Segment],
2615 path_span: Span,
2616 second_binding: Option<&NameBinding<'_>>,
2617 ) {
2618 let (diag_id, diag_span) = match crate_lint {
2619 CrateLint::No => return,
2620 CrateLint::SimplePath(id) => (id, path_span),
2621 CrateLint::UsePath { root_id, root_span } => (root_id, root_span),
2622 CrateLint::QPathTrait { qpath_id, qpath_span } => (qpath_id, qpath_span),
2623 };
2624
2625 let first_name = match path.get(0) {
2626 // In the 2018 edition this lint is a hard error, so nothing to do
2627 Some(seg) if seg.ident.span.rust_2015() && self.session.rust_2015() => seg.ident.name,
2628 _ => return,
2629 };
2630
2631 // We're only interested in `use` paths which should start with
2632 // `{{root}}` currently.
2633 if first_name != kw::PathRoot {
2634 return;
2635 }
2636
2637 match path.get(1) {
2638 // If this import looks like `crate::...` it's already good
2639 Some(Segment { ident, .. }) if ident.name == kw::Crate => return,
2640 // Otherwise go below to see if it's an extern crate
2641 Some(_) => {}
2642 // If the path has length one (and it's `PathRoot` most likely)
2643 // then we don't know whether we're gonna be importing a crate or an
2644 // item in our crate. Defer this lint to elsewhere
2645 None => return,
2646 }
2647
2648 // If the first element of our path was actually resolved to an
2649 // `ExternCrate` (also used for `crate::...`) then no need to issue a
2650 // warning, this looks all good!
2651 if let Some(binding) = second_binding {
2652 if let NameBindingKind::Import { import, .. } = binding.kind {
2653 // Careful: we still want to rewrite paths from renamed extern crates.
2654 if let ImportKind::ExternCrate { source: None, .. } = import.kind {
2655 return;
2656 }
2657 }
2658 }
2659
2660 let diag = BuiltinLintDiagnostics::AbsPathWithModule(diag_span);
2661 self.lint_buffer.buffer_lint_with_diagnostic(
2662 lint::builtin::ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
2663 diag_id,
2664 diag_span,
2665 "absolute paths must start with `self`, `super`, \
2666 `crate`, or an external crate name in the 2018 edition",
2667 diag,
2668 );
2669 }
2670
2671 // Validate a local resolution (from ribs).
validate_res_from_ribs( &mut self, rib_index: usize, rib_ident: Ident, mut res: Res, record_used: bool, span: Span, original_rib_ident_def: Ident, all_ribs: &[Rib<'a>], ) -> Res2672 fn validate_res_from_ribs(
2673 &mut self,
2674 rib_index: usize,
2675 rib_ident: Ident,
2676 mut res: Res,
2677 record_used: bool,
2678 span: Span,
2679 original_rib_ident_def: Ident,
2680 all_ribs: &[Rib<'a>],
2681 ) -> Res {
2682 const CG_BUG_STR: &str = "min_const_generics resolve check didn't stop compilation";
2683 debug!("validate_res_from_ribs({:?})", res);
2684 let ribs = &all_ribs[rib_index + 1..];
2685
2686 // An invalid forward use of a generic parameter from a previous default.
2687 if let ForwardGenericParamBanRibKind = all_ribs[rib_index].kind {
2688 if record_used {
2689 let res_error = if rib_ident.name == kw::SelfUpper {
2690 ResolutionError::SelfInGenericParamDefault
2691 } else {
2692 ResolutionError::ForwardDeclaredGenericParam
2693 };
2694 self.report_error(span, res_error);
2695 }
2696 assert_eq!(res, Res::Err);
2697 return Res::Err;
2698 }
2699
2700 match res {
2701 Res::Local(_) => {
2702 use ResolutionError::*;
2703 let mut res_err = None;
2704
2705 for rib in ribs {
2706 match rib.kind {
2707 NormalRibKind
2708 | ClosureOrAsyncRibKind
2709 | ModuleRibKind(..)
2710 | MacroDefinition(..)
2711 | ForwardGenericParamBanRibKind => {
2712 // Nothing to do. Continue.
2713 }
2714 ItemRibKind(_) | FnItemRibKind | AssocItemRibKind => {
2715 // This was an attempt to access an upvar inside a
2716 // named function item. This is not allowed, so we
2717 // report an error.
2718 if record_used {
2719 // We don't immediately trigger a resolve error, because
2720 // we want certain other resolution errors (namely those
2721 // emitted for `ConstantItemRibKind` below) to take
2722 // precedence.
2723 res_err = Some(CannotCaptureDynamicEnvironmentInFnItem);
2724 }
2725 }
2726 ConstantItemRibKind(_, item) => {
2727 // Still doesn't deal with upvars
2728 if record_used {
2729 let (span, resolution_error) =
2730 if let Some((ident, constant_item_kind)) = item {
2731 let kind_str = match constant_item_kind {
2732 ConstantItemKind::Const => "const",
2733 ConstantItemKind::Static => "static",
2734 };
2735 (
2736 span,
2737 AttemptToUseNonConstantValueInConstant(
2738 ident, "let", kind_str,
2739 ),
2740 )
2741 } else {
2742 (
2743 rib_ident.span,
2744 AttemptToUseNonConstantValueInConstant(
2745 original_rib_ident_def,
2746 "const",
2747 "let",
2748 ),
2749 )
2750 };
2751 self.report_error(span, resolution_error);
2752 }
2753 return Res::Err;
2754 }
2755 ConstParamTyRibKind => {
2756 if record_used {
2757 self.report_error(span, ParamInTyOfConstParam(rib_ident.name));
2758 }
2759 return Res::Err;
2760 }
2761 }
2762 }
2763 if let Some(res_err) = res_err {
2764 self.report_error(span, res_err);
2765 return Res::Err;
2766 }
2767 }
2768 Res::Def(DefKind::TyParam, _) | Res::SelfTy(..) => {
2769 for rib in ribs {
2770 let has_generic_params: HasGenericParams = match rib.kind {
2771 NormalRibKind
2772 | ClosureOrAsyncRibKind
2773 | AssocItemRibKind
2774 | ModuleRibKind(..)
2775 | MacroDefinition(..)
2776 | ForwardGenericParamBanRibKind => {
2777 // Nothing to do. Continue.
2778 continue;
2779 }
2780
2781 ConstantItemRibKind(trivial, _) => {
2782 let features = self.session.features_untracked();
2783 // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
2784 if !(trivial || features.generic_const_exprs) {
2785 // HACK(min_const_generics): If we encounter `Self` in an anonymous constant
2786 // we can't easily tell if it's generic at this stage, so we instead remember
2787 // this and then enforce the self type to be concrete later on.
2788 if let Res::SelfTy(trait_def, Some((impl_def, _))) = res {
2789 res = Res::SelfTy(trait_def, Some((impl_def, true)));
2790 } else {
2791 if record_used {
2792 self.report_error(
2793 span,
2794 ResolutionError::ParamInNonTrivialAnonConst {
2795 name: rib_ident.name,
2796 is_type: true,
2797 },
2798 );
2799 }
2800
2801 self.session.delay_span_bug(span, CG_BUG_STR);
2802 return Res::Err;
2803 }
2804 }
2805
2806 continue;
2807 }
2808
2809 // This was an attempt to use a type parameter outside its scope.
2810 ItemRibKind(has_generic_params) => has_generic_params,
2811 FnItemRibKind => HasGenericParams::Yes,
2812 ConstParamTyRibKind => {
2813 if record_used {
2814 self.report_error(
2815 span,
2816 ResolutionError::ParamInTyOfConstParam(rib_ident.name),
2817 );
2818 }
2819 return Res::Err;
2820 }
2821 };
2822
2823 if record_used {
2824 self.report_error(
2825 span,
2826 ResolutionError::GenericParamsFromOuterFunction(
2827 res,
2828 has_generic_params,
2829 ),
2830 );
2831 }
2832 return Res::Err;
2833 }
2834 }
2835 Res::Def(DefKind::ConstParam, _) => {
2836 let mut ribs = ribs.iter().peekable();
2837 if let Some(Rib { kind: FnItemRibKind, .. }) = ribs.peek() {
2838 // When declaring const parameters inside function signatures, the first rib
2839 // is always a `FnItemRibKind`. In this case, we can skip it, to avoid it
2840 // (spuriously) conflicting with the const param.
2841 ribs.next();
2842 }
2843
2844 for rib in ribs {
2845 let has_generic_params = match rib.kind {
2846 NormalRibKind
2847 | ClosureOrAsyncRibKind
2848 | AssocItemRibKind
2849 | ModuleRibKind(..)
2850 | MacroDefinition(..)
2851 | ForwardGenericParamBanRibKind => continue,
2852
2853 ConstantItemRibKind(trivial, _) => {
2854 let features = self.session.features_untracked();
2855 // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
2856 if !(trivial || features.generic_const_exprs) {
2857 if record_used {
2858 self.report_error(
2859 span,
2860 ResolutionError::ParamInNonTrivialAnonConst {
2861 name: rib_ident.name,
2862 is_type: false,
2863 },
2864 );
2865 }
2866
2867 self.session.delay_span_bug(span, CG_BUG_STR);
2868 return Res::Err;
2869 }
2870
2871 continue;
2872 }
2873
2874 ItemRibKind(has_generic_params) => has_generic_params,
2875 FnItemRibKind => HasGenericParams::Yes,
2876 ConstParamTyRibKind => {
2877 if record_used {
2878 self.report_error(
2879 span,
2880 ResolutionError::ParamInTyOfConstParam(rib_ident.name),
2881 );
2882 }
2883 return Res::Err;
2884 }
2885 };
2886
2887 // This was an attempt to use a const parameter outside its scope.
2888 if record_used {
2889 self.report_error(
2890 span,
2891 ResolutionError::GenericParamsFromOuterFunction(
2892 res,
2893 has_generic_params,
2894 ),
2895 );
2896 }
2897 return Res::Err;
2898 }
2899 }
2900 _ => {}
2901 }
2902 res
2903 }
2904
record_partial_res(&mut self, node_id: NodeId, resolution: PartialRes)2905 fn record_partial_res(&mut self, node_id: NodeId, resolution: PartialRes) {
2906 debug!("(recording res) recording {:?} for {}", resolution, node_id);
2907 if let Some(prev_res) = self.partial_res_map.insert(node_id, resolution) {
2908 panic!("path resolved multiple times ({:?} before, {:?} now)", prev_res, resolution);
2909 }
2910 }
2911
record_pat_span(&mut self, node: NodeId, span: Span)2912 fn record_pat_span(&mut self, node: NodeId, span: Span) {
2913 debug!("(recording pat) recording {:?} for {:?}", node, span);
2914 self.pat_span_map.insert(node, span);
2915 }
2916
is_accessible_from(&self, vis: ty::Visibility, module: Module<'a>) -> bool2917 fn is_accessible_from(&self, vis: ty::Visibility, module: Module<'a>) -> bool {
2918 vis.is_accessible_from(module.nearest_parent_mod(), self)
2919 }
2920
set_binding_parent_module(&mut self, binding: &'a NameBinding<'a>, module: Module<'a>)2921 fn set_binding_parent_module(&mut self, binding: &'a NameBinding<'a>, module: Module<'a>) {
2922 if let Some(old_module) = self.binding_parent_modules.insert(PtrKey(binding), module) {
2923 if !ptr::eq(module, old_module) {
2924 span_bug!(binding.span, "parent module is reset for binding");
2925 }
2926 }
2927 }
2928
disambiguate_macro_rules_vs_modularized( &self, macro_rules: &'a NameBinding<'a>, modularized: &'a NameBinding<'a>, ) -> bool2929 fn disambiguate_macro_rules_vs_modularized(
2930 &self,
2931 macro_rules: &'a NameBinding<'a>,
2932 modularized: &'a NameBinding<'a>,
2933 ) -> bool {
2934 // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
2935 // is disambiguated to mitigate regressions from macro modularization.
2936 // Scoping for `macro_rules` behaves like scoping for `let` at module level, in general.
2937 match (
2938 self.binding_parent_modules.get(&PtrKey(macro_rules)),
2939 self.binding_parent_modules.get(&PtrKey(modularized)),
2940 ) {
2941 (Some(macro_rules), Some(modularized)) => {
2942 macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
2943 && modularized.is_ancestor_of(macro_rules)
2944 }
2945 _ => false,
2946 }
2947 }
2948
report_errors(&mut self, krate: &Crate)2949 fn report_errors(&mut self, krate: &Crate) {
2950 self.report_with_use_injections(krate);
2951
2952 for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
2953 let msg = "macro-expanded `macro_export` macros from the current crate \
2954 cannot be referred to by absolute paths";
2955 self.lint_buffer.buffer_lint_with_diagnostic(
2956 lint::builtin::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
2957 CRATE_NODE_ID,
2958 span_use,
2959 msg,
2960 BuiltinLintDiagnostics::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
2961 );
2962 }
2963
2964 for ambiguity_error in &self.ambiguity_errors {
2965 self.report_ambiguity_error(ambiguity_error);
2966 }
2967
2968 let mut reported_spans = FxHashSet::default();
2969 for error in &self.privacy_errors {
2970 if reported_spans.insert(error.dedup_span) {
2971 self.report_privacy_error(error);
2972 }
2973 }
2974 }
2975
report_with_use_injections(&mut self, krate: &Crate)2976 fn report_with_use_injections(&mut self, krate: &Crate) {
2977 for UseError { mut err, candidates, def_id, instead, suggestion } in
2978 self.use_injections.drain(..)
2979 {
2980 let (span, found_use) = if let Some(def_id) = def_id.as_local() {
2981 UsePlacementFinder::check(krate, self.def_id_to_node_id[def_id])
2982 } else {
2983 (None, false)
2984 };
2985 if !candidates.is_empty() {
2986 diagnostics::show_candidates(
2987 &self.definitions,
2988 self.session,
2989 &mut err,
2990 span,
2991 &candidates,
2992 instead,
2993 found_use,
2994 );
2995 } else if let Some((span, msg, sugg, appl)) = suggestion {
2996 err.span_suggestion(span, msg, sugg, appl);
2997 }
2998 err.emit();
2999 }
3000 }
3001
report_conflict<'b>( &mut self, parent: Module<'_>, ident: Ident, ns: Namespace, new_binding: &NameBinding<'b>, old_binding: &NameBinding<'b>, )3002 fn report_conflict<'b>(
3003 &mut self,
3004 parent: Module<'_>,
3005 ident: Ident,
3006 ns: Namespace,
3007 new_binding: &NameBinding<'b>,
3008 old_binding: &NameBinding<'b>,
3009 ) {
3010 // Error on the second of two conflicting names
3011 if old_binding.span.lo() > new_binding.span.lo() {
3012 return self.report_conflict(parent, ident, ns, old_binding, new_binding);
3013 }
3014
3015 let container = match parent.kind {
3016 ModuleKind::Def(kind, _, _) => kind.descr(parent.def_id()),
3017 ModuleKind::Block(..) => "block",
3018 };
3019
3020 let old_noun = match old_binding.is_import() {
3021 true => "import",
3022 false => "definition",
3023 };
3024
3025 let new_participle = match new_binding.is_import() {
3026 true => "imported",
3027 false => "defined",
3028 };
3029
3030 let (name, span) =
3031 (ident.name, self.session.source_map().guess_head_span(new_binding.span));
3032
3033 if let Some(s) = self.name_already_seen.get(&name) {
3034 if s == &span {
3035 return;
3036 }
3037 }
3038
3039 let old_kind = match (ns, old_binding.module()) {
3040 (ValueNS, _) => "value",
3041 (MacroNS, _) => "macro",
3042 (TypeNS, _) if old_binding.is_extern_crate() => "extern crate",
3043 (TypeNS, Some(module)) if module.is_normal() => "module",
3044 (TypeNS, Some(module)) if module.is_trait() => "trait",
3045 (TypeNS, _) => "type",
3046 };
3047
3048 let msg = format!("the name `{}` is defined multiple times", name);
3049
3050 let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
3051 (true, true) => struct_span_err!(self.session, span, E0259, "{}", msg),
3052 (true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
3053 true => struct_span_err!(self.session, span, E0254, "{}", msg),
3054 false => struct_span_err!(self.session, span, E0260, "{}", msg),
3055 },
3056 _ => match (old_binding.is_import(), new_binding.is_import()) {
3057 (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
3058 (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
3059 _ => struct_span_err!(self.session, span, E0255, "{}", msg),
3060 },
3061 };
3062
3063 err.note(&format!(
3064 "`{}` must be defined only once in the {} namespace of this {}",
3065 name,
3066 ns.descr(),
3067 container
3068 ));
3069
3070 err.span_label(span, format!("`{}` re{} here", name, new_participle));
3071 err.span_label(
3072 self.session.source_map().guess_head_span(old_binding.span),
3073 format!("previous {} of the {} `{}` here", old_noun, old_kind, name),
3074 );
3075
3076 // See https://github.com/rust-lang/rust/issues/32354
3077 use NameBindingKind::Import;
3078 let import = match (&new_binding.kind, &old_binding.kind) {
3079 // If there are two imports where one or both have attributes then prefer removing the
3080 // import without attributes.
3081 (Import { import: new, .. }, Import { import: old, .. })
3082 if {
3083 !new_binding.span.is_dummy()
3084 && !old_binding.span.is_dummy()
3085 && (new.has_attributes || old.has_attributes)
3086 } =>
3087 {
3088 if old.has_attributes {
3089 Some((new, new_binding.span, true))
3090 } else {
3091 Some((old, old_binding.span, true))
3092 }
3093 }
3094 // Otherwise prioritize the new binding.
3095 (Import { import, .. }, other) if !new_binding.span.is_dummy() => {
3096 Some((import, new_binding.span, other.is_import()))
3097 }
3098 (other, Import { import, .. }) if !old_binding.span.is_dummy() => {
3099 Some((import, old_binding.span, other.is_import()))
3100 }
3101 _ => None,
3102 };
3103
3104 // Check if the target of the use for both bindings is the same.
3105 let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
3106 let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
3107 let from_item =
3108 self.extern_prelude.get(&ident).map_or(true, |entry| entry.introduced_by_item);
3109 // Only suggest removing an import if both bindings are to the same def, if both spans
3110 // aren't dummy spans. Further, if both bindings are imports, then the ident must have
3111 // been introduced by an item.
3112 let should_remove_import = duplicate
3113 && !has_dummy_span
3114 && ((new_binding.is_extern_crate() || old_binding.is_extern_crate()) || from_item);
3115
3116 match import {
3117 Some((import, span, true)) if should_remove_import && import.is_nested() => {
3118 self.add_suggestion_for_duplicate_nested_use(&mut err, import, span)
3119 }
3120 Some((import, _, true)) if should_remove_import && !import.is_glob() => {
3121 // Simple case - remove the entire import. Due to the above match arm, this can
3122 // only be a single use so just remove it entirely.
3123 err.tool_only_span_suggestion(
3124 import.use_span_with_attributes,
3125 "remove unnecessary import",
3126 String::new(),
3127 Applicability::MaybeIncorrect,
3128 );
3129 }
3130 Some((import, span, _)) => {
3131 self.add_suggestion_for_rename_of_use(&mut err, name, import, span)
3132 }
3133 _ => {}
3134 }
3135
3136 err.emit();
3137 self.name_already_seen.insert(name, span);
3138 }
3139
3140 /// This function adds a suggestion to change the binding name of a new import that conflicts
3141 /// with an existing import.
3142 ///
3143 /// ```text,ignore (diagnostic)
3144 /// help: you can use `as` to change the binding name of the import
3145 /// |
3146 /// LL | use foo::bar as other_bar;
3147 /// | ^^^^^^^^^^^^^^^^^^^^^
3148 /// ```
add_suggestion_for_rename_of_use( &self, err: &mut DiagnosticBuilder<'_>, name: Symbol, import: &Import<'_>, binding_span: Span, )3149 fn add_suggestion_for_rename_of_use(
3150 &self,
3151 err: &mut DiagnosticBuilder<'_>,
3152 name: Symbol,
3153 import: &Import<'_>,
3154 binding_span: Span,
3155 ) {
3156 let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() {
3157 format!("Other{}", name)
3158 } else {
3159 format!("other_{}", name)
3160 };
3161
3162 let mut suggestion = None;
3163 match import.kind {
3164 ImportKind::Single { type_ns_only: true, .. } => {
3165 suggestion = Some(format!("self as {}", suggested_name))
3166 }
3167 ImportKind::Single { source, .. } => {
3168 if let Some(pos) =
3169 source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize)
3170 {
3171 if let Ok(snippet) = self.session.source_map().span_to_snippet(binding_span) {
3172 if pos <= snippet.len() {
3173 suggestion = Some(format!(
3174 "{} as {}{}",
3175 &snippet[..pos],
3176 suggested_name,
3177 if snippet.ends_with(';') { ";" } else { "" }
3178 ))
3179 }
3180 }
3181 }
3182 }
3183 ImportKind::ExternCrate { source, target, .. } => {
3184 suggestion = Some(format!(
3185 "extern crate {} as {};",
3186 source.unwrap_or(target.name),
3187 suggested_name,
3188 ))
3189 }
3190 _ => unreachable!(),
3191 }
3192
3193 let rename_msg = "you can use `as` to change the binding name of the import";
3194 if let Some(suggestion) = suggestion {
3195 err.span_suggestion(
3196 binding_span,
3197 rename_msg,
3198 suggestion,
3199 Applicability::MaybeIncorrect,
3200 );
3201 } else {
3202 err.span_label(binding_span, rename_msg);
3203 }
3204 }
3205
3206 /// This function adds a suggestion to remove an unnecessary binding from an import that is
3207 /// nested. In the following example, this function will be invoked to remove the `a` binding
3208 /// in the second use statement:
3209 ///
3210 /// ```ignore (diagnostic)
3211 /// use issue_52891::a;
3212 /// use issue_52891::{d, a, e};
3213 /// ```
3214 ///
3215 /// The following suggestion will be added:
3216 ///
3217 /// ```ignore (diagnostic)
3218 /// use issue_52891::{d, a, e};
3219 /// ^-- help: remove unnecessary import
3220 /// ```
3221 ///
3222 /// If the nested use contains only one import then the suggestion will remove the entire
3223 /// line.
3224 ///
3225 /// It is expected that the provided import is nested - this isn't checked by the
3226 /// function. If this invariant is not upheld, this function's behaviour will be unexpected
3227 /// as characters expected by span manipulations won't be present.
add_suggestion_for_duplicate_nested_use( &self, err: &mut DiagnosticBuilder<'_>, import: &Import<'_>, binding_span: Span, )3228 fn add_suggestion_for_duplicate_nested_use(
3229 &self,
3230 err: &mut DiagnosticBuilder<'_>,
3231 import: &Import<'_>,
3232 binding_span: Span,
3233 ) {
3234 assert!(import.is_nested());
3235 let message = "remove unnecessary import";
3236
3237 // Two examples will be used to illustrate the span manipulations we're doing:
3238 //
3239 // - Given `use issue_52891::{d, a, e};` where `a` is a duplicate then `binding_span` is
3240 // `a` and `import.use_span` is `issue_52891::{d, a, e};`.
3241 // - Given `use issue_52891::{d, e, a};` where `a` is a duplicate then `binding_span` is
3242 // `a` and `import.use_span` is `issue_52891::{d, e, a};`.
3243
3244 let (found_closing_brace, span) =
3245 find_span_of_binding_until_next_binding(self.session, binding_span, import.use_span);
3246
3247 // If there was a closing brace then identify the span to remove any trailing commas from
3248 // previous imports.
3249 if found_closing_brace {
3250 if let Some(span) = extend_span_to_previous_binding(self.session, span) {
3251 err.tool_only_span_suggestion(
3252 span,
3253 message,
3254 String::new(),
3255 Applicability::MaybeIncorrect,
3256 );
3257 } else {
3258 // Remove the entire line if we cannot extend the span back, this indicates an
3259 // `issue_52891::{self}` case.
3260 err.span_suggestion(
3261 import.use_span_with_attributes,
3262 message,
3263 String::new(),
3264 Applicability::MaybeIncorrect,
3265 );
3266 }
3267
3268 return;
3269 }
3270
3271 err.span_suggestion(span, message, String::new(), Applicability::MachineApplicable);
3272 }
3273
extern_prelude_get( &mut self, ident: Ident, speculative: bool, ) -> Option<&'a NameBinding<'a>>3274 fn extern_prelude_get(
3275 &mut self,
3276 ident: Ident,
3277 speculative: bool,
3278 ) -> Option<&'a NameBinding<'a>> {
3279 if ident.is_path_segment_keyword() {
3280 // Make sure `self`, `super` etc produce an error when passed to here.
3281 return None;
3282 }
3283 self.extern_prelude.get(&ident.normalize_to_macros_2_0()).cloned().and_then(|entry| {
3284 if let Some(binding) = entry.extern_crate_item {
3285 if !speculative && entry.introduced_by_item {
3286 self.record_use(ident, binding, false);
3287 }
3288 Some(binding)
3289 } else {
3290 let crate_id = if !speculative {
3291 self.crate_loader.process_path_extern(ident.name, ident.span)
3292 } else {
3293 self.crate_loader.maybe_process_path_extern(ident.name)?
3294 };
3295 let crate_root = self.expect_module(crate_id.as_def_id());
3296 Some(
3297 (crate_root, ty::Visibility::Public, DUMMY_SP, LocalExpnId::ROOT)
3298 .to_name_binding(self.arenas),
3299 )
3300 }
3301 })
3302 }
3303
3304 /// Rustdoc uses this to resolve things in a recoverable way. `ResolutionError<'a>`
3305 /// isn't something that can be returned because it can't be made to live that long,
3306 /// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
3307 /// just that an error occurred.
3308 // FIXME(Manishearth): intra-doc links won't get warned of epoch changes.
resolve_str_path_error( &mut self, span: Span, path_str: &str, ns: Namespace, module_id: DefId, ) -> Result<(ast::Path, Res), ()>3309 pub fn resolve_str_path_error(
3310 &mut self,
3311 span: Span,
3312 path_str: &str,
3313 ns: Namespace,
3314 module_id: DefId,
3315 ) -> Result<(ast::Path, Res), ()> {
3316 let path = if path_str.starts_with("::") {
3317 ast::Path {
3318 span,
3319 segments: iter::once(Ident::with_dummy_span(kw::PathRoot))
3320 .chain(path_str.split("::").skip(1).map(Ident::from_str))
3321 .map(|i| self.new_ast_path_segment(i))
3322 .collect(),
3323 tokens: None,
3324 }
3325 } else {
3326 ast::Path {
3327 span,
3328 segments: path_str
3329 .split("::")
3330 .map(Ident::from_str)
3331 .map(|i| self.new_ast_path_segment(i))
3332 .collect(),
3333 tokens: None,
3334 }
3335 };
3336 let module = self.expect_module(module_id);
3337 let parent_scope = &ParentScope::module(module, self);
3338 let res = self.resolve_ast_path(&path, ns, parent_scope).map_err(|_| ())?;
3339 Ok((path, res))
3340 }
3341
3342 // Resolve a path passed from rustdoc or HIR lowering.
resolve_ast_path( &mut self, path: &ast::Path, ns: Namespace, parent_scope: &ParentScope<'a>, ) -> Result<Res, (Span, ResolutionError<'a>)>3343 fn resolve_ast_path(
3344 &mut self,
3345 path: &ast::Path,
3346 ns: Namespace,
3347 parent_scope: &ParentScope<'a>,
3348 ) -> Result<Res, (Span, ResolutionError<'a>)> {
3349 match self.resolve_path(
3350 &Segment::from_path(path),
3351 Some(ns),
3352 parent_scope,
3353 false,
3354 path.span,
3355 CrateLint::No,
3356 ) {
3357 PathResult::Module(ModuleOrUniformRoot::Module(module)) => Ok(module.res().unwrap()),
3358 PathResult::NonModule(path_res) if path_res.unresolved_segments() == 0 => {
3359 Ok(path_res.base_res())
3360 }
3361 PathResult::NonModule(..) => Err((
3362 path.span,
3363 ResolutionError::FailedToResolve {
3364 label: String::from("type-relative paths are not supported in this context"),
3365 suggestion: None,
3366 },
3367 )),
3368 PathResult::Module(..) | PathResult::Indeterminate => unreachable!(),
3369 PathResult::Failed { span, label, suggestion, .. } => {
3370 Err((span, ResolutionError::FailedToResolve { label, suggestion }))
3371 }
3372 }
3373 }
3374
new_ast_path_segment(&mut self, ident: Ident) -> ast::PathSegment3375 fn new_ast_path_segment(&mut self, ident: Ident) -> ast::PathSegment {
3376 let mut seg = ast::PathSegment::from_ident(ident);
3377 seg.id = self.next_node_id();
3378 seg
3379 }
3380
3381 // For rustdoc.
graph_root(&self) -> Module<'a>3382 pub fn graph_root(&self) -> Module<'a> {
3383 self.graph_root
3384 }
3385
3386 // For rustdoc.
all_macros(&self) -> &FxHashMap<Symbol, Res>3387 pub fn all_macros(&self) -> &FxHashMap<Symbol, Res> {
3388 &self.all_macros
3389 }
3390
3391 /// Retrieves the span of the given `DefId` if `DefId` is in the local crate.
3392 #[inline]
opt_span(&self, def_id: DefId) -> Option<Span>3393 pub fn opt_span(&self, def_id: DefId) -> Option<Span> {
3394 def_id.as_local().map(|def_id| self.definitions.def_span(def_id))
3395 }
3396
3397 /// Checks if an expression refers to a function marked with
3398 /// `#[rustc_legacy_const_generics]` and returns the argument index list
3399 /// from the attribute.
legacy_const_generic_args(&mut self, expr: &Expr) -> Option<Vec<usize>>3400 pub fn legacy_const_generic_args(&mut self, expr: &Expr) -> Option<Vec<usize>> {
3401 if let ExprKind::Path(None, path) = &expr.kind {
3402 // Don't perform legacy const generics rewriting if the path already
3403 // has generic arguments.
3404 if path.segments.last().unwrap().args.is_some() {
3405 return None;
3406 }
3407
3408 let partial_res = self.partial_res_map.get(&expr.id)?;
3409 if partial_res.unresolved_segments() != 0 {
3410 return None;
3411 }
3412
3413 if let Res::Def(def::DefKind::Fn, def_id) = partial_res.base_res() {
3414 // We only support cross-crate argument rewriting. Uses
3415 // within the same crate should be updated to use the new
3416 // const generics style.
3417 if def_id.is_local() {
3418 return None;
3419 }
3420
3421 if let Some(v) = self.legacy_const_generic_args.get(&def_id) {
3422 return v.clone();
3423 }
3424
3425 let parse_attrs = || {
3426 let attrs = self.cstore().item_attrs(def_id, self.session);
3427 let attr =
3428 attrs.iter().find(|a| a.has_name(sym::rustc_legacy_const_generics))?;
3429 let mut ret = vec![];
3430 for meta in attr.meta_item_list()? {
3431 match meta.literal()?.kind {
3432 LitKind::Int(a, _) => {
3433 ret.push(a as usize);
3434 }
3435 _ => panic!("invalid arg index"),
3436 }
3437 }
3438 Some(ret)
3439 };
3440
3441 // Cache the lookup to avoid parsing attributes for an iterm
3442 // multiple times.
3443 let ret = parse_attrs();
3444 self.legacy_const_generic_args.insert(def_id, ret.clone());
3445 return ret;
3446 }
3447 }
3448 None
3449 }
3450
resolve_main(&mut self)3451 fn resolve_main(&mut self) {
3452 let module = self.graph_root;
3453 let ident = Ident::with_dummy_span(sym::main);
3454 let parent_scope = &ParentScope::module(module, self);
3455
3456 let name_binding = match self.resolve_ident_in_module(
3457 ModuleOrUniformRoot::Module(module),
3458 ident,
3459 ValueNS,
3460 parent_scope,
3461 false,
3462 DUMMY_SP,
3463 ) {
3464 Ok(name_binding) => name_binding,
3465 _ => return,
3466 };
3467
3468 let res = name_binding.res();
3469 let is_import = name_binding.is_import();
3470 let span = name_binding.span;
3471 if let Res::Def(DefKind::Fn, _) = res {
3472 self.record_use(ident, name_binding, false);
3473 }
3474 self.main_def = Some(MainDefinition { res, is_import, span });
3475 }
3476 }
3477
names_to_string(names: &[Symbol]) -> String3478 fn names_to_string(names: &[Symbol]) -> String {
3479 let mut result = String::new();
3480 for (i, name) in names.iter().filter(|name| **name != kw::PathRoot).enumerate() {
3481 if i > 0 {
3482 result.push_str("::");
3483 }
3484 if Ident::with_dummy_span(*name).is_raw_guess() {
3485 result.push_str("r#");
3486 }
3487 result.push_str(&name.as_str());
3488 }
3489 result
3490 }
3491
path_names_to_string(path: &Path) -> String3492 fn path_names_to_string(path: &Path) -> String {
3493 names_to_string(&path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>())
3494 }
3495
3496 /// A somewhat inefficient routine to obtain the name of a module.
module_to_string(module: Module<'_>) -> Option<String>3497 fn module_to_string(module: Module<'_>) -> Option<String> {
3498 let mut names = Vec::new();
3499
3500 fn collect_mod(names: &mut Vec<Symbol>, module: Module<'_>) {
3501 if let ModuleKind::Def(.., name) = module.kind {
3502 if let Some(parent) = module.parent {
3503 names.push(name);
3504 collect_mod(names, parent);
3505 }
3506 } else {
3507 names.push(Symbol::intern("<opaque>"));
3508 collect_mod(names, module.parent.unwrap());
3509 }
3510 }
3511 collect_mod(&mut names, module);
3512
3513 if names.is_empty() {
3514 return None;
3515 }
3516 names.reverse();
3517 Some(names_to_string(&names))
3518 }
3519
3520 #[derive(Copy, Clone, Debug)]
3521 enum CrateLint {
3522 /// Do not issue the lint.
3523 No,
3524
3525 /// This lint applies to some arbitrary path; e.g., `impl ::foo::Bar`.
3526 /// In this case, we can take the span of that path.
3527 SimplePath(NodeId),
3528
3529 /// This lint comes from a `use` statement. In this case, what we
3530 /// care about really is the *root* `use` statement; e.g., if we
3531 /// have nested things like `use a::{b, c}`, we care about the
3532 /// `use a` part.
3533 UsePath { root_id: NodeId, root_span: Span },
3534
3535 /// This is the "trait item" from a fully qualified path. For example,
3536 /// we might be resolving `X::Y::Z` from a path like `<T as X::Y>::Z`.
3537 /// The `path_span` is the span of the to the trait itself (`X::Y`).
3538 QPathTrait { qpath_id: NodeId, qpath_span: Span },
3539 }
3540
3541 impl CrateLint {
node_id(&self) -> Option<NodeId>3542 fn node_id(&self) -> Option<NodeId> {
3543 match *self {
3544 CrateLint::No => None,
3545 CrateLint::SimplePath(id)
3546 | CrateLint::UsePath { root_id: id, .. }
3547 | CrateLint::QPathTrait { qpath_id: id, .. } => Some(id),
3548 }
3549 }
3550 }
3551
provide(providers: &mut Providers)3552 pub fn provide(providers: &mut Providers) {
3553 late::lifetimes::provide(providers);
3554 }
3555