Extending Universal Regions Check and Examples

already in other contexts). Moreover, since `'static` is in the root universe U0, we know that all variables can see it – so basically if we find that `value(V2)` contains `placeholder(x)` for some universe `x` that `V1` can't see, then we force `V1` to `'static`. ## Extending the "universal regions" check After all constraints have been propagated, the NLL region inference has one final check, where it goes over the values that wound up being computed for each universal region and checks that they did not get 'too large'. In our case, we will go through each placeholder region and check that it contains *only* the `placeholder(u)` element it is known to outlive. (Later, we might be able to know that there are relationships between two placeholder regions and take those into account, as we do for universal regions from the fn signature.) Put another way, the "universal regions" check can be considered to be checking constraints like: ```text {placeholder(1)}: V1 ``` where `{placeholder(1)}` is like a constant set, and V1 is the variable we made to represent the `!1` region. ## Back to our example OK, so far so good. Now let's walk through what would happen with our first example: ```text fn(&'static u32) <: fn(&'!1 u32) @ P // this point P is not imp't here ``` The region inference engine will create a region element domain like this: ```text { CFG; end('static); placeholder(1) } --- ------------ ------- from the universe `!1` | 'static is always in scope all points in the CFG; not especially relevant here ``` It will always create two universal variables, one representing `'static` and one representing `'!1`. Let's call them Vs and V1. They will have initial values like so: ```text Vs = { CFG; end('static) } // it is in U0, so can't name anything else V1 = { placeholder(1) } ``` From the subtyping constraint above, we would have an outlives constraint like ```text '!1: 'static @ P ``` To process this, we would grow the value of V1 to include all of Vs: ```text Vs = { CFG; end('static) } V1 = { CFG; end('static), placeholder(1) } ``` At that point, constraint propagation is complete, because all the outlives relationships are satisfied. Then we would go to the "check universal regions" portion of the code, which would test that no universal region grew too large. In this case, `V1` *did* grow too large – it is not known to outlive `end('static)`, nor any of the CFG – so we would report an error. ## Another example What about this subtyping relationship? ```text for<'a> fn(&'a u32, &'a u32) <: for<'b, 'c> fn(&'b u32, &'c u32) ``` Here we would replace the bound region in the supertype with a placeholder, as before, yielding: ```text for<'a> fn(&'a u32, &'a u32) <: fn(&'!1 u32, &'!2 u32) ``` then we instantiate the variable on the left-hand side with an existential in universe U2, yielding the following (`?n` is a notation for an existential variable):

This section elaborates on extending the "universal regions" check in Rust's NLL region inference. It explains how the check verifies that universal regions (like placeholder regions) haven't grown too large, ensuring they only contain the elements they're known to outlive. Two examples are provided. The first demonstrates a scenario where a lifetime subtyping relationship causes a universal region to grow too large, triggering an error. The second illustrates a more complex example involving higher-ranked types and placeholder regions, where the bound regions are replaced with placeholders. An existential variable in universe U2 is then used to instantiate the variable on the left-hand side.