Enum ClauseKind

pub enum ClauseKind<I>
where
    I: Interner,
{
    Trait(TraitPredicate<I>),
    RegionOutlives(OutlivesPredicate<I, <I as Interner>::Region>),
    TypeOutlives(OutlivesPredicate<I, <I as Interner>::Ty>),
    Projection(ProjectionPredicate<I>),
    ConstArgHasType(<I as Interner>::Const, <I as Interner>::Ty),
    WellFormed(<I as Interner>::GenericArg),
    ConstEvaluatable(<I as Interner>::Const),
    HostEffect(HostEffectPredicate<I>),
}

A clause is something that can appear in where bounds or be inferred by implied bounds.

Variants

Trait(TraitPredicate<I>)

Corresponds to where Foo: Bar<A, B, C>. Foo here would be the Self type of the trait reference and A, B, and C would be the type parameters.

RegionOutlives(OutlivesPredicate<I, <I as Interner>::Region>)

where 'a: 'r

TypeOutlives(OutlivesPredicate<I, <I as Interner>::Ty>)

where T: 'r

Projection(ProjectionPredicate<I>)

where <T as TraitRef>::Name == X, approximately. See the ProjectionPredicate struct for details.

ConstArgHasType(<I as Interner>::Const, <I as Interner>::Ty)

Ensures that a const generic argument to a parameter const N: u8 is of type u8.

WellFormed(<I as Interner>::GenericArg)

No syntax: T well-formed.

ConstEvaluatable(<I as Interner>::Const)

Constant initializer must evaluate successfully.

HostEffect(HostEffectPredicate<I>)

Enforces the constness of the predicate we’re calling. Like a projection goal from a where clause, it’s always going to be paired with a corresponding trait clause; this just enforces the constness of that implementation.

Trait Implementations

impl<I> Clone for ClauseKind<I>

where I: Interner,

fn clone(&self) -> ClauseKind<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for ClauseKind<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __D> Decodable<__D> for ClauseKind<I>

where I: Interner, __D: TyDecoder<I = I>, TraitPredicate<I>: Decodable<__D>, OutlivesPredicate<I, <I as Interner>::Region>: Decodable<__D>, OutlivesPredicate<I, <I as Interner>::Ty>: Decodable<__D>, ProjectionPredicate<I>: Decodable<__D>, <I as Interner>::Const: Decodable<__D>, <I as Interner>::Ty: Decodable<__D>, <I as Interner>::GenericArg: Decodable<__D>, HostEffectPredicate<I>: Decodable<__D>,

fn decode(__decoder: &mut __D) -> ClauseKind<I>

impl<I, __E> Encodable<__E> for ClauseKind<I>

where I: Interner, __E: TyEncoder<I = I>, TraitPredicate<I>: Encodable<__E>, OutlivesPredicate<I, <I as Interner>::Region>: Encodable<__E>, OutlivesPredicate<I, <I as Interner>::Ty>: Encodable<__E>, ProjectionPredicate<I>: Encodable<__E>, <I as Interner>::Const: Encodable<__E>, <I as Interner>::Ty: Encodable<__E>, <I as Interner>::GenericArg: Encodable<__E>, HostEffectPredicate<I>: Encodable<__E>,

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

impl<'tcx> EraseType for ClauseKind<TyCtxt<'tcx>>

type Result = [u8; 32]

impl<I> Hash for ClauseKind<I>

where I: Interner,

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<I, __CTX> HashStable<__CTX> for ClauseKind<I>

where I: Interner, TraitPredicate<I>: HashStable<__CTX>, OutlivesPredicate<I, <I as Interner>::Region>: HashStable<__CTX>, OutlivesPredicate<I, <I as Interner>::Ty>: HashStable<__CTX>, ProjectionPredicate<I>: HashStable<__CTX>, <I as Interner>::Const: HashStable<__CTX>, <I as Interner>::Ty: HashStable<__CTX>, <I as Interner>::GenericArg: HashStable<__CTX>, HostEffectPredicate<I>: HashStable<__CTX>,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl ParameterizedOverTcx for ClauseKind<TyCtxt<'static>>

type Value<'tcx> = ClauseKind<TyCtxt<'tcx>>

impl<I> PartialEq for ClauseKind<I>

where I: Interner,

fn eq(&self, __other: &ClauseKind<I>) -> 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<'tcx, P> Print<'tcx, P> for ClauseKind<TyCtxt<'tcx>>

where P: PrettyPrinter<'tcx>,

fn print(&self, cx: &mut P) -> Result<(), Error>

impl<I> TypeFoldable<I> for ClauseKind<I>

where I: Interner, TraitPredicate<I>: TypeFoldable<I>, OutlivesPredicate<I, <I as Interner>::Region>: TypeFoldable<I>, OutlivesPredicate<I, <I as Interner>::Ty>: TypeFoldable<I>, ProjectionPredicate<I>: TypeFoldable<I>, <I as Interner>::Const: TypeFoldable<I>, <I as Interner>::Ty: TypeFoldable<I>, <I as Interner>::GenericArg: TypeFoldable<I>, HostEffectPredicate<I>: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ClauseKind<I>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

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) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<I> TypeVisitable<I> for ClauseKind<I>

where I: Interner, TraitPredicate<I>: TypeVisitable<I>, OutlivesPredicate<I, <I as Interner>::Region>: TypeVisitable<I>, OutlivesPredicate<I, <I as Interner>::Ty>: TypeVisitable<I>, ProjectionPredicate<I>: TypeVisitable<I>, <I as Interner>::Const: TypeVisitable<I>, <I as Interner>::Ty: TypeVisitable<I>, <I as Interner>::GenericArg: TypeVisitable<I>, HostEffectPredicate<I>: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

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

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>> for Clause<'tcx>

fn upcast_from( from: ClauseKind<TyCtxt<'tcx>>, tcx: TyCtxt<'tcx>, ) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>> for Predicate<'tcx>

fn upcast_from( from: ClauseKind<TyCtxt<'tcx>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<I> Copy for ClauseKind<I>

where I: Interner,

impl<I> Eq for ClauseKind<I>

where I: Interner,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.