Applying Member Constraints: Lower and Upper Bounds

`'a`, because there is no need for it too -- we have a constraint that `'a: '0`, but that just puts a "cap" on how *large* `'0` can grow to become. Since we compute the *minimal* value that we can, we are happy to leave `'0` as being just equal to the liveness set. This is where member constraints come in. ## Choices are always lifetime parameters At present, the "choice" regions from a member constraint are always lifetime parameters from the current function. As of  October 2021, this falls out from the placement of impl Trait, though in the future it may not be the case. We take some advantage of this fact, as it simplifies the current code. In particular, we don't have to consider a case like `'0 member of ['1, 'static]`, in which the value of both `'0` and `'1` are being inferred and hence changing. See [rust-lang/rust#61773][#61773] for more information. ## Applying member constraints Member constraints are a bit more complex than other forms of constraints. This is because they have a "or" quality to them -- that is, they describe multiple choices that we must select from. E.g., in our example constraint `'0 member of ['a, 'b, 'static]`, it might be that `'0` is equal to `'a`, `'b`, *or* `'static`. How can we pick the correct one? What we currently do is to look for a *minimal choice* -- if we find one, then we will grow `'0` to be equal to that minimal choice. To find that minimal choice, we take two factors into consideration: lower and upper bounds. ### Lower bounds The *lower bounds* are those lifetimes that `'0` *must outlive* -- i.e., that `'0` must be larger than. In fact, when it comes time to apply member constraints, we've already *computed* the lower bounds of `'0` because we computed its minimal value (or at least, the lower bounds considering everything but member constraints). Let `LB` be the current value of `'0`. We know then that `'0: LB` must hold, whatever the final value of `'0` is. Therefore, we can rule out any choice `'choice` where `'choice: LB` does not hold. Unfortunately, in our example, this is not very helpful. The lower bound for `'0` will just be the liveness set `{L}`, and we know that all the lifetime parameters outlive that set. So we are left with the same set of choices here. (But in other examples, particularly those with different variance, lower bound constraints may be relevant.) ### Upper bounds The *upper bounds* are those lifetimes that *must outlive* `'0` -- i.e., that `'0` must be *smaller* than. In our example, this would be `'a`, because we have the constraint that `'a: '0`. In more complex

Member constraints are applied by finding a minimal choice for the constrained region. This involves considering lower and upper bounds. Lower bounds are lifetimes that the region must outlive; choices that don't outlive these bounds are discarded. Upper bounds are lifetimes that must outlive the region; a minimal choice is one that is a subtype of all upper bounds.