( )⚙ D11134 dirstate-map: move most of `dirstate.update_file` logic in the dsmap

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11134

dirstate-map: move most of `dirstate.update_file` logic in the dsmap
ClosedPublic

Authored by marmoute on Jul 19 2021, 6:40 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe5fb14a07866: dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Summary

A new reset_state method is introduced to deal with most of that logic. This
move things one layer lower, but the ultimate goal is to deal with most of this
at the DirstateItem level.

This reveal various imperfection with the data passed to update_file by
mergestate.recordupdates, however this is orthogonal to this patch and should
be dealt with at a higher level.

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

marmoute created this revision.Jul 19 2021, 6:40 AM
Alphare accepted this revision.Jul 19 2021, 12:28 PM
This revision is now accepted and ready to land.Jul 19 2021, 12:28 PM
baymax updated this revision to Diff 29553.Jul 20 2021, 3:21 AM

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

pulkit accepted this revision.Jul 20 2021, 3:29 PM

Revision Contents
Changeset List

Diff 29635

mercurial/dirstate.py

note: the API is at an early stage and we might need to ajust it note: the API is at an early stage and we might need to ajust it
depending of what information ends up being relevant and useful to depending of what information ends up being relevant and useful to
other processing. other processing.
""" """
if merged and (clean_p1 or clean_p2): if merged and (clean_p1 or clean_p2):
msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`' msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
if not (p1_tracked or p2_tracked or wc_tracked):
self._drop(filename) # note: I do not think we need to double check name clash here since we
elif merged: # are in a update/merge case that should already have taken care of
assert wc_tracked # this. The test agrees
assert self.in_merge # we are never in the "normallookup" case
self.otherparent(filename) self._dirty = True
elif not (p1_tracked or p2_tracked) and wc_tracked: self._updatedfiles.add(filename)
self._addpath(filename, added=True, possibly_dirty=possibly_dirty)
self._map.copymap.pop(filename, None) need_parent_file_data = (
elif (p1_tracked or p2_tracked) and not wc_tracked: not (possibly_dirty or clean_p2 or merged)
self._remove(filename) and wc_tracked
elif clean_p2 and wc_tracked: and p1_tracked
assert p2_tracked )
self.otherparent(filename)
elif not p1_tracked and p2_tracked and wc_tracked: # this mean we are doing call for file we do not really care about the
self._addpath(filename, from_p2=True, possibly_dirty=possibly_dirty) # data (eg: added or removed), however this should be a minor overhead
self._map.copymap.pop(filename, None) # compared to the overall update process calling this.
elif possibly_dirty: if need_parent_file_data:
self._addpath(filename, possibly_dirty=possibly_dirty) if parentfiledata is None:
elif wc_tracked: parentfiledata = self._get_filedata(filename)
self.normal(filename, parentfiledata=parentfiledata) mtime = parentfiledata[2]
# XXX We need something for file that are dirty after an update
else: if mtime > self._lastnormaltime:
assert False, 'unreachable' # Remember the most recent modification timeslot for
# status(), to make sure we won't miss future
# size-preserving file content modifications that happen
# within the same timeslot.
self._lastnormaltime = mtime
self._map.reset_state(
filename,
wc_tracked,
p1_tracked,
p2_tracked=p2_tracked,
merged=merged,
clean_p1=clean_p1,
clean_p2=clean_p2,
possibly_dirty=possibly_dirty,
parentfiledata=parentfiledata,
)
def _addpath( def _addpath(
self, self,
f, f,
mode=0, mode=0,
size=None, size=None,
mtime=None, mtime=None,
added=False, added=False,

mercurial/dirstatemap.py

old_entry = self.get(f) old_entry = self.get(f)
self._dirs_incr(f, old_entry) self._dirs_incr(f, old_entry)
e = self._map[f] = DirstateItem(state, mode, size, mtime) e = self._map[f] = DirstateItem(state, mode, size, mtime)
if e.dm_nonnormal: if e.dm_nonnormal:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if e.dm_otherparent: if e.dm_otherparent:
self.otherparentset.add(f) self.otherparentset.add(f)
def reset_state(
self,
filename,
wc_tracked,
p1_tracked,
p2_tracked=False,
merged=False,
clean_p1=False,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None,
):
"""Set a entry to a given state, diregarding all previous state
This is to be used by the part of the dirstate API dedicated to
adjusting the dirstate after a update/merge.
note: calling this might result to no entry existing at all if the
dirstate map does not see any point at having one for this file
anymore.
"""
if merged and (clean_p1 or clean_p2):
msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
raise error.ProgrammingError(msg)
# copy information are now outdated
# (maybe new information should be in directly passed to this function)
self.copymap.pop(filename, None)
if not (p1_tracked or p2_tracked or wc_tracked):
self.dropfile(filename)
elif merged:
# XXX might be merged and removed ?
entry = self.get(filename)
if entry is not None and entry.tracked:
# XXX mostly replicate dirstate.other parent. We should get
# the higher layer to pass us more reliable data where `merged`
# actually mean merged. Dropping the else clause will show
# failure in `test-graft.t`
self.addfile(filename, merged=True)
else:
self.addfile(filename, from_p2=True)
elif not (p1_tracked or p2_tracked) and wc_tracked:
self.addfile(filename, added=True, possibly_dirty=possibly_dirty)
elif (p1_tracked or p2_tracked) and not wc_tracked:
# XXX might be merged and removed ?
old_entry = self._map.get(filename)
self._dirs_decr(filename, old_entry=old_entry, remove_variant=True)
self._map[filename] = DirstateItem(b'r', 0, 0, 0)
self.nonnormalset.add(filename)
elif clean_p2 and wc_tracked:
if p1_tracked or self.get(filename) is not None:
# XXX the `self.get` call is catching some case in
# `test-merge-remove.t` where the file is tracked in p1, the
# p1_tracked argument is False.
#
# In addition, this seems to be a case where the file is marked
# as merged without actually being the result of a merge
# action. So thing are not ideal here.
self.addfile(filename, merged=True)
else:
self.addfile(filename, from_p2=True)
elif not p1_tracked and p2_tracked and wc_tracked:
self.addfile(filename, from_p2=True, possibly_dirty=possibly_dirty)
elif possibly_dirty:
self.addfile(filename, possibly_dirty=possibly_dirty)
elif wc_tracked:
# this is a "normal" file
if parentfiledata is None:
msg = b'failed to pass parentfiledata for a normal file: %s'
msg %= filename
raise error.ProgrammingError(msg)
mode, size, mtime = parentfiledata
self.addfile(filename, mode=mode, size=size, mtime=mtime)
self.nonnormalset.discard(filename)
else:
assert False, 'unreachable'
def removefile(self, f, in_merge=False): def removefile(self, f, in_merge=False):
""" """
Mark a file as removed in the dirstate. Mark a file as removed in the dirstate.
The `size` parameter is used to store sentinel values that indicate The `size` parameter is used to store sentinel values that indicate
the file's previous state. In the future, we should refactor this the file's previous state. In the future, we should refactor this
to be more explicit about what that state is. to be more explicit about what that state is.
""" """
size, size,
mtime, mtime,
added, added,
merged, merged,
from_p2, from_p2,
possibly_dirty, possibly_dirty,
) )
def reset_state(
self,
filename,
wc_tracked,
p1_tracked,
p2_tracked=False,
merged=False,
clean_p1=False,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None,
):
"""Set a entry to a given state, disregarding all previous state
This is to be used by the part of the dirstate API dedicated to
adjusting the dirstate after a update/merge.
note: calling this might result to no entry existing at all if the
dirstate map does not see any point at having one for this file
anymore.
"""
if merged and (clean_p1 or clean_p2):
msg = (
b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
)
raise error.ProgrammingError(msg)
# copy information are now outdated
# (maybe new information should be in directly passed to this function)
self.copymap.pop(filename, None)
if not (p1_tracked or p2_tracked or wc_tracked):
self.dropfile(filename)
elif merged:
# XXX might be merged and removed ?
entry = self.get(filename)
if entry is not None and entry.tracked:
# XXX mostly replicate dirstate.other parent. We should get
# the higher layer to pass us more reliable data where `merged`
# actually mean merged. Dropping the else clause will show
# failure in `test-graft.t`
self.addfile(filename, merged=True)
else:
self.addfile(filename, from_p2=True)
elif not (p1_tracked or p2_tracked) and wc_tracked:
self.addfile(
filename, added=True, possibly_dirty=possibly_dirty
)
elif (p1_tracked or p2_tracked) and not wc_tracked:
# XXX might be merged and removed ?
self[filename] = DirstateItem(b'r', 0, 0, 0)
self.nonnormalset.add(filename)
elif clean_p2 and wc_tracked:
if p1_tracked or self.get(filename) is not None:
# XXX the `self.get` call is catching some case in
# `test-merge-remove.t` where the file is tracked in p1, the
# p1_tracked argument is False.
#
# In addition, this seems to be a case where the file is marked
# as merged without actually being the result of a merge
# action. So thing are not ideal here.
self.addfile(filename, merged=True)
else:
self.addfile(filename, from_p2=True)
elif not p1_tracked and p2_tracked and wc_tracked:
self.addfile(
filename, from_p2=True, possibly_dirty=possibly_dirty
)
elif possibly_dirty:
self.addfile(filename, possibly_dirty=possibly_dirty)
elif wc_tracked:
# this is a "normal" file
if parentfiledata is None:
msg = b'failed to pass parentfiledata for a normal file: %s'
msg %= filename
raise error.ProgrammingError(msg)
mode, size, mtime = parentfiledata
self.addfile(filename, mode=mode, size=size, mtime=mtime)
self.nonnormalset.discard(filename)
else:
assert False, 'unreachable'
def removefile(self, *args, **kwargs): def removefile(self, *args, **kwargs):
return self._rustmap.removefile(*args, **kwargs) return self._rustmap.removefile(*args, **kwargs)
def dropfile(self, *args, **kwargs): def dropfile(self, *args, **kwargs):
return self._rustmap.dropfile(*args, **kwargs) return self._rustmap.dropfile(*args, **kwargs)
def clearambiguoustimes(self, *args, **kwargs): def clearambiguoustimes(self, *args, **kwargs):
return self._rustmap.clearambiguoustimes(*args, **kwargs) return self._rustmap.clearambiguoustimes(*args, **kwargs)
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._rustmap.tracked_dirs(): for name in self._rustmap.tracked_dirs():
f[normcase(name)] = name f[normcase(name)] = name
return f return f
def __setitem__(self, key, value):
assert isinstance(value, DirstateItem)
self._rustmap.set_v1(key, value)

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

pub fn clear(&mut self) { pub fn clear(&mut self) {
self.state_map = StateMap::default(); self.state_map = StateMap::default();
self.copy_map.clear(); self.copy_map.clear();
self.non_normal_set = None; self.non_normal_set = None;
self.other_parent_set = None; self.other_parent_set = None;
} }
pub fn set_v1_inner(&mut self, filename: &HgPath, entry: DirstateEntry) {
self.state_map.insert(filename.to_owned(), entry);
}
/// Add a tracked file to the dirstate /// Add a tracked file to the dirstate
pub fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
// XXX once the dust settle this should probably become an enum // XXX once the dust settle this should probably become an enum
added: bool, added: bool,
merged: bool, merged: bool,
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
} }
} }
} }
pub fn non_normal_entries_remove(&mut self, key: impl AsRef<HgPath>) { pub fn non_normal_entries_remove(
&mut self,
key: impl AsRef<HgPath>,
) -> bool {
self.get_non_normal_other_parent_entries()
.0
.remove(key.as_ref())
}
pub fn non_normal_entries_add(&mut self, key: impl AsRef<HgPath>) {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.remove(key.as_ref()); .insert(key.as_ref().into());
} }
pub fn non_normal_entries_union( pub fn non_normal_entries_union(
&mut self, &mut self,
other: HashSet<HgPathBuf>, other: HashSet<HgPathBuf>,
) -> Vec<HgPathBuf> { ) -> Vec<HgPathBuf> {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0

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

impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> { impl<'on_disk> super::dispatch::DirstateMapMethods for DirstateMap<'on_disk> {
fn clear(&mut self) { fn clear(&mut self) {
self.root = Default::default(); self.root = Default::default();
self.nodes_with_entry_count = 0; self.nodes_with_entry_count = 0;
self.nodes_with_copy_source_count = 0; self.nodes_with_copy_source_count = 0;
} }
fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry) {
let node =
self.get_or_insert(&filename).expect("no parse error in v1");
node.data = NodeData::Entry(entry);
node.children = ChildNodes::default();
node.copy_source = None;
node.descendants_with_entry_count = 0;
node.tracked_descendants_count = 0;
}
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? { Ok(if let Some(node) = self.get_node(key)? {
node.entry()?.map_or(false, |entry| entry.is_non_normal()) node.entry()?.map_or(false, |entry| entry.is_non_normal())
} else { } else {
false false
}) })
} }
fn non_normal_entries_remove(&mut self, _key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
// Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date.
if let Ok(Some(v)) = self.get(key) {
return v.is_non_normal();
}
false
}
fn non_normal_entries_add(&mut self, _key: &HgPath) {
// Do nothing, this `DirstateMap` does not have a separate "non normal // Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date // entries" set that need to be kept up to date
} }
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_> ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{ {

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

/// abstracted in this trait. /// abstracted in this trait.
/// ///
/// The dirstate map associates paths of files in the working directory to /// The dirstate map associates paths of files in the working directory to
/// various information about the state of those files. /// various information about the state of those files.
pub trait DirstateMapMethods { pub trait DirstateMapMethods {
/// Remove information about all files in this map /// Remove information about all files in this map
fn clear(&mut self); fn clear(&mut self);
fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry);
/// Add or change the information associated to a given file. /// Add or change the information associated to a given file.
/// ///
/// `old_state` is the state in the entry that `get` would have returned /// `old_state` is the state in the entry that `get` would have returned
/// before this call, or `EntryState::Unknown` if there was no such entry. /// before this call, or `EntryState::Unknown` if there was no such entry.
/// ///
/// `entry.state` should never be `EntryState::Unknown`. /// `entry.state` should never be `EntryState::Unknown`.
fn add_file( fn add_file(
&mut self, &mut self,
fn non_normal_entries_contains( fn non_normal_entries_contains(
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError>; ) -> Result<bool, DirstateV2ParseError>;
/// Mark the given path as "normal" file. This is only relevant in the flat /// Mark the given path as "normal" file. This is only relevant in the flat
/// dirstate map where there is a separate `HashSet` that needs to be kept /// dirstate map where there is a separate `HashSet` that needs to be kept
/// up to date. /// up to date.
fn non_normal_entries_remove(&mut self, key: &HgPath); /// Returns whether the key was present in the set.
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;
/// Mark the given path as "non-normal" file.
/// This is only relevant in the flat dirstate map where there is a
/// separate `HashSet` that needs to be kept up to date.
fn non_normal_entries_add(&mut self, key: &HgPath);
/// Return an iterator of paths whose respective entry are either /// Return an iterator of paths whose respective entry are either
/// "non-normal" (see `non_normal_entries_contains`) or "from other /// "non-normal" (see `non_normal_entries_contains`) or "from other
/// parent". /// parent".
/// ///
/// If that information is cached, create the cache as needed. /// If that information is cached, create the cache as needed.
/// ///
/// "From other parent" is defined as `state == Normal && size == -2`. /// "From other parent" is defined as `state == Normal && size == -2`.
>; >;
} }
impl DirstateMapMethods for DirstateMap { impl DirstateMapMethods for DirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.clear() self.clear()
} }
/// Used to set a value directory.
///
/// XXX Is temporary during a refactor of V1 dirstate and will disappear
/// shortly.
fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry) {
self.set_v1_inner(&filename, entry)
}
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
let (non_normal, _other_parent) = let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Ok(non_normal.contains(key)) Ok(non_normal.contains(key))
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { 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_add(&mut self, key: &HgPath) {
self.non_normal_entries_add(key)
}
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_> ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{ {
let (non_normal, other_parent) = let (non_normal, other_parent) =
self.get_non_normal_other_parent_entries(); self.get_non_normal_other_parent_entries();
Box::new(non_normal.union(other_parent).map(|p| Ok(&**p))) Box::new(non_normal.union(other_parent).map(|p| Ok(&**p)))
} }

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

{ {
Some(entry) => { Some(entry) => {
Ok(Some(make_dirstate_item(py, &entry)?)) Ok(Some(make_dirstate_item(py, &entry)?))
}, },
None => Ok(default) None => Ok(default)
} }
} }
def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> {
let f = path.extract::<PyBytes>(py)?;
let filename = HgPath::new(f.data(py));
let state = item.getattr(py, "state")?.extract::<PyBytes>(py)?;
let state = state.data(py)[0];
let entry = DirstateEntry {
state: state.try_into().expect("state is always valid"),
mtime: item.getattr(py, "mtime")?.extract(py)?,
size: item.getattr(py, "size")?.extract(py)?,
mode: item.getattr(py, "mode")?.extract(py)?,
};
self.inner(py).borrow_mut().set_v1(filename, entry);
Ok(py.None())
}
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
mode: PyObject, mode: PyObject,
size: PyObject, size: PyObject,
mtime: PyObject, mtime: PyObject,
added: PyObject, added: PyObject,
merged: PyObject, merged: PyObject,
.collect::<Result<Vec<_>, _>>() .collect::<Result<Vec<_>, _>>()
.map_err(|e| v2_error(py, e))?; .map_err(|e| v2_error(py, e))?;
let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", ")); let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", "));
Ok(PyString::new(py, &formatted)) Ok(PyString::new(py, &formatted))
} }
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)?;
let key = key.data(py);
let was_present = self
.inner(py)
.borrow_mut()
.non_normal_entries_remove(HgPath::new(key));
if !was_present {
let msg = String::from_utf8_lossy(key);
Err(PyErr::new::<exc::KeyError, _>(py, msg))
} else {
Ok(py.None())
}
}
def non_normal_entries_discard(&self, key: PyObject) -> PyResult<PyObject>
{
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_add(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?;
self
.inner(py)
.borrow_mut()
.non_normal_entries_add(HgPath::new(key.data(py)));
Ok(py.None())
}
def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> { def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
let mut inner = self.inner(py).borrow_mut(); let mut inner = self.inner(py).borrow_mut();
let ret = PyList::new(py, &[]); let ret = PyList::new(py, &[]);
for filename in inner.non_normal_or_other_parent_paths() { for filename in inner.non_normal_or_other_parent_paths() {
let filename = filename.map_err(|e| v2_error(py, e))?; let filename = filename.map_err(|e| v2_error(py, e))?;
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());

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

use hg::StatusOptions; use hg::StatusOptions;
use std::path::PathBuf; use std::path::PathBuf;
impl DirstateMapMethods for OwningDirstateMap { impl DirstateMapMethods for OwningDirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.get_mut().clear() self.get_mut().clear()
} }
fn set_v1(&mut self, filename: &HgPath, entry: DirstateEntry) {
self.get_mut().set_v1(filename, entry)
}
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
fn non_normal_entries_contains( fn non_normal_entries_contains(
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
self.get_mut().non_normal_entries_contains(key) self.get_mut().non_normal_entries_contains(key)
} }
fn non_normal_entries_remove(&mut self, key: &HgPath) { fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
self.get_mut().non_normal_entries_remove(key) self.get_mut().non_normal_entries_remove(key)
} }
fn non_normal_entries_add(&mut self, key: &HgPath) {
self.get_mut().non_normal_entries_add(key)
}
fn non_normal_or_other_parent_paths( fn non_normal_or_other_parent_paths(
&mut self, &mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_> ) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{ {
self.get_mut().non_normal_or_other_parent_paths() self.get_mut().non_normal_or_other_parent_paths()
} }
fn set_non_normal_other_parent_entries(&mut self, force: bool) { fn set_non_normal_other_parent_entries(&mut self, force: bool) {

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

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 add(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_add(py, key)
}
def discard(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_discard(py, key)
}
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> {