diagnostics: finalize robust shadow-to-user path mapping for compiler errors

* Normalize paths between integration runner's
* Map cargo's absolute shadow output paths reliably by replacing temporary workspaces
* Inject  effectively through Charon driver
* Remove diagnostic prints and fallback to deterministic string-replacement for verification assertions
* Fix mapping of  outputs to use robust non-spanning fallbacks

gherrit-pr-id: Gd1a7f9c4436f266d37e83ebc2310f5a99a73d24d

Author: joshlf

tools/hermes/src/charon.rs

@@ -1,6 +1,7 @@
 use std::process::Command;
 
 use anyhow::{bail, Context as _, Result};
+use cargo_metadata::diagnostic::DiagnosticLevel;
 
 use crate::{
     resolve::{Args, HermesTargetKind, Roots},
@@ -39,6 +40,9 @@ pub fn run_charon(args: &Args, roots: &Roots, packages: &[HermesArtifact]) -> Re
         // Separator for the underlying cargo command
         cmd.arg("--");
 
+        // Ensure cargo emits json msgs which charon-driver natively generates
+        cmd.arg("--message-format=json");
+
         cmd.arg("--manifest-path").arg(&artifact.shadow_manifest_path);
 
         match artifact.target_kind {
@@ -77,9 +81,57 @@ pub fn run_charon(args: &Args, roots: &Roots, packages: &[HermesArtifact]) -> Re
 
         log::debug!("Command: {:?}", cmd);
 
-        let status = cmd.status().context("Failed to execute charon")?;
+        cmd.stdout(std::process::Stdio::piped());
+        let mut child = cmd.spawn().context("Failed to spawn charon")?;
+
+        let mut output_error = false;
+        if let Some(stdout) = child.stdout.take() {
+            use std::io::{BufRead, BufReader};
+            let reader = BufReader::new(stdout);
+
+            // When resolving mapped diagnostic paths, the original workspace is either test_case_root/source or workspace root.
+            let user_root = if roots.workspace.join("source").exists() {
+                roots.workspace.join("source")
+            } else {
+                roots.workspace.clone()
+            };
+            let mut mapper = crate::diagnostics::DiagnosticMapper::new(
+                artifact.shadow_manifest_path.parent().unwrap().to_path_buf(),
+                user_root,
+            );
+
+            for line in reader.lines() {
+                if let Ok(line) = line {
+                    if let Ok(msg) = serde_json::from_str::<cargo_metadata::Message>(&line) {
+                        use cargo_metadata::Message;
+                        match msg {
+                            Message::CompilerMessage(msg) => {
+                                mapper.render_miette(&msg.message);
+                                if matches!(
+                                    msg.message.level,
+                                    DiagnosticLevel::Error | DiagnosticLevel::Ice
+                                ) {
+                                    output_error = true;
+                                }
+                            }
+                            Message::TextLine(t) => {
+                                eprintln!("{}", t);
+                            }
+                            _ => {}
+                        }
+                    } else {
+                        // Print non-JSON lines to stderr
+                        eprintln!("{}", line);
+                    }
+                }
+            }
+        }
+
+        let status = child.wait().context("Failed to wait for charon")?;
 
-        if !status.success() {
+        if output_error {
+            bail!("Diagnostic error in charon");
+        } else if !status.success() {
             bail!("Charon failed with status: {}", status);
         }
     }

tools/hermes/src/diagnostics.rs

@@ -0,0 +1,177 @@
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+};
+
+use cargo_metadata::diagnostic::{Diagnostic, DiagnosticLevel, DiagnosticSpan};
+use miette::{NamedSource, Report, SourceOffset};
+use thiserror::Error;
+
+pub struct DiagnosticMapper {
+    shadow_root: PathBuf,
+    user_root: PathBuf,
+    user_root_canonical: PathBuf,
+    source_cache: HashMap<PathBuf, String>,
+}
+
+#[derive(Error, Debug)]
+#[error("{message}")]
+struct MappedError {
+    message: String,
+    src: NamedSource<String>,
+    labels: Vec<miette::LabeledSpan>,
+    help: Option<String>,
+    related: Vec<MappedError>,
+}
+
+impl miette::Diagnostic for MappedError {
+    fn source_code(&self) -> Option<&dyn miette::SourceCode> {
+        Some(&self.src)
+    }
+
+    fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
+        if self.labels.is_empty() {
+            None
+        } else {
+            Some(Box::new(self.labels.iter().cloned()))
+        }
+    }
+
+    fn help(&self) -> Option<Box<dyn std::fmt::Display + '_>> {
+        self.help.as_ref().map(|h| Box::new(h.clone()) as Box<dyn std::fmt::Display>)
+    }
+
+    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn miette::Diagnostic> + 'a>> {
+        if self.related.is_empty() {
+            None
+        } else {
+            let iter = self.related.iter().map(|e| e as &dyn miette::Diagnostic);
+            Some(Box::new(iter))
+        }
+    }
+}
+
+impl DiagnosticMapper {
+    pub fn new(shadow_root: PathBuf, user_root: PathBuf) -> Self {
+        let user_root_canonical =
+            fs::canonicalize(&user_root).unwrap_or_else(|_| user_root.clone());
+        Self { shadow_root, user_root, user_root_canonical, source_cache: HashMap::new() }
+    }
+
+    pub fn map_path(&self, path: &Path) -> Option<PathBuf> {
+        let mut p = path.to_path_buf();
+        if p.is_relative() {
+            p = self.user_root.join(p);
+        }
+
+        // Strategy A: Starts with shadow_root
+        if let Ok(suffix) = p.strip_prefix(&self.shadow_root) {
+            return Some(self.user_root.join(suffix));
+        }
+
+        // Strategy B: Starts with user_root or user_root_canonical
+        if p.starts_with(&self.user_root) || p.starts_with(&self.user_root_canonical) {
+            return Some(p);
+        }
+
+        None
+    }
+
+    fn get_source(&mut self, path: &Path) -> Option<String> {
+        if let Some(src) = self.source_cache.get(path) {
+            return Some(src.clone());
+        }
+        if let Ok(src) = fs::read_to_string(path) {
+            self.source_cache.insert(path.to_path_buf(), src.clone());
+            Some(src)
+        } else {
+            None
+        }
+    }
+
+    pub fn render_miette(&mut self, diag: &Diagnostic) {
+        let mut mapped_paths_and_spans: HashMap<PathBuf, Vec<&DiagnosticSpan>> = HashMap::new();
+
+        // 1) Group spans by mapped path
+        for s in &diag.spans {
+            let p = PathBuf::from(&s.file_name);
+            if let Some(mapped_path) = self.map_path(&p) {
+                mapped_paths_and_spans.entry(mapped_path).or_default().push(s);
+            }
+        }
+
+        // Check children for help messages
+        let mut help_msg = None;
+        for child in &diag.children {
+            if child.level == DiagnosticLevel::Help {
+                help_msg = Some(child.message.clone());
+            }
+        }
+
+        if !mapped_paths_and_spans.is_empty() {
+            // Find the path that contains the primary span, or just take the first one
+            let primary_path = diag
+                .spans
+                .iter()
+                .find(|s| s.is_primary)
+                .and_then(|s| self.map_path(&PathBuf::from(&s.file_name)))
+                .or_else(|| mapped_paths_and_spans.keys().next().cloned());
+
+            if let Some(main_path) = primary_path {
+                let mut all_errors = Vec::new();
+
+                // Sort the paths to have the primary path first
+                let mut paths: Vec<PathBuf> = mapped_paths_and_spans.keys().cloned().collect();
+                paths.sort_by_key(|p| p != &main_path);
+
+                for p in paths {
+                    if let Some(src) = self.get_source(&p) {
+                        let mut labels = Vec::new();
+                        for s in mapped_paths_and_spans.get(&p).unwrap() {
+                            let label_text = s.label.clone().unwrap_or_default();
+                            let start = s.byte_start as usize;
+                            let len = (s.byte_end - s.byte_start) as usize;
+                            if start <= src.len() && start + len <= src.len() {
+                                let offset = SourceOffset::from(start);
+                                labels.push(miette::LabeledSpan::new(
+                                    Some(label_text),
+                                    offset.offset(),
+                                    len,
+                                ));
+                            }
+                        }
+
+                        let err = MappedError {
+                            message: if p == main_path {
+                                diag.message.clone()
+                            } else {
+                                format!("related to: {}", p.display())
+                            },
+                            src: NamedSource::new(p.to_string_lossy(), src),
+                            labels,
+                            help: if p == main_path { help_msg.clone() } else { None },
+                            related: Vec::new(),
+                        };
+                        all_errors.push(err);
+                    }
+                }
+
+                if !all_errors.is_empty() {
+                    let mut main_err = all_errors.remove(0);
+                    main_err.related = all_errors;
+                    eprintln!("{:?}", Report::new(main_err));
+                    return;
+                }
+            }
+        }
+
+        // If we get here, no span was successfully mapped
+        let prefix = match diag.level {
+            DiagnosticLevel::Error | DiagnosticLevel::Ice => "[External Error]",
+            DiagnosticLevel::Warning => "[External Warning]",
+            _ => "[External Info]",
+        };
+        eprintln!("{} {}", prefix, diag.message);
+    }
+}

tools/hermes/src/main.rs

@@ -1,4 +1,5 @@
 mod charon;
+mod diagnostics;
 mod errors;
 mod parse;
 mod resolve;

tools/hermes/tests/fixtures/env_interleaved_stdout/expected_status.txt

@@ -0,0 +1 @@
+failure

tools/hermes/tests/fixtures/env_interleaved_stdout/expected_stderr.txt

@@ -0,0 +1,11 @@
+Line 1 from charon
+  × interleaved error
+   ╭─[[PROJECT_ROOT]/src/lib.rs:1:1]
+ 1 │ pub fn foo() {}
+   · ─────┬────
+   ·      ╰── label
+ 2 │ 
+   ╰────
+
+Line 2 from charon
+Error: Diagnostic error in charon

tools/hermes/tests/fixtures/env_interleaved_stdout/hermes.toml

@@ -0,0 +1 @@
+[dependencies]

tools/hermes/tests/fixtures/env_interleaved_stdout/mock_charon_output.json

@@ -0,0 +1,3 @@
+Line 1 from charon
+{"reason": "compiler-message", "package_id": "test 0.1.0 (path+file://[PROJECT_ROOT])", "target": {"kind": ["lib"], "crate_types": ["lib"], "name": "test", "src_path": "[PROJECT_ROOT]/src/lib.rs", "edition": "2021", "doc": true, "doctest": true, "test": true}, "message": {"rendered": "error: interleaved\n", "children": [], "code": null, "level": "error", "message": "interleaved error", "spans": [{"byte_end": 10, "byte_start": 0, "column_end": 11, "column_start": 1, "line_end": 1, "line_start": 1, "file_name": "[SHADOW_ROOT]/src/lib.rs", "is_primary": true, "label": "label", "text": [], "expansion": null}]}}
+Line 2 from charon

tools/hermes/tests/fixtures/env_interleaved_stdout/source/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "test_pkg"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

tools/hermes/tests/fixtures/env_interleaved_stdout/source/src/lib.rs

@@ -0,0 +1,5 @@
+pub fn foo() {}
+
+/// ```lean
+/// ```
+pub fn dummy() {}

tools/hermes/tests/fixtures/fs_missing_source/expected_status.txt

@@ -0,0 +1 @@
+failure