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

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