Add clippy support

Author: UebelAndre

docs/src/rust_analyzer.md

@@ -75,7 +75,11 @@ Re-runnable at any time. Global flags work on any subcommand.
 | `--workspace <path>` | Workspace root. Defaults to `$BUILD_WORKSPACE_DIRECTORY` (set by `bazel run`). |
 | `--skip-proc-macro-server` | Don't manage the proc-macro key. |
 | `--skip-rustfmt` | Don't manage the formatter key (use host rustfmt). |
-| `--per-package-workspaces` | Opt in to per-package workspace splitting (see below). |
+| `--per-package-workspaces` / `--no-per-package-workspaces` | Opt this developer in/out of per-package workspace splitting (see below). |
+| `--clippy` / `--no-clippy` | Opt this developer in/out of running clippy on save and streaming its diagnostics alongside rustc's. |
+| `--clean` | Delete `<launcher-dir>/cache/` before running the rest of setup. See Troubleshooting. |
+
+The `--clippy` and `--per-package-workspaces` toggles are **per-user**: they mutate `<launcher-dir>/user_config.json` (gitignored) instead of the shared committed settings file. Two developers on the same workspace can hold different preferences without touching the checked-in configuration. Editing `user_config.json` by hand works too.
 
 The `vscode` subcommand adds:
 
@@ -102,14 +106,13 @@ The `vscode` subcommand adds:
 ### Symbols / deps look wrong
 
 Restart rust-analyzer (or save a `BUILD` file). If that doesn't fix
-it, clear the discovery cache and try again:
+it, re-run setup with `--clean` to nuke the discovery cache:
 
 ```
-rm -rf <workspace>/<editor-dir>/.rules_rust_analyzer/cache
+bazel run @rules_rust//tools/rust_analyzer:setup -- --clean vscode
 ```
 
-`<editor-dir>` is `.vscode` for VSCode, `.helix` for Helix, or empty
-for Neovim / `print`.
+Works with any subcommand (`vscode` / `neovim` / `helix` / `print`).
 
 ### Diagnostics stopped appearing
 
@@ -119,6 +122,25 @@ Check `<workspace>/.rules_rust_analyzer/flycheck.log`.
 
 Re-run `setup`.
 
+### Noisy `cargo metadata` errors on startup
+
+`setup` does not manage `rust-analyzer.files.excludeDirs`. If your
+workspace has stub `Cargo.toml` files that aren't meant to be
+auto-loaded (common in `rules_rust` itself under `examples/`,
+`crate_universe/`, etc.), rust-analyzer still finds them and logs
+errors. Silence them by adding the directory names to `settings.json`
+yourself — your entries survive future `setup` runs:
+
+```
+"rust-analyzer.files.excludeDirs": ["examples", "some_other_dir"]
+```
+
+Trade-off: `files.excludeDirs` also hides those sources from
+rust-analyzer's virtual filesystem, so files under those directories
+won't get IDE features even if they're part of a Bazel-discovered
+crate. Only exclude directories whose sources you're willing to lose
+IDE support on.
+
 ## Workspace splitting
 
 By default the whole project is treated as a single workspace.

tools/rust_analyzer/bep.rs

@@ -27,6 +27,12 @@ pub const SPEC_OUTPUT_GROUP: &str = "rust_analyzer_crate_spec";
 /// [`generate_output_diagnostics`] in `rust/private/utils.bzl`.
 pub const RUSTC_OUTPUT_GROUP: &str = "rustc_output";
 
+/// Output group clippy-emitted diagnostics land in when
+/// `--@rules_rust//rust/settings:clippy_output_diagnostics=true` is set,
+/// under the `rust_clippy_aspect`. Each entry is a per-crate
+/// `.clippy.diagnostics` file. See `rust/private/clippy.bzl`.
+pub const CLIPPY_OUTPUT_GROUP: &str = "clippy_output";
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct BuildEvent {

tools/rust_analyzer/bin/discover_rust_project.rs

@@ -12,8 +12,8 @@ use camino::{Utf8Path, Utf8PathBuf};
 use clap::Parser;
 use env_logger::{fmt::Formatter, Target, WriteStyle};
 use gen_rust_project_lib::{
-    bazel_info, generate_rust_project, DiscoverProject, RustAnalyzerArg, BUILD_FILE_NAMES,
-    WORKSPACE_ROOT_FILE_NAMES,
+    bazel_info, generate_rust_project, install_dir, user_config, DiscoverProject, RustAnalyzerArg,
+    BUILD_FILE_NAMES, WORKSPACE_ROOT_FILE_NAMES,
 };
 use log::{LevelFilter, Record};
 
@@ -42,11 +42,32 @@ fn project_discovery() -> anyhow::Result<DiscoverProject<'static>> {
         rust_analyzer_argument,
     } = Config::parse()?;
 
+    // Per-user, per-workspace preferences. Rendered
+    // `discoverConfig.command` is intentionally identical for every
+    // developer — clippy and per-package-workspaces toggles live in
+    // `<launcher_dir>/user_config.json` (see `user_config.rs`).
+    let user = user_config::load(&install_dir()?);
+    log::info!(
+        "user config: clippy={} per_package_workspaces={}",
+        user.clippy,
+        user.per_package_workspaces
+    );
+
     log::info!("got rust-analyzer argument: {rust_analyzer_argument:?}");
 
-    let ra_arg = match rust_analyzer_argument {
-        Some(ra_arg) => ra_arg,
-        None => RustAnalyzerArg::Buildfile(find_workspace_root_file(&workspace)?),
+    // When per-package-workspaces is off, the rust-analyzer-provided
+    // arg is discarded and we always emit the whole-workspace project.
+    // The rendered `{arg}` template stays in the discover command
+    // regardless — this keeps the shared settings byte-identical, at
+    // the cost of an occasional cache-hit-only re-invocation of
+    // discover on file open.
+    let ra_arg = if user.per_package_workspaces {
+        match rust_analyzer_argument {
+            Some(ra_arg) => ra_arg,
+            None => RustAnalyzerArg::Buildfile(find_workspace_root_file(&workspace)?),
+        }
+    } else {
+        RustAnalyzerArg::Buildfile(find_workspace_root_file(&workspace)?)
     };
 
     let rules_rust_name = env!("ASPECT_REPOSITORY");
@@ -68,6 +89,7 @@ fn project_discovery() -> anyhow::Result<DiscoverProject<'static>> {
         &bazel_args,
         rules_rust_name,
         &[targets],
+        user.clippy,
     )?;
 
     Ok(DiscoverProject::Finished { buildfile, project })

tools/rust_analyzer/bin/flycheck.rs

@@ -27,7 +27,7 @@ use std::{
 use anyhow::{Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
 use clap::Parser;
-use gen_rust_project_lib::bep;
+use gen_rust_project_lib::{bep, install_dir, user_config};
 use serde_json::Value;
 
 #[derive(Parser, Debug)]
@@ -87,8 +87,16 @@ fn run() -> Result<u8> {
     std::fs::create_dir_all(&output_user_root)
         .with_context(|| format!("creating output_user_root {output_user_root}"))?;
 
-    let status = Command::new(args.bazel.as_str())
-        .current_dir(&workspace)
+    // Per-user preferences live in `<launcher_dir>/user_config.json`.
+    // Clippy mode is a per-user opt-in there — the shared discover
+    // command doesn't decide it — so we consult the config on every
+    // save rather than baking the choice into flycheck's argv.
+    let user = user_config::load(&install_dir()?);
+
+    // Assemble the bazel command. Clippy mode adds the aspect and
+    // its diagnostics output group on top of the base build flags.
+    let mut cmd = Command::new(args.bazel.as_str());
+    cmd.current_dir(&workspace)
         // BUILD_WORKSPACE_DIRECTORY / BUILD_WORKING_DIRECTORY leak in from
         // the outer `bazel run` invocation and would confuse the nested
         // bazel client; clear them so the nested call rediscovers the
@@ -109,19 +117,39 @@ fn run() -> Result<u8> {
         .arg("--@rules_rust//rust/settings:rustc_output_diagnostics=true")
         .arg(format!("--output_groups=+{}", bep::RUSTC_OUTPUT_GROUP))
         .arg("--keep_going")
-        .arg(format!("--build_event_json_file={bep_path}"))
+        .arg(format!("--build_event_json_file={bep_path}"));
+    if user.clippy {
+        cmd.arg("--aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect")
+            // Diagnostics go to a declared `.clippy.diagnostics` file per
+            // crate, exposed via the `clippy_output` output group. Without
+            // this flag the aspect only emits a marker file, so we'd have
+            // nowhere to read clippy JSON from.
+            .arg("--@rules_rust//rust/settings:clippy_output_diagnostics=true")
+            .arg(format!("--output_groups=+{}", bep::CLIPPY_OUTPUT_GROUP));
+    }
+    let status = cmd
         .status()
         .with_context(|| format!("invoking {}", args.bazel))?;
 
-    let stderr_files = match bep::parse_action_stderr_paths(&bep_path) {
+    let mut diagnostic_files = match bep::parse_action_stderr_paths(&bep_path) {
         Ok(paths) => paths,
         Err(e) => {
             eprintln!("flycheck: parsing BEP failed: {e:#}");
             Vec::new()
         }
     };
+    if user.clippy {
+        // Additive: the `clippy_output` group holds `.clippy.diagnostics`
+        // files that action-stderr harvesting doesn't cover (clippy's JSON
+        // goes to the declared file, not stderr, when
+        // `clippy_output_diagnostics=true`).
+        match bep::parse_output_group_paths(&bep_path, bep::CLIPPY_OUTPUT_GROUP) {
+            Ok(paths) => diagnostic_files.extend(paths),
+            Err(e) => eprintln!("flycheck: parsing clippy_output group failed: {e:#}"),
+        }
+    }
 
-    emit_diagnostics(&stderr_files, &workspace)?;
+    emit_diagnostics(&diagnostic_files, &workspace)?;
 
     // Forward Bazel's exit code so rust-analyzer can tell apart "build
     // succeeded with diagnostics" from "build tool itself broke".

tools/rust_analyzer/bin/gen_rust_project.rs

@@ -30,6 +30,7 @@ fn write_rust_project() -> anyhow::Result<()> {
         &bazel_args,
         rules_rust_name,
         &targets,
+        false,
     )?;
 
     let rust_project_path = &workspace.join("rust-project.json");