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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 30474

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())