tests/ui/associated-type-bounds/struct-bounds.rs

   1 // run-pass
   2
   3 #![allow(unused)]
   4 #![feature(associated_type_bounds)]
   5
   6 trait Tr1 { type As1; }
   7 trait Tr2 { type As2; }
   8 trait Tr3 {}
   9 trait Tr4<'a> { type As4; }
  10 trait Tr5 { type As5; }
  11
  12 impl Tr1 for &str { type As1 = bool; }
  13 impl Tr2 for bool { type As2 = u8; }
  14 impl Tr3 for u8 {}
  15 impl Tr1 for () { type As1 = (usize,); }
  16 impl<'a> Tr4<'a> for (usize,) { type As4 = u8; }
  17 impl Tr5 for bool { type As5 = u16; }
  18
  19 struct St1<T: Tr1<As1: Tr2>> {
  20     outest: T,
  21     outer: T::As1,
  22     inner: <T::As1 as Tr2>::As2,
  23 }
  24
  25 fn unwrap_1_st1<T: Tr1<As1: Tr2>>(x: St1<T>) -> (T, T::As1, <T::As1 as Tr2>::As2) {
  26     (x.outest, x.outer, x.inner)
  27 }
  28
  29 fn unwrap_2_st1<T>(x: St1<T>) -> (T, T::As1, <T::As1 as Tr2>::As2)
  30 where
  31     T: Tr1,
  32     T::As1: Tr2,
  33 {
  34     unwrap_1_st1(x)
  35 }
  36
  37 struct St2<T: Tr1<As1: Tr2<As2: Tr3>>> {
  38     outest: T,
  39     outer: T::As1,
  40     inner: <T::As1 as Tr2>::As2,
  41 }
  42
  43 struct St3<T: Tr1<As1: 'static>> {
  44     outest: T,
  45     outer: &'static T::As1,
  46 }
  47
  48 struct St4<'x1, 'x2, T: Tr1<As1: for<'l> Tr4<'l>>> {
  49     f1: &'x1 <T::As1 as Tr4<'x1>>::As4,
  50     f2: &'x2 <T::As1 as Tr4<'x2>>::As4,
  51 }
  52
  53 struct St5<'x1, 'x2, T: Tr1<As1: for<'l> Tr4<'l, As4: Copy>>> {
  54     f1: &'x1 <T::As1 as Tr4<'x1>>::As4,
  55     f2: &'x2 <T::As1 as Tr4<'x2>>::As4,
  56 }
  57
  58 struct St6<T>
  59 where
  60     T: Tr1<As1: Tr2 + 'static + Tr5>,
  61 {
  62     f0: T,
  63     f1: <T::As1 as Tr2>::As2,
  64     f2: &'static T::As1,
  65     f3: <T::As1 as Tr5>::As5,
  66 }
  67
  68 struct St7<'a, 'b, T> // `<T::As1 as Tr2>::As2: 'a` is implied.
  69 where
  70     T: Tr1<As1: Tr2>,
  71 {
  72     f0: &'a T,
  73     f1: &'b <T::As1 as Tr2>::As2,
  74 }
  75
  76 fn _use_st7<'a, 'b, T>(x: St7<'a, 'b, T>)
  77 where
  78     T: Tr1,
  79     T::As1: Tr2,
  80 {
  81     let _: &'a T = &x.f0;
  82 }
  83
  84 struct StSelf<T> where Self: Tr1<As1: Tr2> {
  85     f2: <<Self as Tr1>::As1 as Tr2>::As2,
  86 }
  87
  88 impl Tr1 for StSelf<&'static str> { type As1 = bool; }
  89
  90 fn main() {
  91     let st1 = St1 { outest: "foo", outer: true, inner: 42u8 };
  92     assert_eq!(("foo", true, 42), unwrap_1_st1(st1));
  93
  94     let _ = St2 { outest: "foo", outer: true, inner: 42u8 };
  95
  96     let _ = St3 { outest: "foo", outer: &true };
  97
  98     let f1 = (1,);
  99     let f2 = (2,);
 100     let st4 = St4::<()> { f1: &f1.0, f2: &f2.0, };
 101     assert_eq!((&1, &2), (st4.f1, st4.f2));
 102
 103     // FIXME: requires lazy normalization.
 104     /*
 105     let f1 = (1,);
 106     let f2 = (2,);
 107     let st5 = St5::<()> { f1: &f1.0, f2: &f2.0, };
 108     assert_eq!((&1, &2), (st5.f1, st5.f2));
 109     */
 110
 111     let st6 = St6 { f0: "bar", f1: 24u8, f2: &true, f3: 12u16, };
 112     assert_eq!(("bar", 24, &true, 12), (st6.f0, st6.f1, st6.f2, st6.f3));
 113
 114     let stself = StSelf::<&'static str> { f2: 42u8 };
 115     assert_eq!(stself.f2, 42u8);
 116 }