Incorporate last spec changes and remove qualifiers from allocated type

Also update tests for new semantics

Author: ojhunt

clang/include/clang/AST/ExprCXX.h

@@ -2261,21 +2261,19 @@ inline SizedDeallocationMode sizedDeallocationModeFromBool(bool IsSized) {
 }
 
 struct ImplicitAllocationParameters {
-  ImplicitAllocationParameters(QualType Type,
+  ImplicitAllocationParameters(QualType AllocType,
                                TypeAwareAllocationMode PassTypeIdentity,
                                AlignedAllocationMode PassAlignment)
-      : Type(Type.isNull() ? Type : Type.getUnqualifiedType()),
-        PassTypeIdentity(PassTypeIdentity), PassAlignment(PassAlignment) {
-    if (Type.isNull())
-      assert(!isTypeAwareAllocation(PassTypeIdentity));
-    assert(!Type.isNull());
+      : Type(AllocType), PassTypeIdentity(PassTypeIdentity),
+        PassAlignment(PassAlignment) {
+    if (!Type.isNull())
+      Type = Type.getUnqualifiedType();
+    assert(isValid());
   }
   explicit ImplicitAllocationParameters(AlignedAllocationMode PassAlignment)
       : PassTypeIdentity(TypeAwareAllocationMode::No),
         PassAlignment(PassAlignment) {}
-  QualType Type;
-  TypeAwareAllocationMode PassTypeIdentity;
-  AlignedAllocationMode PassAlignment;
+
   unsigned getNumImplicitArgs() const {
     unsigned Count = 1; // Size
     if (isTypeAwareAllocation(PassTypeIdentity))
@@ -2285,33 +2283,35 @@ struct ImplicitAllocationParameters {
     return Count;
   }
   bool isValid() const {
+    if (!Type.isNull() && Type.hasQualifiers())
+      return false;
     if (!isTypeAwareAllocation(PassTypeIdentity))
       return true;
     return !Type.isNull();
   }
+
+  QualType Type;
+  TypeAwareAllocationMode PassTypeIdentity;
+  AlignedAllocationMode PassAlignment;
 };
 
 struct ImplicitDeallocationParameters {
-  ImplicitDeallocationParameters(QualType Type,
+  ImplicitDeallocationParameters(QualType DeallocType,
                                  TypeAwareAllocationMode PassTypeIdentity,
                                  AlignedAllocationMode PassAlignment,
                                  SizedDeallocationMode PassSize)
-      : Type(Type.isNull() ? Type : Type.getUnqualifiedType()),
-        PassTypeIdentity(PassTypeIdentity), PassAlignment(PassAlignment),
-        PassSize(PassSize) {
-    if (Type.isNull())
-      assert(!isTypeAwareAllocation(PassTypeIdentity));
-    assert(!Type.isNull());
+      : Type(DeallocType), PassTypeIdentity(PassTypeIdentity),
+        PassAlignment(PassAlignment), PassSize(PassSize) {
+    if (!Type.isNull())
+      Type = Type.getUnqualifiedType();
+    assert(isValid());
   }
 
   ImplicitDeallocationParameters(AlignedAllocationMode PassAlignment,
                                  SizedDeallocationMode PassSize)
       : PassTypeIdentity(TypeAwareAllocationMode::No),
         PassAlignment(PassAlignment), PassSize(PassSize) {}
-  QualType Type;
-  TypeAwareAllocationMode PassTypeIdentity;
-  AlignedAllocationMode PassAlignment;
-  SizedDeallocationMode PassSize;
+
   unsigned getNumImplicitArgs() const {
     unsigned Count = 1; // Size
     if (isTypeAwareAllocation(PassTypeIdentity))
@@ -2323,10 +2323,19 @@ struct ImplicitDeallocationParameters {
     return Count;
   }
   bool isValid() const {
+    if (!Type.isNull()) {
+      assert(!Type.hasQualifiers());
+      return !Type.hasQualifiers();
+    }
     if (!isTypeAwareAllocation(PassTypeIdentity))
       return true;
     return !Type.isNull();
   }
+
+  QualType Type;
+  TypeAwareAllocationMode PassTypeIdentity;
+  AlignedAllocationMode PassAlignment;
+  SizedDeallocationMode PassSize;
 };
 
 /// Represents a new-expression for memory allocation and constructor

clang/include/clang/Basic/DiagnosticGroups.td

@@ -636,7 +636,6 @@ def Packed : DiagGroup<"packed", [PackedNonPod]>;
 def PaddedBitField : DiagGroup<"padded-bitfield">;
 def Padded : DiagGroup<"padded", [PaddedBitField]>;
 def UnalignedAccess : DiagGroup<"unaligned-access">;
-def StrictTypeAwareAllocators : DiagGroup<"strict-type-aware-allocators">;
 
 def PessimizingMove : DiagGroup<"pessimizing-move">;
 def ReturnStdMove : DiagGroup<"return-std-move">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9768,40 +9768,40 @@ def err_operator_new_delete_invalid_result_type : Error<
 def err_operator_new_delete_dependent_result_type : Error<
   "%0 cannot have a dependent return type; use %1 instead">;
 def err_operator_new_delete_too_few_parameters : Error<
-  "%select{|type aware }0%1 must have at least %select{|one|two|three|four}2 parameter%s2">;
+  "%select{|type aware }0%select{|destroying }1%2 must have at least %select{|one|two|three|four|five}3 parameter%s3">;
 def err_operator_new_delete_template_too_few_parameters : Error<
   "%0 template must have at least two parameters">;
 def warn_operator_new_returns_null : Warning<
   "%0 should not return a null pointer unless it is declared 'throw()'"
   "%select{| or 'noexcept'}1">, InGroup<OperatorNewReturnsNull>;
 
 def err_operator_new_dependent_param_type : Error<
-  "%select{|type aware }0%1 cannot take a dependent type as %select{first|second|third|fourth}2 parameter; "
-  "use %4 (%3) instead">;
+  "%select{|type aware }0%select{|destroying }1%2 cannot take a dependent type as its %select{first|second|third|fourth|fifth}3 parameter; "
+  "use %5 (%4) instead">;
 def err_operator_new_param_type : Error<
-  "%select{|type aware }0%1 takes type %4 (%3) as %select{first|second|third|fourth}2 parameter">;
+  "%select{|type aware }0%select{|destroying }1%2 takes type %5 (%4) as %select{first|second|third|fourth|fifth}3 parameter">;
 def err_operator_new_default_arg: Error<
   "parameter of %0 cannot have a default argument">;
 def err_operator_delete_dependent_param_type : Error<
-  "%select{|type aware }0%1 cannot take a dependent type as %select{first|second|third|fourth}2 parameter; "
-  "use %3 instead">;
+  "%select{|type aware }0%select{|destroying }1%2 cannot take a dependent type as its %select{first|second|third|fourth|fifth}3 parameter; "
+  "use %4 instead">;
 def err_operator_delete_param_type : Error<
-  "%select{first|second|third|fourth}2 parameter of%select{| type aware}0 %1 must have type %3">;
+  "%select{first|second|third|fourth|fifth}3 parameter of%select{| type aware}0%select{| destroying}1 %2 must have type %4">;
 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'">;
 def err_unsupported_type_aware_allocator : Error<
   "type aware allocation operators are disabled, enable with '-fexperimental-cxx-type-aware-allocators'">;
-def warn_type_aware_cleanup_deallocator_context_mismatch : Warning<
-  "type aware %0 requires matching %1 in %2">,
-  InGroup<StrictTypeAwareAllocators>, DefaultError;
+def err_no_type_aware_cleanup_operator_delete : Error<
+  "type aware %0 requires matching cleanup %1 in %2">;
+def err_type_aware_cleanup_deallocator_context_mismatch : Error<
+  "type aware %0 requires matching %1 in %2">;
 def note_type_aware_operator_found : Note<
   "type aware %0 found in %1">;
-def warn_mismatching_type_aware_cleanup_deallocator : Warning<
-  "mismatched type aware allocation operators for constructor cleanup">,
-  InGroup<StrictTypeAwareAllocators>;
+def err_mismatching_type_aware_cleanup_deallocator : Error<
+  "mismatched type aware allocation operators for constructor cleanup">;
 def note_type_aware_operator_declared : Note<
   "%select{|non-}0type aware %1 declared here">;
 def note_implicit_delete_this_in_destructor_here : Note<

clang/include/clang/Sema/Sema.h

@@ -8239,10 +8239,9 @@ class Sema final : public SemaBase {
 
   bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
                                 DeclarationName Name, FunctionDecl *&Operator,
-                                QualType DeallocType,
                                 ImplicitDeallocationParameters,
                                 bool Diagnose = true);
-  FunctionDecl *FindUsualDeallocationFunction(QualType, SourceLocation StartLoc,
+  FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
                                               ImplicitDeallocationParameters,
                                               DeclarationName Name);
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,

clang/lib/AST/ByteCode/Interp.cpp

@@ -1575,7 +1575,8 @@ bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E) {
         return true;
       S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
           << /*C++26 feature*/ 1 << E->getSourceRange();
-    } else if (!OperatorNew->isConstEvalSafeOrReplaceableGlobalAllocationFunction()) {
+    } else if (!OperatorNew
+                    ->isConstEvalSafeOrReplaceableGlobalAllocationFunction()) {
       S.FFDiag(S.Current->getSource(OpPC),
                diag::note_constexpr_new_non_replaceable)
           << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
@@ -1593,7 +1594,8 @@ bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E) {
   } else {
     const auto *DeleteExpr = cast<CXXDeleteExpr>(E);
     const FunctionDecl *OperatorDelete = DeleteExpr->getOperatorDelete();
-    if (!OperatorDelete->isConstEvalSafeOrReplaceableGlobalAllocationFunction()) {
+    if (!OperatorDelete
+             ->isConstEvalSafeOrReplaceableGlobalAllocationFunction()) {
       S.FFDiag(S.Current->getSource(OpPC),
                diag::note_constexpr_new_non_replaceable)
           << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;

clang/lib/CodeGen/CGExprCXX.cpp

@@ -1445,6 +1445,7 @@ namespace {
     LLVM_PREFERRED_TYPE(TypeAwareAllocationMode)
     unsigned PassTypeToPlacementDelete : 1;
     const FunctionDecl *OperatorDelete;
+    RValueTy TypeIdentity;
     ValueTy Ptr;
     ValueTy AllocSize;
     CharUnits AllocAlign;
@@ -1459,15 +1460,15 @@ namespace {
     }
 
     CallDeleteDuringNew(size_t NumPlacementArgs,
-                        const FunctionDecl *OperatorDelete, ValueTy Ptr,
-                        ValueTy AllocSize,
+                        const FunctionDecl *OperatorDelete,
+                        RValueTy TypeIdentity, ValueTy Ptr, ValueTy AllocSize,
                         const ImplicitAllocationParameters &IAP,
                         CharUnits AllocAlign)
         : NumPlacementArgs(NumPlacementArgs),
           PassAlignmentToPlacementDelete(
               isAlignedAllocation(IAP.PassAlignment)),
-          OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
-          AllocAlign(AllocAlign) {}
+          OperatorDelete(OperatorDelete), TypeIdentity(TypeIdentity), Ptr(Ptr),
+          AllocSize(AllocSize), AllocAlign(AllocAlign) {}
 
     void setPlacementArg(unsigned I, RValueTy Arg, QualType Type) {
       assert(I < NumPlacementArgs && "index out of range");
@@ -1484,10 +1485,7 @@ namespace {
         TypeAwareDeallocation = TypeAwareAllocationMode::Yes;
         QualType SpecializedTypeIdentity = FPT->getParamType(0);
         ++FirstNonTypeArg;
-        CXXScalarValueInitExpr TypeIdentityParam(SpecializedTypeIdentity,
-                                                 nullptr, SourceLocation());
-        DeleteArgs.add(CGF.EmitAnyExprToTemp(&TypeIdentityParam),
-                       SpecializedTypeIdentity);
+        DeleteArgs.add(Traits::get(CGF, TypeIdentity), SpecializedTypeIdentity);
       }
       // The first non type tag argument is always a void* (or C* for a
       // destroying operator  delete for class type C).
@@ -1501,6 +1499,7 @@ namespace {
         Params.Alignment =
             alignedAllocationModeFromBool(PassAlignmentToPlacementDelete);
         Params.TypeAwareDelete = TypeAwareDeallocation;
+        Params.Size = isTypeAwareAllocation(Params.TypeAwareDelete);
       } else {
         // For a non-placement new-expression, 'operator delete' can take a
         // size and/or an alignment if it has the right parameters.
@@ -1538,11 +1537,9 @@ namespace {
 
 /// Enter a cleanup to call 'operator delete' if the initializer in a
 /// new-expression throws.
-static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
-                                  const CXXNewExpr *E,
-                                  Address NewPtr,
-                                  llvm::Value *AllocSize,
-                                  CharUnits AllocAlign,
+static void EnterNewDeleteCleanup(CodeGenFunction &CGF, const CXXNewExpr *E,
+                                  RValue TypeIdentity, Address NewPtr,
+                                  llvm::Value *AllocSize, CharUnits AllocAlign,
                                   const CallArgList &NewArgs) {
   unsigned NumNonPlacementArgs = E->getNumImplicitArgs();
 
@@ -1560,7 +1557,7 @@ static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
 
     DirectCleanup *Cleanup = CGF.EHStack.pushCleanupWithExtra<DirectCleanup>(
         EHCleanup, E->getNumPlacementArgs(), E->getOperatorDelete(),
-        NewPtr.emitRawPointer(CGF), AllocSize,
+        TypeIdentity, NewPtr.emitRawPointer(CGF), AllocSize,
         E->implicitAllocationParameters(), AllocAlign);
     for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
       auto &Arg = NewArgs[I + NumNonPlacementArgs];
@@ -1575,7 +1572,8 @@ static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
       DominatingValue<RValue>::save(CGF, RValue::get(NewPtr, CGF));
   DominatingValue<RValue>::saved_type SavedAllocSize =
     DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
-
+  DominatingValue<RValue>::saved_type SavedTypeIdentity =
+      DominatingValue<RValue>::save(CGF, TypeIdentity);
   struct ConditionalCleanupTraits {
     typedef DominatingValue<RValue>::saved_type ValueTy;
     typedef DominatingValue<RValue>::saved_type RValueTy;
@@ -1588,8 +1586,8 @@ static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
   ConditionalCleanup *Cleanup =
       CGF.EHStack.pushCleanupWithExtra<ConditionalCleanup>(
           EHCleanup, E->getNumPlacementArgs(), E->getOperatorDelete(),
-          SavedNewPtr, SavedAllocSize, E->implicitAllocationParameters(),
-          AllocAlign);
+          SavedTypeIdentity, SavedNewPtr, SavedAllocSize,
+          E->implicitAllocationParameters(), AllocAlign);
   for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
     auto &Arg = NewArgs[I + NumNonPlacementArgs];
     Cleanup->setPlacementArg(
@@ -1636,6 +1634,7 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
   // operator, just "inline" it directly.
   Address allocation = Address::invalid();
   CallArgList allocatorArgs;
+  RValue TypeIdentityArg;
   if (allocator->isReservedGlobalPlacementOperator()) {
     assert(E->getNumPlacementArgs() == 1);
     const Expr *arg = *E->placement_arguments().begin();
@@ -1666,8 +1665,8 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
       QualType SpecializedTypeIdentity = allocatorType->getParamType(0);
       CXXScalarValueInitExpr TypeIdentityParam(SpecializedTypeIdentity, nullptr,
                                                SourceLocation());
-      allocatorArgs.add(EmitAnyExprToTemp(&TypeIdentityParam),
-                        SpecializedTypeIdentity);
+      TypeIdentityArg = EmitAnyExprToTemp(&TypeIdentityParam);
+      allocatorArgs.add(TypeIdentityArg, SpecializedTypeIdentity);
       ++ParamsToSkip;
       ++IndexOfAlignArg;
     }
@@ -1762,8 +1761,8 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
   llvm::Instruction *cleanupDominator = nullptr;
   if (E->getOperatorDelete() &&
       !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
-    EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocAlign,
-                          allocatorArgs);
+    EnterNewDeleteCleanup(*this, E, TypeIdentityArg, allocation, allocSize,
+                          allocAlign, allocatorArgs);
     operatorDeleteCleanup = EHStack.stable_begin();
     cleanupDominator = Builder.CreateUnreachable();
   }

clang/lib/Sema/SemaCoroutine.cpp

@@ -1141,7 +1141,7 @@ static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseTy
   ImplicitDeallocationParameters IDP = {
       alignedAllocationModeFromBool(Overaligned), SizedDeallocationMode::Yes};
   if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete,
-                                 PromiseType, IDP, /*Diagnose*/ true))
+                                 IDP, /*Diagnose*/ true))
     return false;
 
   // [dcl.fct.def.coroutine]p12
@@ -1157,8 +1157,7 @@ static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseTy
     // parameter if failed.
     // Coroutines can always provide their required size.
     IDP.PassSize = SizedDeallocationMode::Yes;
-    OperatorDelete =
-        S.FindUsualDeallocationFunction(PromiseType, Loc, IDP, DeleteName);
+    OperatorDelete = S.FindUsualDeallocationFunction(Loc, IDP, DeleteName);
 
     if (!OperatorDelete)
       return false;