A pile of refactoring that i think cleans up the logic

Author: ojhunt

clang/include/clang/AST/Type.h

@@ -2639,7 +2639,10 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   bool isTypeIdentitySpecialization() const; // std::type_identity<X> for any X
   bool isDestroyingDeleteT() const;
 
-  TemplateDecl *tryGetSpecializedTemplateDecl() const;
+  /// If this type is a template specialization return the TemplateDecl
+  /// that was specialized. It this is not a template specialization,
+  /// returns NULL.
+  TemplateDecl *getSpecializedTemplateDecl() const;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   bool is##Id##Type() const;

clang/lib/AST/DeclCXX.cpp

@@ -2533,37 +2533,46 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
       getOverloadedOperator() != OO_Array_Delete)
     return false;
 
-  bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
-  if (IsTypeAware && isVariadic())
-    return false;
+  if (isTypeAwareOperatorNewOrDelete()) {
+    // A variadic type aware allocation function is not a usual deallocation
+    // function
+    if (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, only the type-identity
-  //   parameter is dependent, and there is no parameter pack in the argument
-  //   list.
-  if (FunctionTemplateDecl *PrimaryTemplate = getPrimaryTemplate()) {
-    if (!IsTypeAware)
-      // Stop early on if the specialization is not explicitly type aware
+    // Type aware deallocation functions are only usual if they only accept the
+    // mandatory arguments
+    if (getNumParams() != FunctionDecl::RequiredTypeAwareDeleteParameterCount)
       return false;
 
+    FunctionTemplateDecl *PrimaryTemplate = getPrimaryTemplate();
+    if (!PrimaryTemplate)
+      return true;
+
+    // A template instance is is only a usual deallocation function if it has a
+    // type-identity parameter, the type-identity parameter is a dependent type
+    // (i.e. the type-identity parameter is of type std::type_identity<U> where
+    // U shall be a dependent type), and the type-identity parameter is the only
+    // dependent parameter, and there are no template packs in the parameter
+    // list.
     FunctionDecl *SpecializedDecl = PrimaryTemplate->getTemplatedDecl();
-    // A type aware allocation function template is only valid if the first
-    // parameter is dependent
     if (!SpecializedDecl->getParamDecl(0)->getType()->isDependentType())
       return false;
-
-    // and none of the other parameters are dependent
     for (unsigned Idx = 1; Idx < getNumParams(); ++Idx) {
       if (SpecializedDecl->getParamDecl(Idx)->getType()->isDependentType())
         return false;
     }
+    return true;
   }
 
+  // C++ [basic.stc.dynamic.deallocation]p2:
+  //   A template instance is never a usual deallocation function,
+  //   regardless of its signature.
+  // Post-P2719 adoption:
+  //   A template instance is is only a usual deallocation function if it has a
+  //   type-identity parameter
+  if (getPrimaryTemplate())
+    return false;
+
   // C++ [basic.stc.dynamic.deallocation]p2:
   //   If a class T has a member deallocation function named operator delete
   //   with exactly one parameter, then that function is a usual (non-placement)
@@ -2572,18 +2581,13 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
     return true;
   unsigned UsualParams = 1;
 
-  if (IsTypeAware)
-    ++UsualParams;
-
   // C++ P0722:
   //   A destroying operator delete is a usual deallocation function if
   //   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()) {
-    assert(!IsTypeAware);
+  if (isDestroyingOperatorDelete())
     ++UsualParams;
-  }
 
   // C++ <=14 [basic.stc.dynamic.deallocation]p2:
   //   [...] If class T does not declare such an operator delete but does
@@ -2595,11 +2599,6 @@ 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(),
@@ -2619,8 +2618,8 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
   // FIXME(EricWF): Destroying Delete should be a language option. How do we
   // handle when destroying delete is used prior to C++17?
   if (Context.getLangOpts().CPlusPlus17 ||
-      Context.getLangOpts().AlignedAllocation || isDestroyingOperatorDelete() ||
-      IsTypeAware)
+      Context.getLangOpts().AlignedAllocation ||
+      isDestroyingOperatorDelete())
     return true;
 
   // This function is a usual deallocation function if there are no

clang/lib/AST/Type.cpp

@@ -3140,7 +3140,7 @@ bool Type::isDestroyingDeleteT() const {
          RD->getIdentifier()->isStr("destroying_delete_t");
 }
 
-TemplateDecl *Type::tryGetSpecializedTemplateDecl() const {
+TemplateDecl *Type::getSpecializedTemplateDecl() const {
   auto UnderlyingType = getCanonicalTypeInternal();
   if (auto *TST = UnderlyingType->getAs<TemplateSpecializationType>())
     return TST->getTemplateName().getAsTemplateDecl();
@@ -3152,7 +3152,7 @@ TemplateDecl *Type::tryGetSpecializedTemplateDecl() const {
 }
 
 bool Type::isTypeIdentitySpecialization() const {
-  const TemplateDecl *STDecl = tryGetSpecializedTemplateDecl();
+  const TemplateDecl *STDecl = getSpecializedTemplateDecl();
   if (!STDecl)
     return false;
   IdentifierInfo *II = STDecl->getIdentifier();

clang/lib/CodeGen/CGExprCXX.cpp

@@ -1844,15 +1844,16 @@ void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
   auto Params = getUsualDeleteParams(DeleteFD);
   auto ParamTypeIt = DeleteFTy->param_type_begin();
 
-  llvm::SmallVector<llvm::AllocaInst *, 2> TagAllocas;
+  std::optional<llvm::AllocaInst *> TagAlloca;
   auto EmitTag = [&](QualType TagType, const char *TagName) {
+    assert(!TagAlloca);
     llvm::Type *Ty = getTypes().ConvertType(TagType);
     CharUnits Align = CGM.getNaturalTypeAlignment(TagType);
     llvm::AllocaInst *TagAllocation = CreateTempAlloca(Ty, TagName);
     TagAllocation->setAlignment(Align.getAsAlign());
     DeleteArgs.add(RValue::getAggregate(Address(TagAllocation, Ty, Align)),
                    TagType);
-    TagAllocas.push_back(TagAllocation);
+    TagAlloca = TagAllocation;
   };
 
   // Pass std::type_identity tag if present
@@ -1903,14 +1904,11 @@ void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
   // Emit the call to delete.
   EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
 
-  // If call argument lowering didn't use the tag arguments allocas we remove
-  // them
-  for (auto *TagAlloca : TagAllocas) {
-    if (TagAlloca && TagAlloca->use_empty())
-      TagAlloca->eraseFromParent();
-  }
+  // If call argument lowering didn't use a generated tag argument alloca we
+  // remove them
+  if (TagAlloca && (*TagAlloca)->use_empty())
+    (*TagAlloca)->eraseFromParent();
 }
-
 namespace {
   /// Calls the given 'operator delete' on a single object.
   struct CallObjectDelete final : EHScopeStack::Cleanup {

clang/lib/Sema/SemaDeclCXX.cpp

@@ -16422,8 +16422,8 @@ enum class AllocationOperatorKind { New, Delete };
 static inline bool CheckOperatorNewDeleteTypes(
     Sema &SemaRef, const FunctionDecl *FnDecl,
     AllocationOperatorKind OperatorKind, CanQualType ExpectedResultType,
-    CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag,
-    unsigned InvalidParamTypeDiag, unsigned *MinimumNonDefaultArgs) {
+    CanQualType ExpectedSizeOrAddressParamType, unsigned DependentParamTypeDiag,
+    unsigned InvalidParamTypeDiag) {
   auto NormalizeType = [&SemaRef](QualType T) {
     if (SemaRef.getLangOpts().OpenCLCPlusPlus) {
       // The operator is valid on any address space for OpenCL.
@@ -16467,18 +16467,26 @@ static inline bool CheckOperatorNewDeleteTypes(
     ++MinimumMandatoryArgumentCount;
     ++SizeParameterIndex;
   }
-  *MinimumNonDefaultArgs = MinimumMandatoryArgumentCount;
 
   if (FnDecl->getNumParams() < MinimumMandatoryArgumentCount)
     return SemaRef.Diag(FnDecl->getLocation(),
                         diag::err_operator_new_delete_too_few_parameters)
            << IsPotentiallyTypeAware << IsDestroyingDelete
            << FnDecl->getDeclName() << MinimumMandatoryArgumentCount;
 
+  for (unsigned Idx = 0; Idx < MinimumMandatoryArgumentCount; ++Idx) {
+    const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
+    if (ParamDecl->hasDefaultArg())
+      return SemaRef.Diag(FnDecl->getLocation(),
+                          diag::err_operator_new_default_arg)
+             << FnDecl->getDeclName() << Idx << ParamDecl->getDefaultArgRange();
+  }
+
   auto *FnType = FnDecl->getType()->castAs<FunctionType>();
   QualType CanResultType = NormalizeType(FnType->getReturnType());
   QualType CanExpectedResultType = NormalizeType(ExpectedResultType);
-  QualType CanExpectedFirstParamType = NormalizeType(ExpectedFirstParamType);
+  QualType CanExpectedSizeOrAddressParamType =
+      NormalizeType(ExpectedSizeOrAddressParamType);
 
   // Check that the result type is what we expect.
   if (CanResultType != CanExpectedResultType) {
@@ -16520,12 +16528,11 @@ static inline bool CheckOperatorNewDeleteTypes(
   };
 
   // Check that the first parameter type is what we expect.
-  if (CheckType(FirstNonTypeParam, CanExpectedFirstParamType, "size_t"))
+  if (CheckType(FirstNonTypeParam, CanExpectedSizeOrAddressParamType, "size_t"))
     return true;
 
-  // If the first parameter type is a type_identity specialization
-  // we need to ensure the remaining mandatory parameters are present
-  // and have the correct type
+  // If the first parameter type is not a type-identity we're done, otherwise
+  // we need to ensure the size and alignment parameters have the correct type
   if (!IsPotentiallyTypeAware)
     return false;
 
@@ -16554,24 +16561,10 @@ CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
   // C++ [basic.stc.dynamic.allocation]p1:
   //  The return type shall be void*. The first parameter shall have type
   //  std::size_t.
-  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, AllocationOperatorKind::New,
-                                  SemaRef.Context.VoidPtrTy, SizeTy,
-                                  diag::err_operator_new_dependent_param_type,
-                                  diag::err_operator_new_param_type,
-                                  &MinimumNonDefaultArgs))
-    return true;
-  assert(MinimumNonDefaultArgs > 0 && MinimumNonDefaultArgs <= 4);
-  // C++ [basic.stc.dynamic.allocation]p1:
-  //  The first parameter shall not have an associated default argument.
-  for (unsigned Idx = 0; Idx < MinimumNonDefaultArgs; ++Idx) {
-    const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
-    if (ParamDecl->hasDefaultArg()) {
-      return SemaRef.Diag(FnDecl->getLocation(),
-                          diag::err_operator_new_default_arg)
-             << FnDecl->getDeclName() << Idx << ParamDecl->getDefaultArgRange();
-    }
-  }
-  return false;
+  return CheckOperatorNewDeleteTypes(
+      SemaRef, FnDecl, AllocationOperatorKind::New, SemaRef.Context.VoidPtrTy,
+      SizeTy, diag::err_operator_new_dependent_param_type,
+      diag::err_operator_new_param_type);
 }
 
 static bool
@@ -16590,20 +16583,12 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
         SemaRef.Context.getRecordType(MD->getParent())));
   };
 
-  // C++ P0722:
-  //   Within a class C, the first parameter of a destroying operator delete
-  //   shall be of type C *. The first parameter of any other deallocation
-  //   function shall be of type void *.
-  CanQualType ExpectedFirstParamType =
-      MD && MD->isDestroyingOperatorDelete()
-          ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
-                SemaRef.Context.getRecordType(MD->getParent())))
-          : SemaRef.Context.VoidPtrTy;
-
   // C++ P2719: A destroying operator delete cannot be type aware
   // so as a QoL we actually check for this explicitly
-  bool IsTypeAwareClassMethod = MD && MD->isTypeAwareOperatorNewOrDelete();
-  if (IsTypeAwareClassMethod && MD->getNumParams() > 1) {
+  bool IsPotentiallyTypeAwareClassMethod =
+      MD && MD->getNumParams() > 0 &&
+      MD->getParamDecl(0)->getType()->isTypeIdentitySpecialization();
+  if (IsPotentiallyTypeAwareClassMethod) {
     QualType AddressParamType =
         SemaRef.Context.getCanonicalType(MD->getParamDecl(1)->getType());
     if (AddressParamType != SemaRef.Context.VoidPtrTy &&
@@ -16626,19 +16611,25 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
     }
   }
 
-  unsigned MinimumNonDefaultArgs = 0;
+  // C++ P0722:
+  //   Within a class C, the first parameter of a destroying operator delete
+  //   shall be of type C *. The first parameter of any other deallocation
+  //   function shall be of type void *.
+  CanQualType ExpectedAddressParamType =
+      MD && MD->isDestroyingOperatorDelete()
+          ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
+                SemaRef.Context.getRecordType(MD->getParent())))
+          : SemaRef.Context.VoidPtrTy;
+
   // C++ [basic.stc.dynamic.deallocation]p2:
   //   Each deallocation function shall return void
   if (CheckOperatorNewDeleteTypes(
           SemaRef, FnDecl, AllocationOperatorKind::Delete,
-          SemaRef.Context.VoidTy, ExpectedFirstParamType,
+          SemaRef.Context.VoidTy, ExpectedAddressParamType,
           diag::err_operator_delete_dependent_param_type,
-          diag::err_operator_delete_param_type, &MinimumNonDefaultArgs))
+          diag::err_operator_delete_param_type))
     return true;
 
-  assert(MinimumNonDefaultArgs > 0 &&
-         MinimumNonDefaultArgs <=
-             FunctionDecl::RequiredTypeAwareDeleteParameterCount);
   // C++ P0722:
   //   A destroying operator delete shall be a usual deallocation function.
   if (MD && !MD->getParent()->isDependentContext() &&
@@ -16649,14 +16640,6 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
       return true;
     }
   }
-  for (unsigned Idx = 0; Idx < MinimumNonDefaultArgs; ++Idx) {
-    const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
-    if (ParamDecl->hasDefaultArg()) {
-      return SemaRef.Diag(FnDecl->getLocation(),
-                          diag::err_operator_new_default_arg)
-             << FnDecl->getDeclName() << ParamDecl->getDefaultArgRange();
-    }
-  }
 
   return false;
 }

clang/lib/Sema/SemaInit.cpp

@@ -9902,7 +9902,7 @@ QualType Sema::DeduceTemplateSpecializationFromInitializer(
       // C++ [over.match.class.deduct#3]: ..., the defining-type-id of A must be
       // of the form
       //   [typename] [nested-name-specifier] [template] simple-template-id
-      auto SpecializedTD = UnderlyingType->tryGetSpecializedTemplateDecl();
+      auto SpecializedTD = UnderlyingType->getSpecializedTemplateDecl();
       Template = dyn_cast_or_null<ClassTemplateDecl>(SpecializedTD);
     }
   }