1 files changed, 109 insertions, 0 deletions
diff --git a/tests/ui/unsafe-fields/unsafe-fields.rs b/tests/ui/unsafe-fields/unsafe-fields.rs
new file mode 100644
index 00000000000..637471582d7
--- /dev/null
+++ b/tests/ui/unsafe-fields/unsafe-fields.rs
@@ -0,0 +1,109 @@
+//@ compile-flags: --crate-type=lib
+#![allow(incomplete_features)]
+#![feature(unsafe_fields)]
+
+struct WithUnsafeField {
+    unsafe unsafe_field: u32,
+    safe_field: u32,
+}
+
+enum A {
+    WithUnsafeField { unsafe unsafe_field: u32, safe_field: u32 },
+}
+
+fn f(a: A) {
+    let A::WithUnsafeField { unsafe_field, safe_field } = a;
+    //~^ ERROR
+}
+
+struct WithInvalidUnsafeField {
+    unsafe unsafe_noncopy_field: Vec<u32>, //~ ERROR
+}
+
+struct WithManuallyDropUnsafeField {
+    unsafe unsafe_noncopy_field: std::mem::ManuallyDrop<Vec<u32>>,
+}
+
+union WithUnsafeFieldUnion {
+    unsafe unsafe_field: u32,
+    safe_field: u32,
+}
+
+impl WithUnsafeField {
+    fn new() -> WithUnsafeField {
+        unsafe {
+            WithUnsafeField {
+                unsafe_field: 0,
+                safe_field: 0,
+            }
+        }
+    }
+
+    fn new_without_unsafe() -> WithUnsafeField {
+        WithUnsafeField { //~ ERROR
+            unsafe_field: 0,
+            safe_field: 0,
+        }
+    }
+
+    fn operate_on_safe_field(&mut self) {
+        self.safe_field = 2;
+        &self.safe_field;
+        self.safe_field;
+    }
+
+    fn set_unsafe_field(&mut self) {
+        unsafe {
+            self.unsafe_field = 2;
+        }
+    }
+
+    fn read_unsafe_field(&self) -> u32 {
+        unsafe {
+            self.unsafe_field
+        }
+    }
+
+    fn ref_unsafe_field(&self) -> &u32 {
+        unsafe {
+            &self.unsafe_field
+        }
+    }
+
+    fn destructure(&self) {
+        unsafe {
+            let Self { safe_field, unsafe_field } = self;
+        }
+    }
+
+    fn set_unsafe_field_without_unsafe(&mut self) {
+        self.unsafe_field = 2;
+        //~^ ERROR
+    }
+
+    fn read_unsafe_field_without_unsafe(&self) -> u32 {
+        self.unsafe_field
+        //~^ ERROR
+    }
+
+    fn ref_unsafe_field_without_unsafe(&self) -> &u32 {
+        &self.unsafe_field
+        //~^ ERROR
+    }
+
+    fn destructure_without_unsafe(&self) {
+        let Self { safe_field, unsafe_field } = self;
+        //~^ ERROR
+
+        let WithUnsafeField { safe_field, .. } = self;
+    }
+
+    fn offset_of(&self) -> usize {
+        std::mem::offset_of!(WithUnsafeField, unsafe_field)
+    }
+
+    fn raw_const(&self) -> *const u32 {
+        &raw const self.unsafe_field
+        //~^ ERROR
+    }
+}