Remove pseudo coverage of allocation for coroutines

While coroutines perform a notionally usual lookup for new/delete
on the promise type, they are using the result to allocate space
for an anonymous type representing the frame. There's no C++
representation of this type (currently) so simply passing the
promise type is erroneous, and there's no real mechanism vend
a real type.

In the long term this needs to be addressed by the coroutine
specification.

Author: ojhunt

clang/include/clang/AST/ExprCXX.h

@@ -2261,6 +2261,12 @@ inline SizedDeallocationMode sizedDeallocationModeFromBool(bool IsSized) {
 }
 
 struct ImplicitAllocationParameters {
+  ImplicitAllocationParameters(QualType Type,
+                               TypeAwareAllocationMode PassTypeIdentity,
+                               AlignedAllocationMode PassAlignment)
+      : Type(Type.isNull() ? Type : Type.getUnqualifiedType()),
+        PassTypeIdentity(PassTypeIdentity), PassAlignment(PassAlignment) {}
+  QualType Type;
   TypeAwareAllocationMode PassTypeIdentity;
   AlignedAllocationMode PassAlignment;
   unsigned getNumImplicitArgs() const {
@@ -2274,6 +2280,14 @@ struct ImplicitAllocationParameters {
 };
 
 struct ImplicitDeallocationParameters {
+  ImplicitDeallocationParameters(QualType Type,
+                                 TypeAwareAllocationMode PassTypeIdentity,
+                                 AlignedAllocationMode PassAlignment,
+                                 SizedDeallocationMode PassSize)
+      : Type(Type.isNull() ? Type : Type.getUnqualifiedType()),
+        PassTypeIdentity(PassTypeIdentity), PassAlignment(PassAlignment),
+        PassSize(PassSize) {}
+  QualType Type;
   TypeAwareAllocationMode PassTypeIdentity;
   AlignedAllocationMode PassAlignment;
   SizedDeallocationMode PassSize;
@@ -2502,6 +2516,7 @@ class CXXNewExpr final
   /// parameters in this call
   ImplicitAllocationParameters implicitAllocationParameters() const {
     return ImplicitAllocationParameters{
+        getAllocatedType(),
         typeAwareAllocationModeFromBool(CXXNewExprBits.ShouldPassTypeIdentity),
         alignedAllocationModeFromBool(CXXNewExprBits.ShouldPassAlignment)};
   }

clang/include/clang/Basic/DiagnosticGroups.td

@@ -64,8 +64,11 @@ def AlwaysInlineCoroutine :
   DiagGroup<"always-inline-coroutine">;
 def CoroNonAlignedAllocationFunction :
   DiagGroup<"coro-non-aligned-allocation-function">;
+def CoroTypeAwareAllocationFunction :
+  DiagGroup<"coro-type-aware-allocation-function">;
 def Coroutine : DiagGroup<"coroutine", [CoroutineMissingUnhandledException, DeprecatedCoroutine,
-                                        AlwaysInlineCoroutine, CoroNonAlignedAllocationFunction]>;
+                                        AlwaysInlineCoroutine, CoroNonAlignedAllocationFunction,
+                                        CoroTypeAwareAllocationFunction]>;
 def ObjCBoolConstantConversion : DiagGroup<"objc-bool-constant-conversion">;
 def ConstantConversion : DiagGroup<"constant-conversion",
                                    [BitFieldConstantConversion,

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9733,7 +9733,7 @@ def err_unsupported_type_aware_allocator : Error<
 def warn_type_aware_cleanup_deallocator_context_mismatch : Warning<
   "type aware %0 requires matching %1 in %2">,
   InGroup<StrictTypeAwareAllocators>, DefaultError;
-def err_type_aware_operator_found : Note<
+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">,
@@ -12044,6 +12044,9 @@ def warn_always_inline_coroutine : Warning<
 def err_coroutine_unusable_new : Error<
   "'operator new' provided by %0 is not usable with the function signature of %1"
 >;
+def note_coroutine_unusable_type_aware_allocators : Note<
+  "type aware %0 will not be used for coroutine allocation"
+>;
 def err_coroutine_unfound_nothrow_new : Error <
   "unable to find %select{'::operator new(size_t, nothrow_t)'|"
   "'::operator new(size_t, align_val_t, nothrow_t)'}1 for %0"
@@ -12063,6 +12066,9 @@ def err_coroutine_return_type : Error<
   "function returns a type %0 marked with [[clang::coro_return_type]] but is neither a coroutine nor a coroutine wrapper; "
   "non-coroutines should be marked with [[clang::coro_wrapper]] to allow returning coroutine return type"
 >;
+def warn_coroutine_type_aware_allocator_ignored : Warning <
+  "type aware %0 will not be used for coroutine allocation">,
+  InGroup<CoroTypeAwareAllocationFunction>;
 } // end of coroutines issue category
 
 let CategoryName = "Documentation Issue" in {

clang/lib/AST/DeclCXX.cpp

@@ -2480,26 +2480,20 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
   bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
 
   // 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.
   if (FunctionTemplateDecl *PrimaryTemplate = getPrimaryTemplate()) {
-    // Addendum: a template instance is a usual deallocation function if there
-    // is a single template parameter, that parameter is a type, only the first
-    // parameter is dependent, and that parameter is a specialization of
-    // std::type_identity.
     if (!IsTypeAware) {
       // Stop early on if the specialization is not explicitly type aware
       return false;
     }
 
     FunctionDecl *SpecializedDecl = PrimaryTemplate->getTemplatedDecl();
-    if (!SpecializedDecl->isTypeAwareOperatorNewOrDelete()) {
-      // The underlying template decl must also be explicitly type aware
-      // e.g. template <typename T> void operator delete(T, ...)
-      // specialized on T=type_identity<X> is not usual
-      return false;
-    }
-
     for (unsigned Idx = 1; Idx < NumParams; ++Idx) {
       if (SpecializedDecl->getParamDecl(Idx)->getType()->isDependentType())
         return false;
@@ -2512,9 +2506,10 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
 
   // 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)
+  //   with exactly one parameter or a type aware operator delete with two
+  //   two arguments, then that function is a usual (non-placement)
   //   deallocation function. [...]
-  if (getNumParams() == 1)
+  if (getNumParams() == UsualParams)
     return true;
 
   // C++ P0722:

clang/lib/Sema/SemaCoroutine.cpp

@@ -1095,12 +1095,40 @@ static TypeSourceInfo *getTypeSourceInfoForStdAlignValT(Sema &S,
   return S.Context.getTrivialTypeSourceInfo(StdAlignValDecl);
 }
 
+// When searching for custom allocators on the PromiseType we want to
+// warn that we will ignore type aware allocators.
+static bool DiagnoseTypeAwareAllocatorsIfNecessary(Sema &S, SourceLocation Loc,
+                                                   unsigned DiagnosticID,
+                                                   DeclarationName Name,
+                                                   QualType PromiseType) {
+  if (!S.getLangOpts().TypeAwareAllocators)
+    return false;
+  if (!PromiseType->isRecordType())
+    return false;
+  LookupResult R(S, Name, Loc, Sema::LookupOrdinaryName);
+  S.LookupQualifiedName(R, PromiseType->getAsCXXRecordDecl());
+  bool HaveIssuedWarning = false;
+  for (auto Decl : R) {
+    if (S.isTypeAwareOperatorNewOrDelete(Decl)) {
+      if (!HaveIssuedWarning) {
+        S.Diag(Loc, DiagnosticID) << Name;
+        HaveIssuedWarning = true;
+      }
+      S.Diag(Decl->getLocation(), diag::note_type_aware_operator_declared)
+          << 0 << Decl;
+    }
+  }
+  return HaveIssuedWarning;
+}
+
 // Find an appropriate delete for the promise.
 static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseType,
                                  FunctionDecl *&OperatorDelete) {
   DeclarationName DeleteName =
       S.Context.DeclarationNames.getCXXOperatorName(OO_Delete);
-
+  DiagnoseTypeAwareAllocatorsIfNecessary(
+      S, Loc, diag::warn_coroutine_type_aware_allocator_ignored, DeleteName,
+      PromiseType);
   auto *PointeeRD = PromiseType->getAsCXXRecordDecl();
   assert(PointeeRD && "PromiseType must be a CxxRecordDecl type");
 
@@ -1111,7 +1139,7 @@ static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseTy
   // scope of the promise type. If nothing is found, a search is performed in
   // the global scope.
   ImplicitDeallocationParameters IDP = {
-      typeAwareAllocationModeFromBool(S.getLangOpts().TypeAwareAllocators),
+      S.Context.VoidTy, TypeAwareAllocationMode::No,
       alignedAllocationModeFromBool(Overaligned), SizedDeallocationMode::Yes};
   if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete,
                                  PromiseType, IDP, /*Diagnose*/ true))
@@ -1407,10 +1435,10 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
 
   FunctionDecl *OperatorNew = nullptr;
   SmallVector<Expr *, 1> PlacementArgs;
+  DeclarationName NewName =
+      S.getASTContext().DeclarationNames.getCXXOperatorName(OO_New);
 
-  const bool PromiseContainsNew = [this, &PromiseType]() -> bool {
-    DeclarationName NewName =
-        S.getASTContext().DeclarationNames.getCXXOperatorName(OO_New);
+  const bool PromiseContainsNew = [this, &PromiseType, NewName]() -> bool {
     LookupResult R(S, NewName, Loc, Sema::LookupOrdinaryName);
 
     if (PromiseType->isRecordType())
@@ -1422,36 +1450,36 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   // Helper function to indicate whether the last lookup found the aligned
   // allocation function.
   ImplicitAllocationParameters IAP = {
-      typeAwareAllocationModeFromBool(S.getLangOpts().TypeAwareAllocators),
+      S.Context.VoidTy, TypeAwareAllocationMode::No,
       alignedAllocationModeFromBool(S.getLangOpts().CoroAlignedAllocation)};
-  auto LookupAllocationFunction = [&](Sema::AllocationFunctionScope NewScope =
-                                          Sema::AFS_Both,
-                                      bool WithoutPlacementArgs = false,
-                                      bool ForceNonAligned = false) {
-    // [dcl.fct.def.coroutine]p9
-    //   The allocation function's name is looked up by searching for it in
-    //   the
-    // scope of the promise type.
-    // - If any declarations are found, ...
-    // - If no declarations are found in the scope of the promise type, a
-    //   search is performed in the global scope.
-    if (NewScope == Sema::AFS_Both)
-      NewScope = PromiseContainsNew ? Sema::AFS_Class : Sema::AFS_Global;
-
-    bool ShouldUseAlignedAlloc =
-        !ForceNonAligned && S.getLangOpts().CoroAlignedAllocation;
-    IAP = {typeAwareAllocationModeFromBool(S.getLangOpts().TypeAwareAllocators),
-           alignedAllocationModeFromBool(ShouldUseAlignedAlloc)};
-
-    FunctionDecl *UnusedResult = nullptr;
-
-    S.FindAllocationFunctions(Loc, SourceRange(), NewScope,
-                              /*DeleteScope*/ Sema::AFS_Both, PromiseType,
-                              /*isArray*/ false, IAP,
-                              WithoutPlacementArgs ? MultiExprArg{}
-                                                   : PlacementArgs,
-                              OperatorNew, UnusedResult, /*Diagnose*/ false);
-  };
+  auto LookupAllocationFunction =
+      [&](Sema::AllocationFunctionScope NewScope = Sema::AFS_Both,
+          bool WithoutPlacementArgs = false, bool ForceNonAligned = false) {
+        // [dcl.fct.def.coroutine]p9
+        //   The allocation function's name is looked up by searching for it in
+        //   the
+        // scope of the promise type.
+        // - If any declarations are found, ...
+        // - If no declarations are found in the scope of the promise type, a
+        //   search is performed in the global scope.
+        if (NewScope == Sema::AFS_Both)
+          NewScope = PromiseContainsNew ? Sema::AFS_Class : Sema::AFS_Global;
+
+        bool ShouldUseAlignedAlloc =
+            !ForceNonAligned && S.getLangOpts().CoroAlignedAllocation;
+        IAP = {S.Context.VoidTy, TypeAwareAllocationMode::No,
+               alignedAllocationModeFromBool(ShouldUseAlignedAlloc)};
+
+        FunctionDecl *UnusedResult = nullptr;
+
+        S.FindAllocationFunctions(
+            Loc, SourceRange(), NewScope,
+            /*DeleteScope*/ Sema::AFS_Both, PromiseType,
+            /*isArray*/ false, IAP,
+            WithoutPlacementArgs ? MultiExprArg{} : PlacementArgs, OperatorNew,
+            UnusedResult, /*Diagnose*/ false);
+        assert(!OperatorNew || !OperatorNew->isTypeAwareOperatorNewOrDelete());
+      };
 
   // We don't expect to call to global operator new with (size, p0, …, pn).
   // So if we choose to lookup the allocation function in global scope, we
@@ -1537,15 +1565,22 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   }
 
   if (!OperatorNew) {
-    if (PromiseContainsNew)
+    if (PromiseContainsNew) {
       S.Diag(Loc, diag::err_coroutine_unusable_new) << PromiseType << &FD;
-    else if (RequiresNoThrowAlloc)
+      DiagnoseTypeAwareAllocatorsIfNecessary(
+          S, Loc, diag::note_coroutine_unusable_type_aware_allocators, NewName,
+          PromiseType);
+    } else if (RequiresNoThrowAlloc)
       S.Diag(Loc, diag::err_coroutine_unfound_nothrow_new)
           << &FD << S.getLangOpts().CoroAlignedAllocation;
 
     return false;
   }
 
+  DiagnoseTypeAwareAllocatorsIfNecessary(
+      S, Loc, diag::warn_coroutine_type_aware_allocator_ignored, NewName,
+      PromiseType);
+
   if (RequiresNoThrowAlloc) {
     const auto *FT = OperatorNew->getType()->castAs<FunctionProtoType>();
     if (!FT->isNothrow(/*ResultIfDependent*/ false)) {

clang/lib/Sema/SemaDeclCXX.cpp

@@ -9716,6 +9716,7 @@ bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD,
     DeclarationName Name =
       Context.DeclarationNames.getCXXOperatorName(OO_Delete);
     ImplicitDeallocationParameters IDP = {
+        DeallocType,
         typeAwareAllocationModeFromBool(getLangOpts().TypeAwareAllocators),
         AlignedAllocationMode::No, SizedDeallocationMode::No};
     if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,

clang/lib/Sema/SemaExprCXX.cpp

@@ -1775,12 +1775,15 @@ static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
 
 namespace {
   struct UsualDeallocFnInfo {
-    UsualDeallocFnInfo() : Found(), FD(nullptr) {}
+    UsualDeallocFnInfo()
+        : Found(), FD(nullptr),
+          IDP(QualType(), TypeAwareAllocationMode::No,
+              AlignedAllocationMode::No, SizedDeallocationMode::No) {}
     UsualDeallocFnInfo(Sema &S, DeclAccessPair Found, QualType AllocType)
         : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())),
           Destroying(false),
-          IDP({TypeAwareAllocationMode::No, AlignedAllocationMode::No,
-               SizedDeallocationMode::No}),
+          IDP({AllocType, TypeAwareAllocationMode::No,
+               AlignedAllocationMode::No, SizedDeallocationMode::No}),
           CUDAPref(SemaCUDA::CFP_Native) {
       // A function template declaration is only a usual deallocation function
       // if it is a typed delete.
@@ -2008,7 +2011,7 @@ static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc,
   //   If the deallocation functions have class scope, the one without a
   //   parameter of type std::size_t is selected.
   ImplicitDeallocationParameters IDP = {
-      PassType,
+      allocType, PassType,
       alignedAllocationModeFromBool(hasNewExtendedAlignment(S, allocType)),
       SizedDeallocationMode::No};
   auto Best = resolveDeallocationOverload(S, ops, IDP, allocType);
@@ -2425,6 +2428,7 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
       AllocType->isDependentType() ? 0 : Context.getTypeAlign(AllocType);
   unsigned NewAlignment = Context.getTargetInfo().getNewAlign();
   ImplicitAllocationParameters IAP = {
+      AllocType,
       typeAwareAllocationModeFromBool(getLangOpts().TypeAwareAllocators),
       alignedAllocationModeFromBool(getLangOpts().AlignedAllocation &&
                                     Alignment > NewAlignment)};
@@ -3159,7 +3163,7 @@ bool Sema::FindAllocationFunctions(
     // with a size_t where possible (which it always is in this case).
     llvm::SmallVector<UsualDeallocFnInfo, 4> BestDeallocFns;
     ImplicitDeallocationParameters IDP = {
-        OriginalTypeAwareState,
+        AllocElemType, OriginalTypeAwareState,
         alignedAllocationModeFromBool(
             hasNewExtendedAlignment(*this, AllocElemType)),
         sizedDeallocationModeFromBool(FoundGlobalDelete)};
@@ -3197,9 +3201,9 @@ bool Sema::FindAllocationFunctions(
         OperatorDelete->getDeclContext() != OperatorNew->getDeclContext()) {
       Diag(StartLoc, diag::warn_type_aware_cleanup_deallocator_context_mismatch)
           << OperatorNew << DeleteName << OperatorNew->getDeclContext();
-      Diag(OperatorNew->getLocation(), diag::err_type_aware_operator_found)
+      Diag(OperatorNew->getLocation(), diag::note_type_aware_operator_found)
           << OperatorNew << OperatorNew->getDeclContext();
-      Diag(OperatorDelete->getLocation(), diag::err_type_aware_operator_found)
+      Diag(OperatorDelete->getLocation(), diag::note_type_aware_operator_found)
           << OperatorDelete << OperatorDelete->getDeclContext();
     }
 
@@ -3221,7 +3225,7 @@ bool Sema::FindAllocationFunctions(
       bool IsSizedDelete = isSizedDeallocation(Info.IDP.PassSize);
       if (IsSizedDelete && !FoundGlobalDelete) {
         ImplicitDeallocationParameters SizeTestingIDP = {
-            Info.IDP.PassTypeIdentity, Info.IDP.PassAlignment,
+            AllocElemType, Info.IDP.PassTypeIdentity, Info.IDP.PassAlignment,
             SizedDeallocationMode::No};
         auto NonSizedDelete = resolveDeallocationOverload(
             *this, FoundDelete, SizeTestingIDP, AllocElemType);
@@ -3544,6 +3548,7 @@ FunctionDecl *Sema::FindDeallocationFunctionForDestructor(SourceLocation Loc,
   FunctionDecl *OperatorDelete = nullptr;
   QualType DeallocType = Context.getRecordType(RD);
   ImplicitDeallocationParameters IDP = {
+      DeallocType,
       typeAwareAllocationModeFromBool(getLangOpts().TypeAwareAllocators),
       AlignedAllocationMode::No, SizedDeallocationMode::No};
 
@@ -4017,6 +4022,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
 
     if (PointeeRD) {
       ImplicitDeallocationParameters IDP = {
+          Pointee,
           typeAwareAllocationModeFromBool(getLangOpts().TypeAwareAllocators),
           AlignedAllocationMode::No, SizedDeallocationMode::No};
       if (!UseGlobal &&
@@ -4070,6 +4076,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
 
       // Look for a global declaration.
       ImplicitDeallocationParameters IDP = {
+          Pointee,
           typeAwareAllocationModeFromBool(getLangOpts().TypeAwareAllocators),
           alignedAllocationModeFromBool(Overaligned),
           sizedDeallocationModeFromBool(CanProvideSize)};