( )⚙ D11315 dirstatemap: replace `removefile` by an explicit `entry.set_untracked()`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11315

dirstatemap: replace `removefile` by an explicit `entry.set_untracked()`
ClosedPublic

Authored by marmoute on Aug 21 2021, 5:55 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3853e6ee160d: dirstatemap: replace `removefile` by an explicit `entry.set_untracked()`
Summary

All the other caller goes through reset_state, so we can safely have an
explicit method on DirstateItem object.
This means that all the logic to preserve the previous state (from p2, merged,
etc) is now properly encapsulated within the DirstateItem. This pave the way to
using different storage for these information.

Diff Detail

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

Event Timeline

marmoute created this revision.Aug 21 2021, 5:55 AM
Alphare accepted this revision.Aug 25 2021, 9:49 AM
This revision is now accepted and ready to land.Aug 25 2021, 9:49 AM
baymax updated this revision to Diff 30041.Aug 26 2021, 8:59 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 29964

mercurial/cext/parsers.c

/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->mtime = ambiguous_time; self->mtime = ambiguous_time;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{
if (self->state == 'm') {
self->size = dirstate_v1_nonnormal;
} else if (self->state == 'n' && self->size == dirstate_v1_from_p2) {
self->size = dirstate_v1_from_p2;
} else {
self->size = 0;
}
self->state = 'r';
self->mode = 0;
self->mtime = 0;
Py_RETURN_NONE;
}
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS, {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
"return a \"state\" suitable for v1 serialization"}, "return a \"state\" suitable for v1 serialization"},
{"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS, {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
{"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O, {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,
"True if the stored mtime would be ambiguous with the current time"}, "True if the stored mtime would be ambiguous with the current time"},
{"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, METH_O, {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, METH_O,
"build a new DirstateItem object from V1 data"}, "build a new DirstateItem object from V1 data"},
{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty, {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
METH_NOARGS, "mark a file as \"possibly dirty\""}, METH_NOARGS, "mark a file as \"possibly dirty\""},
{"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
"mark a file as \"untracked\""},
{"dm_nonnormal", (PyCFunction)dm_nonnormal, METH_NOARGS, {"dm_nonnormal", (PyCFunction)dm_nonnormal, METH_NOARGS,
"True is the entry is non-normal in the dirstatemap sense"}, "True is the entry is non-normal in the dirstatemap sense"},
{"dm_otherparent", (PyCFunction)dm_otherparent, METH_NOARGS, {"dm_otherparent", (PyCFunction)dm_otherparent, METH_NOARGS,
"True is the entry is `otherparent` in the dirstatemap sense"}, "True is the entry is `otherparent` in the dirstatemap sense"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstate_item_get_mode(dirstateItemObject *self) static PyObject *dirstate_item_get_mode(dirstateItemObject *self)

mercurial/dirstate.py

if entry is None: if entry is None:
return False return False
elif entry.added: elif entry.added:
self._drop(filename) self._drop(filename)
return True return True
else: else:
self._dirty = True self._dirty = True
self._updatedfiles.add(filename) self._updatedfiles.add(filename)
self._map.removefile(filename, in_merge=self.in_merge) self._map.set_untracked(filename)
return True return True
@requires_no_parents_change @requires_no_parents_change
def set_clean(self, filename, parentfiledata=None): def set_clean(self, filename, parentfiledata=None):
"""record that the current state of the file on disk is known to be clean""" """record that the current state of the file on disk is known to be clean"""
self._dirty = True self._dirty = True
self._updatedfiles.add(filename) self._updatedfiles.add(filename)
self._normal(filename, parentfiledata=parentfiledata) self._normal(filename, parentfiledata=parentfiledata)

mercurial/dirstatemap.py

msg %= filename msg %= filename
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
mode, size, mtime = parentfiledata mode, size, mtime = parentfiledata
self.addfile(filename, mode=mode, size=size, mtime=mtime) self.addfile(filename, mode=mode, size=size, mtime=mtime)
self.nonnormalset.discard(filename) self.nonnormalset.discard(filename)
else: else:
assert False, 'unreachable' assert False, 'unreachable'
def removefile(self, f, in_merge=False): def set_untracked(self, f):
""" """Mark a file as no longer tracked in the dirstate map"""
Mark a file as removed in the dirstate. entry = self[f]
self._dirs_decr(f, old_entry=entry, remove_variant=True)
The `size` parameter is used to store sentinel values that indicate if entry.from_p2:
the file's previous state. In the future, we should refactor this
to be more explicit about what that state is.
"""
entry = self.get(f)
size = 0
if in_merge:
# XXX we should not be able to have 'm' state and 'FROM_P2' if not
# during a merge. So I (marmoute) am not sure we need the
# conditionnal at all. Adding double checking this with assert
# would be nice.
if entry is not None:
# backup the previous state
if entry.merged: # merge
size = NONNORMAL
elif entry.from_p2:
size = FROM_P2
self.otherparentset.add(f) self.otherparentset.add(f)
if entry is not None and not (entry.merged or entry.from_p2): elif not entry.merged:
self.copymap.pop(f, None) self.copymap.pop(f, None)
self._dirs_decr(f, old_entry=entry, remove_variant=True) entry.set_untracked()
self._map[f] = DirstateItem(b'r', 0, size, 0)
self.nonnormalset.add(f) self.nonnormalset.add(f)
def dropfile(self, f): def dropfile(self, f):
""" """
Remove a file from the dirstate. Returns True if the file was Remove a file from the dirstate. Returns True if the file was
previously recorded. previously recorded.
""" """
old_entry = self._map.pop(f, None) old_entry = self._map.pop(f, None)
msg %= filename msg %= filename
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
mode, size, mtime = parentfiledata mode, size, mtime = parentfiledata
self.addfile(filename, mode=mode, size=size, mtime=mtime) self.addfile(filename, mode=mode, size=size, mtime=mtime)
self.nonnormalset.discard(filename) self.nonnormalset.discard(filename)
else: else:
assert False, 'unreachable' assert False, 'unreachable'
def set_untracked(self, f):
"""Mark a file as no longer tracked in the dirstate map"""
# in merge is only trigger more logic, so it "fine" to pass it.
#
# the inner rust dirstate map code need to be adjusted once the API
# for dirstate/dirstatemap/DirstateItem is a bit more settled
self._rustmap.removefile(f, in_merge=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, *args, **kwargs): def dropfile(self, *args, **kwargs):
return self._rustmap.dropfile(*args, **kwargs) return self._rustmap.dropfile(*args, **kwargs)
def clearambiguoustimes(self, *args, **kwargs): def clearambiguoustimes(self, *args, **kwargs):
return self._rustmap.clearambiguoustimes(*args, **kwargs) return self._rustmap.clearambiguoustimes(*args, **kwargs)

mercurial/pure/parsers.py

def set_possibly_dirty(self): def set_possibly_dirty(self):
"""Mark a file as "possibly dirty" """Mark a file as "possibly dirty"
This means the next status call will have to actually check its content This means the next status call will have to actually check its content
to make sure it is correct. to make sure it is correct.
""" """
self._mtime = AMBIGUOUS_TIME self._mtime = AMBIGUOUS_TIME
def set_untracked(self):
"""mark a file as untracked in the working copy
This will ultimately be called by command like `hg remove`.
"""
# backup the previous state (useful for merge)
size = 0
if self.merged: # merge
size = NONNORMAL
elif self.from_p2:
size = FROM_P2
self._state = b'r'
self._mode = 0
self._size = size
self._mtime = 0
def __getitem__(self, idx): def __getitem__(self, idx):
if idx == 0 or idx == -4: if idx == 0 or idx == -4:
msg = b"do not use item[x], use item.state" msg = b"do not use item[x], use item.state"
util.nouideprecwarn(msg, b'6.0', stacklevel=2) util.nouideprecwarn(msg, b'6.0', stacklevel=2)
return self._state return self._state
elif idx == 1 or idx == -3: elif idx == 1 or idx == -3:
msg = b"do not use item[x], use item.mode" msg = b"do not use item[x], use item.mode"
util.nouideprecwarn(msg, b'6.0', stacklevel=2) util.nouideprecwarn(msg, b'6.0', stacklevel=2)