perf(fmt): speed up file diffing

Cargo.toml

@@ -362,6 +362,7 @@ dprint-plugin-markdown = "=0.20.0"
 dprint-plugin-typescript = "=0.95.15"
 env_logger = "=0.11.6"
 fancy-regex = "=0.14.0"
+imara-diff = "=0.2.0"
 libsui = "0.12.6"
 malva = "=0.12.1"
 markup_fmt = "=0.22.0"

libs/resolver/Cargo.toml

@@ -49,9 +49,9 @@ deno_permissions = { workspace = true, optional = true }
 deno_semver.workspace = true
 deno_terminal.workspace = true
 deno_unsync.workspace = true
-dissimilar.workspace = true
 futures.workspace = true
 http = { workspace = true, optional = true }
+imara-diff.workspace = true
 import_map.workspace = true
 indexmap.workspace = true
 jsonc-parser.workspace = true
@@ -69,5 +69,5 @@ url.workspace = true
 
 [dev-dependencies]
 node_resolver.workspace = true
-sys_traits = { workspace = true, features = ["memory", "real", "serde_json"] }
+sys_traits = { workspace = true, features = ["getrandom", "memory", "real", "serde_json"] }
 test_util.workspace = true

libs/resolver/display.rs

@@ -6,8 +6,8 @@
 use std::fmt::Write as _;
 
 use deno_terminal::colors;
-use dissimilar::Chunk;
-use dissimilar::diff as difference;
+use imara_diff::Diff;
+use imara_diff::InternedInput;
 
 /// Print diff of the same file_path, before and after formatting.
 ///
@@ -28,25 +28,25 @@ pub fn diff(orig_text: &str, edit_text: &str) -> String {
   DiffBuilder::build(&orig_text, &edit_text)
 }
 
-struct DiffBuilder {
+struct DiffBuilder<'a> {
+  input: InternedInput<&'a str>,
   output: String,
   line_number_width: usize,
   orig_line: usize,
   edit_line: usize,
-  orig: String,
-  edit: String,
-  has_changes: bool,
 }
 
-impl DiffBuilder {
-  pub fn build(orig_text: &str, edit_text: &str) -> String {
-    let mut diff_builder = DiffBuilder {
+impl<'a> DiffBuilder<'a> {
+  pub fn build(orig_text: &'a str, edit_text: &'a str) -> String {
+    let input = InternedInput::new(orig_text, edit_text);
+    let mut diff = Diff::compute(imara_diff::Algorithm::Histogram, &input);
+    diff.postprocess_lines(&input);
+
+    let diff_builder = DiffBuilder {
+      input,
       output: String::new(),
       orig_line: 1,
       edit_line: 1,
-      orig: String::new(),
-      edit: String::new(),
-      has_changes: false,
       line_number_width: {
         let line_count = std::cmp::max(
           orig_text.split('\n').count(),
@@ -55,108 +55,75 @@ impl DiffBuilder {
         line_count.to_string().chars().count()
       },
     };
-
-    let chunks = difference(orig_text, edit_text);
-    diff_builder.handle_chunks(chunks);
-    diff_builder.output
+    diff_builder.handle_diff(diff)
   }
 
-  fn handle_chunks<'a>(&'a mut self, chunks: Vec<Chunk<'a>>) {
-    for chunk in chunks {
-      match chunk {
-        Chunk::Delete(s) => {
-          let split = s.split('\n').enumerate();
-          for (i, s) in split {
-            if i > 0 {
-              self.orig.push('\n');
-            }
-            self.orig.push_str(&fmt_rem_text_highlight(s));
-          }
-          self.has_changes = true
-        }
-        Chunk::Insert(s) => {
-          let split = s.split('\n').enumerate();
-          for (i, s) in split {
-            if i > 0 {
-              self.edit.push('\n');
-            }
-            self.edit.push_str(&fmt_add_text_highlight(s));
-          }
-          self.has_changes = true
-        }
-        Chunk::Equal(s) => {
-          let split = s.split('\n').enumerate();
-          for (i, s) in split {
-            if i > 0 {
-              self.flush_changes();
-            }
-            self.orig.push_str(&fmt_rem_text(s));
-            self.edit.push_str(&fmt_add_text(s));
-          }
-        }
+  fn handle_diff(mut self, diff: Diff) -> String {
+    let mut prev_before_end: u32 = 0;
+    let mut prev_after_end: u32 = 0;
+
+    for hunk in diff.hunks() {
+      // Skip unchanged lines between hunks
+      self.orig_line +=
+        (hunk.before.start - prev_before_end) as usize;
+      self.edit_line +=
+        (hunk.after.start - prev_after_end) as usize;
+
+      // Write deleted lines
+      for del in hunk.before.clone() {
+        let s = self.input.interner[self.input.before[del as usize]];
+        self.write_rem_line(s);
+      }
+      // Write inserted lines
+      for ins in hunk.after.clone() {
+        let s = self.input.interner[self.input.after[ins as usize]];
+        self.write_add_line(s);
       }
-    }
-
-    self.flush_changes();
-  }
-
-  fn flush_changes(&mut self) {
-    if self.has_changes {
-      self.write_line_diff();
 
-      self.orig_line += self.orig.split('\n').count();
-      self.edit_line += self.edit.split('\n').count();
-      self.has_changes = false;
-    } else {
-      self.orig_line += 1;
-      self.edit_line += 1;
+      prev_before_end = hunk.before.end;
+      prev_after_end = hunk.after.end;
     }
 
-    self.orig.clear();
-    self.edit.clear();
+    self.output
   }
 
-  fn write_line_diff(&mut self) {
-    let split = self.orig.split('\n').enumerate();
-    for (i, s) in split {
-      write!(
-        self.output,
-        "{:width$}{} ",
-        self.orig_line + i,
-        colors::gray(" |"),
-        width = self.line_number_width
-      )
-      .unwrap();
-      self.output.push_str(&fmt_rem());
-      self.output.push_str(s);
-      self.output.push('\n');
-    }
+  fn write_rem_line(&mut self, text: &str) {
+    let text = text.strip_suffix('\n').unwrap_or(text);
+    write!(
+      self.output,
+      "{:width$}{} ",
+      self.orig_line,
+      colors::gray(" |"),
+      width = self.line_number_width
+    )
+    .unwrap();
+    self.output.push_str(&fmt_rem());
+    self.output.push_str(&fmt_rem_text_highlight(text));
+    self.output.push('\n');
+    self.orig_line += 1;
+  }
 
-    let split = self.edit.split('\n').enumerate();
-    for (i, s) in split {
-      write!(
-        self.output,
-        "{:width$}{} ",
-        self.edit_line + i,
-        colors::gray(" |"),
-        width = self.line_number_width
-      )
-      .unwrap();
-      self.output.push_str(&fmt_add());
-      self.output.push_str(s);
-      self.output.push('\n');
-    }
+  fn write_add_line(&mut self, text: &str) {
+    let text = text.strip_suffix('\n').unwrap_or(text);
+    write!(
+      self.output,
+      "{:width$}{} ",
+      self.edit_line,
+      colors::gray(" |"),
+      width = self.line_number_width
+    )
+    .unwrap();
+    self.output.push_str(&fmt_add());
+    self.output.push_str(&fmt_add_text_highlight(text));
+    self.output.push('\n');
+    self.edit_line += 1;
   }
 }
 
 fn fmt_add() -> String {
   colors::green_bold("+").to_string()
 }
 
-fn fmt_add_text(x: &str) -> String {
-  colors::green(x).to_string()
-}
-
 fn fmt_add_text_highlight(x: &str) -> String {
   colors::black_on_green(x).to_string()
 }
@@ -165,10 +132,6 @@ fn fmt_rem() -> String {
   colors::red_bold("-").to_string()
 }
 
-fn fmt_rem_text(x: &str) -> String {
-  colors::red(x).to_string()
-}
-
 fn fmt_rem_text_highlight(x: &str) -> String {
   colors::white_on_red(x).to_string()
 }
@@ -268,11 +231,10 @@ mod tests {
         "2 | -\n",
         "3 | -\n",
         "4 | -\n",
-        "5 | -console.log(\n",
-        "1 | +console.log(\n",
         "6 | -'Hello World'\n",
+        "7 | -)\n",
         "2 | +\"Hello World\"\n",
-        "7 | -)\n3 | +);\n",
+        "3 | +);\n",
       ),
     );
   }
@@ -285,7 +247,6 @@ mod tests {
       concat!(
         "2 | -some line text test\n",
         "2 | +some line text test\n",
-        "3 | +\n",
       ),
     );
   }