Struct Resolver 

pub struct Resolver<'db> {
    scopes: Vec<Scope<'db>>,
    module_scope: ModuleItemMap<'db>,
}

Fields

scopes: Vec<Scope<'db>>

The stack of scopes, where the inner-most scope is the last item.

When using, you generally want to process the scopes in reverse order, there’s scopes method for that.

module_scope: ModuleItemMap<'db>

Implementations

impl<'db> Resolver<'db>

pub fn resolve_known_trait( &self, db: &dyn SourceDatabase, path: &ModPath, ) -> Option<TraitId>

Resolve known trait from std, like std::futures::Future

pub fn resolve_known_struct( &self, db: &dyn SourceDatabase, path: &ModPath, ) -> Option<StructId>

Resolve known struct from std, like std::boxed::Box

pub fn resolve_known_enum( &self, db: &dyn SourceDatabase, path: &ModPath, ) -> Option<EnumId>

Resolve known enum from std, like std::result::Result

pub fn resolve_module_path_in_items( &self, db: &dyn SourceDatabase, path: &ModPath, ) -> PerNs

pub fn resolve_path_in_type_ns( &self, db: &dyn SourceDatabase, path: &Path, ) -> Option<(TypeNs, Option<usize>, Option<ImportOrExternCrate>)>

pub fn resolve_path_in_type_ns_with_prefix_info( &self, db: &dyn SourceDatabase, path: &Path, ) -> Option<(TypeNs, Option<usize>, Option<ImportOrExternCrate>, ResolvePathResultPrefixInfo, Visibility)>

pub fn resolve_path_in_type_ns_fully( &self, db: &dyn SourceDatabase, path: &Path, ) -> Option<TypeNs>

pub fn resolve_visibility( &self, db: &dyn SourceDatabase, visibility: &RawVisibility, ) -> Option<Visibility>

pub fn resolve_path_in_value_ns( &self, db: &dyn SourceDatabase, path: &Path, hygiene_id: HygieneId, ) -> Option<ResolveValueResult>

fn skip_to_mod<'this, T>( &'this self, f: impl FnMut(&'this ModuleItemMap<'db>) -> Option<T>, ) -> Option<T>

pub fn resolve_path_in_value_ns_with_prefix_info( &self, db: &dyn SourceDatabase, path: &Path, hygiene_id: HygieneId, ) -> Option<(ResolveValueResult, ResolvePathResultPrefixInfo, Visibility)>

pub fn resolve_path_in_value_ns_fully( &self, db: &dyn SourceDatabase, path: &Path, hygiene: HygieneId, ) -> Option<ValueNs>

pub fn resolve_path_as_macro( &self, db: &dyn SourceDatabase, path: &ModPath, expected_macro_kind: Option<MacroSubNs>, ) -> Option<MacrosItem>

pub fn resolve_path_as_macro_def( &self, db: &dyn SourceDatabase, path: &ModPath, expected_macro_kind: Option<MacroSubNs>, ) -> Option<MacroDefId>

pub fn resolve_lifetime(&self, lifetime: &LifetimeRef) -> Option<LifetimeNs>

pub fn names_in_scope( &self, db: &dyn SourceDatabase, ) -> IndexMap<Name, SmallVec<[ScopeDef; 1]>, FxBuildHasher>

Returns a set of names available in the current scope.

Note that this is a somewhat fuzzy concept – internally, the compiler doesn’t necessary follow a strict scoping discipline. Rather, it just tells for each ident what it resolves to.

A good example is something like str::from_utf8. From scopes point of view, this code is erroneous – both str module and str type occupy the same type namespace.

We don’t try to model that super-correctly – this functionality is primarily exposed for completions.

Note that in Rust one name can be bound to several items:

macro_rules! t { () => (()) }
type t = t!();
const t: t = t!();

That’s why we return a multimap.

The shadowing is accounted for: in

let it = 92;
{
    let it = 92;
    $0
}

there will be only one entry for it in the result.

The result is ordered roughly from the innermost scope to the outermost: when the name is introduced in two namespaces in two scopes, we use the position of the first scope.

pub fn extern_crate_decls_in_scope<'a>( &'a self, db: &'a dyn SourceDatabase, ) -> impl Iterator<Item = Name> + 'a

Note: Not to be used directly within hir-def/hir-ty

pub fn extern_crates_in_scope( &self, ) -> impl Iterator<Item = (Name, ModuleId)> + '_

pub fn traits_in_scope(&self, db: &dyn SourceDatabase) -> FxHashSet<TraitId>

pub fn traits_in_scope_from_block_scopes( &self, ) -> impl Iterator<Item = TraitId> + '_

pub fn module(&self) -> ModuleId

pub fn item_scope(&self) -> &ItemScope

pub fn krate(&self) -> Crate

pub fn def_map(&self) -> &DefMap

pub fn top_level_def_map(&self) -> &'db DefMap

pub fn is_visible( &self, db: &dyn SourceDatabase, visibility: Visibility, ) -> bool

pub fn generic_def(&self) -> Option<GenericDefId>

pub fn generic_params(&self) -> Option<&GenericParams>

pub fn all_generic_params( &self, ) -> impl Iterator<Item = (&GenericParams, GenericDefId)>

pub fn expression_store_owner(&self) -> Option<ExpressionStoreOwnerId>

pub fn impl_def(&self) -> Option<ImplId>

pub fn rename_will_conflict_with_another_variable( &self, db: &dyn SourceDatabase, current_name: &Name, current_name_as_path: &ModPath, hygiene_id: HygieneId, new_name: &Symbol, to_be_renamed: BindingId, ) -> Option<BindingId>

Checks if we rename renamed (currently named current_name) to new_name, will the meaning of this reference (that contains current_name path) change from renamed to some another variable (returned as Some).

pub fn rename_will_conflict_with_renamed( &self, db: &dyn SourceDatabase, name: &Name, name_as_path: &ModPath, hygiene_id: HygieneId, to_be_renamed: BindingId, ) -> Option<BindingId>

Checks if we rename renamed to name, will the meaning of this reference (that contains name path) change from some other variable (returned as Some) to renamed.

pub fn update_to_inner_scope( &mut self, db: &'db dyn SourceDatabase, owner: impl Into<ExpressionStoreOwnerId>, expr_id: ExprId, ) -> UpdateGuard

expr_id is required to be an expression id that comes after the top level expression scope in the given resolver

fn update_to_inner_scope_( &mut self, db: &'db dyn SourceDatabase, owner: ExpressionStoreOwnerId, expr_id: ExprId, ) -> UpdateGuard

pub fn reset_to_guard(&mut self, UpdateGuard: UpdateGuard)

impl<'db> Resolver<'db>

fn scopes(&self) -> impl Iterator<Item = &Scope<'db>>

fn resolve_module_path( &self, db: &dyn SourceDatabase, path: &ModPath, shadow: BuiltinShadowMode, ) -> PerNs

fn item_scope_(&self) -> (&DefMap, &LocalDefMap, ModuleId)

The innermost block scope that contains items or the module scope that contains this resolver.

impl<'db> Resolver<'db>

fn push_scope(self, scope: Scope<'db>) -> Resolver<'db>

fn push_generic_params_scope( self, db: &'db dyn SourceDatabase, def: GenericDefId, ) -> Resolver<'db>

fn push_block_scope( self, def_map: &'db DefMap, local_def_map: &'db LocalDefMap, module_id: ModuleId, ) -> Resolver<'db>

fn push_expr_scope( self, owner: ExpressionStoreOwnerId, expr_scopes: &'db ExprScopes, scope_id: ScopeId, ) -> Resolver<'db>

Trait Implementations

impl<'db> Clone for Resolver<'db>

fn clone(&self) -> Resolver<'db>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'db> Debug for Resolver<'db>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.