Enum LeafRegionConstraint 

pub enum LeafRegionConstraint<I, S = ()>
where
    I: Interner,
    S: Clone + Debug,
{
    Ambiguity(S),
    RegionOutlives(Region<I>, Region<I>, S),
    AliasTyOutlivesViaEnv(Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>, S),
    PlaceholderTyOutlives(<I as Interner>::Ty, Region<I>, S),
}

Variants

Ambiguity(S)

RegionOutlives(Region<I>, Region<I>, S)

AliasTyOutlivesViaEnv(Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>, S)

Requirement that a (potentially higher ranked) alias outlives some (potentially higher ranked) region due to an assumption in the environment. This cannot be satisfied via component outlives or item bounds.

We cannot eagerly look at assumptions as we are usually working with an incomplete set of assumptions and there may wind up being assumptions we can use to prove this when we’re in a smaller universe.

We eagerly destructure alias outlives requirements into region outlives requirements corresponding to component outlives & item bound outlives rules, leaving only param env candidates.

PlaceholderTyOutlives(<I as Interner>::Ty, Region<I>, S)

This is an I::Ty for two reasons:

1. We need the type visitable impl to be able to visit_ty on this so canonicalization knows about the placeholder
2. When exiting the trait solver there may be placeholder outlives corresponding to params from the root universe. These need to be changed from a Placeholder to the original Param.

We cannot eagerly look at assumptions as we are usually working with an incomplete set of assumptions and there may wind up being assumptions we can use to prove this when we’re in a smaller universe.

Implementations

impl<I> LeafRegionConstraint<I>

where I: Interner,

pub fn with_span<S>(self, span: S) -> LeafRegionConstraint<I, S>

where S: Clone + Debug + Eq + Hash,

impl<I, S> LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + Eq + Hash,

pub fn without_span(self) -> LeafRegionConstraint<I>

pub fn span(&self) -> S

impl<I, S> LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug,

pub fn is_ambig(&self) -> bool

Trait Implementations

impl<I, S> Clone for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug,

fn clone(&self) -> LeafRegionConstraint<I, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, S> Debug for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug,

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

Formats the value using the given formatter.

impl<I, S> Eq for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + Eq,

impl<I, S, __V> GenericTypeVisitable<__V> for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + GenericTypeVisitable<__V>, Region<I>: GenericTypeVisitable<__V>, Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>: GenericTypeVisitable<__V>, <I as Interner>::Ty: GenericTypeVisitable<__V>,

fn generic_visit_with(&self, __visitor: &mut __V)

impl<I, S> Hash for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + Hash,

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

where __H: Hasher,

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<I, S> PartialEq for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + PartialEq,

fn eq(&self, __other: &LeafRegionConstraint<I, S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<I, S> StableHash for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + StableHash, Region<I>: StableHash, Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>: StableHash, <I as Interner>::Ty: StableHash,

fn stable_hash<__Hcx>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher<SipHasher128>, )

where __Hcx: StableHashCtxt,

impl<I, S> TypeFoldable<I> for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + TypeFoldable<I>, Region<I>: TypeFoldable<I>, Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>: TypeFoldable<I>, <I as Interner>::Ty: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<LeafRegionConstraint<I, S>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

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) -> LeafRegionConstraint<I, S>

where __F: TypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<I, S> TypeVisitable<I> for LeafRegionConstraint<I, S>

where I: Interner, S: Clone + Debug + TypeVisitable<I>, Region<I>: TypeVisitable<I>, Binder<I, (Alias<I, AliasTyKind<I>>, Region<I>)>: TypeVisitable<I>, <I as Interner>::Ty: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

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

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.