[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

4

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/docs/ReleaseNotes.rst

 - Improve compile-times with large dynamic array allocations with trivial
   constructors. This fixes
   `Issue 56774 <https://github.com/llvm/llvm-project/issues/56774>`_.
 - No longer assert/miscompile when trying to make a vectorized ``_BitInt`` type
   using the ``ext_vector_type`` attribute (the ``vector_size`` attribute was
   already properly diagnosing this case).
 - Fix clang not properly diagnosing the failing subexpression when chained
   binary operators are used in a ``static_assert`` expression.
+- Fix a crash when evaluating a multi-dimensional array's array filler
+  expression is element-dependent. This fixes
+  `Issue 50601 <https://github.com/llvm/llvm-project/issues/56016>`_.
+
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now correctly diagnose as ill-formed a constant expression where an
   enum without a fixed underlying type is set to a value outside the range of
   the enumeration's values. Fixes
   `Issue 50055: <https://github.com/llvm/llvm-project/issues/50055>`_.
 - Clang will now check compile-time determinable string literals as format strings.

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
+
+/// This test case used to crash in constant evaluation
+/// because of the two-dimensional array with an array
+/// filler expression.
+
+/// 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);
+