llvm::sort(C.begin(), C.end(), ...) -> llvm::sort(C, ...)

[MaskRay]

Summary

The convenience wrapper in STLExtras is available since rL342102.

[rsmith]

Thanks for the cleanup! Maybe consider running clang-format-diff on this?

lib/Sema/SemaOverload.cpp

10813–10814

Reflow.

lib/Serialization/ASTReader.cpp

9193–9194

Reflow if this fits on the previous line.

lib/Serialization/ASTWriter.cpp

2498–2499

Reflow.

3233–3234

Reflow.

lib/StaticAnalyzer/Core/BugReporter.cpp

2389–2390

Reflow if this fits on the previous line.

utils/TableGen/ClangDiagnosticsEmitter.cpp

1716–1719

Reflow these lines.

[MaskRay]

Reflow nearby statements as rsmith@ requested:

git diff -U0 --no-color 'HEAD^' | ~/llvm/tools/clang/tools/clang-format/clang-format-diff.py -i -p1

lib/AST/ItaniumMangle.cpp

void write(raw_ostream &Out, const NamedDecl *ND,
 
       if (AdditionalAbiTags) {
         UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(),
                            AdditionalAbiTags->end());
         TagList.insert(TagList.end(), AdditionalAbiTags->begin(),
                        AdditionalAbiTags->end());
       }
 
-      llvm::sort(TagList.begin(), TagList.end());
+      llvm::sort(TagList);
       TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end());
 
       writeSortedUniqueAbiTags(Out, TagList);
     }
 
     const AbiTagList &getUsedAbiTags() const { return UsedAbiTags; }
     void setUsedAbiTags(const AbiTagList &AbiTags) {
       UsedAbiTags = AbiTags;
     }
 
     const AbiTagList &getEmittedAbiTags() const {
       return EmittedAbiTags;
     }
 
     const AbiTagList &getSortedUniqueUsedAbiTags() {
-      llvm::sort(UsedAbiTags.begin(), UsedAbiTags.end());
+      llvm::sort(UsedAbiTags);
       UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
                         UsedAbiTags.end());
       return UsedAbiTags;
     }
 
   private:
     //! All abi tags used implicitly or explicitly.
     AbiTagList UsedAbiTags;

lib/AST/VTableBuilder.cpp

for (const auto &I : Thunks) {
       MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
     }
 
     for (const auto &I : MethodNamesAndDecls) {
       const std::string &MethodName = I.first;
       const CXXMethodDecl *MD = I.second;
 
       ThunkInfoVectorTy ThunksVector = Thunks[MD];
-      llvm::sort(ThunksVector.begin(), ThunksVector.end(),
+      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);
       });
 
       Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
       Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
 
static bool rebucketPaths(VPtrInfoVector &Paths) {
   // is usually the direct base of the inherited the vbptr.  This code uses a
   // sorted vector to implement a multiset to form the buckets.  Note that the
   // ordering is based on pointers, but it doesn't change our output order.  The
   // current algorithm is designed to match MSVC 2012's names.
   llvm::SmallVector<std::reference_wrapper<VPtrInfo>, 2> PathsSorted;
   PathsSorted.reserve(Paths.size());
   for (auto& P : Paths)
     PathsSorted.push_back(*P);
-  llvm::sort(PathsSorted.begin(), PathsSorted.end(),
+  llvm::sort(PathsSorted,
              [](const VPtrInfo &LHS, const VPtrInfo &RHS) {
     return LHS.MangledPath < RHS.MangledPath;
   });
   bool Changed = false;
   for (size_t I = 0, E = PathsSorted.size(); I != E;) {
     // Scan forward to find the end of the bucket.
     size_t BucketStart = I;
     do {

lib/Analysis/LiveVariables.cpp

 
 void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
   std::vector<const CFGBlock *> vec;
   for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator
        it = blocksEndToLiveness.begin(), ei = blocksEndToLiveness.end();
        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();
   });
 
   std::vector<const VarDecl*> declVec;
 
   for (std::vector<const CFGBlock *>::iterator
         it = vec.begin(), ei = vec.end(); it != ei; ++it) {
     llvm::errs() << "\n[ B" << (*it)->getBlockID()
                  << " (live variables at block exit) ]\n";
 
     LiveVariables::LivenessValues vals = blocksEndToLiveness[*it];
     declVec.clear();
 
     for (llvm::ImmutableSet<const VarDecl *>::iterator si =
           vals.liveDecls.begin(),
           se = vals.liveDecls.end(); si != se; ++si) {
       declVec.push_back(*si);
     }
 
-    llvm::sort(declVec.begin(), declVec.end(),
+    llvm::sort(declVec,
                [](const Decl *A, const Decl *B) {
                  return A->getBeginLoc() < B->getBeginLoc();
                });
 
     for (std::vector<const VarDecl*>::iterator di = declVec.begin(),
          de = declVec.end(); di != de; ++di) {
       llvm::errs() << " " << (*di)->getDeclName().getAsString()
                    << " <";

lib/Basic/VirtualFileSystem.cpp

if (!Entries.empty()) {
     OS << "\n";
   }
 
   OS << "  ]\n"
      << "}\n";
 }
 
 void YAMLVFSWriter::write(llvm::raw_ostream &OS) {
-  llvm::sort(Mappings.begin(), Mappings.end(),
+  llvm::sort(Mappings,
              [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) {
     return LHS.VPath < RHS.VPath;
   });
 
   JSONWriter(OS).write(Mappings, UseExternalNames, IsCaseSensitive,
                        IsOverlayRelative, IgnoreNonExistentContents,
                        OverlayDir);
 }

lib/CodeGen/CGBlocks.cpp

for (const auto &CI : BlockInfo.getBlockDecl()->captures()) {
     if (CopyInfo.first != BlockCaptureEntityKind::None ||
         DisposeInfo.first != BlockCaptureEntityKind::None)
       ManagedCaptures.emplace_back(CopyInfo.first, DisposeInfo.first,
                                    CopyInfo.second, DisposeInfo.second, CI,
                                    Capture);
   }
 
   // Sort the captures by offset.
-  llvm::sort(ManagedCaptures.begin(), ManagedCaptures.end());
+  llvm::sort(ManagedCaptures);
 }
 
 namespace {
 /// Release a __block variable.
 struct CallBlockRelease final : EHScopeStack::Cleanup {
   Address Addr;
   BlockFieldFlags FieldFlags;
   bool LoadBlockVarAddr, CanThrow;

lib/CodeGen/CGObjCGNU.cpp

llvm::Function *CGObjCGNU::ModuleInitFunction() {
   // Pointer to an array of selectors used in this module.
   llvm::GlobalVariable *selectorList = [&] {
     ConstantInitBuilder builder(CGM);
     auto selectors = builder.beginArray(selStructTy);
     auto &table = SelectorTable; // MSVC workaround
     std::vector<Selector> 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();
       llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name");
 
       for (TypedSelector &sel : table[untypedSel]) {
         llvm::Constant *selectorTypeEncoding = NULLPtr;
         if (!sel.first.empty())

lib/CodeGen/CGVTables.cpp

void CodeGenModule::EmitVTableTypeMetadata(llvm::GlobalVariable *VTable,
   typedef std::pair<const CXXRecordDecl *, unsigned> AddressPoint;
   std::vector<AddressPoint> AddressPoints;
   for (auto &&AP : VTLayout.getAddressPoints())
     AddressPoints.push_back(std::make_pair(
         AP.first.getBase(), VTLayout.getVTableOffset(AP.second.VTableIndex) +
                                 AP.second.AddressPointIndex));
 
   // Sort the address points for determinism.
-  llvm::sort(AddressPoints.begin(), AddressPoints.end(),
+  llvm::sort(AddressPoints,
              [this](const AddressPoint &AP1, const AddressPoint &AP2) {
     if (&AP1 == &AP2)
       return false;
 
     std::string S1;
     llvm::raw_string_ostream O1(S1);
     getCXXABI().getMangleContext().mangleTypeName(
         QualType(AP1.first->getTypeForDecl(), 0), O1);

lib/CodeGen/CodeGenModule.cpp

if (TD || SD) {
     Features = getTarget().getTargetOpts().Features;
   }
 
   if (TargetCPU != "") {
     Attrs.addAttribute("target-cpu", TargetCPU);
     AddedAttr = true;
   }
   if (!Features.empty()) {
-    llvm::sort(Features.begin(), Features.end());
+    llvm::sort(Features);
     Attrs.addAttribute("target-features", llvm::join(Features, ","));
     AddedAttr = true;
   }
 
   return AddedAttr;
 }
 
 void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,

lib/CodeGen/TargetInfo.cpp

if (RD && !RD->field_empty()) {
     if (!extractFieldType(FE, RD, CGM, TSC)) {
       (void) TSC.removeIncomplete(ID);
       return false;
     }
     IsRecursive = TSC.removeIncomplete(ID);
     // 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) {
       if (I)
         Enc += ',';
       Enc += FE[I].str();
     }
   }
for (auto I = ED->enumerator_begin(), E = ED->enumerator_end(); I != E;
       SmallStringEnc EnumEnc;
       EnumEnc += "m(";
       EnumEnc += I->getName();
       EnumEnc += "){";
       I->getInitVal().toString(EnumEnc);
       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)
         Enc += ',';
       Enc += FE[I].str();
     }
   }
   Enc += '}';

lib/Driver/Driver.cpp

for (StringRef S : DiagnosticIDs::getDiagnosticFlags())
       if (S.startswith(Cur))
         SuggestedCompletions.push_back(S);
   }
 
   // Sort the autocomplete candidates so that shells print them out in a
   // 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(),
+  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';
 }

lib/Driver/XRayArgs.cpp

else
             Modes.clear();
           else if (M == "all")
             llvm::copy(XRaySupportedModes, std::back_inserter(Modes));
           else
             Modes.push_back(M);
       }
 
     // 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());
   }
 }
 
 void XRayArgs::addArgs(const ToolChain &TC, const ArgList &Args,
                        ArgStringList &CmdArgs, types::ID InputType) const {
   if (!XRayInstrument)
     return;

lib/Format/FormatTokenLexer.cpp

: FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
   Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
   for (const std::string &ForEachMacro : Style.ForEachMacros)
     ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
-  llvm::sort(ForEachMacros.begin(), ForEachMacros.end());
+  llvm::sort(ForEachMacros);
 }
 
 ArrayRef<FormatToken *> FormatTokenLexer::lex() {
   assert(Tokens.empty());
   assert(FirstInLineIndex == 0);
   do {
     Tokens.push_back(getNextToken());
     if (Style.Language == FormatStyle::LK_JavaScript) {

lib/Format/WhitespaceManager.cpp

Changes.push_back(
              std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,
              InPPDirective && !Tok.IsFirst, /*IsInsideToken=*/true));
 }
 
 const tooling::Replacements &WhitespaceManager::generateReplacements() {
   if (Changes.empty())
     return Replaces;
 
-  llvm::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
+  llvm::sort(Changes, Change::IsBeforeInFile(SourceMgr));
   calculateLineBreakInformation();
   alignConsecutiveDeclarations();
   alignConsecutiveAssignments();
   alignTrailingComments();
   alignEscapedNewlines();
   generateChanges();
 
   return Replaces;

lib/Frontend/DiagnosticRenderer.cpp

 /// intersection. Produces a sorted vector of FileIDs in CommonArgExpansions.
 static void computeCommonMacroArgExpansionFileIDs(
     SourceLocation Begin, SourceLocation End, const SourceManager *SM,
     SmallVectorImpl<FileID> &CommonArgExpansions) {
   SmallVector<FileID, 4> BeginArgExpansions;
   SmallVector<FileID, 4> 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));
 }
 
 // Helper function to fix up source ranges.  It takes in an array of ranges,
 // and outputs an array of ranges where we want to draw the range highlighting
 // around the location specified by CaretLoc.

lib/Sema/AnalysisBasedWarnings.cpp

for (WeakObjectUseMap::const_iterator I = WeakMap.begin(), E = WeakMap.end();
     UsesByStmt.push_back(StmtUsesPair(UI->getUseExpr(), I));
   }
 
   if (UsesByStmt.empty())
     return;
 
   // 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());
              });
 
   // Classify the current code body for better warning text.
   // This enum should stay in sync with the cases in
   // warn_arc_repeated_use_of_weak and warn_arc_possible_repeated_use_of_weak.

lib/Sema/SemaDeclAttr.cpp

if (NS->isAnonymousNamespace()) {
       return;
     }
     if (AL.getNumArgs() == 0)
       Tags.push_back(NS->getName());
   } else if (!checkAttributeAtLeastNumArgs(S, AL, 1))
     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)
              AbiTagAttr(AL.getRange(), S.Context, Tags.data(), Tags.size(),
                         AL.getAttributeSpellingListIndex()));
 }
 
 static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {

lib/Sema/SemaLookup.cpp

void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
       while (!Common->Encloses(EffectiveDC))
         Common = Common->getParent();
       Common = Common->getPrimaryContext();
 
       list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
     }
 
     void done() {
-      llvm::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
+      llvm::sort(list, UnqualUsingEntry::Comparator());
     }
 
     typedef ListTy::const_iterator const_iterator;
 
     const_iterator begin() const { return list.begin(); }
     const_iterator end() const { return list.end(); }
 
     llvm::iterator_range<const_iterator>

lib/Sema/SemaOverload.cpp

void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {
   Cands.reserve(size());
   for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
     if (Cand->Specialization)
       Cands.push_back(Cand);
     // Otherwise, this is a non-matching builtin candidate.  We do not,
     // in general, want to list every possible builtin candidate.
   }
 
-  llvm::sort(Cands.begin(), Cands.end(),
+  llvm::sort(Cands,
              CompareTemplateSpecCandidatesForDisplay(S));
 
   // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
   // for generalization purposes (?).
   const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
 
   SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E;
   unsigned CandsShown = 0;
   for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {

lib/Sema/SemaType.cpp

if (IsQualifiedFunction &&
           RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc());
         if (Chunk.Fun.TypeQuals & Qualifiers::Const)
           RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc());
         if (Chunk.Fun.TypeQuals & Qualifiers::Volatile)
           RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc());
         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<SourceLocation>(S.getSourceManager()));
           RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back());
           Loc = RemovalLocs.front();
         }
       }
 
       S.Diag(Loc, diag::err_invalid_qualified_function_type)
         << Kind << D.isFunctionDeclarator() << T

lib/Serialization/ASTReader.cpp

 #undef CHECK_TARGET_OPT
 
   // Compare feature sets.
   SmallVector<StringRef, 4> ExistingFeatures(
                                              ExistingTargetOpts.FeaturesAsWritten.begin(),
                                              ExistingTargetOpts.FeaturesAsWritten.end());
   SmallVector<StringRef, 4> 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.
   SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
   std::set_difference(
       ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
       ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
   std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
while (true) {
             SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
         break;
       }
       }
     }
   NextCursor:
     // De-serialized SourceLocations get negative FileIDs for other modules,
     // potentially invalidating the original order. Sort it again.
-    llvm::sort(Comments.begin(), Comments.end(),
+    llvm::sort(Comments,
                BeforeThanCompare<RawComment>(SourceMgr));
     Context.Comments.addDeserializedComments(Comments);
   }
 }
 
 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
                                 bool IncludeSystem, bool Complain,
                     llvm::function_ref<void(const serialization::InputFile &IF,
                                             bool isSystem)> Visitor) {

lib/Serialization/ASTReaderDecl.cpp

void AddLazySpecializations(T *D,
 
       // FIXME: We should avoid this pattern of getting the ASTContext.
       ASTContext &C = D->getASTContext();
 
       auto *&LazySpecializations = D->getCommonPtr()->LazySpecializations;
 
       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());
       }
 
       auto *Result = new (C) serialization::DeclID[1 + IDs.size()];
       *Result = IDs.size();
       std::copy(IDs.begin(), IDs.end(), Result + 1);
 
       LazySpecializations = Result;

lib/Serialization/ASTWriter.cpp

void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
   SmallVector<const IdentifierInfo *, 128> MacroIdentifiers;
   for (auto &Id : PP.getIdentifierTable())
     if (Id.second->hadMacroDefinition() &&
         (!Id.second->isFromAST() ||
          Id.second->hasChangedSinceDeserialization()))
       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::sort(MacroIdentifiers,
              llvm::less_ptr<IdentifierInfo>());
 
   // Emit the macro directives as a list and associate the offset with the
   // identifier they belong to.
   for (const IdentifierInfo *Name : MacroIdentifiers) {
     MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name);
     auto StartOffset = Stream.GetCurrentBitNo();
 
     // Emit the macro directives in reverse source order.
void ASTWriter::WriteTypeDeclOffsets() {
   }
 }
 
 void ASTWriter::WriteFileDeclIDsMap() {
   using namespace llvm;
 
   SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> SortedFileDeclIDs(
       FileDeclIDs.begin(), FileDeclIDs.end());
-  llvm::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(),
+  llvm::sort(SortedFileDeclIDs,
              llvm::less_first());
 
   // Join the vectors of DeclIDs from all files.
   SmallVector<DeclID, 256> FileGroupedDeclIDs;
   for (auto &FileDeclEntry : SortedFileDeclIDs) {
     DeclIDInFileInfo &Info = *FileDeclEntry.second;
     Info.FirstDeclIndex = FileGroupedDeclIDs.size();
     for (auto &LocDeclEntry : Info.DeclIDs)
       FileGroupedDeclIDs.push_back(LocDeclEntry.second);
// strings.
     // table to enable checking of the predefines buffer in the case
     // where the user adds new macro definitions when building the AST
     // file.
     SmallVector<const IdentifierInfo *, 128> IIs;
     for (const auto &ID : PP.getIdentifierTable())
       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<IdentifierInfo>());
+    llvm::sort(IIs, llvm::less_ptr<IdentifierInfo>());
     for (const IdentifierInfo *II : IIs)
       if (Trait.isInterestingNonMacroIdentifier(II))
         getIdentifierRef(II);
 
     // Create the on-disk hash table representation. We only store offsets
     // for identifiers that appear here for the first time.
     IdentifierOffsets.resize(NextIdentID - FirstIdentID);
     for (auto IdentIDPair : IdentifierIDs) {
case DeclarationName::CXXConversionFunctionName:
       assert(isa<CXXRecordDecl>(DC) &&
              "Cannot have a conversion function name outside of a class!");
       ConversionNameSet.insert(Name);
       break;
     }
   }
 
   // Sort the names into a stable order.
-  llvm::sort(Names.begin(), Names.end());
+  llvm::sort(Names);
 
   if (auto *D = dyn_cast<CXXRecordDecl>(DC)) {
     // We need to establish an ordering of constructor and conversion function
     // names, and they don't have an intrinsic ordering.
 
     // First we try the easy case by forming the current context's constructor
     // name and adding that name first. This is a very useful optimization to
     // avoid walking the lexical declarations in many cases, and it also
SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16>
         LookupResults;
     if (Map) {
       LookupResults.reserve(Map->size());
       for (auto &Entry : *Map)
         LookupResults.push_back(
             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;
       if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
           Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
         // We have to work around a name lookup bug here where negative lookup
         // results for these names get cached in namespace lookup tables (these
         // names should never be looked up in a namespace).
ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
   if (!WritingModule || !getLangOpts().CPlusPlus) {
     llvm::SmallVector<const IdentifierInfo*, 256> IIs;
     for (const auto &ID : PP.getIdentifierTable()) {
       const IdentifierInfo *II = ID.second;
       if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization())
         IIs.push_back(II);
     }
     // Sort the identifiers to visit based on their name.
-    llvm::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
+    llvm::sort(IIs, llvm::less_ptr<IdentifierInfo>());
     for (const IdentifierInfo *II : IIs) {
       for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II),
                                      DEnd = SemaRef.IdResolver.end();
            D != DEnd; ++D) {
         GetDeclRef(*D);
       }
     }
   }
if (!Imports.empty()) {
       auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
         return A.ID < B.ID;
       };
       auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) {
         return A.ID == B.ID;
       };
 
       // 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());
 
       RecordData ImportedModules;
       for (const auto &Import : Imports) {
         ImportedModules.push_back(Import.ID);
         // FIXME: If the module has macros imported then later has declarations
         // imported, this location won't be the right one as a location for the

lib/StaticAnalyzer/Checkers/PaddingChecker.cpp

auto GatherSizesAndAlignments = [](const FieldDecl *FD) {
           Ctx.getTypeInfoInChars(FD->getType());
       assert(llvm::isPowerOf2_64(RetVal.Align.getQuantity()));
       if (auto Max = FD->getMaxAlignment())
         RetVal.Align = std::max(Ctx.toCharUnitsFromBits(Max), RetVal.Align);
       return RetVal;
     };
     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
     // could pack more bytes in to a base class's tail padding.
     CharUnits NewOffset = ASTContext.toCharUnitsFromBits(RL.getFieldOffset(0));
     CharUnits NewPad;
     SmallVector<const FieldDecl *, 20> OptimalFieldsOrder;
     while (!Fields.empty()) {

lib/StaticAnalyzer/Core/BugReporter.cpp

while (!WS.empty()) {
 
     for (ExplodedNode::const_pred_iterator I = Node->succ_begin(),
                                            E = Node->succ_end();
          I != E; ++I)
       WS.push(*I);
   }
 
   // Sort the error paths from longest to shortest.
-  llvm::sort(ReportNodes.begin(), ReportNodes.end(),
+  llvm::sort(ReportNodes,
              PriorityCompare<true>(PriorityMap));
 }
 
 bool TrimmedGraph::popNextReportGraph(ReportGraph &GraphWrapper) {
   if (ReportNodes.empty())
     return false;
 
   const ExplodedNode *OrigN;
   std::tie(OrigN, GraphWrapper.Index) = ReportNodes.pop_back_val();

lib/StaticAnalyzer/Core/CheckerRegistry.cpp

while (!leafName.empty()) {
     Packages[packageName] += 1;
     std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
   }
 }
 
 void CheckerRegistry::initializeManager(CheckerManager &checkerMgr,
                                   SmallVectorImpl<CheckerOptInfo> &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;
   for (auto &i : opts)
     collectCheckers(Checkers, Packages, i, enabledCheckers);
 
   // Initialize the CheckerManager with all enabled checkers.
   for (const auto *i :enabledCheckers) {
void CheckerRegistry::validateCheckerOptions(const AnalyzerOptions &opts,
   }
 }
 
 void CheckerRegistry::printHelp(raw_ostream &out,
                                 size_t maxNameChars) const {
   // 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.
 
   out << "CHECKERS:\n";
 
   // Find the maximum option length.
   size_t optionFieldWidth = 0;
   for (const auto &i : Checkers) {
for (const auto &i : Checkers) {
     out.indent(pad + 2) << i.Desc;
 
     out << '\n';
   }
 }
 
 void CheckerRegistry::printList(
     raw_ostream &out, SmallVectorImpl<CheckerOptInfo> &opts) const {
-  llvm::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
+  llvm::sort(Checkers, checkerNameLT);
 
   // Collect checkers enabled by the options.
   CheckerInfoSet enabledCheckers;
   for (auto &i : opts)
     collectCheckers(Checkers, Packages, i, enabledCheckers);
 
   for (const auto *i : enabledCheckers)
     out << i->FullName << '\n';
 }

lib/Tooling/ASTDiff/ASTDiff.cpp

std::vector<NodeId> pop() {
     std::vector<NodeId> Result;
     if (Max == 0)
       return Result;
     while (peekMax() == Max) {
       Result.push_back(List.top());
       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 {
     if (List.empty())
       return 0;
     return Tree.getNode(List.top()).Height;
   }
   void open(NodeId Id) {

lib/Tooling/Core/Replacement.cpp

Replacements Replacements::merge(const Replacements &ReplacesToMerge) const {
   }
   return Replacements(Result.begin(), Result.end());
 }
 
 // Combines overlapping ranges in \p Ranges and sorts the combined ranges.
 // Returns a set of non-overlapping and sorted ranges that is equivalent to
 // \p Ranges.
 static std::vector<Range> combineAndSortRanges(std::vector<Range> Ranges) {
-  llvm::sort(Ranges.begin(), Ranges.end(),
+  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<Range> Result;
   for (const auto &R : Ranges) {
     if (Result.empty() ||

lib/Tooling/InterpolatingCompilationDatabase.cpp

 //
 // Apart from path proximity signals, also takes file extensions into account
 // when scoring the candidates.
 class FileIndex {
 public:
   FileIndex(std::vector<std::string> 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());
     for (size_t I = 0; I < OriginalPaths.size(); ++I) {
       StringRef Path = Strings.save(StringRef(OriginalPaths[I]).lower());
 
       Paths.emplace_back(Path, I);
       Types.push_back(foldType(guessType(Path)));
       Stems.emplace_back(sys::path::stem(Path), I);
       auto Dir = ++sys::path::rbegin(Path), DirEnd = sys::path::rend(Path);
       for (int J = 0; J < DirectorySegmentsIndexed && Dir != DirEnd; ++J, ++Dir)
         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(); }
 
   // Returns the path for the file that best fits OriginalFilename.
   // Candidates with extensions matching PreferLanguage will be chosen over
   // others (unless it's TY_INVALID, or all candidates are bad).
   StringRef chooseProxy(StringRef OriginalFilename,

tools/diagtool/DiagTool.cpp

void DiagTools::printCommands(llvm::raw_ostream &out) {
   unsigned maxName = 0;
   for (ToolMap::iterator it = getTools(tools)->begin(),
        ei = getTools(tools)->end(); it != ei; ++it) {
     toolNames.push_back(it->getKey());
     unsigned len = it->getKey().size();
     if (len > maxName)
       maxName = len;    
   }
-  llvm::sort(toolNames.begin(), toolNames.end());
+  llvm::sort(toolNames);
 
   for (std::vector<llvm::StringRef>::iterator it = toolNames.begin(),
        ei = toolNames.end(); it != ei; ++it) {
 
     out << "  " << (*it);
     unsigned spaces = (maxName + 3) - (it->size());
     for (unsigned i = 0; i < spaces; ++i)
       out << ' ';
     
     out << getTool(*it)->getDescription() << '\n';    
   }
 }
 
 namespace diagtool {
   llvm::ManagedStatic<DiagTools> diagTools;
 }

tools/libclang/CIndex.cpp

bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
   for (auto *SubDecl : D->decls()) {
     if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
         SubDecl->getBeginLoc().isInvalid())
       continue;
     DeclsInContainer.push_back(SubDecl);
   }
 
   // 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();
                return L_A != L_B ? SM.isBeforeInTranslationUnit(L_A, L_B)
                                  : SM.isBeforeInTranslationUnit(A->getEndLoc(),
                                                                 B->getEndLoc());
              });
 
if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
       return getCursorPlatformAvailabilityForDecl(
           cast<Decl>(EnumConst->getDeclContext()), always_deprecated,
           deprecated_message, always_unavailable, unavailable_message,
           AvailabilityAttrs);
 
   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(),
       [&Ctx](AvailabilityAttr *LHS, AvailabilityAttr *RHS) {

unittests/Basic/VirtualFileSystemTest.cpp

static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) {
   SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end());
   SmallVector<std::string, 4> InputToCheck;
 
   // Do not rely on iteration order to check for contents, sort both
   // content vectors before comparison.
   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());
   for (unsigned Idx = 0; Idx != LastElt; ++Idx)
     EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]);
 }
 
 TEST(VirtualFileSystemTest, OverlayIteration) {

utils/TableGen/ClangDiagnosticsEmitter.cpp

static void groupDiagnostics(const std::vector<Record*> &Diags,
 
   // Sort the implicit groups, so we can warn about them deterministically.
   SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
                                             ImplicitGroups.end());
   for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
                                               E = SortedGroups.end();
        I != E; ++I) {
     MutableArrayRef<const Record *> 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<GroupInfo *>::const_iterator I = SortedGroups.begin(),
                                                     E = SortedGroups.end();
        I != E; ++I) {
     ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
 
     if ((*I)->ExplicitDef) {
void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
 
   std::vector<RecordIndexElement> Index;
   Index.reserve(Diags.size());
   for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
     const Record &R = *(Diags[i]);
     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];
 
     OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
void EmitClangDiagDocs(RecordKeeper &Records, raw_ostream &OS) {
 
   DiagnosticTextBuilder Builder(Records);
 
   std::vector<Record*> Diags =
       Records.getAllDerivedDefinitions("Diagnostic");
 
   std::vector<Record*> DiagGroups =
       Records.getAllDerivedDefinitions("DiagGroup");
-  llvm::sort(DiagGroups.begin(), DiagGroups.end(), diagGroupBeforeByName);
+  llvm::sort(DiagGroups, diagGroupBeforeByName);
 
   DiagGroupParentMap DGParentMap(Records);
 
   std::map<std::string, GroupInfo> DiagsInGroup;
   groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
 
   // Compute the set of diagnostics that are in -Wpedantic.
   {
     RecordSet DiagsInPedanticSet;
     RecordSet GroupsInPedanticSet;
     InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
     inferPedantic.compute(&DiagsInPedanticSet, &GroupsInPedanticSet);
     auto &PedDiags = DiagsInGroup["pedantic"];
     // Put the diagnostics into a deterministic order.
     RecordVec DiagsInPedantic(DiagsInPedanticSet.begin(),
                               DiagsInPedanticSet.end());
     RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(),
                                GroupsInPedanticSet.end());
-    llvm::sort(DiagsInPedantic.begin(), DiagsInPedantic.end(),
+    llvm::sort(DiagsInPedantic,
                beforeThanCompare);
-    llvm::sort(GroupsInPedantic.begin(), GroupsInPedantic.end(),
+    llvm::sort(GroupsInPedantic,
                beforeThanCompare);
     PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(),
                                  DiagsInPedantic.begin(),
                                  DiagsInPedantic.end());
     for (auto *Group : GroupsInPedantic)
       PedDiags.SubGroups.push_back(Group->getValueAsString("GroupName"));
   }
 
   // FIXME: Write diagnostic categories and link to diagnostic groups in each.

utils/TableGen/ClangOptionDocEmitter.cpp

Documentation extractDocumentation(RecordKeeper &Records) {
   };
 
   auto CompareByLocation = [](Record *A, Record *B) {
     return A->getLoc()[0].getPointer() < B->getLoc()[0].getPointer();
   };
 
   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)};
   };
 
   std::function<Documentation(Record *)> DocumentationForGroup =
       [&](Record *R) -> Documentation {
     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;
       Documentation &Base = D.Groups.back();
       Base = DocumentationForGroup(G);
     }
 
     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));
 
     return D;
   };
 
   return DocumentationForGroup(nullptr);
 }

utils/TableGen/NeonEmitter.cpp

if (CartesianProductOfTypes) {
           continue;
         NewTypeSpecs.push_back(std::make_pair(TS, SrcTS));
       }
     } else {
       NewTypeSpecs.push_back(std::make_pair(TS, TS));
     }
   }
 
-  llvm::sort(NewTypeSpecs.begin(), NewTypeSpecs.end());
+  llvm::sort(NewTypeSpecs);
   NewTypeSpecs.erase(std::unique(NewTypeSpecs.begin(), NewTypeSpecs.end()),
          NewTypeSpecs.end());
   auto &Entry = IntrinsicMap[Name];
 
   for (auto &I : NewTypeSpecs) {
     Entry.emplace_back(R, Name, Proto, I.first, I.second, CK, Body, *this,
                        Guard, IsUnavailable, BigEndianSafe);
     Out.push_back(&Entry.back());