Struct ResolverData 

pub struct ResolverData<'db> {
    pub module_id: ModuleId<'db>,
    pub generic_params: Vec<GenericParamId<'db>>,
    pub type_enriched_members: OrderedHashMap<(TypeId<'db>, bool), EnrichedMembers<'db>>,
    pub resolved_items: ResolvedItems<'db>,
    pub inference_data: InferenceData<'db>,
    pub trait_or_impl_ctx: TraitOrImplContext<'db>,
    pub feature_config: FeatureConfig<'db>,
    pub used_uses: OrderedHashSet<UseId<'db>>,
    /* private fields */
}

Fields

module_id: ModuleId<'db>

Current module in which to resolve the path.

generic_params: Vec<GenericParamId<'db>>

All generic parameters accessible to the resolver.

type_enriched_members: OrderedHashMap<(TypeId<'db>, bool), EnrichedMembers<'db>>

The enriched members per type and its mutability in the resolver context.

resolved_items: ResolvedItems<'db>

Lookback map for resolved identifiers in path. Used in “Go to definition”.

inference_data: InferenceData<'db>

Inference data for the resolver.

trait_or_impl_ctx: TraitOrImplContext<'db>

The trait/impl context the resolver is currently in. Used to resolve “Self::” paths.

feature_config: FeatureConfig<'db>

The configuration of allowed features.

used_uses: OrderedHashSet<UseId<'db>>

The set of used use items in the current context.

Implementations

impl<'db> ResolverData<'db>

pub fn new(module_id: ModuleId<'db>, inference_id: InferenceId<'db>) -> Self

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

Trait Implementations

impl<'db> Debug for ResolverData<'db>

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

Formats the value using the given formatter.

impl<'db> DebugWithDb<'db> for ResolverData<'db>

type Db = dyn Database

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

fn debug<'me>(&'me self, db: &'db Self::Db) -> DebugWith<'me, 'db, Self::Db>

where Self: Sized + 'me,

fn into_debug<'me>(self, db: &'db Self::Db) -> DebugWith<'me, 'db, Self::Db>

where Self: Sized + 'me,

impl<'db> PartialEq for ResolverData<'db>

fn eq(&self, other: &ResolverData<'db>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'db> Update for ResolverData<'db>

unsafe fn maybe_update(old_pointer_: *mut Self, new_value_: Self) -> bool

Returns

impl<'db> Eq for ResolverData<'db>

impl<'db> StructuralPartialEq for ResolverData<'db>