Struct rustc_resolve::imports::ImportResolver

pub struct ImportResolver<'a, 'b> {
    pub r: &'a mut Resolver<'b>,
}

Fields

r: &'a mut Resolver<'b>

Implementations

impl<'a, 'b> ImportResolver<'a, 'b>

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

Adds suggestions for a path that cannot be resolved.

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

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

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

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

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

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

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

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

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

fn make_external_crate_suggestion(
    &mut self,
    span: Span,
    path: Vec<Segment>,
    parent_scope: &ParentScope<'b>
) -> Option<(Vec<Segment>, Vec<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.

pub(crate) fn check_for_module_export_macro(
    &mut self,
    import: &'b Import<'b>,
    module: ModuleOrUniformRoot<'b>,
    ident: Ident
) -> Option<(Option<(Vec<(Span, String)>, String, Applicability)>, Vec<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

impl<'a, 'b> ImportResolver<'a, 'b>

pub fn resolve_imports(&mut self)

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

pub fn finalize_imports(&mut self)

fn throw_unresolved_import_error(
    &self,
    errors: Vec<(String, UnresolvedImportError)>,
    span: Option<MultiSpan>
)

fn resolve_import(&mut self, import: &'b Import<'b>) -> bool

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,
    import: &'b Import<'b>
) -> 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.

fn check_for_redundant_imports(
    &mut self,
    ident: Ident,
    import: &'b Import<'b>,
    source_bindings: &PerNS<Cell<Result<&'b NameBinding<'b>, Determinacy>>>,
    target_bindings: &PerNS<Cell<Option<&'b NameBinding<'b>>>>,
    target: Ident
)

fn resolve_glob_import(&mut self, import: &'b Import<'b>)

fn finalize_resolutions_in(&mut self, module: &'b ModuleData<'b>)

Trait Implementations

impl<'a, 'b> DefIdTree for &'a ImportResolver<'a, 'b>

fn parent(self, id: DefId) -> Option<DefId>

fn is_descendant_of(self, descendant: DefId, ancestor: DefId) -> bool

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: 8 bytes