This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7722

rust-discovery: simplifying add_missing_revisions()
Needs RevisionPublic

Authored by gracinet on Dec 24 2019, 8:50 AM.

Details

Reviewers
Alphare
baymax
Group Reviewers
hg-reviewers
Summary

with the removal of the various ensure() it's become
clear that this doesn't have error cases any more, and we didn't
need the full match at the end.

Diff Detail

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

Event Timeline

gracinet created this revision.Dec 24 2019, 8:50 AM
Alphare accepted this revision.Jan 3 2020, 4:57 AM
baymax requested changes to this revision.Apr 22 2020, 11:52 AM

There seems to have been no activities on this Diff for the past 3 Months.

By policy, we are automatically moving it out of the need-review state.

Please, move it back to need-review without hesitation if this diff should still be discussed.

:baymax:need-review-idle:

This revision now requires changes to proceed.Apr 22 2020, 11:52 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/discovery.rs (21 lines)

Diff 18930

rust/hg-core/src/discovery.rs

) -> Result<(), GraphError> { ) -> Result<(), GraphError> {
let missing: VecDeque<Revision> = missing.into_iter().collect(); let missing: VecDeque<Revision> = missing.into_iter().collect();
if missing.is_empty() { if missing.is_empty() {
return Ok(()); return Ok(());
} }
self.mutate_undecided( self.mutate_undecided(
|oc| oc.compute_undecided(), |oc| oc.compute_undecided(),
|wu| wu.add_missing_revisions(missing), |wu| Ok(wu.add_missing_revisions(missing)),
) )
} }
/// Mutate into a `WithUndecided` and apply the `mutator` closure. /// Mutate into a `WithUndecided` and apply the `mutator` closure.
/// ///
/// If `self` is still in the `OnlyCommons` stage, this applies first /// If `self` is still in the `OnlyCommons` stage, this applies first
/// the `transitor` closure to produce a `WithUndecided`. /// the `transitor` closure to produce a `WithUndecided`.
/// ///
/// Register revisions known as being missing /// Register revisions known as being missing
/// ///
/// # Performance note /// # Performance note
/// ///
/// `tovisit` is provided as a `VecDeque` already so that a potential /// `tovisit` is provided as a `VecDeque` already so that a potential
/// caller from `PartialDiscovery` can avoid the undecided set in case /// caller from `PartialDiscovery` can avoid the undecided set in case
/// it turns out to be empty (hence restrain /// it turns out to be empty (hence restrain
/// from performing the transition to `WithUndecided`) /// from performing the transition to `WithUndecided`)
pub fn add_missing_revisions( pub fn add_missing_revisions(&mut self, mut tovisit: VecDeque<Revision>) {
&mut self,
mut tovisit: VecDeque<Revision>,
) -> Result<(), GraphError> {
let mut seen: HashSet<Revision> = HashSet::new(); let mut seen: HashSet<Revision> = HashSet::new();
let undecided_mut = &mut self.undecided; let undecided_mut = &mut self.undecided;
let children = &self.children_cache; let children = &self.children_cache;
while let Some(rev) = tovisit.pop_front() { while let Some(rev) = tovisit.pop_front() {
if !self.missing.insert(rev) { if !self.missing.insert(rev) {
// either it's known to be missing from a previous // either it's known to be missing from a previous
// invocation, and there's no need to iterate on its // invocation, and there's no need to iterate on its
// children (we now they are all missing) // children (we now they are all missing)
// or it's from a previous iteration of this loop // or it's from a previous iteration of this loop
// and its children have already been queued // and its children have already been queued
continue; continue;
} }
undecided_mut.remove(&rev); undecided_mut.remove(&rev);
match children.get(&rev) { if let Some(this_children) = children.get(&rev) {
None => {
continue;
}
Some(this_children) => {
for child in this_children.iter().cloned() { for child in this_children.iter().cloned() {
if seen.insert(child) { if seen.insert(child) {
tovisit.push_back(child); tovisit.push_back(child);
} }
} }
} }
} }
} }
Ok(())
}
fn compute_children_cache( fn compute_children_cache(
graph: &G, graph: &G,
undecided: impl Iterator<Item = Revision>, undecided: impl Iterator<Item = Revision>,
) -> Result<(FastHashMap<Revision, Vec<Revision>>), GraphError> { ) -> Result<(FastHashMap<Revision, Vec<Revision>>), GraphError> {
let mut children: FastHashMap<Revision, Vec<Revision>> = let mut children: FastHashMap<Revision, Vec<Revision>> =
FastHashMap::default(); FastHashMap::default();
for rev in undecided.into_iter() { for rev in undecided.into_iter() {