Updating for review feedback

Author: ojhunt

clang/docs/CXXTypeAwareAllocators.rst

@@ -33,7 +33,7 @@ performed through specific interfaces, or explicitly via global ``new`` and
 
 P2719 introduces a type-identity tag as valid parameter type for all allocation
 operators. This tag is a default initialized value of type 
-`std::type_identity<T>` where T is the type being allocated or deallocated.
+``std::type_identity<T>`` where T is the type being allocated or deallocated.
 Unlike the other placement arguments this tag is passed as the first parameter
 to the operator.
 
@@ -67,12 +67,12 @@ by using templates. In addition to adding the type-identity tag, P2719 allows
 the tag parameter to be a dependent specialization of `std::type_identity`,
 updates the overload resolution rules to support full template deduction and
 constraint semantics, and updates the definition of usual deallocation functions
-to include `operator delete` definitions that are templatized on the
+to include ``operator delete`` definitions that are templatized on the
 type-identity tag.
 
 This allows arbitrarily constrained definitions of the operators that resolve
 as would be expected for any other template function resolution, e.g (only
-showing `operator new` for brevity)
+showing ``operator new`` for brevity)
 
 .. code-block:: c++
 
@@ -132,7 +132,7 @@ is avoiding dynamic dispatch.
 Subclassing and polymorphism
 ----------------------------
 
-While a type aware operator new will always receive the exact type being
+While a type aware ``operator new`` will always receive the exact type being
 allocated, deletion is limited to awareness of the dynamic type of an object.
 If deletion is performed via a virtual call, the type-identity tag passed to
 the type aware ``operator delete`` will be the dynamic type of the object.

clang/include/clang/AST/Decl.h

@@ -2530,6 +2530,7 @@ class FunctionDecl : public DeclaratorDecl,
   /// Determine whether this is a destroying operator delete.
   bool isDestroyingOperatorDelete() const;
 
+  /// Determine whether this is a type aware operator new or delete.
   bool isTypeAwareOperatorNewOrDelete() const;
 
   /// Compute the language linkage.

clang/include/clang/AST/Type.h

@@ -2633,7 +2633,6 @@ 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;          // std::destroying_delete_t
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   bool is##Id##Type() const;
@@ -2699,8 +2698,6 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
     return static_cast<TypeDependence>(TypeBits.Dependence);
   }
 
-  const TemplateDecl *getSpecializedTemplateDecl() const;
-
   /// Whether this type is an error type.
   bool containsErrors() const {
     return getDependence() & TypeDependence::Error;

clang/include/clang/Sema/Sema.h

@@ -4786,14 +4786,10 @@ class Sema final : public SemaBase {
   EnumDecl *getStdAlignValT() const;
   const ClassTemplateDecl *getStdTypeIdentity() const;
   ClassTemplateDecl *getStdTypeIdentity();
-  std::optional<QualType> instantiateSpecializedTypeIdentity(QualType Subject);
-  bool isTypeIdentitySpecialization(QualType Type) const;
-  bool isTypeAwareOperatorNewOrDelete(const FunctionDecl *FnDecl) const;
-  bool isTypeAwareOperatorNewOrDelete(const FunctionTemplateDecl *FnDecl) const;
   bool isTypeAwareOperatorNewOrDelete(const NamedDecl *FnDecl) const;
-  std::optional<FunctionDecl *>
-  instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnDecl,
-                                  QualType AllocType);
+  QualType instantiateSpecializedTypeIdentity(QualType Subject);
+  FunctionDecl *instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnDecl,
+                                                QualType AllocType);
 
   ValueDecl *tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl,
                                            const IdentifierInfo *MemberOrBase);

clang/lib/AST/Type.cpp

@@ -3130,8 +3130,8 @@ bool Type::isStdByteType() const {
   return false;
 }
 
-const TemplateDecl *Type::getSpecializedTemplateDecl() const {
-  const Type *DesugaredType = getUnqualifiedDesugaredType();
+static const TemplateDecl *getSpecializedTemplateType(const Type *T) {
+  const Type *DesugaredType = T->getUnqualifiedDesugaredType();
   if (const auto *Specialization =
           DesugaredType->getAs<TemplateSpecializationType>())
     return Specialization->getTemplateName().getAsTemplateDecl();
@@ -3143,15 +3143,11 @@ const TemplateDecl *Type::getSpecializedTemplateDecl() const {
 }
 
 bool Type::isTypeIdentitySpecialization() const {
-  const TemplateDecl *SpecializedDecl = getSpecializedTemplateDecl();
-  if (!SpecializedDecl)
+  const TemplateDecl *STDecl = getSpecializedTemplateType(this);
+  if (!STDecl)
     return false;
-  IdentifierInfo *II = SpecializedDecl->getIdentifier();
-  if (!II)
-    return false;
-  if (!SpecializedDecl->isInStdNamespace())
-    return false;
-  return II->isStr("type_identity");
+  IdentifierInfo *II = STDecl->getIdentifier();
+  return II && STDecl->isInStdNamespace() && II->isStr("type_identity");
 }
 
 bool Type::isSpecifierType() const {

clang/lib/Sema/SemaCoroutine.cpp

@@ -1595,12 +1595,12 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   SmallVector<Expr *, 3> NewArgs;
   auto BuildTypeIdentityArg = [PromiseType](Sema &S,
                                             SourceLocation Loc) -> Expr * {
-    std::optional<QualType> SpecializedTypeIdentity =
+    QualType SpecializedTypeIdentity =
         S.instantiateSpecializedTypeIdentity(PromiseType);
-    if (!SpecializedTypeIdentity)
+    if (SpecializedTypeIdentity.isNull())
       return nullptr;
     TypeSourceInfo *SpecializedTypeInfo =
-        S.Context.getTrivialTypeSourceInfo(*SpecializedTypeIdentity, Loc);
+        S.Context.getTrivialTypeSourceInfo(SpecializedTypeIdentity, Loc);
     ExprResult TypeIdentity =
         S.BuildCXXTypeConstructExpr(SpecializedTypeInfo, Loc, {}, Loc, false);
     if (TypeIdentity.isInvalid())
@@ -1649,7 +1649,7 @@ bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   //   used, the size of the block is passed as the corresponding argument.
   const auto *OpDeleteType =
       OpDeleteQualType.getTypePtr()->castAs<FunctionProtoType>();
-  if (S.isTypeAwareOperatorNewOrDelete(OperatorDelete)) {
+  if (OperatorDelete->isTypeAwareOperatorNewOrDelete()) {
     Expr *TypeIdentity = BuildTypeIdentityArg(S, Loc);
     if (!TypeIdentity)
       return false;

clang/lib/Sema/SemaDeclCXX.cpp

@@ -10872,7 +10872,7 @@ bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
       // first parameter, perform that conversion now.
       if (OperatorDelete->isDestroyingOperatorDelete()) {
         unsigned PointerParam = 0;
-        if (isTypeAwareOperatorNewOrDelete(OperatorDelete))
+        if (OperatorDelete->isTypeAwareOperatorNewOrDelete())
           ++PointerParam;
         QualType ParamType =
             OperatorDelete->getParamDecl(PointerParam)->getType();
@@ -16127,72 +16127,53 @@ bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
   return Invalid;
 }
 
-bool Sema::isTypeIdentitySpecialization(QualType Type) const {
-  const ClassTemplateDecl *TypeIdentity = getStdTypeIdentity();
-  if (!TypeIdentity)
-    return false;
-  const TemplateDecl *SpecializedDecl = Type->getSpecializedTemplateDecl();
-  return TypeIdentity == SpecializedDecl;
-}
-
-bool Sema::isTypeAwareOperatorNewOrDelete(const FunctionDecl *FnDecl) const {
-  // Type aware operators
-  if (FnDecl->getNumParams() < 2)
-    return false;
-  const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(0);
-  return isTypeIdentitySpecialization(ParamDecl->getType());
-}
-
-bool Sema::isTypeAwareOperatorNewOrDelete(
-    const FunctionTemplateDecl *FTD) const {
-  return isTypeAwareOperatorNewOrDelete(FTD->getTemplatedDecl());
-}
-
 bool Sema::isTypeAwareOperatorNewOrDelete(const NamedDecl *ND) const {
+  const FunctionDecl *FnDecl = nullptr;
   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
-    return isTypeAwareOperatorNewOrDelete(FTD->getTemplatedDecl());
-  if (auto *FnDecl = dyn_cast<FunctionDecl>(ND))
-    return isTypeAwareOperatorNewOrDelete(FnDecl);
-  return false;
+    FnDecl = FTD->getTemplatedDecl();
+  else if (auto *FD = dyn_cast<FunctionDecl>(ND))
+    FnDecl = FD;
+
+  return FnDecl->isTypeAwareOperatorNewOrDelete();
 }
 
-std::optional<FunctionDecl *>
+FunctionDecl *
 Sema::instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
                                       QualType DeallocType) {
   if (!isTypeAwareAllocation(allocationModeInCurrentContext()))
-    return std::nullopt;
+    return nullptr;
 
   TemplateParameterList *TemplateParameters =
       FnTemplateDecl->getTemplateParameters();
   if (TemplateParameters->hasParameterPack())
-    return std::nullopt;
+    return nullptr;
 
   FunctionDecl *FnDecl = FnTemplateDecl->getTemplatedDecl();
-  if (!isTypeAwareOperatorNewOrDelete(FnDecl))
-    return std::nullopt;
+  if (!FnDecl->isTypeAwareOperatorNewOrDelete())
+    return nullptr;
 
   if (FnDecl->isVariadic())
-    return std::nullopt;
+    return nullptr;
 
   unsigned NumParams = FnDecl->getNumParams();
   if (NumParams < 2)
-    return std::nullopt;
+    return nullptr;
 
   for (size_t Idx = 1; Idx < NumParams; ++Idx) {
     // A type aware allocation is only usual if the only dependent parameter is
     // the first parameter.
     const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
     if (ParamDecl->getType()->isDependentType())
-      return std::nullopt;
+      return nullptr;
   }
 
-  std::optional<QualType> SpecializedTypeIdentity =
+  QualType SpecializedTypeIdentity =
       instantiateSpecializedTypeIdentity(DeallocType);
-  if (!SpecializedTypeIdentity)
-    return std::nullopt;
+  if (SpecializedTypeIdentity.isNull())
+    return nullptr;
   SmallVector<QualType, 4> ArgTypes;
   ArgTypes.reserve(NumParams);
-  ArgTypes.push_back(*SpecializedTypeIdentity);
+  ArgTypes.push_back(SpecializedTypeIdentity);
   ArgTypes.push_back(FnDecl->getParamDecl(1)->getType());
   unsigned UsualParamsIdx = 2;
   if (UsualParamsIdx < NumParams && FnDecl->isDestroyingOperatorDelete()) {
@@ -16218,7 +16199,7 @@ Sema::instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
   }
 
   if (UsualParamsIdx != NumParams)
-    return std::nullopt;
+    return nullptr;
 
   FunctionProtoType::ExtProtoInfo EPI;
   QualType ExpectedFunctionType =
@@ -16228,24 +16209,23 @@ Sema::instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
   FunctionDecl *Result;
   if (DeduceTemplateArguments(FnTemplateDecl, nullptr, ExpectedFunctionType,
                               Result, Info) != TemplateDeductionResult::Success)
-    return std::nullopt;
+    return nullptr;
   return Result;
 }
 
-std::optional<QualType>
-Sema::instantiateSpecializedTypeIdentity(QualType Subject) {
+QualType Sema::instantiateSpecializedTypeIdentity(QualType Subject) {
   assert(clang::isTypeAwareAllocation(allocationModeInCurrentContext()));
   ClassTemplateDecl *TypeIdentity = getStdTypeIdentity();
   if (!TypeIdentity)
-    return std::nullopt;
+    return QualType();
 
   auto TN = TemplateName(TypeIdentity);
   TemplateArgumentListInfo Arguments;
   Arguments.addArgument(getTrivialTemplateArgumentLoc(
       TemplateArgument(Subject), QualType(), SourceLocation()));
   QualType Result = CheckTemplateIdType(TN, SourceLocation(), Arguments);
   if (Result.isNull())
-    return std::nullopt;
+    return QualType();
   return Result;
 }