PR45879: Use LValue object to evaluate active union members

[sepavloff]

Summary

The function HandleUnionActiveMemberChange determined union members that
become active by analyzing LHS expression. It works for assignment
operator but in the case of C++ assignment operator LHS is not easily
available. Actually RHS was used instead, wich resulted in crash
reported in PR45879.

This change uses LValue object to find union members.

[rsmith]

This change is not correct. The language rules only apply to particular syntactic forms, so we need to check for those exact syntactic forms here.

[sepavloff]

Alternative implementation in in https://reviews.llvm.org/D103395.

clang/lib/AST/ExprConstant.cpp

 } // end anonymous namespace
 
 const AccessKinds StartLifetimeOfUnionMemberHandler::AccessKind;
 
 /// Handle a builtin simple-assignment or a call to a trivial assignment
 /// operator whose left-hand side might involve a union member access. If it
 /// does, implicitly start the lifetime of any accessed union elements per
 /// C++20 [class.union]5.
-static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
+static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *E,
                                           const LValue &LHS) {
   if (LHS.InvalidBase || LHS.Designator.Invalid)
     return false;
 
   llvm::SmallVector<std::pair<unsigned, const FieldDecl*>, 4> UnionPathLengths;
   // C++ [class.union]p5:
   //   define the set S(E) of subexpressions of E as follows:
-  unsigned PathLength = LHS.Designator.Entries.size();
-  for (const Expr *E = LHSExpr; E != nullptr;) {
+  for (unsigned PathLength = LHS.Designator.Entries.size(); PathLength;
+       --PathLength) {
+    SubobjectDesignator::PathEntry PE = LHS.Designator.Entries[PathLength - 1];
     //   -- If E is of the form A.B, S(E) contains the elements of S(A)...
-    if (auto *ME = dyn_cast<MemberExpr>(E)) {
-      auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
+    if (auto *FD = PE.getAsFieldOrNull()) {
       // Note that we can't implicitly start the lifetime of a reference,
       // so we don't need to proceed any further if we reach one.
       if (!FD || FD->getType()->isReferenceType())
         break;
 
       //    ... and also contains A.B if B names a union member ...
       if (FD->getParent()->isUnion()) {
         //    ... of a non-class, non-array type, or of a class type with a
         //    trivial default constructor that is not deleted, or an array of
         //    such types.
         auto *RD =
             FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
         if (!RD || RD->hasTrivialDefaultConstructor())
           UnionPathLengths.push_back({PathLength - 1, FD});
       }
 
-      E = ME->getBase();
-      --PathLength;
-      assert(declaresSameEntity(
-          FD, LHS.Designator.Entries[PathLength].getAsBaseOrMember()));
-
       //   -- If E is of the form A[B] and is interpreted as a built-in array
       //      subscripting operator, S(E) is [S(the array operand, if any)].
-    } else if (auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
-      // Step over an ArrayToPointerDecay implicit cast.
-      auto *Base = ASE->getBase()->IgnoreImplicit();
-      if (!Base->getType()->isArrayType())
-        break;
-
-      E = Base;
-      --PathLength;
-
-    } else if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
-      // Step over a derived-to-base conversion.
-      E = ICE->getSubExpr();
-      if (ICE->getCastKind() == CK_NoOp)
-        continue;
-      if (ICE->getCastKind() != CK_DerivedToBase &&
-          ICE->getCastKind() != CK_UncheckedDerivedToBase)
-        break;
-      // Walk path backwards as we walk up from the base to the derived class.
-      for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) {
-        --PathLength;
-        (void)Elt;
-        assert(
-            declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
-                               LHS.Designator.Entries[PathLength].getAsBase()));
-      }
-
       //   -- Otherwise, S(E) is empty.
-    } else {
+    } else if (!PE.isArrayIndex() && !PE.isAnyBase()) {
       break;
     }
   }
 
   // Common case: no unions' lifetimes are started.
   if (UnionPathLengths.empty())
     return true;
 
   //   if modification of X [would access an inactive union member], an object
   //   of the type of X is implicitly created
   CompleteObject Obj =
-      findCompleteObject(Info, LHSExpr, AK_Assign, LHS, LHSExpr->getType());
+      findCompleteObject(Info, E, AK_Assign, LHS, E->getType());
   if (!Obj)
     return false;
   for (std::pair<unsigned, const FieldDecl *> LengthAndField :
            llvm::reverse(UnionPathLengths)) {
     // Form a designator for the union object.
     SubobjectDesignator D = LHS.Designator;
     D.truncate(Info.Ctx, LHS.Base, LengthAndField.first);
 
     bool DuringInit = Info.isEvaluatingCtorDtor(LHS.Base, D.Entries) ==
                       ConstructionPhase::AfterBases;
     StartLifetimeOfUnionMemberHandler StartLifetime{
-        Info, LHSExpr, LengthAndField.second, DuringInit};
-    if (!findSubobject(Info, LHSExpr, Obj, D, StartLifetime))
+        Info, E, LengthAndField.second, DuringInit};
+    if (!findSubobject(Info, E, Obj, D, StartLifetime))
       return false;
   }
 
   return true;
 }
 
 static bool EvaluateCallArg(const ParmVarDecl *PVD, const Expr *Arg,
                             CallRef Call, EvalInfo &Info,

clang/test/SemaCXX/constant-expression-cxx2a.cpp

namespace Union {
   }
   constexpr int read_uninitialized() {
     B b = {.b = 1};
     int *p = &b.a.y;
     b.a.x = 1;
     return *p; // expected-note {{read of uninitialized object}}
   }
   static_assert(read_uninitialized() == 0); // expected-error {{constant}} expected-note {{in call}}
-  constexpr void write_wrong_member_indirect() { // expected-error {{never produces a constant}}
+  constexpr void write_wrong_member_indirect() {
     B b = {.b = 1};
     int *p = &b.a.y;
-    *p = 1; // expected-note {{assignment to member 'a' of union with active member 'b'}}
+    *p = 1;
   }
   constexpr int write_uninitialized() {
     B b = {.b = 1};
     int *p = &b.a.y;
     b.a.x = 1;
     *p = 1;
     return *p;
   }
namespace PR48582 {
   struct S {
     void *p = this;
     constexpr S() {}
     constexpr S(const S&) {}
   };
   constexpr bool b = [a = S(), b = S()] { return a.p == b.p; }();
   static_assert(!b);
 }
+
+namespace PR45879 {
+  struct Base { int m; };
+  struct Derived : Base {};
+  constexpr int k = ((Base{} = Derived{}), 0);
+}