This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11506

dirstate: use a new `drop_merge_data` in `setparent`
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGa660d8a53267: dirstate: use a new `drop_merge_data` in `setparent`
Summary

What is happening in this setparent loop is that we remove all merge
related information when the dirstate is moved out of a merge situation.

So instead of shuffling state to get them where we want, we simply add a method
on the DirstateItem to do drop the information we want dropped.

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:54 PM
Alphare requested changes to this revision.Sep 29 2021, 4:45 AM
Alphare added a subscriber: Alphare.

Please do a typo pass on this, it's a bit hard to read. The change looks good otherwise

This revision now requires changes to proceed.Sep 29 2021, 4:45 AM
marmoute edited the summary of this revision. (Show Details)Sep 29 2021, 5:04 AM
Alphare accepted this revision.Sep 30 2021, 9:45 AM
This revision is now accepted and ready to land.Sep 30 2021, 9:45 AM
marmoute added a commit: rHGa660d8a53267: dirstate: use a new `drop_merge_data` in `setparent`.Oct 1 2021, 9:17 AM
Closed by commit rHGa660d8a53267: dirstate: use a new `drop_merge_data` in `setparent` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30478

mercurial/cext/parsers.c

{ {
self->flags &= ~dirstate_flag_wc_tracked; self->flags &= ~dirstate_flag_wc_tracked;
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0; self->size = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
{
if (dirstate_item_c_merged(self) || dirstate_item_c_from_p2(self)) {
if (dirstate_item_c_merged(self)) {
self->flags |= dirstate_flag_p1_tracked;
} else {
self->flags &= ~dirstate_flag_p1_tracked;
}
self->flags &=
~(dirstate_flag_merged | dirstate_flag_clean_p1 |
dirstate_flag_clean_p2 | dirstate_flag_p2_tracked);
self->flags |= dirstate_flag_possibly_dirty;
self->mode = 0;
self->mtime = 0;
/* size = None on the python size turn into size = NON_NORMAL
* when accessed. So the next line is currently required, but a
* some future clean up would be welcome. */
self->size = dirstate_v1_nonnormal;
}
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,
{"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_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS, {"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
"mark a file as \"clean\""}, "mark a file as \"clean\""},
{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS, {"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
"mark a file as \"tracked\""}, "mark a file as \"tracked\""},
{"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS, {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
"mark a file as \"untracked\""}, "mark a file as \"untracked\""},
{"drop_merge_data", (PyCFunction)dirstate_item_drop_merge_data, METH_NOARGS,
"remove all \"merge-only\" from a DirstateItem"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstate_item_get_mode(dirstateItemObject *self) static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
{ {
return PyInt_FromLong(dirstate_item_c_v1_mode(self)); return PyInt_FromLong(dirstate_item_c_v1_mode(self));
}; };

mercurial/dirstatemap.py

candidatefiles = self.non_normal_or_other_parent_paths() candidatefiles = self.non_normal_or_other_parent_paths()
for f in candidatefiles: for f in candidatefiles:
s = self.get(f) s = self.get(f)
if s is None: if s is None:
continue continue
# Discard "merged" markers when moving away from a merge state # Discard "merged" markers when moving away from a merge state
if s.merged: if s.merged or s.from_p2:
source = self.copymap.get(f) source = self.copymap.pop(f, None)
if source:
copies[f] = source
self.reset_state(
f,
wc_tracked=True,
p1_tracked=True,
possibly_dirty=True,
)
# Also fix up otherparent markers
elif s.from_p2:
source = self.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.reset_state( s.drop_merge_data()
f,
p1_tracked=False,
wc_tracked=True,
)
return copies return copies
def read(self): def read(self):
# ignore HG_PENDING because identity is used only for writing # ignore HG_PENDING because identity is used only for writing
self.identity = util.filestat.frompath( self.identity = util.filestat.frompath(
self._opener.join(self._filename) self._opener.join(self._filename)
) )

mercurial/pure/parsers.py

This will ultimately be called by command like `hg remove`. This will ultimately be called by command like `hg remove`.
""" """
# backup the previous state (useful for merge) # backup the previous state (useful for merge)
self._wc_tracked = False self._wc_tracked = False
self._mode = None self._mode = None
self._size = None self._size = None
self._mtime = None self._mtime = None
def drop_merge_data(self):
"""remove all "merge-only" from a DirstateItem
This is to be call by the dirstatemap code when the second parent is dropped
"""
if not (self.merged or self.from_p2):
return
self._p1_tracked = self.merged # why is this not already properly set ?
self._merged = False
self._clean_p1 = False
self._clean_p2 = False
self._p2_tracked = False
self._possibly_dirty = True
self._mode = None
self._size = None
self._mtime = None
@property @property
def mode(self): def mode(self):
return self.v1_mode() return self.v1_mode()
@property @property
def size(self): def size(self):
return self.v1_size() return self.v1_size()