merge main into amd-staging

Author: ronlieb

clang-tools-extra/clang-tidy/llvm/CMakeLists.txt

@@ -12,6 +12,7 @@ add_clang_library(clangTidyLLVMModule STATIC
   PreferStaticOverAnonymousNamespaceCheck.cpp
   TwineLocalCheck.cpp
   UseNewMLIROpBuilderCheck.cpp
+  UseRangesCheck.cpp
 
   LINK_LIBS
   clangTidy

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

@@ -19,6 +19,7 @@
 #include "PreferStaticOverAnonymousNamespaceCheck.h"
 #include "TwineLocalCheck.h"
 #include "UseNewMLIROpBuilderCheck.h"
+#include "UseRangesCheck.h"
 
 namespace clang::tidy {
 namespace llvm_check {
@@ -43,6 +44,7 @@ class LLVMModule : public ClangTidyModule {
     CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
     CheckFactories.registerCheck<UseNewMlirOpBuilderCheck>(
         "llvm-use-new-mlir-op-builder");
+    CheckFactories.registerCheck<UseRangesCheck>("llvm-use-ranges");
   }
 
   ClangTidyOptions getModuleOptions() override {

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

@@ -0,0 +1,97 @@
+//===--- 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"
+
+namespace clang::tidy::llvm_check {
+
+namespace {
+
+class StdToLLVMReplacer : public utils::UseRangesCheck::Replacer {
+public:
+  explicit StdToLLVMReplacer(
+      ArrayRef<utils::UseRangesCheck::Signature> Signatures)
+      : Signatures(Signatures) {}
+
+  ArrayRef<utils::UseRangesCheck::Signature>
+  getReplacementSignatures() const override {
+    return Signatures;
+  }
+
+  std::optional<std::string>
+  getReplaceName(const NamedDecl &OriginalName) const override {
+    return ("llvm::" + OriginalName.getName()).str();
+  }
+
+  std::optional<std::string>
+  getHeaderInclusion(const NamedDecl &) const override {
+    return "llvm/ADT/STLExtras.h";
+  }
+
+private:
+  ArrayRef<utils::UseRangesCheck::Signature> Signatures;
+};
+
+} // namespace
+
+utils::UseRangesCheck::ReplacerMap UseRangesCheck::getReplacerMap() const {
+  ReplacerMap Results;
+
+  static const Signature SingleSig = {{0}};
+  static const Signature TwoSig = {{0}, {2}};
+
+  const auto AddStdToLLVM =
+      [&Results](llvm::IntrusiveRefCntPtr<Replacer> Replacer,
+                 std::initializer_list<StringRef> Names) {
+        for (const auto &Name : Names) {
+          Results.try_emplace(("::std::" + Name).str(), Replacer);
+        }
+      };
+
+  // Single range algorithms
+  AddStdToLLVM(llvm::makeIntrusiveRefCnt<StdToLLVMReplacer>(SingleSig),
+               {"all_of",      "any_of",
+                "none_of",     "for_each",
+                "find",        "find_if",
+                "find_if_not", "fill",
+                "count",       "count_if",
+                "copy",        "copy_if",
+                "transform",   "replace",
+                "remove_if",   "stable_sort",
+                "partition",   "partition_point",
+                "is_sorted",   "min_element",
+                "max_element", "binary_search",
+                "lower_bound", "upper_bound",
+                "unique",      "uninitialized_copy"});
+
+  // Two range algorithms
+  AddStdToLLVM(llvm::makeIntrusiveRefCnt<StdToLLVMReplacer>(TwoSig),
+               {"equal", "mismatch", "includes"});
+
+  return Results;
+}
+
+UseRangesCheck::UseRangesCheck(StringRef Name, ClangTidyContext *Context)
+    : utils::UseRangesCheck(Name, Context) {}
+
+DiagnosticBuilder UseRangesCheck::createDiag(const CallExpr &Call) {
+  return diag(Call.getBeginLoc(), "use an LLVM range-based algorithm");
+}
+
+ArrayRef<std::pair<StringRef, StringRef>>
+UseRangesCheck::getFreeBeginEndMethods() const {
+  static constexpr std::pair<StringRef, StringRef> Refs[] = {
+      {"::std::begin", "::std::end"},
+      {"::std::cbegin", "::std::cend"},
+      {"::std::rbegin", "::std::rend"},
+      {"::std::crbegin", "::std::crend"},
+  };
+  return Refs;
+}
+
+} // namespace clang::tidy::llvm_check

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

@@ -0,0 +1,33 @@
+//===--- 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_LLVM_USERANGESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_USERANGESCHECK_H
+
+#include "../utils/UseRangesCheck.h"
+
+namespace clang::tidy::llvm_check {
+
+/// Finds calls to STL iterator algorithms that can be replaced with LLVM
+/// range-based algorithms from `llvm/ADT/STLExtras.h`.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/llvm/use-ranges.html
+class UseRangesCheck : public utils::UseRangesCheck {
+public:
+  UseRangesCheck(StringRef Name, ClangTidyContext *Context);
+
+  ReplacerMap getReplacerMap() const override;
+  DiagnosticBuilder createDiag(const CallExpr &Call) override;
+  ArrayRef<std::pair<StringRef, StringRef>>
+  getFreeBeginEndMethods() const override;
+};
+
+} // namespace clang::tidy::llvm_check
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_USERANGESCHECK_H

clang-tools-extra/clang-tidy/tool/clang-tidy-diff.py

@@ -258,6 +258,11 @@ def main():
         help="Upgrades clang-tidy warnings to errors. Same format as '-checks'.",
         default="",
     )
+    parser.add_argument(
+        "-hide-progress",
+        action="store_true",
+        help="Hide progress",
+    )
 
     clang_tidy_args = []
     argv = sys.argv[1:]
@@ -312,7 +317,8 @@ def main():
     if max_task_count == 0:
         max_task_count = multiprocessing.cpu_count()
     max_task_count = min(len(lines_by_file), max_task_count)
-    print(f"Running clang-tidy in {max_task_count} threads...")
+    if not args.hide_progress:
+        print(f"Running clang-tidy in {max_task_count} threads...")
 
     combine_fixes = False
     export_fixes_dir = None
@@ -408,7 +414,8 @@ def main():
         return_code = 1
 
     if combine_fixes:
-        print("Writing fixes to " + args.export_fixes + " ...")
+        if not args.hide_progress:
+            print(f"Writing fixes to {args.export_fixes} ...")
         try:
             merge_replacement_files(export_fixes_dir, args.export_fixes)
         except:

clang-tools-extra/clang-tidy/tool/run-clang-tidy.py

@@ -576,6 +576,11 @@ async def main() -> None:
         action="store_true",
         help="Enable per-check timing profiles, and print a report",
     )
+    parser.add_argument(
+        "-hide-progress",
+        action="store_true",
+        help="Hide progress",
+    )
     args = parser.parse_args()
 
     db_path = "compile_commands.json"
@@ -681,13 +686,11 @@ async def main() -> None:
     file_name_re = re.compile("|".join(args.files))
     files = {f for f in files if file_name_re.search(f)}
 
-    print(
-        f"Running clang-tidy in {max_task} threads for",
-        len(files),
-        "files out of",
-        number_files_in_database,
-        "in compilation database ...",
-    )
+    if not args.hide_progress:
+        print(
+            f"Running clang-tidy in {max_task} threads for {len(files)} files "
+            f"out of {number_files_in_database} in compilation database ..."
+        )
 
     returncode = 0
     semaphore = asyncio.Semaphore(max_task)
@@ -716,13 +719,15 @@ async def main() -> None:
                     result.stderr += f"{result.filename}: terminated by signal {-result.returncode}\n"
             progress = f"[{i + 1: >{len(f'{len(files)}')}}/{len(files)}]"
             runtime = f"[{result.elapsed:.1f}s]"
-            print(f"{progress}{runtime} {' '.join(result.invocation)}")
+            if not args.hide_progress:
+                print(f"{progress}{runtime} {' '.join(result.invocation)}")
             if result.stdout:
                 print(result.stdout, end=("" if result.stderr else "\n"))
             if result.stderr:
                 print(result.stderr)
     except asyncio.CancelledError:
-        print("\nCtrl-C detected, goodbye.")
+        if not args.hide_progress:
+            print("\nCtrl-C detected, goodbye.")
         for task in tasks:
             task.cancel()
         if delete_fixes_dir:
@@ -742,7 +747,8 @@ async def main() -> None:
             print("No profiling data found.")
 
     if combine_fixes:
-        print(f"Writing fixes to {args.export_fixes} ...")
+        if not args.hide_progress:
+            print(f"Writing fixes to {args.export_fixes} ...")
         try:
             assert export_fixes_dir
             merge_replacement_files(export_fixes_dir, args.export_fixes)
@@ -752,7 +758,8 @@ async def main() -> None:
             returncode = 1
 
     if args.fix:
-        print("Applying fixes ...")
+        if not args.hide_progress:
+            print("Applying fixes ...")
         try:
             assert export_fixes_dir
             apply_fixes(args, clang_apply_replacements_binary, export_fixes_dir)

clang-tools-extra/docs/ReleaseNotes.rst

@@ -135,6 +135,10 @@ Improvements to clang-tidy
   :program:`clang-tidy-20`. Users should use the check-specific options of the
   same name instead.
 
+- Improved :program:`run-clang-tidy.py` and :program:`clang-tidy-diff.py` 
+  scripts by adding the `-hide-progress` option to suppress progress and
+  informational messages.
+
 New checks
 ^^^^^^^^^^
 
@@ -157,6 +161,12 @@ New checks
   Checks for uses of MLIR's old/to be deprecated ``OpBuilder::create<T>`` form
   and suggests using ``T::create`` instead.
 
+- New :doc:`llvm-use-ranges
+  <clang-tidy/checks/llvm/use-ranges>` check.
+
+  Finds calls to STL library iterator algorithms that could be replaced with
+  LLVM range-based algorithms from ``llvm/ADT/STLExtras.h``.
+
 - New :doc:`misc-override-with-different-visibility
   <clang-tidy/checks/misc/override-with-different-visibility>` check.
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -249,12 +249,13 @@ Clang-Tidy Checks
    :doc:`linuxkernel-must-check-errs <linuxkernel/must-check-errs>`,
    :doc:`llvm-header-guard <llvm/header-guard>`,
    :doc:`llvm-include-order <llvm/include-order>`, "Yes"
-   :doc:`llvm-use-new-mlir-op-builder <llvm/use-new-mlir-op-builder>`, "Yes"
    :doc:`llvm-namespace-comment <llvm/namespace-comment>`,
    :doc:`llvm-prefer-isa-or-dyn-cast-in-conditionals <llvm/prefer-isa-or-dyn-cast-in-conditionals>`, "Yes"
    :doc:`llvm-prefer-register-over-unsigned <llvm/prefer-register-over-unsigned>`, "Yes"
    :doc:`llvm-prefer-static-over-anonymous-namespace <llvm/prefer-static-over-anonymous-namespace>`,
    :doc:`llvm-twine-local <llvm/twine-local>`, "Yes"
+   :doc:`llvm-use-new-mlir-op-builder <llvm/use-new-mlir-op-builder>`, "Yes"
+   :doc:`llvm-use-ranges <llvm/use-ranges>`, "Yes"
    :doc:`llvmlibc-callee-namespace <llvmlibc/callee-namespace>`,
    :doc:`llvmlibc-implementation-in-namespace <llvmlibc/implementation-in-namespace>`,
    :doc:`llvmlibc-inline-function-decl <llvmlibc/inline-function-decl>`, "Yes"

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

@@ -0,0 +1,61 @@
+.. title:: clang-tidy - llvm-use-ranges
+
+llvm-use-ranges
+===============
+
+Finds calls to STL library iterator algorithms that could be replaced with
+LLVM range-based algorithms from ``llvm/ADT/STLExtras.h``.
+
+Example
+-------
+
+.. code-block:: c++
+
+  auto it = std::find(vec.begin(), vec.end(), value);
+  bool all = std::all_of(vec.begin(), vec.end(), 
+                         [](int x) { return x > 0; });
+
+Transforms to:
+
+.. code-block:: c++
+
+  auto it = llvm::find(vec, value);
+  bool all = llvm::all_of(vec, [](int x) { return x > 0; });
+
+Supported algorithms
+--------------------
+
+Calls to the following STL algorithms are checked:
+
+``std::all_of``,
+``std::any_of``,
+``std::binary_search``,
+``std::copy``,
+``std::copy_if``,
+``std::count``,
+``std::count_if``,
+``std::equal``,
+``std::fill``,
+``std::find``,
+``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::stable_sort``,
+``std::transform``,
+``std::uninitialized_copy``,
+``std::unique``,
+``std::upper_bound``.
+
+The check will add the necessary ``#include "llvm/ADT/STLExtras.h"`` directive
+when applying fixes.