Struct rustc_middle::ty::Clause

pub struct Clause<'tcx>(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 subst_supertrait( self, tcx: TyCtxt<'tcx>, trait_ref: &PolyTraitRef<'tcx> ) -> Clause<'tcx>

Performs a substitution 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 substitution in terms of what happens with bound regions. See lengthy comment below for details.

Trait Implementations

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, 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 IntoDiagnosticArg for Clause<'_>

fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static>

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

type Lifted = Clause<'tcx>

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

impl ParameterizedOverTcx for Clause<'static>

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

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

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

type Output = P

type Error = Error

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

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for Binder<'tcx, ClauseKind<'tcx>>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for Binder<'tcx, TraitRef<'tcx>>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for ClauseKind<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyProjectionPredicate<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyTraitPredicate<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for ProjectionPredicate<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for TraitPredicate<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for TraitRef<'tcx>

fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>

impl<'tcx> ToPredicate<'tcx, Predicate<'tcx>> for Clause<'tcx>

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> Predicate<'tcx>

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) -> Selfwhere 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 ) -> ControlFlow<V::BreakTy>

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

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

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

impl<'tcx> StructuralEq 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