Struct GenericArgs

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

Implementations

impl GenericArgs<'static>

pub fn ingredient<Db>(db: &Db) -> &IngredientImpl<GenericArgs<'static>>

where Db: Database + ?Sized,

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>,

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

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

impl<'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(&Symbol, 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.

Trait Implementations

impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for Substitution<Interner>

fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArgs<'db>

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>