Struct rustc_resolve::Resolver
source · pub struct Resolver<'a> {Show 79 fields
pub(crate) session: &'a Session,
pub(crate) definitions: Definitions,
pub(crate) expn_that_defined: FxHashMap<LocalDefId, ExpnId>,
pub(crate) source_span: IndexVec<LocalDefId, Span>,
pub(crate) graph_root: &'a ModuleData<'a>,
pub(crate) prelude: Option<&'a ModuleData<'a>>,
pub(crate) extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>,
pub(crate) has_self: FxHashSet<DefId>,
pub(crate) field_names: FxHashMap<DefId, Vec<Spanned<Symbol>>>,
pub(crate) determined_imports: Vec<&'a Import<'a>>,
pub(crate) indeterminate_imports: Vec<&'a Import<'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) reexport_map: FxHashMap<LocalDefId, Vec<ModChild>>,
pub(crate) trait_map: NodeMap<Vec<TraitCandidate>>,
pub(crate) block_map: NodeMap<&'a ModuleData<'a>>,
pub(crate) empty_module: &'a ModuleData<'a>,
pub(crate) module_map: FxHashMap<DefId, &'a ModuleData<'a>>,
pub(crate) binding_parent_modules: FxHashMap<Interned<'a, NameBinding<'a>>, &'a ModuleData<'a>>,
pub(crate) underscore_disambiguator: u32,
pub(crate) glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,
pub(crate) visibilities: FxHashMap<LocalDefId, Visibility>,
pub(crate) has_pub_restricted: bool,
pub(crate) used_imports: FxHashSet<NodeId>,
pub(crate) maybe_unused_trait_imports: FxIndexSet<LocalDefId>,
pub(crate) maybe_unused_extern_crates: Vec<(LocalDefId, Span)>,
pub(crate) privacy_errors: Vec<PrivacyError<'a>>,
pub(crate) ambiguity_errors: Vec<AmbiguityError<'a>>,
pub(crate) use_injections: Vec<UseError<'a>>,
pub(crate) macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>,
pub(crate) arenas: &'a ResolverArenas<'a>,
pub(crate) dummy_binding: &'a NameBinding<'a>,
pub(crate) crate_loader: CrateLoader<'a>,
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: RegisteredTools,
pub(crate) macro_use_prelude: FxHashMap<Symbol, &'a NameBinding<'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, &'a ModuleData<'a>>,
pub(crate) ast_transform_scopes: FxHashMap<LocalExpnId, &'a ModuleData<'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<&'a NameBinding<'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>>,
pub(crate) derive_data: FxHashMap<LocalExpnId, DeriveData>,
pub(crate) name_already_seen: FxHashMap<Symbol, Span>,
pub(crate) potentially_unused_imports: Vec<&'a Import<'a>>,
pub(crate) struct_constructors: DefIdMap<(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) access_levels: AccessLevels,
}
Expand description
The main resolver class.
This is the visitor that walks the whole crate.
Fields
session: &'a Session
definitions: Definitions
expn_that_defined: FxHashMap<LocalDefId, ExpnId>
Item with a given LocalDefId
was defined during macro expansion with ID ExpnId
.
source_span: IndexVec<LocalDefId, Span>
Reference span for definitions.
graph_root: &'a ModuleData<'a>
prelude: Option<&'a ModuleData<'a>>
extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'a>>
has_self: FxHashSet<DefId>
N.B., this is used only for better diagnostics, not name resolution itself.
field_names: FxHashMap<DefId, Vec<Spanned<Symbol>>>
Names of fields of an item DefId
accessible with dot syntax.
Used for hints during error reporting.
determined_imports: Vec<&'a Import<'a>>
All imports known to succeed or fail.
indeterminate_imports: Vec<&'a Import<'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.
reexport_map: FxHashMap<LocalDefId, Vec<ModChild>>
trait_map: NodeMap<Vec<TraitCandidate>>
block_map: NodeMap<&'a ModuleData<'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: &'a ModuleData<'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, &'a ModuleData<'a>>
binding_parent_modules: FxHashMap<Interned<'a, NameBinding<'a>>, &'a ModuleData<'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.
has_pub_restricted: bool
used_imports: FxHashSet<NodeId>
maybe_unused_trait_imports: FxIndexSet<LocalDefId>
maybe_unused_extern_crates: Vec<(LocalDefId, Span)>
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<'a>>
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: &'a NameBinding<'a>
crate_loader: CrateLoader<'a>
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: RegisteredTools
macro_use_prelude: FxHashMap<Symbol, &'a NameBinding<'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, &'a ModuleData<'a>>
ast_transform_scopes: FxHashMap<LocalExpnId, &'a ModuleData<'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<&'a NameBinding<'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>>
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<&'a Import<'a>>
struct_constructors: DefIdMap<(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>
access_levels: AccessLevels
Implementations
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
sourcepub(crate) fn define<T>(
&mut self,
parent: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
def: T
)where
T: ToNameBinding<'a>,
pub(crate) fn define<T>(
&mut self,
parent: &'a ModuleData<'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.
sourcepub fn get_nearest_non_block_module(
&mut self,
def_id: DefId
) -> &'a ModuleData<'a>
pub fn get_nearest_non_block_module(
&mut self,
def_id: DefId
) -> &'a ModuleData<'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).
pub fn expect_module(&mut self, def_id: DefId) -> &'a ModuleData<'a>
sourcepub(crate) fn get_module(&mut self, def_id: DefId) -> Option<&'a ModuleData<'a>>
pub(crate) fn get_module(&mut self, def_id: DefId) -> Option<&'a ModuleData<'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
.
pub(crate) fn expn_def_scope(&mut self, expn_id: ExpnId) -> &'a ModuleData<'a>
pub(crate) fn macro_def_scope(&mut self, def_id: DefId) -> &'a ModuleData<'a>
pub(crate) fn get_macro(&mut self, res: Res<NodeId>) -> Option<MacroData>
pub(crate) fn get_macro_by_def_id(&mut self, def_id: DefId) -> MacroData
pub(crate) fn build_reduced_graph(
&mut self,
fragment: &AstFragment,
parent_scope: ParentScope<'a>
) -> Interned<'a, Cell<MacroRulesScope<'a>>>
pub(crate) fn build_reduced_graph_external(&mut self, module: &'a ModuleData<'a>)
sourceimpl Resolver<'_>
impl Resolver<'_>
pub(crate) fn check_unused(&mut self, krate: &Crate)
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
pub(crate) fn report_errors(&mut self, krate: &Crate)
fn report_with_use_injections(&mut self, krate: &Crate)
pub(crate) fn report_conflict<'b>(
&mut self,
parent: &'_ ModuleData<'_>,
ident: Ident,
ns: Namespace,
new_binding: &NameBinding<'b>,
old_binding: &NameBinding<'b>
)
sourcefn add_suggestion_for_rename_of_use(
&self,
err: &mut Diagnostic,
name: Symbol,
import: &Import<'_>,
binding_span: Span
)
fn add_suggestion_for_rename_of_use(
&self,
err: &mut Diagnostic,
name: Symbol,
import: &Import<'_>,
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;
| ^^^^^^^^^^^^^^^^^^^^^
sourcefn add_suggestion_for_duplicate_nested_use(
&self,
err: &mut Diagnostic,
import: &Import<'_>,
binding_span: Span
)
fn add_suggestion_for_duplicate_nested_use(
&self,
err: &mut Diagnostic,
import: &Import<'_>,
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.
pub(crate) fn lint_if_path_starts_with_module(
&mut self,
finalize: Option<Finalize>,
path: &[Segment],
second_binding: Option<&NameBinding<'_>>
)
pub(crate) fn add_module_candidates(
&mut self,
module: &'a ModuleData<'a>,
names: &mut Vec<TypoSuggestion>,
filter_fn: &impl Fn(Res<NodeId>) -> bool
)
sourcepub(crate) fn report_error(
&mut self,
span: Span,
resolution_error: ResolutionError<'a>
)
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.
pub(crate) fn into_struct_error(
&mut self,
span: Span,
resolution_error: ResolutionError<'a>
) -> DiagnosticBuilder<'_, ErrorGuaranteed>
pub(crate) fn report_vis_error(
&mut self,
vis_resolution_error: VisResolutionError<'_>
) -> ErrorGuaranteed
sourcefn 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>
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.
fn lookup_import_candidates_from_module<FilterFn>(
&mut self,
lookup_ident: Ident,
namespace: Namespace,
parent_scope: &ParentScope<'a>,
start_module: &'a ModuleData<'a>,
crate_name: Ident,
filter_fn: FilterFn
) -> Vec<ImportSuggestion>where
FilterFn: Fn(Res<NodeId>) -> bool,
sourcepub(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,
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).
pub(crate) fn unresolved_macro_suggestions(
&mut self,
err: &mut Diagnostic,
macro_kind: MacroKind,
parent_scope: &ParentScope<'a>,
ident: Ident
)
pub(crate) fn add_typo_suggestion(
&self,
err: &mut Diagnostic,
suggestion: Option<TypoSuggestion>,
span: Span
) -> bool
fn binding_description(
&self,
b: &NameBinding<'_>,
ident: Ident,
from_prelude: bool
) -> String
fn report_ambiguity_error(&self, ambiguity_error: &AmbiguityError<'_>)
sourcefn ctor_fields_span(&self, binding: &NameBinding<'_>) -> Option<Span>
fn ctor_fields_span(&self, binding: &NameBinding<'_>) -> Option<Span>
If the binding refers to a tuple struct constructor with fields, returns the span of its fields.
fn report_privacy_error(&self, privacy_error: &PrivacyError<'_>)
pub(crate) fn find_similarly_named_module_or_crate(
&mut self,
ident: Symbol,
current_module: &&'a ModuleData<'a>
) -> Option<Symbol>
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<&'a NameBinding<'a>>,
module: Option<ModuleOrUniformRoot<'a>>,
i: usize,
ident: Ident
) -> (String, Option<(Vec<(Span, String)>, String, Applicability)>)
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
sourcepub(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>
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.
fn hygienic_lexical_parent(
&mut self,
module: &'a ModuleData<'a>,
ctxt: &mut SyntaxContext,
derive_fallback_lint_id: Option<NodeId>
) -> Option<(&'a ModuleData<'a>, Option<NodeId>)>
sourcepub(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<&'a NameBinding<'a>>
) -> Option<LexicalScopeBinding<'a>>
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<&'a NameBinding<'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.
sourcepub(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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, Determinacy>
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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'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.
pub(crate) fn maybe_resolve_ident_in_module(
&mut self,
module: ModuleOrUniformRoot<'a>,
ident: Ident,
ns: Namespace,
parent_scope: &ParentScope<'a>
) -> Result<&'a NameBinding<'a>, Determinacy>
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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, Determinacy>
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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, (Determinacy, Weak)>
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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, Determinacy>
sourcefn 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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, (Determinacy, Weak)>
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<&'a NameBinding<'a>>
) -> Result<&'a NameBinding<'a>, (Determinacy, Weak)>
Attempts to resolve ident
in namespaces ns
of module
.
Invariant: if finalize
is Some
, expansion and import resolution must be complete.
sourcefn 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>
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).
pub(crate) fn maybe_resolve_path(
&mut self,
path: &[Segment],
opt_ns: Option<Namespace>,
parent_scope: &ParentScope<'a>
) -> PathResult<'a>
pub(crate) fn resolve_path(
&mut self,
path: &[Segment],
opt_ns: Option<Namespace>,
parent_scope: &ParentScope<'a>,
finalize: Option<Finalize>,
ignore_binding: Option<&'a NameBinding<'a>>
) -> PathResult<'a>
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<&'a NameBinding<'a>>
) -> PathResult<'a>
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
pub(crate) fn import(
&self,
binding: &'a NameBinding<'a>,
import: &'a Import<'a>
) -> &'a NameBinding<'a>
pub(crate) fn try_define(
&mut self,
module: &'a ModuleData<'a>,
key: BindingKey,
binding: &'a NameBinding<'a>
) -> Result<(), &'a NameBinding<'a>>
fn ambiguity(
&self,
kind: AmbiguityKind,
primary_binding: &'a NameBinding<'a>,
secondary_binding: &'a NameBinding<'a>
) -> &'a NameBinding<'a>
fn update_resolution<T, F>(
&mut self,
module: &'a ModuleData<'a>,
key: BindingKey,
f: F
) -> Twhere
F: FnOnce(&mut Resolver<'a>, &mut NameResolution<'a>) -> T,
fn import_dummy_binding(&mut self, import: &'a Import<'a>)
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
pub(crate) fn late_resolve_crate(&mut self, krate: &Crate)
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
sourcefn 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>
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.
pub 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>
pub(crate) fn finalize_macro_resolutions(&mut self)
fn check_stability_and_deprecation(
&mut self,
ext: &SyntaxExtension,
path: &Path,
node_id: NodeId
)
fn prohibit_imported_non_macro_attrs(
&self,
binding: Option<&'a NameBinding<'a>>,
res: Option<Res<NodeId>>,
span: Span
)
pub(crate) fn check_reserved_macro_name(&mut self, ident: Ident, res: Res<NodeId>)
sourcepub(crate) fn compile_macro(
&mut self,
item: &Item,
edition: Edition
) -> (SyntaxExtension, Vec<(usize, Span)>)
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.
sourceimpl Resolver<'_>
impl Resolver<'_>
pub(crate) fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>
pub fn local_def_id(&self, node: NodeId) -> LocalDefId
sourcepub(crate) fn create_def(
&mut self,
parent: LocalDefId,
node_id: NodeId,
data: DefPathData,
expn_id: ExpnId,
span: Span
) -> LocalDefId
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.
pub(crate) fn item_generics_num_lifetimes(&self, def_id: DefId) -> usize
sourceimpl<'a> Resolver<'a>
impl<'a> Resolver<'a>
pub fn new(
session: &'a Session,
krate: &Crate,
crate_name: &str,
metadata_loader: Box<MetadataLoaderDyn>,
arenas: &'a ResolverArenas<'a>
) -> Resolver<'a>
pub(crate) fn new_module(
&mut self,
parent: Option<&'a ModuleData<'a>>,
kind: ModuleKind,
expn_id: ExpnId,
span: Span,
no_implicit_prelude: bool
) -> &'a ModuleData<'a>
pub fn next_node_id(&mut self) -> NodeId
pub fn next_node_ids(&mut self, count: usize) -> Range<NodeId>
pub fn lint_buffer(&mut self) -> &mut LintBuffer
pub fn arenas() -> ResolverArenas<'a>
pub fn into_outputs(
self
) -> (Definitions, Box<CrateStoreDyn>, ResolverOutputs, ResolverAstLowering)
pub fn clone_outputs(
&self
) -> (Definitions, Box<CrateStoreDyn>, ResolverOutputs, ResolverAstLowering)
pub(crate) fn create_stable_hashing_context(&self) -> StableHashingContext<'_>
pub fn cstore(&self) -> &CStore
pub(crate) fn dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension>
sourcepub(crate) fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, f: F)
pub(crate) fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, f: F)
Runs the function on each namespace.
pub(crate) fn is_builtin_macro(&mut self, res: Res<NodeId>) -> bool
pub(crate) fn macro_def(&self, ctxt: SyntaxContext) -> DefId
sourcepub fn resolve_crate(&mut self, krate: &Crate)
pub fn resolve_crate(&mut self, krate: &Crate)
Entry point to crate resolution.
pub fn traits_in_scope(
&mut self,
current_trait: Option<&'a ModuleData<'a>>,
parent_scope: &ParentScope<'a>,
ctxt: SyntaxContext,
assoc_item: Option<(Symbol, Namespace)>
) -> Vec<TraitCandidate>
pub(crate) fn traits_in_module(
&mut self,
module: &'a ModuleData<'a>,
assoc_item: Option<(Symbol, Namespace)>,
found_traits: &mut Vec<TraitCandidate>
)
pub(crate) fn trait_may_have_item(
&mut self,
trait_module: Option<&'a ModuleData<'a>>,
assoc_item: Option<(Symbol, Namespace)>
) -> bool
pub(crate) fn find_transitive_imports(
&mut self,
kind: &NameBindingKind<'_>,
trait_name: Ident
) -> SmallVec<[LocalDefId; 1]>
pub(crate) fn new_key(&mut self, ident: Ident, ns: Namespace) -> BindingKey
pub(crate) fn resolutions(
&mut self,
module: &'a ModuleData<'a>
) -> &'a RefCell<FxIndexMap<BindingKey, &'a RefCell<NameResolution<'a>>>>
pub(crate) fn resolution(
&mut self,
module: &'a ModuleData<'a>,
key: BindingKey
) -> &'a RefCell<NameResolution<'a>>
pub(crate) fn record_use(
&mut self,
ident: Ident,
used_binding: &'a NameBinding<'a>,
is_lexical_scope: bool
)
pub(crate) fn add_to_glob_map(&mut self, import: &Import<'_>, ident: Ident)
pub(crate) fn resolve_crate_root(&mut self, ident: Ident) -> &'a ModuleData<'a>
pub(crate) fn resolve_self(
&mut self,
ctxt: &mut SyntaxContext,
module: &'a ModuleData<'a>
) -> &'a ModuleData<'a>
pub(crate) fn record_partial_res(
&mut self,
node_id: NodeId,
resolution: PartialRes
)
pub(crate) fn record_pat_span(&mut self, node: NodeId, span: Span)
pub(crate) fn is_accessible_from(
&self,
vis: Visibility<impl Into<DefId>>,
module: &'a ModuleData<'a>
) -> bool
pub(crate) fn set_binding_parent_module(
&mut self,
binding: &'a NameBinding<'a>,
module: &'a ModuleData<'a>
)
pub(crate) fn disambiguate_macro_rules_vs_modularized(
&self,
macro_rules: &'a NameBinding<'a>,
modularized: &'a NameBinding<'a>
) -> bool
pub(crate) fn extern_prelude_get(
&mut self,
ident: Ident,
finalize: bool
) -> Option<&'a NameBinding<'a>>
sourcepub fn resolve_rustdoc_path(
&mut self,
path_str: &str,
ns: Namespace,
parent_scope: ParentScope<'a>
) -> Option<Res<NodeId>>
pub 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.
sourcepub fn module_children_or_reexports(&self, def_id: DefId) -> Vec<ModChild>
pub fn module_children_or_reexports(&self, def_id: DefId) -> Vec<ModChild>
For rustdoc. For local modules returns only reexports, for external modules returns all children.
sourcepub fn macro_rules_scope(
&self,
def_id: LocalDefId
) -> (Interned<'a, Cell<MacroRulesScope<'a>>>, Res<NodeId>)
pub fn macro_rules_scope(
&self,
def_id: LocalDefId
) -> (Interned<'a, Cell<MacroRulesScope<'a>>>, Res<NodeId>)
For rustdoc.
sourcepub fn opt_span(&self, def_id: DefId) -> Option<Span>
pub fn opt_span(&self, def_id: DefId) -> Option<Span>
Retrieves the span of the given DefId
if DefId
is in the local crate.
sourcepub fn legacy_const_generic_args(&mut self, expr: &Expr) -> Option<Vec<usize>>
pub 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.
pub(crate) fn resolve_main(&mut self)
pub(crate) fn is_reexport(&self, binding: &NameBinding<'a>) -> Option<Res<!>>
Trait Implementations
sourceimpl<'a> AsMut<Resolver<'a>> for BuildReducedGraphVisitor<'a, '_>
impl<'a> AsMut<Resolver<'a>> for BuildReducedGraphVisitor<'a, '_>
sourceimpl<'a, 'b> DefIdTree for &'a Resolver<'b>
impl<'a, 'b> DefIdTree for &'a Resolver<'b>
fn opt_parent(self, id: DefId) -> Option<DefId>
fn parent(self, id: DefId) -> DefId
fn opt_local_parent(self, id: LocalDefId) -> Option<LocalDefId>
fn local_parent(self, id: LocalDefId) -> LocalDefId
fn is_descendant_of(self, descendant: DefId, ancestor: DefId) -> bool
sourceimpl<'a> ResolverExpand for Resolver<'a>
impl<'a> ResolverExpand for Resolver<'a>
fn next_node_id(&mut self) -> NodeId
fn invocation_parent(&self, id: LocalExpnId) -> LocalDefId
fn resolve_dollar_crates(&mut self)
fn visit_ast_fragment_with_placeholders(
&mut self,
expansion: LocalExpnId,
fragment: &AstFragment
)
fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind)
fn expansion_for_ast_pass(
&mut self,
call_site: Span,
pass: AstPass,
features: &[Symbol],
parent_module_id: Option<NodeId>
) -> LocalExpnId
fn resolve_imports(&mut self)
fn resolve_macro_invocation(
&mut self,
invoc: &Invocation,
eager_expansion_root: LocalExpnId,
force: bool
) -> Result<Lrc<SyntaxExtension>, Indeterminate>
fn record_macro_rule_usage(&mut self, id: NodeId, rule_i: usize)
fn check_unused_macros(&mut self)
sourcefn has_derive_copy(&self, expn_id: LocalExpnId) -> bool
fn has_derive_copy(&self, expn_id: LocalExpnId) -> bool
#[derive(...)]
attribute with the given ExpnId
have built-in Copy
inside it?sourcefn resolve_derives(
&mut self,
expn_id: LocalExpnId,
force: bool,
derive_paths: &dyn Fn() -> DeriveResolutions
) -> Result<(), Indeterminate>
fn resolve_derives(
&mut self,
expn_id: LocalExpnId,
force: bool,
derive_paths: &dyn Fn() -> DeriveResolutions
) -> Result<(), Indeterminate>
#[derive(...)]
attribute with the given ExpnId
.sourcefn take_derive_resolutions(
&mut self,
expn_id: LocalExpnId
) -> Option<DeriveResolutions>
fn take_derive_resolutions(
&mut self,
expn_id: LocalExpnId
) -> Option<DeriveResolutions>
#[derive(...)]
attribute with the given ExpnId
back from resolver. Read moresourcefn cfg_accessible(
&mut self,
expn_id: LocalExpnId,
path: &Path
) -> Result<bool, Indeterminate>
fn cfg_accessible(
&mut self,
expn_id: LocalExpnId,
path: &Path
) -> Result<bool, Indeterminate>
#[cfg_accessible(path)]
.sourcefn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span
fn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span
sourcefn declare_proc_macro(&mut self, id: NodeId)
fn declare_proc_macro(&mut self, id: NodeId)
sourcefn registered_tools(&self) -> &RegisteredTools
fn registered_tools(&self) -> &RegisteredTools
#![register_tool]
and used by tool attributes and lints.Auto Trait Implementations
impl<'a> !RefUnwindSafe for Resolver<'a>
impl<'a> !Send for Resolver<'a>
impl<'a> !Sync for Resolver<'a>
impl<'a> Unpin for Resolver<'a>
impl<'a> !UnwindSafe for Resolver<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
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: 2360 bytes