Index: include/clang/Basic/Attr.td =================================================================== --- include/clang/Basic/Attr.td +++ include/clang/Basic/Attr.td @@ -1875,7 +1875,7 @@ template ParsedTargetAttr parse(Compare cmp) const { ParsedTargetAttr Attrs = parse(); - std::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp); + llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp); return Attrs; } Index: include/clang/Serialization/ContinuousRangeMap.h =================================================================== --- include/clang/Serialization/ContinuousRangeMap.h +++ include/clang/Serialization/ContinuousRangeMap.h @@ -117,7 +117,7 @@ Builder &operator=(const Builder&) = delete; ~Builder() { - std::sort(Self.Rep.begin(), Self.Rep.end(), Compare()); + llvm::sort(Self.Rep.begin(), Self.Rep.end(), Compare()); std::unique(Self.Rep.begin(), Self.Rep.end(), [](const_reference A, const_reference B) { // FIXME: we should not allow any duplicate keys, but there are a lot of Index: lib/AST/ASTContext.cpp =================================================================== --- lib/AST/ASTContext.cpp +++ lib/AST/ASTContext.cpp @@ -2186,7 +2186,7 @@ } } - std::sort( + llvm::sort( Bases.begin(), Bases.end(), [&](const std::pair &L, const std::pair &R) { return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) < Index: lib/AST/ItaniumMangle.cpp =================================================================== --- lib/AST/ItaniumMangle.cpp +++ lib/AST/ItaniumMangle.cpp @@ -323,7 +323,7 @@ AdditionalAbiTags->end()); } - std::sort(TagList.begin(), TagList.end()); + llvm::sort(TagList.begin(), TagList.end()); TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end()); writeSortedUniqueAbiTags(Out, TagList); @@ -339,7 +339,7 @@ } const AbiTagList &getSortedUniqueUsedAbiTags() { - std::sort(UsedAbiTags.begin(), UsedAbiTags.end()); + llvm::sort(UsedAbiTags.begin(), UsedAbiTags.end()); UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()), UsedAbiTags.end()); return UsedAbiTags; Index: lib/AST/VTableBuilder.cpp =================================================================== --- lib/AST/VTableBuilder.cpp +++ lib/AST/VTableBuilder.cpp @@ -2105,8 +2105,8 @@ const CXXMethodDecl *MD = I.second; ThunkInfoVectorTy ThunksVector = Thunks[MD]; - std::sort(ThunksVector.begin(), ThunksVector.end(), - [](const ThunkInfo &LHS, const ThunkInfo &RHS) { + llvm::sort(ThunksVector.begin(), ThunksVector.end(), + [](const ThunkInfo &LHS, const ThunkInfo &RHS) { assert(LHS.Method == nullptr && RHS.Method == nullptr); return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return); }); @@ -2206,9 +2206,9 @@ else this->VTableIndices = OwningArrayRef(VTableIndices); - std::sort(this->VTableThunks.begin(), this->VTableThunks.end(), - [](const VTableLayout::VTableThunkTy &LHS, - const VTableLayout::VTableThunkTy &RHS) { + llvm::sort(this->VTableThunks.begin(), this->VTableThunks.end(), + [](const VTableLayout::VTableThunkTy &LHS, + const VTableLayout::VTableThunkTy &RHS) { assert((LHS.first != RHS.first || LHS.second == RHS.second) && "Different thunks should have unique indices!"); return LHS.first < RHS.first; @@ -3344,8 +3344,8 @@ PathsSorted.reserve(Paths.size()); for (auto& P : Paths) PathsSorted.push_back(*P); - std::sort(PathsSorted.begin(), PathsSorted.end(), - [](const VPtrInfo &LHS, const VPtrInfo &RHS) { + llvm::sort(PathsSorted.begin(), PathsSorted.end(), + [](const VPtrInfo &LHS, const VPtrInfo &RHS) { return LHS.MangledPath < RHS.MangledPath; }); bool Changed = false; Index: lib/ASTMatchers/Dynamic/Parser.cpp =================================================================== --- lib/ASTMatchers/Dynamic/Parser.cpp +++ lib/ASTMatchers/Dynamic/Parser.cpp @@ -619,8 +619,8 @@ P.parseExpressionImpl(&Dummy); // Sort by specificity, then by name. - std::sort(P.Completions.begin(), P.Completions.end(), - [](const MatcherCompletion &A, const MatcherCompletion &B) { + llvm::sort(P.Completions.begin(), P.Completions.end(), + [](const MatcherCompletion &A, const MatcherCompletion &B) { if (A.Specificity != B.Specificity) return A.Specificity > B.Specificity; return A.TypedText < B.TypedText; Index: lib/Analysis/LiveVariables.cpp =================================================================== --- lib/Analysis/LiveVariables.cpp +++ lib/Analysis/LiveVariables.cpp @@ -563,7 +563,7 @@ it != ei; ++it) { vec.push_back(it->first); } - std::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) { + llvm::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) { return A->getBlockID() < B->getBlockID(); }); @@ -583,7 +583,8 @@ declVec.push_back(*si); } - std::sort(declVec.begin(), declVec.end(), [](const Decl *A, const Decl *B) { + llvm::sort(declVec.begin(), declVec.end(), + [](const Decl *A, const Decl *B) { return A->getLocStart() < B->getLocStart(); }); Index: lib/Basic/VirtualFileSystem.cpp =================================================================== --- lib/Basic/VirtualFileSystem.cpp +++ lib/Basic/VirtualFileSystem.cpp @@ -1812,8 +1812,8 @@ } void YAMLVFSWriter::write(llvm::raw_ostream &OS) { - std::sort(Mappings.begin(), Mappings.end(), - [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) { + llvm::sort(Mappings.begin(), Mappings.end(), + [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) { return LHS.VPath < RHS.VPath; }); Index: lib/CodeGen/CGVTables.cpp =================================================================== --- lib/CodeGen/CGVTables.cpp +++ lib/CodeGen/CGVTables.cpp @@ -992,8 +992,8 @@ AP.second.AddressPointIndex)); // Sort the bit set entries for determinism. - std::sort(BitsetEntries.begin(), BitsetEntries.end(), - [this](const BSEntry &E1, const BSEntry &E2) { + llvm::sort(BitsetEntries.begin(), BitsetEntries.end(), + [this](const BSEntry &E1, const BSEntry &E2) { if (&E1 == &E2) return false; Index: lib/CodeGen/CodeGenModule.cpp =================================================================== --- lib/CodeGen/CodeGenModule.cpp +++ lib/CodeGen/CodeGenModule.cpp @@ -1302,7 +1302,7 @@ AddedAttr = true; } if (!Features.empty()) { - std::sort(Features.begin(), Features.end()); + llvm::sort(Features.begin(), Features.end()); Attrs.addAttribute("target-features", llvm::join(Features, ",")); AddedAttr = true; } Index: lib/CodeGen/TargetInfo.cpp =================================================================== --- lib/CodeGen/TargetInfo.cpp +++ lib/CodeGen/TargetInfo.cpp @@ -8520,7 +8520,7 @@ // The ABI requires unions to be sorted but not structures. // See FieldEncoding::operator< for sort algorithm. if (RT->isUnionType()) - std::sort(FE.begin(), FE.end()); + llvm::sort(FE.begin(), FE.end()); // We can now complete the TypeString. unsigned E = FE.size(); for (unsigned I = 0; I != E; ++I) { @@ -8564,7 +8564,7 @@ EnumEnc += '}'; FE.push_back(FieldEncoding(!I->getName().empty(), EnumEnc)); } - std::sort(FE.begin(), FE.end()); + llvm::sort(FE.begin(), FE.end()); unsigned E = FE.size(); for (unsigned I = 0; I != E; ++I) { if (I) Index: lib/Driver/Driver.cpp =================================================================== --- lib/Driver/Driver.cpp +++ lib/Driver/Driver.cpp @@ -1474,11 +1474,11 @@ // deterministic order. We could sort in any way, but we chose // case-insensitive sorting for consistency with the -help option // which prints out options in the case-insensitive alphabetical order. - std::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(), - [](StringRef A, StringRef B) { - if (int X = A.compare_lower(B)) - return X < 0; - return A.compare(B) > 0; + llvm::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(), + [](StringRef A, StringRef B) { + if (int X = A.compare_lower(B)) + return X < 0; + return A.compare(B) > 0; }); llvm::outs() << llvm::join(SuggestedCompletions, "\n") << '\n'; Index: lib/Format/FormatTokenLexer.cpp =================================================================== --- lib/Format/FormatTokenLexer.cpp +++ lib/Format/FormatTokenLexer.cpp @@ -38,7 +38,7 @@ for (const std::string &ForEachMacro : Style.ForEachMacros) ForEachMacros.push_back(&IdentTable.get(ForEachMacro)); - std::sort(ForEachMacros.begin(), ForEachMacros.end()); + llvm::sort(ForEachMacros.begin(), ForEachMacros.end()); } ArrayRef FormatTokenLexer::lex() { Index: lib/Format/WhitespaceManager.cpp =================================================================== --- lib/Format/WhitespaceManager.cpp +++ lib/Format/WhitespaceManager.cpp @@ -90,7 +90,7 @@ if (Changes.empty()) return Replaces; - std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); + llvm::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); calculateLineBreakInformation(); alignConsecutiveDeclarations(); alignConsecutiveAssignments(); Index: lib/Frontend/CompilerInvocation.cpp =================================================================== --- lib/Frontend/CompilerInvocation.cpp +++ lib/Frontend/CompilerInvocation.cpp @@ -1243,7 +1243,7 @@ Success = false; } else - std::sort(Opts.VerifyPrefixes.begin(), Opts.VerifyPrefixes.end()); + llvm::sort(Opts.VerifyPrefixes.begin(), Opts.VerifyPrefixes.end()); DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None; Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=", Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), @@ -2369,7 +2369,7 @@ Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ); Opts.AppExt = Args.hasArg(OPT_fapplication_extension); Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature); - std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end()); + llvm::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end()); Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type); Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns); // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns Index: lib/Frontend/DiagnosticRenderer.cpp =================================================================== --- lib/Frontend/DiagnosticRenderer.cpp +++ lib/Frontend/DiagnosticRenderer.cpp @@ -318,8 +318,8 @@ SmallVector EndArgExpansions; getMacroArgExpansionFileIDs(Begin, BeginArgExpansions, /*IsBegin=*/true, SM); getMacroArgExpansionFileIDs(End, EndArgExpansions, /*IsBegin=*/false, SM); - std::sort(BeginArgExpansions.begin(), BeginArgExpansions.end()); - std::sort(EndArgExpansions.begin(), EndArgExpansions.end()); + llvm::sort(BeginArgExpansions.begin(), BeginArgExpansions.end()); + llvm::sort(EndArgExpansions.begin(), EndArgExpansions.end()); std::set_intersection(BeginArgExpansions.begin(), BeginArgExpansions.end(), EndArgExpansions.begin(), EndArgExpansions.end(), std::back_inserter(CommonArgExpansions)); Index: lib/Sema/AnalysisBasedWarnings.cpp =================================================================== --- lib/Sema/AnalysisBasedWarnings.cpp +++ lib/Sema/AnalysisBasedWarnings.cpp @@ -1410,8 +1410,8 @@ // Sort by first use so that we emit the warnings in a deterministic order. SourceManager &SM = S.getSourceManager(); - std::sort(UsesByStmt.begin(), UsesByStmt.end(), - [&SM](const StmtUsesPair &LHS, const StmtUsesPair &RHS) { + llvm::sort(UsesByStmt.begin(), UsesByStmt.end(), + [&SM](const StmtUsesPair &LHS, const StmtUsesPair &RHS) { return SM.isBeforeInTranslationUnit(LHS.first->getLocStart(), RHS.first->getLocStart()); }); @@ -1549,8 +1549,8 @@ // Sort the uses by their SourceLocations. While not strictly // guaranteed to produce them in line/column order, this will provide // a stable ordering. - std::sort(vec->begin(), vec->end(), - [](const UninitUse &a, const UninitUse &b) { + llvm::sort(vec->begin(), vec->end(), + [](const UninitUse &a, const UninitUse &b) { // Prefer a more confident report over a less confident one. if (a.getKind() != b.getKind()) return a.getKind() > b.getKind(); Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -9374,7 +9374,7 @@ TargetAttr::ParsedTargetAttr NewParsed = NewTA->parse(); // Sort order doesn't matter, it just needs to be consistent. - std::sort(NewParsed.Features.begin(), NewParsed.Features.end()); + llvm::sort(NewParsed.Features.begin(), NewParsed.Features.end()); const auto *OldTA = OldFD->getAttr(); if (!OldFD->isMultiVersion()) { Index: lib/Sema/SemaDeclAttr.cpp =================================================================== --- lib/Sema/SemaDeclAttr.cpp +++ lib/Sema/SemaDeclAttr.cpp @@ -5080,7 +5080,7 @@ return; // Store tags sorted and without duplicates. - std::sort(Tags.begin(), Tags.end()); + llvm::sort(Tags.begin(), Tags.end()); Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end()); D->addAttr(::new (S.Context) Index: lib/Sema/SemaLookup.cpp =================================================================== --- lib/Sema/SemaLookup.cpp +++ lib/Sema/SemaLookup.cpp @@ -187,7 +187,7 @@ } void done() { - std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator()); + llvm::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator()); } typedef ListTy::const_iterator const_iterator; Index: lib/Sema/SemaOverload.cpp =================================================================== --- lib/Sema/SemaOverload.cpp +++ lib/Sema/SemaOverload.cpp @@ -10688,8 +10688,8 @@ // in general, want to list every possible builtin candidate. } - std::sort(Cands.begin(), Cands.end(), - CompareTemplateSpecCandidatesForDisplay(S)); + llvm::sort(Cands.begin(), Cands.end(), + CompareTemplateSpecCandidatesForDisplay(S)); // FIXME: Perhaps rename OverloadsShown and getShowOverloads() // for generalization purposes (?). Index: lib/Sema/SemaType.cpp =================================================================== --- lib/Sema/SemaType.cpp +++ lib/Sema/SemaType.cpp @@ -4860,8 +4860,8 @@ if (Chunk.Fun.TypeQuals & Qualifiers::Restrict) RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc()); if (!RemovalLocs.empty()) { - std::sort(RemovalLocs.begin(), RemovalLocs.end(), - BeforeThanCompare(S.getSourceManager())); + llvm::sort(RemovalLocs.begin(), RemovalLocs.end(), + BeforeThanCompare(S.getSourceManager())); RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back()); Loc = RemovalLocs.front(); } Index: lib/Serialization/ASTReader.cpp =================================================================== --- lib/Serialization/ASTReader.cpp +++ lib/Serialization/ASTReader.cpp @@ -396,8 +396,8 @@ ExistingTargetOpts.FeaturesAsWritten.end()); SmallVector ReadFeatures(TargetOpts.FeaturesAsWritten.begin(), TargetOpts.FeaturesAsWritten.end()); - std::sort(ExistingFeatures.begin(), ExistingFeatures.end()); - std::sort(ReadFeatures.begin(), ReadFeatures.end()); + llvm::sort(ExistingFeatures.begin(), ExistingFeatures.end()); + llvm::sort(ReadFeatures.begin(), ReadFeatures.end()); // We compute the set difference in both directions explicitly so that we can // diagnose the differences differently. @@ -9076,8 +9076,8 @@ NextCursor: // De-serialized SourceLocations get negative FileIDs for other modules, // potentially invalidating the original order. Sort it again. - std::sort(Comments.begin(), Comments.end(), - BeforeThanCompare(SourceMgr)); + llvm::sort(Comments.begin(), Comments.end(), + BeforeThanCompare(SourceMgr)); Context.Comments.addDeserializedComments(Comments); } } Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp +++ lib/Serialization/ASTReaderDecl.cpp @@ -232,7 +232,7 @@ if (auto &Old = LazySpecializations) { IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]); - std::sort(IDs.begin(), IDs.end()); + llvm::sort(IDs.begin(), IDs.end()); IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end()); } Index: lib/Serialization/ASTWriter.cpp =================================================================== --- lib/Serialization/ASTWriter.cpp +++ lib/Serialization/ASTWriter.cpp @@ -2481,8 +2481,8 @@ MacroIdentifiers.push_back(Id.second); // Sort the set of macro definitions that need to be serialized by the // name of the macro, to provide a stable ordering. - std::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), - llvm::less_ptr()); + llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), + llvm::less_ptr()); // Emit the macro directives as a list and associate the offset with the // identifier they belong to. @@ -3214,8 +3214,8 @@ SmallVector, 64> SortedFileDeclIDs( FileDeclIDs.begin(), FileDeclIDs.end()); - std::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), - llvm::less_first()); + llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), + llvm::less_first()); // Join the vectors of DeclIDs from all files. SmallVector FileGroupedDeclIDs; @@ -3719,7 +3719,7 @@ IIs.push_back(ID.second); // Sort the identifiers lexicographically before getting them references so // that their order is stable. - std::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); + llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); for (const IdentifierInfo *II : IIs) if (Trait.isInterestingNonMacroIdentifier(II)) getIdentifierRef(II); @@ -4017,7 +4017,7 @@ } // Sort the names into a stable order. - std::sort(Names.begin(), Names.end()); + llvm::sort(Names.begin(), Names.end()); if (auto *D = dyn_cast(DC)) { // We need to establish an ordering of constructor and conversion function @@ -4154,7 +4154,7 @@ std::make_pair(Entry.first, Entry.second.getLookupResult())); } - std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); + llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); for (auto &NameAndResult : LookupResults) { DeclarationName Name = NameAndResult.first; DeclContext::lookup_result Result = NameAndResult.second; @@ -4850,7 +4850,7 @@ IIs.push_back(II); } // Sort the identifiers to visit based on their name. - std::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); + llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); for (const IdentifierInfo *II : IIs) { for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), DEnd = SemaRef.IdResolver.end(); @@ -5087,7 +5087,7 @@ }; // Sort and deduplicate module IDs. - std::sort(Imports.begin(), Imports.end(), Cmp); + llvm::sort(Imports.begin(), Imports.end(), Cmp); Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq), Imports.end()); Index: lib/StaticAnalyzer/Checkers/PaddingChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/PaddingChecker.cpp +++ lib/StaticAnalyzer/Checkers/PaddingChecker.cpp @@ -237,7 +237,7 @@ }; std::transform(RD->field_begin(), RD->field_end(), std::back_inserter(Fields), GatherSizesAndAlignments); - std::sort(Fields.begin(), Fields.end()); + llvm::sort(Fields.begin(), Fields.end()); // This lets us skip over vptrs and non-virtual bases, // so that we can just worry about the fields in our object. // Note that this does cause us to miss some cases where we Index: lib/StaticAnalyzer/Core/BugReporter.cpp =================================================================== --- lib/StaticAnalyzer/Core/BugReporter.cpp +++ lib/StaticAnalyzer/Core/BugReporter.cpp @@ -2947,8 +2947,8 @@ } // Sort the error paths from longest to shortest. - std::sort(ReportNodes.begin(), ReportNodes.end(), - PriorityCompare(PriorityMap)); + llvm::sort(ReportNodes.begin(), ReportNodes.end(), + PriorityCompare(PriorityMap)); } bool TrimmedGraph::popNextReportGraph(ReportGraph &GraphWrapper) { Index: lib/StaticAnalyzer/Core/CheckerRegistry.cpp =================================================================== --- lib/StaticAnalyzer/Core/CheckerRegistry.cpp +++ lib/StaticAnalyzer/Core/CheckerRegistry.cpp @@ -97,7 +97,7 @@ void CheckerRegistry::initializeManager(CheckerManager &checkerMgr, SmallVectorImpl &opts) const { // Sort checkers for efficient collection. - std::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); // Collect checkers enabled by the options. CheckerInfoSet enabledCheckers; @@ -141,7 +141,7 @@ // FIXME: Alphabetical sort puts 'experimental' in the middle. // Would it be better to name it '~experimental' or something else // that's ASCIIbetically last? - std::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); // FIXME: Print available packages. @@ -178,7 +178,7 @@ void CheckerRegistry::printList( raw_ostream &out, SmallVectorImpl &opts) const { - std::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); // Collect checkers enabled by the options. CheckerInfoSet enabledCheckers; Index: lib/Tooling/ASTDiff/ASTDiff.cpp =================================================================== --- lib/Tooling/ASTDiff/ASTDiff.cpp +++ lib/Tooling/ASTDiff/ASTDiff.cpp @@ -741,7 +741,7 @@ List.pop(); } // TODO this is here to get a stable output, not a good heuristic - std::sort(Result.begin(), Result.end()); + llvm::sort(Result.begin(), Result.end()); return Result; } int peekMax() const { Index: lib/Tooling/Core/Replacement.cpp =================================================================== --- lib/Tooling/Core/Replacement.cpp +++ lib/Tooling/Core/Replacement.cpp @@ -463,11 +463,11 @@ // Returns a set of non-overlapping and sorted ranges that is equivalent to // \p Ranges. static std::vector combineAndSortRanges(std::vector Ranges) { - std::sort(Ranges.begin(), Ranges.end(), - [](const Range &LHS, const Range &RHS) { - if (LHS.getOffset() != RHS.getOffset()) - return LHS.getOffset() < RHS.getOffset(); - return LHS.getLength() < RHS.getLength(); + llvm::sort(Ranges.begin(), Ranges.end(), + [](const Range &LHS, const Range &RHS) { + if (LHS.getOffset() != RHS.getOffset()) + return LHS.getOffset() < RHS.getOffset(); + return LHS.getLength() < RHS.getLength(); }); std::vector Result; for (const auto &R : Ranges) { Index: tools/diagtool/DiagTool.cpp =================================================================== --- tools/diagtool/DiagTool.cpp +++ tools/diagtool/DiagTool.cpp @@ -48,7 +48,7 @@ if (len > maxName) maxName = len; } - std::sort(toolNames.begin(), toolNames.end()); + llvm::sort(toolNames.begin(), toolNames.end()); for (std::vector::iterator it = toolNames.begin(), ei = toolNames.end(); it != ei; ++it) { Index: tools/libclang/CIndex.cpp =================================================================== --- tools/libclang/CIndex.cpp +++ tools/libclang/CIndex.cpp @@ -1039,8 +1039,8 @@ } // Now sort the Decls so that they appear in lexical order. - std::sort(DeclsInContainer.begin(), DeclsInContainer.end(), - [&SM](Decl *A, Decl *B) { + llvm::sort(DeclsInContainer.begin(), DeclsInContainer.end(), + [&SM](Decl *A, Decl *B) { SourceLocation L_A = A->getLocStart(); SourceLocation L_B = B->getLocStart(); return L_A != L_B ? @@ -7573,10 +7573,10 @@ if (AvailabilityAttrs.empty()) return; - std::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(), - [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) { - return LHS->getPlatform()->getName() < - RHS->getPlatform()->getName(); + llvm::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(), + [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) { + return LHS->getPlatform()->getName() < + RHS->getPlatform()->getName(); }); ASTContext &Ctx = D->getASTContext(); auto It = std::unique( Index: unittests/Basic/VirtualFileSystemTest.cpp =================================================================== --- unittests/Basic/VirtualFileSystemTest.cpp +++ unittests/Basic/VirtualFileSystemTest.cpp @@ -471,7 +471,7 @@ } // Check sorted contents. - std::sort(Contents.begin(), Contents.end()); + llvm::sort(Contents.begin(), Contents.end()); EXPECT_EQ(Expected.size(), Contents.size()); EXPECT_TRUE(std::equal(Contents.begin(), Contents.end(), Expected.begin())); } @@ -488,8 +488,8 @@ for (DirIter E; !EC && I != E; I.increment(EC)) InputToCheck.push_back(I->getName()); - std::sort(InputToCheck.begin(), InputToCheck.end()); - std::sort(Expected.begin(), Expected.end()); + llvm::sort(InputToCheck.begin(), InputToCheck.end()); + llvm::sort(Expected.begin(), Expected.end()); EXPECT_EQ(InputToCheck.size(), Expected.size()); unsigned LastElt = std::min(InputToCheck.size(), Expected.size()); Index: utils/TableGen/ClangAttrEmitter.cpp =================================================================== --- utils/TableGen/ClangAttrEmitter.cpp +++ utils/TableGen/ClangAttrEmitter.cpp @@ -3877,9 +3877,9 @@ for (auto &I : SplitDocs) { WriteCategoryHeader(I.first, OS); - std::sort(I.second.begin(), I.second.end(), - [](const DocumentationData &D1, const DocumentationData &D2) { - return D1.Heading < D2.Heading; + llvm::sort(I.second.begin(), I.second.end(), + [](const DocumentationData &D1, const DocumentationData &D2) { + return D1.Heading < D2.Heading; }); // Walk over each of the attributes in the category and write out their Index: utils/TableGen/ClangDiagnosticsEmitter.cpp =================================================================== --- utils/TableGen/ClangDiagnosticsEmitter.cpp +++ utils/TableGen/ClangDiagnosticsEmitter.cpp @@ -207,9 +207,9 @@ E = SortedGroups.end(); I != E; ++I) { MutableArrayRef GroupDiags = (*I)->DiagsInGroup; - std::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare); + llvm::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare); } - std::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups); + llvm::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups); // Warn about the same group being used anonymously in multiple places. for (SmallVectorImpl::const_iterator I = SortedGroups.begin(), @@ -863,9 +863,10 @@ Index.push_back(RecordIndexElement(R)); } - std::sort(Index.begin(), Index.end(), - [](const RecordIndexElement &Lhs, - const RecordIndexElement &Rhs) { return Lhs.Name < Rhs.Name; }); + llvm::sort(Index.begin(), Index.end(), + [](const RecordIndexElement &Lhs, const RecordIndexElement &Rhs) { + return Lhs.Name < Rhs.Name; + }); for (unsigned i = 0, e = Index.size(); i != e; ++i) { const RecordIndexElement &R = Index[i]; @@ -1212,7 +1213,7 @@ Records.getAllDerivedDefinitions("Diagnostic"); std::vector DiagGroups = Records.getAllDerivedDefinitions("DiagGroup"); - std::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName); + llvm::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName); DiagGroupParentMap DGParentMap(Records); @@ -1231,10 +1232,10 @@ DiagsInPedanticSet.end()); RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(), GroupsInPedanticSet.end()); - std::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(), - beforeThanCompare); - std::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(), - beforeThanCompare); + llvm::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(), + beforeThanCompare); + llvm::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(), + beforeThanCompare); PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(), DiagsInPedantic.begin(), DiagsInPedantic.end()); @@ -1283,7 +1284,7 @@ OS << "Also controls "; bool First = true; - std::sort(GroupInfo.SubGroups.begin(), GroupInfo.SubGroups.end()); + llvm::sort(GroupInfo.SubGroups.begin(), GroupInfo.SubGroups.end()); for (const auto &Name : GroupInfo.SubGroups) { if (!First) OS << ", "; OS << "`" << (IsRemarkGroup ? "-R" : "-W") << Name << "`_"; Index: utils/TableGen/ClangOptionDocEmitter.cpp =================================================================== --- utils/TableGen/ClangOptionDocEmitter.cpp +++ utils/TableGen/ClangOptionDocEmitter.cpp @@ -111,7 +111,7 @@ auto DocumentationForOption = [&](Record *R) -> DocumentedOption { auto &A = Aliases[R]; - std::sort(A.begin(), A.end(), CompareByName); + llvm::sort(A.begin(), A.end(), CompareByName); return {R, std::move(A)}; }; @@ -120,7 +120,7 @@ Documentation D; auto &Groups = GroupsInGroup[R]; - std::sort(Groups.begin(), Groups.end(), CompareByLocation); + llvm::sort(Groups.begin(), Groups.end(), CompareByLocation); for (Record *G : Groups) { D.Groups.emplace_back(); D.Groups.back().Group = G; @@ -129,7 +129,7 @@ } auto &Options = OptionsInGroup[R]; - std::sort(Options.begin(), Options.end(), CompareByName); + llvm::sort(Options.begin(), Options.end(), CompareByName); for (Record *O : Options) D.Options.push_back(DocumentationForOption(O)); Index: utils/TableGen/NeonEmitter.cpp =================================================================== --- utils/TableGen/NeonEmitter.cpp +++ utils/TableGen/NeonEmitter.cpp @@ -2007,7 +2007,7 @@ } } - std::sort(NewTypeSpecs.begin(), NewTypeSpecs.end()); + llvm::sort(NewTypeSpecs.begin(), NewTypeSpecs.end()); NewTypeSpecs.erase(std::unique(NewTypeSpecs.begin(), NewTypeSpecs.end()), NewTypeSpecs.end()); auto &Entry = IntrinsicMap[Name];