( )⚙ D9496 copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9496

copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite
ClosedPublic

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

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGecbb2fc9418c: copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite
Summary

The core information that we want here is about "does information from revision
X overwrite information in Y". To do so, we check is X is an ancestors of Y, but
this is an implementation details, they could be other ways. We update the
naming to clarify this (and align more with wording used in upcoming changesets.

For people curious about other ways: for example we could record the overwrite
graph as it happens and reuse that to check if X overwrite Y, without having to
do potential expensive is_ancestor call on the revision graph.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Dec 2 2020, 11:02 AM
baymax updated this revision to Diff 23960.Dec 2 2020, 1:19 PM
Alphare accepted this revision.Dec 14 2020, 4:51 AM
marmoute updated this revision to Diff 24219.Dec 14 2020, 6:17 AM
baymax updated this revision to Diff 24240.Dec 14 2020, 7:48 AM

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

pulkit accepted this revision.Dec 17 2020, 6:16 AM
This revision is now accepted and ready to land.Dec 17 2020, 6:16 AM
baymax updated this revision to Diff 24357.Dec 17 2020, 3:47 PM

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

Revision Contents
Changeset List

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

Diff 24219

rust/hg-core/src/copy_tracing.rs

fn new(func: &'a A) -> Self { fn new(func: &'a A) -> Self {
Self { Self {
inner: func, inner: func,
pairs: HashMap::default(), pairs: HashMap::default(),
} }
} }
/// returns `true` if `anc` is an ancestors of `desc`, `false` otherwise /// returns `true` if `anc` is an ancestors of `desc`, `false` otherwise
fn is_ancestor(&mut self, anc: Revision, desc: Revision) -> bool { fn is_overwrite(&mut self, anc: Revision, desc: Revision) -> bool {
if anc > desc { if anc > desc {
false false
} else if anc == desc { } else if anc == desc {
true true
} else { } else {
if let Some(b) = self.pairs.get(&(anc, desc)) { if let Some(b) = self.pairs.get(&(anc, desc)) {
*b *b
} else { } else {
src_minor: &TimeStampedPathCopy, src_minor: &TimeStampedPathCopy,
src_major: &TimeStampedPathCopy, src_major: &TimeStampedPathCopy,
) -> MergePick { ) -> MergePick {
if src_major.path == src_minor.path { 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_ancestor(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
} }
} else if src_major.rev == src_minor.rev { } else if src_major.rev == src_minor.rev {
// We cannot get copy information for both p1 and p2 in the // We cannot get copy information for both p1 and p2 in the
// same rev. So this is the same value. // same rev. So this is the same value.
unreachable!( unreachable!(
// salvaged by the merge, unconditionnaly preserve the // salvaged by the merge, unconditionnaly preserve the
// major side. // major side.
MergePick::Major MergePick::Major
} else if action == MergeCase::Merged { } else if action == MergeCase::Merged {
// If the file was actively merged, copy information // If the file was actively merged, copy information
// from each side might conflict. The major side will // from each side might conflict. The major side will
// win such conflict. // win such conflict.
MergePick::Major MergePick::Major
} else if oracle.is_ancestor(src_major.rev, src_minor.rev) { } else if oracle.is_overwrite(src_major.rev, src_minor.rev) {
// If the minor side is strictly newer than the major // If the minor side is strictly newer than the major
// side, it should be kept. // side, it should be kept.
MergePick::Minor MergePick::Minor
} else if src_major.path.is_some() { } else if src_major.path.is_some() {
// without any special case, the "major" value win // without any special case, the "major" value win
// other the "minor" one. // other the "minor" one.
MergePick::Major MergePick::Major
} else if oracle.is_ancestor(src_minor.rev, src_major.rev) { } else if oracle.is_overwrite(src_minor.rev, src_major.rev) {
// the "major" rev is a direct ancestors of "minor", // the "major" rev is a direct ancestors of "minor",
// any different value should // any different value should
// overwrite // overwrite
MergePick::Major MergePick::Major
} else { } else {
// major version is None (so the file was deleted on // major version is None (so the file was deleted on
// that branch) and that branch is independant (neither // that branch) and that branch is independant (neither
// minor nor major is an ancestors of the other one.) // minor nor major is an ancestors of the other one.)
// We preserve the new // We preserve the new
// information about the new file. // information about the new file.
MergePick::Minor MergePick::Minor
} }
} }
} }