Struct Resolver

pub struct Resolver<'db> {
    pub data: ResolverData,
    pub owning_crate_id: CrateId,
    pub edition: Edition,
    /* private fields */
}

Resolves paths semantically.

Fields

data: ResolverData

owning_crate_id: CrateId

edition: Edition

Implementations

impl Resolver<'_>

pub fn set_feature_config( &mut self, element_id: &impl LanguageElementId, syntax: &impl QueryAttrs, diagnostics: &mut SemanticDiagnostics, )

Extracts the allowed node from the syntax, and sets it as the allowed features of the resolver.

impl<'db> Resolver<'db>

pub fn new( db: &'db dyn SemanticGroup, module_file_id: ModuleFileId, inference_id: InferenceId, ) -> Self

pub fn with_data(db: &'db dyn SemanticGroup, data: ResolverData) -> Self

pub fn inference(&mut self) -> Inference<'_>

pub fn add_generic_param(&mut self, generic_param_id: GenericParamId)

Adds a generic param to an existing resolver. This is required since a resolver needs to exist before resolving the generic params, and thus, they are added to the Resolver only after they are resolved.

pub fn resolve_concrete_path( &mut self, diagnostics: &mut SemanticDiagnostics, path: impl AsSegments, item_type: NotFoundItemType, ) -> Maybe<ResolvedConcreteItem>

Resolves a concrete item, given a path. Guaranteed to result in at most one diagnostic.

pub fn resolve_generic_path( &mut self, diagnostics: &mut SemanticDiagnostics, path: impl AsSegments, item_type: NotFoundItemType, ) -> Maybe<ResolvedGenericItem>

Resolves a generic item, given a path. Guaranteed to result in at most one diagnostic.

pub fn resolve_generic_path_with_args( &mut self, diagnostics: &mut SemanticDiagnostics, path: impl AsSegments, item_type: NotFoundItemType, ) -> Maybe<ResolvedGenericItem>

Resolves a generic item, given a concrete item path, while ignoring the generic args. Guaranteed to result in at most one diagnostic.

pub fn prelude_submodule(&self) -> ModuleId

Returns the crate’s prelude submodule.

pub fn specialize_function( &mut self, diagnostics: &mut SemanticDiagnostics, stable_ptr: SyntaxStablePtrId, generic_function: GenericFunctionId, generic_args: &[GenericArg], ) -> Maybe<FunctionId>

Specializes a generic function.

pub fn specialize_type( &mut self, diagnostics: &mut SemanticDiagnostics, stable_ptr: SyntaxStablePtrId, generic_type: GenericTypeId, generic_args: &[GenericArg], ) -> Maybe<TypeId>

Specializes a generic type.

pub fn impl_lookup_context(&self) -> ImplLookupContext

pub fn resolve_generic_args( &mut self, diagnostics: &mut SemanticDiagnostics, generic_params: &[GenericParam], generic_args_syntax: &[GenericArg], stable_ptr: SyntaxStablePtrId, ) -> Maybe<Vec<GenericArgumentId>>

pub fn ignore_visibility_checks(&self, module_id: ModuleId) -> bool

Should visibility checks not actually happen for lookups in this module.

Methods from Deref<Target = ResolverData>

pub fn clone_with_inference_id( &self, db: &dyn SemanticGroup, inference_id: InferenceId, ) -> Self

Trait Implementations

impl Deref for Resolver<'_>

type Target = ResolverData

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Resolver<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.