src/test/ui/hr-subtype/hr-subtype.rs

   1 // Targeted tests for the higher-ranked subtyping code.
   2
   3 #![allow(dead_code)]
   4
   5 // revisions: bound_a_vs_bound_a
   6 // revisions: bound_a_vs_bound_b
   7 // revisions: bound_inv_a_vs_bound_inv_b
   8 // revisions: bound_co_a_vs_bound_co_b
   9 // revisions: bound_a_vs_free_x
  10 // revisions: free_x_vs_free_x
  11 // revisions: free_x_vs_free_y
  12 // revisions: free_inv_x_vs_free_inv_y
  13 // revisions: bound_a_b_vs_bound_a
  14 // revisions: bound_co_a_b_vs_bound_co_a
  15 // revisions: bound_contra_a_contra_b_ret_co_a
  16 // revisions: bound_co_a_co_b_ret_contra_a
  17 // revisions: bound_inv_a_b_vs_bound_inv_a
  18 // revisions: bound_a_b_ret_a_vs_bound_a_ret_a
  19
  20 //[bound_a_vs_bound_a] check-pass
  21 //[bound_a_vs_bound_b] check-pass
  22 //[bound_inv_a_vs_bound_inv_b] check-pass
  23 //[bound_co_a_vs_bound_co_b] check-pass
  24 //[free_x_vs_free_x] check-pass
  25 //[bound_co_a_b_vs_bound_co_a] check-pass
  26 //[bound_co_a_co_b_ret_contra_a] check-pass
  27 //[bound_a_b_vs_bound_a] check-pass
  28 //[bound_contra_a_contra_b_ret_co_a] check-pass
  29
  30 fn gimme<T>(_: Option<T>) {}
  31
  32 struct Inv<'a> {
  33     x: *mut &'a u32,
  34 }
  35
  36 struct Co<'a> {
  37     x: fn(&'a u32),
  38 }
  39
  40 struct Contra<'a> {
  41     x: &'a u32,
  42 }
  43
  44 macro_rules! check {
  45     ($rev:ident: ($t1:ty, $t2:ty)) => {
  46         #[cfg($rev)]
  47         fn subtype<'x, 'y: 'x, 'z: 'y>() {
  48             gimme::<$t2>(None::<$t1>);
  49             //[free_inv_x_vs_free_inv_y]~^ ERROR
  50         }
  51
  52         #[cfg($rev)]
  53         fn supertype<'x, 'y: 'x, 'z: 'y>() {
  54             gimme::<$t1>(None::<$t2>);
  55             //[bound_a_vs_free_x]~^ ERROR
  56             //[free_x_vs_free_y]~^^ ERROR
  57             //[bound_inv_a_b_vs_bound_inv_a]~^^^ ERROR
  58             //[bound_inv_a_b_vs_bound_inv_a]~| ERROR
  59             //[bound_a_b_ret_a_vs_bound_a_ret_a]~^^^^^ ERROR
  60             //[free_inv_x_vs_free_inv_y]~^^^^^^ ERROR
  61         }
  62     };
  63 }
  64
  65 // If both have bound regions, they are equivalent, regardless of
  66 // variant.
  67 check! { bound_a_vs_bound_a: (for<'a> fn(&'a u32),
  68 for<'a> fn(&'a u32)) }
  69 check! { bound_a_vs_bound_b: (for<'a> fn(&'a u32),
  70 for<'b> fn(&'b u32)) }
  71 check! { bound_inv_a_vs_bound_inv_b: (for<'a> fn(Inv<'a>),
  72 for<'b> fn(Inv<'b>)) }
  73 check! { bound_co_a_vs_bound_co_b: (for<'a> fn(Co<'a>),
  74 for<'b> fn(Co<'b>)) }
  75
  76 // Bound is a subtype of free.
  77 check! { bound_a_vs_free_x: (for<'a> fn(&'a u32),
  78 fn(&'x u32)) }
  79
  80 // Two free regions are relatable if subtyping holds.
  81 check! { free_x_vs_free_x: (fn(&'x u32),
  82 fn(&'x u32)) }
  83 check! { free_x_vs_free_y: (fn(&'x u32),
  84 fn(&'y u32)) }
  85 check! { free_inv_x_vs_free_inv_y: (fn(Inv<'x>),
  86 fn(Inv<'y>)) }
  87
  88 // Somewhat surprisingly, a fn taking two distinct bound lifetimes and
  89 // a fn taking one bound lifetime can be interchangeable, but only if
  90 // we are co- or contra-variant with respect to both lifetimes.
  91 //
  92 // The reason is:
  93 // - if we are covariant, then 'a and 'b can be set to the call-site
  94 //   intersection;
  95 // - if we are contravariant, then 'a can be inferred to 'static.
  96 check! { bound_a_b_vs_bound_a: (for<'a,'b> fn(&'a u32, &'b u32),
  97 for<'a>    fn(&'a u32, &'a u32)) }
  98 check! { bound_co_a_b_vs_bound_co_a: (for<'a,'b> fn(Co<'a>, Co<'b>),
  99 for<'a>    fn(Co<'a>, Co<'a>)) }
 100 check! { bound_contra_a_contra_b_ret_co_a: (for<'a,'b> fn(Contra<'a>, Contra<'b>) -> Co<'a>,
 101 for<'a>    fn(Contra<'a>, Contra<'a>) -> Co<'a>) }
 102 check! { bound_co_a_co_b_ret_contra_a: (for<'a,'b> fn(Co<'a>, Co<'b>) -> Contra<'a>,
 103 for<'a>    fn(Co<'a>, Co<'a>) -> Contra<'a>) }
 104
 105 // If we make those lifetimes invariant, then the two types are not interchangeable.
 106 check! { bound_inv_a_b_vs_bound_inv_a: (for<'a,'b> fn(Inv<'a>, Inv<'b>),
 107 for<'a>    fn(Inv<'a>, Inv<'a>)) }
 108 check! { bound_a_b_ret_a_vs_bound_a_ret_a: (for<'a,'b> fn(&'a u32, &'b u32) -> &'a u32,
 109 for<'a>    fn(&'a u32, &'a u32) -> &'a u32) }
 110
 111 fn main() {}