scripts: add "clippy" internal tool

Similar to the "ninja scan-build" target for C, add a clippy internal
tool that runs clippy-driver on all crates in the project.

The approach used is more efficient than with "ninja scan-build", and
does not require rerunning Meson in a separate build directory; it
uses the introspection data to find the compiler arguments for the
target and invokes clippy-driver with a slightly modified command
line.

This could actually be applied to scan-build as well, reusing the
run_tool_on_targets() function.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

2 files changed, 77 insertions, 0 deletions

diff --git a/mesonbuild/scripts/clippy.py b/mesonbuild/scripts/clippy.py
new file mode 100644
index 000000000..a5161462c
--- /dev/null
+++ b/mesonbuild/scripts/clippy.py
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 The Meson development team
+
+from __future__ import annotations
+from collections import defaultdict
+import os
+import tempfile
+import typing as T
+
+from .run_tool import run_tool_on_targets, run_with_buffered_output
+from .. import build, mlog
+from ..mesonlib import MachineChoice, PerMachine
+
+if T.TYPE_CHECKING:
+    from ..compilers.rust import RustCompiler
+
+class ClippyDriver:
+    def __init__(self, build: build.Build, tempdir: str):
+        self.tools: PerMachine[T.List[str]] = PerMachine([], [])
+        self.warned: T.DefaultDict[str, bool] = defaultdict(lambda: False)
+        self.tempdir = tempdir
+        for machine in MachineChoice:
+            compilers = build.environment.coredata.compilers[machine]
+            if 'rust' in compilers:
+                compiler = T.cast('RustCompiler', compilers['rust'])
+                self.tools[machine] = compiler.get_rust_tool('clippy-driver', build.environment)
+
+    def warn_missing_clippy(self, machine: str) -> None:
+        if self.warned[machine]:
+            return
+        mlog.warning(f'clippy-driver not found for {machine} machine')
+        self.warned[machine] = True
+
+    def __call__(self, target: T.Dict[str, T.Any]) -> T.Iterable[T.Coroutine[None, None, int]]:
+        for src_block in target['target_sources']:
+            if src_block['language'] == 'rust':
+                clippy = getattr(self.tools, src_block['machine'])
+                if not clippy:
+                    self.warn_missing_clippy(src_block['machine'])
+                    continue
+
+                cmdlist = list(clippy)
+                prev = None
+                for arg in src_block['parameters']:
+                    if prev:
+                        prev = None
+                        continue
+                    elif arg in {'--emit', '--out-dir'}:
+                        prev = arg
+                    else:
+                        cmdlist.append(arg)
+
+                cmdlist.extend(src_block['sources'])
+                # the default for --emit is to go all the way to linking,
+                # and --emit dep-info= is not enough for clippy to do
+                # enough analysis, so use --emit metadata.
+                cmdlist.append('--emit')
+                cmdlist.append('metadata')
+                cmdlist.append('--out-dir')
+                cmdlist.append(self.tempdir)
+                yield run_with_buffered_output(cmdlist)
+
+def run(args: T.List[str]) -> int:
+    os.chdir(args[0])
+    build_data = build.load(os.getcwd())
+    with tempfile.TemporaryDirectory() as d:
+        return run_tool_on_targets(ClippyDriver(build_data, d))
diff --git a/mesonbuild/scripts/run_tool.py b/mesonbuild/scripts/run_tool.py
index bccc4cb83..e206ff7fe 100644
--- a/mesonbuild/scripts/run_tool.py
+++ b/mesonbuild/scripts/run_tool.py
@@ -6,6 +6,7 @@ from __future__ import annotations
 import asyncio.subprocess
 import fnmatch
 import itertools
+import json
 import signal
 import sys
 from pathlib import Path
@@ -126,3 +127,12 @@ def run_clang_tool(name: str, srcdir: Path, builddir: Path, fn: T.Callable[...,
     def wrapper(path: Path) -> T.Iterable[T.Coroutine[None, None, int]]:
         yield fn(path, *args)
     return asyncio.run(_run_workers(all_clike_files(name, srcdir, builddir), wrapper))
+
+def run_tool_on_targets(fn: T.Callable[[T.Dict[str, T.Any]],
+                                       T.Iterable[T.Coroutine[None, None, int]]]) -> int:
+    if sys.platform == 'win32':
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+
+    with open('meson-info/intro-targets.json', encoding='utf-8') as fp:
+        targets = json.load(fp)
+    return asyncio.run(_run_workers(targets, fn))