add clippy-json target

Add a clippy-json target to the ninja script.

This is useful for rust-analyzer, which requires an "external check
command" to function when not using cargo.

Also we add a "clippy-json-prereq" target, and invoke it in the
clippy.py script. The prereq target tries to build as much of the
project as possible with "-k0".

Author: Jturnerusa

docs/markdown/Rust.md

@@ -91,6 +91,13 @@ write files into the source directory). [See the upstream
 docs](https://rust-analyzer.github.io/book/non_cargo_based_projects.html) for
 more information on how to configure that.
 
+### Clippy
+You can use the "clippy-json" build target as rust-analyer's "check command" to recieve clippy diagnostics in your editor. 
+
+Without overriding the check command, the LSP will function in a limited state, only showing certain errors (for example, no borrow checking errors are shown).
+
+[Non cargo based projects](https://rust-analyzer.github.io/book/non_cargo_based_projects.html) shows how to override the check command, you probably want to set it to `ninja clippy-json -C build`.
+
 ## Linking with standard libraries
 
 Meson will link the Rust standard libraries (e.g. libstd) statically, unless the

docs/markdown/snippets/clippy-json.md

@@ -0,0 +1,9 @@
+# New "clippy-json" Ninja Target For rust-analyzer
+
+A new `clippy-json` ninja target will now be generated for rust projects.
+
+rust-analyzer supports non-cargo based projects so long as you provide it with a `rust-project.json` file and a custom "check command" to provide compiler errors.
+
+Meson already for some time has generated a `rust-project.json` file for rust-analyzer, but had no way to hook up its rustc/clippy output to rust-analyzer.
+
+To use the new feature, you want to override the rust-analyzer check command as shown [here](https://rust-analyzer.github.io/book/non_cargo_based_projects.html), and set it to `ninja clippy-json -C build` or something to the same effect.

mesonbuild/backend/ninjabackend.py

@@ -3947,6 +3947,28 @@ def generate_clippy(self) -> None:
         elem.add_dep(list(self.all_structured_sources))
         self.add_build(elem)
 
+    def generate_clippy_json_prereq(self) -> None:
+        if 'clippy-json-prereq' in self.all_outputs or not self.have_language('rust'):
+            return
+
+        elem = self.create_phony_target('clippy-json-prereq', 'CUSTOM_COMMAND', 'PHONY')
+        for crate in self.rust_crates.values():
+            if crate.crate_type in {'rlib', 'dylib', 'proc-macro'}:
+                elem.add_dep(crate.target_name)
+        elem.add_dep(list(self.all_structured_sources))
+        self.add_build(elem)
+
+    def generate_clippy_json(self) -> None:
+        if 'clippy-json' in self.all_outputs or not self.have_language('rust'):
+            return
+
+        cmd = self.environment.get_build_command() + \
+            ['--internal', 'clippy', self.environment.build_dir, '--error-format=json']
+        elem = self.create_phony_target('clippy-json', 'CUSTOM_COMMAND', 'PHONY')
+        elem.add_item('COMMAND', cmd)
+        elem.add_item('pool', 'console')
+        self.add_build(elem)
+
     def generate_rustdoc(self) -> None:
         if 'rustdoc' in self.all_outputs or not self.have_language('rust'):
             return
@@ -4036,6 +4058,8 @@ def generate_utils(self) -> None:
         self.generate_clangformat()
         self.generate_clangtidy()
         self.generate_clippy()
+        self.generate_clippy_json_prereq()
+        self.generate_clippy_json()
         self.generate_rustdoc()
         self.generate_tags('etags', 'TAGS')
         self.generate_tags('ctags', 'ctags')

mesonbuild/scripts/clippy.py

@@ -6,16 +6,18 @@
 import os
 import tempfile
 import typing as T
+import subprocess
 
 from .run_tool import run_tool_on_targets, run_with_buffered_output
 from .. import build, mlog
 from ..mesonlib import MachineChoice, PerMachine
+from ..tooldetect import detect_ninja
 
 if T.TYPE_CHECKING:
     from ..compilers.rust import RustCompiler
 
 class ClippyDriver:
-    def __init__(self, build: build.Build, tempdir: str):
+    def __init__(self, build: build.Build, tempdir: str, args: list[str]):
         self.tools: PerMachine[T.List[str]] = PerMachine([], [])
         self.warned: T.DefaultDict[str, bool] = defaultdict(lambda: False)
         self.tempdir = tempdir
@@ -24,6 +26,7 @@ def __init__(self, build: build.Build, tempdir: str):
             if 'rust' in compilers:
                 compiler = T.cast('RustCompiler', compilers['rust'])
                 self.tools[machine] = compiler.get_rust_tool('clippy-driver')
+        self.args = args
 
     def warn_missing_clippy(self, machine: str) -> None:
         if self.warned[machine]:
@@ -67,10 +70,17 @@ def __call__(self, target: T.Dict[str, T.Any]) -> T.Iterable[T.Coroutine[None, N
                 cmdlist.append('metadata')
                 cmdlist.append('--out-dir')
                 cmdlist.append(self.tempdir)
+                cmdlist += self.args
                 yield run_with_buffered_output(cmdlist)
 
 def run(args: T.List[str]) -> int:
     os.chdir(args[0])
     build_data = build.load(os.getcwd())
+
+    # Build as much of the project as possible, or else
+    # we get errors about missing libraries in the build directory and
+    # other related errors.
+    subprocess.run(detect_ninja() + ['clippy-json-prereq', '-k0'])
+
     with tempfile.TemporaryDirectory() as d:
-        return run_tool_on_targets(ClippyDriver(build_data, d))
+        return run_tool_on_targets(ClippyDriver(build_data, d, args[1:]))