tests/ui/traits/trait-upcasting/lifetime.rs

   1 // run-pass
   2
   3 #![feature(trait_upcasting)]
   4
   5 trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
   6     fn a(&self) -> i32 {
   7         10
   8     }
   9
  10     fn z(&self) -> i32 {
  11         11
  12     }
  13
  14     fn y(&self) -> i32 {
  15         12
  16     }
  17 }
  18
  19 trait Bar: Foo {
  20     fn b(&self) -> i32 {
  21         20
  22     }
  23
  24     fn w(&self) -> i32 {
  25         21
  26     }
  27 }
  28
  29 trait Baz: Bar {
  30     fn c(&self) -> i32 {
  31         30
  32     }
  33 }
  34
  35 impl Foo for i32 {
  36     fn a(&self) -> i32 {
  37         100
  38     }
  39 }
  40
  41 impl Bar for i32 {
  42     fn b(&self) -> i32 {
  43         200
  44     }
  45 }
  46
  47 impl Baz for i32 {
  48     fn c(&self) -> i32 {
  49         300
  50     }
  51 }
  52
  53 // Note: upcast lifetime means a shorter lifetime.
  54 fn upcast_baz<'a: 'b, 'b, T>(v: Box<dyn Baz + 'a>, _l: &'b T) -> Box<dyn Baz + 'b> {
  55     v
  56 }
  57 fn upcast_bar<'a: 'b, 'b, T>(v: Box<dyn Bar + 'a>, _l: &'b T) -> Box<dyn Bar + 'b> {
  58     v
  59 }
  60 fn upcast_foo<'a: 'b, 'b, T>(v: Box<dyn Foo + 'a>, _l: &'b T) -> Box<dyn Foo + 'b> {
  61     v
  62 }
  63
  64 fn main() {
  65     let v = Box::new(1);
  66     let l = &(); // dummy lifetime (shorter than `baz`)
  67
  68     let baz: Box<dyn Baz> = v.clone();
  69     let u = upcast_baz(baz, &l);
  70     assert_eq!(*u, 1);
  71     assert_eq!(u.a(), 100);
  72     assert_eq!(u.b(), 200);
  73     assert_eq!(u.c(), 300);
  74
  75     let baz: Box<dyn Baz> = v.clone();
  76     let bar: Box<dyn Bar> = baz;
  77     let u = upcast_bar(bar, &l);
  78     assert_eq!(*u, 1);
  79     assert_eq!(u.a(), 100);
  80     assert_eq!(u.b(), 200);
  81
  82     let baz: Box<dyn Baz> = v.clone();
  83     let foo: Box<dyn Foo> = baz;
  84     let u = upcast_foo(foo, &l);
  85     assert_eq!(*u, 1);
  86     assert_eq!(u.a(), 100);
  87
  88     let baz: Box<dyn Baz> = v.clone();
  89     let bar: Box<dyn Bar> = baz;
  90     let foo: Box<dyn Foo> = bar;
  91     let u = upcast_foo(foo, &l);
  92     assert_eq!(*u, 1);
  93     assert_eq!(u.a(), 100);
  94 }