files: take Merge argument to merge()

All non-test callers already have a `Merge` object, so let's pass that
instead. We thereby simplify the callers a little, and we enforce the
"adds.len() == removes.len() + 1" constraint in the type.

cli/src/merge_tools/builtin.rs

@@ -513,7 +513,7 @@ pub fn edit_merge_builtin(
     content: Merge<ContentHunk>,
 ) -> Result<MergedTreeId, BuiltinToolError> {
     let slices = content.map(|ContentHunk(v)| v.as_slice());
-    let merge_result = files::merge(slices.removes(), slices.adds());
+    let merge_result = files::merge(slices);
     let sections = make_merge_sections(merge_result)?;
     let recorder = scm_record::Recorder::new(
         scm_record::RecordState {
@@ -726,7 +726,7 @@ mod tests {
         );
         let content = extract_as_single_hunk(&merge, store, &path);
         let slices = content.map(|ContentHunk(buf)| buf.as_slice());
-        let merge_result = files::merge(slices.removes(), slices.adds());
+        let merge_result = files::merge(slices);
         let sections = make_merge_sections(merge_result).unwrap();
         insta::assert_debug_snapshot!(sections, @r###"
         [

lib/src/conflicts.rs

@@ -103,7 +103,7 @@ pub fn materialize_merge_result(
     output: &mut dyn Write,
 ) -> std::io::Result<()> {
     let slices = single_hunk.map(|content| content.0.as_slice());
-    let merge_result = files::merge(slices.removes(), slices.adds());
+    let merge_result = files::merge(slices);
     match merge_result {
         MergeResult::Resolved(content) => {
             output.write_all(&content.0)?;

lib/src/files.rs

@@ -167,8 +167,8 @@ struct SyncRegion {
     right: Range<usize>,
 }
 
-pub fn merge(removes: &[&[u8]], adds: &[&[u8]]) -> MergeResult {
-    assert_eq!(adds.len(), removes.len() + 1);
+pub fn merge(slices: Merge<&[u8]>) -> MergeResult {
+    let (removes, adds) = slices.take();
     let num_diffs = removes.len();
     // TODO: Using the first remove as base (first in the inputs) is how it's
     // usually done for 3-way conflicts. Are there better heuristics when there are
@@ -225,6 +225,10 @@ mod tests {
         ContentHunk(data.to_vec())
     }
 
+    fn merge(removes: &[&[u8]], adds: &[&[u8]]) -> MergeResult {
+        super::merge(Merge::new(removes.to_vec(), adds.to_vec()))
+    }
+
     #[test]
     fn test_merge_single_hunk() {
         // Unchanged and empty on all sides

lib/src/tree.rs

@@ -433,20 +433,20 @@ pub fn try_resolve_file_conflict(
             executable,
         }));
     }
-    let contents = file_id_conflict.try_map(|&file_id| -> Result<Vec<u8>, TreeMergeError> {
-        let mut content = vec![];
-        store
-            .read_file(filename, file_id)?
-            .read_to_end(&mut content)
-            .map_err(|err| TreeMergeError::ReadError {
-                source: err,
-                file_id: file_id.clone(),
-            })?;
-        Ok(content)
-    })?;
-    let removed_contents = contents.removes().iter().map(Vec::as_slice).collect_vec();
-    let added_contents = contents.adds().iter().map(Vec::as_slice).collect_vec();
-    let merge_result = files::merge(&removed_contents, &added_contents);
+    let contents: Merge<Vec<u8>> =
+        file_id_conflict.try_map(|&file_id| -> Result<Vec<u8>, TreeMergeError> {
+            let mut content = vec![];
+            store
+                .read_file(filename, file_id)?
+                .read_to_end(&mut content)
+                .map_err(|err| TreeMergeError::ReadError {
+                    source: err,
+                    file_id: file_id.clone(),
+                })?;
+            Ok(content)
+        })?;
+    let slices = contents.map(|content| content.as_slice());
+    let merge_result = files::merge(slices);
     match merge_result {
         MergeResult::Resolved(merged_content) => {
             let id = store.write_file(filename, &mut merged_content.0.as_slice())?;