( )⚙ D9492 copies-rust: pre-introduce a PathToken type and use it where applicable

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9492

copies-rust: pre-introduce a PathToken type and use it where applicable
ClosedPublic

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

Details

Reviewers
pulkit
Alphare
Group Reviewers
hg-reviewers
Commits
rHG818502d2f5e3: copies-rust: pre-introduce a PathToken type and use it where applicable
Summary

Handling string all the time is quite slow. So we are about to use more
efficient "token". We do some of the churn early to clarify the next changesets.

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 24121.Dec 8 2020, 6:25 AM

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

baymax updated this revision to Diff 24134.Dec 8 2020, 10:11 PM

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

pulkit accepted this revision.Dec 12 2020, 3:27 AM
This revision is now accepted and ready to land.Dec 12 2020, 3:27 AM
Alphare accepted this revision.Dec 14 2020, 4:41 AM
marmoute updated this revision to Diff 24215.Dec 14 2020, 6:16 AM
baymax updated this revision to Diff 24244.Dec 14 2020, 7:59 AM

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

Revision Contents
Changeset List

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

Diff 24215

rust/hg-core/src/copy_tracing.rs

use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::utils::hg_path::HgPathBuf; use crate::utils::hg_path::HgPathBuf;
use crate::Revision; use crate::Revision;
use crate::NULL_REVISION; use crate::NULL_REVISION;
use im_rc::ordmap::DiffItem; use im_rc::ordmap::DiffItem;
use im_rc::ordmap::OrdMap; use im_rc::ordmap::OrdMap;
use std::cmp::Ordering; use std::cmp::Ordering;
use std::collections::HashMap; use std::collections::HashMap;
use std::convert::TryInto; use std::convert::TryInto;
pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>; pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;
type PathToken = HgPathBuf;
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
struct TimeStampedPathCopy { struct TimeStampedPathCopy {
/// revision at which the copy information was added /// revision at which the copy information was added
rev: Revision, rev: Revision,
/// the copy source, (Set to None in case of deletion of the associated /// the copy source, (Set to None in case of deletion of the associated
/// key) /// key)
path: Option<HgPathBuf>, path: Option<PathToken>,
} }
/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation) /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
type TimeStampedPathCopies = OrdMap<HgPathBuf, TimeStampedPathCopy>; type TimeStampedPathCopies = OrdMap<PathToken, TimeStampedPathCopy>;
/// hold parent 1, parent 2 and relevant files actions. /// hold parent 1, parent 2 and relevant files actions.
pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>); pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>);
/// represent the files affected by a changesets /// represent the files affected by a changesets
/// ///
/// This hold a subset of mercurial.metadata.ChangingFiles as we do not need /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need
/// all the data categories tracked by it. /// all the data categories tracked by it.
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: &HgPathBuf, |dest: &PathToken,
src_minor: &TimeStampedPathCopy, src_minor: &TimeStampedPathCopy,
src_major: &TimeStampedPathCopy| { src_major: &TimeStampedPathCopy| {
compare_value(changes, oracle, dest, src_minor, src_major) compare_value(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
} }
}; };
} }
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();
let mut to_major = |k: &HgPathBuf, v: &TimeStampedPathCopy| { let mut to_major = |k: &PathToken, v: &TimeStampedPathCopy| {
override_major.push((k.clone(), v.clone())) override_major.push((k.clone(), v.clone()))
}; };
let mut to_minor = |k: &HgPathBuf, v: &TimeStampedPathCopy| { let mut to_minor = |k: &PathToken, v: &TimeStampedPathCopy| {
override_minor.push((k.clone(), v.clone())) override_minor.push((k.clone(), v.clone()))
}; };
// The diff function leverage detection of the identical subpart if // The diff function leverage detection of the identical subpart if
// minor and major has some common ancestors. This make it very // minor and major has some common ancestors. This make it very
// fast is most case. // fast is most case.
// //
// In case where the two map are vastly different in size, the current // In case where the two map are vastly different in size, the current
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>(
changes: &ChangedFiles, changes: &ChangedFiles,
oracle: &mut AncestorOracle<A>, oracle: &mut AncestorOracle<A>,
dest: &HgPathBuf, 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.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