Restore full paths in spans

Author: saulshanabrook

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [Unreleased] - ReleaseDate
 
+- Report full source file paths in egglog span and error messages.
 - Desugar `relation`s to `constructor`s to simplify the language and implementation. Relations no longer return unit `()` values.
 - Refactored API to use [`TermId`] more consistently instead of `Term` where possible, simplifying egglog code.
 - **Typed primitive surface for seminaive safety (#772).** Custom primitives now pick one of `PurePrim` / `ReadPrim` / `WritePrim` / `FullPrim` based on what the body needs, and register via the matching `add_*_primitive`. Rust enforces capability bounds via the state wrapper passed to the body; the egglog typechecker enforces context bounds. See the `egglog::exec_state` module docs and the `*Prim` trait docs for the full picture. Migration: `rust_rule` callbacks now take `&mut WriteState` (replacing `RustRuleContext`); a new `rust_rule_full` gives action callbacks read access. Higher-order primitives over `unstable-fn` values dispatch via `state.apply_function(&fc, args)`.

egglog-ast/src/span.rs

@@ -74,14 +74,7 @@ impl Display for Span {
                     .file
                     .get_location((span.j.saturating_sub(1)).max(span.i));
                 let quote = self.string();
-                // Use just the file name, not the full path, for cross-platform consistency in snapshots
-                let display_name = span.file.name.as_ref().map(|path| {
-                    std::path::Path::new(path)
-                        .file_name()
-                        .and_then(|n| n.to_str())
-                        .unwrap_or(path)
-                });
-                match (&display_name, start_line == end_line) {
+                match (&span.file.name, start_line == end_line) {
                     (Some(filename), true) => write!(
                         f,
                         "In {start_line}:{start_col}-{end_col} of {filename}: {quote}"
@@ -102,3 +95,23 @@ impl Display for Span {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn egglog_span_display_preserves_full_path() {
+        let path = "/tmp/egglog/full/path/example.egg".to_string();
+        let span = Span::Egglog(Arc::new(EgglogSpan {
+            file: Arc::new(SrcFile {
+                name: Some(path.clone()),
+                contents: "(bad)".to_string(),
+            }),
+            i: 0,
+            j: 5,
+        }));
+
+        assert_eq!(span.to_string(), format!("In 1:1-5 of {path}: (bad)"));
+    }
+}

tests/files.rs

@@ -22,6 +22,19 @@ impl Run {
         self.path.parent().unwrap().ends_with("proofs")
     }
 
+    fn filename_for_test_run(&self) -> Option<String> {
+        if self.should_fail() {
+            // Fail-typecheck errors are snapshot-tested. Pass a stable display
+            // name so Span can render the caller-provided path verbatim without
+            // making snapshots depend on the local checkout path.
+            self.path
+                .file_name()
+                .map(|name| name.to_string_lossy().into())
+        } else {
+            self.path.to_str().map(String::from)
+        }
+    }
+
     /// Extraction results may differ slightly due to the proof encoding when multiple
     /// solutions have the same cost. Snapshot only the extracted cost so shared
     /// snapshots still verify that normal and proof modes find equally good solutions.
@@ -51,7 +64,7 @@ impl Run {
 
         let result = if !self.desugar {
             self.test_program(
-                self.path.to_str().map(String::from),
+                self.filename_for_test_run(),
                 &program,
                 "",
                 "Top level error",