Do not make it an extension as there is no good way to introduce a warning for it

Author: cor3ntin

clang/docs/LanguageExtensions.rst

@@ -1506,7 +1506,6 @@ Attributes on Structured Bindings            __cpp_structured_bindings        C+
 Pack Indexing                                __cpp_pack_indexing              C++26         C++03
 ``= delete ("should have a reason");``       __cpp_deleted_function           C++26         C++03
 Variadic Friends                             __cpp_variadic_friend            C++26         C++03
-``constexpr`` placement new                  __cpp_constexpr                  C++26         C++20
 -------------------------------------------- -------------------------------- ------------- -------------
 Designated initializers (N494)                                                C99           C89
 Array & element qualification (N2607)                                         C23           C89

clang/lib/AST/ExprConstant.cpp

@@ -10025,7 +10025,9 @@ bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
     if (!EvaluateLValue(E->getPlacementArg(0), Nothrow, Info))
       return false;
     IsNothrow = true;
-  } else if (OperatorNew->isReservedGlobalPlacementOperator()) {
+  } else if (OperatorNew->isReservedGlobalPlacementOperator() &&
+             (Info.CurrentCall->isStdFunction() ||
+              Info.getLangOpts().CPlusPlus26)) {
     if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
       return false;
     if (Result.Designator.Invalid)

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 {{placement new would change type of storage from 'char' to 'int'}} \
+    new (c) int{12}; // ref-note {{this placement new expression is not yet supported in constant expressions}} \
                      // expected-note {{subexpression not valid in a constant expression}}
     return 0;
   }

clang/test/CXX/drs/cwg29xx.cpp

@@ -24,7 +24,7 @@ struct S {
 };
 } // namespace cwg2917
 
-#if __cplusplus >= 202002
+#if __cplusplus >= 202400L
 
 namespace std {
   using size_t = decltype(sizeof(0));

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

@@ -1,6 +1,7 @@
-// RUN: %clang_cc1 -std=c++2a -verify %s -DNEW=__builtin_operator_new -DDELETE=__builtin_operator_delete
-// RUN: %clang_cc1 -std=c++2a -verify %s "-DNEW=operator new" "-DDELETE=operator delete"
-// RUN: %clang_cc1 -std=c++2a -verify %s "-DNEW=::operator new" "-DDELETE=::operator delete"
+// RUN: %clang_cc1 -std=c++2a -verify=expected,cxx20 %s -DNEW=__builtin_operator_new -DDELETE=__builtin_operator_delete
+// RUN: %clang_cc1 -std=c++2a -verify=expected,cxx20 %s "-DNEW=operator new" "-DDELETE=operator delete"
+// RUN: %clang_cc1 -std=c++2a -verify=expected,cxx20 %s "-DNEW=::operator new" "-DDELETE=::operator delete"
+// RUN: %clang_cc1 -std=c++2c -verify=expected,cxx26 %s "-DNEW=::operator new" "-DDELETE=::operator delete"
 
 constexpr bool alloc_from_user_code() {
   void *p = NEW(sizeof(int)); // expected-note {{cannot allocate untyped memory in a constant expression; use 'std::allocator<T>::allocate'}}
@@ -91,9 +92,9 @@ constexpr int no_deallocate_nonalloc = (std::allocator<int>().deallocate((int*)&
 
 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() {
+constexpr bool no_placement_new_in_user_code() { // cxx20-error {{constexpr function never produces a constant expression}}
   int a;
-  new (&a) int(42);
+  new (&a) int(42); // cxx20-note {{this placement new expression is not yet supported in constant expressions}}
   return a == 42;
 }
 
@@ -240,80 +241,3 @@ void f() {
 }
 
 }
-
-namespace placement_new {
-
-template <typename T, typename U>
-constexpr void f(T* t, U u) {
-    new (t) U(u);
-}
-
-consteval int ok() {
-    int i;
-    new (&i) int(0);
-    new (&i) int[1]{1};
-    new (static_cast<void*>(&i)) int(0);
-    return 0;
-}
-
-consteval int conversion() { // expected-error {{consteval function never produces a constant expression}}
-    int i;
-    new (static_cast<void*>(&i)) float(0);
-    // expected-note@-1 {{placement new would change type of storage from 'int' to 'float'}}
-    return 0;
-}
-
-consteval int indeterminate() {
-    int * indeterminate;
-    new (indeterminate) int(0);
-    // expected-note@-1 {{read of uninitialized object is not allowed in a constant expression}}
-    return 0;
-}
-
-consteval int array1() {
-    int i[2];
-    new (&i) int[]{1,2};
-    new (&i) int[]{1};
-    new (&i) int(0);
-    new (static_cast<void*>(&i)) int[]{1,2};
-    new (static_cast<void*>(&i)) int[]{1};
-    return 0;
-}
-
-consteval int array2() { // expected-error {{consteval function never produces a constant expression}}
-    int i[1];
-    new (&i) int[2];
-    //expected-note@-1 {{placement new would change type of storage from 'int[1]' to 'int[2]'}}
-    return 0;
-}
-
-struct S{
-    int* i;
-    constexpr S() : i(new int(42)) {} // expected-note {{allocation performed here was not deallocated}}
-    constexpr ~S() {delete i;}
-};
-
-consteval void alloc() {
-    S* s = new S();
-    s->~S();
-    new (s) S();
-    delete s;
-}
-
-
-consteval void alloc_err() {
-    S* s = new S();
-    new (s) S();
-    delete s;
-}
-
-
-
-int a = ok();
-int c = indeterminate(); // expected-error {{call to consteval function 'placement_new::indeterminate' is not a constant expression}} \
-             // expected-note {{in call to 'indeterminate()'}}
-int d = array1();
-int alloc1 = (alloc(), 0);
-int alloc2 = (alloc_err(), 0); // expected-error {{call to consteval function 'placement_new::alloc_err' is not a constant expression}}
-
-}

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

@@ -0,0 +1,78 @@
+// RUN: %clang_cc1 -std=c++2c -verify %s
+
+
+namespace std {
+  using size_t = decltype(sizeof(0));
+}
+
+void *operator new(std::size_t, void *p) { return p; }
+void* operator new[] (std::size_t, void* p) {return p;}
+
+
+consteval int ok() {
+    int i;
+    new (&i) int(0);
+    new (&i) int[1]{1};
+    new (static_cast<void*>(&i)) int(0);
+    return 0;
+}
+
+consteval int conversion() { // expected-error {{consteval function never produces a constant expression}}
+    int i;
+    new (static_cast<void*>(&i)) float(0);
+    // expected-note@-1 {{placement new would change type of storage from 'int' to 'float'}}
+    return 0;
+}
+
+consteval int indeterminate() {
+    int * indeterminate;
+    new (indeterminate) int(0);
+    // expected-note@-1 {{read of uninitialized object is not allowed in a constant expression}}
+    return 0;
+}
+
+consteval int array1() {
+    int i[2];
+    new (&i) int[]{1,2};
+    new (&i) int[]{1};
+    new (&i) int(0);
+    new (static_cast<void*>(&i)) int[]{1,2};
+    new (static_cast<void*>(&i)) int[]{1};
+    return 0;
+}
+
+consteval int array2() { // expected-error {{consteval function never produces a constant expression}}
+    int i[1];
+    new (&i) int[2];
+    //expected-note@-1 {{placement new would change type of storage from 'int[1]' to 'int[2]'}}
+    return 0;
+}
+
+struct S{
+    int* i;
+    constexpr S() : i(new int(42)) {} // expected-note {{allocation performed here was not deallocated}}
+    constexpr ~S() {delete i;}
+};
+
+consteval void alloc() {
+    S* s = new S();
+    s->~S();
+    new (s) S();
+    delete s;
+}
+
+
+consteval void alloc_err() {
+    S* s = new S();
+    new (s) S();
+    delete s;
+}
+
+
+
+int a = ok();
+int c = indeterminate(); // expected-error {{call to consteval function 'placement_new::indeterminate' is not a constant expression}} \
+             // expected-note {{in call to 'indeterminate()'}}
+int d = array1();
+int alloc1 = (alloc(), 0);
+int alloc2 = (alloc_err(), 0); // expected-error {{call to consteval function 'placement_new::alloc_err' is not a constant expression}}