Merging upstream version 1.67.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 89 insertions, 0 deletions

diff --git a/src/test/ui/repr/align-with-extern-c-fn.rs b/src/test/ui/repr/align-with-extern-c-fn.rs
new file mode 100644
index 000000000..9e490e27a
--- /dev/null
+++ b/src/test/ui/repr/align-with-extern-c-fn.rs
@@ -0,0 +1,18 @@
+// run-pass
+
+#![allow(stable_features)]
+#![allow(unused_variables)]
+
+// #45662
+
+#![feature(repr_align)]
+
+#[repr(align(16))]
+pub struct A(#[allow(unused_tuple_struct_fields)] i64);
+
+#[allow(improper_ctypes_definitions)]
+pub extern "C" fn foo(x: A) {}
+
+fn main() {
+    foo(A(0));
+}
diff --git a/src/test/ui/repr/aligned_enum_cast.rs b/src/test/ui/repr/aligned_enum_cast.rs
new file mode 100644
index 000000000..1ddf12717
--- /dev/null
+++ b/src/test/ui/repr/aligned_enum_cast.rs
@@ -0,0 +1,25 @@
+// run-pass
+// allows aligned custom discriminant enums to cast into other types
+// See the issue #92464 for more info
+#[allow(dead_code)]
+#[repr(align(8))]
+enum Aligned {
+    Zero = 0,
+    One = 1,
+}
+
+fn main() {
+    let aligned = Aligned::Zero;
+    let fo = aligned as u8;
+    println!("foo {}", fo);
+    assert_eq!(fo, 0);
+    println!("{}", tou8(Aligned::Zero));
+    assert_eq!(tou8(Aligned::Zero), 0);
+}
+
+#[inline(never)]
+fn tou8(al: Aligned) -> u8 {
+    // Cast behind a function call so ConstProp does not see it
+    // (so that we can test codegen).
+    al as u8
+}
diff --git a/src/test/ui/repr/repr_c_int_align.rs b/src/test/ui/repr/repr_c_int_align.rs
new file mode 100644
index 000000000..fdd14fc2d
--- /dev/null
+++ b/src/test/ui/repr/repr_c_int_align.rs
@@ -0,0 +1,46 @@
+// run-pass
+// compile-flags: -O
+
+#![allow(dead_code)]
+
+#[repr(C, u8)]
+enum ReprCu8 {
+    A(u16),
+    B,
+}
+
+#[repr(u8)]
+enum Repru8 {
+    A(u16),
+    B,
+}
+
+#[repr(C)]
+struct ReprC {
+    tag: u8,
+    padding: u8,
+    payload: u16,
+}
+
+fn main() {
+    // Test `repr(C, u8)`.
+    let r1 = ReprC { tag: 0, padding: 0, payload: 0 };
+    let r2 = ReprC { tag: 0, padding: 1, payload: 1 };
+
+    let t1: &ReprCu8 = unsafe { std::mem::transmute(&r1) };
+    let t2: &ReprCu8 = unsafe { std::mem::transmute(&r2) };
+
+    match (t1, t2) {
+        (ReprCu8::A(_), ReprCu8::A(_)) => (),
+        _ => assert!(false)
+    };
+
+    // Test `repr(u8)`.
+    let t1: &Repru8 = unsafe { std::mem::transmute(&r1) };
+    let t2: &Repru8 = unsafe { std::mem::transmute(&r2) };
+
+    match (t1, t2) {
+        (Repru8::A(_), Repru8::A(_)) => (),
+        _ => assert!(false)
+    };
+}