Yet more review comments

Author: ojhunt

clang/include/clang/Basic/DiagnosticGroups.td

@@ -1524,10 +1524,6 @@ in addition with the pragmas or -fmax-tokens flag to get any warnings.
 }];
 }
 
-// Warning group for type aware allocators
-def TypeAwareAllocatorMismatch :
-  DiagGroup<"type-aware-allocator-mismatch">;
-
 def WebAssemblyExceptionSpec : DiagGroup<"wasm-exception-spec">;
 
 def RTTI : DiagGroup<"rtti">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9717,7 +9717,7 @@ def err_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<TypeAwareAllocatorMismatch>;
+  InGroup<DiagGroup<"type-aware-allocator-mismatch">>;
 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

@@ -4757,7 +4757,8 @@ class Sema final : public SemaBase {
 
   CXXRecordDecl *getStdBadAlloc() const;
   EnumDecl *getStdAlignValT() const;
-  ClassTemplateDecl *getStdTypeIdentity() const;
+  const ClassTemplateDecl *getStdTypeIdentity() const;
+  ClassTemplateDecl *getStdTypeIdentity();
   std::optional<QualType> instantiateSpecializedTypeIdentity(QualType Subject);
   bool isTypeIdentitySpecialization(QualType Type) const;
   bool isTypeAwareOperatorNewOrDelete(const FunctionDecl *FnDecl) const;
@@ -8146,7 +8147,7 @@ class Sema final : public SemaBase {
 
   /// The scope in which to find allocation functions.
   enum AllocationFunctionScope {
-    /// Only look for allocation functions in the global scope
+    /// Only look for allocation functions in the global scope.
     AFS_Global,
     /// Only look for allocation functions in the scope of the
     /// allocated class.

clang/lib/AST/Type.cpp

@@ -3103,7 +3103,7 @@ const TemplateDecl *Type::getSpecializedTemplateDecl() const {
   if (const auto *Specialization = DesugaredType->getAs<TemplateSpecializationType>())
     return Specialization->getTemplateName().getAsTemplateDecl();
   if (const auto *Record = DesugaredType->getAsCXXRecordDecl()) {
-    if (auto *CTS = dyn_cast<ClassTemplateSpecializationDecl>(Record))
+    if (const auto *CTS = dyn_cast<ClassTemplateSpecializationDecl>(Record))
       return CTS->getSpecializedTemplate();
   }
   return nullptr;

clang/lib/CodeGen/CGExprCXX.cpp

@@ -1395,7 +1395,7 @@ static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD) {
 
   if (FD->isTypeAwareOperatorNewOrDelete()) {
     // Assume Sema has ensured a non-pointer first parameter is
-    // a type identity
+    // a type identity.
     Params.TypedAwareDelete = true;
     assert(AI != AE);
     ++AI;
@@ -1441,7 +1441,7 @@ namespace {
       QualType ArgType;
     };
 
-    unsigned NumPlacementArgs : 31;
+    unsigned NumPlacementArgs : 30;
     LLVM_PREFERRED_TYPE(bool)
     unsigned PassAlignmentToPlacementDelete : 1;
     LLVM_PREFERRED_TYPE(bool)
@@ -1829,7 +1829,7 @@ void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
   auto Params = getUsualDeleteParams(DeleteFD);
   auto ParamTypeIt = DeleteFTy->param_type_begin();
 
-  llvm::AllocaInst *TypeIdentityag = nullptr;
+  llvm::AllocaInst *TypeIdentityArg = nullptr;
   if (Params.TypedAwareDelete) {
     QualType SpecializedTypeIdentity = *ParamTypeIt++;
     CXXScalarValueInitExpr TypeIdentityParam(SpecializedTypeIdentity, nullptr,
@@ -1890,8 +1890,8 @@ void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
   // Emit the call to delete.
   EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
 
-  if (TypeIdentityag && TypeIdentityag->use_empty())
-    TypeIdentityag->eraseFromParent();
+  if (TypeIdentityArg && TypeIdentityArg->use_empty())
+    TypeIdentityArg->eraseFromParent();
 
   // If call argument lowering didn't use the destroying_delete_t alloca,
   // remove it again.

clang/lib/Sema/SemaDeclCXX.cpp

@@ -11740,7 +11740,12 @@ NamespaceDecl *Sema::getStdNamespace() const {
                                  StdNamespace.get(Context.getExternalSource()));
 }
 
-ClassTemplateDecl *Sema::getStdTypeIdentity() const {
+const ClassTemplateDecl *Sema::getStdTypeIdentity() const {
+  return cast_or_null<ClassTemplateDecl>(
+      StdTypeIdentity.get(Context.getExternalSource()));
+}
+
+ClassTemplateDecl *Sema::getStdTypeIdentity() {
   return cast_or_null<ClassTemplateDecl>(
       StdTypeIdentity.get(Context.getExternalSource()));
 }
@@ -16124,7 +16129,7 @@ bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
 }
 
 bool Sema::isTypeIdentitySpecialization(QualType Type) const {
-  ClassTemplateDecl *TypeIdentity = getStdTypeIdentity();
+  const ClassTemplateDecl *TypeIdentity = getStdTypeIdentity();
   if (!TypeIdentity)
     return false;
   const TemplateDecl *SpecializedDecl = Type->getSpecializedTemplateDecl();
@@ -16175,7 +16180,7 @@ Sema::instantiateTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
 
   for (size_t Idx = 1; Idx < NumParams; ++Idx) {
     // A type aware allocation is only usual if the only dependent parameter is
-    // the first parameter
+    // the first parameter.
     const ParmVarDecl *ParamDecl = FnDecl->getParamDecl(Idx);
     if (ParamDecl->getType()->isDependentType())
       return std::nullopt;
@@ -16231,9 +16236,9 @@ std::optional<QualType>
 Sema::instantiateSpecializedTypeIdentity(QualType Subject) {
   assert(AllowTypeAwareAllocators());
   ClassTemplateDecl *TypeIdentity = getStdTypeIdentity();
-  if (!TypeIdentity) {
+  if (!TypeIdentity)
     return std::nullopt;
-  }
+
   auto TN = TemplateName(TypeIdentity);
   TemplateArgumentListInfo Arguments;
   Arguments.addArgument(getTrivialTemplateArgumentLoc(

clang/lib/Sema/SemaExprCXX.cpp

@@ -1781,7 +1781,7 @@ namespace {
           Destroying(false), HasSizeT(false), HasAlignValT(false),
           HasTypeIdentity(false), CUDAPref(SemaCUDA::CFP_Native) {
       // A function template declaration is only a usual deallocation function
-      // if it is a typed delete
+      // if it is a typed delete.
       if (!FD) {
         auto *FTD = dyn_cast<FunctionTemplateDecl>(Found->getUnderlyingDecl());
         if (!FTD)