Struct GenericClauses 

pub struct GenericClauses<'tcx> {
    pub parent: Option<DefId>,
    pub clauses: &'tcx [(Clause<'tcx>, Span)],
}

Bounds on generics.

Fields

parent: Option<DefId>

clauses: &'tcx [(Clause<'tcx>, Span)]

Implementations

impl<'tcx> GenericClauses<'tcx>

pub fn instantiate( self, tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>, ) -> InstantiatedClauses<'tcx>

pub fn instantiate_own( self, tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>, ) -> impl Iterator<Item = (Unnormalized<'tcx, Clause<'tcx>>, Span)> + DoubleEndedIterator + ExactSizeIterator + Clone

pub fn instantiate_own_identity( self, ) -> impl Iterator<Item = (Unnormalized<'tcx, Clause<'tcx>>, Span)> + DoubleEndedIterator + ExactSizeIterator + Clone

fn instantiate_into( self, tcx: TyCtxt<'tcx>, instantiated: &mut InstantiatedClauses<'tcx>, args: GenericArgsRef<'tcx>, )

pub fn instantiate_identity( self, tcx: TyCtxt<'tcx>, ) -> InstantiatedClauses<'tcx>

fn instantiate_identity_into( self, tcx: TyCtxt<'tcx>, instantiated: &mut InstantiatedClauses<'tcx>, )

pub fn is_fully_generic_for_reflection(self) -> bool

Allow simple where bounds like T: Debug, but prevent any kind of outlives bounds or uses of generic parameters on the right hand side.

We allow simple bounds because when the T actually gets substituted with a concrete type during monomorphization, we will be checking its Debug impl for fully_generic_for_reflection.

Constants (associated or generic) are irrelevant for this analysis, as their value is neither affected by lifetimes, nor do they affect lifetimes.

Trait Implementations

impl<'tcx> Clone for GenericClauses<'tcx>

fn clone(&self) -> GenericClauses<'tcx>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'tcx> Copy for GenericClauses<'tcx>

impl<'tcx> Debug for GenericClauses<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for GenericClauses<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx> Default for GenericClauses<'tcx>

fn default() -> GenericClauses<'tcx>

Returns the “default value” for a type.

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for GenericClauses<'tcx>

fn encode(&self, __encoder: &mut __E)

impl Erasable for GenericClauses<'_>

type Storage = [u8; 24]

Storage type to used for erased values of this type. Should be [u8; N], where N is equal to size_of::<Self>.

impl<'tcx> StableHash for GenericClauses<'tcx>

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes