copies-rust: pre-indent some code to clarify the next changeset

The next changeset will massively rewrite the next function. However having a
clear diff on the core semantic of the function will help making the next
changesets clearer. So we do most of the churn beforehand.

Differential Revision: https://phab.mercurial-scm.org/D9301

rust/hg-core/src/copy_tracing.rs

@@ -1,264 +1,269 b''
 use crate::utils::hg_path::HgPathBuf;
 use crate::Revision;
 
 use im_rc::ordmap::OrdMap;
 
 use std::collections::HashMap;
 use std::collections::HashSet;
 
 pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;
 
 #[derive(Clone, Debug)]
 struct TimeStampedPathCopy {
     /// revision at which the copy information was added
     rev: Revision,
     /// the copy source, (Set to None in case of deletion of the associated
     /// key)
     path: Option<HgPathBuf>,
 }
 
 /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
 type TimeStampedPathCopies = OrdMap<HgPathBuf, TimeStampedPathCopy>;
 
 /// hold parent 1, parent 2 and relevant files actions.
 pub type RevInfo = (Revision, Revision, ChangedFiles);
 
 /// represent the files affected by a changesets
 ///
 /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need
 /// all the data categories tracked by it.
 pub struct ChangedFiles {
     removed: HashSet<HgPathBuf>,
     merged: HashSet<HgPathBuf>,
     salvaged: HashSet<HgPathBuf>,
     copied_from_p1: PathCopies,
     copied_from_p2: PathCopies,
 }
 
 impl ChangedFiles {
     pub fn new(
         removed: HashSet<HgPathBuf>,
         merged: HashSet<HgPathBuf>,
         salvaged: HashSet<HgPathBuf>,
         copied_from_p1: PathCopies,
         copied_from_p2: PathCopies,
     ) -> Self {
         ChangedFiles {
             removed,
             merged,
             salvaged,
             copied_from_p1,
             copied_from_p2,
         }
     }
 
     pub fn new_empty() -> Self {
         ChangedFiles {
             removed: HashSet::new(),
             merged: HashSet::new(),
             salvaged: HashSet::new(),
             copied_from_p1: PathCopies::new(),
             copied_from_p2: PathCopies::new(),
         }
     }
 }
 
 /// Same as mercurial.copies._combine_changeset_copies, but in Rust.
 ///
 /// Arguments are:
 ///
 /// revs: all revisions to be considered
 /// children: a {parent ? [childrens]} mapping
 /// target_rev: the final revision we are combining copies to
 /// rev_info(rev): callback to get revision information:
 ///   * first parent
 ///   * second parent
 ///   * ChangedFiles
 /// isancestors(low_rev, high_rev): callback to check if a revision is an
 ///                                 ancestor of another
 pub fn combine_changeset_copies(
     revs: Vec<Revision>,
     children: HashMap<Revision, Vec<Revision>>,
     target_rev: Revision,
     rev_info: &impl Fn(Revision) -> RevInfo,
     is_ancestor: &impl Fn(Revision, Revision) -> bool,
 ) -> PathCopies {
     let mut all_copies = HashMap::new();
 
     for rev in revs {
         // Retrieve data computed in a previous iteration
         let copies = all_copies.remove(&rev);
         let copies = match copies {
             Some(c) => c,
             None => TimeStampedPathCopies::default(), // root of the walked set
         };
 
         let current_children = match children.get(&rev) {
             Some(c) => c,
             None => panic!("inconsistent `revs` and `children`"),
         };
 
         for child in current_children {
             // We will chain the copies information accumulated for `rev` with
             // the individual copies information for each of its children.
             // Creating a new PathCopies for each `rev` ? `children` vertex.
             let (p1, p2, changes) = rev_info(*child);
 
             let (parent, child_copies) = if rev == p1 {
                 (1, &changes.copied_from_p1)
             } else {
                 assert_eq!(rev, p2);
                 (2, &changes.copied_from_p2)
             };
             let mut new_copies = copies.clone();
 
             for (dest, source) in child_copies {
                 let entry;
                 if let Some(v) = copies.get(source) {
                     entry = match &v.path {
                         Some(path) => Some((*(path)).to_owned()),
                         None => Some(source.to_owned()),
                     }
                 } else {
                     entry = Some(source.to_owned());
                 }
                 // Each new entry is introduced by the children, we record this
                 // information as we will need it to take the right decision
                 // when merging conflicting copy information. See
                 // merge_copies_dict for details.
                 let ttpc = TimeStampedPathCopy {
                     rev: *child,
                     path: entry,
                 };
                 new_copies.insert(dest.to_owned(), ttpc);
             }
 
             // We must drop copy information for removed file.
             //
             // We need to explicitly record them as dropped to propagate this
             // information when merging two TimeStampedPathCopies object.
             for f in changes.removed.iter() {
                 if new_copies.contains_key(f.as_ref()) {
                     let ttpc = TimeStampedPathCopy {
                         rev: *child,
                         path: None,
                     };
                     new_copies.insert(f.to_owned(), ttpc);
                 }
             }
 
             // Merge has two parents needs to combines their copy information.
             //
             // If the vertex from the other parent was already processed, we
             // will have a value for the child ready to be used. We need to
             // grab it and combine it with the one we already
             // computed. If not we can simply store the newly
             // computed data. The processing happening at
             // the time of the second parent will take care of combining the
             // two TimeStampedPathCopies instance.
             match all_copies.remove(child) {
                 None => {
                     all_copies.insert(child, new_copies);
                 }
                 Some(other_copies) => {
                     let (minor, major) = match parent {
                         1 => (other_copies, new_copies),
                         2 => (new_copies, other_copies),
                         _ => unreachable!(),
                     };
                     let merged_copies =
                         merge_copies_dict(minor, major, &changes, is_ancestor);
                     all_copies.insert(child, merged_copies);
                 }
             };
         }
     }
 
     // Drop internal information (like the timestamp) and return the final
     // mapping.
     let tt_result = all_copies
         .remove(&target_rev)
         .expect("target revision was not processed");
     let mut result = PathCopies::default();
     for (dest, tt_source) in tt_result {
         if let Some(path) = tt_source.path {
             result.insert(dest, path);
         }
     }
     result
 }
 
 /// merge two copies-mapping together, minor and major
 ///
 /// In case of conflict, value from "major" will be picked, unless in some
 /// cases. See inline documentation for details.
 #[allow(clippy::if_same_then_else)]
 fn merge_copies_dict(
     minor: TimeStampedPathCopies,
     major: TimeStampedPathCopies,
     changes: &ChangedFiles,
     is_ancestor: &impl Fn(Revision, Revision) -> bool,
 ) -> TimeStampedPathCopies {
     let mut result = minor.clone();
     for (dest, src_major) in major {
         let overwrite;
         if let Some(src_minor) = minor.get(&dest) {
-            if src_major.path == src_minor.path {
-                // we have the same value, but from other source;
-                if src_major.rev == src_minor.rev {
-                    // If the two entry are identical, no need to do anything
+            {
+                if src_major.path == src_minor.path {
+                    // we have the same value, no need to battle;
+                    if src_major.rev == src_minor.rev {
+                        // If the two entry are identical, no need to do
+                        // anything
+                        overwrite = false;
+                    } else if is_ancestor(src_major.rev, src_minor.rev) {
+                        overwrite = false;
+                    } else {
+                        overwrite = true;
+                    }
+                } else if src_major.rev == src_minor.rev {
+                    // We cannot get copy information for both p1 and p2 in the
+                    // same rev. So this is the same value.
+                    overwrite = false;
+                } else if src_major.path.is_none()
+                    && changes.salvaged.contains(&dest)
+                {
+                    // If the file is "deleted" in the major side but was
+                    // salvaged by the merge, we keep the minor side alive
                     overwrite = false;
+                } else if src_minor.path.is_none()
+                    && changes.salvaged.contains(&dest)
+                {
+                    // If the file is "deleted" in the minor side but was
+                    // salvaged by the merge, unconditionnaly preserve the
+                    // major side.
+                    overwrite = true;
+                } else if changes.merged.contains(&dest) {
+                    // If the file was actively merged, copy information from
+                    // each side might conflict.  The major side will win such
+                    // conflict.
+                    overwrite = true;
                 } else if is_ancestor(src_major.rev, src_minor.rev) {
+                    // If the minor side is strictly newer than the major side,
+                    // it should be kept.
                     overwrite = false;
+                } else if src_major.path.is_some() {
+                    // without any special case, the "major" value win other
+                    // the "minor" one.
+                    overwrite = true;
+                } else if is_ancestor(src_minor.rev, src_major.rev) {
+                    // the "major" rev is a direct ancestors of "minor", any
+                    // different value should overwrite
+                    overwrite = true;
                 } else {
-                    overwrite = true;
+                    // major version is None (so the file was deleted on that
+                    // branch) and that branch is independant (neither minor
+                    // nor major is an ancestors of the other one.) We preserve
+                    // the new information about the new file.
+                    overwrite = false;
                 }
-            } else if src_major.rev == src_minor.rev {
-                // We cannot get copy information for both p1 and p2 in the
-                // same rev. So this is the same value.
-                overwrite = false;
-            } else if src_major.path.is_none()
-                && changes.salvaged.contains(&dest)
-            {
-                // If the file is "deleted" in the major side but was salvaged
-                // by the merge, we keep the minor side alive
-                overwrite = false;
-            } else if src_minor.path.is_none()
-                && changes.salvaged.contains(&dest)
-            {
-                // If the file is "deleted" in the minor side but was salvaged
-                // by the merge, unconditionnaly preserve the major side.
-                overwrite = true;
-            } else if changes.merged.contains(&dest) {
-                // If the file was actively merged, copy information from each
-                // side might conflict. The major side will win such conflict.
-                overwrite = true;
-            } else if is_ancestor(src_major.rev, src_minor.rev) {
-                // If the minor side is strictly newer than the major side, it
-                // should be kept.
-                overwrite = false;
-            } else if src_major.path.is_some() {
-                // without any special case, the "major" value win other the
-                // "minor" one.
-                overwrite = true;
-            } else if is_ancestor(src_minor.rev, src_major.rev) {
-                // the "major" rev is a direct ancestors of "minor", any
-                // different value should overwrite
-                overwrite = true;
-            } else {
-                // major version is None (so the file was deleted on that
-                // branch) annd that branch is independant (neither minor nor
-                // major is an ancestors of the other one.) We preserve the new
-                // information about the new file.
-                overwrite = false;
             }
         } else {
             // minor had no value
             overwrite = true;
         }
         if overwrite {
             result.insert(dest, src_major);
         }
     }
     result
 }