tests/ui/lint/unaligned_references.rs

   1 #![deny(unaligned_references)]
   2
   3 #[repr(packed)]
   4 pub struct Good {
   5     data: u64,
   6     ptr: &'static u64,
   7     data2: [u64; 2],
   8     aligned: [u8; 32],
   9 }
  10
  11 #[repr(packed(2))]
  12 pub struct Packed2 {
  13     x: u32,
  14     y: u16,
  15     z: u8,
  16 }
  17
  18 fn main() {
  19     unsafe {
  20         let good = Good { data: 0, ptr: &0, data2: [0, 0], aligned: [0; 32] };
  21
  22         let _ = &good.ptr; //~ ERROR reference to packed field
  23         //~^ previously accepted
  24         let _ = &good.data; //~ ERROR reference to packed field
  25         //~^ previously accepted
  26         // Error even when turned into raw pointer immediately.
  27         let _ = &good.data as *const _; //~ ERROR reference to packed field
  28         //~^ previously accepted
  29         let _: *const _ = &good.data; //~ ERROR reference to packed field
  30         //~^ previously accepted
  31         // Error on method call.
  32         let _ = good.data.clone(); //~ ERROR reference to packed field
  33         //~^ previously accepted
  34         // Error for nested fields.
  35         let _ = &good.data2[0]; //~ ERROR reference to packed field
  36         //~^ previously accepted
  37
  38         let _ = &*good.ptr; // ok, behind a pointer
  39         let _ = &good.aligned; // ok, has align 1
  40         let _ = &good.aligned[2]; // ok, has align 1
  41     }
  42
  43     unsafe {
  44         let packed2 = Packed2 { x: 0, y: 0, z: 0 };
  45         let _ = &packed2.x; //~ ERROR reference to packed field
  46         //~^ previously accepted
  47         let _ = &packed2.y; // ok, has align 2 in packed(2) struct
  48         let _ = &packed2.z; // ok, has align 1
  49     }
  50
  51     unsafe {
  52         struct U16(u16);
  53
  54         impl Drop for U16 {
  55             fn drop(&mut self) {
  56                 println!("{:p}", self);
  57             }
  58         }
  59
  60         struct HasDrop;
  61
  62         impl Drop for HasDrop {
  63             fn drop(&mut self) {}
  64         }
  65
  66         #[allow(unused)]
  67         struct Wrapper {
  68             a: U16,
  69             b: HasDrop,
  70         }
  71         #[allow(unused)]
  72         #[repr(packed(2))]
  73         struct Wrapper2 {
  74             a: U16,
  75             b: HasDrop,
  76         }
  77
  78         // An outer struct with more restrictive packing than the inner struct -- make sure we
  79         // notice that!
  80         #[repr(packed)]
  81         struct Misalign<T>(u8, T);
  82
  83         let m1 = Misalign(
  84             0,
  85             Wrapper {
  86                 a: U16(10),
  87                 b: HasDrop,
  88             },
  89         );
  90         let _ref = &m1.1.a; //~ ERROR reference to packed field
  91         //~^ previously accepted
  92
  93         let m2 = Misalign(
  94             0,
  95             Wrapper2 {
  96                 a: U16(10),
  97                 b: HasDrop,
  98             },
  99         );
 100         let _ref = &m2.1.a; //~ ERROR reference to packed field
 101         //~^ previously accepted
 102     }
 103 }