Struct hir_def::resolver::Resolver

pub struct Resolver { /* private fields */ }

Implementations

impl Resolver

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

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

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

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

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

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

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

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

pub fn resolve_path_in_type_ns_fully_with_imports( &self, db: &dyn DefDatabase, path: &Path, ) -> Option<(TypeNs, Option<ImportOrExternCrate>)>

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

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

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

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

pub fn resolve_path_as_macro( &self, db: &dyn DefDatabase, path: &ModPath, expected_macro_kind: Option<MacroSubNs>, ) -> Option<(MacroId, Option<ImportId>)>

pub fn resolve_path_as_macro_def( &self, db: &dyn DefDatabase, 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 DefDatabase, ) -> IndexMap<Name, SmallVec<[ScopeDef; 1]>, BuildHasherDefault<FxHasher>>

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 DefDatabase, ) -> impl Iterator<Item = Name> + 'a

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

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

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

pub fn module(&self) -> ModuleId

pub fn krate(&self) -> CrateId

pub fn def_map(&self) -> &DefMap

pub fn where_predicates_in_scope( &self, ) -> impl Iterator<Item = (&WherePredicate, (&GenericDefId, &TypesMap))>

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

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

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

pub fn body_owner(&self) -> Option<DefWithBodyId>

pub fn type_owner(&self) -> Option<TypeOwnerId>

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

pub fn update_to_inner_scope( &mut self, db: &dyn DefDatabase, owner: DefWithBodyId, 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

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

Trait Implementations

impl Clone for Resolver

fn clone(&self) -> Resolver

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Resolver

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

Formats the value using the given formatter.