github-actions[bot] wrote: <!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning: <details> <summary> You can test this locally with the following command: </summary> ``````````bash git-clang-format --diff 1ecbab56dcbb78268c8d19af34a50591f90b12a0 59e1880df74434e3c446705788d92b5949d99536 -- clang/include/clang/AST/DeclTemplate.h clang/lib/AST/DeclTemplate.cpp clang/lib/AST/ODRHash.cpp clang/lib/Serialization/ASTReader.cpp clang/lib/Serialization/ASTReaderDecl.cpp clang/lib/Serialization/ASTWriter.cpp clang/lib/Serialization/ASTWriterDecl.cpp `````````` </details> <details> <summary> View the diff from clang-format here. </summary> ``````````diff diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h index 4ed9b58d4f..51caef54ba 100644 --- a/clang/include/clang/AST/DeclTemplate.h +++ b/clang/include/clang/AST/DeclTemplate.h @@ -739,8 +739,8 @@ class RedeclarableTemplateDecl : public TemplateDecl, bool IsPartial = false; LazySpecializationInfo(uint32_t ID, unsigned Hash = ~0U, bool Partial = false) - : DeclID(ID), ODRHash(Hash), IsPartial(Partial) { } - LazySpecializationInfo() { } + : DeclID(ID), ODRHash(Hash), IsPartial(Partial) {} + LazySpecializationInfo() {} bool operator<(const LazySpecializationInfo &Other) const { return DeclID < Other.DeclID; } diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp index 1babe39ee2..aa2368783d 100644 --- a/clang/lib/AST/DeclTemplate.cpp +++ b/clang/lib/AST/DeclTemplate.cpp @@ -16,12 +16,12 @@ #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/Expr.h" +#include "clang/AST/ExprCXX.h" #include "clang/AST/ExternalASTSource.h" +#include "clang/AST/ODRHash.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" -#include "clang/AST/ODRHash.h" -#include "clang/AST/ExprCXX.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/LLVM.h" @@ -334,7 +334,7 @@ RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() c } void RedeclarableTemplateDecl::loadLazySpecializationsImpl( - bool OnlyPartial/*=false*/) const { + bool OnlyPartial /*=false*/) const { // Grab the most recent declaration to ensure we've loaded any lazy // redeclarations of this template. CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr(); @@ -343,16 +343,16 @@ void RedeclarableTemplateDecl::loadLazySpecializationsImpl( CommonBasePtr->LazySpecializations = nullptr; for (uint32_t I = 0, N = Specs[0].DeclID; I != N; ++I) { // Skip over already loaded specializations. - if (!Specs[I+1].ODRHash) + if (!Specs[I + 1].ODRHash) continue; - if (!OnlyPartial || Specs[I+1].IsPartial) - (void)loadLazySpecializationImpl(Specs[I+1]); + if (!OnlyPartial || Specs[I + 1].IsPartial) + (void)loadLazySpecializationImpl(Specs[I + 1]); } } } Decl *RedeclarableTemplateDecl::loadLazySpecializationImpl( - LazySpecializationInfo &LazySpecInfo) const { + LazySpecializationInfo &LazySpecInfo) const { uint32_t ID = LazySpecInfo.DeclID; assert(ID && "Loading already loaded specialization!"); // Note that we loaded the specialization. @@ -360,16 +360,14 @@ Decl *RedeclarableTemplateDecl::loadLazySpecializationImpl( return getASTContext().getExternalSource()->GetExternalDecl(ID); } -void -RedeclarableTemplateDecl::loadLazySpecializationsImpl(ArrayRef<TemplateArgument> - Args, - TemplateParameterList *TPL) const { +void RedeclarableTemplateDecl::loadLazySpecializationsImpl( + ArrayRef<TemplateArgument> Args, TemplateParameterList *TPL) const { CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr(); if (auto *Specs = CommonBasePtr->LazySpecializations) { unsigned Hash = TemplateArgumentList::ComputeODRHash(Args); for (uint32_t I = 0, N = Specs[0].DeclID; I != N; ++I) - if (Specs[I+1].ODRHash && Specs[I+1].ODRHash == Hash) - (void)loadLazySpecializationImpl(Specs[I+1]); + if (Specs[I + 1].ODRHash && Specs[I + 1].ODRHash == Hash) + (void)loadLazySpecializationImpl(Specs[I + 1]); } } @@ -546,7 +544,7 @@ ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C, } void ClassTemplateDecl::LoadLazySpecializations( - bool OnlyPartial/*=false*/) const { + bool OnlyPartial /*=false*/) const { loadLazySpecializationsImpl(OnlyPartial); } @@ -1275,7 +1273,7 @@ VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C, } void VarTemplateDecl::LoadLazySpecializations( - bool OnlyPartial/*=false*/) const { + bool OnlyPartial /*=false*/) const { loadLazySpecializationsImpl(OnlyPartial); } diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp index 07d4fe8195..95942387a9 100644 --- a/clang/lib/Serialization/ASTReaderDecl.cpp +++ b/clang/lib/Serialization/ASTReaderDecl.cpp @@ -88,8 +88,8 @@ namespace clang { const SourceLocation ThisDeclLoc; using RecordData = ASTReader::RecordData; - using LazySpecializationInfo - = RedeclarableTemplateDecl::LazySpecializationInfo; + using LazySpecializationInfo = + RedeclarableTemplateDecl::LazySpecializationInfo; TypeID DeferredTypeID = 0; unsigned AnonymousDeclNumber = 0; @@ -274,9 +274,9 @@ namespace clang { : Reader(Reader), Record(Record), Loc(Loc), ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {} - template <typename T> static - void AddLazySpecializations(T *D, - SmallVectorImpl<LazySpecializationInfo>& IDs) { + template <typename T> + static void + AddLazySpecializations(T *D, SmallVectorImpl<LazySpecializationInfo> &IDs) { if (IDs.empty()) return; @@ -328,7 +328,7 @@ namespace clang { void ReadFunctionDefinition(FunctionDecl *FD); void Visit(Decl *D); - void UpdateDecl(Decl *D, llvm::SmallVectorImpl<LazySpecializationInfo>&); + void UpdateDecl(Decl *D, llvm::SmallVectorImpl<LazySpecializationInfo> &); static void setNextObjCCategory(ObjCCategoryDecl *Cat, ObjCCategoryDecl *Next) { @@ -4199,8 +4199,8 @@ void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) { ProcessingUpdatesRAIIObj ProcessingUpdates(*this); DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID); - using LazySpecializationInfo - = RedeclarableTemplateDecl::LazySpecializationInfo; + using LazySpecializationInfo = + RedeclarableTemplateDecl::LazySpecializationInfo; llvm::SmallVector<LazySpecializationInfo, 8> PendingLazySpecializationIDs; if (UpdI != DeclUpdateOffsets.end()) { @@ -4470,8 +4470,9 @@ static void forAllLaterRedecls(DeclT *D, Fn F) { } } -void ASTDeclReader::UpdateDecl(Decl *D, - SmallVectorImpl<LazySpecializationInfo> &PendingLazySpecializationIDs) { +void ASTDeclReader::UpdateDecl( + Decl *D, + SmallVectorImpl<LazySpecializationInfo> &PendingLazySpecializationIDs) { while (Record.getIdx() < Record.size()) { switch ((DeclUpdateKind)Record.readInt()) { case UPD_CXX_ADDED_IMPLICIT_MEMBER: { diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 6cb6d3d8fa..30deca374a 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -5346,9 +5346,9 @@ void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { Args = FD->getTemplateSpecializationArgs()->asArray(); assert(Args.size()); Record.push_back(TemplateArgumentList::ComputeODRHash(Args)); - bool IsPartialSpecialization - = isa<ClassTemplatePartialSpecializationDecl>(Spec) || - isa<VarTemplatePartialSpecializationDecl>(Spec); + bool IsPartialSpecialization = + isa<ClassTemplatePartialSpecializationDecl>(Spec) || + isa<VarTemplatePartialSpecializationDecl>(Spec); Record.push_back(IsPartialSpecialization); break; } diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp index 2cbf8e7a82..95d8735fe5 100644 --- a/clang/lib/Serialization/ASTWriterDecl.cpp +++ b/clang/lib/Serialization/ASTWriterDecl.cpp @@ -177,8 +177,9 @@ namespace clang { /// Collect the first declaration from each module file that provides a /// declaration of D. - void CollectFirstDeclFromEachModule(const Decl *D, bool IncludeLocal, - llvm::MapVector<ModuleFile*, const Decl*> &Firsts) { + void CollectFirstDeclFromEachModule( + const Decl *D, bool IncludeLocal, + llvm::MapVector<ModuleFile *, const Decl *> &Firsts) { // FIXME: We can skip entries that we know are implied by others. for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) { @@ -193,7 +194,7 @@ namespace clang { /// provides a declaration of D. The intent is to provide a sufficient /// set such that reloading this set will load all current redeclarations. void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) { - llvm::MapVector<ModuleFile*, const Decl*> Firsts; + llvm::MapVector<ModuleFile *, const Decl *> Firsts; CollectFirstDeclFromEachModule(D, IncludeLocal, Firsts); for (const auto &F : Firsts) @@ -207,9 +208,9 @@ namespace clang { void AddFirstSpecializationDeclFromEachModule(const Decl *D, bool IncludeLocal) { assert(isa<ClassTemplateSpecializationDecl>(D) || - isa<VarTemplateSpecializationDecl>(D) || isa<FunctionDecl>(D) && - "Must not be called with other decls"); - llvm::MapVector<ModuleFile*, const Decl*> Firsts; + isa<VarTemplateSpecializationDecl>(D) || + isa<FunctionDecl>(D) && "Must not be called with other decls"); + llvm::MapVector<ModuleFile *, const Decl *> Firsts; CollectFirstDeclFromEachModule(D, IncludeLocal, Firsts); for (const auto &F : Firsts) { @@ -223,9 +224,9 @@ namespace clang { Args = FD->getTemplateSpecializationArgs()->asArray(); assert(Args.size()); Record.push_back(TemplateArgumentList::ComputeODRHash(Args)); - bool IsPartialSpecialization - = isa<ClassTemplatePartialSpecializationDecl>(D) || - isa<VarTemplatePartialSpecializationDecl>(D); + bool IsPartialSpecialization = + isa<ClassTemplatePartialSpecializationDecl>(D) || + isa<VarTemplatePartialSpecializationDecl>(D); Record.push_back(IsPartialSpecialization); } } @@ -260,8 +261,8 @@ namespace clang { assert(!Common->LazySpecializations); } - using LazySpecializationInfo - = RedeclarableTemplateDecl::LazySpecializationInfo; + using LazySpecializationInfo = + RedeclarableTemplateDecl::LazySpecializationInfo; ArrayRef<LazySpecializationInfo> LazySpecializations; if (auto *LS = Common->LazySpecializations) LazySpecializations = llvm::ArrayRef(LS + 1, LS[0].DeclID); @@ -280,7 +281,7 @@ namespace clang { for (auto *D : Specs) { assert(D->isCanonicalDecl() && "non-canonical decl in set"); - AddFirstSpecializationDeclFromEachModule(D, /*IncludeLocal*/true); + AddFirstSpecializationDeclFromEachModule(D, /*IncludeLocal*/ true); } for (auto &SpecInfo : LazySpecializations) { Record.push_back(SpecInfo.DeclID); @@ -291,8 +292,8 @@ namespace clang { // Update the size entry we added earlier. We linerized the // LazySpecializationInfo members and we need to adjust the size as we // will read them always together. - assert ((Record.size() - I - 1) % 3 == 0 - && "Must be divisible by LazySpecializationInfo count!"); + assert((Record.size() - I - 1) % 3 == 0 && + "Must be divisible by LazySpecializationInfo count!"); Record[I] = (Record.size() - I - 1) / 3; } `````````` </details> https://github.com/llvm/llvm-project/pull/83108 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits