Struct rustc_resolve::Resolver

source ·
pub struct Resolver<'a, 'tcx> {
Show 85 fields pub(crate) tcx: TyCtxt<'tcx>, pub(crate) expn_that_defined: FxHashMap<LocalDefId, ExpnId>, pub(crate) graph_root: Module<'a>, pub(crate) prelude: Option<Module<'a>>, pub(crate) extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>, pub(crate) has_self: LocalDefIdSet, pub(crate) field_def_ids: LocalDefIdMap<&'tcx [DefId]>, pub(crate) field_visibility_spans: FxHashMap<DefId, Vec<Span>>, pub(crate) determined_imports: Vec<Interned<'a, ImportData<'a>>>, pub(crate) indeterminate_imports: Vec<Interned<'a, ImportData<'a>>>, pub(crate) pat_span_map: NodeMap<Span>, pub(crate) partial_res_map: NodeMap<PartialRes>, pub(crate) import_res_map: NodeMap<PerNS<Option<Res<NodeId>>>>, pub(crate) label_res_map: NodeMap<NodeId>, pub(crate) lifetimes_res_map: NodeMap<LifetimeRes>, pub(crate) extra_lifetime_params_map: NodeMap<Vec<(Ident, NodeId, LifetimeRes)>>, pub(crate) extern_crate_map: FxHashMap<LocalDefId, CrateNum>, pub(crate) module_children: LocalDefIdMap<Vec<ModChild>>, pub(crate) trait_map: NodeMap<Vec<TraitCandidate>>, pub(crate) block_map: NodeMap<Module<'a>>, pub(crate) empty_module: Module<'a>, pub(crate) module_map: FxHashMap<DefId, Module<'a>>, pub(crate) binding_parent_modules: FxHashMap<Interned<'a, NameBindingData<'a>>, Module<'a>>, pub(crate) underscore_disambiguator: u32, pub(crate) glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>, pub(crate) visibilities: FxHashMap<LocalDefId, Visibility>, pub(crate) used_imports: FxHashSet<NodeId>, pub(crate) maybe_unused_trait_imports: FxIndexSet<LocalDefId>, pub(crate) privacy_errors: Vec<PrivacyError<'a>>, pub(crate) ambiguity_errors: Vec<AmbiguityError<'a>>, pub(crate) use_injections: Vec<UseError<'tcx>>, pub(crate) macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>, pub(crate) arenas: &'a ResolverArenas<'a>, pub(crate) dummy_binding: Interned<'a, NameBindingData<'a>>, pub(crate) builtin_types_bindings: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>, pub(crate) builtin_attrs_bindings: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>, pub(crate) registered_tool_bindings: FxHashMap<Ident, Interned<'a, NameBindingData<'a>>>, pub(crate) module_self_bindings: FxHashMap<Module<'a>, Interned<'a, NameBindingData<'a>>>, pub(crate) used_extern_options: FxHashSet<Symbol>, pub(crate) macro_names: FxHashSet<Ident>, pub(crate) builtin_macros: FxHashMap<Symbol, BuiltinMacroState>, pub(crate) builtin_macro_kinds: FxHashMap<LocalDefId, MacroKind>, pub(crate) registered_tools: &'tcx RegisteredTools, pub(crate) macro_use_prelude: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>, pub(crate) macro_map: FxHashMap<DefId, MacroData>, pub(crate) dummy_ext_bang: Lrc<SyntaxExtension>, pub(crate) dummy_ext_derive: Lrc<SyntaxExtension>, pub(crate) non_macro_attr: Lrc<SyntaxExtension>, pub(crate) local_macro_def_scopes: FxHashMap<LocalDefId, Module<'a>>, pub(crate) ast_transform_scopes: FxHashMap<LocalExpnId, Module<'a>>, pub(crate) unused_macros: FxHashMap<LocalDefId, (NodeId, Ident)>, pub(crate) unused_macro_rules: FxHashMap<(LocalDefId, usize), (Ident, Span)>, pub(crate) proc_macro_stubs: FxHashSet<LocalDefId>, pub(crate) single_segment_macro_resolutions: Vec<(Ident, MacroKind, ParentScope<'a>, Option<Interned<'a, NameBindingData<'a>>>)>, pub(crate) multi_segment_macro_resolutions: Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'a>, Option<Res<NodeId>>)>, pub(crate) builtin_attrs: Vec<(Ident, ParentScope<'a>)>, pub(crate) containers_deriving_copy: FxHashSet<LocalExpnId>, pub(crate) invocation_parent_scopes: FxHashMap<LocalExpnId, ParentScope<'a>>, pub(crate) output_macro_rules_scopes: FxHashMap<LocalExpnId, Interned<'a, Cell<MacroRulesScope<'a>>>>, pub(crate) macro_rules_scopes: FxHashMap<LocalDefId, Interned<'a, Cell<MacroRulesScope<'a>>>>, pub(crate) helper_attrs: FxHashMap<LocalExpnId, Vec<(Ident, Interned<'a, NameBindingData<'a>>)>>, pub(crate) derive_data: FxHashMap<LocalExpnId, DeriveData>, pub(crate) name_already_seen: FxHashMap<Symbol, Span>, pub(crate) potentially_unused_imports: Vec<Interned<'a, ImportData<'a>>>, pub(crate) struct_constructors: LocalDefIdMap<(Res<NodeId>, Visibility<DefId>, Vec<Visibility<DefId>>)>, pub(crate) active_features: FxHashSet<Symbol>, pub(crate) lint_buffer: LintBuffer, pub(crate) next_node_id: NodeId, pub(crate) node_id_to_def_id: FxHashMap<NodeId, LocalDefId>, pub(crate) def_id_to_node_id: IndexVec<LocalDefId, NodeId>, pub(crate) placeholder_field_indices: FxHashMap<NodeId, usize>, pub(crate) invocation_parents: FxHashMap<LocalExpnId, (LocalDefId, ImplTraitContext)>, pub(crate) trait_impl_items: FxHashSet<LocalDefId>, pub(crate) legacy_const_generic_args: FxHashMap<DefId, Option<Vec<usize>>>, pub(crate) item_generics_num_lifetimes: FxHashMap<LocalDefId, usize>, pub(crate) main_def: Option<MainDefinition>, pub(crate) trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>, pub(crate) proc_macros: Vec<NodeId>, pub(crate) confused_type_with_std_module: FxHashMap<Span, Span>, pub(crate) lifetime_elision_allowed: FxHashSet<NodeId>, pub(crate) stripped_cfg_items: Vec<StrippedCfgItem<NodeId>>, pub(crate) effective_visibilities: EffectiveVisibilities, pub(crate) doc_link_resolutions: FxHashMap<LocalDefId, DocLinkResMap>, pub(crate) doc_link_traits_in_scope: FxHashMap<LocalDefId, Vec<DefId>>, pub(crate) all_macro_rules: FxHashMap<Symbol, Res<NodeId>>,
}
Expand description

The main resolver class.

This is the visitor that walks the whole crate.

Fields§

§tcx: TyCtxt<'tcx>§expn_that_defined: FxHashMap<LocalDefId, ExpnId>

Item with a given LocalDefId was defined during macro expansion with ID ExpnId.

§graph_root: Module<'a>§prelude: Option<Module<'a>>§extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>§has_self: LocalDefIdSet

N.B., this is used only for better diagnostics, not name resolution itself.

§field_def_ids: LocalDefIdMap<&'tcx [DefId]>§field_visibility_spans: FxHashMap<DefId, Vec<Span>>

Span of the privacy modifier in fields of an item DefId accessible with dot syntax. Used for hints during error reporting.

§determined_imports: Vec<Interned<'a, ImportData<'a>>>

All imports known to succeed or fail.

§indeterminate_imports: Vec<Interned<'a, ImportData<'a>>>

All non-determined imports.

§pat_span_map: NodeMap<Span>§partial_res_map: NodeMap<PartialRes>

Resolutions for nodes that have a single resolution.

§import_res_map: NodeMap<PerNS<Option<Res<NodeId>>>>

Resolutions for import nodes, which have multiple resolutions in different namespaces.

§label_res_map: NodeMap<NodeId>

Resolutions for labels (node IDs of their corresponding blocks or loops).

§lifetimes_res_map: NodeMap<LifetimeRes>

Resolutions for lifetimes.

§extra_lifetime_params_map: NodeMap<Vec<(Ident, NodeId, LifetimeRes)>>

Lifetime parameters that lowering will have to introduce.

§extern_crate_map: FxHashMap<LocalDefId, CrateNum>

CrateNum resolutions of extern crate items.

§module_children: LocalDefIdMap<Vec<ModChild>>§trait_map: NodeMap<Vec<TraitCandidate>>§block_map: NodeMap<Module<'a>>

A map from nodes to anonymous modules. Anonymous modules are pseudo-modules that are implicitly created around items contained within blocks.

For example, if we have this:

fn f() { fn g() { … } }

There will be an anonymous module created around g with the ID of the entry block for f.

§empty_module: Module<'a>

A fake module that contains no definition and no prelude. Used so that some AST passes can generate identifiers that only resolve to local or language items.

§module_map: FxHashMap<DefId, Module<'a>>§binding_parent_modules: FxHashMap<Interned<'a, NameBindingData<'a>>, Module<'a>>§underscore_disambiguator: u32§glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>

Maps glob imports to the names of items actually imported.

§visibilities: FxHashMap<LocalDefId, Visibility>

Visibilities in “lowered” form, for all entities that have them.

§used_imports: FxHashSet<NodeId>§maybe_unused_trait_imports: FxIndexSet<LocalDefId>§privacy_errors: Vec<PrivacyError<'a>>

Privacy errors are delayed until the end in order to deduplicate them.

§ambiguity_errors: Vec<AmbiguityError<'a>>

Ambiguity errors are delayed for deduplication.

§use_injections: Vec<UseError<'tcx>>

use injections are delayed for better placement and deduplication.

§macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>

Crate-local macro expanded macro_export referred to by a module-relative path.

§arenas: &'a ResolverArenas<'a>§dummy_binding: Interned<'a, NameBindingData<'a>>§builtin_types_bindings: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>§builtin_attrs_bindings: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>§registered_tool_bindings: FxHashMap<Ident, Interned<'a, NameBindingData<'a>>>§module_self_bindings: FxHashMap<Module<'a>, Interned<'a, NameBindingData<'a>>>

Binding for implicitly declared names that come with a module, like self (not yet used), or crate/$crate (for root modules).

§used_extern_options: FxHashSet<Symbol>§macro_names: FxHashSet<Ident>§builtin_macros: FxHashMap<Symbol, BuiltinMacroState>§builtin_macro_kinds: FxHashMap<LocalDefId, MacroKind>

A small map keeping true kinds of built-in macros that appear to be fn-like on the surface (macro items in libcore), but are actually attributes or derives.

§registered_tools: &'tcx RegisteredTools§macro_use_prelude: FxHashMap<Symbol, Interned<'a, NameBindingData<'a>>>§macro_map: FxHashMap<DefId, MacroData>§dummy_ext_bang: Lrc<SyntaxExtension>§dummy_ext_derive: Lrc<SyntaxExtension>§non_macro_attr: Lrc<SyntaxExtension>§local_macro_def_scopes: FxHashMap<LocalDefId, Module<'a>>§ast_transform_scopes: FxHashMap<LocalExpnId, Module<'a>>§unused_macros: FxHashMap<LocalDefId, (NodeId, Ident)>§unused_macro_rules: FxHashMap<(LocalDefId, usize), (Ident, Span)>§proc_macro_stubs: FxHashSet<LocalDefId>§single_segment_macro_resolutions: Vec<(Ident, MacroKind, ParentScope<'a>, Option<Interned<'a, NameBindingData<'a>>>)>

Traces collected during macro resolution and validated when it’s complete.

§multi_segment_macro_resolutions: Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'a>, Option<Res<NodeId>>)>§builtin_attrs: Vec<(Ident, ParentScope<'a>)>§containers_deriving_copy: FxHashSet<LocalExpnId>

derive(Copy) marks items they are applied to so they are treated specially later. Derive macros cannot modify the item themselves and have to store the markers in the global context, so they attach the markers to derive container IDs using this resolver table.

§invocation_parent_scopes: FxHashMap<LocalExpnId, ParentScope<'a>>

Parent scopes in which the macros were invoked. FIXME: derives are missing in these parent scopes and need to be taken from elsewhere.

§output_macro_rules_scopes: FxHashMap<LocalExpnId, Interned<'a, Cell<MacroRulesScope<'a>>>>

macro_rules scopes produced by expanding the macro invocations, include all the macro_rules items and other invocations generated by them.

§macro_rules_scopes: FxHashMap<LocalDefId, Interned<'a, Cell<MacroRulesScope<'a>>>>

macro_rules scopes produced by macro_rules item definitions.

§helper_attrs: FxHashMap<LocalExpnId, Vec<(Ident, Interned<'a, NameBindingData<'a>>)>>

Helper attributes that are in scope for the given expansion.

§derive_data: FxHashMap<LocalExpnId, DeriveData>

Ready or in-progress results of resolving paths inside the #[derive(...)] attribute with the given ExpnId.

§name_already_seen: FxHashMap<Symbol, Span>

Avoid duplicated errors for “name already defined”.

§potentially_unused_imports: Vec<Interned<'a, ImportData<'a>>>§struct_constructors: LocalDefIdMap<(Res<NodeId>, Visibility<DefId>, Vec<Visibility<DefId>>)>

Table for mapping struct IDs into struct constructor IDs, it’s not used during normal resolution, only for better error reporting. Also includes of list of each fields visibility

§active_features: FxHashSet<Symbol>

Features enabled for this crate.

§lint_buffer: LintBuffer§next_node_id: NodeId§node_id_to_def_id: FxHashMap<NodeId, LocalDefId>§def_id_to_node_id: IndexVec<LocalDefId, NodeId>§placeholder_field_indices: FxHashMap<NodeId, usize>

Indices of unnamed struct or variant fields with unresolved attributes.

§invocation_parents: FxHashMap<LocalExpnId, (LocalDefId, ImplTraitContext)>

When collecting definitions from an AST fragment produced by a macro invocation ExpnId we know what parent node that fragment should be attached to thanks to this table, and how the impl Trait fragments were introduced.

§trait_impl_items: FxHashSet<LocalDefId>

Some way to know that we are in a trait impl in visit_assoc_item. FIXME: Replace with a more general AST map (together with some other fields).

§legacy_const_generic_args: FxHashMap<DefId, Option<Vec<usize>>>§item_generics_num_lifetimes: FxHashMap<LocalDefId, usize>

Amount of lifetime parameters for each item in the crate.

§main_def: Option<MainDefinition>§trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>§proc_macros: Vec<NodeId>

A list of proc macro LocalDefIds, written out in the order in which they are declared in the static array generated by proc_macro_harness.

§confused_type_with_std_module: FxHashMap<Span, Span>§lifetime_elision_allowed: FxHashSet<NodeId>

Whether lifetime elision was successful.

§stripped_cfg_items: Vec<StrippedCfgItem<NodeId>>

Names of items that were stripped out via cfg with their corresponding cfg meta item.

§effective_visibilities: EffectiveVisibilities§doc_link_resolutions: FxHashMap<LocalDefId, DocLinkResMap>§doc_link_traits_in_scope: FxHashMap<LocalDefId, Vec<DefId>>§all_macro_rules: FxHashMap<Symbol, Res<NodeId>>

Implementations§

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub(crate) fn define<T>( &mut self, parent: Module<'a>, ident: Ident, ns: Namespace, def: T )where T: ToNameBinding<'a>,

Defines name in namespace ns of module parent to be def if it is not yet defined; otherwise, reports an error.

source

pub(crate) fn get_nearest_non_block_module( &mut self, def_id: DefId ) -> Module<'a>

Walks up the tree of definitions starting at def_id, stopping at the first encountered module. Parent block modules for arbitrary def-ids are not recorded for the local crate, and are not preserved in metadata for foreign crates, so block modules are never returned by this function.

For the local crate ignoring block modules may be incorrect, so use this method with care.

For foreign crates block modules can be ignored without introducing observable differences, moreover they has to be ignored right now because they are not kept in metadata. Foreign parent modules are used for resolving names used by foreign macros with def-site hygiene, therefore block module ignorability relies on macros with def-site hygiene and block module parents being unreachable from other crates. Reachable macros with block module parents exist due to #[macro_export] macro_rules!, but they cannot use def-site hygiene, so the assumption holds (https://github.com/rust-lang/rust/pull/77984#issuecomment-712445508).

source

pub(crate) fn expect_module(&mut self, def_id: DefId) -> Module<'a>

source

pub(crate) fn get_module(&mut self, def_id: DefId) -> Option<Module<'a>>

If def_id refers to a module (in resolver’s sense, i.e. a module item, crate root, enum, or trait), then this function returns that module’s resolver representation, otherwise it returns None.

source

pub(crate) fn expn_def_scope(&mut self, expn_id: ExpnId) -> Module<'a>

source

pub(crate) fn macro_def_scope(&mut self, def_id: DefId) -> Module<'a>

source

pub(crate) fn get_macro(&mut self, res: Res<NodeId>) -> Option<MacroData>

source

pub(crate) fn get_macro_by_def_id(&mut self, def_id: DefId) -> MacroData

source

pub(crate) fn build_reduced_graph( &mut self, fragment: &AstFragment, parent_scope: ParentScope<'a> ) -> Interned<'a, Cell<MacroRulesScope<'a>>>

source

pub(crate) fn build_reduced_graph_external(&mut self, module: Module<'a>)

source§

impl Resolver<'_, '_>

source

pub(crate) fn check_unused(&mut self, krate: &Crate)

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub(crate) fn report_errors(&mut self, krate: &Crate)

source

fn report_with_use_injections(&mut self, krate: &Crate)

source

pub(crate) fn report_conflict( &mut self, parent: Module<'_>, ident: Ident, ns: Namespace, new_binding: Interned<'a, NameBindingData<'a>>, old_binding: Interned<'a, NameBindingData<'a>> )

source

fn add_suggestion_for_rename_of_use( &self, err: &mut Diagnostic, name: Symbol, import: Interned<'_, ImportData<'_>>, binding_span: Span )

This function adds a suggestion to change the binding name of a new import that conflicts with an existing import.

help: you can use `as` to change the binding name of the import
   |
LL | use foo::bar as other_bar;
   |     ^^^^^^^^^^^^^^^^^^^^^
source

fn add_suggestion_for_duplicate_nested_use( &self, err: &mut Diagnostic, import: Interned<'_, ImportData<'_>>, binding_span: Span )

This function adds a suggestion to remove an unnecessary binding from an import that is nested. In the following example, this function will be invoked to remove the a binding in the second use statement:

use issue_52891::a;
use issue_52891::{d, a, e};

The following suggestion will be added:

use issue_52891::{d, a, e};
                     ^-- help: remove unnecessary import

If the nested use contains only one import then the suggestion will remove the entire line.

It is expected that the provided import is nested - this isn’t checked by the function. If this invariant is not upheld, this function’s behaviour will be unexpected as characters expected by span manipulations won’t be present.

source

pub(crate) fn lint_if_path_starts_with_module( &mut self, finalize: Option<Finalize>, path: &[Segment], second_binding: Option<Interned<'_, NameBindingData<'_>>> )

source

pub(crate) fn add_module_candidates( &mut self, module: Module<'a>, names: &mut Vec<TypoSuggestion>, filter_fn: &impl Fn(Res<NodeId>) -> bool, ctxt: Option<SyntaxContext> )

source

pub(crate) fn report_error( &mut self, span: Span, resolution_error: ResolutionError<'a> )

Combines an error with provided span and emits it.

This takes the error provided, combines it with the span and any additional spans inside the error and emits it.

source

pub(crate) fn into_struct_error( &mut self, span: Span, resolution_error: ResolutionError<'a> ) -> DiagnosticBuilder<'_, ErrorGuaranteed>

source

pub(crate) fn report_vis_error( &mut self, vis_resolution_error: VisResolutionError<'_> ) -> ErrorGuaranteed

source

fn early_lookup_typo_candidate( &mut self, scope_set: ScopeSet<'a>, parent_scope: &ParentScope<'a>, ident: Ident, filter_fn: &impl Fn(Res<NodeId>) -> bool ) -> Option<TypoSuggestion>

Lookup typo candidate in scope for a macro or import.

source

fn lookup_import_candidates_from_module<FilterFn>( &mut self, lookup_ident: Ident, namespace: Namespace, parent_scope: &ParentScope<'a>, start_module: Module<'a>, crate_name: Ident, filter_fn: FilterFn ) -> Vec<ImportSuggestion>where FilterFn: Fn(Res<NodeId>) -> bool,

source

pub(crate) fn lookup_import_candidates<FilterFn>( &mut self, lookup_ident: Ident, namespace: Namespace, parent_scope: &ParentScope<'a>, filter_fn: FilterFn ) -> Vec<ImportSuggestion>where FilterFn: Fn(Res<NodeId>) -> bool,

When name resolution fails, this method can be used to look up candidate entities with the expected name. It allows filtering them using the supplied predicate (which should be used to only accept the types of definitions expected, e.g., traits). The lookup spans across all crates.

N.B., the method does not look into imports, but this is not a problem, since we report the definitions (thus, the de-aliased imports).

source

pub(crate) fn unresolved_macro_suggestions( &mut self, err: &mut Diagnostic, macro_kind: MacroKind, parent_scope: &ParentScope<'a>, ident: Ident, krate: &Crate )

source

pub(crate) fn add_typo_suggestion( &self, err: &mut Diagnostic, suggestion: Option<TypoSuggestion>, span: Span ) -> bool

source

fn binding_description( &self, b: Interned<'_, NameBindingData<'_>>, ident: Ident, from_prelude: bool ) -> String

source

fn ambiguity_diagnostics( &self, ambiguity_error: &AmbiguityError<'_> ) -> AmbiguityErrorDiag

source

fn ctor_fields_span( &self, binding: Interned<'_, NameBindingData<'_>> ) -> Option<Span>

If the binding refers to a tuple struct constructor with fields, returns the span of its fields.

source

fn report_privacy_error(&mut self, privacy_error: &PrivacyError<'a>)

source

pub(crate) fn find_similarly_named_module_or_crate( &mut self, ident: Symbol, current_module: Module<'a> ) -> Option<Symbol>

source

pub(crate) fn report_path_resolution_error( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a>, ribs: Option<&PerNS<Vec<Rib<'a>>>>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>>, module: Option<ModuleOrUniformRoot<'a>>, failed_segment_idx: usize, ident: Ident ) -> (String, Option<(Vec<(Span, String)>, String, Applicability)>)

source

pub(crate) fn make_path_suggestion( &mut self, span: Span, path: Vec<Segment>, parent_scope: &ParentScope<'a> ) -> Option<(Vec<Segment>, Option<String>)>

Adds suggestions for a path that cannot be resolved.

source

fn make_missing_self_suggestion( &mut self, path: Vec<Segment>, parent_scope: &ParentScope<'a> ) -> Option<(Vec<Segment>, Option<String>)>

Suggest a missing self:: if that resolves to an correct module.

   |
LL | use foo::Bar;
   |     ^^^ did you mean `self::foo`?
source

fn make_missing_crate_suggestion( &mut self, path: Vec<Segment>, parent_scope: &ParentScope<'a> ) -> Option<(Vec<Segment>, Option<String>)>

Suggests a missing crate:: if that resolves to an correct module.

   |
LL | use foo::Bar;
   |     ^^^ did you mean `crate::foo`?
source

fn make_missing_super_suggestion( &mut self, path: Vec<Segment>, parent_scope: &ParentScope<'a> ) -> Option<(Vec<Segment>, Option<String>)>

Suggests a missing super:: if that resolves to an correct module.

   |
LL | use foo::Bar;
   |     ^^^ did you mean `super::foo`?
source

fn make_external_crate_suggestion( &mut self, path: Vec<Segment>, parent_scope: &ParentScope<'a> ) -> Option<(Vec<Segment>, Option<String>)>

Suggests a missing external crate name if that resolves to an correct module.

   |
LL | use foobar::Baz;
   |     ^^^^^^ did you mean `baz::foobar`?

Used when importing a submodule of an external crate but missing that crate’s name as the first part of path.

source

pub(crate) fn check_for_module_export_macro( &mut self, import: Interned<'a, ImportData<'a>>, module: ModuleOrUniformRoot<'a>, ident: Ident ) -> Option<(Option<(Vec<(Span, String)>, String, Applicability)>, Option<String>)>

Suggests importing a macro from the root of the crate rather than a module within the crate.

help: a macro with this name exists at the root of the crate
   |
LL | use issue_59764::makro;
   |     ^^^^^^^^^^^^^^^^^^
   |
   = note: this could be because a macro annotated with `#[macro_export]` will be exported
           at the root of the crate instead of the module where it is defined
source

pub(crate) fn find_cfg_stripped( &mut self, err: &mut Diagnostic, last_segment: &Symbol, module: DefId )

Finds a cfg-ed out item inside module with the matching name.

source§

impl Resolver<'_, '_>

source

fn nearest_normal_mod(&mut self, def_id: LocalDefId) -> LocalDefId

source

fn private_vis_import( &mut self, binding: Interned<'_, NameBindingData<'_>> ) -> Visibility

source

fn private_vis_def(&mut self, def_id: LocalDefId) -> Visibility

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub(crate) fn visit_scopes<T>( &mut self, scope_set: ScopeSet<'a>, parent_scope: &ParentScope<'a>, ctxt: SyntaxContext, visitor: impl FnMut(&mut Self, Scope<'a>, bool, SyntaxContext) -> Option<T> ) -> Option<T>

A generic scope visitor. Visits scopes in order to resolve some identifier in them or perform other actions. If the callback returns Some result, we stop visiting scopes and return it.

source

fn hygienic_lexical_parent( &mut self, module: Module<'a>, ctxt: &mut SyntaxContext, derive_fallback_lint_id: Option<NodeId> ) -> Option<(Module<'a>, Option<NodeId>)>

source

pub(crate) fn resolve_ident_in_lexical_scope( &mut self, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ribs: &[Rib<'a>], ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Option<LexicalScopeBinding<'a>>

This resolves the identifier ident in the namespace ns in the current lexical scope. More specifically, we proceed up the hierarchy of scopes and return the binding for ident in the first scope that defines it (or None if no scopes define it).

A block’s items are above its local variables in the scope hierarchy, regardless of where the items are defined in the block. For example,

fn f() {
   g(); // Since there are no local variables in scope yet, this resolves to the item.
   let g = || {};
   fn g() {}
   g(); // This resolves to the local variable `g` since it shadows the item.
}

Invariant: This must only be called during main resolution, not during import resolution.

source

pub(crate) fn early_resolve_ident_in_lexical_scope( &mut self, orig_ident: Ident, scope_set: ScopeSet<'a>, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, force: bool, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Result<Interned<'a, NameBindingData<'a>>, Determinacy>

Resolve an identifier in lexical scope. This is a variation of fn resolve_ident_in_lexical_scope that can be run during expansion and import resolution (perhaps they can be merged in the future). The function is used for resolving initial segments of macro paths (e.g., foo in foo::bar!(); or foo!();) and also for import paths on 2018 edition.

source

pub(crate) fn maybe_resolve_ident_in_module( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a> ) -> Result<Interned<'a, NameBindingData<'a>>, Determinacy>

source

pub(crate) fn resolve_ident_in_module( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Result<Interned<'a, NameBindingData<'a>>, Determinacy>

source

fn resolve_ident_in_module_ext( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Result<Interned<'a, NameBindingData<'a>>, (Determinacy, Weak)>

source

fn resolve_ident_in_module_unadjusted( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Result<Interned<'a, NameBindingData<'a>>, Determinacy>

source

fn resolve_ident_in_module_unadjusted_ext( &mut self, module: ModuleOrUniformRoot<'a>, ident: Ident, ns: Namespace, parent_scope: &ParentScope<'a>, restricted_shadowing: bool, finalize: Option<Finalize>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> Result<Interned<'a, NameBindingData<'a>>, (Determinacy, Weak)>

Attempts to resolve ident in namespaces ns of module. Invariant: if finalize is Some, expansion and import resolution must be complete.

source

fn validate_res_from_ribs( &mut self, rib_index: usize, rib_ident: Ident, res: Res<NodeId>, finalize: Option<Span>, original_rib_ident_def: Ident, all_ribs: &[Rib<'a>] ) -> Res<NodeId>

Validate a local resolution (from ribs).

source

pub(crate) fn maybe_resolve_path( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a> ) -> PathResult<'a>

source

pub(crate) fn resolve_path( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> PathResult<'a>

source

pub(crate) fn resolve_path_with_ribs( &mut self, path: &[Segment], opt_ns: Option<Namespace>, parent_scope: &ParentScope<'a>, finalize: Option<Finalize>, ribs: Option<&PerNS<Vec<Rib<'a>>>>, ignore_binding: Option<Interned<'a, NameBindingData<'a>>> ) -> PathResult<'a>

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub(crate) fn import( &self, binding: Interned<'a, NameBindingData<'a>>, import: Interned<'a, ImportData<'a>> ) -> Interned<'a, NameBindingData<'a>>

Given a binding and an import that resolves to it, return the corresponding binding defined by the import.

source

pub(crate) fn try_define( &mut self, module: Module<'a>, key: BindingKey, binding: Interned<'a, NameBindingData<'a>>, warn_ambiguity: bool ) -> Result<(), Interned<'a, NameBindingData<'a>>>

Define the name or return the existing binding if there is a collision. update indicates if the definition is a redefinition of an existing binding.

source

fn ambiguity( &self, kind: AmbiguityKind, primary_binding: Interned<'a, NameBindingData<'a>>, secondary_binding: Interned<'a, NameBindingData<'a>> ) -> Interned<'a, NameBindingData<'a>>

source

fn warn_ambiguity( &self, kind: AmbiguityKind, primary_binding: Interned<'a, NameBindingData<'a>>, secondary_binding: Interned<'a, NameBindingData<'a>> ) -> Interned<'a, NameBindingData<'a>>

source

fn update_resolution<T, F>( &mut self, module: Module<'a>, key: BindingKey, warn_ambiguity: bool, f: F ) -> Twhere F: FnOnce(&mut Resolver<'a, 'tcx>, &mut NameResolution<'a>) -> T,

source

fn import_dummy_binding( &mut self, import: Interned<'a, ImportData<'a>>, is_indeterminate: bool )

source

pub(crate) fn resolve_imports(&mut self)

Resolves all imports for the crate. This method performs the fixed- point iteration.

source

pub(crate) fn finalize_imports(&mut self)

source

pub(crate) fn check_hidden_glob_reexports( &mut self, exported_ambiguities: FxHashSet<Interned<'a, NameBindingData<'a>>> )

source

fn throw_unresolved_import_error( &mut self, errors: Vec<(Interned<'_, ImportData<'_>>, UnresolvedImportError)> )

source

fn resolve_import(&mut self, import: Interned<'a, ImportData<'a>>) -> usize

Attempts to resolve the given import, returning:

  • 0 means its resolution is determined.
  • Other values mean that indeterminate exists under certain namespaces.

Meanwhile, if resolve successful, the resolved bindings are written into the module.

source

fn finalize_import( &mut self, import: Interned<'a, ImportData<'a>> ) -> Option<UnresolvedImportError>

Performs final import resolution, consistency checks and error reporting.

Optionally returns an unresolved import error. This error is buffered and used to consolidate multiple unresolved import errors into a single diagnostic.

source

fn check_for_redundant_imports( &mut self, ident: Ident, import: Interned<'a, ImportData<'a>>, source_bindings: &PerNS<Cell<Result<Interned<'a, NameBindingData<'a>>, Determinacy>>>, target_bindings: &PerNS<Cell<Option<Interned<'a, NameBindingData<'a>>>>>, target: Ident )

source

fn resolve_glob_import(&mut self, import: Interned<'a, ImportData<'a>>)

source

fn finalize_resolutions_in(&mut self, module: Module<'a>)

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub(crate) fn late_resolve_crate(&mut self, krate: &Crate)

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

fn smart_resolve_macro_path( &mut self, path: &Path, kind: MacroKind, supports_macro_expansion: SupportsMacroExpansion, inner_attr: bool, parent_scope: &ParentScope<'a>, node_id: NodeId, force: bool, soft_custom_inner_attributes_gate: bool ) -> Result<(Lrc<SyntaxExtension>, Res<NodeId>), Indeterminate>

Resolve macro path with error reporting and recovery. Uses dummy syntax extensions for unresolved macros or macros with unexpected resolutions for better error recovery.

source

pub(crate) fn resolve_macro_path( &mut self, path: &Path, kind: Option<MacroKind>, parent_scope: &ParentScope<'a>, trace: bool, force: bool ) -> Result<(Option<Lrc<SyntaxExtension>>, Res<NodeId>), Determinacy>

source

pub(crate) fn finalize_macro_resolutions(&mut self, krate: &Crate)

source

fn check_stability_and_deprecation( &mut self, ext: &SyntaxExtension, path: &Path, node_id: NodeId )

source

fn prohibit_imported_non_macro_attrs( &self, binding: Option<Interned<'a, NameBindingData<'a>>>, res: Option<Res<NodeId>>, span: Span )

source

pub(crate) fn check_reserved_macro_name( &mut self, ident: Ident, res: Res<NodeId> )

source

pub(crate) fn compile_macro( &mut self, item: &Item, edition: Edition ) -> (SyntaxExtension, Vec<(usize, Span)>)

Compile the macro into a SyntaxExtension and its rule spans.

Possibly replace its expander to a pre-defined one for built-in macros.

source§

impl<'tcx> Resolver<'_, 'tcx>

source

pub(crate) fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>

source

pub(crate) fn local_def_id(&self, node: NodeId) -> LocalDefId

source

pub(crate) fn create_def( &mut self, parent: LocalDefId, node_id: NodeId, data: DefPathData, expn_id: ExpnId, span: Span ) -> LocalDefId

Adds a definition with a parent definition.

source

pub(crate) fn item_generics_num_lifetimes(&self, def_id: DefId) -> usize

source

pub fn tcx(&self) -> TyCtxt<'tcx>

source§

impl<'a, 'tcx> Resolver<'a, 'tcx>

source

pub fn new( tcx: TyCtxt<'tcx>, attrs: &[Attribute], crate_span: Span, arenas: &'a ResolverArenas<'a> ) -> Resolver<'a, 'tcx>

source

pub(crate) fn new_module( &mut self, parent: Option<Module<'a>>, kind: ModuleKind, expn_id: ExpnId, span: Span, no_implicit_prelude: bool ) -> Module<'a>

source

pub(crate) fn next_node_id(&mut self) -> NodeId

source

pub(crate) fn next_node_ids(&mut self, count: usize) -> Range<NodeId>

source

pub fn lint_buffer(&mut self) -> &mut LintBuffer

source

pub fn arenas() -> ResolverArenas<'a>

source

pub fn into_outputs(self) -> ResolverOutputs

source

pub(crate) fn create_stable_hashing_context(&self) -> StableHashingContext<'_>

source

pub(crate) fn crate_loader<T>( &mut self, f: impl FnOnce(&mut CrateLoader<'_, '_>) -> T ) -> T

source

pub(crate) fn cstore(&self) -> FreezeReadGuard<'_, CStore>

source

pub(crate) fn dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension>

source

pub(crate) fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, f: F)

Runs the function on each namespace.

source

pub(crate) fn is_builtin_macro(&mut self, res: Res<NodeId>) -> bool

source

pub(crate) fn macro_def(&self, ctxt: SyntaxContext) -> DefId

source

pub fn resolve_crate(&mut self, krate: &Crate)

Entry point to crate resolution.

source

pub(crate) fn traits_in_scope( &mut self, current_trait: Option<Module<'a>>, parent_scope: &ParentScope<'a>, ctxt: SyntaxContext, assoc_item: Option<(Symbol, Namespace)> ) -> Vec<TraitCandidate>

source

pub(crate) fn traits_in_module( &mut self, module: Module<'a>, assoc_item: Option<(Symbol, Namespace)>, found_traits: &mut Vec<TraitCandidate> )

source

pub(crate) fn trait_may_have_item( &mut self, trait_module: Option<Module<'a>>, assoc_item: Option<(Symbol, Namespace)> ) -> bool

source

pub(crate) fn find_transitive_imports( &mut self, kind: &NameBindingKind<'_>, trait_name: Ident ) -> SmallVec<[LocalDefId; 1]>

source

pub(crate) fn new_disambiguated_key( &mut self, ident: Ident, ns: Namespace ) -> BindingKey

source

pub(crate) fn resolutions( &mut self, module: Module<'a> ) -> &'a RefCell<FxIndexMap<BindingKey, &'a RefCell<NameResolution<'a>>>>

source

pub(crate) fn resolution( &mut self, module: Module<'a>, key: BindingKey ) -> &'a RefCell<NameResolution<'a>>

source

pub(crate) fn matches_previous_ambiguity_error( &mut self, ambi: &AmbiguityError<'_> ) -> bool

Test if AmbiguityError ambi is any identical to any one inside ambiguity_errors

source

pub(crate) fn record_use( &mut self, ident: Ident, used_binding: Interned<'a, NameBindingData<'a>>, is_lexical_scope: bool )

source

pub(crate) fn record_use_inner( &mut self, ident: Ident, used_binding: Interned<'a, NameBindingData<'a>>, is_lexical_scope: bool, warn_ambiguity: bool )

source

pub(crate) fn add_to_glob_map( &mut self, import: Interned<'_, ImportData<'_>>, ident: Ident )

source

pub(crate) fn resolve_crate_root(&mut self, ident: Ident) -> Module<'a>

source

pub(crate) fn resolve_self( &mut self, ctxt: &mut SyntaxContext, module: Module<'a> ) -> Module<'a>

source

pub(crate) fn record_partial_res( &mut self, node_id: NodeId, resolution: PartialRes )

source

pub(crate) fn record_pat_span(&mut self, node: NodeId, span: Span)

source

pub(crate) fn is_accessible_from( &self, vis: Visibility<impl Into<DefId>>, module: Module<'a> ) -> bool

source

pub(crate) fn set_binding_parent_module( &mut self, binding: Interned<'a, NameBindingData<'a>>, module: Module<'a> )

source

pub(crate) fn disambiguate_macro_rules_vs_modularized( &self, macro_rules: Interned<'a, NameBindingData<'a>>, modularized: Interned<'a, NameBindingData<'a>> ) -> bool

source

pub(crate) fn extern_prelude_get( &mut self, ident: Ident, finalize: bool ) -> Option<Interned<'a, NameBindingData<'a>>>

source

pub(crate) fn resolve_rustdoc_path( &mut self, path_str: &str, ns: Namespace, parent_scope: ParentScope<'a> ) -> Option<Res<NodeId>>

Rustdoc uses this to resolve doc link paths in a recoverable way. PathResult<'a> isn’t something that can be returned because it can’t be made to live that long, and also it’s a private type. Fortunately rustdoc doesn’t need to know the error, just that an error occurred.

source

pub(crate) fn def_span(&self, def_id: DefId) -> Span

Retrieves definition span of the given DefId.

source

pub(crate) fn field_def_ids(&self, def_id: DefId) -> Option<&'tcx [DefId]>

source

pub(crate) fn legacy_const_generic_args( &mut self, expr: &Expr ) -> Option<Vec<usize>>

Checks if an expression refers to a function marked with #[rustc_legacy_const_generics] and returns the argument index list from the attribute.

source

pub(crate) fn resolve_main(&mut self)

Trait Implementations§

source§

impl<'a, 'tcx> AsMut<Resolver<'a, 'tcx>> for BuildReducedGraphVisitor<'a, '_, 'tcx>

source§

fn as_mut(&mut self) -> &mut Resolver<'a, 'tcx>

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<'a, 'tcx> AsMut<Resolver<'a, 'tcx>> for Resolver<'a, 'tcx>

source§

fn as_mut(&mut self) -> &mut Resolver<'a, 'tcx>

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx>

source§

fn next_node_id(&mut self) -> NodeId

source§

fn invocation_parent(&self, id: LocalExpnId) -> LocalDefId

source§

fn resolve_dollar_crates(&mut self)

source§

fn visit_ast_fragment_with_placeholders( &mut self, expansion: LocalExpnId, fragment: &AstFragment )

source§

fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind)

source§

fn expansion_for_ast_pass( &mut self, call_site: Span, pass: AstPass, features: &[Symbol], parent_module_id: Option<NodeId> ) -> LocalExpnId

source§

fn resolve_imports(&mut self)

source§

fn resolve_macro_invocation( &mut self, invoc: &Invocation, eager_expansion_root: LocalExpnId, force: bool ) -> Result<Lrc<SyntaxExtension>, Indeterminate>

source§

fn record_macro_rule_usage(&mut self, id: NodeId, rule_i: usize)

source§

fn check_unused_macros(&mut self)

source§

fn has_derive_copy(&self, expn_id: LocalExpnId) -> bool

Does #[derive(...)] attribute with the given ExpnId have built-in Copy inside it?
source§

fn resolve_derives( &mut self, expn_id: LocalExpnId, force: bool, derive_paths: &dyn Fn() -> DeriveResolutions ) -> Result<(), Indeterminate>

Resolve paths inside the #[derive(...)] attribute with the given ExpnId.
source§

fn take_derive_resolutions( &mut self, expn_id: LocalExpnId ) -> Option<DeriveResolutions>

Take resolutions for paths inside the #[derive(...)] attribute with the given ExpnId back from resolver.
source§

fn cfg_accessible( &mut self, expn_id: LocalExpnId, path: &Path ) -> Result<bool, Indeterminate>

Path resolution logic for #[cfg_accessible(path)].
source§

fn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span

Decodes the proc-macro quoted span in the specified crate, with the specified id. No caching is performed.
source§

fn declare_proc_macro(&mut self, id: NodeId)

The order of items in the HIR is unrelated to the order of items in the AST. However, we generate proc macro harnesses based on the AST order, and later refer to these harnesses from the HIR. This field keeps track of the order in which we generated proc macros harnesses, so that we can map HIR proc macros items back to their harness items.
source§

fn append_stripped_cfg_item( &mut self, parent_node: NodeId, name: Ident, cfg: MetaItem )

source§

fn registered_tools(&self) -> &RegisteredTools

Tools registered with #![register_tool] and used by tool attributes and lints.

Auto Trait Implementations§

§

impl<'a, 'tcx> !RefUnwindSafe for Resolver<'a, 'tcx>

§

impl<'a, 'tcx> !Send for Resolver<'a, 'tcx>

§

impl<'a, 'tcx> !Sync for Resolver<'a, 'tcx>

§

impl<'a, 'tcx> Unpin for Resolver<'a, 'tcx>

§

impl<'a, 'tcx> !UnwindSafe for Resolver<'a, 'tcx>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2384 bytes