infer variance for region parameters

[nikomatsakis]

It occurs to me that we are always treating regions covariantly. This is clearly wrong. We should either (1) not allow regions to appear in in- or contravariant positions within nominal types or (2) allow variance to be declared. I am leaning towards (1) at the moment.

[graydon]

Can you clarify this with an example?

[nikomatsakis]

A bug might look like this:

type T/& = {
    mut f: &uint
};

enum E/& = T;

fn foo(x: &E, v: &uint) {
    x.f = v;
}

fn bar(x: &E) {
    let v = 3u;
    foo(x, &v);
}

The call to foo() will store the region pointer into the mutable record embedded within the enum. bar() makes this call with a region pointer from its own stack. Region subtyping makes the call to foo() type-check.

This is a result of the typing rules for nominal types. Basically we have to know whether the region is used covariantly within the nominal type definition.

[brson]

punting to 0.4

[nikomatsakis]

It turns out that we are always treating region parameters as invariant. This is good, because it is sound, but less flexible than we might like. I've decided it's probably best to infer the variance on regions.

[nikomatsakis]

Here is a test from @bblum that doesn't work because we are always invariant:

struct mutex { i: (); }
struct condvar { lock: &mutex; }

impl &mutex {
    fn lock_cond<U>(blk: fn(condvar) -> U) -> U {
        blk(condvar { lock: self })
    }
}

impl &condvar {
    fn wait() { }
}

fn main() {
    let m = ~(mutex { i: () });
    do m.lock_cond |cond| {
        (&cond).wait();
    }
}