src/tools/miri/tests/pass/dst-raw.rs

   1 // Test DST raw pointers
   2
   3 trait Trait {
   4     fn foo(&self) -> isize;
   5 }
   6
   7 struct A {
   8     f: isize,
   9 }
  10 impl Trait for A {
  11     fn foo(&self) -> isize {
  12         self.f
  13     }
  14 }
  15
  16 struct Foo<T: ?Sized> {
  17     f: T,
  18 }
  19
  20 pub fn main() {
  21     // raw trait object
  22     let x = A { f: 42 };
  23     let z: *const dyn Trait = &x;
  24     let r = unsafe { (&*z).foo() };
  25     assert_eq!(r, 42);
  26
  27     // raw DST struct
  28     let p = Foo { f: A { f: 42 } };
  29     let o: *const Foo<dyn Trait> = &p;
  30     let r = unsafe { (&*o).f.foo() };
  31     assert_eq!(r, 42);
  32
  33     // raw slice
  34     let a: *const [_] = &[1, 2, 3];
  35     unsafe {
  36         let b = (*a)[2];
  37         assert_eq!(b, 3);
  38         let len = (*a).len();
  39         assert_eq!(len, 3);
  40     }
  41
  42     // raw slice with explicit cast
  43     let a = &[1, 2, 3] as *const [i32];
  44     unsafe {
  45         let b = (*a)[2];
  46         assert_eq!(b, 3);
  47         let len = (*a).len();
  48         assert_eq!(len, 3);
  49     }
  50
  51     // raw DST struct with slice
  52     let c: *const Foo<[_]> = &Foo { f: [1, 2, 3] };
  53     unsafe {
  54         let b = (&*c).f[0];
  55         assert_eq!(b, 1);
  56         let len = (&*c).f.len();
  57         assert_eq!(len, 3);
  58     }
  59
  60     // all of the above with *mut
  61     let mut x = A { f: 42 };
  62     let z: *mut dyn Trait = &mut x;
  63     let r = unsafe { (&*z).foo() };
  64     assert_eq!(r, 42);
  65
  66     let mut p = Foo { f: A { f: 42 } };
  67     let o: *mut Foo<dyn Trait> = &mut p;
  68     let r = unsafe { (&*o).f.foo() };
  69     assert_eq!(r, 42);
  70
  71     let a: *mut [_] = &mut [1, 2, 3];
  72     unsafe {
  73         let b = (*a)[2];
  74         assert_eq!(b, 3);
  75         let len = (*a).len();
  76         assert_eq!(len, 3);
  77     }
  78
  79     let a = &mut [1, 2, 3] as *mut [i32];
  80     unsafe {
  81         let b = (*a)[2];
  82         assert_eq!(b, 3);
  83         let len = (*a).len();
  84         assert_eq!(len, 3);
  85     }
  86
  87     let c: *mut Foo<[_]> = &mut Foo { f: [1, 2, 3] };
  88     unsafe {
  89         let b = (&*c).f[0];
  90         assert_eq!(b, 1);
  91         let len = (&*c).f.len();
  92         assert_eq!(len, 3);
  93     }
  94 }