Enum rustc_type_ir::predicate_kind::ClauseKind

pub enum ClauseKind<I: Interner> {
    Trait(I::TraitPredicate),
    RegionOutlives(I::RegionOutlivesPredicate),
    TypeOutlives(I::TypeOutlivesPredicate),
    Projection(I::ProjectionPredicate),
    ConstArgHasType(I::Const, I::Ty),
    WellFormed(I::GenericArg),
    ConstEvaluatable(I::Const),
}

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

Variants

Trait(I::TraitPredicate)

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(I::RegionOutlivesPredicate)

where 'a: 'b

TypeOutlives(I::TypeOutlivesPredicate)

where T: 'a

Projection(I::ProjectionPredicate)

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

ConstArgHasType(I::Const, I::Ty)

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

WellFormed(I::GenericArg)

No syntax: T well-formed.

ConstEvaluatable(I::Const)

Constant initializer must evaluate successfully.

Trait Implementations

impl<I: Interner> Clone for ClauseKind<I>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Interner> Debug for ClauseKind<I>

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

Formats the value using the given formatter.

impl<I: Interner, __D: TyDecoder<I = I>> Decodable<__D> for ClauseKind<I>

where I::TraitPredicate: Decodable<__D>, I::RegionOutlivesPredicate: Decodable<__D>, I::TypeOutlivesPredicate: Decodable<__D>, I::ProjectionPredicate: Decodable<__D>, I::Const: Decodable<__D>, I::Ty: Decodable<__D>, I::GenericArg: Decodable<__D>,

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

impl<I: Interner, __E: TyEncoder<I = I>> Encodable<__E> for ClauseKind<I>

where I::TraitPredicate: Encodable<__E>, I::RegionOutlivesPredicate: Encodable<__E>, I::TypeOutlivesPredicate: Encodable<__E>, I::ProjectionPredicate: Encodable<__E>, I::Const: Encodable<__E>, I::Ty: Encodable<__E>, I::GenericArg: Encodable<__E>,

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

impl<I: Interner> Hash for ClauseKind<I>

fn hash<__HI>(&self, __state: &mut __HI)

where __HI: 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: Interner, __CTX> HashStable<__CTX> for ClauseKind<I>

where I::TraitPredicate: HashStable<__CTX>, I::RegionOutlivesPredicate: HashStable<__CTX>, I::TypeOutlivesPredicate: HashStable<__CTX>, I::ProjectionPredicate: HashStable<__CTX>, I::Const: HashStable<__CTX>, I::Ty: HashStable<__CTX>, I::GenericArg: HashStable<__CTX>,

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

impl<I: Interner> PartialEq for ClauseKind<I>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Interner> TypeFoldable<I> for ClauseKind<I>

where I::Ty: TypeFoldable<I>, I::Const: TypeFoldable<I>, I::GenericArg: TypeFoldable<I>, I::TraitPredicate: TypeFoldable<I>, I::ProjectionPredicate: TypeFoldable<I>, I::TypeOutlivesPredicate: TypeFoldable<I>, I::RegionOutlivesPredicate: TypeFoldable<I>,

fn try_fold_with<F: FallibleTypeFolder<I>>( 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<I>>(self, folder: &mut F) -> Self

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: Interner> TypeVisitable<I> for ClauseKind<I>

where I::Ty: TypeVisitable<I>, I::Const: TypeVisitable<I>, I::GenericArg: TypeVisitable<I>, I::TraitPredicate: TypeVisitable<I>, I::ProjectionPredicate: TypeVisitable<I>, I::TypeOutlivesPredicate: TypeVisitable<I>, I::RegionOutlivesPredicate: TypeVisitable<I>,

fn visit_with<V: TypeVisitor<I>>( &self, visitor: &mut V ) -> ControlFlow<V::BreakTy>

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

impl<I: Interner> Copy for ClauseKind<I>

impl<I: Interner> Eq for ClauseKind<I>

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.