Struct GenericArgs 

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

Implementations

impl GenericArgs<'static>

pub fn ingredient(zalsa: &Zalsa) -> &IngredientImpl<GenericArgs<'static>>

impl<'db> GenericArgs<'db>

pub fn new_<Db_, T0>(db: &'db Db_, inner_: T0) -> GenericArgs<'db>

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

impl GenericArgs<'_>

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

where SmallVec<[GenericArg<'db>; 2]>: for<'db> 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>) -> GenericArgs<'db>

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

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, ) -> Binder<DbInterner<'db>, FnSig<DbInterner<'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> 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<'db> Debug for GenericArgs<'db>

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

Formats the value using the given formatter.

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

fn default() -> GenericArgs<'db>

Returns the “default value” for a type.

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> Hash for GenericArgs<'db>

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

where __H: Hasher,

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) -> <GenericArgs<'db> as IntoIterator>::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>( relation: &mut R, a: GenericArgs<'db>, b: GenericArgs<'db>, ) -> Result<GenericArgs<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

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

type Item = GenericArg<'db>

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

fn iter(self) -> <GenericArgs<'db> as SliceLike>::IntoIter

fn as_slice(&self) -> &[<GenericArgs<'db> as SliceLike>::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>( self, folder: &mut F, ) -> Result<GenericArgs<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

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

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

where F: TypeFolder<DbInterner<'db>>,

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>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

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 GenericArgs<'db>, new_value: GenericArgs<'db>, ) -> 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>