wildcard-tyvars.rs

#![feature(nll, type_ascription)]

#![allow(dead_code, unused_mut)]
type Pair<T> = (T, T);

pub fn swap<T>(_: &mut T, _: &mut T) { unimplemented!() }

fn static_to_a_to_static_through_tyvar<'a>(_x: &'a u32, s: &'static u32) -> &'static u32 {
    let local = 3;
    let (mut y, mut _z): Pair<&u32> = (s, &local);
    // let (mut y, mut _z): Pair<&u32> = (s, &local);

    // I should be able to add the call to `swap` below at whim based
    // on the above type annotation, which should coerce both `s` and
    // `local` to `&'1 u32` (and then `'1` should be inferred to be a
    // function-local region).
    //
    // Furthermore, since I should be able to add the below call to
    // `swap`, it should also be legal for me to include the `unsafe`
    // code block given below, which has the same end effect of
    // swapping the two values. (And that *definitely* will break the
    // return type.)

    // swap(&mut y, &mut _z);

    #[cfg(not_now)]
    unsafe {
        let p_y = &mut y as *mut _;
        let p_z = &mut _z as *mut _;
        let t = *p_y;
        *p_y = *p_z;
        *p_z = t;
    }

    // Likewise, the same rules that caused `y` and `_z` to have the
    // same `&'1 u32` type should likewise cause a borrow-check error
    // at this attempt to return a `&'static u32`.
    y
}

fn main() {
    static_to_a_to_static_through_tyvar(&3, &4);
}