Remember to run clang-format

ojhunt · ojhunt · commit ae0729d4f93b · 2025-03-18T23:21:34.000-07:00
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
@@ -2564,11 +2564,12 @@ class FunctionDecl : public DeclaratorDecl,
 
   /// Count of mandatory parameters for type aware operator new
   static constexpr unsigned RequiredTypeAwareNewParameterCount =
-    /* type-identity */ 1 + /* size */ 1 + /* alignment */ 1;
+      /* type-identity */ 1 + /* size */ 1 + /* alignment */ 1;
 
   /// Count of mandatory parameters for type aware operator delete
   static constexpr unsigned RequiredTypeAwareDeleteParameterCount =
-    /* type-identity */ 1 + /* address */ 1 + /* size */ 1 + /* alignment */ 1;
+      /* type-identity */ 1 + /* address */ 1 + /* size */ 1 +
+      /* alignment */ 1;
 
   /// Determine whether this is a type aware operator new or delete.
   bool isTypeAwareOperatorNewOrDelete() const;
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
@@ -2639,7 +2639,7 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   bool isTypeIdentitySpecialization() const; // std::type_identity<X> for any X
   bool isDestroyingDeleteT() const;
 
-  TemplateDecl *TryGetSpecializedTemplateDecl() const;
+  TemplateDecl *tryGetSpecializedTemplateDecl() const;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   bool is##Id##Type() const;
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
@@ -3400,9 +3400,12 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
 
   if (isTypeAwareOperatorNewOrDelete()) {
     bool IsDelete = getDeclName().isOperatorDelete();
-    unsigned RequiredParameterCount = IsDelete ? FunctionDecl::RequiredTypeAwareDeleteParameterCount : FunctionDecl::RequiredTypeAwareNewParameterCount;
+    unsigned RequiredParameterCount =
+        IsDelete ? FunctionDecl::RequiredTypeAwareDeleteParameterCount
+                 : FunctionDecl::RequiredTypeAwareNewParameterCount;
     if (AlignmentParam)
-      *AlignmentParam = /* type identity */ 1  + /* address */ IsDelete + /* size */ 1;
+      *AlignmentParam =
+          /* type identity */ 1 + /* address */ IsDelete + /* size */ 1;
     if (RequiredParameterCount == getNumParams())
       return true;
     if (getNumParams() > RequiredParameterCount + 1)
@@ -3411,7 +3414,7 @@ bool FunctionDecl::isUsableAsGlobalAllocationFunctionInConstantEvaluation(
       return false;
 
     if (IsNothrow)
-        *IsNothrow = true;
+      *IsNothrow = true;
     return true;
   }
 
diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp
@@ -2535,7 +2535,7 @@ bool CXXMethodDecl::isUsualDeallocationFunction(
 
   bool IsTypeAware = isTypeAwareOperatorNewOrDelete();
   if (IsTypeAware && isVariadic())
-      return false;
+    return false;
 
   // C++ [basic.stc.dynamic.deallocation]p2:
   //   Pre-type aware allocators:
diff --git a/clang/lib/AST/Type.cpp b/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::tryGetSpecializedTemplateDecl() 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 = tryGetSpecializedTemplateDecl();
   if (!STDecl)
     return false;
   IdentifierInfo *II = STDecl->getIdentifier();
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -7189,7 +7189,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back("-fcoro-aligned-allocation");
 
   if (Arg *A = Args.getLastArg(options::OPT_fcxx_type_aware_allocators,
-      options::OPT_fno_cxx_type_aware_allocators)) {
+                               options::OPT_fno_cxx_type_aware_allocators)) {
     if (A->getOption().matches(options::OPT_fno_cxx_type_aware_allocators))
       CmdArgs.push_back("-fno-cxx-type-aware-allocators");
     else
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -16349,7 +16349,7 @@ Sema::BuildTypeAwareUsualDelete(FunctionTemplateDecl *FnTemplateDecl,
 
   unsigned NumParams = FnDecl->getNumParams();
   constexpr unsigned RequiredParameterCount =
-    FunctionDecl::RequiredTypeAwareDeleteParameterCount;
+      FunctionDecl::RequiredTypeAwareDeleteParameterCount;
   // A usual deallocation function has no placement parameters
   if (NumParams != RequiredParameterCount)
     return nullptr;
@@ -16435,8 +16435,9 @@ static inline bool CheckOperatorNewDeleteTypes(
   };
 
   unsigned FirstNonTypeParam = 0;
-  bool IsPotentiallyTypeAware = FnDecl->getNumParams() > 0 &&
-    FnDecl->getParamDecl(0)->getType()->isTypeIdentitySpecialization();
+  bool IsPotentiallyTypeAware =
+      FnDecl->getNumParams() > 0 &&
+      FnDecl->getParamDecl(0)->getType()->isTypeIdentitySpecialization();
   unsigned MinimumMandatoryArgumentCount = 1;
   unsigned SizeParameterIndex = 0;
   if (IsPotentiallyTypeAware) {
@@ -16449,10 +16450,12 @@ static inline bool CheckOperatorNewDeleteTypes(
 
     if (OperatorKind == AllocationOperatorKind::New) {
       SizeParameterIndex = 1;
-      MinimumMandatoryArgumentCount = FunctionDecl::RequiredTypeAwareNewParameterCount;
+      MinimumMandatoryArgumentCount =
+          FunctionDecl::RequiredTypeAwareNewParameterCount;
     } else {
       SizeParameterIndex = 2;
-      MinimumMandatoryArgumentCount = FunctionDecl::RequiredTypeAwareDeleteParameterCount;
+      MinimumMandatoryArgumentCount =
+          FunctionDecl::RequiredTypeAwareDeleteParameterCount;
     }
     FirstNonTypeParam = 1;
   }
@@ -16466,8 +16469,8 @@ static inline bool CheckOperatorNewDeleteTypes(
   if (FnDecl->getNumParams() < MinimumMandatoryArgumentCount)
     return SemaRef.Diag(FnDecl->getLocation(),
                         diag::err_operator_new_delete_too_few_parameters)
-           << IsPotentiallyTypeAware << IsDestroyingDelete << FnDecl->getDeclName()
-           << MinimumMandatoryArgumentCount;
+           << IsPotentiallyTypeAware << IsDestroyingDelete
+           << FnDecl->getDeclName() << MinimumMandatoryArgumentCount;
 
   auto *FnType = FnDecl->getType()->castAs<FunctionType>();
   QualType CanResultType = NormalizeType(FnType->getReturnType());
@@ -16496,8 +16499,8 @@ static inline bool CheckOperatorNewDeleteTypes(
                        auto FallbackType) -> bool {
     if (ExpectedType.isNull()) {
       return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
-             << IsPotentiallyTypeAware << IsDestroyingDelete << FnDecl->getDeclName()
-             << ParamIdx << FallbackType;
+             << IsPotentiallyTypeAware << IsDestroyingDelete
+             << FnDecl->getDeclName() << ParamIdx << FallbackType;
     }
     CanQualType CanExpectedTy =
         NormalizeType(SemaRef.Context.getCanonicalType(ExpectedType));
@@ -16509,8 +16512,8 @@ static inline bool CheckOperatorNewDeleteTypes(
                               ? DependentParamTypeDiag
                               : InvalidParamTypeDiag;
     return SemaRef.Diag(FnDecl->getLocation(), Diagnostic)
-           << IsPotentiallyTypeAware << IsDestroyingDelete << FnDecl->getDeclName()
-           << ParamIdx << ExpectedType << FallbackType;
+           << IsPotentiallyTypeAware << IsDestroyingDelete
+           << FnDecl->getDeclName() << ParamIdx << ExpectedType << FallbackType;
   };
 
   // Check that the first parameter type is what we expect.
@@ -16581,7 +16584,7 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
   auto ConstructDestroyingDeleteAddressType = [&]() {
     assert(MD);
     return SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
-      SemaRef.Context.getRecordType(MD->getParent())));
+        SemaRef.Context.getRecordType(MD->getParent())));
   };
 
   // C++ P0722:
@@ -16598,7 +16601,8 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
   // so as a QoL we actually check for this explicitly
   bool IsTypeAwareClassMethod = MD && MD->isTypeAwareOperatorNewOrDelete();
   if (IsTypeAwareClassMethod && MD->getNumParams() > 1) {
-    QualType AddressParamType = SemaRef.Context.getCanonicalType(MD->getParamDecl(1)->getType());
+    QualType AddressParamType =
+        SemaRef.Context.getCanonicalType(MD->getParamDecl(1)->getType());
     if (AddressParamType != SemaRef.Context.VoidPtrTy &&
         AddressParamType == ConstructDestroyingDeleteAddressType()) {
       // The address parameter type implies an author trying to construct a
@@ -16610,7 +16614,9 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
       // the core problem.
       for (auto Param : MD->parameters()) {
         if (Param->getType()->isDestroyingDeleteT()) {
-          SemaRef.Diag(MD->getLocation(), diag::err_type_aware_destroying_operator_delete) << Param->getLocation();
+          SemaRef.Diag(MD->getLocation(),
+                       diag::err_type_aware_destroying_operator_delete)
+              << Param->getLocation();
           return true;
         }
       }
@@ -16627,7 +16633,9 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
           diag::err_operator_delete_param_type, &MinimumNonDefaultArgs))
     return true;
 
-  assert(MinimumNonDefaultArgs > 0 && MinimumNonDefaultArgs <= FunctionDecl::RequiredTypeAwareDeleteParameterCount);
+  assert(MinimumNonDefaultArgs > 0 &&
+         MinimumNonDefaultArgs <=
+             FunctionDecl::RequiredTypeAwareDeleteParameterCount);
   // C++ P0722:
   //   A destroying operator delete shall be a usual deallocation function.
   if (MD && !MD->getParent()->isDependentContext() &&
@@ -16646,6 +16654,7 @@ CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
              << FnDecl->getDeclName() << ParamDecl->getDefaultArgRange();
     }
   }
+
   return false;
 }
 
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
@@ -1755,7 +1755,8 @@ static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
 
   if (S.getLangOpts().TypeAwareAllocators &&
       FD->isTypeAwareOperatorNewOrDelete())
-    return FunctionDecl::RequiredTypeAwareDeleteParameterCount == FD->getNumParams();
+    return FunctionDecl::RequiredTypeAwareDeleteParameterCount ==
+           FD->getNumParams();
 
   unsigned UsualParams = 1;
   if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
diff --git a/clang/lib/Sema/SemaInit.cpp b/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->tryGetSpecializedTemplateDecl();
       Template = dyn_cast_or_null<ClassTemplateDecl>(SpecializedTD);
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -9902,7 +9902,7 @@ QualType Sema::DeduceTemplateSpecializationFromInitializer(`
`9902`	`9902`	`// C++ [over.match.class.deduct#3]: ..., the defining-type-id of A must be`
`9903`	`9903`	`// of the form`
`9904`	`9904`	`// [typename] [nested-name-specifier] [template] simple-template-id`
`9905`		`- auto SpecializedTD = UnderlyingType->TryGetSpecializedTemplateDecl();`
	`9905`	`+ auto SpecializedTD = UnderlyingType->tryGetSpecializedTemplateDecl();`
`9906`	`9906`	`Template = dyn_cast_or_null<ClassTemplateDecl>(SpecializedTD);`
`9907`	`9907`	`}`
`9908`	`9908`	`}`