dirstate: remove need_delay logic

Now that all¹ stored mtime are non ambiguous, we no longer need to apply the `need_delay` step.
The need delay logic was not great are mtime gathered during longer operation
could be ambiguous but younger than the `dirstate.write` call time.

So, we don't need that logic anymore and can drop it

This make the code much simpler. The code related to the test extension faking
the dirstate write is now obsolete and associated test will be migrated as
follow up. They currently do not break.

[1] except the ones from `hg update`, but `need_delay` no longer help for them
either.

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

mercurial/cext/parsers.c

@@ -1,1355 +1,1320 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
 #else
 /* Windows on Python 2.7 doesn't define S_IFLNK. Python 3+ defines via
  * pyport.h. */
 #ifndef S_IFLNK
 #define S_IFLNK 0120000
 #endif
 #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_info;
 	int has_meaningful_data;
 	int has_meaningful_mtime;
 	int mode;
 	int size;
 	int mtime_s;
 	int mtime_ns;
 	PyObject *parentfiledata;
 	PyObject *mtime;
 	PyObject *fallback_exec;
 	PyObject *fallback_symlink;
 	static char *keywords_name[] = {
 	    "wc_tracked",          "p1_tracked",           "p2_info",
 	    "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",
 	    "fallback_exec",       "fallback_symlink",     NULL,
 	};
 	wc_tracked = 0;
 	p1_tracked = 0;
 	p2_info = 0;
 	has_meaningful_mtime = 1;
 	has_meaningful_data = 1;
 	parentfiledata = Py_None;
 	fallback_exec = Py_None;
 	fallback_symlink = Py_None;
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiOOO", keywords_name,
 	                                 &wc_tracked, &p1_tracked, &p2_info,
 	                                 &has_meaningful_data,
 	                                 &has_meaningful_mtime, &parentfiledata,
 	                                 &fallback_exec, &fallback_symlink)) {
 		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_info) {
 		t->flags |= dirstate_flag_p2_info;
 	}
 
 	if (fallback_exec != Py_None) {
 		t->flags |= dirstate_flag_has_fallback_exec;
 		if (PyObject_IsTrue(fallback_exec)) {
 			t->flags |= dirstate_flag_fallback_exec;
 		}
 	}
 	if (fallback_symlink != Py_None) {
 		t->flags |= dirstate_flag_has_fallback_symlink;
 		if (PyObject_IsTrue(fallback_symlink)) {
 			t->flags |= dirstate_flag_fallback_symlink;
 		}
 	}
 
 	if (parentfiledata != Py_None) {
 		if (!PyArg_ParseTuple(parentfiledata, "iiO", &mode, &size,
 		                      &mtime)) {
 			return NULL;
 		}
 		if (mtime != Py_None) {
 			if (!PyArg_ParseTuple(mtime, "ii", &mtime_s,
 			                      &mtime_ns)) {
 				return NULL;
 			}
 		} else {
 			has_meaningful_mtime = 0;
 		}
 	} else {
 		has_meaningful_data = 0;
 		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_mtime;
 		t->mtime_s = mtime_s;
 		t->mtime_ns = mtime_ns;
 	} else {
 		t->mtime_s = 0;
 		t->mtime_ns = 0;
 	}
 	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_any_tracked(dirstateItemObject *self)
 {
 	const int 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)
 {
 	const int mask = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	                  dirstate_flag_p2_info);
 	const int 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_info));
 }
 
 static inline bool dirstate_item_c_merged(dirstateItemObject *self)
 {
 	return ((self->flags & dirstate_flag_wc_tracked) &&
 	        (self->flags & dirstate_flag_p1_tracked) &&
 	        (self->flags & dirstate_flag_p2_info));
 }
 
 static inline bool dirstate_item_c_from_p2(dirstateItemObject *self)
 {
 	return ((self->flags & dirstate_flag_wc_tracked) &&
 	        !(self->flags & dirstate_flag_p1_tracked) &&
 	        (self->flags & dirstate_flag_p2_info));
 }
 
 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 bool dirstate_item_c_has_fallback_exec(dirstateItemObject *self)
 {
 	return (bool)self->flags & dirstate_flag_has_fallback_exec;
 }
 
 static inline bool
 dirstate_item_c_has_fallback_symlink(dirstateItemObject *self)
 {
 	return (bool)self->flags & dirstate_flag_has_fallback_symlink;
 }
 
 static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_has_meaningful_data) {
 		return self->mode;
 	} else {
 		return 0;
 	}
 }
 
 static inline int dirstate_item_c_v1_size(dirstateItemObject *self)
 {
 	if (!(self->flags & dirstate_flag_wc_tracked) &&
 	    (self->flags & dirstate_flag_p2_info)) {
 		if (self->flags & dirstate_flag_p1_tracked) {
 			return dirstate_v1_nonnormal;
 		} else {
 			return dirstate_v1_from_p2;
 		}
 	} else if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (self->flags & dirstate_flag_p2_info) {
 		return dirstate_v1_from_p2;
 	} else if (dirstate_item_c_added(self)) {
 		return dirstate_v1_nonnormal;
 	} else if (self->flags & dirstate_flag_has_meaningful_data) {
 		return self->size;
 	} else {
 		return dirstate_v1_nonnormal;
 	}
 }
 
 static inline int dirstate_item_c_v1_mtime(dirstateItemObject *self)
 {
 	if (dirstate_item_c_removed(self)) {
 		return 0;
 	} else if (!(self->flags & dirstate_flag_has_mtime) ||
 	           !(self->flags & dirstate_flag_p1_tracked) ||
 	           !(self->flags & dirstate_flag_wc_tracked) ||
 	           (self->flags & dirstate_flag_p2_info)) {
 		return ambiguous_time;
 	} else {
 		return self->mtime_s;
 	}
 }
 
 static PyObject *dirstate_item_v2_data(dirstateItemObject *self)
 {
 	int flags = self->flags;
 	int mode = dirstate_item_c_v1_mode(self);
 #ifdef S_IXUSR
 	/* This is for platforms with an exec bit */
 	if ((mode & S_IXUSR) != 0) {
 		flags |= dirstate_flag_mode_exec_perm;
 	} else {
 		flags &= ~dirstate_flag_mode_exec_perm;
 	}
 #else
 	flags &= ~dirstate_flag_mode_exec_perm;
 #endif
 #ifdef S_ISLNK
 	/* This is for platforms with support for symlinks */
 	if (S_ISLNK(mode)) {
 		flags |= dirstate_flag_mode_is_symlink;
 	} else {
 		flags &= ~dirstate_flag_mode_is_symlink;
 	}
 #else
 	flags &= ~dirstate_flag_mode_is_symlink;
 #endif
 	return Py_BuildValue("iiii", flags, self->size, self->mtime_s,
 	                     self->mtime_ns);
 };
 
 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 *now)
-{
-	int now_s;
-	int now_ns;
-	if (!PyArg_ParseTuple(now, "ii", &now_s, &now_ns)) {
-		return NULL;
-	}
-	if (dirstate_item_c_v1_state(self) == 'n' && self->mtime_s == now_s) {
-		Py_RETURN_TRUE;
-	} else {
-		Py_RETURN_FALSE;
-	}
-};
-
 static PyObject *dirstate_item_mtime_likely_equal_to(dirstateItemObject *self,
                                                      PyObject *other)
 {
 	int other_s;
 	int other_ns;
 	if (!PyArg_ParseTuple(other, "ii", &other_s, &other_ns)) {
 		return NULL;
 	}
 	if ((self->flags & dirstate_flag_has_mtime) &&
 	    self->mtime_s == other_s &&
 	    (self->mtime_ns == other_ns || self->mtime_ns == 0 ||
 	     other_ns == 0)) {
 		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;
 	}
 	t->flags = 0;
 	t->mode = 0;
 	t->size = 0;
 	t->mtime_s = 0;
 	t->mtime_ns = 0;
 
 	if (state == 'm') {
 		t->flags = (dirstate_flag_wc_tracked |
 		            dirstate_flag_p1_tracked | dirstate_flag_p2_info);
 	} else if (state == 'a') {
 		t->flags = dirstate_flag_wc_tracked;
 	} else if (state == 'r') {
 		if (size == dirstate_v1_nonnormal) {
 			t->flags =
 			    dirstate_flag_p1_tracked | dirstate_flag_p2_info;
 		} else if (size == dirstate_v1_from_p2) {
 			t->flags = dirstate_flag_p2_info;
 		} 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_info;
 		} else if (size == dirstate_v1_nonnormal) {
 			t->flags =
 			    dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
 		} else if (mtime == ambiguous_time) {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked |
 			            dirstate_flag_has_meaningful_data);
 			t->mode = mode;
 			t->size = size;
 		} else {
 			t->flags = (dirstate_flag_wc_tracked |
 			            dirstate_flag_p1_tracked |
 			            dirstate_flag_has_meaningful_data |
 			            dirstate_flag_has_mtime);
 			t->mode = mode;
 			t->size = size;
 			t->mtime_s = 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);
 };
 
 static PyObject *dirstate_item_from_v2_meth(PyTypeObject *subtype,
                                             PyObject *args)
 {
 	dirstateItemObject *t =
 	    PyObject_New(dirstateItemObject, &dirstateItemType);
 	if (!t) {
 		return NULL;
 	}
 	if (!PyArg_ParseTuple(args, "iiii", &t->flags, &t->size, &t->mtime_s,
 	                      &t->mtime_ns)) {
 		return NULL;
 	}
 	if (t->flags & dirstate_flag_expected_state_is_modified) {
 		t->flags &= ~(dirstate_flag_expected_state_is_modified |
 		              dirstate_flag_has_meaningful_data |
 		              dirstate_flag_has_mtime);
 	}
 	if (t->flags & dirstate_flag_mtime_second_ambiguous) {
 		/* The current code is not able to do the more subtle comparison
 		 * that the MTIME_SECOND_AMBIGUOUS requires. So we ignore the
 		 * mtime */
 		t->flags &= ~(dirstate_flag_mtime_second_ambiguous |
 		              dirstate_flag_has_meaningful_data |
 		              dirstate_flag_has_mtime);
 	}
 	t->mode = 0;
 	if (t->flags & dirstate_flag_has_meaningful_data) {
 		if (t->flags & dirstate_flag_mode_exec_perm) {
 			t->mode = 0755;
 		} else {
 			t->mode = 0644;
 		}
 		if (t->flags & dirstate_flag_mode_is_symlink) {
 			t->mode |= S_IFLNK;
 		} else {
 			t->mode |= S_IFREG;
 		}
 	}
 	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_has_mtime;
 	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_s, mtime_ns;
 	PyObject *mtime;
 	mtime_s = 0;
 	mtime_ns = 0;
 	if (!PyArg_ParseTuple(args, "iiO", &mode, &size, &mtime)) {
 		return NULL;
 	}
 	if (mtime != Py_None) {
 		if (!PyArg_ParseTuple(mtime, "ii", &mtime_s, &mtime_ns)) {
 			return NULL;
 		}
 	} else {
 		self->flags &= ~dirstate_flag_has_mtime;
 	}
 	self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
 	              dirstate_flag_has_meaningful_data |
 	              dirstate_flag_has_mtime;
 	self->mode = mode;
 	self->size = size;
 	self->mtime_s = mtime_s;
 	self->mtime_ns = mtime_ns;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
 {
 	self->flags |= dirstate_flag_wc_tracked;
 	self->flags &= ~dirstate_flag_has_mtime;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
 {
 	self->flags &= ~dirstate_flag_wc_tracked;
 	self->mode = 0;
 	self->size = 0;
 	self->mtime_s = 0;
 	self->mtime_ns = 0;
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirstate_item_drop_merge_data(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_p2_info) {
 		self->flags &= ~(dirstate_flag_p2_info |
 		                 dirstate_flag_has_meaningful_data |
 		                 dirstate_flag_has_mtime);
 		self->mode = 0;
 		self->size = 0;
 		self->mtime_s = 0;
 		self->mtime_ns = 0;
 	}
 	Py_RETURN_NONE;
 }
 static PyMethodDef dirstate_item_methods[] = {
     {"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,
      "return data suitable for v2 serialization"},
     {"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"},
     {"mtime_likely_equal_to", (PyCFunction)dirstate_item_mtime_likely_equal_to,
      METH_O, "True if the stored mtime is likely equal to the given mtime"},
     {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
      METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
     {"from_v2_data", (PyCFunction)dirstate_item_from_v2_meth,
      METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V2 data"},
     {"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_has_fallback_exec(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_exec(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_fallback_exec(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_exec(self)) {
 		if (self->flags & dirstate_flag_fallback_exec) {
 			Py_RETURN_TRUE;
 		} else {
 			Py_RETURN_FALSE;
 		}
 	} else {
 		Py_RETURN_NONE;
 	}
 };
 
 static int dirstate_item_set_fallback_exec(dirstateItemObject *self,
                                            PyObject *value)
 {
 	if ((value == Py_None) || (value == NULL)) {
 		self->flags &= ~dirstate_flag_has_fallback_exec;
 	} else {
 		self->flags |= dirstate_flag_has_fallback_exec;
 		if (PyObject_IsTrue(value)) {
 			self->flags |= dirstate_flag_fallback_exec;
 		} else {
 			self->flags &= ~dirstate_flag_fallback_exec;
 		}
 	}
 	return 0;
 };
 
 static PyObject *
 dirstate_item_get_has_fallback_symlink(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_symlink(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 static PyObject *dirstate_item_get_fallback_symlink(dirstateItemObject *self)
 {
 	if (dirstate_item_c_has_fallback_symlink(self)) {
 		if (self->flags & dirstate_flag_fallback_symlink) {
 			Py_RETURN_TRUE;
 		} else {
 			Py_RETURN_FALSE;
 		}
 	} else {
 		Py_RETURN_NONE;
 	}
 };
 
 static int dirstate_item_set_fallback_symlink(dirstateItemObject *self,
                                               PyObject *value)
 {
 	if ((value == Py_None) || (value == NULL)) {
 		self->flags &= ~dirstate_flag_has_fallback_symlink;
 	} else {
 		self->flags |= dirstate_flag_has_fallback_symlink;
 		if (PyObject_IsTrue(value)) {
 			self->flags |= dirstate_flag_fallback_symlink;
 		} else {
 			self->flags &= ~dirstate_flag_fallback_symlink;
 		}
 	}
 	return 0;
 };
 
 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_p1_tracked(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_p1_tracked) {
 		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_p2_info(dirstateItemObject *self)
 {
 	if (self->flags & dirstate_flag_wc_tracked &&
 	    self->flags & dirstate_flag_p2_info) {
 		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 (!(self->flags & dirstate_flag_p1_tracked)) {
 		Py_RETURN_FALSE;
 	} else if (self->flags & dirstate_flag_p2_info) {
 		Py_RETURN_FALSE;
 	} else {
 		Py_RETURN_TRUE;
 	}
 };
 
 static PyObject *dirstate_item_get_any_tracked(dirstateItemObject *self)
 {
 	if (dirstate_item_c_any_tracked(self)) {
 		Py_RETURN_TRUE;
 	} else {
 		Py_RETURN_FALSE;
 	}
 };
 
 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},
     {"has_fallback_exec", (getter)dirstate_item_get_has_fallback_exec, NULL,
      "has_fallback_exec", NULL},
     {"fallback_exec", (getter)dirstate_item_get_fallback_exec,
      (setter)dirstate_item_set_fallback_exec, "fallback_exec", NULL},
     {"has_fallback_symlink", (getter)dirstate_item_get_has_fallback_symlink,
      NULL, "has_fallback_symlink", NULL},
     {"fallback_symlink", (getter)dirstate_item_get_fallback_symlink,
      (setter)dirstate_item_set_fallback_symlink, "fallback_symlink", NULL},
     {"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
     {"p1_tracked", (getter)dirstate_item_get_p1_tracked, NULL, "p1_tracked",
      NULL},
     {"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
     {"p2_info", (getter)dirstate_item_get_p2_info, NULL, "p2_info", 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},
     {"any_tracked", (getter)dirstate_item_get_any_tracked, NULL, "any_tracked",
      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_s;
-	int now_ns;
 
-	if (!PyArg_ParseTuple(args, "O!O!O!(ii):pack_dirstate", &PyDict_Type,
-	                      &map, &PyDict_Type, &copymap, &PyTuple_Type, &pl,
-	                      &now_s, &now_ns)) {
+	if (!PyArg_ParseTuple(args, "O!O!O!:pack_dirstate", &PyDict_Type, &map,
+	                      &PyDict_Type, &copymap, &PyTuple_Type, &pl)) {
 		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' && tuple->mtime_s == now_s) {
-			/* 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/dirstate.py

@@ -1,1491 +1,1472 b''
 # dirstate.py - working directory tracking for mercurial
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # 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 collections
 import contextlib
 import errno
 import os
 import stat
 
 from .i18n import _
 from .pycompat import delattr
 
 from hgdemandimport import tracing
 
 from . import (
     dirstatemap,
     encoding,
     error,
     match as matchmod,
     pathutil,
     policy,
     pycompat,
     scmutil,
     sparse,
     util,
 )
 
 from .dirstateutils import (
     timestamp,
 )
 
 from .interfaces import (
     dirstate as intdirstate,
     util as interfaceutil,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 HAS_FAST_DIRSTATE_V2 = rustmod is not None
 
 propertycache = util.propertycache
 filecache = scmutil.filecache
 _rangemask = dirstatemap.rangemask
 
 DirstateItem = dirstatemap.DirstateItem
 
 
 class repocache(filecache):
     """filecache for files in .hg/"""
 
     def join(self, obj, fname):
         return obj._opener.join(fname)
 
 
 class rootcache(filecache):
     """filecache for files in the repository root"""
 
     def join(self, obj, fname):
         return obj._join(fname)
 
 
 def requires_parents_change(func):
     def wrap(self, *args, **kwargs):
         if not self.pendingparentchange():
             msg = 'calling `%s` outside of a parentchange context'
             msg %= func.__name__
             raise error.ProgrammingError(msg)
         return func(self, *args, **kwargs)
 
     return wrap
 
 
 def requires_no_parents_change(func):
     def wrap(self, *args, **kwargs):
         if self.pendingparentchange():
             msg = 'calling `%s` inside of a parentchange context'
             msg %= func.__name__
             raise error.ProgrammingError(msg)
         return func(self, *args, **kwargs)
 
     return wrap
 
 
 @interfaceutil.implementer(intdirstate.idirstate)
 class dirstate(object):
     def __init__(
         self,
         opener,
         ui,
         root,
         validate,
         sparsematchfn,
         nodeconstants,
         use_dirstate_v2,
     ):
         """Create a new dirstate object.
 
         opener is an open()-like callable that can be used to open the
         dirstate file; root is the root of the directory tracked by
         the dirstate.
         """
         self._use_dirstate_v2 = use_dirstate_v2
         self._nodeconstants = nodeconstants
         self._opener = opener
         self._validate = validate
         self._root = root
         self._sparsematchfn = sparsematchfn
         # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
         # UNC path pointing to root share (issue4557)
         self._rootdir = pathutil.normasprefix(root)
         self._dirty = False
         self._ui = ui
         self._filecache = {}
         self._parentwriters = 0
         self._filename = b'dirstate'
         self._pendingfilename = b'%s.pending' % self._filename
         self._plchangecallbacks = {}
         self._origpl = None
         self._mapcls = dirstatemap.dirstatemap
         # Access and cache cwd early, so we don't access it for the first time
         # after a working-copy update caused it to not exist (accessing it then
         # raises an exception).
         self._cwd
 
     def prefetch_parents(self):
         """make sure the parents are loaded
 
         Used to avoid a race condition.
         """
         self._pl
 
     @contextlib.contextmanager
     def parentchange(self):
         """Context manager for handling dirstate parents.
 
         If an exception occurs in the scope of the context manager,
         the incoherent dirstate won't be written when wlock is
         released.
         """
         self._parentwriters += 1
         yield
         # Typically we want the "undo" step of a context manager in a
         # finally block so it happens even when an exception
         # occurs. In this case, however, we only want to decrement
         # parentwriters if the code in the with statement exits
         # normally, so we don't have a try/finally here on purpose.
         self._parentwriters -= 1
 
     def pendingparentchange(self):
         """Returns true if the dirstate is in the middle of a set of changes
         that modify the dirstate parent.
         """
         return self._parentwriters > 0
 
     @propertycache
     def _map(self):
         """Return the dirstate contents (see documentation for dirstatemap)."""
         self._map = self._mapcls(
             self._ui,
             self._opener,
             self._root,
             self._nodeconstants,
             self._use_dirstate_v2,
         )
         return self._map
 
     @property
     def _sparsematcher(self):
         """The matcher for the sparse checkout.
 
         The working directory may not include every file from a manifest. The
         matcher obtained by this property will match a path if it is to be
         included in the working directory.
         """
         # TODO there is potential to cache this property. For now, the matcher
         # is resolved on every access. (But the called function does use a
         # cache to keep the lookup fast.)
         return self._sparsematchfn()
 
     @repocache(b'branch')
     def _branch(self):
         try:
             return self._opener.read(b"branch").strip() or b"default"
         except IOError as inst:
             if inst.errno != errno.ENOENT:
                 raise
             return b"default"
 
     @property
     def _pl(self):
         return self._map.parents()
 
     def hasdir(self, d):
         return self._map.hastrackeddir(d)
 
     @rootcache(b'.hgignore')
     def _ignore(self):
         files = self._ignorefiles()
         if not files:
             return matchmod.never()
 
         pats = [b'include:%s' % f for f in files]
         return matchmod.match(self._root, b'', [], pats, warn=self._ui.warn)
 
     @propertycache
     def _slash(self):
         return self._ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/'
 
     @propertycache
     def _checklink(self):
         return util.checklink(self._root)
 
     @propertycache
     def _checkexec(self):
         return bool(util.checkexec(self._root))
 
     @propertycache
     def _checkcase(self):
         return not util.fscasesensitive(self._join(b'.hg'))
 
     def _join(self, f):
         # much faster than os.path.join()
         # it's safe because f is always a relative path
         return self._rootdir + f
 
     def flagfunc(self, buildfallback):
         """build a callable that returns flags associated with a filename
 
         The information is extracted from three possible layers:
         1. the file system if it supports the information
         2. the "fallback" information stored in the dirstate if any
         3. a more expensive mechanism inferring the flags from the parents.
         """
 
         # small hack to cache the result of buildfallback()
         fallback_func = []
 
         def get_flags(x):
             entry = None
             fallback_value = None
             try:
                 st = os.lstat(self._join(x))
             except OSError:
                 return b''
 
             if self._checklink:
                 if util.statislink(st):
                     return b'l'
             else:
                 entry = self.get_entry(x)
                 if entry.has_fallback_symlink:
                     if entry.fallback_symlink:
                         return b'l'
                 else:
                     if not fallback_func:
                         fallback_func.append(buildfallback())
                     fallback_value = fallback_func[0](x)
                     if b'l' in fallback_value:
                         return b'l'
 
             if self._checkexec:
                 if util.statisexec(st):
                     return b'x'
             else:
                 if entry is None:
                     entry = self.get_entry(x)
                 if entry.has_fallback_exec:
                     if entry.fallback_exec:
                         return b'x'
                 else:
                     if fallback_value is None:
                         if not fallback_func:
                             fallback_func.append(buildfallback())
                         fallback_value = fallback_func[0](x)
                     if b'x' in fallback_value:
                         return b'x'
             return b''
 
         return get_flags
 
     @propertycache
     def _cwd(self):
         # internal config: ui.forcecwd
         forcecwd = self._ui.config(b'ui', b'forcecwd')
         if forcecwd:
             return forcecwd
         return encoding.getcwd()
 
     def getcwd(self):
         """Return the path from which a canonical path is calculated.
 
         This path should be used to resolve file patterns or to convert
         canonical paths back to file paths for display. It shouldn't be
         used to get real file paths. Use vfs functions instead.
         """
         cwd = self._cwd
         if cwd == self._root:
             return b''
         # self._root ends with a path separator if self._root is '/' or 'C:\'
         rootsep = self._root
         if not util.endswithsep(rootsep):
             rootsep += pycompat.ossep
         if cwd.startswith(rootsep):
             return cwd[len(rootsep) :]
         else:
             # we're outside the repo. return an absolute path.
             return cwd
 
     def pathto(self, f, cwd=None):
         if cwd is None:
             cwd = self.getcwd()
         path = util.pathto(self._root, cwd, f)
         if self._slash:
             return util.pconvert(path)
         return path
 
     def __getitem__(self, key):
         """Return the current state of key (a filename) in the dirstate.
 
         States are:
           n  normal
           m  needs merging
           r  marked for removal
           a  marked for addition
           ?  not tracked
 
         XXX The "state" is a bit obscure to be in the "public" API. we should
         consider migrating all user of this to going through the dirstate entry
         instead.
         """
         msg = b"don't use dirstate[file], use dirstate.get_entry(file)"
         util.nouideprecwarn(msg, b'6.1', stacklevel=2)
         entry = self._map.get(key)
         if entry is not None:
             return entry.state
         return b'?'
 
     def get_entry(self, path):
         """return a DirstateItem for the associated path"""
         entry = self._map.get(path)
         if entry is None:
             return DirstateItem()
         return entry
 
     def __contains__(self, key):
         return key in self._map
 
     def __iter__(self):
         return iter(sorted(self._map))
 
     def items(self):
         return pycompat.iteritems(self._map)
 
     iteritems = items
 
     def parents(self):
         return [self._validate(p) for p in self._pl]
 
     def p1(self):
         return self._validate(self._pl[0])
 
     def p2(self):
         return self._validate(self._pl[1])
 
     @property
     def in_merge(self):
         """True if a merge is in progress"""
         return self._pl[1] != self._nodeconstants.nullid
 
     def branch(self):
         return encoding.tolocal(self._branch)
 
     def setparents(self, p1, p2=None):
         """Set dirstate parents to p1 and p2.
 
         When moving from two parents to one, "merged" entries a
         adjusted to normal and previous copy records discarded and
         returned by the call.
 
         See localrepo.setparents()
         """
         if p2 is None:
             p2 = self._nodeconstants.nullid
         if self._parentwriters == 0:
             raise ValueError(
                 b"cannot set dirstate parent outside of "
                 b"dirstate.parentchange context manager"
             )
 
         self._dirty = True
         oldp2 = self._pl[1]
         if self._origpl is None:
             self._origpl = self._pl
         nullid = self._nodeconstants.nullid
         # True if we need to fold p2 related state back to a linear case
         fold_p2 = oldp2 != nullid and p2 == nullid
         return self._map.setparents(p1, p2, fold_p2=fold_p2)
 
     def setbranch(self, branch):
         self.__class__._branch.set(self, encoding.fromlocal(branch))
         f = self._opener(b'branch', b'w', atomictemp=True, checkambig=True)
         try:
             f.write(self._branch + b'\n')
             f.close()
 
             # make sure filecache has the correct stat info for _branch after
             # replacing the underlying file
             ce = self._filecache[b'_branch']
             if ce:
                 ce.refresh()
         except:  # re-raises
             f.discard()
             raise
 
     def invalidate(self):
         """Causes the next access to reread the dirstate.
 
         This is different from localrepo.invalidatedirstate() because it always
         rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
         check whether the dirstate has changed before rereading it."""
 
         for a in ("_map", "_branch", "_ignore"):
             if a in self.__dict__:
                 delattr(self, a)
         self._dirty = False
         self._parentwriters = 0
         self._origpl = None
 
     def copy(self, source, dest):
         """Mark dest as a copy of source. Unmark dest if source is None."""
         if source == dest:
             return
         self._dirty = True
         if source is not None:
             self._map.copymap[dest] = source
         else:
             self._map.copymap.pop(dest, None)
 
     def copied(self, file):
         return self._map.copymap.get(file, None)
 
     def copies(self):
         return self._map.copymap
 
     @requires_no_parents_change
     def set_tracked(self, filename, reset_copy=False):
         """a "public" method for generic code to mark a file as tracked
 
         This function is to be called outside of "update/merge" case. For
         example by a command like `hg add X`.
 
         if reset_copy is set, any existing copy information will be dropped.
 
         return True the file was previously untracked, False otherwise.
         """
         self._dirty = True
         entry = self._map.get(filename)
         if entry is None or not entry.tracked:
             self._check_new_tracked_filename(filename)
         pre_tracked = self._map.set_tracked(filename)
         if reset_copy:
             self._map.copymap.pop(filename, None)
         return pre_tracked
 
     @requires_no_parents_change
     def set_untracked(self, filename):
         """a "public" method for generic code to mark a file as untracked
 
         This function is to be called outside of "update/merge" case. For
         example by a command like `hg remove X`.
 
         return True the file was previously tracked, False otherwise.
         """
         ret = self._map.set_untracked(filename)
         if ret:
             self._dirty = True
         return ret
 
     @requires_no_parents_change
     def set_clean(self, filename, parentfiledata):
         """record that the current state of the file on disk is known to be clean"""
         self._dirty = True
         if not self._map[filename].tracked:
             self._check_new_tracked_filename(filename)
         (mode, size, mtime) = parentfiledata
         self._map.set_clean(filename, mode, size, mtime)
 
     @requires_no_parents_change
     def set_possibly_dirty(self, filename):
         """record that the current state of the file on disk is unknown"""
         self._dirty = True
         self._map.set_possibly_dirty(filename)
 
     @requires_parents_change
     def update_file_p1(
         self,
         filename,
         p1_tracked,
     ):
         """Set a file as tracked in the parent (or not)
 
         This is to be called when adjust the dirstate to a new parent after an history
         rewriting operation.
 
         It should not be called during a merge (p2 != nullid) and only within
         a `with dirstate.parentchange():` context.
         """
         if self.in_merge:
             msg = b'update_file_reference should not be called when merging'
             raise error.ProgrammingError(msg)
         entry = self._map.get(filename)
         if entry is None:
             wc_tracked = False
         else:
             wc_tracked = entry.tracked
         if not (p1_tracked or wc_tracked):
             # the file is no longer relevant to anyone
             if self._map.get(filename) is not None:
                 self._map.reset_state(filename)
                 self._dirty = True
         elif (not p1_tracked) and wc_tracked:
             if entry is not None and entry.added:
                 return  # avoid dropping copy information (maybe?)
 
         self._map.reset_state(
             filename,
             wc_tracked,
             p1_tracked,
             # the underlying reference might have changed, we will have to
             # check it.
             has_meaningful_mtime=False,
         )
 
     @requires_parents_change
     def update_file(
         self,
         filename,
         wc_tracked,
         p1_tracked,
         p2_info=False,
         possibly_dirty=False,
         parentfiledata=None,
     ):
         """update the information about a file in the dirstate
 
         This is to be called when the direstates parent changes to keep track
         of what is the file situation in regards to the working copy and its parent.
 
         This function must be called within a `dirstate.parentchange` context.
 
         note: the API is at an early stage and we might need to adjust it
         depending of what information ends up being relevant and useful to
         other processing.
         """
 
         # note: I do not think we need to double check name clash here since we
         # are in a update/merge case that should already have taken care of
         # this. The test agrees
 
         self._dirty = True
 
         self._map.reset_state(
             filename,
             wc_tracked,
             p1_tracked,
             p2_info=p2_info,
             has_meaningful_mtime=not possibly_dirty,
             parentfiledata=parentfiledata,
         )
 
     def _check_new_tracked_filename(self, filename):
         scmutil.checkfilename(filename)
         if self._map.hastrackeddir(filename):
             msg = _(b'directory %r already in dirstate')
             msg %= pycompat.bytestr(filename)
             raise error.Abort(msg)
         # shadows
         for d in pathutil.finddirs(filename):
             if self._map.hastrackeddir(d):
                 break
             entry = self._map.get(d)
             if entry is not None and not entry.removed:
                 msg = _(b'file %r in dirstate clashes with %r')
                 msg %= (pycompat.bytestr(d), pycompat.bytestr(filename))
                 raise error.Abort(msg)
 
     def _get_filedata(self, filename):
         """returns"""
         s = os.lstat(self._join(filename))
         mode = s.st_mode
         size = s.st_size
         mtime = timestamp.mtime_of(s)
         return (mode, size, mtime)
 
     def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
         if exists is None:
             exists = os.path.lexists(os.path.join(self._root, path))
         if not exists:
             # Maybe a path component exists
             if not ignoremissing and b'/' in path:
                 d, f = path.rsplit(b'/', 1)
                 d = self._normalize(d, False, ignoremissing, None)
                 folded = d + b"/" + f
             else:
                 # No path components, preserve original case
                 folded = path
         else:
             # recursively normalize leading directory components
             # against dirstate
             if b'/' in normed:
                 d, f = normed.rsplit(b'/', 1)
                 d = self._normalize(d, False, ignoremissing, True)
                 r = self._root + b"/" + d
                 folded = d + b"/" + util.fspath(f, r)
             else:
                 folded = util.fspath(normed, self._root)
             storemap[normed] = folded
 
         return folded
 
     def _normalizefile(self, path, isknown, ignoremissing=False, exists=None):
         normed = util.normcase(path)
         folded = self._map.filefoldmap.get(normed, None)
         if folded is None:
             if isknown:
                 folded = path
             else:
                 folded = self._discoverpath(
                     path, normed, ignoremissing, exists, self._map.filefoldmap
                 )
         return folded
 
     def _normalize(self, path, isknown, ignoremissing=False, exists=None):
         normed = util.normcase(path)
         folded = self._map.filefoldmap.get(normed, None)
         if folded is None:
             folded = self._map.dirfoldmap.get(normed, None)
         if folded is None:
             if isknown:
                 folded = path
             else:
                 # store discovered result in dirfoldmap so that future
                 # normalizefile calls don't start matching directories
                 folded = self._discoverpath(
                     path, normed, ignoremissing, exists, self._map.dirfoldmap
                 )
         return folded
 
     def normalize(self, path, isknown=False, ignoremissing=False):
         """
         normalize the case of a pathname when on a casefolding filesystem
 
         isknown specifies whether the filename came from walking the
         disk, to avoid extra filesystem access.
 
         If ignoremissing is True, missing path are returned
         unchanged. Otherwise, we try harder to normalize possibly
         existing path components.
 
         The normalized case is determined based on the following precedence:
 
         - version of name already stored in the dirstate
         - version of name stored on disk
         - version provided via command arguments
         """
 
         if self._checkcase:
             return self._normalize(path, isknown, ignoremissing)
         return path
 
     def clear(self):
         self._map.clear()
         self._dirty = True
 
     def rebuild(self, parent, allfiles, changedfiles=None):
         if changedfiles is None:
             # Rebuild entire dirstate
             to_lookup = allfiles
             to_drop = []
             self.clear()
         elif len(changedfiles) < 10:
             # Avoid turning allfiles into a set, which can be expensive if it's
             # large.
             to_lookup = []
             to_drop = []
             for f in changedfiles:
                 if f in allfiles:
                     to_lookup.append(f)
                 else:
                     to_drop.append(f)
         else:
             changedfilesset = set(changedfiles)
             to_lookup = changedfilesset & set(allfiles)
             to_drop = changedfilesset - to_lookup
 
         if self._origpl is None:
             self._origpl = self._pl
         self._map.setparents(parent, self._nodeconstants.nullid)
 
         for f in to_lookup:
 
             if self.in_merge:
                 self.set_tracked(f)
             else:
                 self._map.reset_state(
                     f,
                     wc_tracked=True,
                     p1_tracked=True,
                 )
         for f in to_drop:
             self._map.reset_state(f)
 
         self._dirty = True
 
     def identity(self):
         """Return identity of dirstate itself to detect changing in storage
 
         If identity of previous dirstate is equal to this, writing
         changes based on the former dirstate out can keep consistency.
         """
         return self._map.identity
 
     def write(self, tr):
         if not self._dirty:
             return
 
         filename = self._filename
         if tr:
             # 'dirstate.write()' is not only for writing in-memory
             # changes out, but also for dropping ambiguous timestamp.
             # delayed writing re-raise "ambiguous timestamp issue".
             # See also the wiki page below for detail:
             # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan
 
             # record when mtime start to be ambiguous
             now = timestamp.get_fs_now(self._opener)
 
             # delay writing in-memory changes out
             tr.addfilegenerator(
                 b'dirstate',
                 (self._filename,),
                 lambda f: self._writedirstate(tr, f, now=now),
                 location=b'plain',
             )
             return
 
         st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
         self._writedirstate(tr, st)
 
     def addparentchangecallback(self, category, callback):
         """add a callback to be called when the wd parents are changed
 
         Callback will be called with the following arguments:
             dirstate, (oldp1, oldp2), (newp1, newp2)
 
         Category is a unique identifier to allow overwriting an old callback
         with a newer callback.
         """
         self._plchangecallbacks[category] = callback
 
     def _writedirstate(self, tr, st, now=None):
         # notify callbacks about parents change
         if self._origpl is not None and self._origpl != self._pl:
             for c, callback in sorted(
                 pycompat.iteritems(self._plchangecallbacks)
             ):
                 callback(self, self._origpl, self._pl)
             self._origpl = None
 
         if now is None:
             # use the modification time of the newly created temporary file as the
             # filesystem's notion of 'now'
             now = timestamp.mtime_of(util.fstat(st))
 
-        # enough 'delaywrite' prevents 'pack_dirstate' from dropping
-        # timestamp of each entries in dirstate, because of 'now > mtime'
-        delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
-        if delaywrite > 0:
-            # do we have any files to delay for?
-            for f, e in pycompat.iteritems(self._map):
-                if e.need_delay(now):
-                    import time  # to avoid useless import
-
-                    # rather than sleep n seconds, sleep until the next
-                    # multiple of n seconds
-                    clock = time.time()
-                    start = int(clock) - (int(clock) % delaywrite)
-                    end = start + delaywrite
-                    time.sleep(end - clock)
-                    # trust our estimate that the end is near now
-                    now = timestamp.timestamp((end, 0))
-                    break
-
         self._map.write(tr, st, now)
         self._dirty = False
 
     def _dirignore(self, f):
         if self._ignore(f):
             return True
         for p in pathutil.finddirs(f):
             if self._ignore(p):
                 return True
         return False
 
     def _ignorefiles(self):
         files = []
         if os.path.exists(self._join(b'.hgignore')):
             files.append(self._join(b'.hgignore'))
         for name, path in self._ui.configitems(b"ui"):
             if name == b'ignore' or name.startswith(b'ignore.'):
                 # we need to use os.path.join here rather than self._join
                 # because path is arbitrary and user-specified
                 files.append(os.path.join(self._rootdir, util.expandpath(path)))
         return files
 
     def _ignorefileandline(self, f):
         files = collections.deque(self._ignorefiles())
         visited = set()
         while files:
             i = files.popleft()
             patterns = matchmod.readpatternfile(
                 i, self._ui.warn, sourceinfo=True
             )
             for pattern, lineno, line in patterns:
                 kind, p = matchmod._patsplit(pattern, b'glob')
                 if kind == b"subinclude":
                     if p not in visited:
                         files.append(p)
                     continue
                 m = matchmod.match(
                     self._root, b'', [], [pattern], warn=self._ui.warn
                 )
                 if m(f):
                     return (i, lineno, line)
             visited.add(i)
         return (None, -1, b"")
 
     def _walkexplicit(self, match, subrepos):
         """Get stat data about the files explicitly specified by match.
 
         Return a triple (results, dirsfound, dirsnotfound).
         - results is a mapping from filename to stat result. It also contains
           listings mapping subrepos and .hg to None.
         - dirsfound is a list of files found to be directories.
         - dirsnotfound is a list of files that the dirstate thinks are
           directories and that were not found."""
 
         def badtype(mode):
             kind = _(b'unknown')
             if stat.S_ISCHR(mode):
                 kind = _(b'character device')
             elif stat.S_ISBLK(mode):
                 kind = _(b'block device')
             elif stat.S_ISFIFO(mode):
                 kind = _(b'fifo')
             elif stat.S_ISSOCK(mode):
                 kind = _(b'socket')
             elif stat.S_ISDIR(mode):
                 kind = _(b'directory')
             return _(b'unsupported file type (type is %s)') % kind
 
         badfn = match.bad
         dmap = self._map
         lstat = os.lstat
         getkind = stat.S_IFMT
         dirkind = stat.S_IFDIR
         regkind = stat.S_IFREG
         lnkkind = stat.S_IFLNK
         join = self._join
         dirsfound = []
         foundadd = dirsfound.append
         dirsnotfound = []
         notfoundadd = dirsnotfound.append
 
         if not match.isexact() and self._checkcase:
             normalize = self._normalize
         else:
             normalize = None
 
         files = sorted(match.files())
         subrepos.sort()
         i, j = 0, 0
         while i < len(files) and j < len(subrepos):
             subpath = subrepos[j] + b"/"
             if files[i] < subpath:
                 i += 1
                 continue
             while i < len(files) and files[i].startswith(subpath):
                 del files[i]
             j += 1
 
         if not files or b'' in files:
             files = [b'']
             # constructing the foldmap is expensive, so don't do it for the
             # common case where files is ['']
             normalize = None
         results = dict.fromkeys(subrepos)
         results[b'.hg'] = None
 
         for ff in files:
             if normalize:
                 nf = normalize(ff, False, True)
             else:
                 nf = ff
             if nf in results:
                 continue
 
             try:
                 st = lstat(join(nf))
                 kind = getkind(st.st_mode)
                 if kind == dirkind:
                     if nf in dmap:
                         # file replaced by dir on disk but still in dirstate
                         results[nf] = None
                     foundadd((nf, ff))
                 elif kind == regkind or kind == lnkkind:
                     results[nf] = st
                 else:
                     badfn(ff, badtype(kind))
                     if nf in dmap:
                         results[nf] = None
             except OSError as inst:  # nf not found on disk - it is dirstate only
                 if nf in dmap:  # does it exactly match a missing file?
                     results[nf] = None
                 else:  # does it match a missing directory?
                     if self._map.hasdir(nf):
                         notfoundadd(nf)
                     else:
                         badfn(ff, encoding.strtolocal(inst.strerror))
 
         # match.files() may contain explicitly-specified paths that shouldn't
         # be taken; drop them from the list of files found. dirsfound/notfound
         # aren't filtered here because they will be tested later.
         if match.anypats():
             for f in list(results):
                 if f == b'.hg' or f in subrepos:
                     # keep sentinel to disable further out-of-repo walks
                     continue
                 if not match(f):
                     del results[f]
 
         # Case insensitive filesystems cannot rely on lstat() failing to detect
         # a case-only rename.  Prune the stat object for any file that does not
         # match the case in the filesystem, if there are multiple files that
         # normalize to the same path.
         if match.isexact() and self._checkcase:
             normed = {}
 
             for f, st in pycompat.iteritems(results):
                 if st is None:
                     continue
 
                 nc = util.normcase(f)
                 paths = normed.get(nc)
 
                 if paths is None:
                     paths = set()
                     normed[nc] = paths
 
                 paths.add(f)
 
             for norm, paths in pycompat.iteritems(normed):
                 if len(paths) > 1:
                     for path in paths:
                         folded = self._discoverpath(
                             path, norm, True, None, self._map.dirfoldmap
                         )
                         if path != folded:
                             results[path] = None
 
         return results, dirsfound, dirsnotfound
 
     def walk(self, match, subrepos, unknown, ignored, full=True):
         """
         Walk recursively through the directory tree, finding all files
         matched by match.
 
         If full is False, maybe skip some known-clean files.
 
         Return a dict mapping filename to stat-like object (either
         mercurial.osutil.stat instance or return value of os.stat()).
 
         """
         # full is a flag that extensions that hook into walk can use -- this
         # implementation doesn't use it at all. This satisfies the contract
         # because we only guarantee a "maybe".
 
         if ignored:
             ignore = util.never
             dirignore = util.never
         elif unknown:
             ignore = self._ignore
             dirignore = self._dirignore
         else:
             # if not unknown and not ignored, drop dir recursion and step 2
             ignore = util.always
             dirignore = util.always
 
         matchfn = match.matchfn
         matchalways = match.always()
         matchtdir = match.traversedir
         dmap = self._map
         listdir = util.listdir
         lstat = os.lstat
         dirkind = stat.S_IFDIR
         regkind = stat.S_IFREG
         lnkkind = stat.S_IFLNK
         join = self._join
 
         exact = skipstep3 = False
         if match.isexact():  # match.exact
             exact = True
             dirignore = util.always  # skip step 2
         elif match.prefix():  # match.match, no patterns
             skipstep3 = True
 
         if not exact and self._checkcase:
             normalize = self._normalize
             normalizefile = self._normalizefile
             skipstep3 = False
         else:
             normalize = self._normalize
             normalizefile = None
 
         # step 1: find all explicit files
         results, work, dirsnotfound = self._walkexplicit(match, subrepos)
         if matchtdir:
             for d in work:
                 matchtdir(d[0])
             for d in dirsnotfound:
                 matchtdir(d)
 
         skipstep3 = skipstep3 and not (work or dirsnotfound)
         work = [d for d in work if not dirignore(d[0])]
 
         # step 2: visit subdirectories
         def traverse(work, alreadynormed):
             wadd = work.append
             while work:
                 tracing.counter('dirstate.walk work', len(work))
                 nd = work.pop()
                 visitentries = match.visitchildrenset(nd)
                 if not visitentries:
                     continue
                 if visitentries == b'this' or visitentries == b'all':
                     visitentries = None
                 skip = None
                 if nd != b'':
                     skip = b'.hg'
                 try:
                     with tracing.log('dirstate.walk.traverse listdir %s', nd):
                         entries = listdir(join(nd), stat=True, skip=skip)
                 except OSError as inst:
                     if inst.errno in (errno.EACCES, errno.ENOENT):
                         match.bad(
                             self.pathto(nd), encoding.strtolocal(inst.strerror)
                         )
                         continue
                     raise
                 for f, kind, st in entries:
                     # Some matchers may return files in the visitentries set,
                     # instead of 'this', if the matcher explicitly mentions them
                     # and is not an exactmatcher. This is acceptable; we do not
                     # make any hard assumptions about file-or-directory below
                     # based on the presence of `f` in visitentries. If
                     # visitchildrenset returned a set, we can always skip the
                     # entries *not* in the set it provided regardless of whether
                     # they're actually a file or a directory.
                     if visitentries and f not in visitentries:
                         continue
                     if normalizefile:
                         # even though f might be a directory, we're only
                         # interested in comparing it to files currently in the
                         # dmap -- therefore normalizefile is enough
                         nf = normalizefile(
                             nd and (nd + b"/" + f) or f, True, True
                         )
                     else:
                         nf = nd and (nd + b"/" + f) or f
                     if nf not in results:
                         if kind == dirkind:
                             if not ignore(nf):
                                 if matchtdir:
                                     matchtdir(nf)
                                 wadd(nf)
                             if nf in dmap and (matchalways or matchfn(nf)):
                                 results[nf] = None
                         elif kind == regkind or kind == lnkkind:
                             if nf in dmap:
                                 if matchalways or matchfn(nf):
                                     results[nf] = st
                             elif (matchalways or matchfn(nf)) and not ignore(
                                 nf
                             ):
                                 # unknown file -- normalize if necessary
                                 if not alreadynormed:
                                     nf = normalize(nf, False, True)
                                 results[nf] = st
                         elif nf in dmap and (matchalways or matchfn(nf)):
                             results[nf] = None
 
         for nd, d in work:
             # alreadynormed means that processwork doesn't have to do any
             # expensive directory normalization
             alreadynormed = not normalize or nd == d
             traverse([d], alreadynormed)
 
         for s in subrepos:
             del results[s]
         del results[b'.hg']
 
         # step 3: visit remaining files from dmap
         if not skipstep3 and not exact:
             # If a dmap file is not in results yet, it was either
             # a) not matching matchfn b) ignored, c) missing, or d) under a
             # symlink directory.
             if not results and matchalways:
                 visit = [f for f in dmap]
             else:
                 visit = [f for f in dmap if f not in results and matchfn(f)]
             visit.sort()
 
             if unknown:
                 # unknown == True means we walked all dirs under the roots
                 # that wasn't ignored, and everything that matched was stat'ed
                 # and is already in results.
                 # The rest must thus be ignored or under a symlink.
                 audit_path = pathutil.pathauditor(self._root, cached=True)
 
                 for nf in iter(visit):
                     # If a stat for the same file was already added with a
                     # different case, don't add one for this, since that would
                     # make it appear as if the file exists under both names
                     # on disk.
                     if (
                         normalizefile
                         and normalizefile(nf, True, True) in results
                     ):
                         results[nf] = None
                     # Report ignored items in the dmap as long as they are not
                     # under a symlink directory.
                     elif audit_path.check(nf):
                         try:
                             results[nf] = lstat(join(nf))
                             # file was just ignored, no links, and exists
                         except OSError:
                             # file doesn't exist
                             results[nf] = None
                     else:
                         # It's either missing or under a symlink directory
                         # which we in this case report as missing
                         results[nf] = None
             else:
                 # We may not have walked the full directory tree above,
                 # so stat and check everything we missed.
                 iv = iter(visit)
                 for st in util.statfiles([join(i) for i in visit]):
                     results[next(iv)] = st
         return results
 
     def _rust_status(self, matcher, list_clean, list_ignored, list_unknown):
         # Force Rayon (Rust parallelism library) to respect the number of
         # workers. This is a temporary workaround until Rust code knows
         # how to read the config file.
         numcpus = self._ui.configint(b"worker", b"numcpus")
         if numcpus is not None:
             encoding.environ.setdefault(b'RAYON_NUM_THREADS', b'%d' % numcpus)
 
         workers_enabled = self._ui.configbool(b"worker", b"enabled", True)
         if not workers_enabled:
             encoding.environ[b"RAYON_NUM_THREADS"] = b"1"
 
         (
             lookup,
             modified,
             added,
             removed,
             deleted,
             clean,
             ignored,
             unknown,
             warnings,
             bad,
             traversed,
             dirty,
         ) = rustmod.status(
             self._map._map,
             matcher,
             self._rootdir,
             self._ignorefiles(),
             self._checkexec,
             bool(list_clean),
             bool(list_ignored),
             bool(list_unknown),
             bool(matcher.traversedir),
         )
 
         self._dirty |= dirty
 
         if matcher.traversedir:
             for dir in traversed:
                 matcher.traversedir(dir)
 
         if self._ui.warn:
             for item in warnings:
                 if isinstance(item, tuple):
                     file_path, syntax = item
                     msg = _(b"%s: ignoring invalid syntax '%s'\n") % (
                         file_path,
                         syntax,
                     )
                     self._ui.warn(msg)
                 else:
                     msg = _(b"skipping unreadable pattern file '%s': %s\n")
                     self._ui.warn(
                         msg
                         % (
                             pathutil.canonpath(
                                 self._rootdir, self._rootdir, item
                             ),
                             b"No such file or directory",
                         )
                     )
 
         for (fn, message) in bad:
             matcher.bad(fn, encoding.strtolocal(message))
 
         status = scmutil.status(
             modified=modified,
             added=added,
             removed=removed,
             deleted=deleted,
             unknown=unknown,
             ignored=ignored,
             clean=clean,
         )
         return (lookup, status)
 
     def status(self, match, subrepos, ignored, clean, unknown):
         """Determine the status of the working copy relative to the
         dirstate and return a pair of (unsure, status), where status is of type
         scmutil.status and:
 
           unsure:
             files that might have been modified since the dirstate was
             written, but need to be read to be sure (size is the same
             but mtime differs)
           status.modified:
             files that have definitely been modified since the dirstate
             was written (different size or mode)
           status.clean:
             files that have definitely not been modified since the
             dirstate was written
         """
         listignored, listclean, listunknown = ignored, clean, unknown
         lookup, modified, added, unknown, ignored = [], [], [], [], []
         removed, deleted, clean = [], [], []
 
         dmap = self._map
         dmap.preload()
 
         use_rust = True
 
         allowed_matchers = (
             matchmod.alwaysmatcher,
             matchmod.exactmatcher,
             matchmod.includematcher,
         )
 
         if rustmod is None:
             use_rust = False
         elif self._checkcase:
             # Case-insensitive filesystems are not handled yet
             use_rust = False
         elif subrepos:
             use_rust = False
         elif sparse.enabled:
             use_rust = False
         elif not isinstance(match, allowed_matchers):
             # Some matchers have yet to be implemented
             use_rust = False
 
         # Get the time from the filesystem so we can disambiguate files that
         # appear modified in the present or future.
         try:
             mtime_boundary = timestamp.get_fs_now(self._opener)
         except OSError:
             # In largefiles or readonly context
             mtime_boundary = None
 
         if use_rust:
             try:
                 res = self._rust_status(
                     match, listclean, listignored, listunknown
                 )
                 return res + (mtime_boundary,)
             except rustmod.FallbackError:
                 pass
 
         def noop(f):
             pass
 
         dcontains = dmap.__contains__
         dget = dmap.__getitem__
         ladd = lookup.append  # aka "unsure"
         madd = modified.append
         aadd = added.append
         uadd = unknown.append if listunknown else noop
         iadd = ignored.append if listignored else noop
         radd = removed.append
         dadd = deleted.append
         cadd = clean.append if listclean else noop
         mexact = match.exact
         dirignore = self._dirignore
         checkexec = self._checkexec
         checklink = self._checklink
         copymap = self._map.copymap
 
         # We need to do full walks when either
         # - we're listing all clean files, or
         # - match.traversedir does something, because match.traversedir should
         #   be called for every dir in the working dir
         full = listclean or match.traversedir is not None
         for fn, st in pycompat.iteritems(
             self.walk(match, subrepos, listunknown, listignored, full=full)
         ):
             if not dcontains(fn):
                 if (listignored or mexact(fn)) and dirignore(fn):
                     if listignored:
                         iadd(fn)
                 else:
                     uadd(fn)
                 continue
 
             t = dget(fn)
             mode = t.mode
             size = t.size
 
             if not st and t.tracked:
                 dadd(fn)
             elif t.p2_info:
                 madd(fn)
             elif t.added:
                 aadd(fn)
             elif t.removed:
                 radd(fn)
             elif t.tracked:
                 if not checklink and t.has_fallback_symlink:
                     # If the file system does not support symlink, the mode
                     # might not be correctly stored in the dirstate, so do not
                     # trust it.
                     ladd(fn)
                 elif not checkexec and t.has_fallback_exec:
                     # If the file system does not support exec bits, the mode
                     # might not be correctly stored in the dirstate, so do not
                     # trust it.
                     ladd(fn)
                 elif (
                     size >= 0
                     and (
                         (size != st.st_size and size != st.st_size & _rangemask)
                         or ((mode ^ st.st_mode) & 0o100 and checkexec)
                     )
                     or fn in copymap
                 ):
                     if stat.S_ISLNK(st.st_mode) and size != st.st_size:
                         # issue6456: Size returned may be longer due to
                         # encryption on EXT-4 fscrypt, undecided.
                         ladd(fn)
                     else:
                         madd(fn)
                 elif not t.mtime_likely_equal_to(timestamp.mtime_of(st)):
                     # There might be a change in the future if for example the
                     # internal clock is off, but this is a case where the issues
                     # the user would face would be a lot worse and there is
                     # nothing we can really do.
                     ladd(fn)
                 elif listclean:
                     cadd(fn)
         status = scmutil.status(
             modified, added, removed, deleted, unknown, ignored, clean
         )
         return (lookup, status, mtime_boundary)
 
     def matches(self, match):
         """
         return files in the dirstate (in whatever state) filtered by match
         """
         dmap = self._map
         if rustmod is not None:
             dmap = self._map._map
 
         if match.always():
             return dmap.keys()
         files = match.files()
         if match.isexact():
             # fast path -- filter the other way around, since typically files is
             # much smaller than dmap
             return [f for f in files if f in dmap]
         if match.prefix() and all(fn in dmap for fn in files):
             # fast path -- all the values are known to be files, so just return
             # that
             return list(files)
         return [f for f in dmap if match(f)]
 
     def _actualfilename(self, tr):
         if tr:
             return self._pendingfilename
         else:
             return self._filename
 
     def savebackup(self, tr, backupname):
         '''Save current dirstate into backup file'''
         filename = self._actualfilename(tr)
         assert backupname != filename
 
         # use '_writedirstate' instead of 'write' to write changes certainly,
         # because the latter omits writing out if transaction is running.
         # output file will be used to create backup of dirstate at this point.
         if self._dirty or not self._opener.exists(filename):
             self._writedirstate(
                 tr,
                 self._opener(filename, b"w", atomictemp=True, checkambig=True),
             )
 
         if tr:
             # ensure that subsequent tr.writepending returns True for
             # changes written out above, even if dirstate is never
             # changed after this
             tr.addfilegenerator(
                 b'dirstate',
                 (self._filename,),
                 lambda f: self._writedirstate(tr, f),
                 location=b'plain',
             )
 
             # ensure that pending file written above is unlinked at
             # failure, even if tr.writepending isn't invoked until the
             # end of this transaction
             tr.registertmp(filename, location=b'plain')
 
         self._opener.tryunlink(backupname)
         # hardlink backup is okay because _writedirstate is always called
         # with an "atomictemp=True" file.
         util.copyfile(
             self._opener.join(filename),
             self._opener.join(backupname),
             hardlink=True,
         )
 
     def restorebackup(self, tr, backupname):
         '''Restore dirstate by backup file'''
         # this "invalidate()" prevents "wlock.release()" from writing
         # changes of dirstate out after restoring from backup file
         self.invalidate()
         filename = self._actualfilename(tr)
         o = self._opener
         if util.samefile(o.join(backupname), o.join(filename)):
             o.unlink(backupname)
         else:
             o.rename(backupname, filename, checkambig=True)
 
     def clearbackup(self, tr, backupname):
         '''Clear backup file'''
         self._opener.unlink(backupname)
 
     def verify(self, m1, m2):
         """check the dirstate content again the parent manifest and yield errors"""
         missing_from_p1 = b"%s in state %s, but not in manifest1\n"
         unexpected_in_p1 = b"%s in state %s, but also in manifest1\n"
         missing_from_ps = b"%s in state %s, but not in either manifest\n"
         missing_from_ds = b"%s in manifest1, but listed as state %s\n"
         for f, entry in self.items():
             state = entry.state
             if state in b"nr" and f not in m1:
                 yield (missing_from_p1, f, state)
             if state in b"a" and f in m1:
                 yield (unexpected_in_p1, f, state)
             if state in b"m" and f not in m1 and f not in m2:
                 yield (missing_from_ps, f, state)
         for f in m1:
             state = self.get_entry(f).state
             if state not in b"nrm":
                 yield (missing_from_ds, f, state)

mercurial/dirstatemap.py

@@ -1,732 +1,732 b''
 # dirstatemap.py
 #
 # 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 errno
 
 from .i18n import _
 
 from . import (
     error,
     pathutil,
     policy,
     pycompat,
     txnutil,
     util,
 )
 
 from .dirstateutils import (
     docket as docketmod,
     v2,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 propertycache = util.propertycache
 
 if rustmod is None:
     DirstateItem = parsers.DirstateItem
 else:
     DirstateItem = rustmod.DirstateItem
 
 rangemask = 0x7FFFFFFF
 
 
 class _dirstatemapcommon(object):
     """
     Methods that are identical for both implementations of the dirstatemap
     class, with and without Rust extensions enabled.
     """
 
     # please pytype
 
     _map = None
     copymap = None
 
     def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
         self._use_dirstate_v2 = use_dirstate_v2
         self._nodeconstants = nodeconstants
         self._ui = ui
         self._opener = opener
         self._root = root
         self._filename = b'dirstate'
         self._nodelen = 20  # Also update Rust code when changing this!
         self._parents = None
         self._dirtyparents = False
         self._docket = None
 
         # for consistent view between _pl() and _read() invocations
         self._pendingmode = None
 
     def preload(self):
         """Loads the underlying data, if it's not already loaded"""
         self._map
 
     def get(self, key, default=None):
         return self._map.get(key, default)
 
     def __len__(self):
         return len(self._map)
 
     def __iter__(self):
         return iter(self._map)
 
     def __contains__(self, key):
         return key in self._map
 
     def __getitem__(self, item):
         return self._map[item]
 
     ### sub-class utility method
     #
     # Use to allow for generic implementation of some method while still coping
     # with minor difference between implementation.
 
     def _dirs_incr(self, filename, old_entry=None):
         """incremente the dirstate counter if applicable
 
         This might be a no-op for some subclass who deal with directory
         tracking in a different way.
         """
 
     def _dirs_decr(self, filename, old_entry=None, remove_variant=False):
         """decremente the dirstate counter if applicable
 
         This might be a no-op for some subclass who deal with directory
         tracking in a different way.
         """
 
     def _refresh_entry(self, f, entry):
         """record updated state of an entry"""
 
     def _insert_entry(self, f, entry):
         """add a new dirstate entry (or replace an unrelated one)
 
         The fact it is actually new is the responsability of the caller
         """
 
     def _drop_entry(self, f):
         """remove any entry for file f
 
         This should also drop associated copy information
 
         The fact we actually need to drop it is the responsability of the caller"""
 
     ### method to manipulate the entries
 
     def set_possibly_dirty(self, filename):
         """record that the current state of the file on disk is unknown"""
         entry = self[filename]
         entry.set_possibly_dirty()
         self._refresh_entry(filename, entry)
 
     def set_clean(self, filename, mode, size, mtime):
         """mark a file as back to a clean state"""
         entry = self[filename]
         size = size & rangemask
         entry.set_clean(mode, size, mtime)
         self._refresh_entry(filename, entry)
         self.copymap.pop(filename, None)
 
     def set_tracked(self, filename):
         new = False
         entry = self.get(filename)
         if entry is None:
             self._dirs_incr(filename)
             entry = DirstateItem(
                 wc_tracked=True,
             )
 
             self._insert_entry(filename, entry)
             new = True
         elif not entry.tracked:
             self._dirs_incr(filename, entry)
             entry.set_tracked()
             self._refresh_entry(filename, entry)
             new = True
         else:
             # XXX This is probably overkill for more case, but we need this to
             # fully replace the `normallookup` call with `set_tracked` one.
             # Consider smoothing this in the future.
             entry.set_possibly_dirty()
             self._refresh_entry(filename, entry)
         return new
 
     def set_untracked(self, f):
         """Mark a file as no longer tracked in the dirstate map"""
         entry = self.get(f)
         if entry is None:
             return False
         else:
             self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)
             if not entry.p2_info:
                 self.copymap.pop(f, None)
             entry.set_untracked()
             self._refresh_entry(f, entry)
             return True
 
     def reset_state(
         self,
         filename,
         wc_tracked=False,
         p1_tracked=False,
         p2_info=False,
         has_meaningful_mtime=True,
         has_meaningful_data=True,
         parentfiledata=None,
     ):
         """Set a entry to a given state, diregarding all previous state
 
         This is to be used by the part of the dirstate API dedicated to
         adjusting the dirstate after a update/merge.
 
         note: calling this might result to no entry existing at all if the
         dirstate map does not see any point at having one for this file
         anymore.
         """
         # copy information are now outdated
         # (maybe new information should be in directly passed to this function)
         self.copymap.pop(filename, None)
 
         if not (p1_tracked or p2_info or wc_tracked):
             old_entry = self._map.get(filename)
             self._drop_entry(filename)
             self._dirs_decr(filename, old_entry=old_entry)
             return
 
         old_entry = self._map.get(filename)
         self._dirs_incr(filename, old_entry)
         entry = DirstateItem(
             wc_tracked=wc_tracked,
             p1_tracked=p1_tracked,
             p2_info=p2_info,
             has_meaningful_mtime=has_meaningful_mtime,
             parentfiledata=parentfiledata,
         )
         self._insert_entry(filename, entry)
 
     ### disk interaction
 
     def _opendirstatefile(self):
         fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
         if self._pendingmode is not None and self._pendingmode != mode:
             fp.close()
             raise error.Abort(
                 _(b'working directory state may be changed parallelly')
             )
         self._pendingmode = mode
         return fp
 
     def _readdirstatefile(self, size=-1):
         try:
             with self._opendirstatefile() as fp:
                 return fp.read(size)
         except IOError as err:
             if err.errno != errno.ENOENT:
                 raise
             # File doesn't exist, so the current state is empty
             return b''
 
     @property
     def docket(self):
         if not self._docket:
             if not self._use_dirstate_v2:
                 raise error.ProgrammingError(
                     b'dirstate only has a docket in v2 format'
                 )
             self._docket = docketmod.DirstateDocket.parse(
                 self._readdirstatefile(), self._nodeconstants
             )
         return self._docket
 
     def write_v2_no_append(self, tr, st, meta, packed):
         old_docket = self.docket
         new_docket = docketmod.DirstateDocket.with_new_uuid(
             self.parents(), len(packed), meta
         )
         data_filename = new_docket.data_filename()
         if tr:
             tr.add(data_filename, 0)
         self._opener.write(data_filename, packed)
         # Write the new docket after the new data file has been
         # written. Because `st` was opened with `atomictemp=True`,
         # the actual `.hg/dirstate` file is only affected on close.
         st.write(new_docket.serialize())
         st.close()
         # Remove the old data file after the new docket pointing to
         # the new data file was written.
         if old_docket.uuid:
             data_filename = old_docket.data_filename()
             unlink = lambda _tr=None: self._opener.unlink(data_filename)
             if tr:
                 category = b"dirstate-v2-clean-" + old_docket.uuid
                 tr.addpostclose(category, unlink)
             else:
                 unlink()
         self._docket = new_docket
 
     ### reading/setting parents
 
     def parents(self):
         if not self._parents:
             if self._use_dirstate_v2:
                 self._parents = self.docket.parents
             else:
                 read_len = self._nodelen * 2
                 st = self._readdirstatefile(read_len)
                 l = len(st)
                 if l == read_len:
                     self._parents = (
                         st[: self._nodelen],
                         st[self._nodelen : 2 * self._nodelen],
                     )
                 elif l == 0:
                     self._parents = (
                         self._nodeconstants.nullid,
                         self._nodeconstants.nullid,
                     )
                 else:
                     raise error.Abort(
                         _(b'working directory state appears damaged!')
                     )
 
         return self._parents
 
 
 class dirstatemap(_dirstatemapcommon):
     """Map encapsulating the dirstate's contents.
 
     The dirstate contains the following state:
 
     - `identity` is the identity of the dirstate file, which can be used to
       detect when changes have occurred to the dirstate file.
 
     - `parents` is a pair containing the parents of the working copy. The
       parents are updated by calling `setparents`.
 
     - the state map maps filenames to tuples of (state, mode, size, mtime),
       where state is a single character representing 'normal', 'added',
       'removed', or 'merged'. It is read by treating the dirstate as a
       dict.  File state is updated by calling various methods (see each
       documentation for details):
 
       - `reset_state`,
       - `set_tracked`
       - `set_untracked`
       - `set_clean`
       - `set_possibly_dirty`
 
     - `copymap` maps destination filenames to their source filename.
 
     The dirstate also provides the following views onto the state:
 
     - `filefoldmap` is a dict mapping normalized filenames to the denormalized
       form that they appear as in the dirstate.
 
     - `dirfoldmap` is a dict mapping normalized directory names to the
       denormalized form that they appear as in the dirstate.
     """
 
     ### Core data storage and access
 
     @propertycache
     def _map(self):
         self._map = {}
         self.read()
         return self._map
 
     @propertycache
     def copymap(self):
         self.copymap = {}
         self._map
         return self.copymap
 
     def clear(self):
         self._map.clear()
         self.copymap.clear()
         self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
         util.clearcachedproperty(self, b"_dirs")
         util.clearcachedproperty(self, b"_alldirs")
         util.clearcachedproperty(self, b"filefoldmap")
         util.clearcachedproperty(self, b"dirfoldmap")
 
     def items(self):
         return pycompat.iteritems(self._map)
 
     # forward for python2,3 compat
     iteritems = items
 
     def debug_iter(self, all):
         """
         Return an iterator of (filename, state, mode, size, mtime) tuples
 
         `all` is unused when Rust is not enabled
         """
         for (filename, item) in self.items():
             yield (filename, item.state, item.mode, item.size, item.mtime)
 
     def keys(self):
         return self._map.keys()
 
     ### reading/setting parents
 
     def setparents(self, p1, p2, fold_p2=False):
         self._parents = (p1, p2)
         self._dirtyparents = True
         copies = {}
         if fold_p2:
             for f, s in pycompat.iteritems(self._map):
                 # Discard "merged" markers when moving away from a merge state
                 if s.p2_info:
                     source = self.copymap.pop(f, None)
                     if source:
                         copies[f] = source
                     s.drop_merge_data()
         return copies
 
     ### disk interaction
 
     def read(self):
         # ignore HG_PENDING because identity is used only for writing
         self.identity = util.filestat.frompath(
             self._opener.join(self._filename)
         )
 
         if self._use_dirstate_v2:
             if not self.docket.uuid:
                 return
             st = self._opener.read(self.docket.data_filename())
         else:
             st = self._readdirstatefile()
 
         if not st:
             return
 
         # TODO: adjust this estimate for dirstate-v2
         if util.safehasattr(parsers, b'dict_new_presized'):
             # Make an estimate of the number of files in the dirstate based on
             # its size. This trades wasting some memory for avoiding costly
             # resizes. Each entry have a prefix of 17 bytes followed by one or
             # two path names. Studies on various large-scale real-world repositories
             # found 54 bytes a reasonable upper limit for the average path names.
             # Copy entries are ignored for the sake of this estimate.
             self._map = parsers.dict_new_presized(len(st) // 71)
 
         # Python's garbage collector triggers a GC each time a certain number
         # of container objects (the number being defined by
         # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
         # for each file in the dirstate. The C version then immediately marks
         # them as not to be tracked by the collector. However, this has no
         # effect on when GCs are triggered, only on what objects the GC looks
         # into. This means that O(number of files) GCs are unavoidable.
         # Depending on when in the process's lifetime the dirstate is parsed,
         # this can get very expensive. As a workaround, disable GC while
         # parsing the dirstate.
         #
         # (we cannot decorate the function directly since it is in a C module)
         if self._use_dirstate_v2:
             p = self.docket.parents
             meta = self.docket.tree_metadata
             parse_dirstate = util.nogc(v2.parse_dirstate)
             parse_dirstate(self._map, self.copymap, st, meta)
         else:
             parse_dirstate = util.nogc(parsers.parse_dirstate)
             p = parse_dirstate(self._map, self.copymap, st)
         if not self._dirtyparents:
             self.setparents(*p)
 
         # Avoid excess attribute lookups by fast pathing certain checks
         self.__contains__ = self._map.__contains__
         self.__getitem__ = self._map.__getitem__
         self.get = self._map.get
 
     def write(self, tr, st, now):
         if self._use_dirstate_v2:
-            packed, meta = v2.pack_dirstate(self._map, self.copymap, now)
+            packed, meta = v2.pack_dirstate(self._map, self.copymap)
             self.write_v2_no_append(tr, st, meta, packed)
         else:
             packed = parsers.pack_dirstate(
-                self._map, self.copymap, self.parents(), now
+                self._map, self.copymap, self.parents()
             )
             st.write(packed)
             st.close()
         self._dirtyparents = False
 
     @propertycache
     def identity(self):
         self._map
         return self.identity
 
     ### code related to maintaining and accessing "extra" property
     # (e.g. "has_dir")
 
     def _dirs_incr(self, filename, old_entry=None):
         """incremente the dirstate counter if applicable"""
         if (
             old_entry is None or old_entry.removed
         ) and "_dirs" in self.__dict__:
             self._dirs.addpath(filename)
         if old_entry is None and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
 
     def _dirs_decr(self, filename, old_entry=None, remove_variant=False):
         """decremente the dirstate counter if applicable"""
         if old_entry is not None:
             if "_dirs" in self.__dict__ and not old_entry.removed:
                 self._dirs.delpath(filename)
             if "_alldirs" in self.__dict__ and not remove_variant:
                 self._alldirs.delpath(filename)
         elif remove_variant and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
         if "filefoldmap" in self.__dict__:
             normed = util.normcase(filename)
             self.filefoldmap.pop(normed, None)
 
     @propertycache
     def filefoldmap(self):
         """Returns a dictionary mapping normalized case paths to their
         non-normalized versions.
         """
         try:
             makefilefoldmap = parsers.make_file_foldmap
         except AttributeError:
             pass
         else:
             return makefilefoldmap(
                 self._map, util.normcasespec, util.normcasefallback
             )
 
         f = {}
         normcase = util.normcase
         for name, s in pycompat.iteritems(self._map):
             if not s.removed:
                 f[normcase(name)] = name
         f[b'.'] = b'.'  # prevents useless util.fspath() invocation
         return f
 
     @propertycache
     def dirfoldmap(self):
         f = {}
         normcase = util.normcase
         for name in self._dirs:
             f[normcase(name)] = name
         return f
 
     def hastrackeddir(self, d):
         """
         Returns True if the dirstate contains a tracked (not removed) file
         in this directory.
         """
         return d in self._dirs
 
     def hasdir(self, d):
         """
         Returns True if the dirstate contains a file (tracked or removed)
         in this directory.
         """
         return d in self._alldirs
 
     @propertycache
     def _dirs(self):
         return pathutil.dirs(self._map, only_tracked=True)
 
     @propertycache
     def _alldirs(self):
         return pathutil.dirs(self._map)
 
     ### code related to manipulation of entries and copy-sources
 
     def _refresh_entry(self, f, entry):
         if not entry.any_tracked:
             self._map.pop(f, None)
 
     def _insert_entry(self, f, entry):
         self._map[f] = entry
 
     def _drop_entry(self, f):
         self._map.pop(f, None)
         self.copymap.pop(f, None)
 
 
 if rustmod is not None:
 
     class dirstatemap(_dirstatemapcommon):
 
         ### Core data storage and access
 
         @propertycache
         def _map(self):
             """
             Fills the Dirstatemap when called.
             """
             # ignore HG_PENDING because identity is used only for writing
             self.identity = util.filestat.frompath(
                 self._opener.join(self._filename)
             )
 
             if self._use_dirstate_v2:
                 if self.docket.uuid:
                     # TODO: use mmap when possible
                     data = self._opener.read(self.docket.data_filename())
                 else:
                     data = b''
                 self._map = rustmod.DirstateMap.new_v2(
                     data, self.docket.data_size, self.docket.tree_metadata
                 )
                 parents = self.docket.parents
             else:
                 self._map, parents = rustmod.DirstateMap.new_v1(
                     self._readdirstatefile()
                 )
 
             if parents and not self._dirtyparents:
                 self.setparents(*parents)
 
             self.__contains__ = self._map.__contains__
             self.__getitem__ = self._map.__getitem__
             self.get = self._map.get
             return self._map
 
         @property
         def copymap(self):
             return self._map.copymap()
 
         def debug_iter(self, all):
             """
             Return an iterator of (filename, state, mode, size, mtime) tuples
 
             `all`: also include with `state == b' '` dirstate tree nodes that
             don't have an associated `DirstateItem`.
 
             """
             return self._map.debug_iter(all)
 
         def clear(self):
             self._map.clear()
             self.setparents(
                 self._nodeconstants.nullid, self._nodeconstants.nullid
             )
             util.clearcachedproperty(self, b"_dirs")
             util.clearcachedproperty(self, b"_alldirs")
             util.clearcachedproperty(self, b"dirfoldmap")
 
         def items(self):
             return self._map.items()
 
         # forward for python2,3 compat
         iteritems = items
 
         def keys(self):
             return iter(self._map)
 
         ### reading/setting parents
 
         def setparents(self, p1, p2, fold_p2=False):
             self._parents = (p1, p2)
             self._dirtyparents = True
             copies = {}
             if fold_p2:
                 # Collect into an intermediate list to avoid a `RuntimeError`
                 # exception due to mutation during iteration.
                 # TODO: move this the whole loop to Rust where `iter_mut`
                 # enables in-place mutation of elements of a collection while
                 # iterating it, without mutating the collection itself.
                 files_with_p2_info = [
                     f for f, s in self._map.items() if s.p2_info
                 ]
                 rust_map = self._map
                 for f in files_with_p2_info:
                     e = rust_map.get(f)
                     source = self.copymap.pop(f, None)
                     if source:
                         copies[f] = source
                     e.drop_merge_data()
                     rust_map.set_dirstate_item(f, e)
             return copies
 
         ### disk interaction
 
         @propertycache
         def identity(self):
             self._map
             return self.identity
 
         def write(self, tr, st, now):
             if not self._use_dirstate_v2:
                 p1, p2 = self.parents()
-                packed = self._map.write_v1(p1, p2, now)
+                packed = self._map.write_v1(p1, p2)
                 st.write(packed)
                 st.close()
                 self._dirtyparents = False
                 return
 
             # We can only append to an existing data file if there is one
             can_append = self.docket.uuid is not None
-            packed, meta, append = self._map.write_v2(now, can_append)
+            packed, meta, append = self._map.write_v2(can_append)
             if append:
                 docket = self.docket
                 data_filename = docket.data_filename()
                 if tr:
                     tr.add(data_filename, docket.data_size)
                 with self._opener(data_filename, b'r+b') as fp:
                     fp.seek(docket.data_size)
                     assert fp.tell() == docket.data_size
                     written = fp.write(packed)
                     if written is not None:  # py2 may return None
                         assert written == len(packed), (written, len(packed))
                 docket.data_size += len(packed)
                 docket.parents = self.parents()
                 docket.tree_metadata = meta
                 st.write(docket.serialize())
                 st.close()
             else:
                 self.write_v2_no_append(tr, st, meta, packed)
             # Reload from the newly-written file
             util.clearcachedproperty(self, b"_map")
             self._dirtyparents = False
 
         ### code related to maintaining and accessing "extra" property
         # (e.g. "has_dir")
 
         @propertycache
         def filefoldmap(self):
             """Returns a dictionary mapping normalized case paths to their
             non-normalized versions.
             """
             return self._map.filefoldmapasdict()
 
         def hastrackeddir(self, d):
             return self._map.hastrackeddir(d)
 
         def hasdir(self, d):
             return self._map.hasdir(d)
 
         @propertycache
         def dirfoldmap(self):
             f = {}
             normcase = util.normcase
             for name in self._map.tracked_dirs():
                 f[normcase(name)] = name
             return f
 
         ### code related to manipulation of entries and copy-sources
 
         def _refresh_entry(self, f, entry):
             if not entry.any_tracked:
                 self._map.drop_item_and_copy_source(f)
             else:
                 self._map.addfile(f, entry)
 
         def _insert_entry(self, f, entry):
             self._map.addfile(f, entry)
 
         def _drop_entry(self, f):
             self._map.drop_item_and_copy_source(f)
 
         def __setitem__(self, key, value):
             assert isinstance(value, DirstateItem)
             self._map.set_dirstate_item(key, value)

mercurial/dirstateutils/v2.py

@@ -1,414 +1,401 b''
 # v2.py - Pure-Python implementation of the dirstate-v2 file format
 #
 # Copyright Mercurial Contributors
 #
 # 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
 
 from ..thirdparty import attr
 from .. import error, policy
 
 parsers = policy.importmod('parsers')
 
 
 # Must match the constant of the same name in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`
 TREE_METADATA_SIZE = 44
 NODE_SIZE = 44
 
 
 # Must match the `TreeMetadata` Rust struct in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`. See doc-comments there.
 #
 # * 4 bytes: start offset of root nodes
 # * 4 bytes: number of root nodes
 # * 4 bytes: total number of nodes in the tree that have an entry
 # * 4 bytes: total number of nodes in the tree that have a copy source
 # * 4 bytes: number of bytes in the data file that are not used anymore
 # * 4 bytes: unused
 # * 20 bytes: SHA-1 hash of ignore patterns
 TREE_METADATA = struct.Struct('>LLLLL4s20s')
 
 
 # Must match the `Node` Rust struct in
 # `rust/hg-core/src/dirstate_tree/on_disk.rs`. See doc-comments there.
 #
 # * 4 bytes: start offset of full path
 # * 2 bytes: length of the full path
 # * 2 bytes: length within the full path before its "base name"
 # * 4 bytes: start offset of the copy source if any, or zero for no copy source
 # * 2 bytes: length of the copy source if any, or unused
 # * 4 bytes: start offset of child nodes
 # * 4 bytes: number of child nodes
 # * 4 bytes: number of descendant nodes that have an entry
 # * 4 bytes: number of descendant nodes that have a "tracked" state
 # * 1 byte: flags
 # * 4 bytes: expected size
 # * 4 bytes: mtime seconds
 # * 4 bytes: mtime nanoseconds
 NODE = struct.Struct('>LHHLHLLLLHlll')
 
 
 assert TREE_METADATA_SIZE == TREE_METADATA.size
 assert NODE_SIZE == NODE.size
 
 # match constant in mercurial/pure/parsers.py
 DIRSTATE_V2_DIRECTORY = 1 << 5
 
 
 def parse_dirstate(map, copy_map, data, tree_metadata):
     """parse a full v2-dirstate from a binary data into dictionnaries:
 
     - map: a {path: entry} mapping that will be filled
     - copy_map: a {path: copy-source} mapping that will be filled
     - data: a binary blob contains v2 nodes data
     - tree_metadata:: a binary blob of the top level node (from the docket)
     """
     (
         root_nodes_start,
         root_nodes_len,
         _nodes_with_entry_count,
         _nodes_with_copy_source_count,
         _unreachable_bytes,
         _unused,
         _ignore_patterns_hash,
     ) = TREE_METADATA.unpack(tree_metadata)
     parse_nodes(map, copy_map, data, root_nodes_start, root_nodes_len)
 
 
 def parse_nodes(map, copy_map, data, start, len):
     """parse <len> nodes from <data> starting at offset <start>
 
     This is used by parse_dirstate to recursively fill `map` and `copy_map`.
 
     All directory specific information is ignored and do not need any
     processing (DIRECTORY, ALL_UNKNOWN_RECORDED, ALL_IGNORED_RECORDED)
     """
     for i in range(len):
         node_start = start + NODE_SIZE * i
         node_bytes = slice_with_len(data, node_start, NODE_SIZE)
         (
             path_start,
             path_len,
             _basename_start,
             copy_source_start,
             copy_source_len,
             children_start,
             children_count,
             _descendants_with_entry_count,
             _tracked_descendants_count,
             flags,
             size,
             mtime_s,
             mtime_ns,
         ) = NODE.unpack(node_bytes)
 
         # Parse child nodes of this node recursively
         parse_nodes(map, copy_map, data, children_start, children_count)
 
         item = parsers.DirstateItem.from_v2_data(flags, size, mtime_s, mtime_ns)
         if not item.any_tracked:
             continue
         path = slice_with_len(data, path_start, path_len)
         map[path] = item
         if copy_source_start:
             copy_map[path] = slice_with_len(
                 data, copy_source_start, copy_source_len
             )
 
 
 def slice_with_len(data, start, len):
     return data[start : start + len]
 
 
 @attr.s
 class Node(object):
     path = attr.ib()
     entry = attr.ib()
     parent = attr.ib(default=None)
     children_count = attr.ib(default=0)
     children_offset = attr.ib(default=0)
     descendants_with_entry = attr.ib(default=0)
     tracked_descendants = attr.ib(default=0)
 
     def pack(self, copy_map, paths_offset):
         path = self.path
         copy = copy_map.get(path)
         entry = self.entry
 
         path_start = paths_offset
         path_len = len(path)
         basename_start = path.rfind(b'/') + 1  # 0 if rfind returns -1
         if copy is not None:
             copy_source_start = paths_offset + len(path)
             copy_source_len = len(copy)
         else:
             copy_source_start = 0
             copy_source_len = 0
         if entry is not None:
             flags, size, mtime_s, mtime_ns = entry.v2_data()
         else:
             # There are no mtime-cached directories in the Python implementation
             flags = DIRSTATE_V2_DIRECTORY
             size = 0
             mtime_s = 0
             mtime_ns = 0
         return NODE.pack(
             path_start,
             path_len,
             basename_start,
             copy_source_start,
             copy_source_len,
             self.children_offset,
             self.children_count,
             self.descendants_with_entry,
             self.tracked_descendants,
             flags,
             size,
             mtime_s,
             mtime_ns,
         )
 
 
-def pack_dirstate(map, copy_map, now):
+def pack_dirstate(map, copy_map):
     """
     Pack `map` and `copy_map` into the dirstate v2 binary format and return
     the bytearray.
-    `now` is a timestamp of the current filesystem time used to detect race
-    conditions in writing the dirstate to disk, see inline comment.
 
     The on-disk format expects a tree-like structure where the leaves are
     written first (and sorted per-directory), going up levels until the root
     node and writing that one to the docket. See more details on the on-disk
     format in `mercurial/helptext/internals/dirstate-v2`.
 
     Since both `map` and `copy_map` are flat dicts we need to figure out the
     hierarchy. This algorithm does so without having to build the entire tree
     in-memory: it only keeps the minimum number of nodes around to satisfy the
     format.
 
     # Algorithm explanation
 
     This explanation does not talk about the different counters for tracked
     descendents and storing the copies, but that work is pretty simple once this
     algorithm is in place.
 
     ## Building a subtree
 
     First, sort `map`: this makes it so the leaves of the tree are contiguous
     per directory (i.e. a/b/c and a/b/d will be next to each other in the list),
     and enables us to use the ordering of folders to have a "cursor" of the
     current folder we're in without ever going twice in the same branch of the
     tree. The cursor is a node that remembers its parent and any information
     relevant to the format (see the `Node` class), building the relevant part
     of the tree lazily.
     Then, for each file in `map`, move the cursor into the tree to the
     corresponding folder of the file: for example, if the very first file
     is "a/b/c", we start from `Node[""]`, create `Node["a"]` which points to
     its parent `Node[""]`, then create `Node["a/b"]`, which points to its parent
     `Node["a"]`. These nodes are kept around in a stack.
     If the next file in `map` is in the same subtree ("a/b/d" or "a/b/e/f"), we
     add it to the stack and keep looping with the same logic of creating the
     tree nodes as needed. If however the next file in `map` is *not* in the same
     subtree ("a/other", if we're still in the "a/b" folder), then we know that
     the subtree we're in is complete.
 
     ## Writing the subtree
 
     We have the entire subtree in the stack, so we start writing it to disk
     folder by folder. The way we write a folder is to pop the stack into a list
     until the folder changes, revert this list of direct children (to satisfy
     the format requirement that children be sorted). This process repeats until
     we hit the "other" subtree.
 
     An example:
         a
         dir1/b
         dir1/c
         dir2/dir3/d
         dir2/dir3/e
         dir2/f
 
     Would have us:
         - add to the stack until "dir2/dir3/e"
         - realize that "dir2/f" is in a different subtree
         - pop "dir2/dir3/e", "dir2/dir3/d", reverse them so they're sorted and
           pack them since the next entry is "dir2/dir3"
         - go back up to "dir2"
         - add "dir2/f" to the stack
         - realize we're done with the map
         - pop "dir2/f", "dir2/dir3" from the stack, reverse and pack them
         - go up to the root node, do the same to write "a", "dir1" and "dir2" in
           that order
 
     ## Special case for the root node
 
     The root node is not serialized in the format, but its information is
     written to the docket. Again, see more details on the on-disk format in
     `mercurial/helptext/internals/dirstate-v2`.
     """
     data = bytearray()
     root_nodes_start = 0
     root_nodes_len = 0
     nodes_with_entry_count = 0
     nodes_with_copy_source_count = 0
     # Will always be 0 since this implementation always re-writes everything
     # to disk
     unreachable_bytes = 0
     unused = b'\x00' * 4
     # This is an optimization that's only useful for the Rust implementation
     ignore_patterns_hash = b'\x00' * 20
 
     if len(map) == 0:
         tree_metadata = TREE_METADATA.pack(
             root_nodes_start,
             root_nodes_len,
             nodes_with_entry_count,
             nodes_with_copy_source_count,
             unreachable_bytes,
             unused,
             ignore_patterns_hash,
         )
         return data, tree_metadata
 
     sorted_map = sorted(map.items(), key=lambda x: x[0])
 
     # Use a stack to not have to only remember the nodes we currently need
     # instead of building the entire tree in memory
     stack = []
     current_node = Node(b"", None)
     stack.append(current_node)
 
     for index, (path, entry) in enumerate(sorted_map, 1):
-        if entry.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.
-            entry.set_possibly_dirty()
         nodes_with_entry_count += 1
         if path in copy_map:
             nodes_with_copy_source_count += 1
         current_folder = get_folder(path)
         current_node = move_to_correct_node_in_tree(
             current_folder, current_node, stack
         )
 
         current_node.children_count += 1
         # Entries from `map` are never `None`
         if entry.tracked:
             current_node.tracked_descendants += 1
         current_node.descendants_with_entry += 1
         stack.append(Node(path, entry, current_node))
 
         should_pack = True
         next_path = None
         if index < len(sorted_map):
             # Determine if the next entry is in the same sub-tree, if so don't
             # pack yet
             next_path = sorted_map[index][0]
             should_pack = not get_folder(next_path).startswith(current_folder)
         if should_pack:
             pack_directory_children(current_node, copy_map, data, stack)
             while stack and current_node.path != b"":
                 # Go up the tree and write until we reach the folder of the next
                 # entry (if any, otherwise the root)
                 parent = current_node.parent
                 in_parent_folder_of_next_entry = next_path is not None and (
                     get_folder(next_path).startswith(get_folder(stack[-1].path))
                 )
                 if parent is None or in_parent_folder_of_next_entry:
                     break
                 pack_directory_children(parent, copy_map, data, stack)
                 current_node = parent
 
     # Special case for the root node since we don't write it to disk, only its
     # children to the docket
     current_node = stack.pop()
     assert current_node.path == b"", current_node.path
     assert len(stack) == 0, len(stack)
 
     tree_metadata = TREE_METADATA.pack(
         current_node.children_offset,
         current_node.children_count,
         nodes_with_entry_count,
         nodes_with_copy_source_count,
         unreachable_bytes,
         unused,
         ignore_patterns_hash,
     )
 
     return data, tree_metadata
 
 
 def get_folder(path):
     """
     Return the folder of the path that's given, an empty string for root paths.
     """
     return path.rsplit(b'/', 1)[0] if b'/' in path else b''
 
 
 def move_to_correct_node_in_tree(target_folder, current_node, stack):
     """
     Move inside the dirstate node tree to the node corresponding to
     `target_folder`, creating the missing nodes along the way if needed.
     """
     while target_folder != current_node.path:
         if target_folder.startswith(current_node.path):
             # We need to go down a folder
             prefix = target_folder[len(current_node.path) :].lstrip(b'/')
             subfolder_name = prefix.split(b'/', 1)[0]
             if current_node.path:
                 subfolder_path = current_node.path + b'/' + subfolder_name
             else:
                 subfolder_path = subfolder_name
             next_node = stack[-1]
             if next_node.path == target_folder:
                 # This folder is now a file and only contains removed entries
                 # merge with the last node
                 current_node = next_node
             else:
                 current_node.children_count += 1
                 current_node = Node(subfolder_path, None, current_node)
                 stack.append(current_node)
         else:
             # We need to go up a folder
             current_node = current_node.parent
     return current_node
 
 
 def pack_directory_children(node, copy_map, data, stack):
     """
     Write the binary representation of the direct sorted children of `node` to
     `data`
     """
     direct_children = []
 
     while stack[-1].path != b"" and get_folder(stack[-1].path) == node.path:
         direct_children.append(stack.pop())
     if not direct_children:
         raise error.ProgrammingError(b"no direct children for %r" % node.path)
 
     # Reverse the stack to get the correct sorted order
     direct_children.reverse()
     packed_children = bytearray()
     # Write the paths to `data`. Pack child nodes but don't write them yet
     for child in direct_children:
         packed = child.pack(copy_map=copy_map, paths_offset=len(data))
         packed_children.extend(packed)
         data.extend(child.path)
         data.extend(copy_map.get(child.path, b""))
         node.tracked_descendants += child.tracked_descendants
         node.descendants_with_entry += child.descendants_with_entry
     # Write the fixed-size child nodes all together
     node.children_offset = len(data)
     data.extend(packed_children)

mercurial/pure/parsers.py

@@ -1,937 +1,921 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 stat
 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
 
 # Bits of the `flags` byte inside a node in the file format
 DIRSTATE_V2_WDIR_TRACKED = 1 << 0
 DIRSTATE_V2_P1_TRACKED = 1 << 1
 DIRSTATE_V2_P2_INFO = 1 << 2
 DIRSTATE_V2_MODE_EXEC_PERM = 1 << 3
 DIRSTATE_V2_MODE_IS_SYMLINK = 1 << 4
 DIRSTATE_V2_HAS_FALLBACK_EXEC = 1 << 5
 DIRSTATE_V2_FALLBACK_EXEC = 1 << 6
 DIRSTATE_V2_HAS_FALLBACK_SYMLINK = 1 << 7
 DIRSTATE_V2_FALLBACK_SYMLINK = 1 << 8
 DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED = 1 << 9
 DIRSTATE_V2_HAS_MODE_AND_SIZE = 1 << 10
 DIRSTATE_V2_HAS_MTIME = 1 << 11
 DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS = 1 << 12
 DIRSTATE_V2_DIRECTORY = 1 << 13
 DIRSTATE_V2_ALL_UNKNOWN_RECORDED = 1 << 14
 DIRSTATE_V2_ALL_IGNORED_RECORDED = 1 << 15
 
 
 @attr.s(slots=True, init=False)
 class DirstateItem(object):
     """represent a dirstate entry
 
     It hold multiple attributes
 
     # about file tracking
     - wc_tracked: is the file tracked by the working copy
     - p1_tracked: is the file tracked in working copy first parent
     - p2_info: the file has been involved in some merge operation. Either
                because it was actually merged, or because the p2 version was
                ahead, or because some rename moved it there. In either case
                `hg status` will want it displayed as modified.
 
     # about the file state expected from p1 manifest:
     - mode: the file mode 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:
     - mtime: the last known clean mtime for the file.
 
     This value can be set to None if no cachable state exist. Either because we
     do not care (see previous section) or because we could not cache something
     yet.
     """
 
     _wc_tracked = attr.ib()
     _p1_tracked = attr.ib()
     _p2_info = attr.ib()
     _mode = attr.ib()
     _size = attr.ib()
     _mtime_s = attr.ib()
     _mtime_ns = attr.ib()
     _fallback_exec = attr.ib()
     _fallback_symlink = attr.ib()
 
     def __init__(
         self,
         wc_tracked=False,
         p1_tracked=False,
         p2_info=False,
         has_meaningful_data=True,
         has_meaningful_mtime=True,
         parentfiledata=None,
         fallback_exec=None,
         fallback_symlink=None,
     ):
         self._wc_tracked = wc_tracked
         self._p1_tracked = p1_tracked
         self._p2_info = p2_info
 
         self._fallback_exec = fallback_exec
         self._fallback_symlink = fallback_symlink
 
         self._mode = None
         self._size = None
         self._mtime_s = None
         self._mtime_ns = None
         if parentfiledata is None:
             has_meaningful_mtime = False
             has_meaningful_data = False
         elif parentfiledata[2] is None:
             has_meaningful_mtime = False
         if has_meaningful_data:
             self._mode = parentfiledata[0]
             self._size = parentfiledata[1]
         if has_meaningful_mtime:
             self._mtime_s, self._mtime_ns = parentfiledata[2]
 
     @classmethod
     def from_v2_data(cls, flags, size, mtime_s, mtime_ns):
         """Build a new DirstateItem object from V2 data"""
         has_mode_size = bool(flags & DIRSTATE_V2_HAS_MODE_AND_SIZE)
         has_meaningful_mtime = bool(flags & DIRSTATE_V2_HAS_MTIME)
         if flags & DIRSTATE_V2_MTIME_SECOND_AMBIGUOUS:
             # The current code is not able to do the more subtle comparison that the
             # MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime
             has_meaningful_mtime = False
         mode = None
 
         if flags & +DIRSTATE_V2_EXPECTED_STATE_IS_MODIFIED:
             # we do not have support for this flag in the code yet,
             # force a lookup for this file.
             has_mode_size = False
             has_meaningful_mtime = False
 
         fallback_exec = None
         if flags & DIRSTATE_V2_HAS_FALLBACK_EXEC:
             fallback_exec = flags & DIRSTATE_V2_FALLBACK_EXEC
 
         fallback_symlink = None
         if flags & DIRSTATE_V2_HAS_FALLBACK_SYMLINK:
             fallback_symlink = flags & DIRSTATE_V2_FALLBACK_SYMLINK
 
         if has_mode_size:
             assert stat.S_IXUSR == 0o100
             if flags & DIRSTATE_V2_MODE_EXEC_PERM:
                 mode = 0o755
             else:
                 mode = 0o644
             if flags & DIRSTATE_V2_MODE_IS_SYMLINK:
                 mode |= stat.S_IFLNK
             else:
                 mode |= stat.S_IFREG
         return cls(
             wc_tracked=bool(flags & DIRSTATE_V2_WDIR_TRACKED),
             p1_tracked=bool(flags & DIRSTATE_V2_P1_TRACKED),
             p2_info=bool(flags & DIRSTATE_V2_P2_INFO),
             has_meaningful_data=has_mode_size,
             has_meaningful_mtime=has_meaningful_mtime,
             parentfiledata=(mode, size, (mtime_s, mtime_ns)),
             fallback_exec=fallback_exec,
             fallback_symlink=fallback_symlink,
         )
 
     @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(wc_tracked=True, p1_tracked=True, p2_info=True)
         elif state == b'a':
             return cls(wc_tracked=True)
         elif state == b'r':
             if size == NONNORMAL:
                 p1_tracked = True
                 p2_info = True
             elif size == FROM_P2:
                 p1_tracked = False
                 p2_info = True
             else:
                 p1_tracked = True
                 p2_info = False
             return cls(p1_tracked=p1_tracked, p2_info=p2_info)
         elif state == b'n':
             if size == FROM_P2:
                 return cls(wc_tracked=True, p2_info=True)
             elif size == NONNORMAL:
                 return cls(wc_tracked=True, p1_tracked=True)
             elif mtime == AMBIGUOUS_TIME:
                 return cls(
                     wc_tracked=True,
                     p1_tracked=True,
                     has_meaningful_mtime=False,
                     parentfiledata=(mode, size, (42, 0)),
                 )
             else:
                 return cls(
                     wc_tracked=True,
                     p1_tracked=True,
                     parentfiledata=(mode, size, (mtime, 0)),
                 )
         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._mtime_s = None
         self._mtime_ns = None
 
     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._mode = mode
         self._size = size
         self._mtime_s, self._mtime_ns = 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 mark
         # the files as needing lookup
         #
         # Consider dropping this in the future in favor of something less broad.
         self._mtime_s = None
         self._mtime_ns = None
 
     def set_untracked(self):
         """mark a file as untracked in the working copy
 
         This will ultimately be called by command like `hg remove`.
         """
         self._wc_tracked = False
         self._mode = None
         self._size = None
         self._mtime_s = None
         self._mtime_ns = 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 self._p2_info:
             self._p2_info = False
             self._mode = None
             self._size = None
             self._mtime_s = None
             self._mtime_ns = 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()
 
     def mtime_likely_equal_to(self, other_mtime):
         self_sec = self._mtime_s
         if self_sec is None:
             return False
         self_ns = self._mtime_ns
         other_sec, other_ns = other_mtime
         return self_sec == other_sec and (
             self_ns == other_ns or self_ns == 0 or other_ns == 0
         )
 
     @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.
         """
         if not self.any_tracked:
             return b'?'
         return self.v1_state()
 
     @property
     def has_fallback_exec(self):
         """True if "fallback" information are available for the "exec" bit
 
         Fallback information can be stored in the dirstate to keep track of
         filesystem attribute tracked by Mercurial when the underlying file
         system or operating system does not support that property, (e.g.
         Windows).
 
         Not all version of the dirstate on-disk storage support preserving this
         information.
         """
         return self._fallback_exec is not None
 
     @property
     def fallback_exec(self):
         """ "fallback" information for the executable bit
 
         True if the file should be considered executable when we cannot get
         this information from the files system. False if it should be
         considered non-executable.
 
         See has_fallback_exec for details."""
         return self._fallback_exec
 
     @fallback_exec.setter
     def set_fallback_exec(self, value):
         """control "fallback" executable bit
 
         Set to:
         - True if the file should be considered executable,
         - False if the file should be considered non-executable,
         - None if we do not have valid fallback data.
 
         See has_fallback_exec for details."""
         if value is None:
             self._fallback_exec = None
         else:
             self._fallback_exec = bool(value)
 
     @property
     def has_fallback_symlink(self):
         """True if "fallback" information are available for symlink status
 
         Fallback information can be stored in the dirstate to keep track of
         filesystem attribute tracked by Mercurial when the underlying file
         system or operating system does not support that property, (e.g.
         Windows).
 
         Not all version of the dirstate on-disk storage support preserving this
         information."""
         return self._fallback_symlink is not None
 
     @property
     def fallback_symlink(self):
         """ "fallback" information for symlink status
 
         True if the file should be considered executable when we cannot get
         this information from the files system. False if it should be
         considered non-executable.
 
         See has_fallback_exec for details."""
         return self._fallback_symlink
 
     @fallback_symlink.setter
     def set_fallback_symlink(self, value):
         """control "fallback" symlink status
 
         Set to:
         - True if the file should be considered a symlink,
         - False if the file should be considered not a symlink,
         - None if we do not have valid fallback data.
 
         See has_fallback_symlink for details."""
         if value is None:
             self._fallback_symlink = None
         else:
             self._fallback_symlink = bool(value)
 
     @property
     def tracked(self):
         """True is the file is tracked in the working copy"""
         return self._wc_tracked
 
     @property
     def any_tracked(self):
         """True is the file is tracked anywhere (wc or parents)"""
         return self._wc_tracked or self._p1_tracked or self._p2_info
 
     @property
     def added(self):
         """True if the file has been added"""
         return self._wc_tracked and not (self._p1_tracked or self._p2_info)
 
     @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 not self._p1_tracked:
             return False
         elif self._p2_info:
             return False
         return True
 
     @property
     def p1_tracked(self):
         """True if the file is tracked in the first parent manifest"""
         return self._p1_tracked
 
     @property
     def p2_info(self):
         """True if the file needed to merge or apply any input from p2
 
         See the class documentation for details.
         """
         return self._wc_tracked and self._p2_info
 
     @property
     def removed(self):
         """True if the file has been removed"""
         return not self._wc_tracked and (self._p1_tracked or self._p2_info)
 
     def v2_data(self):
         """Returns (flags, mode, size, mtime) for v2 serialization"""
         flags = 0
         if self._wc_tracked:
             flags |= DIRSTATE_V2_WDIR_TRACKED
         if self._p1_tracked:
             flags |= DIRSTATE_V2_P1_TRACKED
         if self._p2_info:
             flags |= DIRSTATE_V2_P2_INFO
         if self._mode is not None and self._size is not None:
             flags |= DIRSTATE_V2_HAS_MODE_AND_SIZE
             if self.mode & stat.S_IXUSR:
                 flags |= DIRSTATE_V2_MODE_EXEC_PERM
             if stat.S_ISLNK(self.mode):
                 flags |= DIRSTATE_V2_MODE_IS_SYMLINK
         if self._mtime_s is not None:
             flags |= DIRSTATE_V2_HAS_MTIME
 
         if self._fallback_exec is not None:
             flags |= DIRSTATE_V2_HAS_FALLBACK_EXEC
             if self._fallback_exec:
                 flags |= DIRSTATE_V2_FALLBACK_EXEC
 
         if self._fallback_symlink is not None:
             flags |= DIRSTATE_V2_HAS_FALLBACK_SYMLINK
             if self._fallback_symlink:
                 flags |= DIRSTATE_V2_FALLBACK_SYMLINK
 
         # Note: we do not need to do anything regarding
         # DIRSTATE_V2_ALL_UNKNOWN_RECORDED and DIRSTATE_V2_ALL_IGNORED_RECORDED
         # since we never set _DIRSTATE_V2_HAS_DIRCTORY_MTIME
         return (flags, self._size or 0, self._mtime_s or 0, self._mtime_ns or 0)
 
     def v1_state(self):
         """return a "state" suitable for v1 serialization"""
         if not self.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return b'r'
         elif self._p1_tracked and self._p2_info:
             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.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed and self._p1_tracked and self._p2_info:
             return NONNORMAL
         elif self._p2_info:
             return FROM_P2
         elif self.removed:
             return 0
         elif self.added:
             return NONNORMAL
         elif self._size is None:
             return NONNORMAL
         else:
             return self._size
 
     def v1_mtime(self):
         """return a "mtime" suitable for v1 serialization"""
         if not self.any_tracked:
             # the object has no state to record, this is -currently-
             # unsupported
             raise RuntimeError('untracked item')
         elif self.removed:
             return 0
         elif self._mtime_s is None:
             return AMBIGUOUS_TIME
         elif self._p2_info:
             return AMBIGUOUS_TIME
         elif not self._p1_tracked:
             return AMBIGUOUS_TIME
         else:
             return self._mtime_s
 
-    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._mtime_s == now[0]
-
 
 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):
+def pack_dirstate(dmap, copymap, pl):
     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,649 +1,639 b''
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::errors::HgError;
 use bitflags::bitflags;
 use std::convert::{TryFrom, TryInto};
 use std::fs;
 use std::io;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum EntryState {
     Normal,
     Added,
     Removed,
     Merged,
 }
 
 /// `size` and `mtime.seconds` are truncated to 31 bits.
 ///
 /// TODO: double-check status algorithm correctness for files
 /// larger than 2 GiB or modified after 2038.
 #[derive(Debug, Copy, Clone)]
 pub struct DirstateEntry {
     pub(crate) flags: Flags,
     mode_size: Option<(u32, u32)>,
     mtime: Option<TruncatedTimestamp>,
 }
 
 bitflags! {
     pub(crate) struct Flags: u8 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_INFO = 1 << 2;
         const HAS_FALLBACK_EXEC = 1 << 3;
         const FALLBACK_EXEC = 1 << 4;
         const HAS_FALLBACK_SYMLINK = 1 << 5;
         const FALLBACK_SYMLINK = 1 << 6;
     }
 }
 
 /// A Unix timestamp with nanoseconds precision
 #[derive(Debug, Copy, Clone)]
 pub struct TruncatedTimestamp {
     truncated_seconds: u32,
     /// Always in the `0 .. 1_000_000_000` range.
     nanoseconds: u32,
 }
 
 impl TruncatedTimestamp {
     /// Constructs from a timestamp potentially outside of the supported range,
     /// and truncate the seconds components to its lower 31 bits.
     ///
     /// Panics if the nanoseconds components is not in the expected range.
     pub fn new_truncate(seconds: i64, nanoseconds: u32) -> Self {
         assert!(nanoseconds < NSEC_PER_SEC);
         Self {
             truncated_seconds: seconds as u32 & RANGE_MASK_31BIT,
             nanoseconds,
         }
     }
 
     /// Construct from components. Returns an error if they are not in the
     /// expcted range.
     pub fn from_already_truncated(
         truncated_seconds: u32,
         nanoseconds: u32,
     ) -> Result<Self, DirstateV2ParseError> {
         if truncated_seconds & !RANGE_MASK_31BIT == 0
             && nanoseconds < NSEC_PER_SEC
         {
             Ok(Self {
                 truncated_seconds,
                 nanoseconds,
             })
         } else {
             Err(DirstateV2ParseError)
         }
     }
 
     pub fn for_mtime_of(metadata: &fs::Metadata) -> io::Result<Self> {
         #[cfg(unix)]
         {
             use std::os::unix::fs::MetadataExt;
             let seconds = metadata.mtime();
             // i64 -> u32 with value always in the `0 .. NSEC_PER_SEC` range
             let nanoseconds = metadata.mtime_nsec().try_into().unwrap();
             Ok(Self::new_truncate(seconds, nanoseconds))
         }
         #[cfg(not(unix))]
         {
             metadata.modified().map(Self::from)
         }
     }
 
     /// The lower 31 bits of the number of seconds since the epoch.
     pub fn truncated_seconds(&self) -> u32 {
         self.truncated_seconds
     }
 
     /// The sub-second component of this timestamp, in nanoseconds.
     /// Always in the `0 .. 1_000_000_000` range.
     ///
     /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
     pub fn nanoseconds(&self) -> u32 {
         self.nanoseconds
     }
 
     /// Returns whether two timestamps are equal modulo 2**31 seconds.
     ///
     /// If this returns `true`, the original values converted from `SystemTime`
     /// or given to `new_truncate` were very likely equal. A false positive is
     /// possible if they were exactly a multiple of 2**31 seconds apart (around
     /// 68 years). This is deemed very unlikely to happen by chance, especially
     /// on filesystems that support sub-second precision.
     ///
     /// If someone is manipulating the modification times of some files to
     /// intentionally make `hg status` return incorrect results, not truncating
     /// wouldn’t help much since they can set exactly the expected timestamp.
     ///
     /// Sub-second precision is ignored if it is zero in either value.
     /// Some APIs simply return zero when more precision is not available.
     /// When comparing values from different sources, if only one is truncated
     /// in that way, doing a simple comparison would cause many false
     /// negatives.
     pub fn likely_equal(self, other: Self) -> bool {
         self.truncated_seconds == other.truncated_seconds
             && (self.nanoseconds == other.nanoseconds
                 || self.nanoseconds == 0
                 || other.nanoseconds == 0)
     }
 
     pub fn likely_equal_to_mtime_of(
         self,
         metadata: &fs::Metadata,
     ) -> io::Result<bool> {
         Ok(self.likely_equal(Self::for_mtime_of(metadata)?))
     }
 }
 
 impl From<SystemTime> for TruncatedTimestamp {
     fn from(system_time: SystemTime) -> Self {
         // On Unix, `SystemTime` is a wrapper for the `timespec` C struct:
         // https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec
         // We want to effectively access its fields, but the Rust standard
         // library does not expose them. The best we can do is:
         let seconds;
         let nanoseconds;
         match system_time.duration_since(UNIX_EPOCH) {
             Ok(duration) => {
                 seconds = duration.as_secs() as i64;
                 nanoseconds = duration.subsec_nanos();
             }
             Err(error) => {
                 // `system_time` is before `UNIX_EPOCH`.
                 // We need to undo this algorithm:
                 // https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41
                 let negative = error.duration();
                 let negative_secs = negative.as_secs() as i64;
                 let negative_nanos = negative.subsec_nanos();
                 if negative_nanos == 0 {
                     seconds = -negative_secs;
                     nanoseconds = 0;
                 } else {
                     // For example if `system_time` was 4.3 seconds before
                     // the Unix epoch we get a Duration that represents
                     // `(-4, -0.3)` but we want `(-5, +0.7)`:
                     seconds = -1 - negative_secs;
                     nanoseconds = NSEC_PER_SEC - negative_nanos;
                 }
             }
         };
         Self::new_truncate(seconds, nanoseconds)
     }
 }
 
 const NSEC_PER_SEC: u32 = 1_000_000_000;
 const RANGE_MASK_31BIT: u32 = 0x7FFF_FFFF;
 
 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 from_v2_data(
         wdir_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         mode_size: Option<(u32, u32)>,
         mtime: Option<TruncatedTimestamp>,
         fallback_exec: Option<bool>,
         fallback_symlink: Option<bool>,
     ) -> Self {
         if let Some((mode, size)) = mode_size {
             // TODO: return an error for out of range values?
             assert!(mode & !RANGE_MASK_31BIT == 0);
             assert!(size & !RANGE_MASK_31BIT == 0);
         }
         let mut flags = Flags::empty();
         flags.set(Flags::WDIR_TRACKED, wdir_tracked);
         flags.set(Flags::P1_TRACKED, p1_tracked);
         flags.set(Flags::P2_INFO, p2_info);
         if let Some(exec) = fallback_exec {
             flags.insert(Flags::HAS_FALLBACK_EXEC);
             if exec {
                 flags.insert(Flags::FALLBACK_EXEC);
             }
         }
         if let Some(exec) = fallback_symlink {
             flags.insert(Flags::HAS_FALLBACK_SYMLINK);
             if exec {
                 flags.insert(Flags::FALLBACK_SYMLINK);
             }
         }
         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 {
                         // might be missing P1_TRACKED
                         flags: Flags::WDIR_TRACKED | Flags::P2_INFO,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if size == SIZE_NON_NORMAL {
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if mtime == MTIME_UNSET {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: None,
                     }
                 } else {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     let mtime = u32::try_from(mtime).unwrap();
                     let mtime =
                         TruncatedTimestamp::from_already_truncated(mtime, 0)
                             .unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: Some(mtime),
                     }
                 }
             }
             EntryState::Added => Self {
                 flags: Flags::WDIR_TRACKED,
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Removed => Self {
                 flags: if size == SIZE_NON_NORMAL {
                     Flags::P1_TRACKED | Flags::P2_INFO
                 } else if size == SIZE_FROM_OTHER_PARENT {
                     // We don’t know if P1_TRACKED should be set (file history)
                     Flags::P2_INFO
                 } else {
                     Flags::P1_TRACKED
                 },
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Merged => Self {
                 flags: Flags::WDIR_TRACKED
                     | Flags::P1_TRACKED // might not be true because of rename ?
                     | Flags::P2_INFO, // might not be true because of rename ?
                 mode_size: None,
                 mtime: None,
             },
         }
     }
 
     /// 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)
     }
 
     pub fn p1_tracked(&self) -> bool {
         self.flags.contains(Flags::P1_TRACKED)
     }
 
     fn in_either_parent(&self) -> bool {
         self.flags.intersects(Flags::P1_TRACKED | Flags::P2_INFO)
     }
 
     pub fn removed(&self) -> bool {
         self.in_either_parent() && !self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn p2_info(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::P2_INFO)
     }
 
     pub fn added(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED) && !self.in_either_parent()
     }
 
     pub fn maybe_clean(&self) -> bool {
         if !self.flags.contains(Flags::WDIR_TRACKED) {
             false
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             false
         } else if self.flags.contains(Flags::P2_INFO) {
             false
         } else {
             true
         }
     }
 
     pub fn any_tracked(&self) -> bool {
         self.flags.intersects(
             Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
         )
     }
 
     /// Returns `(wdir_tracked, p1_tracked, p2_info, mode_size, mtime)`
     pub(crate) fn v2_data(
         &self,
     ) -> (
         bool,
         bool,
         bool,
         Option<(u32, u32)>,
         Option<TruncatedTimestamp>,
         Option<bool>,
         Option<bool>,
     ) {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_state of an untracked DirstateEntry")
         }
         let wdir_tracked = self.flags.contains(Flags::WDIR_TRACKED);
         let p1_tracked = self.flags.contains(Flags::P1_TRACKED);
         let p2_info = self.flags.contains(Flags::P2_INFO);
         let mode_size = self.mode_size;
         let mtime = self.mtime;
         (
             wdir_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
             self.get_fallback_exec(),
             self.get_fallback_symlink(),
         )
     }
 
     fn v1_state(&self) -> EntryState {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_state of an untracked DirstateEntry")
         }
         if self.removed() {
             EntryState::Removed
         } else if self
             .flags
             .contains(Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO)
         {
             EntryState::Merged
         } else if self.added() {
             EntryState::Added
         } else {
             EntryState::Normal
         }
     }
 
     fn v1_mode(&self) -> i32 {
         if let Some((mode, _size)) = self.mode_size {
             i32::try_from(mode).unwrap()
         } else {
             0
         }
     }
 
     fn v1_size(&self) -> i32 {
         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
         } else if self.flags.contains(Flags::P2_INFO) {
             SIZE_FROM_OTHER_PARENT
         } else if self.removed() {
             0
         } else if self.added() {
             SIZE_NON_NORMAL
         } else if let Some((_mode, size)) = self.mode_size {
             i32::try_from(size).unwrap()
         } else {
             SIZE_NON_NORMAL
         }
     }
 
     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() {
             0
         } else if self.flags.contains(Flags::P2_INFO) {
             MTIME_UNSET
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             MTIME_UNSET
         } else if let Some(mtime) = self.mtime {
             i32::try_from(mtime.truncated_seconds()).unwrap()
         } else {
             MTIME_UNSET
         }
     }
 
     // TODO: return `Option<EntryState>`? None when `!self.any_tracked`
     pub fn state(&self) -> EntryState {
         self.v1_state()
     }
 
     // TODO: return Option?
     pub fn mode(&self) -> i32 {
         self.v1_mode()
     }
 
     // TODO: return Option?
     pub fn size(&self) -> i32 {
         self.v1_size()
     }
 
     // TODO: return Option?
     pub fn mtime(&self) -> i32 {
         self.v1_mtime()
     }
 
     pub fn get_fallback_exec(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_EXEC) {
             Some(self.flags.contains(Flags::FALLBACK_EXEC))
         } else {
             None
         }
     }
 
     pub fn set_fallback_exec(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_EXEC);
                 self.flags.remove(Flags::FALLBACK_EXEC);
             }
             Some(exec) => {
                 self.flags.insert(Flags::HAS_FALLBACK_EXEC);
                 if exec {
                     self.flags.insert(Flags::FALLBACK_EXEC);
                 }
             }
         }
     }
 
     pub fn get_fallback_symlink(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_SYMLINK) {
             Some(self.flags.contains(Flags::FALLBACK_SYMLINK))
         } else {
             None
         }
     }
 
     pub fn set_fallback_symlink(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_SYMLINK);
                 self.flags.remove(Flags::FALLBACK_SYMLINK);
             }
             Some(symlink) => {
                 self.flags.insert(Flags::HAS_FALLBACK_SYMLINK);
                 if symlink {
                     self.flags.insert(Flags::FALLBACK_SYMLINK);
                 }
             }
         }
     }
 
     pub fn truncated_mtime(&self) -> Option<TruncatedTimestamp> {
         self.mtime
     }
 
     pub fn drop_merge_data(&mut self) {
         if self.flags.contains(Flags::P2_INFO) {
             self.flags.remove(Flags::P2_INFO);
             self.mode_size = None;
             self.mtime = None;
         }
     }
 
     pub fn set_possibly_dirty(&mut self) {
         self.mtime = None
     }
 
     pub fn set_clean(
         &mut self,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) {
         let size = size & RANGE_MASK_31BIT;
         self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
         self.mode_size = Some((mode, size));
         self.mtime = Some(mtime);
     }
 
     pub fn set_tracked(&mut self) {
         self.flags.insert(Flags::WDIR_TRACKED);
         // `set_tracked` is replacing various `normallookup` call. So we mark
         // the files as needing lookup
         //
         // Consider dropping this in the future in favor of something less
         // broad.
         self.mtime = None;
     }
 
     pub fn set_untracked(&mut self) {
         self.flags.remove(Flags::WDIR_TRACKED);
         self.mode_size = None;
         self.mtime = None;
     }
 
     /// 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.v1_state().into(),
             self.v1_mode(),
             self.v1_size(),
             self.v1_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 {
         let dirstate_exec_bit = (self.mode() as u32 & EXEC_BIT_MASK) != 0;
         let fs_exec_bit = has_exec_bit(filesystem_metadata);
         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) {
         (self.state().into(), self.mode(), self.size(), self.mtime())
     }
-
-    /// True if the stored mtime would be ambiguous with the current time
-    pub fn need_delay(&self, now: TruncatedTimestamp) -> bool {
-        if let Some(mtime) = self.mtime {
-            self.state() == EntryState::Normal
-                && mtime.truncated_seconds() == now.truncated_seconds()
-        } else {
-            false
-        }
-    }
 }
 
 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',
         }
     }
 }
 
 const EXEC_BIT_MASK: u32 = 0o100;
 
 pub fn has_exec_bit(metadata: &std::fs::Metadata) -> bool {
     // TODO: How to handle executable permissions on Windows?
     use std::os::unix::fs::MetadataExt;
     (metadata.mode() & EXEC_BIT_MASK) != 0
 }

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

@@ -1,1184 +1,1139 b''
 use bytes_cast::BytesCast;
 use micro_timer::timed;
 use std::borrow::Cow;
 use std::path::PathBuf;
 
 use super::on_disk;
 use super::on_disk::DirstateV2ParseError;
 use super::owning::OwningDirstateMap;
 use super::path_with_basename::WithBasename;
 use crate::dirstate::parsers::pack_entry;
 use crate::dirstate::parsers::packed_entry_size;
 use crate::dirstate::parsers::parse_dirstate_entries;
 use crate::dirstate::CopyMapIter;
 use crate::dirstate::StateMapIter;
 use crate::dirstate::TruncatedTimestamp;
 use crate::dirstate::SIZE_FROM_OTHER_PARENT;
 use crate::dirstate::SIZE_NON_NORMAL;
 use crate::matchers::Matcher;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateParents;
 use crate::DirstateStatus;
 use crate::EntryState;
 use crate::FastHashMap;
 use crate::PatternFileWarning;
 use crate::StatusError;
 use crate::StatusOptions;
 
 /// Append to an existing data file if the amount of unreachable data (not used
 /// anymore) is less than this fraction of the total amount of existing data.
 const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5;
 
 pub struct DirstateMap<'on_disk> {
     /// Contents of the `.hg/dirstate` file
     pub(super) on_disk: &'on_disk [u8],
 
     pub(super) root: ChildNodes<'on_disk>,
 
     /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
     pub(super) nodes_with_entry_count: u32,
 
     /// Number of nodes anywhere in the tree that have
     /// `.copy_source.is_some()`.
     pub(super) nodes_with_copy_source_count: u32,
 
     /// See on_disk::Header
     pub(super) ignore_patterns_hash: on_disk::IgnorePatternsHash,
 
     /// How many bytes of `on_disk` are not used anymore
     pub(super) unreachable_bytes: u32,
 }
 
 /// Using a plain `HgPathBuf` of the full path from the repository root as a
 /// map key would also work: all paths in a given map have the same parent
 /// path, so comparing full paths gives the same result as comparing base
 /// names. However `HashMap` would waste time always re-hashing the same
 /// string prefix.
 pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
 
 /// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned
 /// for on-disk nodes that don’t actually have a `Cow` to borrow.
 pub(super) enum BorrowedPath<'tree, 'on_disk> {
     InMemory(&'tree HgPathBuf),
     OnDisk(&'on_disk HgPath),
 }
 
 pub(super) enum ChildNodes<'on_disk> {
     InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 pub(super) enum ChildNodesRef<'tree, 'on_disk> {
     InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 pub(super) enum NodeRef<'tree, 'on_disk> {
     InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
     OnDisk(&'on_disk on_disk::Node),
 }
 
 impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {
     pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {
         match *self {
             BorrowedPath::InMemory(in_memory) => Cow::Owned(in_memory.clone()),
             BorrowedPath::OnDisk(on_disk) => Cow::Borrowed(on_disk),
         }
     }
 }
 
 impl<'tree, 'on_disk> std::ops::Deref for BorrowedPath<'tree, 'on_disk> {
     type Target = HgPath;
 
     fn deref(&self) -> &HgPath {
         match *self {
             BorrowedPath::InMemory(in_memory) => in_memory,
             BorrowedPath::OnDisk(on_disk) => on_disk,
         }
     }
 }
 
 impl Default for ChildNodes<'_> {
     fn default() -> Self {
         ChildNodes::InMemory(Default::default())
     }
 }
 
 impl<'on_disk> ChildNodes<'on_disk> {
     pub(super) fn as_ref<'tree>(
         &'tree self,
     ) -> ChildNodesRef<'tree, 'on_disk> {
         match self {
             ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes),
             ChildNodes::OnDisk(nodes) => ChildNodesRef::OnDisk(nodes),
         }
     }
 
     pub(super) fn is_empty(&self) -> bool {
         match self {
             ChildNodes::InMemory(nodes) => nodes.is_empty(),
             ChildNodes::OnDisk(nodes) => nodes.is_empty(),
         }
     }
 
     fn make_mut(
         &mut self,
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
     ) -> Result<
         &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
         DirstateV2ParseError,
     > {
         match self {
             ChildNodes::InMemory(nodes) => Ok(nodes),
             ChildNodes::OnDisk(nodes) => {
                 *unreachable_bytes +=
                     std::mem::size_of_val::<[on_disk::Node]>(nodes) as u32;
                 let nodes = nodes
                     .iter()
                     .map(|node| {
                         Ok((
                             node.path(on_disk)?,
                             node.to_in_memory_node(on_disk)?,
                         ))
                     })
                     .collect::<Result<_, _>>()?;
                 *self = ChildNodes::InMemory(nodes);
                 match self {
                     ChildNodes::InMemory(nodes) => Ok(nodes),
                     ChildNodes::OnDisk(_) => unreachable!(),
                 }
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {
     pub(super) fn get(
         &self,
         base_name: &HgPath,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         match self {
             ChildNodesRef::InMemory(nodes) => Ok(nodes
                 .get_key_value(base_name)
                 .map(|(k, v)| NodeRef::InMemory(k, v))),
             ChildNodesRef::OnDisk(nodes) => {
                 let mut parse_result = Ok(());
                 let search_result = nodes.binary_search_by(|node| {
                     match node.base_name(on_disk) {
                         Ok(node_base_name) => node_base_name.cmp(base_name),
                         Err(e) => {
                             parse_result = Err(e);
                             // Dummy comparison result, `search_result` won’t
                             // be used since `parse_result` is an error
                             std::cmp::Ordering::Equal
                         }
                     }
                 });
                 parse_result.map(|()| {
                     search_result.ok().map(|i| NodeRef::OnDisk(&nodes[i]))
                 })
             }
         }
     }
 
     /// Iterate in undefined order
     pub(super) fn iter(
         &self,
     ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => itertools::Either::Left(
                 nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => {
                 itertools::Either::Right(nodes.iter().map(NodeRef::OnDisk))
             }
         }
     }
 
     /// Iterate in parallel in undefined order
     pub(super) fn par_iter(
         &self,
     ) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>>
     {
         use rayon::prelude::*;
         match self {
             ChildNodesRef::InMemory(nodes) => rayon::iter::Either::Left(
                 nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => rayon::iter::Either::Right(
                 nodes.par_iter().map(NodeRef::OnDisk),
             ),
         }
     }
 
     pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => {
                 let mut vec: Vec<_> = nodes
                     .iter()
                     .map(|(k, v)| NodeRef::InMemory(k, v))
                     .collect();
                 fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {
                     match node {
                         NodeRef::InMemory(path, _node) => path.base_name(),
                         NodeRef::OnDisk(_) => unreachable!(),
                     }
                 }
                 // `sort_unstable_by_key` doesn’t allow keys borrowing from the
                 // value: https://github.com/rust-lang/rust/issues/34162
                 vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));
                 vec
             }
             ChildNodesRef::OnDisk(nodes) => {
                 // Nodes on disk are already sorted
                 nodes.iter().map(NodeRef::OnDisk).collect()
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {
     pub(super) fn full_path(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.full_path()),
             NodeRef::OnDisk(node) => node.full_path(on_disk),
         }
     }
 
     /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
     /// HgPath>` detached from `'tree`
     pub(super) fn full_path_borrowed(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<BorrowedPath<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => match path.full_path() {
                 Cow::Borrowed(on_disk) => Ok(BorrowedPath::OnDisk(on_disk)),
                 Cow::Owned(in_memory) => Ok(BorrowedPath::InMemory(in_memory)),
             },
             NodeRef::OnDisk(node) => {
                 Ok(BorrowedPath::OnDisk(node.full_path(on_disk)?))
             }
         }
     }
 
     pub(super) fn base_name(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.base_name()),
             NodeRef::OnDisk(node) => node.base_name(on_disk),
         }
     }
 
     pub(super) fn children(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),
             NodeRef::OnDisk(node) => {
                 Ok(ChildNodesRef::OnDisk(node.children(on_disk)?))
             }
         }
     }
 
     pub(super) fn has_copy_source(&self) -> bool {
         match self {
             NodeRef::InMemory(_path, node) => node.copy_source.is_some(),
             NodeRef::OnDisk(node) => node.has_copy_source(),
         }
     }
 
     pub(super) fn copy_source(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.copy_source.as_ref().map(|s| &**s))
             }
             NodeRef::OnDisk(node) => node.copy_source(on_disk),
         }
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.data.as_entry().copied())
             }
             NodeRef::OnDisk(node) => node.entry(),
         }
     }
 
     pub(super) fn state(
         &self,
     ) -> Result<Option<EntryState>, DirstateV2ParseError> {
         Ok(self.entry()?.map(|e| e.state()))
     }
 
     pub(super) fn cached_directory_mtime(
         &self,
     ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(match node.data {
                 NodeData::CachedDirectory { mtime } => Some(mtime),
                 _ => None,
             }),
             NodeRef::OnDisk(node) => node.cached_directory_mtime(),
         }
     }
 
     pub(super) fn descendants_with_entry_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => {
                 node.descendants_with_entry_count
             }
             NodeRef::OnDisk(node) => node.descendants_with_entry_count.get(),
         }
     }
 
     pub(super) fn tracked_descendants_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
             NodeRef::OnDisk(node) => node.tracked_descendants_count.get(),
         }
     }
 }
 
 /// Represents a file or a directory
 #[derive(Default)]
 pub(super) struct Node<'on_disk> {
     pub(super) data: NodeData,
 
     pub(super) copy_source: Option<Cow<'on_disk, HgPath>>,
 
     pub(super) children: ChildNodes<'on_disk>,
 
     /// How many (non-inclusive) descendants of this node have an entry.
     pub(super) descendants_with_entry_count: u32,
 
     /// How many (non-inclusive) descendants of this node have an entry whose
     /// state is "tracked".
     pub(super) tracked_descendants_count: u32,
 }
 
 pub(super) enum NodeData {
     Entry(DirstateEntry),
     CachedDirectory { mtime: TruncatedTimestamp },
     None,
 }
 
 impl Default for NodeData {
     fn default() -> Self {
         NodeData::None
     }
 }
 
 impl NodeData {
     fn has_entry(&self) -> bool {
         match self {
             NodeData::Entry(_) => true,
             _ => false,
         }
     }
 
     fn as_entry(&self) -> Option<&DirstateEntry> {
         match self {
             NodeData::Entry(entry) => Some(entry),
             _ => None,
         }
     }
 }
 
 impl<'on_disk> DirstateMap<'on_disk> {
     pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {
         Self {
             on_disk,
             root: ChildNodes::default(),
             nodes_with_entry_count: 0,
             nodes_with_copy_source_count: 0,
             ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],
             unreachable_bytes: 0,
         }
     }
 
     #[timed]
     pub fn new_v2(
         on_disk: &'on_disk [u8],
         data_size: usize,
         metadata: &[u8],
     ) -> Result<Self, DirstateError> {
         if let Some(data) = on_disk.get(..data_size) {
             Ok(on_disk::read(data, metadata)?)
         } else {
             Err(DirstateV2ParseError.into())
         }
     }
 
     #[timed]
     pub fn new_v1(
         on_disk: &'on_disk [u8],
     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
         let mut map = Self::empty(on_disk);
         if map.on_disk.is_empty() {
             return Ok((map, None));
         }
 
         let parents = parse_dirstate_entries(
             map.on_disk,
             |path, entry, copy_source| {
                 let tracked = entry.state().is_tracked();
                 let node = Self::get_or_insert_node(
                     map.on_disk,
                     &mut map.unreachable_bytes,
                     &mut map.root,
                     path,
                     WithBasename::to_cow_borrowed,
                     |ancestor| {
                         if tracked {
                             ancestor.tracked_descendants_count += 1
                         }
                         ancestor.descendants_with_entry_count += 1
                     },
                 )?;
                 assert!(
                     !node.data.has_entry(),
                     "duplicate dirstate entry in read"
                 );
                 assert!(
                     node.copy_source.is_none(),
                     "duplicate dirstate entry in read"
                 );
                 node.data = NodeData::Entry(*entry);
                 node.copy_source = copy_source.map(Cow::Borrowed);
                 map.nodes_with_entry_count += 1;
                 if copy_source.is_some() {
                     map.nodes_with_copy_source_count += 1
                 }
                 Ok(())
             },
         )?;
         let parents = Some(parents.clone());
 
         Ok((map, parents))
     }
 
     /// Assuming dirstate-v2 format, returns whether the next write should
     /// append to the existing data file that contains `self.on_disk` (true),
     /// or create a new data file from scratch (false).
     pub(super) fn write_should_append(&self) -> bool {
         let ratio = self.unreachable_bytes as f32 / self.on_disk.len() as f32;
         ratio < ACCEPTABLE_UNREACHABLE_BYTES_RATIO
     }
 
     fn get_node<'tree>(
         &'tree self,
         path: &HgPath,
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         let mut children = self.root.as_ref();
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children.get(component, self.on_disk)? {
                 if let Some(next_component) = components.next() {
                     component = next_component;
                     children = child.children(self.on_disk)?;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     /// Returns a mutable reference to the node at `path` if it exists
     ///
     /// This takes `root` instead of `&mut self` so that callers can mutate
     /// other fields while the returned borrow is still valid
     fn get_node_mut<'tree>(
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
         root: &'tree mut ChildNodes<'on_disk>,
         path: &HgPath,
     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
         let mut children = root;
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children
                 .make_mut(on_disk, unreachable_bytes)?
                 .get_mut(component)
             {
                 if let Some(next_component) = components.next() {
                     component = next_component;
                     children = &mut child.children;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     pub(super) fn get_or_insert<'tree, 'path>(
         &'tree mut self,
         path: &HgPath,
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             |_| {},
         )
     }
 
     fn get_or_insert_node<'tree, 'path>(
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
         root: &'tree mut ChildNodes<'on_disk>,
         path: &'path HgPath,
         to_cow: impl Fn(
             WithBasename<&'path HgPath>,
         ) -> WithBasename<Cow<'on_disk, HgPath>>,
         mut each_ancestor: impl FnMut(&mut Node),
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         let mut child_nodes = root;
         let mut inclusive_ancestor_paths =
             WithBasename::inclusive_ancestors_of(path);
         let mut ancestor_path = inclusive_ancestor_paths
             .next()
             .expect("expected at least one inclusive ancestor");
         loop {
             // TODO: can we avoid allocating an owned key in cases where the
             // map already contains that key, without introducing double
             // lookup?
             let child_node = child_nodes
                 .make_mut(on_disk, unreachable_bytes)?
                 .entry(to_cow(ancestor_path))
                 .or_default();
             if let Some(next) = inclusive_ancestor_paths.next() {
                 each_ancestor(child_node);
                 ancestor_path = next;
                 child_nodes = &mut child_node.children;
             } else {
                 return Ok(child_node);
             }
         }
     }
 
     fn add_or_remove_file(
         &mut self,
         path: &HgPath,
         old_state: Option<EntryState>,
         new_entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let had_entry = old_state.is_some();
         let was_tracked = old_state.map_or(false, |s| s.is_tracked());
         let tracked_count_increment =
             match (was_tracked, new_entry.state().is_tracked()) {
                 (false, true) => 1,
                 (true, false) => -1,
                 _ => 0,
             };
 
         let node = Self::get_or_insert_node(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             |ancestor| {
                 if !had_entry {
                     ancestor.descendants_with_entry_count += 1;
                 }
 
                 // We can’t use `+= increment` because the counter is unsigned,
                 // and we want debug builds to detect accidental underflow
                 // through zero
                 match tracked_count_increment {
                     1 => ancestor.tracked_descendants_count += 1,
                     -1 => ancestor.tracked_descendants_count -= 1,
                     _ => {}
                 }
             },
         )?;
         if !had_entry {
             self.nodes_with_entry_count += 1
         }
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     fn iter_nodes<'tree>(
         &'tree self,
     ) -> impl Iterator<
         Item = Result<NodeRef<'tree, 'on_disk>, DirstateV2ParseError>,
     > + 'tree {
         // Depth first tree traversal.
         //
         // If we could afford internal iteration and recursion,
         // this would look like:
         //
         // ```
         // fn traverse_children(
         //     children: &ChildNodes,
         //     each: &mut impl FnMut(&Node),
         // ) {
         //     for child in children.values() {
         //         traverse_children(&child.children, each);
         //         each(child);
         //     }
         // }
         // ```
         //
         // However we want an external iterator and therefore can’t use the
         // call stack. Use an explicit stack instead:
         let mut stack = Vec::new();
         let mut iter = self.root.as_ref().iter();
         std::iter::from_fn(move || {
             while let Some(child_node) = iter.next() {
                 let children = match child_node.children(self.on_disk) {
                     Ok(children) => children,
                     Err(error) => return Some(Err(error)),
                 };
                 // Pseudo-recursion
                 let new_iter = children.iter();
                 let old_iter = std::mem::replace(&mut iter, new_iter);
                 stack.push((child_node, old_iter));
             }
             // Found the end of a `children.iter()` iterator.
             if let Some((child_node, next_iter)) = stack.pop() {
                 // "Return" from pseudo-recursion by restoring state from the
                 // explicit stack
                 iter = next_iter;
 
                 Some(Ok(child_node))
             } else {
                 // Reached the bottom of the stack, we’re done
                 None
             }
         })
     }
 
-    fn clear_known_ambiguous_mtimes(
-        &mut self,
-        paths: &[impl AsRef<HgPath>],
-    ) -> Result<(), DirstateV2ParseError> {
-        for path in paths {
-            if let Some(node) = Self::get_node_mut(
-                self.on_disk,
-                &mut self.unreachable_bytes,
-                &mut self.root,
-                path.as_ref(),
-            )? {
-                if let NodeData::Entry(entry) = &mut node.data {
-                    entry.set_possibly_dirty();
-                }
-            }
-        }
-        Ok(())
-    }
-
     fn count_dropped_path(unreachable_bytes: &mut u32, path: &Cow<HgPath>) {
         if let Cow::Borrowed(path) = path {
             *unreachable_bytes += path.len() as u32
         }
     }
 }
 
 /// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s.
 ///
 /// The callback is only called for incoming `Ok` values. Errors are passed
 /// through as-is. In order to let it use the `?` operator the callback is
 /// expected to return a `Result` of `Option`, instead of an `Option` of
 /// `Result`.
 fn filter_map_results<'a, I, F, A, B, E>(
     iter: I,
     f: F,
 ) -> impl Iterator<Item = Result<B, E>> + 'a
 where
     I: Iterator<Item = Result<A, E>> + 'a,
     F: Fn(A) -> Result<Option<B>, E> + 'a,
 {
     iter.filter_map(move |result| match result {
         Ok(node) => f(node).transpose(),
         Err(e) => Some(Err(e)),
     })
 }
 
 impl OwningDirstateMap {
     pub fn clear(&mut self) {
         let map = self.get_map_mut();
         map.root = Default::default();
         map.nodes_with_entry_count = 0;
         map.nodes_with_copy_source_count = 0;
     }
 
     pub fn set_entry(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let map = self.get_map_mut();
         map.get_or_insert(&filename)?.data = NodeData::Entry(entry);
         Ok(())
     }
 
     pub fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
     ) -> Result<(), DirstateError> {
         let old_state = self.get(filename)?.map(|e| e.state());
         let map = self.get_map_mut();
         Ok(map.add_or_remove_file(filename, old_state, entry)?)
     }
 
     pub fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         let old_entry_opt = self.get(filename)?;
         let old_state = old_entry_opt.map(|e| e.state());
         let mut size = 0;
         if in_merge {
             // XXX we should not be able to have 'm' state and 'FROM_P2' if not
             // during a merge. So I (marmoute) am not sure we need the
             // conditionnal at all. Adding double checking this with assert
             // would be nice.
             if let Some(old_entry) = old_entry_opt {
                 // backup the previous state
                 if old_entry.state() == EntryState::Merged {
                     size = SIZE_NON_NORMAL;
                 } else if old_entry.state() == EntryState::Normal
                     && old_entry.size() == SIZE_FROM_OTHER_PARENT
                 {
                     // other parent
                     size = SIZE_FROM_OTHER_PARENT;
                 }
             }
         }
         if size == 0 {
             self.copy_map_remove(filename)?;
         }
         let map = self.get_map_mut();
         let entry = DirstateEntry::new_removed(size);
         Ok(map.add_or_remove_file(filename, old_state, entry)?)
     }
 
     pub fn drop_entry_and_copy_source(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         let was_tracked = self
             .get(filename)?
             .map_or(false, |e| e.state().is_tracked());
         let map = self.get_map_mut();
         struct Dropped {
             was_tracked: bool,
             had_entry: bool,
             had_copy_source: bool,
         }
 
         /// If this returns `Ok(Some((dropped, removed)))`, then
         ///
         /// * `dropped` is about the leaf node that was at `filename`
         /// * `removed` is whether this particular level of recursion just
         ///   removed a node in `nodes`.
         fn recur<'on_disk>(
             on_disk: &'on_disk [u8],
             unreachable_bytes: &mut u32,
             nodes: &mut ChildNodes<'on_disk>,
             path: &HgPath,
         ) -> Result<Option<(Dropped, bool)>, DirstateV2ParseError> {
             let (first_path_component, rest_of_path) =
                 path.split_first_component();
             let nodes = nodes.make_mut(on_disk, unreachable_bytes)?;
             let node = if let Some(node) = nodes.get_mut(first_path_component)
             {
                 node
             } else {
                 return Ok(None);
             };
             let dropped;
             if let Some(rest) = rest_of_path {
                 if let Some((d, removed)) = recur(
                     on_disk,
                     unreachable_bytes,
                     &mut node.children,
                     rest,
                 )? {
                     dropped = d;
                     if dropped.had_entry {
                         node.descendants_with_entry_count -= 1;
                     }
                     if dropped.was_tracked {
                         node.tracked_descendants_count -= 1;
                     }
 
                     // Directory caches must be invalidated when removing a
                     // child node
                     if removed {
                         if let NodeData::CachedDirectory { .. } = &node.data {
                             node.data = NodeData::None
                         }
                     }
                 } else {
                     return Ok(None);
                 }
             } else {
                 let had_entry = node.data.has_entry();
                 if had_entry {
                     node.data = NodeData::None
                 }
                 if let Some(source) = &node.copy_source {
                     DirstateMap::count_dropped_path(unreachable_bytes, source);
                     node.copy_source = None
                 }
                 dropped = Dropped {
                     was_tracked: node
                         .data
                         .as_entry()
                         .map_or(false, |entry| entry.state().is_tracked()),
                     had_entry,
                     had_copy_source: node.copy_source.take().is_some(),
                 };
             }
             // After recursion, for both leaf (rest_of_path is None) nodes and
             // parent nodes, remove a node if it just became empty.
             let remove = !node.data.has_entry()
                 && node.copy_source.is_none()
                 && node.children.is_empty();
             if remove {
                 let (key, _) =
                     nodes.remove_entry(first_path_component).unwrap();
                 DirstateMap::count_dropped_path(
                     unreachable_bytes,
                     key.full_path(),
                 )
             }
             Ok(Some((dropped, remove)))
         }
 
         if let Some((dropped, _removed)) = recur(
             map.on_disk,
             &mut map.unreachable_bytes,
             &mut map.root,
             filename,
         )? {
             if dropped.had_entry {
                 map.nodes_with_entry_count -= 1
             }
             if dropped.had_copy_source {
                 map.nodes_with_copy_source_count -= 1
             }
         } else {
             debug_assert!(!was_tracked);
         }
         Ok(())
     }
 
     pub fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         let map = self.get_map_mut();
         if let Some(node) = map.get_node(directory)? {
             // A node without a `DirstateEntry` was created to hold child
             // nodes, and is therefore a directory.
             let state = node.state()?;
             Ok(state.is_none() && node.tracked_descendants_count() > 0)
         } else {
             Ok(false)
         }
     }
 
     pub fn has_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         let map = self.get_map_mut();
         if let Some(node) = map.get_node(directory)? {
             // A node without a `DirstateEntry` was created to hold child
             // nodes, and is therefore a directory.
             let state = node.state()?;
             Ok(state.is_none() && node.descendants_with_entry_count() > 0)
         } else {
             Ok(false)
         }
     }
 
     #[timed]
     pub fn pack_v1(
         &mut self,
         parents: DirstateParents,
-        now: TruncatedTimestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         let map = self.get_map_mut();
-        let mut ambiguous_mtimes = Vec::new();
         // Optizimation (to be measured?): pre-compute size to avoid `Vec`
         // reallocations
         let mut size = parents.as_bytes().len();
         for node in map.iter_nodes() {
             let node = node?;
-            if let Some(entry) = node.entry()? {
+            if node.entry()?.is_some() {
                 size += packed_entry_size(
                     node.full_path(map.on_disk)?,
                     node.copy_source(map.on_disk)?,
                 );
-                if entry.need_delay(now) {
-                    ambiguous_mtimes.push(
-                        node.full_path_borrowed(map.on_disk)?
-                            .detach_from_tree(),
-                    )
-                }
             }
         }
-        map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
 
         let mut packed = Vec::with_capacity(size);
         packed.extend(parents.as_bytes());
 
         for node in map.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 pack_entry(
                     node.full_path(map.on_disk)?,
                     &entry,
                     node.copy_source(map.on_disk)?,
                     &mut packed,
                 );
             }
         }
         Ok(packed)
     }
 
     /// Returns new data and metadata together with whether that data should be
     /// appended to the existing data file whose content is at
     /// `map.on_disk` (true), instead of written to a new data file
     /// (false).
     #[timed]
     pub fn pack_v2(
         &mut self,
-        now: TruncatedTimestamp,
         can_append: bool,
     ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
         let map = self.get_map_mut();
-        let mut paths = Vec::new();
-        for node in map.iter_nodes() {
-            let node = node?;
-            if let Some(entry) = node.entry()? {
-                if entry.need_delay(now) {
-                    paths.push(
-                        node.full_path_borrowed(map.on_disk)?
-                            .detach_from_tree(),
-                    )
-                }
-            }
-        }
-        // Borrow of `self` ends here since we collect cloned paths
-
-        map.clear_known_ambiguous_mtimes(&paths)?;
-
         on_disk::write(map, can_append)
     }
 
     pub fn status<'a>(
         &'a mut self,
         matcher: &'a (dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
     ) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>
     {
         let map = self.get_map_mut();
         super::status::status(map, matcher, root_dir, ignore_files, options)
     }
 
     pub fn copy_map_len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_copy_source_count as usize
     }
 
     pub fn copy_map_iter(&self) -> CopyMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(source) = node.copy_source(map.on_disk)? {
                 Some((node.full_path(map.on_disk)?, source))
             } else {
                 None
             })
         }))
     }
 
     pub fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.has_copy_source()
         } else {
             false
         })
     }
 
     pub fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         let map = self.get_map();
         if let Some(node) = map.get_node(key)? {
             if let Some(source) = node.copy_source(map.on_disk)? {
                 return Ok(Some(source));
             }
         }
         Ok(None)
     }
 
     pub fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         let map = self.get_map_mut();
         let count = &mut map.nodes_with_copy_source_count;
         let unreachable_bytes = &mut map.unreachable_bytes;
         Ok(DirstateMap::get_node_mut(
             map.on_disk,
             unreachable_bytes,
             &mut map.root,
             key,
         )?
         .and_then(|node| {
             if let Some(source) = &node.copy_source {
                 *count -= 1;
                 DirstateMap::count_dropped_path(unreachable_bytes, source);
             }
             node.copy_source.take().map(Cow::into_owned)
         }))
     }
 
     pub fn copy_map_insert(
         &mut self,
         key: HgPathBuf,
         value: HgPathBuf,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         let map = self.get_map_mut();
         let node = DirstateMap::get_or_insert_node(
             map.on_disk,
             &mut map.unreachable_bytes,
             &mut map.root,
             &key,
             WithBasename::to_cow_owned,
             |_ancestor| {},
         )?;
         if node.copy_source.is_none() {
             map.nodes_with_copy_source_count += 1
         }
         Ok(node.copy_source.replace(value.into()).map(Cow::into_owned))
     }
 
     pub fn len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_entry_count as usize
     }
 
     pub fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(self.get(key)?.is_some())
     }
 
     pub fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.entry()?
         } else {
             None
         })
     }
 
     pub fn iter(&self) -> StateMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(entry) = node.entry()? {
                 Some((node.full_path(map.on_disk)?, entry))
             } else {
                 None
             })
         }))
     }
 
     pub fn iter_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         let map = self.get_map_mut();
         let on_disk = map.on_disk;
         Ok(Box::new(filter_map_results(
             map.iter_nodes(),
             move |node| {
                 Ok(if node.tracked_descendants_count() > 0 {
                     Some(node.full_path(on_disk)?)
                 } else {
                     None
                 })
             },
         )))
     }
 
     pub fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
                     (&HgPath, (u8, i32, i32, i32)),
                     DirstateV2ParseError,
                 >,
             > + Send
             + '_,
     > {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             let debug_tuple = if let Some(entry) = node.entry()? {
                 entry.debug_tuple()
             } else if !all {
                 return Ok(None);
             } else if let Some(mtime) = node.cached_directory_mtime()? {
                 (b' ', 0, -1, mtime.truncated_seconds() as i32)
             } else {
                 (b' ', 0, -1, -1)
             };
             Ok(Some((node.full_path(map.on_disk)?, debug_tuple)))
         }))
     }
 }

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

@@ -1,505 +1,499 b''
 // dirstate_map.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
 //! `hg-core` package.
 
 use std::cell::{RefCell, RefMut};
 use std::convert::TryInto;
 
 use cpython::{
     exc, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, PyNone, PyObject,
     PyResult, Python, PythonObject, ToPyObject, UnsafePyLeaked,
 };
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
-    dirstate::item::{timestamp, DirstateItem},
+    dirstate::item::DirstateItem,
     pybytes_deref::PyBytesDeref,
 };
 use hg::{
     dirstate::StateMapIter,
     dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
     dirstate_tree::on_disk::DirstateV2ParseError,
     dirstate_tree::owning::OwningDirstateMap,
     revlog::Node,
     utils::files::normalize_case,
     utils::hg_path::{HgPath, HgPathBuf},
     DirstateEntry, DirstateError, DirstateParents, EntryState,
 };
 
 // TODO
 //     This object needs to share references to multiple members of its Rust
 //     inner struct, namely `copy_map`, `dirs` and `all_dirs`.
 //     Right now `CopyMap` is done, but it needs to have an explicit reference
 //     to `RustDirstateMap` which itself needs to have an encapsulation for
 //     every method in `CopyMap` (copymapcopy, etc.).
 //     This is ugly and hard to maintain.
 //     The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
 //     `py_class!` is already implemented and does not mention
 //     `RustDirstateMap`, rightfully so.
 //     All attributes also have to have a separate refcount data attribute for
 //     leaks, with all methods that go along for reference sharing.
 py_class!(pub class DirstateMap |py| {
     @shared data inner: OwningDirstateMap;
 
     /// Returns a `(dirstate_map, parents)` tuple
     @staticmethod
     def new_v1(
         on_disk: PyBytes,
     ) -> PyResult<PyObject> {
         let on_disk = PyBytesDeref::new(py, on_disk);
         let mut map = OwningDirstateMap::new_empty(on_disk);
         let (on_disk, map_placeholder) = map.get_pair_mut();
 
         let (actual_map, parents) = TreeDirstateMap::new_v1(on_disk)
             .map_err(|e| dirstate_error(py, e))?;
         *map_placeholder = actual_map;
         let map = Self::create_instance(py, map)?;
         let parents = parents.map(|p| {
             let p1 = PyBytes::new(py, p.p1.as_bytes());
             let p2 = PyBytes::new(py, p.p2.as_bytes());
             (p1, p2)
         });
         Ok((map, parents).to_py_object(py).into_object())
     }
 
     /// Returns a DirstateMap
     @staticmethod
     def new_v2(
         on_disk: PyBytes,
         data_size: usize,
         tree_metadata: PyBytes,
     ) -> PyResult<PyObject> {
         let dirstate_error = |e: DirstateError| {
             PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
         };
         let on_disk = PyBytesDeref::new(py, on_disk);
         let mut map = OwningDirstateMap::new_empty(on_disk);
         let (on_disk, map_placeholder) = map.get_pair_mut();
         *map_placeholder = TreeDirstateMap::new_v2(
             on_disk, data_size, tree_metadata.data(py),
         ).map_err(dirstate_error)?;
         let map = Self::create_instance(py, map)?;
         Ok(map.into_object())
     }
 
     def clear(&self) -> PyResult<PyObject> {
         self.inner(py).borrow_mut().clear();
         Ok(py.None())
     }
 
     def get(
         &self,
         key: PyObject,
         default: Option<PyObject> = None
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(entry) => {
                 Ok(Some(DirstateItem::new_as_pyobject(py, entry)?))
             },
             None => Ok(default)
         }
     }
 
     def set_dirstate_item(
         &self,
         path: PyObject,
         item: DirstateItem
     ) -> PyResult<PyObject> {
         let f = path.extract::<PyBytes>(py)?;
         let filename = HgPath::new(f.data(py));
         self.inner(py)
             .borrow_mut()
             .set_entry(filename, item.get_entry(py))
             .map_err(|e| v2_error(py, e))?;
         Ok(py.None())
     }
 
     def addfile(
         &self,
         f: PyBytes,
         item: DirstateItem,
     ) -> PyResult<PyNone> {
         let filename = HgPath::new(f.data(py));
         let entry = item.get_entry(py);
         self.inner(py)
             .borrow_mut()
             .add_file(filename, entry)
             .map_err(|e |dirstate_error(py, e))?;
         Ok(PyNone)
     }
 
     def removefile(
         &self,
         f: PyObject,
         in_merge: PyObject
     ) -> PyResult<PyObject> {
         self.inner(py).borrow_mut()
             .remove_file(
                 HgPath::new(f.extract::<PyBytes>(py)?.data(py)),
                 in_merge.extract::<PyBool>(py)?.is_true(),
             )
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })?;
         Ok(py.None())
     }
 
     def drop_item_and_copy_source(
         &self,
         f: PyBytes,
     ) -> PyResult<PyNone> {
         self.inner(py)
             .borrow_mut()
             .drop_entry_and_copy_source(HgPath::new(f.data(py)))
             .map_err(|e |dirstate_error(py, e))?;
         Ok(PyNone)
     }
 
     def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow_mut()
             .has_tracked_dir(HgPath::new(d.data(py)))
             .map_err(|e| {
                 PyErr::new::<exc::ValueError, _>(py, e.to_string())
             })?
             .to_py_object(py))
     }
 
     def hasdir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow_mut()
             .has_dir(HgPath::new(d.data(py)))
             .map_err(|e| {
                 PyErr::new::<exc::ValueError, _>(py, e.to_string())
             })?
             .to_py_object(py))
     }
 
     def write_v1(
         &self,
         p1: PyObject,
         p2: PyObject,
-        now: (u32, u32)
     ) -> PyResult<PyBytes> {
-        let now = timestamp(py, now)?;
-
         let mut inner = self.inner(py).borrow_mut();
         let parents = DirstateParents {
             p1: extract_node_id(py, &p1)?,
             p2: extract_node_id(py, &p2)?,
         };
-        let result = inner.pack_v1(parents, now);
+        let result = inner.pack_v1(parents);
         match result {
             Ok(packed) => Ok(PyBytes::new(py, &packed)),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
 
     /// Returns new data together with whether that data should be appended to
     /// the existing data file whose content is at `self.on_disk` (True),
     /// instead of written to a new data file (False).
     def write_v2(
         &self,
-        now: (u32, u32),
         can_append: bool,
     ) -> PyResult<PyObject> {
-        let now = timestamp(py, now)?;
-
         let mut inner = self.inner(py).borrow_mut();
-        let result = inner.pack_v2(now, can_append);
+        let result = inner.pack_v2(can_append);
         match result {
             Ok((packed, tree_metadata, append)) => {
                 let packed = PyBytes::new(py, &packed);
                 let tree_metadata = PyBytes::new(py, &tree_metadata);
                 let tuple = (packed, tree_metadata, append);
                 Ok(tuple.to_py_object(py).into_object())
             },
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
 
     def filefoldmapasdict(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for item in self.inner(py).borrow_mut().iter() {
             let (path, entry) = item.map_err(|e| v2_error(py, e))?;
             if entry.state() != EntryState::Removed {
                 let key = normalize_case(path);
                 let value = path;
                 dict.set_item(
                     py,
                     PyBytes::new(py, key.as_bytes()).into_object(),
                     PyBytes::new(py, value.as_bytes()).into_object(),
                 )?;
             }
         }
         Ok(dict)
     }
 
     def __len__(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().len())
     }
 
     def __contains__(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow()
             .contains_key(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))
     }
 
     def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let key = HgPath::new(key.data(py));
         match self
             .inner(py)
             .borrow()
             .get(key)
             .map_err(|e| v2_error(py, e))?
         {
             Some(entry) => {
                 Ok(DirstateItem::new_as_pyobject(py, entry)?)
             },
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key.as_bytes()),
             )),
         }
     }
 
     def keys(&self) -> PyResult<DirstateMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     def items(&self) -> PyResult<DirstateMapItemsIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapItemsIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirstateMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     // TODO all copymap* methods, see docstring above
     def copymapcopy(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for item in self.inner(py).borrow().copy_map_iter() {
             let (key, value) = item.map_err(|e| v2_error(py, e))?;
             dict.set_item(
                 py,
                 PyBytes::new(py, key.as_bytes()),
                 PyBytes::new(py, value.as_bytes()),
             )?;
         }
         Ok(dict)
     }
 
     def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .copy_map_get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(copy) => Ok(PyBytes::new(py, copy.as_bytes())),
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key.data(py)),
             )),
         }
     }
     def copymap(&self) -> PyResult<CopyMap> {
         CopyMap::from_inner(py, self.clone_ref(py))
     }
 
     def copymaplen(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().copy_map_len())
     }
     def copymapcontains(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow()
             .copy_map_contains_key(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))
     }
     def copymapget(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow()
             .copy_map_get(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(copy) => Ok(Some(
                 PyBytes::new(py, copy.as_bytes()).into_object(),
             )),
             None => Ok(default),
         }
     }
     def copymapsetitem(
         &self,
         key: PyObject,
         value: PyObject
     ) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let value = value.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow_mut()
             .copy_map_insert(
                 HgPathBuf::from_bytes(key.data(py)),
                 HgPathBuf::from_bytes(value.data(py)),
             )
             .map_err(|e| v2_error(py, e))?;
         Ok(py.None())
     }
     def copymappop(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self
             .inner(py)
             .borrow_mut()
             .copy_map_remove(HgPath::new(key.data(py)))
             .map_err(|e| v2_error(py, e))?
         {
             Some(copy) => Ok(Some(
                 PyBytes::new(py, copy.as_bytes()).into_object(),
             )),
             None => Ok(default),
         }
     }
 
     def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         CopyMapKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
         )
     }
 
     def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         CopyMapItemsIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
         )
     }
 
     def tracked_dirs(&self) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
         for path in self.inner(py).borrow_mut().iter_tracked_dirs()
             .map_err(|e |dirstate_error(py, e))?
         {
             let path = path.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());
             dirs.append(py, path.into_object())
         }
         Ok(dirs)
     }
 
     def debug_iter(&self, all: bool) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
         for item in self.inner(py).borrow().debug_iter(all) {
             let (path, (state, mode, size, mtime)) =
                 item.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());
             let item = (path, state, mode, size, mtime);
             dirs.append(py, item.to_py_object(py).into_object())
         }
         Ok(dirs)
     }
 });
 
 impl DirstateMap {
     pub fn get_inner_mut<'a>(
         &'a self,
         py: Python<'a>,
     ) -> RefMut<'a, OwningDirstateMap> {
         self.inner(py).borrow_mut()
     }
     fn translate_key(
         py: Python,
         res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
     ) -> PyResult<Option<PyBytes>> {
         let (f, _entry) = res.map_err(|e| v2_error(py, e))?;
         Ok(Some(PyBytes::new(py, f.as_bytes())))
     }
     fn translate_key_value(
         py: Python,
         res: Result<(&HgPath, DirstateEntry), DirstateV2ParseError>,
     ) -> PyResult<Option<(PyBytes, PyObject)>> {
         let (f, entry) = res.map_err(|e| v2_error(py, e))?;
         Ok(Some((
             PyBytes::new(py, f.as_bytes()),
             DirstateItem::new_as_pyobject(py, entry)?,
         )))
     }
 }
 
 py_shared_iterator!(
     DirstateMapKeysIterator,
     UnsafePyLeaked<StateMapIter<'static>>,
     DirstateMap::translate_key,
     Option<PyBytes>
 );
 
 py_shared_iterator!(
     DirstateMapItemsIterator,
     UnsafePyLeaked<StateMapIter<'static>>,
     DirstateMap::translate_key_value,
     Option<(PyBytes, PyObject)>
 );
 
 fn extract_node_id(py: Python, obj: &PyObject) -> PyResult<Node> {
     let bytes = obj.extract::<PyBytes>(py)?;
     match bytes.data(py).try_into() {
         Ok(s) => Ok(s),
         Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
     }
 }
 
 pub(super) fn v2_error(py: Python<'_>, _: DirstateV2ParseError) -> PyErr {
     PyErr::new::<exc::ValueError, _>(py, "corrupted dirstate-v2")
 }
 
 fn dirstate_error(py: Python<'_>, e: DirstateError) -> PyErr {
     PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
 }

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

@@ -1,288 +1,283 b''
 use cpython::exc;
 use cpython::ObjectProtocol;
 use cpython::PyBytes;
 use cpython::PyErr;
 use cpython::PyNone;
 use cpython::PyObject;
 use cpython::PyResult;
 use cpython::Python;
 use cpython::PythonObject;
 use hg::dirstate::DirstateEntry;
 use hg::dirstate::EntryState;
 use hg::dirstate::TruncatedTimestamp;
 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_info: bool = false,
         has_meaningful_data: bool = true,
         has_meaningful_mtime: bool = true,
         parentfiledata: Option<(u32, u32, Option<(u32, u32)>)> = None,
         fallback_exec: Option<bool> = None,
         fallback_symlink: Option<bool> = None,
 
     ) -> PyResult<DirstateItem> {
         let mut mode_size_opt = None;
         let mut mtime_opt = None;
         if let Some((mode, size, mtime)) = parentfiledata {
             if has_meaningful_data {
                 mode_size_opt = Some((mode, size))
             }
             if has_meaningful_mtime {
                 if let Some(m) = mtime {
                     mtime_opt = Some(timestamp(py, m)?);
                 }
             }
         }
         let entry = DirstateEntry::from_v2_data(
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size_opt,
             mtime_opt,
             fallback_exec,
             fallback_symlink,
         );
         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 has_fallback_exec(&self) -> PyResult<bool> {
         match self.entry(py).get().get_fallback_exec() {
             Some(_) => Ok(true),
             None => Ok(false),
         }
     }
 
     @property
     def fallback_exec(&self) -> PyResult<Option<bool>> {
         match self.entry(py).get().get_fallback_exec() {
             Some(exec) => Ok(Some(exec)),
             None => Ok(None),
         }
     }
 
     @fallback_exec.setter
     def set_fallback_exec(&self, value: Option<PyObject>) -> PyResult<()> {
         match value {
             None => {self.entry(py).get().set_fallback_exec(None);},
             Some(value) => {
             if value.is_none(py) {
                 self.entry(py).get().set_fallback_exec(None);
             } else {
                 self.entry(py).get().set_fallback_exec(
                     Some(value.is_true(py)?)
                 );
             }},
         }
         Ok(())
     }
 
     @property
     def has_fallback_symlink(&self) -> PyResult<bool> {
         match self.entry(py).get().get_fallback_symlink() {
             Some(_) => Ok(true),
             None => Ok(false),
         }
     }
 
     @property
     def fallback_symlink(&self) -> PyResult<Option<bool>> {
         match self.entry(py).get().get_fallback_symlink() {
             Some(symlink) => Ok(Some(symlink)),
             None => Ok(None),
         }
     }
 
     @fallback_symlink.setter
     def set_fallback_symlink(&self, value: Option<PyObject>) -> PyResult<()> {
         match value {
             None => {self.entry(py).get().set_fallback_symlink(None);},
             Some(value) => {
             if value.is_none(py) {
                 self.entry(py).get().set_fallback_symlink(None);
             } else {
                 self.entry(py).get().set_fallback_symlink(
                     Some(value.is_true(py)?)
                 );
             }},
         }
         Ok(())
     }
 
     @property
     def tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().tracked())
     }
 
     @property
     def p1_tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().p1_tracked())
     }
 
     @property
     def added(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().added())
     }
 
 
     @property
     def p2_info(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().p2_info())
     }
 
     @property
     def removed(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().removed())
     }
 
     @property
     def maybe_clean(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().maybe_clean())
     }
 
     @property
     def any_tracked(&self) -> PyResult<bool> {
         Ok(self.entry(py).get().any_tracked())
     }
 
     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: (u32, u32)) -> PyResult<bool> {
-        let now = timestamp(py, now)?;
-        Ok(self.entry(py).get().need_delay(now))
-    }
-
     def mtime_likely_equal_to(&self, other: (u32, u32)) -> PyResult<bool> {
         if let Some(mtime) = self.entry(py).get().truncated_mtime() {
             Ok(mtime.likely_equal(timestamp(py, other)?))
         } else {
             Ok(false)
         }
     }
 
     @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))
     }
 
     def drop_merge_data(&self) -> PyResult<PyNone> {
         self.update(py, |entry| entry.drop_merge_data());
         Ok(PyNone)
     }
 
     def set_clean(
         &self,
         mode: u32,
         size: u32,
         mtime: (u32, u32),
     ) -> PyResult<PyNone> {
         let mtime = timestamp(py, mtime)?;
         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)
     }
 }
 
 pub(crate) fn timestamp(
     py: Python<'_>,
     (s, ns): (u32, u32),
 ) -> PyResult<TruncatedTimestamp> {
     TruncatedTimestamp::from_already_truncated(s, ns).map_err(|_| {
         PyErr::new::<exc::ValueError, _>(
             py,
             "expected mtime truncated to 31 bits",
         )
     })
 }

tests/fakedirstatewritetime.py

@@ -1,106 +1,100 b''
 # extension to emulate invoking 'dirstate.write()' at the time
 # specified by '[fakedirstatewritetime] fakenow', only when
 # 'dirstate.write()' is invoked via functions below:
 #
 #   - 'workingctx._poststatusfixup()' (= 'repo.status()')
 #   - 'committablectx.markcommitted()'
 
 from __future__ import absolute_import
 
 from mercurial import (
     context,
     dirstatemap as dirstatemapmod,
     extensions,
     policy,
     registrar,
 )
 from mercurial.dirstateutils import timestamp
 from mercurial.utils import dateutil
 
 try:
     from mercurial import rustext
 
     rustext.__name__  # force actual import (see hgdemandimport)
 except ImportError:
     rustext = None
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
     b'fakedirstatewritetime',
     b'fakenow',
     default=None,
 )
 
 parsers = policy.importmod('parsers')
 has_rust_dirstate = policy.importrust('dirstate') is not None
 
 
-def pack_dirstate(fakenow, orig, dmap, copymap, pl, now):
-    # execute what original parsers.pack_dirstate should do actually
-    # for consistency
-    for f, e in dmap.items():
-        if e.need_delay(now):
-            e.set_possibly_dirty()
-
-    return orig(dmap, copymap, pl, fakenow)
+def pack_dirstate(orig, dmap, copymap, pl):
+    return orig(dmap, copymap, pl)
 
 
 def fakewrite(ui, func):
     # fake "now" of 'pack_dirstate' only if it is invoked while 'func'
 
     fakenow = ui.config(b'fakedirstatewritetime', b'fakenow')
     if not fakenow:
         # Execute original one, if fakenow isn't configured. This is
         # useful to prevent subrepos from executing replaced one,
         # because replacing 'parsers.pack_dirstate' is also effective
         # in subrepos.
         return func()
 
     # parsing 'fakenow' in YYYYmmddHHMM format makes comparison between
     # 'fakenow' value and 'touch -t YYYYmmddHHMM' argument easy
     fakenow = dateutil.parsedate(fakenow, [b'%Y%m%d%H%M'])[0]
     fakenow = timestamp.timestamp((fakenow, 0))
 
     if has_rust_dirstate:
         # The Rust implementation does not use public parse/pack dirstate
         # to prevent conversion round-trips
         orig_dirstatemap_write = dirstatemapmod.dirstatemap.write
-        wrapper = lambda self, tr, st, now: orig_dirstatemap_write(
-            self, tr, st, fakenow
-        )
+        wrapper = lambda self, tr, st: orig_dirstatemap_write(self, tr, st)
         dirstatemapmod.dirstatemap.write = wrapper
 
     orig_get_fs_now = timestamp.get_fs_now
-    wrapper = lambda *args: pack_dirstate(fakenow, orig_pack_dirstate, *args)
+    wrapper = lambda *args: pack_dirstate(orig_pack_dirstate, *args)
 
     orig_module = parsers
     orig_pack_dirstate = parsers.pack_dirstate
 
     orig_module.pack_dirstate = wrapper
-    timestamp.get_fs_now = lambda *args: fakenow
+    timestamp.get_fs_now = (
+        lambda *args: fakenow
+    )  # XXX useless for this purpose now
     try:
         return func()
     finally:
         orig_module.pack_dirstate = orig_pack_dirstate
         timestamp.get_fs_now = orig_get_fs_now
         if has_rust_dirstate:
             dirstatemapmod.dirstatemap.write = orig_dirstatemap_write
 
 
 def _poststatusfixup(orig, workingctx, status, fixup):
     ui = workingctx.repo().ui
     return fakewrite(ui, lambda: orig(workingctx, status, fixup))
 
 
 def markcommitted(orig, committablectx, node):
     ui = committablectx.repo().ui
     return fakewrite(ui, lambda: orig(committablectx, node))
 
 
 def extsetup(ui):
     extensions.wrapfunction(
         context.workingctx, '_poststatusfixup', _poststatusfixup
     )
     extensions.wrapfunction(context.workingctx, 'markcommitted', markcommitted)

tests/test-merge1.t

@@ -1,439 +1,426 b''
   $ cat <<EOF > merge
   > from __future__ import print_function
   > import sys, os
   > 
   > try:
   >     import msvcrt
   >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
   >     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
   > except ImportError:
   >     pass
   > 
   > print("merging for", os.path.basename(sys.argv[1]))
   > EOF
   $ HGMERGE="\"$PYTHON\" ../merge"; export HGMERGE
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
 
   $ hg update 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Test interrupted updates by having a non-empty dir with the same name as one
 of the files in a commit we're updating to
 
   $ mkdir b && touch b/nonempty
   $ hg up
   abort: Unlinking directory not permitted: *$TESTTMP/t/b* (glob) (windows !)
   abort: Directory not empty: '?\$TESTTMP/t/b'? (re) (no-windows !)
   [255]
   $ hg ci
   abort: last update was interrupted
   (use 'hg update' to get a consistent checkout)
   [20]
   $ hg sum
   parent: 0:538afb845929 
    commit #0
   branch: default
   commit: 1 unknown (interrupted update)
   update: 1 new changesets (update)
   phases: 2 draft
 Detect interrupted update by hg status --verbose
   $ hg status -v
   ? b/nonempty
   # The repository is in an unfinished *update* state.
   
   # To continue:    hg update .
   
 
   $ rm b/nonempty
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:b8bb4a988f25 tip
    commit #1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
 Prepare a basic merge
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #2"
   created new head
   $ echo This is file b1 > b
 no merges expected
   $ hg merge -P 1
   changeset:   1:b8bb4a988f25
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit #1
   
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 49035e18a8e6 b
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +This is file b1
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
 
   $ hg update 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #2"
   created new head
   $ echo This is file b2 > b
 merge should fail
   $ hg merge 1
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
 
 #if symlink
 symlinks to directories should be treated as regular files (issue5027)
   $ rm b
   $ ln -s 'This is file b2' b
   $ hg merge 1
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
 symlinks shouldn't be followed
   $ rm b
   $ echo This is file b1 > .hg/b
   $ ln -s .hg/b b
   $ hg merge 1
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
 
   $ rm b
   $ echo This is file b2 > b
 #endif
 
 bad config
   $ hg merge 1 --config merge.checkunknown=x
   config error: merge.checkunknown not valid ('x' is none of 'abort', 'ignore', 'warn')
   [30]
 this merge should fail
   $ hg merge 1 --config merge.checkunknown=abort
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
 
 this merge should warn
   $ hg merge 1 --config merge.checkunknown=warn
   b: replacing untracked file
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat b.orig
   This is file b2
   $ hg up --clean 2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ mv b.orig b
 
 this merge should silently ignore
   $ cat b
   This is file b2
   $ hg merge 1 --config merge.checkunknown=ignore
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 merge.checkignored
   $ hg up --clean 1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ cat >> .hgignore << EOF
   > remoteignored
   > EOF
   $ echo This is file localignored3 > localignored
   $ echo This is file remoteignored3 > remoteignored
   $ hg add .hgignore localignored remoteignored
   $ hg commit -m "commit #3"
 
   $ hg up 2
   1 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ cat >> .hgignore << EOF
   > localignored
   > EOF
   $ hg add .hgignore
   $ hg commit -m "commit #4"
 
 remote .hgignore shouldn't be used for determining whether a file is ignored
   $ echo This is file remoteignored4 > remoteignored
   $ hg merge 3 --config merge.checkignored=ignore --config merge.checkunknown=abort
   remoteignored: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
   $ hg merge 3 --config merge.checkignored=abort --config merge.checkunknown=ignore
   merging .hgignore
   merging for .hgignore
   3 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat remoteignored
   This is file remoteignored3
   $ cat remoteignored.orig
   This is file remoteignored4
   $ rm remoteignored.orig
 
 local .hgignore should be used for that
   $ hg up --clean 4
   1 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ echo This is file localignored4 > localignored
 also test other conflicting files to see we output the full set of warnings
   $ echo This is file b2 > b
   $ hg merge 3 --config merge.checkignored=abort --config merge.checkunknown=abort
   b: untracked file differs
   localignored: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
   $ hg merge 3 --config merge.checkignored=abort --config merge.checkunknown=ignore
   localignored: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
   $ hg merge 3 --config merge.checkignored=warn --config merge.checkunknown=abort
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [20]
   $ hg merge 3 --config merge.checkignored=warn --config merge.checkunknown=warn
   b: replacing untracked file
   localignored: replacing untracked file
   merging .hgignore
   merging for .hgignore
   3 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat localignored
   This is file localignored3
   $ cat localignored.orig
   This is file localignored4
   $ rm localignored.orig
 
   $ cat b.orig
   This is file b2
   $ hg up --clean 2
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ mv b.orig b
 
 this merge of b should work
   $ cat b
   This is file b2
   $ hg merge -f 1
   merging b
   merging for b
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 49035e18a8e6 b
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +This is file b2
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
   $ echo This is file b22 > b
   $ hg commit -m "commit #2"
   $ hg update 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #3"
   created new head
 
 Contents of b should be "this is file b1"
   $ cat b
   This is file b1
 
   $ echo This is file b22 > b
 merge fails
   $ hg merge 2
   abort: uncommitted changes
   (use 'hg status' to list changes)
   [20]
 merge expected!
   $ hg merge -f 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 85de557015a8 b
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -This is file b1
   +This is file b22
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
   $ echo This is file b22 > b
   $ hg commit -m "commit #2"
   $ hg update 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #3"
   created new head
   $ echo This is file b33 > b
 merge of b should fail
   $ hg merge 2
   abort: uncommitted changes
   (use 'hg status' to list changes)
   [20]
 merge of b expected
   $ hg merge -f 2
   merging b
   merging for b
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 85de557015a8 b
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -This is file b1
   +This is file b33
   $ hg status
   M b
 
 Test for issue2364
 
   $ hg up -qC .
   $ hg rm b
   $ hg ci -md
   $ hg revert -r -2 b
   $ hg up -q -- -2
 
 Test that updated files are treated as "modified", when
 'merge.update()' is aborted before 'merge.recordupdates()' (= parents
 aren't changed), even if none of mode, size and timestamp of them
 isn't changed on the filesystem (see also issue4583).
 
+This test is now "best effort" as the mechanism to prevent such race are
+getting better, it get more complicated to test a specific scenario that would
+trigger it. If you see flakyness here, there is a race.
+
   $ cat > $TESTTMP/abort.py <<EOF
   > from __future__ import absolute_import
   > # emulate aborting before "recordupdates()". in this case, files
   > # are changed without updating dirstate
   > from mercurial import (
   >   error,
   >   extensions,
   >   merge,
   > )
   > def applyupdates(orig, *args, **kwargs):
   >     orig(*args, **kwargs)
   >     raise error.Abort(b'intentional aborting')
   > def extsetup(ui):
   >     extensions.wrapfunction(merge, "applyupdates", applyupdates)
   > EOF
 
-  $ cat >> .hg/hgrc <<EOF
-  > [fakedirstatewritetime]
-  > # emulate invoking dirstate.write() via repo.status()
-  > # at 2000-01-01 00:00
-  > fakenow = 200001010000
-  > EOF
-
 (file gotten from other revision)
 
   $ hg update -q -C 2
   $ echo 'THIS IS FILE B5' > b
   $ hg commit -m 'commit #5'
 
   $ hg update -q -C 3
   $ cat b
   This is file b1
-  $ touch -t 200001010000 b
-  $ hg debugrebuildstate
-
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
-  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
   > abort = $TESTTMP/abort.py
   > EOF
   $ hg merge 5
   abort: intentional aborting
   [255]
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
-  > fakedirstatewritetime = !
   > abort = !
   > EOF
 
   $ cat b
   THIS IS FILE B5
-  $ touch -t 200001010000 b
   $ hg status -A b
   M b
 
 (file merged from other revision)
 
   $ hg update -q -C 3
   $ echo 'this is file b6' > b
   $ hg commit -m 'commit #6'
   created new head
 
   $ cat b
   this is file b6
-  $ touch -t 200001010000 b
-  $ hg debugrebuildstate
+  $ hg status
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
-  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
   > abort = $TESTTMP/abort.py
   > EOF
   $ hg merge --tool internal:other 5
   abort: intentional aborting
   [255]
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
-  > fakedirstatewritetime = !
   > abort = !
   > EOF
 
   $ cat b
   THIS IS FILE B5
-  $ touch -t 200001010000 b
   $ hg status -A b
   M b
 
   $ cd ..

tests/test-subrepo.t

@@ -1,2035 +1,2019 b''
 Let commit recurse into subrepos by default to match pre-2.0 behavior:
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
 
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first sub
 
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ echo a > s/a
 
 Issue2232: committing a subrepo without .hgsub
 
   $ hg ci -mbad s
   abort: can't commit subrepos without .hgsub
   [255]
 
   $ hg -R s add s/a
   $ hg files -S
   .hgsub
   a
   s/a
 
 `hg files` respects ui.relative-paths
 BROKEN: shows subrepo paths relative to the subrepo
   $ hg files -S --config ui.relative-paths=no
   .hgsub
   a
   s/a
 
   $ hg -R s ci -Ams0
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   phases: 1 draft
   $ hg ci -m1
 
 test handling .hgsubstate "added" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg add .hgsubstate
   $ hg ci -m1
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
 
 Subrepopath which overlaps with filepath, does not change warnings in remove()
 
   $ mkdir snot
   $ touch snot/file
   $ hg remove -S snot/file
   not removing snot/file: file is untracked
   [1]
   $ hg cat snot/filenot
   snot/filenot: no such file in rev 7cf8cfea66e4
   [1]
   $ rm -r snot
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert --dry-run "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a
   $ cat s/a
   b
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a
   $ cat s/a
   a
   $ rm s/a.orig
 
 Revert subrepo with no backup. The "reverting s/a" line is gone since
 we're really running 'hg update' in the subrepo:
 
   $ echo b > s/a
   $ hg revert --no-backup s
   reverting subrepo s
 
 Issue2022: update -C
 
   $ echo b > s/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
 commands that require a clean repo should respect subrepos
 
   $ echo b >> s/a
   $ hg backout tip
   abort: uncommitted changes in subrepository "s"
   [255]
   $ hg revert -C -R s s/a
 
 add sub sub
 
   $ echo ss = ss > s/.hgsub
   $ hg init s/ss
   $ echo a > s/ss/a
   $ hg -R s add s/.hgsub
   $ hg -R s/ss add s/ss/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg ci -m2
   committing subrepository s
   committing subrepository s/ss
   $ hg sum
   parent: 2:df30734270ae tip
    2
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 test handling .hgsubstate "modified" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
   $ hg rollback -q
   $ hg status -A .hgsubstate
   M .hgsubstate
   $ hg ci -m2
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
 
 bump sub rev (and check it is ignored by ui.commitsubrepos)
 
   $ echo b > s/a
   $ hg -R s ci -ms1
   $ hg --config ui.commitsubrepos=no ci -m3
 
 leave sub dirty (and check ui.commitsubrepos=no aborts the commit)
 
   $ echo c > s/a
   $ hg --config ui.commitsubrepos=no ci -m4
   abort: uncommitted changes in subrepository "s"
   (use --subrepos for recursive commit)
   [255]
   $ hg id
   f6affe3fbfaa+ tip
   $ hg -R s ci -mc
   $ hg id
   f6affe3fbfaa+ tip
   $ echo d > s/a
   $ hg ci -m4
   committing subrepository s
   $ hg tip -R s
   changeset:   4:02dcf1d70411
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
 
 check caching
 
   $ hg co 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg debugsub
 
 restore
 
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   s
    revision 02dcf1d704118aee3ee306ccfa1910850d5b05ef
 
 new branch for merge tests
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo t = t >> .hgsub
   $ hg init t
   $ echo t > t/t
   $ hg -R t add t
   adding t/t
 
 5
 
   $ hg ci -m5 # add sub
   committing subrepository t
   created new head
   $ echo t2 > t/t
 
 6
 
   $ hg st -R s
   $ hg ci -m6 # change sub
   committing subrepository t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo t3 > t/t
 
 7
 
   $ hg ci -m7 # change sub again for conflict test
   committing subrepository t
   $ hg rm .hgsub
 
 8
 
   $ hg ci -m8 # remove sub
 
 test handling .hgsubstate "removed" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg remove .hgsubstate
   $ hg ci -m8
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
 
 merge tests
 
   $ hg co -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 5 # test adding
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
   $ hg ci -m9
   created new head
   $ hg merge 6 --debug # test change
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1f14a2e2d3ec, local: f0d2028bf86d+, remote: 1831e14459c4
   starting 4 threads for background file closing (?)
    .hgsubstate: versions differ -> m (premerge)
   subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
     subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
   getting subrepo t
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 60ca1237c194, local: 60ca1237c194+, remote: 6747d179aa9a
    t: remote is newer -> g
   getting t
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo conflict > t/t
   $ hg ci -m10
   committing subrepository t
   $ HGMERGE=internal:merge hg merge --debug 7 # test conflict
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1831e14459c4, local: e45c8b14af55+, remote: f94576341bcf
   starting 4 threads for background file closing (?)
    .hgsubstate: versions differ -> m (premerge)
   subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
     subrepo t: both sides changed 
    subrepository t diverged (local revision: 20a0db6fbf6c, remote revision: 7af322bc1198)
   starting 4 threads for background file closing (?)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [merge rev].
   what do you want to do? m
   merging subrepository "t"
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 6747d179aa9a, local: 20a0db6fbf6c+, remote: 7af322bc1198
   starting 4 threads for background file closing (?)
    preserving t for resolve of t
    t: versions differ -> m (premerge)
   picked tool ':merge' for t (binary False symlink False changedelete False)
   merging t
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
    t: versions differ -> m (merge)
   picked tool ':merge' for t (binary False symlink False changedelete False)
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
   warning: conflicts while merging t! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
     subrepo t: merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should conflict
 
   $ cat t/t
   <<<<<<< local: 20a0db6fbf6c - test: 10
   conflict
   =======
   t3
   >>>>>>> other: 7af322bc1198 - test: 7
 
 11: remove subrepo t
 
   $ hg co -C 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert -r 4 .hgsub # remove t
   $ hg ci -m11
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 
 local removed, remote changed, keep changed
 
   $ hg merge 6
    remote [merge rev] changed subrepository t which local [working copy] removed
   use (c)hanged version or (d)elete? c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   6747d179aa9a688023c4b0cad32e4c92bb7f34ad t
   $ hg ci -m 'local removed, remote changed, keep changed'
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local removed, remote changed, keep removed
 
   $ hg co -C 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 6 <<EOF
   > d
   > EOF
    remote [merge rev] changed subrepository t which local [working copy] removed
   use (c)hanged version or (d)elete? d
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local removed, remote changed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 local changed, remote removed, keep changed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 11
    local [working copy] changed subrepository t which remote [merge rev] removed
   use (c)hanged version or (d)elete? c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep changed'
   created new head
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local changed, remote removed, keep removed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 11 <<EOF
   > d
   > EOF
    local [working copy] changed subrepository t which remote [merge rev] removed
   use (c)hanged version or (d)elete? d
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 clean up to avoid having to fix up the tests below
 
   $ hg co -C 10
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > strip=
   > EOF
   $ hg strip -r 11:15
   saved backup bundle to $TESTTMP/t/.hg/strip-backup/*-backup.hg (glob)
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   cloning subrepo s from $TESTTMP/t/s
   cloning subrepo s/ss from $TESTTMP/t/s/ss
   cloning subrepo t from $TESTTMP/t/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
   $ cd ..
 
 clone with subrepo disabled (update should fail)
 
   $ hg clone t -U tc2 --config subrepos.allowed=false
   $ hg update -R tc2 --config subrepos.allowed=false
   abort: subrepos not enabled
   (see 'hg help config.subrepos' for details)
   [255]
   $ ls -A tc2
   .hg
   .hgsub
   .hgsubstate
   a
 
   $ hg clone t tc3 --config subrepos.allowed=false
   updating to branch default
   abort: subrepos not enabled
   (see 'hg help config.subrepos' for details)
   [255]
   $ ls -A tc3
   .hg
   .hgsub
   .hgsubstate
   a
 
 And again with just the hg type disabled
 
   $ hg clone t -U tc4 --config subrepos.hg:allowed=false
   $ hg update -R tc4 --config subrepos.hg:allowed=false
   abort: hg subrepos not allowed
   (see 'hg help config.subrepos' for details)
   [255]
   $ ls -A tc4
   .hg
   .hgsub
   .hgsubstate
   a
 
   $ hg clone t tc5 --config subrepos.hg:allowed=false
   updating to branch default
   abort: hg subrepos not allowed
   (see 'hg help config.subrepos' for details)
   [255]
   $ ls -A tc5
   .hg
   .hgsub
   .hgsubstate
   a
 
 push
 
   $ cd tc
   $ echo bah > t/t
   $ hg ci -m11
   committing subrepository t
   $ hg push
   pushing to $TESTTMP/t
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
   no changes made to subrepo s since last push to $TESTTMP/t/s
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 push -f
 
   $ echo bah > s/a
   $ hg ci -m12
   committing subrepository s
   $ hg push
   pushing to $TESTTMP/t
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   abort: push creates new remote head 12a213df6fa9 (in subrepository "s")
   (merge or see 'hg help push' for details about pushing new heads)
   [255]
   $ hg push -f
   pushing to $TESTTMP/t
   pushing subrepo s/ss to $TESTTMP/t/s/ss
   searching for changes
   no changes found
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 check that unmodified subrepos are not pushed
 
   $ hg clone . ../tcc
   updating to branch default
   cloning subrepo s from $TESTTMP/tc/s
   cloning subrepo s/ss from $TESTTMP/tc/s/ss
   cloning subrepo t from $TESTTMP/tc/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 the subrepos on the new clone have nothing to push to its source
 
   $ hg push -R ../tcc .
   pushing to .
   no changes made to subrepo s/ss since last push to s/ss
   no changes made to subrepo s since last push to s
   no changes made to subrepo t since last push to t
   searching for changes
   no changes found
   [1]
 
 the subrepos on the source do not have a clean store versus the clone target
 because they were never explicitly pushed to the source
 
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss
   searching for changes
   no changes found
   pushing subrepo s to ../tcc/s
   searching for changes
   no changes found
   pushing subrepo t to ../tcc/t
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 
 after push their stores become clean
 
   $ hg push ../tcc
   pushing to ../tcc
   no changes made to subrepo s/ss since last push to ../tcc/s/ss
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 updating a subrepo to a different revision or changing
 its working directory does not make its store dirty
 
   $ hg -R s update '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg push
   pushing to $TESTTMP/t
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ echo foo >> s/a
   $ hg push
   pushing to $TESTTMP/t
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg -R s update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 committing into a subrepo makes its store (but not its parent's store) dirty
 
   $ echo foo >> s/ss/a
   $ hg -R s/ss commit -m 'test dirty store detection'
 
   $ hg out -S -r `hg log -r tip -T "{node|short}"`
   comparing with $TESTTMP/t
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s/ss
   searching for changes
   changeset:   1:79ea5566a333
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test dirty store detection
   
   comparing with $TESTTMP/t/t
   searching for changes
   no changes found
 
   $ hg push
   pushing to $TESTTMP/t
   pushing subrepo s/ss to $TESTTMP/t/s/ss
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
 
 a subrepo store may be clean versus one repo but not versus another
 
   $ hg push
   pushing to $TESTTMP/t
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 update
 
   $ cd ../t
   $ hg up -C # discard our earlier merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "c373c8102e68: 12"
   2 other heads for branch "default"
   $ echo blah > t/t
   $ hg ci -m13
   committing subrepository t
 
 backout calls revert internally with minimal opts, which should not raise
 KeyError
 
   $ hg backout ".^" --no-commit
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   changeset c373c8102e68 backed out, don't forget to commit.
 
   $ hg up -C # discard changes
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "925c17564ef8: 13"
   2 other heads for branch "default"
 
 pull
 
   $ cd ../tc
   $ hg pull
   pulling from $TESTTMP/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 925c17564ef8
   (run 'hg update' to get a working copy)
 
 should pull t
 
   $ hg incoming -S -r `hg log -r tip -T "{node|short}"`
   comparing with $TESTTMP/t
   no changes found
   comparing with $TESTTMP/t/s
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s/ss
   searching for changes
   no changes found
   comparing with $TESTTMP/t/t
   searching for changes
   changeset:   5:52c0adc0515a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     13
   
 
   $ hg up
   pulling subrepo t from $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 52c0adc0515a
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "925c17564ef8: 13"
   2 other heads for branch "default"
   $ cat t/t
   blah
 
 bogus subrepo path aborts
 
   $ echo 'bogus=[boguspath' >> .hgsub
   $ hg ci -m 'bogus subrepo path'
   abort: missing ] in subrepository source
   [255]
 
 Issue1986: merge aborts when trying to merge a subrepo that
 shouldn't need merging
 
 # subrepo layout
 #
 #   o   5 br
 #  /|
 # o |   4 default
 # | |
 # | o   3 br
 # |/|
 # o |   2 default
 # | |
 # | o   1 br
 # |/
 # o     0 default
 
   $ cd ..
   $ rm -rf sub
   $ hg init main
   $ cd main
   $ hg init s
   $ cd s
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m1
   $ hg up default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg up br
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
 
 # main repo layout:
 #
 #   * <-- try to merge default into br again
 # .`|
 # . o   5 br      --> substate = 5
 # . |
 # o |   4 default --> substate = 4
 # | |
 # | o   3 br      --> substate = 2
 # |/|
 # o |   2 default --> substate = 2
 # | |
 # | o   1 br      --> substate = 3
 # |/
 # o     0 default --> substate = 2
 
   $ cd ..
   $ echo 's = s' > .hgsub
   $ hg -R s up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci -Am1
   adding .hgsub
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg -R s up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg ci -Am1
   adding b
   $ hg up default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Am1
   adding d
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e > e
   $ hg ci -Am1
   adding e
 
   $ hg up 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4    # try to merge default into br again
    subrepository s diverged (local revision: f8f13b33206e, remote revision: a3f9062a4f88)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [merge rev].
   what do you want to do? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 test subrepo delete from .hgsubstate
 
   $ hg init testdelete
   $ mkdir testdelete/nested testdelete/nested2
   $ hg init testdelete/nested
   $ hg init testdelete/nested2
   $ echo test > testdelete/nested/foo
   $ echo test > testdelete/nested2/foo
   $ hg -R testdelete/nested add
   adding testdelete/nested/foo
   $ hg -R testdelete/nested2 add
   adding testdelete/nested2/foo
   $ hg -R testdelete/nested ci -m test
   $ hg -R testdelete/nested2 ci -m test
   $ echo nested = nested > testdelete/.hgsub
   $ echo nested2 = nested2 >> testdelete/.hgsub
   $ hg -R testdelete add
   adding testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 1 & 2 added"
   $ echo nested = nested > testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 2 deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
   $ hg -R testdelete remove testdelete/.hgsub
   $ hg -R testdelete ci -m ".hgsub deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
 
 test repository cloning
 
   $ mkdir mercurial mercurial2
   $ hg init nested_absolute
   $ echo test > nested_absolute/foo
   $ hg -R nested_absolute add
   adding nested_absolute/foo
   $ hg -R nested_absolute ci -mtest
   $ cd mercurial
   $ hg init nested_relative
   $ echo test2 > nested_relative/foo2
   $ hg -R nested_relative add
   adding nested_relative/foo2
   $ hg -R nested_relative ci -mtest2
   $ hg init main
   $ echo "nested_relative = ../nested_relative" > main/.hgsub
   $ echo "nested_absolute = `pwd`/nested_absolute" >> main/.hgsub
   $ hg -R main add
   adding main/.hgsub
   $ hg -R main ci -m "add subrepos"
   $ cd ..
   $ hg clone mercurial/main mercurial2/main
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat mercurial2/main/nested_absolute/.hg/hgrc \
   >     mercurial2/main/nested_relative/.hg/hgrc
   [paths]
   default = $TESTTMP/mercurial/nested_absolute
   [paths]
   default = $TESTTMP/mercurial/nested_relative
   $ rm -rf mercurial mercurial2
 
 Issue1977: multirepo push should fail if subrepo push fails
 
   $ hg init repo
   $ hg init repo/s
   $ echo a > repo/s/a
   $ hg -R repo/s ci -Am0
   adding a
   $ echo s = s > repo/.hgsub
   $ hg -R repo ci -Am1
   adding .hgsub
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo s from $TESTTMP/repo/s
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -q -R repo2 pull -u
   $ echo 1 > repo2/s/a
   $ hg -R repo2/s ci -m2
   $ hg -q -R repo2/s push
   $ hg -R repo2/s up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > repo2/s/b
   $ hg -R repo2/s ci -m3 -A
   adding b
   created new head
   $ hg -R repo2 ci -m3
   $ hg -q -R repo2 push
   abort: push creates new remote head cc505f09a8b2 (in subrepository "s")
   (merge or see 'hg help push' for details about pushing new heads)
   [255]
   $ hg -R repo update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test if untracked file is not overwritten
 
-(this also tests that updated .hgsubstate is treated as "modified",
-when 'merge.update()' is aborted before 'merge.recordupdates()', even
-if none of mode, size and timestamp of it isn't changed on the
-filesystem (see also issue4583))
+(this tests also has a change to update .hgsubstate and merge it within the
+same second. It should mark is are modified , even if none of mode, size and
+timestamp of it isn't changed on the filesystem (see also issue4583))
 
   $ echo issue3276_ok > repo/s/b
   $ hg -R repo2 push -f -q
-  $ touch -t 200001010000 repo/.hgsubstate
 
-  $ cat >> repo/.hg/hgrc <<EOF
-  > [fakedirstatewritetime]
-  > # emulate invoking dirstate.write() via repo.status()
-  > # at 2000-01-01 00:00
-  > fakenow = 200001010000
-  > 
-  > [extensions]
-  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
-  > EOF
   $ hg -R repo update
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision (in subrepository "s")
   [255]
-  $ cat >> repo/.hg/hgrc <<EOF
-  > [extensions]
-  > fakedirstatewritetime = !
-  > EOF
 
   $ cat repo/s/b
   issue3276_ok
   $ rm repo/s/b
-  $ touch -t 200001010000 repo/.hgsubstate
   $ hg -R repo revert --all
   reverting repo/.hgsubstate
   reverting subrepo s
   $ hg -R repo update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat repo/s/b
   2
   $ rm -rf repo2 repo
 
 
 Issue1852 subrepos with relative paths always push/pull relative to default
 
 Prepare a repo with subrepo
 
   $ hg init issue1852a
   $ cd issue1852a
   $ hg init sub/repo
   $ echo test > sub/repo/foo
   $ hg -R sub/repo add sub/repo/foo
   $ echo sub/repo = sub/repo > .hgsub
   $ hg add .hgsub
   $ hg ci -mtest
   committing subrepository sub/repo
   $ echo test >> sub/repo/foo
   $ hg ci -mtest
   committing subrepository sub/repo
   $ hg cat sub/repo/foo
   test
   test
   $ hg cat sub/repo/foo -Tjson | sed 's|\\\\|/|g'
   [
    {
     "data": "test\ntest\n",
     "path": "foo"
    }
   ]
 
  non-exact match:
 
   $ hg cat -T '{path|relpath}\n' 'glob:**'
   .hgsub
   .hgsubstate
   sub/repo/foo
   $ hg cat -T '{path|relpath}\n' 're:^sub'
   sub/repo/foo
 
  missing subrepos in working directory:
 
   $ mkdir -p tmp/sub/repo
   $ hg cat -r 0 --output tmp/%p_p sub/repo/foo
   $ cat tmp/sub/repo/foo_p
   test
   $ mv sub/repo sub_
   $ hg cat sub/repo/baz
   skipping missing subrepository: sub/repo
   [1]
   $ rm -rf sub/repo
   $ mv sub_ sub/repo
   $ cd ..
 
 Create repo without default path, pull top repo, and see what happens on update
 
   $ hg init issue1852b
   $ hg -R issue1852b pull issue1852a
   pulling from issue1852a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   new changesets 19487b456929:be5eb94e7215
   (run 'hg update' to get a working copy)
   $ hg -R issue1852b update
   abort: default path for subrepository not found (in subrepository "sub/repo")
   [255]
 
 Ensure a full traceback, not just the SubrepoAbort part
 
   $ hg -R issue1852b update --traceback 2>&1 | grep 'raise error\.Abort'
       raise error.Abort(_(b"default path for subrepository not found"))
 
 Pull -u now doesn't help
 
   $ hg -R issue1852b pull -u issue1852a
   pulling from issue1852a
   searching for changes
   no changes found
 
 Try the same, but with pull -u
 
   $ hg init issue1852c
   $ hg -R issue1852c pull -r0 -u issue1852a
   pulling from issue1852a
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 19487b456929
   cloning subrepo sub/repo from issue1852a/sub/repo
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try to push from the other side
 
   $ hg -R issue1852a push `pwd`/issue1852c
   pushing to $TESTTMP/issue1852c
   pushing subrepo sub/repo to $TESTTMP/issue1852c/sub/repo
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incoming and outgoing should not use the default path:
 
   $ hg clone -q issue1852a issue1852d
   $ hg -R issue1852d outgoing --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
   $ hg -R issue1852d incoming --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
 
 Check that merge of a new subrepo doesn't write the uncommitted state to
 .hgsubstate (issue4622)
 
   $ hg init issue1852a/addedsub
   $ echo zzz > issue1852a/addedsub/zz.txt
   $ hg -R issue1852a/addedsub ci -Aqm "initial ZZ"
 
   $ hg clone issue1852a/addedsub issue1852d/addedsub
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo def > issue1852a/sub/repo/foo
   $ hg -R issue1852a ci -SAm 'tweaked subrepo'
   adding tmp/sub/repo/foo_p
   committing subrepository sub/repo
 
   $ echo 'addedsub = addedsub' >> issue1852d/.hgsub
   $ echo xyz > issue1852d/sub/repo/foo
   $ hg -R issue1852d pull -u
   pulling from $TESTTMP/issue1852a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets c82b79fdcc5b
    subrepository sub/repo diverged (local revision: f42d5c7504a8, remote revision: 46cd4aac504c)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
   pulling subrepo sub/repo from $TESTTMP/issue1852a/sub/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 46cd4aac504c
    subrepository sources for sub/repo differ
   you can use (l)ocal source (f42d5c7504a8) or (r)emote source (46cd4aac504c).
   what do you want to do? l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat issue1852d/.hgsubstate
   f42d5c7504a811dda50f5cf3e5e16c3330b87172 sub/repo
 
 Check status of files when none of them belong to the first
 subrepository:
 
   $ hg init subrepo-status
   $ cd subrepo-status
   $ hg init subrepo-1
   $ hg init subrepo-2
   $ cd subrepo-2
   $ touch file
   $ hg add file
   $ cd ..
   $ echo subrepo-1 = subrepo-1 > .hgsub
   $ echo subrepo-2 = subrepo-2 >> .hgsub
   $ hg add .hgsub
   $ hg ci -m 'Added subrepos'
   committing subrepository subrepo-2
   $ hg st subrepo-2/file
 
 Check that share works with subrepo
   $ hg --config extensions.share= share . ../shared
   updating working directory
   sharing subrepo subrepo-1 from $TESTTMP/subrepo-status/subrepo-1
   sharing subrepo subrepo-2 from $TESTTMP/subrepo-status/subrepo-2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find ../shared/* | sort
   ../shared/subrepo-1
   ../shared/subrepo-1/.hg
   ../shared/subrepo-1/.hg/cache
   ../shared/subrepo-1/.hg/cache/storehash
   ../shared/subrepo-1/.hg/cache/storehash/* (glob)
   ../shared/subrepo-1/.hg/hgrc
   ../shared/subrepo-1/.hg/requires
   ../shared/subrepo-1/.hg/sharedpath
   ../shared/subrepo-1/.hg/wcache
   ../shared/subrepo-2
   ../shared/subrepo-2/.hg
   ../shared/subrepo-2/.hg/branch
   ../shared/subrepo-2/.hg/cache
   ../shared/subrepo-2/.hg/cache/storehash
   ../shared/subrepo-2/.hg/cache/storehash/* (glob)
   ../shared/subrepo-2/.hg/dirstate
   ../shared/subrepo-2/.hg/hgrc
   ../shared/subrepo-2/.hg/requires
   ../shared/subrepo-2/.hg/sharedpath
   ../shared/subrepo-2/.hg/wcache
   ../shared/subrepo-2/.hg/wcache/checkisexec (execbit !)
   ../shared/subrepo-2/.hg/wcache/checklink (symlink no-rust !)
   ../shared/subrepo-2/.hg/wcache/checklink-target (symlink no-rust !)
   ../shared/subrepo-2/.hg/wcache/manifestfulltextcache (reporevlogstore !)
   ../shared/subrepo-2/file
   $ hg -R ../shared in
   abort: repository default not found
   [255]
   $ hg -R ../shared/subrepo-2 showconfig paths
   paths.default=$TESTTMP/subrepo-status/subrepo-2
   $ hg -R ../shared/subrepo-1 sum --remote
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   remote: (synced)
 
 Check hg update --clean
   $ cd $TESTTMP/t
   $ rm -r t/t.orig
   $ hg status -S --all
   C .hgsub
   C .hgsubstate
   C a
   C s/.hgsub
   C s/.hgsubstate
   C s/a
   C s/ss/a
   C t/t
   $ echo c1 > s/a
   $ cd s
   $ echo c1 > b
   $ echo c1 > c
   $ hg add b
   $ cd ..
   $ hg status -S
   M s/a
   A s/b
   ? s/c
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "925c17564ef8: 13"
   2 other heads for branch "default"
   $ hg status -S
   ? s/b
   ? s/c
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/t
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ hg update 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   365661e5936a
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Sticky subrepositories, file changes
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   365661e5936a+
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update tip
    subrepository s diverged (local revision: fc627a69481f, remote revision: 12a213df6fa9)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository sources for s differ
   you can use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9).
   what do you want to do? l
    subrepository t diverged (local revision: e95bcfa18a35, remote revision: 52c0adc0515a)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository sources for t differ
   you can use (l)ocal source (e95bcfa18a35) or (r)emote source (52c0adc0515a).
   what do you want to do? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ cd s
   $ hg update -r -2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../t
   $ hg update -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 10
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 20a0db6fbf6c)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository sources for t differ (in checked out version)
   you can use (l)ocal source (7af322bc1198) or (r)emote source (20a0db6fbf6c).
   what do you want to do? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411
   $ hg -R t id
   7af322bc1198
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
   $ hg update tip
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: 12a213df6fa9)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository sources for s differ
   you can use (l)ocal source (02dcf1d70411) or (r)emote source (12a213df6fa9).
   what do you want to do? l
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 52c0adc0515a)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
    subrepository sources for t differ
   you can use (l)ocal source (7af322bc1198) or (r)emote source (52c0adc0515a).
   what do you want to do? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
 
 Sticky repository, update --clean
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
 
 Test subrepo already at intended revision:
   $ cd s
   $ hg update fc627a69481f
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 11
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   you can (m)erge, keep (l)ocal [working copy] or keep (r)emote [destination].
   what do you want to do? m
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   11+
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Test that removing .hgsubstate doesn't break anything:
 
   $ hg rm -f .hgsubstate
   $ hg ci -mrm
   nothing changed
   [1]
   $ hg log -vr tip
   changeset:   13:925c17564ef8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsubstate
   description:
   13
   
   
 
 Test that removing .hgsub removes .hgsubstate:
 
   $ hg rm .hgsub
   $ hg ci -mrm2
   created new head
   $ hg log -vr tip
   changeset:   14:2400bccd50af
   tag:         tip
   parent:      11:365661e5936a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsub .hgsubstate
   description:
   rm2
   
   
 Test issue3153: diff -S with deleted subrepos
 
   $ hg diff --nodates -S -c .
   diff -r 365661e5936a -r 2400bccd50af .hgsub
   --- a/.hgsub
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -s = s
   -t = t
   diff -r 365661e5936a -r 2400bccd50af .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   -e95bcfa18a358dc4936da981ebf4147b4cad1362 t
 
 Test behavior of add for explicit path in subrepo:
   $ cd ..
   $ hg init explicit
   $ cd explicit
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ hg ci -m0
 Adding with an explicit path in a subrepo adds the file
   $ echo c1 > f1
   $ echo c2 > s/f2
   $ hg st -S
   ? f1
   ? s/f2
   $ hg add s/f2
   $ hg st -S
   A s/f2
   ? f1
   $ hg ci -R s -m0
   $ hg ci -Am1
   adding f1
 Adding with an explicit path in a subrepo with -S has the same behavior
   $ echo c3 > f3
   $ echo c4 > s/f4
   $ hg st -S
   ? f3
   ? s/f4
   $ hg add -S s/f4
   $ hg st -S
   A s/f4
   ? f3
   $ hg ci -R s -m1
   $ hg ci -Ama2
   adding f3
 Adding without a path or pattern silently ignores subrepos
   $ echo c5 > f5
   $ echo c6 > s/f6
   $ echo c7 > s/f7
   $ hg st -S
   ? f5
   ? s/f6
   ? s/f7
   $ hg add
   adding f5
   $ hg st -S
   A f5
   ? s/f6
   ? s/f7
   $ hg ci -R s -Am2
   adding f6
   adding f7
   $ hg ci -m3
 Adding without a path or pattern with -S also adds files in subrepos
   $ echo c8 > f8
   $ echo c9 > s/f9
   $ echo c10 > s/f10
   $ hg st -S
   ? f8
   ? s/f10
   ? s/f9
   $ hg add -S
   adding f8
   adding s/f10
   adding s/f9
   $ hg st -S
   A f8
   A s/f10
   A s/f9
   $ hg ci -R s -m3
   $ hg ci -m4
 Adding with a pattern silently ignores subrepos
   $ echo c11 > fm11
   $ echo c12 > fn12
   $ echo c13 > s/fm13
   $ echo c14 > s/fn14
   $ hg st -S
   ? fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg add 'glob:**fm*'
   adding fm11
   $ hg st -S
   A fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg ci -R s -Am4
   adding fm13
   adding fn14
   $ hg ci -Am5
   adding fn12
 Adding with a pattern with -S also adds matches in subrepos
   $ echo c15 > fm15
   $ echo c16 > fn16
   $ echo c17 > s/fm17
   $ echo c18 > s/fn18
   $ hg st -S
   ? fm15
   ? fn16
   ? s/fm17
   ? s/fn18
   $ hg add -S 'glob:**fm*'
   adding fm15
   adding s/fm17
   $ hg st -S
   A fm15
   A s/fm17
   ? fn16
   ? s/fn18
   $ hg ci -R s -Am5
   adding fn18
   $ hg ci -Am6
   adding fn16
 
 Test behavior of forget for explicit path in subrepo:
 Forgetting an explicit path in a subrepo untracks the file
   $ echo c19 > s/f19
   $ hg add s/f19
   $ hg st -S
   A s/f19
   $ hg forget s/f19
   $ hg st -S
   ? s/f19
   $ rm s/f19
   $ cd ..
 
 Courtesy phases synchronisation to publishing server does not block the push
 (issue3781)
 
   $ cp -R main issue3781
   $ cp -R main issue3781-dest
   $ cd issue3781-dest/s
   $ hg phase tip # show we have draft changeset
   5: draft
   $ chmod a-w .hg/store/phaseroots # prevent phase push
   $ cd ../../issue3781
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default=../issue3781-dest/
   > EOF
   $ hg push --config devel.legacy.exchange=bundle1
   pushing to $TESTTMP/issue3781-dest
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 # clean the push cache
   $ rm s/.hg/cache/storehash/*
   $ hg push # bundle2+
   pushing to $TESTTMP/issue3781-dest
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 Test phase choice for newly created commit with "phases.subrepochecks"
 configuration
 
   $ cd t
   $ hg update -q -r 12
 
   $ cat >> s/ss/.hg/hgrc <<EOF
   > [phases]
   > new-commit = secret
   > EOF
   $ cat >> s/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ echo phasecheck1 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=abort -m phasecheck1
   committing subrepository ss
   transaction abort!
   rollback completed
   abort: can't commit in draft phase conflicting secret from subrepository ss
   [255]
   $ echo phasecheck2 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=ignore -m phasecheck2
   committing subrepository ss
   $ hg -R s/ss phase tip
   3: secret
   $ hg -R s phase tip
   6: draft
   $ echo phasecheck3 >> s/ss/a
   $ hg -R s commit -S -m phasecheck3
   committing subrepository ss
   warning: changes are committed in secret phase from subrepository ss
   $ hg -R s/ss phase tip
   4: secret
   $ hg -R s phase tip
   7: secret
 
   $ cat >> t/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > new-commit = public
   > EOF
   $ echo phasecheck4 >>   s/ss/a
   $ echo phasecheck4 >>   t/t
   $ hg commit -S -m phasecheck4
   committing subrepository s
   committing subrepository s/ss
   warning: changes are committed in secret phase from subrepository ss
   committing subrepository t
   warning: changes are committed in secret phase from subrepository s
   created new head
   $ hg -R s/ss phase tip
   5: secret
   $ hg -R s phase tip
   8: secret
   $ hg -R t phase tip
   6: draft
   $ hg phase tip
   15: secret
 
   $ cd ..
 
 
 Test that commit --secret works on both repo and subrepo (issue4182)
 
   $ cd main
   $ echo secret >> b
   $ echo secret >> s/b
   $ hg commit --secret --subrepo -m "secret"
   committing subrepository s
   $ hg phase -r .
   6: secret
   $ cd s
   $ hg phase -r .
   6: secret
   $ cd ../../
 
 Test "subrepos" template keyword
 
   $ cd t
   $ hg update -q 15
   $ cat > .hgsub <<EOF
   > s = s
   > EOF
   $ hg commit -m "16"
   warning: changes are committed in secret phase from subrepository s
 
 (addition of ".hgsub" itself)
 
   $ hg diff --nodates -c 1 .hgsubstate
   diff -r f7b1eb17ad24 -r 7cf8cfea66e4 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg log -r 1 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f7b1eb17ad24 000000000000
   s
 
 (modification of existing entry)
 
   $ hg diff --nodates -c 2 .hgsubstate
   diff -r 7cf8cfea66e4 -r df30734270ae .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +dc73e2e6d2675eb2e41e33c205f4bdab4ea5111d s
   $ hg log -r 2 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   s
 
 (addition of entry)
 
   $ hg diff --nodates -c 5 .hgsubstate
   diff -r 7cf8cfea66e4 -r 1f14a2e2d3ec .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 5 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   t
 
 (removal of existing entry)
 
   $ hg diff --nodates -c 16 .hgsubstate
   diff -r 8bec38d2bd0b -r f2f70bc3d3c9 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,2 +1,1 @@
    0731af8ca9423976d3743119d0865097c07bdc1b s
   -e202dc79b04c88a636ea8913d9182a1346d9b3dc t
   $ hg log -r 16 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   8bec38d2bd0b 000000000000
   t
 
 (merging)
 
   $ hg diff --nodates -c 9 .hgsubstate
   diff -r f6affe3fbfaa -r f0d2028bf86d .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 9 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f6affe3fbfaa 1f14a2e2d3ec
   t
 
 (removal of ".hgsub" itself)
 
   $ hg diff --nodates -c 8 .hgsubstate
   diff -r f94576341bcf -r 96615c1dad2d .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   -7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4 t
   $ hg log -r 8 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f94576341bcf 000000000000
 
 Test that '[paths]' is configured correctly at subrepo creation
 
   $ cd $TESTTMP/tc
   $ cat > .hgsub <<EOF
   > # to clear bogus subrepo path 'bogus=[boguspath'
   > s = s
   > t = t
   > EOF
   $ hg update -q --clean null
   $ rm -rf s t
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > default-push = /foo/bar
   > EOF
   $ hg update -q
   $ cat s/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s
   default-push = /foo/bar/s
   $ cat s/ss/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s/ss
   default-push = /foo/bar/s/ss
   $ cat t/.hg/hgrc
   [paths]
   default = $TESTTMP/t/t
   default-push = /foo/bar/t
 
   $ cd $TESTTMP/t
   $ hg up -qC 0
   $ echo 'bar' > bar.txt
   $ hg ci -Am 'branch before subrepo add'
   adding bar.txt
   created new head
   $ hg merge -r "first(subrepo('s'))"
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status -S -X '.hgsub*'
   A s/a
   ? s/b
   ? s/c
   ? s/f1
   $ hg status -S --rev 'p2()'
   A bar.txt
   ? s/b
   ? s/c
   ? s/f1
   $ hg diff -S -X '.hgsub*' --nodates
   diff -r 000000000000 s/a
   --- /dev/null
   +++ b/s/a
   @@ -0,0 +1,1 @@
   +a
   $ hg diff -S --rev 'p2()' --nodates
   diff -r 7cf8cfea66e4 bar.txt
   --- /dev/null
   +++ b/bar.txt
   @@ -0,0 +1,1 @@
   +bar
 
   $ hg diff -X '.hgsub*' --nodates s
   diff -r 000000000000 s/a
   --- /dev/null
   +++ b/s/a
   @@ -0,0 +1,1 @@
   +a
   $ hg diff -X '.hgsub*' --nodates s/a
   diff -r 000000000000 s/a
   --- /dev/null
   +++ b/s/a
   @@ -0,0 +1,1 @@
   +a
 
   $ cd ..
 
 test for ssh exploit 2017-07-25
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ssh = sh -c "read l; read l; read l"
   > EOF
 
   $ hg init malicious-proxycommand
   $ cd malicious-proxycommand
   $ echo 's = [hg]ssh://-oProxyCommand=touch${IFS}owned/path' > .hgsub
   $ hg init s
   $ cd s
   $ echo init > init
   $ hg add
   adding init
   $ hg commit -m init
   $ cd ..
   $ hg add .hgsub
   $ hg ci -m 'add subrepo'
   $ cd ..
   $ hg clone malicious-proxycommand malicious-proxycommand-clone
   updating to branch default
   cloning subrepo s from ssh://-oProxyCommand%3Dtouch%24%7BIFS%7Downed/path
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path' (in subrepository "s")
   [255]
 
 also check that a percent encoded '-' (%2D) doesn't work
 
   $ cd malicious-proxycommand
   $ echo 's = [hg]ssh://%2DoProxyCommand=touch${IFS}owned/path' > .hgsub
   $ hg ci -m 'change url to percent encoded'
   $ cd ..
   $ rm -r malicious-proxycommand-clone
   $ hg clone malicious-proxycommand malicious-proxycommand-clone
   updating to branch default
   cloning subrepo s from ssh://-oProxyCommand%3Dtouch%24%7BIFS%7Downed/path
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path' (in subrepository "s")
   [255]
 
 also check for a pipe
 
   $ cd malicious-proxycommand
   $ echo 's = [hg]ssh://fakehost|touch${IFS}owned/path' > .hgsub
   $ hg ci -m 'change url to pipe'
   $ cd ..
   $ rm -r malicious-proxycommand-clone
   $ hg clone malicious-proxycommand malicious-proxycommand-clone
   updating to branch default
   cloning subrepo s from ssh://fakehost%7Ctouch%24%7BIFS%7Downed/path
   abort: no suitable response from remote hg
   [255]
   $ [ ! -f owned ] || echo 'you got owned'
 
 also check that a percent encoded '|' (%7C) doesn't work
 
   $ cd malicious-proxycommand
   $ echo 's = [hg]ssh://fakehost%7Ctouch%20owned/path' > .hgsub
   $ hg ci -m 'change url to percent encoded pipe'
   $ cd ..
   $ rm -r malicious-proxycommand-clone
   $ hg clone malicious-proxycommand malicious-proxycommand-clone
   updating to branch default
   cloning subrepo s from ssh://fakehost%7Ctouch%20owned/path
   abort: no suitable response from remote hg
   [255]
   $ [ ! -f owned ] || echo 'you got owned'
 
 and bad usernames:
   $ cd malicious-proxycommand
   $ echo 's = [hg]ssh://-oProxyCommand=touch [e-mail]/path' > .hgsub
   $ hg ci -m 'owned username'
   $ cd ..
   $ rm -r malicious-proxycommand-clone
   $ hg clone malicious-proxycommand malicious-proxycommand-clone
   updating to branch default
   cloning subrepo s from ssh://[e-mail]/path
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch [e-mail]/path' (in subrepository "s")
   [255]
 
 Test convert subrepositories including merge (issue5526):
 
   $ hg init tconv
   $ hg convert --config extensions.convert= -q t/s tconv/s
   $ hg convert --config extensions.convert= -q t/s/ss tconv/s/ss
   $ hg convert --config extensions.convert= -q t/t tconv/t
 
  convert shouldn't fail because of pseudo filenode:
 
   $ hg convert --config extensions.convert= t tconv
   scanning source...
   sorting...
   converting...
   17 0
   16 1
   15 2
   14 3
   13 4
   12 5
   11 6
   10 7
   9 8
   8 9
   7 10
   6 11
   5 12
   4 13
   3 rm2
   2 phasecheck4
   1 16
   0 branch before subrepo add
 
  converted .hgsubstate should point to valid nodes:
 
   $ hg up -R tconv 9
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat tconv/.hgsubstate
   fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t