facebook/sapling
1
1
Fork 0
mirror of https://github.com/facebook/sapling.git synced 2024-10-08 07:49:11 +03:00
Code Issues Projects Releases Wiki Activity

nameset: make Id{Static,Lazy}Set require Dag on construction

Browse Source 
Summary:
Both IdSet and IdLazy set require both Dag and IdMap to construct.
This is step 1 torwards making Dag and IdMap immutable in hints.

A misspeall of "lhs" vs "hints" in the union set is discovered by the change
and fixed.

Reviewed By: sfilipco

Differential Revision: D23182520

fbshipit-source-id: 3d052de4b8681d3672ebc45d953d1e784f64b2a4
This commit is contained in:
Jun Wu 2020-08-26 15:26:49 -07:00 committed by Facebook GitHub Bot
parent 3ba655abf3
commit 682365f14d
8 changed files with 149 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
eden/scm/lib/dag/src/namedag.rs
View File

@ -26,9 +26,7 @@ use crate::idmap::MemIdMap;
use crate::idmap::SyncableIdMap;
use crate::nameset::hints::Flags;
use crate::nameset::hints::Hints;
use crate::nameset::id_static::IdStaticSet;
use crate::nameset::NameSet;
use crate::nameset::NameSetQuery;
use crate::ops::DagAddHeads;
use crate::ops::DagAlgorithm;
use crate::ops::DagPersistent;
@ -386,7 +384,7 @@ impl DagAddHeads for MemNameDag {
// See [`IdDag`] for the actual implementations of these algorithms.
/// DAG related read-only algorithms.
impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
impl<T: NameDagStorage + IdMapSnapshot + Send + Sync> DagAlgorithm for T {
/// Sort a `NameSet` topologically.
fn sort(&self, set: &NameSet) -> Result<NameSet> {
if set.hints().contains(Flags::TOPO_DESC)
@ -400,11 +398,8 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
let id = self.map().vertex_id(name?)?;
spans.push(id);
}
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result
.hints()
.add_flags(flags)
.set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(flags);
Ok(result)
}
}
@ -422,10 +417,8 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
/// Returns a [`SpanSet`] that covers all vertexes tracked by this DAG.
fn all(&self) -> Result<NameSet> {
let spans = self.dag().all()?;
let query = IdStaticSet::from_spans_idmap(spans, self.clone_map());
let hints = query.hints();
hints.add_flags(Flags::FULL).set_dag(self.dag_snapshot()?);
let result = NameSet::from_query(query);
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(Flags::FULL);
Ok(result)
}
@ -438,11 +431,8 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
}
let spans = self.to_id_set(&set)?;
let spans = self.dag().ancestors(spans)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result
.hints()
.add_flags(Flags::ANCESTORS)
.set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(Flags::ANCESTORS);
Ok(result)
}
@ -454,7 +444,7 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
// Preserve ANCESTORS flag. If ancestors(x) == x, then ancestors(parents(x)) == parents(x).
let flags = extract_ancestor_flag_if_compatible(set.hints(), self.dag_snapshot()?);
let spans = self.dag().parents(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(flags);
#[cfg(test)]
{
@ -487,8 +477,7 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
return self.heads_ancestors(set);
}
let spans = self.dag().heads(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
#[cfg(test)]
{
result.assert_eq(crate::default_impl::heads(self, set)?);
@ -499,8 +488,7 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
/// Calculates children of the given set.
fn children(&self, set: NameSet) -> Result<NameSet> {
let spans = self.dag().children(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
Ok(result)
}
@ -508,11 +496,8 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
fn roots(&self, set: NameSet) -> Result<NameSet> {
let flags = extract_ancestor_flag_if_compatible(set.hints(), self.dag_snapshot()?);
let spans = self.dag().roots(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result
.hints()
.add_flags(flags)
.set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(flags);
#[cfg(test)]
{
result.assert_eq(crate::default_impl::roots(self, set)?);
@ -541,8 +526,7 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
/// `gca_one` is faster if an arbitrary answer is ok.
fn gca_all(&self, set: NameSet) -> Result<NameSet> {
let spans = self.dag().gca_all(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
#[cfg(test)]
{
result.assert_eq(crate::default_impl::gca_all(self, set)?);
@ -553,11 +537,8 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
/// Calculates all common ancestors of the given set.
fn common_ancestors(&self, set: NameSet) -> Result<NameSet> {
let spans = self.dag().common_ancestors(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result
.hints()
.add_flags(Flags::ANCESTORS)
.set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
result.hints().add_flags(Flags::ANCESTORS);
#[cfg(test)]
{
result.assert_eq(crate::default_impl::common_ancestors(self, set)?);
@ -590,8 +571,7 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
/// Y while this function won't.
fn heads_ancestors(&self, set: NameSet) -> Result<NameSet> {
let spans = self.dag().heads_ancestors(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
#[cfg(test)]
{
// default_impl::heads_ancestors calls `heads` if `Flags::ANCESTORS`
@ -608,16 +588,14 @@ impl<T: NameDagStorage + Send + Sync> DagAlgorithm for T {
let roots = self.to_id_set(&roots)?;
let heads = self.to_id_set(&heads)?;
let spans = self.dag().range(roots, heads)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
Ok(result)
}
/// Calculates the descendants of the given set.
fn descendants(&self, set: NameSet) -> Result<NameSet> {
let spans = self.dag().descendants(self.to_id_set(&set)?)?;
let result = NameSet::from_spans_idmap(spans, self.clone_map());
result.hints().set_dag(self.dag_snapshot()?);
let result = NameSet::from_spans_dag(spans, self)?;
Ok(result)
}

35
eden/scm/lib/dag/src/nameset/id_lazy.rs
View File

@ -8,6 +8,7 @@
use super::hints::Flags;
use super::id_static::IdStaticSet;
use super::{Hints, NameIter, NameSetQuery};
use crate::ops::DagAlgorithm;
use crate::ops::IdConvert;
use crate::spanset::SpanSet;
use crate::Group;
@ -25,6 +26,7 @@ pub struct IdLazySet {
// Arc: iter() result does not have a lifetime on this struct.
inner: Arc<Mutex<Inner>>,
pub map: Arc<dyn IdConvert + Send + Sync>,
pub(crate) dag: Arc<dyn DagAlgorithm + Send + Sync>,
hints: Hints,
}
@ -151,7 +153,11 @@ impl fmt::Debug for IdLazySet {
}
impl IdLazySet {
pub fn from_iter_idmap<I>(names: I, map: Arc<dyn IdConvert + Send + Sync>) -> Self
pub fn from_iter_idmap_dag<I>(
names: I,
map: Arc<dyn IdConvert + Send + Sync>,
dag: Arc<dyn DagAlgorithm + Send + Sync>,
) -> Self
where
I: IntoIterator<Item = Result<Id>> + 'static,
<I as IntoIterator>::IntoIter: Send + Sync,
@ -163,10 +169,12 @@ impl IdLazySet {
state: State::Incomplete,
};
let hints = Hints::default();
hints.set_dag(dag.clone());
hints.set_id_map(map.clone());
Self {
inner: Arc::new(Mutex::new(inner)),
map,
dag,
hints,
}
}
@ -178,7 +186,11 @@ impl IdLazySet {
for &id in inner.visited.iter() {
spans.push(id);
}
Ok(IdStaticSet::from_spans_idmap(spans, self.map.clone()))
Ok(IdStaticSet::from_spans_idmap_dag(
spans,
self.map.clone(),
self.dag.clone(),
))
}
fn load_all(&self) -> Result<MutexGuard<Inner>> {
@ -284,12 +296,22 @@ pub(crate) mod tests {
use super::super::tests::*;
use super::super::NameSet;
use super::*;
use crate::tests::dummy_dag::DummyDag;
use std::collections::HashSet;
use std::convert::TryInto;
pub fn lazy_set(a: &[u64]) -> IdLazySet {
let ids: Vec<Id> = a.iter().map(|i| Id(*i as _)).collect();
IdLazySet::from_iter_idmap(ids.into_iter().map(Ok), Arc::new(StrIdMap))
IdLazySet::from_iter_idmap_dag(
ids.into_iter().map(Ok),
Arc::new(StrIdMap),
Arc::new(DummyDag),
)
}
pub fn lazy_set_inherit(a: &[u64], set: &IdLazySet) -> IdLazySet {
let ids: Vec<Id> = a.iter().map(|i| Id(*i as _)).collect();
IdLazySet::from_iter_idmap_dag(ids.into_iter().map(Ok), set.map.clone(), set.dag.clone())
}
struct StrIdMap;
@ -381,9 +403,10 @@ pub(crate) mod tests {
#[test]
fn test_flatten() {
let set1 = NameSet::from_query(lazy_set(&[3, 2, 4]));
let set2 = NameSet::from_query(lazy_set(&[3, 7, 6]));
set2.hints().inherit_id_map(set1.hints());
let set1 = lazy_set(&[3, 2, 4]);
let set2 = lazy_set_inherit(&[3, 7, 6], &set1);
let set1 = NameSet::from_query(set1);
let set2 = NameSet::from_query(set2);
// Show flatten by names, and flatten by ids.
// The first should be <static ...>, the second should be <spans ...>.

16
eden/scm/lib/dag/src/nameset/id_static.rs
View File

@ -7,6 +7,7 @@
use super::hints::Flags;
use super::{Hints, NameIter, NameSetQuery};
use crate::ops::DagAlgorithm;
use crate::ops::IdConvert;
use crate::spanset::Span;
use crate::spanset::{SpanSet, SpanSetIter};
@ -22,6 +23,7 @@ use std::sync::Arc;
pub struct IdStaticSet {
pub(crate) spans: SpanSet,
pub(crate) map: Arc<dyn IdConvert + Send + Sync>,
pub(crate) dag: Arc<dyn DagAlgorithm + Send + Sync>,
hints: Hints,
}
@ -102,17 +104,27 @@ impl fmt::Debug for IdStaticSet {
}
impl IdStaticSet {
pub(crate) fn from_spans_idmap(spans: SpanSet, map: Arc<dyn IdConvert + Send + Sync>) -> Self {
pub(crate) fn from_spans_idmap_dag(
spans: SpanSet,
map: Arc<dyn IdConvert + Send + Sync>,
dag: Arc<dyn DagAlgorithm + Send + Sync>,
) -> Self {
let hints = Hints::default();
hints.add_flags(Flags::ID_DESC | Flags::TOPO_DESC);
hints.set_id_map(map.clone());
hints.set_dag(dag.clone());
if spans.is_empty() {
hints.add_flags(Flags::EMPTY);
} else {
hints.set_min_id(spans.min().unwrap());
hints.set_max_id(spans.max().unwrap());
}
Self { spans, map, hints }
Self {
spans,
map,
hints,
dag,
}
}
}

2
eden/scm/lib/dag/src/nameset/legacy.rs
View File

@ -27,7 +27,7 @@ impl<'a> From<(LegacyCodeNeedIdAccess, &'a IdStaticSet)> for SpanSet {
impl<'a> From<(LegacyCodeNeedIdAccess, SpanSet, &'a NameDag)> for NameSet {
fn from(value: (LegacyCodeNeedIdAccess, SpanSet, &'a NameDag)) -> NameSet {
NameSet::from_spans_idmap(value.1, value.2.snapshot_map.clone())
NameSet::from_spans_dag(value.1, value.2).unwrap()
}
}

82
eden/scm/lib/dag/src/nameset/mod.rs
View File

@ -11,6 +11,7 @@
use crate::ops::DagAlgorithm;
use crate::ops::IdConvert;
use crate::ops::IdMapSnapshot;
use crate::spanset::SpanSet;
use crate::Id;
use crate::Result;
@ -69,18 +70,50 @@ impl NameSet {
Self::from_query(lazy::LazySet::from_iter(iter))
}
/// Creates from a (lazy) iterator of Ids and an IdMap.
pub fn from_iter_idmap<I>(iter: I, map: Arc<dyn IdConvert + Send + Sync>) -> NameSet
/// Creates from a (lazy) iterator of Ids, an IdMap, and a Dag.
pub fn from_id_iter_idmap_dag<I>(
iter: I,
map: Arc<dyn IdConvert + Send + Sync>,
dag: Arc<dyn DagAlgorithm + Send + Sync>,
) -> NameSet
where
I: IntoIterator<Item = Result<Id>> + 'static,
<I as IntoIterator>::IntoIter: Send + Sync,
{
Self::from_query(id_lazy::IdLazySet::from_iter_idmap(iter, map))
Self::from_query(id_lazy::IdLazySet::from_iter_idmap_dag(iter, map, dag))
}
/// Creates from [`SpanSet`] and [`IdMap`]. Used by [`NameDag`].
pub fn from_spans_idmap(spans: SpanSet, map: Arc<dyn IdConvert + Send + Sync>) -> NameSet {
Self::from_query(IdStaticSet::from_spans_idmap(spans, map))
/// Creates from a (lazy) iterator of Ids and a struct with snapshot abilities.
pub fn from_id_iter_dag<I>(
iter: I,
dag: &(impl DagAlgorithm + IdMapSnapshot),
) -> Result<NameSet>
where
I: IntoIterator<Item = Result<Id>> + 'static,
<I as IntoIterator>::IntoIter: Send + Sync,
{
let map = dag.id_map_snapshot()?;
let dag = dag.dag_snapshot()?;
Ok(Self::from_id_iter_idmap_dag(iter, map, dag))
}
/// Creates from [`SpanSet`], [`IdMap`] and [`DagAlgorithm`].
pub fn from_spans_idmap_dag(
spans: SpanSet,
map: Arc<dyn IdConvert + Send + Sync>,
dag: Arc<dyn DagAlgorithm + Send + Sync>,
) -> NameSet {
Self::from_query(IdStaticSet::from_spans_idmap_dag(spans, map, dag))
}
/// Creates from [`SpanSet`] and a struct with snapshot abilities.
pub fn from_spans_dag(
spans: SpanSet,
dag: &(impl DagAlgorithm + IdMapSnapshot),
) -> Result<Self> {
let map = dag.id_map_snapshot()?;
let dag = dag.dag_snapshot()?;
Ok(Self::from_spans_idmap_dag(spans, map, dag))
}
/// Creates from a function that evaluates to a [`NameSet`], and a
@ -106,8 +139,11 @@ impl NameSet {
) {
if Arc::ptr_eq(&this.map, &other.map) {
// Fast path for IdStaticSet
let result =
Self::from_spans_idmap(this.spans.difference(&other.spans), this.map.clone());
let result = Self::from_spans_idmap_dag(
this.spans.difference(&other.spans),
this.map.clone(),
this.dag.clone(),
);
result
.hints()
.inherit_id_map(self.hints())
@ -135,8 +171,11 @@ impl NameSet {
) {
if Arc::ptr_eq(&this.map, &other.map) {
// Fast path for IdStaticSet
let result =
Self::from_spans_idmap(this.spans.intersection(&other.spans), this.map.clone());
let result = Self::from_spans_idmap_dag(
this.spans.intersection(&other.spans),
this.map.clone(),
this.dag.clone(),
);
result
.hints()
.inherit_id_map(self.hints())
@ -169,8 +208,11 @@ impl NameSet {
) {
if Arc::ptr_eq(&this.map, &other.map) {
// Fast path for IdStaticSet
let result =
Self::from_spans_idmap(this.spans.union(&other.spans), this.map.clone());
let result = Self::from_spans_idmap_dag(
this.spans.union(&other.spans),
this.map.clone(),
this.dag.clone(),
);
result
.hints()
.inherit_id_map(self.hints())
@ -195,12 +237,12 @@ impl NameSet {
/// fast paths. This is useful for some common sets like `obsolete()` that
/// might be represented by a complex expression.
pub fn flatten(&self) -> Result<NameSet> {
match self.id_map() {
Some(id_map) => {
match (self.id_map(), self.dag()) {
(Some(id_map), Some(dag)) => {
// Convert to IdStaticSet
self.flatten_id(id_map)
self.flatten_id(id_map, dag)
}
None => {
_ => {
// Convert to StaticSet
self.flatten_names()
}
@ -208,7 +250,11 @@ impl NameSet {
}
/// Convert this set to a static id set.
pub fn flatten_id(&self, id_map: Arc<dyn IdConvert + Send + Sync>) -> Result<NameSet> {
pub fn flatten_id(
&self,
id_map: Arc<dyn IdConvert + Send + Sync>,
dag: Arc<dyn DagAlgorithm + Send + Sync>,
) -> Result<NameSet> {
if self.as_any().is::<IdStaticSet>() {
return Ok(self.clone());
}
@ -219,7 +265,7 @@ impl NameSet {
}
ids.sort_unstable_by_key(|i| u64::MAX - i.0);
let spans = SpanSet::from_sorted_spans(ids);
let flat_set = NameSet::from_spans_idmap(spans, id_map);
let flat_set = NameSet::from_spans_idmap_dag(spans, id_map, dag);
flat_set.hints().replace(self.hints());
Ok(flat_set)
}

2
eden/scm/lib/dag/src/nameset/union.rs
View File

@ -37,7 +37,7 @@ impl UnionSet {
hints.set_max_id(id1.max(id2));
}
}
if hints.is_dag_compatible(rhs.hints()) {
if lhs.hints().is_dag_compatible(rhs.hints()) {
hints.inherit_dag(&lhs.hints());
hints.add_flags(lhs.hints().flags() & rhs.hints().flags() & Flags::ANCESTORS);
}

5
eden/scm/lib/dag/src/ops.rs
View File

@ -454,9 +454,6 @@ impl<T: IdConvert + IdMapEq> ToIdSet for T {
impl<T: IdMapSnapshot + DagAlgorithm> ToSet for T {
/// Converts [`SpanSet`] to [`NameSet`].
fn to_set(&self, set: &IdSet) -> Result<NameSet> {
let id_map = self.id_map_snapshot()?;
let result = NameSet::from_spans_idmap(set.clone(), id_map);
result.hints().set_dag(self.dag_snapshot()?);
Ok(result)
NameSet::from_spans_dag(set.clone(), self)
}
}

68
eden/scm/lib/revlogindex/src/revlogindex.rs
View File

@ -966,8 +966,7 @@ impl DagAlgorithm for RevlogIndex {
let id = self.vertex_id(name?)?;
spans.push(id);
}
let result = Set::from_spans_idmap(spans, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(spans, self)?;
Ok(result)
}
}
@ -991,11 +990,8 @@ impl DagAlgorithm for RevlogIndex {
} else {
IdSet::from(Id(0)..=Id(self.len() as u64 - 1))
};
let result = Set::from_spans_idmap(id_set, self.get_snapshot());
result
.hints()
.add_flags(Flags::FULL)
.set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(id_set, self)?;
result.hints().add_flags(Flags::FULL);
Ok(result)
}
@ -1036,13 +1032,10 @@ impl DagAlgorithm for RevlogIndex {
}
});
let map = self.get_snapshot() as Arc<dyn IdConvert + Send + Sync>;
let set = Set::from_iter_idmap(iter, map);
let set = Set::from_id_iter_dag(iter, self)?;
set.hints()
.add_flags(Flags::ID_DESC | Flags::TOPO_DESC | Flags::ANCESTORS)
.set_max_id(max_id)
.set_dag(self.dag_snapshot()?);
.set_max_id(max_id);
Ok(set)
}
@ -1080,9 +1073,8 @@ impl DagAlgorithm for RevlogIndex {
}
}
let idmap = dag;
let result = Set::from_spans_idmap(id_spans, idmap);
result.hints().set_dag(self.dag_snapshot()?);
let idmap = dag.clone();
let result = Set::from_spans_idmap_dag(id_spans, idmap, dag);
Ok(result)
}
@ -1112,12 +1104,8 @@ impl DagAlgorithm for RevlogIndex {
}
});
let map = self.get_snapshot() as Arc<dyn IdConvert + Send + Sync>;
let set = Set::from_iter_idmap(iter, map);
set.hints()
.add_flags(Flags::ID_ASC)
.set_min_id(min_id)
.set_dag(self.dag_snapshot()?);
let set = Set::from_id_iter_dag(iter, self)?;
set.hints().add_flags(Flags::ID_ASC).set_min_id(min_id);
Ok(set)
}
@ -1146,12 +1134,11 @@ impl DagAlgorithm for RevlogIndex {
None
}
});
let set = Set::from_iter_idmap(iter, self.get_snapshot());
let set = Set::from_id_iter_dag(iter, self)?;
set.hints()
.add_flags(Flags::ID_DESC | Flags::TOPO_DESC)
.set_min_id(min_id)
.set_max_id(max_id)
.set_dag(self.dag_snapshot()?);
.set_max_id(max_id);
Ok(set)
}
@ -1201,8 +1188,7 @@ impl DagAlgorithm for RevlogIndex {
let revs: Vec<u32> = id_set.iter().map(|id| id.0 as u32).collect();
let gcas = self.gca_revs(&revs, usize::max_value())?;
let spans = IdSet::from_spans(gcas.into_iter().map(|r| Id(r as _)));
let result = Set::from_spans_idmap(spans, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(spans, self)?;
Ok(result)
}
@ -1267,8 +1253,7 @@ impl DagAlgorithm for RevlogIndex {
}
}
}
let result = Set::from_spans_idmap(result_id_set, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(result_id_set, self)?;
Ok(result)
}
@ -1289,8 +1274,7 @@ impl DagAlgorithm for RevlogIndex {
let head_revs: Vec<u32> = head_ids.into_iter().map(|i| i.0 as u32).collect();
let result_revs = self.range_revs(&root_revs, &head_revs)?;
let result_id_set = IdSet::from_spans(result_revs.into_iter().map(|r| Id(r as _)));
let result = Set::from_spans_idmap(result_id_set, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(result_id_set, self)?;
Ok(result)
}
@ -1360,8 +1344,7 @@ impl DagAlgorithm for RevlogIndex {
}
}
let result = Set::from_spans_idmap(result, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(result, self)?;
Ok(result)
}
@ -1374,13 +1357,9 @@ impl DagAlgorithm for RevlogIndex {
// This is a same problem to head-based public/draft phase calculation.
let (result_unreachable_id_set, result_reachable_id_set) =
self.phasesets(unreachable_revs, reachable_revs)?;
let only = Set::from_spans_idmap(result_reachable_id_set, self.get_snapshot());
let ancestors = Set::from_spans_idmap(result_unreachable_id_set, self.get_snapshot());
ancestors
.hints()
.add_flags(Flags::ANCESTORS)
.set_dag(self.dag_snapshot()?);
only.hints().set_dag(self.dag_snapshot()?);
let only = Set::from_spans_dag(result_reachable_id_set, self)?;
let ancestors = Set::from_spans_dag(result_unreachable_id_set, self)?;
ancestors.hints().add_flags(Flags::ANCESTORS);
Ok((only, ancestors))
}
@ -1418,12 +1397,8 @@ impl DagAlgorithm for RevlogIndex {
}
});
let map = self.get_snapshot() as Arc<dyn IdConvert + Send + Sync>;
let set = Set::from_iter_idmap(iter, map);
set.hints()
.add_flags(Flags::ID_ASC)
.set_min_id(min_id)
.set_dag(self.dag_snapshot()?);
let set = Set::from_id_iter_dag(iter, self)?;
set.hints().add_flags(Flags::ID_ASC).set_min_id(min_id);
Ok(set)
}
@ -1489,8 +1464,7 @@ impl DagAlgorithm for RevlogIndex {
}
}
let result = Set::from_spans_idmap(result, self.get_snapshot());
result.hints().set_dag(self.dag_snapshot()?);
let result = Set::from_spans_dag(result, self)?;
Ok(result)
}