tests/ui/dynamically-sized-types/dst-raw.rs

   1 // run-pass
   2 // Test DST raw pointers
   3
   4
   5 #![feature(unsized_tuple_coercion)]
   6
   7 trait Trait {
   8     fn foo(&self) -> isize;
   9 }
  10
  11 struct A {
  12     f: isize
  13 }
  14 impl Trait for A {
  15     fn foo(&self) -> isize {
  16         self.f
  17     }
  18 }
  19
  20 struct Foo<T: ?Sized> {
  21     f: T
  22 }
  23
  24 pub fn main() {
  25     // raw trait object
  26     let x = A { f: 42 };
  27     let z: *const dyn Trait = &x;
  28     let r = unsafe {
  29         (&*z).foo()
  30     };
  31     assert_eq!(r, 42);
  32
  33     // raw DST struct
  34     let p = Foo {f: A { f: 42 }};
  35     let o: *const Foo<dyn Trait> = &p;
  36     let r = unsafe {
  37         (&*o).f.foo()
  38     };
  39     assert_eq!(r, 42);
  40
  41     // raw DST tuple
  42     let p = (A { f: 42 },);
  43     let o: *const (dyn Trait,) = &p;
  44     let r = unsafe {
  45         (&*o).0.foo()
  46     };
  47     assert_eq!(r, 42);
  48
  49     // raw slice
  50     let a: *const [_] = &[1, 2, 3];
  51     unsafe {
  52         let b = (*a)[2];
  53         assert_eq!(b, 3);
  54         let len = (*a).len();
  55         assert_eq!(len, 3);
  56     }
  57
  58     // raw slice with explicit cast
  59     let a = &[1, 2, 3] as *const [i32];
  60     unsafe {
  61         let b = (*a)[2];
  62         assert_eq!(b, 3);
  63         let len = (*a).len();
  64         assert_eq!(len, 3);
  65     }
  66
  67     // raw DST struct with slice
  68     let c: *const Foo<[_]> = &Foo {f: [1, 2, 3]};
  69     unsafe {
  70         let b = (&*c).f[0];
  71         assert_eq!(b, 1);
  72         let len = (&*c).f.len();
  73         assert_eq!(len, 3);
  74     }
  75
  76     // raw DST tuple with slice
  77     let c: *const ([_],) = &([1, 2, 3],);
  78     unsafe {
  79         let b = (&*c).0[0];
  80         assert_eq!(b, 1);
  81         let len = (&*c).0.len();
  82         assert_eq!(len, 3);
  83     }
  84
  85     // all of the above with *mut
  86     let mut x = A { f: 42 };
  87     let z: *mut dyn Trait = &mut x;
  88     let r = unsafe {
  89         (&*z).foo()
  90     };
  91     assert_eq!(r, 42);
  92
  93     let mut p = Foo {f: A { f: 42 }};
  94     let o: *mut Foo<dyn Trait> = &mut p;
  95     let r = unsafe {
  96         (&*o).f.foo()
  97     };
  98     assert_eq!(r, 42);
  99
 100     let mut p = (A { f: 42 },);
 101     let o: *mut (dyn Trait,) = &mut p;
 102     let r = unsafe {
 103         (&*o).0.foo()
 104     };
 105     assert_eq!(r, 42);
 106
 107     let a: *mut [_] = &mut [1, 2, 3];
 108     unsafe {
 109         let b = (*a)[2];
 110         assert_eq!(b, 3);
 111         let len = (*a).len();
 112         assert_eq!(len, 3);
 113     }
 114
 115     let a = &mut [1, 2, 3] as *mut [i32];
 116     unsafe {
 117         let b = (*a)[2];
 118         assert_eq!(b, 3);
 119         let len = (*a).len();
 120         assert_eq!(len, 3);
 121     }
 122
 123     let c: *mut Foo<[_]> = &mut Foo {f: [1, 2, 3]};
 124     unsafe {
 125         let b = (&*c).f[0];
 126         assert_eq!(b, 1);
 127         let len = (&*c).f.len();
 128         assert_eq!(len, 3);
 129     }
 130
 131     let c: *mut ([_],) = &mut ([1, 2, 3],);
 132     unsafe {
 133         let b = (&*c).0[0];
 134         assert_eq!(b, 1);
 135         let len = (&*c).0.len();
 136         assert_eq!(len, 3);
 137     }
 138 }