Address Aarons's feedback

Author: cor3ntin

clang/include/clang/Basic/DiagnosticASTKinds.td

@@ -333,9 +333,10 @@ def note_constexpr_new : Note<
 def note_constexpr_new_non_replaceable : Note<
   "call to %select{placement|class-specific}0 %1">;
 def note_constexpr_new_placement : Note<
-  "this placement new expression is not yet supported in constant expressions">;
+  "this placement new expression is not supported in constant expressions "
+  "%select{|before C++2c}0">;
 def note_constexpr_placement_new_wrong_type : Note<
-    "placement new would change type of storage from %0 to %1">;
+  "placement new would change type of storage from %0 to %1">;
 def note_constexpr_new_negative : Note<
   "cannot allocate array; evaluated array bound %0 is negative">;
 def note_constexpr_new_too_large : Note<

clang/lib/AST/ExprConstant.cpp

@@ -10009,7 +10009,7 @@ bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
   bool IsNothrow = false;
   bool IsPlacement = false;
 
-  if (E->getNumPlacementArgs() && E->getNumPlacementArgs() == 1 &&
+  if (E->getNumPlacementArgs() == 1 &&
       E->getPlacementArg(0)->getType()->isNothrowT()) {
     // The only new-placement list we support is of the form (std::nothrow).
     //
@@ -10025,17 +10025,23 @@ bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
     if (!EvaluateLValue(E->getPlacementArg(0), Nothrow, Info))
       return false;
     IsNothrow = true;
-  } else if (OperatorNew->isReservedGlobalPlacementOperator() &&
-             (Info.CurrentCall->isStdFunction() ||
-              Info.getLangOpts().CPlusPlus26)) {
-    if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
-      return false;
-    if (Result.Designator.Invalid)
+  } else if (OperatorNew->isReservedGlobalPlacementOperator()) {
+    if (Info.CurrentCall->isStdFunction() || Info.getLangOpts().CPlusPlus26) {
+      if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
+        return false;
+      if (Result.Designator.Invalid)
+        return false;
+      TargetType = E->getPlacementArg(0)->getType();
+      IsPlacement = true;
+    } else {
+      Info.FFDiag(E, diag::note_constexpr_new_placement)
+          << /*C++26 feature*/ 1 << E->getSourceRange();
       return false;
-    TargetType = E->getPlacementArg(0)->getType();
-    IsPlacement = true;
+    }
   } else if (E->getNumPlacementArgs()) {
-    return Error(E, diag::note_constexpr_new_placement);
+    Info.FFDiag(E, diag::note_constexpr_new_placement)
+        << /*Unsupported*/ 0 << E->getSourceRange();
+    return false;
   } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {
     Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
         << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;

clang/test/AST/ByteCode/new-delete.cpp

@@ -245,7 +245,7 @@ namespace std {
 namespace PlacementNew {
   constexpr int foo() { // both-error {{never produces a constant expression}}
     char c[sizeof(int)];
-    new (c) int{12}; // ref-note {{this placement new expression is not yet supported in constant expressions}} \
+    new (c) int{12}; // ref-note {{this placement new expression is not supported in constant expressions}} \
                      // expected-note {{subexpression not valid in a constant expression}}
     return 0;
   }
@@ -309,7 +309,7 @@ namespace placement_new_delete {
   constexpr bool bad(int which) {
     switch (which) {
     case 0:
-      delete new (placement_new_arg{}) int; // ref-note {{this placement new expression is not yet supported in constant expression}} \
+      delete new (placement_new_arg{}) int; // ref-note {{this placement new expression is not supported in constant expressions}} \
                                             // expected-note {{subexpression not valid in a constant expression}}
       break;
 
@@ -328,7 +328,7 @@ namespace placement_new_delete {
     case 4:
       // FIXME: This technically follows the standard's rules, but it seems
       // unreasonable to expect implementations to support this.
-      delete new (std::align_val_t{64}) Overaligned; // ref-note {{placement new expression is not yet supported}} \
+      delete new (std::align_val_t{64}) Overaligned; // ref-note {{this placement new expression is not supported in constant expressions }} \
                                                      // expected-note {{subexpression not valid in a constant expression}}
       break;
     }

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

@@ -994,7 +994,7 @@ namespace placement_new_delete {
   constexpr bool bad(int which) {
     switch (which) {
     case 0:
-      delete new (placement_new_arg{}) int; // expected-note {{this placement new expression is not yet supported in constant expressions}}
+      delete new (placement_new_arg{}) int; // expected-note {{this placement new expression is not supported in constant expressions}}
       break;
 
     case 1:
@@ -1012,7 +1012,7 @@ namespace placement_new_delete {
     case 4:
       // FIXME: This technically follows the standard's rules, but it seems
       // unreasonable to expect implementations to support this.
-      delete new (std::align_val_t{64}) Overaligned; // expected-note {{placement new expression is not yet supported}}
+      delete new (std::align_val_t{64}) Overaligned; // expected-note {{this placement new expression is not supported in constant expressions}}
       break;
     }
 

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

@@ -94,7 +94,7 @@ void *operator new(std::size_t, void *p) { return p; }
 void* operator new[] (std::size_t, void* p) {return p;}
 constexpr bool no_placement_new_in_user_code() { // cxx20-error {{constexpr function never produces a constant expression}}
   int a;
-  new (&a) int(42); // cxx20-note {{this placement new expression is not yet supported in constant expressions}}
+  new (&a) int(42); // cxx20-note {{this placement new expression is not supported in constant expressions before C++2c}}
   return a == 42;
 }
 

clang/test/SemaCXX/cxx2c-constexpr-placement-new.cpp

@@ -17,7 +17,7 @@ consteval int ok() {
     return 0;
 }
 
-consteval int conversion() { // expected-error {{consteval function never produces a constant expression}}
+consteval int conversion() {
     int i;
     new (static_cast<void*>(&i)) float(0);
     // expected-note@-1 {{placement new would change type of storage from 'int' to 'float'}}
@@ -41,7 +41,7 @@ consteval int array1() {
     return 0;
 }
 
-consteval int array2() { // expected-error {{consteval function never produces a constant expression}}
+consteval int array2() {
     int i[1];
     new (&i) int[2];
     //expected-note@-1 {{placement new would change type of storage from 'int[1]' to 'int[2]'}}
@@ -71,8 +71,45 @@ consteval void alloc_err() {
 
 
 int a = ok();
-int c = indeterminate(); // expected-error {{call to consteval function 'placement_new::indeterminate' is not a constant expression}} \
+int b = conversion(); // expected-error {{call to consteval function 'conversion' is not a constant expression}} \
+             // expected-note {{in call to 'conversion()'}}
+int c = indeterminate(); // expected-error {{call to consteval function 'indeterminate' is not a constant expression}} \
              // expected-note {{in call to 'indeterminate()'}}
 int d = array1();
+int e = array2(); // expected-error {{call to consteval function 'array2' is not a constant expression}} \
+                  // expected-note {{in call to 'array2()'}}
 int alloc1 = (alloc(), 0);
-int alloc2 = (alloc_err(), 0); // expected-error {{call to consteval function 'placement_new::alloc_err' is not a constant expression}}
+int alloc2 = (alloc_err(), 0); // expected-error {{call to consteval function 'alloc_err' is not a constant expression}}
+
+constexpr int *intptr() {
+  return new int;
+}
+
+constexpr bool yay() {
+  int *ptr = new (intptr()) int(42);
+  bool ret = *ptr == 42;
+  delete ptr;
+  return ret;
+}
+static_assert(yay());
+
+constexpr bool blah() {
+  int *ptr = new (intptr()) int[3]{ 1, 2, 3 }; // expected-note {{placement new would change type of storage from 'int' to 'int[3]'}}
+  bool ret = ptr[0] == 1 && ptr[1] == 2 && ptr[2] == 3;
+  delete [] ptr;
+  return ret;
+}
+static_assert(blah()); // expected-error {{not an integral constant expression}} \
+                       // expected-note {{in call to 'blah()'}}
+
+constexpr int *get_indeterminate() {
+  int *evil;
+  return evil; // expected-note {{read of uninitialized object is not allowed in a constant expression}}
+}
+
+constexpr bool bleh() {
+  int *ptr = new (get_indeterminate()) int;  // expected-note {{in call to 'get_indeterminate()'}}
+  return true;
+}
+static_assert(bleh()); // expected-error {{not an integral constant expression}} \
+                        // expected-note {{in call to 'bleh()'}}