Fix union field access by representing unions as structs

crates/rustc_codegen_spirv/src/abi.rs

@@ -718,21 +718,22 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
         FieldsShape::Union(_) => {
             assert!(!ty.is_unsized(), "{ty:#?}");
 
-            // Represent the `union` with its largest case, which should work
-            // for at least `MaybeUninit<T>` (which is between `T` and `()`),
-            // but also potentially some other ones as well.
-            // NOTE(eddyb) even if long-term this may become a byte array, that
-            // only works for "data types" and not "opaque handles" (images etc.).
-            let largest_case = (0..ty.fields.count())
-                .map(|i| ty.field(cx, i))
-                .max_by_key(|case| case.size);
-
-            if let Some(case) = largest_case {
-                assert_eq!(ty.size, case.size);
-                case.spirv_type(span, cx)
-            } else {
-                assert_eq!(ty.size, Size::ZERO);
-                create_zst(cx, span, ty)
+            // NOTE(eddyb) even if long-term this may become a byte array, that only
+            // works for "data types" and not "opaque handles" (images etc.).
+            match ty.fields.count() {
+                // For unions with no fields, represent as a zero-sized type.
+                0 => {
+                    assert_eq!(ty.size, Size::ZERO);
+                    create_zst(cx, span, ty)
+                }
+                // For unions with a single field, represent as the field itself.
+                1 => {
+                    let field = ty.field(cx, 0);
+                    assert_eq!(ty.size, field.size);
+                    field.spirv_type(span, cx)
+                }
+                // For unions with multiple fields, represent as struct with all fields at offset 0
+                _ => trans_struct(cx, span, ty),
             }
         }
         FieldsShape::Array { stride, count } => {

tests/ui/lang/core/union_cast.rs

@@ -0,0 +1,32 @@
+// build-pass
+
+use spirv_std::spirv;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct Data {
+    a: f32,
+    b: [f32; 3],
+    c: f32,
+}
+
+#[repr(C)]
+union DataOrArray {
+    arr: [f32; 5],
+    str: Data,
+}
+
+impl DataOrArray {
+    fn arr(&self) -> [f32; 5] {
+        unsafe { self.arr }
+    }
+    fn new(arr: [f32; 5]) -> Self {
+        Self { arr }
+    }
+}
+
+#[spirv(fragment)]
+pub fn main() {
+    let dora = DataOrArray::new([0.0, 0.0, 0.0, 0.0, 0.0]);
+    let _arr = dora.arr();
+}