This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10363

dirstate-tree: Abstract "non-normal" and "other parent" sets
ClosedPublic

Authored by SimonSapin on Apr 12 2021, 8:23 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGe061a1df32a8: dirstate-tree: Abstract "non-normal" and "other parent" sets
rHGdfd8639a977a: dirstate-tree: Abstract "non-normal" and "other parent" sets
Summary

Instead of exposing HashSets directly, have slightly higher-level
methods for the operations that Python bindings need on them.

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

SimonSapin created this revision.Apr 12 2021, 8:23 AM
baymax updated this revision to Diff 27047.Apr 19 2021, 11:02 AM

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

Alphare accepted this revision.Apr 19 2021, 11:21 AM
SimonSapin updated this revision to Diff 27314.May 3 2021, 6:23 AM
SimonSapin added a commit: rHGdfd8639a977a: dirstate-tree: Abstract "non-normal" and "other parent" sets.May 6 2021, 12:48 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGdfd8639a977a: dirstate-tree: Abstract "non-normal" and "other parent" sets (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27638

mercurial/dirstate.py

if self._origpl is None: if self._origpl is None:
self._origpl = self._pl self._origpl = self._pl
self._map.setparents(p1, p2) self._map.setparents(p1, p2)
copies = {} copies = {}
if ( if (
oldp2 != self._nodeconstants.nullid oldp2 != self._nodeconstants.nullid
and p2 == self._nodeconstants.nullid and p2 == self._nodeconstants.nullid
): ):
candidatefiles = self._map.nonnormalset.union( candidatefiles = self._map.non_normal_or_other_parent_paths()
self._map.otherparentset
)
for f in candidatefiles: for f in candidatefiles:
s = self._map.get(f) s = self._map.get(f)
if s is None: if s is None:
continue continue
# Discard 'm' markers when moving away from a merge state # Discard 'm' markers when moving away from a merge state
if s[0] == b'm': if s[0] == b'm':
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
return nonnorm return nonnorm
@propertycache @propertycache
def otherparentset(self): def otherparentset(self):
nonnorm, otherparents = self.nonnormalentries() nonnorm, otherparents = self.nonnormalentries()
self.nonnormalset = nonnorm self.nonnormalset = nonnorm
return otherparents return otherparents
def non_normal_or_other_parent_paths(self):
return self.nonnormalset.union(self.otherparentset)
@propertycache @propertycache
def identity(self): def identity(self):
self._map self._map
return self.identity return self.identity
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
nonnorm = self._rustmap.non_normal_entries() nonnorm = self._rustmap.non_normal_entries()
return nonnorm return nonnorm
@propertycache @propertycache
def otherparentset(self): def otherparentset(self):
otherparents = self._rustmap.other_parent_entries() otherparents = self._rustmap.other_parent_entries()
return otherparents return otherparents
def non_normal_or_other_parent_paths(self):
return self._rustmap.non_normal_or_other_parent_paths()
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._dirs: for name in self._dirs:
f[normcase(name)] = name f[normcase(name)] = name
return f return f

rust/hg-core/src/dirstate_tree/dispatch.rs

use std::collections::HashSet;
use std::path::PathBuf; use std::path::PathBuf;
use std::time::Duration; use std::time::Duration;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
fn drop_file( fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateMapError>;
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32); fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32);
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool;
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool; fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;
fn non_normal_entries_union( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
other: HashSet<HgPathBuf>, ) -> Box<dyn Iterator<Item = &HgPathBuf> + '_>;
) -> Vec<HgPathBuf>;
fn set_non_normal_other_parent_entries(&mut self, force: bool); fn set_non_normal_other_parent_entries(&mut self, force: bool);
fn get_non_normal_other_parent_entries_panic( fn iter_non_normal_paths(
&mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;
fn iter_non_normal_paths_panic(
&self, &self,
) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>); ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;
fn get_non_normal_other_parent_entries( fn iter_other_parent_paths(
&mut self, &mut self,
) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>); ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError>; ) -> Result<bool, DirstateMapError>;
fn has_dir( fn has_dir(
&mut self, &mut self,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
self.drop_file(filename, old_state) self.drop_file(filename, old_state)
} }
fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) { fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) {
self.clear_ambiguous_times(filenames, now) self.clear_ambiguous_times(filenames, now)
} }
fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool {
let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries();
non_normal.contains(key)
}
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool { fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
self.non_normal_entries_remove(key) self.non_normal_entries_remove(key)
} }
fn non_normal_entries_union( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
other: HashSet<HgPathBuf>, ) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
) -> Vec<HgPathBuf> { let (non_normal, other_parent) =
self.non_normal_entries_union(other) self.get_non_normal_other_parent_entries();
Box::new(non_normal.union(other_parent))
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.set_non_normal_other_parent_entries(force) self.set_non_normal_other_parent_entries(force)
} }
fn get_non_normal_other_parent_entries_panic( fn iter_non_normal_paths(
&mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries();
Box::new(non_normal.iter())
}
fn iter_non_normal_paths_panic(
&self, &self,
) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) { ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
self.get_non_normal_other_parent_entries_panic() let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries_panic();
Box::new(non_normal.iter())
} }
fn get_non_normal_other_parent_entries( fn iter_other_parent_paths(
&mut self, &mut self,
) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) { ) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
self.get_non_normal_other_parent_entries() let (_non_normal, other_parent) =
self.get_non_normal_other_parent_entries();
Box::new(other_parent.iter())
} }
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateMapError> { ) -> Result<bool, DirstateMapError> {
self.has_tracked_dir(directory) self.has_tracked_dir(directory)
} }

rust/hg-cpython/src/dirstate/dirstate_map.rs

.collect(); .collect();
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
.clear_ambiguous_times(files?, now.extract(py)?); .clear_ambiguous_times(files?, now.extract(py)?);
Ok(py.None()) Ok(py.None())
} }
def other_parent_entries(&self) -> PyResult<PyObject> { def other_parent_entries(&self) -> PyResult<PyObject> {
let mut inner_shared = self.inner(py).borrow_mut(); let mut inner_shared = self.inner(py).borrow_mut();
let (_, other_parent) =
inner_shared.get_non_normal_other_parent_entries();
let set = PySet::empty(py)?; let set = PySet::empty(py)?;
for path in other_parent.iter() { for path in inner_shared.iter_other_parent_paths() {
set.add(py, PyBytes::new(py, path.as_bytes()))?; set.add(py, PyBytes::new(py, path.as_bytes()))?;
} }
Ok(set.into_object()) Ok(set.into_object())
} }
def non_normal_entries(&self) -> PyResult<NonNormalEntries> { def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
NonNormalEntries::from_inner(py, self.clone_ref(py)) NonNormalEntries::from_inner(py, self.clone_ref(py))
} }
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> { def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
Ok(self Ok(self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.get_non_normal_other_parent_entries().0 .non_normal_entries_contains(HgPath::new(key.data(py))))
.contains(HgPath::new(key.data(py))))
} }
def non_normal_entries_display(&self) -> PyResult<PyString> { def non_normal_entries_display(&self) -> PyResult<PyString> {
Ok( Ok(
PyString::new( PyString::new(
py, py,
&format!( &format!(
"NonNormalEntries: {:?}", "NonNormalEntries: {}",
hg::utils::join_display(
self self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.get_non_normal_other_parent_entries().0 .iter_non_normal_paths(),
.iter().map(|o| o)) ", "
)
)
) )
) )
} }
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> { def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
self self
.inner(py) .inner(py)
.borrow_mut() .borrow_mut()
.non_normal_entries_remove(HgPath::new(key.data(py))); .non_normal_entries_remove(HgPath::new(key.data(py)));
Ok(py.None()) Ok(py.None())
} }
def non_normal_entries_union(&self, other: PyObject) -> PyResult<PyList> { def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
let other: PyResult<_> = other.iter(py)? let mut inner = self.inner(py).borrow_mut();
.map(|f| {
Ok(HgPathBuf::from_bytes(
f?.extract::<PyBytes>(py)?.data(py),
))
})
.collect();
let res = self
.inner(py)
.borrow_mut()
.non_normal_entries_union(other?);
let ret = PyList::new(py, &[]); let ret = PyList::new(py, &[]);
for filename in res.iter() { for filename in inner.non_normal_or_other_parent_paths() {
let as_pystring = PyBytes::new(py, filename.as_bytes()); let as_pystring = PyBytes::new(py, filename.as_bytes());
ret.append(py, as_pystring.into_object()); ret.append(py, as_pystring.into_object());
} }
Ok(ret) Ok(ret)
} }
def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> { def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {
// Make sure the sets are defined before we no longer have a mutable // Make sure the sets are defined before we no longer have a mutable
// reference to the dmap. // reference to the dmap.
self.inner(py) self.inner(py)
.borrow_mut() .borrow_mut()
.set_non_normal_other_parent_entries(false); .set_non_normal_other_parent_entries(false);
let leaked_ref = self.inner(py).leak_immutable(); let leaked_ref = self.inner(py).leak_immutable();
NonNormalEntriesIterator::from_inner(py, unsafe { NonNormalEntriesIterator::from_inner(py, unsafe {
leaked_ref.map(py, |o| { leaked_ref.map(py, |o| {
o.get_non_normal_other_parent_entries_panic().0.iter() o.iter_non_normal_paths_panic()
}) })
}) })
} }
def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> { def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
let d = d.extract::<PyBytes>(py)?; let d = d.extract::<PyBytes>(py)?;
Ok(self.inner(py).borrow_mut() Ok(self.inner(py).borrow_mut()
.has_tracked_dir(HgPath::new(d.data(py))) .has_tracked_dir(HgPath::new(d.data(py)))

rust/hg-cpython/src/dirstate/non_normal_entries.rs

// non_normal_other_parent_entries.rs // non_normal_other_parent_entries.rs
// //
// Copyright 2020 Raphaël Gomès <rgomes@octobus.net> // Copyright 2020 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use cpython::{ use cpython::{
exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone, exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,
PyErr, PyList, PyObject, PyResult, PyString, Python, PythonObject, PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
ToPyObject, UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::dirstate::DirstateMap; use crate::dirstate::DirstateMap;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::hash_set;
py_class!(pub class NonNormalEntries |py| { py_class!(pub class NonNormalEntries |py| {
data dmap: DirstateMap; data dmap: DirstateMap;
def __contains__(&self, key: PyObject) -> PyResult<bool> { def __contains__(&self, key: PyObject) -> PyResult<bool> {
self.dmap(py).non_normal_entries_contains(py, key) self.dmap(py).non_normal_entries_contains(py, key)
} }
def remove(&self, key: PyObject) -> PyResult<PyObject> { def remove(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_remove(py, key) self.dmap(py).non_normal_entries_remove(py, key)
} }
def union(&self, other: PyObject) -> PyResult<PyList> {
self.dmap(py).non_normal_entries_union(py, other)
}
def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> { def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> {
match op { match op {
CompareOp::Eq => self.is_equal_to(py, other), CompareOp::Eq => self.is_equal_to(py, other),
CompareOp::Ne => Ok(!self.is_equal_to(py, other)?), CompareOp::Ne => Ok(!self.is_equal_to(py, other)?),
_ => Err(PyErr::new::<NotImplementedError, _>(py, "")) _ => Err(PyErr::new::<NotImplementedError, _>(py, ""))
} }
} }
def __repr__(&self) -> PyResult<PyString> { def __repr__(&self) -> PyResult<PyString> {
fn translate_key( fn translate_key(
py: Python, py: Python,
key: &HgPathBuf, key: &HgPathBuf,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, key.as_bytes()))) Ok(Some(PyBytes::new(py, key.as_bytes())))
} }
} }
type NonNormalEntriesIter<'a> = hash_set::Iter<'a, HgPathBuf>; type NonNormalEntriesIter<'a> =
Box<dyn Iterator<Item = &'a HgPathBuf> + Send + 'a>;
py_shared_iterator!( py_shared_iterator!(
NonNormalEntriesIterator, NonNormalEntriesIterator,
UnsafePyLeaked<NonNormalEntriesIter<'static>>, UnsafePyLeaked<NonNormalEntriesIter<'static>>,
NonNormalEntries::translate_key, NonNormalEntries::translate_key,
Option<PyBytes> Option<PyBytes>
); );