( )⚙ D11506 dirstate: use a new `drop_merge_data` in `setparent`

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 30429

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