Pile of clean up and updates

Author: ojhunt

clang/include/clang/AST/Decl.h

@@ -2537,7 +2537,21 @@ class FunctionDecl : public DeclaratorDecl,
 
   /// Determines whether this function is one of the replaceable global
   /// allocation functions described in isReplaceableGlobalAllocationFunction,
-  /// or is a function that may be treated as such during constant evaluation
+  /// or is a function that may be treated as such during constant evaluation.
+  /// This adds support for potentially templated type aware global allocation
+  /// functions of the form:
+  ///    void *operator new(type-identity, std::size_t, std::align_val_t)
+  ///    void *operator new(type-identity, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  ///    void *operator new[](type-identity, std::size_t, std::align_val_t)
+  ///    void *operator new[](type-identity, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  ///    void operator delete(type-identity, void*, std::size_t, std::align_val_t) noexcept;
+  ///    void operator delete(type-identity, void*, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  ///    void operator delete[](type-identity, void*, std::size_t, std::align_val_t) noexcept;
+  ///    void operator delete[](type-identity, void*, std::size_t, std::align_val_t, const std::nothrow_t &) noexcept;
+  /// Where `type-identity` is a specialization of std::type_identity. If the
+  /// declaration is a templated function, it may not include a parameter pack
+  /// in the argument list, the type-identity parameter is required to be
+  /// dependent, and is the only permitted dependent parameter.
   bool isUsableAsGlobalAllocationFunctionInConstantEvaluation(
       std::optional<unsigned> *AlignmentParam = nullptr,
       bool *IsNothrow = nullptr) const;
@@ -2548,6 +2562,14 @@ class FunctionDecl : public DeclaratorDecl,
   /// Determine whether this is a destroying operator delete.
   bool isDestroyingOperatorDelete() const;
 
+  /// Count of mandatory parameters for type aware operator new
+  static constexpr unsigned RequiredTypeAwareNewParameterCount =
+    /* type-identity */ 1 + /* size */ 1 + /* alignment */ 1;
+
+  /// Count of mandatory parameters for type aware operator delete
+  static constexpr unsigned RequiredTypeAwareDeleteParameterCount =
+    /* type-identity */ 1 + /* address */ 1 + /* size */ 1 + /* alignment */ 1;
+
   /// Determine whether this is a type aware operator new or delete.
   bool isTypeAwareOperatorNewOrDelete() const;
 

clang/include/clang/AST/DeclarationName.h

@@ -477,6 +477,44 @@ class DeclarationName {
     return OO_None;
   }
 
+  bool isOperatorNew() const {
+    if (getNameKind() != DeclarationName::CXXOperatorName)
+      return false;
+    switch (getCXXOverloadedOperator()) {
+    case OO_New:
+    case OO_Array_New:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isOperatorDelete() const {
+    if (getNameKind() != DeclarationName::CXXOperatorName)
+      return false;
+    switch (getCXXOverloadedOperator()) {
+    case OO_Delete:
+    case OO_Array_Delete:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isOperatorNewOrDelete() const {
+    if (getNameKind() != DeclarationName::CXXOperatorName)
+      return false;
+    switch (getCXXOverloadedOperator()) {
+    case OO_New:
+    case OO_Array_New:
+    case OO_Delete:
+    case OO_Array_Delete:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   /// If this name is the name of a literal operator,
   /// retrieve the identifier associated with it.
   const IdentifierInfo *getCXXLiteralIdentifier() const {

clang/include/clang/Basic/Features.def

@@ -317,7 +317,6 @@ FEATURE(clang_atomic_attributes, true)
 
 // Type aware allocators
 FEATURE(cxx_type_aware_allocators, LangOpts.TypeAwareAllocators)
-FEATURE(cxx_type_aware_destroying_delete, LangOpts.TypeAwareDestroyingDelete)
 
 // CUDA/HIP Features
 FEATURE(cuda_noinline_keyword, LangOpts.CUDA)

clang/include/clang/Basic/LangOptions.def

@@ -313,7 +313,6 @@ LANGOPT(OpenACC           , 1, 0, "OpenACC Enabled")
 LANGOPT(MSVCEnableStdcMacro , 1, 0, "Define __STDC__ with '-fms-compatibility'")
 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
 LANGOPT(TypeAwareAllocators , 1, 1, "type aware C++ allocation operators")
-LANGOPT(TypeAwareDestroyingDelete , 1, 1, "type aware C++ destroying delete")
 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")

clang/include/clang/Driver/Options.td

@@ -3527,10 +3527,6 @@ defm cxx_type_aware_allocators : BoolFOption<"experimental-cxx-type-aware-alloca
   LangOpts<"TypeAwareAllocators">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption], "Enable experimental C++ type aware allocator operators">,
   NegFlag<SetFalse>, BothFlags<[], [ClangOption, CC1Option]>>;
-defm cxx_type_aware_destroying_delete : BoolFOption<"experimental-cxx-type-aware-destroying-delete",
-  LangOpts<"TypeAwareDestroyingDelete">, DefaultFalse,
-  PosFlag<SetTrue, [], [ClangOption], "Enable experimental C++ type aware allocator operators for destroying delete">,
-  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>;
 defm objc_infer_related_result_type : BoolFOption<"objc-infer-related-result-type",

clang/lib/AST/ByteCode/Compiler.cpp

@@ -4779,8 +4779,7 @@ bool Compiler<Emitter>::VisitCallExpr(const CallExpr *E) {
   // Calls to replaceable operator new/operator delete.
   if (FuncDecl &&
       FuncDecl->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
-    if (FuncDecl->getDeclName().getCXXOverloadedOperator() == OO_New ||
-        FuncDecl->getDeclName().getCXXOverloadedOperator() == OO_Array_New) {
+    if (FuncDecl->getDeclName().isOperatorNew()) {
       return VisitBuiltinCallExpr(E, Builtin::BI__builtin_operator_new);
     } else {
       assert(FuncDecl->getDeclName().getCXXOverloadedOperator() == OO_Delete);

clang/lib/AST/Decl.cpp

@@ -3362,12 +3362,7 @@ bool FunctionDecl::isMSVCRTEntryPoint() const {
 }
 
 bool FunctionDecl::isReservedGlobalPlacementOperator() const {
-  if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
-    return false;
-  if (getDeclName().getCXXOverloadedOperator() != OO_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Delete &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
+  if (!getDeclName().isOperatorNewOrDelete())
     return false;
 
   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
@@ -3390,12 +3385,7 @@ bool FunctionDecl::isReservedGlobalPlacementOperator() const {
 
 bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
     std::optional<unsigned> *AlignmentParam, bool *IsNothrow) const {
-  if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
-    return false;
-  if (getDeclName().getCXXOverloadedOperator() != OO_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Delete &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
+  if (!getDeclName().isOperatorNewOrDelete())
     return false;
 
   if (isa<CXXRecordDecl>(getDeclContext()))
@@ -3406,7 +3396,9 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
     return false;
 
   bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
-  unsigned MaxParamCount = IsTypeAware + 4;
+  // address, (size or hot_cold_t), alignment, no_throw_t
+  unsigned MaxImplicitParameters = 4;
+  unsigned MaxParamCount = IsTypeAware + MaxImplicitParameters;
   const auto *FPT = getType()->castAs<FunctionProtoType>();
   if (FPT->getNumParams() == 0 || FPT->getNumParams() > MaxParamCount ||
       FPT->isVariadic())
@@ -3506,32 +3498,28 @@ bool FunctionDecl::isDestroyingOperatorDelete() const {
   //   Within a class C, a single object deallocation function with signature
   //     (T, std::destroying_delete_t, <more params>)
   //   is a destroying operator delete.
-  if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete)
+  if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||
+      getNumParams() < 2)
     return false;
 
-  unsigned DestroyingDeleteTagParam = 1;
   if (isTypeAwareOperatorNewOrDelete())
-    ++DestroyingDeleteTagParam;
-
-  if (getNumParams() <= DestroyingDeleteTagParam)
     return false;
 
-  auto *RD =
-      getParamDecl(DestroyingDeleteTagParam)->getType()->getAsCXXRecordDecl();
+  auto *RD = getParamDecl(1)->getType()->getAsCXXRecordDecl();
   return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
          RD->getIdentifier()->isStr("destroying_delete_t");
 }
 
 bool FunctionDecl::isTypeAwareOperatorNewOrDelete() const {
-  if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
-    return false;
-  if (getDeclName().getCXXOverloadedOperator() != OO_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Delete &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
-      getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
-    return false;
-  if (getNumParams() < 2)
+  if (getDeclName().isOperatorNew()) {
+    if (getNumParams() < FunctionDecl::RequiredTypeAwareNewParameterCount)
+      return false;
+  } else if (getDeclName().isOperatorDelete()) {
+    if (getNumParams() < FunctionDecl::RequiredTypeAwareDeleteParameterCount)
+      return false;
+  } else
     return false;
+
   return getParamDecl(0)->getType()->isTypeIdentitySpecialization();
 }
 

clang/lib/AST/DeclCXX.cpp

@@ -2534,20 +2534,22 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
     return false;
 
   bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
+  if (IsTypeAware && isVariadic())
+      return false;
 
   // C++ [basic.stc.dynamic.deallocation]p2:
   //   Pre-type aware allocators:
   //   A template instance is never a usual deallocation function,
   //   regardless of its signature.
   //   Pending final C++26 text:
   //   A template instance is only a usual deallocation function if it
-  //   is a type aware deallocation function, and only the type-identity
-  //   parameter is dependent.
+  //   is a type aware deallocation function, only the type-identity
+  //   parameter is dependent, and there is no parameter pack in the argument
+  //   list.
   if (FunctionTemplateDecl *PrimaryTemplate = getPrimaryTemplate()) {
-    if (!IsTypeAware) {
+    if (!IsTypeAware)
       // Stop early on if the specialization is not explicitly type aware
       return false;
-    }
 
     FunctionDecl *SpecializedDecl = PrimaryTemplate->getTemplatedDecl();
     // A type aware allocation function template is only valid if the first
@@ -2578,8 +2580,10 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
   //   removing the std::destroying_delete_t parameter and changing the
   //   first parameter type from T* to void* results in the signature of
   //   a usual deallocation function.
-  if (isDestroyingOperatorDelete())
+  if (isDestroyingOperatorDelete()) {
+    assert(!IsTypeAware);
     ++UsualParams;
+  }
 
   // C++ <=14 [basic.stc.dynamic.deallocation]p2:
   //   [...] If class T does not declare such an operator delete but does
@@ -2591,6 +2595,11 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
   //   (void* [, size_t] [, std::align_val_t] [, ...])
   // and all such functions are usual deallocation functions. It's not clear
   // that allowing varargs functions was intentional.
+  //
+  // P2719 extends usual deallocation functions to permit
+  //   (type_identity<U>, void*, size_t, std::align_val_t)
+  // it does not permit variadic or template parameter packs
+
   ASTContext &Context = getASTContext();
   if (UsualParams < getNumParams() &&
       Context.hasSameUnqualifiedType(getParamDecl(UsualParams)->getType(),

clang/lib/AST/ExprConstant.cpp

@@ -8340,8 +8340,7 @@ class ExprEvaluatorBase
         } else
           FD = LambdaCallOp;
       } else if (FD->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
-        if (FD->getDeclName().getCXXOverloadedOperator() == OO_New ||
-            FD->getDeclName().getCXXOverloadedOperator() == OO_Array_New) {
+        if (FD->getDeclName().isOperatorNew()) {
           LValue Ptr;
           if (!HandleOperatorNewCall(Info, E, Ptr))
             return false;

clang/lib/AST/Type.cpp

@@ -3144,7 +3144,7 @@ bool Type::isTypeIdentitySpecialization() const {
   if (!STDecl)
     return false;
   IdentifierInfo *II = STDecl->getIdentifier();
-  return II && STDecl->isInStdNamespace() && II->isStr("type_identity");
+  return STDecl->isInStdNamespace() && II->isStr("type_identity");
 }
 
 bool Type::isSpecifierType() const {