Use the range-based overload of llvm::sort where possible

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

for (const auto &D : TU.Diagnostics)
         for (const auto &Fix : *ChoosenFix)
           for (const tooling::Replacement &R : Fix.second)
             AddToGroup(R, &TU, D.BuildDirectory);
       }
 
   // Sort replacements per file to keep consistent behavior when
   // clang-apply-replacements run on differents machine.
   for (auto &FileAndReplacements : GroupedReplacements) {
-    llvm::sort(FileAndReplacements.second.begin(),
-               FileAndReplacements.second.end());
+    llvm::sort(FileAndReplacements.second);
   }
 
   return GroupedReplacements;
 }
 
 bool mergeAndDeduplicate(const TUReplacements &TUs, const TUDiagnostics &TUDs,
                          FileToChangesMap &FileChanges,
                          clang::SourceManager &SM, bool IgnoreInsertConflict) {

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

for (const auto &Symbol : Symbols) {
     // with the current file and the popularity of the symbol.
     double NewScore = similarityScore(FileName, Symbol.Symbol.getFilePath()) *
                       (1.0 + std::log2(1 + Symbol.Signals.Seen));
     double &S = Score[Symbol.Symbol.getFilePath()];
     S = std::max(S, NewScore);
   }
   // Sort by the gathered scores. Use file name as a tie breaker so we can
   // deduplicate.
-  llvm::sort(Symbols.begin(), Symbols.end(),
+  llvm::sort(Symbols,
              [&](const SymbolAndSignals &A, const SymbolAndSignals &B) {
                auto AS = Score[A.Symbol.getFilePath()];
                auto BS = Score[B.Symbol.getFilePath()];
                if (AS != BS)
                  return AS > BS;
                return A.Symbol.getFilePath() < B.Symbol.getFilePath();
              });
 }

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.cpp

for (const auto &InputValue : IgnoredFloatingPointValuesInput) {
 
       llvm::APFloat DoubleValue(llvm::APFloat::IEEEdouble());
       StatusOrErr =
           DoubleValue.convertFromString(InputValue, DefaultRoundingMode);
       assert(StatusOrErr && "Invalid floating point representation");
       consumeError(StatusOrErr.takeError());
       IgnoredDoublePointValues.push_back(DoubleValue.convertToDouble());
     }
-    llvm::sort(IgnoredFloatingPointValues.begin(),
-               IgnoredFloatingPointValues.end());
-    llvm::sort(IgnoredDoublePointValues.begin(),
-               IgnoredDoublePointValues.end());
+    llvm::sort(IgnoredFloatingPointValues);
+    llvm::sort(IgnoredDoublePointValues);
   }
 }
 
 void MagicNumbersCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreAllFloatingPointValues",
                 IgnoreAllFloatingPointValues);
   Options.store(Opts, "IgnoreBitFieldsWidths", IgnoreBitFieldsWidths);
   Options.store(Opts, "IgnorePowersOf2IntegerValues",

clang-tools-extra/clangd/index/StdLib.cpp

std::string buildUmbrella(llvm::StringLiteral Mandatory,
   // stdlib version that don't have headers for the newest language standards.
   // But make sure we get *some* error if things are totally broken.
   OS << llvm::formatv(
       "#if !__has_include(<{0}>)\n"
       "#error Mandatory header <{0}> not found in standard library!\n"
       "#endif\n",
       Mandatory);
 
-  llvm::sort(Headers.begin(), Headers.end());
+  llvm::sort(Headers);
   auto Last = std::unique(Headers.begin(), Headers.end());
   for (auto Header = Headers.begin(); Header != Last; ++Header) {
     OS << llvm::formatv("#if __has_include({0})\n"
                         "#include {0}\n"
                         "#endif\n",
                         *Header);
   }
   OS.flush();

clang/include/clang/Basic/Attr.td

void getAddedFeatures(llvm::SmallVectorImpl<StringRef> &Out) const {
             !Feature.startswith("fpmath=") && !Feature.startswith("tune="))
           Out.push_back(Feature);
       }
     }
 
     template<class Compare>
     ParsedTargetAttr parse(Compare cmp) const {
       ParsedTargetAttr Attrs = parse();
-      llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp);
+      llvm::sort(Attrs.Features, cmp);
       return Attrs;
     }
 
     bool isDefaultVersion() const { return getFeaturesStr() == "default"; }
 
     static ParsedTargetAttr parse(StringRef Features) {
       ParsedTargetAttr Ret;
       if (Features == "default") return Ret;

clang/lib/Driver/Multilib.cpp

bool MultilibSet::select(const Multilib::flags_list &Flags, Multilib &M) const {
   if (Filtered.empty())
     return false;
   if (Filtered.size() == 1) {
     M = Filtered[0];
     return true;
   }
 
   // Sort multilibs by priority and select the one with the highest priority.
-  llvm::sort(Filtered.begin(), Filtered.end(),
-             [](const Multilib &a, const Multilib &b) -> bool {
-               return a.priority() > b.priority();
-             });
+  llvm::sort(Filtered, [](const Multilib &a, const Multilib &b) -> bool {
 
   if (Filtered[0].priority() > Filtered[1].priority()) {
     M = Filtered[0];
     return true;
   }
 
   // TODO: We should consider returning llvm::Error rather than aborting.
   assert(false && "More than one multilib with the same priority");

clang/lib/Frontend/FrontendAction.cpp

for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
       Headers.push_back(std::make_pair(RelName, *Header));
     }
 
     if (EC)
       return EC;
 
     // Sort header paths and make the header inclusion order deterministic
     // across different OSs and filesystems.
-    llvm::sort(Headers.begin(), Headers.end(), llvm::less_first());
+    llvm::sort(Headers, llvm::less_first());
     for (auto &H : Headers) {
       // Include this header as part of the umbrella directory.
       Module->addTopHeader(H.second);
       addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
     }
   }
 
   // Recurse into submodules.

 }
 bool WrapperFrontendAction::hasCodeCompletionSupport() const {
   return WrappedAction->hasCodeCompletionSupport();
 }
 
 WrapperFrontendAction::WrapperFrontendAction(
     std::unique_ptr<FrontendAction> WrappedAction)
   : WrappedAction(std::move(WrappedAction)) {}
-

clang/lib/Sema/AnalysisBasedWarnings.cpp

for (const auto &P : uses) {
         DiagnoseUninitializedUse(S, vd,
                                  UninitUse(vd->getInit()->IgnoreParenCasts(),
                                            /* isAlwaysUninit */ true),
                                  /* alwaysReportSelfInit */ true);
       else {
         // Sort the uses by their SourceLocations.  While not strictly
         // guaranteed to produce them in line/column order, this will provide
         // a stable ordering.
-        llvm::sort(vec->begin(), vec->end(),
-                   [](const UninitUse &a, const UninitUse &b) {
+        llvm::sort(*vec, [](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();
           return a.getUser()->getBeginLoc() < b.getUser()->getBeginLoc();
         });
 
         for (const auto &U : *vec) {
           // If we have self-init, downgrade all uses to 'may be uninitialized'.

lldb/source/Interpreter/OptionValueArray.cpp

if (argc > 0) {
           remove_indexes.push_back(idx);
       }
 
       if (all_indexes_valid) {
         size_t num_remove_indexes = remove_indexes.size();
         if (num_remove_indexes) {
           // Sort and then erase in reverse so indexes are always valid
           if (num_remove_indexes > 1) {
-            llvm::sort(remove_indexes.begin(), remove_indexes.end());
+            llvm::sort(remove_indexes);
             for (std::vector<int>::const_reverse_iterator
                      pos = remove_indexes.rbegin(),
                      end = remove_indexes.rend();
                  pos != end; ++pos) {
               m_values.erase(m_values.begin() + *pos);
             }
           } else {
             // Only one index

lldb/source/Interpreter/OptionValueFileSpecList.cpp

if (argc > 0) {
         else
           remove_indexes.push_back(idx);
       }
 
       if (all_indexes_valid) {
         size_t num_remove_indexes = remove_indexes.size();
         if (num_remove_indexes) {
           // Sort and then erase in reverse so indexes are always valid
-          llvm::sort(remove_indexes.begin(), remove_indexes.end());
+          llvm::sort(remove_indexes);
           for (size_t j = num_remove_indexes - 1; j < num_remove_indexes; ++j) {
             m_current_value.Remove(j);
           }
         }
         NotifyValueChanged();
       } else {
         error.SetErrorStringWithFormat(
             "invalid array index '%s', aborting remove operation",

lldb/source/Interpreter/OptionValuePathMappings.cpp

if (argc > 0) {
               "invalid array index '%s', aborting remove operation",
               args.GetArgumentAtIndex(i));
           break;
         } else
           remove_indexes.push_back(idx);
       }
 
       // Sort and then erase in reverse so indexes are always valid
-      llvm::sort(remove_indexes.begin(), remove_indexes.end());
+      llvm::sort(remove_indexes);
       for (auto index : llvm::reverse(remove_indexes))
         m_path_mappings.Remove(index, m_notify_changes);
       NotifyValueChanged();
     } else {
       error.SetErrorString("remove operation takes one or more array index");
     }
     break;
 
   case eVarSetOperationInvalid:
     error = OptionValue::SetValueFromString(value, op);
     break;
   }
   return error;
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
   // DenseMap with a pointer as the key type, this means we cannot simply
   // iterate over the map, as the order will be non-deterministic.  Instead we
   // have to sort by the offset and then insert in sorted order.
   typedef llvm::DenseMap<const D *, O> MapType;
   typedef typename MapType::value_type PairType;
   std::vector<PairType> sorted_items;
   sorted_items.reserve(source_map.size());
   sorted_items.assign(source_map.begin(), source_map.end());
-  llvm::sort(sorted_items.begin(), sorted_items.end(),
-             [](const PairType &lhs, const PairType &rhs) {
-               return lhs.second < rhs.second;
-             });
+  llvm::sort(sorted_items, [](const PairType &lhs, const PairType &rhs) {
 
   for (const auto &item : sorted_items) {
     DeclFromUser<D> user_decl(const_cast<D *>(item.first));
     DeclFromParser<D> parser_decl(user_decl.Import(source));
     if (parser_decl.IsInvalid())
       return false;
     destination_map.insert(
         std::pair<const D *, O>(parser_decl.decl, item.second));

lldb/source/Symbol/ArmUnwindInfo.cpp

while (m_arm_exidx_data.ValidOffset(offset)) {
     lldb::addr_t addr = exidx_base_addr + (addr_t)offset +
                         Prel31ToAddr(m_arm_exidx_data.GetU32(&offset));
     uint32_t data = m_arm_exidx_data.GetU32(&offset);
     m_exidx_entries.emplace_back(file_addr, addr, data);
   }
 
   // Sort the entries in the exidx section. The entries should be sorted inside
   // the section but some old compiler isn't sorted them.
-  llvm::sort(m_exidx_entries.begin(), m_exidx_entries.end());
+  llvm::sort(m_exidx_entries);
 }
 
 ArmUnwindInfo::~ArmUnwindInfo() = default;
 
 // Read a byte from the unwind instruction stream with the given offset. Custom
 // function is required because have to red in order of significance within
 // their containing word (most significant byte first) and in increasing word
 // address order.

lldb/source/Symbol/CompileUnit.cpp

 }
 
 void CompileUnit::ForeachFunction(
     llvm::function_ref<bool(const FunctionSP &)> lambda) const {
   std::vector<lldb::FunctionSP> sorted_functions;
   sorted_functions.reserve(m_functions_by_uid.size());
   for (auto &p : m_functions_by_uid)
     sorted_functions.push_back(p.second);
-  llvm::sort(sorted_functions.begin(), sorted_functions.end(),
+  llvm::sort(sorted_functions,
              [](const lldb::FunctionSP &a, const lldb::FunctionSP &b) {
                return a->GetID() < b->GetID();
              });
 
   for (auto &f : sorted_functions)
     if (lambda(f))
       return;
 }

lldb/source/Symbol/Symtab.cpp

if (name_type_mask & type) {
       for (match = map.FindFirstValueForName(name); match != nullptr;
            match = map.FindNextValueForName(match)) {
         symbol_indexes.push_back(match->value);
       }
     }
   }
 
   if (!symbol_indexes.empty()) {
-    llvm::sort(symbol_indexes.begin(), symbol_indexes.end());
+    llvm::sort(symbol_indexes);
     symbol_indexes.erase(
         std::unique(symbol_indexes.begin(), symbol_indexes.end()),
         symbol_indexes.end());
     SymbolIndicesToSymbolContextList(symbol_indexes, sc_list);
   }
 }
 
 const Symbol *Symtab::GetParent(Symbol *child_symbol) const {

lldb/source/Target/DynamicRegisterInfo.cpp

void DynamicRegisterInfo::Finalize(const ArchSpec &arch) {
   }
 
   // sort and unique all invalidate registers and make sure each is terminated
   // with LLDB_INVALID_REGNUM
   for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
                                  end = m_invalidate_regs_map.end();
        pos != end; ++pos) {
     if (pos->second.size() > 1) {
-      llvm::sort(pos->second.begin(), pos->second.end());
+      llvm::sort(pos->second);
       reg_num_collection::iterator unique_end =
           std::unique(pos->second.begin(), pos->second.end());
       if (unique_end != pos->second.end())
         pos->second.erase(unique_end, pos->second.end());
     }
     assert(!pos->second.empty());
     if (pos->second.back() != LLDB_INVALID_REGNUM)
       pos->second.push_back(LLDB_INVALID_REGNUM);

lldb/source/Target/Target.cpp

for (auto bp_sp : *expected_vector)
     bp_name.ConfigureBreakpoint(bp_sp);
 }
 
 void Target::GetBreakpointNames(std::vector<std::string> &names) {
   names.clear();
   for (auto bp_name : m_breakpoint_names) {
     names.push_back(bp_name.first.AsCString());
   }
-  llvm::sort(names.begin(), names.end());
+  llvm::sort(names);
 }
 
 bool Target::ProcessIsValid() {
   return (m_process_sp && m_process_sp->IsAlive());
 }
 
 static bool CheckIfWatchpointsSupported(Target *target, Status &error) {
   uint32_t num_supported_hardware_watchpoints;

lldb/source/Utility/ReproducerProvider.cpp

 void SymbolFileProvider::Keep() {
   FileSpec file = this->GetRoot().CopyByAppendingPathComponent(Info::file);
   std::error_code ec;
   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_TextWithCRLF);
   if (ec)
     return;
 
   // Remove duplicates.
-  llvm::sort(m_symbol_files.begin(), m_symbol_files.end());
+  llvm::sort(m_symbol_files);
   m_symbol_files.erase(
       std::unique(m_symbol_files.begin(), m_symbol_files.end()),
       m_symbol_files.end());
 
   llvm::yaml::Output yout(os);
   yout << m_symbol_files;
 }
 

lldb/source/Utility/Timer.cpp

if (nanos) {
       Stats stats{i->m_name, nanos, nanos_total, count};
       sorted.push_back(stats);
     }
   }
   if (sorted.empty())
     return; // Later code will break without any elements.
 
   // Sort by time
-  llvm::sort(sorted.begin(), sorted.end(), CategoryMapIteratorSortCriterion);
+  llvm::sort(sorted, CategoryMapIteratorSortCriterion);
 
   for (const auto &stats : sorted)
     s->Printf("%.9f sec (total: %.3fs; child: %.3fs; count: %" PRIu64
               ") for %s\n",
               stats.nanos / 1000000000., stats.nanos_total / 1000000000.,
               (stats.nanos_total - stats.nanos) / 1000000000., stats.count,
               stats.name);
 }

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

while (!Parser.done()) {
 
       DWARFDebugLine::LineTable LT =
           Parser.parseNext(RecoverableErrorHandler, UnrecoverableErrorHandler);
       Result &= collectLineTableSources(LT, /*CompDir=*/"", Sources);
     }
   }
 
   // Dedup and order the sources.
-  llvm::sort(Sources.begin(), Sources.end());
+  llvm::sort(Sources);
   Sources.erase(std::unique(Sources.begin(), Sources.end()), Sources.end());
 
   for (StringRef Name : Sources)
     OS << Name << "\n";
   return Result;
 }
 
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx,

llvm/unittests/ADT/SmallPtrSetTest.cpp

TEST(SmallPtrSetTest, dereferenceAndIterate) {
   // Iterate from each and count how many times each element is found.
   int Found[sizeof(Ints)/sizeof(int)] = {0};
   for (int &I : Ints)
     for (auto F = S.find(&I), E = S.end(); F != E; ++F)
       ++Found[*F - Ints];
 
   // Sort.  We should hit the first element just once and the final element N
   // times.
-  llvm::sort(std::begin(Found), std::end(Found));
+  llvm::sort(Found);
   for (auto F = std::begin(Found), E = std::end(Found); F != E; ++F)
     EXPECT_EQ(F - Found + 1, *F);
 }
 
 // Verify that const pointers work for count and find even when the underlying
 // SmallPtrSet is not for a const pointer type.
 TEST(SmallPtrSetTest, ConstTest) {
   SmallPtrSet<int *, 8> IntSet;

llvm/unittests/TextAPI/TextStubV1Tests.cpp

TEST(TBDv1, ReadFile) {
   ExportedSymbolSeq Exports;
   for (const auto *Sym : File->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
     EXPECT_FALSE(Sym->isUndefined());
     Exports.emplace_back(
         ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
                        Sym->isWeakDefined(), Sym->isThreadLocalValue()});
   }
-  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Exports);
 
   EXPECT_EQ(sizeof(TBDv1Symbols) / sizeof(ExportedSymbol), Exports.size());
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv1Symbols)));
 
   File->addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1", {Targets[1]});
   File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
                   {Targets[1]});

llvm/unittests/TextAPI/TextStubV2Tests.cpp

TEST(TBDv2, ReadFile) {
   ExportedSymbolSeq Exports;
   for (const auto *Sym : File->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
     EXPECT_FALSE(Sym->isUndefined());
     Exports.emplace_back(
         ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
                        Sym->isWeakDefined(), Sym->isThreadLocalValue()});
   }
-  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Exports);
 
   EXPECT_EQ(sizeof(TBDv2Symbols) / sizeof(ExportedSymbol), Exports.size());
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv2Symbols)));
 }
 
 TEST(TBDv2, ReadFile2) {
   static const char TBDv2File2[] =

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, ReadFile) {
   ExportedSymbolSeq Exports;
   for (const auto *Sym : File->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
     EXPECT_FALSE(Sym->isUndefined());
     Exports.emplace_back(
         ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
                        Sym->isWeakDefined(), Sym->isThreadLocalValue()});
   }
-  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Exports);
 
   EXPECT_EQ(sizeof(TBDv3Symbols) / sizeof(ExportedSymbol), Exports.size());
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv3Symbols)));
 }
 
 TEST(TBDv3, ReadMultipleDocuments) {
   static const char TBDv3Inlines[] =
TEST(TBDv3, ReadMultipleDocuments) {
   ExportedSymbolSeq Exports;
   for (const auto *Sym : File->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
     EXPECT_FALSE(Sym->isUndefined());
     Exports.emplace_back(ExportedSymbol{Sym->getKind(), Sym->getName().str(),
                                         Sym->isWeakDefined(),
                                         Sym->isThreadLocalValue()});
   }
-  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Exports);
 
   EXPECT_EQ(sizeof(TBDv3Symbols) / sizeof(ExportedSymbol), Exports.size());
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv3Symbols)));
 
   // Check Second Document
   Exports.clear();
   TBDReexportFile Document = File->documents().front();
   EXPECT_EQ(FileType::TBD_V3, Document->getFileType());
   EXPECT_EQ(Archs, Document->getArchitectures());
   EXPECT_EQ(Uuids, Document->uuids());
   EXPECT_EQ(Platform, *Document->getPlatforms().begin());
   EXPECT_EQ(std::string("TestInline.dylib"), Document->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), Document->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), Document->getCompatibilityVersion());
   EXPECT_EQ(2U, Document->getSwiftABIVersion());
 
   for (const auto *Sym : Document->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
     EXPECT_FALSE(Sym->isUndefined());
     Exports.emplace_back(ExportedSymbol{Sym->getKind(), Sym->getName().str(),
                                         Sym->isWeakDefined(),
                                         Sym->isThreadLocalValue()});
   }
-  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Exports);
 
   ExportedSymbolSeq DocumentSymbols{
       {SymbolKind::GlobalSymbol, "_sym5", false, false},
       {SymbolKind::GlobalSymbol, "_sym6", false, false},
   };
 
   EXPECT_EQ(DocumentSymbols.size(), Exports.size());
   EXPECT_TRUE(

llvm/unittests/TextAPI/TextStubV4Tests.cpp

temp = ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
                           Sym->isWeakDefined(), Sym->isThreadLocalValue()};
     EXPECT_FALSE(Sym->isWeakReferenced());
     if (Sym->isUndefined())
       Undefineds.emplace_back(std::move(temp));
     else
       Sym->isReexported() ? Reexports.emplace_back(std::move(temp))
                           : Exports.emplace_back(std::move(temp));
   }
-  llvm::sort(Exports.begin(), Exports.end());
-  llvm::sort(Reexports.begin(), Reexports.end());
-  llvm::sort(Undefineds.begin(), Undefineds.end());
+  llvm::sort(Exports);
+  llvm::sort(Reexports);
+  llvm::sort(Undefineds);
 
   static ExportedSymbol ExpectedExportedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symA", false, false},
       {SymbolKind::GlobalSymbol, "_symAB", false, false},
       {SymbolKind::GlobalSymbol, "_symB", false, false},
   };
 
   static ExportedSymbol ExpectedReexportedSymbols[] = {
ExportedSymbol Temp =
                        Sym->isWeakDefined(), Sym->isThreadLocalValue()};
     EXPECT_FALSE(Sym->isWeakReferenced());
     if (Sym->isUndefined())
       Undefineds.emplace_back(std::move(Temp));
     else
       Sym->isReexported() ? Reexports.emplace_back(std::move(Temp))
                           : Exports.emplace_back(std::move(Temp));
   }
-  llvm::sort(Exports.begin(), Exports.end());
-  llvm::sort(Reexports.begin(), Reexports.end());
-  llvm::sort(Undefineds.begin(), Undefineds.end());
+  llvm::sort(Exports);
+  llvm::sort(Reexports);
+  llvm::sort(Undefineds);
 
   static ExportedSymbol ExpectedExportedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symA", false, false},
       {SymbolKind::GlobalSymbol, "_symAB", false, false},
   };
 
   static ExportedSymbol ExpectedReexportedSymbols[] = {
       {SymbolKind::GlobalSymbol, "_symC", false, false},