This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9420

copies-rust: move the parent token to an enum
ClosedPublic

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

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG12192fdbf3ac: copies-rust: move the parent token to an enum
Summary

We carry around information about which parent of a revision is been dealt
with. So far this was a usize but as we are about to pass it around to more
function it seems like a good idea to start cleaning this up and use a proper
enum.

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

Alphare created this revision.Nov 27 2020, 11:12 AM
marmoute updated this revision to Diff 23818.Nov 29 2020, 6:13 AM
marmoute updated this revision to Diff 23867.Nov 29 2020, 3:29 PM
Alphare added a subscriber: marmoute.Dec 7 2020, 5:56 AM

Note to reviewers: this patch through to D9426 are authored by @marmoute. I'm waiting for him to commandeer them, I just sent them because he had some Phabricator trouble.

pulkit accepted this revision.Dec 7 2020, 8:41 AM
This revision is now accepted and ready to land.Dec 7 2020, 8:41 AM
marmoute added a commit: rHG12192fdbf3ac: copies-rust: move the parent token to an enum.Dec 7 2020, 1:19 PM
Closed by commit rHG12192fdbf3ac: copies-rust: move the parent token to an enum (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

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

Diff 24085

rust/hg-core/src/copy_tracing.rs

let end = end as usize; let end = end as usize;
let raw = (&self.index[start..end]) let raw = (&self.index[start..end])
.try_into() .try_into()
.expect("failed to turn 4 bytes into 4 bytes"); .expect("failed to turn 4 bytes into 4 bytes");
u32::from_be_bytes(raw) u32::from_be_bytes(raw)
} }
/// Return an iterator over all the `Action` in this instance. /// Return an iterator over all the `Action` in this instance.
fn iter_actions(&self, parent: usize) -> ActionsIterator { fn iter_actions(&self, parent: Parent) -> ActionsIterator {
ActionsIterator { ActionsIterator {
changes: &self, changes: &self,
parent: parent, parent: parent,
current: 0, current: 0,
} }
} }
/// return the MergeCase value associated with a filename /// return the MergeCase value associated with a filename
b b
} }
} }
} }
} }
struct ActionsIterator<'a> { struct ActionsIterator<'a> {
changes: &'a ChangedFiles<'a>, changes: &'a ChangedFiles<'a>,
parent: usize, parent: Parent,
current: u32, current: u32,
} }
impl<'a> Iterator for ActionsIterator<'a> { impl<'a> Iterator for ActionsIterator<'a> {
type Item = Action<'a>; type Item = Action<'a>;
fn next(&mut self) -> Option<Action<'a>> { fn next(&mut self) -> Option<Action<'a>> {
let copy_flag = match self.parent {
Parent::FirstParent => P1_COPY,
Parent::SecondParent => P2_COPY,
};
while self.current < self.changes.nb_items { while self.current < self.changes.nb_items {
let (flags, file, source) = self.changes.entry(self.current); let (flags, file, source) = self.changes.entry(self.current);
self.current += 1; self.current += 1;
if (flags & ACTION_MASK) == REMOVED { if (flags & ACTION_MASK) == REMOVED {
return Some(Action::Removed(file)); return Some(Action::Removed(file));
} }
let copy = flags & COPY_MASK; let copy = flags & COPY_MASK;
if self.parent == 1 && copy == P1_COPY { if copy == copy_flag {
return Some(Action::Copied(file, source));
}
if self.parent == 2 && copy == P2_COPY {
return Some(Action::Copied(file, source)); return Some(Action::Copied(file, source));
} }
} }
return None; return None;
} }
} }
/// A small struct whose purpose is to ensure lifetime of bytes referenced in /// A small struct whose purpose is to ensure lifetime of bytes referenced in
/// ChangedFiles /// ChangedFiles
/// ///
/// It is passed to the RevInfoMaker callback who can assign any necessary /// It is passed to the RevInfoMaker callback who can assign any necessary
/// content to the `data` attribute. The copy tracing code is responsible for /// content to the `data` attribute. The copy tracing code is responsible for
/// keeping the DataHolder alive at least as long as the ChangedFiles object. /// keeping the DataHolder alive at least as long as the ChangedFiles object.
pub struct DataHolder<D> { pub struct DataHolder<D> {
/// RevInfoMaker callback should assign data referenced by the /// RevInfoMaker callback should assign data referenced by the
/// ChangedFiles struct it return to this attribute. The DataHolder /// ChangedFiles struct it return to this attribute. The DataHolder
/// lifetime will be at least as long as the ChangedFiles one. /// lifetime will be at least as long as the ChangedFiles one.
pub data: Option<D>, pub data: Option<D>,
} }
pub type RevInfoMaker<'a, D> = pub type RevInfoMaker<'a, D> =
Box<dyn for<'r> Fn(Revision, &'r mut DataHolder<D>) -> RevInfo<'r> + 'a>; Box<dyn for<'r> Fn(Revision, &'r mut DataHolder<D>) -> RevInfo<'r> + 'a>;
/// enum used to carry information about the parent → child currently processed
#[derive(Copy, Clone, Debug)]
enum Parent {
/// The `p1(x) → x` edge
FirstParent,
/// The `p2(x) → x` edge
SecondParent,
}
/// Same as mercurial.copies._combine_changeset_copies, but in Rust. /// Same as mercurial.copies._combine_changeset_copies, but in Rust.
/// ///
/// Arguments are: /// Arguments are:
/// ///
/// revs: all revisions to be considered /// revs: all revisions to be considered
/// children: a {parent ? [childrens]} mapping /// children: a {parent ? [childrens]} mapping
/// target_rev: the final revision we are combining copies to /// target_rev: the final revision we are combining copies to
/// rev_info(rev): callback to get revision information: /// rev_info(rev): callback to get revision information:
for child in current_children { for child in current_children {
// We will chain the copies information accumulated for `rev` with // We will chain the copies information accumulated for `rev` with
// the individual copies information for each of its children. // the individual copies information for each of its children.
// Creating a new PathCopies for each `rev` → `children` vertex. // Creating a new PathCopies for each `rev` → `children` vertex.
let mut d: DataHolder<D> = DataHolder { data: None }; let mut d: DataHolder<D> = DataHolder { data: None };
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 {
1 Parent::FirstParent
} else { } else {
assert_eq!(rev, p2); assert_eq!(rev, p2);
2 Parent::SecondParent
}; };
let mut new_copies = copies.clone(); let mut new_copies = copies.clone();
for action in changes.iter_actions(parent) { for action in changes.iter_actions(parent) {
match action { match action {
Action::Copied(dest, source) => { Action::Copied(dest, source) => {
let entry; let entry;
if let Some(v) = copies.get(source) { if let Some(v) = copies.get(source) {
// the time of the second parent will take care of combining the // the time of the second parent will take care of combining the
// two TimeStampedPathCopies instance. // two TimeStampedPathCopies instance.
match all_copies.remove(child) { match all_copies.remove(child) {
None => { None => {
all_copies.insert(child, new_copies); all_copies.insert(child, new_copies);
} }
Some(other_copies) => { Some(other_copies) => {
let (minor, major) = match parent { let (minor, major) = match parent {
1 => (other_copies, new_copies), Parent::FirstParent => (other_copies, new_copies),
2 => (new_copies, other_copies), Parent::SecondParent => (new_copies, other_copies),
_ => unreachable!(),
}; };
let merged_copies = let merged_copies =
merge_copies_dict(minor, major, &changes, &mut oracle); merge_copies_dict(minor, major, &changes, &mut oracle);
all_copies.insert(child, merged_copies); all_copies.insert(child, merged_copies);
} }
}; };
} }
} }