Merge branch 'llvm:main' into gh-101657

Author: ravindra-shinde2

bolt/lib/Core/BinaryBasicBlock.cpp

@@ -372,8 +372,7 @@ void BinaryBasicBlock::updateJumpTableSuccessors() {
              [](const BinaryBasicBlock *BB1, const BinaryBasicBlock *BB2) {
                return BB1->getInputOffset() < BB2->getInputOffset();
              });
-  SuccessorBBs.erase(std::unique(SuccessorBBs.begin(), SuccessorBBs.end()),
-                     SuccessorBBs.end());
+  SuccessorBBs.erase(llvm::unique(SuccessorBBs), SuccessorBBs.end());
 
   for (BinaryBasicBlock *BB : SuccessorBBs)
     addSuccessor(BB);

bolt/lib/Core/BinaryFunction.cpp

@@ -2376,7 +2376,7 @@ Error BinaryFunction::buildCFG(MCPlusBuilder::AllocatorIdTy AllocatorId) {
   // Without doing jump table value profiling we don't have a use for extra
   // (duplicate) branches.
   llvm::sort(TakenBranches);
-  auto NewEnd = std::unique(TakenBranches.begin(), TakenBranches.end());
+  auto NewEnd = llvm::unique(TakenBranches);
   TakenBranches.erase(NewEnd, TakenBranches.end());
 
   for (std::pair<uint32_t, uint32_t> &Branch : TakenBranches) {

bolt/lib/Core/DebugNames.cpp

@@ -440,8 +440,7 @@ void DWARF5AcceleratorTable::computeBucketCount() {
   for (const auto &E : Entries)
     Uniques.push_back(E.second.HashValue);
   array_pod_sort(Uniques.begin(), Uniques.end());
-  std::vector<uint32_t>::iterator P =
-      std::unique(Uniques.begin(), Uniques.end());
+  std::vector<uint32_t>::iterator P = llvm::unique(Uniques);
 
   UniqueHashCount = std::distance(Uniques.begin(), P);
 

bolt/lib/Profile/YAMLProfileWriter.cpp

@@ -133,12 +133,9 @@ std::vector<yaml::bolt::PseudoProbeInfo>
 YAMLProfileWriter::convertNodeProbes(NodeIdToProbes &NodeProbes) {
   struct BlockProbeInfoHasher {
     size_t operator()(const yaml::bolt::PseudoProbeInfo &BPI) const {
-      auto HashCombine = [](auto &Range) {
-        return llvm::hash_combine_range(Range.begin(), Range.end());
-      };
-      return llvm::hash_combine(HashCombine(BPI.BlockProbes),
-                                HashCombine(BPI.CallProbes),
-                                HashCombine(BPI.IndCallProbes));
+      return llvm::hash_combine(llvm::hash_combine_range(BPI.BlockProbes),
+                                llvm::hash_combine_range(BPI.CallProbes),
+                                llvm::hash_combine_range(BPI.IndCallProbes));
     }
   };
 

clang-tools-extra/clang-doc/Representation.cpp

@@ -200,7 +200,7 @@ void Info::mergeBase(Info &&Other) {
   std::move(Other.Description.begin(), Other.Description.end(),
             std::back_inserter(Description));
   llvm::sort(Description);
-  auto Last = std::unique(Description.begin(), Description.end());
+  auto Last = llvm::unique(Description);
   Description.erase(Last, Description.end());
 }
 
@@ -215,7 +215,7 @@ void SymbolInfo::merge(SymbolInfo &&Other) {
   // Unconditionally extend the list of locations, since we want all of them.
   std::move(Other.Loc.begin(), Other.Loc.end(), std::back_inserter(Loc));
   llvm::sort(Loc);
-  auto *Last = std::unique(Loc.begin(), Loc.end());
+  auto *Last = llvm::unique(Loc);
   Loc.erase(Last, Loc.end());
   mergeBase(std::move(Other));
 }

clang-tools-extra/clang-include-fixer/IncludeFixerContext.cpp

@@ -90,10 +90,10 @@ IncludeFixerContext::IncludeFixerContext(
                       std::make_pair(B.Range.getOffset(), B.Range.getLength());
              });
   QuerySymbolInfos.erase(
-      std::unique(QuerySymbolInfos.begin(), QuerySymbolInfos.end(),
-                  [](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {
-                    return A.Range == B.Range;
-                  }),
+      llvm::unique(QuerySymbolInfos,
+                   [](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {
+                     return A.Range == B.Range;
+                   }),
       QuerySymbolInfos.end());
   for (const auto &Symbol : MatchedSymbols) {
     HeaderInfos.push_back(
@@ -103,11 +103,11 @@ IncludeFixerContext::IncludeFixerContext(
              QuerySymbolInfos.front().ScopedQualifiers, Symbol)});
   }
   // Deduplicate header infos.
-  HeaderInfos.erase(std::unique(HeaderInfos.begin(), HeaderInfos.end(),
-                                [](const HeaderInfo &A, const HeaderInfo &B) {
-                                  return A.Header == B.Header &&
-                                         A.QualifiedName == B.QualifiedName;
-                                }),
+  HeaderInfos.erase(llvm::unique(HeaderInfos,
+                                 [](const HeaderInfo &A, const HeaderInfo &B) {
+                                   return A.Header == B.Header &&
+                                          A.QualifiedName == B.QualifiedName;
+                                 }),
                     HeaderInfos.end());
 }
 

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

@@ -754,8 +754,7 @@ std::vector<ClangTidyError> ClangTidyDiagnosticConsumer::take() {
   finalizeLastError();
 
   llvm::stable_sort(Errors, LessClangTidyError());
-  Errors.erase(std::unique(Errors.begin(), Errors.end(), EqualClangTidyError()),
-               Errors.end());
+  Errors.erase(llvm::unique(Errors, EqualClangTidyError()), Errors.end());
   if (RemoveIncompatibleErrors)
     removeIncompatibleErrors();
   return std::move(Errors);

clang-tools-extra/clang-tidy/abseil/CleanupCtadCheck.cpp

@@ -21,9 +21,9 @@ using namespace ::clang::transformer;
 
 namespace clang::tidy::abseil {
 
-RewriteRuleWith<std::string> CleanupCtadCheckImpl() {
-  auto warning_message = cat("prefer absl::Cleanup's class template argument "
-                             "deduction pattern in C++17 and higher");
+RewriteRuleWith<std::string> cleanupCtadCheckImpl() {
+  auto WarningMessage = cat("prefer absl::Cleanup's class template argument "
+                            "deduction pattern in C++17 and higher");
 
   return makeRule(
       declStmt(hasSingleDecl(varDecl(
@@ -34,10 +34,10 @@ RewriteRuleWith<std::string> CleanupCtadCheckImpl() {
                   .bind("make_cleanup_call")))))),
       {changeTo(node("auto_type_loc"), cat("absl::Cleanup")),
        changeTo(node("make_cleanup_call"), cat(callArgs("make_cleanup_call")))},
-      warning_message);
+      WarningMessage);
 }
 
 CleanupCtadCheck::CleanupCtadCheck(StringRef Name, ClangTidyContext *Context)
-    : utils::TransformerClangTidyCheck(CleanupCtadCheckImpl(), Name, Context) {}
+    : utils::TransformerClangTidyCheck(cleanupCtadCheckImpl(), Name, Context) {}
 
 } // namespace clang::tidy::abseil

clang-tools-extra/clang-tidy/bugprone/BranchCloneCheck.cpp

@@ -250,10 +250,10 @@ static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
 
     if (!llvm::all_of(llvm::zip(CompStmt1->body(), CompStmt2->body()),
                       [&Ctx, IgnoreSideEffects](
-                          std::tuple<const Stmt *, const Stmt *> stmtPair) {
-                        const Stmt *stmt0 = std::get<0>(stmtPair);
-                        const Stmt *stmt1 = std::get<1>(stmtPair);
-                        return isIdenticalStmt(Ctx, stmt0, stmt1,
+                          std::tuple<const Stmt *, const Stmt *> StmtPair) {
+                        const Stmt *Stmt0 = std::get<0>(StmtPair);
+                        const Stmt *Stmt1 = std::get<1>(StmtPair);
+                        return isIdenticalStmt(Ctx, Stmt0, Stmt1,
                                                IgnoreSideEffects);
                       })) {
       return false;
@@ -477,7 +477,7 @@ void BranchCloneCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (const auto *IS = Result.Nodes.getNodeAs<IfStmt>("ifWithDescendantIf")) {
     const Stmt *Then = IS->getThen();
-    auto CS = dyn_cast<CompoundStmt>(Then);
+    const auto *CS = dyn_cast<CompoundStmt>(Then);
     if (CS && (!CS->body_empty())) {
       const auto *InnerIf = dyn_cast<IfStmt>(*CS->body_begin());
       if (InnerIf && isIdenticalStmt(Context, IS->getCond(), InnerIf->getCond(),

clang-tools-extra/clang-tidy/bugprone/SignalHandlerCheck.cpp

@@ -301,7 +301,7 @@ bool isCXXOnlyStmt(const Stmt *S) {
 /// It is unspecified which call is found if multiple calls exist, but the order
 /// should be deterministic (depend only on the AST).
 Expr *findCallExpr(const CallGraphNode *Caller, const CallGraphNode *Callee) {
-  auto FoundCallee = llvm::find_if(
+  const auto *FoundCallee = llvm::find_if(
       Caller->callees(), [Callee](const CallGraphNode::CallRecord &Call) {
         return Call.Callee == Callee;
       });