Index: lib/AST/ItaniumMangle.cpp =================================================================== --- lib/AST/ItaniumMangle.cpp +++ lib/AST/ItaniumMangle.cpp @@ -323,7 +323,7 @@ AdditionalAbiTags->end()); } - llvm::sort(TagList.begin(), TagList.end()); + llvm::sort(TagList); TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end()); writeSortedUniqueAbiTags(Out, TagList); @@ -339,7 +339,7 @@ } const AbiTagList &getSortedUniqueUsedAbiTags() { - llvm::sort(UsedAbiTags.begin(), UsedAbiTags.end()); + llvm::sort(UsedAbiTags); 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,7 @@ const CXXMethodDecl *MD = I.second; ThunkInfoVectorTy ThunksVector = Thunks[MD]; - llvm::sort(ThunksVector.begin(), ThunksVector.end(), - [](const ThunkInfo &LHS, const ThunkInfo &RHS) { + llvm::sort(ThunksVector, [](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); }); @@ -3345,8 +3344,7 @@ PathsSorted.reserve(Paths.size()); for (auto& P : Paths) PathsSorted.push_back(*P); - llvm::sort(PathsSorted.begin(), PathsSorted.end(), - [](const VPtrInfo &LHS, const VPtrInfo &RHS) { + llvm::sort(PathsSorted, [](const VPtrInfo &LHS, const VPtrInfo &RHS) { return LHS.MangledPath < RHS.MangledPath; }); bool Changed = false; Index: lib/Analysis/LiveVariables.cpp =================================================================== --- lib/Analysis/LiveVariables.cpp +++ lib/Analysis/LiveVariables.cpp @@ -597,7 +597,7 @@ it != ei; ++it) { vec.push_back(it->first); } - llvm::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) { + llvm::sort(vec, [](const CFGBlock *A, const CFGBlock *B) { return A->getBlockID() < B->getBlockID(); }); @@ -617,10 +617,9 @@ declVec.push_back(*si); } - llvm::sort(declVec.begin(), declVec.end(), - [](const Decl *A, const Decl *B) { - return A->getBeginLoc() < B->getBeginLoc(); - }); + llvm::sort(declVec, [](const Decl *A, const Decl *B) { + return A->getBeginLoc() < B->getBeginLoc(); + }); for (std::vector::iterator di = declVec.begin(), de = declVec.end(); di != de; ++di) { Index: lib/Basic/VirtualFileSystem.cpp =================================================================== --- lib/Basic/VirtualFileSystem.cpp +++ lib/Basic/VirtualFileSystem.cpp @@ -2064,8 +2064,7 @@ } void YAMLVFSWriter::write(llvm::raw_ostream &OS) { - llvm::sort(Mappings.begin(), Mappings.end(), - [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) { + llvm::sort(Mappings, [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) { return LHS.VPath < RHS.VPath; }); Index: lib/CodeGen/CGBlocks.cpp =================================================================== --- lib/CodeGen/CGBlocks.cpp +++ lib/CodeGen/CGBlocks.cpp @@ -1729,7 +1729,7 @@ } // Sort the captures by offset. - llvm::sort(ManagedCaptures.begin(), ManagedCaptures.end()); + llvm::sort(ManagedCaptures); } namespace { Index: lib/CodeGen/CGObjCGNU.cpp =================================================================== --- lib/CodeGen/CGObjCGNU.cpp +++ lib/CodeGen/CGObjCGNU.cpp @@ -3544,7 +3544,7 @@ std::vector allSelectors; for (auto &entry : table) allSelectors.push_back(entry.first); - llvm::sort(allSelectors.begin(), allSelectors.end()); + llvm::sort(allSelectors); for (auto &untypedSel : allSelectors) { std::string selNameStr = untypedSel.getAsString(); Index: lib/CodeGen/CGVTables.cpp =================================================================== --- lib/CodeGen/CGVTables.cpp +++ lib/CodeGen/CGVTables.cpp @@ -1022,8 +1022,8 @@ AP.second.AddressPointIndex)); // Sort the address points for determinism. - llvm::sort(AddressPoints.begin(), AddressPoints.end(), - [this](const AddressPoint &AP1, const AddressPoint &AP2) { + llvm::sort(AddressPoints, [this](const AddressPoint &AP1, + const AddressPoint &AP2) { if (&AP1 == &AP2) return false; Index: lib/CodeGen/CodeGenModule.cpp =================================================================== --- lib/CodeGen/CodeGenModule.cpp +++ lib/CodeGen/CodeGenModule.cpp @@ -1423,7 +1423,7 @@ AddedAttr = true; } if (!Features.empty()) { - llvm::sort(Features.begin(), Features.end()); + llvm::sort(Features); Attrs.addAttribute("target-features", llvm::join(Features, ",")); AddedAttr = true; } Index: lib/CodeGen/TargetInfo.cpp =================================================================== --- lib/CodeGen/TargetInfo.cpp +++ lib/CodeGen/TargetInfo.cpp @@ -8598,7 +8598,7 @@ // The ABI requires unions to be sorted but not structures. // See FieldEncoding::operator< for sort algorithm. if (RT->isUnionType()) - llvm::sort(FE.begin(), FE.end()); + llvm::sort(FE); // We can now complete the TypeString. unsigned E = FE.size(); for (unsigned I = 0; I != E; ++I) { @@ -8642,7 +8642,7 @@ EnumEnc += '}'; FE.push_back(FieldEncoding(!I->getName().empty(), EnumEnc)); } - llvm::sort(FE.begin(), FE.end()); + llvm::sort(FE); 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 @@ -1516,12 +1516,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. - 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::sort(SuggestedCompletions, [](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/Driver/XRayArgs.cpp =================================================================== --- lib/Driver/XRayArgs.cpp +++ lib/Driver/XRayArgs.cpp @@ -165,7 +165,7 @@ } // Then we want to sort and unique the modes we've collected. - llvm::sort(Modes.begin(), Modes.end()); + llvm::sort(Modes); Modes.erase(std::unique(Modes.begin(), Modes.end()), Modes.end()); } } 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)); - llvm::sort(ForEachMacros.begin(), ForEachMacros.end()); + llvm::sort(ForEachMacros); } 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; - llvm::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); + llvm::sort(Changes, Change::IsBeforeInFile(SourceMgr)); calculateLineBreakInformation(); alignConsecutiveDeclarations(); alignConsecutiveAssignments(); Index: lib/Frontend/DiagnosticRenderer.cpp =================================================================== --- lib/Frontend/DiagnosticRenderer.cpp +++ lib/Frontend/DiagnosticRenderer.cpp @@ -337,8 +337,8 @@ SmallVector EndArgExpansions; getMacroArgExpansionFileIDs(Begin, BeginArgExpansions, /*IsBegin=*/true, SM); getMacroArgExpansionFileIDs(End, EndArgExpansions, /*IsBegin=*/false, SM); - llvm::sort(BeginArgExpansions.begin(), BeginArgExpansions.end()); - llvm::sort(EndArgExpansions.begin(), EndArgExpansions.end()); + llvm::sort(BeginArgExpansions); + llvm::sort(EndArgExpansions); 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 @@ -1391,7 +1391,7 @@ // Sort by first use so that we emit the warnings in a deterministic order. SourceManager &SM = S.getSourceManager(); - llvm::sort(UsesByStmt.begin(), UsesByStmt.end(), + llvm::sort(UsesByStmt, [&SM](const StmtUsesPair &LHS, const StmtUsesPair &RHS) { return SM.isBeforeInTranslationUnit(LHS.first->getBeginLoc(), RHS.first->getBeginLoc()); Index: lib/Sema/SemaDeclAttr.cpp =================================================================== --- lib/Sema/SemaDeclAttr.cpp +++ lib/Sema/SemaDeclAttr.cpp @@ -5206,7 +5206,7 @@ return; // Store tags sorted and without duplicates. - llvm::sort(Tags.begin(), Tags.end()); + llvm::sort(Tags); 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 @@ -186,9 +186,7 @@ list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common)); } - void done() { - llvm::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator()); - } + void done() { llvm::sort(list, UnqualUsingEntry::Comparator()); } typedef ListTy::const_iterator const_iterator; Index: lib/Sema/SemaOverload.cpp =================================================================== --- lib/Sema/SemaOverload.cpp +++ lib/Sema/SemaOverload.cpp @@ -10810,8 +10810,7 @@ // in general, want to list every possible builtin candidate. } - llvm::sort(Cands.begin(), Cands.end(), - CompareTemplateSpecCandidatesForDisplay(S)); + llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S)); // FIXME: Perhaps rename OverloadsShown and getShowOverloads() // for generalization purposes (?). Index: lib/Sema/SemaType.cpp =================================================================== --- lib/Sema/SemaType.cpp +++ lib/Sema/SemaType.cpp @@ -4986,7 +4986,7 @@ if (Chunk.Fun.TypeQuals & Qualifiers::Restrict) RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc()); if (!RemovalLocs.empty()) { - llvm::sort(RemovalLocs.begin(), RemovalLocs.end(), + llvm::sort(RemovalLocs, 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()); - llvm::sort(ExistingFeatures.begin(), ExistingFeatures.end()); - llvm::sort(ReadFeatures.begin(), ReadFeatures.end()); + llvm::sort(ExistingFeatures); + llvm::sort(ReadFeatures); // We compute the set difference in both directions explicitly so that we can // diagnose the differences differently. @@ -9190,8 +9190,7 @@ NextCursor: // De-serialized SourceLocations get negative FileIDs for other modules, // potentially invalidating the original order. Sort it again. - llvm::sort(Comments.begin(), Comments.end(), - BeforeThanCompare(SourceMgr)); + llvm::sort(Comments, BeforeThanCompare(SourceMgr)); Context.Comments.addDeserializedComments(Comments); } } Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp +++ lib/Serialization/ASTReaderDecl.cpp @@ -275,7 +275,7 @@ if (auto &Old = LazySpecializations) { IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]); - llvm::sort(IDs.begin(), IDs.end()); + llvm::sort(IDs); IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end()); } Index: lib/Serialization/ASTWriter.cpp =================================================================== --- lib/Serialization/ASTWriter.cpp +++ lib/Serialization/ASTWriter.cpp @@ -2495,8 +2495,7 @@ 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. - llvm::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), - llvm::less_ptr()); + llvm::sort(MacroIdentifiers, llvm::less_ptr()); // Emit the macro directives as a list and associate the offset with the // identifier they belong to. @@ -3230,8 +3229,7 @@ SmallVector, 64> SortedFileDeclIDs( FileDeclIDs.begin(), FileDeclIDs.end()); - llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), - llvm::less_first()); + llvm::sort(SortedFileDeclIDs, llvm::less_first()); // Join the vectors of DeclIDs from all files. SmallVector FileGroupedDeclIDs; @@ -3737,7 +3735,7 @@ IIs.push_back(ID.second); // Sort the identifiers lexicographically before getting them references so // that their order is stable. - llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); + llvm::sort(IIs, llvm::less_ptr()); for (const IdentifierInfo *II : IIs) if (Trait.isInterestingNonMacroIdentifier(II)) getIdentifierRef(II); @@ -4035,7 +4033,7 @@ } // Sort the names into a stable order. - llvm::sort(Names.begin(), Names.end()); + llvm::sort(Names); if (auto *D = dyn_cast(DC)) { // We need to establish an ordering of constructor and conversion function @@ -4172,7 +4170,7 @@ std::make_pair(Entry.first, Entry.second.getLookupResult())); } - llvm::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); + llvm::sort(LookupResults, llvm::less_first()); for (auto &NameAndResult : LookupResults) { DeclarationName Name = NameAndResult.first; DeclContext::lookup_result Result = NameAndResult.second; @@ -4875,7 +4873,7 @@ IIs.push_back(II); } // Sort the identifiers to visit based on their name. - llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr()); + llvm::sort(IIs, llvm::less_ptr()); for (const IdentifierInfo *II : IIs) { for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), DEnd = SemaRef.IdResolver.end(); @@ -5112,7 +5110,7 @@ }; // Sort and deduplicate module IDs. - llvm::sort(Imports.begin(), Imports.end(), Cmp); + llvm::sort(Imports, 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); - llvm::sort(Fields.begin(), Fields.end()); + llvm::sort(Fields); // 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 @@ -2386,8 +2386,7 @@ } // Sort the error paths from longest to shortest. - llvm::sort(ReportNodes.begin(), ReportNodes.end(), - PriorityCompare(PriorityMap)); + llvm::sort(ReportNodes, PriorityCompare(PriorityMap)); } bool TrimmedGraph::popNextReportGraph(ReportGraph &GraphWrapper) { Index: lib/StaticAnalyzer/Core/CheckerRegistry.cpp =================================================================== --- lib/StaticAnalyzer/Core/CheckerRegistry.cpp +++ lib/StaticAnalyzer/Core/CheckerRegistry.cpp @@ -103,7 +103,7 @@ void CheckerRegistry::initializeManager(CheckerManager &checkerMgr, SmallVectorImpl &opts) const { // Sort checkers for efficient collection. - llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers, checkerNameLT); // Collect checkers enabled by the options. CheckerInfoSet enabledCheckers; @@ -143,7 +143,7 @@ // FIXME: Alphabetical sort puts 'experimental' in the middle. // Would it be better to name it '~experimental' or something else // that's ASCIIbetically last? - llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers, checkerNameLT); // FIXME: Print available packages. @@ -178,7 +178,7 @@ void CheckerRegistry::printList( raw_ostream &out, SmallVectorImpl &opts) const { - llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT); + llvm::sort(Checkers, 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 - llvm::sort(Result.begin(), Result.end()); + llvm::sort(Result); return Result; } int peekMax() const { Index: lib/Tooling/Core/Replacement.cpp =================================================================== --- lib/Tooling/Core/Replacement.cpp +++ lib/Tooling/Core/Replacement.cpp @@ -483,12 +483,11 @@ // Returns a set of non-overlapping and sorted ranges that is equivalent to // \p Ranges. static std::vector combineAndSortRanges(std::vector Ranges) { - 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(); - }); + llvm::sort(Ranges, [](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) { if (Result.empty() || Index: lib/Tooling/InterpolatingCompilationDatabase.cpp =================================================================== --- lib/Tooling/InterpolatingCompilationDatabase.cpp +++ lib/Tooling/InterpolatingCompilationDatabase.cpp @@ -321,7 +321,7 @@ FileIndex(std::vector Files) : OriginalPaths(std::move(Files)), Strings(Arena) { // Sort commands by filename for determinism (index is a tiebreaker later). - llvm::sort(OriginalPaths.begin(), OriginalPaths.end()); + llvm::sort(OriginalPaths); Paths.reserve(OriginalPaths.size()); Types.reserve(OriginalPaths.size()); Stems.reserve(OriginalPaths.size()); @@ -336,9 +336,9 @@ if (Dir->size() > ShortDirectorySegment) // not trivial ones Components.emplace_back(*Dir, I); } - llvm::sort(Paths.begin(), Paths.end()); - llvm::sort(Stems.begin(), Stems.end()); - llvm::sort(Components.begin(), Components.end()); + llvm::sort(Paths); + llvm::sort(Stems); + llvm::sort(Components); } bool empty() const { return Paths.empty(); } Index: tools/diagtool/DiagTool.cpp =================================================================== --- tools/diagtool/DiagTool.cpp +++ tools/diagtool/DiagTool.cpp @@ -48,7 +48,7 @@ if (len > maxName) maxName = len; } - llvm::sort(toolNames.begin(), toolNames.end()); + llvm::sort(toolNames); 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 @@ -1044,7 +1044,7 @@ } // Now sort the Decls so that they appear in lexical order. - llvm::sort(DeclsInContainer.begin(), DeclsInContainer.end(), + llvm::sort(DeclsInContainer, [&SM](Decl *A, Decl *B) { SourceLocation L_A = A->getBeginLoc(); SourceLocation L_B = B->getBeginLoc(); @@ -7803,11 +7803,11 @@ if (AvailabilityAttrs.empty()) return; - llvm::sort(AvailabilityAttrs.begin(), AvailabilityAttrs.end(), + llvm::sort(AvailabilityAttrs, [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) { return LHS->getPlatform()->getName() < RHS->getPlatform()->getName(); - }); + }); ASTContext &Ctx = D->getASTContext(); auto It = std::unique( AvailabilityAttrs.begin(), AvailabilityAttrs.end(), Index: unittests/Basic/VirtualFileSystemTest.cpp =================================================================== --- unittests/Basic/VirtualFileSystemTest.cpp +++ unittests/Basic/VirtualFileSystemTest.cpp @@ -553,8 +553,8 @@ for (DirIter E; !EC && I != E; I.increment(EC)) InputToCheck.push_back(I->path()); - llvm::sort(InputToCheck.begin(), InputToCheck.end()); - llvm::sort(Expected.begin(), Expected.end()); + llvm::sort(InputToCheck); + llvm::sort(Expected); EXPECT_EQ(InputToCheck.size(), Expected.size()); unsigned LastElt = std::min(InputToCheck.size(), Expected.size()); Index: utils/TableGen/ClangDiagnosticsEmitter.cpp =================================================================== --- utils/TableGen/ClangDiagnosticsEmitter.cpp +++ utils/TableGen/ClangDiagnosticsEmitter.cpp @@ -208,9 +208,9 @@ E = SortedGroups.end(); I != E; ++I) { MutableArrayRef GroupDiags = (*I)->DiagsInGroup; - llvm::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare); + llvm::sort(GroupDiags, beforeThanCompare); } - llvm::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups); + llvm::sort(SortedGroups, beforeThanCompareGroups); // Warn about the same group being used anonymously in multiple places. for (SmallVectorImpl::const_iterator I = SortedGroups.begin(), @@ -1595,10 +1595,10 @@ Index.push_back(RecordIndexElement(R)); } - llvm::sort(Index.begin(), Index.end(), + llvm::sort(Index, [](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]; @@ -1694,7 +1694,7 @@ std::vector DiagGroups = Records.getAllDerivedDefinitions("DiagGroup"); - llvm::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName); + llvm::sort(DiagGroups, diagGroupBeforeByName); DiagGroupParentMap DGParentMap(Records); @@ -1713,10 +1713,8 @@ DiagsInPedanticSet.end()); RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(), GroupsInPedanticSet.end()); - llvm::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(), - beforeThanCompare); - llvm::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(), - beforeThanCompare); + llvm::sort(DiagsInPedantic, beforeThanCompare); + llvm::sort(GroupsInPedantic, beforeThanCompare); PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(), DiagsInPedantic.begin(), DiagsInPedantic.end()); 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]; - llvm::sort(A.begin(), A.end(), CompareByName); + llvm::sort(A, CompareByName); return {R, std::move(A)}; }; @@ -120,7 +120,7 @@ Documentation D; auto &Groups = GroupsInGroup[R]; - llvm::sort(Groups.begin(), Groups.end(), CompareByLocation); + llvm::sort(Groups, CompareByLocation); for (Record *G : Groups) { D.Groups.emplace_back(); D.Groups.back().Group = G; @@ -129,7 +129,7 @@ } auto &Options = OptionsInGroup[R]; - llvm::sort(Options.begin(), Options.end(), CompareByName); + llvm::sort(Options, CompareByName); for (Record *O : Options) D.Options.push_back(DocumentationForOption(O)); Index: utils/TableGen/NeonEmitter.cpp =================================================================== --- utils/TableGen/NeonEmitter.cpp +++ utils/TableGen/NeonEmitter.cpp @@ -2020,7 +2020,7 @@ } } - llvm::sort(NewTypeSpecs.begin(), NewTypeSpecs.end()); + llvm::sort(NewTypeSpecs); NewTypeSpecs.erase(std::unique(NewTypeSpecs.begin(), NewTypeSpecs.end()), NewTypeSpecs.end()); auto &Entry = IntrinsicMap[Name];