Struct GenericArgs 

pub struct GenericArgs<'db>(/* private fields */);

Implementations

impl GenericArgs<'static>

pub fn ingredient(zalsa: &Zalsa) -> &IngredientImpl<Self>

impl<'db> GenericArgs<'db>

pub fn new_<Db_, T0: Lookup<SmallVec<[GenericArg<'db>; 2]>> + Hash>( db: &'db Db_, inner_: T0, ) -> Self

where Db_: ?Sized + Database, SmallVec<[GenericArg<'db>; 2]>: HashEqLike<T0>,

impl GenericArgs<'_>

pub fn default_debug_fmt(this: Self, f: &mut Formatter<'_>) -> Result

where for<'db> SmallVec<[GenericArg<'db>; 2]>: Debug,

Default debug formatting for this struct (may be useful if you define your own Debug impl)

impl<'db> GenericArgs<'db>

pub fn empty(interner: DbInterner<'db>) -> Self

pub fn new_from_iter( interner: DbInterner<'db>, data: impl IntoIterator<Item = GenericArg<'db>>, ) -> Self

pub fn inner(&self) -> &SmallVec<[GenericArg<'db>; 2]>

impl<'db> GenericArgs<'db>

pub fn for_item<F>( interner: DbInterner<'db>, def_id: SolverDefId, mk_kind: F, ) -> GenericArgs<'db>

where F: FnMut(u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,

Creates an GenericArgs for generic parameter definitions, by calling closures to obtain each kind. The closures get to observe the GenericArgs as they’re being built, which can be used to correctly replace defaults of generic parameters.

pub fn error_for_item( interner: DbInterner<'db>, def_id: SolverDefId, ) -> GenericArgs<'db>

Creates an all-error GenericArgs.

pub fn for_item_with_defaults<F>( interner: DbInterner<'db>, def_id: GenericDefId, fallback: F, ) -> GenericArgs<'db>

where F: FnMut(u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,

Like for_item, but prefers the default of a parameter if it has any.

pub fn fill_rest<F>( interner: DbInterner<'db>, def_id: SolverDefId, first: impl IntoIterator<Item = GenericArg<'db>>, fallback: F, ) -> GenericArgs<'db>

where F: FnMut(u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,

Like for_item(), but calls first uses the args from first.

pub fn fill_with_defaults<F>( interner: DbInterner<'db>, def_id: GenericDefId, first: impl IntoIterator<Item = GenericArg<'db>>, fallback: F, ) -> GenericArgs<'db>

where F: FnMut(u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,

Appends default param values to first if needed. Params without default will call fallback().

pub fn closure_sig_untupled(self) -> PolyFnSig<'db>

pub fn split_closure_args_untupled(self) -> ClosureArgsParts<DbInterner<'db>>

A “sensible” .split_closure_args(), where the arguments are not in a tuple.

pub fn types(self) -> impl Iterator<Item = Ty<'db>>

pub fn consts(self) -> impl Iterator<Item = Const<'db>>

pub fn regions(self) -> impl Iterator<Item = Region<'db>>

Trait Implementations

impl<'db> AsId for GenericArgs<'db>

fn as_id(&self) -> Id

impl<'db> Clone for GenericArgs<'db>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Configuration for GenericArgs<'static>

const LOCATION: Location

const DEBUG_NAME: &'static str = "GenericArgs"

const PERSIST: bool = false

Whether this struct should be persisted with the database.

type Fields<'a> = (SmallVec<[GenericArg<'a>; 2]>,)

The fields of the struct being interned.

type Struct<'db> = GenericArgs<'db>

The end user struct

fn serialize<S: Serializer>( fields: &Self::Fields<'_>, serializer: S, ) -> Result<S::Ok, S::Error>

Serialize the fields using serde.

fn deserialize<'de, D: Deserializer<'de>>( deserializer: D, ) -> Result<Self::Fields<'static>, D::Error>

Deserialize the fields using serde.

const REVISIONS: NonZero<usize> = _

fn heap_size(_value: &Self::Fields<'_>) -> Option<usize>

Returns the size of any heap allocations in the output value, in bytes.

impl<'db> Debug for GenericArgs<'db>

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

Formats the value using the given formatter.

impl<'db> Default for GenericArgs<'db>

fn default() -> Self

Returns the “default value” for a type.

impl<'db> FromId for GenericArgs<'db>

fn from_id(id: Id) -> Self

impl<'db> GenericArgs<DbInterner<'db>> for GenericArgs<'db>

fn as_closure(self) -> ClosureArgs<DbInterner<'db>>

fn as_coroutine(self) -> CoroutineArgs<DbInterner<'db>>

fn as_coroutine_closure(self) -> CoroutineClosureArgs<DbInterner<'db>>

fn rebase_onto( self, interner: DbInterner<'db>, source_def_id: <DbInterner<'db> as Interner>::DefId, target: <DbInterner<'db> as Interner>::GenericArgs, ) -> <DbInterner<'db> as Interner>::GenericArgs

fn identity_for_item( interner: DbInterner<'db>, def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::GenericArgs

fn extend_with_error( interner: DbInterner<'db>, def_id: <DbInterner<'db> as Interner>::DefId, original_args: &[<DbInterner<'db> as Interner>::GenericArg], ) -> <DbInterner<'db> as Interner>::GenericArgs

fn type_at(self, i: usize) -> <DbInterner<'db> as Interner>::Ty

fn region_at(self, i: usize) -> <DbInterner<'db> as Interner>::Region

fn const_at(self, i: usize) -> <DbInterner<'db> as Interner>::Const

fn split_closure_args(self) -> ClosureArgsParts<DbInterner<'db>>

fn split_coroutine_closure_args( self, ) -> CoroutineClosureArgsParts<DbInterner<'db>>

fn split_coroutine_args(self) -> CoroutineArgsParts<DbInterner<'db>>

impl<'db> HasJar for GenericArgs<'db>

const KIND: JarKind = zalsa_::JarKind::Struct

The [JarKind] for Self::Jar.

type Jar = JarImpl<GenericArgs<'static>>

The [Jar] associated with this ingredient.

impl<'db> Hash for GenericArgs<'db>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'db> IntoIterator for GenericArgs<'db>

type Item = GenericArg<'db>

The type of the elements being iterated over.

type IntoIter = <GenericArgs<'db> as SliceLike>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'db> PartialEq for GenericArgs<'db>

fn eq(&self, other: &GenericArgs<'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> Relate<DbInterner<'db>> for GenericArgs<'db>

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

impl<'db> SalsaStructInDb for GenericArgs<'db>

type MemoIngredientMap = MemoIngredientSingletonIndex

fn lookup_ingredient_index(aux: &Zalsa) -> IngredientIndices

Lookup or create ingredient indices.

fn entries(zalsa: &Zalsa) -> impl Iterator<Item = DatabaseKeyIndex> + '_

Returns the IDs of any instances of this struct in the database.

fn cast(id: Id, type_id: TypeId) -> Option<Self>

Plumbing to support nested salsa supertypes.

unsafe fn memo_table( zalsa: &Zalsa, id: Id, current_revision: Revision, ) -> MemoTableWithTypes<'_>

Return the memo table associated with id.

impl<'db> SliceLike for GenericArgs<'db>

type Item = GenericArg<'db>

type IntoIter = <SmallVec<[GenericArg<'db>; 2]> as IntoIterator>::IntoIter

fn iter(self) -> Self::IntoIter

fn as_slice(&self) -> &[Self::Item]

fn get(self, idx: usize) -> Option<Self::Item>

fn len(self) -> usize

fn is_empty(self) -> bool

fn contains(self, t: &Self::Item) -> bool

where Self::Item: PartialEq,

fn to_vec(self) -> Vec<Self::Item>

fn last(self) -> Option<Self::Item>

fn split_last(&self) -> Option<(&Self::Item, &[Self::Item])>

impl<'db> TypeFoldable<DbInterner<'db>> for GenericArgs<'db>

fn try_fold_with<F: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeVisitable<DbInterner<'db>> for GenericArgs<'db>

fn visit_with<V: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> Update for GenericArgs<'db>

unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool

Returns

impl<'db> Copy for GenericArgs<'db>

impl<'db> Eq for GenericArgs<'db>

impl<'db> Send for GenericArgs<'db>

impl<'db> StructuralPartialEq for GenericArgs<'db>

impl<'db> Sync for GenericArgs<'db>