https://github.com/MaskRay created https://github.com/llvm/llvm-project/pull/219844
findSpecialization/AddSpecialization and their Decl.h wrappers stop threading a `void *` through the AST, Sema, Serialization and CodeGen callers. This is the last user of FoldingSet's `void *` insert position. In PPMacroExpansion.cpp the token is named InsertToken, as Token there means the lexer token. >From ebf29a2370a7971d05d315ebf6b4f287fd6b0f74 Mon Sep 17 00:00:00 2001 From: Fangrui Song <[email protected]> Date: Sun, 30 Aug 2026 12:56:30 -0700 Subject: [PATCH] [clang] Migrate remaining FoldingSet users to lookup/insert. NFC findSpecialization/AddSpecialization and their Decl.h wrappers stop threading a `void *` through the AST, Sema, Serialization and CodeGen callers. This is the last user of FoldingSet's `void *` insert position. In PPMacroExpansion.cpp the token is named InsertToken, as Token there means the lexer token. --- clang/include/clang/AST/Decl.h | 11 ++- clang/include/clang/AST/DeclTemplate.h | 49 ++++++---- .../Core/PathSensitive/SymbolManager.h | 6 +- clang/lib/AST/ASTImporter.cpp | 37 ++++---- clang/lib/AST/ByteCode/Compiler.cpp | 4 +- clang/lib/AST/Decl.cpp | 4 +- clang/lib/AST/DeclTemplate.cpp | 91 +++++++++---------- clang/lib/AST/ExprConstant.cpp | 4 +- clang/lib/Analysis/AnalysisDeclContext.cpp | 6 +- clang/lib/Analysis/LifetimeSafety/Loans.cpp | 14 ++- clang/lib/Analysis/PathDiagnostic.cpp | 18 ++-- clang/lib/Analysis/RetainSummaryManager.cpp | 6 +- clang/lib/Basic/IdentifierTable.cpp | 7 +- clang/lib/CIR/CodeGen/CIRGenClass.cpp | 4 +- clang/lib/CIR/CodeGen/CIRGenTypes.cpp | 6 +- clang/lib/CodeGen/CGBlocks.cpp | 7 +- clang/lib/CodeGen/CGCall.cpp | 6 +- clang/lib/CodeGen/CGClass.cpp | 4 +- clang/lib/Lex/PPMacroExpansion.cpp | 10 +- clang/lib/Sema/HLSLExternalSemaSource.cpp | 2 +- clang/lib/Sema/SemaCXXScopeSpec.cpp | 4 +- clang/lib/Sema/SemaTemplate.cpp | 43 +++++---- .../lib/Sema/SemaTemplateInstantiateDecl.cpp | 56 ++++++------ clang/lib/Serialization/ASTReaderDecl.cpp | 32 ++++--- .../StaticAnalyzer/Core/BasicValueFactory.cpp | 38 ++++---- clang/lib/StaticAnalyzer/Core/BugReporter.cpp | 10 +- .../lib/StaticAnalyzer/Core/ExplodedGraph.cpp | 8 +- clang/lib/StaticAnalyzer/Core/MemRegion.cpp | 24 ++--- .../lib/StaticAnalyzer/Core/ProgramState.cpp | 8 +- .../Core/RangeConstraintManager.cpp | 6 +- clang/unittests/AST/ExternalASTSourceTest.cpp | 2 +- 31 files changed, 265 insertions(+), 262 deletions(-) diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h index 92050d635e2e0..f239bbad2f17c 100644 --- a/clang/include/clang/AST/Decl.h +++ b/clang/include/clang/AST/Decl.h @@ -37,6 +37,7 @@ #include "clang/Basic/Visibility.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/StringRef.h" @@ -2228,7 +2229,7 @@ class FunctionDecl : public DeclaratorDecl, /// \param TemplateArgs the template arguments that produced this /// function template specialization from the template. /// - /// \param InsertPos If non-NULL, the position in the function template + /// \param Token If set, the insert token in the function template /// specialization set where the function template specialization data will /// be inserted. /// @@ -2240,7 +2241,7 @@ class FunctionDecl : public DeclaratorDecl, /// specialization was first instantiated. void setFunctionTemplateSpecialization( ASTContext &C, FunctionTemplateDecl *Template, - TemplateArgumentList *TemplateArgs, void *InsertPos, + TemplateArgumentList *TemplateArgs, llvm::FoldingSetInsertToken Token, TemplateSpecializationKind TSK, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation PointOfInstantiation); @@ -3191,7 +3192,7 @@ class FunctionDecl : public DeclaratorDecl, /// \param TemplateArgs the template arguments that produced this /// function template specialization from the template. /// - /// \param InsertPos If non-NULL, the position in the function template + /// \param Token If set, the insert token in the function template /// specialization set where the function template specialization data will /// be inserted. /// @@ -3203,12 +3204,12 @@ class FunctionDecl : public DeclaratorDecl, /// specialization was first instantiated. void setFunctionTemplateSpecialization( FunctionTemplateDecl *Template, TemplateArgumentList *TemplateArgs, - void *InsertPos, + llvm::FoldingSetInsertToken Token, TemplateSpecializationKind TSK = TSK_ImplicitInstantiation, TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr, SourceLocation PointOfInstantiation = SourceLocation()) { setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs, - InsertPos, TSK, TemplateArgsAsWritten, + Token, TSK, TemplateArgsAsWritten, PointOfInstantiation); } diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h index f5b26b0aab9ba..14b353d48c690 100644 --- a/clang/include/clang/AST/DeclTemplate.h +++ b/clang/include/clang/AST/DeclTemplate.h @@ -778,16 +778,19 @@ class RedeclarableTemplateDecl : public TemplateDecl, template <class EntryType, typename... ProfileArguments> typename SpecEntryTraits<EntryType>::DeclType * findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs, - void *&InsertPos, ProfileArguments... ProfileArgs); + llvm::FoldingSetInsertToken &Token, + ProfileArguments... ProfileArgs); template <class EntryType, typename... ProfileArguments> typename SpecEntryTraits<EntryType>::DeclType * findSpecializationLocally(llvm::FoldingSetVector<EntryType> &Specs, - void *&InsertPos, ProfileArguments... ProfileArgs); + llvm::FoldingSetInsertToken &Token, + ProfileArguments... ProfileArgs); template <class Derived, class EntryType> void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs, - EntryType *Entry, void *InsertPos); + EntryType *Entry, + llvm::FoldingSetInsertToken Token); struct CommonBase { CommonBase() : InstantiatedFromMember(nullptr, false) {} @@ -983,10 +986,10 @@ class FunctionTemplateDecl : public RedeclarableTemplateDecl { /// Add a specialization of this function template. /// - /// \param InsertPos Insert position in the FoldingSetVector, must have been - /// retrieved by an earlier call to findSpecialization(). - void addSpecialization(FunctionTemplateSpecializationInfo* Info, - void *InsertPos); + /// \param Token Insert token, must have been retrieved by an earlier call + /// to findSpecialization(). + void addSpecialization(FunctionTemplateSpecializationInfo *Info, + llvm::FoldingSetInsertToken Token); public: friend class ASTDeclReader; @@ -1029,7 +1032,7 @@ class FunctionTemplateDecl : public RedeclarableTemplateDecl { /// Return the specialization with the provided arguments if it exists, /// otherwise return the insertion point. FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args, - void *&InsertPos); + llvm::FoldingSetInsertToken &Token); FunctionTemplateDecl *getCanonicalDecl() override { return cast<FunctionTemplateDecl>( @@ -2338,11 +2341,13 @@ class ClassTemplateDecl : public RedeclarableTemplateDecl { /// Return the specialization with the provided arguments if it exists, /// otherwise return the insertion point. ClassTemplateSpecializationDecl * - findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos); + findSpecialization(ArrayRef<TemplateArgument> Args, + llvm::FoldingSetInsertToken &Token); /// Insert the specified specialization knowing that it is not already - /// in. InsertPos must be obtained from findSpecialization. - void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos); + /// in. Token must be obtained from findSpecialization. + void AddSpecialization(ClassTemplateSpecializationDecl *D, + llvm::FoldingSetInsertToken Token); ClassTemplateDecl *getCanonicalDecl() override { return cast<ClassTemplateDecl>( @@ -2382,12 +2387,13 @@ class ClassTemplateDecl : public RedeclarableTemplateDecl { /// exists, otherwise return the insertion point. ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef<TemplateArgument> Args, - TemplateParameterList *TPL, void *&InsertPos); + TemplateParameterList *TPL, + llvm::FoldingSetInsertToken &Token); /// Insert the specified partial specialization knowing that it is not - /// already in. InsertPos must be obtained from findPartialSpecialization. + /// already in. Token must be obtained from findPartialSpecialization. void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, - void *InsertPos); + llvm::FoldingSetInsertToken Token); /// Retrieve the partial specializations as an ordered list. void getPartialSpecializations( @@ -3097,11 +3103,13 @@ class VarTemplateDecl : public RedeclarableTemplateDecl { /// Return the specialization with the provided arguments if it exists, /// otherwise return the insertion point. VarTemplateSpecializationDecl * - findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos); + findSpecialization(ArrayRef<TemplateArgument> Args, + llvm::FoldingSetInsertToken &Token); /// Insert the specified specialization knowing that it is not already - /// in. InsertPos must be obtained from findSpecialization. - void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos); + /// in. Token must be obtained from findSpecialization. + void AddSpecialization(VarTemplateSpecializationDecl *D, + llvm::FoldingSetInsertToken Token); VarTemplateDecl *getCanonicalDecl() override { return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl()); @@ -3139,12 +3147,13 @@ class VarTemplateDecl : public RedeclarableTemplateDecl { /// exists, otherwise return the insertion point. VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef<TemplateArgument> Args, - TemplateParameterList *TPL, void *&InsertPos); + TemplateParameterList *TPL, + llvm::FoldingSetInsertToken &Token); /// Insert the specified partial specialization knowing that it is not - /// already in. InsertPos must be obtained from findPartialSpecialization. + /// already in. Token must be obtained from findPartialSpecialization. void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, - void *InsertPos); + llvm::FoldingSetInsertToken Token); /// Retrieve the partial specializations as an ordered list. void getPartialSpecializations( diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h index a5d49200a50cb..3fcc505e9f94e 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h @@ -675,11 +675,11 @@ template <typename T, typename... Args> const T *SymbolManager::acquire(Args &&...args) { llvm::FoldingSetNodeID profile; T::Profile(profile, args...); - void *InsertPos; - SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos); + llvm::FoldingSetInsertToken Token; + SymExpr *SD = DataSet.lookup(profile, Token); if (!SD) { SD = Alloc.make<T>(std::forward<Args>(args)...); - DataSet.InsertNode(SD, InsertPos); + DataSet.insert(SD, Token); } return cast<T>(SD); } diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index 0ad4130ce252a..b684ba7ab0f29 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -3727,8 +3727,8 @@ Error ASTNodeImporter::ImportTemplateInformation( TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind(); ToFD->setFunctionTemplateSpecialization( - std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr, - TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr); + std::get<0>(*FunctionAndArgsOrErr), ToTAList, /*Token=*/{}, TSK, + FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr); return Error::success(); } @@ -3769,8 +3769,8 @@ ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) { FunctionTemplateDecl *Template; TemplateArgsTy ToTemplArgs; std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr; - void *InsertPos = nullptr; - auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos); + llvm::FoldingSetInsertToken Token; + auto *FoundSpec = Template->findSpecialization(ToTemplArgs, Token); return FoundSpec; } @@ -6368,7 +6368,7 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( return std::move(Err); // Try to find an existing specialization with these template arguments and // template parameter list. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *PrevDecl = nullptr; ClassTemplatePartialSpecializationDecl *PartialSpec = dyn_cast<ClassTemplatePartialSpecializationDecl>(D); @@ -6382,10 +6382,9 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( return ToTPListOrErr.takeError(); ToTPList = *ToTPListOrErr; PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs, - *ToTPListOrErr, - InsertPos); + *ToTPListOrErr, Token); } else - PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); + PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, Token); if (PrevDecl) { if (IsStructuralMatch(D, PrevDecl)) { @@ -6446,13 +6445,13 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl))) return D2; - // Update InsertPos, because preceding import calls may have invalidated + // Update Token, because preceding import calls may have invalidated // it by adding new specializations. auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2); if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList, - InsertPos)) + Token)) // Add this partial specialization to the class template. - ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos); + ClassTemplate->AddPartialSpecialization(PartSpec2, Token); if (Expected<ClassTemplatePartialSpecializationDecl *> ToInstOrErr = import(PartialSpec->getInstantiatedFromMember())) PartSpec2->setInstantiatedFromMember(*ToInstOrErr); @@ -6467,11 +6466,11 @@ ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( PrevDecl)) return D2; - // Update InsertPos, because preceding import calls may have invalidated + // Update Token, because preceding import calls may have invalidated // it by adding new specializations. - if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos)) + if (!ClassTemplate->findSpecialization(TemplateArgs, Token)) // Add this specialization to the class template. - ClassTemplate->AddSpecialization(D2, InsertPos); + ClassTemplate->AddSpecialization(D2, Token); } D2->setSpecializationKind(D->getSpecializationKind()); @@ -6698,9 +6697,9 @@ ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl( return std::move(Err); // Try to find an existing specialization with these template arguments. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; VarTemplateSpecializationDecl *FoundSpecialization = - VarTemplate->findSpecialization(TemplateArgs, InsertPos); + VarTemplate->findSpecialization(TemplateArgs, Token); if (FoundSpecialization) { if (IsStructuralMatch(D, FoundSpecialization)) { VarDecl *FoundDef = FoundSpecialization->getDefinition(); @@ -6770,10 +6769,10 @@ ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl( return D2; } - // Update InsertPos, because preceding import calls may have invalidated + // Update Token, because preceding import calls may have invalidated // it by adding new specializations. - if (!VarTemplate->findSpecialization(TemplateArgs, InsertPos)) - VarTemplate->AddSpecialization(D2, InsertPos); + if (!VarTemplate->findSpecialization(TemplateArgs, Token)) + VarTemplate->AddSpecialization(D2, Token); QualType T; if (Error Err = importInto(T, D->getType())) diff --git a/clang/lib/AST/ByteCode/Compiler.cpp b/clang/lib/AST/ByteCode/Compiler.cpp index c182639ea07f8..fec8d00fcae12 100644 --- a/clang/lib/AST/ByteCode/Compiler.cpp +++ b/clang/lib/AST/ByteCode/Compiler.cpp @@ -7282,9 +7282,9 @@ bool Compiler<Emitter>::emitLambdaStaticInvokerBody(const CXXMethodDecl *MD) { const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs(); FunctionTemplateDecl *CallOpTemplate = LambdaCallOp->getDescribedFunctionTemplate(); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; const FunctionDecl *CorrespondingCallOpSpecialization = - CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos); + CallOpTemplate->findSpecialization(TAL->asArray(), Token); assert(CorrespondingCallOpSpecialization); LambdaCallOp = CorrespondingCallOpSpecialization; } else { diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp index c9524dc82588a..93a7a47955936 100644 --- a/clang/lib/AST/Decl.cpp +++ b/clang/lib/AST/Decl.cpp @@ -4393,7 +4393,7 @@ FunctionDecl::getTemplateSpecializationArgsAsWritten() const { void FunctionDecl::setFunctionTemplateSpecialization( ASTContext &C, FunctionTemplateDecl *Template, - TemplateArgumentList *TemplateArgs, void *InsertPos, + TemplateArgumentList *TemplateArgs, llvm::FoldingSetInsertToken Token, TemplateSpecializationKind TSK, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation PointOfInstantiation) { @@ -4413,7 +4413,7 @@ void FunctionDecl::setFunctionTemplateSpecialization( dyn_cast_if_present<MemberSpecializationInfo *>( TemplateOrSpecialization)); TemplateOrSpecialization = Info; - Template->addSpecialization(Info, InsertPos); + Template->addSpecialization(Info, Token); } void FunctionDecl::setDependentTemplateSpecialization( diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp index 3f952a1fe980b..188c67b9738a5 100644 --- a/clang/lib/AST/DeclTemplate.cpp +++ b/clang/lib/AST/DeclTemplate.cpp @@ -376,38 +376,38 @@ bool RedeclarableTemplateDecl::loadLazySpecializationsImpl( template <class EntryType, typename... ProfileArguments> typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType * RedeclarableTemplateDecl::findSpecializationLocally( - llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos, - ProfileArguments... ProfileArgs) { + llvm::FoldingSetVector<EntryType> &Specs, + llvm::FoldingSetInsertToken &Token, ProfileArguments... ProfileArgs) { using SETraits = RedeclarableTemplateDecl::SpecEntryTraits<EntryType>; llvm::FoldingSetNodeID ID; EntryType::Profile(ID, ProfileArgs..., getASTContext()); - EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos); + EntryType *Entry = Specs.lookup(ID, Token); return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr; } template <class EntryType, typename... ProfileArguments> typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType * RedeclarableTemplateDecl::findSpecializationImpl( - llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos, - ProfileArguments... ProfileArgs) { + llvm::FoldingSetVector<EntryType> &Specs, + llvm::FoldingSetInsertToken &Token, ProfileArguments... ProfileArgs) { - if (auto *Found = findSpecializationLocally(Specs, InsertPos, ProfileArgs...)) + if (auto *Found = findSpecializationLocally(Specs, Token, ProfileArgs...)) return Found; if (!loadLazySpecializationsImpl(ProfileArgs...)) return nullptr; - return findSpecializationLocally(Specs, InsertPos, ProfileArgs...); + return findSpecializationLocally(Specs, Token, ProfileArgs...); } -template<class Derived, class EntryType> +template <class Derived, class EntryType> void RedeclarableTemplateDecl::addSpecializationImpl( llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry, - void *InsertPos) { + llvm::FoldingSetInsertToken Token) { using SETraits = SpecEntryTraits<EntryType>; - if (InsertPos) { + if (Token) { #ifndef NDEBUG auto Args = SETraits::getTemplateArgs(Entry); // Due to hash collisions, it can happen that we load another template @@ -415,14 +415,13 @@ void RedeclarableTemplateDecl::addSpecializationImpl( // call to findSpecializationImpl does not find a matching Decl for the // template arguments. loadLazySpecializationsImpl(Args); - void *CorrectInsertPos; - assert(!findSpecializationImpl(Specializations, CorrectInsertPos, Args) && - InsertPos == CorrectInsertPos && - "given incorrect InsertPos for specialization"); + llvm::FoldingSetInsertToken CorrectToken; + assert(!findSpecializationImpl(Specializations, CorrectToken, Args) && + Token == CorrectToken && "given incorrect Token for specialization"); #endif - Specializations.InsertNode(Entry, InsertPos); + Specializations.insert(Entry, Token); } else { - EntryType *Existing = Specializations.GetOrInsertNode(Entry); + EntryType *Existing = Specializations.getOrInsert(Entry); (void)Existing; assert(SETraits::getDecl(Existing)->isCanonicalDecl() && "non-canonical specialization?"); @@ -474,16 +473,17 @@ FunctionTemplateDecl::getSpecializations() const { FunctionDecl * FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, - void *&InsertPos) { + llvm::FoldingSetInsertToken &Token) { auto *Common = getCommonPtr(); - return findSpecializationImpl(Common->Specializations, InsertPos, Args); + return findSpecializationImpl(Common->Specializations, Token, Args); } void FunctionTemplateDecl::addSpecialization( - FunctionTemplateSpecializationInfo *Info, void *InsertPos) { + FunctionTemplateSpecializationInfo *Info, + llvm::FoldingSetInsertToken Token) { auto *Common = getCommonPtr(); addSpecializationImpl<FunctionTemplateDecl>(Common->Specializations, Info, - InsertPos); + Token); } void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) { @@ -569,24 +569,22 @@ ClassTemplateDecl::newCommon(ASTContext &C) const { ClassTemplateSpecializationDecl * ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, - void *&InsertPos) { + llvm::FoldingSetInsertToken &Token) { auto *Common = getCommonPtr(); - return findSpecializationImpl(Common->Specializations, InsertPos, Args); + return findSpecializationImpl(Common->Specializations, Token, Args); } void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, - void *InsertPos) { + llvm::FoldingSetInsertToken Token) { auto *Common = getCommonPtr(); - addSpecializationImpl<ClassTemplateDecl>(Common->Specializations, D, - InsertPos); + addSpecializationImpl<ClassTemplateDecl>(Common->Specializations, D, Token); } ClassTemplatePartialSpecializationDecl * ClassTemplateDecl::findPartialSpecialization( - ArrayRef<TemplateArgument> Args, - TemplateParameterList *TPL, void *&InsertPos) { - return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args, - TPL); + ArrayRef<TemplateArgument> Args, TemplateParameterList *TPL, + llvm::FoldingSetInsertToken &Token) { + return findSpecializationImpl(getPartialSpecializations(), Token, Args, TPL); } void ClassTemplatePartialSpecializationDecl::Profile( @@ -599,13 +597,13 @@ void ClassTemplatePartialSpecializationDecl::Profile( } void ClassTemplateDecl::AddPartialSpecialization( - ClassTemplatePartialSpecializationDecl *D, - void *InsertPos) { - if (InsertPos) - getPartialSpecializations().InsertNode(D, InsertPos); + ClassTemplatePartialSpecializationDecl *D, + llvm::FoldingSetInsertToken Token) { + if (Token) + getPartialSpecializations().insert(D, Token); else { - ClassTemplatePartialSpecializationDecl *Existing - = getPartialSpecializations().GetOrInsertNode(D); + ClassTemplatePartialSpecializationDecl *Existing = + getPartialSpecializations().getOrInsert(D); (void)Existing; assert(Existing->isCanonicalDecl() && "Non-canonical specialization?"); } @@ -1363,22 +1361,22 @@ VarTemplateDecl::newCommon(ASTContext &C) const { VarTemplateSpecializationDecl * VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args, - void *&InsertPos) { + llvm::FoldingSetInsertToken &Token) { auto *Common = getCommonPtr(); - return findSpecializationImpl(Common->Specializations, InsertPos, Args); + return findSpecializationImpl(Common->Specializations, Token, Args); } void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D, - void *InsertPos) { + llvm::FoldingSetInsertToken Token) { auto *Common = getCommonPtr(); - addSpecializationImpl<VarTemplateDecl>(Common->Specializations, D, InsertPos); + addSpecializationImpl<VarTemplateDecl>(Common->Specializations, D, Token); } VarTemplatePartialSpecializationDecl * VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args, - TemplateParameterList *TPL, void *&InsertPos) { - return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args, - TPL); + TemplateParameterList *TPL, + llvm::FoldingSetInsertToken &Token) { + return findSpecializationImpl(getPartialSpecializations(), Token, Args, TPL); } void VarTemplatePartialSpecializationDecl::Profile( @@ -1391,12 +1389,13 @@ void VarTemplatePartialSpecializationDecl::Profile( } void VarTemplateDecl::AddPartialSpecialization( - VarTemplatePartialSpecializationDecl *D, void *InsertPos) { - if (InsertPos) - getPartialSpecializations().InsertNode(D, InsertPos); + VarTemplatePartialSpecializationDecl *D, + llvm::FoldingSetInsertToken Token) { + if (Token) + getPartialSpecializations().insert(D, Token); else { VarTemplatePartialSpecializationDecl *Existing = - getPartialSpecializations().GetOrInsertNode(D); + getPartialSpecializations().getOrInsert(D); (void)Existing; assert(Existing->isCanonicalDecl() && "Non-canonical specialization?"); } diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 9702105951b7b..6892f159edecb 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -9018,9 +9018,9 @@ class ExprEvaluatorBase const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs(); FunctionTemplateDecl *CallOpTemplate = LambdaCallOp->getDescribedFunctionTemplate(); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; FunctionDecl *CorrespondingCallOpSpecialization = - CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos); + CallOpTemplate->findSpecialization(TAL->asArray(), Token); assert(CorrespondingCallOpSpecialization && "We must always have a function call operator specialization " "that corresponds to our static invoker specialization"); diff --git a/clang/lib/Analysis/AnalysisDeclContext.cpp b/clang/lib/Analysis/AnalysisDeclContext.cpp index 649035c46d019..cf7a1611fe142 100644 --- a/clang/lib/Analysis/AnalysisDeclContext.cpp +++ b/clang/lib/Analysis/AnalysisDeclContext.cpp @@ -411,11 +411,11 @@ const StackFrame *StackFrameManager::getStackFrame( const Expr *E, const CFGBlock *B, unsigned BlockCount, unsigned StmtIdx) { llvm::FoldingSetNodeID ID; StackFrame::Profile(ID, Ctx, Parent, Data, E, B, BlockCount, StmtIdx); - void *InsertPos; - StackFrame *SF = Frames.FindNodeOrInsertPos(ID, InsertPos); + llvm::FoldingSetInsertToken Token; + StackFrame *SF = Frames.lookup(ID, Token); if (!SF) { SF = new StackFrame(Ctx, Parent, Data, E, B, BlockCount, StmtIdx, ++NewID); - Frames.InsertNode(SF, InsertPos); + Frames.insert(SF, Token); } return SF; } diff --git a/clang/lib/Analysis/LifetimeSafety/Loans.cpp b/clang/lib/Analysis/LifetimeSafety/Loans.cpp index e71842eefca6a..fef4a1dcba0f0 100644 --- a/clang/lib/Analysis/LifetimeSafety/Loans.cpp +++ b/clang/lib/Analysis/LifetimeSafety/Loans.cpp @@ -39,14 +39,13 @@ const PlaceholderBase * LoanManager::getOrCreatePlaceholderBase(const ParmVarDecl *PVD) { llvm::FoldingSetNodeID ID; ID.AddPointer(PVD); - void *InsertPos = nullptr; - if (PlaceholderBase *Existing = - PlaceholderBases.FindNodeOrInsertPos(ID, InsertPos)) + llvm::FoldingSetInsertToken Token; + if (PlaceholderBase *Existing = PlaceholderBases.lookup(ID, Token)) return Existing; void *Mem = LoanAllocator.Allocate<PlaceholderBase>(); PlaceholderBase *NewPB = new (Mem) PlaceholderBase(PVD); - PlaceholderBases.InsertNode(NewPB, InsertPos); + PlaceholderBases.insert(NewPB, Token); return NewPB; } @@ -54,14 +53,13 @@ const PlaceholderBase * LoanManager::getOrCreatePlaceholderBase(const CXXMethodDecl *MD) { llvm::FoldingSetNodeID ID; ID.AddPointer(MD); - void *InsertPos = nullptr; - if (PlaceholderBase *Existing = - PlaceholderBases.FindNodeOrInsertPos(ID, InsertPos)) + llvm::FoldingSetInsertToken Token; + if (PlaceholderBase *Existing = PlaceholderBases.lookup(ID, Token)) return Existing; void *Mem = LoanAllocator.Allocate<PlaceholderBase>(); PlaceholderBase *NewPB = new (Mem) PlaceholderBase(MD); - PlaceholderBases.InsertNode(NewPB, InsertPos); + PlaceholderBases.insert(NewPB, Token); return NewPB; } } // namespace clang::lifetimes::internal diff --git a/clang/lib/Analysis/PathDiagnostic.cpp b/clang/lib/Analysis/PathDiagnostic.cpp index a95ef4582be99..48b51a469ac26 100644 --- a/clang/lib/Analysis/PathDiagnostic.cpp +++ b/clang/lib/Analysis/PathDiagnostic.cpp @@ -199,9 +199,9 @@ void PathDiagnosticConsumer::HandlePathDiagnostic( // Profile the node to see if we already have something matching it llvm::FoldingSetNodeID profile; D->Profile(profile); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; - if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) { + if (PathDiagnostic *orig = Diags.lookup(profile, Token)) { // Keep the PathDiagnostic with the shorter path. // Note, the enclosing routine is called in deterministic order, so the // results will be consistent between runs (no reason to break ties if the @@ -212,11 +212,11 @@ void PathDiagnosticConsumer::HandlePathDiagnostic( return; assert(orig != D.get()); - Diags.RemoveNode(orig); + Diags.erase(orig); delete orig; } - Diags.InsertNode(D.release()); + Diags.insert(D.release()); } static std::optional<bool> comparePath(const PathPieces &X, @@ -437,12 +437,12 @@ void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, StringRef FileName) { llvm::FoldingSetNodeID NodeID; NodeID.Add(PD); - void *InsertPos; - PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); + llvm::FoldingSetInsertToken Token; + PDFileEntry *Entry = Set.lookup(NodeID, Token); if (!Entry) { Entry = Alloc.Allocate<PDFileEntry>(); Entry = new (Entry) PDFileEntry(NodeID); - Set.InsertNode(Entry, InsertPos); + Set.insert(Entry, Token); } // Allocate persistent storage for the file name. @@ -458,8 +458,8 @@ PathDiagnosticConsumer::PDFileEntry::ConsumerFiles * PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) { llvm::FoldingSetNodeID NodeID; NodeID.Add(PD); - void *InsertPos; - PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); + llvm::FoldingSetInsertToken Token; + PDFileEntry *Entry = Set.lookup(NodeID, Token); if (!Entry) return nullptr; return &Entry->files; diff --git a/clang/lib/Analysis/RetainSummaryManager.cpp b/clang/lib/Analysis/RetainSummaryManager.cpp index b622027ee7e1e..2294a165a0eea 100644 --- a/clang/lib/Analysis/RetainSummaryManager.cpp +++ b/clang/lib/Analysis/RetainSummaryManager.cpp @@ -120,13 +120,13 @@ RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) { ::llvm::FoldingSetNodeID ID; OldSumm.Profile(ID); - void *Pos; - CachedSummaryNode *N = SimpleSummaries.FindNodeOrInsertPos(ID, Pos); + llvm::FoldingSetInsertToken Token; + CachedSummaryNode *N = SimpleSummaries.lookup(ID, Token); if (!N) { N = (CachedSummaryNode *) BPAlloc.Allocate<CachedSummaryNode>(); new (N) CachedSummaryNode(OldSumm); - SimpleSummaries.InsertNode(N, Pos); + SimpleSummaries.insert(N, Token); } return &N->getValue(); diff --git a/clang/lib/Basic/IdentifierTable.cpp b/clang/lib/Basic/IdentifierTable.cpp index 68cd02a623351..f4ebf40e2e60c 100644 --- a/clang/lib/Basic/IdentifierTable.cpp +++ b/clang/lib/Basic/IdentifierTable.cpp @@ -754,9 +754,8 @@ Selector SelectorTable::getSelector(unsigned nKeys, llvm::FoldingSetNodeID ID; MultiKeywordSelector::Profile(ID, IIV, nKeys); - void *InsertPos = nullptr; - if (MultiKeywordSelector *SI = - SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos)) + llvm::FoldingSetInsertToken Token; + if (MultiKeywordSelector *SI = SelTabImpl.Table.lookup(ID, Token)) return Selector(SI); // MultiKeywordSelector objects are not allocated with new because they have a @@ -766,7 +765,7 @@ Selector SelectorTable::getSelector(unsigned nKeys, (MultiKeywordSelector *)SelTabImpl.Allocator.Allocate( Size, alignof(MultiKeywordSelector)); new (SI) MultiKeywordSelector(nKeys, IIV); - SelTabImpl.Table.InsertNode(SI, InsertPos); + SelTabImpl.Table.insert(SI, Token); return Selector(SI); } diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp index dded17c6aeb0f..18abcf761378d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp @@ -982,9 +982,9 @@ void CIRGenFunction::emitLambdaDelegatingInvokeBody(const CXXMethodDecl *md) { const TemplateArgumentList *tal = md->getTemplateSpecializationArgs(); FunctionTemplateDecl *callOpTemplate = callOp->getDescribedFunctionTemplate(); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; FunctionDecl *correspondingCallOpSpecialization = - callOpTemplate->findSpecialization(tal->asArray(), InsertPos); + callOpTemplate->findSpecialization(tal->asArray(), Token); assert(correspondingCallOpSpecialization); callOp = cast<CXXMethodDecl>(correspondingCallOpSpecialization); } diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp index f1834d8fc7f37..2ca2f43e87e3b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp @@ -764,8 +764,8 @@ const CIRGenFunctionInfo &CIRGenTypes::arrangeCIRFunctionInfo( CIRGenFunctionInfo::Profile(id, isInstanceMethod, info, required, returnType, argTypes); - void *insertPos = nullptr; - CIRGenFunctionInfo *fi = functionInfos.FindNodeOrInsertPos(id, insertPos); + llvm::FoldingSetInsertToken token; + CIRGenFunctionInfo *fi = functionInfos.lookup(id, token); if (fi) { // We found a matching function info based on id. These asserts verify that // it really is a match. @@ -781,7 +781,7 @@ const CIRGenFunctionInfo &CIRGenTypes::arrangeCIRFunctionInfo( // Construction the function info. We co-allocate the ArgInfos. fi = CIRGenFunctionInfo::create(info, isInstanceMethod, returnType, argTypes, required); - functionInfos.InsertNode(fi, insertPos); + functionInfos.insert(fi, token); return *fi; } diff --git a/clang/lib/CodeGen/CGBlocks.cpp b/clang/lib/CodeGen/CGBlocks.cpp index aeb2e3321c4d7..7e5d6b8f0f923 100644 --- a/clang/lib/CodeGen/CGBlocks.cpp +++ b/clang/lib/CodeGen/CGBlocks.cpp @@ -2509,16 +2509,15 @@ static T *buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, llvm::FoldingSetNodeID id; generator.Profile(id); - void *insertPos; - BlockByrefHelpers *node - = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos); + llvm::FoldingSetInsertToken Token; + BlockByrefHelpers *node = CGM.ByrefHelpersCache.lookup(id, Token); if (node) return static_cast<T*>(node); generator.CopyHelper = buildByrefCopyHelper(CGM, byrefInfo, generator); generator.DisposeHelper = buildByrefDisposeHelper(CGM, byrefInfo, generator); T *copy = new (CGM.getContext()) T(std::forward<T>(generator)); - CGM.ByrefHelpersCache.InsertNode(copy, insertPos); + CGM.ByrefHelpersCache.insert(copy, Token); return copy; } diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index 86400cd1187be..0851e4f59279a 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -1092,8 +1092,8 @@ CGFunctionInfo *CodeGenTypes::findOrInsertCGFunctionInfo( X86ABIAVXLevel, info, paramInfos, required, resultType, argTypes); - void *insertPos = nullptr; - CGFunctionInfo *FI = FunctionInfos.FindNodeOrInsertPos(ID, insertPos); + llvm::FoldingSetInsertToken Token; + CGFunctionInfo *FI = FunctionInfos.lookup(ID, Token); if (FI) return FI; @@ -1103,7 +1103,7 @@ CGFunctionInfo *CodeGenTypes::findOrInsertCGFunctionInfo( FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall, X86ABIAVXLevel, info, paramInfos, resultType, argTypes, required); - FunctionInfos.InsertNode(FI, insertPos); + FunctionInfos.insert(FI, Token); bool inserted = FunctionsBeingProcessed.insert(FI).second; (void)inserted; diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp index 9c0c1cbdeb219..2369e08cf9374 100644 --- a/clang/lib/CodeGen/CGClass.cpp +++ b/clang/lib/CodeGen/CGClass.cpp @@ -3235,9 +3235,9 @@ void CodeGenFunction::EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD, const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs(); FunctionTemplateDecl *CallOpTemplate = CallOp->getDescribedFunctionTemplate(); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; FunctionDecl *CorrespondingCallOpSpecialization = - CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos); + CallOpTemplate->findSpecialization(TAL->asArray(), Token); assert(CorrespondingCallOpSpecialization); CallOp = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization); } diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp index eabb1d242506f..a8b9bcd4e4572 100644 --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -134,14 +134,14 @@ ModuleMacro *Preprocessor::addModuleMacro(Module *Mod, IdentifierInfo *II, llvm::FoldingSetNodeID ID; ModuleMacro::Profile(ID, Mod, II); - void *InsertPos; - if (auto *MM = ModuleMacros.FindNodeOrInsertPos(ID, InsertPos)) { + llvm::FoldingSetInsertToken InsertToken; + if (auto *MM = ModuleMacros.lookup(ID, InsertToken)) { New = false; return MM; } auto *MM = ModuleMacro::create(*this, Mod, II, Macro, Overrides); - ModuleMacros.InsertNode(MM, InsertPos); + ModuleMacros.insert(MM, InsertToken); // Each overridden macro is now overridden by one more macro. bool HidAny = false; @@ -171,8 +171,8 @@ ModuleMacro *Preprocessor::getModuleMacro(Module *Mod, llvm::FoldingSetNodeID ID; ModuleMacro::Profile(ID, Mod, II); - void *InsertPos; - return ModuleMacros.FindNodeOrInsertPos(ID, InsertPos); + llvm::FoldingSetInsertToken InsertToken; + return ModuleMacros.lookup(ID, InsertToken); } void Preprocessor::updateModuleMacroInfo(const IdentifierInfo *II, diff --git a/clang/lib/Sema/HLSLExternalSemaSource.cpp b/clang/lib/Sema/HLSLExternalSemaSource.cpp index f8fe990210fbb..2bfb8a77cc0f9 100644 --- a/clang/lib/Sema/HLSLExternalSemaSource.cpp +++ b/clang/lib/Sema/HLSLExternalSemaSource.cpp @@ -382,7 +382,7 @@ addVectorTexturePartialSpecialization(Sema &S, NamespaceDecl *HLSLNamespace, // Add the partial specialization to the namespace and the class template. HLSLNamespace->addDecl(PartialSpec); - TextureTemplate->AddPartialSpecialization(PartialSpec, nullptr); + TextureTemplate->AddPartialSpecialization(PartialSpec, {}); return PartialSpec; } diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp index 58da58ca3c899..b8aeb0549a21b 100644 --- a/clang/lib/Sema/SemaCXXScopeSpec.cpp +++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp @@ -100,9 +100,9 @@ DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS, return TPL->getDepth() == Depth; }); if (L != TemplateParamLists.end()) { - void *Pos = nullptr; + llvm::FoldingSetInsertToken Token; PartialSpec = ClassTemplate->findPartialSpecialization( - SpecType->template_arguments(), *L, Pos); + SpecType->template_arguments(), *L, Token); } } else { // FIXME: The fallback on the search of partial diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index eb93a5e03b06f..55692f882649e 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -3977,9 +3977,9 @@ QualType Sema::CheckTemplateIdType(ElaboratedTypeKeyword Keyword, dyn_cast<ClassTemplateDecl>(Template)) { // Find the class template specialization declaration that // corresponds to these arguments. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *Decl = - ClassTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + ClassTemplate->findSpecialization(CTAI.CanonicalConverted, Token); if (!Decl) { // This is the first time we have referenced this class template // specialization. Create the canonical declaration and add it to @@ -3990,7 +3990,7 @@ QualType Sema::CheckTemplateIdType(ElaboratedTypeKeyword Keyword, ClassTemplate->getTemplatedDecl()->getBeginLoc(), ClassTemplate->getLocation(), ClassTemplate, CTAI.CanonicalConverted, CTAI.StrictPackMatch, nullptr); - ClassTemplate->AddSpecialization(Decl, InsertPos); + ClassTemplate->AddSpecialization(Decl, Token); if (ClassTemplate->isOutOfLine()) Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext()); } @@ -4465,15 +4465,14 @@ DeclResult Sema::ActOnVarTemplateSpecialization( } } - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; VarTemplateSpecializationDecl *PrevDecl = nullptr; if (IsPartialSpecialization) - PrevDecl = VarTemplate->findPartialSpecialization( - CTAI.CanonicalConverted, TemplateParams, InsertPos); + PrevDecl = VarTemplate->findPartialSpecialization(CTAI.CanonicalConverted, + TemplateParams, Token); else - PrevDecl = - VarTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + PrevDecl = VarTemplate->findSpecialization(CTAI.CanonicalConverted, Token); VarTemplateSpecializationDecl *Specialization = nullptr; @@ -4504,7 +4503,7 @@ DeclResult Sema::ActOnVarTemplateSpecialization( Partial->setTemplateArgsAsWritten(TemplateArgs); if (!PrevPartial) - VarTemplate->AddPartialSpecialization(Partial, InsertPos); + VarTemplate->AddPartialSpecialization(Partial, Token); Specialization = Partial; CheckTemplatePartialSpecialization(Partial); @@ -4517,7 +4516,7 @@ DeclResult Sema::ActOnVarTemplateSpecialization( Specialization->setTemplateArgsAsWritten(TemplateArgs); if (!PrevDecl) - VarTemplate->AddSpecialization(Specialization, InsertPos); + VarTemplate->AddSpecialization(Specialization, Token); } // C++ [temp.expl.spec]p6: @@ -4658,9 +4657,9 @@ Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, // Find the variable template specialization declaration that // corresponds to these arguments. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; if (VarTemplateSpecializationDecl *Spec = - Template->findSpecialization(CTAI.CanonicalConverted, InsertPos)) { + Template->findSpecialization(CTAI.CanonicalConverted, Token)) { checkSpecializationReachability(TemplateNameLoc, Spec); if (Spec->getType()->isUndeducedType()) { if (ParsingInitForAutoVars.count(Spec)) @@ -8952,15 +8951,15 @@ DeclResult Sema::ActOnClassTemplateSpecialization( } } - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *PrevDecl = nullptr; if (isPartialSpecialization) - PrevDecl = ClassTemplate->findPartialSpecialization( - CTAI.CanonicalConverted, TemplateParams, InsertPos); + PrevDecl = ClassTemplate->findPartialSpecialization(CTAI.CanonicalConverted, + TemplateParams, Token); else PrevDecl = - ClassTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + ClassTemplate->findSpecialization(CTAI.CanonicalConverted, Token); ClassTemplateSpecializationDecl *Specialization = nullptr; @@ -8986,7 +8985,7 @@ DeclResult Sema::ActOnClassTemplateSpecialization( } if (!PrevDecl) - ClassTemplate->AddSpecialization(Specialization, InsertPos); + ClassTemplate->AddSpecialization(Specialization, Token); } else { CanQualType CanonType = CanQualType::CreateUnsafe( Context.getCanonicalTemplateSpecializationType( @@ -9031,7 +9030,7 @@ DeclResult Sema::ActOnClassTemplateSpecialization( } if (!PrevPartial) - ClassTemplate->AddPartialSpecialization(Partial, InsertPos); + ClassTemplate->AddPartialSpecialization(Partial, Token); Specialization = Partial; // If we are providing an explicit specialization of a member class @@ -9858,7 +9857,7 @@ bool Sema::CheckFunctionTemplateSpecialization( TemplateArgumentList *TemplArgs = TemplateArgumentList::CreateCopy( Context, Specialization->getTemplateSpecializationArgs()->asArray()); FD->setFunctionTemplateSpecialization( - Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr, + Specialization->getPrimaryTemplate(), TemplArgs, /*Token=*/{}, SpecInfo->getTemplateSpecializationKind(), ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr); @@ -10356,9 +10355,9 @@ DeclResult Sema::ActOnExplicitInstantiation( // Find the class template specialization declaration that // corresponds to these arguments. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *PrevDecl = - ClassTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + ClassTemplate->findSpecialization(CTAI.CanonicalConverted, Token); TemplateSpecializationKind PrevDecl_TSK = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared; @@ -10449,7 +10448,7 @@ DeclResult Sema::ActOnExplicitInstantiation( if (!HasNoEffect && !PrevDecl) { // Insert the new specialization. - ClassTemplate->AddSpecialization(Specialization, InsertPos); + ClassTemplate->AddSpecialization(Specialization, Token); } } diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index ff29ae27a3b66..2dfdc852c82a6 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -2977,9 +2977,9 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl( if (FunctionTemplate && !TemplateParams) { ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); - void *InsertPos = nullptr; - FunctionDecl *SpecFunc - = FunctionTemplate->findSpecialization(Innermost, InsertPos); + llvm::FoldingSetInsertToken Token; + FunctionDecl *SpecFunc = + FunctionTemplate->findSpecialization(Innermost, Token); // If we already have a function template specialization, return it. if (SpecFunc) @@ -3147,10 +3147,10 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl( Sema::CodeSynthesisContext::BuildingDeductionGuides) { // Record this function template specialization. ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); - Function->setFunctionTemplateSpecialization(FunctionTemplate, - TemplateArgumentList::CreateCopy(SemaRef.Context, - Innermost), - /*InsertPos=*/nullptr); + Function->setFunctionTemplateSpecialization( + FunctionTemplate, + TemplateArgumentList::CreateCopy(SemaRef.Context, Innermost), + /*Token=*/{}); } else if (FunctionRewriteKind == RewriteKind::None) { if (isFriend && D->isThisDeclarationADefinition()) { // Do not connect the friend to the template unless it's actually a @@ -3351,9 +3351,9 @@ Decl *TemplateDeclInstantiator::VisitCXXMethodDecl( // specialization for this particular set of template arguments. ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); - void *InsertPos = nullptr; - FunctionDecl *SpecFunc - = FunctionTemplate->findSpecialization(Innermost, InsertPos); + llvm::FoldingSetInsertToken Token; + FunctionDecl *SpecFunc = + FunctionTemplate->findSpecialization(Innermost, Token); // If we already have a function template specialization, return it. if (SpecFunc) @@ -3557,10 +3557,10 @@ Decl *TemplateDeclInstantiator::VisitCXXMethodDecl( } else if (FunctionTemplate) { // Record this function template specialization. ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); - Method->setFunctionTemplateSpecialization(FunctionTemplate, - TemplateArgumentList::CreateCopy(SemaRef.Context, - Innermost), - /*InsertPos=*/nullptr); + Method->setFunctionTemplateSpecialization( + FunctionTemplate, + TemplateArgumentList::CreateCopy(SemaRef.Context, Innermost), + /*Token=*/{}); } else if (!isFriend && FunctionRewriteKind == RewriteKind::None) { // Record that this is an instantiation of a member function. Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); @@ -4797,9 +4797,9 @@ TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl( // Figure out where to insert this class template explicit specialization // in the member template's set of class template explicit specializations. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *PrevDecl = - InstClassTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + InstClassTemplate->findSpecialization(CTAI.CanonicalConverted, Token); // Check whether we've already seen a conflicting instantiation of this // declaration (for instance, if there was a prior implicit instantiation). @@ -4844,7 +4844,7 @@ TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl( // Add this partial specialization to the set of class template partial // specializations. if (!PrevDecl) - InstClassTemplate->AddSpecialization(InstD, InsertPos); + InstClassTemplate->AddSpecialization(InstD, Token); // Substitute the nested name specifier, if any. if (SubstQualifier(D, InstD)) @@ -4905,9 +4905,9 @@ Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl( return nullptr; // Check whether we've already seen a declaration of this specialization. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; VarTemplateSpecializationDecl *PrevDecl = - InstVarTemplate->findSpecialization(CTAI.CanonicalConverted, InsertPos); + InstVarTemplate->findSpecialization(CTAI.CanonicalConverted, Token); // Check whether we've already seen a conflicting instantiation of this // declaration (for instance, if there was a prior implicit instantiation). @@ -4950,9 +4950,9 @@ TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl( SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(), VarTemplate, TSI->getType(), TSI, D->getStorageClass(), Converted); if (!PrevDecl) { - void *InsertPos = nullptr; - VarTemplate->findSpecialization(Converted, InsertPos); - VarTemplate->AddSpecialization(Var, InsertPos); + llvm::FoldingSetInsertToken Token; + VarTemplate->findSpecialization(Converted, Token); + VarTemplate->AddSpecialization(Var, Token); } if (SemaRef.getLangOpts().OpenCL) @@ -5249,10 +5249,10 @@ TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( // Figure out where to insert this class template partial specialization // in the member template's set of class template partial specializations. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; ClassTemplateSpecializationDecl *PrevDecl = ClassTemplate->findPartialSpecialization(CTAI.CanonicalConverted, - InstParams, InsertPos); + InstParams, Token); // Create the class template partial specialization declaration. ClassTemplatePartialSpecializationDecl *InstPartialSpec = @@ -5301,7 +5301,7 @@ TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( // Add this partial specialization to the set of class template partial // specializations. ClassTemplate->AddPartialSpecialization(InstPartialSpec, - /*InsertPos=*/nullptr); + /*Token=*/{}); return InstPartialSpec; } @@ -5358,10 +5358,10 @@ TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization( // Figure out where to insert this variable template partial specialization // in the member template's set of variable template partial specializations. - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; VarTemplateSpecializationDecl *PrevDecl = VarTemplate->findPartialSpecialization(CTAI.CanonicalConverted, - InstParams, InsertPos); + InstParams, Token); // Do substitution on the type of the declaration TypeSourceInfo *TSI = SemaRef.SubstType( @@ -5420,7 +5420,7 @@ TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization( // Add this partial specialization to the set of variable template partial // specializations. The instantiation of the initializer is not necessary. - VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr); + VarTemplate->AddPartialSpecialization(InstPartialSpec, /*Token=*/{}); SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs, LateAttrs, Owner, StartingScope); diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp index 74e0106520011..7e06269a8d8aa 100644 --- a/clang/lib/Serialization/ASTReaderDecl.cpp +++ b/clang/lib/Serialization/ASTReaderDecl.cpp @@ -983,19 +983,19 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) { // The template that contains the specializations set. It's not safe to // use getCanonicalDecl on Template since it may still be initializing. auto *CanonTemplate = readDeclAs<FunctionTemplateDecl>(); - // Get the InsertPos by FindNodeOrInsertPos() instead of calling - // InsertNode(FTInfo) directly to avoid the getASTContext() call in + // Get the insert token by lookup() instead of calling insert(FTInfo) + // directly to avoid the getASTContext() call in // FunctionTemplateSpecializationInfo's Profile(). // We avoid getASTContext because a decl in the parent hierarchy may // be initializing. llvm::FoldingSetNodeID ID; FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C); - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr(); FunctionTemplateSpecializationInfo *ExistingInfo = - CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos); - if (InsertPos) - CommonPtr->Specializations.InsertNode(FTInfo, InsertPos); + CommonPtr->Specializations.lookup(ID, Token); + if (Token) + CommonPtr->Specializations.insert(FTInfo, Token); else { Existing = ExistingInfo->getFunction(); } @@ -1573,7 +1573,7 @@ void ASTDeclReader::VisitMSGuidDecl(MSGuidDecl *D) { C = Record.readInt(); // Add this GUID to the AST context's lookup structure, and merge if needed. - if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.GetOrInsertNode(D)) + if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.getOrInsert(D)) Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl()); } @@ -1584,7 +1584,7 @@ void ASTDeclReader::VisitUnnamedGlobalConstantDecl( // Add this to the AST context's lookup structure, and merge if needed. if (UnnamedGlobalConstantDecl *Existing = - Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D)) + Reader.getContext().UnnamedGlobalConstantDecls.getOrInsert(D)) Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl()); } @@ -1595,7 +1595,7 @@ void ASTDeclReader::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) { // Add this template parameter object to the AST context's lookup structure, // and merge if needed. if (TemplateParamObjectDecl *Existing = - Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D)) + Reader.getContext().TemplateParamObjectDecls.getOrInsert(D)) Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl()); } @@ -2598,11 +2598,12 @@ RedeclarableResult ASTDeclReader::VisitClassTemplateSpecializationDeclImpl( // Set this as, or find, the canonical declaration for this specialization ClassTemplateSpecializationDecl *CanonSpec; if (auto *Partial = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) { - CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations - .GetOrInsertNode(Partial); + CanonSpec = + CanonPattern->getCommonPtr()->PartialSpecializations.getOrInsert( + Partial); } else { CanonSpec = - CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D); + CanonPattern->getCommonPtr()->Specializations.getOrInsert(D); } // If there was already a canonical specialization, merge into it. if (CanonSpec != D) { @@ -2713,11 +2714,12 @@ RedeclarableResult ASTDeclReader::VisitVarTemplateSpecializationDeclImpl( if (D->isCanonicalDecl()) { // It's kept in the folding set. VarTemplateSpecializationDecl *CanonSpec; if (auto *Partial = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) { - CanonSpec = CanonPattern->getCommonPtr() - ->PartialSpecializations.GetOrInsertNode(Partial); + CanonSpec = + CanonPattern->getCommonPtr()->PartialSpecializations.getOrInsert( + Partial); } else { CanonSpec = - CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D); + CanonPattern->getCommonPtr()->Specializations.getOrInsert(D); } // If we already have a matching specialization, merge it. if (CanonSpec != D) diff --git a/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp b/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp index b86f0e8309dc7..9c18d59042368 100644 --- a/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp +++ b/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp @@ -89,16 +89,16 @@ BasicValueFactory::~BasicValueFactory() { APSIntPtr BasicValueFactory::getValue(const llvm::APSInt &X) { llvm::FoldingSetNodeID ID; - void *InsertPos; + llvm::FoldingSetInsertToken Token; using FoldNodeTy = llvm::FoldingSetNodeWrapper<llvm::APSInt>; X.Profile(ID); - FoldNodeTy* P = APSIntSet.FindNodeOrInsertPos(ID, InsertPos); + FoldNodeTy *P = APSIntSet.lookup(ID, Token); if (!P) { P = new (BPAlloc) FoldNodeTy(X); - APSIntSet.InsertNode(P, InsertPos); + APSIntSet.insert(P, Token); } // We own the APSInt object. It's safe here. @@ -126,13 +126,13 @@ BasicValueFactory::getCompoundValData(QualType T, llvm::ImmutableList<SVal> Vals) { llvm::FoldingSetNodeID ID; CompoundValData::Profile(ID, T, Vals); - void *InsertPos; + llvm::FoldingSetInsertToken Token; - CompoundValData* D = CompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos); + CompoundValData *D = CompoundValDataSet.lookup(ID, Token); if (!D) { D = new (BPAlloc) CompoundValData(T, Vals); - CompoundValDataSet.InsertNode(D, InsertPos); + CompoundValDataSet.insert(D, Token); } return D; @@ -143,14 +143,13 @@ BasicValueFactory::getLazyCompoundValData(const StoreRef &store, const TypedValueRegion *region) { llvm::FoldingSetNodeID ID; LazyCompoundValData::Profile(ID, store, region); - void *InsertPos; + llvm::FoldingSetInsertToken Token; - LazyCompoundValData *D = - LazyCompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos); + LazyCompoundValData *D = LazyCompoundValDataSet.lookup(ID, Token); if (!D) { D = new (BPAlloc) LazyCompoundValData(store, region); - LazyCompoundValDataSet.InsertNode(D, InsertPos); + LazyCompoundValDataSet.insert(D, Token); } return D; @@ -160,14 +159,13 @@ const PointerToMemberData *BasicValueFactory::getPointerToMemberData( const NamedDecl *ND, llvm::ImmutableList<const CXXBaseSpecifier *> L) { llvm::FoldingSetNodeID ID; PointerToMemberData::Profile(ID, ND, L); - void *InsertPos; + llvm::FoldingSetInsertToken Token; - PointerToMemberData *D = - PointerToMemberDataSet.FindNodeOrInsertPos(ID, InsertPos); + PointerToMemberData *D = PointerToMemberDataSet.lookup(ID, Token); if (!D) { D = new (BPAlloc) PointerToMemberData(ND, L); - PointerToMemberDataSet.InsertNode(D, InsertPos); + PointerToMemberDataSet.insert(D, Token); } return D; @@ -351,7 +349,7 @@ BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) { if (!PersistentSVals) PersistentSVals = new PersistentSValsTy(); llvm::FoldingSetNodeID ID; - void *InsertPos; + llvm::FoldingSetInsertToken Token; V.Profile(ID); ID.AddPointer((void*) Data); @@ -359,11 +357,11 @@ BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) { using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValData>; - FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos); + FoldNodeTy *P = Map.lookup(ID, Token); if (!P) { P = new (BPAlloc) FoldNodeTy(std::make_pair(V, Data)); - Map.InsertNode(P, InsertPos); + Map.insert(P, Token); } return P->getValue(); @@ -375,7 +373,7 @@ BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) { if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy(); llvm::FoldingSetNodeID ID; - void *InsertPos; + llvm::FoldingSetInsertToken Token; V1.Profile(ID); V2.Profile(ID); @@ -383,11 +381,11 @@ BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) { using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValPair>; - FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos); + FoldNodeTy *P = Map.lookup(ID, Token); if (!P) { P = new (BPAlloc) FoldNodeTy(std::make_pair(V1, V2)); - Map.InsertNode(P, InsertPos); + Map.insert(P, Token); } return P->getValue(); diff --git a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp index ad36d1c55a64a..9ba2d3fa1a7cb 100644 --- a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp +++ b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp @@ -2188,8 +2188,8 @@ void PathSensitiveBugReport::addVisitor( llvm::FoldingSetNodeID ID; visitor->Profile(ID); - void *InsertPos = nullptr; - if (CallbacksSet.FindNodeOrInsertPos(ID, InsertPos)) { + llvm::FoldingSetInsertToken Token; + if (CallbacksSet.lookup(ID, Token)) { return; } @@ -2985,12 +2985,12 @@ void BugReporter::emitReport(std::unique_ptr<BugReport> R) { R->Profile(ID); // Lookup the equivance class. If there isn't one, create it. - void *InsertPos; - BugReportEquivClass* EQ = EQClasses.FindNodeOrInsertPos(ID, InsertPos); + llvm::FoldingSetInsertToken Token; + BugReportEquivClass *EQ = EQClasses.lookup(ID, Token); if (!EQ) { EQ = new BugReportEquivClass(std::move(R)); - EQClasses.InsertNode(EQ, InsertPos); + EQClasses.insert(EQ, Token); EQClassesVector.push_back(EQ); } else EQ->AddReport(std::move(R)); diff --git a/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp b/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp index 454eff97511b1..619d1c769db2e 100644 --- a/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp +++ b/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp @@ -158,7 +158,7 @@ void ExplodedGraph::collectNode(ExplodedNode *node) { pred->replaceSuccessor(succ); succ->replacePredecessor(pred); FreeNodes.push_back(node); - Nodes.RemoveNode(node); + Nodes.erase(node); --NumNodes; node->~ExplodedNode(); } @@ -393,10 +393,10 @@ ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L, bool* IsNew) { // Profile 'State' to determine if we already have an existing node. llvm::FoldingSetNodeID profile; - void *InsertPos = nullptr; + llvm::FoldingSetInsertToken Token; NodeTy::Profile(profile, L, State, IsSink); - NodeTy* V = Nodes.FindNodeOrInsertPos(profile, InsertPos); + NodeTy *V = Nodes.lookup(profile, Token); if (!V) { if (!FreeNodes.empty()) { @@ -415,7 +415,7 @@ ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L, ChangedNodes.push_back(V); // Insert the node into the node set and return it. - Nodes.InsertNode(V, InsertPos); + Nodes.insert(V, Token); if (IsNew) *IsNew = true; } diff --git a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp index 086e8900a717a..4dc9195e9b778 100644 --- a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp +++ b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp @@ -76,12 +76,12 @@ RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const SuperTy *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, arg1, superRegion); - void *InsertPos; - auto *R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, InsertPos)); + llvm::FoldingSetInsertToken Token; + auto *R = cast_or_null<RegionTy>(Regions.lookup(ID, Token)); if (!R) { R = new (A) RegionTy(arg1, superRegion); - Regions.InsertNode(R, InsertPos); + Regions.insert(R, Token); assert(!isAReferenceTypedValueRegion(superRegion)); } @@ -93,12 +93,12 @@ RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2, const SuperTy *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, arg1, arg2, superRegion); - void *InsertPos; - auto *R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, InsertPos)); + llvm::FoldingSetInsertToken Token; + auto *R = cast_or_null<RegionTy>(Regions.lookup(ID, Token)); if (!R) { R = new (A) RegionTy(arg1, arg2, superRegion); - Regions.InsertNode(R, InsertPos); + Regions.insert(R, Token); assert(!isAReferenceTypedValueRegion(superRegion)); } @@ -112,12 +112,12 @@ RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2, const SuperTy *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, arg1, arg2, arg3, superRegion); - void *InsertPos; - auto *R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, InsertPos)); + llvm::FoldingSetInsertToken Token; + auto *R = cast_or_null<RegionTy>(Regions.lookup(ID, Token)); if (!R) { R = new (A) RegionTy(arg1, arg2, arg3, superRegion); - Regions.InsertNode(R, InsertPos); + Regions.insert(R, Token); assert(!isAReferenceTypedValueRegion(superRegion)); } @@ -1260,13 +1260,13 @@ MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx, llvm::FoldingSetNodeID ID; ElementRegion::ProfileRegion(ID, T, Idx, superRegion); - void *InsertPos; - MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos); + llvm::FoldingSetInsertToken Token; + MemRegion *data = Regions.lookup(ID, Token); auto *R = cast_or_null<ElementRegion>(data); if (!R) { R = new (A) ElementRegion(T, Idx, superRegion); - Regions.InsertNode(R, InsertPos); + Regions.insert(R, Token); } return R; diff --git a/clang/lib/StaticAnalyzer/Core/ProgramState.cpp b/clang/lib/StaticAnalyzer/Core/ProgramState.cpp index da0d00daa3685..9b9c054c038ad 100644 --- a/clang/lib/StaticAnalyzer/Core/ProgramState.cpp +++ b/clang/lib/StaticAnalyzer/Core/ProgramState.cpp @@ -36,7 +36,7 @@ void ProgramStateRelease(const ProgramState *state) { ProgramState *s = const_cast<ProgramState*>(state); if (--s->refCount == 0) { ProgramStateManager &Mgr = s->getStateManager(); - Mgr.StateSet.RemoveNode(s); + Mgr.StateSet.erase(s); s->~ProgramState(); Mgr.freeStates.push_back(s); } @@ -403,9 +403,9 @@ ProgramStateRef ProgramStateManager::getPersistentState(ProgramState &State) { llvm::FoldingSetNodeID ID; State.Profile(ID); - void *InsertPos; + llvm::FoldingSetInsertToken Token; - if (ProgramState *I = StateSet.FindNodeOrInsertPos(ID, InsertPos)) + if (ProgramState *I = StateSet.lookup(ID, Token)) return I; ProgramState *newState = nullptr; @@ -417,7 +417,7 @@ ProgramStateRef ProgramStateManager::getPersistentState(ProgramState &State) { newState = Alloc.Allocate<ProgramState>(); } new (newState) ProgramState(State); - StateSet.InsertNode(newState, InsertPos); + StateSet.insert(newState, Token); return newState; } diff --git a/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp b/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp index 5c09163b36be9..8c8c7dcfcf1c1 100644 --- a/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp +++ b/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp @@ -323,17 +323,17 @@ RangeSet RangeSet::Factory::getRangeSet(Range From) { RangeSet RangeSet::Factory::makePersistent(ContainerType &&From) { llvm::FoldingSetNodeID ID; - void *InsertPos; + llvm::FoldingSetInsertToken Token; From.Profile(ID); - ContainerType *Result = Cache.FindNodeOrInsertPos(ID, InsertPos); + ContainerType *Result = Cache.lookup(ID, Token); if (!Result) { // It is cheaper to fully construct the resulting range on stack // and move it to the freshly allocated buffer if we don't have // a set like this already. Result = construct(std::move(From)); - Cache.InsertNode(Result, InsertPos); + Cache.insert(Result, Token); } return Result; diff --git a/clang/unittests/AST/ExternalASTSourceTest.cpp b/clang/unittests/AST/ExternalASTSourceTest.cpp index 19bc143ddb3d3..f7ddebb7614d2 100644 --- a/clang/unittests/AST/ExternalASTSourceTest.cpp +++ b/clang/unittests/AST/ExternalASTSourceTest.cpp @@ -151,7 +151,7 @@ struct LazyTemplatePatterns : TestExternalASTSource { ASTTemplateArgumentListInfo::Create(Ctx, ArgsInfo)); TU->addDecl(Partial); - Template->AddPartialSpecialization(Partial, nullptr); + Template->AddPartialSpecialization(Partial, {}); } void CompleteType(TagDecl *Tag) override { _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
