( )⚙ D10982 dirstate-item: rename the class to DirstateItem

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

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 28803

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):
"""represente a dirstate entry """represente a dirstate entry
It constains: It constains:
- 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'