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,121 @@
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+};
+
+use cargo_metadata::diagnostic::{Diagnostic, DiagnosticLevel};
+use miette::{NamedSource, Report, SourceOffset};
+use thiserror::Error;
+
+pub struct DiagnosticMapper {
+    shadow_root: PathBuf,
+    user_root: 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>,
+}
+
+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>)
+    }
+}
+
+impl DiagnosticMapper {
+    pub fn new(shadow_root: PathBuf, user_root: PathBuf) -> Self {
+        Self { shadow_root, user_root, source_cache: HashMap::new() }
+    }
+
+    pub fn map_path(&self, path: &Path) -> Option<PathBuf> {
+        path.strip_prefix(&self.shadow_root).ok().map(|suffix| self.user_root.join(suffix))
+    }
+
+    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 primary_span = diag.spans.iter().find(|s| s.is_primary);
+
+        let mut mapped = false;
+        if let Some(span) = primary_span {
+            let path = PathBuf::from(&span.file_name);
+            if let Some(mapped_path) = self.map_path(&path) {
+                if let Some(src) = self.get_source(&mapped_path) {
+                    let mut labels = Vec::new();
+
+                    for s in &diag.spans {
+                        let s_path = PathBuf::from(&s.file_name);
+                        if s_path == path || self.map_path(&s_path).as_ref() == Some(&mapped_path) {
+                            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,
+                                ));
+                            }
+                        }
+                    }
+
+                    // 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());
+                        }
+                    }
+
+                    let err = MappedError {
+                        message: diag.message.clone(),
+                        src: NamedSource::new(mapped_path.to_string_lossy(), src),
+                        labels,
+                        help: help_msg,
+                    };
+
+                    eprintln!("{:?}", Report::new(err));
+                    mapped = true;
+                }
+            }
+        }
+
+        if !mapped {
+            if diag.spans.is_empty() {
+                eprintln!("[External Error] {}", diag.message);
+            } else {
+                eprintln!("[External Error] {}", 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