Struct Assumptions 

pub struct Assumptions<I: Interner> {
    pub type_outlives: Vec<Binder<I, OutlivesClause<I, I::Ty>>>,
    pub region_outlives: TransitiveRelation<Region<I>>,
    pub inverse_region_outlives: TransitiveRelation<Region<I>>,
}

Fields

type_outlives: Vec<Binder<I, OutlivesClause<I, I::Ty>>>

region_outlives: TransitiveRelation<Region<I>>

Known 'a: 'b assumptions, stored as an edge from the outliving region to the outlived one, i.e. an edge ('a, 'b) means 'a: 'b. Constructors expect a relation with this direction, see regions_outlived_by and regions_outliving for how it is consumed.

inverse_region_outlives: TransitiveRelation<Region<I>>

Implementations

impl<I: Interner> Assumptions<I>

pub fn empty() -> Self

pub fn new( infcx: &impl InferCtxtLike<Interner = I>, clauses: impl IntoIterator<Item = I::Clause>, region_outlives: TransitiveRelation<Region<I>>, universe: UniverseIndex, ) -> Self

Builds assumptions from clauses, elaborating them and keeping the outlives ones.

Callers hand us their clauses straight from the environment, so we have to elaborate here to get at the implied outlives bounds:

• a Ty: 'a clause tells us that every region component of Ty outlives 'a, e.g. &'b u8: 'a implies 'b: 'a. Without it we’d fail to prove 'b: 'a when leaving the binder these assumptions belong to.
• it also gives us the components as type outlives, e.g. Vec<T>: 'a implies T: 'a, which we need for placeholder and alias outlives.
• trait clauses imply their supertraits, so T: Bound<'a> where trait Bound<'c>: 'c gives us T: 'a. This is why we take clauses rather than just the outlives ones: filtering down to outlives before elaborating would throw those away.

Only the clauses whose max universe is exactly universe are kept, which is what the solver wants when computing the assumptions of a single binder. This happens after elaboration on purpose, so a clause whose regions live in more than one universe still contributes its implied bounds to each of them: (&'b u8, &'c u8): 'a gives us 'c: 'a in 'cs universe even though the clause itself is in 'bs.

Use Assumptions::new_unelaborated when the caller needs the assumptions to be exactly the clauses it passed in.

pub fn new_unelaborated( type_outlives: Vec<Binder<I, OutlivesClause<I, I::Ty>>>, region_outlives: TransitiveRelation<Region<I>>, ) -> Self

Builds assumptions from exactly the given clauses, see Assumptions::new for when the clauses should get elaborated instead.

Trait Implementations

impl<I> Clone for Assumptions<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 Assumptions<I>

where I: Interner,

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

Formats the value using the given formatter.

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: 280 bytes