( )⚙ D11507 dirstate: drop all logic around the "non-normal" sets

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11507

dirstate: drop all logic around the "non-normal" sets
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG060cd909439f: dirstate: drop all logic around the "non-normal" sets
Summary

The dirstate has a lot of code to compute a set of all "non-normal" and
"from_other_parent" entries.

This is all used in one, unique, location, when setparent is called and moved
from a merge to a non merge. At that time, any "merge related" information has
to be dropped. This is mostly useful for command like graft or shelve that
move to a single-parent state -before- the commit. Otherwise the commit will
already have removed all traces of the merge information in the dirstate (e.g.
for a regular merges).

The bookkeeping for these sets is quite invasive. And it seems simpler to just
drop it and do the full computation in the single location where we actually
use it (since we have to do the computation at least once anyway).

This simplify the code a lot, and clarify why this kind of computation is
needed.

The possible drawback compared to the previous code are:

  • if the operation happens in a loop, we will end up doing it multiple time,
  • the C code to detect entry of interest have been dropped, for now. It will be re-introduced later, with a processing code directly in C for even faster operation.

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 added a subscriber: Alphare.Sep 29 2021, 4:55 AM

Very happy that this can be dropped, it was a lot of complexity for not much (after all the refactoring, of course). I'll accept it once the description is updated to reflect that the Rust changes have indeed been done.

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: rHG060cd909439f: dirstate: drop all logic around the "non-normal" sets.Oct 1 2021, 9:18 AM
Closed by commit rHG060cd909439f: dirstate: drop all logic around the "non-normal" sets (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30479

contrib/dirstatenonnormalcheck.py

  • This file was deleted.
# dirstatenonnormalcheck.py - extension to check the consistency of the
# dirstate's non-normal map
#
# For most operations on dirstate, this extensions checks that the nonnormalset
# contains the right entries.
# It compares the nonnormal file to a nonnormalset built from the map of all
# the files in the dirstate to check that they contain the same files.
from __future__ import absolute_import
from mercurial import (
dirstate,
extensions,
pycompat,
)
def nonnormalentries(dmap):
"""Compute nonnormal entries from dirstate's dmap"""
res = set()
for f, e in dmap.iteritems():
if e.state != b'n' or e.mtime == -1:
res.add(f)
return res
INCONSISTENCY_MESSAGE = b"""%s call to %s
inconsistency in nonnormalset
result from dirstatemap: %s
expected nonnormalset: %s
"""
def checkconsistency(ui, orig, dmap, _nonnormalset, label):
"""Compute nonnormalset from dmap, check that it matches _nonnormalset"""
nonnormalcomputedmap = nonnormalentries(dmap)
if _nonnormalset != nonnormalcomputedmap:
b_orig = pycompat.sysbytes(repr(orig))
b_nonnormal = pycompat.sysbytes(repr(_nonnormalset))
b_nonnormalcomputed = pycompat.sysbytes(repr(nonnormalcomputedmap))
msg = INCONSISTENCY_MESSAGE % (
label,
b_orig,
b_nonnormal,
b_nonnormalcomputed,
)
ui.develwarn(msg, config=b'dirstate')
def _checkdirstate(orig, self, *args, **kwargs):
"""Check nonnormal set consistency before and after the call to orig"""
checkconsistency(
self._ui, orig, self._map, self._map.nonnormalset, b"before"
)
r = orig(self, *args, **kwargs)
checkconsistency(
self._ui, orig, self._map, self._map.nonnormalset, b"after"
)
return r
def extsetup(ui):
"""Wrap functions modifying dirstate to check nonnormalset consistency"""
dirstatecl = dirstate.dirstate
devel = ui.configbool(b'devel', b'all-warnings')
paranoid = ui.configbool(b'experimental', b'nonnormalparanoidcheck')
if devel:
extensions.wrapfunction(dirstatecl, '_writedirstate', _checkdirstate)
if paranoid:
# We don't do all these checks when paranoid is disable as it would
# make the extension run very slowly on large repos
extensions.wrapfunction(dirstatecl, 'write', _checkdirstate)
extensions.wrapfunction(dirstatecl, 'set_tracked', _checkdirstate)
extensions.wrapfunction(dirstatecl, 'set_untracked', _checkdirstate)
extensions.wrapfunction(
dirstatecl, 'set_possibly_dirty', _checkdirstate
)
extensions.wrapfunction(
dirstatecl, 'update_file_p1', _checkdirstate
)
extensions.wrapfunction(dirstatecl, 'update_file', _checkdirstate)

mercurial/cext/parsers.c

{ {
if (dirstate_item_c_removed(self)) { if (dirstate_item_c_removed(self)) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dm_nonnormal(dirstateItemObject *self)
{
if ((dirstate_item_c_v1_state(self) != 'n') ||
(dirstate_item_c_v1_mtime(self) == ambiguous_time)) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
};
static PyObject *dm_otherparent(dirstateItemObject *self)
{
if (dirstate_item_c_v1_mtime(self) == dirstate_v1_from_p2) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
};
static PyGetSetDef dirstate_item_getset[] = { static PyGetSetDef dirstate_item_getset[] = {
{"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL}, {"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
{"size", (getter)dirstate_item_get_size, NULL, "size", NULL}, {"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
{"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL}, {"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
{"state", (getter)dirstate_item_get_state, NULL, "state", NULL}, {"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
{"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL}, {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
{"added", (getter)dirstate_item_get_added, NULL, "added", NULL}, {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
{"merged_removed", (getter)dirstate_item_get_merged_removed, NULL, {"merged_removed", (getter)dirstate_item_get_merged_removed, NULL,
"merged_removed", NULL}, "merged_removed", NULL},
{"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL}, {"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
{"from_p2_removed", (getter)dirstate_item_get_from_p2_removed, NULL, {"from_p2_removed", (getter)dirstate_item_get_from_p2_removed, NULL,
"from_p2_removed", NULL}, "from_p2_removed", NULL},
{"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL}, {"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
{"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL}, {"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},
{"dm_nonnormal", (getter)dm_nonnormal, NULL, "dm_nonnormal", NULL},
{"dm_otherparent", (getter)dm_otherparent, NULL, "dm_otherparent", NULL},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
PyTypeObject dirstateItemType = { PyTypeObject dirstateItemType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"dirstate_tuple", /* tp_name */ "dirstate_tuple", /* tp_name */
sizeof(dirstateItemObject), /* tp_basicsize */ sizeof(dirstateItemObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
Py_XDECREF(fname); Py_XDECREF(fname);
Py_XDECREF(cname); Py_XDECREF(cname);
Py_XDECREF(entry); Py_XDECREF(entry);
Py_XDECREF(parents); Py_XDECREF(parents);
return ret; return ret;
} }
/* /*
* Build a set of non-normal and other parent entries from the dirstate dmap
*/
static PyObject *nonnormalotherparententries(PyObject *self, PyObject *args)
{
PyObject *dmap, *fname, *v;
PyObject *nonnset = NULL, *otherpset = NULL, *result = NULL;
Py_ssize_t pos;
if (!PyArg_ParseTuple(args, "O!:nonnormalentries", &PyDict_Type,
&dmap)) {
goto bail;
}
nonnset = PySet_New(NULL);
if (nonnset == NULL) {
goto bail;
}
otherpset = PySet_New(NULL);
if (otherpset == NULL) {
goto bail;
}
pos = 0;
while (PyDict_Next(dmap, &pos, &fname, &v)) {
dirstateItemObject *t;
if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple");
goto bail;
}
t = (dirstateItemObject *)v;
if (dirstate_item_c_from_p2(t)) {
if (PySet_Add(otherpset, fname) == -1) {
goto bail;
}
}
if (!(t->flags & dirstate_flag_wc_tracked) ||
!(t->flags &
(dirstate_flag_p1_tracked | dirstate_flag_p2_tracked)) ||
(t->flags &
(dirstate_flag_possibly_dirty | dirstate_flag_merged))) {
if (PySet_Add(nonnset, fname) == -1) {
goto bail;
}
}
}
result = Py_BuildValue("(OO)", nonnset, otherpset);
if (result == NULL) {
goto bail;
}
Py_DECREF(nonnset);
Py_DECREF(otherpset);
return result;
bail:
Py_XDECREF(nonnset);
Py_XDECREF(otherpset);
Py_XDECREF(result);
return NULL;
}
/*
* Efficiently pack a dirstate object into its on-disk format. * Efficiently pack a dirstate object into its on-disk format.
*/ */
static PyObject *pack_dirstate(PyObject *self, PyObject *args) static PyObject *pack_dirstate(PyObject *self, PyObject *args)
{ {
PyObject *packobj = NULL; PyObject *packobj = NULL;
PyObject *map, *copymap, *pl, *mtime_unset = NULL; PyObject *map, *copymap, *pl, *mtime_unset = NULL;
Py_ssize_t nbytes, pos, l; Py_ssize_t nbytes, pos, l;
PyObject *k, *v = NULL, *pn; PyObject *k, *v = NULL, *pn;
PyObject *encodedir(PyObject *self, PyObject *args); PyObject *encodedir(PyObject *self, PyObject *args);
PyObject *pathencode(PyObject *self, PyObject *args); PyObject *pathencode(PyObject *self, PyObject *args);
PyObject *lowerencode(PyObject *self, PyObject *args); PyObject *lowerencode(PyObject *self, PyObject *args);
PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs); PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs);
static PyMethodDef methods[] = { static PyMethodDef methods[] = {
{"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"}, {"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"},
{"nonnormalotherparententries", nonnormalotherparententries, METH_VARARGS,
"create a set containing non-normal and other parent entries of given "
"dirstate\n"},
{"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"}, {"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"},
{"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS, {"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS,
"parse a revlog index\n"}, "parse a revlog index\n"},
{"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"}, {"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"},
{"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"}, {"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"},
{"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"}, {"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"},
{"dict_new_presized", dict_new_presized, METH_VARARGS, {"dict_new_presized", dict_new_presized, METH_VARARGS,
"construct a dict with an expected size\n"}, "construct a dict with an expected size\n"},

mercurial/dirstatemap.py

- `set_untracked` - `set_untracked`
- `set_clean` - `set_clean`
- `set_possibly_dirty` - `set_possibly_dirty`
- `copymap` maps destination filenames to their source filename. - `copymap` maps destination filenames to their source filename.
The dirstate also provides the following views onto the state: The dirstate also provides the following views onto the state:
- `nonnormalset` is a set of the filenames that have state other
than 'normal', or are normal but have an mtime of -1 ('normallookup').
- `otherparentset` is a set of the filenames that are marked as coming
from the second parent when the dirstate is currently being merged.
- `filefoldmap` is a dict mapping normalized filenames to the denormalized - `filefoldmap` is a dict mapping normalized filenames to the denormalized
form that they appear as in the dirstate. form that they appear as in the dirstate.
- `dirfoldmap` is a dict mapping normalized directory names to the - `dirfoldmap` is a dict mapping normalized directory names to the
denormalized form that they appear as in the dirstate. denormalized form that they appear as in the dirstate.
""" """
def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2): def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
def clear(self): def clear(self):
self._map.clear() self._map.clear()
self.copymap.clear() self.copymap.clear()
self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
util.clearcachedproperty(self, b"_dirs") util.clearcachedproperty(self, b"_dirs")
util.clearcachedproperty(self, b"_alldirs") util.clearcachedproperty(self, b"_alldirs")
util.clearcachedproperty(self, b"filefoldmap") util.clearcachedproperty(self, b"filefoldmap")
util.clearcachedproperty(self, b"dirfoldmap") util.clearcachedproperty(self, b"dirfoldmap")
util.clearcachedproperty(self, b"nonnormalset")
util.clearcachedproperty(self, b"otherparentset")
def items(self): def items(self):
return pycompat.iteritems(self._map) return pycompat.iteritems(self._map)
# forward for python2,3 compat # forward for python2,3 compat
iteritems = items iteritems = items
def debug_iter(self, all): def debug_iter(self, all):
def set_clean(self, filename, mode, size, mtime): def set_clean(self, filename, mode, size, mtime):
"""mark a file as back to a clean state""" """mark a file as back to a clean state"""
entry = self[filename] entry = self[filename]
mtime = mtime & rangemask mtime = mtime & rangemask
size = size & rangemask size = size & rangemask
entry.set_clean(mode, size, mtime) entry.set_clean(mode, size, mtime)
self.copymap.pop(filename, None) self.copymap.pop(filename, None)
self.nonnormalset.discard(filename)
def reset_state( def reset_state(
self, self,
filename, filename,
wc_tracked=False, wc_tracked=False,
p1_tracked=False, p1_tracked=False,
p2_tracked=False, p2_tracked=False,
merged=False, merged=False,
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
# copy information are now outdated # copy information are now outdated
# (maybe new information should be in directly passed to this function) # (maybe new information should be in directly passed to this function)
self.copymap.pop(filename, None) self.copymap.pop(filename, None)
if not (p1_tracked or p2_tracked or wc_tracked): if not (p1_tracked or p2_tracked or wc_tracked):
old_entry = self._map.pop(filename, None) old_entry = self._map.pop(filename, None)
self._dirs_decr(filename, old_entry=old_entry) self._dirs_decr(filename, old_entry=old_entry)
self.nonnormalset.discard(filename)
self.copymap.pop(filename, None) self.copymap.pop(filename, None)
return return
elif merged: elif merged:
# XXX might be merged and removed ? # XXX might be merged and removed ?
entry = self.get(filename) entry = self.get(filename)
if entry is None or not entry.tracked: if entry is None or not entry.tracked:
# XXX mostly replicate dirstate.other parent. We should get # XXX mostly replicate dirstate.other parent. We should get
# the higher layer to pass us more reliable data where `merged` # the higher layer to pass us more reliable data where `merged`
p1_tracked=p1_tracked, p1_tracked=p1_tracked,
p2_tracked=p2_tracked, p2_tracked=p2_tracked,
merged=merged, merged=merged,
clean_p1=clean_p1, clean_p1=clean_p1,
clean_p2=clean_p2, clean_p2=clean_p2,
possibly_dirty=possibly_dirty, possibly_dirty=possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
if entry.dm_nonnormal:
self.nonnormalset.add(filename)
else:
self.nonnormalset.discard(filename)
if entry.dm_otherparent:
self.otherparentset.add(filename)
else:
self.otherparentset.discard(filename)
self._map[filename] = entry self._map[filename] = entry
def set_tracked(self, filename): def set_tracked(self, filename):
new = False new = False
entry = self.get(filename) entry = self.get(filename)
if entry is None: if entry is None:
self._dirs_incr(filename) self._dirs_incr(filename)
entry = DirstateItem( entry = DirstateItem(
p1_tracked=False, p1_tracked=False,
p2_tracked=False, p2_tracked=False,
wc_tracked=True, wc_tracked=True,
merged=False, merged=False,
clean_p1=False, clean_p1=False,
clean_p2=False, clean_p2=False,
possibly_dirty=False, possibly_dirty=False,
parentfiledata=None, parentfiledata=None,
) )
self._map[filename] = entry self._map[filename] = entry
if entry.dm_nonnormal:
self.nonnormalset.add(filename)
new = True new = True
elif not entry.tracked: elif not entry.tracked:
self._dirs_incr(filename, entry) self._dirs_incr(filename, entry)
entry.set_tracked() entry.set_tracked()
new = True new = True
else: else:
# XXX This is probably overkill for more case, but we need this to # XXX This is probably overkill for more case, but we need this to
# fully replace the `normallookup` call with `set_tracked` one. # fully replace the `normallookup` call with `set_tracked` one.
# Consider smoothing this in the future. # Consider smoothing this in the future.
self.set_possibly_dirty(filename) self.set_possibly_dirty(filename)
return new return new
def set_untracked(self, f): def set_untracked(self, f):
"""Mark a file as no longer tracked in the dirstate map""" """Mark a file as no longer tracked in the dirstate map"""
entry = self.get(f) entry = self.get(f)
if entry is None: if entry is None:
return False return False
else: else:
self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added) self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)
if not entry.merged: if not entry.merged:
self.copymap.pop(f, None) self.copymap.pop(f, None)
if entry.added: if entry.added:
self.nonnormalset.discard(f)
self._map.pop(f, None) self._map.pop(f, None)
else: else:
self.nonnormalset.add(f)
if entry.from_p2:
self.otherparentset.add(f)
entry.set_untracked() entry.set_untracked()
return True return True
def nonnormalentries(self):
'''Compute the nonnormal dirstate entries from the dmap'''
try:
return parsers.nonnormalotherparententries(self._map)
except AttributeError:
nonnorm = set()
otherparent = set()
for fname, e in pycompat.iteritems(self._map):
if e.dm_nonnormal:
nonnorm.add(fname)
if e.from_p2:
otherparent.add(fname)
return nonnorm, otherparent
@propertycache @propertycache
def filefoldmap(self): def filefoldmap(self):
"""Returns a dictionary mapping normalized case paths to their """Returns a dictionary mapping normalized case paths to their
non-normalized versions. non-normalized versions.
""" """
try: try:
makefilefoldmap = parsers.make_file_foldmap makefilefoldmap = parsers.make_file_foldmap
except AttributeError: except AttributeError:
return self._parents return self._parents
def setparents(self, p1, p2, fold_p2=False): def setparents(self, p1, p2, fold_p2=False):
self._parents = (p1, p2) self._parents = (p1, p2)
self._dirtyparents = True self._dirtyparents = True
copies = {} copies = {}
if fold_p2: if fold_p2:
candidatefiles = self.non_normal_or_other_parent_paths() for f, s in pycompat.iteritems(self._map):
for f in candidatefiles:
s = self.get(f)
if s is None:
continue
# Discard "merged" markers when moving away from a merge state # Discard "merged" markers when moving away from a merge state
if s.merged or s.from_p2: if s.merged or s.from_p2:
source = self.copymap.pop(f, None) source = self.copymap.pop(f, None)
if source: if source:
copies[f] = source copies[f] = source
s.drop_merge_data() s.drop_merge_data()
return copies return copies
self.get = self._map.get self.get = self._map.get
def write(self, _tr, st, now): def write(self, _tr, st, now):
st.write( st.write(
parsers.pack_dirstate(self._map, self.copymap, self.parents(), now) parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
) )
st.close() st.close()
self._dirtyparents = False self._dirtyparents = False
self.nonnormalset, self.otherparentset = self.nonnormalentries()
@propertycache
def nonnormalset(self):
nonnorm, otherparents = self.nonnormalentries()
self.otherparentset = otherparents
return nonnorm
@propertycache
def otherparentset(self):
nonnorm, otherparents = self.nonnormalentries()
self.nonnormalset = nonnorm
return otherparents
def non_normal_or_other_parent_paths(self):
return self.nonnormalset.union(self.otherparentset)
@propertycache @propertycache
def identity(self): def identity(self):
self._map self._map
return self.identity return self.identity
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
self.addfile(filename, from_p2=True) self.addfile(filename, from_p2=True)
elif not (p1_tracked or p2_tracked) and wc_tracked: elif not (p1_tracked or p2_tracked) and wc_tracked:
self.addfile( self.addfile(
filename, added=True, possibly_dirty=possibly_dirty filename, added=True, possibly_dirty=possibly_dirty
) )
elif (p1_tracked or p2_tracked) and not wc_tracked: elif (p1_tracked or p2_tracked) and not wc_tracked:
# XXX might be merged and removed ? # XXX might be merged and removed ?
self[filename] = DirstateItem.from_v1_data(b'r', 0, 0, 0) self[filename] = DirstateItem.from_v1_data(b'r', 0, 0, 0)
self.nonnormalset.add(filename)
elif clean_p2 and wc_tracked: elif clean_p2 and wc_tracked:
if p1_tracked or self.get(filename) is not None: if p1_tracked or self.get(filename) is not None:
# XXX the `self.get` call is catching some case in # XXX the `self.get` call is catching some case in
# `test-merge-remove.t` where the file is tracked in p1, the # `test-merge-remove.t` where the file is tracked in p1, the
# p1_tracked argument is False. # p1_tracked argument is False.
# #
# In addition, this seems to be a case where the file is marked # In addition, this seems to be a case where the file is marked
# as merged without actually being the result of a merge # as merged without actually being the result of a merge
elif wc_tracked: elif wc_tracked:
# this is a "normal" file # this is a "normal" file
if parentfiledata is None: if parentfiledata is None:
msg = b'failed to pass parentfiledata for a normal file: %s' msg = b'failed to pass parentfiledata for a normal file: %s'
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)
else: else:
assert False, 'unreachable' assert False, 'unreachable'
def set_tracked(self, filename): def set_tracked(self, filename):
new = False new = False
entry = self.get(filename) entry = self.get(filename)
if entry is None: if entry is None:
self.addfile(filename, added=True) self.addfile(filename, added=True)
self._rustmap.drop_item_and_copy_source(f) self._rustmap.drop_item_and_copy_source(f)
else: else:
self._rustmap.removefile(f, in_merge=True) self._rustmap.removefile(f, in_merge=True)
return True return True
def removefile(self, *args, **kwargs): def removefile(self, *args, **kwargs):
return self._rustmap.removefile(*args, **kwargs) return self._rustmap.removefile(*args, **kwargs)
def nonnormalentries(self):
return self._rustmap.nonnormalentries()
def get(self, *args, **kwargs): def get(self, *args, **kwargs):
return self._rustmap.get(*args, **kwargs) return self._rustmap.get(*args, **kwargs)
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def debug_iter(self, all): def debug_iter(self, all):
# File doesn't exist, so the current state is empty # File doesn't exist, so the current state is empty
return b'' return b''
def setparents(self, p1, p2, fold_p2=False): def setparents(self, p1, p2, fold_p2=False):
self._parents = (p1, p2) self._parents = (p1, p2)
self._dirtyparents = True self._dirtyparents = True
copies = {} copies = {}
if fold_p2: if fold_p2:
candidatefiles = self.non_normal_or_other_parent_paths() # Collect into an intermediate list to avoid a `RuntimeError`
# exception due to mutation during iteration.
for f in candidatefiles: # TODO: move this the whole loop to Rust where `iter_mut`
s = self.get(f) # enables in-place mutation of elements of a collection while
if s is None: # iterating it, without mutating the collection itself.
continue candidatefiles = [
(f, s)
for f, s in self._rustmap.items()
if s.merged or s.from_p2
]
for f, s in candidatefiles:
# 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:
source = self.copymap.get(f) source = self.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.reset_state( self.reset_state(
f, f,
wc_tracked=True, wc_tracked=True,
def hasdir(self, d): def hasdir(self, d):
return self._rustmap.hasdir(d) return self._rustmap.hasdir(d)
@propertycache @propertycache
def identity(self): def identity(self):
self._rustmap self._rustmap
return self.identity return self.identity
@property
def nonnormalset(self):
nonnorm = self._rustmap.non_normal_entries()
return nonnorm
@propertycache
def otherparentset(self):
otherparents = self._rustmap.other_parent_entries()
return otherparents
def non_normal_or_other_parent_paths(self):
return self._rustmap.non_normal_or_other_parent_paths()
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name in self._rustmap.tracked_dirs(): for name in self._rustmap.tracked_dirs():
f[normcase(name)] = name f[normcase(name)] = name
return f return f

mercurial/pure/parsers.py

def merged_removed(self): def merged_removed(self):
"""True if the file has been removed, but was "merged" initially """True if the file has been removed, but was "merged" initially
This property seems like an abstraction leakage and should probably be This property seems like an abstraction leakage and should probably be
dealt in this class (or maybe the dirstatemap) directly. dealt in this class (or maybe the dirstatemap) directly.
""" """
return self.removed and self._merged return self.removed and self._merged
@property
def dm_nonnormal(self):
"""True is the entry is non-normal in the dirstatemap sense
There is no reason for any code, but the dirstatemap one to use this.
"""
return self.v1_state() != b'n' or self.v1_mtime() == AMBIGUOUS_TIME
@property
def dm_otherparent(self):
"""True is the entry is `otherparent` in the dirstatemap sense
There is no reason for any code, but the dirstatemap one to use this.
"""
return self.v1_size() == FROM_P2
def v1_state(self): def v1_state(self):
"""return a "state" suitable for v1 serialization""" """return a "state" suitable for v1 serialization"""
if not (self._p1_tracked or self._p2_tracked or self._wc_tracked): if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
# the object has no state to record, this is -currently- # the object has no state to record, this is -currently-
# unsupported # unsupported
raise RuntimeError('untracked item') raise RuntimeError('untracked item')
elif self.removed: elif self.removed:
return b'r' return b'r'

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::errors::HgError;
use crate::{ use crate::{
dirstate::EntryState, dirstate::EntryState,
dirstate::SIZE_FROM_OTHER_PARENT, dirstate::SIZE_FROM_OTHER_PARENT,
dirstate::SIZE_NON_NORMAL, dirstate::SIZE_NON_NORMAL,
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents,
StateMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
#[derive(Default)] #[derive(Default)]
pub struct DirstateMap { pub struct DirstateMap {
state_map: StateMap, state_map: StateMap,
pub copy_map: CopyMap, pub copy_map: CopyMap,
pub dirs: Option<DirsMultiset>, pub dirs: Option<DirsMultiset>,
pub all_dirs: Option<DirsMultiset>, pub all_dirs: Option<DirsMultiset>,
non_normal_set: Option<HashSet<HgPathBuf>>,
other_parent_set: Option<HashSet<HgPathBuf>>,
} }
/// Should only really be used in python interface code, for clarity /// Should only really be used in python interface code, for clarity
impl Deref for DirstateMap { impl Deref for DirstateMap {
type Target = StateMap; type Target = StateMap;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
&self.state_map &self.state_map
impl DirstateMap { impl DirstateMap {
pub fn new() -> Self { pub fn new() -> Self {
Self::default() Self::default()
} }
pub fn clear(&mut self) { pub fn clear(&mut self) {
self.state_map = StateMap::default(); self.state_map = StateMap::default();
self.copy_map.clear(); self.copy_map.clear();
self.non_normal_set = None;
self.other_parent_set = None;
} }
pub fn set_entry(&mut self, filename: &HgPath, entry: DirstateEntry) { pub fn set_entry(&mut self, filename: &HgPath, entry: DirstateEntry) {
self.state_map.insert(filename.to_owned(), entry); self.state_map.insert(filename.to_owned(), entry);
} }
/// Add a tracked file to the dirstate /// Add a tracked file to the dirstate
pub fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_state = self.get(filename).map(|e| e.state()); let old_state = self.get(filename).map(|e| e.state());
if old_state.is_none() || old_state == Some(EntryState::Removed) { if old_state.is_none() || old_state == Some(EntryState::Removed) {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.add_path(filename)?; dirs.add_path(filename)?;
} }
} }
if old_state.is_none() { if old_state.is_none() {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
self.state_map.insert(filename.to_owned(), entry.to_owned()); self.state_map.insert(filename.to_owned(), entry.to_owned());
if entry.is_non_normal() {
self.get_non_normal_other_parent_entries()
.0
.insert(filename.to_owned());
}
if entry.is_from_other_parent() {
self.get_non_normal_other_parent_entries()
.1
.insert(filename.to_owned());
}
Ok(()) Ok(())
} }
/// Mark a file as removed in the dirstate. /// Mark a file as removed in the dirstate.
/// ///
/// The `size` parameter is used to store sentinel values that indicate /// The `size` parameter is used to store sentinel values that indicate
/// the file's previous state. In the future, we should refactor this /// the file's previous state. In the future, we should refactor this
/// to be more explicit about what that state is. /// to be more explicit about what that state is.
// backup the previous state // backup the previous state
if old_entry.state() == EntryState::Merged { if old_entry.state() == EntryState::Merged {
size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
} else if old_entry.state() == EntryState::Normal } else if old_entry.state() == EntryState::Normal
&& old_entry.size() == SIZE_FROM_OTHER_PARENT && old_entry.size() == SIZE_FROM_OTHER_PARENT
{ {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
self.get_non_normal_other_parent_entries()
.1
.insert(filename.to_owned());
} }
} }
} }
if old_state.is_some() && old_state != Some(EntryState::Removed) { if old_state.is_some() && old_state != Some(EntryState::Removed) {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if old_state.is_none() { if old_state.is_none() {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
if size == 0 { if size == 0 {
self.copy_map.remove(filename); self.copy_map.remove(filename);
} }
self.state_map self.state_map
.insert(filename.to_owned(), DirstateEntry::new_removed(size)); .insert(filename.to_owned(), DirstateEntry::new_removed(size));
self.get_non_normal_other_parent_entries()
.0
.insert(filename.to_owned());
Ok(()) Ok(())
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_entry_and_copy_source( pub fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_state = self.get(filename).map(|e| e.state()); let old_state = self.get(filename).map(|e| e.state());
let exists = self.state_map.remove(filename).is_some(); let exists = self.state_map.remove(filename).is_some();
if exists { if exists {
if old_state != Some(EntryState::Removed) { if old_state != Some(EntryState::Removed) {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.delete_path(filename)?; all_dirs.delete_path(filename)?;
} }
} }
self.get_non_normal_other_parent_entries()
.0
.remove(filename);
self.copy_map.remove(filename); self.copy_map.remove(filename);
Ok(()) Ok(())
} }
pub fn non_normal_entries_remove(
&mut self,
key: impl AsRef<HgPath>,
) -> bool {
self.get_non_normal_other_parent_entries()
.0
.remove(key.as_ref())
}
pub fn non_normal_entries_add(&mut self, key: impl AsRef<HgPath>) {
self.get_non_normal_other_parent_entries()
.0
.insert(key.as_ref().into());
}
pub fn non_normal_entries_union(
&mut self,
other: HashSet<HgPathBuf>,
) -> Vec<HgPathBuf> {
self.get_non_normal_other_parent_entries()
.0
.union(&other)
.map(ToOwned::to_owned)
.collect()
}
pub fn get_non_normal_other_parent_entries(
&mut self,
) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {
self.set_non_normal_other_parent_entries(false);
(
self.non_normal_set.as_mut().unwrap(),
self.other_parent_set.as_mut().unwrap(),
)
}
/// Useful to get immutable references to those sets in contexts where
/// you only have an immutable reference to the `DirstateMap`, like when
/// sharing references with Python.
///
/// TODO, get rid of this along with the other "setter/getter" stuff when
/// a nice typestate plan is defined.
///
/// # Panics
///
/// Will panic if either set is `None`.
pub fn get_non_normal_other_parent_entries_panic(
&self,
) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) {
(
self.non_normal_set.as_ref().unwrap(),
self.other_parent_set.as_ref().unwrap(),
)
}
pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
if !force
&& self.non_normal_set.is_some()
&& self.other_parent_set.is_some()
{
return;
}
let mut non_normal = HashSet::new();
let mut other_parent = HashSet::new();
for (filename, entry) in self.state_map.iter() {
if entry.is_non_normal() {
non_normal.insert(filename.to_owned());
}
if entry.is_from_other_parent() {
other_parent.insert(filename.to_owned());
}
}
self.non_normal_set = Some(non_normal);
self.other_parent_set = Some(other_parent);
}
/// Both of these setters and their uses appear to be the simplest way to /// Both of these setters and their uses appear to be the simplest way to
/// emulate a Python lazy property, but it is ugly and unidiomatic. /// emulate a Python lazy property, but it is ugly and unidiomatic.
/// TODO One day, rewriting this struct using the typestate might be a /// TODO One day, rewriting this struct using the typestate might be a
/// good idea. /// good idea.
pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> { pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
if self.all_dirs.is_none() { if self.all_dirs.is_none() {
self.all_dirs = Some(DirsMultiset::from_dirstate( self.all_dirs = Some(DirsMultiset::from_dirstate(
self.state_map.iter().map(|(k, v)| Ok((k, *v))), self.state_map.iter().map(|(k, v)| Ok((k, *v))),
); );
Ok(Some(parents.clone())) Ok(Some(parents.clone()))
} }
pub fn pack( pub fn pack(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, HgError> {
let packed = pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)
pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
self.set_non_normal_other_parent_entries(true);
Ok(packed)
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test] #[test]
map.add_file( map.add_file(
HgPath::new(b"meh"), HgPath::new(b"meh"),
DirstateEntry::from_v1_data(EntryState::Normal, 1337, 1337, 1337), DirstateEntry::from_v1_data(EntryState::Normal, 1337, 1337, 1337),
) )
.unwrap(); .unwrap();
assert_eq!(1, map.len()); assert_eq!(1, map.len());
assert_eq!(0, map.get_non_normal_other_parent_entries().0.len());
assert_eq!(0, map.get_non_normal_other_parent_entries().1.len());
}
#[test]
fn test_non_normal_other_parent_entries() {
let mut map: DirstateMap = [
(b"f1", (EntryState::Removed, 1337, 1337, 1337)),
(b"f2", (EntryState::Normal, 1337, 1337, -1)),
(b"f3", (EntryState::Normal, 1337, 1337, 1337)),
(b"f4", (EntryState::Normal, 1337, -2, 1337)),
(b"f5", (EntryState::Added, 1337, 1337, 1337)),
(b"f6", (EntryState::Added, 1337, 1337, -1)),
(b"f7", (EntryState::Merged, 1337, 1337, -1)),
(b"f8", (EntryState::Merged, 1337, 1337, 1337)),
(b"f9", (EntryState::Merged, 1337, -2, 1337)),
(b"fa", (EntryState::Added, 1337, -2, 1337)),
(b"fb", (EntryState::Removed, 1337, -2, 1337)),
]
.iter()
.map(|(fname, (state, mode, size, mtime))| {
(
HgPathBuf::from_bytes(fname.as_ref()),
DirstateEntry::from_v1_data(*state, *mode, *size, *mtime),
)
})
.collect();
let mut non_normal = [
b"f1", b"f2", b"f4", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa",
b"fb",
]
.iter()
.map(|x| HgPathBuf::from_bytes(x.as_ref()))
.collect();
let mut other_parent = HashSet::new();
other_parent.insert(HgPathBuf::from_bytes(b"f4"));
let entries = map.get_non_normal_other_parent_entries();
assert_eq!(
(&mut non_normal, &mut other_parent),
(entries.0, entries.1)
);
} }
} }

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

/// ///
/// This includes marker values such as `mtime == -1`. In the future we may /// This includes marker values such as `mtime == -1`. In the future we may
/// want to not represent these cases that way in memory, but serialization /// want to not represent these cases that way in memory, but serialization
/// will need to keep the same format. /// will need to keep the same format.
pub fn v1_data(&self) -> (u8, i32, i32, i32) { pub fn v1_data(&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 is_non_normal(&self) -> bool { pub(crate) fn is_from_other_parent(&self) -> bool {
self.state() != EntryState::Normal || self.mtime() == MTIME_UNSET
}
pub fn is_from_other_parent(&self) -> bool {
self.state() == EntryState::Normal self.state() == EntryState::Normal
&& self.size() == SIZE_FROM_OTHER_PARENT && self.size() == SIZE_FROM_OTHER_PARENT
} }
// TODO: other platforms // TODO: other platforms
#[cfg(unix)] #[cfg(unix)]
pub fn mode_changed( pub fn mode_changed(
&self, &self,

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

if let NodeData::Entry(entry) = &mut node.data { if let NodeData::Entry(entry) = &mut node.data {
entry.clear_mtime(); entry.clear_mtime();
} }
} }
} }
Ok(()) Ok(())
} }
/// Return a faillilble iterator of full paths of nodes that have an
/// `entry` for which the given `predicate` returns true.
///
/// Fallibility means that each iterator item is a `Result`, which may
/// indicate a parse error of the on-disk dirstate-v2 format. Such errors
/// should only happen if Mercurial is buggy or a repository is corrupted.
fn filter_full_paths<'tree>(
&'tree self,
predicate: impl Fn(&DirstateEntry) -> bool + 'tree,
) -> impl Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + 'tree
{
filter_map_results(self.iter_nodes(), move |node| {
if let Some(entry) = node.entry()? {
if predicate(&entry) {
return Ok(Some(node.full_path(self.on_disk)?));
}
}
Ok(None)
})
}
fn count_dropped_path(unreachable_bytes: &mut u32, path: &Cow<HgPath>) { fn count_dropped_path(unreachable_bytes: &mut u32, path: &Cow<HgPath>) {
if let Cow::Borrowed(path) = path { if let Cow::Borrowed(path) = path {
*unreachable_bytes += path.len() as u32 *unreachable_bytes += path.len() as u32
} }
} }
} }
/// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s. /// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s.
self.nodes_with_copy_source_count -= 1 self.nodes_with_copy_source_count -= 1
} }
} else { } else {
debug_assert!(!was_tracked); debug_assert!(!was_tracked);
} }
Ok(()) Ok(())
} }
fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
Ok(if let Some(node) = self.get_node(key)? {
node.entry()?.map_or(false, |entry| entry.is_non_normal())
} else {
false
})
}
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
// Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date.
if let Ok(Some(v)) = self.get(key) {
return v.is_non_normal();
}
false
}
fn non_normal_entries_add(&mut self, _key: &HgPath) {
// Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" set that need to be kept up to date
}
fn non_normal_or_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{
Box::new(self.filter_full_paths(|entry| {
entry.is_non_normal() || entry.is_from_other_parent()
}))
}
fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
// Do nothing, this `DirstateMap` does not have a separate "non normal
// entries" and "from other parent" sets that need to be recomputed
}
fn iter_non_normal_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.iter_non_normal_paths_panic()
}
fn iter_non_normal_paths_panic(
&self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
Box::new(self.filter_full_paths(|entry| entry.is_non_normal()))
}
fn iter_other_parent_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
Box::new(self.filter_full_paths(|entry| entry.is_from_other_parent()))
}
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
if let Some(node) = self.get_node(directory)? { if let Some(node) = self.get_node(directory)? {
// A node without a `DirstateEntry` was created to hold child // A node without a `DirstateEntry` was created to hold child
// nodes, and is therefore a directory. // nodes, and is therefore a directory.
let state = node.state()?; let state = node.state()?;

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

/// Drop information about this file from the map if any. /// Drop information about this file from the map if any.
/// ///
/// `get` will now return `None` for this filename. /// `get` will now return `None` for this filename.
fn drop_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError>; ) -> Result<(), DirstateError>;
/// Return whether the map has an "non-normal" entry for the given
/// filename. That is, any entry with a `state` other than
/// `EntryState::Normal` or with an ambiguous `mtime`.
fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError>;
/// Mark the given path as "normal" file. This is only relevant in the flat
/// dirstate map where there is a separate `HashSet` that needs to be kept
/// up to date.
/// Returns whether the key was present in the set.
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;
/// Mark the given path as "non-normal" file.
/// This is only relevant in the flat dirstate map where there is a
/// separate `HashSet` that needs to be kept up to date.
fn non_normal_entries_add(&mut self, key: &HgPath);
/// Return an iterator of paths whose respective entry are either
/// "non-normal" (see `non_normal_entries_contains`) or "from other
/// parent".
///
/// If that information is cached, create the cache as needed.
///
/// "From other parent" is defined as `state == Normal && size == -2`.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn non_normal_or_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>;
/// Create the cache for `non_normal_or_other_parent_paths` if needed.
///
/// If `force` is true, the cache is re-created even if it already exists.
fn set_non_normal_other_parent_entries(&mut self, force: bool);
/// Return an iterator of paths whose respective entry are "non-normal"
/// (see `non_normal_entries_contains`).
///
/// If that information is cached, create the cache as needed.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn iter_non_normal_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
/// Same as `iter_non_normal_paths`, but takes `&self` instead of `&mut
/// self`.
///
/// Panics if a cache is necessary but does not exist yet.
fn iter_non_normal_paths_panic(
&self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
/// Return an iterator of paths whose respective entry are "from other
/// parent".
///
/// If that information is cached, create the cache as needed.
///
/// "From other parent" is defined as `state == Normal && size == -2`.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn iter_other_parent_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
>;
/// Returns whether the sub-tree rooted at the given directory contains any /// Returns whether the sub-tree rooted at the given directory contains any
/// tracked file. /// tracked file.
/// ///
/// A file is tracked if it has a `state` other than `EntryState::Removed`. /// A file is tracked if it has a `state` other than `EntryState::Removed`.
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError>; ) -> Result<bool, DirstateError>;
fn drop_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.drop_entry_and_copy_source(filename) self.drop_entry_and_copy_source(filename)
} }
fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries();
Ok(non_normal.contains(key))
}
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
self.non_normal_entries_remove(key)
}
fn non_normal_entries_add(&mut self, key: &HgPath) {
self.non_normal_entries_add(key)
}
fn non_normal_or_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{
let (non_normal, other_parent) =
self.get_non_normal_other_parent_entries();
Box::new(non_normal.union(other_parent).map(|p| Ok(&**p)))
}
fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.set_non_normal_other_parent_entries(force)
}
fn iter_non_normal_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries();
Box::new(non_normal.iter().map(|p| Ok(&**p)))
}
fn iter_non_normal_paths_panic(
&self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (non_normal, _other_parent) =
self.get_non_normal_other_parent_entries_panic();
Box::new(non_normal.iter().map(|p| Ok(&**p)))
}
fn iter_other_parent_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
let (_non_normal, other_parent) =
self.get_non_normal_other_parent_entries();
Box::new(other_parent.iter().map(|p| Ok(&**p)))
}
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
self.has_tracked_dir(directory) self.has_tracked_dir(directory)
} }
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> { fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {
self.has_dir(directory) self.has_dir(directory)
} }
fn pack_v1( fn pack_v1(
&mut self, &mut self,
parents: DirstateParents, parents: DirstateParents,
now: Timestamp, now: Timestamp,
) -> Result<Vec<u8>, DirstateError> { ) -> Result<Vec<u8>, DirstateError> {
self.pack(parents, now) Ok(self.pack(parents, now)?)
} }
fn pack_v2( fn pack_v2(
&mut self, &mut self,
_now: Timestamp, _now: Timestamp,
_can_append: bool, _can_append: bool,
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> { ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
panic!( panic!(

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

fn drop_entry_and_copy_source( fn drop_entry_and_copy_source(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().drop_entry_and_copy_source(filename) self.get_mut().drop_entry_and_copy_source(filename)
} }
fn non_normal_entries_contains(
&mut self,
key: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
self.get_mut().non_normal_entries_contains(key)
}
fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
self.get_mut().non_normal_entries_remove(key)
}
fn non_normal_entries_add(&mut self, key: &HgPath) {
self.get_mut().non_normal_entries_add(key)
}
fn non_normal_or_other_parent_paths(
&mut self,
) -> Box<dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + '_>
{
self.get_mut().non_normal_or_other_parent_paths()
}
fn set_non_normal_other_parent_entries(&mut self, force: bool) {
self.get_mut().set_non_normal_other_parent_entries(force)
}
fn iter_non_normal_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get_mut().iter_non_normal_paths()
}
fn iter_non_normal_paths_panic(
&self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get().iter_non_normal_paths_panic()
}
fn iter_other_parent_paths(
&mut self,
) -> Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + Send + '_,
> {
self.get_mut().iter_other_parent_paths()
}
fn has_tracked_dir( fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
self.get_mut().has_tracked_dir(directory) self.get_mut().has_tracked_dir(directory)
} }
fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> { fn has_dir(&mut self, directory: &HgPath) -> Result<bool, DirstateError> {

rust/hg-cpython/src/dirstate.rs

// dirstate.rs // dirstate.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate` module provided by the //! Bindings for the `hg::dirstate` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dirstate` //! From Python, this will be seen as `mercurial.rustext.dirstate`
mod copymap; mod copymap;
mod dirs_multiset; mod dirs_multiset;
mod dirstate_map; mod dirstate_map;
mod item; mod item;
mod non_normal_entries;
mod status; mod status;
use self::item::DirstateItem; use self::item::DirstateItem;
use crate::{ use crate::{
dirstate::{ dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}, },
exceptions, exceptions,
}; };

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::dirstate_map` file provided by the //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::{RefCell, RefMut}; use std::cell::{RefCell, RefMut};
use std::convert::TryInto; use std::convert::TryInto;
use cpython::{ use cpython::{
exc, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, PyNone, PyObject, exc, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, PyNone, PyObject,
PyResult, PySet, PyString, Python, PythonObject, ToPyObject, PyResult, Python, PythonObject, ToPyObject, UnsafePyLeaked,
UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::item::DirstateItem, dirstate::item::DirstateItem,
dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator,
},
pybytes_deref::PyBytesDeref, pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap, dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError, dirstate_tree::on_disk::DirstateV2ParseError,
dirstate_tree::owning::OwningDirstateMap, dirstate_tree::owning::OwningDirstateMap,
) -> PyResult<PyNone> { ) -> PyResult<PyNone> {
self.inner(py) self.inner(py)
.borrow_mut() .borrow_mut()
.drop_entry_and_copy_source(HgPath::new(f.data(py))) .drop_entry_and_copy_source(HgPath::new(f.data(py)))
.map_err(|e |dirstate_error(py, e))?; .map_err(|e |dirstate_error(py, e))?;
Ok(PyNone) Ok(PyNone)
} }
def other_parent_entries(&self) -> PyResult<PyObject> {
let mut inner_shared = self.inner(py).borrow_mut();
let set = PySet::empty(py)?;
for path in inner_shared.iter_other_parent_paths() {
let path = path.map_err(|e| v2_error(py, e))?;
set.add(py, PyBytes::new(py, path.as_bytes()))?;
}
Ok(set.into_object())
}
def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
NonNormalEntries::from_inner(py, self.clone_ref(py))
}
def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
let key = key.extract::<PyBytes>(py)?;
self.inner(py)
.borrow_mut()
.non_normal_entries_contains(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))
}
def non_normal_entries_display(&self) -> PyResult<PyString> {
let mut inner = self.inner(py).borrow_mut();
let paths = inner
.iter_non_normal_paths()
.collect::<Result<Vec<_>, _>>()
.map_err(|e| v2_error(py, e))?;
let formatted = format!("NonNormalEntries: {}", hg::utils::join_display(paths, ", "));
Ok(PyString::new(py, &formatted))
}
def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?;
let key = key.data(py);
let was_present = self
.inner(py)
.borrow_mut()
.non_normal_entries_remove(HgPath::new(key));
if !was_present {
let msg = String::from_utf8_lossy(key);
Err(PyErr::new::<exc::KeyError, _>(py, msg))
} else {
Ok(py.None())
}
}
def non_normal_entries_discard(&self, key: PyObject) -> PyResult<PyObject>
{
let key = key.extract::<PyBytes>(py)?;
self
.inner(py)
.borrow_mut()
.non_normal_entries_remove(HgPath::new(key.data(py)));
Ok(py.None())
}
def non_normal_entries_add(&self, key: PyObject) -> PyResult<PyObject> {
let key = key.extract::<PyBytes>(py)?;
self
.inner(py)
.borrow_mut()
.non_normal_entries_add(HgPath::new(key.data(py)));
Ok(py.None())
}
def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
let mut inner = self.inner(py).borrow_mut();
let ret = PyList::new(py, &[]);
for filename in inner.non_normal_or_other_parent_paths() {
let filename = filename.map_err(|e| v2_error(py, e))?;
let as_pystring = PyBytes::new(py, filename.as_bytes());
ret.append(py, as_pystring.into_object());
}
Ok(ret)
}
def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {
// Make sure the sets are defined before we no longer have a mutable
// reference to the dmap.
self.inner(py)
.borrow_mut()
.set_non_normal_other_parent_entries(false);
let leaked_ref = self.inner(py).leak_immutable();
NonNormalEntriesIterator::from_inner(py, unsafe {
leaked_ref.map(py, |o| {
o.iter_non_normal_paths_panic()
})
})
}
def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> { def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
let d = d.extract::<PyBytes>(py)?; let d = d.extract::<PyBytes>(py)?;
Ok(self.inner(py).borrow_mut() Ok(self.inner(py).borrow_mut()
.has_tracked_dir(HgPath::new(d.data(py))) .has_tracked_dir(HgPath::new(d.data(py)))
.map_err(|e| { .map_err(|e| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})? })?
.to_py_object(py)) .to_py_object(py))

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

Ok(self.entry(py).get().merged_removed()) Ok(self.entry(py).get().merged_removed())
} }
@property @property
def from_p2_removed(&self) -> PyResult<bool> { def from_p2_removed(&self) -> PyResult<bool> {
Ok(self.entry(py).get().from_p2_removed()) Ok(self.entry(py).get().from_p2_removed())
} }
@property
def dm_nonnormal(&self) -> PyResult<bool> {
Ok(self.entry(py).get().is_non_normal())
}
@property
def dm_otherparent(&self) -> PyResult<bool> {
Ok(self.entry(py).get().is_from_other_parent())
}
def v1_state(&self) -> PyResult<PyBytes> { def v1_state(&self) -> PyResult<PyBytes> {
let (state, _mode, _size, _mtime) = self.entry(py).get().v1_data(); let (state, _mode, _size, _mtime) = self.entry(py).get().v1_data();
let state_byte: u8 = state.into(); let state_byte: u8 = state.into();
Ok(PyBytes::new(py, &[state_byte])) Ok(PyBytes::new(py, &[state_byte]))
} }
def v1_mode(&self) -> PyResult<i32> { def v1_mode(&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();

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

  • This file was deleted.
// non_normal_other_parent_entries.rs
//
// Copyright 2020 Raphaël Gomès <rgomes@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use cpython::{
exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,
PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked,
};
use crate::dirstate::dirstate_map::v2_error;
use crate::dirstate::DirstateMap;
use hg::dirstate_tree::on_disk::DirstateV2ParseError;
use hg::utils::hg_path::HgPath;
use std::cell::RefCell;
py_class!(pub class NonNormalEntries |py| {
data dmap: DirstateMap;
def __contains__(&self, key: PyObject) -> PyResult<bool> {
self.dmap(py).non_normal_entries_contains(py, key)
}
def remove(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_remove(py, key)
}
def add(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_add(py, key)
}
def discard(&self, key: PyObject) -> PyResult<PyObject> {
self.dmap(py).non_normal_entries_discard(py, key)
}
def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> {
match op {
CompareOp::Eq => self.is_equal_to(py, other),
CompareOp::Ne => Ok(!self.is_equal_to(py, other)?),
_ => Err(PyErr::new::<NotImplementedError, _>(py, ""))
}
}
def __repr__(&self) -> PyResult<PyString> {
self.dmap(py).non_normal_entries_display(py)
}
def __iter__(&self) -> PyResult<NonNormalEntriesIterator> {
self.dmap(py).non_normal_entries_iter(py)
}
});
impl NonNormalEntries {
pub fn from_inner(py: Python, dm: DirstateMap) -> PyResult<Self> {
Self::create_instance(py, dm)
}
fn is_equal_to(&self, py: Python, other: PyObject) -> PyResult<bool> {
for item in other.iter(py)? {
if !self.dmap(py).non_normal_entries_contains(py, item?)? {
return Ok(false);
}
}
Ok(true)
}
fn translate_key(
py: Python,
key: Result<&HgPath, DirstateV2ParseError>,
) -> PyResult<Option<PyBytes>> {
let key = key.map_err(|e| v2_error(py, e))?;
Ok(Some(PyBytes::new(py, key.as_bytes())))
}
}
type NonNormalEntriesIter<'a> = Box<
dyn Iterator<Item = Result<&'a HgPath, DirstateV2ParseError>> + Send + 'a,
>;
py_shared_iterator!(
NonNormalEntriesIterator,
UnsafePyLeaked<NonNormalEntriesIter<'static>>,
NonNormalEntries::translate_key,
Option<PyBytes>
);

tests/test-dirstate-nonnormalset.t

  • This file was deleted.
$ cat >> $HGRCPATH << EOF
> [command-templates]
> log="{rev}:{node|short} ({phase}) [{tags} {bookmarks}] {desc|firstline}\n"
> [extensions]
> dirstateparanoidcheck = $TESTDIR/../contrib/dirstatenonnormalcheck.py
> [experimental]
> nonnormalparanoidcheck = True
> [devel]
> all-warnings=True
> EOF
$ mkcommit() {
> echo "$1" > "$1"
> hg add "$1"
> hg ci -m "add $1"
> }
$ hg init testrepo
$ cd testrepo
$ mkcommit a
$ mkcommit b
$ mkcommit c
$ hg status
rust/hg-cpython/src/dirstate/non_normal_entries.rs