Struct Predicate

pub struct Predicate<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<Binder<'tcx, PredicateKind<'tcx>>>>);

A statement that can be proven by a trait solver. This includes things that may show up in where clauses, such as trait predicates and projection predicates, and also things that are emitted as part of type checking such as DynCompatible predicate which is emitted when a type is coerced to a trait object.

Use this rather than PredicateKind, whenever possible.

Tuple Fields

0: Interned<'tcx, WithCachedTypeInfo<Binder<'tcx, PredicateKind<'tcx>>>>

Implementations

impl<'tcx> Predicate<'tcx>

pub fn kind(self) -> Binder<'tcx, PredicateKind<'tcx>>

Gets the inner ty::Binder<'tcx, PredicateKind<'tcx>>.

pub fn flags(self) -> TypeFlags

pub fn outer_exclusive_binder(self) -> DebruijnIndex

pub fn flip_polarity(self, tcx: TyCtxt<'tcx>) -> Option<Predicate<'tcx>>

Flips the polarity of a Predicate.

Given T: Trait predicate it returns T: !Trait and given T: !Trait returns T: Trait.

pub fn is_coinductive(self, tcx: TyCtxt<'tcx>) -> bool

pub fn allow_normalization(self) -> bool

Whether this projection can be soundly normalized.

Wf predicates must not be normalized, as normalization can remove required bounds which would cause us to unsoundly accept some programs. See #91068.

impl<'tcx> Predicate<'tcx>

pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'tcx>>

pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'tcx>>

pub fn as_clause(self) -> Option<Clause<'tcx>>

Matches a PredicateKind::Clause and turns it into a Clause, otherwise returns None.

pub fn expect_clause(self) -> Clause<'tcx>

Assert that the predicate is a clause.

Trait Implementations

impl<'tcx> Clone for Predicate<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for Predicate<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for Predicate<'tcx>

fn decode(decoder: &mut D) -> Predicate<'tcx>

impl<'tcx> Display for Predicate<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Elaboratable<TyCtxt<'tcx>> for Predicate<'tcx>

fn predicate(&self) -> Predicate<'tcx>

fn child(&self, clause: Clause<'tcx>) -> Self

fn child_with_derived_cause( &self, clause: Clause<'tcx>, _span: Span, _parent_trait_pred: PolyTraitPredicate<'tcx>, _index: usize, ) -> Self

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for Predicate<'tcx>

fn encode(&self, e: &mut E)

impl<'tcx> EraseType for Predicate<'tcx>

type Result = [u8; 8]

impl<'tcx> Flags for Predicate<'tcx>

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<'tcx> Hash for Predicate<'tcx>

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

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<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Predicate<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl IntoDiagArg for Predicate<'_>

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> IntoKind for Predicate<'tcx>

type Kind = Binder<TyCtxt<'tcx>, PredicateKind<TyCtxt<'tcx>>>

fn kind(self) -> Self::Kind

impl<'a, 'tcx> Lift<TyCtxt<'tcx>> for Predicate<'a>

type Lifted = Predicate<'tcx>

fn lift_to_interner(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl ParameterizedOverTcx for Predicate<'static>

type Value<'tcx> = Predicate<'tcx>

impl<'tcx> PartialEq for Predicate<'tcx>

fn eq(&self, other: &Predicate<'tcx>) -> 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> Predicate<TyCtxt<'tcx>> for Predicate<'tcx>

fn as_clause(self) -> Option<Clause<'tcx>>

fn is_coinductive(self, interner: TyCtxt<'tcx>) -> bool

fn allow_normalization(self) -> bool

impl<'tcx, P: PrettyPrinter<'tcx>> Print<'tcx, P> for Predicate<'tcx>

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Predicate<'tcx>

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( 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>(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<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Predicate<'tcx>

fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

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

impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Predicate<'tcx>

fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V, ) -> V::Result

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Predicate<'tcx>

fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result

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

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

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

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Region<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: PolyRegionOutlivesPredicate<'tcx>, tcx: TyCtxt<'tcx>, ) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, PredicateKind<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<'tcx, PredicateKind<'tcx>>, tcx: TyCtxt<'tcx>, ) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from(from: PolyProjectionPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from(from: PolyTraitPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from(from: Binder<'tcx, TraitRef<'tcx>>, tcx: TyCtxt<'tcx>) -> Self

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

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

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

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

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

fn upcast_from(from: NormalizesTo<'tcx>, tcx: TyCtxt<'tcx>) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Region<'tcx>>> for Predicate<'tcx>

fn upcast_from(from: RegionOutlivesPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Ty<'tcx>>> for Predicate<'tcx>

fn upcast_from(from: TypeOutlivesPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

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

fn upcast_from(from: PredicateKind<'tcx>, tcx: TyCtxt<'tcx>) -> Self

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

fn upcast_from(from: ProjectionPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

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

fn upcast_from(from: TraitPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self

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

fn upcast_from(from: TraitRef<'tcx>, tcx: TyCtxt<'tcx>) -> Self

impl<'tcx> Copy for Predicate<'tcx>

impl<'tcx> Eq for Predicate<'tcx>

impl<'tcx> StructuralPartialEq for Predicate<'tcx>

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: 8 bytes