This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9613

copies: detect case when a merge decision overwrite previous data
ClosedPublic

Authored by marmoute on Dec 15 2020, 4:07 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc19c662097e1: copies: detect case when a merge decision overwrite previous data
rHG740234aca875: copies: detect case when a merge decision overwrite previous data
Summary

We now detect and record when a merge case required special logic (eg: thing
that append during the merge, ambiguity leading to picking p1 data, etc) and we
explicitly mark the result as superseding the previous data.

This fixes the family of test we previously added.

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 15 2020, 4:07 AM
baymax updated this revision to Diff 24285.Dec 15 2020, 11:43 AM

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

baymax updated this revision to Diff 24376.Dec 17 2020, 4:04 PM

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

baymax updated this revision to Diff 24403.Dec 18 2020, 9:12 AM

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

baymax updated this revision to Diff 24410.Dec 18 2020, 9:32 AM

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

baymax updated this revision to Diff 24418.Dec 18 2020, 9:55 AM

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

baymax updated this revision to Diff 24456.Dec 21 2020, 3:00 AM

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

baymax updated this revision to Diff 24572.Jan 5 2021, 3:38 AM

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

baymax updated this revision to Diff 24595.Jan 5 2021, 9:02 AM

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

Alphare accepted this revision.Jan 8 2021, 6:10 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/copies.py
500

typo

rust/hg-core/src/copy_tracing.rs
768

Please add a small mention of the override in the docstring

baymax updated this revision to Diff 24636.Jan 8 2021, 10:25 AM

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

marmoute updated this revision to Diff 25737.Feb 22 2021, 9:35 AM
baymax updated this revision to Diff 25739.Feb 22 2021, 10:27 AM

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

baymax updated this revision to Diff 25778.Feb 22 2021, 2:45 PM

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

marmoute added a commit: rHG740234aca875: copies: detect case when a merge decision overwrite previous data.Feb 24 2021, 11:00 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG740234aca875: copies: detect case when a merge decision overwrite previous data (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25843

mercurial/copies.py

# work with the other. # work with the other.
# #
# In case of conflict, parent 1 take precedence over parent 2. # In case of conflict, parent 1 take precedence over parent 2.
# This is an arbitrary choice made anew when implementing # This is an arbitrary choice made anew when implementing
# changeset based copies. It was made without regards with # changeset based copies. It was made without regards with
# potential filelog related behavior. # potential filelog related behavior.
assert parent == 2 assert parent == 2
current_copies = _merge_copies_dict( current_copies = _merge_copies_dict(
newcopies, current_copies, isancestor, changes newcopies,
current_copies,
isancestor,
changes,
current_rev,
) )
all_copies[current_rev] = current_copies all_copies[current_rev] = current_copies
# filter out internal details and return a {dest: source mapping} # filter out internal details and return a {dest: source mapping}
final_copies = {} final_copies = {}
for dest, (tt, source) in all_copies[targetrev].items(): for dest, (tt, source) in all_copies[targetrev].items():
if source is not None: if source is not None:
final_copies[dest] = source final_copies[dest] = source
if not alwaysmatch: if not alwaysmatch:
for filename in list(final_copies.keys()): for filename in list(final_copies.keys()):
if not match(filename): if not match(filename):
del final_copies[filename] del final_copies[filename]
return final_copies return final_copies
# constant to decide which side to pick with _merge_copies_dict # constant to decide which side to pick with _merge_copies_dict
PICK_MINOR = 0 PICK_MINOR = 0
PICK_MAJOR = 1 PICK_MAJOR = 1
PICK_EITHER = 2 PICK_EITHER = 2
def _merge_copies_dict(minor, major, isancestor, changes): def _merge_copies_dict(minor, major, isancestor, changes, current_merge):
"""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. In case of conflict, value from "major" will be picked.
- `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an - `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an
ancestors of `high_rev`, ancestors of `high_rev`,
- `ismerged(path)`: callable return True if `path` have been merged in the - `ismerged(path)`: callable return True if `path` have been merged in the
current revision, current revision,
return the resulting dict (in practice, the "minor" object, updated) return the resulting dict (in practice, the "minor" object, updated)
""" """
for dest, value in major.items(): for dest, value in major.items():
other = minor.get(dest) other = minor.get(dest)
if other is None: if other is None:
minor[dest] = value minor[dest] = value
else: else:
pick = _compare_values(changes, isancestor, dest, other, value) pick, overwrite = _compare_values(
changes, isancestor, dest, other, value
)
if overwrite:
if pick == PICK_MAJOR: if pick == PICK_MAJOR:
minor[dest] = (current_merge, value[1])
else:
minor[dest] = (current_merge, other[1])
elif pick == PICK_MAJOR:
minor[dest] = value minor[dest] = value
return minor return minor
def _compare_values(changes, isancestor, dest, minor, major): def _compare_values(changes, isancestor, dest, minor, major):
"""compare two value within a _merge_copies_dict loop iteration """compare two value within a _merge_copies_dict loop iteration
return pick return (pick, overwrite).
- pick is one of PICK_MINOR, PICK_MAJOR or PICK_EITHER - pick is one of PICK_MINOR, PICK_MAJOR or PICK_EITHER
- overwrite is True if pick is a return of an ambiguity that needs resolution.
AlphareUnsubmitted
Not Done

typo

Alphare: typo
""" """
major_tt, major_value = major major_tt, major_value = major
minor_tt, minor_value = minor minor_tt, minor_value = minor
if major_tt == minor_tt: if major_tt == minor_tt:
# if it comes from the same revision it must be the same value # if it comes from the same revision it must be the same value
assert major_value == minor_value assert major_value == minor_value
return PICK_EITHER return PICK_EITHER, False
elif ( elif (
changes is not None changes is not None
and minor_value is not None and minor_value is not None
and major_value is None and major_value is None
and dest in changes.salvaged and dest in changes.salvaged
): ):
# In this case, a deletion was reverted, the "alive" value overwrite # In this case, a deletion was reverted, the "alive" value overwrite
# the deleted one. # the deleted one.
return PICK_MINOR return PICK_MINOR, True
elif ( elif (
changes is not None changes is not None
and major_value is not None and major_value is not None
and minor_value is None and minor_value is None
and dest in changes.salvaged and dest in changes.salvaged
): ):
# In this case, a deletion was reverted, the "alive" value overwrite # In this case, a deletion was reverted, the "alive" value overwrite
# the deleted one. # the deleted one.
return PICK_MAJOR return PICK_MAJOR, True
elif isancestor(minor_tt, major_tt): elif isancestor(minor_tt, major_tt):
if changes is not None and dest in changes.merged: if changes is not None and dest in changes.merged:
# change to dest happened on the branch without copy-source change, # change to dest happened on the branch without copy-source change,
# so both source are valid and "major" wins. # so both source are valid and "major" wins.
return PICK_MAJOR return PICK_MAJOR, True
else: else:
return PICK_MAJOR return PICK_MAJOR, False
elif isancestor(major_tt, minor_tt): elif isancestor(major_tt, minor_tt):
if changes is not None and dest in changes.merged: if changes is not None and dest in changes.merged:
# change to dest happened on the branch without copy-source change, # change to dest happened on the branch without copy-source change,
# so both source are valid and "major" wins. # so both source are valid and "major" wins.
return PICK_MAJOR return PICK_MAJOR, True
else: else:
return PICK_MINOR return PICK_MINOR, False
elif minor_value is None: elif minor_value is None:
# in case of conflict, the "alive" side wins. # in case of conflict, the "alive" side wins.
return PICK_MAJOR return PICK_MAJOR, True
elif major_value is None: elif major_value is None:
# in case of conflict, the "alive" side wins. # in case of conflict, the "alive" side wins.
return PICK_MINOR return PICK_MINOR, True
else: else:
# in case of conflict where both side are alive, major wins. # in case of conflict where both side are alive, major wins.
return PICK_MAJOR return PICK_MAJOR, True
def _revinfo_getter_extra(repo): def _revinfo_getter_extra(repo):
"""return a function that return multiple data given a <rev>"i """return a function that return multiple data given a <rev>"i
* p1: revision number of first parent * p1: revision number of first parent
* p2: revision number of first parent * p2: revision number of first parent
* p1copies: mapping of copies from p1 * p1copies: mapping of copies from p1

rust/hg-core/src/copy_tracing.rs

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 cmp_value = |oracle: &mut AncestorOracle<A>,
|dest: &PathToken, dest: &PathToken,
src_minor: &TimeStampedPathCopy, src_minor: &TimeStampedPathCopy,
src_major: &TimeStampedPathCopy| { src_major: &TimeStampedPathCopy| {
compare_value( compare_value(
path_map, path_map,
current_merge, current_merge,
changes, changes,
oracle, oracle,
dest, dest,
src_minor, src_minor,
src_major, 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.
// //
// If A contains N items, the merge result will never contains more // If A contains N items, the merge result will never contains more
// than N values differents than the one in A // than N values differents than the one in A
// //
// If B contains M items, with M > N, the merge result will always // If B contains M items, with M > N, the merge result will always
// result in a minimum of M - N value differents than the on in // result in a minimum of M - N value differents than the on in
// A // A
// //
// As a result, if N < (M-N), we know that simply iterating over A will // As a result, if N < (M-N), we know that simply iterating over A will
// yield less difference than iterating over the difference // yield less difference than iterating over the difference
// between A and B. // between A and B.
// //
// This help performance a lot in case were a tiny // This help performance a lot in case were a tiny
// TimeStampedPathCopies is merged with a much larger one. // TimeStampedPathCopies is merged with a much larger one.
for (dest, src_minor) in minor { for (dest, src_minor) in minor {
let src_major = major.get(&dest); let src_major = major.get(&dest);
match src_major { match src_major {
None => major.insert(dest, src_minor), None => {
major.insert(dest, src_minor);
}
Some(src_major) => { Some(src_major) => {
match cmp_value(&dest, &src_minor, src_major) { let (pick, overwrite) =
cmp_value(oracle, &dest, &src_minor, src_major);
if overwrite {
oracle.record_overwrite(src_minor.rev, current_merge);
oracle.record_overwrite(src_major.rev, current_merge);
let path = match pick {
MergePick::Major => src_major.path,
MergePick::Minor => src_minor.path,
MergePick::Any => src_major.path,
};
let src = TimeStampedPathCopy {
rev: current_merge,
path,
};
major.insert(dest, src);
} else {
match pick {
MergePick::Any | MergePick::Major => None, MergePick::Any | MergePick::Major => None,
MergePick::Minor => major.insert(dest, src_minor), MergePick::Minor => major.insert(dest, src_minor),
};
} }
} }
}; };
} }
major major
} else if major.len() * 2 < minor.len() { } else if major.len() * 2 < minor.len() {
// This use the same rational than the previous block. // This use the same rational than the previous block.
// (Check previous block documentation for details.) // (Check previous block documentation for details.)
for (dest, src_major) in major { for (dest, src_major) in major {
let src_minor = minor.get(&dest); let src_minor = minor.get(&dest);
match src_minor { match src_minor {
None => minor.insert(dest, src_major), None => {
minor.insert(dest, src_major);
}
Some(src_minor) => { Some(src_minor) => {
match cmp_value(&dest, src_minor, &src_major) { let (pick, overwrite) =
MergePick::Any | MergePick::Minor => None, cmp_value(oracle, &dest, &src_major, src_minor);
MergePick::Major => minor.insert(dest, src_major), if overwrite {
oracle.record_overwrite(src_minor.rev, current_merge);
oracle.record_overwrite(src_major.rev, current_merge);
let path = match pick {
MergePick::Major => src_minor.path,
MergePick::Minor => src_major.path,
MergePick::Any => src_major.path,
};
let src = TimeStampedPathCopy {
rev: current_merge,
path,
};
minor.insert(dest, src);
} else {
match pick {
MergePick::Any | MergePick::Major => None,
MergePick::Minor => minor.insert(dest, src_major),
};
} }
} }
}; };
} }
minor minor
} else { } else {
let mut override_minor = Vec::new(); let mut override_minor = Vec::new();
let mut override_major = Vec::new(); let mut override_major = Vec::new();
// differently. // differently.
for d in minor.diff(&major) { for d in minor.diff(&major) {
match d { match d {
DiffItem::Add(k, v) => to_minor(k, v), DiffItem::Add(k, v) => to_minor(k, v),
DiffItem::Remove(k, v) => to_major(k, v), DiffItem::Remove(k, v) => to_major(k, v),
DiffItem::Update { old, new } => { DiffItem::Update { old, new } => {
let (dest, src_major) = new; let (dest, src_major) = new;
let (_, src_minor) = old; let (_, src_minor) = old;
match cmp_value(dest, src_minor, src_major) { let (pick, overwrite) =
cmp_value(oracle, dest, src_minor, src_major);
if overwrite {
oracle.record_overwrite(src_minor.rev, current_merge);
oracle.record_overwrite(src_major.rev, current_merge);
let path = match pick {
MergePick::Major => src_major.path,
MergePick::Minor => src_minor.path,
// If the two entry are identical, no need to do
// anything (but diff should not have yield them)
MergePick::Any => src_major.path,
};
let src = TimeStampedPathCopy {
rev: current_merge,
path,
};
to_minor(dest, &src);
to_major(dest, &src);
} else {
match pick {
MergePick::Major => to_minor(dest, src_major), MergePick::Major => to_minor(dest, src_major),
MergePick::Minor => to_major(dest, src_minor), MergePick::Minor => to_major(dest, src_minor),
// If the two entry are identical, no need to do // If the two entry are identical, no need to do
// anything (but diff should not have yield them) // anything (but diff should not have yield them)
MergePick::Any => unreachable!(), MergePick::Any => unreachable!(),
} }
} }
}
}; };
} }
let updates; let updates;
let mut result; let mut result;
if override_major.is_empty() { if override_major.is_empty() {
result = major result = major
} else if override_minor.is_empty() { } else if override_minor.is_empty() {
/// The "major" (p1) side prevails /// The "major" (p1) side prevails
Major, Major,
/// The "minor" (p2) side prevails /// The "minor" (p2) side prevails
Minor, Minor,
/// 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
AlphareUnsubmitted
Not Done

Please add a small mention of the override in the docstring

Alphare: Please add a small mention of the override in the docstring
#[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, 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, bool) {
if src_major.rev == current_merge { if src_major.rev == current_merge {
if src_minor.rev == current_merge { if src_minor.rev == current_merge {
if src_major.path.is_none() { if src_major.path.is_none() {
// We cannot get different copy information for both p1 and p2 // We cannot get different copy information for both p1 and p2
// from the same revision. Unless this was a // from the same revision. Unless this was a
// deletion // deletion
MergePick::Any (MergePick::Any, false)
} else { } else {
unreachable!(); unreachable!();
} }
} else { } else {
// The last value comes the current merge, this value -will- win // The last value comes the current merge, this value -will- win
// eventually. // eventually.
oracle.record_overwrite(src_minor.rev, src_major.rev); (MergePick::Major, true)
MergePick::Major
} }
} else if src_minor.rev == current_merge { } else if src_minor.rev == current_merge {
// The last value comes the current merge, this value -will- win // The last value comes the current merge, this value -will- win
// eventually. // eventually.
oracle.record_overwrite(src_major.rev, src_minor.rev); (MergePick::Minor, true)
MergePick::Minor
} else if src_major.path == src_minor.path { } 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, false)
} 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, false)
} else if oracle.is_overwrite(src_minor.rev, src_major.rev) { } else if oracle.is_overwrite(src_minor.rev, src_major.rev) {
MergePick::Major (MergePick::Major, false)
} else { } else {
MergePick::Major (MergePick::Any, true)
} }
} 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!(
"conflicting information from p1 and p2 in the same revision" "conflicting information from p1 and p2 in the same revision"
); );
} else { } else {
let dest_path = path_map.untokenize(*dest); let dest_path = path_map.untokenize(*dest);
let action = changes.get_merge_case(dest_path); let action = changes.get_merge_case(dest_path);
if src_minor.path.is_some() if src_minor.path.is_some()
&& src_major.path.is_none() && src_major.path.is_none()
&& action == MergeCase::Salvaged && action == MergeCase::Salvaged
{ {
// If the file is "deleted" in the major side but was // If the file is "deleted" in the major side but was
// salvaged by the merge, we keep the minor side alive // salvaged by the merge, we keep the minor side alive
MergePick::Minor (MergePick::Minor, true)
} else if src_major.path.is_some() } else if src_major.path.is_some()
&& src_minor.path.is_none() && src_minor.path.is_none()
&& action == MergeCase::Salvaged && action == MergeCase::Salvaged
{ {
// If the file is "deleted" in the minor side but was // If the file is "deleted" in the minor side but was
// salvaged by the merge, unconditionnaly preserve the // salvaged by the merge, unconditionnaly preserve the
// major side. // major side.
MergePick::Major (MergePick::Major, true)
} else if oracle.is_overwrite(src_minor.rev, src_major.rev) { } else if oracle.is_overwrite(src_minor.rev, src_major.rev) {
// The information from the minor version are strictly older than // The information from the minor version are strictly older than
// the major version // the major version
if action == MergeCase::Merged { if action == MergeCase::Merged {
// If the file was actively merged, its means some non-copy // If the file was actively merged, its means some non-copy
// activity happened on the other branch. It // activity happened on the other branch. It
// mean the older copy information are still relevant. // mean the older copy information are still relevant.
// //
// The major side wins such conflict. // The major side wins such conflict.
MergePick::Major (MergePick::Major, true)
} else { } else {
// No activity on the minor branch, pick the newer one. // No activity on the minor branch, pick the newer one.
MergePick::Major (MergePick::Major, false)
} }
} else if oracle.is_overwrite(src_major.rev, src_minor.rev) { } else if oracle.is_overwrite(src_major.rev, src_minor.rev) {
if action == MergeCase::Merged { if action == MergeCase::Merged {
// If the file was actively merged, its means some non-copy // If the file was actively merged, its means some non-copy
// activity happened on the other branch. It // activity happened on the other branch. It
// mean the older copy information are still relevant. // mean the older copy information are still relevant.
// //
// The major side wins such conflict. // The major side wins such conflict.
MergePick::Major (MergePick::Major, true)
} else { } else {
// No activity on the minor branch, pick the newer one. // No activity on the minor branch, pick the newer one.
MergePick::Minor (MergePick::Minor, false)
} }
} else if src_minor.path.is_none() { } else if src_minor.path.is_none() {
// the minor side has no relevant information, pick the alive one // the minor side has no relevant information, pick the alive one
MergePick::Major (MergePick::Major, true)
} else if src_major.path.is_none() { } else if src_major.path.is_none() {
// the major side has no relevant information, pick the alive one // the major side has no relevant information, pick the alive one
MergePick::Minor (MergePick::Minor, true)
} else { } else {
// by default the major side wins // by default the major side wins
MergePick::Major (MergePick::Major, true)
} }
} }
} }

tests/test-copies-chain-merge.t

A f A f
a (filelog !) a (filelog !)
a (sidedata !) a (sidedata !)
a (upgraded !) a (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mK,AEm")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mK,AEm")' f
A f A f
a (filelog !) a (filelog !)
a (missing-correct-output sidedata !) a (sidedata !)
a (missing-correct-output upgraded !) a (upgraded !)
b (known-bad-output sidedata !)
b (known-bad-output upgraded !)
The result from mEAm is the same for the subsequent merge: The result from mEAm is the same for the subsequent merge:
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEAm")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEAm")' f
A f A f
a (filelog !) a (filelog !)
b (sidedata !) b (sidedata !)
b (upgraded !) b (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA,Jm")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA,Jm")' f
A f A f
a (filelog !) a (filelog !)
b (sidedata !) b (sidedata !)
b (upgraded !) b (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mJ,EAm")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mJ,EAm")' f
A f A f
a (filelog !) a (filelog !)
b (missing-correct-output sidedata !) b (sidedata !)
b (missing-correct-output upgraded !) b (upgraded !)
a (known-bad-output sidedata !)
a (known-bad-output upgraded !)
Subcase: chaining conflicting rename resolution Subcase: chaining conflicting rename resolution
``````````````````````````````````````````````` ```````````````````````````````````````````````
The "mPQm" and "mQPm" case create a rename tracking conflict on file 'v'. We The "mPQm" and "mQPm" case create a rename tracking conflict on file 'v'. We
add more change on the respective branch and merge again. These second merge add more change on the respective branch and merge again. These second merge
does not involve the file 'v' and the arbitration done within "mPQm" and "mQP" does not involve the file 'v' and the arbitration done within "mPQm" and "mQP"
about that file should stay unchanged. about that file should stay unchanged.
A v A v
r (filelog !) r (filelog !)
p (sidedata !) p (sidedata !)
p (upgraded !) p (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mT,PQm")' v $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mT,PQm")' v
A v A v
r (filelog !) r (filelog !)
p (missing-correct-output sidedata !) p (sidedata !)
p (missing-correct-output upgraded !) p (upgraded !)
r (known-bad-output sidedata !)
r (known-bad-output upgraded !)
The result from mQPm is the same for the subsequent merge: The result from mQPm is the same for the subsequent merge:
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mQPm")' v $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mQPm")' v
A v A v
r (no-changeset no-compatibility !) r (no-changeset no-compatibility !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mQP,Sm")' v $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mQP,Sm")' v
A v A v
r (no-changeset no-compatibility !) r (no-changeset no-compatibility !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mS,QPm")' v $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mS,QPm")' v
A v A v
r (filelog !) r (filelog !)
r (missing-correct-output sidedata !) r (sidedata !)
r (missing-correct-output upgraded !) r (upgraded !)
p (known-bad-output sidedata !)
p (known-bad-output upgraded !)
Subcase: chaining salvage information during a merge Subcase: chaining salvage information during a merge
```````````````````````````````````````````````````` ````````````````````````````````````````````````````
We add more change on the branch were the file was deleted. merging again We add more change on the branch were the file was deleted. merging again
should preserve the fact eh file was salvaged. should preserve the fact eh file was salvaged.
reference output: reference output:
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mCB-revert-m-0")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mCB-revert-m-0")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (sidedata !)
a (upgraded !)
A t A t
p p
R a R a
R p R p
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mBC-revert-m-0")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mBC-revert-m-0")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (sidedata !)
a (upgraded !)
A t A t
p p
R a R a
R p R p
chained output chained output
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mBC+revert,Lm")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mBC+revert,Lm")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
A t A t
p p
A unrelated-l A unrelated-l
R a R a
R p R p
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mCB+revert,Lm")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mCB+revert,Lm")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
A t A t
p p
A unrelated-l A unrelated-l
R a R a
R p R p
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mL,BC+revertm")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mL,BC+revertm")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
A t A t
p p
A unrelated-l A unrelated-l
R a R a
R p R p
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mL,CB+revertm")' $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mL,CB+revertm")'
M b M b
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
A t A t
p p
A unrelated-l A unrelated-l
R a R a
R p R p
Subcase: chaining "merged" information during a merge Subcase: chaining "merged" information during a merge
`````````````````````````````````````````````````````` ``````````````````````````````````````````````````````
A d A d
a (filelog !) a (filelog !)
h (sidedata !) h (sidedata !)
h (upgraded !) h (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mGF,Nm")' d $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mGF,Nm")' d
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
h (known-bad-output sidedata !)
h (known-bad-output upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mN,GFm")' d $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mN,GFm")' d
A d A d
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
h (known-bad-output sidedata !)
h (known-bad-output upgraded !)
Subcase: chaining conflicting rename resolution, with extra change during the merge Subcase: chaining conflicting rename resolution, with extra change during the merge
``````````````````````````````````````````````````````````````````````````````````` ```````````````````````````````````````````````````````````````````````````````````
The "mAEm" and "mEAm" case create a rename tracking conflict on file 'f'. We The "mAEm" and "mEAm" case create a rename tracking conflict on file 'f'. We
add more change on the respective branch and merge again. These second merge add more change on the respective branch and merge again. These second merge
does not involve the file 'f' and the arbitration done within "mAEm" and "mEA" does not involve the file 'f' and the arbitration done within "mAEm" and "mEA"
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mAE-change,Km")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mAE-change,Km")' f
A f A f
a (filelog !) a (filelog !)
a (sidedata !) a (sidedata !)
a (upgraded !) a (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mK,AE-change-m")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mK,AE-change-m")' f
A f A f
a (filelog !) a (no-changeset no-compatibility !)
a (missing-correct-output sidedata !)
a (missing-correct-output upgraded !)
b (known-bad-output sidedata !)
b (known-bad-output upgraded !)
The result from mEAm is the same for the subsequent merge: The result from mEAm is the same for the subsequent merge:
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA-change-m")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA-change-m")' f
A f A f
a (filelog !) a (filelog !)
b (sidedata !) b (sidedata !)
b (upgraded !) b (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA-change,Jm")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mEA-change,Jm")' f
A f A f
a (filelog !) a (filelog !)
b (sidedata !) b (sidedata !)
b (upgraded !) b (upgraded !)
$ hg status --copies --rev 'desc("i-0")' --rev 'desc("mJ,EA-change-m")' f $ hg status --copies --rev 'desc("i-0")' --rev 'desc("mJ,EA-change-m")' f
A f A f
a (filelog !) a (filelog !)
b (missing-correct-output sidedata !) b (sidedata !)
b (missing-correct-output upgraded !) b (upgraded !)
a (known-bad-output sidedata !)
a (known-bad-output upgraded !)