[clang] Expand array expressions if the filler expression's filler is element dependent

[tbaeder]

Summary

This is about the problem described in https://discourse.llvm.org/t/apvalue-lifetime-problem-when-evaluating-constant-expressions/64002/5

The (old) condition in this if statement is meant to handle initializers that depend on (other) array elements. In this case, the array needs to be expanded before the array filler is evaluated:

if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr))
  NumEltsToInit = NumElts;

in the test case described on Discourse (which is attached in the patch), MaybeElementDependentArrayFiller() returns false for the outer array but true for the inner array. Since every InitListExpr can have an array filler, I believe the function should take that into account.

This fixes https://github.com/llvm/llvm-project/issues/56016

[aaron.ballman]

Your logic makes sense to me and these changes look correct; good catch! Please be sure to add a release note when landing. Thanks for the fix!

[erichkeane]

This seems reasonable to me as well.

[arichardson]

clang/test/SemaCXX/constexpr-array-init.cpp

3

Nit: It might be helpful to add a comment to this test explaining what it's testing. This makes it easier to diagnose tests failures (e.g. in downstream forks) without having to rely on git blame.

clang/lib/AST/ExprConstant.cpp

static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
   // lists comprised of them.
   if (isa<ImplicitValueInitExpr>(FillerExpr))
     return false;
   if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
     for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
       if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
         return true;
     }
+
+    if (ILE->hasArrayFiller() &&
+        MaybeElementDependentArrayFiller(ILE->getArrayFiller()))
+      return true;
+
     return false;
   }
   return true;
 }
 
 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E,
                                            QualType AllocType) {
   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(

clang/test/SemaCXX/constexpr-array-init.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+
+
+/// expected-no-diagnostics
+struct Foo {
+  int a;
+  constexpr Foo()
+      : a(get_int()) {
+  }
+
+  constexpr int get_int() const {
+    return 5;
+  }
+};
+
+static constexpr Foo bar[2][1] = {
+    {{}},
+};
+static_assert(bar[0][0].a == 5);
+static_assert(bar[1][0].a == 5);
+