( )⚙ D11517 dirstate: Remove the Rust abstraction DirstateMapMethods

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11517

dirstate: Remove the Rust abstraction DirstateMapMethods
ClosedPublic

Authored by SimonSapin on Sep 29 2021, 10:56 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3d0a9c6e614d: dirstate: Remove the Rust abstraction DirstateMapMethods
Summary

This Rust trait used to exist in order to allow the DirstateMap class exposed
to Python to be backed by either of two implementations: one similar to the
Python implementation based on a "flat" HashMap<HgPathBuf, DirstateEntry>,
and the newer one based on a tree of nodes matching the directory structure
of tracked files. A boxed trait object was used with dynamic dispatch.

With the flat implementation removed and only the tree one remaining, this
abstraction is not useful anymore and the concrete type can be stored directly.

It remains that the trait was implemented separately for DirstateMap<'_>
(which takes a lifetime parameter) and OwningDirstateMap (whose job is to
wrap the former and hide the lifetime parameter), with the latter impl only
forwarding calls.

This changeset also removes this forwarding. Instead, the methods formerly of
the DirstateMapMethods trait are now inherent methods implemented for
OwningDirstateMap (where they will actually be used) but in the module that
defines DirstateMap. This unusual setup gives access to the private fields
of DirstateMap from those methods.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Sep 29 2021, 10:56 AM
Alphare accepted this revision.Sep 29 2021, 12:35 PM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-core/src/dirstate_tree/owning.rs
47

Good catch!

This revision is now accepted and ready to land.Sep 29 2021, 12:35 PM

Revision Contents
Changeset List

Diff 30443

rust/hg-core/src/dirstate_tree.rs

pub mod dirstate_map; pub mod dirstate_map;
pub mod dispatch;
pub mod on_disk; pub mod on_disk;
pub mod owning; pub mod owning;
mod owning_dispatch;
pub mod path_with_basename; pub mod path_with_basename;
pub mod status; pub mod status;

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

use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use micro_timer::timed; use micro_timer::timed;
use std::borrow::Cow; use std::borrow::Cow;
use std::convert::TryInto; use std::convert::TryInto;
use std::path::PathBuf; use std::path::PathBuf;
use super::on_disk; use super::on_disk;
use super::on_disk::DirstateV2ParseError; use super::on_disk::DirstateV2ParseError;
use super::owning::OwningDirstateMap;
use super::path_with_basename::WithBasename; use super::path_with_basename::WithBasename;
use crate::dirstate::parsers::pack_entry; use crate::dirstate::parsers::pack_entry;
use crate::dirstate::parsers::packed_entry_size; use crate::dirstate::parsers::packed_entry_size;
use crate::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::dirstate::CopyMapIter; use crate::dirstate::CopyMapIter;
use crate::dirstate::StateMapIter; use crate::dirstate::StateMapIter;
use crate::dirstate::SIZE_FROM_OTHER_PARENT; use crate::dirstate::SIZE_FROM_OTHER_PARENT;
F: Fn(A) -> Result<Option<B>, E> + 'a, F: Fn(A) -> Result<Option<B>, E> + 'a,
{ {
iter.filter_map(move |result| match result { iter.filter_map(move |result| match result {
Ok(node) => f(node).transpose(), Ok(node) => f(node).transpose(),
Err(e) => Some(Err(e)), Err(e) => Some(Err(e)),
}) })
} }
impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> { impl OwningDirstateMap {
fn clear(&mut self) { pub fn clear(&mut self) {
self.root = Default::default(); let map = self.get_map_mut();
self.nodes_with_entry_count = 0; map.root = Default::default();
self.nodes_with_copy_source_count = 0; map.nodes_with_entry_count = 0;
map.nodes_with_copy_source_count = 0;
} }
fn set_entry( pub fn set_entry(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
self.get_or_insert(&filename)?.data = NodeData::Entry(entry); let map = self.get_map_mut();
map.get_or_insert(&filename)?.data = NodeData::Entry(entry);
Ok(()) Ok(())
} }
fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_state = self.get(filename)?.map(|e| e.state()); let old_state = self.get(filename)?.map(|e| e.state());
Ok(self.add_or_remove_file(filename, old_state, entry)?) let map = self.get_map_mut();
Ok(map.add_or_remove_file(filename, old_state, entry)?)
} }
fn remove_file( pub fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_entry_opt = self.get(filename)?; let old_entry_opt = self.get(filename)?;
let old_state = old_entry_opt.map(|e| e.state()); let old_state = old_entry_opt.map(|e| e.state());
let mut size = 0; let mut size = 0;
if in_merge { if in_merge {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
} }
} }
} }
if size == 0 { if size == 0 {
self.copy_map_remove(filename)?; self.copy_map_remove(filename)?;
} }
let map = self.get_map_mut();
let entry = DirstateEntry::new_removed(size); let entry = DirstateEntry::new_removed(size);
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(map.add_or_remove_file(filename, old_state, entry)?)
} }
fn drop_entry_and_copy_source( pub fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let was_tracked = self let was_tracked = self
.get(filename)? .get(filename)?
.map_or(false, |e| e.state().is_tracked()); .map_or(false, |e| e.state().is_tracked());
let map = self.get_map_mut();
struct Dropped { struct Dropped {
was_tracked: bool, was_tracked: bool,
had_entry: bool, had_entry: bool,
had_copy_source: bool, had_copy_source: bool,
} }
/// If this returns `Ok(Some((dropped, removed)))`, then /// If this returns `Ok(Some((dropped, removed)))`, then
/// ///
unreachable_bytes, unreachable_bytes,
key.full_path(), key.full_path(),
) )
} }
Ok(Some((dropped, remove))) Ok(Some((dropped, remove)))
} }
if let Some((dropped, _removed)) = recur( if let Some((dropped, _removed)) = recur(
self.on_disk, map.on_disk,
&mut self.unreachable_bytes, &mut map.unreachable_bytes,
&mut self.root, &mut map.root,
filename, filename,
)? { )? {
if dropped.had_entry { if dropped.had_entry {
self.nodes_with_entry_count -= 1 map.nodes_with_entry_count -= 1
} }
if dropped.had_copy_source { if dropped.had_copy_source {
self.nodes_with_copy_source_count -= 1 map.nodes_with_copy_source_count -= 1
} }
} else { } else {
debug_assert!(!was_tracked); debug_assert!(!was_tracked);
} }
Ok(()) Ok(())
} }
fn has_tracked_dir( pub fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
if let Some(node) = self.get_node(directory)? { let map = self.get_map_mut();
if let Some(node) = map.get_node(directory)? {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child
// nodes, and is therefore a directory. // nodes, and is therefore a directory.
let state = node.state()?; let state = node.state()?;
Ok(state.is_none() && node.tracked_descendants_count() > 0) Ok(state.is_none() && node.tracked_descendants_count() > 0)
} else { } else {
Ok(false) Ok(false)
} }
} }
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> { pub fn has_dir(
if let Some(node) = self.get_node(directory)? { &mut self,
directory: &HgPath,
) -> Result<bool, DirstateError> {
let map = self.get_map_mut();
if let Some(node) = map.get_node(directory)? {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child
// nodes, and is therefore a directory. // nodes, and is therefore a directory.
let state = node.state()?; let state = node.state()?;
Ok(state.is_none() && node.descendants_with_entry_count() > 0) Ok(state.is_none() && node.descendants_with_entry_count() > 0)
} else { } else {
Ok(false) Ok(false)
} }
} }
#[timed] #[timed]
fn pack_v1( pub fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
let map = self.get_map_mut();
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut ambiguous_mtimes = Vec::new(); let mut ambiguous_mtimes = Vec::new();
// Optizimation (to be measured?): pre-compute size to avoid `Vec` // Optizimation (to be measured?): pre-compute size to avoid `Vec`
// reallocations // reallocations
let mut size = parents.as_bytes().len(); let mut size = parents.as_bytes().len();
for node in self.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
size += packed_entry_size( size += packed_entry_size(
node.full_path(self.on_disk)?, node.full_path(map.on_disk)?,
node.copy_source(self.on_disk)?, node.copy_source(map.on_disk)?,
); );
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
ambiguous_mtimes.push( ambiguous_mtimes.push(
node.full_path_borrowed(self.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
let mut packed = Vec::with_capacity(size); let mut packed = Vec::with_capacity(size);
packed.extend(parents.as_bytes()); packed.extend(parents.as_bytes());
for node in self.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
pack_entry( pack_entry(
node.full_path(self.on_disk)?, node.full_path(map.on_disk)?,
&entry, &entry,
node.copy_source(self.on_disk)?, node.copy_source(map.on_disk)?,
&mut packed, &mut packed,
); );
} }
} }
Ok(packed) Ok(packed)
} }
/// Returns new data and metadata together with whether that data should be /// Returns new data and metadata together with whether that data should be
/// appended to the existing data file whose content is at /// appended to the existing data file whose content is at
/// `self.on_disk` (true), instead of written to a new data file /// `map.on_disk` (true), instead of written to a new data file
/// (false). /// (false).
#[timed] #[timed]
fn pack_v2( pub fn pack_v2(
&mut self, &mut self,
now: Timestamp, now: Timestamp,
can_append: bool, can_append: bool,
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> { ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
let map = self.get_map_mut();
// TODO:!how do we want to handle this in 2038? // TODO:!how do we want to handle this in 2038?
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut paths = Vec::new(); let mut paths = Vec::new();
for node in self.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
if entry.mtime_is_ambiguous(now) { if entry.mtime_is_ambiguous(now) {
paths.push( paths.push(
node.full_path_borrowed(self.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
// Borrow of `self` ends here since we collect cloned paths // Borrow of `self` ends here since we collect cloned paths
self.clear_known_ambiguous_mtimes(&paths)?; map.clear_known_ambiguous_mtimes(&paths)?;
on_disk::write(self, can_append) on_disk::write(map, can_append)
} }
fn status<'a>( pub fn status<'a>(
&'a mut 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>
{ {
super::status::status(self, matcher, root_dir, ignore_files, options) let map = self.get_map_mut();
super::status::status(map, matcher, root_dir, ignore_files, options)
} }
fn copy_map_len(&self) -> usize { pub fn copy_map_len(&self) -> usize {
self.nodes_with_copy_source_count as usize let map = self.get_map();
map.nodes_with_copy_source_count as usize
} }
fn copy_map_iter(&self) -> CopyMapIter<'_> { pub fn copy_map_iter(&self) -> CopyMapIter<'_> {
Box::new(filter_map_results(self.iter_nodes(), move |node| { let map = self.get_map();
Ok(if let Some(source) = node.copy_source(self.on_disk)? { Box::new(filter_map_results(map.iter_nodes(), move |node| {
Some((node.full_path(self.on_disk)?, source)) Ok(if let Some(source) = node.copy_source(map.on_disk)? {
Some((node.full_path(map.on_disk)?, source))
} else { } else {
None None
}) })
})) }))
} }
fn copy_map_contains_key( pub fn copy_map_contains_key(
&self, &self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? { let map = self.get_map();
Ok(if let Some(node) = map.get_node(key)? {
node.has_copy_source() node.has_copy_source()
} else { } else {
false false
}) })
} }
fn copy_map_get( pub fn copy_map_get(
&self, &self,
key: &HgPath, key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError> { ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
if let Some(node) = self.get_node(key)? { let map = self.get_map();
if let Some(source) = node.copy_source(self.on_disk)? { if let Some(node) = map.get_node(key)? {
if let Some(source) = node.copy_source(map.on_disk)? {
return Ok(Some(source)); return Ok(Some(source));
} }
} }
Ok(None) Ok(None)
} }
fn copy_map_remove( pub fn copy_map_remove(
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
let count = &mut self.nodes_with_copy_source_count; let map = self.get_map_mut();
let unreachable_bytes = &mut self.unreachable_bytes; let count = &mut map.nodes_with_copy_source_count;
Ok(Self::get_node_mut( let unreachable_bytes = &mut map.unreachable_bytes;
self.on_disk, Ok(DirstateMap::get_node_mut(
map.on_disk,
unreachable_bytes, unreachable_bytes,
&mut self.root, &mut map.root,
key, key,
)? )?
.and_then(|node| { .and_then(|node| {
if let Some(source) = &node.copy_source { if let Some(source) = &node.copy_source {
*count -= 1; *count -= 1;
Self::count_dropped_path(unreachable_bytes, source); DirstateMap::count_dropped_path(unreachable_bytes, source);
} }
node.copy_source.take().map(Cow::into_owned) node.copy_source.take().map(Cow::into_owned)
})) }))
} }
fn copy_map_insert( pub fn copy_map_insert(
&mut self, &mut self,
key: HgPathBuf, key: HgPathBuf,
value: HgPathBuf, value: HgPathBuf,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
let node = Self::get_or_insert_node( let map = self.get_map_mut();
self.on_disk, let node = DirstateMap::get_or_insert_node(
&mut self.unreachable_bytes, map.on_disk,
&mut self.root, &mut map.unreachable_bytes,
&mut map.root,
&key, &key,
WithBasename::to_cow_owned, WithBasename::to_cow_owned,
|_ancestor| {}, |_ancestor| {},
)?; )?;
if node.copy_source.is_none() { if node.copy_source.is_none() {
self.nodes_with_copy_source_count += 1 map.nodes_with_copy_source_count += 1
} }
Ok(node.copy_source.replace(value.into()).map(Cow::into_owned)) Ok(node.copy_source.replace(value.into()).map(Cow::into_owned))
} }
fn len(&self) -> usize { pub fn len(&self) -> usize {
self.nodes_with_entry_count as usize let map = self.get_map();
map.nodes_with_entry_count as usize
} }
fn contains_key( pub fn contains_key(
&self, &self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
Ok(self.get(key)?.is_some()) Ok(self.get(key)?.is_some())
} }
fn get( pub fn get(
&self, &self,
key: &HgPath, key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? { let map = self.get_map();
Ok(if let Some(node) = map.get_node(key)? {
node.entry()? node.entry()?
} else { } else {
None None
}) })
} }
fn iter(&self) -> StateMapIter<'_> { pub fn iter(&self) -> StateMapIter<'_> {
Box::new(filter_map_results(self.iter_nodes(), move |node| { let map = self.get_map();
Box::new(filter_map_results(map.iter_nodes(), move |node| {
Ok(if let Some(entry) = node.entry()? { Ok(if let Some(entry) = node.entry()? {
Some((node.full_path(self.on_disk)?, entry)) Some((node.full_path(map.on_disk)?, entry))
} else { } else {
None None
}) })
})) }))
} }
fn iter_tracked_dirs( pub fn iter_tracked_dirs(
&mut self, &mut self,
) -> Result< ) -> Result<
Box< Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send + Send
+ '_, + '_,
>, >,
DirstateError, DirstateError,
> { > {
let on_disk = self.on_disk; let map = self.get_map_mut();
let on_disk = map.on_disk;
Ok(Box::new(filter_map_results( Ok(Box::new(filter_map_results(
self.iter_nodes(), map.iter_nodes(),
move |node| { move |node| {
Ok(if node.tracked_descendants_count() > 0 { Ok(if node.tracked_descendants_count() > 0 {
Some(node.full_path(on_disk)?) Some(node.full_path(on_disk)?)
} else { } else {
None None
}) })
}, },
))) )))
} }
fn debug_iter( pub fn debug_iter(
&self, &self,
all: bool, all: bool,
) -> Box< ) -> Box<
dyn Iterator< dyn Iterator<
Item = Result< Item = Result<
(&HgPath, (u8, i32, i32, i32)), (&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError, DirstateV2ParseError,
>, >,
> + Send > + Send
+ '_, + '_,
> { > {
Box::new(filter_map_results(self.iter_nodes(), move |node| { let map = self.get_map();
Box::new(filter_map_results(map.iter_nodes(), move |node| {
let debug_tuple = if let Some(entry) = node.entry()? { let debug_tuple = if let Some(entry) = node.entry()? {
entry.debug_tuple() entry.debug_tuple()
} else if !all { } else if !all {
return Ok(None); return Ok(None);
} else if let Some(mtime) = node.cached_directory_mtime() { } else if let Some(mtime) = node.cached_directory_mtime() {
(b' ', 0, -1, mtime.seconds() as i32) (b' ', 0, -1, mtime.seconds() as i32)
} else { } else {
(b' ', 0, -1, -1) (b' ', 0, -1, -1)
}; };
Ok(Some((node.full_path(self.on_disk)?, debug_tuple))) Ok(Some((node.full_path(map.on_disk)?, debug_tuple)))
})) }))
} }
} }

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

  • This file was deleted.
use std::path::PathBuf;
use crate::dirstate::parsers::Timestamp;
use crate::dirstate::CopyMapIter;
use crate::dirstate::StateMapIter;
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::DirstateEntry;
use crate::DirstateError;
use crate::DirstateParents;
use crate::DirstateStatus;
use crate::PatternFileWarning;
use crate::StatusError;
use crate::StatusOptions;
/// `rust/hg-cpython/src/dirstate/dirstate_map.rs` implements in Rust a
/// `DirstateMap` Python class that wraps `Box<dyn DirstateMapMethods + Send>`,
/// a trait object of this trait. Except for constructors, this trait defines
/// all APIs that the class needs to interact with its inner dirstate map.
///
/// A trait object is used to support two different concrete types:
///
/// * `rust/hg-core/src/dirstate/dirstate_map.rs` defines the "flat dirstate
/// map" which is based on a few large `HgPath`-keyed `HashMap` and `HashSet`
/// fields.
/// * `rust/hg-core/src/dirstate_tree/dirstate_map.rs` defines the "tree
/// dirstate map" based on a tree data struture with nodes for directories
/// containing child nodes for their files and sub-directories. This tree
/// enables a more efficient algorithm for `hg status`, but its details are
/// abstracted in this trait.
///
/// The dirstate map associates paths of files in the working directory to
/// various information about the state of those files.
pub trait DirstateMapMethods {
/// Remove information about all files in this map
fn clear(&mut self);
/// Add the given filename to the map if it is not already there, and
/// associate the given entry with it.
fn set_entry(
&mut self,
filename: &HgPath,
entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError>;
/// Add or change the information associated to a given file.
fn add_file(
&mut self,
filename: &HgPath,
entry: DirstateEntry,
) -> Result<(), DirstateError>;
/// Mark a file as "removed" (as in `hg rm`).
fn remove_file(
&mut self,
filename: &HgPath,
in_merge: bool,
) -> Result<(), DirstateError>;
/// Drop information about this file from the map if any.
///
/// `get` will now return `None` for this filename.
fn drop_entry_and_copy_source(
&mut self,
filename: &HgPath,
) -> Result<(), DirstateError>;
/// Returns whether the sub-tree rooted at the given directory contains any
/// tracked file.
///
/// A file is tracked if it has a `state` other than `EntryState::Removed`.
fn has_tracked_dir(
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateError>;
/// Returns whether the sub-tree rooted at the given directory contains any
/// file with a dirstate entry.
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError>;
/// Clear mtimes equal to `now` in entries with `state ==
/// EntryState::Normal`, and serialize bytes to write the `.hg/dirstate`
/// file to disk in dirstate-v1 format.
fn pack_v1(
&mut self,
parents: DirstateParents,
now: Timestamp,
) -> Result<Vec<u8>, DirstateError>;
/// Clear mtimes equal to `now` in entries with `state ==
/// EntryState::Normal`, and serialize bytes to write a dirstate data file
/// to disk in dirstate-v2 format.
///
/// Returns new data and metadata together with whether that data should be
/// appended to the existing data file whose content is at
/// `self.on_disk` (true), instead of written to a new data file
/// (false).
///
/// Note: this is only supported by the tree dirstate map.
fn pack_v2(
&mut self,
now: Timestamp,
can_append: bool,
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError>;
/// Run the status algorithm.
///
/// This is not sematically a method of the dirstate map, but a different
/// algorithm is used for the flat v.s. tree dirstate map so having it in
/// this trait enables the same dynamic dispatch as with other methods.
fn status<'a>(
&'a mut self,
matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf,
ignore_files: Vec<PathBuf>,
options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
/// Returns how many files in the dirstate map have a recorded copy source.
fn copy_map_len(&self) -> usize;
/// Returns an iterator of `(path, copy_source)` for all files that have a
/// copy source.
fn copy_map_iter(&self) -> CopyMapIter<'_>;
/// Returns whether the givef file has a copy source.
fn copy_map_contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError>;
/// Returns the copy source for the given file.
fn copy_map_get(
&self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError>;
/// Removes the recorded copy source if any for the given file, and returns
/// it.
fn copy_map_remove(
&mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
/// Set the given `value` copy source for the given `key` file.
fn copy_map_insert(
&mut self,
key: HgPathBuf,
value: HgPathBuf,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError>;
/// Returns the number of files that have an entry.
fn len(&self) -> usize;
/// Returns whether the given file has an entry.
fn contains_key(&self, key: &HgPath)
-> Result<bool, DirstateV2ParseError>;
/// Returns the entry, if any, for the given file.
fn get(
&self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError>;
/// Returns a `(path, entry)` iterator of files that have an entry.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn iter(&self) -> StateMapIter<'_>;
/// Returns an iterator of tracked directories.
///
/// This is the paths for which `has_tracked_dir` would return true.
/// Or, in other words, the union of ancestor paths of all paths that have
/// an associated entry in a "tracked" state in this dirstate map.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
>;
/// Return an iterator of `(path, (state, mode, size, mtime))` for every
/// node stored in this dirstate map, for the purpose of the `hg
/// debugdirstate` command.
///
/// If `all` is true, include nodes that don’t have an entry.
/// For such nodes `state` is the ASCII space.
/// An `mtime` may still be present. It is used to optimize `status`.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn debug_iter(
&self,
all: bool,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError,
>,
> + Send
+ '_,
>;
}

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

let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map)); let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));
// Erase the pointed type entirely in order to erase the lifetime. // Erase the pointed type entirely in order to erase the lifetime.
let ptr: *mut () = ptr.cast(); let ptr: *mut () = ptr.cast();
Self { on_disk, ptr } Self { on_disk, ptr }
} }
pub fn get_mut_pair<'a>( pub fn get_pair_mut<'a>(
AlphareUnsubmitted
Not Done

Good catch!

Alphare: Good catch!
&'a mut self, &'a mut self,
) -> (&'a [u8], &'a mut DirstateMap<'a>) { ) -> (&'a [u8], &'a mut DirstateMap<'a>) {
// SAFETY: We cast the type-erased pointer back to the same type it had // SAFETY: We cast the type-erased pointer back to the same type it had
// in `new`, except with a different lifetime parameter. This time we // in `new`, except with a different lifetime parameter. This time we
// connect the lifetime to that of `self`. This cast is valid because // connect the lifetime to that of `self`. This cast is valid because
// `self` owns the same `PyBytes` whose buffer `DirstateMap` // `self` owns the same `PyBytes` whose buffer `DirstateMap`
// references. That buffer has a stable memory address because the byte // references. That buffer has a stable memory address because the byte
// string value of a `PyBytes` is immutable. // string value of a `PyBytes` is immutable.
let ptr: *mut DirstateMap<'a> = self.ptr.cast(); let ptr: *mut DirstateMap<'a> = self.ptr.cast();
// SAFETY: we dereference that pointer, connecting the lifetime of the // SAFETY: we dereference that pointer, connecting the lifetime of the
// new `&mut` to that of `self`. This is valid because the // new `&mut` to that of `self`. This is valid because the
// raw pointer is to a boxed value, and `self` owns that box. // raw pointer is to a boxed value, and `self` owns that box.
(&self.on_disk, unsafe { &mut *ptr }) (&self.on_disk, unsafe { &mut *ptr })
} }
pub fn get_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> { pub fn get_map_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> {
self.get_mut_pair().1 self.get_pair_mut().1
} }
pub fn get<'a>(&'a self) -> &'a DirstateMap<'a> { pub fn get_map<'a>(&'a self) -> &'a DirstateMap<'a> {
// SAFETY: same reasoning as in `get_mut` above. // SAFETY: same reasoning as in `get_mut` above.
let ptr: *mut DirstateMap<'a> = self.ptr.cast(); let ptr: *mut DirstateMap<'a> = self.ptr.cast();
unsafe { &*ptr } unsafe { &*ptr }
} }
pub fn on_disk<'a>(&'a self) -> &'a [u8] { pub fn on_disk<'a>(&'a self) -> &'a [u8] {
&self.on_disk &self.on_disk
} }

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

  • This file was deleted.
use crate::dirstate::parsers::Timestamp;
use crate::dirstate::CopyMapIter;
use crate::dirstate::StateMapIter;
use crate::dirstate_tree::dispatch::DirstateMapMethods;
use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::dirstate_tree::owning::OwningDirstateMap;
use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::DirstateEntry;
use crate::DirstateError;
use crate::DirstateParents;
use crate::DirstateStatus;
use crate::PatternFileWarning;
use crate::StatusError;
use crate::StatusOptions;
use std::path::PathBuf;
impl DirstateMapMethods for OwningDirstateMap {
fn clear(&mut self) {
self.get_mut().clear()
}
fn set_entry(
&mut self,
filename: &HgPath,
entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> {
self.get_mut().set_entry(filename, entry)
}
fn add_file(
&mut self,
filename: &HgPath,
entry: DirstateEntry,
) -> Result<(), DirstateError> {
self.get_mut().add_file(filename, entry)
}
fn remove_file(
&mut self,
filename: &HgPath,
in_merge: bool,
) -> Result<(), DirstateError> {
self.get_mut().remove_file(filename, in_merge)
}
fn drop_entry_and_copy_source(
&mut self,
filename: &HgPath,
) -> Result<(), DirstateError> {
self.get_mut().drop_entry_and_copy_source(filename)
}
fn has_tracked_dir(
&mut self,
directory: &HgPath,
) -> Result<bool, DirstateError> {
self.get_mut().has_tracked_dir(directory)
}
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
self.get_mut().has_dir(directory)
}
fn pack_v1(
&mut self,
parents: DirstateParents,
now: Timestamp,
) -> Result<Vec<u8>, DirstateError> {
self.get_mut().pack_v1(parents, now)
}
fn pack_v2(
&mut self,
now: Timestamp,
can_append: bool,
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
self.get_mut().pack_v2(now, can_append)
}
fn status<'a>(
&'a mut self,
matcher: &'a (dyn Matcher + Sync),
root_dir: PathBuf,
ignore_files: Vec<PathBuf>,
options: StatusOptions,
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
{
self.get_mut()
.status(matcher, root_dir, ignore_files, options)
}
fn copy_map_len(&self) -> usize {
self.get().copy_map_len()
}
fn copy_map_iter(&self) -> CopyMapIter<'_> {
self.get().copy_map_iter()
}
fn copy_map_contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get().copy_map_contains_key(key)
}
fn copy_map_get(
&self,
key: &HgPath,
) -> Result<Option<&HgPath>, DirstateV2ParseError> {
self.get().copy_map_get(key)
}
fn copy_map_remove(
&mut self,
key: &HgPath,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
self.get_mut().copy_map_remove(key)
}
fn copy_map_insert(
&mut self,
key: HgPathBuf,
value: HgPathBuf,
) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
self.get_mut().copy_map_insert(key, value)
}
fn len(&self) -> usize {
self.get().len()
}
fn contains_key(
&self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get().contains_key(key)
}
fn get(
&self,
key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
self.get().get(key)
}
fn iter(&self) -> StateMapIter<'_> {
self.get().iter()
}
fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
> {
self.get_mut().iter_tracked_dirs()
}
fn debug_iter(
&self,
all: bool,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError,
>,
> + Send
+ '_,
> {
self.get().debug_iter(all)
}
}

rust/hg-core/src/repo.rs

.hg_vfs() .hg_vfs()
.mmap_open(docket.data_filename()) .mmap_open(docket.data_filename())
.io_not_found_as_none()? .io_not_found_as_none()?
{ {
OwningDirstateMap::new_empty(data_mmap) OwningDirstateMap::new_empty(data_mmap)
} else { } else {
OwningDirstateMap::new_empty(Vec::new()) OwningDirstateMap::new_empty(Vec::new())
}; };
let (on_disk, placeholder) = map.get_mut_pair(); let (on_disk, placeholder) = map.get_pair_mut();
*placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?; *placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?;
Ok(map) Ok(map)
} else { } else {
let mut map = OwningDirstateMap::new_empty(dirstate_file_contents); let mut map = OwningDirstateMap::new_empty(dirstate_file_contents);
let (on_disk, placeholder) = map.get_mut_pair(); let (on_disk, placeholder) = map.get_pair_mut();
let (inner, parents) = DirstateMap::new_v1(on_disk)?; let (inner, parents) = DirstateMap::new_v1(on_disk)?;
self.dirstate_parents self.dirstate_parents
.set(Some(parents.unwrap_or(DirstateParents::NULL))); .set(Some(parents.unwrap_or(DirstateParents::NULL)));
*placeholder = inner; *placeholder = inner;
Ok(map) Ok(map)
} }
} }

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

dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::item::DirstateItem, dirstate::item::DirstateItem,
pybytes_deref::PyBytesDeref, pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::StateMapIter, dirstate::StateMapIter,
dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap, dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError, dirstate_tree::on_disk::DirstateV2ParseError,
dirstate_tree::owning::OwningDirstateMap, dirstate_tree::owning::OwningDirstateMap,
revlog::Node, revlog::Node,
utils::files::normalize_case, utils::files::normalize_case,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirstateEntry, DirstateError, DirstateParents, EntryState, DirstateEntry, DirstateError, DirstateParents, EntryState,
}; };
// TODO // TODO
// This object needs to share references to multiple members of its Rust // This object needs to share references to multiple members of its Rust
// inner struct, namely `copy_map`, `dirs` and `all_dirs`. // inner struct, namely `copy_map`, `dirs` and `all_dirs`.
// Right now `CopyMap` is done, but it needs to have an explicit reference // Right now `CopyMap` is done, but it needs to have an explicit reference
// to `RustDirstateMap` which itself needs to have an encapsulation for // to `RustDirstateMap` which itself needs to have an encapsulation for
// every method in `CopyMap` (copymapcopy, etc.). // every method in `CopyMap` (copymapcopy, etc.).
// This is ugly and hard to maintain. // This is ugly and hard to maintain.
// 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: OwningDirstateMap;
/// Returns a `(dirstate_map, parents)` tuple /// Returns a `(dirstate_map, parents)` tuple
@staticmethod @staticmethod
def new_v1( def new_v1(
on_disk: PyBytes, on_disk: PyBytes,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let on_disk = PyBytesDeref::new(py, on_disk); let on_disk = PyBytesDeref::new(py, on_disk);
let mut map = OwningDirstateMap::new_empty(on_disk); let mut map = OwningDirstateMap::new_empty(on_disk);
let (on_disk, map_placeholder) = map.get_mut_pair(); let (on_disk, map_placeholder) = map.get_pair_mut();
let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk) let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk)
.map_err(|e| dirstate_error(py, e))?; .map_err(|e| dirstate_error(py, e))?;
*map_placeholder = actual_map; *map_placeholder = actual_map;
let map = Self::create_instance(py, Box::new(map))?; let map = Self::create_instance(py, map)?;
let parents = parents.map(|p| { let parents = parents.map(|p| {
let p1 = PyBytes::new(py, p.p1.as_bytes()); let p1 = PyBytes::new(py, p.p1.as_bytes());
let p2 = PyBytes::new(py, p.p2.as_bytes()); let p2 = PyBytes::new(py, p.p2.as_bytes());
(p1, p2) (p1, p2)
}); });
Ok((map, parents).to_py_object(py).into_object()) Ok((map, parents).to_py_object(py).into_object())
} }
/// Returns a DirstateMap /// Returns a DirstateMap
@staticmethod @staticmethod
def new_v2( def new_v2(
on_disk: PyBytes, on_disk: PyBytes,
data_size: usize, data_size: usize,
tree_metadata: PyBytes, tree_metadata: PyBytes,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let dirstate_error = |e: DirstateError| { let dirstate_error = |e: DirstateError| {
PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e)) PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
}; };
let on_disk = PyBytesDeref::new(py, on_disk); let on_disk = PyBytesDeref::new(py, on_disk);
let mut map = OwningDirstateMap::new_empty(on_disk); let mut map = OwningDirstateMap::new_empty(on_disk);
let (on_disk, map_placeholder) = map.get_mut_pair(); let (on_disk, map_placeholder) = map.get_pair_mut();
*map_placeholder = TreeDirstateMap::new_v2( *map_placeholder = TreeDirstateMap::new_v2(
on_disk, data_size, tree_metadata.data(py), on_disk, data_size, tree_metadata.data(py),
).map_err(dirstate_error)?; ).map_err(dirstate_error)?;
let map = Self::create_instance(py, Box::new(map))?; let map = Self::create_instance(py, map)?;
Ok(map.into_object()) Ok(map.into_object())
} }
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())
} }
Ok(dirs) Ok(dirs)
} }
}); });
impl DirstateMap { impl DirstateMap {
pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, OwningDirstateMap> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
} }
fn translate_key( fn translate_key(
py: Python, py: Python,
res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>, res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
) -> PyResult<Option<PyBytes>> { ) -> PyResult<Option<PyBytes>> {
let (f, _entry) = res.map_err(|e| v2_error(py, e))?; let (f, _entry) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(PyBytes::new(py, f.as_bytes()))) Ok(Some(PyBytes::new(py, f.as_bytes())))

rust/rhg/src/commands/status.rs

// status.rs // status.rs
// //
// Copyright 2020, Georges Racinet <georges.racinets@octobus.net> // Copyright 2020, Georges Racinet <georges.racinets@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 crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use hg; use hg;
use hg::dirstate_tree::dispatch::DirstateMapMethods;
use hg::errors::HgError; use hg::errors::HgError;
use hg::manifest::Manifest; use hg::manifest::Manifest;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::hg_path::{hg_path_to_os_string, HgPath}; use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
rust/hg-core/src/dirstate_tree/owning.rs