Create a more compact diff format

Author: oli-obk

Cargo.lock

@@ -15,7 +15,7 @@ rustc_version = "0.4"
 colored = "2"
 # Features chosen to match those required by env_logger, to avoid rebuilds
 regex = { version = "1.5.5", default-features = false, features = ["perf", "std"] }
-pretty_assertions = "1.2.1"
+diff = "0.1.13"
 crossbeam = "0.8.1"
 lazy_static = "1.4.0"
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -0,0 +1,111 @@
+use colored::*;
+use diff::{chars, lines, Result, Result::*};
+
+#[derive(Default)]
+struct DiffState<'a> {
+    skipped_lines: usize,
+    /// When we see a removed line, we don't print it, we
+    /// keep it around to compare it with the next added line.
+    prev_left: Option<&'a str>,
+}
+
+impl<'a> DiffState<'a> {
+    fn print_skip(&mut self) {
+        if self.skipped_lines != 0 {
+            eprintln!("... {} lines skipped", self.skipped_lines);
+        }
+        self.skipped_lines = 0;
+    }
+
+    fn print_prev(&mut self) {
+        if let Some(l) = self.prev_left.take() {
+            self.print_left(l);
+        }
+    }
+
+    fn print_left(&self, l: &str) {
+        eprintln!("{}{}", "-".red(), l.red());
+    }
+
+    fn print_right(&self, r: &str) {
+        eprintln!("{}{}", "+".green(), r.green());
+    }
+
+    fn row(&mut self, row: Result<&'a str>) {
+        match row {
+            Left(l) => {
+                self.print_skip();
+                self.print_prev();
+                self.prev_left = Some(l);
+            }
+            Both(..) => {
+                self.print_prev();
+                self.skipped_lines += 1
+            }
+            Right(r) => {
+                if let Some(l) = self.prev_left.take() {
+                    // If the lines only add chars or only remove chars, display an inline diff
+                    let diff = chars(l, r);
+                    let mut seen_l = false;
+                    let mut seen_r = false;
+                    for char in &diff {
+                        match char {
+                            Left(l) if !l.is_whitespace() => seen_l = true,
+                            Right(r) if !r.is_whitespace() => seen_r = true,
+                            _ => {}
+                        }
+                    }
+                    if seen_l && seen_r {
+                        // the line both adds and removes chars, print both lines, but highlight their differences
+                        eprint!("{}", "-".red());
+                        for char in &diff {
+                            match char {
+                                Left(l) => eprint!("{}", l.to_string().red()),
+                                Right(_) => {}
+                                Both(l, _) => eprint!("{}", l),
+                            }
+                        }
+                        eprintln!();
+                        eprint!("{}", "+".green());
+                        for char in &diff {
+                            match char {
+                                Left(_) => {}
+                                Right(r) => eprint!("{}", r.to_string().green()),
+                                Both(l, _) => eprint!("{}", l),
+                            }
+                        }
+                        eprintln!();
+                    } else {
+                        eprint!("{}", "~".yellow());
+                        for char in diff {
+                            match char {
+                                Left(l) => eprint!("{}", l.to_string().red()),
+                                Both(l, _) => eprint!("{}", l),
+                                Right(r) => eprint!("{}", r.to_string().green()),
+                            }
+                        }
+                        eprintln!();
+                    }
+                } else {
+                    self.print_skip();
+                    self.print_right(r);
+                }
+            }
+        }
+    }
+
+    fn finish(self) {
+        if self.skipped_lines != 0 {
+            eprintln!("... {} lines skipped ...", self.skipped_lines);
+        }
+        eprintln!()
+    }
+}
+
+pub fn print_diff(expected: &str, actual: &str) {
+    let mut state = DiffState::default();
+    for row in lines(expected, actual) {
+        state.row(row);
+    }
+    state.finish();
+}

src/diff.rs

@@ -25,6 +25,7 @@ use crate::dependencies::build_dependencies;
 use crate::parser::{Comments, Condition};
 
 mod dependencies;
+mod diff;
 mod parser;
 mod rustc_stderr;
 #[cfg(test)]
@@ -322,11 +323,7 @@ pub fn run_tests_generic(config: Config, file_filter: impl Fn(&Path) -> bool + S
                         expected,
                     } => {
                         eprintln!("actual output differed from expected {}", path.display());
-                        eprintln!(
-                            "{}",
-                            pretty_assertions::StrComparison::new(expected, actual)
-                        );
-                        eprintln!()
+                        diff::print_diff(expected, actual);
                     }
                     Error::ErrorsWithoutPattern { path: None, msgs } => {
                         eprintln!(

src/lib.rs

@@ -40,29 +40,17 @@ tests/actual_tests/foomp.rs FAILED:
 command: "rustc" "--error-format=json" "--edition=2021" "--extern" "basic_fail=$DIR/$DIR/../../../target/debug/libbasic_fail-$HASH.rmeta" "-L" "$DIR/$DIR/../../../target/debug" "-L" "$DIR/$DIR/../../../target/debug" "tests/actual_tests/foomp.rs"
 
 actual output differed from expected tests/actual_tests/foomp.stderr
-Diff < left / right > :
- error[E0308]: mismatched types
-  --> $DIR/foomp.rs:4:9
-   |
- 4 |     add("42", 3);
-   |     --- ^^^^ expected `usize`, found `&str`
->  |     |
->  |     arguments to this function are incorrect
-   |
- note: function defined here
-< --> $DIR/tests/integrations/basic/src/lib.rs:1:8
-> --> $DIR/tests/integrations/basic-fail/src/lib.rs:1:8
-   |
- 1 | pub fn add(left: usize, right: usize) -> usize {
-<  |        ^^^ some expected text that isn't in the actual message
->  |        ^^^
- 
-<error: aborting doo to previous error
->error: aborting due to previous error
- 
- For more information about this error, try `rustc --explain E0308`.
- 
-
+... 5 lines skipped
++  |     |
++  |     arguments to this function are incorrect
+... 2 lines skipped
+~ --> $DIR/$DIR/src/lib.rs:1:8
+... 2 lines skipped
+~  |        ^^^ some expected text that isn't in the actual message
+... 1 lines skipped
+-error: aborting doo to previous error
++error: aborting due to previous error
+... 3 lines skipped ...
 
 
 full stderr: