( )⚙ D11491 dirstate: Remove return boolean from dirstatemap.dropfile

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11491

dirstate: Remove return boolean from dirstatemap.dropfile
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG76f1c76186a1: dirstate: Remove return boolean from dirstatemap.dropfile
Summary

None of the remaining callers use it.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Sep 23 2021, 1:42 PM
Alphare accepted this revision.Sep 24 2021, 5:57 AM
This revision is now accepted and ready to land.Sep 24 2021, 5:57 AM

Revision Contents
Changeset List

Diff 30387

mercurial/dirstatemap.py

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): def dropfile(self, f, *args, **kwargs):
self._rustmap.copymap().pop(f, None) self._rustmap.copymap().pop(f, None)
return self._rustmap.dropfile(f, *args, **kwargs) 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):

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

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_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<bool, 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);
Ok(exists) 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,
) { ) {
for filename in filenames { for filename in filenames {

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<bool, DirstateError> { fn drop_file(&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,
} }
filename, filename,
)? { )? {
if dropped.had_entry { if dropped.had_entry {
self.nodes_with_entry_count -= 1 self.nodes_with_entry_count -= 1
} }
if dropped.had_copy_source { if dropped.had_copy_source {
self.nodes_with_copy_source_count -= 1 self.nodes_with_copy_source_count -= 1
} }
Ok(dropped.had_entry)
} else { } else {
debug_assert!(!was_tracked); debug_assert!(!was_tracked);
Ok(false)
} }
Ok(())
} }
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> {
for filename in filenames { for filename in filenames {

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

/// Drop information about this file from the map if any, and return /// Drop information about this file from the map if any, and return
/// whether there was any. /// whether there was any.
/// ///
/// `get` will now return `None` for this filename. /// `get` will now return `None` for this filename.
/// ///
/// `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.
fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError>; fn drop_file(&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<bool, DirstateError> { fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> {
self.drop_file(filename) self.drop_file(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> {

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<bool, DirstateError> { fn drop_file(&mut self, filename: &HgPath) -> Result<(), DirstateError> {
self.get_mut().drop_file(filename) self.get_mut().drop_file(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> {

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::{RefCell, RefMut}; 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, Python, PythonObject, ToPyObject, PyNone, PyObject, PyResult, PySet, PyString, Python, PythonObject,
UnsafePyLeaked, ToPyObject, UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::item::DirstateItem, dirstate::item::DirstateItem,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
"Dirstate error".to_string(), "Dirstate error".to_string(),
)) ))
})?; })?;
Ok(py.None()) Ok(py.None())
} }
def dropfile( def dropfile(
&self, &self,
f: PyObject, f: PyBytes,
) -> PyResult<PyBool> { ) -> PyResult<PyNone> {
self.inner(py).borrow_mut() self.inner(py)
.drop_file( .borrow_mut()
HgPath::new(f.extract::<PyBytes>(py)?.data(py)), .drop_file(HgPath::new(f.data(py)))
) .map_err(|e |dirstate_error(py, e))?;
.and_then(|b| Ok(b.to_py_object(py))) Ok(PyNone)
.or_else(|e| {
Err(PyErr::new::<exc::OSError, _>(
py,
format!("Dirstate error: {}", e.to_string()),
))
})
} }
def clearambiguoustimes( def clearambiguoustimes(
&self, &self,
files: PyObject, files: PyObject,
now: PyObject now: PyObject
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let files: PyResult<Vec<HgPathBuf>> = files let files: PyResult<Vec<HgPathBuf>> = files