[clang-tools-extra] Add checks to convert std library iterator algorithms into c++20 or boost ranges (PR #97764)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Jul 4 13:46:13 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-tools-extra
Author: Nathan James (njames93)
<details>
<summary>Changes</summary>
---
Patch is 48.09 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/97764.diff
17 Files Affected:
- (modified) clang-tools-extra/clang-tidy/boost/BoostTidyModule.cpp (+2)
- (modified) clang-tools-extra/clang-tidy/boost/CMakeLists.txt (+1)
- (added) clang-tools-extra/clang-tidy/boost/UseRangesCheck.cpp (+208)
- (added) clang-tools-extra/clang-tidy/boost/UseRangesCheck.h (+34)
- (modified) clang-tools-extra/clang-tidy/modernize/CMakeLists.txt (+1)
- (modified) clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp (+2)
- (added) clang-tools-extra/clang-tidy/modernize/UseRangesCheck.cpp (+148)
- (added) clang-tools-extra/clang-tidy/modernize/UseRangesCheck.h (+31)
- (modified) clang-tools-extra/clang-tidy/utils/CMakeLists.txt (+1)
- (added) clang-tools-extra/clang-tidy/utils/UseRangesCheck.cpp (+253)
- (added) clang-tools-extra/clang-tidy/utils/UseRangesCheck.h (+58)
- (modified) clang-tools-extra/docs/ReleaseNotes.rst (+12)
- (added) clang-tools-extra/docs/clang-tidy/checks/boost/use-ranges.rst (+24)
- (modified) clang-tools-extra/docs/clang-tidy/checks/list.rst (+2)
- (added) clang-tools-extra/docs/clang-tidy/checks/modernize/use-ranges.rst (+24)
- (added) clang-tools-extra/test/clang-tidy/checkers/boost/use-ranges.cpp (+132)
- (added) clang-tools-extra/test/clang-tidy/checkers/modernize/use-ranges.cpp (+171)
``````````diff
diff --git a/clang-tools-extra/clang-tidy/boost/BoostTidyModule.cpp b/clang-tools-extra/clang-tidy/boost/BoostTidyModule.cpp
index 4c5808daa6ae7..79d0e380e402d 100644
--- a/clang-tools-extra/clang-tidy/boost/BoostTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/boost/BoostTidyModule.cpp
@@ -9,6 +9,7 @@
#include "../ClangTidy.h"
#include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h"
+#include "UseRangesCheck.h"
#include "UseToStringCheck.h"
using namespace clang::ast_matchers;
@@ -18,6 +19,7 @@ namespace boost {
class BoostModule : public ClangTidyModule {
public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+ CheckFactories.registerCheck<UseRangesCheck>("boost-use-ranges");
CheckFactories.registerCheck<UseToStringCheck>("boost-use-to-string");
}
};
diff --git a/clang-tools-extra/clang-tidy/boost/CMakeLists.txt b/clang-tools-extra/clang-tidy/boost/CMakeLists.txt
index 167b6fab774b7..fed3c3ba01c16 100644
--- a/clang-tools-extra/clang-tidy/boost/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/boost/CMakeLists.txt
@@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
add_clang_library(clangTidyBoostModule
BoostTidyModule.cpp
+ UseRangesCheck.cpp
UseToStringCheck.cpp
LINK_LIBS
diff --git a/clang-tools-extra/clang-tidy/boost/UseRangesCheck.cpp b/clang-tools-extra/clang-tidy/boost/UseRangesCheck.cpp
new file mode 100644
index 0000000000000..eb9e9a262d63a
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/boost/UseRangesCheck.cpp
@@ -0,0 +1,208 @@
+//===--- UseRangesCheck.cpp - clang-tidy ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "UseRangesCheck.h"
+#include "clang/AST/Decl.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/StringRef.h"
+#include <initializer_list>
+#include <string>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::boost {
+
+namespace {
+/// Base replacer that handles the boost include path and namespace
+class BoostReplacer : public UseRangesCheck::Replacer {
+public:
+ BoostReplacer(ArrayRef<ArrayRef<Indexes>> Signature, bool IncludeSystem)
+ : Signature(Signature), IncludeSystem(IncludeSystem) {}
+
+ ArrayRef<ArrayRef<Indexes>> getReplacementSignatures() const final {
+ return Signature;
+ }
+
+ virtual std::pair<StringRef, StringRef>
+ getBoostName(const NamedDecl &OriginalName) const = 0;
+ virtual std::pair<StringRef, StringRef>
+ getBoostHeader(const NamedDecl &OriginalName) const = 0;
+
+ std::string getReplaceName(const NamedDecl &OriginalName) const final {
+ auto [Namespace, Function] = getBoostName(OriginalName);
+ return ("boost::" + Namespace + (Namespace.empty() ? "" : "::") + Function)
+ .str();
+ }
+
+ std::optional<std::string>
+ getHeaderInclusion(const NamedDecl &OriginalName) const final {
+ auto [Path, HeaderName] = getBoostHeader(OriginalName);
+ return ((IncludeSystem ? "<boost/" : "boost/") + Path +
+ (Path.empty() ? "" : "/") + HeaderName +
+ (IncludeSystem ? ".hpp>" : ".hpp"))
+ .str();
+ }
+
+private:
+ ArrayRef<ArrayRef<Indexes>> Signature;
+ bool IncludeSystem;
+};
+
+/// Creates replaces where the header file lives in
+/// `boost/algorithm/<FUNC_NAME>.hpp and the function is named
+/// `boost::range::<FUNC_NAME>`
+class BoostRangeAlgorithmReplacer : public BoostReplacer {
+public:
+ using BoostReplacer::BoostReplacer;
+ std::pair<StringRef, StringRef>
+ getBoostName(const NamedDecl &OriginalName) const override {
+ return {"range", OriginalName.getName()};
+ }
+
+ std::pair<StringRef, StringRef>
+ getBoostHeader(const NamedDecl &OriginalName) const override {
+ return {"range/algorithm", OriginalName.getName()};
+ }
+};
+
+/// Creates replaces where the header file lives in
+/// `boost/algorithm/<CUSTOM_HEADER>.hpp and the function is named
+/// `boost::range::<FUNC_NAME>`
+class CustomBoostAlgorithmHeaderReplacer : public BoostRangeAlgorithmReplacer {
+public:
+ CustomBoostAlgorithmHeaderReplacer(StringRef HeaderName,
+ ArrayRef<ArrayRef<Indexes>> Signature,
+ bool IncludeSystem)
+ : BoostRangeAlgorithmReplacer(Signature, IncludeSystem),
+ HeaderName(HeaderName) {}
+
+ std::pair<StringRef, StringRef>
+ getBoostHeader(const NamedDecl & /*OriginalName*/) const override {
+ return {"range/algorithm", HeaderName};
+ }
+
+private:
+ StringRef HeaderName;
+};
+
+/// Creates replaces where the header file lives in
+/// `boost/algorithm/<SUB_HEADER>.hpp and the function is named
+/// `boost::algorithm::<FUNC_NAME>`
+class BoostAlgorithmReplacer : public BoostReplacer {
+public:
+ BoostAlgorithmReplacer(StringRef SubHeader,
+ ArrayRef<ArrayRef<Indexes>> Signature,
+ bool IncludeSystem)
+ : BoostReplacer(Signature, IncludeSystem),
+ SubHeader(("algorithm/" + SubHeader).str()) {}
+ std::pair<StringRef, StringRef>
+ getBoostName(const NamedDecl &OriginalName) const override {
+ return {"algorithm", OriginalName.getName()};
+ }
+
+ std::pair<StringRef, StringRef>
+ getBoostHeader(const NamedDecl &OriginalName) const override {
+ return {SubHeader, OriginalName.getName()};
+ }
+
+ std::string SubHeader;
+};
+
+/// Creates replaces where the header file lives in
+/// `boost/algorithm/<SUB_HEADER>/<HEADER_NAME>.hpp and the function is named
+/// `boost::algorithm::<FUNC_NAME>`
+class CustomBoostAlgorithmReplacer : public BoostReplacer {
+public:
+ CustomBoostAlgorithmReplacer(StringRef SubHeader, StringRef HeaderName,
+ ArrayRef<ArrayRef<Indexes>> Signature,
+ bool IncludeSystem)
+ : BoostReplacer(Signature, IncludeSystem),
+ SubHeader(("algorithm/" + SubHeader).str()), HeaderName(HeaderName) {}
+ std::pair<StringRef, StringRef>
+ getBoostName(const NamedDecl &OriginalName) const override {
+ return {"algorithm", OriginalName.getName()};
+ }
+
+ std::pair<StringRef, StringRef>
+ getBoostHeader(const NamedDecl & /*OriginalName*/) const override {
+ return {SubHeader, HeaderName};
+ }
+
+ std::string SubHeader;
+ StringRef HeaderName;
+};
+
+} // namespace
+
+utils::UseRangesCheck::ReplacerMap UseRangesCheck::GetReplacerMap() const {
+
+ ReplacerMap Results;
+ static const Replacer::Indexes SingleSig[] = {{0}};
+ static const Replacer::Indexes TwoSig[] = {{0}, {2}};
+ static const ArrayRef<Replacer::Indexes> Single = {SingleSig};
+ static const ArrayRef<Replacer::Indexes> Two = {TwoSig};
+ static const auto Add =
+ [&Results](llvm::IntrusiveRefCntPtr<BoostReplacer> Replacer,
+ std::initializer_list<StringRef> Names) {
+ for (const auto &Name : Names) {
+ Results.try_emplace(("::std::" + Name).str(), Replacer);
+ }
+ };
+
+ Add(llvm::makeIntrusiveRefCnt<CustomBoostAlgorithmHeaderReplacer>(
+ "set_algorithm", Two, IncludeBoostSystem),
+ {"includes", "set_union", "set_intersection", "set_difference",
+ "set_symmetric_difference"});
+ Add(llvm::makeIntrusiveRefCnt<BoostRangeAlgorithmReplacer>(
+ Single, IncludeBoostSystem),
+ {"unique", "lower_bound", "stable_sort",
+ "equal_range", "remove_if", "sort",
+ "random_shuffle", "remove_copy", "stable_partition",
+ "remove_copy_if", "count", "copy_backward",
+ "reverse_copy", "adjacent_find", "remove",
+ "upper_bound", "binary_search", "replace_copy_if",
+ "for_each", "generate", "count_if",
+ "min_element", "reverse", "replace_copy",
+ "fill", "unique_copy", "transform",
+ "copy", "replace", "find",
+ "replace_if", "find_if", "partition",
+ "max_element"});
+ Add(llvm::makeIntrusiveRefCnt<BoostRangeAlgorithmReplacer>(
+ Two, IncludeBoostSystem),
+ {"find_end", "merge", "partial_sort_copy", "find_first_of", "search",
+ "lexicographical_compare", "equal", "mismatch"});
+ Add(llvm::makeIntrusiveRefCnt<CustomBoostAlgorithmHeaderReplacer>(
+ "permutation", Single, IncludeBoostSystem),
+ {"next_permutation", "prev_permutation"});
+ Add(llvm::makeIntrusiveRefCnt<CustomBoostAlgorithmHeaderReplacer>(
+ "heap_algorithm", Single, IncludeBoostSystem),
+ {"push_heap", "pop_heap", "make_heap", "sort_heap"});
+ Add(llvm::makeIntrusiveRefCnt<BoostAlgorithmReplacer>("cxx11", Single,
+ IncludeBoostSystem),
+ {"copy_if", "is_permutation", "is_partitioned", "find_if_not",
+ "partition_copy", "any_of", "iota", "all_of", "partition_point",
+ "is_sorted", "none_of"});
+ Add(llvm::makeIntrusiveRefCnt<CustomBoostAlgorithmReplacer>(
+ "cxx11", "is_sorted", Single, IncludeBoostSystem),
+ {"is_sorted_until"});
+ Add(llvm::makeIntrusiveRefCnt<BoostAlgorithmReplacer>("cxx17", Single,
+ IncludeBoostSystem),
+ {"reduce"});
+
+ return Results;
+}
+
+UseRangesCheck::UseRangesCheck(StringRef Name, ClangTidyContext *Context)
+ : utils::UseRangesCheck(Name, Context),
+ IncludeBoostSystem(Options.get("IncludeBoostSystem", true)) {}
+
+void UseRangesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+ utils::UseRangesCheck::storeOptions(Opts);
+ Options.store(Opts, "IncludeBoostSystem", IncludeBoostSystem);
+}
+} // namespace clang::tidy::boost
diff --git a/clang-tools-extra/clang-tidy/boost/UseRangesCheck.h b/clang-tools-extra/clang-tidy/boost/UseRangesCheck.h
new file mode 100644
index 0000000000000..8ae21e2c5262b
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/boost/UseRangesCheck.h
@@ -0,0 +1,34 @@
+//===--- UseRangesCheck.h - clang-tidy --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USERANGESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USERANGESCHECK_H
+
+#include "../utils/UseRangesCheck.h"
+
+namespace clang::tidy::boost {
+
+/// FIXME: Write a short description.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/boost/use-ranges.html
+class UseRangesCheck : public utils::UseRangesCheck {
+public:
+ UseRangesCheck(StringRef Name, ClangTidyContext *Context);
+
+ void storeOptions(ClangTidyOptions::OptionMap &Options) override;
+
+ ReplacerMap GetReplacerMap() const override;
+
+private:
+ bool IncludeBoostSystem;
+};
+
+} // namespace clang::tidy::boost
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USERANGESCHECK_H
diff --git a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
index 576805c4c7f18..4f68c487cac9d 100644
--- a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
@@ -40,6 +40,7 @@ add_clang_library(clangTidyModernizeModule
UseNoexceptCheck.cpp
UseNullptrCheck.cpp
UseOverrideCheck.cpp
+ UseRangesCheck.cpp
UseStartsEndsWithCheck.cpp
UseStdFormatCheck.cpp
UseStdNumbersCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
index b9c7a2dc383e8..1860759332063 100644
--- a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
@@ -41,6 +41,7 @@
#include "UseNoexceptCheck.h"
#include "UseNullptrCheck.h"
#include "UseOverrideCheck.h"
+#include "UseRangesCheck.h"
#include "UseStartsEndsWithCheck.h"
#include "UseStdFormatCheck.h"
#include "UseStdNumbersCheck.h"
@@ -75,6 +76,7 @@ class ModernizeModule : public ClangTidyModule {
CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
CheckFactories.registerCheck<UseDesignatedInitializersCheck>(
"modernize-use-designated-initializers");
+ CheckFactories.registerCheck<UseRangesCheck>("modernize-use-ranges");
CheckFactories.registerCheck<UseStartsEndsWithCheck>(
"modernize-use-starts-ends-with");
CheckFactories.registerCheck<UseStdFormatCheck>("modernize-use-std-format");
diff --git a/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.cpp
new file mode 100644
index 0000000000000..e40428a8217b7
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.cpp
@@ -0,0 +1,148 @@
+//===--- UseRangesCheck.cpp - clang-tidy ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "UseRangesCheck.h"
+#include "clang/AST/Decl.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang::tidy::modernize {
+
+utils::UseRangesCheck::ReplacerMap UseRangesCheck::GetReplacerMap() const {
+ class StdReplacer : public utils::UseRangesCheck::Replacer {
+ public:
+ explicit StdReplacer(ArrayRef<ArrayRef<Indexes>> Indexes)
+ : Indexes(Indexes) {}
+ std::string getReplaceName(const NamedDecl &OriginalName) const override {
+ return ("std::ranges::" + OriginalName.getName()).str();
+ }
+ ArrayRef<ArrayRef<Indexes>> getReplacementSignatures() const override {
+ return Indexes;
+ }
+ std::optional<std::string>
+ getHeaderInclusion(const NamedDecl &OriginalName) const override {
+ return "<algorithm>";
+ }
+
+ private:
+ ArrayRef<ArrayRef<Indexes>> Indexes;
+ };
+ using Indexes = UseRangesCheck::Replacer::Indexes;
+ // using Signatures = Signature[];
+ utils::UseRangesCheck::ReplacerMap Result;
+ // template<typename Iter> Func(Iter first, Iter last,...).
+ static const Indexes SingleRangeArgs[] = {{0}};
+ // template<typename Policy, typename Iter>
+ // Func(Policy policy, Iter first, // Iter last,...).
+ static const Indexes SingleRangeExecPolicy[] = {{1}};
+ // template<typename Iter1, typename Iter2>
+ // Func(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2,...).
+ static const Indexes TwoRangeArgs[] = {{0}, {2}};
+ // template<typename Policy, typename Iter1, typename Iter2>
+ // Func(Policy policy, Iter1 first1, Iter1 last1, Iter2 first2, Iter2
+ // last2,...).
+ static const Indexes TwoRangeExecPolicy[] = {{1}, {3}};
+
+ static const ArrayRef<Indexes> SingleRangeFunc[] = {SingleRangeArgs};
+
+ static const ArrayRef<Indexes> SingleRangeExecFunc[] = {
+ SingleRangeArgs, SingleRangeExecPolicy};
+ static const ArrayRef<Indexes> TwoRangeExecFunc[] = {TwoRangeArgs,
+ TwoRangeExecPolicy};
+ static const ArrayRef<Indexes> OneOrTwoFunc[] = {SingleRangeArgs,
+ TwoRangeArgs};
+ static const ArrayRef<Indexes> OneOrTwoExecFunc[] = {
+ SingleRangeArgs, SingleRangeExecPolicy, TwoRangeArgs, TwoRangeExecPolicy};
+
+ static const std::pair<ArrayRef<ArrayRef<Indexes>>, ArrayRef<StringRef>>
+ Names[] = {
+ {SingleRangeFunc,
+ {"all_of",
+ "any_of",
+ "none_of",
+ "for_each",
+ "find",
+ "find_if",
+ "find_if_not",
+ "adjacent_find",
+ "copy",
+ "copy_if",
+ "copy_backward",
+ "move",
+ "move_backward",
+ "fill",
+ "transform",
+ "replace",
+ "replace_if",
+ "generate",
+ "remove",
+ "remove_if",
+ "remove_copy",
+ "remove_copy_if",
+ "unique",
+ "unique_copy",
+ "sample",
+ "partition_point",
+ "lower_bound",
+ "upper_bound",
+ "equal_range",
+ "binary_search",
+ "push_heap",
+ "pop_heap",
+ "make_heap",
+ "sort_heap",
+ "next_permutation",
+ "prev_permutation",
+ "iota"}},
+ {SingleRangeExecFunc,
+ {"reverse",
+ "reverse_copy",
+ "shift_left",
+ "shift_right",
+ "is_partitioned",
+ "partition",
+ "partition_copy",
+ "stable_partition",
+ "sort",
+ "stable_sort",
+ "is_sorted",
+ "is_sorted_until",
+ "is_heap",
+ "is_heap_until",
+ "max_element",
+ "min_element",
+ "minmax_element",
+ "uninitialized_copy",
+ "uninitialized_fill",
+ "uninitialized_move",
+ "uninitialized_default_construct",
+ "uninitialized_value_construct",
+ "destroy"}},
+ {TwoRangeExecFunc,
+ {"partial_sort_copy", "includes", "set_union", "set_intersection",
+ "set_difference", "set_symmetric_difference", "merge",
+ "lexicographical_compare", "find_end", "search"}},
+ {OneOrTwoFunc, {"is_permutation"}},
+ {OneOrTwoExecFunc, {"equal", "mismatch"}}};
+ SmallString<64> Buff;
+ for (const auto &[Signature, Values] : Names) {
+ auto Replacer = llvm::makeIntrusiveRefCnt<StdReplacer>(Signature);
+ for (const auto &Name : Values) {
+ Buff.clear();
+ Result.try_emplace(("::std::" + Name).toStringRef(Buff), Replacer);
+ }
+ }
+ return Result;
+}
+
+bool UseRangesCheck::isLanguageVersionSupported(
+ const LangOptions &LangOpts) const {
+ return LangOpts.CPlusPlus20;
+}
+} // namespace clang::tidy::modernize
diff --git a/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.h b/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.h
new file mode 100644
index 0000000000000..4cb82016d45cf
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/UseRangesCheck.h
@@ -0,0 +1,31 @@
+//===--- UseRangesCheck.h - clang-tidy --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USERANGESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USERANGESCHECK_H
+
+#include "../utils/UseRangesCheck.h"
+
+namespace clang::tidy::modernize {
+
+/// Detects calls to standard library iterator algorithms that could be
+/// replaced with a ranges version instead
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/use-ranges.html
+class UseRangesCheck : public utils::UseRangesCheck {
+public:
+ using utils::UseRangesCheck::UseRangesCheck;
+
+ ReplacerMap GetReplacerMap() const override;
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USERANGESCHECK_H
diff --git a/clang-tools-extra/clang-tidy/utils/CMakeLists.txt b/clang-tools-extra/clang-tidy/utils/CMakeLists.txt
index 9cff7d475425d..1841ea981359c 100644
--- a/clang-tools-extra/clang-tidy/utils/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/utils/CMakeLists.txt
@@ -26,6 +26,7 @@ add_clang_library(clangTidyUtils
TransformerClangTidyCheck.cpp
TypeTraits.cpp
UsingInserter.cpp
+ UseRangesCheck.cpp
LINK_LIBS
clangTidy
diff --git a/clang-tools-extra/clang-tidy/utils/UseRangesCheck.cpp b...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/97764
More information about the cfe-commits
mailing list