( )⚙ D10364 dirstate-tree: Empty shell for a second Rust DirstateMap implementation

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10364

dirstate-tree: Empty shell for a second Rust DirstateMap implementation
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG473abf4728bf: dirstate-tree: Empty shell for a second Rust DirstateMap implementation
rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation
Summary

For background see description of the previous changeset
"Make Rust DirstateMap bindings go through a trait object".

Add an empty shell for a opt-in second Rust implementation of the
DirstateMap type and the status function. For now all methods panic.
This can be seen in "action" with:

./hg status --config experimental.dirstate-tree.in-memory=1

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 27048.Apr 19 2021, 11:02 AM

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

Alphare accepted this revision.Apr 19 2021, 11:23 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-cpython/src/dirstate/dirstate_map.rs
57

I didn't know you could write as _, but it's cool!

SimonSapin updated this revision to Diff 27315.May 3 2021, 6:23 AM
SimonSapin added a commit: rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation.May 6 2021, 12:48 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27639

mercurial/configitems.py

) )
coreconfigitem( coreconfigitem(
b'experimental', b'experimental',
b'directaccess.revnums', b'directaccess.revnums',
default=False, default=False,
) )
coreconfigitem( coreconfigitem(
b'experimental', b'experimental',
b'dirstate-tree.in-memory',
default=False,
)
coreconfigitem(
b'experimental',
b'editortmpinhg', b'editortmpinhg',
default=False, default=False,
) )
coreconfigitem( coreconfigitem(
b'experimental', b'experimental',
b'evolution', b'evolution',
default=list, default=list,
) )

mercurial/dirstate.py

return self._rustmap return self._rustmap
@propertycache @propertycache
def _inner_rustmap(self): def _inner_rustmap(self):
""" """
Does not fill the Dirstatemap when called. This allows for Does not fill the Dirstatemap when called. This allows for
optimizations where only setting/getting the parents is needed. optimizations where only setting/getting the parents is needed.
""" """
self._inner_rustmap = rustmod.DirstateMap(self._root) use_dirstate_tree = self._ui.configbool(
b"experimental",
b"dirstate-tree.in-memory",
False,
)
self._inner_rustmap = rustmod.DirstateMap(use_dirstate_tree)
return self._inner_rustmap return self._inner_rustmap
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def preload(self): def preload(self):
self._rustmap self._rustmap

rust/hg-core/src/dirstate_tree.rs

pub mod dirstate_map;
pub mod dispatch; pub mod dispatch;

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

  • This file was added.
use std::path::PathBuf;
use std::time::Duration;
use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter;
use crate::DirstateEntry;
use crate::DirstateError;
use crate::DirstateMapError;
use crate::DirstateParents;
use crate::DirstateStatus;
use crate::EntryState;
use crate::FastHashMap;
use crate::HgPathCow;
use crate::PatternFileWarning;
use crate::StateMapIter;
use crate::StatusError;
use crate::StatusOptions;
pub struct DirstateMap {
// TODO
}
impl DirstateMap {
pub fn new() -> Self {
todo!()
}
}
impl super::dispatch::DirstateMapMethods for DirstateMap {
fn clear(&mut self) {
todo!()
}
fn add_file(
&mut self,
_filename: &HgPath,
_old_state: EntryState,
_entry: DirstateEntry,
) -> Result<(), DirstateMapError> {
todo!()
}
fn remove_file(
&mut self,
_filename: &HgPath,
_old_state: EntryState,
_size: i32,
) -> Result<(), DirstateMapError> {
todo!()
}
fn drop_file(
&mut self,
_filename: &HgPath,
_old_state: EntryState,
) -> Result<bool, DirstateMapError> {
todo!()
}
fn clear_ambiguous_times(
&mut self,
_filenames: Vec<HgPathBuf>,
_now: i32,
) {
todo!()
}
fn non_normal_entries_contains(&mut self, _key: &HgPath) -> bool {
todo!()
}
fn non_normal_entries_remove(&mut self, _key: &HgPath) -> bool {
todo!()
}
fn non_normal_or_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
todo!()
}
fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
todo!()
}
fn iter_non_normal_paths(
&mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!()
}
fn iter_non_normal_paths_panic(
&self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!()
}
fn iter_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
todo!()
}
fn has_tracked_dir(
&mut self,
_directory: &HgPath,
) -> Result<bool, DirstateMapError> {
todo!()
}
fn has_dir(
&mut self,
_directory: &HgPath,
) -> Result<bool, DirstateMapError> {
todo!()
}
fn parents(
&mut self,
_file_contents: &[u8],
) -> Result<&DirstateParents, DirstateError> {
todo!()
}
fn set_parents(&mut self, _parents: &DirstateParents) {
todo!()
}
fn read<'a>(
&mut self,
_file_contents: &'a [u8],
) -> Result<Option<&'a DirstateParents>, DirstateError> {
todo!()
}
fn pack(
&mut self,
_parents: DirstateParents,
_now: Duration,
) -> Result<Vec<u8>, DirstateError> {
todo!()
}
fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> {
todo!()
}
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> {
todo!()
}
fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
todo!()
}
fn status<'a>(
&'a self,
_matcher: &'a (dyn Matcher + Sync),
_root_dir: PathBuf,
_ignore_files: Vec<PathBuf>,
_options: StatusOptions,
) -> Result<
(
(Vec<HgPathCow<'a>>, DirstateStatus<'a>),
Vec<PatternFileWarning>,
),
StatusError,
> {
todo!()
}
fn copy_map_len(&self) -> usize {
todo!()
}
fn copy_map_iter(&self) -> CopyMapIter<'_> {
todo!()
}
fn copy_map_contains_key(&self, _key: &HgPath) -> bool {
todo!()
}
fn copy_map_get(&self, _key: &HgPath) -> Option<&HgPathBuf> {
todo!()
}
fn copy_map_remove(&mut self, _key: &HgPath) -> Option<HgPathBuf> {
todo!()
}
fn copy_map_insert(
&mut self,
_key: HgPathBuf,
_value: HgPathBuf,
) -> Option<HgPathBuf> {
todo!()
}
fn len(&self) -> usize {
todo!()
}
fn contains_key(&self, _key: &HgPath) -> bool {
todo!()
}
fn get(&self, _key: &HgPath) -> Option<&DirstateEntry> {
todo!()
}
fn iter(&self) -> StateMapIter<'_> {
todo!()
}
}

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

// The same logic applies to `dirs` and `all_dirs`, however the `Dirs` // The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
// `py_class!` is already implemented and does not mention // `py_class!` is already implemented and does not mention
// `RustDirstateMap`, rightfully so. // `RustDirstateMap`, rightfully so.
// All attributes also have to have a separate refcount data attribute for // All attributes also have to have a separate refcount data attribute for
// leaks, with all methods that go along for reference sharing. // leaks, with all methods that go along for reference sharing.
py_class!(pub class DirstateMap |py| { py_class!(pub class DirstateMap |py| {
@shared data inner: Box<dyn DirstateMapMethods + Send>; @shared data inner: Box<dyn DirstateMapMethods + Send>;
def __new__(_cls, _root: PyObject) -> PyResult<Self> { def __new__(_cls, use_dirstate_tree: bool) -> PyResult<Self> {
let inner = Box::new(RustDirstateMap::default()); let inner = if use_dirstate_tree {
Box::new(hg::dirstate_tree::dirstate_map::DirstateMap::new()) as _
} else {
Box::new(RustDirstateMap::default()) as _
AlphareUnsubmitted
Not Done

I didn't know you could write as _, but it's cool!

Alphare: I didn't know you could write `as _`, but it's cool!
};
Self::create_instance(py, inner) Self::create_instance(py, inner)
} }
def clear(&self) -> PyResult<PyObject> { def clear(&self) -> PyResult<PyObject> {
self.inner(py).borrow_mut().clear(); self.inner(py).borrow_mut().clear();
Ok(py.None()) Ok(py.None())
} }