bundle old root into `SyntaxEdit` result

useful for `SourceChangeBuilder` so it can still perform a tree diff without having to store the old root separately

2 files changed, 30 insertions, 12 deletions

diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
index 139c6518bf7..eb114f5e5f1 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
@@ -102,16 +102,23 @@ impl SyntaxEditor {
     }
 }
 
+/// Represents a completed [`SyntaxEditor`] operation.
 pub struct SyntaxEdit {
-    root: SyntaxNode,
+    old_root: SyntaxNode,
+    new_root: SyntaxNode,
     changed_elements: Vec<SyntaxElement>,
     annotations: FxHashMap<SyntaxAnnotation, Vec<SyntaxElement>>,
 }
 
 impl SyntaxEdit {
-    /// Root of the modified syntax tree
-    pub fn root(&self) -> &SyntaxNode {
-        &self.root
+    /// Root of the initial unmodified syntax tree.
+    pub fn old_root(&self) -> &SyntaxNode {
+        &self.old_root
+    }
+
+    /// Root of the modified syntax tree.
+    pub fn new_root(&self) -> &SyntaxNode {
+        &self.new_root
     }
 
     /// Which syntax elements in the modified syntax tree were inserted or
@@ -441,14 +448,14 @@ mod tests {
                 let var_name = 2 + 2;
                 (var_name, true)
             }"#]];
-        expect.assert_eq(&edit.root.to_string());
+        expect.assert_eq(&edit.new_root.to_string());
 
         assert_eq!(edit.find_annotation(placeholder_snippet).len(), 2);
         assert!(edit
             .annotations
             .iter()
             .flat_map(|(_, elements)| elements)
-            .all(|element| element.ancestors().any(|it| &it == edit.root())))
+            .all(|element| element.ancestors().any(|it| &it == edit.new_root())))
     }
 
     #[test]
@@ -495,7 +502,7 @@ mod tests {
             let first = 1;{
                 let second = 2;let third = 3;
             }"#]];
-        expect.assert_eq(&edit.root.to_string());
+        expect.assert_eq(&edit.new_root.to_string());
     }
 
     #[test]
@@ -556,7 +563,7 @@ mod tests {
             }
             }
             }"#]];
-        expect.assert_eq(&edit.root.to_string());
+        expect.assert_eq(&edit.new_root.to_string());
     }
 
     #[test]
@@ -599,6 +606,6 @@ mod tests {
                 let second = 2;
             }
             }"#]];
-        expect.assert_eq(&edit.root.to_string());
+        expect.assert_eq(&edit.new_root.to_string());
     }
 }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edit_algo.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edit_algo.rs
index 55e8867a46c..b769c941105 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edit_algo.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edit_algo.rs
@@ -81,7 +81,12 @@ pub(super) fn apply_edits(editor: SyntaxEditor) -> SyntaxEdit {
         "some replace change ranges intersect: {:?}",
         changes
     ) {
-        return SyntaxEdit { root, annotations: Default::default(), changed_elements: vec![] };
+        return SyntaxEdit {
+            old_root: root.clone(),
+            new_root: root,
+            annotations: Default::default(),
+            changed_elements: vec![],
+        };
     }
 
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -273,7 +278,12 @@ pub(super) fn apply_edits(editor: SyntaxEditor) -> SyntaxEdit {
         annotation_groups.entry(annotation).or_insert(vec![]).push(element);
     }
 
-    SyntaxEdit { root, changed_elements, annotations: annotation_groups }
+    SyntaxEdit {
+        old_root: tree_mutator.immutable,
+        new_root: root,
+        changed_elements,
+        annotations: annotation_groups,
+    }
 }
 
 fn to_owning_node(element: &SyntaxElement) -> SyntaxNode {
@@ -329,6 +339,7 @@ impl ChangedAncestor {
 }
 
 struct TreeMutator {
+    immutable: SyntaxNode,
     mutable_clone: SyntaxNode,
 }
 
@@ -336,7 +347,7 @@ impl TreeMutator {
     fn new(immutable: &SyntaxNode) -> TreeMutator {
         let immutable = immutable.clone();
         let mutable_clone = immutable.clone_for_update();
-        TreeMutator { mutable_clone }
+        TreeMutator { immutable, mutable_clone }
     }
 
     fn make_element_mut(&self, element: &SyntaxElement) -> SyntaxElement {