( )⚙ D11502 dirstate: drop the `clearambiguoustimes` method for the map

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11502

dirstate: drop the `clearambiguoustimes` method for the map
ClosedPublic

Authored by SimonSapin on Sep 28 2021, 3:53 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGcd13d3c2ad2e: dirstate: drop the `clearambiguoustimes` method for the map
Summary

This is no longer called anywhere.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Sep 28 2021, 3:53 PM
Alphare accepted this revision.Sep 29 2021, 4:21 AM
This revision is now accepted and ready to land.Sep 29 2021, 4:21 AM

Revision Contents
Changeset List

Diff 30425

mercurial/dirstatemap.py

self._map.pop(f, None) self._map.pop(f, None)
else: else:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if entry.from_p2: if entry.from_p2:
self.otherparentset.add(f) self.otherparentset.add(f)
entry.set_untracked() entry.set_untracked()
return True return True
def clearambiguoustimes(self, files, now):
for f in files:
e = self.get(f)
if e is not None and e.need_delay(now):
e.set_possibly_dirty()
self.nonnormalset.add(f)
def nonnormalentries(self): def nonnormalentries(self):
'''Compute the nonnormal dirstate entries from the dmap''' '''Compute the nonnormal dirstate entries from the dmap'''
try: try:
return parsers.nonnormalotherparententries(self._map) return parsers.nonnormalotherparententries(self._map)
except AttributeError: except AttributeError:
nonnorm = set() nonnorm = set()
otherparent = set() otherparent = set()
for fname, e in pycompat.iteritems(self._map): for fname, e in pycompat.iteritems(self._map):
self._rustmap.drop_item_and_copy_source(f) self._rustmap.drop_item_and_copy_source(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 clearambiguoustimes(self, *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)
@property @property
def copymap(self): def copymap(self):

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

.0 .0
.remove(filename); .remove(filename);
self.copy_map.remove(filename); self.copy_map.remove(filename);
Ok(()) Ok(())
} }
pub fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) {
for filename in filenames {
if let Some(entry) = self.state_map.get_mut(&filename) {
if entry.clear_ambiguous_mtime(now) {
self.get_non_normal_other_parent_entries()
.0
.insert(filename.to_owned());
}
}
}
}
pub fn non_normal_entries_remove( pub fn non_normal_entries_remove(
&mut self, &mut self,
key: impl AsRef<HgPath>, key: impl AsRef<HgPath>,
) -> bool { ) -> bool {
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.remove(key.as_ref()) .remove(key.as_ref())
} }

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

self.nodes_with_copy_source_count -= 1 self.nodes_with_copy_source_count -= 1
} }
} else { } else {
debug_assert!(!was_tracked); debug_assert!(!was_tracked);
} }
Ok(()) Ok(())
} }
fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
for filename in filenames {
if let Some(node) = Self::get_node_mut(
self.on_disk,
&mut self.unreachable_bytes,
&mut self.root,
&filename,
)? {
if let NodeData::Entry(entry) = &mut node.data {
entry.clear_ambiguous_mtime(now);
}
}
}
Ok(())
}
fn non_normal_entries_contains( fn non_normal_entries_contains(
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> 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

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

/// 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_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError>; ) -> Result<(), DirstateError>;
/// Among given files, mark the stored `mtime` as ambiguous if there is one
/// (if `state == EntryState::Normal`) equal to the given current Unix
/// timestamp.
fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError>;
/// Return whether the map has an "non-normal" entry for the given /// Return whether the map has an "non-normal" entry for the given
/// filename. That is, any entry with a `state` other than /// filename. That is, any entry with a `state` other than
/// `EntryState::Normal` or with an ambiguous `mtime`. /// `EntryState::Normal` or with an ambiguous `mtime`.
fn non_normal_entries_contains( fn non_normal_entries_contains(
&mut self, &mut self,
key: &HgPath, key: &HgPath,
) -> Result<bool, DirstateV2ParseError>; ) -> Result<bool, DirstateV2ParseError>;
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError>; ) -> Result<bool, DirstateError>;
/// Returns whether the sub-tree rooted at the given directory contains any /// Returns whether the sub-tree rooted at the given directory contains any
/// file with a dirstate entry. /// file with a dirstate entry.
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError>; fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError>;
/// Clear mtimes that are ambigous with `now` (similar to /// Clear mtimes equal to `now` in entries with `state ==
/// `clear_ambiguous_times` but for all files in the dirstate map), and /// EntryState::Normal`, and serialize bytes to write the `.hg/dirstate`
/// serialize bytes to write the `.hg/dirstate` file to disk in dirstate-v1 /// file to disk in dirstate-v1 format.
/// format.
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError>; ) -> Result<Vec<u8>, DirstateError>;
/// Clear mtimes that are ambigous with `now` (similar to /// Clear mtimes equal to `now` in entries with `state ==
/// `clear_ambiguous_times` but for all files in the dirstate map), and /// EntryState::Normal`, and serialize bytes to write a dirstate data file
/// serialize bytes to write a dirstate data file to disk in dirstate-v2 /// to disk in dirstate-v2 format.
/// format.
/// ///
/// 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 /// `self.on_disk` (true), instead of written to a new data file
/// (false). /// (false).
/// ///
/// Note: this is only supported by the tree dirstate map. /// Note: this is only supported by the tree dirstate map.
fn pack_v2( fn pack_v2(
fn drop_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.drop_entry_and_copy_source(filename) self.drop_entry_and_copy_source(filename)
} }
fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
Ok(self.clear_ambiguous_times(filenames, now))
}
fn non_normal_entries_contains( fn non_normal_entries_contains(
&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))
} }

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

fn drop_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().drop_entry_and_copy_source(filename) self.get_mut().drop_entry_and_copy_source(filename)
} }
fn clear_ambiguous_times(
&mut self,
filenames: Vec<HgPathBuf>,
now: i32,
) -> Result<(), DirstateV2ParseError> {
self.get_mut().clear_ambiguous_times(filenames, now)
}
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) -> bool { fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {

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, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, PyNone, PyObject,
PyNone, PyObject, PyResult, PySet, PyString, Python, PythonObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
ToPyObject, UnsafePyLeaked, 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,
}, },
) -> PyResult<PyNone> { ) -> PyResult<PyNone> {
self.inner(py) self.inner(py)
.borrow_mut() .borrow_mut()
.drop_entry_and_copy_source(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(
&self,
files: PyObject,
now: PyObject
) -> PyResult<PyObject> {
let files: PyResult<Vec<HgPathBuf>> = files
.iter(py)?
.map(|filename| {
Ok(HgPathBuf::from_bytes(
filename?.extract::<PyBytes>(py)?.data(py),
))
})
.collect();
self.inner(py)
.borrow_mut()
.clear_ambiguous_times(files?, now.extract(py)?)
.map_err(|e| v2_error(py, e))?;
Ok(py.None())
}
def other_parent_entries(&self) -> PyResult<PyObject> { def other_parent_entries(&self) -> PyResult<PyObject> {
let mut inner_shared = self.inner(py).borrow_mut(); let mut inner_shared = self.inner(py).borrow_mut();
let set = PySet::empty(py)?; let set = PySet::empty(py)?;
for path in inner_shared.iter_other_parent_paths() { for path in inner_shared.iter_other_parent_paths() {
let path = path.map_err(|e| v2_error(py, e))?; let path = path.map_err(|e| v2_error(py, e))?;
set.add(py, PyBytes::new(py, path.as_bytes()))?; set.add(py, PyBytes::new(py, path.as_bytes()))?;
} }
Ok(set.into_object()) Ok(set.into_object())