Struct VerifyIfEq 

pub struct VerifyIfEq<'db> {
    pub ty: Ty<'db>,
    pub bound: Region<'db>,
}

This is a “conditional bound” that checks the result of inference and supplies a bound if it ended up being relevant. It’s used in situations like this:

fn foo<'a, 'b, T: SomeTrait<'a>>
where
   <T as SomeTrait<'a>>::Item: 'b

If we have an obligation like <T as SomeTrait<'?x>>::Item: 'c, then we don’t know yet whether it suffices to show that 'b: 'c. If '?x winds up being equal to 'a, then the where-clauses on function applies, and in that case we can show 'b: 'c. But if '?x winds up being something else, the bound isn’t relevant.

In the VerifyBound, this struct is enclosed in Binder to account for cases like

where for<'a> <T as SomeTrait<'a>::Item: 'a

The idea is that we have to find some instantiation of 'a that can make <T as SomeTrait<'a>>::Item equal to the final value of G, the generic we are checking.

fn(min) -> bool {
    exists<'a> {
        if G == K {
            B(min)
        } else {
            false
        }
    }
}

Fields

ty: Ty<'db>

Type which must match the generic G

bound: Region<'db>

Bound that applies if ty is equal.

Trait Implementations

impl<'db> Clone for VerifyIfEq<'db>

fn clone(&self) -> VerifyIfEq<'db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Debug for VerifyIfEq<'db>

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

Formats the value using the given formatter.