src/test/ui/traits/trait-upcasting/struct.rs

   1 // run-pass
   2
   3 #![feature(trait_upcasting)]
   4
   5 use std::rc::Rc;
   6 use std::sync::Arc;
   7
   8 trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
   9     fn a(&self) -> i32 {
  10         10
  11     }
  12
  13     fn z(&self) -> i32 {
  14         11
  15     }
  16
  17     fn y(&self) -> i32 {
  18         12
  19     }
  20 }
  21
  22 trait Bar: Foo {
  23     fn b(&self) -> i32 {
  24         20
  25     }
  26
  27     fn w(&self) -> i32 {
  28         21
  29     }
  30 }
  31
  32 trait Baz: Bar {
  33     fn c(&self) -> i32 {
  34         30
  35     }
  36 }
  37
  38 impl Foo for i32 {
  39     fn a(&self) -> i32 {
  40         100
  41     }
  42 }
  43
  44 impl Bar for i32 {
  45     fn b(&self) -> i32 {
  46         200
  47     }
  48 }
  49
  50 impl Baz for i32 {
  51     fn c(&self) -> i32 {
  52         300
  53     }
  54 }
  55
  56 fn test_box() {
  57     let v = Box::new(1);
  58
  59     let baz: Box<dyn Baz> = v.clone();
  60     assert_eq!(*baz, 1);
  61     assert_eq!(baz.a(), 100);
  62     assert_eq!(baz.b(), 200);
  63     assert_eq!(baz.c(), 300);
  64     assert_eq!(baz.z(), 11);
  65     assert_eq!(baz.y(), 12);
  66     assert_eq!(baz.w(), 21);
  67
  68     let baz: Box<dyn Baz> = v.clone();
  69     let bar: Box<dyn Bar> = baz;
  70     assert_eq!(*bar, 1);
  71     assert_eq!(bar.a(), 100);
  72     assert_eq!(bar.b(), 200);
  73     assert_eq!(bar.z(), 11);
  74     assert_eq!(bar.y(), 12);
  75     assert_eq!(bar.w(), 21);
  76
  77     let baz: Box<dyn Baz> = v.clone();
  78     let foo: Box<dyn Foo> = baz;
  79     assert_eq!(*foo, 1);
  80     assert_eq!(foo.a(), 100);
  81     assert_eq!(foo.z(), 11);
  82     assert_eq!(foo.y(), 12);
  83
  84     let baz: Box<dyn Baz> = v.clone();
  85     let bar: Box<dyn Bar> = baz;
  86     let foo: Box<dyn Foo> = bar;
  87     assert_eq!(*foo, 1);
  88     assert_eq!(foo.a(), 100);
  89     assert_eq!(foo.z(), 11);
  90     assert_eq!(foo.y(), 12);
  91 }
  92
  93 fn test_rc() {
  94     let v = Rc::new(1);
  95
  96     let baz: Rc<dyn Baz> = v.clone();
  97     assert_eq!(*baz, 1);
  98     assert_eq!(baz.a(), 100);
  99     assert_eq!(baz.b(), 200);
 100     assert_eq!(baz.c(), 300);
 101     assert_eq!(baz.z(), 11);
 102     assert_eq!(baz.y(), 12);
 103     assert_eq!(baz.w(), 21);
 104
 105     let baz: Rc<dyn Baz> = v.clone();
 106     let bar: Rc<dyn Bar> = baz;
 107     assert_eq!(*bar, 1);
 108     assert_eq!(bar.a(), 100);
 109     assert_eq!(bar.b(), 200);
 110     assert_eq!(bar.z(), 11);
 111     assert_eq!(bar.y(), 12);
 112     assert_eq!(bar.w(), 21);
 113
 114     let baz: Rc<dyn Baz> = v.clone();
 115     let foo: Rc<dyn Foo> = baz;
 116     assert_eq!(*foo, 1);
 117     assert_eq!(foo.a(), 100);
 118     assert_eq!(foo.z(), 11);
 119     assert_eq!(foo.y(), 12);
 120
 121     let baz: Rc<dyn Baz> = v.clone();
 122     let bar: Rc<dyn Bar> = baz;
 123     let foo: Rc<dyn Foo> = bar;
 124     assert_eq!(*foo, 1);
 125     assert_eq!(foo.a(), 100);
 126     assert_eq!(foo.z(), 11);
 127     assert_eq!(foo.y(), 12);
 128     assert_eq!(foo.z(), 11);
 129     assert_eq!(foo.y(), 12);
 130 }
 131
 132 fn test_arc() {
 133     let v = Arc::new(1);
 134
 135     let baz: Arc<dyn Baz> = v.clone();
 136     assert_eq!(*baz, 1);
 137     assert_eq!(baz.a(), 100);
 138     assert_eq!(baz.b(), 200);
 139     assert_eq!(baz.c(), 300);
 140     assert_eq!(baz.z(), 11);
 141     assert_eq!(baz.y(), 12);
 142     assert_eq!(baz.w(), 21);
 143
 144     let baz: Arc<dyn Baz> = v.clone();
 145     let bar: Arc<dyn Bar> = baz;
 146     assert_eq!(*bar, 1);
 147     assert_eq!(bar.a(), 100);
 148     assert_eq!(bar.b(), 200);
 149     assert_eq!(bar.z(), 11);
 150     assert_eq!(bar.y(), 12);
 151     assert_eq!(bar.w(), 21);
 152
 153     let baz: Arc<dyn Baz> = v.clone();
 154     let foo: Arc<dyn Foo> = baz;
 155     assert_eq!(*foo, 1);
 156     assert_eq!(foo.a(), 100);
 157     assert_eq!(foo.z(), 11);
 158     assert_eq!(foo.y(), 12);
 159
 160     let baz: Arc<dyn Baz> = v.clone();
 161     let bar: Arc<dyn Bar> = baz;
 162     let foo: Arc<dyn Foo> = bar;
 163     assert_eq!(*foo, 1);
 164     assert_eq!(foo.a(), 100);
 165     assert_eq!(foo.z(), 11);
 166     assert_eq!(foo.y(), 12);
 167 }
 168
 169 fn main() {
 170     test_box();
 171     test_rc();
 172     test_arc();
 173 }