tests/ui/regions/regions-early-bound-trait-param.rs

   1 // run-pass
   2 // Tests that you can use an early-bound lifetime parameter as
   3 // on of the generic parameters in a trait.
   4
   5 trait Trait<'a> {
   6     fn long(&'a self) -> isize;
   7     fn short<'b>(&'b self) -> isize;
   8 }
   9
  10 fn poly_invoke<'c, T: Trait<'c>>(x: &'c T) -> (isize, isize) {
  11     let l = x.long();
  12     let s = x.short();
  13     (l,s)
  14 }
  15
  16 fn object_invoke1<'d>(x: &'d dyn Trait<'d>) -> (isize, isize) {
  17     let l = x.long();
  18     let s = x.short();
  19     (l,s)
  20 }
  21
  22 struct Struct1<'e> {
  23     f: &'e (dyn Trait<'e>+'e)
  24 }
  25
  26 fn field_invoke1<'f, 'g>(x: &'g Struct1<'f>) -> (isize,isize) {
  27     let l = x.f.long();
  28     let s = x.f.short();
  29     (l,s)
  30 }
  31
  32 struct Struct2<'h, 'i:'h> {
  33     f: &'h (dyn Trait<'i>+'h)
  34 }
  35
  36 fn object_invoke2<'j, 'k>(x: &'k dyn Trait<'j>) -> isize {
  37     x.short()
  38 }
  39
  40 fn field_invoke2<'l, 'm, 'n>(x: &'n Struct2<'l,'m>) -> isize {
  41     x.f.short()
  42 }
  43
  44 trait MakerTrait {
  45     fn mk() -> Self;
  46 }
  47
  48 fn make_val<T:MakerTrait>() -> T {
  49     MakerTrait::mk()
  50 }
  51
  52 trait RefMakerTrait<'q> {
  53     fn mk(_: Self) -> &'q Self;
  54 }
  55
  56 fn make_ref<'r, T:RefMakerTrait<'r>>(t:T) -> &'r T {
  57     RefMakerTrait::mk(t)
  58 }
  59
  60 impl<'s> Trait<'s> for (isize,isize) {
  61     fn long(&'s self) -> isize {
  62         let &(x,_) = self;
  63         x
  64     }
  65     fn short<'b>(&'b self) -> isize {
  66         let &(_,y) = self;
  67         y
  68     }
  69 }
  70
  71 impl<'t> MakerTrait for Box<dyn Trait<'t>+'static> {
  72     fn mk() -> Box<dyn Trait<'t>+'static> {
  73         let tup: Box<(isize, isize)> = Box::new((4,5));
  74         tup as Box<dyn Trait>
  75     }
  76 }
  77
  78 enum List<'l> {
  79     Cons(isize, &'l List<'l>),
  80     Null
  81 }
  82
  83 impl<'l> List<'l> {
  84     fn car<'m>(&'m self) -> isize {
  85         match self {
  86             &List::Cons(car, _) => car,
  87             &List::Null => panic!(),
  88         }
  89     }
  90     fn cdr<'n>(&'n self) -> &'l List<'l> {
  91         match self {
  92             &List::Cons(_, cdr) => cdr,
  93             &List::Null => panic!(),
  94         }
  95     }
  96 }
  97
  98 impl<'t> RefMakerTrait<'t> for List<'t> {
  99     fn mk(l:List<'t>) -> &'t List<'t> {
 100         l.cdr()
 101     }
 102 }
 103
 104 pub fn main() {
 105     let t = (2,3);
 106     let o = &t as &dyn Trait;
 107     let s1 = Struct1 { f: o };
 108     let s2 = Struct2 { f: o };
 109     assert_eq!(poly_invoke(&t), (2,3));
 110     assert_eq!(object_invoke1(&t), (2,3));
 111     assert_eq!(field_invoke1(&s1), (2,3));
 112     assert_eq!(object_invoke2(&t), 3);
 113     assert_eq!(field_invoke2(&s2), 3);
 114
 115     let m : Box<dyn Trait> = make_val();
 116     // assert_eq!(object_invoke1(&*m), (4,5));
 117     //            ~~~~~~~~~~~~~~~~~~~
 118     // this call yields a compilation error; see ui/span/dropck-object-cycle.rs
 119     // for details.
 120     assert_eq!(object_invoke2(&*m), 5);
 121
 122     // The RefMakerTrait above is pretty strange (i.e., it is strange
 123     // to consume a value of type T and return a &T).  Easiest thing
 124     // that came to my mind: consume a cell of a linked list and
 125     // return a reference to the list it points to.
 126     let l0 = List::Null;
 127     let l1 = List::Cons(1, &l0);
 128     let l2 = List::Cons(2, &l1);
 129     let rl1 = &l1;
 130     let r  = make_ref(l2);
 131     assert_eq!(rl1.car(), r.car());
 132 }