This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9421

copies-rust: extract the processing of a ChangedFiles in its own function
ClosedPublic

Authored by Alphare on Nov 27 2020, 11:12 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGdacb771f6dd2: copies-rust: extract the processing of a ChangedFiles in its own function
Summary

This is a reasonably independent piece of code that we can extract in its own
function. This extraction will be very useful for the next changeset, where we
will change the iteration order (but still do the same kind of processing).

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.

Revision Contents
Changeset List

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

Diff 24086

rust/hg-core/src/copy_tracing.rs

let (p1, p2, changes) = rev_info(*child, &mut d); let (p1, p2, changes) = rev_info(*child, &mut d);
let parent = if rev == p1 { let parent = if rev == p1 {
Parent::FirstParent Parent::FirstParent
} else { } else {
assert_eq!(rev, p2); assert_eq!(rev, p2);
Parent::SecondParent Parent::SecondParent
}; };
let mut new_copies = copies.clone(); let new_copies =
add_from_changes(&copies, &changes, parent, *child);
for action in changes.iter_actions(parent) {
match action {
Action::Copied(dest, source) => {
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);
}
Action::Removed(f) => {
// 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.
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. // Merge has two parents needs to combines their copy information.
// //
// If the vertex from the other parent was already processed, we // 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 // will have a value for the child ready to be used. We need to
// grab it and combine it with the one we already // grab it and combine it with the one we already
// computed. If not we can simply store the newly // computed. If not we can simply store the newly
// computed data. The processing happening at // computed data. The processing happening at
for (dest, tt_source) in tt_result { for (dest, tt_source) in tt_result {
if let Some(path) = tt_source.path { if let Some(path) = tt_source.path {
result.insert(dest, path); result.insert(dest, path);
} }
} }
result result
} }
/// Combine ChangedFiles with some existing PathCopies information and return
/// the result
fn add_from_changes(
base_copies: &TimeStampedPathCopies,
changes: &ChangedFiles,
parent: Parent,
current_rev: Revision,
) -> TimeStampedPathCopies {
let mut copies = base_copies.clone();
for action in changes.iter_actions(parent) {
match action {
Action::Copied(dest, source) => {
let entry;
if let Some(v) = base_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: current_rev,
path: entry,
};
copies.insert(dest.to_owned(), ttpc);
}
Action::Removed(f) => {
// 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.
if copies.contains_key(f.as_ref()) {
let ttpc = TimeStampedPathCopy {
rev: current_rev,
path: None,
};
copies.insert(f.to_owned(), ttpc);
}
}
}
}
copies
}
/// 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.
#[allow(clippy::if_same_then_else)] #[allow(clippy::if_same_then_else)]
fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>( fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>(
minor: TimeStampedPathCopies, minor: TimeStampedPathCopies,
major: TimeStampedPathCopies, major: TimeStampedPathCopies,