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

Summary: The convenience wrapper in STLExtras is available since rL342102.

Reviewers: dblaikie, javed.absar, JDevlieghere, andreadb

Subscribers: MatzeB, sanjoy, arsenm, dschuff, mehdi_amini, sdardis, nemanjai, jvesely, nhaehnle, sbc100, jgravelle-google, eraman, aheejin, kbarton, JDevlieghere, javed.absar, gbedwell, jrtc27, mgrang, atanasyan, steven_wu, george.burgess.iv, dexonsmith, kristina, jsji, llvm-commits

Differential Revision: https://reviews.llvm.org/D52573

llvm-svn: 343163

1 files changed, 64 insertions, 67 deletions

diff --git a/llvm/tools/llvm-xray/xray-account.cpp b/llvm/tools/llvm-xray/xray-account.cpp
index 77de1de496f..93bb271b328 100644
--- a/llvm/tools/llvm-xray/xray-account.cpp
+++ b/llvm/tools/llvm-xray/xray-account.cpp
@@ -282,79 +282,76 @@ void LatencyAccountant::exportStats(const XRayFileHeader &Header, F Fn) const {
   // Sort the data according to user-provided flags.
   switch (AccountSortOutput) {
   case SortField::FUNCID:
-    llvm::sort(Results.begin(), Results.end(),
-               [](const TupleType &L, const TupleType &R) {
-                 if (AccountSortOrder == SortDirection::ASCENDING)
-                   return std::get<0>(L) < std::get<0>(R);
-                 if (AccountSortOrder == SortDirection::DESCENDING)
-                   return std::get<0>(L) > std::get<0>(R);
-                 llvm_unreachable("Unknown sort direction");
-               });
+    llvm::sort(Results, [](const TupleType &L, const TupleType &R) {
+      if (AccountSortOrder == SortDirection::ASCENDING)
+        return std::get<0>(L) < std::get<0>(R);
+      if (AccountSortOrder == SortDirection::DESCENDING)
+        return std::get<0>(L) > std::get<0>(R);
+      llvm_unreachable("Unknown sort direction");
+    });
     break;
   case SortField::COUNT:
-    llvm::sort(Results.begin(), Results.end(),
-               [](const TupleType &L, const TupleType &R) {
-                 if (AccountSortOrder == SortDirection::ASCENDING)
-                   return std::get<1>(L) < std::get<1>(R);
-                 if (AccountSortOrder == SortDirection::DESCENDING)
-                   return std::get<1>(L) > std::get<1>(R);
-                 llvm_unreachable("Unknown sort direction");
-               });
+    llvm::sort(Results, [](const TupleType &L, const TupleType &R) {
+      if (AccountSortOrder == SortDirection::ASCENDING)
+        return std::get<1>(L) < std::get<1>(R);
+      if (AccountSortOrder == SortDirection::DESCENDING)
+        return std::get<1>(L) > std::get<1>(R);
+      llvm_unreachable("Unknown sort direction");
+    });
     break;
   default:
     // Here we need to look into the ResultRow for the rest of the data that
     // we want to sort by.
-    llvm::sort(Results.begin(), Results.end(),
-               [&](const TupleType &L, const TupleType &R) {
-                 auto &LR = std::get<2>(L);
-                 auto &RR = std::get<2>(R);
-                 switch (AccountSortOutput) {
-                 case SortField::COUNT:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Count < RR.Count;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Count > RR.Count;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::MIN:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Min < RR.Min;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Min > RR.Min;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::MED:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Median < RR.Median;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Median > RR.Median;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::PCT90:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Pct90 < RR.Pct90;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Pct90 > RR.Pct90;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::PCT99:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Pct99 < RR.Pct99;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Pct99 > RR.Pct99;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::MAX:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Max < RR.Max;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Max > RR.Max;
-                   llvm_unreachable("Unknown sort direction");
-                 case SortField::SUM:
-                   if (AccountSortOrder == SortDirection::ASCENDING)
-                     return LR.Sum < RR.Sum;
-                   if (AccountSortOrder == SortDirection::DESCENDING)
-                     return LR.Sum > RR.Sum;
-                   llvm_unreachable("Unknown sort direction");
-                 default:
-                   llvm_unreachable("Unsupported sort order");
-                 }
-               });
+    llvm::sort(Results, [&](const TupleType &L, const TupleType &R) {
+      auto &LR = std::get<2>(L);
+      auto &RR = std::get<2>(R);
+      switch (AccountSortOutput) {
+      case SortField::COUNT:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Count < RR.Count;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Count > RR.Count;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::MIN:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Min < RR.Min;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Min > RR.Min;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::MED:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Median < RR.Median;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Median > RR.Median;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::PCT90:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Pct90 < RR.Pct90;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Pct90 > RR.Pct90;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::PCT99:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Pct99 < RR.Pct99;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Pct99 > RR.Pct99;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::MAX:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Max < RR.Max;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Max > RR.Max;
+        llvm_unreachable("Unknown sort direction");
+      case SortField::SUM:
+        if (AccountSortOrder == SortDirection::ASCENDING)
+          return LR.Sum < RR.Sum;
+        if (AccountSortOrder == SortDirection::DESCENDING)
+          return LR.Sum > RR.Sum;
+        llvm_unreachable("Unknown sort direction");
+      default:
+        llvm_unreachable("Unsupported sort order");
+      }
+    });
     break;
   }