This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11699

dirstate: align Rust function name to `need_delay`
ClosedPublic

Authored by marmoute on Oct 19 2021, 6:02 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc591944f42c1: dirstate: align Rust function name to `need_delay`
Summary

The rest of the code use this name. It is not a great name, but it is better to
stay consistent.

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.Oct 19 2021, 6:02 PM
Alphare accepted this revision.Oct 20 2021, 4:33 AM
Alphare added a subscriber: Alphare.

I think a docstring would be good for this function. If this ends up being the only nit in the series it can be done in a follow-up.

This revision is now accepted and ready to land.Oct 20 2021, 4:33 AM
marmoute updated this revision to Diff 30929.Oct 20 2021, 5:12 AM
marmoute added a commit: rHGc591944f42c1: dirstate: align Rust function name to `need_delay`.Oct 20 2021, 5:30 AM
Closed by commit rHGc591944f42c1: dirstate: align Rust function name to `need_delay` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30940

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

} }
/// Returns a `(state, mode, size, mtime)` tuple as for /// Returns a `(state, mode, size, mtime)` tuple as for
/// `DirstateMapMethods::debug_iter`. /// `DirstateMapMethods::debug_iter`.
pub fn debug_tuple(&self) -> (u8, i32, i32, i32) { pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
(self.state().into(), self.mode(), self.size(), self.mtime()) (self.state().into(), self.mode(), self.size(), self.mtime())
} }
pub fn mtime_is_ambiguous(&self, now: i32) -> bool { /// True if the stored mtime would be ambiguous with the current time
pub fn need_delay(&self, now: i32) -> bool {
self.state() == EntryState::Normal && self.mtime() == now self.state() == EntryState::Normal && self.mtime() == now
} }
pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool { pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool {
let ambiguous = self.mtime_is_ambiguous(now); let ambiguous = self.need_delay(now);
if ambiguous { if ambiguous {
// The file was last modified "simultaneously" with the current // The file was last modified "simultaneously" with the current
// write to dirstate (i.e. within the same second for file- // write to dirstate (i.e. within the same second for file-
// systems with a granularity of 1 sec). This commonly happens // systems with a granularity of 1 sec). This commonly happens
// for at least a couple of files on 'update'. // for at least a couple of files on 'update'.
// The user could change the file without changing its size // The user could change the file without changing its size
// within the same second. Invalidate the file's mtime in // within the same second. Invalidate the file's mtime in
// dirstate, forcing future 'status' calls to compare the // dirstate, forcing future 'status' calls to compare the

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

let mut size = parents.as_bytes().len(); let mut size = parents.as_bytes().len();
for node in map.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
size += packed_entry_size( size += packed_entry_size(
node.full_path(map.on_disk)?, node.full_path(map.on_disk)?,
node.copy_source(map.on_disk)?, node.copy_source(map.on_disk)?,
); );
if entry.mtime_is_ambiguous(now) { if entry.need_delay(now) {
ambiguous_mtimes.push( ambiguous_mtimes.push(
node.full_path_borrowed(map.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> { ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
let map = self.get_map_mut(); let map = self.get_map_mut();
// TODO:!how do we want to handle this in 2038? // TODO:!how do we want to handle this in 2038?
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut paths = Vec::new(); let mut paths = Vec::new();
for node in map.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
if entry.mtime_is_ambiguous(now) { if entry.need_delay(now) {
paths.push( paths.push(
node.full_path_borrowed(map.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
// Borrow of `self` ends here since we collect cloned paths // Borrow of `self` ends here since we collect cloned paths

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

} }
def v1_mtime(&self) -> PyResult<i32> { def v1_mtime(&self) -> PyResult<i32> {
let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data(); let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
Ok(mtime) Ok(mtime)
} }
def need_delay(&self, now: i32) -> PyResult<bool> { def need_delay(&self, now: i32) -> PyResult<bool> {
Ok(self.entry(py).get().mtime_is_ambiguous(now)) Ok(self.entry(py).get().need_delay(now))
} }
@classmethod @classmethod
def from_v1_data( def from_v1_data(
_cls, _cls,
state: PyBytes, state: PyBytes,
mode: i32, mode: i32,
size: i32, size: i32,