More cleanup following mandatory arguments, responding to review comments

Author: ojhunt

clang/docs/CXXTypeAwareAllocators.rst

@@ -61,7 +61,6 @@ Using Clang as a Compiler
    APINotes
    DebuggingCoroutines
    AMDGPUSupport
-   CXXTypeAwareAllocators
    CommandGuide/index
    FAQ
 

clang/docs/index.rst

@@ -2637,6 +2637,7 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   bool isTypedefNameType() const;               // typedef or alias template
 
   bool isTypeIdentitySpecialization() const; // std::type_identity<X> for any X
+  bool isDestroyingDeleteT() const;
 
   TemplateDecl *TryGetSpecializedTemplateDecl() const;
 

clang/include/clang/AST/Type.h

@@ -9839,10 +9839,14 @@ def err_operator_delete_param_type : Error<
 def err_destroying_operator_delete_not_usual : Error<
   "destroying operator delete can have only an optional size and optional "
   "alignment parameter">;
+
 def err_type_aware_destroying_operator_delete : Error<
-  "type aware destroying delete is not permitted, enable with '-fexperimental-cxx-type-aware-destroying-delete'">;
+  "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 '-fexperimental-cxx-type-aware-allocators'">;
+  "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">,
+  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">;
 def err_type_aware_cleanup_deallocator_context_mismatch : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -624,6 +624,7 @@ defvar cpp14 = LangOpts<"CPlusPlus14">;
 defvar cpp17 = LangOpts<"CPlusPlus17">;
 defvar cpp20 = LangOpts<"CPlusPlus20">;
 defvar cpp23 = LangOpts<"CPlusPlus23">;
+defvar cpp26 = LangOpts<"CPlusPlus26">;
 defvar c99 = LangOpts<"C99">;
 defvar c23 = LangOpts<"C23">;
 defvar lang_std = LangOpts<"LangStd">;
@@ -3521,9 +3522,9 @@ def : Flag<["-"], "faligned-new">, Alias<faligned_allocation>;
 def : Flag<["-"], "fno-aligned-new">, Alias<fno_aligned_allocation>;
 def faligned_new_EQ : Joined<["-"], "faligned-new=">;
 
-defm cxx_type_aware_allocators : BoolFOption<"experimental-cxx-type-aware-allocators",
-  LangOpts<"TypeAwareAllocators">, DefaultFalse,
-  PosFlag<SetTrue, [], [ClangOption], "Enable experimental C++ type aware allocator operators">,
+defm cxx_type_aware_allocators : BoolFOption<"cxx-type-aware-allocators",
+  LangOpts<"TypeAwareAllocators">, Default<cpp26.KeyPath>,
+  PosFlag<SetTrue, [], [ClangOption], "Enable C++26 type aware allocator operators">,
   NegFlag<SetFalse>, BothFlags<[], [ClangOption, CC1Option]>>;
 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;

clang/include/clang/Driver/Options.td

@@ -3395,22 +3395,36 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
     return false;
 
-  bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
-  // address, (size or hot_cold_t), alignment, no_throw_t
-  unsigned MaxImplicitParameters = 4;
-  unsigned MaxParamCount = IsTypeAware + MaxImplicitParameters;
+  if (isVariadic())
+    return false;
+
+  if (isTypeAwareOperatorNewOrDelete()) {
+    bool IsDelete = getDeclName().isOperatorDelete();
+    unsigned RequiredParameterCount = IsDelete ? FunctionDecl::RequiredTypeAwareDeleteParameterCount : FunctionDecl::RequiredTypeAwareNewParameterCount;
+    if (AlignmentParam)
+      *AlignmentParam = /* type identity */ 1  + /* address */ IsDelete + /* size */ 1;
+    if (RequiredParameterCount == getNumParams())
+      return true;
+    if (getNumParams() > RequiredParameterCount + 1)
+      return false;
+    if (!getParamDecl(RequiredParameterCount)->getType()->isNothrowT())
+      return false;
+
+    if (IsNothrow)
+        *IsNothrow = true;
+    return true;
+  }
+
   const auto *FPT = getType()->castAs<FunctionProtoType>();
-  if (FPT->getNumParams() == 0 || FPT->getNumParams() > MaxParamCount ||
-      FPT->isVariadic())
+  if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4)
     return false;
 
-  unsigned MinimumParamCount = IsTypeAware + 1;
   // If this is a single-parameter function, it must be a replaceable global
   // allocation or deallocation function.
-  if (FPT->getNumParams() == MinimumParamCount)
+  if (FPT->getNumParams() == 1)
     return true;
 
-  unsigned Params = MinimumParamCount;
+  unsigned Params = 1;
   QualType Ty = FPT->getParamType(Params);
   const ASTContext &Ctx = getASTContext();
 
@@ -3421,7 +3435,7 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
 
   // In C++14, the next parameter can be a 'std::size_t' for sized delete.
   bool IsSizedDelete = false;
-  if ((IsTypeAware || Ctx.getLangOpts().SizedDeallocation) &&
+  if (Ctx.getLangOpts().SizedDeallocation &&
       (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
        getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
       Ctx.hasSameType(Ty, Ctx.getSizeType())) {
@@ -3431,8 +3445,7 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
 
   // In C++17, the next parameter can be a 'std::align_val_t' for aligned
   // new/delete.
-  if ((IsTypeAware || Ctx.getLangOpts().AlignedAllocation) && !Ty.isNull() &&
-      Ty->isAlignValT()) {
+  if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
     Consume();
     if (AlignmentParam)
       *AlignmentParam = Params;
@@ -3505,9 +3518,7 @@ bool FunctionDecl::isDestroyingOperatorDelete() const {
   if (isTypeAwareOperatorNewOrDelete())
     return false;
 
-  auto *RD = getParamDecl(1)->getType()->getAsCXXRecordDecl();
-  return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
-         RD->getIdentifier()->isStr("destroying_delete_t");
+  return getParamDecl(1)->getType()->isDestroyingDeleteT();
 }
 
 bool FunctionDecl::isTypeAwareOperatorNewOrDelete() const {

clang/lib/AST/Decl.cpp

@@ -3134,6 +3134,12 @@ bool Type::isStdByteType() const {
   return false;
 }
 
+bool Type::isDestroyingDeleteT() const {
+  auto *RD = getAsCXXRecordDecl();
+  return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
+         RD->getIdentifier()->isStr("destroying_delete_t");
+}
+
 TemplateDecl *Type::TryGetSpecializedTemplateDecl() const {
   auto UnderlyingType = getCanonicalTypeInternal();
   if (auto *TST = UnderlyingType->getAs<TemplateSpecializationType>())

clang/lib/AST/Type.cpp

@@ -7188,9 +7188,13 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
       types::isCXX(InputType))
     CmdArgs.push_back("-fcoro-aligned-allocation");
 
-  if (Args.hasFlag(options::OPT_fcxx_type_aware_allocators,
-                   options::OPT_fno_cxx_type_aware_allocators, false))
-    CmdArgs.push_back("-fexperimental-cxx-type-aware-allocators");
+  if (Arg *A = Args.getLastArg(options::OPT_fcxx_type_aware_allocators,
+      options::OPT_fno_cxx_type_aware_allocators)) {
+    if (A->getOption().matches(options::OPT_fno_cxx_type_aware_allocators))
+      CmdArgs.push_back("-fno-cxx-type-aware-allocators");
+    else
+      CmdArgs.push_back("-fcxx-type-aware-allocators");
+  }
 
   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
                   options::OPT_fno_double_square_bracket_attributes);