This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10546

dirstate-tree: Give to `status()` mutable access to the `DirstateMap`
ClosedPublic

Authored by SimonSapin on May 3 2021, 6:24 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGd5956136d19d: dirstate-tree: Give to `status()` mutable access to the `DirstateMap`
rHG5d323a0ba8ef: dirstate-tree: Give to `status()` mutable access to the `DirstateMap`

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.May 3 2021, 6:24 AM
Alphare added a subscriber: Alphare.May 3 2021, 9:03 AM
Alphare added inline comments.
rust/hg-cpython/src/dirstate/dirstate_map.rs
530

Should this be called get_inner_mut then?

SimonSapin added inline comments.May 6 2021, 5:09 AM
rust/hg-cpython/src/dirstate/dirstate_map.rs
530

Yeah that makes sense, will do.

baymax updated this revision to Diff 27622.May 6 2021, 12:03 PM

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

Alphare accepted this revision.May 6 2021, 12:09 PM
This revision is now accepted and ready to land.May 6 2021, 12:09 PM

Revision Contents
Changeset List

Diff 27656

rust/hg-core/src/dirstate/status.rs

was_file: bool, was_file: bool,
}, },
} }
type IoResult<T> = std::io::Result<T>; type IoResult<T> = std::io::Result<T>;
/// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait, 'static>`, so add /// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait, 'static>`, so add
/// an explicit lifetime here to not fight `'static` bounds "out of nowhere". /// an explicit lifetime here to not fight `'static` bounds "out of nowhere".
type IgnoreFnType<'a> = Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>; pub type IgnoreFnType<'a> =
Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>;
/// We have a good mix of owned (from directory traversal) and borrowed (from /// We have a good mix of owned (from directory traversal) and borrowed (from
/// the dirstate/explicit) paths, this comes up a lot. /// the dirstate/explicit) paths, this comes up a lot.
pub type HgPathCow<'a> = Cow<'a, HgPath>; pub type HgPathCow<'a> = Cow<'a, HgPath>;
/// A path with its computed ``Dispatch`` information /// A path with its computed ``Dispatch`` information
type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch); type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch);

rust/hg-core/src/dirstate_tree.rs

pub mod dirstate_map; pub mod dirstate_map;
pub mod dispatch; pub mod dispatch;
pub mod path_with_basename; pub mod path_with_basename;
mod status;

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

fn set_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
// Do nothing, this `DirstateMap` does not a separate `dirs` that needs // Do nothing, this `DirstateMap` does not a separate `dirs` that needs
// to be recomputed // to be recomputed
Ok(()) Ok(())
} }
fn status<'a>( fn status<'a>(
&'a self, &'a mut self,
_matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
_root_dir: PathBuf, root_dir: PathBuf,
_ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
_options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {
todo!() super::status::status(self, matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { fn copy_map_len(&self) -> usize {
self.nodes_with_copy_source_count self.nodes_with_copy_source_count
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(self.iter_nodes().filter_map(|(path, node)| { Box::new(self.iter_nodes().filter_map(|(path, node)| {

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

now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>;
fn set_dirs(&mut self) -> Result<(), DirstateMapError>; fn set_dirs(&mut self) -> Result<(), DirstateMapError>;
fn status<'a>( fn status<'a>(
&'a self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>; ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
fn copy_map_len(&self) -> usize; fn copy_map_len(&self) -> usize;
self.set_all_dirs() self.set_all_dirs()
} }
fn set_dirs(&mut self) -> Result<(), DirstateMapError> { fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
self.set_dirs() self.set_dirs()
} }
fn status<'a>( fn status<'a>(
&'a self, &'a mut self,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{ {
crate::status(self, matcher, root_dir, ignore_files, options) crate::status(self, matcher, root_dir, ignore_files, options)
} }

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

  • This file was added.
use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::matchers::Matcher;
use crate::DirstateStatus;
use crate::PatternFileWarning;
use crate::StatusError;
use crate::StatusOptions;
use std::path::PathBuf;
pub fn status<'a>(
_dmap: &'a mut DirstateMap,
_matcher: &'a (dyn Matcher + Sync),
_root_dir: PathBuf,
_ignore_files: Vec<PathBuf>,
_options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> {
todo!()
}

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 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.
//! Bindings for the `hg::dirstate::dirstate_map` file provided by the //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::{Ref, RefCell}; use std::cell::{RefCell, RefMut};
use std::convert::TryInto; use std::convert::TryInto;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, PyTuple, Python, PythonObject, PyObject, PyResult, PySet, PyString, PyTuple, Python, PythonObject,
ToPyObject, UnsafePyLeaked, ToPyObject, UnsafePyLeaked,
}; };
py, py,
unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) }, unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
) )
} }
}); });
impl DirstateMap { impl DirstateMap {
pub fn get_inner<'a>( pub fn get_inner_mut<'a>(
AlphareUnsubmitted
Not Done

Should this be called get_inner_mut then?

Alphare: Should this be called `get_inner_mut` then?
SimonSapinAuthorUnsubmitted
Done

Yeah that makes sense, will do.

SimonSapin: Yeah that makes sense, will do.
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> Ref<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
self.inner(py).borrow() self.inner(py).borrow_mut()
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: (&HgPathBuf, &DirstateEntry), res: (&HgPathBuf, &DirstateEntry),
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
Ok(Some(PyBytes::new(py, res.0.as_bytes()))) Ok(Some(PyBytes::new(py, res.0.as_bytes())))
} }
fn translate_key_value( fn translate_key_value(

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

list_ignored: bool, list_ignored: bool,
list_unknown: bool, list_unknown: bool,
collect_traversed_dirs: bool, collect_traversed_dirs: bool,
) -> PyResult<PyTuple> { ) -> PyResult<PyTuple> {
let bytes = root_dir.extract::<PyBytes>(py)?; let bytes = root_dir.extract::<PyBytes>(py)?;
let root_dir = get_path_from_bytes(bytes.data(py)); let root_dir = get_path_from_bytes(bytes.data(py));
let dmap: DirstateMap = dmap.to_py_object(py); let dmap: DirstateMap = dmap.to_py_object(py);
let dmap = dmap.get_inner(py); let mut dmap = dmap.get_inner_mut(py);
let ignore_files: PyResult<Vec<_>> = ignore_files let ignore_files: PyResult<Vec<_>> = ignore_files
.iter(py) .iter(py)
.map(|b| { .map(|b| {
let file = b.extract::<PyBytes>(py)?; let file = b.extract::<PyBytes>(py)?;
Ok(get_path_from_bytes(file.data(py)).to_owned()) Ok(get_path_from_bytes(file.data(py)).to_owned())
}) })
.collect(); .collect();