Struct rustc_middle::ty::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 ObjectSafe 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 to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>>

pub fn to_opt_poly_projection_pred( 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, 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<'a, 'tcx> Lift<'tcx> for Predicate<'a>

type Lifted = Predicate<'tcx>

fn lift_to_tcx(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

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