Struct rustc_resolve::resolve_imports::ImportResolver [−][src]
pub struct ImportResolver<'a, 'b: 'a> { pub resolver: &'a mut Resolver<'b>, }
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Fields
resolver: &'a mut Resolver<'b>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Methods
impl<'a, 'b: 'a> ImportResolver<'a, 'b>
[src]
impl<'a, 'b: 'a> ImportResolver<'a, 'b>
pub fn resolve_imports(&mut self)
[src]
pub fn resolve_imports(&mut self)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Resolves all imports for the crate. This method performs the fixed- point iteration.
pub fn finalize_imports(&mut self)
[src]
pub fn finalize_imports(&mut self)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> bool
[src]
fn resolve_import(&mut self, directive: &'b ImportDirective<'b>) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Attempts to resolve the given import, returning true if its resolution is determined. If successful, the resolved bindings are written into the module.
fn finalize_import(
&mut self,
directive: &'b ImportDirective<'b>
) -> Option<(Span, String)>
[src]
fn finalize_import(
&mut self,
directive: &'b ImportDirective<'b>
) -> Option<(Span, String)>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_glob_import(&mut self, directive: &'b ImportDirective<'b>)
[src]
fn resolve_glob_import(&mut self, directive: &'b ImportDirective<'b>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn finalize_resolutions_in(&mut self, module: &'b ModuleData<'b>)
[src]
fn finalize_resolutions_in(&mut self, module: &'b ModuleData<'b>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Methods from Deref<Target = Resolver<'b>>
fn report_proc_macro_stub(&self, span: Span)
[src]
fn report_proc_macro_stub(&self, span: Span)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_invoc_to_def(
&mut self,
invoc: &mut Invocation,
scope: Mark,
force: bool
) -> Result<Def, Determinacy>
[src]
fn resolve_invoc_to_def(
&mut self,
invoc: &mut Invocation,
scope: Mark,
force: bool
) -> Result<Def, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_macro_to_def(
&mut self,
scope: Mark,
path: &Path,
kind: MacroKind,
force: bool
) -> Result<Def, Determinacy>
[src]
fn resolve_macro_to_def(
&mut self,
scope: Mark,
path: &Path,
kind: MacroKind,
force: bool
) -> Result<Def, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_macro_to_def_inner(
&mut self,
scope: Mark,
path: &Path,
kind: MacroKind,
force: bool
) -> Result<Def, Determinacy>
[src]
pub fn resolve_macro_to_def_inner(
&mut self,
scope: Mark,
path: &Path,
kind: MacroKind,
force: bool
) -> Result<Def, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_lexical_macro_path_segment(
&mut self,
ident: Ident,
ns: Namespace,
record_used: bool,
path_span: Span
) -> Result<MacroBinding<'a>, Determinacy>
[src]
pub fn resolve_lexical_macro_path_segment(
&mut self,
ident: Ident,
ns: Namespace,
record_used: bool,
path_span: Span
) -> Result<MacroBinding<'a>, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_legacy_scope(
&mut self,
scope: &'a Cell<LegacyScope<'a>>,
ident: Ident,
record_used: bool
) -> Option<MacroBinding<'a>>
[src]
pub fn resolve_legacy_scope(
&mut self,
scope: &'a Cell<LegacyScope<'a>>,
ident: Ident,
record_used: bool
) -> Option<MacroBinding<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn finalize_current_module_macro_resolutions(&mut self)
[src]
pub fn finalize_current_module_macro_resolutions(&mut self)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn suggest_macro_name(
&mut self,
name: &str,
kind: MacroKind,
err: &mut DiagnosticBuilder<'a>,
span: Span
)
[src]
fn suggest_macro_name(
&mut self,
name: &str,
kind: MacroKind,
err: &mut DiagnosticBuilder<'a>,
span: Span
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn collect_def_ids(
&mut self,
mark: Mark,
invocation: &'a InvocationData<'a>,
fragment: &AstFragment
)
[src]
fn collect_def_ids(
&mut self,
mark: Mark,
invocation: &'a InvocationData<'a>,
fragment: &AstFragment
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn define_macro(
&mut self,
item: &Item,
expansion: Mark,
legacy_scope: &mut LegacyScope<'a>
)
[src]
pub fn define_macro(
&mut self,
item: &Item,
expansion: Mark,
legacy_scope: &mut LegacyScope<'a>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn err_if_macro_use_proc_macro(
&mut self,
name: Name,
use_span: Span,
binding: &NameBinding<'a>
)
[src]
fn err_if_macro_use_proc_macro(
&mut self,
name: Name,
use_span: Span,
binding: &NameBinding<'a>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Error if ext
is a Macros 1.1 procedural macro being imported by #[macro_use]
pub fn report_proc_macro_import(&mut self, krate: &Crate)
[src]
pub fn report_proc_macro_import(&mut self, krate: &Crate)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn gate_legacy_custom_derive(&mut self, name: Symbol, span: Span)
[src]
fn gate_legacy_custom_derive(&mut self, name: Symbol, span: Span)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn define<T>(
&mut self,
parent: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
def: T
) where
T: ToNameBinding<'a>,
[src]
pub fn define<T>(
&mut self,
parent: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
def: T
) where
T: ToNameBinding<'a>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Defines name
in namespace ns
of module parent
to be def
if it is not yet defined;
otherwise, reports an error.
fn block_needs_anonymous_module(&mut self, block: &Block) -> bool
[src]
fn block_needs_anonymous_module(&mut self, block: &Block) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn insert_field_names(&mut self, def_id: DefId, field_names: Vec<Name>)
[src]
fn insert_field_names(&mut self, def_id: DefId, field_names: Vec<Name>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn build_reduced_graph_for_use_tree(
&mut self,
root_use_tree: &UseTree,
root_id: NodeId,
use_tree: &UseTree,
id: NodeId,
vis: Visibility,
prefix: &Path,
nested: bool,
item: &Item,
expansion: Mark
)
[src]
fn build_reduced_graph_for_use_tree(
&mut self,
root_use_tree: &UseTree,
root_id: NodeId,
use_tree: &UseTree,
id: NodeId,
vis: Visibility,
prefix: &Path,
nested: bool,
item: &Item,
expansion: Mark
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn build_reduced_graph_for_item(&mut self, item: &Item, expansion: Mark)
[src]
fn build_reduced_graph_for_item(&mut self, item: &Item, expansion: Mark)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Constructs the reduced graph for one item.
fn build_reduced_graph_for_variant(
&mut self,
variant: &Variant,
parent: &'a ModuleData<'a>,
vis: Visibility,
expansion: Mark
)
[src]
fn build_reduced_graph_for_variant(
&mut self,
variant: &Variant,
parent: &'a ModuleData<'a>,
vis: Visibility,
expansion: Mark
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn build_reduced_graph_for_foreign_item(
&mut self,
item: &ForeignItem,
expansion: Mark
)
[src]
fn build_reduced_graph_for_foreign_item(
&mut self,
item: &ForeignItem,
expansion: Mark
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Constructs the reduced graph for one foreign item.
fn build_reduced_graph_for_block(&mut self, block: &Block, expansion: Mark)
[src]
fn build_reduced_graph_for_block(&mut self, block: &Block, expansion: Mark)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn build_reduced_graph_for_external_crate_def(
&mut self,
parent: &'a ModuleData<'a>,
child: Export
)
[src]
fn build_reduced_graph_for_external_crate_def(
&mut self,
parent: &'a ModuleData<'a>,
child: Export
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Builds the reduced graph for a single item in an external crate.
pub fn get_module(&mut self, def_id: DefId) -> &'a ModuleData<'a>
[src]
pub fn get_module(&mut self, def_id: DefId) -> &'a ModuleData<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn macro_def_scope(&mut self, expansion: Mark) -> &'a ModuleData<'a>
[src]
pub fn macro_def_scope(&mut self, expansion: Mark) -> &'a ModuleData<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn get_macro(&mut self, def: Def) -> Lrc<SyntaxExtension>
[src]
pub fn get_macro(&mut self, def: Def) -> Lrc<SyntaxExtension>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn populate_module_if_necessary(&mut self, module: &'a ModuleData<'a>)
[src]
pub fn populate_module_if_necessary(&mut self, module: &'a ModuleData<'a>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Ensures that the reduced graph rooted at the given external module is built, building it if it is not.
fn legacy_import_macro(
&mut self,
name: Name,
binding: &'a NameBinding<'a>,
span: Span,
allow_shadowing: bool
)
[src]
fn legacy_import_macro(
&mut self,
name: Name,
binding: &'a NameBinding<'a>,
span: Span,
allow_shadowing: bool
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn process_legacy_macro_imports(
&mut self,
item: &Item,
module: &'a ModuleData<'a>,
expansion: Mark
) -> bool
[src]
fn process_legacy_macro_imports(
&mut self,
item: &Item,
module: &'a ModuleData<'a>,
expansion: Mark
) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn contains_macro_use(&mut self, attrs: &[Attribute]) -> bool
[src]
fn contains_macro_use(&mut self, attrs: &[Attribute]) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn legacy_macro_imports(&mut self, attrs: &[Attribute]) -> LegacyMacroImports
[src]
fn legacy_macro_imports(&mut self, attrs: &[Attribute]) -> LegacyMacroImports
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolution(
&self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace
) -> &'a RefCell<NameResolution<'a>>
[src]
fn resolution(
&self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace
) -> &'a RefCell<NameResolution<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_ident_in_module_unadjusted(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
restricted_shadowing: bool,
record_used: bool,
path_span: Span
) -> Result<&'a NameBinding<'a>, Determinacy>
[src]
pub fn resolve_ident_in_module_unadjusted(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
restricted_shadowing: bool,
record_used: bool,
path_span: Span
) -> Result<&'a NameBinding<'a>, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Attempts to resolve ident
in namespaces ns
of module
.
Invariant: if record_used
is Some
, expansion and import resolution must be complete.
pub fn add_import_directive(
&mut self,
module_path: Vec<Ident>,
subclass: ImportDirectiveSubclass<'a>,
span: Span,
id: NodeId,
root_span: Span,
root_id: NodeId,
vis: Visibility,
expansion: Mark
)
[src]
pub fn add_import_directive(
&mut self,
module_path: Vec<Ident>,
subclass: ImportDirectiveSubclass<'a>,
span: Span,
id: NodeId,
root_span: Span,
root_id: NodeId,
vis: Visibility,
expansion: Mark
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn import(
&self,
binding: &'a NameBinding<'a>,
directive: &'a ImportDirective<'a>
) -> &'a NameBinding<'a>
[src]
pub fn import(
&self,
binding: &'a NameBinding<'a>,
directive: &'a ImportDirective<'a>
) -> &'a NameBinding<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn try_define(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
binding: &'a NameBinding<'a>
) -> Result<(), &'a NameBinding<'a>>
[src]
pub fn try_define(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
binding: &'a NameBinding<'a>
) -> Result<(), &'a NameBinding<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn ambiguity(
&self,
b1: &'a NameBinding<'a>,
b2: &'a NameBinding<'a>
) -> &'a NameBinding<'a>
[src]
pub fn ambiguity(
&self,
b1: &'a NameBinding<'a>,
b2: &'a NameBinding<'a>
) -> &'a NameBinding<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn update_resolution<T, F>(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
f: F
) -> T where
F: FnOnce(&mut Resolver<'a>, &mut NameResolution<'a>) -> T,
[src]
fn update_resolution<T, F>(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
f: F
) -> T where
F: FnOnce(&mut Resolver<'a>, &mut NameResolution<'a>) -> T,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn import_dummy_binding(&mut self, directive: &'a ImportDirective<'a>)
[src]
fn import_dummy_binding(&mut self, directive: &'a ImportDirective<'a>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_str_path_error(
&mut self,
span: Span,
path_str: &str,
is_value: bool
) -> Result<Path, ()>
[src]
pub fn resolve_str_path_error(
&mut self,
span: Span,
path_str: &str,
is_value: bool
) -> Result<Path, ()>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Rustdoc uses this to resolve things in a recoverable way. ResolutionError<'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.
fn resolve_hir_path_cb<F>(
&mut self,
path: &mut Path,
is_value: bool,
error_callback: F
) where
F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>),
[src]
fn resolve_hir_path_cb<F>(
&mut self,
path: &mut Path,
is_value: bool,
error_callback: F
) where
F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
resolve_hir_path, but takes a callback in case there was an error
fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, f: F)
[src]
fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, f: F)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Runs the function on each namespace.
fn macro_def(&self, ctxt: SyntaxContext) -> DefId
[src]
fn macro_def(&self, ctxt: SyntaxContext) -> DefId
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn resolve_crate(&mut self, krate: &Crate)
[src]
pub fn resolve_crate(&mut self, krate: &Crate)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Entry point to crate resolution.
fn new_module(
&self,
parent: &'a ModuleData<'a>,
kind: ModuleKind,
normal_ancestor_id: DefId,
expansion: Mark,
span: Span
) -> &'a ModuleData<'a>
[src]
fn new_module(
&self,
parent: &'a ModuleData<'a>,
kind: ModuleKind,
normal_ancestor_id: DefId,
expansion: Mark,
span: Span
) -> &'a ModuleData<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn record_use(
&mut self,
ident: Ident,
ns: Namespace,
binding: &'a NameBinding<'a>,
span: Span
) -> bool
[src]
fn record_use(
&mut self,
ident: Ident,
ns: Namespace,
binding: &'a NameBinding<'a>,
span: Span
) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn add_to_glob_map(&mut self, id: NodeId, ident: Ident)
[src]
fn add_to_glob_map(&mut self, id: NodeId, ident: Ident)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_ident_in_lexical_scope(
&mut self,
ident: Ident,
ns: Namespace,
record_used_id: Option<NodeId>,
path_span: Span
) -> Option<LexicalScopeBinding<'a>>
[src]
fn resolve_ident_in_lexical_scope(
&mut self,
ident: Ident,
ns: Namespace,
record_used_id: Option<NodeId>,
path_span: Span
) -> Option<LexicalScopeBinding<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
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.
fn hygienic_lexical_parent(
&mut self,
module: &'a ModuleData<'a>,
span: &mut Span
) -> Option<&'a ModuleData<'a>>
[src]
fn hygienic_lexical_parent(
&mut self,
module: &'a ModuleData<'a>,
span: &mut Span
) -> Option<&'a ModuleData<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn hygienic_lexical_parent_with_compatibility_fallback(
&mut self,
module: &'a ModuleData<'a>,
span: &mut Span,
node_id: NodeId,
poisoned: &mut Option<NodeId>
) -> Option<&'a ModuleData<'a>>
[src]
fn hygienic_lexical_parent_with_compatibility_fallback(
&mut self,
module: &'a ModuleData<'a>,
span: &mut Span,
node_id: NodeId,
poisoned: &mut Option<NodeId>
) -> Option<&'a ModuleData<'a>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_ident_in_module(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
record_used: bool,
span: Span
) -> Result<&'a NameBinding<'a>, Determinacy>
[src]
fn resolve_ident_in_module(
&mut self,
module: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
record_used: bool,
span: Span
) -> Result<&'a NameBinding<'a>, Determinacy>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_crate_root(&mut self, ident: Ident) -> &'a ModuleData<'a>
[src]
fn resolve_crate_root(&mut self, ident: Ident) -> &'a ModuleData<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_self(
&mut self,
ctxt: &mut SyntaxContext,
module: &'a ModuleData<'a>
) -> &'a ModuleData<'a>
[src]
fn resolve_self(
&mut self,
ctxt: &mut SyntaxContext,
module: &'a ModuleData<'a>
) -> &'a ModuleData<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn with_scope<F, T>(&mut self, id: NodeId, f: F) -> T where
F: FnOnce(&mut Resolver) -> T,
[src]
pub fn with_scope<F, T>(&mut self, id: NodeId, f: F) -> T where
F: FnOnce(&mut Resolver) -> T,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn search_label<P, R>(&self, ident: Ident, pred: P) -> Option<R> where
P: Fn(&Rib, Ident) -> Option<R>,
[src]
fn search_label<P, R>(&self, ident: Ident, pred: P) -> Option<R> where
P: Fn(&Rib, Ident) -> Option<R>,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Searches the current set of local scopes for labels. Returns the first non-None label that is returned by the given predicate function
Stops after meeting a closure.
fn resolve_item(&mut self, item: &Item)
[src]
fn resolve_item(&mut self, item: &Item)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_use_tree(
&mut self,
root_id: NodeId,
root_span: Span,
id: NodeId,
use_tree: &UseTree,
prefix: &Path
)
[src]
fn resolve_use_tree(
&mut self,
root_id: NodeId,
root_span: Span,
id: NodeId,
use_tree: &UseTree,
prefix: &Path
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
For the most part, use trees are desugared into ImportDirective
instances
when building the reduced graph (see build_reduced_graph_for_use_tree
). But
there is one special case we handle here: an empty nested import like
a::{b::{}}
, which desugares into...no import directives.
fn with_type_parameter_rib<'b, F>(
&'b mut self,
type_parameters: TypeParameters<'a, 'b>,
f: F
) where
F: FnOnce(&mut Resolver),
[src]
fn with_type_parameter_rib<'b, F>(
&'b mut self,
type_parameters: TypeParameters<'a, 'b>,
f: F
) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_label_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
[src]
fn with_label_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_item_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
[src]
fn with_item_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_constant_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
[src]
fn with_constant_rib<F>(&mut self, f: F) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_current_self_type<T, F>(&mut self, self_type: &Ty, f: F) -> T where
F: FnOnce(&mut Resolver) -> T,
[src]
fn with_current_self_type<T, F>(&mut self, self_type: &Ty, f: F) -> T where
F: FnOnce(&mut Resolver) -> T,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_optional_trait_ref<T, F>(
&mut self,
opt_trait_ref: Option<&TraitRef>,
f: F
) -> T where
F: FnOnce(&mut Resolver, Option<DefId>) -> T,
[src]
fn with_optional_trait_ref<T, F>(
&mut self,
opt_trait_ref: Option<&TraitRef>,
f: F
) -> T where
F: FnOnce(&mut Resolver, Option<DefId>) -> T,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
This is called to resolve a trait reference from an impl
(i.e. impl Trait for Foo
)
fn with_self_rib<F>(&mut self, self_def: Def, f: F) where
F: FnOnce(&mut Resolver),
[src]
fn with_self_rib<F>(&mut self, self_def: Def, f: F) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_implementation(
&mut self,
generics: &Generics,
opt_trait_reference: &Option<TraitRef>,
self_type: &Ty,
item_id: NodeId,
impl_items: &[ImplItem]
)
[src]
fn resolve_implementation(
&mut self,
generics: &Generics,
opt_trait_reference: &Option<TraitRef>,
self_type: &Ty,
item_id: NodeId,
impl_items: &[ImplItem]
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn check_trait_item<F>(
&mut self,
ident: Ident,
ns: Namespace,
span: Span,
err: F
) where
F: FnOnce(Name, &str) -> ResolutionError,
[src]
fn check_trait_item<F>(
&mut self,
ident: Ident,
ns: Namespace,
span: Span,
err: F
) where
F: FnOnce(Name, &str) -> ResolutionError,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_local(&mut self, local: &Local)
[src]
fn resolve_local(&mut self, local: &Local)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn binding_mode_map(&mut self, pat: &Pat) -> FxHashMap<Ident, BindingInfo>
[src]
fn binding_mode_map(&mut self, pat: &Pat) -> FxHashMap<Ident, BindingInfo>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn check_consistent_bindings(&mut self, pats: &[P<Pat>])
[src]
fn check_consistent_bindings(&mut self, pats: &[P<Pat>])
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_arm(&mut self, arm: &Arm)
[src]
fn resolve_arm(&mut self, arm: &Arm)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_block(&mut self, block: &Block)
[src]
fn resolve_block(&mut self, block: &Block)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn fresh_binding(
&mut self,
ident: Ident,
pat_id: NodeId,
outer_pat_id: NodeId,
pat_src: PatternSource,
bindings: &mut FxHashMap<Ident, NodeId>
) -> PathResolution
[src]
fn fresh_binding(
&mut self,
ident: Ident,
pat_id: NodeId,
outer_pat_id: NodeId,
pat_src: PatternSource,
bindings: &mut FxHashMap<Ident, NodeId>
) -> PathResolution
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_pattern(
&mut self,
pat: &Pat,
pat_src: PatternSource,
bindings: &mut FxHashMap<Ident, NodeId>
)
[src]
fn resolve_pattern(
&mut self,
pat: &Pat,
pat_src: PatternSource,
bindings: &mut FxHashMap<Ident, NodeId>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn smart_resolve_path(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &Path,
source: PathSource
) -> PathResolution
[src]
fn smart_resolve_path(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &Path,
source: PathSource
) -> PathResolution
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn smart_resolve_path_with_crate_lint(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &Path,
source: PathSource,
crate_lint: CrateLint
) -> PathResolution
[src]
fn smart_resolve_path_with_crate_lint(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &Path,
source: PathSource,
crate_lint: CrateLint
) -> PathResolution
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
A variant of smart_resolve_path
where you also specify extra
information about where the path came from; this extra info is
sometimes needed for the lint that recommends rewriting
absolute paths to crate
, so that it knows how to frame the
suggestion. If you are just resolving a path like foo::bar
that appears...somewhere, though, then you just want
CrateLint::SimplePath
, which is what smart_resolve_path
already provides.
fn smart_resolve_path_fragment(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
span: Span,
source: PathSource,
crate_lint: CrateLint
) -> PathResolution
[src]
fn smart_resolve_path_fragment(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
span: Span,
source: PathSource,
crate_lint: CrateLint
) -> PathResolution
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn type_ascription_suggestion(
&self,
err: &mut DiagnosticBuilder,
base_span: Span
)
[src]
fn type_ascription_suggestion(
&self,
err: &mut DiagnosticBuilder,
base_span: Span
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn self_type_is_available(&mut self, span: Span) -> bool
[src]
fn self_type_is_available(&mut self, span: Span) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn self_value_is_available(&mut self, self_span: Span, path_span: Span) -> bool
[src]
fn self_value_is_available(&mut self, self_span: Span, path_span: Span) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_qpath_anywhere(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
primary_ns: Namespace,
span: Span,
defer_to_typeck: bool,
global_by_default: bool,
crate_lint: CrateLint
) -> Option<PathResolution>
[src]
fn resolve_qpath_anywhere(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
primary_ns: Namespace,
span: Span,
defer_to_typeck: bool,
global_by_default: bool,
crate_lint: CrateLint
) -> Option<PathResolution>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_qpath(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
ns: Namespace,
span: Span,
global_by_default: bool,
crate_lint: CrateLint
) -> Option<PathResolution>
[src]
fn resolve_qpath(
&mut self,
id: NodeId,
qself: Option<&QSelf>,
path: &[Ident],
ns: Namespace,
span: Span,
global_by_default: bool,
crate_lint: CrateLint
) -> Option<PathResolution>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Handles paths that may refer to associated items.
fn resolve_path(
&mut self,
path: &[Ident],
opt_ns: Option<Namespace>,
record_used: bool,
path_span: Span,
crate_lint: CrateLint
) -> PathResult<'a>
[src]
fn resolve_path(
&mut self,
path: &[Ident],
opt_ns: Option<Namespace>,
record_used: bool,
path_span: Span,
crate_lint: CrateLint
) -> PathResult<'a>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn lint_if_path_starts_with_module(
&self,
crate_lint: CrateLint,
path: &[Ident],
path_span: Span,
second_binding: Option<&NameBinding>
)
[src]
fn lint_if_path_starts_with_module(
&self,
crate_lint: CrateLint,
path: &[Ident],
path_span: Span,
second_binding: Option<&NameBinding>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn lint_path_starts_with_module(&self, id: NodeId, span: Span)
[src]
fn lint_path_starts_with_module(&self, id: NodeId, span: Span)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn adjust_local_def(
&mut self,
ns: Namespace,
rib_index: usize,
def: Def,
record_used: bool,
span: Span
) -> Def
[src]
fn adjust_local_def(
&mut self,
ns: Namespace,
rib_index: usize,
def: Def,
record_used: bool,
span: Span
) -> Def
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn lookup_assoc_candidate<FilterFn>(
&mut self,
ident: Ident,
ns: Namespace,
filter_fn: FilterFn
) -> Option<AssocSuggestion> where
FilterFn: Fn(Def) -> bool,
[src]
fn lookup_assoc_candidate<FilterFn>(
&mut self,
ident: Ident,
ns: Namespace,
filter_fn: FilterFn
) -> Option<AssocSuggestion> where
FilterFn: Fn(Def) -> bool,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn lookup_typo_candidate<FilterFn>(
&mut self,
path: &[Ident],
ns: Namespace,
filter_fn: FilterFn,
span: Span
) -> Option<Symbol> where
FilterFn: Fn(Def) -> bool,
[src]
fn lookup_typo_candidate<FilterFn>(
&mut self,
path: &[Ident],
ns: Namespace,
filter_fn: FilterFn,
span: Span
) -> Option<Symbol> where
FilterFn: Fn(Def) -> bool,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn with_resolved_label<F>(&mut self, label: Option<Label>, id: NodeId, f: F) where
F: FnOnce(&mut Resolver),
[src]
fn with_resolved_label<F>(&mut self, label: Option<Label>, id: NodeId, f: F) where
F: FnOnce(&mut Resolver),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_labeled_block(
&mut self,
label: Option<Label>,
id: NodeId,
block: &Block
)
[src]
fn resolve_labeled_block(
&mut self,
label: Option<Label>,
id: NodeId,
block: &Block
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_expr(&mut self, expr: &Expr, parent: Option<&Expr>)
[src]
fn resolve_expr(&mut self, expr: &Expr, parent: Option<&Expr>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr)
[src]
fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn get_traits_containing_item(
&mut self,
ident: Ident,
ns: Namespace
) -> Vec<TraitCandidate>
[src]
fn get_traits_containing_item(
&mut self,
ident: Ident,
ns: Namespace
) -> Vec<TraitCandidate>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn get_traits_in_module_containing_item(
&mut self,
ident: Ident,
ns: Namespace,
module: &'a ModuleData<'a>,
found_traits: &mut Vec<TraitCandidate>
)
[src]
fn get_traits_in_module_containing_item(
&mut self,
ident: Ident,
ns: Namespace,
module: &'a ModuleData<'a>,
found_traits: &mut Vec<TraitCandidate>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn lookup_import_candidates<FilterFn>(
&mut self,
lookup_name: Name,
namespace: Namespace,
filter_fn: FilterFn
) -> Vec<ImportSuggestion> where
FilterFn: Fn(Def) -> bool,
[src]
fn lookup_import_candidates<FilterFn>(
&mut self,
lookup_name: Name,
namespace: Namespace,
filter_fn: FilterFn
) -> Vec<ImportSuggestion> where
FilterFn: Fn(Def) -> bool,
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
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.
NOTE: The method does not look into imports, but this is not a problem, since we report the definitions (thus, the de-aliased imports).
fn find_module(
&mut self,
module_def: Def
) -> Option<(&'a ModuleData<'a>, ImportSuggestion)>
[src]
fn find_module(
&mut self,
module_def: Def
) -> Option<(&'a ModuleData<'a>, ImportSuggestion)>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn collect_enum_variants(&mut self, enum_def: Def) -> Option<Vec<Path>>
[src]
fn collect_enum_variants(&mut self, enum_def: Def) -> Option<Vec<Path>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn record_def(&mut self, node_id: NodeId, resolution: PathResolution)
[src]
fn record_def(&mut self, node_id: NodeId, resolution: PathResolution)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn resolve_visibility(&mut self, vis: &Visibility) -> Visibility
[src]
fn resolve_visibility(&mut self, vis: &Visibility) -> Visibility
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn is_accessible(&self, vis: Visibility) -> bool
[src]
fn is_accessible(&self, vis: Visibility) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn is_accessible_from(
&self,
vis: Visibility,
module: &'a ModuleData<'a>
) -> bool
[src]
fn is_accessible_from(
&self,
vis: Visibility,
module: &'a ModuleData<'a>
) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn report_errors(&mut self, krate: &Crate)
[src]
fn report_errors(&mut self, krate: &Crate)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn report_with_use_injections(&mut self, krate: &Crate)
[src]
fn report_with_use_injections(&mut self, krate: &Crate)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn report_shadowing_errors(&mut self)
[src]
fn report_shadowing_errors(&mut self)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn report_conflict<'b>(
&mut self,
parent: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
new_binding: &NameBinding<'b>,
old_binding: &NameBinding<'b>
)
[src]
fn report_conflict<'b>(
&mut self,
parent: &'a ModuleData<'a>,
ident: Ident,
ns: Namespace,
new_binding: &NameBinding<'b>,
old_binding: &NameBinding<'b>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn check_proc_macro_attrs(&mut self, attrs: &[Attribute])
[src]
fn check_proc_macro_attrs(&mut self, attrs: &[Attribute])
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Trait Implementations
impl<'a, 'b: 'a> Deref for ImportResolver<'a, 'b>
[src]
impl<'a, 'b: 'a> Deref for ImportResolver<'a, 'b>
type Target = Resolver<'b>
The resulting type after dereferencing.
fn deref(&self) -> &Resolver<'b>
[src]
fn deref(&self) -> &Resolver<'b>
Dereferences the value.
impl<'a, 'b: 'a> DerefMut for ImportResolver<'a, 'b>
[src]
impl<'a, 'b: 'a> DerefMut for ImportResolver<'a, 'b>
impl<'a, 'b: 'a> DefIdTree for &'a ImportResolver<'a, 'b>
[src]
impl<'a, 'b: 'a> DefIdTree for &'a ImportResolver<'a, 'b>
fn parent(self, id: DefId) -> Option<DefId>
[src]
fn parent(self, id: DefId) -> Option<DefId>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn is_descendant_of(self, descendant: DefId, ancestor: DefId) -> bool
[src]
fn is_descendant_of(self, descendant: DefId, ancestor: DefId) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Auto Trait Implementations
impl<'a, 'b> !Send for ImportResolver<'a, 'b>
impl<'a, 'b> !Send for ImportResolver<'a, 'b>
impl<'a, 'b> !Sync for ImportResolver<'a, 'b>
impl<'a, 'b> !Sync for ImportResolver<'a, 'b>