| //! Parse Bazel's Build Event Protocol (BEP) JSON stream to discover the | |
| //! `rust-analyzer` crate spec files produced by `rust_analyzer_aspect`. | |
| //! | |
| //! BEP replaces a separate `bazel aquery` round-trip with a side-effect of | |
| //! the `bazel build` that's already running. The aspect declares its output | |
| //! group; BEP reports each target/aspect completion with the file sets it | |
| //! produced. Walking those is O(events) — much cheaper than rescanning the | |
| //! action graph for the same data. | |
| use std::{ | |
| collections::BTreeMap, | |
| fs::File, | |
| io::{BufRead, BufReader}, | |
| }; | |
| use anyhow::{Context, Result}; | |
| use camino::{Utf8Path, Utf8PathBuf}; | |
| use serde::Deserialize; | |
| /// Output group name the `rust_analyzer_aspect` puts the per-crate spec files | |
| /// in. Must match the key used in [`OutputGroupInfo`] in | |
| /// `rust/private/rust_analyzer.bzl`. | |
| pub const SPEC_OUTPUT_GROUP: &str = "rust_analyzer_crate_spec"; | |
| /// Output group rustc-emitted diagnostics land in when | |
| /// `--@rules_rust//rust/settings:rustc_output_diagnostics=true` is set. See | |
| /// [`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 { | |
| #[serde(default)] | |
| id: Option<EventId>, | |
| #[serde(default)] | |
| named_set_of_files: Option<NamedSetOfFiles>, | |
| #[serde(default)] | |
| completed: Option<Completed>, | |
| #[serde(default)] | |
| action: Option<ActionPayload>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| #[serde(rename_all = "camelCase")] | |
| struct EventId { | |
| #[serde(default)] | |
| named_set: Option<NamedSetId>, | |
| #[serde(default)] | |
| action_completed: Option<ActionCompletedId>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| struct ActionCompletedId {} | |
| #[derive(Debug, Deserialize)] | |
| struct ActionPayload { | |
| #[serde(default)] | |
| stderr: Option<BepFile>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| struct NamedSetId { | |
| id: String, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| #[serde(rename_all = "camelCase")] | |
| struct NamedSetOfFiles { | |
| #[serde(default)] | |
| files: Vec<BepFile>, | |
| #[serde(default)] | |
| file_sets: Vec<FileSetRef>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| struct BepFile { | |
| /// Either `uri` or `name`/`pathPrefix` may be populated depending on | |
| /// Bazel version. We prefer `uri` (a `file://` URL) when available. | |
| #[serde(default)] | |
| uri: Option<String>, | |
| #[serde(default)] | |
| name: Option<String>, | |
| #[serde(default, rename = "pathPrefix")] | |
| path_prefix: Vec<String>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| struct FileSetRef { | |
| id: String, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| #[serde(rename_all = "camelCase")] | |
| struct Completed { | |
| #[serde(default)] | |
| output_group: Vec<OutputGroup>, | |
| } | |
| #[derive(Debug, Deserialize)] | |
| #[serde(rename_all = "camelCase")] | |
| struct OutputGroup { | |
| name: String, | |
| #[serde(default)] | |
| file_sets: Vec<FileSetRef>, | |
| } | |
| /// Read a BEP JSONL file and return every path that appears in the named | |
| /// output group of any completed target or aspect, deduplicated. Paths are | |
| /// absolute on the local filesystem. | |
| pub fn parse_output_group_paths( | |
| bep_path: &Utf8Path, | |
| output_group: &str, | |
| execution_root: &Utf8Path, | |
| ) -> Result<Vec<Utf8PathBuf>> { | |
| let file = File::open(bep_path).with_context(|| format!("opening BEP file {bep_path}"))?; | |
| let reader = BufReader::new(file); | |
| // First pass: collect every named file set and every matching fileset id. | |
| let mut file_sets: BTreeMap<String, NamedSetOfFiles> = BTreeMap::new(); | |
| let mut matching_fileset_ids: Vec<String> = Vec::new(); | |
| for line in reader.lines() { | |
| let line = line.with_context(|| format!("reading BEP file {bep_path}"))?; | |
| if line.is_empty() { | |
| continue; | |
| } | |
| // Skip BEP events we don't recognize rather than failing the whole | |
| // discovery on a forward-compatible field. | |
| let event: BuildEvent = match serde_json::from_str(&line) { | |
| Ok(e) => e, | |
| Err(_) => continue, | |
| }; | |
| if let Some(named_set) = event.named_set_of_files { | |
| if let Some(EventId { | |
| named_set: Some(NamedSetId { id }), | |
| .. | |
| }) = event.id | |
| { | |
| file_sets.insert(id, named_set); | |
| } | |
| } else if let Some(completed) = event.completed { | |
| for group in completed.output_group { | |
| if group.name == output_group { | |
| for fileset in group.file_sets { | |
| matching_fileset_ids.push(fileset.id); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // Walk the named file sets transitively, gathering file URIs. | |
| let mut paths: Vec<Utf8PathBuf> = Vec::new(); | |
| let mut visited: std::collections::BTreeSet<String> = std::collections::BTreeSet::new(); | |
| let mut stack: Vec<String> = matching_fileset_ids; | |
| while let Some(id) = stack.pop() { | |
| if !visited.insert(id.clone()) { | |
| continue; | |
| } | |
| let Some(set) = file_sets.get(&id) else { | |
| continue; | |
| }; | |
| for file in &set.files { | |
| if let Some(path) = file_to_path(file) { | |
| let mut absolute_path = path; | |
| if !absolute_path.is_absolute() { | |
| absolute_path = execution_root.join(absolute_path); | |
| } | |
| paths.push(absolute_path); | |
| } | |
| } | |
| for child in &set.file_sets { | |
| stack.push(child.id.clone()); | |
| } | |
| } | |
| paths.sort(); | |
| paths.dedup(); | |
| Ok(paths) | |
| } | |
| /// Convenience wrapper for the `rust_analyzer_crate_spec` output group used | |
| /// during project discovery. | |
| pub fn parse_spec_paths( | |
| bep_path: &Utf8Path, | |
| execution_root: &Utf8Path, | |
| ) -> Result<Vec<Utf8PathBuf>> { | |
| parse_output_group_paths(bep_path, SPEC_OUTPUT_GROUP, execution_root) | |
| } | |
| /// Return the stderr file path captured for every completed Bazel action | |
| /// in the BEP, regardless of label. With `error_format=json` set on the | |
| /// build, those files contain rustc's machine-readable diagnostics — the | |
| /// only place to read them when the action fails (failed actions don't | |
| /// produce their declared `.rustc-output` artifacts). | |
| /// | |
| /// We deliberately do NOT filter by the saved-file's target label. | |
| /// That matches `cargo check`'s behavior: when a dep of the edited | |
| /// crate fails, cargo surfaces the dep's rustc errors at the dep's | |
| /// file paths, and rust-analyzer renders them there. Filtering by the | |
| /// saved-file's label silently drops every upstream failure, which | |
| /// surfaces in the editor as "no diagnostics anywhere" — the user has | |
| /// no idea why their save produced nothing. | |
| pub fn parse_action_stderr_paths(bep_path: &Utf8Path) -> Result<Vec<Utf8PathBuf>> { | |
| let file = File::open(bep_path).with_context(|| format!("opening BEP file {bep_path}"))?; | |
| let reader = BufReader::new(file); | |
| let mut paths: Vec<Utf8PathBuf> = Vec::new(); | |
| for line in reader.lines() { | |
| let line = line.with_context(|| format!("reading BEP file {bep_path}"))?; | |
| if line.is_empty() { | |
| continue; | |
| } | |
| let event: BuildEvent = match serde_json::from_str(&line) { | |
| Ok(e) => e, | |
| Err(_) => continue, | |
| }; | |
| if event | |
| .id | |
| .as_ref() | |
| .and_then(|i| i.action_completed.as_ref()) | |
| .is_none() | |
| { | |
| continue; | |
| } | |
| let action = match event.action { | |
| Some(a) => a, | |
| None => continue, | |
| }; | |
| if let Some(stderr) = action.stderr { | |
| if let Some(path) = file_to_path(&stderr) { | |
| paths.push(path); | |
| } | |
| } | |
| } | |
| paths.sort(); | |
| paths.dedup(); | |
| Ok(paths) | |
| } | |
| fn file_to_path(file: &BepFile) -> Option<Utf8PathBuf> { | |
| if let Some(uri) = &file.uri { | |
| if let Some(rest) = uri.strip_prefix("file://") { | |
| let decoded = percent_decode(rest); | |
| return Some(Utf8PathBuf::from(strip_uri_drive_prefix(&decoded))); | |
| } | |
| } | |
| // Fallback: reconstruct from pathPrefix + name. Bazel uses this form | |
| // when the file lives in bazel-out and the absolute URI isn't reported. | |
| if let Some(name) = &file.name { | |
| if !file.path_prefix.is_empty() { | |
| let mut path = Utf8PathBuf::from(&file.path_prefix[0]); | |
| for segment in file.path_prefix.iter().skip(1) { | |
| path.push(segment); | |
| } | |
| path.push(name); | |
| return Some(path); | |
| } | |
| } | |
| None | |
| } | |
| /// `file://` URIs on Windows look like `file:///C:/path` — after stripping | |
| /// the `file://` scheme prefix, the result is `/C:/path` where the leading | |
| /// `/` is the URI authority separator, NOT part of the actual filesystem | |
| /// path. Strip it when the next characters are `<drive-letter>:` so the | |
| /// resulting `C:/path` parses as a valid Windows path. | |
| /// | |
| /// Safe on POSIX: a real POSIX file URI `file:///foo/bar` strips to | |
| /// `/foo/bar` which doesn't match the `/<letter>:` shape, so the path | |
| /// passes through unchanged. | |
| fn strip_uri_drive_prefix(s: &str) -> &str { | |
| let bytes = s.as_bytes(); | |
| if bytes.len() >= 3 && bytes[0] == b'/' && bytes[1].is_ascii_alphabetic() && bytes[2] == b':' { | |
| &s[1..] | |
| } else { | |
| s | |
| } | |
| } | |
| fn percent_decode(s: &str) -> String { | |
| let bytes = s.as_bytes(); | |
| let mut out = Vec::with_capacity(bytes.len()); | |
| let mut i = 0; | |
| while i < bytes.len() { | |
| if bytes[i] == b'%' && i + 2 < bytes.len() { | |
| if let (Some(hi), Some(lo)) = (hex_digit(bytes[i + 1]), hex_digit(bytes[i + 2])) { | |
| out.push(hi * 16 + lo); | |
| i += 3; | |
| continue; | |
| } | |
| } | |
| out.push(bytes[i]); | |
| i += 1; | |
| } | |
| // The decoded URI path must be valid UTF-8 on the platforms we support. | |
| String::from_utf8(out).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned()) | |
| } | |
| fn hex_digit(b: u8) -> Option<u8> { | |
| match b { | |
| b'0'..=b'9' => Some(b - b'0'), | |
| b'a'..=b'f' => Some(b - b'a' + 10), | |
| b'A'..=b'F' => Some(b - b'A' + 10), | |
| _ => None, | |
| } | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| #[test] | |
| fn percent_decode_basic() { | |
| assert_eq!(percent_decode("/path/with%20space"), "/path/with space"); | |
| assert_eq!(percent_decode("noop"), "noop"); | |
| assert_eq!(percent_decode("a%2Fb"), "a/b"); | |
| } | |
| #[test] | |
| fn strip_uri_drive_prefix_handles_windows_and_posix() { | |
| // Windows: `file:///C:/path` → after `file://` strip → `/C:/path`. | |
| // The leading `/` is the URI authority separator and must go. | |
| assert_eq!( | |
| strip_uri_drive_prefix("/C:/path/to/file"), | |
| "C:/path/to/file" | |
| ); | |
| assert_eq!(strip_uri_drive_prefix("/D:/other"), "D:/other"); | |
| // POSIX: `file:///foo/bar` → `/foo/bar`. Leading `/` IS the path root. | |
| assert_eq!(strip_uri_drive_prefix("/foo/bar"), "/foo/bar"); | |
| assert_eq!( | |
| strip_uri_drive_prefix("/abs/lib.spec.json"), | |
| "/abs/lib.spec.json" | |
| ); | |
| // Edge cases. | |
| assert_eq!(strip_uri_drive_prefix(""), ""); | |
| assert_eq!(strip_uri_drive_prefix("/"), "/"); | |
| assert_eq!( | |
| strip_uri_drive_prefix("C:/already_clean"), | |
| "C:/already_clean" | |
| ); | |
| } | |
| #[test] | |
| fn parse_spec_paths_resolves_nested_filesets() { | |
| let dir = tempdir(); | |
| let bep_path = dir.join("bep.json"); | |
| std::fs::write( | |
| &bep_path, | |
| r#"{"id":{"namedSet":{"id":"0"}},"namedSetOfFiles":{"files":[{"uri":"file:///abs/foo.rust_analyzer_crate_spec.json"}],"fileSets":[{"id":"1"}]}} | |
| {"id":{"namedSet":{"id":"1"}},"namedSetOfFiles":{"files":[{"uri":"file:///abs/bar.rust_analyzer_crate_spec.json"}]}} | |
| {"id":{"targetCompleted":{"label":"//pkg:lib"}},"completed":{"outputGroup":[{"name":"rust_analyzer_crate_spec","fileSets":[{"id":"0"}]}]}} | |
| {"id":{"namedSet":{"id":"2"}},"namedSetOfFiles":{"files":[{"uri":"file:///abs/unrelated.json"}]}} | |
| "#, | |
| ) | |
| .unwrap(); | |
| let paths = parse_spec_paths(&bep_path, Utf8Path::new("/execroot")).unwrap(); | |
| assert_eq!( | |
| paths, | |
| vec![ | |
| Utf8PathBuf::from("/abs/bar.rust_analyzer_crate_spec.json"), | |
| Utf8PathBuf::from("/abs/foo.rust_analyzer_crate_spec.json"), | |
| ] | |
| ); | |
| } | |
| #[test] | |
| fn parse_spec_paths_handles_relative_paths() { | |
| let dir = tempdir(); | |
| let bep_path = dir.join("bep.json"); | |
| std::fs::write( | |
| &bep_path, | |
| r#"{"id":{"namedSet":{"id":"0"}},"namedSetOfFiles":{"files":[{"uri":"bytestream://remote/blob","pathPrefix":["bazel-out","k8-fastbuild","bin"],"name":"pkg/lib.rust_analyzer_crate_spec.json"}]}} | |
| {"id":{"targetCompleted":{"label":"//pkg:lib"}},"completed":{"outputGroup":[{"name":"rust_analyzer_crate_spec","fileSets":[{"id":"0"}]}]}} | |
| "#, | |
| ) | |
| .unwrap(); | |
| let paths = parse_spec_paths(&bep_path, Utf8Path::new("/execroot")).unwrap(); | |
| assert_eq!( | |
| paths, | |
| vec![Utf8PathBuf::from( | |
| "/execroot/bazel-out/k8-fastbuild/bin/pkg/lib.rust_analyzer_crate_spec.json", | |
| )] | |
| ); | |
| } | |
| #[test] | |
| fn parse_output_group_paths_filters_by_group() { | |
| let dir = tempdir(); | |
| let bep_path = dir.join("bep.json"); | |
| std::fs::write( | |
| &bep_path, | |
| r#"{"id":{"namedSet":{"id":"0"}},"namedSetOfFiles":{"files":[{"uri":"file:///abs/lib.rustc-output"}]}} | |
| {"id":{"namedSet":{"id":"1"}},"namedSetOfFiles":{"files":[{"uri":"file:///abs/lib.spec.json"}]}} | |
| {"id":{"targetCompleted":{"label":"//pkg:lib"}},"completed":{"outputGroup":[{"name":"rustc_output","fileSets":[{"id":"0"}]},{"name":"rust_analyzer_crate_spec","fileSets":[{"id":"1"}]}]}} | |
| "#, | |
| ) | |
| .unwrap(); | |
| let rustc = | |
| parse_output_group_paths(&bep_path, RUSTC_OUTPUT_GROUP, Utf8Path::new("/execroot")) | |
| .unwrap(); | |
| assert_eq!(rustc, vec![Utf8PathBuf::from("/abs/lib.rustc-output")]); | |
| let specs = parse_output_group_paths( | |
| &bep_path, | |
| "rust_analyzer_crate_spec", | |
| Utf8Path::new("/execroot"), | |
| ) | |
| .unwrap(); | |
| assert_eq!(specs, vec![Utf8PathBuf::from("/abs/lib.spec.json")]); | |
| } | |
| fn tempdir() -> Utf8PathBuf { | |
| use std::convert::TryFrom; | |
| // Sanitize the thread name: libtest gives us names like | |
| // `bep::tests::foo`, and Windows rejects `:` in filenames. | |
| let raw_name = std::thread::current().name().unwrap_or("anon").to_owned(); | |
| let safe_name: String = raw_name | |
| .chars() | |
| .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' }) | |
| .collect(); | |
| let dir = | |
| std::env::temp_dir().join(format!("bep_test_{}_{}", std::process::id(), safe_name,)); | |
| let _ = std::fs::remove_dir_all(&dir); | |
| std::fs::create_dir_all(&dir).unwrap(); | |
| Utf8PathBuf::try_from(dir).unwrap() | |
| } | |
| } |