This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11557

dirstate-item: change the internal storage and constructor value
ClosedPublic

Authored by marmoute on Oct 1 2021, 2:40 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG38488d488ec1: dirstate-item: change the internal storage and constructor value
Summary

This should be closer to what we do need and what we can actually reliably
record.

In practice it means that we abandon the prospect of storing much more refined
data for now. We don't have the necessary information nor code using it right
now. So it seems safer to just use a clearer version of what we had so far.

See the documentation changes for details.

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.Oct 1 2021, 2:40 PM
baymax updated this revision to Diff 30549.Oct 1 2021, 6:04 PM

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

marmoute updated this revision to Diff 30579.Oct 2 2021, 8:39 PM
Alphare accepted this revision.Oct 3 2021, 4:57 PM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-core/src/dirstate/entry.rs
19–20

Could be worthwhile to add a comment saying that this makes sense semantically because both the mode and size would be None together. But this could also be a follow-up

198

I don't think returning an Option here would be valuable, IMO panicking is the right choice

This revision is now accepted and ready to land.Oct 3 2021, 4:57 PM

Revision Contents
Changeset List

Diff 30640

mercurial/cext/parsers.c

static PyObject *dirstate_item_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_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
int wc_tracked; int wc_tracked;
int p1_tracked; int p1_tracked;
int p2_tracked; int p2_info;
int merged; int has_meaningful_data;
int clean_p1; int has_meaningful_mtime;
int clean_p2; int mode;
int possibly_dirty; int size;
int mtime;
PyObject *parentfiledata; PyObject *parentfiledata;
static char *keywords_name[] = { static char *keywords_name[] = {
"wc_tracked", "p1_tracked", "p2_tracked", "wc_tracked",
"merged", "clean_p1", "clean_p2", "p1_tracked",
"possibly_dirty", "parentfiledata", NULL, "p2_info",
"has_meaningful_data",
"has_meaningful_mtime",
"parentfiledata",
NULL,
}; };
wc_tracked = 0; wc_tracked = 0;
p1_tracked = 0; p1_tracked = 0;
p2_tracked = 0; p2_info = 0;
merged = 0; has_meaningful_mtime = 1;
clean_p1 = 0; has_meaningful_data = 1;
clean_p2 = 0;
possibly_dirty = 0;
parentfiledata = Py_None; parentfiledata = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiiiO", keywords_name, if (!PyArg_ParseTupleAndKeywords(
&wc_tracked, &p1_tracked, &p2_tracked, args, kwds, "|iiiiiO", keywords_name, &wc_tracked, &p1_tracked,
&merged, &clean_p1, &clean_p2, &p2_info, &has_meaningful_data, &has_meaningful_mtime,
&possibly_dirty, &parentfiledata &parentfiledata)) {
)) {
return NULL;
}
if (merged && (clean_p1 || clean_p2)) {
PyErr_SetString(PyExc_RuntimeError,
"`merged` argument incompatible with "
"`clean_p1`/`clean_p2`");
return NULL; return NULL;
} }
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = 0; t->flags = 0;
if (wc_tracked) { if (wc_tracked) {
t->flags |= dirstate_flag_wc_tracked; t->flags |= dirstate_flag_wc_tracked;
} }
if (p1_tracked) { if (p1_tracked) {
t->flags |= dirstate_flag_p1_tracked; t->flags |= dirstate_flag_p1_tracked;
} }
if (p2_tracked) { if (p2_info) {
t->flags |= dirstate_flag_p2_tracked; t->flags |= dirstate_flag_p2_info;
}
if (possibly_dirty) {
t->flags |= dirstate_flag_possibly_dirty;
}
if (merged) {
t->flags |= dirstate_flag_merged;
}
if (clean_p1) {
t->flags |= dirstate_flag_clean_p1;
} }
if (clean_p2) {
t->flags |= dirstate_flag_clean_p2;
}
t->mode = 0;
t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time;
if (parentfiledata != Py_None) { if (parentfiledata != Py_None) {
if (!PyTuple_CheckExact(parentfiledata)) { if (!PyTuple_CheckExact(parentfiledata)) {
PyErr_SetString( PyErr_SetString(
PyExc_TypeError, PyExc_TypeError,
"parentfiledata should be a Tuple or None"); "parentfiledata should be a Tuple or None");
return NULL; return NULL;
} }
t->mode = mode = (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0));
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0)); size = (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1));
t->size = mtime = (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2));
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1)); } else {
t->mtime = has_meaningful_data = 0;
(int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2)); has_meaningful_mtime = 0;
}
if (has_meaningful_data) {
t->flags |= dirstate_flag_has_meaningful_data;
t->mode = mode;
t->size = size;
} else {
t->mode = 0;
t->size = 0;
}
if (has_meaningful_mtime) {
t->flags |= dirstate_flag_has_meaningful_mtime;
t->mtime = mtime;
} else {
t->mtime = 0;
} }
return (PyObject *)t; return (PyObject *)t;
} }
static void dirstate_item_dealloc(PyObject *o) static void dirstate_item_dealloc(PyObject *o)
{ {
PyObject_Del(o); PyObject_Del(o);
} }
static inline bool dirstate_item_c_tracked(dirstateItemObject *self) static inline bool dirstate_item_c_tracked(dirstateItemObject *self)
{ {
return (self->flags & dirstate_flag_wc_tracked); return (self->flags & dirstate_flag_wc_tracked);
} }
static inline bool dirstate_item_c_any_tracked(dirstateItemObject *self)
{
const unsigned char mask = dirstate_flag_wc_tracked |
dirstate_flag_p1_tracked |
dirstate_flag_p2_info;
return (self->flags & mask);
}
static inline bool dirstate_item_c_added(dirstateItemObject *self) static inline bool dirstate_item_c_added(dirstateItemObject *self)
{ {
unsigned char mask = const unsigned char mask =
(dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_p2_tracked); dirstate_flag_p2_info);
unsigned char target = dirstate_flag_wc_tracked; const unsigned char target = dirstate_flag_wc_tracked;
return (self->flags & mask) == target; return (self->flags & mask) == target;
} }
static inline bool dirstate_item_c_removed(dirstateItemObject *self) static inline bool dirstate_item_c_removed(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_wc_tracked) { if (self->flags & dirstate_flag_wc_tracked) {
return false; return false;
} }
return (self->flags & return (self->flags &
(dirstate_flag_p1_tracked | dirstate_flag_p2_tracked)); (dirstate_flag_p1_tracked | dirstate_flag_p2_info));
} }
static inline bool dirstate_item_c_merged(dirstateItemObject *self) static inline bool dirstate_item_c_merged(dirstateItemObject *self)
{ {
return ((self->flags & dirstate_flag_wc_tracked) && return ((self->flags & dirstate_flag_wc_tracked) &&
(self->flags & dirstate_flag_merged)); (self->flags & dirstate_flag_p1_tracked) &&
(self->flags & dirstate_flag_p2_info));
} }
static inline bool dirstate_item_c_from_p2(dirstateItemObject *self) static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)
{ {
if (!dirstate_item_c_tracked(self)) { return ((self->flags & dirstate_flag_wc_tracked) &&
return false; !(self->flags & dirstate_flag_p1_tracked) &&
} (self->flags & dirstate_flag_p2_info));
return (self->flags & dirstate_flag_clean_p2);
} }
static inline char dirstate_item_c_v1_state(dirstateItemObject *self) static inline char dirstate_item_c_v1_state(dirstateItemObject *self)
{ {
if (dirstate_item_c_removed(self)) { if (dirstate_item_c_removed(self)) {
return 'r'; return 'r';
} else if (dirstate_item_c_merged(self)) { } else if (dirstate_item_c_merged(self)) {
return 'm'; return 'm';
} else if (dirstate_item_c_added(self)) { } else if (dirstate_item_c_added(self)) {
return 'a'; return 'a';
} else { } else {
return 'n'; return 'n';
} }
} }
static inline int dirstate_item_c_v1_mode(dirstateItemObject *self) static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
{ {
if (self->flags & dirstate_flag_has_meaningful_data) {
return self->mode; return self->mode;
} else {
return 0;
}
} }
static inline int dirstate_item_c_v1_size(dirstateItemObject *self) static inline int dirstate_item_c_v1_size(dirstateItemObject *self)
{ {
if (dirstate_item_c_removed(self) && if (!(self->flags & dirstate_flag_wc_tracked) &&
(self->flags & dirstate_flag_merged)) { (self->flags & dirstate_flag_p2_info)) {
if (self->flags & dirstate_flag_p1_tracked) {
return dirstate_v1_nonnormal; return dirstate_v1_nonnormal;
} else if (dirstate_item_c_removed(self) && } else {
(self->flags & dirstate_flag_clean_p2)) {
return dirstate_v1_from_p2; return dirstate_v1_from_p2;
}
} else if (dirstate_item_c_removed(self)) { } else if (dirstate_item_c_removed(self)) {
return 0; return 0;
} else if (dirstate_item_c_merged(self)) { } else if (self->flags & dirstate_flag_p2_info) {
return dirstate_v1_from_p2; return dirstate_v1_from_p2;
} else if (dirstate_item_c_added(self)) { } else if (dirstate_item_c_added(self)) {
return dirstate_v1_nonnormal; return dirstate_v1_nonnormal;
} else if (dirstate_item_c_from_p2(self)) { } else if (self->flags & dirstate_flag_has_meaningful_data) {
return dirstate_v1_from_p2;
} else if (self->flags & dirstate_flag_possibly_dirty) {
return self->size; /* NON NORMAL ? */
} else {
return self->size; return self->size;
} else {
return dirstate_v1_nonnormal;
} }
} }
static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self) static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
{ {
if (dirstate_item_c_removed(self)) { if (dirstate_item_c_removed(self)) {
return 0; return 0;
} else if (self->flags & dirstate_flag_possibly_dirty) { } else if (!(self->flags & dirstate_flag_has_meaningful_mtime) ||
return ambiguous_time; !(self->flags & dirstate_flag_p1_tracked) ||
} else if (dirstate_item_c_merged(self)) { !(self->flags & dirstate_flag_wc_tracked) ||
return ambiguous_time; (self->flags & dirstate_flag_p2_info)) {
} else if (dirstate_item_c_added(self)) {
return ambiguous_time;
} else if (dirstate_item_c_from_p2(self)) {
return ambiguous_time; return ambiguous_time;
} else { } else {
return self->mtime; return self->mtime;
} }
} }
static PyObject *dirstate_item_v1_state(dirstateItemObject *self) static PyObject *dirstate_item_v1_state(dirstateItemObject *self)
{ {
static inline dirstateItemObject * static inline dirstateItemObject *
dirstate_item_from_v1_data(char state, int mode, int size, int mtime) dirstate_item_from_v1_data(char state, int mode, int size, int mtime)
{ {
dirstateItemObject *t = dirstateItemObject *t =
PyObject_New(dirstateItemObject, &dirstateItemType); PyObject_New(dirstateItemObject, &dirstateItemType);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = 0;
t->mode = 0;
t->size = 0;
t->mtime = 0;
if (state == 'm') { if (state == 'm') {
t->flags = t->flags = (dirstate_flag_wc_tracked |
(dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | dirstate_flag_p1_tracked | dirstate_flag_p2_info);
dirstate_flag_p2_tracked | dirstate_flag_merged);
t->mode = 0;
t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time;
} else if (state == 'a') { } else if (state == 'a') {
t->flags = dirstate_flag_wc_tracked; t->flags = dirstate_flag_wc_tracked;
t->mode = 0;
t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time;
} else if (state == 'r') { } else if (state == 'r') {
t->mode = 0;
t->size = 0;
t->mtime = 0;
if (size == dirstate_v1_nonnormal) { if (size == dirstate_v1_nonnormal) {
t->flags = t->flags =
(dirstate_flag_p1_tracked | dirstate_flag_p1_tracked | dirstate_flag_p2_info;
dirstate_flag_p2_tracked | dirstate_flag_merged);
} else if (size == dirstate_v1_from_p2) { } else if (size == dirstate_v1_from_p2) {
t->flags = t->flags = dirstate_flag_p2_info;
(dirstate_flag_p2_tracked | dirstate_flag_clean_p2);
} else { } else {
t->flags = dirstate_flag_p1_tracked; t->flags = dirstate_flag_p1_tracked;
} }
} else if (state == 'n') { } else if (state == 'n') {
if (size == dirstate_v1_from_p2) { if (size == dirstate_v1_from_p2) {
t->flags = t->flags =
(dirstate_flag_wc_tracked | dirstate_flag_wc_tracked | dirstate_flag_p2_info;
dirstate_flag_p2_tracked | dirstate_flag_clean_p2);
t->mode = 0;
t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time;
} else if (size == dirstate_v1_nonnormal) { } else if (size == dirstate_v1_nonnormal) {
t->flags = (dirstate_flag_wc_tracked | t->flags =
dirstate_flag_p1_tracked | dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
dirstate_flag_possibly_dirty);
t->mode = 0;
t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time;
} else if (mtime == ambiguous_time) { } else if (mtime == ambiguous_time) {
t->flags = (dirstate_flag_wc_tracked | t->flags = (dirstate_flag_wc_tracked |
dirstate_flag_p1_tracked | dirstate_flag_p1_tracked |
dirstate_flag_possibly_dirty); dirstate_flag_has_meaningful_data);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = 0;
} else { } else {
t->flags = (dirstate_flag_wc_tracked | t->flags = (dirstate_flag_wc_tracked |
dirstate_flag_p1_tracked); dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data |
dirstate_flag_has_meaningful_mtime);
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
} }
} else { } else {
PyErr_Format(PyExc_RuntimeError, PyErr_Format(PyExc_RuntimeError,
"unknown state: `%c` (%d, %d, %d)", state, mode, "unknown state: `%c` (%d, %d, %d)", state, mode,
size, mtime, NULL); size, mtime, NULL);
{ {
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = dirstate_flag_wc_tracked; t->flags = dirstate_flag_wc_tracked;
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_nonnormal; t->size = 0;
t->mtime = ambiguous_time; t->mtime = 0;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "merged" item /* constructor to help legacy API to build a new "merged" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_merged(PyTypeObject *subtype) static PyObject *dirstate_item_new_merged(PyTypeObject *subtype)
{ {
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_p2_tracked | dirstate_flag_merged); dirstate_flag_p2_info);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_from_p2; t->size = 0;
t->mtime = ambiguous_time; t->mtime = 0;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "from_p2" item /* constructor to help legacy API to build a new "from_p2" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype) static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype)
{ {
/* 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_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p2_tracked | t->flags = dirstate_flag_wc_tracked | dirstate_flag_p2_info;
dirstate_flag_clean_p2);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_from_p2; t->size = 0;
t->mtime = ambiguous_time; t->mtime = 0;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "possibly" item /* constructor to help legacy API to build a new "possibly" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype) static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
{ {
/* 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_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | t->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
dirstate_flag_possibly_dirty);
t->mode = 0; t->mode = 0;
t->size = dirstate_v1_nonnormal; t->size = 0;
t->mtime = ambiguous_time; t->mtime = 0;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "normal" item /* constructor to help legacy API to build a new "normal" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args) static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
{ {
t->mtime = mtime; t->mtime = mtime;
return (PyObject *)t; return (PyObject *)t;
}; };
/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->flags |= dirstate_flag_possibly_dirty; self->flags &= ~dirstate_flag_has_meaningful_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* See docstring of the python implementation for details */ /* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self, static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args) PyObject *args)
{ {
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) { if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL; return NULL;
} }
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked; self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data |
dirstate_flag_has_meaningful_mtime;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime = mtime; self->mtime = mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_tracked(dirstateItemObject *self) static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
{ {
self->flags |= dirstate_flag_wc_tracked; self->flags |= dirstate_flag_wc_tracked;
self->flags |= dirstate_flag_possibly_dirty; self->flags &= ~dirstate_flag_has_meaningful_mtime;
/* size = None on the python size turn into size = NON_NORMAL when
* accessed. So the next line is currently required, but a some future
* clean up would be welcome. */
self->size = dirstate_v1_nonnormal;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self) static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_wc_tracked; self->flags &= ~dirstate_flag_wc_tracked;
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0; self->size = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self) static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
{ {
if (dirstate_item_c_merged(self) || dirstate_item_c_from_p2(self)) { if (self->flags & dirstate_flag_p2_info) {
if (dirstate_item_c_merged(self)) { self->flags &= ~(dirstate_flag_p2_info |
self->flags |= dirstate_flag_p1_tracked; dirstate_flag_has_meaningful_data |
} else { dirstate_flag_has_meaningful_mtime);
self->flags &= ~dirstate_flag_p1_tracked;
}
self->flags &=
~(dirstate_flag_merged | dirstate_flag_clean_p1 |
dirstate_flag_clean_p2 | dirstate_flag_p2_tracked);
self->flags |= dirstate_flag_possibly_dirty;
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
/* size = None on the python size turn into size = NON_NORMAL self->size = 0;
* when accessed. So the next line is currently required, but a
* some future clean up would be welcome. */
self->size = dirstate_v1_nonnormal;
} }
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyMethodDef dirstate_item_methods[] = { static PyMethodDef dirstate_item_methods[] = {
{"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS, {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
"return a \"state\" suitable for v1 serialization"}, "return a \"state\" suitable for v1 serialization"},
{"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS, {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstate_item_get_maybe_clean(dirstateItemObject *self) static PyObject *dirstate_item_get_maybe_clean(dirstateItemObject *self)
{ {
if (!(self->flags & dirstate_flag_wc_tracked)) { if (!(self->flags & dirstate_flag_wc_tracked)) {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} else if (dirstate_item_c_added(self)) { } else if (!(self->flags & dirstate_flag_p1_tracked)) {
Py_RETURN_FALSE;
} else if (self->flags & dirstate_flag_merged) {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} else if (self->flags & dirstate_flag_clean_p2) { } else if (self->flags & dirstate_flag_p2_info) {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} else { } else {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} }
}; };
static PyObject *dirstate_item_get_any_tracked(dirstateItemObject *self) static PyObject *dirstate_item_get_any_tracked(dirstateItemObject *self)
{ {
unsigned char mask = dirstate_flag_wc_tracked | if (dirstate_item_c_any_tracked(self)) {
dirstate_flag_p1_tracked |
dirstate_flag_p2_tracked;
if ((self->flags & mask) != 0) {
Py_RETURN_TRUE; Py_RETURN_TRUE;
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyObject *dirstate_item_get_removed(dirstateItemObject *self) static PyObject *dirstate_item_get_removed(dirstateItemObject *self)
{ {

mercurial/cext/util.h

int mode; int mode;
int size; int size;
int mtime; int mtime;
} dirstateItemObject; } dirstateItemObject;
/* clang-format on */ /* clang-format on */
static const unsigned char dirstate_flag_wc_tracked = 1; static const unsigned char dirstate_flag_wc_tracked = 1;
static const unsigned char dirstate_flag_p1_tracked = 1 << 1; static const unsigned char dirstate_flag_p1_tracked = 1 << 1;
static const unsigned char dirstate_flag_p2_tracked = 1 << 2; static const unsigned char dirstate_flag_p2_info = 1 << 2;
static const unsigned char dirstate_flag_possibly_dirty = 1 << 3; static const unsigned char dirstate_flag_has_meaningful_data = 1 << 3;
static const unsigned char dirstate_flag_merged = 1 << 4; static const unsigned char dirstate_flag_has_meaningful_mtime = 1 << 4;
static const unsigned char dirstate_flag_clean_p1 = 1 << 5;
static const unsigned char dirstate_flag_clean_p2 = 1 << 6;
extern PyTypeObject dirstateItemType; extern PyTypeObject dirstateItemType;
#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType) #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 */

mercurial/dirstatemap.py

self.copymap.pop(filename, None) self.copymap.pop(filename, None)
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,
p2_tracked=False,
wc_tracked=True, wc_tracked=True,
merged=False,
clean_p1=False,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None,
) )
self._insert_entry(filename, entry) self._insert_entry(filename, entry)
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()
self._refresh_entry(filename, entry) self._refresh_entry(filename, entry)
# (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.get(filename) old_entry = self._map.get(filename)
self._drop_entry(filename) self._drop_entry(filename)
self._dirs_decr(filename, old_entry=old_entry) self._dirs_decr(filename, old_entry=old_entry)
return return
elif merged:
pass p2_info = merged or clean_p2
elif not (p1_tracked or p2_tracked) and wc_tracked: if merged:
pass # file is added, nothing special to adjust assert p1_tracked
elif (p1_tracked or p2_tracked) and not wc_tracked:
pass has_meaningful_mtime = not possibly_dirty
elif clean_p2 and wc_tracked:
pass
elif not p1_tracked and p2_tracked and wc_tracked:
clean_p2 = True
elif possibly_dirty:
pass
elif wc_tracked:
# this is a "normal" file
if parentfiledata is None:
msg = b'failed to pass parentfiledata for a normal file: %s'
msg %= filename
raise error.ProgrammingError(msg)
else:
assert False, 'unreachable'
old_entry = self._map.get(filename) old_entry = self._map.get(filename)
self._dirs_incr(filename, old_entry) self._dirs_incr(filename, old_entry)
entry = DirstateItem( entry = DirstateItem(
wc_tracked=wc_tracked, wc_tracked=wc_tracked,
p1_tracked=p1_tracked, p1_tracked=p1_tracked,
p2_tracked=p2_tracked, p2_info=p2_info,
merged=merged, has_meaningful_mtime=has_meaningful_mtime,
clean_p1=clean_p1,
clean_p2=clean_p2,
possibly_dirty=possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
self._insert_entry(filename, entry) self._insert_entry(filename, entry)
class dirstatemap(_dirstatemapcommon): class dirstatemap(_dirstatemapcommon):
"""Map encapsulating the dirstate's contents. """Map encapsulating the dirstate's contents.

mercurial/pure/parsers.py

class DirstateItem(object): class DirstateItem(object):
"""represent a dirstate entry """represent a dirstate entry
It hold multiple attributes It hold multiple attributes
# about file tracking # about file tracking
- wc_tracked: is the file tracked by the working copy - wc_tracked: is the file tracked by the working copy
- p1_tracked: is the file tracked in working copy first parent - p1_tracked: is the file tracked in working copy first parent
- p2_tracked: is the file tracked in working copy second parent - p2_info: the file has been involved in some merge operation. Either
because it was actually merged, or because the p2 version was
# about what possible merge action related to this file ahead, or because some renamed moved it there. In either case
- clean_p1: merge picked the file content from p1 `hg status` will want it displayed as modified.
- clean_p2: merge picked the file content from p2
- merged: file gather changes from both side.
# about the file state expected from p1 manifest: # about the file state expected from p1 manifest:
- mode: the file mode in p1 - mode: the file mode in p1
- size: the file size in p1 - size: the file size in p1
These value can be set to None, which mean we don't have a meaningful value
to compare with. Either because we don't really care about them as there
`status` is known without having to look at the disk or because we don't
know these right now and a full comparison will be needed to find out if
the file is clean.
# about the file state on disk last time we saw it: # about the file state on disk last time we saw it:
- mtime: the last known clean mtime for the file. - mtime: the last known clean mtime for the file.
The last three item (mode, size and mtime) can be None if no meaningful (or This value can be set to None if no cachable state exist. Either because we
trusted) value exists. do not care (see previous section) or because we could not cache something
yet.
""" """
_wc_tracked = attr.ib() _wc_tracked = attr.ib()
_p1_tracked = attr.ib() _p1_tracked = attr.ib()
_p2_tracked = attr.ib() _p2_info = attr.ib()
# the three item above should probably be combined
#
# However it is unclear if they properly cover some of the most advanced
# merge case. So we should probably wait on this to be settled.
_merged = attr.ib()
_clean_p1 = attr.ib()
_clean_p2 = attr.ib()
_possibly_dirty = attr.ib()
_mode = attr.ib() _mode = attr.ib()
_size = attr.ib() _size = attr.ib()
_mtime = attr.ib() _mtime = attr.ib()
def __init__( def __init__(
self, self,
wc_tracked=False, wc_tracked=False,
p1_tracked=False, p1_tracked=False,
p2_tracked=False, p2_info=False,
merged=False, has_meaningful_data=True,
clean_p1=False, has_meaningful_mtime=True,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None, parentfiledata=None,
): ):
if merged and (clean_p1 or clean_p2):
msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
raise error.ProgrammingError(msg)
assert not (merged and not p1_tracked)
self._wc_tracked = wc_tracked self._wc_tracked = wc_tracked
self._p1_tracked = p1_tracked self._p1_tracked = p1_tracked
self._p2_tracked = p2_tracked self._p2_info = p2_info
self._merged = merged
self._clean_p1 = clean_p1
self._clean_p2 = clean_p2
self._possibly_dirty = possibly_dirty
if parentfiledata is None:
self._mode = None self._mode = None
self._size = None self._size = None
self._mtime = None self._mtime = None
else: if parentfiledata is None:
has_meaningful_mtime = False
has_meaningful_data = False
if has_meaningful_data:
self._mode = parentfiledata[0] self._mode = parentfiledata[0]
self._size = parentfiledata[1] self._size = parentfiledata[1]
if has_meaningful_mtime:
self._mtime = parentfiledata[2] self._mtime = parentfiledata[2]
@classmethod @classmethod
def new_added(cls): def new_added(cls):
"""constructor to help legacy API to build a new "added" item """constructor to help legacy API to build a new "added" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() return cls(wc_tracked=True)
instance._wc_tracked = True
instance._p1_tracked = False
instance._p2_tracked = False
return instance
@classmethod @classmethod
def new_merged(cls): def new_merged(cls):
"""constructor to help legacy API to build a new "merged" item """constructor to help legacy API to build a new "merged" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() return cls(wc_tracked=True, p1_tracked=True, p2_info=True)
instance._wc_tracked = True
instance._p1_tracked = True # might not be True because of rename ?
instance._p2_tracked = True # might not be True because of rename ?
instance._merged = True
return instance
@classmethod @classmethod
def new_from_p2(cls): def new_from_p2(cls):
"""constructor to help legacy API to build a new "from_p2" item """constructor to help legacy API to build a new "from_p2" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() return cls(wc_tracked=True, p2_info=True)
instance._wc_tracked = True
instance._p1_tracked = False # might actually be True
instance._p2_tracked = True
instance._clean_p2 = True
return instance
@classmethod @classmethod
def new_possibly_dirty(cls): def new_possibly_dirty(cls):
"""constructor to help legacy API to build a new "possibly_dirty" item """constructor to help legacy API to build a new "possibly_dirty" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() return cls(wc_tracked=True, p1_tracked=True)
instance._wc_tracked = True
instance._p1_tracked = True
instance._possibly_dirty = True
return instance
@classmethod @classmethod
def new_normal(cls, mode, size, mtime): def new_normal(cls, mode, size, mtime):
"""constructor to help legacy API to build a new "normal" item """constructor to help legacy API to build a new "normal" item
Should eventually be removed Should eventually be removed
""" """
assert size != FROM_P2 assert size != FROM_P2
assert size != NONNORMAL assert size != NONNORMAL
instance = cls() return cls(
instance._wc_tracked = True wc_tracked=True,
instance._p1_tracked = True p1_tracked=True,
instance._mode = mode parentfiledata=(mode, size, mtime),
instance._size = size )
instance._mtime = mtime
return instance
@classmethod @classmethod
def from_v1_data(cls, state, mode, size, mtime): def from_v1_data(cls, state, mode, size, mtime):
"""Build a new DirstateItem object from V1 data """Build a new DirstateItem object from V1 data
Since the dirstate-v1 format is frozen, the signature of this function Since the dirstate-v1 format is frozen, the signature of this function
is not expected to change, unlike the __init__ one. is not expected to change, unlike the __init__ one.
""" """
if state == b'm': if state == b'm':
return cls.new_merged() return cls.new_merged()
elif state == b'a': elif state == b'a':
return cls.new_added() return cls.new_added()
elif state == b'r': elif state == b'r':
instance = cls()
instance._wc_tracked = False
if size == NONNORMAL: if size == NONNORMAL:
instance._merged = True p1_tracked = True
instance._p1_tracked = ( p2_info = True
True # might not be True because of rename ?
)
instance._p2_tracked = (
True # might not be True because of rename ?
)
elif size == FROM_P2: elif size == FROM_P2:
instance._clean_p2 = True p1_tracked = False
instance._p1_tracked = ( p2_info = True
False # We actually don't know (file history)
)
instance._p2_tracked = True
else: else:
instance._p1_tracked = True p1_tracked = True
return instance p2_info = False
return cls(p1_tracked=p1_tracked, p2_info=p2_info)
elif state == b'n': elif state == b'n':
if size == FROM_P2: if size == FROM_P2:
return cls.new_from_p2() return cls.new_from_p2()
elif size == NONNORMAL: elif size == NONNORMAL:
return cls.new_possibly_dirty() return cls.new_possibly_dirty()
elif mtime == AMBIGUOUS_TIME: elif mtime == AMBIGUOUS_TIME:
instance = cls.new_normal(mode, size, 42) instance = cls.new_normal(mode, size, 42)
instance._mtime = None instance._mtime = None
instance._possibly_dirty = True
return instance return instance
else: else:
return cls.new_normal(mode, size, mtime) return cls.new_normal(mode, size, mtime)
else: else:
raise RuntimeError(b'unknown state: %s' % state) raise RuntimeError(b'unknown state: %s' % state)
def set_possibly_dirty(self): def set_possibly_dirty(self):
"""Mark a file as "possibly dirty" """Mark a file as "possibly dirty"
This means the next status call will have to actually check its content This means the next status call will have to actually check its content
to make sure it is correct. to make sure it is correct.
""" """
self._possibly_dirty = True self._mtime = None
def set_clean(self, mode, size, mtime): def set_clean(self, mode, size, mtime):
"""mark a file as "clean" cancelling potential "possibly dirty call" """mark a file as "clean" cancelling potential "possibly dirty call"
Note: this function is a descendant of `dirstate.normal` and is Note: this function is a descendant of `dirstate.normal` and is
currently expected to be call on "normal" entry only. There are not currently expected to be call on "normal" entry only. There are not
reason for this to not change in the future as long as the ccode is reason for this to not change in the future as long as the ccode is
updated to preserve the proper state of the non-normal files. updated to preserve the proper state of the non-normal files.
""" """
self._wc_tracked = True self._wc_tracked = True
self._p1_tracked = True self._p1_tracked = True
self._p2_tracked = False # this might be wrong
self._merged = False
self._clean_p2 = False
self._possibly_dirty = False
self._mode = mode self._mode = mode
self._size = size self._size = size
self._mtime = mtime self._mtime = mtime
def set_tracked(self): def set_tracked(self):
"""mark a file as tracked in the working copy """mark a file as tracked in the working copy
This will ultimately be called by command like `hg add`. This will ultimately be called by command like `hg add`.
""" """
self._wc_tracked = True self._wc_tracked = True
# `set_tracked` is replacing various `normallookup` call. So we set # `set_tracked` is replacing various `normallookup` call. So we mark
# "possibly dirty" to stay on the safe side. # the files as needing lookup
# #
# Consider dropping this in the future in favor of something less broad. # Consider dropping this in the future in favor of something less broad.
self._possibly_dirty = True self._mtime = None
def set_untracked(self): def set_untracked(self):
"""mark a file as untracked in the working copy """mark a file as untracked in the working copy
This will ultimately be called by command like `hg remove`. This will ultimately be called by command like `hg remove`.
""" """
self._wc_tracked = False self._wc_tracked = False
self._mode = None self._mode = None
self._size = None self._size = None
self._mtime = None self._mtime = None
def drop_merge_data(self): def drop_merge_data(self):
"""remove all "merge-only" from a DirstateItem """remove all "merge-only" from a DirstateItem
This is to be call by the dirstatemap code when the second parent is dropped This is to be call by the dirstatemap code when the second parent is dropped
""" """
if not (self.merged or self.from_p2): if self._p2_info:
return self._p2_info = False
self._p1_tracked = self.merged # why is this not already properly set ?
self._merged = False
self._clean_p1 = False
self._clean_p2 = False
self._p2_tracked = False
self._possibly_dirty = True
self._mode = None self._mode = None
self._size = None self._size = None
self._mtime = None self._mtime = None
@property @property
def mode(self): def mode(self):
return self.v1_mode() return self.v1_mode()
@property @property
def size(self): def size(self):
return self.v1_size() return self.v1_size()
@property @property
def tracked(self): def tracked(self):
"""True is the file is tracked in the working copy""" """True is the file is tracked in the working copy"""
return self._wc_tracked return self._wc_tracked
@property @property
def any_tracked(self): def any_tracked(self):
"""True is the file is tracked anywhere (wc or parents)""" """True is the file is tracked anywhere (wc or parents)"""
return self._wc_tracked or self._p1_tracked or self._p2_tracked return self._wc_tracked or self._p1_tracked or self._p2_info
@property @property
def added(self): def added(self):
"""True if the file has been added""" """True if the file has been added"""
return self._wc_tracked and not (self._p1_tracked or self._p2_tracked) return self._wc_tracked and not (self._p1_tracked or self._p2_info)
@property @property
def maybe_clean(self): def maybe_clean(self):
"""True if the file has a chance to be in the "clean" state""" """True if the file has a chance to be in the "clean" state"""
if not self._wc_tracked: if not self._wc_tracked:
return False return False
elif self.added: elif not self._p1_tracked:
return False
elif self._merged:
return False return False
elif self._clean_p2: elif self._p2_info:
return False return False
return True return True
@property @property
def merged(self): def merged(self):
"""True if the file has been merged """True if the file has been merged
Should only be set if a merge is in progress in the dirstate Should only be set if a merge is in progress in the dirstate
""" """
return self._wc_tracked and self._merged return self._wc_tracked and self._p1_tracked and self._p2_info
@property @property
def from_p2(self): def from_p2(self):
"""True if the file have been fetched from p2 during the current merge """True if the file have been fetched from p2 during the current merge
This is only True is the file is currently tracked. This is only True is the file is currently tracked.
Should only be set if a merge is in progress in the dirstate Should only be set if a merge is in progress in the dirstate
""" """
if not self._wc_tracked: return self._wc_tracked and (not self._p1_tracked) and self._p2_info
return False
return self._clean_p2
@property @property
def removed(self): def removed(self):
"""True if the file has been removed""" """True if the file has been removed"""
return not self._wc_tracked and (self._p1_tracked or self._p2_tracked) return not self._wc_tracked and (self._p1_tracked or self._p2_info)
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.any_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'
elif self.merged: elif self.merged:
return b'm' return b'm'
elif self.added: elif self.added:
return b'a' return b'a'
else: else:
return b'n' return b'n'
def v1_mode(self): def v1_mode(self):
"""return a "mode" suitable for v1 serialization""" """return a "mode" suitable for v1 serialization"""
return self._mode if self._mode is not None else 0 return self._mode if self._mode is not None else 0
def v1_size(self): def v1_size(self):
"""return a "size" suitable for v1 serialization""" """return a "size" suitable for v1 serialization"""
if not self.any_tracked: if not self.any_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 and self._merged: elif self.removed and self._p1_tracked and self._p2_info:
return NONNORMAL return NONNORMAL
elif self.removed and self._clean_p2: elif self.removed and self._p2_info:
return FROM_P2 return FROM_P2
elif self.removed: elif self.removed:
return 0 return 0
elif self.merged: elif self.merged:
return FROM_P2 return FROM_P2
elif self.added: elif self.added:
return NONNORMAL return NONNORMAL
elif self.from_p2: elif self.from_p2:
return FROM_P2 return FROM_P2
elif self._possibly_dirty: elif self._size is None:
return self._size if self._size is not None else NONNORMAL return NONNORMAL
else: else:
return self._size return self._size
def v1_mtime(self): def v1_mtime(self):
"""return a "mtime" suitable for v1 serialization""" """return a "mtime" suitable for v1 serialization"""
if not self.any_tracked: if not self.any_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 0 return 0
elif self._possibly_dirty: elif self._mtime is None:
return AMBIGUOUS_TIME return AMBIGUOUS_TIME
elif self.merged: elif self._p2_info:
return AMBIGUOUS_TIME
elif self.added:
return AMBIGUOUS_TIME return AMBIGUOUS_TIME
elif self.from_p2: elif not self._p1_tracked:
return AMBIGUOUS_TIME return AMBIGUOUS_TIME
else: else:
return self._mtime if self._mtime is not None else 0 return self._mtime
def need_delay(self, now): def need_delay(self, now):
"""True if the stored mtime would be ambiguous with the current time""" """True if the stored mtime would be ambiguous with the current time"""
return self.v1_state() == b'n' and self.v1_mtime() == now return self.v1_state() == b'n' and self.v1_mtime() == now
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)

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

} }
/// The C implementation uses all signed types. This will be an issue /// The C implementation uses all signed types. This will be an issue
/// either when 4GB+ source files are commonplace or in 2038, whichever /// either when 4GB+ source files are commonplace or in 2038, whichever
/// comes first. /// comes first.
#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
flags: Flags, flags: Flags,
mode: i32, mode_size: Option<(i32, i32)>,
size: i32, mtime: Option<i32>,
AlphareUnsubmitted
Not Done

Could be worthwhile to add a comment saying that this makes sense semantically because both the mode and size would be None together. But this could also be a follow-up

Alphare: Could be worthwhile to add a comment saying that this makes sense semantically because both the…
mtime: i32,
} }
bitflags! { bitflags! {
pub struct Flags: u8 { struct Flags: u8 {
const WDIR_TRACKED = 1 << 0; const WDIR_TRACKED = 1 << 0;
const P1_TRACKED = 1 << 1; const P1_TRACKED = 1 << 1;
const P2_TRACKED = 1 << 2; const P2_INFO = 1 << 2;
const POSSIBLY_DIRTY = 1 << 3;
const MERGED = 1 << 4;
const CLEAN_P1 = 1 << 5;
const CLEAN_P2 = 1 << 6;
const ENTRYLESS_TREE_NODE = 1 << 7;
} }
} }
pub const V1_RANGEMASK: i32 = 0x7FFFFFFF; pub const V1_RANGEMASK: i32 = 0x7FFFFFFF;
pub const MTIME_UNSET: i32 = -1; pub const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
/// A special value used for internal representation of special case in /// A special value used for internal representation of special case in
/// dirstate v1 format. /// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1; pub const SIZE_NON_NORMAL: i32 = -1;
impl DirstateEntry { impl DirstateEntry {
pub fn new( pub fn new(
flags: Flags, wdir_tracked: bool,
mode_size_mtime: Option<(i32, i32, i32)>, p1_tracked: bool,
p2_info: bool,
mode_size: Option<(i32, i32)>,
mtime: Option<i32>,
) -> Self { ) -> Self {
let (mode, size, mtime) = let mut flags = Flags::empty();
mode_size_mtime.unwrap_or((0, SIZE_NON_NORMAL, MTIME_UNSET)); flags.set(Flags::WDIR_TRACKED, wdir_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_INFO, p2_info);
Self { Self {
flags, flags,
mode, mode_size,
size,
mtime, mtime,
} }
} }
pub fn from_v1_data( pub fn from_v1_data(
state: EntryState, state: EntryState,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,
) -> Self { ) -> Self {
match state { match state {
EntryState::Normal => { EntryState::Normal => {
if size == SIZE_FROM_OTHER_PARENT { if size == SIZE_FROM_OTHER_PARENT {
Self::new_from_p2() Self::new_from_p2()
} else if size == SIZE_NON_NORMAL { } else if size == SIZE_NON_NORMAL {
Self::new_possibly_dirty() Self::new_possibly_dirty()
} else if mtime == MTIME_UNSET { } else if mtime == MTIME_UNSET {
Self { Self {
flags: Flags::WDIR_TRACKED flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
| Flags::P1_TRACKED mode_size: Some((mode, size)),
| Flags::POSSIBLY_DIRTY, mtime: None,
mode,
size,
mtime: 0,
} }
} else { } else {
Self::new_normal(mode, size, mtime) Self::new_normal(mode, size, mtime)
} }
} }
EntryState::Added => Self::new_added(), EntryState::Added => Self::new_added(),
EntryState::Removed => Self { EntryState::Removed => Self {
flags: if size == SIZE_NON_NORMAL { flags: if size == SIZE_NON_NORMAL {
Flags::P1_TRACKED // might not be true because of rename ? Flags::P1_TRACKED | Flags::P2_INFO
| Flags::P2_TRACKED // might not be true because of rename ?
| Flags::MERGED
} else if size == SIZE_FROM_OTHER_PARENT { } else if size == SIZE_FROM_OTHER_PARENT {
// We don’t know if P1_TRACKED should be set (file history) // We don’t know if P1_TRACKED should be set (file history)
Flags::P2_TRACKED | Flags::CLEAN_P2 Flags::P2_INFO
} else { } else {
Flags::P1_TRACKED Flags::P1_TRACKED
}, },
mode: 0, mode_size: None,
size: 0, mtime: None,
mtime: 0,
}, },
EntryState::Merged => Self::new_merged(), EntryState::Merged => Self::new_merged(),
} }
} }
pub fn new_from_p2() -> Self { pub fn new_from_p2() -> Self {
Self { Self {
// might be missing P1_TRACKED // might be missing P1_TRACKED
flags: Flags::WDIR_TRACKED | Flags::P2_TRACKED | Flags::CLEAN_P2, flags: Flags::WDIR_TRACKED | Flags::P2_INFO,
mode: 0, mode_size: None,
size: SIZE_FROM_OTHER_PARENT, mtime: None,
mtime: MTIME_UNSET,
} }
} }
pub fn new_possibly_dirty() -> Self { pub fn new_possibly_dirty() -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
| Flags::P1_TRACKED mode_size: None,
| Flags::POSSIBLY_DIRTY, mtime: None,
mode: 0,
size: SIZE_NON_NORMAL,
mtime: MTIME_UNSET,
} }
} }
pub fn new_added() -> Self { pub fn new_added() -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED, flags: Flags::WDIR_TRACKED,
mode: 0, mode_size: None,
size: SIZE_NON_NORMAL, mtime: None,
mtime: MTIME_UNSET,
} }
} }
pub fn new_merged() -> Self { pub fn new_merged() -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED flags: Flags::WDIR_TRACKED
| Flags::P1_TRACKED // might not be true because of rename ? | Flags::P1_TRACKED // might not be true because of rename ?
| Flags::P2_TRACKED // might not be true because of rename ? | Flags::P2_INFO, // might not be true because of rename ?
| Flags::MERGED, mode_size: None,
mode: 0, mtime: None,
size: SIZE_NON_NORMAL,
mtime: MTIME_UNSET,
} }
} }
pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self { pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode, mode_size: Some((mode, size)),
size, mtime: Some(mtime),
mtime,
} }
} }
/// Creates a new entry in "removed" state. /// Creates a new entry in "removed" state.
/// ///
/// `size` is expected to be zero, `SIZE_NON_NORMAL`, or /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
/// `SIZE_FROM_OTHER_PARENT` /// `SIZE_FROM_OTHER_PARENT`
pub fn new_removed(size: i32) -> Self { pub fn new_removed(size: i32) -> Self {
Self::from_v1_data(EntryState::Removed, 0, size, 0) Self::from_v1_data(EntryState::Removed, 0, size, 0)
} }
pub fn tracked(&self) -> bool { pub fn tracked(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED) self.flags.contains(Flags::WDIR_TRACKED)
} }
fn tracked_in_any_parent(&self) -> bool { fn in_either_parent(&self) -> bool {
self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED) self.flags.intersects(Flags::P1_TRACKED | Flags::P2_INFO)
} }
pub fn removed(&self) -> bool { pub fn removed(&self) -> bool {
self.tracked_in_any_parent() self.in_either_parent() && !self.flags.contains(Flags::WDIR_TRACKED)
&& !self.flags.contains(Flags::WDIR_TRACKED)
} }
pub fn merged(&self) -> bool { pub fn merged(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED) self.flags
.contains(Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO)
} }
pub fn added(&self) -> bool { pub fn added(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED) self.flags.contains(Flags::WDIR_TRACKED) && !self.in_either_parent()
&& !self.tracked_in_any_parent()
} }
pub fn from_p2(&self) -> bool { pub fn from_p2(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2) self.flags.contains(Flags::WDIR_TRACKED | Flags::P2_INFO)
&& !self.flags.contains(Flags::P1_TRACKED)
} }
pub fn maybe_clean(&self) -> bool { pub fn maybe_clean(&self) -> bool {
if !self.flags.contains(Flags::WDIR_TRACKED) { if !self.flags.contains(Flags::WDIR_TRACKED) {
false false
} else if self.added() { } else if !self.flags.contains(Flags::P1_TRACKED) {
false
} else if self.flags.contains(Flags::MERGED) {
false false
} else if self.flags.contains(Flags::CLEAN_P2) { } else if self.flags.contains(Flags::P2_INFO) {
false false
} else { } else {
true true
} }
} }
pub fn any_tracked(&self) -> bool { pub fn any_tracked(&self) -> bool {
self.flags.intersects( self.flags.intersects(
Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_TRACKED, Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
) )
} }
pub fn state(&self) -> EntryState { fn v1_state(&self) -> EntryState {
if !self.any_tracked() {
// TODO: return an Option instead?
AlphareUnsubmitted
Not Done

I don't think returning an Option here would be valuable, IMO panicking is the right choice

Alphare: I don't think returning an `Option` here would be valuable, IMO panicking is the right choice
panic!("Accessing v1_state of an untracked DirstateEntry")
}
if self.removed() { if self.removed() {
EntryState::Removed EntryState::Removed
} else if self.merged() { } else if self.merged() {
EntryState::Merged EntryState::Merged
} else if self.added() { } else if self.added() {
EntryState::Added EntryState::Added
} else { } else {
EntryState::Normal EntryState::Normal
} }
} }
pub fn mode(&self) -> i32 { fn v1_mode(&self) -> i32 {
self.mode if let Some((mode, _size)) = self.mode_size {
mode
} else {
0
}
} }
pub fn size(&self) -> i32 { fn v1_size(&self) -> i32 {
if self.removed() && self.flags.contains(Flags::MERGED) { if !self.any_tracked() {
// TODO: return an Option instead?
panic!("Accessing v1_size of an untracked DirstateEntry")
}
if self.removed()
&& self.flags.contains(Flags::P1_TRACKED | Flags::P2_INFO)
{
SIZE_NON_NORMAL SIZE_NON_NORMAL
} else if self.removed() && self.flags.contains(Flags::CLEAN_P2) { } else if self.removed() && self.flags.contains(Flags::P2_INFO) {
SIZE_FROM_OTHER_PARENT SIZE_FROM_OTHER_PARENT
} else if self.removed() { } else if self.removed() {
0 0
} else if self.merged() { } else if self.merged() {
SIZE_FROM_OTHER_PARENT SIZE_FROM_OTHER_PARENT
} else if self.added() { } else if self.added() {
SIZE_NON_NORMAL SIZE_NON_NORMAL
} else if self.from_p2() { } else if self.from_p2() {
SIZE_FROM_OTHER_PARENT SIZE_FROM_OTHER_PARENT
} else if self.flags.contains(Flags::POSSIBLY_DIRTY) { } else if let Some((_mode, size)) = self.mode_size {
self.size // TODO: SIZE_NON_NORMAL ? size
} else { } else {
self.size SIZE_NON_NORMAL
} }
} }
pub fn mtime(&self) -> i32 { fn v1_mtime(&self) -> i32 {
if !self.any_tracked() {
// TODO: return an Option instead?
panic!("Accessing v1_mtime of an untracked DirstateEntry")
}
if self.removed() { if self.removed() {
0 0
} else if self.flags.contains(Flags::POSSIBLY_DIRTY) { } else if self.flags.contains(Flags::P2_INFO) {
MTIME_UNSET
} else if self.merged() {
MTIME_UNSET
} else if self.added() {
MTIME_UNSET MTIME_UNSET
} else if self.from_p2() { } else if !self.flags.contains(Flags::P1_TRACKED) {
MTIME_UNSET MTIME_UNSET
} else { } else {
self.mtime self.mtime.unwrap_or(MTIME_UNSET)
} }
} }
pub fn drop_merge_data(&mut self) { // TODO: return `Option<EntryState>`? None when `!self.any_tracked`
if self.flags.contains(Flags::CLEAN_P1) pub fn state(&self) -> EntryState {
|| self.flags.contains(Flags::CLEAN_P2) self.v1_state()
|| self.flags.contains(Flags::MERGED) }
|| self.flags.contains(Flags::P2_TRACKED)
{ // TODO: return Option?
if self.flags.contains(Flags::MERGED) { pub fn mode(&self) -> i32 {
self.flags.insert(Flags::P1_TRACKED); self.v1_mode()
} else { }
self.flags.remove(Flags::P1_TRACKED);
// TODO: return Option?
pub fn size(&self) -> i32 {
self.v1_size()
} }
self.flags.remove(
Flags::MERGED // TODO: return Option?
| Flags::CLEAN_P1 pub fn mtime(&self) -> i32 {
| Flags::CLEAN_P2 self.v1_mtime()
| Flags::P2_TRACKED, }
);
self.flags.insert(Flags::POSSIBLY_DIRTY); pub fn drop_merge_data(&mut self) {
self.mode = 0; if self.flags.contains(Flags::P2_INFO) {
self.mtime = 0; self.flags.remove(Flags::P2_INFO);
// size = None on the python size turn into size = NON_NORMAL when self.mode_size = None;
// accessed. So the next line is currently required, but a some self.mtime = None;
// future clean up would be welcome.
self.size = SIZE_NON_NORMAL;
} }
} }
pub fn set_possibly_dirty(&mut self) { pub fn set_possibly_dirty(&mut self) {
self.flags.insert(Flags::POSSIBLY_DIRTY) self.mtime = None
} }
pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) { pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) {
self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED); self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
self.flags.remove( self.mode_size = Some((mode, size));
Flags::P2_TRACKED // This might be wrong self.mtime = Some(mtime);
| Flags::MERGED
| Flags::CLEAN_P2
| Flags::POSSIBLY_DIRTY,
);
self.mode = mode;
self.size = size;
self.mtime = mtime;
} }
pub fn set_tracked(&mut self) { pub fn set_tracked(&mut self) {
self.flags self.flags.insert(Flags::WDIR_TRACKED);
.insert(Flags::WDIR_TRACKED | Flags::POSSIBLY_DIRTY); // `set_tracked` is replacing various `normallookup` call. So we mark
// size = None on the python size turn into size = NON_NORMAL when // the files as needing lookup
// accessed. So the next line is currently required, but a some future //
// clean up would be welcome. // Consider dropping this in the future in favor of something less
self.size = SIZE_NON_NORMAL; // broad.
self.mtime = None;
} }
pub fn set_untracked(&mut self) { pub fn set_untracked(&mut self) {
self.flags.remove(Flags::WDIR_TRACKED); self.flags.remove(Flags::WDIR_TRACKED);
self.mode = 0; self.mode_size = None;
self.size = 0; self.mtime = None;
self.mtime = 0;
} }
/// Returns `(state, mode, size, mtime)` for the puprose of serialization /// Returns `(state, mode, size, mtime)` for the puprose of serialization
/// in the dirstate-v1 format. /// in the dirstate-v1 format.
/// ///
/// 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.v1_state().into(),
self.v1_mode(),
self.v1_size(),
self.v1_mtime(),
)
} }
pub(crate) fn is_from_other_parent(&self) -> bool { pub(crate) 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,
filesystem_metadata: &std::fs::Metadata, filesystem_metadata: &std::fs::Metadata,
) -> bool { ) -> bool {
use std::os::unix::fs::MetadataExt; use std::os::unix::fs::MetadataExt;
const EXEC_BIT_MASK: u32 = 0o100; const EXEC_BIT_MASK: u32 = 0o100;
let dirstate_exec_bit = (self.mode() as u32) & EXEC_BIT_MASK; let dirstate_exec_bit = (self.mode() as u32) & EXEC_BIT_MASK;
let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK; let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
dirstate_exec_bit != fs_exec_bit dirstate_exec_bit != fs_exec_bit
} }
/// Returns a `(state, mode, size, mtime)` tuple as for /// Returns a `(state, mode, size, mtime)` tuple as for
/// `DirstateMapMethods::debug_iter`. /// `DirstateMapMethods::debug_iter`.
pub fn debug_tuple(&self) -> (u8, i32, i32, i32) { pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
let state = if self.flags.contains(Flags::ENTRYLESS_TREE_NODE) { (self.state().into(), self.mode(), self.size(), self.mtime())
b' '
} else {
self.state().into()
};
(state, self.mode(), self.size(), self.mtime())
} }
pub fn mtime_is_ambiguous(&self, now: i32) -> bool { pub fn mtime_is_ambiguous(&self, now: i32) -> bool {
self.state() == EntryState::Normal && self.mtime() == now self.state() == EntryState::Normal && self.mtime() == now
} }
pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool { pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool {
let ambiguous = self.mtime_is_ambiguous(now); let ambiguous = self.mtime_is_ambiguous(now);
if ambiguous { if ambiguous {
// 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.
self.clear_mtime() self.set_possibly_dirty()
} }
ambiguous ambiguous
} }
pub fn clear_mtime(&mut self) {
self.mtime = -1;
}
} }
impl EntryState { impl EntryState {
pub fn is_tracked(self) -> bool { pub fn is_tracked(self) -> bool {
use EntryState::*; use EntryState::*;
match self { match self {
Normal | Added | Merged => true, Normal | Added | Merged => true,
Removed => false, Removed => false,

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

for path in paths { for path in paths {
if let Some(node) = Self::get_node_mut( if let Some(node) = Self::get_node_mut(
self.on_disk, self.on_disk,
&mut self.unreachable_bytes, &mut self.unreachable_bytes,
&mut self.root, &mut self.root,
path.as_ref(), path.as_ref(),
)? { )? {
if let NodeData::Entry(entry) = &mut node.data { if let NodeData::Entry(entry) = &mut node.data {
entry.clear_mtime(); entry.set_possibly_dirty();
} }
} }
} }
Ok(()) Ok(())
} }
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 {

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

use cpython::exc; use cpython::exc;
use cpython::PyBytes; use cpython::PyBytes;
use cpython::PyErr; use cpython::PyErr;
use cpython::PyNone; use cpython::PyNone;
use cpython::PyObject; use cpython::PyObject;
use cpython::PyResult; use cpython::PyResult;
use cpython::Python; use cpython::Python;
use cpython::PythonObject; use cpython::PythonObject;
use hg::dirstate::entry::Flags;
use hg::dirstate::DirstateEntry; use hg::dirstate::DirstateEntry;
use hg::dirstate::EntryState; use hg::dirstate::EntryState;
use std::cell::Cell; use std::cell::Cell;
use std::convert::TryFrom; use std::convert::TryFrom;
py_class!(pub class DirstateItem |py| { py_class!(pub class DirstateItem |py| {
data entry: Cell<DirstateEntry>; data entry: Cell<DirstateEntry>;
def __new__( def __new__(
_cls, _cls,
wc_tracked: bool = false, wc_tracked: bool = false,
p1_tracked: bool = false, p1_tracked: bool = false,
p2_tracked: bool = false, p2_info: bool = false,
merged: bool = false, has_meaningful_data: bool = true,
clean_p1: bool = false, has_meaningful_mtime: bool = true,
clean_p2: bool = false,
possibly_dirty: bool = false,
parentfiledata: Option<(i32, i32, i32)> = None, parentfiledata: Option<(i32, i32, i32)> = None,
) -> PyResult<DirstateItem> { ) -> PyResult<DirstateItem> {
let mut flags = Flags::empty(); let mut mode_size_opt = None;
flags.set(Flags::WDIR_TRACKED, wc_tracked); let mut mtime_opt = None;
flags.set(Flags::P1_TRACKED, p1_tracked); if let Some((mode, size, mtime)) = parentfiledata {
flags.set(Flags::P2_TRACKED, p2_tracked); if has_meaningful_data {
flags.set(Flags::MERGED, merged); mode_size_opt = Some((mode, size))
flags.set(Flags::CLEAN_P1, clean_p1); }
flags.set(Flags::CLEAN_P2, clean_p2); if has_meaningful_mtime {
flags.set(Flags::POSSIBLY_DIRTY, possibly_dirty); mtime_opt = Some(mtime)
let entry = DirstateEntry::new(flags, parentfiledata); }
}
let entry = DirstateEntry::new(
wc_tracked, p1_tracked, p2_info, mode_size_opt, mtime_opt,
);
DirstateItem::create_instance(py, Cell::new(entry)) DirstateItem::create_instance(py, Cell::new(entry))
} }
@property @property
def state(&self) -> PyResult<PyBytes> { def state(&self) -> PyResult<PyBytes> {
let state_byte: u8 = self.entry(py).get().state().into(); let state_byte: u8 = self.entry(py).get().state().into();
Ok(PyBytes::new(py, &[state_byte])) Ok(PyBytes::new(py, &[state_byte]))
} }