Struct Clause

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

A subset of predicates which can be assumed by the trait solver. They show up in an item’s where clauses, hence the name Clause, and may either be user-written (such as traits) or may be inserted during lowering.

Tuple Fields

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

Implementations

impl<'tcx> Clause<'tcx>

pub fn as_predicate(self) -> Predicate<'tcx>

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

pub fn as_trait_clause(self) -> Option<Binder<'tcx, TraitPredicate<'tcx>>>

pub fn as_projection_clause( self, ) -> Option<Binder<'tcx, ProjectionPredicate<'tcx>>>

pub fn as_type_outlives_clause( self, ) -> Option<Binder<'tcx, TypeOutlivesPredicate<'tcx>>>

pub fn as_region_outlives_clause( self, ) -> Option<Binder<'tcx, RegionOutlivesPredicate<'tcx>>>

impl<'tcx> Clause<'tcx>

pub fn instantiate_supertrait( self, tcx: TyCtxt<'tcx>, trait_ref: PolyTraitRef<'tcx>, ) -> Clause<'tcx>

Performs a instantiation suitable for going from a poly-trait-ref to supertraits that must hold if that poly-trait-ref holds. This is slightly different from a normal instantiation in terms of what happens with bound regions. See lengthy comment below for details.

Trait Implementations

impl<'tcx> Clause<TyCtxt<'tcx>> for Clause<'tcx>

fn as_predicate(self) -> Predicate<'tcx>

fn instantiate_supertrait( self, tcx: TyCtxt<'tcx>, trait_ref: PolyTraitRef<'tcx>, ) -> Self

Performs a instantiation suitable for going from a poly-trait-ref to supertraits that must hold if that poly-trait-ref holds. This is slightly different from a normal instantiation in terms of what happens with bound regions.

fn as_trait_clause(self) -> Option<Binder<I, TraitPredicate<I>>>

fn as_projection_clause(self) -> Option<Binder<I, ProjectionPredicate<I>>>

impl<'tcx> Clone for Clause<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for Clause<'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 Clause<'tcx>

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

impl<'tcx> Display for Clause<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Elaboratable<TyCtxt<'tcx>> for Clause<'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 Clause<'tcx>

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

impl<'tcx> Hash for Clause<'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 Clause<'tcx>

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

impl IntoDiagArg for Clause<'_>

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> IntoKind for Clause<'tcx>

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

fn kind(self) -> Self::Kind

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

type Lifted = Clause<'tcx>

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

impl ParameterizedOverTcx for Clause<'static>

type Value<'tcx> = Clause<'tcx>

impl<'tcx> PartialEq for Clause<'tcx>

fn eq(&self, other: &Clause<'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, P: PrettyPrinter<'tcx>> Print<'tcx, P> for Clause<'tcx>

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Clause<'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> TypeVisitable<TyCtxt<'tcx>> for Clause<'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 Clause<'tcx>

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

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

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

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

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

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Clause<'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 Clause<'tcx>

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

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

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

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

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

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

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

impl<'tcx> Copy for Clause<'tcx>

impl<'tcx> Eq for Clause<'tcx>

impl<'tcx> StructuralPartialEq for Clause<'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