Enum rustc_middle::ty::PredicateKind

source · [−]

pub enum PredicateKind<'tcx> {
    Trait(TraitPredicate<'tcx>),
    RegionOutlives(RegionOutlivesPredicate<'tcx>),
    TypeOutlives(TypeOutlivesPredicate<'tcx>),
    Projection(ProjectionPredicate<'tcx>),
    WellFormed(GenericArg<'tcx>),
    ObjectSafe(DefId),
    ClosureKind(DefId, SubstsRef<'tcx>, ClosureKind),
    Subtype(SubtypePredicate<'tcx>),
    Coerce(CoercePredicate<'tcx>),
    ConstEvaluatable(Unevaluated<'tcx, ()>),
    ConstEquate(Const<'tcx>, Const<'tcx>),
    TypeWellFormedFromEnv(Ty<'tcx>),
}

Variants

`Trait(TraitPredicate<'tcx>)`

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(RegionOutlivesPredicate<'tcx>)`

where 'a: 'b

`TypeOutlives(TypeOutlivesPredicate<'tcx>)`

where T: 'a

`Projection(ProjectionPredicate<'tcx>)`

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

`WellFormed(GenericArg<'tcx>)`

No syntax: T well-formed.

`ObjectSafe(DefId)`

Trait must be object-safe.

`ClosureKind(DefId, SubstsRef<'tcx>, ClosureKind)`

No direct syntax. May be thought of as where T: FnFoo<...> for some substitutions ... and T being a closure type. Satisfied (or refuted) once we know the closure’s kind.

`Subtype(SubtypePredicate<'tcx>)`

T1 <: T2

This obligation is created most often when we have two unresolved type variables and hence don’t have enough information to process the subtyping obligation yet.

`Coerce(CoercePredicate<'tcx>)`

T1 coerced to T2

Like a subtyping obligation, this is created most often when we have two unresolved type variables and hence don’t have enough information to process the coercion obligation yet. At the moment, we actually process coercions very much like subtyping and don’t handle the full coercion logic.

`ConstEvaluatable(Unevaluated<'tcx, ()>)`

Constant initializer must evaluate successfully.

`ConstEquate(Const<'tcx>, Const<'tcx>)`

Constants must be equal. The first component is the const that is expected.

`TypeWellFormedFromEnv(Ty<'tcx>)`

Represents a type found in the environment that we can use for implied bounds.

Only used for Chalk.

Enum rustc_middle::ty::PredicateKind

Variants

Trait(TraitPredicate<'tcx>)

RegionOutlives(RegionOutlivesPredicate<'tcx>)

TypeOutlives(TypeOutlivesPredicate<'tcx>)

Projection(ProjectionPredicate<'tcx>)

WellFormed(GenericArg<'tcx>)

ObjectSafe(DefId)

ClosureKind(DefId, SubstsRef<'tcx>, ClosureKind)

Subtype(SubtypePredicate<'tcx>)

Coerce(CoercePredicate<'tcx>)

ConstEvaluatable(Unevaluated<'tcx, ()>)

ConstEquate(Const<'tcx>, Const<'tcx>)

TypeWellFormedFromEnv(Ty<'tcx>)

Trait Implementations

impl<'tcx> Clone for PredicateKind<'tcx>

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

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

impl<'tcx> Debug for PredicateKind<'tcx>

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

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for PredicateKind<'tcx>

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

impl<'tcx> Display for PredicateKind<'tcx>

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

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for PredicateKind<'tcx>

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

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> EncodableWithShorthand<E> for PredicateKind<'tcx>

type Variant = PredicateKind<'tcx>

fn variant(&self) -> &Self::Variant

impl<'tcx> Hash for PredicateKind<'tcx>

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

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for PredicateKind<'tcx>

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

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

type Lifted = PredicateKind<'tcx>

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

impl<'tcx> PartialEq<PredicateKind<'tcx>> for PredicateKind<'tcx>

fn eq(&self, other: &PredicateKind<'tcx>) -> bool

fn ne(&self, other: &PredicateKind<'tcx>) -> bool

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

type Output = P

type Error = Error

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

impl<'tcx> TypeFoldable<'tcx> for PredicateKind<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<'tcx>>( self, __folder: &mut __F) -> Result<Self, __F::Error>

fn fold_with<F: TypeFolder<'tcx>>(self, folder: &mut F) -> Self

impl<'tcx> TypeVisitable<'tcx> for PredicateKind<'tcx>

fn visit_with<__V: TypeVisitor<'tcx>>( &self, __visitor: &mut __V) -> ControlFlow<__V::BreakTy>

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

fn has_escaping_bound_vars(&self) -> bool

fn has_type_flags(&self, flags: TypeFlags) -> bool

fn has_projections(&self) -> bool

fn has_opaque_types(&self) -> bool

fn references_error(&self) -> bool

fn error_reported(&self) -> Option<ErrorGuaranteed>

fn has_param_types_or_consts(&self) -> bool

fn has_infer_regions(&self) -> bool

fn has_infer_types(&self) -> bool

fn has_infer_types_or_consts(&self) -> bool

fn needs_infer(&self) -> bool

fn has_placeholders(&self) -> bool

fn needs_subst(&self) -> bool

fn has_free_regions(&self) -> bool

fn has_erased_regions(&self) -> bool

fn has_erasable_regions(&self) -> bool

fn is_global(&self) -> bool

fn has_late_bound_regions(&self) -> bool

fn still_further_specializable(&self) -> bool

impl<'tcx> Copy for PredicateKind<'tcx>

impl<'tcx> Eq for PredicateKind<'tcx>

impl<'tcx> StructuralEq for PredicateKind<'tcx>

impl<'tcx> StructuralPartialEq for PredicateKind<'tcx>

Auto Trait Implementations

impl<'tcx> !RefUnwindSafe for PredicateKind<'tcx>

impl<'tcx> Send for PredicateKind<'tcx>

impl<'tcx> Sync for PredicateKind<'tcx>

impl<'tcx> Unpin for PredicateKind<'tcx>

impl<'tcx> !UnwindSafe for PredicateKind<'tcx>

`Trait(TraitPredicate<'tcx>)`

`RegionOutlives(RegionOutlivesPredicate<'tcx>)`

`TypeOutlives(TypeOutlivesPredicate<'tcx>)`

`Projection(ProjectionPredicate<'tcx>)`

`WellFormed(GenericArg<'tcx>)`

`ObjectSafe(DefId)`

`ClosureKind(DefId, SubstsRef<'tcx>, ClosureKind)`

`Subtype(SubtypePredicate<'tcx>)`

`Coerce(CoercePredicate<'tcx>)`

`ConstEvaluatable(Unevaluated<'tcx, ()>)`

`ConstEquate(Const<'tcx>, Const<'tcx>)`

`TypeWellFormedFromEnv(Ty<'tcx>)`

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

fn decode(decoder: &mut D) -> Self

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

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

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

fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for PredicateKind<'tcx>

fn hash_stable(
&self,
hcx: &mut StableHashingContext<'ctx>,
__hasher: &mut StableHasher
)

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

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

impl<T> Any for T where
T: 'static + ?Sized,

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T where
T: Copy,

fn allocate_from_iter(
arena: &'a Arena<'tcx>,
iter: impl IntoIterator<Item = T>
) -> &'a mut [T]ⓘNotable traits for &mut [u8]`impl Write for &mut [u8]impl Read for &[u8]`

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<Ctxt, T> DepNodeParams<Ctxt> for T where
Ctxt: DepContext,
T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

fn intern_with<I, F>(iter: I, f: F) -> <T as InternIteratorElement<T, R>>::Output where
I: Iterator<Item = T>,
F: FnOnce(&[T]) -> R,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ToOwned for T where
T: Clone,

impl<T> ToString for T where
T: Display + ?Sized,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<'a, T> Captures<'a> for T where
T: ?Sized,