Enum RegionConstraint 

pub enum RegionConstraint<I: Interner> {
    Ambiguity,
    RegionOutlives(I::Region, I::Region),
    AliasTyOutlivesViaEnv(Binder<I, (AliasTy<I>, I::Region)>),
    PlaceholderTyOutlives(I::Ty, I::Region),
    And(Box<[RegionConstraint<I>]>),
    Or(Box<[RegionConstraint<I>]>),
}

Variants

Ambiguity

RegionOutlives(I::Region, I::Region)

AliasTyOutlivesViaEnv(Binder<I, (AliasTy<I>, I::Region)>)

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::Ty, I::Region)

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.

And(Box<[RegionConstraint<I>]>)

Or(Box<[RegionConstraint<I>]>)

Implementations

impl<I: Interner> RegionConstraint<I>

pub fn new_true() -> Self

pub fn is_true(&self) -> bool

pub fn new_false() -> Self

pub fn is_false(&self) -> bool

pub fn is_or(&self) -> bool

pub fn unwrap_or(self) -> Box<[RegionConstraint<I>]>

pub fn unwrap_and(self) -> Box<[RegionConstraint<I>]>

pub fn is_and(&self) -> bool

pub fn is_ambig(&self) -> bool

pub fn and(self, other: RegionConstraint<I>) -> RegionConstraint<I>

pub fn canonical_form(self) -> Self

Converts the region constraint into an ORs of ANDs of “leaf” constraints. Where a leaf constraint is a non-or/and constraint.

fn is_leaf_constraint(&self) -> bool

fn is_canonical_and(&self) -> bool

pub fn is_canonical_form(&self) -> bool

Trait Implementations

impl<I> Clone for RegionConstraint<I>

where I: Interner,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for RegionConstraint<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I: Interner> Default for RegionConstraint<I>

fn default() -> Self

Returns the “default value” for a type.

impl<I> Hash for RegionConstraint<I>

where I: Interner,

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<I> PartialEq for RegionConstraint<I>

where I: Interner,

fn eq(&self, __other: &Self) -> 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<I: Interner> StableHash for RegionConstraint<I>

where I::Region: StableHash, I::Ty: StableHash, I::GenericArgs: StableHash, I::TraitAssocTyId: StableHash, I::InherentAssocTyId: StableHash, I::OpaqueTyId: StableHash, I::FreeTyAliasId: StableHash, I::BoundVarKinds: StableHash,

Available on crate feature nightly only.

fn stable_hash<CTX: StableHashCtxt>( &self, hcx: &mut CTX, hasher: &mut StableHasher, )

impl<I: Interner> TypeFoldable<I> for RegionConstraint<I>

fn try_fold_with<F: FallibleTypeFolder<I>>( self, f: &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: TypeFolder<I>>(self, f: &mut F) -> Self

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

impl<I: Interner> TypeVisitable<I> for RegionConstraint<I>

fn visit_with<F: TypeVisitor<I>>(&self, f: &mut F) -> F::Result

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.