This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10982

dirstate-item: rename the class to DirstateItem
ClosedPublic

Authored by marmoute on Jul 4 2021, 5:52 PM.

Details

Reviewers
durin42
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHG84391ddf4c78: dirstate-item: rename the class to DirstateItem
Summary

The object is no longer a tuple, so it seems clearer to rename it (and its
associated method)

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.Jul 4 2021, 5:52 PM
SimonSapin accepted this revision.Jul 5 2021, 1:29 AM
baymax updated this revision to Diff 28884.Jul 6 2021, 2:09 PM

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

pulkit accepted this revision.Jul 6 2021, 3:13 PM
This revision is now accepted and ready to land.Jul 6 2021, 3:13 PM
marmoute added a commit: rHG84391ddf4c78: dirstate-item: rename the class to DirstateItem.Jul 6 2021, 3:42 PM
Closed by commit rHG84391ddf4c78: dirstate-item: rename the class to DirstateItem (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28920

hgext/git/dirstate.py

# TODO how on earth do we find p2 if a merge is in flight? # TODO how on earth do we find p2 if a merge is in flight?
return self.p1(), sha1nodeconstants.nullid return self.p1(), sha1nodeconstants.nullid
def __iter__(self): def __iter__(self):
return (pycompat.fsencode(f.path) for f in self.git.index) return (pycompat.fsencode(f.path) for f in self.git.index)
def items(self): def items(self):
for ie in self.git.index: for ie in self.git.index:
yield ie.path, None # value should be a dirstatetuple yield ie.path, None # value should be a DirstateItem
# py2,3 compat forward # py2,3 compat forward
iteritems = items iteritems = items
def __getitem__(self, filename): def __getitem__(self, filename):
try: try:
gs = self.git.status_file(filename) gs = self.git.status_file(filename)
except KeyError: except KeyError:

mercurial/cext/charencode.c

} }
PyObject *make_file_foldmap(PyObject *self, PyObject *args) PyObject *make_file_foldmap(PyObject *self, PyObject *args)
{ {
PyObject *dmap, *spec_obj, *normcase_fallback; PyObject *dmap, *spec_obj, *normcase_fallback;
PyObject *file_foldmap = NULL; PyObject *file_foldmap = NULL;
enum normcase_spec spec; enum normcase_spec spec;
PyObject *k, *v; PyObject *k, *v;
dirstateTupleObject *tuple; dirstateItemObject *tuple;
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
const char *table; const char *table;
if (!PyArg_ParseTuple(args, "O!O!O!:make_file_foldmap", &PyDict_Type, if (!PyArg_ParseTuple(args, "O!O!O!:make_file_foldmap", &PyDict_Type,
&dmap, &PyInt_Type, &spec_obj, &PyFunction_Type, &dmap, &PyInt_Type, &spec_obj, &PyFunction_Type,
&normcase_fallback)) { &normcase_fallback)) {
goto quit; goto quit;
} }
while (PyDict_Next(dmap, &pos, &k, &v)) { while (PyDict_Next(dmap, &pos, &k, &v)) {
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto quit; goto quit;
} }
tuple = (dirstateTupleObject *)v; tuple = (dirstateItemObject *)v;
if (tuple->state != 'r') { if (tuple->state != 'r') {
PyObject *normed; PyObject *normed;
if (table != NULL) { if (table != NULL) {
normed = _asciitransform(k, table, normed = _asciitransform(k, table,
normcase_fallback); normcase_fallback);
} else { } else {
normed = PyObject_CallFunctionObjArgs( normed = PyObject_CallFunctionObjArgs(
normcase_fallback, k, NULL); normcase_fallback, k, NULL);

mercurial/cext/dirs.c

return -1; return -1;
} }
if (skipchar) { if (skipchar) {
if (!dirstate_tuple_check(value)) { if (!dirstate_tuple_check(value)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
return -1; return -1;
} }
if (((dirstateTupleObject *)value)->state == skipchar) if (((dirstateItemObject *)value)->state == skipchar)
continue; continue;
} }
if (_addpath(dirs, key) == -1) if (_addpath(dirs, key) == -1)
return -1; return -1;
} }
return 0; return 0;

mercurial/cext/parsers.c

if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) { if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) {
return NULL; return NULL;
} }
return _dict_new_presized(expected_size); return _dict_new_presized(expected_size);
} }
static inline dirstateTupleObject *make_dirstate_tuple(char state, int mode, static inline dirstateItemObject *make_dirstate_item(char state, int mode,
int size, int mtime) int size, int mtime)
{ {
dirstateTupleObject *t = dirstateItemObject *t =
PyObject_New(dirstateTupleObject, &dirstateTupleType); PyObject_New(dirstateItemObject, &dirstateItemType);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = state; t->state = state;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return t; return t;
} }
static PyObject *dirstate_tuple_new(PyTypeObject *subtype, PyObject *args, static PyObject *dirstate_item_new(PyTypeObject *subtype, PyObject *args,
PyObject *kwds) PyObject *kwds)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_tuple is immutable. */ * dirstate_item is immutable. */
dirstateTupleObject *t; dirstateItemObject *t;
char state; char state;
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) { if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
return NULL; return NULL;
} }
t = (dirstateTupleObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->state = state; t->state = state;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return (PyObject *)t; return (PyObject *)t;
} }
static void dirstate_tuple_dealloc(PyObject *o) static void dirstate_item_dealloc(PyObject *o)
{ {
PyObject_Del(o); PyObject_Del(o);
} }
static Py_ssize_t dirstate_tuple_length(PyObject *o) static Py_ssize_t dirstate_item_length(PyObject *o)
{ {
return 4; return 4;
} }
static PyObject *dirstate_tuple_item(PyObject *o, Py_ssize_t i) static PyObject *dirstate_item_item(PyObject *o, Py_ssize_t i)
{ {
dirstateTupleObject *t = (dirstateTupleObject *)o; dirstateItemObject *t = (dirstateItemObject *)o;
switch (i) { switch (i) {
case 0: case 0:
return PyBytes_FromStringAndSize(&t->state, 1); return PyBytes_FromStringAndSize(&t->state, 1);
case 1: case 1:
return PyInt_FromLong(t->mode); return PyInt_FromLong(t->mode);
case 2: case 2:
return PyInt_FromLong(t->size); return PyInt_FromLong(t->size);
case 3: case 3:
return PyInt_FromLong(t->mtime); return PyInt_FromLong(t->mtime);
default: default:
PyErr_SetString(PyExc_IndexError, "index out of range"); PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL; return NULL;
} }
} }
static PySequenceMethods dirstate_tuple_sq = { static PySequenceMethods dirstate_item_sq = {
dirstate_tuple_length, /* sq_length */ dirstate_item_length, /* sq_length */
0, /* sq_concat */ 0, /* sq_concat */
0, /* sq_repeat */ 0, /* sq_repeat */
dirstate_tuple_item, /* sq_item */ dirstate_item_item, /* sq_item */
0, /* sq_ass_item */ 0, /* sq_ass_item */
0, /* sq_contains */ 0, /* sq_contains */
0, /* sq_inplace_concat */ 0, /* sq_inplace_concat */
0 /* sq_inplace_repeat */ 0 /* sq_inplace_repeat */
}; };
static PyObject *dirstatetuple_v1_state(dirstateTupleObject *self) static PyObject *dirstate_item_v1_state(dirstateItemObject *self)
{ {
return PyBytes_FromStringAndSize(&self->state, 1); return PyBytes_FromStringAndSize(&self->state, 1);
}; };
static PyObject *dirstatetuple_v1_mode(dirstateTupleObject *self) static PyObject *dirstate_item_v1_mode(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->mode); return PyInt_FromLong(self->mode);
}; };
static PyObject *dirstatetuple_v1_size(dirstateTupleObject *self) static PyObject *dirstate_item_v1_size(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->size); return PyInt_FromLong(self->size);
}; };
static PyObject *dirstatetuple_v1_mtime(dirstateTupleObject *self) static PyObject *dirstate_item_v1_mtime(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->mtime); return PyInt_FromLong(self->mtime);
}; };
static PyObject *dirstatetuple_need_delay(dirstateTupleObject *self, static PyObject *dirstate_item_need_delay(dirstateItemObject *self,
PyObject *value) PyObject *value)
{ {
long now; long now;
if (!pylong_to_long(value, &now)) { if (!pylong_to_long(value, &now)) {
return NULL; return NULL;
} }
if (self->state == 'n' && self->mtime == now) { if (self->state == 'n' && self->mtime == now) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyMethodDef dirstatetuple_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v1_state", (PyCFunction)dirstatetuple_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)dirstatetuple_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)dirstatetuple_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)dirstatetuple_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)dirstatetuple_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"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstatetuple_get_mode(dirstateTupleObject *self) static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->mode); return PyInt_FromLong(self->mode);
}; };
static PyObject *dirstatetuple_get_size(dirstateTupleObject *self) static PyObject *dirstate_item_get_size(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->size); return PyInt_FromLong(self->size);
}; };
static PyObject *dirstatetuple_get_mtime(dirstateTupleObject *self) static PyObject *dirstate_item_get_mtime(dirstateItemObject *self)
{ {
return PyInt_FromLong(self->mtime); return PyInt_FromLong(self->mtime);
}; };
static PyObject *dirstatetuple_get_state(dirstateTupleObject *self) static PyObject *dirstate_item_get_state(dirstateItemObject *self)
{ {
return PyBytes_FromStringAndSize(&self->state, 1); return PyBytes_FromStringAndSize(&self->state, 1);
}; };
static PyObject *dirstatetuple_get_tracked(dirstateTupleObject *self) static PyObject *dirstate_item_get_tracked(dirstateItemObject *self)
{ {
if (self->state == 'a' || self->state == 'm' || self->state == 'n') { if (self->state == 'a' || self->state == 'm' || self->state == 'n') {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_added(dirstateTupleObject *self) static PyObject *dirstate_item_get_added(dirstateItemObject *self)
{ {
if (self->state == 'a') { if (self->state == 'a') {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_merged(dirstateTupleObject *self) static PyObject *dirstate_item_get_merged(dirstateItemObject *self)
{ {
if (self->state == 'm') { if (self->state == 'm') {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_merged_removed(dirstateTupleObject *self) static PyObject *dirstate_item_get_merged_removed(dirstateItemObject *self)
{ {
if (self->state == 'r' && self->size == dirstate_v1_nonnormal) { if (self->state == 'r' && self->size == dirstate_v1_nonnormal) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_from_p2(dirstateTupleObject *self) static PyObject *dirstate_item_get_from_p2(dirstateItemObject *self)
{ {
if (self->state == 'n' && self->size == dirstate_v1_from_p2) { if (self->state == 'n' && self->size == dirstate_v1_from_p2) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_from_p2_removed(dirstateTupleObject *self) static PyObject *dirstate_item_get_from_p2_removed(dirstateItemObject *self)
{ {
if (self->state == 'r' && self->size == dirstate_v1_from_p2) { if (self->state == 'r' && self->size == dirstate_v1_from_p2) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstatetuple_get_removed(dirstateTupleObject *self) static PyObject *dirstate_item_get_removed(dirstateItemObject *self)
{ {
if (self->state == 'r') { if (self->state == 'r') {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyGetSetDef dirstatetuple_getset[] = { static PyGetSetDef dirstate_item_getset[] = {
{"mode", (getter)dirstatetuple_get_mode, NULL, "mode", NULL}, {"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
{"size", (getter)dirstatetuple_get_size, NULL, "size", NULL}, {"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
{"mtime", (getter)dirstatetuple_get_mtime, NULL, "mtime", NULL}, {"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
{"state", (getter)dirstatetuple_get_state, NULL, "state", NULL}, {"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
{"tracked", (getter)dirstatetuple_get_tracked, NULL, "tracked", NULL}, {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
{"added", (getter)dirstatetuple_get_added, NULL, "added", NULL}, {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
{"merged_removed", (getter)dirstatetuple_get_merged_removed, NULL, {"merged_removed", (getter)dirstate_item_get_merged_removed, NULL,
"merged_removed", NULL}, "merged_removed", NULL},
{"merged", (getter)dirstatetuple_get_merged, NULL, "merged", NULL}, {"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
{"from_p2_removed", (getter)dirstatetuple_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)dirstatetuple_get_from_p2, NULL, "from_p2", NULL}, {"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
{"removed", (getter)dirstatetuple_get_removed, NULL, "removed", NULL}, {"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
PyTypeObject dirstateTupleType = { PyTypeObject dirstateItemType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"dirstate_tuple", /* tp_name */ "dirstate_tuple", /* tp_name */
sizeof(dirstateTupleObject), /* tp_basicsize */ sizeof(dirstateItemObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)dirstate_tuple_dealloc, /* tp_dealloc */ (destructor)dirstate_item_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_setattr */ 0, /* tp_setattr */
0, /* tp_compare */ 0, /* tp_compare */
0, /* tp_repr */ 0, /* tp_repr */
0, /* tp_as_number */ 0, /* tp_as_number */
&dirstate_tuple_sq, /* tp_as_sequence */ &dirstate_item_sq, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
0, /* tp_hash */ 0, /* tp_hash */
0, /* tp_call */ 0, /* tp_call */
0, /* tp_str */ 0, /* tp_str */
0, /* tp_getattro */ 0, /* tp_getattro */
0, /* tp_setattro */ 0, /* tp_setattro */
0, /* tp_as_buffer */ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */ Py_TPFLAGS_DEFAULT, /* tp_flags */
"dirstate tuple", /* tp_doc */ "dirstate tuple", /* tp_doc */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
dirstatetuple_methods, /* tp_methods */ dirstate_item_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
dirstatetuple_getset, /* tp_getset */ dirstate_item_getset, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
0, /* tp_init */ 0, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
dirstate_tuple_new, /* tp_new */ dirstate_item_new, /* tp_new */
}; };
static PyObject *parse_dirstate(PyObject *self, PyObject *args) static PyObject *parse_dirstate(PyObject *self, PyObject *args)
{ {
PyObject *dmap, *cmap, *parents = NULL, *ret = NULL; PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;
PyObject *fname = NULL, *cname = NULL, *entry = NULL; PyObject *fname = NULL, *cname = NULL, *entry = NULL;
char state, *cur, *str, *cpos; char state, *cur, *str, *cpos;
int mode, size, mtime; int mode, size, mtime;
cur += 17; cur += 17;
if (flen > len - pos) { if (flen > len - pos) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"overflow in dirstate"); "overflow in dirstate");
goto quit; goto quit;
} }
entry = entry =
(PyObject *)make_dirstate_tuple(state, mode, size, mtime); (PyObject *)make_dirstate_item(state, mode, size, mtime);
cpos = memchr(cur, 0, flen); cpos = memchr(cur, 0, flen);
if (cpos) { if (cpos) {
fname = PyBytes_FromStringAndSize(cur, cpos - cur); fname = PyBytes_FromStringAndSize(cur, cpos - cur);
cname = PyBytes_FromStringAndSize( cname = PyBytes_FromStringAndSize(
cpos + 1, flen - (cpos - cur) - 1); cpos + 1, flen - (cpos - cur) - 1);
if (!fname || !cname || if (!fname || !cname ||
PyDict_SetItem(cmap, fname, cname) == -1 || PyDict_SetItem(cmap, fname, cname) == -1 ||
PyDict_SetItem(dmap, fname, entry) == -1) { PyDict_SetItem(dmap, fname, entry) == -1) {
otherpset = PySet_New(NULL); otherpset = PySet_New(NULL);
if (otherpset == NULL) { if (otherpset == NULL) {
goto bail; goto bail;
} }
pos = 0; pos = 0;
while (PyDict_Next(dmap, &pos, &fname, &v)) { while (PyDict_Next(dmap, &pos, &fname, &v)) {
dirstateTupleObject *t; dirstateItemObject *t;
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto bail; goto bail;
} }
t = (dirstateTupleObject *)v; t = (dirstateItemObject *)v;
if (t->state == 'n' && t->size == -2) { if (t->state == 'n' && t->size == -2) {
if (PySet_Add(otherpset, fname) == -1) { if (PySet_Add(otherpset, fname) == -1) {
goto bail; goto bail;
} }
} }
if (t->state == 'n' && t->mtime != -1) { if (t->state == 'n' && t->mtime != -1) {
if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) { if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash"); PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
goto bail; goto bail;
} }
memcpy(p, s, l); memcpy(p, s, l);
p += 20; p += 20;
for (pos = 0; PyDict_Next(map, &pos, &k, &v);) { for (pos = 0; PyDict_Next(map, &pos, &k, &v);) {
dirstateTupleObject *tuple; dirstateItemObject *tuple;
char state; char state;
int mode, size, mtime; int mode, size, mtime;
Py_ssize_t len, l; Py_ssize_t len, l;
PyObject *o; PyObject *o;
char *t; char *t;
if (!dirstate_tuple_check(v)) { if (!dirstate_tuple_check(v)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
goto bail; goto bail;
} }
tuple = (dirstateTupleObject *)v; tuple = (dirstateItemObject *)v;
state = tuple->state; state = tuple->state;
mode = tuple->mode; mode = tuple->mode;
size = tuple->size; size = tuple->size;
mtime = tuple->mtime; mtime = tuple->mtime;
if (state == 'n' && mtime == now) { if (state == 'n' && mtime == now) {
/* See pure/parsers.py:pack_dirstate for why we do /* See pure/parsers.py:pack_dirstate for why we do
* this. */ * this. */
mtime = -1; mtime = -1;
mtime_unset = (PyObject *)make_dirstate_tuple( mtime_unset = (PyObject *)make_dirstate_item(
state, mode, size, mtime); state, mode, size, mtime);
if (!mtime_unset) { if (!mtime_unset) {
goto bail; goto bail;
} }
if (PyDict_SetItem(map, k, mtime_unset) == -1) { if (PyDict_SetItem(map, k, mtime_unset) == -1) {
goto bail; goto bail;
} }
Py_DECREF(mtime_unset); Py_DECREF(mtime_unset);
* should not have this module constant. */ * should not have this module constant. */
PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext); PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
dirs_module_init(mod); dirs_module_init(mod);
manifest_module_init(mod); manifest_module_init(mod);
revlog_module_init(mod); revlog_module_init(mod);
capsule = PyCapsule_New( capsule = PyCapsule_New(
make_dirstate_tuple, make_dirstate_item,
"mercurial.cext.parsers.make_dirstate_tuple_CAPI", NULL); "mercurial.cext.parsers.make_dirstate_item_CAPI", NULL);
if (capsule != NULL) if (capsule != NULL)
PyModule_AddObject(mod, "make_dirstate_tuple_CAPI", capsule); PyModule_AddObject(mod, "make_dirstate_item_CAPI", capsule);
if (PyType_Ready(&dirstateTupleType) < 0) { if (PyType_Ready(&dirstateItemType) < 0) {
return; return;
} }
Py_INCREF(&dirstateTupleType); Py_INCREF(&dirstateItemType);
PyModule_AddObject(mod, "dirstatetuple", PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType);
(PyObject *)&dirstateTupleType);
} }
static int check_python_version(void) static int check_python_version(void)
{ {
PyObject *sys = PyImport_ImportModule("sys"), *ver; PyObject *sys = PyImport_ImportModule("sys"), *ver;
long hexversion; long hexversion;
if (!sys) { if (!sys) {
return -1; return -1;

mercurial/cext/parsers.pyi

from typing import ( from typing import (
Callable, Callable,
Dict, Dict,
Iterator, Iterator,
List, List,
Optional, Optional,
Set, Set,
Tuple, Tuple,
Union, Union,
) )
version: int version: int
versionerrortext: str versionerrortext: str
class dirstatetuple: class DirstateItem:
__doc__: str __doc__: str
def __len__(self) -> int: ... def __len__(self) -> int: ...
def __getitem__(self, key: int) -> Union[bytes, int]: ... def __getitem__(self, key: int) -> Union[bytes, int]: ...
# From dirs.c # From dirs.c
class dirs: class dirs:

mercurial/cext/util.h

/* clang-format off */ /* clang-format off */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
char state; char state;
int mode; int mode;
int size; int size;
int mtime; int mtime;
} dirstateTupleObject; } dirstateItemObject;
/* clang-format on */ /* clang-format on */
extern PyTypeObject dirstateTupleType; extern PyTypeObject dirstateItemType;
#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateTupleType) #define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType)
#ifndef MIN #ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b)) #define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif #endif
/* VC9 doesn't include bool and lacks stdbool.h based on my searching */ /* VC9 doesn't include bool and lacks stdbool.h based on my searching */
#if defined(_MSC_VER) || __STDC_VERSION__ < 199901L #if defined(_MSC_VER) || __STDC_VERSION__ < 199901L
#define true 1 #define true 1
#define false 0 #define false 0

mercurial/dirstate.py

rustmod = policy.importrust('dirstate') rustmod = policy.importrust('dirstate')
SUPPORTS_DIRSTATE_V2 = rustmod is not None SUPPORTS_DIRSTATE_V2 = rustmod is not None
propertycache = util.propertycache propertycache = util.propertycache
filecache = scmutil.filecache filecache = scmutil.filecache
_rangemask = dirstatemap.rangemask _rangemask = dirstatemap.rangemask
dirstatetuple = parsers.dirstatetuple DirstateItem = parsers.DirstateItem
class repocache(filecache): class repocache(filecache):
"""filecache for files in .hg/""" """filecache for files in .hg/"""
def join(self, obj, fname): def join(self, obj, fname):
return obj._opener.join(fname) return obj._opener.join(fname)

mercurial/dirstatemap.py

util, util,
) )
parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust('dirstate') rustmod = policy.importrust('dirstate')
propertycache = util.propertycache propertycache = util.propertycache
dirstatetuple = parsers.dirstatetuple DirstateItem = parsers.DirstateItem
# a special value used internally for `size` if the file come from the other parent # a special value used internally for `size` if the file come from the other parent
FROM_P2 = -2 FROM_P2 = -2
# a special value used internally for `size` if the file is modified/merged/added # a special value used internally for `size` if the file is modified/merged/added
NONNORMAL = -1 NONNORMAL = -1
assert mtime is not None assert mtime is not None
old_entry = self.get(f) old_entry = self.get(f)
if ( if (
old_entry is None or old_entry.removed old_entry is None or old_entry.removed
) and "_dirs" in self.__dict__: ) and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
if old_entry is None and "_alldirs" in self.__dict__: if old_entry is None and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
self._map[f] = dirstatetuple(state, mode, size, mtime) self._map[f] = DirstateItem(state, mode, size, mtime)
if state != b'n' or mtime == AMBIGUOUS_TIME: if state != b'n' or mtime == AMBIGUOUS_TIME:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if size == FROM_P2: if size == FROM_P2:
self.otherparentset.add(f) self.otherparentset.add(f)
def removefile(self, f, in_merge=False): def removefile(self, f, in_merge=False):
""" """
Mark a file as removed in the dirstate. Mark a file as removed in the dirstate.
if entry is not None and entry[0] != b'r' and "_dirs" in self.__dict__: if entry is not None and entry[0] != b'r' and "_dirs" in self.__dict__:
self._dirs.delpath(f) self._dirs.delpath(f)
if entry is None and "_alldirs" in self.__dict__: if entry is None and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
if "filefoldmap" in self.__dict__: if "filefoldmap" in self.__dict__:
normed = util.normcase(f) normed = util.normcase(f)
self.filefoldmap.pop(normed, None) self.filefoldmap.pop(normed, None)
self._map[f] = dirstatetuple(b'r', 0, size, 0) 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)
self.filefoldmap.pop(normed, None) self.filefoldmap.pop(normed, None)
self.nonnormalset.discard(f) self.nonnormalset.discard(f)
return exists return exists
def clearambiguoustimes(self, files, now): def clearambiguoustimes(self, files, now):
for f in files: for f in files:
e = self.get(f) e = self.get(f)
if e is not None and e[0] == b'n' and e[3] == now: if e is not None and e[0] == b'n' and e[3] == now:
self._map[f] = dirstatetuple(e[0], e[1], e[2], AMBIGUOUS_TIME) self._map[f] = DirstateItem(e[0], e[1], e[2], AMBIGUOUS_TIME)
self.nonnormalset.add(f) self.nonnormalset.add(f)
def nonnormalentries(self): def nonnormalentries(self):
'''Compute the nonnormal dirstate entries from the dmap''' '''Compute the nonnormal dirstate entries from the dmap'''
try: try:
return parsers.nonnormalotherparententries(self._map) return parsers.nonnormalotherparententries(self._map)
except AttributeError: except AttributeError:
nonnorm = set() nonnorm = set()

mercurial/interfaces/dirstate.py

def __contains__(key): def __contains__(key):
"""Check if bytestring `key` is known to the dirstate.""" """Check if bytestring `key` is known to the dirstate."""
def __iter__(): def __iter__():
"""Iterate the dirstate's contained filenames as bytestrings.""" """Iterate the dirstate's contained filenames as bytestrings."""
def items(): def items():
"""Iterate the dirstate's entries as (filename, dirstatetuple). """Iterate the dirstate's entries as (filename, DirstateItem.
As usual, filename is a bytestring. As usual, filename is a bytestring.
""" """
iteritems = items iteritems = items
def parents(): def parents():
pass pass

mercurial/pure/parsers.py

# a special value used internally for `size` if the file come from the other parent # a special value used internally for `size` if the file come from the other parent
FROM_P2 = -2 FROM_P2 = -2
# a special value used internally for `size` if the file is modified/merged/added # a special value used internally for `size` if the file is modified/merged/added
NONNORMAL = -1 NONNORMAL = -1
class dirstatetuple(object): class DirstateItem(object):
"""represent a dirstate entry """represent a dirstate entry
It contains: It contains:
- state (one of 'n', 'a', 'r', 'm') - state (one of 'n', 'a', 'r', 'm')
- mode, - mode,
- size, - size,
- mtime, - mtime,
while pos1 < l: while pos1 < l:
pos2 = pos1 + e_size pos2 = pos1 + e_size
e = _unpack(b">cllll", st[pos1:pos2]) # a literal here is faster e = _unpack(b">cllll", st[pos1:pos2]) # a literal here is faster
pos1 = pos2 + e[4] pos1 = pos2 + e[4]
f = st[pos2:pos1] f = st[pos2:pos1]
if b'\0' in f: if b'\0' in f:
f, c = f.split(b'\0') f, c = f.split(b'\0')
copymap[f] = c copymap[f] = c
dmap[f] = dirstatetuple(*e[:4]) dmap[f] = DirstateItem(*e[:4])
return parents return parents
def pack_dirstate(dmap, copymap, pl, now): def pack_dirstate(dmap, copymap, pl, now):
now = int(now) now = int(now)
cs = stringio() cs = stringio()
write = cs.write write = cs.write
write(b"".join(pl)) write(b"".join(pl))
for f, e in pycompat.iteritems(dmap): for f, e in pycompat.iteritems(dmap):
if e[0] == b'n' and e[3] == now: if e[0] == b'n' and e[3] == now:
# The file was last modified "simultaneously" with the current # The file was last modified "simultaneously" with the current
# write to dirstate (i.e. within the same second for file- # write to dirstate (i.e. within the same second for file-
# systems with a granularity of 1 sec). This commonly happens # systems with a granularity of 1 sec). This commonly happens
# for at least a couple of files on 'update'. # for at least a couple of files on 'update'.
# The user could change the file without changing its size # The user could change the file without changing its size
# within the same second. Invalidate the file's mtime in # within the same second. Invalidate the file's mtime in
# dirstate, forcing future 'status' calls to compare the # dirstate, forcing future 'status' calls to compare the
# contents of the file if the size is the same. This prevents # contents of the file if the size is the same. This prevents
# mistakenly treating such files as clean. # mistakenly treating such files as clean.
e = dirstatetuple(e[0], e[1], e[2], -1) e = DirstateItem(e[0], e[1], e[2], -1)
dmap[f] = e dmap[f] = e
if f in copymap: if f in copymap:
f = b"%s\0%s" % (f, copymap[f]) f = b"%s\0%s" % (f, copymap[f])
e = _pack( e = _pack(
b">cllll", b">cllll",
e.v1_state(), e.v1_state(),
e.v1_mode(), e.v1_mode(),
e.v1_size(), e.v1_size(),
e.v1_mtime(), e.v1_mtime(),
len(f), len(f),
) )
write(e) write(e)
write(f) write(f)
return cs.getvalue() return cs.getvalue()

rust/hg-cpython/src/dirstate.rs

// C code uses a custom `dirstate_tuple` type, checks in multiple instances // C code uses a custom `dirstate_tuple` type, checks in multiple instances
// for this type, and raises a Python `Exception` if the check does not pass. // for this type, and raises a Python `Exception` if the check does not pass.
// Because this type differs only in name from the regular Python tuple, it // Because this type differs only in name from the regular Python tuple, it
// would be a good idea in the near future to remove it entirely to allow // would be a good idea in the near future to remove it entirely to allow
// for a pure Python tuple of the same effective structure to be used, // for a pure Python tuple of the same effective structure to be used,
// rendering this type and the capsule below useless. // rendering this type and the capsule below useless.
py_capsule_fn!( py_capsule_fn!(
from mercurial.cext.parsers import make_dirstate_tuple_CAPI from mercurial.cext.parsers import make_dirstate_item_CAPI
as make_dirstate_tuple_capi as make_dirstate_item_capi
signature ( signature (
state: c_char, state: c_char,
mode: c_int, mode: c_int,
size: c_int, size: c_int,
mtime: c_int, mtime: c_int,
) -> *mut RawPyObject ) -> *mut RawPyObject
); );
pub fn make_dirstate_tuple( pub fn make_dirstate_item(
py: Python, py: Python,
entry: &DirstateEntry, entry: &DirstateEntry,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
// might be silly to retrieve capsule function in hot loop // might be silly to retrieve capsule function in hot loop
let make = make_dirstate_tuple_capi::retrieve(py)?; let make = make_dirstate_item_capi::retrieve(py)?;
let &DirstateEntry { let &DirstateEntry {
state, state,
mode, mode,
size, size,
mtime, mtime,
} = entry; } = entry;
// Explicitly go through u8 first, then cast to platform-specific `c_char` // Explicitly go through u8 first, then cast to platform-specific `c_char`

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

use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject, PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::make_dirstate_tuple, dirstate::make_dirstate_item,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::owning::OwningDirstateMap, dirstate::owning::OwningDirstateMap,
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
let key = key.extract::<PyBytes>(py)?; let key = key.extract::<PyBytes>(py)?;
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.get(HgPath::new(key.data(py))) .get(HgPath::new(key.data(py)))
.map_err(|e| v2_error(py, e))? .map_err(|e| v2_error(py, e))?
{ {
Some(entry) => { Some(entry) => {
Ok(Some(make_dirstate_tuple(py, &entry)?)) Ok(Some(make_dirstate_item(py, &entry)?))
}, },
None => Ok(default) None => Ok(default)
} }
} }
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
let key = HgPath::new(key.data(py)); let key = HgPath::new(key.data(py));
match self match self
.inner(py) .inner(py)
.borrow() .borrow()
.get(key) .get(key)
.map_err(|e| v2_error(py, e))? .map_err(|e| v2_error(py, e))?
{ {
Some(entry) => { Some(entry) => {
Ok(make_dirstate_tuple(py, &entry)?) Ok(make_dirstate_item(py, &entry)?)
}, },
None => Err(PyErr::new::<exc::KeyError, _>( None => Err(PyErr::new::<exc::KeyError, _>(
py, py,
String::from_utf8_lossy(key.as_bytes()), String::from_utf8_lossy(key.as_bytes()),
)), )),
} }
} }
} }
fn translate_key_value( fn translate_key_value(
py: Python, py: Python,
res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>, res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
) -> PyResult<Option<(PyBytes, PyObject)>> { ) -> PyResult<Option<(PyBytes, PyObject)>> {
let (f, entry) = res.map_err(|e| v2_error(py, e))?; let (f, entry) = res.map_err(|e| v2_error(py, e))?;
Ok(Some(( Ok(Some((
PyBytes::new(py, f.as_bytes()), PyBytes::new(py, f.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_item(py, &entry)?,
))) )))
} }
} }
py_shared_iterator!( py_shared_iterator!(
DirstateMapKeysIterator, DirstateMapKeysIterator,
UnsafePyLeaked<StateMapIter<'static>>, UnsafePyLeaked<StateMapIter<'static>>,
DirstateMap::translate_key, DirstateMap::translate_key,

rust/hg-cpython/src/parsers.rs

}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, pack_dirstate, parse_dirstate, dirstate::parsers::Timestamp, pack_dirstate, parse_dirstate,
utils::hg_path::HgPathBuf, DirstateEntry, DirstateParents, FastHashMap, utils::hg_path::HgPathBuf, DirstateEntry, DirstateParents, FastHashMap,
PARENT_SIZE, PARENT_SIZE,
}; };
use std::convert::TryInto; use std::convert::TryInto;
use crate::dirstate::{extract_dirstate, make_dirstate_tuple}; use crate::dirstate::{extract_dirstate, make_dirstate_item};
fn parse_dirstate_wrapper( fn parse_dirstate_wrapper(
py: Python, py: Python,
dmap: PyDict, dmap: PyDict,
copymap: PyDict, copymap: PyDict,
st: PyBytes, st: PyBytes,
) -> PyResult<PyTuple> { ) -> PyResult<PyTuple> {
match parse_dirstate(st.data(py)) { match parse_dirstate(st.data(py)) {
Ok((parents, entries, copies)) => { Ok((parents, entries, copies)) => {
let dirstate_map: FastHashMap<HgPathBuf, DirstateEntry> = entries let dirstate_map: FastHashMap<HgPathBuf, DirstateEntry> = entries
.into_iter() .into_iter()
.map(|(path, entry)| (path.to_owned(), entry)) .map(|(path, entry)| (path.to_owned(), entry))
.collect(); .collect();
let copy_map: FastHashMap<HgPathBuf, HgPathBuf> = copies let copy_map: FastHashMap<HgPathBuf, HgPathBuf> = copies
.into_iter() .into_iter()
.map(|(path, copy)| (path.to_owned(), copy.to_owned())) .map(|(path, copy)| (path.to_owned(), copy.to_owned()))
.collect(); .collect();
for (filename, entry) in &dirstate_map { for (filename, entry) in &dirstate_map {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_bytes()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, entry)?, make_dirstate_item(py, entry)?,
)?; )?;
} }
for (path, copy_path) in copy_map { for (path, copy_path) in copy_map {
copymap.set_item( copymap.set_item(
py, py,
PyBytes::new(py, path.as_bytes()), PyBytes::new(py, path.as_bytes()),
PyBytes::new(py, copy_path.as_bytes()), PyBytes::new(py, copy_path.as_bytes()),
)?; )?;
}, },
Timestamp(now.as_object().extract::<i64>(py)?), Timestamp(now.as_object().extract::<i64>(py)?),
) { ) {
Ok(packed) => { Ok(packed) => {
for (filename, entry) in dirstate_map.iter() { for (filename, entry) in dirstate_map.iter() {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_bytes()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_item(py, &entry)?,
)?; )?;
} }
Ok(PyBytes::new(py, &packed)) Ok(PyBytes::new(py, &packed))
} }
Err(error) => { Err(error) => {
Err(PyErr::new::<exc::ValueError, _>(py, error.to_string())) Err(PyErr::new::<exc::ValueError, _>(py, error.to_string()))
} }
} }

tests/fakedirstatewritetime.py

def pack_dirstate(fakenow, orig, dmap, copymap, pl, now): def pack_dirstate(fakenow, orig, dmap, copymap, pl, now):
# execute what original parsers.pack_dirstate should do actually # execute what original parsers.pack_dirstate should do actually
# for consistency # for consistency
actualnow = int(now) actualnow = int(now)
for f, e in dmap.items(): for f, e in dmap.items():
if e[0] == 'n' and e[3] == actualnow: if e[0] == 'n' and e[3] == actualnow:
e = parsers.dirstatetuple(e[0], e[1], e[2], -1) e = parsers.DirstateItem(e[0], e[1], e[2], -1)
dmap[f] = e dmap[f] = e
return orig(dmap, copymap, pl, fakenow) return orig(dmap, copymap, pl, fakenow)
def fakewrite(ui, func): def fakewrite(ui, func):
# fake "now" of 'pack_dirstate' only if it is invoked while 'func' # fake "now" of 'pack_dirstate' only if it is invoked while 'func'