Improve language feature extension warnings update release notes

Author: ojhunt

clang/docs/ReleaseNotes.rst

@@ -81,6 +81,8 @@ C++2c Feature Support
 
 - Implemented `P0963R3 Structured binding declaration as a condition <https://wg21.link/P0963R3>`_.
 
+- Implemented `P2719Rx Type-aware allocation and deallocation functions <https://wg21.link/P2719>`_.
+
 C++23 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9844,8 +9844,11 @@ def err_type_aware_destroying_operator_delete : Error<
   "type aware destroying delete is not permitted in C++26">;
 def err_unsupported_type_aware_allocator : Error<
   "type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'">;
-def warn_cxx26_type_aware_allocator : Warning<
-  "use or declaration of type aware allocators are incompatible with C++ standards before C++26">,
+
+def ext_cxx26_type_aware_allocators : ExtWarn<
+  "type aware allocators are a C++2c extension">, InGroup<CXX26>;
+def warn_cxx26_type_aware_allocators : Warning<
+  "type aware allocators are incompatible with C++ standards before C++2c">,
   DefaultIgnore, InGroup<CXXPre26Compat>;
 def err_no_type_aware_cleanup_operator_delete : Error<
   "type aware %0 requires there to be a corresponding cleanup %1 in %2">;

clang/lib/Sema/SemaDeclCXX.cpp

@@ -16444,9 +16444,12 @@ static inline bool CheckOperatorNewDeleteTypes(
     if (!SemaRef.getLangOpts().TypeAwareAllocators)
       return SemaRef.Diag(FnDecl->getLocation(),
                           diag::err_unsupported_type_aware_allocator);
-    if (!SemaRef.getLangOpts().CPlusPlus26)
-      SemaRef.Diag(FnDecl->getLocation(),
-                   diag::warn_cxx26_type_aware_allocator);
+    if (!FnDecl->isTemplateInstantiation()) {
+      unsigned DiagID = SemaRef.getLangOpts().CPlusPlus26
+                            ? diag::warn_cxx26_type_aware_allocators
+                            : diag::ext_cxx26_type_aware_allocators;
+      SemaRef.Diag(FnDecl->getLocation(), DiagID);
+    }
 
     if (OperatorKind == AllocationOperatorKind::New) {
       SizeParameterIndex = 1;

clang/test/SemaCXX/type-aware-new-delete-basic-in-class-declarations.cpp

@@ -1,7 +1,7 @@
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++23    -fcxx-type-aware-allocators
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -DNO_TAA  -std=c++23 -fno-cxx-type-aware-allocators
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -DNO_TAA  -std=c++26 -fno-cxx-type-aware-allocators
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify=expected,precxx26 %s           -std=c++23    -fcxx-type-aware-allocators 
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s                             -std=c++26
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify=expected,precxx26 %s -DNO_TAA  -std=c++23 -fno-cxx-type-aware-allocators
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -DNO_TAA                    -std=c++26 -fno-cxx-type-aware-allocators
 
 namespace std {
   template <class T> struct type_identity {};
@@ -18,6 +18,9 @@ struct S {
 #if defined(NO_TAA)
   //expected-error@#1 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
   //expected-error@#2 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
+#else
+  // precxx26-warning@#1 {{type aware allocators are a C++2c extension}}
+  // precxx26-warning@#2 {{type aware allocators are a C++2c extension}}
 #endif
   void operator delete(S *, std::destroying_delete_t);
 };
@@ -28,6 +31,9 @@ template <typename T> struct S2 {
 #if defined(NO_TAA)
   //expected-error@#3 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
   //expected-error@#4 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
+#else
+  // precxx26-warning@#3 {{type aware allocators are a C++2c extension}}
+  // precxx26-warning@#4 {{type aware allocators are a C++2c extension}}
 #endif
   void operator delete(S2 *, std::destroying_delete_t);
 };
@@ -38,6 +44,9 @@ struct S3 {
 #if defined(NO_TAA)
   //expected-error@#5 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
   //expected-error@#6 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
+#else
+  // precxx26-warning@#5 {{type aware allocators are a C++2c extension}}
+  // precxx26-warning@#6 {{type aware allocators are a C++2c extension}}
 #endif
   void operator delete(S3 *, std::destroying_delete_t);
 };
@@ -51,6 +60,8 @@ struct S4 {
   //expected-error@#8 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
   //expected-error@#9 {{type aware destroying delete is not permitted in C++26}}
 #else
+  // precxx26-warning@#7 {{type aware allocators are a C++2c extension}}
+  // precxx26-warning@#8 {{type aware allocators are a C++2c extension}}
   // expected-error@#9 {{type aware destroying delete is not permitted in C++26}}
 #endif
 };
@@ -65,6 +76,7 @@ struct S5 {
   // expected-error@#10 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
 #else
   // expected-error@#10 {{type aware 'operator delete' cannot take a dependent type as its second parameter}}
+  // precxx26-warning@#10 {{type aware allocators are a C++2c extension}}
 #endif
 };
 
@@ -74,12 +86,14 @@ struct S6 {
   // expected-error@#11 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
 #else
   // expected-error@#11 {{type aware 'operator new' cannot take a dependent type as its second parameter}}
+  // precxx26-warning@#11 {{type aware allocators are a C++2c extension}}
 #endif
   template <typename T> void operator delete(std::type_identity<S6>, T, size_t, std::align_val_t); // #12
 #if defined(NO_TAA)
   // expected-error@#12 {{type aware allocation operators are disabled, enable with '-fcxx-type-aware-allocators'}}
 #else
   // expected-error@#12 {{type aware 'operator delete' cannot take a dependent type as its second parameter}}
+  // precxx26-warning@#12 {{type aware allocators are a C++2c extension}}
 #endif
 };
 
@@ -88,8 +102,10 @@ template <typename U>
 struct S7 {
   template <typename T> void *operator new(std::type_identity<T>, U, std::align_val_t); // #13
   // expected-error@#13 {{type aware 'operator new' cannot take a dependent type as its second parameter;}}
+  // precxx26-warning@#13 {{type aware allocators are a C++2c extension}}
   template <typename T> void operator delete(std::type_identity<T>, U, size_t, std::align_val_t); // #14
   // expected-error@#14 {{type aware 'operator delete' cannot take a dependent type as its second parameter;}}
+  // precxx26-warning@#14 {{type aware allocators are a C++2c extension}}
   template <typename T> void operator delete(std::type_identity<T>, S7 *, std::destroying_delete_t, U, std::align_val_t); // #15
   // expected-error@#15 {{type aware destroying delete is not permitted in C++26}}
   void operator delete(S7 *, std::destroying_delete_t, U); // #16
@@ -104,8 +120,10 @@ void f() {
 struct S8 {
   template <typename T, typename U> void *operator new(std::type_identity<T>, U, std::align_val_t); // #17
   // expected-error@#17 {{type aware 'operator new' cannot take a dependent type as its second parameter;}}
+  // precxx26-warning@#17 {{type aware allocators are a C++2c extension}}
   template <typename T, typename U> void operator delete(std::type_identity<T>, U, size_t, std::align_val_t); // #18
   // expected-error@#18 {{type aware 'operator delete' cannot take a dependent type as its second parameter;}}
+  // precxx26-warning@#18 {{type aware allocators are a C++2c extension}}
   template <typename T, typename U> void operator delete(std::type_identity<T>, S8 *, std::destroying_delete_t, U, std::align_val_t); // #19
   // expected-error@#19 {{type aware destroying delete is not permitted in C++26}}
 };
@@ -116,16 +134,24 @@ typedef std::type_identity<double> TypedefAlias;
 using UsingAlias = std::type_identity<float>;
 struct S9 {
   void *operator new(Alias<size_t>, std::align_val_t);
-  template <typename T> void *operator new(Alias<std::type_identity<T>>, Alias<size_t>, std::align_val_t);
+  template <typename T> void *operator new(Alias<std::type_identity<T>>, Alias<size_t>, std::align_val_t); // #20
+  // precxx26-warning@#20 {{type aware allocators are a C++2c extension}}
   void *operator new(Alias<std::type_identity<int>>, size_t, std::align_val_t);
-  template <typename T> void operator delete(Alias<std::type_identity<T>>, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
+  template <typename T> void operator delete(Alias<std::type_identity<T>>, void *, size_t, std::align_val_t); // #21
+  // precxx26-warning@#21{{type aware allocators are a C++2c extension}}
   void operator delete(Alias<std::type_identity<int>>, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
 };
 struct S10 {
-  template <typename T> void *operator new(TypeIdentityAlias<T>, size_t, std::align_val_t);
+  template <typename T> void *operator new(TypeIdentityAlias<T>, size_t, std::align_val_t); // #22
+  // precxx26-warning@#22 {{type aware allocators are a C++2c extension}}
   void *operator new(TypeIdentityAlias<int>, size_t, std::align_val_t);
-  template <typename T> void operator delete(TypeIdentityAlias<T>, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
+  template <typename T> void operator delete(TypeIdentityAlias<T>, void *, size_t, std::align_val_t); // #23
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void operator delete(TypeIdentityAlias<int>, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
 };
 
 void test() {
@@ -137,20 +163,30 @@ void test() {
 
 struct S11 {
   template <typename T> void *operator new(TypedefAlias, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void *operator new(TypedefAlias, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   template <typename T> void operator delete(TypedefAlias, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void operator delete(TypedefAlias, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
 };
 struct S12 {
   template <typename T> void *operator new(UsingAlias, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void *operator new(UsingAlias, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   template <typename T> void operator delete(UsingAlias, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void operator delete(UsingAlias, void *, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
 };
 
 struct S13 {
   void *operator new(std::type_identity<S13>, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
   void operator delete(std::type_identity<S13>, void*, size_t, std::align_val_t);
+  // precxx26-warning@-1 {{type aware allocators are a C++2c extension}}
 };
 
 #endif

clang/test/SemaCXX/type-aware-new-delete-basic-resolution.cpp

@@ -1,7 +1,7 @@
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++23 -fcxx-type-aware-allocators -fexceptions    -fsized-deallocation    -faligned-allocation
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++23 -fcxx-type-aware-allocators -fexceptions -fno-sized-deallocation    -faligned-allocation
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++23 -fcxx-type-aware-allocators -fexceptions    -fsized-deallocation -fno-aligned-allocation
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++23 -fcxx-type-aware-allocators -fexceptions -fno-sized-deallocation -fno-aligned-allocation
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++26 -fexceptions    -fsized-deallocation    -faligned-allocation
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++26 -fexceptions -fno-sized-deallocation    -faligned-allocation
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++26 -fexceptions    -fsized-deallocation -fno-aligned-allocation
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s        -std=c++26 -fexceptions -fno-sized-deallocation -fno-aligned-allocation
 
 namespace std {
   template <class T> struct type_identity {};