( )⚙ D11493 dirstate: Replace dropfile with drop_item_and_copy_source

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11493

dirstate: Replace dropfile with drop_item_and_copy_source
ClosedPublic

Authored by SimonSapin on Sep 23 2021, 1:42 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2ac0e6b23222: dirstate: Replace dropfile with drop_item_and_copy_source
Summary

Those removing a DirstateItem and a copy source are always done together

Diff Detail

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

Revision Contents
Changeset List

Diff 30389

mercurial/dirstatemap.py

b'`merged` argument incompatible with `clean_p1`/`clean_p2`' b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
) )
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
# copy information are now outdated # copy information are now outdated
# (maybe new information should be in directly passed to this function) # (maybe new information should be in directly passed to this function)
self.copymap.pop(filename, None) self.copymap.pop(filename, None)
if not (p1_tracked or p2_tracked or wc_tracked): if not (p1_tracked or p2_tracked or wc_tracked):
self.dropfile(filename) self._rustmap.drop_item_and_copy_source(filename)
elif merged: elif merged:
# XXX might be merged and removed ? # XXX might be merged and removed ?
entry = self.get(filename) entry = self.get(filename)
if entry is not None and entry.tracked: if entry is not None and entry.tracked:
# XXX mostly replicate dirstate.other parent. We should get # XXX mostly replicate dirstate.other parent. We should get
# the higher layer to pass us more reliable data where `merged` # the higher layer to pass us more reliable data where `merged`
# actually mean merged. Dropping the else clause will show # actually mean merged. Dropping the else clause will show
# failure in `test-graft.t` # failure in `test-graft.t`
# #
# the inner rust dirstate map code need to be adjusted once the API # the inner rust dirstate map code need to be adjusted once the API
# for dirstate/dirstatemap/DirstateItem is a bit more settled # for dirstate/dirstatemap/DirstateItem is a bit more settled
entry = self.get(f) entry = self.get(f)
if entry is None: if entry is None:
return False return False
else: else:
if entry.added: if entry.added:
self._rustmap.copymap().pop(f, None) self._rustmap.drop_item_and_copy_source(f)
self._rustmap.dropfile(f)
else: else:
self._rustmap.removefile(f, in_merge=True) self._rustmap.removefile(f, in_merge=True)
return True return True
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, f, *args, **kwargs):
self._rustmap.copymap().pop(f, None)
self._rustmap.dropfile(f, *args, **kwargs)
def clearambiguoustimes(self, *args, **kwargs): def clearambiguoustimes(self, *args, **kwargs):
return self._rustmap.clearambiguoustimes(*args, **kwargs) return self._rustmap.clearambiguoustimes(*args, **kwargs)
def nonnormalentries(self): def nonnormalentries(self):
return self._rustmap.nonnormalentries() return self._rustmap.nonnormalentries()
def get(self, *args, **kwargs): def get(self, *args, **kwargs):
return self._rustmap.get(*args, **kwargs) return self._rustmap.get(*args, **kwargs)

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

self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
Ok(()) Ok(())
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_file( pub fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_state = self.get(filename).map(|e| e.state()); let old_state = self.get(filename).map(|e| e.state());
let exists = self.state_map.remove(filename).is_some(); let exists = self.state_map.remove(filename).is_some();
if exists { if exists {
if old_state != Some(EntryState::Removed) { if old_state != Some(EntryState::Removed) {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.delete_path(filename)?; all_dirs.delete_path(filename)?;
} }
} }
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.remove(filename); .remove(filename);
self.copy_map.remove(filename);
Ok(()) Ok(())
} }
pub fn clear_ambiguous_times( pub fn clear_ambiguous_times(
&mut self, &mut self,
filenames: Vec<HgPathBuf>, filenames: Vec<HgPathBuf>,
now: i32, now: i32,
) { ) {

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

} }
if size == 0 { if size == 0 {
self.copy_map_remove(filename)?; self.copy_map_remove(filename)?;
} }
let entry = DirstateEntry::new_removed(size); let entry = DirstateEntry::new_removed(size);
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(self.add_or_remove_file(filename, old_state, entry)?)
} }
fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> { fn drop_entry_and_copy_source(
&mut self,
filename: &HgPath,
) -> 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());
struct Dropped { struct Dropped {
was_tracked: bool, was_tracked: bool,
had_entry: bool, had_entry: bool,
had_copy_source: bool, had_copy_source: bool,
} }
return Ok(None); return Ok(None);
} }
} else { } else {
let had_entry = node.data.has_entry(); let had_entry = node.data.has_entry();
if had_entry { if had_entry {
node.data = NodeData::None node.data = NodeData::None
} }
if let Some(source) = &node.copy_source { if let Some(source) = &node.copy_source {
DirstateMap::count_dropped_path(unreachable_bytes, source) DirstateMap::count_dropped_path(unreachable_bytes, source);
node.copy_source = None
} }
dropped = Dropped { dropped = Dropped {
was_tracked: node was_tracked: node
.data .data
.as_entry() .as_entry()
.map_or(false, |entry| entry.state().is_tracked()), .map_or(false, |entry| entry.state().is_tracked()),
had_entry, had_entry,
had_copy_source: node.copy_source.take().is_some(), had_copy_source: node.copy_source.take().is_some(),

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

&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError>; ) -> Result<(), DirstateError>;
/// Drop information about this file from the map if any. /// Drop information about this file from the map if any.
/// ///
/// `get` will now return `None` for this filename. /// `get` will now return `None` for this filename.
fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError>; fn drop_entry_and_copy_source(
&mut self,
filename: &HgPath,
) -> Result<(), DirstateError>;
/// Among given files, mark the stored `mtime` as ambiguous if there is one /// Among given files, mark the stored `mtime` as ambiguous if there is one
/// (if `state == EntryState::Normal`) equal to the given current Unix /// (if `state == EntryState::Normal`) equal to the given current Unix
/// timestamp. /// timestamp.
fn clear_ambiguous_times( fn clear_ambiguous_times(
&mut self, &mut self,
filenames: Vec<HgPathBuf>, filenames: Vec<HgPathBuf>,
now: i32, now: i32,
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.remove_file(filename, in_merge) self.remove_file(filename, in_merge)
} }
fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> { fn drop_entry_and_copy_source(
self.drop_file(filename) &mut self,
filename: &HgPath,
) -> Result<(), DirstateError> {
self.drop_entry_and_copy_source(filename)
} }
fn clear_ambiguous_times( fn clear_ambiguous_times(
&mut self, &mut self,
filenames: Vec<HgPathBuf>, filenames: Vec<HgPathBuf>,
now: i32, now: i32,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
Ok(self.clear_ambiguous_times(filenames, now)) Ok(self.clear_ambiguous_times(filenames, now))

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

fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().remove_file(filename, in_merge) self.get_mut().remove_file(filename, in_merge)
} }
fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> { fn drop_entry_and_copy_source(
self.get_mut().drop_file(filename) &mut self,
filename: &HgPath,
) -> Result<(), DirstateError> {
self.get_mut().drop_entry_and_copy_source(filename)
} }
fn clear_ambiguous_times( fn clear_ambiguous_times(
&mut self, &mut self,
filenames: Vec<HgPathBuf>, filenames: Vec<HgPathBuf>,
now: i32, now: i32,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
self.get_mut().clear_ambiguous_times(filenames, now) self.get_mut().clear_ambiguous_times(filenames, now)

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

Err(PyErr::new::<exc::OSError, _>( Err(PyErr::new::<exc::OSError, _>(
py, py,
"Dirstate error".to_string(), "Dirstate error".to_string(),
)) ))
})?; })?;
Ok(py.None()) Ok(py.None())
} }
def dropfile( def drop_item_and_copy_source(
&self, &self,
f: PyBytes, f: PyBytes,
) -> PyResult<PyNone> { ) -> PyResult<PyNone> {
self.inner(py) self.inner(py)
.borrow_mut() .borrow_mut()
.drop_file(HgPath::new(f.data(py))) .drop_entry_and_copy_source(HgPath::new(f.data(py)))
.map_err(|e |dirstate_error(py, e))?; .map_err(|e |dirstate_error(py, e))?;
Ok(PyNone) Ok(PyNone)
} }
def clearambiguoustimes( def clearambiguoustimes(
&self, &self,
files: PyObject, files: PyObject,
now: PyObject now: PyObject