adjust supported algorithms and convert llvm -> LLVM

Author: vbvictor

clang-tools-extra/clang-tidy/llvm/UseRangesCheck.cpp

@@ -55,16 +55,19 @@ utils::UseRangesCheck::ReplacerMap UseRangesCheck::getReplacerMap() const {
 
   // Single range algorithms
   AddStdToLLVM(llvm::makeIntrusiveRefCnt<StdToLLVMReplacer>(SingleSig),
-               {"all_of",      "any_of",        "none_of",     "for_each",
-                "find",        "find_if",       "find_if_not", "count",
-                "count_if",    "transform",     "replace",     "remove_if",
-                "sort",        "partition",     "is_sorted",   "min_element",
-                "max_element", "binary_search", "lower_bound", "upper_bound",
-                "unique",      "copy",          "copy_if",     "fill"});
+               {"all_of",        "any_of",      "none_of",
+                "for_each",      "find",        "find_if",
+                "find_if_not",   "count",       "count_if",
+                "transform",     "replace",     "remove_if",
+                "stable_sort",   "partition",   "partition_point",
+                "is_sorted",     "min_element", "max_element",
+                "binary_search", "lower_bound", "upper_bound",
+                "unique",        "copy",        "copy_if",
+                "fill"});
 
   // Two range algorithms
   AddStdToLLVM(llvm::makeIntrusiveRefCnt<StdToLLVMReplacer>(TwoSig),
-               {"equal", "mismatch"});
+               {"equal", "mismatch", "includes"});
 
   return Results;
 }
@@ -73,7 +76,7 @@ UseRangesCheck::UseRangesCheck(StringRef Name, ClangTidyContext *Context)
     : utils::UseRangesCheck(Name, Context) {}
 
 DiagnosticBuilder UseRangesCheck::createDiag(const CallExpr &Call) {
-  return diag(Call.getBeginLoc(), "use a llvm range-based algorithm");
+  return diag(Call.getBeginLoc(), "use a LLVM range-based algorithm");
 }
 
 ArrayRef<std::pair<StringRef, StringRef>>

clang-tools-extra/docs/clang-tidy/checks/llvm/use-ranges.rst

@@ -40,16 +40,18 @@ Calls to the following ``std`` library algorithms are checked:
 ``std::find_if``,
 ``std::find_if_not``,
 ``std::for_each``,
+``std::includes``,
 ``std::is_sorted``,
 ``std::lower_bound``,
 ``std::max_element``,
 ``std::min_element``,
 ``std::mismatch``,
 ``std::none_of``,
 ``std::partition``,
+``std::partition_point``,
 ``std::remove_if``,
 ``std::replace``,
-``std::sort``,
+``std::stable_sort``,
 ``std::transform``,
 ``std::unique``,
 ``std::upper_bound``.

clang-tools-extra/test/clang-tidy/checkers/llvm/use-ranges.cpp

@@ -27,6 +27,9 @@ InputIt find(InputIt first, InputIt last, const T &value);
 template <class RandomIt>
 void sort(RandomIt first, RandomIt last);
 
+template <class RandomIt>
+void stable_sort(RandomIt first, RandomIt last);
+
 template <class InputIt, class UnaryPredicate>
 bool all_of(InputIt first, InputIt last, UnaryPredicate p);
 
@@ -60,6 +63,9 @@ ForwardIt unique(ForwardIt first, ForwardIt last);
 template <class ForwardIt>
 bool is_sorted(ForwardIt first, ForwardIt last);
 
+template <class InputIt1, class InputIt2>
+bool includes(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2);
+
 } // namespace std
 
 bool is_even(int x);
@@ -70,54 +76,61 @@ void test_positive() {
   int arr[5] = {1, 2, 3, 4, 5};
 
   auto it1 = std::find(vec.begin(), vec.end(), 3);
-  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: auto it1 = llvm::find(vec, 3);
 
   auto it2 = std::find(std::begin(arr), std::end(arr), 3);
-  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: auto it2 = llvm::find(arr, 3);
 
-  std::sort(vec.begin(), vec.end());
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a llvm range-based algorithm
-  // CHECK-FIXES: llvm::sort(vec);
+  std::stable_sort(vec.begin(), vec.end());
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a LLVM range-based algorithm
+  // CHECK-FIXES: llvm::stable_sort(vec);
 
   bool all = std::all_of(vec.begin(), vec.end(), is_even);
-  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: bool all = llvm::all_of(vec, is_even);
 
   std::for_each(vec.begin(), vec.end(), double_ref);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: llvm::for_each(vec, double_ref);
 
   auto min_it = std::min_element(vec.begin(), vec.end());
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: auto min_it = llvm::min_element(vec);
 
   std::vector<int> vec2;
   bool eq = std::equal(vec.begin(), vec.end(), vec2.begin(), vec2.end());
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: bool eq = llvm::equal(vec, vec2);
 
   std::copy(vec.begin(), vec.end(), vec2.begin());
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: llvm::copy(vec, vec2.begin());
 
   std::fill(vec.begin(), vec.end(), 0);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: llvm::fill(vec, 0);
 
   auto last = std::unique(vec.begin(), vec.end());
-  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: auto last = llvm::unique(vec);
 
   bool sorted = std::is_sorted(vec.begin(), vec.end());
-  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a llvm range-based algorithm
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a LLVM range-based algorithm
   // CHECK-FIXES: bool sorted = llvm::is_sorted(vec);
+
+  std::includes(vec.begin(), vec.end(), std::begin(arr), std::end(arr));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a LLVM range-based algorithm
+  // CHECK-FIXES: llvm::includes(vec, arr);
 }
 
 void test_negative() {
   std::vector<int> v;
 
+  // can not use `llvm::sort` because of potential different ordering from `std::sort`.
+  std::sort(v.begin(), v.end());
+
   //non-begin/end iterators
   auto it1 = std::find(v.begin() + 1, v.end(), 2);
   auto it2 = std::find(v.begin(), v.end() - 1, 2);