dirstate-item: introduce a `maybe_clean` property

It is useful for some extension that seek to invalidate some state.

Differential Revision: https://phab.mercurial-scm.org/D11523

mercurial/cext/parsers.c

@@ -1,1216 +1,1233 b''
 /*
  parsers.c - efficient content parsing
 
  Copyright 2008 Olivia Mackall <[e-mail]> and others
 
  This software may be used and distributed according to the terms of
  the GNU General Public License, incorporated herein by reference.
 */
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <ctype.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "bitmanipulation.h"
 #include "charencode.h"
 #include "util.h"
 
 #ifdef IS_PY3K
 /* The mapping of Python types is meant to be temporary to get Python
  * 3 to compile. We should remove this once Python 3 support is fully
  * supported and proper types are used in the extensions themselves. */
 #define PyInt_Check PyLong_Check
 #define PyInt_FromLong PyLong_FromLong
 #define PyInt_FromSsize_t PyLong_FromSsize_t
 #define PyInt_AsLong PyLong_AsLong
 #endif
 
 static const char *const versionerrortext = "Python minor version mismatch";
 
 static const int dirstate_v1_from_p2 = -2;
 static const int dirstate_v1_nonnormal = -1;
 static const int ambiguous_time = -1;
 
 static PyObject *dict_new_presized(PyObject *self, PyObject *args)
 {
 	Py_ssize_t expected_size;
 
 	if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) {
 		return NULL;
 	}
 
 	return _dict_new_presized(expected_size);
 }
 
 static PyObject *dirstate_item_new(PyTypeObject *subtype, PyObject *args,
                                    PyObject *kwds)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	dirstateItemObject *t;
 	int wc_tracked;
 	int p1_tracked;
 	int p2_tracked;
 	int merged;
 	int clean_p1;
 	int clean_p2;
 	int possibly_dirty;
 	PyObject *parentfiledata;
 	static char *keywords_name[] = {
 	    "wc_tracked",     "p1_tracked",     "p2_tracked",
 	    "merged",         "clean_p1",       "clean_p2",
 	    "possibly_dirty", "parentfiledata", NULL,
 	};
 	wc_tracked = 0;
 	p1_tracked = 0;
 	p2_tracked = 0;
 	merged = 0;
 	clean_p1 = 0;
 	clean_p2 = 0;
 	possibly_dirty = 0;
 	parentfiledata = Py_None;
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiiiO", keywords_name,
 	                                 &wc_tracked, &p1_tracked, &p2_tracked,
 	                                 &merged, &clean_p1, &clean_p2,
 	                                 &possibly_dirty, &parentfiledata
 
 	                                 )) {
 		return NULL;
 	}
 	if (merged && (clean_p1 || clean_p2)) {
 		PyErr_SetString(PyExc_RuntimeError,
 		                "`merged` argument incompatible with "
 		                "`clean_p1`/`clean_p2`");
 		return NULL;
 	}
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 
 	t->flags = 0;
 	if (wc_tracked) {
 		t->flags |= dirstate_flag_wc_tracked;
 	}
 	if (p1_tracked) {
 		t->flags |= dirstate_flag_p1_tracked;
 	}
 	if (p2_tracked) {
 		t->flags |= dirstate_flag_p2_tracked;
 	}
 	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 (!PyTuple_CheckExact(parentfiledata)) {
 			PyErr_SetString(
 			    PyExc_TypeError,
 			    "parentfiledata should be a Tuple or None");
 			return NULL;
 		}
 		t->mode =
 		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0));
 		t->size =
 		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 1));
 		t->mtime =
 		    (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 2));
 	}
 	return (PyObject *)t;
 }
 
 static void dirstate_item_dealloc(PyObject *o)
 {
 	PyObject_Del(o);
 }
 
 static inline bool dirstate_item_c_tracked(dirstateItemObject *self)
 {
 	return (self->flags & dirstate_flag_wc_tracked);
 }
 
 static inline bool dirstate_item_c_added(dirstateItemObject *self)
 {
 	unsigned char mask =
 	    (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	     dirstate_flag_p2_tracked);
 	unsigned char target = dirstate_flag_wc_tracked;
 	return (self->flags & mask) == target;
 }
 
 static inline bool dirstate_item_c_removed(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_wc_tracked) {
 		return false;
 	}
 	return (self->flags &
 	        (dirstate_flag_p1_tracked | dirstate_flag_p2_tracked));
 }
 
 static inline bool dirstate_item_c_merged(dirstateItemObject *self)
 {
 	return ((self->flags & dirstate_flag_wc_tracked) &&
 	        (self->flags & dirstate_flag_merged));
 }
 
 static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)
 {
 	if (!dirstate_item_c_tracked(self)) {
 		return false;
 	}
 	return (self->flags & dirstate_flag_clean_p2);
 }
 
 static inline char dirstate_item_c_v1_state(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		return 'r';
 	} else if (dirstate_item_c_merged(self)) {
 		return 'm';
 	} else if (dirstate_item_c_added(self)) {
 		return 'a';
 	} else {
 		return 'n';
 	}
 }
 
 static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
 {
 	return self->mode;
 }
 
 static inline int dirstate_item_c_v1_size(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self) &&
 	    (self->flags & dirstate_flag_merged)) {
 		return dirstate_v1_nonnormal;
 	} else if (dirstate_item_c_removed(self) &&
 	           (self->flags & dirstate_flag_clean_p2)) {
 		return dirstate_v1_from_p2;
 	} else if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (dirstate_item_c_merged(self)) {
 		return dirstate_v1_from_p2;
 	} else if (dirstate_item_c_added(self)) {
 		return dirstate_v1_nonnormal;
 	} else if (dirstate_item_c_from_p2(self)) {
 		return dirstate_v1_from_p2;
 	} else if (self->flags & dirstate_flag_possibly_dirty) {
 		return self->size; /* NON NORMAL ? */
 	} else {
 		return self->size;
 	}
 }
 
 static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (self->flags & dirstate_flag_possibly_dirty) {
 		return ambiguous_time;
 	} else if (dirstate_item_c_merged(self)) {
 		return ambiguous_time;
 	} else if (dirstate_item_c_added(self)) {
 		return ambiguous_time;
 	} else if (dirstate_item_c_from_p2(self)) {
 		return ambiguous_time;
 	} else {
 		return self->mtime;
 	}
 }
 
 static PyObject *dirstate_item_v1_state(dirstateItemObject *self)
 {
 	char state = dirstate_item_c_v1_state(self);
 	return PyBytes_FromStringAndSize(&state, 1);
 };
 
 static PyObject *dirstate_item_v1_mode(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_mode(self));
 };
 
 static PyObject *dirstate_item_v1_size(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_size(self));
 };
 
 static PyObject *dirstate_item_v1_mtime(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_mtime(self));
 };
 
 static PyObject *dirstate_item_need_delay(dirstateItemObject *self,
                                           PyObject *value)
 {
 	long now;
 	if (!pylong_to_long(value, &now)) {
 		return NULL;
 	}
 	if (dirstate_item_c_v1_state(self) == 'n' &&
 	    dirstate_item_c_v1_mtime(self) == now) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 /* This will never change since it's bound to V1
  */
 static inline dirstateItemObject *
 dirstate_item_from_v1_data(char state, int mode, int size, int mtime)
 {
 	dirstateItemObject *t =
 	    PyObject_New(dirstateItemObject, &dirstateItemType);
 	if (!t) {
 		return NULL;
 	}
 
 	if (state == 'm') {
 		t->flags =
 		    (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 		     dirstate_flag_p2_tracked | dirstate_flag_merged);
 		t->mode = 0;
 		t->size = dirstate_v1_from_p2;
 		t->mtime = ambiguous_time;
 	} else if (state == 'a') {
 		t->flags = dirstate_flag_wc_tracked;
 		t->mode = 0;
 		t->size = dirstate_v1_nonnormal;
 		t->mtime = ambiguous_time;
 	} else if (state == 'r') {
 		t->mode = 0;
 		t->size = 0;
 		t->mtime = 0;
 		if (size == dirstate_v1_nonnormal) {
 			t->flags =
 			    (dirstate_flag_p1_tracked |
 			     dirstate_flag_p2_tracked | dirstate_flag_merged);
 		} else if (size == dirstate_v1_from_p2) {
 			t->flags =
 			    (dirstate_flag_p2_tracked | dirstate_flag_clean_p2);
 		} else {
 			t->flags = dirstate_flag_p1_tracked;
 		}
 	} else if (state == 'n') {
 		if (size == dirstate_v1_from_p2) {
 			t->flags =
 			    (dirstate_flag_wc_tracked |
 			     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) {
 			t->flags = (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) {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked |
 			            dirstate_flag_possibly_dirty);
 			t->mode = mode;
 			t->size = size;
 			t->mtime = 0;
 		} else {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked);
 			t->mode = mode;
 			t->size = size;
 			t->mtime = mtime;
 		}
 	} else {
 		PyErr_Format(PyExc_RuntimeError,
 		             "unknown state: `%c` (%d, %d, %d)", state, mode,
 		             size, mtime, NULL);
 		Py_DECREF(t);
 		return NULL;
 	}
 
 	return t;
 }
 
 /* This will never change since it's bound to V1, unlike `dirstate_item_new` */
 static PyObject *dirstate_item_from_v1_meth(PyTypeObject *subtype,
                                             PyObject *args)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	char state;
 	int size, mode, mtime;
 	if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
 		return NULL;
 	}
 	return (PyObject *)dirstate_item_from_v1_data(state, mode, size, mtime);
 };
 
 /* constructor to help legacy API to build a new "added" item
 
 Should eventually be removed */
 static PyObject *dirstate_item_new_added(PyTypeObject *subtype)
 {
 	dirstateItemObject *t;
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = dirstate_flag_wc_tracked;
 	t->mode = 0;
 	t->size = dirstate_v1_nonnormal;
 	t->mtime = ambiguous_time;
 	return (PyObject *)t;
 };
 
 /* constructor to help legacy API to build a new "merged" item
 
 Should eventually be removed */
 static PyObject *dirstate_item_new_merged(PyTypeObject *subtype)
 {
 	dirstateItemObject *t;
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	            dirstate_flag_p2_tracked | dirstate_flag_merged);
 	t->mode = 0;
 	t->size = dirstate_v1_from_p2;
 	t->mtime = ambiguous_time;
 	return (PyObject *)t;
 };
 
 /* constructor to help legacy API to build a new "from_p2" item
 
 Should eventually be removed */
 static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	dirstateItemObject *t;
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p2_tracked |
 	            dirstate_flag_clean_p2);
 	t->mode = 0;
 	t->size = dirstate_v1_from_p2;
 	t->mtime = ambiguous_time;
 	return (PyObject *)t;
 };
 
 /* constructor to help legacy API to build a new "possibly" item
 
 Should eventually be removed */
 static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	dirstateItemObject *t;
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	            dirstate_flag_possibly_dirty);
 	t->mode = 0;
 	t->size = dirstate_v1_nonnormal;
 	t->mtime = ambiguous_time;
 	return (PyObject *)t;
 };
 
 /* constructor to help legacy API to build a new "normal" item
 
 Should eventually be removed */
 static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
 {
 	/* We do all the initialization here and not a tp_init function because
 	 * dirstate_item is immutable. */
 	dirstateItemObject *t;
 	int size, mode, mtime;
 	if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
 		return NULL;
 	}
 
 	t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
 	if (!t) {
 		return NULL;
 	}
 	t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked);
 	t->mode = mode;
 	t->size = size;
 	t->mtime = mtime;
 	return (PyObject *)t;
 };
 
 /* This means the next status call will have to actually check its content
    to make sure it is correct. */
 static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
 {
 	self->flags |= dirstate_flag_possibly_dirty;
 	Py_RETURN_NONE;
 }
 
 /* See docstring of the python implementation for details */
 static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
                                          PyObject *args)
 {
 	int size, mode, mtime;
 	if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
 		return NULL;
 	}
 	self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
 	self->mode = mode;
 	self->size = size;
 	self->mtime = mtime;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
 {
 	self->flags |= dirstate_flag_wc_tracked;
 	self->flags |= dirstate_flag_possibly_dirty;
 	/* size = None on the python size turn into size = NON_NORMAL when
 	 * accessed. So the next line is currently required, but a some future
 	 * clean up would be welcome. */
 	self->size = dirstate_v1_nonnormal;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
 {
 	self->flags &= ~dirstate_flag_wc_tracked;
 	self->mode = 0;
 	self->mtime = 0;
 	self->size = 0;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
 {
 	if (dirstate_item_c_merged(self) || dirstate_item_c_from_p2(self)) {
 		if (dirstate_item_c_merged(self)) {
 			self->flags |= dirstate_flag_p1_tracked;
 		} else {
 			self->flags &= ~dirstate_flag_p1_tracked;
 		}
 		self->flags &=
 		    ~(dirstate_flag_merged | dirstate_flag_clean_p1 |
 		      dirstate_flag_clean_p2 | dirstate_flag_p2_tracked);
 		self->flags |= dirstate_flag_possibly_dirty;
 		self->mode = 0;
 		self->mtime = 0;
 		/* size = None on the python size turn into size = NON_NORMAL
 		 * when accessed. So the next line is currently required, but a
 		 * some future clean up would be welcome. */
 		self->size = dirstate_v1_nonnormal;
 	}
 	Py_RETURN_NONE;
 }
 static PyMethodDef dirstate_item_methods[] = {
     {"v1_state", (PyCFunction)dirstate_item_v1_state, METH_NOARGS,
      "return a \"state\" suitable for v1 serialization"},
     {"v1_mode", (PyCFunction)dirstate_item_v1_mode, METH_NOARGS,
      "return a \"mode\" suitable for v1 serialization"},
     {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
      "return a \"size\" suitable for v1 serialization"},
     {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
      "return a \"mtime\" suitable for v1 serialization"},
     {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,
      "True if the stored mtime would be ambiguous with the current time"},
     {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
      METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
     {"new_added", (PyCFunction)dirstate_item_new_added,
      METH_NOARGS | METH_CLASS,
      "constructor to help legacy API to build a new \"added\" item"},
     {"new_merged", (PyCFunction)dirstate_item_new_merged,
      METH_NOARGS | METH_CLASS,
      "constructor to help legacy API to build a new \"merged\" item"},
     {"new_from_p2", (PyCFunction)dirstate_item_new_from_p2,
      METH_NOARGS | METH_CLASS,
      "constructor to help legacy API to build a new \"from_p2\" item"},
     {"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,
      METH_NOARGS | METH_CLASS,
      "constructor to help legacy API to build a new \"possibly_dirty\" item"},
     {"new_normal", (PyCFunction)dirstate_item_new_normal,
      METH_VARARGS | METH_CLASS,
      "constructor to help legacy API to build a new \"normal\" item"},
     {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
      METH_NOARGS, "mark a file as \"possibly dirty\""},
     {"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
      "mark a file as \"clean\""},
     {"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
      "mark a file as \"tracked\""},
     {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
      "mark a file as \"untracked\""},
     {"drop_merge_data", (PyCFunction)dirstate_item_drop_merge_data, METH_NOARGS,
      "remove all \"merge-only\" from a DirstateItem"},
     {NULL} /* Sentinel */
 };
 
 static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_mode(self));
 };
 
 static PyObject *dirstate_item_get_size(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_size(self));
 };
 
 static PyObject *dirstate_item_get_mtime(dirstateItemObject *self)
 {
 	return PyInt_FromLong(dirstate_item_c_v1_mtime(self));
 };
 
 static PyObject *dirstate_item_get_state(dirstateItemObject *self)
 {
 	char state = dirstate_item_c_v1_state(self);
 	return PyBytes_FromStringAndSize(&state, 1);
 };
 
 static PyObject *dirstate_item_get_tracked(dirstateItemObject *self)
 {
 	if (dirstate_item_c_tracked(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_added(dirstateItemObject *self)
 {
 	if (dirstate_item_c_added(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_merged(dirstateItemObject *self)
 {
 	if (dirstate_item_c_merged(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_from_p2(dirstateItemObject *self)
 {
 	if (dirstate_item_c_from_p2(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
+static PyObject *dirstate_item_get_maybe_clean(dirstateItemObject *self)
+{
+	if (!(self->flags & dirstate_flag_wc_tracked)) {
+		Py_RETURN_FALSE;
+	} else if (dirstate_item_c_added(self)) {
+		Py_RETURN_FALSE;
+	} else if (self->flags & dirstate_flag_merged) {
+		Py_RETURN_FALSE;
+	} else if (self->flags & dirstate_flag_clean_p2) {
+		Py_RETURN_FALSE;
+	} else {
+		Py_RETURN_TRUE;
+	}
+};
+
 static PyObject *dirstate_item_get_removed(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyGetSetDef dirstate_item_getset[] = {
     {"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
     {"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
     {"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
     {"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
     {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
     {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
     {"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
     {"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
+    {"maybe_clean", (getter)dirstate_item_get_maybe_clean, NULL, "maybe_clean",
+     NULL},
     {"removed", (getter)dirstate_item_get_removed, NULL, "removed", NULL},
     {NULL} /* Sentinel */
 };
 
 PyTypeObject dirstateItemType = {
     PyVarObject_HEAD_INIT(NULL, 0)     /* header */
     "dirstate_tuple",                  /* tp_name */
     sizeof(dirstateItemObject),        /* tp_basicsize */
     0,                                 /* tp_itemsize */
     (destructor)dirstate_item_dealloc, /* tp_dealloc */
     0,                                 /* tp_print */
     0,                                 /* tp_getattr */
     0,                                 /* tp_setattr */
     0,                                 /* tp_compare */
     0,                                 /* tp_repr */
     0,                                 /* tp_as_number */
     0,                                 /* tp_as_sequence */
     0,                                 /* tp_as_mapping */
     0,                                 /* tp_hash  */
     0,                                 /* tp_call */
     0,                                 /* tp_str */
     0,                                 /* tp_getattro */
     0,                                 /* tp_setattro */
     0,                                 /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT,                /* tp_flags */
     "dirstate tuple",                  /* tp_doc */
     0,                                 /* tp_traverse */
     0,                                 /* tp_clear */
     0,                                 /* tp_richcompare */
     0,                                 /* tp_weaklistoffset */
     0,                                 /* tp_iter */
     0,                                 /* tp_iternext */
     dirstate_item_methods,             /* tp_methods */
     0,                                 /* tp_members */
     dirstate_item_getset,              /* tp_getset */
     0,                                 /* tp_base */
     0,                                 /* tp_dict */
     0,                                 /* tp_descr_get */
     0,                                 /* tp_descr_set */
     0,                                 /* tp_dictoffset */
     0,                                 /* tp_init */
     0,                                 /* tp_alloc */
     dirstate_item_new,                 /* tp_new */
 };
 
 static PyObject *parse_dirstate(PyObject *self, PyObject *args)
 {
 	PyObject *dmap, *cmap, *parents = NULL, *ret = NULL;
 	PyObject *fname = NULL, *cname = NULL, *entry = NULL;
 	char state, *cur, *str, *cpos;
 	int mode, size, mtime;
 	unsigned int flen, pos = 40;
 	Py_ssize_t len = 40;
 	Py_ssize_t readlen;
 
 	if (!PyArg_ParseTuple(
 	        args, PY23("O!O!s#:parse_dirstate", "O!O!y#:parse_dirstate"),
 	        &PyDict_Type, &dmap, &PyDict_Type, &cmap, &str, &readlen)) {
 		goto quit;
 	}
 
 	len = readlen;
 
 	/* read parents */
 	if (len < 40) {
 		PyErr_SetString(PyExc_ValueError,
 		                "too little data for parents");
 		goto quit;
 	}
 
 	parents = Py_BuildValue(PY23("s#s#", "y#y#"), str, (Py_ssize_t)20,
 	                        str + 20, (Py_ssize_t)20);
 	if (!parents) {
 		goto quit;
 	}
 
 	/* read filenames */
 	while (pos >= 40 && pos < len) {
 		if (pos + 17 > len) {
 			PyErr_SetString(PyExc_ValueError,
 			                "overflow in dirstate");
 			goto quit;
 		}
 		cur = str + pos;
 		/* unpack header */
 		state = *cur;
 		mode = getbe32(cur + 1);
 		size = getbe32(cur + 5);
 		mtime = getbe32(cur + 9);
 		flen = getbe32(cur + 13);
 		pos += 17;
 		cur += 17;
 		if (flen > len - pos) {
 			PyErr_SetString(PyExc_ValueError,
 			                "overflow in dirstate");
 			goto quit;
 		}
 
 		entry = (PyObject *)dirstate_item_from_v1_data(state, mode,
 		                                               size, mtime);
 		if (!entry)
 			goto quit;
 		cpos = memchr(cur, 0, flen);
 		if (cpos) {
 			fname = PyBytes_FromStringAndSize(cur, cpos - cur);
 			cname = PyBytes_FromStringAndSize(
 			    cpos + 1, flen - (cpos - cur) - 1);
 			if (!fname || !cname ||
 			    PyDict_SetItem(cmap, fname, cname) == -1 ||
 			    PyDict_SetItem(dmap, fname, entry) == -1) {
 				goto quit;
 			}
 			Py_DECREF(cname);
 		} else {
 			fname = PyBytes_FromStringAndSize(cur, flen);
 			if (!fname ||
 			    PyDict_SetItem(dmap, fname, entry) == -1) {
 				goto quit;
 			}
 		}
 		Py_DECREF(fname);
 		Py_DECREF(entry);
 		fname = cname = entry = NULL;
 		pos += flen;
 	}
 
 	ret = parents;
 	Py_INCREF(ret);
 quit:
 	Py_XDECREF(fname);
 	Py_XDECREF(cname);
 	Py_XDECREF(entry);
 	Py_XDECREF(parents);
 	return ret;
 }
 
 /*
  * Efficiently pack a dirstate object into its on-disk format.
  */
 static PyObject *pack_dirstate(PyObject *self, PyObject *args)
 {
 	PyObject *packobj = NULL;
 	PyObject *map, *copymap, *pl, *mtime_unset = NULL;
 	Py_ssize_t nbytes, pos, l;
 	PyObject *k, *v = NULL, *pn;
 	char *p, *s;
 	int now;
 
 	if (!PyArg_ParseTuple(args, "O!O!O!i:pack_dirstate", &PyDict_Type, &map,
 	                      &PyDict_Type, &copymap, &PyTuple_Type, &pl,
 	                      &now)) {
 		return NULL;
 	}
 
 	if (PyTuple_Size(pl) != 2) {
 		PyErr_SetString(PyExc_TypeError, "expected 2-element tuple");
 		return NULL;
 	}
 
 	/* Figure out how much we need to allocate. */
 	for (nbytes = 40, pos = 0; PyDict_Next(map, &pos, &k, &v);) {
 		PyObject *c;
 		if (!PyBytes_Check(k)) {
 			PyErr_SetString(PyExc_TypeError, "expected string key");
 			goto bail;
 		}
 		nbytes += PyBytes_GET_SIZE(k) + 17;
 		c = PyDict_GetItem(copymap, k);
 		if (c) {
 			if (!PyBytes_Check(c)) {
 				PyErr_SetString(PyExc_TypeError,
 				                "expected string key");
 				goto bail;
 			}
 			nbytes += PyBytes_GET_SIZE(c) + 1;
 		}
 	}
 
 	packobj = PyBytes_FromStringAndSize(NULL, nbytes);
 	if (packobj == NULL) {
 		goto bail;
 	}
 
 	p = PyBytes_AS_STRING(packobj);
 
 	pn = PyTuple_GET_ITEM(pl, 0);
 	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
 		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
 		goto bail;
 	}
 	memcpy(p, s, l);
 	p += 20;
 	pn = PyTuple_GET_ITEM(pl, 1);
 	if (PyBytes_AsStringAndSize(pn, &s, &l) == -1 || l != 20) {
 		PyErr_SetString(PyExc_TypeError, "expected a 20-byte hash");
 		goto bail;
 	}
 	memcpy(p, s, l);
 	p += 20;
 
 	for (pos = 0; PyDict_Next(map, &pos, &k, &v);) {
 		dirstateItemObject *tuple;
 		char state;
 		int mode, size, mtime;
 		Py_ssize_t len, l;
 		PyObject *o;
 		char *t;
 
 		if (!dirstate_tuple_check(v)) {
 			PyErr_SetString(PyExc_TypeError,
 			                "expected a dirstate tuple");
 			goto bail;
 		}
 		tuple = (dirstateItemObject *)v;
 
 		state = dirstate_item_c_v1_state(tuple);
 		mode = dirstate_item_c_v1_mode(tuple);
 		size = dirstate_item_c_v1_size(tuple);
 		mtime = dirstate_item_c_v1_mtime(tuple);
 		if (state == 'n' && mtime == now) {
 			/* See pure/parsers.py:pack_dirstate for why we do
 			 * this. */
 			mtime = -1;
 			mtime_unset = (PyObject *)dirstate_item_from_v1_data(
 			    state, mode, size, mtime);
 			if (!mtime_unset) {
 				goto bail;
 			}
 			if (PyDict_SetItem(map, k, mtime_unset) == -1) {
 				goto bail;
 			}
 			Py_DECREF(mtime_unset);
 			mtime_unset = NULL;
 		}
 		*p++ = state;
 		putbe32((uint32_t)mode, p);
 		putbe32((uint32_t)size, p + 4);
 		putbe32((uint32_t)mtime, p + 8);
 		t = p + 12;
 		p += 16;
 		len = PyBytes_GET_SIZE(k);
 		memcpy(p, PyBytes_AS_STRING(k), len);
 		p += len;
 		o = PyDict_GetItem(copymap, k);
 		if (o) {
 			*p++ = '\0';
 			l = PyBytes_GET_SIZE(o);
 			memcpy(p, PyBytes_AS_STRING(o), l);
 			p += l;
 			len += l + 1;
 		}
 		putbe32((uint32_t)len, t);
 	}
 
 	pos = p - PyBytes_AS_STRING(packobj);
 	if (pos != nbytes) {
 		PyErr_Format(PyExc_SystemError, "bad dirstate size: %ld != %ld",
 		             (long)pos, (long)nbytes);
 		goto bail;
 	}
 
 	return packobj;
 bail:
 	Py_XDECREF(mtime_unset);
 	Py_XDECREF(packobj);
 	Py_XDECREF(v);
 	return NULL;
 }
 
 #define BUMPED_FIX 1
 #define USING_SHA_256 2
 #define FM1_HEADER_SIZE (4 + 8 + 2 + 2 + 1 + 1 + 1)
 
 static PyObject *readshas(const char *source, unsigned char num,
                           Py_ssize_t hashwidth)
 {
 	int i;
 	PyObject *list = PyTuple_New(num);
 	if (list == NULL) {
 		return NULL;
 	}
 	for (i = 0; i < num; i++) {
 		PyObject *hash = PyBytes_FromStringAndSize(source, hashwidth);
 		if (hash == NULL) {
 			Py_DECREF(list);
 			return NULL;
 		}
 		PyTuple_SET_ITEM(list, i, hash);
 		source += hashwidth;
 	}
 	return list;
 }
 
 static PyObject *fm1readmarker(const char *databegin, const char *dataend,
                                uint32_t *msize)
 {
 	const char *data = databegin;
 	const char *meta;
 
 	double mtime;
 	int16_t tz;
 	uint16_t flags;
 	unsigned char nsuccs, nparents, nmetadata;
 	Py_ssize_t hashwidth = 20;
 
 	PyObject *prec = NULL, *parents = NULL, *succs = NULL;
 	PyObject *metadata = NULL, *ret = NULL;
 	int i;
 
 	if (data + FM1_HEADER_SIZE > dataend) {
 		goto overflow;
 	}
 
 	*msize = getbe32(data);
 	data += 4;
 	mtime = getbefloat64(data);
 	data += 8;
 	tz = getbeint16(data);
 	data += 2;
 	flags = getbeuint16(data);
 	data += 2;
 
 	if (flags & USING_SHA_256) {
 		hashwidth = 32;
 	}
 
 	nsuccs = (unsigned char)(*data++);
 	nparents = (unsigned char)(*data++);
 	nmetadata = (unsigned char)(*data++);
 
 	if (databegin + *msize > dataend) {
 		goto overflow;
 	}
 	dataend = databegin + *msize; /* narrow down to marker size */
 
 	if (data + hashwidth > dataend) {
 		goto overflow;
 	}
 	prec = PyBytes_FromStringAndSize(data, hashwidth);
 	data += hashwidth;
 	if (prec == NULL) {
 		goto bail;
 	}
 
 	if (data + nsuccs * hashwidth > dataend) {
 		goto overflow;
 	}
 	succs = readshas(data, nsuccs, hashwidth);
 	if (succs == NULL) {
 		goto bail;
 	}
 	data += nsuccs * hashwidth;
 
 	if (nparents == 1 || nparents == 2) {
 		if (data + nparents * hashwidth > dataend) {
 			goto overflow;
 		}
 		parents = readshas(data, nparents, hashwidth);
 		if (parents == NULL) {
 			goto bail;
 		}
 		data += nparents * hashwidth;
 	} else {
 		parents = Py_None;
 		Py_INCREF(parents);
 	}
 
 	if (data + 2 * nmetadata > dataend) {
 		goto overflow;
 	}
 	meta = data + (2 * nmetadata);
 	metadata = PyTuple_New(nmetadata);
 	if (metadata == NULL) {
 		goto bail;
 	}
 	for (i = 0; i < nmetadata; i++) {
 		PyObject *tmp, *left = NULL, *right = NULL;
 		Py_ssize_t leftsize = (unsigned char)(*data++);
 		Py_ssize_t rightsize = (unsigned char)(*data++);
 		if (meta + leftsize + rightsize > dataend) {
 			goto overflow;
 		}
 		left = PyBytes_FromStringAndSize(meta, leftsize);
 		meta += leftsize;
 		right = PyBytes_FromStringAndSize(meta, rightsize);
 		meta += rightsize;
 		tmp = PyTuple_New(2);
 		if (!left || !right || !tmp) {
 			Py_XDECREF(left);
 			Py_XDECREF(right);
 			Py_XDECREF(tmp);
 			goto bail;
 		}
 		PyTuple_SET_ITEM(tmp, 0, left);
 		PyTuple_SET_ITEM(tmp, 1, right);
 		PyTuple_SET_ITEM(metadata, i, tmp);
 	}
 	ret = Py_BuildValue("(OOHO(di)O)", prec, succs, flags, metadata, mtime,
 	                    (int)tz * 60, parents);
 	goto bail; /* return successfully */
 
 overflow:
 	PyErr_SetString(PyExc_ValueError, "overflow in obsstore");
 bail:
 	Py_XDECREF(prec);
 	Py_XDECREF(succs);
 	Py_XDECREF(metadata);
 	Py_XDECREF(parents);
 	return ret;
 }
 
 static PyObject *fm1readmarkers(PyObject *self, PyObject *args)
 {
 	const char *data, *dataend;
 	Py_ssize_t datalen, offset, stop;
 	PyObject *markers = NULL;
 
 	if (!PyArg_ParseTuple(args, PY23("s#nn", "y#nn"), &data, &datalen,
 	                      &offset, &stop)) {
 		return NULL;
 	}
 	if (offset < 0) {
 		PyErr_SetString(PyExc_ValueError,
 		                "invalid negative offset in fm1readmarkers");
 		return NULL;
 	}
 	if (stop > datalen) {
 		PyErr_SetString(
 		    PyExc_ValueError,
 		    "stop longer than data length in fm1readmarkers");
 		return NULL;
 	}
 	dataend = data + datalen;
 	data += offset;
 	markers = PyList_New(0);
 	if (!markers) {
 		return NULL;
 	}
 	while (offset < stop) {
 		uint32_t msize;
 		int error;
 		PyObject *record = fm1readmarker(data, dataend, &msize);
 		if (!record) {
 			goto bail;
 		}
 		error = PyList_Append(markers, record);
 		Py_DECREF(record);
 		if (error) {
 			goto bail;
 		}
 		data += msize;
 		offset += msize;
 	}
 	return markers;
 bail:
 	Py_DECREF(markers);
 	return NULL;
 }
 
 static char parsers_doc[] = "Efficient content parsing.";
 
 PyObject *encodedir(PyObject *self, PyObject *args);
 PyObject *pathencode(PyObject *self, PyObject *args);
 PyObject *lowerencode(PyObject *self, PyObject *args);
 PyObject *parse_index2(PyObject *self, PyObject *args, PyObject *kwargs);
 
 static PyMethodDef methods[] = {
     {"pack_dirstate", pack_dirstate, METH_VARARGS, "pack a dirstate\n"},
     {"parse_dirstate", parse_dirstate, METH_VARARGS, "parse a dirstate\n"},
     {"parse_index2", (PyCFunction)parse_index2, METH_VARARGS | METH_KEYWORDS,
      "parse a revlog index\n"},
     {"isasciistr", isasciistr, METH_VARARGS, "check if an ASCII string\n"},
     {"asciilower", asciilower, METH_VARARGS, "lowercase an ASCII string\n"},
     {"asciiupper", asciiupper, METH_VARARGS, "uppercase an ASCII string\n"},
     {"dict_new_presized", dict_new_presized, METH_VARARGS,
      "construct a dict with an expected size\n"},
     {"make_file_foldmap", make_file_foldmap, METH_VARARGS,
      "make file foldmap\n"},
     {"jsonescapeu8fast", jsonescapeu8fast, METH_VARARGS,
      "escape a UTF-8 byte string to JSON (fast path)\n"},
     {"encodedir", encodedir, METH_VARARGS, "encodedir a path\n"},
     {"pathencode", pathencode, METH_VARARGS, "fncache-encode a path\n"},
     {"lowerencode", lowerencode, METH_VARARGS, "lower-encode a path\n"},
     {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
      "parse v1 obsolete markers\n"},
     {NULL, NULL}};
 
 void dirs_module_init(PyObject *mod);
 void manifest_module_init(PyObject *mod);
 void revlog_module_init(PyObject *mod);
 
 static const int version = 20;
 
 static void module_init(PyObject *mod)
 {
 	PyModule_AddIntConstant(mod, "version", version);
 
 	/* This module constant has two purposes.  First, it lets us unit test
 	 * the ImportError raised without hard-coding any error text.  This
 	 * means we can change the text in the future without breaking tests,
 	 * even across changesets without a recompile.  Second, its presence
 	 * can be used to determine whether the version-checking logic is
 	 * present, which also helps in testing across changesets without a
 	 * recompile.  Note that this means the pure-Python version of parsers
 	 * should not have this module constant. */
 	PyModule_AddStringConstant(mod, "versionerrortext", versionerrortext);
 
 	dirs_module_init(mod);
 	manifest_module_init(mod);
 	revlog_module_init(mod);
 
 	if (PyType_Ready(&dirstateItemType) < 0) {
 		return;
 	}
 	Py_INCREF(&dirstateItemType);
 	PyModule_AddObject(mod, "DirstateItem", (PyObject *)&dirstateItemType);
 }
 
 static int check_python_version(void)
 {
 	PyObject *sys = PyImport_ImportModule("sys"), *ver;
 	long hexversion;
 	if (!sys) {
 		return -1;
 	}
 	ver = PyObject_GetAttrString(sys, "hexversion");
 	Py_DECREF(sys);
 	if (!ver) {
 		return -1;
 	}
 	hexversion = PyInt_AsLong(ver);
 	Py_DECREF(ver);
 	/* sys.hexversion is a 32-bit number by default, so the -1 case
 	 * should only occur in unusual circumstances (e.g. if sys.hexversion
 	 * is manually set to an invalid value). */
 	if ((hexversion == -1) || (hexversion >> 16 != PY_VERSION_HEX >> 16)) {
 		PyErr_Format(PyExc_ImportError,
 		             "%s: The Mercurial extension "
 		             "modules were compiled with Python " PY_VERSION
 		             ", but "
 		             "Mercurial is currently using Python with "
 		             "sys.hexversion=%ld: "
 		             "Python %s\n at: %s",
 		             versionerrortext, hexversion, Py_GetVersion(),
 		             Py_GetProgramFullPath());
 		return -1;
 	}
 	return 0;
 }
 
 #ifdef IS_PY3K
 static struct PyModuleDef parsers_module = {PyModuleDef_HEAD_INIT, "parsers",
                                             parsers_doc, -1, methods};
 
 PyMODINIT_FUNC PyInit_parsers(void)
 {
 	PyObject *mod;
 
 	if (check_python_version() == -1)
 		return NULL;
 	mod = PyModule_Create(&parsers_module);
 	module_init(mod);
 	return mod;
 }
 #else
 PyMODINIT_FUNC initparsers(void)
 {
 	PyObject *mod;
 
 	if (check_python_version() == -1) {
 		return;
 	}
 	mod = Py_InitModule3("parsers", methods, parsers_doc);
 	module_init(mod);
 }
 #endif

mercurial/pure/parsers.py

@@ -1,806 +1,819 b''
 # parsers.py - Python implementation of parsers.c
 #
 # Copyright 2009 Olivia Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import struct
 import zlib
 
 from ..node import (
     nullrev,
     sha1nodeconstants,
 )
 from ..thirdparty import attr
 from .. import (
     error,
     pycompat,
     revlogutils,
     util,
 )
 
 from ..revlogutils import nodemap as nodemaputil
 from ..revlogutils import constants as revlog_constants
 
 stringio = pycompat.bytesio
 
 
 _pack = struct.pack
 _unpack = struct.unpack
 _compress = zlib.compress
 _decompress = zlib.decompress
 
 
 # a special value used internally for `size` if the file come from the other parent
 FROM_P2 = -2
 
 # a special value used internally for `size` if the file is modified/merged/added
 NONNORMAL = -1
 
 # a special value used internally for `time` if the time is ambigeous
 AMBIGUOUS_TIME = -1
 
 
 @attr.s(slots=True, init=False)
 class DirstateItem(object):
     """represent a dirstate entry
 
     It contains:
 
     - state (one of 'n', 'a', 'r', 'm')
     - mode,
     - size,
     - mtime,
     """
 
     _wc_tracked = attr.ib()
     _p1_tracked = attr.ib()
     _p2_tracked = 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()
     _size = attr.ib()
     _mtime = attr.ib()
 
     def __init__(
         self,
         wc_tracked=False,
         p1_tracked=False,
         p2_tracked=False,
         merged=False,
         clean_p1=False,
         clean_p2=False,
         possibly_dirty=False,
         parentfiledata=None,
     ):
         if merged and (clean_p1 or clean_p2):
             msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
             raise error.ProgrammingError(msg)
 
         self._wc_tracked = wc_tracked
         self._p1_tracked = p1_tracked
         self._p2_tracked = p2_tracked
         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._size = None
             self._mtime = None
         else:
             self._mode = parentfiledata[0]
             self._size = parentfiledata[1]
             self._mtime = parentfiledata[2]
 
     @classmethod
     def new_added(cls):
         """constructor to help legacy API to build a new "added" item
 
         Should eventually be removed
         """
         instance = cls()
         instance._wc_tracked = True
         instance._p1_tracked = False
         instance._p2_tracked = False
         return instance
 
     @classmethod
     def new_merged(cls):
         """constructor to help legacy API to build a new "merged" item
 
         Should eventually be removed
         """
         instance = cls()
         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
     def new_from_p2(cls):
         """constructor to help legacy API to build a new "from_p2" item
 
         Should eventually be removed
         """
         instance = cls()
         instance._wc_tracked = True
         instance._p1_tracked = False  # might actually be True
         instance._p2_tracked = True
         instance._clean_p2 = True
         return instance
 
     @classmethod
     def new_possibly_dirty(cls):
         """constructor to help legacy API to build a new "possibly_dirty" item
 
         Should eventually be removed
         """
         instance = cls()
         instance._wc_tracked = True
         instance._p1_tracked = True
         instance._possibly_dirty = True
         return instance
 
     @classmethod
     def new_normal(cls, mode, size, mtime):
         """constructor to help legacy API to build a new "normal" item
 
         Should eventually be removed
         """
         assert size != FROM_P2
         assert size != NONNORMAL
         instance = cls()
         instance._wc_tracked = True
         instance._p1_tracked = True
         instance._mode = mode
         instance._size = size
         instance._mtime = mtime
         return instance
 
     @classmethod
     def from_v1_data(cls, state, mode, size, mtime):
         """Build a new DirstateItem object from V1 data
 
         Since the dirstate-v1 format is frozen, the signature of this function
         is not expected to change, unlike the __init__ one.
         """
         if state == b'm':
             return cls.new_merged()
         elif state == b'a':
             return cls.new_added()
         elif state == b'r':
             instance = cls()
             instance._wc_tracked = False
             if size == NONNORMAL:
                 instance._merged = True
                 instance._p1_tracked = (
                     True  # might not be True because of rename ?
                 )
                 instance._p2_tracked = (
                     True  # might not be True because of rename ?
                 )
             elif size == FROM_P2:
                 instance._clean_p2 = True
                 instance._p1_tracked = (
                     False  # We actually don't know (file history)
                 )
                 instance._p2_tracked = True
             else:
                 instance._p1_tracked = True
             return instance
         elif state == b'n':
             if size == FROM_P2:
                 return cls.new_from_p2()
             elif size == NONNORMAL:
                 return cls.new_possibly_dirty()
             elif mtime == AMBIGUOUS_TIME:
                 instance = cls.new_normal(mode, size, 42)
                 instance._mtime = None
                 instance._possibly_dirty = True
                 return instance
             else:
                 return cls.new_normal(mode, size, mtime)
         else:
             raise RuntimeError(b'unknown state: %s' % state)
 
     def set_possibly_dirty(self):
         """Mark a file as "possibly dirty"
 
         This means the next status call will have to actually check its content
         to make sure it is correct.
         """
         self._possibly_dirty = True
 
     def set_clean(self, mode, size, mtime):
         """mark a file as "clean" cancelling potential "possibly dirty call"
 
         Note: this function is a descendant of `dirstate.normal` and is
         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
         updated to preserve the proper state of the non-normal files.
         """
         self._wc_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._size = size
         self._mtime = mtime
 
     def set_tracked(self):
         """mark a file as tracked in the working copy
 
         This will ultimately be called by command like `hg add`.
         """
         self._wc_tracked = True
         # `set_tracked` is replacing various `normallookup` call. So we set
         # "possibly dirty" to stay on the safe side.
         #
         # Consider dropping this in the future in favor of something less broad.
         self._possibly_dirty = True
 
     def set_untracked(self):
         """mark a file as untracked in the working copy
 
         This will ultimately be called by command like `hg remove`.
         """
         # backup the previous state (useful for merge)
         self._wc_tracked = False
         self._mode = None
         self._size = None
         self._mtime = None
 
     def drop_merge_data(self):
         """remove all "merge-only" from a DirstateItem
 
         This is to be call by the dirstatemap code when the second parent is dropped
         """
         if not (self.merged or self.from_p2):
             return
         self._p1_tracked = self.merged  # why is this not already properly set ?
 
         self._merged = False
         self._clean_p1 = False
         self._clean_p2 = False
         self._p2_tracked = False
         self._possibly_dirty = True
         self._mode = None
         self._size = None
         self._mtime = None
 
     @property
     def mode(self):
         return self.v1_mode()
 
     @property
     def size(self):
         return self.v1_size()
 
     @property
     def mtime(self):
         return self.v1_mtime()
 
     @property
     def state(self):
         """
         States are:
           n  normal
           m  needs merging
           r  marked for removal
           a  marked for addition
 
         XXX This "state" is a bit obscure and mostly a direct expression of the
         dirstatev1 format. It would make sense to ultimately deprecate it in
         favor of the more "semantic" attributes.
         """
         return self.v1_state()
 
     @property
     def tracked(self):
         """True is the file is tracked in the working copy"""
         return self._wc_tracked
 
     @property
     def added(self):
         """True if the file has been added"""
         return self._wc_tracked and not (self._p1_tracked or self._p2_tracked)
 
     @property
+    def maybe_clean(self):
+        """True if the file has a chance to be in the "clean" state"""
+        if not self._wc_tracked:
+            return False
+        elif self.added:
+            return False
+        elif self._merged:
+            return False
+        elif self._clean_p2:
+            return False
+        return True
+
+    @property
     def merged(self):
         """True if the file has been merged
 
         Should only be set if a merge is in progress in the dirstate
         """
         return self._wc_tracked and self._merged
 
     @property
     def from_p2(self):
         """True if the file have been fetched from p2 during the current merge
 
         This is only True is the file is currently tracked.
 
         Should only be set if a merge is in progress in the dirstate
         """
         if not self._wc_tracked:
             return False
         return self._clean_p2
 
     @property
     def removed(self):
         """True if the file has been removed"""
         return not self._wc_tracked and (self._p1_tracked or self._p2_tracked)
 
     def v1_state(self):
         """return a "state" suitable for v1 serialization"""
         if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return b'r'
         elif self.merged:
             return b'm'
         elif self.added:
             return b'a'
         else:
             return b'n'
 
     def v1_mode(self):
         """return a "mode" suitable for v1 serialization"""
         return self._mode if self._mode is not None else 0
 
     def v1_size(self):
         """return a "size" suitable for v1 serialization"""
         if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed and self._merged:
             return NONNORMAL
         elif self.removed and self._clean_p2:
             return FROM_P2
         elif self.removed:
             return 0
         elif self.merged:
             return FROM_P2
         elif self.added:
             return NONNORMAL
         elif self.from_p2:
             return FROM_P2
         elif self._possibly_dirty:
             return self._size if self._size is not None else NONNORMAL
         else:
             return self._size
 
     def v1_mtime(self):
         """return a "mtime" suitable for v1 serialization"""
         if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return 0
         elif self._possibly_dirty:
             return AMBIGUOUS_TIME
         elif self.merged:
             return AMBIGUOUS_TIME
         elif self.added:
             return AMBIGUOUS_TIME
         elif self.from_p2:
             return AMBIGUOUS_TIME
         else:
             return self._mtime if self._mtime is not None else 0
 
     def need_delay(self, now):
         """True if the stored mtime would be ambiguous with the current time"""
         return self.v1_state() == b'n' and self.v1_mtime() == now
 
 
 def gettype(q):
     return int(q & 0xFFFF)
 
 
 class BaseIndexObject(object):
     # Can I be passed to an algorithme implemented in Rust ?
     rust_ext_compat = 0
     # Format of an index entry according to Python's `struct` language
     index_format = revlog_constants.INDEX_ENTRY_V1
     # Size of a C unsigned long long int, platform independent
     big_int_size = struct.calcsize(b'>Q')
     # Size of a C long int, platform independent
     int_size = struct.calcsize(b'>i')
     # An empty index entry, used as a default value to be overridden, or nullrev
     null_item = (
         0,
         0,
         0,
         -1,
         -1,
         -1,
         -1,
         sha1nodeconstants.nullid,
         0,
         0,
         revlog_constants.COMP_MODE_INLINE,
         revlog_constants.COMP_MODE_INLINE,
     )
 
     @util.propertycache
     def entry_size(self):
         return self.index_format.size
 
     @property
     def nodemap(self):
         msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"
         util.nouideprecwarn(msg, b'5.3', stacklevel=2)
         return self._nodemap
 
     @util.propertycache
     def _nodemap(self):
         nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})
         for r in range(0, len(self)):
             n = self[r][7]
             nodemap[n] = r
         return nodemap
 
     def has_node(self, node):
         """return True if the node exist in the index"""
         return node in self._nodemap
 
     def rev(self, node):
         """return a revision for a node
 
         If the node is unknown, raise a RevlogError"""
         return self._nodemap[node]
 
     def get_rev(self, node):
         """return a revision for a node
 
         If the node is unknown, return None"""
         return self._nodemap.get(node)
 
     def _stripnodes(self, start):
         if '_nodemap' in vars(self):
             for r in range(start, len(self)):
                 n = self[r][7]
                 del self._nodemap[n]
 
     def clearcaches(self):
         self.__dict__.pop('_nodemap', None)
 
     def __len__(self):
         return self._lgt + len(self._extra)
 
     def append(self, tup):
         if '_nodemap' in vars(self):
             self._nodemap[tup[7]] = len(self)
         data = self._pack_entry(len(self), tup)
         self._extra.append(data)
 
     def _pack_entry(self, rev, entry):
         assert entry[8] == 0
         assert entry[9] == 0
         return self.index_format.pack(*entry[:8])
 
     def _check_index(self, i):
         if not isinstance(i, int):
             raise TypeError(b"expecting int indexes")
         if i < 0 or i >= len(self):
             raise IndexError
 
     def __getitem__(self, i):
         if i == -1:
             return self.null_item
         self._check_index(i)
         if i >= self._lgt:
             data = self._extra[i - self._lgt]
         else:
             index = self._calculate_index(i)
             data = self._data[index : index + self.entry_size]
         r = self._unpack_entry(i, data)
         if self._lgt and i == 0:
             offset = revlogutils.offset_type(0, gettype(r[0]))
             r = (offset,) + r[1:]
         return r
 
     def _unpack_entry(self, rev, data):
         r = self.index_format.unpack(data)
         r = r + (
             0,
             0,
             revlog_constants.COMP_MODE_INLINE,
             revlog_constants.COMP_MODE_INLINE,
         )
         return r
 
     def pack_header(self, header):
         """pack header information as binary"""
         v_fmt = revlog_constants.INDEX_HEADER
         return v_fmt.pack(header)
 
     def entry_binary(self, rev):
         """return the raw binary string representing a revision"""
         entry = self[rev]
         p = revlog_constants.INDEX_ENTRY_V1.pack(*entry[:8])
         if rev == 0:
             p = p[revlog_constants.INDEX_HEADER.size :]
         return p
 
 
 class IndexObject(BaseIndexObject):
     def __init__(self, data):
         assert len(data) % self.entry_size == 0, (
             len(data),
             self.entry_size,
             len(data) % self.entry_size,
         )
         self._data = data
         self._lgt = len(data) // self.entry_size
         self._extra = []
 
     def _calculate_index(self, i):
         return i * self.entry_size
 
     def __delitem__(self, i):
         if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
             raise ValueError(b"deleting slices only supports a:-1 with step 1")
         i = i.start
         self._check_index(i)
         self._stripnodes(i)
         if i < self._lgt:
             self._data = self._data[: i * self.entry_size]
             self._lgt = i
             self._extra = []
         else:
             self._extra = self._extra[: i - self._lgt]
 
 
 class PersistentNodeMapIndexObject(IndexObject):
     """a Debug oriented class to test persistent nodemap
 
     We need a simple python object to test API and higher level behavior. See
     the Rust implementation for  more serious usage. This should be used only
     through the dedicated `devel.persistent-nodemap` config.
     """
 
     def nodemap_data_all(self):
         """Return bytes containing a full serialization of a nodemap
 
         The nodemap should be valid for the full set of revisions in the
         index."""
         return nodemaputil.persistent_data(self)
 
     def nodemap_data_incremental(self):
         """Return bytes containing a incremental update to persistent nodemap
 
         This containst the data for an append-only update of the data provided
         in the last call to `update_nodemap_data`.
         """
         if self._nm_root is None:
             return None
         docket = self._nm_docket
         changed, data = nodemaputil.update_persistent_data(
             self, self._nm_root, self._nm_max_idx, self._nm_docket.tip_rev
         )
 
         self._nm_root = self._nm_max_idx = self._nm_docket = None
         return docket, changed, data
 
     def update_nodemap_data(self, docket, nm_data):
         """provide full block of persisted binary data for a nodemap
 
         The data are expected to come from disk. See `nodemap_data_all` for a
         produceur of such data."""
         if nm_data is not None:
             self._nm_root, self._nm_max_idx = nodemaputil.parse_data(nm_data)
             if self._nm_root:
                 self._nm_docket = docket
             else:
                 self._nm_root = self._nm_max_idx = self._nm_docket = None
 
 
 class InlinedIndexObject(BaseIndexObject):
     def __init__(self, data, inline=0):
         self._data = data
         self._lgt = self._inline_scan(None)
         self._inline_scan(self._lgt)
         self._extra = []
 
     def _inline_scan(self, lgt):
         off = 0
         if lgt is not None:
             self._offsets = [0] * lgt
         count = 0
         while off <= len(self._data) - self.entry_size:
             start = off + self.big_int_size
             (s,) = struct.unpack(
                 b'>i',
                 self._data[start : start + self.int_size],
             )
             if lgt is not None:
                 self._offsets[count] = off
             count += 1
             off += self.entry_size + s
         if off != len(self._data):
             raise ValueError(b"corrupted data")
         return count
 
     def __delitem__(self, i):
         if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:
             raise ValueError(b"deleting slices only supports a:-1 with step 1")
         i = i.start
         self._check_index(i)
         self._stripnodes(i)
         if i < self._lgt:
             self._offsets = self._offsets[:i]
             self._lgt = i
             self._extra = []
         else:
             self._extra = self._extra[: i - self._lgt]
 
     def _calculate_index(self, i):
         return self._offsets[i]
 
 
 def parse_index2(data, inline, revlogv2=False):
     if not inline:
         cls = IndexObject2 if revlogv2 else IndexObject
         return cls(data), None
     cls = InlinedIndexObject
     return cls(data, inline), (0, data)
 
 
 def parse_index_cl_v2(data):
     return IndexChangelogV2(data), None
 
 
 class IndexObject2(IndexObject):
     index_format = revlog_constants.INDEX_ENTRY_V2
 
     def replace_sidedata_info(
         self,
         rev,
         sidedata_offset,
         sidedata_length,
         offset_flags,
         compression_mode,
     ):
         """
         Replace an existing index entry's sidedata offset and length with new
         ones.
         This cannot be used outside of the context of sidedata rewriting,
         inside the transaction that creates the revision `rev`.
         """
         if rev < 0:
             raise KeyError
         self._check_index(rev)
         if rev < self._lgt:
             msg = b"cannot rewrite entries outside of this transaction"
             raise KeyError(msg)
         else:
             entry = list(self[rev])
             entry[0] = offset_flags
             entry[8] = sidedata_offset
             entry[9] = sidedata_length
             entry[11] = compression_mode
             entry = tuple(entry)
             new = self._pack_entry(rev, entry)
             self._extra[rev - self._lgt] = new
 
     def _unpack_entry(self, rev, data):
         data = self.index_format.unpack(data)
         entry = data[:10]
         data_comp = data[10] & 3
         sidedata_comp = (data[10] & (3 << 2)) >> 2
         return entry + (data_comp, sidedata_comp)
 
     def _pack_entry(self, rev, entry):
         data = entry[:10]
         data_comp = entry[10] & 3
         sidedata_comp = (entry[11] & 3) << 2
         data += (data_comp | sidedata_comp,)
 
         return self.index_format.pack(*data)
 
     def entry_binary(self, rev):
         """return the raw binary string representing a revision"""
         entry = self[rev]
         return self._pack_entry(rev, entry)
 
     def pack_header(self, header):
         """pack header information as binary"""
         msg = 'version header should go in the docket, not the index: %d'
         msg %= header
         raise error.ProgrammingError(msg)
 
 
 class IndexChangelogV2(IndexObject2):
     index_format = revlog_constants.INDEX_ENTRY_CL_V2
 
     def _unpack_entry(self, rev, data, r=True):
         items = self.index_format.unpack(data)
         entry = items[:3] + (rev, rev) + items[3:8]
         data_comp = items[8] & 3
         sidedata_comp = (items[8] >> 2) & 3
         return entry + (data_comp, sidedata_comp)
 
     def _pack_entry(self, rev, entry):
         assert entry[3] == rev, entry[3]
         assert entry[4] == rev, entry[4]
         data = entry[:3] + entry[5:10]
         data_comp = entry[10] & 3
         sidedata_comp = (entry[11] & 3) << 2
         data += (data_comp | sidedata_comp,)
         return self.index_format.pack(*data)
 
 
 def parse_index_devel_nodemap(data, inline):
     """like parse_index2, but alway return a PersistentNodeMapIndexObject"""
     return PersistentNodeMapIndexObject(data), None
 
 
 def parse_dirstate(dmap, copymap, st):
     parents = [st[:20], st[20:40]]
     # dereference fields so they will be local in loop
     format = b">cllll"
     e_size = struct.calcsize(format)
     pos1 = 40
     l = len(st)
 
     # the inner loop
     while pos1 < l:
         pos2 = pos1 + e_size
         e = _unpack(b">cllll", st[pos1:pos2])  # a literal here is faster
         pos1 = pos2 + e[4]
         f = st[pos2:pos1]
         if b'\0' in f:
             f, c = f.split(b'\0')
             copymap[f] = c
         dmap[f] = DirstateItem.from_v1_data(*e[:4])
     return parents
 
 
 def pack_dirstate(dmap, copymap, pl, now):
     now = int(now)
     cs = stringio()
     write = cs.write
     write(b"".join(pl))
     for f, e in pycompat.iteritems(dmap):
         if e.need_delay(now):
             # The file was last modified "simultaneously" with the current
             # write to dirstate (i.e. within the same second for file-
             # systems with a granularity of 1 sec). This commonly happens
             # for at least a couple of files on 'update'.
             # The user could change the file without changing its size
             # within the same second. Invalidate the file's mtime in
             # dirstate, forcing future 'status' calls to compare the
             # contents of the file if the size is the same. This prevents
             # mistakenly treating such files as clean.
             e.set_possibly_dirty()
 
         if f in copymap:
             f = b"%s\0%s" % (f, copymap[f])
         e = _pack(
             b">cllll",
             e.v1_state(),
             e.v1_mode(),
             e.v1_size(),
             e.v1_mtime(),
             len(f),
         )
         write(e)
         write(f)
     return cs.getvalue()

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

@@ -1,380 +1,394 b''
 use crate::errors::HgError;
 use bitflags::bitflags;
 use std::convert::TryFrom;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum EntryState {
     Normal,
     Added,
     Removed,
     Merged,
 }
 
 /// The C implementation uses all signed types. This will be an issue
 /// either when 4GB+ source files are commonplace or in 2038, whichever
 /// comes first.
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub struct DirstateEntry {
     flags: Flags,
     mode: i32,
     size: i32,
     mtime: i32,
 }
 
 bitflags! {
     pub struct Flags: u8 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_TRACKED = 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 MTIME_UNSET: i32 = -1;
 
 /// 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
 /// merge.
 pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
 /// A special value used for internal representation of special case in
 /// dirstate v1 format.
 pub const SIZE_NON_NORMAL: i32 = -1;
 
 impl DirstateEntry {
     pub fn new(
         flags: Flags,
         mode_size_mtime: Option<(i32, i32, i32)>,
     ) -> Self {
         let (mode, size, mtime) =
             mode_size_mtime.unwrap_or((0, SIZE_NON_NORMAL, MTIME_UNSET));
         Self {
             flags,
             mode,
             size,
             mtime,
         }
     }
 
     pub fn from_v1_data(
         state: EntryState,
         mode: i32,
         size: i32,
         mtime: i32,
     ) -> Self {
         match state {
             EntryState::Normal => {
                 if size == SIZE_FROM_OTHER_PARENT {
                     Self::new_from_p2()
                 } else if size == SIZE_NON_NORMAL {
                     Self::new_possibly_dirty()
                 } else if mtime == MTIME_UNSET {
                     Self {
                         flags: Flags::WDIR_TRACKED
                             | Flags::P1_TRACKED
                             | Flags::POSSIBLY_DIRTY,
                         mode,
                         size,
                         mtime: 0,
                     }
                 } else {
                     Self::new_normal(mode, size, mtime)
                 }
             }
             EntryState::Added => Self::new_added(),
             EntryState::Removed => Self {
                 flags: if size == SIZE_NON_NORMAL {
                     Flags::P1_TRACKED // might not be true because of rename ?
                     | Flags::P2_TRACKED // might not be true because of rename ?
                     | Flags::MERGED
                 } else if size == SIZE_FROM_OTHER_PARENT {
                     // We don’t know if P1_TRACKED should be set (file history)
                     Flags::P2_TRACKED | Flags::CLEAN_P2
                 } else {
                     Flags::P1_TRACKED
                 },
                 mode: 0,
                 size: 0,
                 mtime: 0,
             },
             EntryState::Merged => Self::new_merged(),
         }
     }
 
     pub fn new_from_p2() -> Self {
         Self {
             // might be missing P1_TRACKED
             flags: Flags::WDIR_TRACKED | Flags::P2_TRACKED | Flags::CLEAN_P2,
             mode: 0,
             size: SIZE_FROM_OTHER_PARENT,
             mtime: MTIME_UNSET,
         }
     }
 
     pub fn new_possibly_dirty() -> Self {
         Self {
             flags: Flags::WDIR_TRACKED
                 | Flags::P1_TRACKED
                 | Flags::POSSIBLY_DIRTY,
             mode: 0,
             size: SIZE_NON_NORMAL,
             mtime: MTIME_UNSET,
         }
     }
 
     pub fn new_added() -> Self {
         Self {
             flags: Flags::WDIR_TRACKED,
             mode: 0,
             size: SIZE_NON_NORMAL,
             mtime: MTIME_UNSET,
         }
     }
 
     pub fn new_merged() -> Self {
         Self {
             flags: Flags::WDIR_TRACKED
                 | Flags::P1_TRACKED // might not be true because of rename ?
                 | Flags::P2_TRACKED // might not be true because of rename ?
                 | Flags::MERGED,
             mode: 0,
             size: SIZE_NON_NORMAL,
             mtime: MTIME_UNSET,
         }
     }
 
     pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self {
         Self {
             flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
             mode,
             size,
             mtime,
         }
     }
 
     /// Creates a new entry in "removed" state.
     ///
     /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
     /// `SIZE_FROM_OTHER_PARENT`
     pub fn new_removed(size: i32) -> Self {
         Self::from_v1_data(EntryState::Removed, 0, size, 0)
     }
 
     pub fn tracked(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     fn tracked_in_any_parent(&self) -> bool {
         self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED)
     }
 
     pub fn removed(&self) -> bool {
         self.tracked_in_any_parent()
             && !self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn merged(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED)
     }
 
     pub fn added(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED)
             && !self.tracked_in_any_parent()
     }
 
     pub fn from_p2(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2)
     }
 
+    pub fn maybe_clean(&self) -> bool {
+        if !self.flags.contains(Flags::WDIR_TRACKED) {
+            false
+        } else if self.added() {
+            false
+        } else if self.flags.contains(Flags::MERGED) {
+            false
+        } else if self.flags.contains(Flags::CLEAN_P2) {
+            false
+        } else {
+            true
+        }
+    }
+
     pub fn state(&self) -> EntryState {
         if self.removed() {
             EntryState::Removed
         } else if self.merged() {
             EntryState::Merged
         } else if self.added() {
             EntryState::Added
         } else {
             EntryState::Normal
         }
     }
 
     pub fn mode(&self) -> i32 {
         self.mode
     }
 
     pub fn size(&self) -> i32 {
         if self.removed() && self.flags.contains(Flags::MERGED) {
             SIZE_NON_NORMAL
         } else if self.removed() && self.flags.contains(Flags::CLEAN_P2) {
             SIZE_FROM_OTHER_PARENT
         } else if self.removed() {
             0
         } else if self.merged() {
             SIZE_FROM_OTHER_PARENT
         } else if self.added() {
             SIZE_NON_NORMAL
         } else if self.from_p2() {
             SIZE_FROM_OTHER_PARENT
         } else if self.flags.contains(Flags::POSSIBLY_DIRTY) {
             self.size // TODO: SIZE_NON_NORMAL ?
         } else {
             self.size
         }
     }
 
     pub fn mtime(&self) -> i32 {
         if self.removed() {
             0
         } else if self.flags.contains(Flags::POSSIBLY_DIRTY) {
             MTIME_UNSET
         } else if self.merged() {
             MTIME_UNSET
         } else if self.added() {
             MTIME_UNSET
         } else if self.from_p2() {
             MTIME_UNSET
         } else {
             self.mtime
         }
     }
 
     pub fn set_possibly_dirty(&mut self) {
         self.flags.insert(Flags::POSSIBLY_DIRTY)
     }
 
     pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) {
         self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
         self.flags.remove(
             Flags::P2_TRACKED // This might be wrong
                 | Flags::MERGED
                 | Flags::CLEAN_P2
                 | Flags::POSSIBLY_DIRTY,
         );
         self.mode = mode;
         self.size = size;
         self.mtime = mtime;
     }
 
     pub fn set_tracked(&mut self) {
         self.flags
             .insert(Flags::WDIR_TRACKED | Flags::POSSIBLY_DIRTY);
         // 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 = SIZE_NON_NORMAL;
     }
 
     pub fn set_untracked(&mut self) {
         self.flags.remove(Flags::WDIR_TRACKED);
         self.mode = 0;
         self.size = 0;
         self.mtime = 0;
     }
 
     /// Returns `(state, mode, size, mtime)` for the puprose of serialization
     /// in the dirstate-v1 format.
     ///
     /// 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
     /// will need to keep the same format.
     pub fn v1_data(&self) -> (u8, i32, i32, i32) {
         (self.state().into(), self.mode(), self.size(), self.mtime())
     }
 
     pub(crate) fn is_from_other_parent(&self) -> bool {
         self.state() == EntryState::Normal
             && self.size() == SIZE_FROM_OTHER_PARENT
     }
 
     // TODO: other platforms
     #[cfg(unix)]
     pub fn mode_changed(
         &self,
         filesystem_metadata: &std::fs::Metadata,
     ) -> bool {
         use std::os::unix::fs::MetadataExt;
         const EXEC_BIT_MASK: u32 = 0o100;
         let dirstate_exec_bit = (self.mode() as u32) & EXEC_BIT_MASK;
         let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
         dirstate_exec_bit != fs_exec_bit
     }
 
     /// Returns a `(state, mode, size, mtime)` tuple as for
     /// `DirstateMapMethods::debug_iter`.
     pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
         let state = if self.flags.contains(Flags::ENTRYLESS_TREE_NODE) {
             b' '
         } else {
             self.state().into()
         };
         (state, self.mode(), self.size(), self.mtime())
     }
 
     pub fn mtime_is_ambiguous(&self, now: i32) -> bool {
         self.state() == EntryState::Normal && self.mtime() == now
     }
 
     pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool {
         let ambiguous = self.mtime_is_ambiguous(now);
         if ambiguous {
             // The file was last modified "simultaneously" with the current
             // write to dirstate (i.e. within the same second for file-
             // systems with a granularity of 1 sec). This commonly happens
             // for at least a couple of files on 'update'.
             // The user could change the file without changing its size
             // within the same second. Invalidate the file's mtime in
             // dirstate, forcing future 'status' calls to compare the
             // contents of the file if the size is the same. This prevents
             // mistakenly treating such files as clean.
             self.clear_mtime()
         }
         ambiguous
     }
 
     pub fn clear_mtime(&mut self) {
         self.mtime = -1;
     }
 }
 
 impl EntryState {
     pub fn is_tracked(self) -> bool {
         use EntryState::*;
         match self {
             Normal | Added | Merged => true,
             Removed => false,
         }
     }
 }
 
 impl TryFrom<u8> for EntryState {
     type Error = HgError;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
             b'n' => Ok(EntryState::Normal),
             b'a' => Ok(EntryState::Added),
             b'r' => Ok(EntryState::Removed),
             b'm' => Ok(EntryState::Merged),
             _ => Err(HgError::CorruptedRepository(format!(
                 "Incorrect dirstate entry state {}",
                 value
             ))),
         }
     }
 }
 
 impl Into<u8> for EntryState {
     fn into(self) -> u8 {
         match self {
             EntryState::Normal => b'n',
             EntryState::Added => b'a',
             EntryState::Removed => b'r',
             EntryState::Merged => b'm',
         }
     }
 }

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

@@ -1,203 +1,208 b''
 use cpython::exc;
 use cpython::PyBytes;
 use cpython::PyErr;
 use cpython::PyNone;
 use cpython::PyObject;
 use cpython::PyResult;
 use cpython::Python;
 use cpython::PythonObject;
 use hg::dirstate::entry::Flags;
 use hg::dirstate::DirstateEntry;
 use hg::dirstate::EntryState;
 use std::cell::Cell;
 use std::convert::TryFrom;
 
 py_class!(pub class DirstateItem |py| {
     data entry: Cell<DirstateEntry>;
 
     def __new__(
         _cls,
         wc_tracked: bool = false,
         p1_tracked: bool = false,
         p2_tracked: bool = false,
         merged: bool = false,
         clean_p1: bool = false,
         clean_p2: bool = false,
         possibly_dirty: bool = false,
         parentfiledata: Option<(i32, i32, i32)> = None,
 
     ) -> PyResult<DirstateItem> {
         let mut flags = Flags::empty();
         flags.set(Flags::WDIR_TRACKED, wc_tracked);
         flags.set(Flags::P1_TRACKED, p1_tracked);
         flags.set(Flags::P2_TRACKED, p2_tracked);
         flags.set(Flags::MERGED, merged);
         flags.set(Flags::CLEAN_P1, clean_p1);
         flags.set(Flags::CLEAN_P2, clean_p2);
         flags.set(Flags::POSSIBLY_DIRTY, possibly_dirty);
         let entry = DirstateEntry::new(flags, parentfiledata);
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @property
     def state(&self) -> PyResult<PyBytes> {
         let state_byte: u8 = self.entry(py).get().state().into();
         Ok(PyBytes::new(py, &[state_byte]))
     }
 
     @property
     def mode(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().mode())
     }
 
     @property
     def size(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().size())
     }
 
     @property
     def mtime(&self) -> PyResult<i32> {
         Ok(self.entry(py).get().mtime())
     }
 
     @property
     def tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().tracked())
     }
 
     @property
     def added(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().added())
     }
 
     @property
     def merged(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().merged())
     }
 
     @property
     def removed(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().removed())
     }
 
     @property
     def from_p2(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().from_p2())
     }
 
+    @property
+    def maybe_clean(&self) -> PyResult<bool> {
+        Ok(self.entry(py).get().maybe_clean())
+    }
+
     def v1_state(&self) -> PyResult<PyBytes> {
         let (state, _mode, _size, _mtime) = self.entry(py).get().v1_data();
         let state_byte: u8 = state.into();
         Ok(PyBytes::new(py, &[state_byte]))
     }
 
     def v1_mode(&self) -> PyResult<i32> {
         let (_state, mode, _size, _mtime) = self.entry(py).get().v1_data();
         Ok(mode)
     }
 
     def v1_size(&self) -> PyResult<i32> {
         let (_state, _mode, size, _mtime) = self.entry(py).get().v1_data();
         Ok(size)
     }
 
     def v1_mtime(&self) -> PyResult<i32> {
         let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
         Ok(mtime)
     }
 
     def need_delay(&self, now: i32) -> PyResult<bool> {
         Ok(self.entry(py).get().mtime_is_ambiguous(now))
     }
 
     @classmethod
     def from_v1_data(
         _cls,
         state: PyBytes,
         mode: i32,
         size: i32,
         mtime: i32,
     ) -> PyResult<Self> {
         let state = <[u8; 1]>::try_from(state.data(py))
             .ok()
             .and_then(|state| EntryState::try_from(state[0]).ok())
             .ok_or_else(|| PyErr::new::<exc::ValueError, _>(py, "invalid state"))?;
         let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @classmethod
     def new_added(_cls) -> PyResult<Self> {
         let entry = DirstateEntry::new_added();
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @classmethod
     def new_merged(_cls) -> PyResult<Self> {
         let entry = DirstateEntry::new_merged();
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @classmethod
     def new_from_p2(_cls) -> PyResult<Self> {
         let entry = DirstateEntry::new_from_p2();
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @classmethod
     def new_possibly_dirty(_cls) -> PyResult<Self> {
         let entry = DirstateEntry::new_possibly_dirty();
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     @classmethod
     def new_normal(_cls, mode: i32, size: i32, mtime: i32) -> PyResult<Self> {
         let entry = DirstateEntry::new_normal(mode, size, mtime);
         DirstateItem::create_instance(py, Cell::new(entry))
     }
 
     def set_clean(
         &self,
         mode: i32,
         size: i32,
         mtime: i32,
     ) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_clean(mode, size, mtime));
         Ok(PyNone)
     }
 
     def set_possibly_dirty(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_possibly_dirty());
         Ok(PyNone)
     }
 
     def set_tracked(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_tracked());
         Ok(PyNone)
     }
 
     def set_untracked(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.set_untracked());
         Ok(PyNone)
     }
 });
 
 impl DirstateItem {
     pub fn new_as_pyobject(
         py: Python<'_>,
         entry: DirstateEntry,
     ) -> PyResult<PyObject> {
         Ok(DirstateItem::create_instance(py, Cell::new(entry))?.into_object())
     }
 
     pub fn get_entry(&self, py: Python<'_>) -> DirstateEntry {
         self.entry(py).get()
     }
 
     // TODO: Use https://doc.rust-lang.org/std/cell/struct.Cell.html#method.update instead when it’s stable
     pub fn update(&self, py: Python<'_>, f: impl FnOnce(&mut DirstateEntry)) {
         let mut entry = self.entry(py).get();
         f(&mut entry);
         self.entry(py).set(entry)
     }
 }