( )⚙ D11782 dirstate-item: allow mtime to be None in "parentdata"

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11782

dirstate-item: allow mtime to be None in "parentdata"
ClosedPublic

Authored by marmoute on Nov 24 2021, 6:11 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata"
Summary

This will be useful to filter out unreliable mtime.

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.Nov 24 2021, 6:11 AM
Alphare accepted this revision.Nov 24 2021, 8:08 AM
This revision is now accepted and ready to land.Nov 24 2021, 8:08 AM
marmoute edited the summary of this revision. (Show Details)Nov 30 2021, 6:53 PM
marmoute added a commit: rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata".Dec 1 2021, 10:21 AM
Closed by commit rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata" (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31244

mercurial/cext/parsers.c

int p2_info; int p2_info;
int has_meaningful_data; int has_meaningful_data;
int has_meaningful_mtime; int has_meaningful_mtime;
int mode; int mode;
int size; int size;
int mtime_s; int mtime_s;
int mtime_ns; int mtime_ns;
PyObject *parentfiledata; PyObject *parentfiledata;
PyObject *mtime;
PyObject *fallback_exec; PyObject *fallback_exec;
PyObject *fallback_symlink; PyObject *fallback_symlink;
static char *keywords_name[] = { static char *keywords_name[] = {
"wc_tracked", "p1_tracked", "p2_info", "wc_tracked", "p1_tracked", "p2_info",
"has_meaningful_data", "has_meaningful_mtime", "parentfiledata", "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",
"fallback_exec", "fallback_symlink", NULL, "fallback_exec", "fallback_symlink", NULL,
}; };
wc_tracked = 0; wc_tracked = 0;
if (fallback_symlink != Py_None) { if (fallback_symlink != Py_None) {
t->flags |= dirstate_flag_has_fallback_symlink; t->flags |= dirstate_flag_has_fallback_symlink;
if (PyObject_IsTrue(fallback_symlink)) { if (PyObject_IsTrue(fallback_symlink)) {
t->flags |= dirstate_flag_fallback_symlink; t->flags |= dirstate_flag_fallback_symlink;
} }
} }
if (parentfiledata != Py_None) { if (parentfiledata != Py_None) {
if (!PyArg_ParseTuple(parentfiledata, "ii(ii)", &mode, &size, if (!PyArg_ParseTuple(parentfiledata, "iiO", &mode, &size,
&mtime_s, &mtime_ns)) { &mtime)) {
return NULL; return NULL;
} }
if (mtime != Py_None) {
if (!PyArg_ParseTuple(mtime, "ii", &mtime_s,
&mtime_ns)) {
return NULL;
}
} else {
has_meaningful_mtime = 0;
}
} else { } else {
has_meaningful_data = 0; has_meaningful_data = 0;
has_meaningful_mtime = 0; has_meaningful_mtime = 0;
} }
if (has_meaningful_data) { if (has_meaningful_data) {
t->flags |= dirstate_flag_has_meaningful_data; t->flags |= dirstate_flag_has_meaningful_data;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* See docstring of the python implementation for details */ /* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self, static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args) PyObject *args)
{ {
int size, mode, mtime_s, mtime_ns; int size, mode, mtime_s, mtime_ns;
if (!PyArg_ParseTuple(args, "ii(ii)", &mode, &size, &mtime_s, PyObject *mtime;
&mtime_ns)) { mtime_s = 0;
mtime_ns = 0;
if (!PyArg_ParseTuple(args, "iiO", &mode, &size, &mtime)) {
return NULL;
}
if (mtime != Py_None) {
if (!PyArg_ParseTuple(mtime, "ii", &mtime_s, &mtime_ns)) {
return NULL; return NULL;
} }
} else {
self->flags &= ~dirstate_flag_has_mtime;
}
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_mtime; dirstate_flag_has_mtime;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime_s = mtime_s; self->mtime_s = mtime_s;
self->mtime_ns = mtime_ns; self->mtime_ns = mtime_ns;
Py_RETURN_NONE; Py_RETURN_NONE;

mercurial/dirstate.py

wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info=p2_info, p2_info=p2_info,
has_meaningful_mtime=not possibly_dirty, has_meaningful_mtime=not possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
if ( if (
parentfiledata is not None parentfiledata is not None
and parentfiledata[2] is not None
and parentfiledata[2] > self._lastnormaltime and parentfiledata[2] > self._lastnormaltime
): ):
# Remember the most recent modification timeslot for status(), # Remember the most recent modification timeslot for status(),
# to make sure we won't miss future size-preserving file content # to make sure we won't miss future size-preserving file content
# modifications that happen within the same timeslot. # modifications that happen within the same timeslot.
self._lastnormaltime = parentfiledata[2] self._lastnormaltime = parentfiledata[2]
def _check_new_tracked_filename(self, filename): def _check_new_tracked_filename(self, filename):

mercurial/pure/parsers.py

self._mode = None self._mode = None
self._size = None self._size = None
self._mtime_s = None self._mtime_s = None
self._mtime_ns = None self._mtime_ns = None
if parentfiledata is None: if parentfiledata is None:
has_meaningful_mtime = False has_meaningful_mtime = False
has_meaningful_data = False has_meaningful_data = False
elif parentfiledata[2] is None:
has_meaningful_mtime = False
if has_meaningful_data: if has_meaningful_data:
self._mode = parentfiledata[0] self._mode = parentfiledata[0]
self._size = parentfiledata[1] self._size = parentfiledata[1]
if has_meaningful_mtime: if has_meaningful_mtime:
self._mtime_s, self._mtime_ns = parentfiledata[2] self._mtime_s, self._mtime_ns = parentfiledata[2]
@classmethod @classmethod
def from_v2_data(cls, flags, size, mtime_s, mtime_ns): def from_v2_data(cls, flags, size, mtime_s, mtime_ns):

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

def __new__( def __new__(
_cls, _cls,
wc_tracked: bool = false, wc_tracked: bool = false,
p1_tracked: bool = false, p1_tracked: bool = false,
p2_info: bool = false, p2_info: bool = false,
has_meaningful_data: bool = true, has_meaningful_data: bool = true,
has_meaningful_mtime: bool = true, has_meaningful_mtime: bool = true,
parentfiledata: Option<(u32, u32, (u32, u32))> = None, parentfiledata: Option<(u32, u32, Option<(u32, u32)>)> = None,
fallback_exec: Option<bool> = None, fallback_exec: Option<bool> = None,
fallback_symlink: Option<bool> = None, fallback_symlink: Option<bool> = None,
) -> PyResult<DirstateItem> { ) -> PyResult<DirstateItem> {
let mut mode_size_opt = None; let mut mode_size_opt = None;
let mut mtime_opt = None; let mut mtime_opt = None;
if let Some((mode, size, mtime)) = parentfiledata { if let Some((mode, size, mtime)) = parentfiledata {
if has_meaningful_data { if has_meaningful_data {
mode_size_opt = Some((mode, size)) mode_size_opt = Some((mode, size))
} }
if has_meaningful_mtime { if has_meaningful_mtime {
mtime_opt = Some(timestamp(py, mtime)?) if let Some(m) = mtime {
mtime_opt = Some(timestamp(py, m)?);
}
} }
} }
let entry = DirstateEntry::from_v2_data( let entry = DirstateEntry::from_v2_data(
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size_opt, mode_size_opt,
mtime_opt, mtime_opt,