[clang] [Clang] Partial implementation of support for P3074 (trivial unions) (PR #146815)

[via cfe-commits]

================
@@ -0,0 +1,80 @@
+// RUN: %clang_cc1 -verify -std=c++26 %s -Wno-defaulted-function-deleted -triple x86_64-linux-gnu
+
+struct NonTrivial {
+  int i;
+  constexpr NonTrivial(int i) :i(i) { }
+  constexpr ~NonTrivial() { }
+};
+
+union U0 {
+  NonTrivial nt;
+  int i;
+};
+U0 u0;
+
+// check for constant evaluation failure
+constexpr NonTrivial make() {
+    U0 u0;
+    return u0.nt;
+}
+constexpr NonTrivial nt = make(); // expected-error {{must be initialized by a constant expression}}}
+                                  // expected-note at -3 {{union with no active member}}
+                                  // expected-note at -4 {{in call to 'NonTrivial(u0.nt)'}}
+                                  // expected-note at -3 {{in call to 'make()'}}
+
+// overload resolution to select a constructor to default-initialize an object of type X either fails
+union U1 {
+  U1(int);
+  NonTrivial nt; // #1
+};
+U1 u1(1); // expected-error {{deleted function}} expected-note@#1 {{non-trivial destructor}}
+
+// or selects a constructor that is either deleted or not trivial, or
+union U2 {
+  U2() : nt(2) { }
+  NonTrivial nt; // #2
+};
+U2 u2; // expected-error {{deleted function}} expected-note@#2 {{non-trivial destructor}}
+
+union U3 {
+  U3() = delete;
+  U3(int);
+  NonTrivial nt; // #3
+};
+U3 u3(1); // expected-error {{deleted function}} expected-note@#3 {{non-trivial destructor}}
+
+// or X has a variant member V of class type M (or possibly multi-dimensional array thereof) where V has a default member initializer and M has a destructor that is non-trivial,
+union U4 {
+  NonTrivial nt = 1; // #4
+};
+U4 u4; // expected-error {{deleted function}} expected-note@#4 {{non-trivial destructor}}
+
+union U5 {
+  NonTrivial nt;
+  U5* next = nullptr;
+};
+U5 u5;
+
+union U6 {
+  U6() = default;
+  NonTrivial nt;
+  U6* next = nullptr;
+};
+U6 u6;
+
+
+struct DeletedDtor {
+  ~DeletedDtor() = delete; // expected-note 2 {{deleted here}}
+};
+union B1 {
+  B1();
+  DeletedDtor a; // expected-note {{because field 'a' has a deleted destructor}}
+};
+B1 b1; // expected-error {{deleted function}}
+union B2 {
----------------
Sirraide wrote:

Hmm, at a glance nothing jumps out to me; we *do* create a `FieldDecl` for the anonymous struct inside the union so I’d expect this to just handle that case—maybe we’re doing something weird with `IndirectFieldDecl`s somewhere but that’s just a guess. 

I did spot a fixme about anonymous unions inside anonymous unions, so er, here’s another gross test case I suppose:
```c++
union {
    union {
        NonTrivial x;
    };
} a;
```

https://github.com/llvm/llvm-project/pull/146815