merge: add method for indexed adds/removes access

The current adds()/removes() will be changed to return iterators.

lib/src/conflicts.rs

@@ -122,7 +122,7 @@ pub fn materialize_merge_result(
                     output.write_all(CONFLICT_START_LINE)?;
                     let mut add_index = 0;
                     for left in hunk.removes() {
-                        let right1 = if let Some(right1) = hunk.adds().get(add_index) {
+                        let right1 = if let Some(right1) = hunk.get_add(add_index) {
                             right1
                         } else {
                             // If we have no more positive terms, emit the remaining negative
@@ -137,7 +137,7 @@ pub fn materialize_merge_result(
                         // Check if the diff against the next positive term is better. Since
                         // we want to preserve the order of the terms, we don't match against
                         // any later positive terms.
-                        if let Some(right2) = hunk.adds().get(add_index + 1) {
+                        if let Some(right2) = hunk.get_add(add_index + 1) {
                             let diff2 =
                                 Diff::for_tokenizer(&[&left.0, &right2.0], &find_line_ranges)
                                     .hunks()

lib/src/git_backend.rs

@@ -1401,19 +1401,34 @@ mod tests {
         let mut iter = git_tree.iter();
         let entry = iter.next().unwrap();
         assert_eq!(entry.name(), Some(".jjconflict-base-0"));
-        assert_eq!(entry.id().as_bytes(), root_tree.removes()[0].as_bytes());
+        assert_eq!(
+            entry.id().as_bytes(),
+            root_tree.get_remove(0).unwrap().as_bytes()
+        );
         let entry = iter.next().unwrap();
         assert_eq!(entry.name(), Some(".jjconflict-base-1"));
-        assert_eq!(entry.id().as_bytes(), root_tree.removes()[1].as_bytes());
+        assert_eq!(
+            entry.id().as_bytes(),
+            root_tree.get_remove(1).unwrap().as_bytes()
+        );
         let entry = iter.next().unwrap();
         assert_eq!(entry.name(), Some(".jjconflict-side-0"));
-        assert_eq!(entry.id().as_bytes(), root_tree.adds()[0].as_bytes());
+        assert_eq!(
+            entry.id().as_bytes(),
+            root_tree.get_add(0).unwrap().as_bytes()
+        );
         let entry = iter.next().unwrap();
         assert_eq!(entry.name(), Some(".jjconflict-side-1"));
-        assert_eq!(entry.id().as_bytes(), root_tree.adds()[1].as_bytes());
+        assert_eq!(
+            entry.id().as_bytes(),
+            root_tree.get_add(1).unwrap().as_bytes()
+        );
         let entry = iter.next().unwrap();
         assert_eq!(entry.name(), Some(".jjconflict-side-2"));
-        assert_eq!(entry.id().as_bytes(), root_tree.adds()[2].as_bytes());
+        assert_eq!(
+            entry.id().as_bytes(),
+            root_tree.get_add(2).unwrap().as_bytes()
+        );
         assert!(iter.next().is_none());
 
         // When writing a single tree using the new format, it's represented by a

lib/src/merge.rs

@@ -170,6 +170,19 @@ impl<T> Merge<T> {
         &self.adds
     }
 
+    /// Returns the `index`-th removed value, which is considered belonging to
+    /// the `index`-th diff pair.
+    pub fn get_remove(&self, index: usize) -> Option<&T> {
+        self.removes.get(index)
+    }
+
+    /// Returns the `index`-th added value, which is considered belonging to the
+    /// `index-1`-th diff pair. The zeroth add is a diff from the non-existent
+    /// state.
+    pub fn get_add(&self, index: usize) -> Option<&T> {
+        self.adds.get(index)
+    }
+
     /// The number of positive terms in the conflict.
     pub fn num_sides(&self) -> usize {
         self.adds.len()

lib/src/merged_tree.rs

@@ -479,7 +479,7 @@ fn merge_trees(merge: &Merge<Tree>) -> Result<Merge<Tree>, TreeMergeError> {
         let mut tree_removes = vec![];
         for i in 0..merge.removes().len() {
             for (basename, path_conflict) in &conflicts {
-                new_tree.set_or_remove(basename, path_conflict.removes()[i].clone());
+                new_tree.set_or_remove(basename, path_conflict.get_remove(i).unwrap().clone());
             }
             let tree = store.write_tree(dir, new_tree.clone())?;
             tree_removes.push(tree);
@@ -487,7 +487,7 @@ fn merge_trees(merge: &Merge<Tree>) -> Result<Merge<Tree>, TreeMergeError> {
         let mut tree_adds = vec![];
         for i in 0..merge.adds().len() {
             for (basename, path_conflict) in &conflicts {
-                new_tree.set_or_remove(basename, path_conflict.adds()[i].clone());
+                new_tree.set_or_remove(basename, path_conflict.get_add(i).unwrap().clone());
             }
             let tree = store.write_tree(dir, new_tree.clone())?;
             tree_adds.push(tree);