[clang][Interp] Do not call dtors of union members (#102739)

Author: tbaederr

clang/lib/AST/Interp/Compiler.cpp

@@ -5552,22 +5552,21 @@ bool Compiler<Emitter>::emitComplexComparison(const Expr *LHS, const Expr *RHS,
 template <class Emitter>
 bool Compiler<Emitter>::emitRecordDestruction(const Record *R) {
   assert(R);
-  // First, destroy all fields.
-  for (const Record::Field &Field : llvm::reverse(R->fields())) {
-    const Descriptor *D = Field.Desc;
-    if (!D->isPrimitive() && !D->isPrimitiveArray()) {
-      if (!this->emitGetPtrField(Field.Offset, SourceInfo{}))
-        return false;
-      if (!this->emitDestruction(D))
-        return false;
-      if (!this->emitPopPtr(SourceInfo{}))
-        return false;
+  if (!R->isUnion()) {
+    // First, destroy all fields.
+    for (const Record::Field &Field : llvm::reverse(R->fields())) {
+      const Descriptor *D = Field.Desc;
+      if (!D->isPrimitive() && !D->isPrimitiveArray()) {
+        if (!this->emitGetPtrField(Field.Offset, SourceInfo{}))
+          return false;
+        if (!this->emitDestruction(D))
+          return false;
+        if (!this->emitPopPtr(SourceInfo{}))
+          return false;
+      }
     }
   }
 
-  // FIXME: Unions need to be handled differently here. We don't want to
-  //   call the destructor of its members.
-
   // Now emit the destructor and recurse into base classes.
   if (const CXXDestructorDecl *Dtor = R->getDestructor();
       Dtor && !Dtor->isTrivial()) {

clang/test/AST/Interp/unions.cpp

@@ -152,4 +152,50 @@ namespace IndirectFieldDecl {
   };
   static_assert(C().a == 1, "");
 }
+
+namespace UnionDtor {
+
+  union U {
+    int *I;
+    constexpr U(int *I) : I(I) {}
+    constexpr ~U() {
+      *I = 10;
+    }
+  };
+
+  constexpr int foo() {
+    int a = 100;
+    {
+      U u(&a);
+    }
+    return a;
+  }
+  static_assert(foo() == 10);
+}
+
+namespace UnionMemberDtor {
+  class UM {
+  public:
+    int &I;
+    constexpr UM(int &I) : I(I) {}
+    constexpr ~UM() { I = 200; }
+  };
+
+  union U {
+    UM um;
+    constexpr U(int &I) : um(I) {}
+    constexpr ~U() {
+    }
+  };
+
+  constexpr int foo() {
+    int a = 100;
+    {
+      U u(a);
+    }
+
+    return a;
+  }
+  static_assert(foo() == 100);
+}
 #endif