( )⚙ D9498 copies-rust: make the comparison aware of the revision being current merged

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9498

copies-rust: make the comparison aware of the revision being current merged
ClosedPublic

Authored by marmoute on Dec 2 2020, 11:03 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG7d99614b7b77: copies-rust: make the comparison aware of the revision being current merged
Summary

This make no significant performance change in practice (all ±2%) in practice,
but it will help us to distinct between some semantically different cases later
on.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Dec 2 2020, 11:03 AM
baymax updated this revision to Diff 23962.Dec 2 2020, 1:19 PM
Alphare accepted this revision.Dec 14 2020, 4:56 AM
marmoute updated this revision to Diff 24221.Dec 14 2020, 6:17 AM
baymax updated this revision to Diff 24242.Dec 14 2020, 7:48 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 24359.Dec 17 2020, 3:47 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

pulkit accepted this revision.Dec 18 2020, 7:40 AM
This revision is now accepted and ready to land.Dec 18 2020, 7:40 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/copy_tracing.rs (32 lines)

Diff 24429

rust/hg-core/src/copy_tracing.rs

None => Some(vertex_copies), None => Some(vertex_copies),
// Merge has two parents needs to combines their copy // Merge has two parents needs to combines their copy
// information. // information.
// //
// If we got data from both parents, We need to combine // If we got data from both parents, We need to combine
// them. // them.
Some(copies) => Some(merge_copies_dict( Some(copies) => Some(merge_copies_dict(
&path_map, &path_map,
rev,
vertex_copies, vertex_copies,
copies, copies,
&changes, &changes,
&mut oracle, &mut oracle,
)), )),
}; };
} }
} }
} }
/// merge two copies-mapping together, minor and major /// merge two copies-mapping together, minor and major
/// ///
/// In case of conflict, value from "major" will be picked, unless in some /// In case of conflict, value from "major" will be picked, unless in some
/// cases. See inline documentation for details. /// cases. See inline documentation for details.
fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>( fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>(
path_map: &TwoWayPathMap, path_map: &TwoWayPathMap,
current_merge: Revision,
mut minor: TimeStampedPathCopies, mut minor: TimeStampedPathCopies,
mut major: TimeStampedPathCopies, mut major: TimeStampedPathCopies,
changes: &ChangedFiles, changes: &ChangedFiles,
oracle: &mut AncestorOracle<A>, oracle: &mut AncestorOracle<A>,
) -> TimeStampedPathCopies { ) -> TimeStampedPathCopies {
// This closure exist as temporary help while multiple developper are // This closure exist as temporary help while multiple developper are
// actively working on this code. Feel free to re-inline it once this // actively working on this code. Feel free to re-inline it once this
// code is more settled. // code is more settled.
let mut cmp_value = let mut cmp_value =
|dest: &PathToken, |dest: &PathToken,
src_minor: &TimeStampedPathCopy, src_minor: &TimeStampedPathCopy,
src_major: &TimeStampedPathCopy| { src_major: &TimeStampedPathCopy| {
compare_value( compare_value(
path_map, changes, oracle, dest, src_minor, src_major, path_map,
current_merge,
changes,
oracle,
dest,
src_minor,
src_major,
) )
}; };
if minor.is_empty() { if minor.is_empty() {
major major
} else if major.is_empty() { } else if major.is_empty() {
minor minor
} else if minor.len() * 2 < major.len() { } else if minor.len() * 2 < major.len() {
// Lets says we are merging two TimeStampedPathCopies instance A and B. // Lets says we are merging two TimeStampedPathCopies instance A and B.
/// Any side could be used (because they are the same) /// Any side could be used (because they are the same)
Any, Any,
} }
/// decide which side prevails in case of conflicting values /// decide which side prevails in case of conflicting values
#[allow(clippy::if_same_then_else)] #[allow(clippy::if_same_then_else)]
fn compare_value<A: Fn(Revision, Revision) -> bool>( fn compare_value<A: Fn(Revision, Revision) -> bool>(
path_map: &TwoWayPathMap, path_map: &TwoWayPathMap,
current_merge: Revision,
changes: &ChangedFiles, changes: &ChangedFiles,
oracle: &mut AncestorOracle<A>, oracle: &mut AncestorOracle<A>,
dest: &PathToken, dest: &PathToken,
src_minor: &TimeStampedPathCopy, src_minor: &TimeStampedPathCopy,
src_major: &TimeStampedPathCopy, src_major: &TimeStampedPathCopy,
) -> MergePick { ) -> MergePick {
if src_major.path == src_minor.path { if src_major.rev == current_merge {
if src_minor.rev == current_merge {
if src_major.path.is_none() {
// We cannot get different copy information for both p1 and p2
// from the same revision. Unless this was a
// deletion
MergePick::Any
} else {
unreachable!();
}
} else {
// The last value comes the current merge, this value -will- win
// eventually.
MergePick::Major
}
} else if src_minor.rev == current_merge {
// The last value comes the current merge, this value -will- win
// eventually.
MergePick::Minor
} else if src_major.path == src_minor.path {
// we have the same value, but from other source; // we have the same value, but from other source;
if src_major.rev == src_minor.rev { if src_major.rev == src_minor.rev {
// If the two entry are identical, they are both valid // If the two entry are identical, they are both valid
MergePick::Any MergePick::Any
} else if oracle.is_overwrite(src_major.rev, src_minor.rev) { } else if oracle.is_overwrite(src_major.rev, src_minor.rev) {
MergePick::Minor MergePick::Minor
} else { } else {
MergePick::Major MergePick::Major