[clang] Support array placement new in constant expressions

[ldionne]

Summary

This is necessary for std::construct_at to work on arrays inside a
constant expression.

[ldionne]

Gentle ping -- I suspect this may be too naive, but it's a start. It would be awesome to ship this in LLVM 14, since it would allow us to unblock libc++ work on a couple features.

[• Quuxplusone]

I have no special knowledge of this. Seems like "it can't be that easy," but I don't know.

clang/test/SemaCXX/cxx2a-constexpr-dynalloc.cpp

138

I would think you ought to have the same species of test for the array case, also. Could probably be added right in here:

std::construct_at<int>(p + 2, 3);
bool good = p[0] + p[1] + p[2] == 6;
std::construct_at<int[3]>(p, 4, 5, 6);
bool also_good = p[0] + p[1] + p[2] == 15;

Also, it would be good to test the behavior of using T = int[]; new (&a) T{} with an incomplete type, unless that's already tested somewhere.
Also note this test is compile-only (since it expects errors), and so it would probably be a good idea to have some tests for the behavior/codegen, not just that it seems to be accepted silently by the compiler (and in the presence of other errors at that).

[erichkeane]

In D114903#3285144, @Quuxplusone wrote:

I have no special knowledge of this. Seems like "it can't be that easy," but I don't know.

I agree with this. I have a little knowledge of the constant evaluator, but not enough to know what is going on in this function. Presumably the rest of the array case is handled below for the 'nothrow' array case, so maybe it _IS_ that easy? But Richard implemented this back in 2019 without review or explanation here, so we won't have anything for context unless @rsmith can comment.

I'm tempted to try to get this into main "soon" so that this can hang out in ToT for a while before making it to clang-15. I DO think that the suggestions that @Quuxplusone made for new tests is a really good idea (and frankly, I'd like to see this with better test coverage), but otherwise I'm tempted to approve.

[ldionne]

I've run out of time to work on this. It's also not clear that it's supported by the Standard right now since there's a not-voted-yet LWG issue about it (http://wg21.link/LWG3436).

Abandoning. This isn't blocking libc++ anymore, too.

clang/lib/AST/ExprConstant.cpp

bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
   if (Info.SpeculativeEvaluationDepth)
     return false;
 
   FunctionDecl *OperatorNew = E->getOperatorNew();
 
   bool IsNothrow = false;
   bool IsPlacement = false;
   if (OperatorNew->isReservedGlobalPlacementOperator() &&
-      Info.CurrentCall->isStdFunction() && !E->isArray()) {
-    // FIXME Support array placement new.
+      Info.CurrentCall->isStdFunction()) {
     assert(E->getNumPlacementArgs() == 1);
     if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
       return false;
     if (Result.Designator.Invalid)
       return false;
     IsPlacement = true;
   } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {
     Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)

clang/test/SemaCXX/cxx2a-constexpr-dynalloc.cpp

 
 void *operator new(std::size_t, void *p) { return p; }
 constexpr bool no_placement_new_in_user_code() { // expected-error {{never produces a constant expression}}
   int a;
   new (&a) int(42); // expected-note {{call to placement 'operator new'}}
   return a == 42;
 }
 
+void *operator new[](std::size_t, void *p) { return p; }
+constexpr bool no_array_placement_new_in_user_code() { // expected-error {{never produces a constant expression}}
+  int a[3];
+  new (&a) int[3](); // expected-note {{call to placement 'operator new[]'}}
+  return a[0] == 0 && a[1] == 0 && a[2] == 0;
+}
+
 namespace std {
   constexpr bool placement_new_in_stdlib() {
     int a;
     new (&a) int(42);
     return a == 42;
   }
+
+  constexpr bool array_placement_new_in_stdlib() {
+    int a[3];
+    new (&a) int[3]{42, 43, 44};
+    return a[0] == 42 && a[1] == 43 && a[2] == 44;
+  }
 }
 static_assert(std::placement_new_in_stdlib());
+static_assert(std::array_placement_new_in_stdlib());
 
 namespace std {
   template<typename T, typename ...Args>
   constexpr void construct_at(void *p, Args &&...args) {
     new (p) T((Args&&)args...); // #new
   }
 }
 
 constexpr bool call_std_construct_at() {
   int *p = std::allocator<int>().allocate(3);
   std::construct_at<int>(p, 1);
   std::construct_at<int>(p + 1, 2);
   std::construct_at<int>(p + 2, 3);
   bool good = p[0] + p[1] + p[2] == 6;
   std::allocator<int>().deallocate(p);
   return good;
 }
 static_assert(call_std_construct_at());
 
 constexpr bool bad_construct_at_type() {
   int a;
   // expected-note@#new {{placement new would change type of storage from 'int' to 'float'}}
   std::construct_at<float>(&a, 1.0f); // expected-note {{in call}}
   return true;
 }
 static_assert(bad_construct_at_type()); // expected-error{{}} expected-note {{in call}}