pathutil: replace the `skip` argument of `dirs` with a boolean

It is ever only used for `r` file. So we make it a boolean this will give use
more versatility later as we will stop storing the state explicitly.

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

mercurial/cext/dirs.c

@@ -1,327 +1,329 b''
 /*
  dirs.c - dynamic directory diddling for dirstates
 
  Copyright 2013 Facebook
 
  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 <string.h>
 
 #include "util.h"
 
 #ifdef IS_PY3K
 #define PYLONG_VALUE(o) ((PyLongObject *)o)->ob_digit[0]
 #else
 #define PYLONG_VALUE(o) PyInt_AS_LONG(o)
 #endif
 
 /*
  * This is a multiset of directory names, built from the files that
  * appear in a dirstate or manifest.
  *
  * A few implementation notes:
  *
  * We modify Python integers for refcounting, but those integers are
  * never visible to Python code.
  */
 /* clang-format off */
 typedef struct {
 	PyObject_HEAD
 	PyObject *dict;
 } dirsObject;
 /* clang-format on */
 
 static inline Py_ssize_t _finddir(const char *path, Py_ssize_t pos)
 {
 	while (pos != -1) {
 		if (path[pos] == '/')
 			break;
 		pos -= 1;
 	}
 	if (pos == -1) {
 		return 0;
 	}
 
 	return pos;
 }
 
 /* Mercurial will fail to run on directory hierarchies deeper than
  * this constant, so we should try and keep this constant as big as
  * possible.
  */
 #define MAX_DIRS_DEPTH 2048
 
 static int _addpath(PyObject *dirs, PyObject *path)
 {
 	const char *cpath = PyBytes_AS_STRING(path);
 	Py_ssize_t pos = PyBytes_GET_SIZE(path);
 	PyObject *key = NULL;
 	int ret = -1;
 	size_t num_slashes = 0;
 
 	/* This loop is super critical for performance. That's why we inline
 	 * access to Python structs instead of going through a supported API.
 	 * The implementation, therefore, is heavily dependent on CPython
 	 * implementation details. We also commit violations of the Python
 	 * "protocol" such as mutating immutable objects. But since we only
 	 * mutate objects created in this function or in other well-defined
 	 * locations, the references are known so these violations should go
 	 * unnoticed. */
 	while ((pos = _finddir(cpath, pos - 1)) != -1) {
 		PyObject *val;
 		++num_slashes;
 		if (num_slashes > MAX_DIRS_DEPTH) {
 			PyErr_SetString(PyExc_ValueError,
 			                "Directory hierarchy too deep.");
 			goto bail;
 		}
 
 		/* Sniff for trailing slashes, a marker of an invalid input. */
 		if (pos > 0 && cpath[pos - 1] == '/') {
 			PyErr_SetString(
 			    PyExc_ValueError,
 			    "found invalid consecutive slashes in path");
 			goto bail;
 		}
 
 		key = PyBytes_FromStringAndSize(cpath, pos);
 		if (key == NULL)
 			goto bail;
 
 		val = PyDict_GetItem(dirs, key);
 		if (val != NULL) {
 			PYLONG_VALUE(val) += 1;
 			Py_CLEAR(key);
 			break;
 		}
 
 		/* Force Python to not reuse a small shared int. */
 #ifdef IS_PY3K
 		val = PyLong_FromLong(0x1eadbeef);
 #else
 		val = PyInt_FromLong(0x1eadbeef);
 #endif
 
 		if (val == NULL)
 			goto bail;
 
 		PYLONG_VALUE(val) = 1;
 		ret = PyDict_SetItem(dirs, key, val);
 		Py_DECREF(val);
 		if (ret == -1)
 			goto bail;
 		Py_CLEAR(key);
 	}
 	ret = 0;
 
 bail:
 	Py_XDECREF(key);
 
 	return ret;
 }
 
 static int _delpath(PyObject *dirs, PyObject *path)
 {
 	char *cpath = PyBytes_AS_STRING(path);
 	Py_ssize_t pos = PyBytes_GET_SIZE(path);
 	PyObject *key = NULL;
 	int ret = -1;
 
 	while ((pos = _finddir(cpath, pos - 1)) != -1) {
 		PyObject *val;
 
 		key = PyBytes_FromStringAndSize(cpath, pos);
 
 		if (key == NULL)
 			goto bail;
 
 		val = PyDict_GetItem(dirs, key);
 		if (val == NULL) {
 			PyErr_SetString(PyExc_ValueError,
 			                "expected a value, found none");
 			goto bail;
 		}
 
 		if (--PYLONG_VALUE(val) <= 0) {
 			if (PyDict_DelItem(dirs, key) == -1)
 				goto bail;
 		} else
 			break;
 		Py_CLEAR(key);
 	}
 	ret = 0;
 
 bail:
 	Py_XDECREF(key);
 
 	return ret;
 }
 
-static int dirs_fromdict(PyObject *dirs, PyObject *source, char skipchar)
+static int dirs_fromdict(PyObject *dirs, PyObject *source, bool only_tracked)
 {
 	PyObject *key, *value;
 	Py_ssize_t pos = 0;
 
 	while (PyDict_Next(source, &pos, &key, &value)) {
 		if (!PyBytes_Check(key)) {
 			PyErr_SetString(PyExc_TypeError, "expected string key");
 			return -1;
 		}
-		if (skipchar) {
+		if (only_tracked) {
 			if (!dirstate_tuple_check(value)) {
 				PyErr_SetString(PyExc_TypeError,
 				                "expected a dirstate tuple");
 				return -1;
 			}
-			if (((dirstateItemObject *)value)->state == skipchar)
+			if (((dirstateItemObject *)value)->state == 'r')
 				continue;
 		}
 
 		if (_addpath(dirs, key) == -1)
 			return -1;
 	}
 
 	return 0;
 }
 
 static int dirs_fromiter(PyObject *dirs, PyObject *source)
 {
 	PyObject *iter, *item = NULL;
 	int ret;
 
 	iter = PyObject_GetIter(source);
 	if (iter == NULL)
 		return -1;
 
 	while ((item = PyIter_Next(iter)) != NULL) {
 		if (!PyBytes_Check(item)) {
 			PyErr_SetString(PyExc_TypeError, "expected string");
 			break;
 		}
 
 		if (_addpath(dirs, item) == -1)
 			break;
 		Py_CLEAR(item);
 	}
 
 	ret = PyErr_Occurred() ? -1 : 0;
 	Py_DECREF(iter);
 	Py_XDECREF(item);
 	return ret;
 }
 
 /*
  * Calculate a refcounted set of directory names for the files in a
  * dirstate.
  */
-static int dirs_init(dirsObject *self, PyObject *args)
+static int dirs_init(dirsObject *self, PyObject *args, PyObject *kwargs)
 {
 	PyObject *dirs = NULL, *source = NULL;
-	char skipchar = 0;
+	int only_tracked = 0;
 	int ret = -1;
+	static char *keywords_name[] = {"map", "only_tracked", NULL};
 
 	self->dict = NULL;
 
-	if (!PyArg_ParseTuple(args, "|Oc:__init__", &source, &skipchar))
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:__init__",
+	                                 keywords_name, &source, &only_tracked))
 		return -1;
 
 	dirs = PyDict_New();
 
 	if (dirs == NULL)
 		return -1;
 
 	if (source == NULL)
 		ret = 0;
 	else if (PyDict_Check(source))
-		ret = dirs_fromdict(dirs, source, skipchar);
-	else if (skipchar)
+		ret = dirs_fromdict(dirs, source, (bool)only_tracked);
+	else if (only_tracked)
 		PyErr_SetString(PyExc_ValueError,
-		                "skip character is only supported "
+		                "`only_tracked` is only supported "
 		                "with a dict source");
 	else
 		ret = dirs_fromiter(dirs, source);
 
 	if (ret == -1)
 		Py_XDECREF(dirs);
 	else
 		self->dict = dirs;
 
 	return ret;
 }
 
 PyObject *dirs_addpath(dirsObject *self, PyObject *args)
 {
 	PyObject *path;
 
 	if (!PyArg_ParseTuple(args, "O!:addpath", &PyBytes_Type, &path))
 		return NULL;
 
 	if (_addpath(self->dict, path) == -1)
 		return NULL;
 
 	Py_RETURN_NONE;
 }
 
 static PyObject *dirs_delpath(dirsObject *self, PyObject *args)
 {
 	PyObject *path;
 
 	if (!PyArg_ParseTuple(args, "O!:delpath", &PyBytes_Type, &path))
 		return NULL;
 
 	if (_delpath(self->dict, path) == -1)
 		return NULL;
 
 	Py_RETURN_NONE;
 }
 
 static int dirs_contains(dirsObject *self, PyObject *value)
 {
 	return PyBytes_Check(value) ? PyDict_Contains(self->dict, value) : 0;
 }
 
 static void dirs_dealloc(dirsObject *self)
 {
 	Py_XDECREF(self->dict);
 	PyObject_Del(self);
 }
 
 static PyObject *dirs_iter(dirsObject *self)
 {
 	return PyObject_GetIter(self->dict);
 }
 
 static PySequenceMethods dirs_sequence_methods;
 
 static PyMethodDef dirs_methods[] = {
     {"addpath", (PyCFunction)dirs_addpath, METH_VARARGS, "add a path"},
     {"delpath", (PyCFunction)dirs_delpath, METH_VARARGS, "remove a path"},
     {NULL} /* Sentinel */
 };
 
 static PyTypeObject dirsType = {PyVarObject_HEAD_INIT(NULL, 0)};
 
 void dirs_module_init(PyObject *mod)
 {
 	dirs_sequence_methods.sq_contains = (objobjproc)dirs_contains;
 	dirsType.tp_name = "parsers.dirs";
 	dirsType.tp_new = PyType_GenericNew;
 	dirsType.tp_basicsize = sizeof(dirsObject);
 	dirsType.tp_dealloc = (destructor)dirs_dealloc;
 	dirsType.tp_as_sequence = &dirs_sequence_methods;
 	dirsType.tp_flags = Py_TPFLAGS_DEFAULT;
 	dirsType.tp_doc = "dirs";
 	dirsType.tp_iter = (getiterfunc)dirs_iter;
 	dirsType.tp_methods = dirs_methods;
 	dirsType.tp_init = (initproc)dirs_init;
 
 	if (PyType_Ready(&dirsType) < 0)
 		return;
 	Py_INCREF(&dirsType);
 
 	PyModule_AddObject(mod, "dirs", (PyObject *)&dirsType);
 }

mercurial/dirstatemap.py

@@ -1,910 +1,910 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,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 propertycache = util.propertycache
 
 DirstateItem = parsers.DirstateItem
 
 rangemask = 0x7FFFFFFF
 
 
 class dirstatemap(object):
     """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 the `addfile`, `removefile` and
       `dropfile` methods.
 
     - `copymap` maps destination filenames to their source filename.
 
     The dirstate also provides the following views onto the state:
 
     - `nonnormalset` is a set of the filenames that have state other
       than 'normal', or are normal but have an mtime of -1 ('normallookup').
 
     - `otherparentset` is a set of the filenames that are marked as coming
       from the second parent when the dirstate is currently being merged.
 
     - `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.
     """
 
     def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
         self._ui = ui
         self._opener = opener
         self._root = root
         self._filename = b'dirstate'
         self._nodelen = 20
         self._nodeconstants = nodeconstants
         assert (
             not use_dirstate_v2
         ), "should have detected unsupported requirement"
 
         self._parents = None
         self._dirtyparents = False
 
         # for consistent view between _pl() and _read() invocations
         self._pendingmode = None
 
     @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")
         util.clearcachedproperty(self, b"nonnormalset")
         util.clearcachedproperty(self, b"otherparentset")
 
     def items(self):
         return pycompat.iteritems(self._map)
 
     # forward for python2,3 compat
     iteritems = items
 
     debug_iter = items
 
     def __len__(self):
         return len(self._map)
 
     def __iter__(self):
         return iter(self._map)
 
     def get(self, key, default=None):
         return self._map.get(key, default)
 
     def __contains__(self, key):
         return key in self._map
 
     def __getitem__(self, key):
         return self._map[key]
 
     def keys(self):
         return self._map.keys()
 
     def preload(self):
         """Loads the underlying data, if it's not already loaded"""
         self._map
 
     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)
 
     def set_possibly_dirty(self, filename):
         """record that the current state of the file on disk is unknown"""
         self[filename].set_possibly_dirty()
 
     def addfile(
         self,
         f,
         mode=0,
         size=None,
         mtime=None,
         added=False,
         merged=False,
         from_p2=False,
         possibly_dirty=False,
     ):
         """Add a tracked file to the dirstate."""
         if added:
             assert not merged
             assert not possibly_dirty
             assert not from_p2
             new_entry = DirstateItem.new_added()
         elif merged:
             assert not possibly_dirty
             assert not from_p2
             new_entry = DirstateItem.new_merged()
         elif from_p2:
             assert not possibly_dirty
             new_entry = DirstateItem.new_from_p2()
         elif possibly_dirty:
             new_entry = DirstateItem.new_possibly_dirty()
         else:
             assert size is not None
             assert mtime is not None
             size = size & rangemask
             mtime = mtime & rangemask
             new_entry = DirstateItem.new_normal(mode, size, mtime)
         old_entry = self.get(f)
         self._dirs_incr(f, old_entry)
         self._map[f] = new_entry
         if new_entry.dm_nonnormal:
             self.nonnormalset.add(f)
         else:
             self.nonnormalset.discard(f)
         if new_entry.dm_otherparent:
             self.otherparentset.add(f)
         else:
             self.otherparentset.discard(f)
 
     def reset_state(
         self,
         filename,
         wc_tracked,
         p1_tracked,
         p2_tracked=False,
         merged=False,
         clean_p1=False,
         clean_p2=False,
         possibly_dirty=False,
         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.
         """
         if merged and (clean_p1 or clean_p2):
             msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
             raise error.ProgrammingError(msg)
         # 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_tracked or wc_tracked):
             self.dropfile(filename)
             return
         elif merged:
             # XXX might be merged and removed ?
             entry = self.get(filename)
             if entry is None or not entry.tracked:
                 # XXX mostly replicate dirstate.other parent.  We should get
                 # the higher layer to pass us more reliable data where `merged`
                 # actually mean merged. Dropping this clause will show failure
                 # in `test-graft.t`
                 merged = False
                 clean_p2 = True
         elif not (p1_tracked or p2_tracked) and wc_tracked:
             pass  # file is added, nothing special to adjust
         elif (p1_tracked or p2_tracked) and not wc_tracked:
             pass
         elif clean_p2 and wc_tracked:
             if p1_tracked or self.get(filename) is not None:
                 # XXX the `self.get` call is catching some case in
                 # `test-merge-remove.t` where the file is tracked in p1, the
                 # p1_tracked argument is False.
                 #
                 # In addition, this seems to be a case where the file is marked
                 # as merged without actually being the result of a merge
                 # action. So thing are not ideal here.
                 merged = True
                 clean_p2 = False
         elif not p1_tracked and p2_tracked and wc_tracked:
             clean_p2 = True
         elif possibly_dirty:
             pass
         elif wc_tracked:
             # this is a "normal" file
             if parentfiledata is None:
                 msg = b'failed to pass parentfiledata for a normal file: %s'
                 msg %= filename
                 raise error.ProgrammingError(msg)
         else:
             assert False, 'unreachable'
 
         old_entry = self._map.get(filename)
         self._dirs_incr(filename, old_entry)
         entry = DirstateItem(
             wc_tracked=wc_tracked,
             p1_tracked=p1_tracked,
             p2_tracked=p2_tracked,
             merged=merged,
             clean_p1=clean_p1,
             clean_p2=clean_p2,
             possibly_dirty=possibly_dirty,
             parentfiledata=parentfiledata,
         )
         if entry.dm_nonnormal:
             self.nonnormalset.add(filename)
         else:
             self.nonnormalset.discard(filename)
         if entry.dm_otherparent:
             self.otherparentset.add(filename)
         else:
             self.otherparentset.discard(filename)
         self._map[filename] = entry
 
     def set_untracked(self, f):
         """Mark a file as no longer tracked in the dirstate map"""
         entry = self[f]
         self._dirs_decr(f, old_entry=entry, remove_variant=True)
         if entry.from_p2:
             self.otherparentset.add(f)
         elif not entry.merged:
             self.copymap.pop(f, None)
         entry.set_untracked()
         self.nonnormalset.add(f)
 
     def dropfile(self, f):
         """
         Remove a file from the dirstate.  Returns True if the file was
         previously recorded.
         """
         old_entry = self._map.pop(f, None)
         self._dirs_decr(f, old_entry=old_entry)
         self.nonnormalset.discard(f)
         return old_entry is not None
 
     def clearambiguoustimes(self, files, now):
         for f in files:
             e = self.get(f)
             if e is not None and e.need_delay(now):
                 e.set_possibly_dirty()
                 self.nonnormalset.add(f)
 
     def nonnormalentries(self):
         '''Compute the nonnormal dirstate entries from the dmap'''
         try:
             return parsers.nonnormalotherparententries(self._map)
         except AttributeError:
             nonnorm = set()
             otherparent = set()
             for fname, e in pycompat.iteritems(self._map):
                 if e.dm_nonnormal:
                     nonnorm.add(fname)
                 if e.from_p2:
                     otherparent.add(fname)
             return nonnorm, otherparent
 
     @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
 
     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, b'r')
+        return pathutil.dirs(self._map, only_tracked=True)
 
     @propertycache
     def _alldirs(self):
         return pathutil.dirs(self._map)
 
     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 parents(self):
         if not self._parents:
             try:
                 fp = self._opendirstatefile()
                 st = fp.read(2 * self._nodelen)
                 fp.close()
             except IOError as err:
                 if err.errno != errno.ENOENT:
                     raise
                 # File doesn't exist, so the current state is empty
                 st = b''
 
             l = len(st)
             if l == self._nodelen * 2:
                 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
 
     def setparents(self, p1, p2):
         self._parents = (p1, p2)
         self._dirtyparents = True
 
     def read(self):
         # ignore HG_PENDING because identity is used only for writing
         self.identity = util.filestat.frompath(
             self._opener.join(self._filename)
         )
 
         try:
             fp = self._opendirstatefile()
             try:
                 st = fp.read()
             finally:
                 fp.close()
         except IOError as err:
             if err.errno != errno.ENOENT:
                 raise
             return
         if not st:
             return
 
         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)
         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):
         st.write(
             parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
         )
         st.close()
         self._dirtyparents = False
         self.nonnormalset, self.otherparentset = self.nonnormalentries()
 
     @propertycache
     def nonnormalset(self):
         nonnorm, otherparents = self.nonnormalentries()
         self.otherparentset = otherparents
         return nonnorm
 
     @propertycache
     def otherparentset(self):
         nonnorm, otherparents = self.nonnormalentries()
         self.nonnormalset = nonnorm
         return otherparents
 
     def non_normal_or_other_parent_paths(self):
         return self.nonnormalset.union(self.otherparentset)
 
     @propertycache
     def identity(self):
         self._map
         return self.identity
 
     @propertycache
     def dirfoldmap(self):
         f = {}
         normcase = util.normcase
         for name in self._dirs:
             f[normcase(name)] = name
         return f
 
 
 if rustmod is not None:
 
     class dirstatemap(object):
         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
 
             self._use_dirstate_tree = self._ui.configbool(
                 b"experimental",
                 b"dirstate-tree.in-memory",
                 False,
             )
 
         def addfile(
             self,
             f,
             mode=0,
             size=None,
             mtime=None,
             added=False,
             merged=False,
             from_p2=False,
             possibly_dirty=False,
         ):
             return self._rustmap.addfile(
                 f,
                 mode,
                 size,
                 mtime,
                 added,
                 merged,
                 from_p2,
                 possibly_dirty,
             )
 
         def reset_state(
             self,
             filename,
             wc_tracked,
             p1_tracked,
             p2_tracked=False,
             merged=False,
             clean_p1=False,
             clean_p2=False,
             possibly_dirty=False,
             parentfiledata=None,
         ):
             """Set a entry to a given state, disregarding 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.
             """
             if merged and (clean_p1 or clean_p2):
                 msg = (
                     b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
                 )
                 raise error.ProgrammingError(msg)
             # 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_tracked or wc_tracked):
                 self.dropfile(filename)
             elif merged:
                 # XXX might be merged and removed ?
                 entry = self.get(filename)
                 if entry is not None and entry.tracked:
                     # XXX mostly replicate dirstate.other parent.  We should get
                     # the higher layer to pass us more reliable data where `merged`
                     # actually mean merged. Dropping the else clause will show
                     # failure in `test-graft.t`
                     self.addfile(filename, merged=True)
                 else:
                     self.addfile(filename, from_p2=True)
             elif not (p1_tracked or p2_tracked) and wc_tracked:
                 self.addfile(
                     filename, added=True, possibly_dirty=possibly_dirty
                 )
             elif (p1_tracked or p2_tracked) and not wc_tracked:
                 # XXX might be merged and removed ?
                 self[filename] = DirstateItem.from_v1_data(b'r', 0, 0, 0)
                 self.nonnormalset.add(filename)
             elif clean_p2 and wc_tracked:
                 if p1_tracked or self.get(filename) is not None:
                     # XXX the `self.get` call is catching some case in
                     # `test-merge-remove.t` where the file is tracked in p1, the
                     # p1_tracked argument is False.
                     #
                     # In addition, this seems to be a case where the file is marked
                     # as merged without actually being the result of a merge
                     # action. So thing are not ideal here.
                     self.addfile(filename, merged=True)
                 else:
                     self.addfile(filename, from_p2=True)
             elif not p1_tracked and p2_tracked and wc_tracked:
                 self.addfile(
                     filename, from_p2=True, possibly_dirty=possibly_dirty
                 )
             elif possibly_dirty:
                 self.addfile(filename, possibly_dirty=possibly_dirty)
             elif wc_tracked:
                 # this is a "normal" file
                 if parentfiledata is None:
                     msg = b'failed to pass parentfiledata for a normal file: %s'
                     msg %= filename
                     raise error.ProgrammingError(msg)
                 mode, size, mtime = parentfiledata
                 self.addfile(filename, mode=mode, size=size, mtime=mtime)
                 self.nonnormalset.discard(filename)
             else:
                 assert False, 'unreachable'
 
         def set_untracked(self, f):
             """Mark a file as no longer tracked in the dirstate map"""
             # in merge is only trigger more logic, so it "fine" to pass it.
             #
             # the inner rust dirstate map code need to be adjusted once the API
             # for dirstate/dirstatemap/DirstateItem is a bit more settled
             self._rustmap.removefile(f, in_merge=True)
 
         def removefile(self, *args, **kwargs):
             return self._rustmap.removefile(*args, **kwargs)
 
         def dropfile(self, *args, **kwargs):
             return self._rustmap.dropfile(*args, **kwargs)
 
         def clearambiguoustimes(self, *args, **kwargs):
             return self._rustmap.clearambiguoustimes(*args, **kwargs)
 
         def nonnormalentries(self):
             return self._rustmap.nonnormalentries()
 
         def get(self, *args, **kwargs):
             return self._rustmap.get(*args, **kwargs)
 
         @property
         def copymap(self):
             return self._rustmap.copymap()
 
         def directories(self):
             return self._rustmap.directories()
 
         def debug_iter(self):
             return self._rustmap.debug_iter()
 
         def preload(self):
             self._rustmap
 
         def clear(self):
             self._rustmap.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._rustmap.items()
 
         def keys(self):
             return iter(self._rustmap)
 
         def __contains__(self, key):
             return key in self._rustmap
 
         def __getitem__(self, item):
             return self._rustmap[item]
 
         def __len__(self):
             return len(self._rustmap)
 
         def __iter__(self):
             return iter(self._rustmap)
 
         # forward for python2,3 compat
         iteritems = items
 
         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''
 
         def setparents(self, p1, p2):
             self._parents = (p1, p2)
             self._dirtyparents = True
 
         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
 
         @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
 
         @propertycache
         def _rustmap(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._rustmap = rustmod.DirstateMap.new_v2(
                     data, self.docket.data_size, self.docket.tree_metadata
                 )
                 parents = self.docket.parents
             else:
                 self._rustmap, parents = rustmod.DirstateMap.new_v1(
                     self._use_dirstate_tree, self._readdirstatefile()
                 )
 
             if parents and not self._dirtyparents:
                 self.setparents(*parents)
 
             self.__contains__ = self._rustmap.__contains__
             self.__getitem__ = self._rustmap.__getitem__
             self.get = self._rustmap.get
             return self._rustmap
 
         def write(self, tr, st, now):
             if not self._use_dirstate_v2:
                 p1, p2 = self.parents()
                 packed = self._rustmap.write_v1(p1, p2, now)
                 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._rustmap.write_v2(now, 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:
                 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
             # Reload from the newly-written file
             util.clearcachedproperty(self, b"_rustmap")
             self._dirtyparents = False
 
         @propertycache
         def filefoldmap(self):
             """Returns a dictionary mapping normalized case paths to their
             non-normalized versions.
             """
             return self._rustmap.filefoldmapasdict()
 
         def hastrackeddir(self, d):
             return self._rustmap.hastrackeddir(d)
 
         def hasdir(self, d):
             return self._rustmap.hasdir(d)
 
         @propertycache
         def identity(self):
             self._rustmap
             return self.identity
 
         @property
         def nonnormalset(self):
             nonnorm = self._rustmap.non_normal_entries()
             return nonnorm
 
         @propertycache
         def otherparentset(self):
             otherparents = self._rustmap.other_parent_entries()
             return otherparents
 
         def non_normal_or_other_parent_paths(self):
             return self._rustmap.non_normal_or_other_parent_paths()
 
         @propertycache
         def dirfoldmap(self):
             f = {}
             normcase = util.normcase
             for name in self._rustmap.tracked_dirs():
                 f[normcase(name)] = name
             return f
 
         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._rustmap.set_v1(filename, entry)
 
         def __setitem__(self, key, value):
             assert isinstance(value, DirstateItem)
             self._rustmap.set_v1(key, value)

mercurial/pathutil.py

@@ -1,377 +1,376 b''
 from __future__ import absolute_import
 
 import contextlib
 import errno
 import os
 import posixpath
 import stat
 
 from .i18n import _
 from . import (
     encoding,
     error,
     policy,
     pycompat,
     util,
 )
 
 if pycompat.TYPE_CHECKING:
     from typing import (
         Any,
         Callable,
         Iterator,
         Optional,
     )
 
 
 rustdirs = policy.importrust('dirstate', 'Dirs')
 parsers = policy.importmod('parsers')
 
 
 def _lowerclean(s):
     # type: (bytes) -> bytes
     return encoding.hfsignoreclean(s.lower())
 
 
 class pathauditor(object):
     """ensure that a filesystem path contains no banned components.
     the following properties of a path are checked:
 
     - ends with a directory separator
     - under top-level .hg
     - starts at the root of a windows drive
     - contains ".."
 
     More check are also done about the file system states:
     - traverses a symlink (e.g. a/symlink_here/b)
     - inside a nested repository (a callback can be used to approve
       some nested repositories, e.g., subrepositories)
 
     The file system checks are only done when 'realfs' is set to True (the
     default). They should be disable then we are auditing path for operation on
     stored history.
 
     If 'cached' is set to True, audited paths and sub-directories are cached.
     Be careful to not keep the cache of unmanaged directories for long because
     audited paths may be replaced with symlinks.
     """
 
     def __init__(self, root, callback=None, realfs=True, cached=False):
         self.audited = set()
         self.auditeddir = set()
         self.root = root
         self._realfs = realfs
         self._cached = cached
         self.callback = callback
         if os.path.lexists(root) and not util.fscasesensitive(root):
             self.normcase = util.normcase
         else:
             self.normcase = lambda x: x
 
     def __call__(self, path, mode=None):
         # type: (bytes, Optional[Any]) -> None
         """Check the relative path.
         path may contain a pattern (e.g. foodir/**.txt)"""
 
         path = util.localpath(path)
         normpath = self.normcase(path)
         if normpath in self.audited:
             return
         # AIX ignores "/" at end of path, others raise EISDIR.
         if util.endswithsep(path):
             raise error.Abort(_(b"path ends in directory separator: %s") % path)
         parts = util.splitpath(path)
         if (
             os.path.splitdrive(path)[0]
             or _lowerclean(parts[0]) in (b'.hg', b'.hg.', b'')
             or pycompat.ospardir in parts
         ):
             raise error.Abort(_(b"path contains illegal component: %s") % path)
         # Windows shortname aliases
         for p in parts:
             if b"~" in p:
                 first, last = p.split(b"~", 1)
                 if last.isdigit() and first.upper() in [b"HG", b"HG8B6C"]:
                     raise error.Abort(
                         _(b"path contains illegal component: %s") % path
                     )
         if b'.hg' in _lowerclean(path):
             lparts = [_lowerclean(p) for p in parts]
             for p in b'.hg', b'.hg.':
                 if p in lparts[1:]:
                     pos = lparts.index(p)
                     base = os.path.join(*parts[:pos])
                     raise error.Abort(
                         _(b"path '%s' is inside nested repo %r")
                         % (path, pycompat.bytestr(base))
                     )
 
         normparts = util.splitpath(normpath)
         assert len(parts) == len(normparts)
 
         parts.pop()
         normparts.pop()
         # It's important that we check the path parts starting from the root.
         # We don't want to add "foo/bar/baz" to auditeddir before checking if
         # there's a "foo/.hg" directory. This also means we won't accidentally
         # traverse a symlink into some other filesystem (which is potentially
         # expensive to access).
         for i in range(len(parts)):
             prefix = pycompat.ossep.join(parts[: i + 1])
             normprefix = pycompat.ossep.join(normparts[: i + 1])
             if normprefix in self.auditeddir:
                 continue
             if self._realfs:
                 self._checkfs(prefix, path)
             if self._cached:
                 self.auditeddir.add(normprefix)
 
         if self._cached:
             self.audited.add(normpath)
 
     def _checkfs(self, prefix, path):
         # type: (bytes, bytes) -> None
         """raise exception if a file system backed check fails"""
         curpath = os.path.join(self.root, prefix)
         try:
             st = os.lstat(curpath)
         except OSError as err:
             # EINVAL can be raised as invalid path syntax under win32.
             # They must be ignored for patterns can be checked too.
             if err.errno not in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
                 raise
         else:
             if stat.S_ISLNK(st.st_mode):
                 msg = _(b'path %r traverses symbolic link %r') % (
                     pycompat.bytestr(path),
                     pycompat.bytestr(prefix),
                 )
                 raise error.Abort(msg)
             elif stat.S_ISDIR(st.st_mode) and os.path.isdir(
                 os.path.join(curpath, b'.hg')
             ):
                 if not self.callback or not self.callback(curpath):
                     msg = _(b"path '%s' is inside nested repo %r")
                     raise error.Abort(msg % (path, pycompat.bytestr(prefix)))
 
     def check(self, path):
         # type: (bytes) -> bool
         try:
             self(path)
             return True
         except (OSError, error.Abort):
             return False
 
     @contextlib.contextmanager
     def cached(self):
         if self._cached:
             yield
         else:
             try:
                 self._cached = True
                 yield
             finally:
                 self.audited.clear()
                 self.auditeddir.clear()
                 self._cached = False
 
 
 def canonpath(root, cwd, myname, auditor=None):
     # type: (bytes, bytes, bytes, Optional[pathauditor]) -> bytes
     """return the canonical path of myname, given cwd and root
 
     >>> def check(root, cwd, myname):
     ...     a = pathauditor(root, realfs=False)
     ...     try:
     ...         return canonpath(root, cwd, myname, a)
     ...     except error.Abort:
     ...         return 'aborted'
     >>> def unixonly(root, cwd, myname, expected='aborted'):
     ...     if pycompat.iswindows:
     ...         return expected
     ...     return check(root, cwd, myname)
     >>> def winonly(root, cwd, myname, expected='aborted'):
     ...     if not pycompat.iswindows:
     ...         return expected
     ...     return check(root, cwd, myname)
     >>> winonly(b'd:\\\\repo', b'c:\\\\dir', b'filename')
     'aborted'
     >>> winonly(b'c:\\\\repo', b'c:\\\\dir', b'filename')
     'aborted'
     >>> winonly(b'c:\\\\repo', b'c:\\\\', b'filename')
     'aborted'
     >>> winonly(b'c:\\\\repo', b'c:\\\\', b'repo\\\\filename',
     ...         b'filename')
     'filename'
     >>> winonly(b'c:\\\\repo', b'c:\\\\repo', b'filename', b'filename')
     'filename'
     >>> winonly(b'c:\\\\repo', b'c:\\\\repo\\\\subdir', b'filename',
     ...         b'subdir/filename')
     'subdir/filename'
     >>> unixonly(b'/repo', b'/dir', b'filename')
     'aborted'
     >>> unixonly(b'/repo', b'/', b'filename')
     'aborted'
     >>> unixonly(b'/repo', b'/', b'repo/filename', b'filename')
     'filename'
     >>> unixonly(b'/repo', b'/repo', b'filename', b'filename')
     'filename'
     >>> unixonly(b'/repo', b'/repo/subdir', b'filename', b'subdir/filename')
     'subdir/filename'
     """
     if util.endswithsep(root):
         rootsep = root
     else:
         rootsep = root + pycompat.ossep
     name = myname
     if not os.path.isabs(name):
         name = os.path.join(root, cwd, name)
     name = os.path.normpath(name)
     if auditor is None:
         auditor = pathauditor(root)
     if name != rootsep and name.startswith(rootsep):
         name = name[len(rootsep) :]
         auditor(name)
         return util.pconvert(name)
     elif name == root:
         return b''
     else:
         # Determine whether `name' is in the hierarchy at or beneath `root',
         # by iterating name=dirname(name) until that causes no change (can't
         # check name == '/', because that doesn't work on windows). The list
         # `rel' holds the reversed list of components making up the relative
         # file name we want.
         rel = []
         while True:
             try:
                 s = util.samefile(name, root)
             except OSError:
                 s = False
             if s:
                 if not rel:
                     # name was actually the same as root (maybe a symlink)
                     return b''
                 rel.reverse()
                 name = os.path.join(*rel)
                 auditor(name)
                 return util.pconvert(name)
             dirname, basename = util.split(name)
             rel.append(basename)
             if dirname == name:
                 break
             name = dirname
 
         # A common mistake is to use -R, but specify a file relative to the repo
         # instead of cwd.  Detect that case, and provide a hint to the user.
         hint = None
         try:
             if cwd != root:
                 canonpath(root, root, myname, auditor)
                 relpath = util.pathto(root, cwd, b'')
                 if relpath.endswith(pycompat.ossep):
                     relpath = relpath[:-1]
                 hint = _(b"consider using '--cwd %s'") % relpath
         except error.Abort:
             pass
 
         raise error.Abort(
             _(b"%s not under root '%s'") % (myname, root), hint=hint
         )
 
 
 def normasprefix(path):
     # type: (bytes) -> bytes
     """normalize the specified path as path prefix
 
     Returned value can be used safely for "p.startswith(prefix)",
     "p[len(prefix):]", and so on.
 
     For efficiency, this expects "path" argument to be already
     normalized by "os.path.normpath", "os.path.realpath", and so on.
 
     See also issue3033 for detail about need of this function.
 
     >>> normasprefix(b'/foo/bar').replace(pycompat.ossep, b'/')
     '/foo/bar/'
     >>> normasprefix(b'/').replace(pycompat.ossep, b'/')
     '/'
     """
     d, p = os.path.splitdrive(path)
     if len(p) != len(pycompat.ossep):
         return path + pycompat.ossep
     else:
         return path
 
 
 def finddirs(path):
     # type: (bytes) -> Iterator[bytes]
     pos = path.rfind(b'/')
     while pos != -1:
         yield path[:pos]
         pos = path.rfind(b'/', 0, pos)
     yield b''
 
 
 class dirs(object):
     '''a multiset of directory names from a set of file paths'''
 
-    def __init__(self, map, skip=None):
+    def __init__(self, map, only_tracked=False):
         """
         a dict map indicates a dirstate while a list indicates a manifest
         """
         self._dirs = {}
         addpath = self.addpath
-        if isinstance(map, dict) and skip is not None:
+        if isinstance(map, dict) and only_tracked:
             for f, s in pycompat.iteritems(map):
-                if s.state != skip:
+                if s.state != b'r':
                     addpath(f)
-        elif skip is not None:
-            raise error.ProgrammingError(
-                b"skip character is only supported with a dict source"
-            )
+        elif only_tracked:
+            msg = b"`only_tracked` is only supported with a dict source"
+            raise error.ProgrammingError(msg)
         else:
             for f in map:
                 addpath(f)
 
     def addpath(self, path):
         # type: (bytes) -> None
         dirs = self._dirs
         for base in finddirs(path):
             if base.endswith(b'/'):
                 raise ValueError(
                     "found invalid consecutive slashes in path: %r" % base
                 )
             if base in dirs:
                 dirs[base] += 1
                 return
             dirs[base] = 1
 
     def delpath(self, path):
         # type: (bytes) -> None
         dirs = self._dirs
         for base in finddirs(path):
             if dirs[base] > 1:
                 dirs[base] -= 1
                 return
             del dirs[base]
 
     def __iter__(self):
         return iter(self._dirs)
 
     def __contains__(self, d):
         # type: (bytes) -> bool
         return d in self._dirs
 
 
 if util.safehasattr(parsers, 'dirs'):
     dirs = parsers.dirs
 
 if rustdirs is not None:
     dirs = rustdirs
 
 
 # forward two methods from posixpath that do what we need, but we'd
 # rather not let our internals know that we're thinking in posix terms
 # - instead we'll let them be oblivious.
 join = posixpath.join
 dirname = posixpath.dirname  # type: Callable[[bytes], bytes]

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

@@ -1,430 +1,428 b''
 // dirs_multiset.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.
 
 //! A multiset of directory names.
 //!
 //! Used to counts the references to directories in a manifest or dirstate.
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::{
     dirstate::EntryState,
     utils::{
         files,
         hg_path::{HgPath, HgPathBuf, HgPathError},
     },
     DirstateEntry, DirstateError, DirstateMapError, FastHashMap,
 };
 use std::collections::{hash_map, hash_map::Entry, HashMap, HashSet};
 
 // could be encapsulated if we care API stability more seriously
 pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>;
 
 #[derive(PartialEq, Debug)]
 pub struct DirsMultiset {
     inner: FastHashMap<HgPathBuf, u32>,
 }
 
 impl DirsMultiset {
     /// Initializes the multiset from a dirstate.
     ///
     /// If `skip_state` is provided, skips dirstate entries with equal state.
     pub fn from_dirstate<I, P>(
         dirstate: I,
-        skip_state: Option<EntryState>,
+        only_tracked: bool,
     ) -> Result<Self, DirstateError>
     where
         I: IntoIterator<
             Item = Result<(P, DirstateEntry), DirstateV2ParseError>,
         >,
         P: AsRef<HgPath>,
     {
         let mut multiset = DirsMultiset {
             inner: FastHashMap::default(),
         };
         for item in dirstate {
             let (filename, entry) = item?;
             let filename = filename.as_ref();
             // This `if` is optimized out of the loop
-            if let Some(skip) = skip_state {
-                if skip != entry.state {
+            if only_tracked {
+                if entry.state != EntryState::Removed {
                     multiset.add_path(filename)?;
                 }
             } else {
                 multiset.add_path(filename)?;
             }
         }
 
         Ok(multiset)
     }
 
     /// Initializes the multiset from a manifest.
     pub fn from_manifest(
         manifest: &[impl AsRef<HgPath>],
     ) -> Result<Self, DirstateMapError> {
         let mut multiset = DirsMultiset {
             inner: FastHashMap::default(),
         };
 
         for filename in manifest {
             multiset.add_path(filename.as_ref())?;
         }
 
         Ok(multiset)
     }
 
     /// Increases the count of deepest directory contained in the path.
     ///
     /// If the directory is not yet in the map, adds its parents.
     pub fn add_path(
         &mut self,
         path: impl AsRef<HgPath>,
     ) -> Result<(), DirstateMapError> {
         for subpath in files::find_dirs(path.as_ref()) {
             if subpath.as_bytes().last() == Some(&b'/') {
                 // TODO Remove this once PathAuditor is certified
                 // as the only entrypoint for path data
                 let second_slash_index = subpath.len() - 1;
 
                 return Err(DirstateMapError::InvalidPath(
                     HgPathError::ConsecutiveSlashes {
                         bytes: path.as_ref().as_bytes().to_owned(),
                         second_slash_index,
                     },
                 ));
             }
             if let Some(val) = self.inner.get_mut(subpath) {
                 *val += 1;
                 break;
             }
             self.inner.insert(subpath.to_owned(), 1);
         }
         Ok(())
     }
 
     /// Decreases the count of deepest directory contained in the path.
     ///
     /// If it is the only reference, decreases all parents until one is
     /// removed.
     /// If the directory is not in the map, something horrible has happened.
     pub fn delete_path(
         &mut self,
         path: impl AsRef<HgPath>,
     ) -> Result<(), DirstateMapError> {
         for subpath in files::find_dirs(path.as_ref()) {
             match self.inner.entry(subpath.to_owned()) {
                 Entry::Occupied(mut entry) => {
                     let val = *entry.get();
                     if val > 1 {
                         entry.insert(val - 1);
                         break;
                     }
                     entry.remove();
                 }
                 Entry::Vacant(_) => {
                     return Err(DirstateMapError::PathNotFound(
                         path.as_ref().to_owned(),
                     ))
                 }
             };
         }
 
         Ok(())
     }
 
     pub fn contains(&self, key: impl AsRef<HgPath>) -> bool {
         self.inner.contains_key(key.as_ref())
     }
 
     pub fn iter(&self) -> DirsMultisetIter {
         self.inner.keys()
     }
 
     pub fn len(&self) -> usize {
         self.inner.len()
     }
 
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 }
 
 /// This is basically a reimplementation of `DirsMultiset` that stores the
 /// children instead of just a count of them, plus a small optional
 /// optimization to avoid some directories we don't need.
 #[derive(PartialEq, Debug)]
 pub struct DirsChildrenMultiset<'a> {
     inner: FastHashMap<&'a HgPath, HashSet<&'a HgPath>>,
     only_include: Option<HashSet<&'a HgPath>>,
 }
 
 impl<'a> DirsChildrenMultiset<'a> {
     pub fn new(
         paths: impl Iterator<Item = &'a HgPathBuf>,
         only_include: Option<&'a HashSet<impl AsRef<HgPath> + 'a>>,
     ) -> Self {
         let mut new = Self {
             inner: HashMap::default(),
             only_include: only_include
                 .map(|s| s.iter().map(AsRef::as_ref).collect()),
         };
 
         for path in paths {
             new.add_path(path)
         }
 
         new
     }
     fn add_path(&mut self, path: &'a (impl AsRef<HgPath> + 'a)) {
         if path.as_ref().is_empty() {
             return;
         }
         for (directory, basename) in files::find_dirs_with_base(path.as_ref())
         {
             if !self.is_dir_included(directory) {
                 continue;
             }
             self.inner
                 .entry(directory)
                 .and_modify(|e| {
                     e.insert(basename);
                 })
                 .or_insert_with(|| {
                     let mut set = HashSet::new();
                     set.insert(basename);
                     set
                 });
         }
     }
     fn is_dir_included(&self, dir: impl AsRef<HgPath>) -> bool {
         match &self.only_include {
             None => false,
             Some(i) => i.contains(dir.as_ref()),
         }
     }
 
     pub fn get(
         &self,
         path: impl AsRef<HgPath>,
     ) -> Option<&HashSet<&'a HgPath>> {
         self.inner.get(path.as_ref())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::StateMap;
 
     #[test]
     fn test_delete_path_path_not_found() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
         let path = HgPathBuf::from_bytes(b"doesnotexist/");
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_owned())),
             map.delete_path(&path)
         );
     }
 
     #[test]
     fn test_delete_path_empty_path() {
         let mut map =
             DirsMultiset::from_manifest(&vec![HgPathBuf::new()]).unwrap();
         let path = HgPath::new(b"");
         assert_eq!(Ok(()), map.delete_path(path));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_owned())),
             map.delete_path(path)
         );
     }
 
     #[test]
     fn test_delete_path_successful() {
         let mut map = DirsMultiset {
             inner: [("", 5), ("a", 3), ("a/b", 2), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
                 .collect(),
         };
 
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/b/")));
         eprintln!("{:?}", map);
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/b/")));
         eprintln!("{:?}", map);
         assert_eq!(
             Err(DirstateMapError::PathNotFound(HgPathBuf::from_bytes(
                 b"a/b/"
             ))),
             map.delete_path(HgPath::new(b"a/b/"))
         );
 
         assert_eq!(2, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/c")).unwrap());
         eprintln!("{:?}", map);
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/")));
         eprintln!("{:?}", map);
 
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/c/")));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(HgPathBuf::from_bytes(
                 b"a/c/"
             ))),
             map.delete_path(HgPath::new(b"a/c/"))
         );
     }
 
     #[test]
     fn test_add_path_empty_path() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
         let path = HgPath::new(b"");
         map.add_path(path).unwrap();
 
         assert_eq!(1, map.len());
     }
 
     #[test]
     fn test_add_path_successful() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
 
         map.add_path(HgPath::new(b"a/")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"")).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory should be ignored
         map.add_path(HgPath::new(b"a")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory will still add its base
         map.add_path(HgPath::new(b"a/b")).unwrap();
         assert_eq!(2, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, map.len());
 
         // Duplicate path works
         map.add_path(HgPath::new(b"a/")).unwrap();
         assert_eq!(3, *map.inner.get(HgPath::new(b"a")).unwrap());
 
         // Nested dir adds to its base
         map.add_path(HgPath::new(b"a/b/")).unwrap();
         assert_eq!(4, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/b")).unwrap());
 
         // but not its base's base, because it already existed
         map.add_path(HgPath::new(b"a/b/c/")).unwrap();
         assert_eq!(4, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, *map.inner.get(HgPath::new(b"a/b")).unwrap());
 
         map.add_path(HgPath::new(b"a/c/")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/c")).unwrap());
 
         let expected = DirsMultiset {
             inner: [("", 2), ("a", 5), ("a/b", 2), ("a/b/c", 1), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
                 .collect(),
         };
         assert_eq!(map, expected);
     }
 
     #[test]
     fn test_dirsmultiset_new_empty() {
         let manifest: Vec<HgPathBuf> = vec![];
         let new = DirsMultiset::from_manifest(&manifest).unwrap();
         let expected = DirsMultiset {
             inner: FastHashMap::default(),
         };
         assert_eq!(expected, new);
 
         let new = DirsMultiset::from_dirstate(
             StateMap::default().into_iter().map(Ok),
-            None,
+            false,
         )
         .unwrap();
         let expected = DirsMultiset {
             inner: FastHashMap::default(),
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_no_skip() {
         let input_vec: Vec<HgPathBuf> = ["a/", "b/", "a/c", "a/d/"]
             .iter()
             .map(|e| HgPathBuf::from_bytes(e.as_bytes()))
             .collect();
         let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
         let new = DirsMultiset::from_manifest(&input_vec).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
 
         let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| {
             Ok((
                 HgPathBuf::from_bytes(f.as_bytes()),
                 DirstateEntry {
                     state: EntryState::Normal,
                     mode: 0,
                     mtime: 0,
                     size: 0,
                 },
             ))
         });
         let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
-        let new = DirsMultiset::from_dirstate(input_map, None).unwrap();
+        let new = DirsMultiset::from_dirstate(input_map, false).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_skip() {
         let input_map = [
             ("a/", EntryState::Normal),
             ("a/b", EntryState::Normal),
             ("a/c", EntryState::Removed),
             ("a/d", EntryState::Merged),
         ]
         .iter()
         .map(|(f, state)| {
             Ok((
                 HgPathBuf::from_bytes(f.as_bytes()),
                 DirstateEntry {
                     state: *state,
                     mode: 0,
                     mtime: 0,
                     size: 0,
                 },
             ))
         });
 
         // "a" incremented with "a/c" and "a/d/"
-        let expected_inner = [("", 1), ("a", 2)]
+        let expected_inner = [("", 1), ("a", 3)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
-        let new =
-            DirsMultiset::from_dirstate(input_map, Some(EntryState::Normal))
-                .unwrap();
+        let new = DirsMultiset::from_dirstate(input_map, true).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 }

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

@@ -1,494 +1,494 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.
 
 use crate::dirstate::parsers::Timestamp;
 use crate::{
     dirstate::EntryState,
     dirstate::MTIME_UNSET,
     dirstate::SIZE_FROM_OTHER_PARENT,
     dirstate::SIZE_NON_NORMAL,
     dirstate::V1_RANGEMASK,
     pack_dirstate, parse_dirstate,
     utils::hg_path::{HgPath, HgPathBuf},
     CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents,
     StateMap,
 };
 use micro_timer::timed;
 use std::collections::HashSet;
 use std::iter::FromIterator;
 use std::ops::Deref;
 
 #[derive(Default)]
 pub struct DirstateMap {
     state_map: StateMap,
     pub copy_map: CopyMap,
     pub dirs: Option<DirsMultiset>,
     pub all_dirs: Option<DirsMultiset>,
     non_normal_set: Option<HashSet<HgPathBuf>>,
     other_parent_set: Option<HashSet<HgPathBuf>>,
 }
 
 /// Should only really be used in python interface code, for clarity
 impl Deref for DirstateMap {
     type Target = StateMap;
 
     fn deref(&self) -> &Self::Target {
         &self.state_map
     }
 }
 
 impl FromIterator<(HgPathBuf, DirstateEntry)> for DirstateMap {
     fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>(
         iter: I,
     ) -> Self {
         Self {
             state_map: iter.into_iter().collect(),
             ..Self::default()
         }
     }
 }
 
 impl DirstateMap {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn clear(&mut self) {
         self.state_map = StateMap::default();
         self.copy_map.clear();
         self.non_normal_set = None;
         self.other_parent_set = None;
     }
 
     pub fn set_v1_inner(&mut self, filename: &HgPath, entry: DirstateEntry) {
         self.state_map.insert(filename.to_owned(), entry);
     }
 
     /// Add a tracked file to the dirstate
     pub fn add_file(
         &mut self,
         filename: &HgPath,
         entry: DirstateEntry,
         // XXX once the dust settle this should probably become an enum
         added: bool,
         merged: bool,
         from_p2: bool,
         possibly_dirty: bool,
     ) -> Result<(), DirstateError> {
         let mut entry = entry;
         if added {
             assert!(!merged);
             assert!(!possibly_dirty);
             assert!(!from_p2);
             entry.state = EntryState::Added;
             entry.size = SIZE_NON_NORMAL;
             entry.mtime = MTIME_UNSET;
         } else if merged {
             assert!(!possibly_dirty);
             assert!(!from_p2);
             entry.state = EntryState::Merged;
             entry.size = SIZE_FROM_OTHER_PARENT;
             entry.mtime = MTIME_UNSET;
         } else if from_p2 {
             assert!(!possibly_dirty);
             entry.state = EntryState::Normal;
             entry.size = SIZE_FROM_OTHER_PARENT;
             entry.mtime = MTIME_UNSET;
         } else if possibly_dirty {
             entry.state = EntryState::Normal;
             entry.size = SIZE_NON_NORMAL;
             entry.mtime = MTIME_UNSET;
         } else {
             entry.state = EntryState::Normal;
             entry.size = entry.size & V1_RANGEMASK;
             entry.mtime = entry.mtime & V1_RANGEMASK;
         }
         let old_state = match self.get(filename) {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
         if old_state == EntryState::Unknown || old_state == EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.add_path(filename)?;
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)?;
             }
         }
         self.state_map.insert(filename.to_owned(), entry.to_owned());
 
         if entry.is_non_normal() {
             self.get_non_normal_other_parent_entries()
                 .0
                 .insert(filename.to_owned());
         }
 
         if entry.is_from_other_parent() {
             self.get_non_normal_other_parent_entries()
                 .1
                 .insert(filename.to_owned());
         }
         Ok(())
     }
 
     /// Mark a file as removed in the dirstate.
     ///
     /// The `size` parameter is used to store sentinel values that indicate
     /// the file's previous state.  In the future, we should refactor this
     /// to be more explicit about what that state is.
     pub fn remove_file(
         &mut self,
         filename: &HgPath,
         in_merge: bool,
     ) -> Result<(), DirstateError> {
         let old_entry_opt = self.get(filename);
         let old_state = match old_entry_opt {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
         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;
                     self.get_non_normal_other_parent_entries()
                         .1
                         .insert(filename.to_owned());
                 }
             }
         }
         if old_state != EntryState::Unknown && old_state != EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.delete_path(filename)?;
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)?;
             }
         }
         if size == 0 {
             self.copy_map.remove(filename);
         }
 
         self.state_map.insert(
             filename.to_owned(),
             DirstateEntry {
                 state: EntryState::Removed,
                 mode: 0,
                 size,
                 mtime: 0,
             },
         );
         self.get_non_normal_other_parent_entries()
             .0
             .insert(filename.to_owned());
         Ok(())
     }
 
     /// Remove a file from the dirstate.
     /// Returns `true` if the file was previously recorded.
     pub fn drop_file(
         &mut self,
         filename: &HgPath,
     ) -> Result<bool, DirstateError> {
         let old_state = match self.get(filename) {
             Some(e) => e.state,
             None => EntryState::Unknown,
         };
         let exists = self.state_map.remove(filename).is_some();
 
         if exists {
             if old_state != EntryState::Removed {
                 if let Some(ref mut dirs) = self.dirs {
                     dirs.delete_path(filename)?;
                 }
             }
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.delete_path(filename)?;
             }
         }
         self.get_non_normal_other_parent_entries()
             .0
             .remove(filename);
 
         Ok(exists)
     }
 
     pub fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<HgPathBuf>,
         now: i32,
     ) {
         for filename in filenames {
             if let Some(entry) = self.state_map.get_mut(&filename) {
                 if entry.clear_ambiguous_mtime(now) {
                     self.get_non_normal_other_parent_entries()
                         .0
                         .insert(filename.to_owned());
                 }
             }
         }
     }
 
     pub fn non_normal_entries_remove(
         &mut self,
         key: impl AsRef<HgPath>,
     ) -> bool {
         self.get_non_normal_other_parent_entries()
             .0
             .remove(key.as_ref())
     }
 
     pub fn non_normal_entries_add(&mut self, key: impl AsRef<HgPath>) {
         self.get_non_normal_other_parent_entries()
             .0
             .insert(key.as_ref().into());
     }
 
     pub fn non_normal_entries_union(
         &mut self,
         other: HashSet<HgPathBuf>,
     ) -> Vec<HgPathBuf> {
         self.get_non_normal_other_parent_entries()
             .0
             .union(&other)
             .map(ToOwned::to_owned)
             .collect()
     }
 
     pub fn get_non_normal_other_parent_entries(
         &mut self,
     ) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {
         self.set_non_normal_other_parent_entries(false);
         (
             self.non_normal_set.as_mut().unwrap(),
             self.other_parent_set.as_mut().unwrap(),
         )
     }
 
     /// Useful to get immutable references to those sets in contexts where
     /// you only have an immutable reference to the `DirstateMap`, like when
     /// sharing references with Python.
     ///
     /// TODO, get rid of this along with the other "setter/getter" stuff when
     /// a nice typestate plan is defined.
     ///
     /// # Panics
     ///
     /// Will panic if either set is `None`.
     pub fn get_non_normal_other_parent_entries_panic(
         &self,
     ) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) {
         (
             self.non_normal_set.as_ref().unwrap(),
             self.other_parent_set.as_ref().unwrap(),
         )
     }
 
     pub fn set_non_normal_other_parent_entries(&mut self, force: bool) {
         if !force
             && self.non_normal_set.is_some()
             && self.other_parent_set.is_some()
         {
             return;
         }
         let mut non_normal = HashSet::new();
         let mut other_parent = HashSet::new();
 
         for (filename, entry) in self.state_map.iter() {
             if entry.is_non_normal() {
                 non_normal.insert(filename.to_owned());
             }
             if entry.is_from_other_parent() {
                 other_parent.insert(filename.to_owned());
             }
         }
         self.non_normal_set = Some(non_normal);
         self.other_parent_set = Some(other_parent);
     }
 
     /// Both of these setters and their uses appear to be the simplest way to
     /// emulate a Python lazy property, but it is ugly and unidiomatic.
     /// TODO One day, rewriting this struct using the typestate might be a
     /// good idea.
     pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
         if self.all_dirs.is_none() {
             self.all_dirs = Some(DirsMultiset::from_dirstate(
                 self.state_map.iter().map(|(k, v)| Ok((k, *v))),
-                None,
+                false,
             )?);
         }
         Ok(())
     }
 
     pub fn set_dirs(&mut self) -> Result<(), DirstateError> {
         if self.dirs.is_none() {
             self.dirs = Some(DirsMultiset::from_dirstate(
                 self.state_map.iter().map(|(k, v)| Ok((k, *v))),
-                Some(EntryState::Removed),
+                true,
             )?);
         }
         Ok(())
     }
 
     pub fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.set_dirs()?;
         Ok(self.dirs.as_ref().unwrap().contains(directory))
     }
 
     pub fn has_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.set_all_dirs()?;
         Ok(self.all_dirs.as_ref().unwrap().contains(directory))
     }
 
     #[timed]
     pub fn read(
         &mut self,
         file_contents: &[u8],
     ) -> Result<Option<DirstateParents>, DirstateError> {
         if file_contents.is_empty() {
             return Ok(None);
         }
 
         let (parents, entries, copies) = parse_dirstate(file_contents)?;
         self.state_map.extend(
             entries
                 .into_iter()
                 .map(|(path, entry)| (path.to_owned(), entry)),
         );
         self.copy_map.extend(
             copies
                 .into_iter()
                 .map(|(path, copy)| (path.to_owned(), copy.to_owned())),
         );
         Ok(Some(parents.clone()))
     }
 
     pub fn pack(
         &mut self,
         parents: DirstateParents,
         now: Timestamp,
     ) -> Result<Vec<u8>, DirstateError> {
         let packed =
             pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
 
         self.set_non_normal_other_parent_entries(true);
         Ok(packed)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_dirs_multiset() {
         let mut map = DirstateMap::new();
         assert!(map.dirs.is_none());
         assert!(map.all_dirs.is_none());
 
         assert_eq!(map.has_dir(HgPath::new(b"nope")).unwrap(), false);
         assert!(map.all_dirs.is_some());
         assert!(map.dirs.is_none());
 
         assert_eq!(map.has_tracked_dir(HgPath::new(b"nope")).unwrap(), false);
         assert!(map.dirs.is_some());
     }
 
     #[test]
     fn test_add_file() {
         let mut map = DirstateMap::new();
 
         assert_eq!(0, map.len());
 
         map.add_file(
             HgPath::new(b"meh"),
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 1337,
                 mtime: 1337,
                 size: 1337,
             },
             false,
             false,
             false,
             false,
         )
         .unwrap();
 
         assert_eq!(1, map.len());
         assert_eq!(0, map.get_non_normal_other_parent_entries().0.len());
         assert_eq!(0, map.get_non_normal_other_parent_entries().1.len());
     }
 
     #[test]
     fn test_non_normal_other_parent_entries() {
         let mut map: DirstateMap = [
             (b"f1", (EntryState::Removed, 1337, 1337, 1337)),
             (b"f2", (EntryState::Normal, 1337, 1337, -1)),
             (b"f3", (EntryState::Normal, 1337, 1337, 1337)),
             (b"f4", (EntryState::Normal, 1337, -2, 1337)),
             (b"f5", (EntryState::Added, 1337, 1337, 1337)),
             (b"f6", (EntryState::Added, 1337, 1337, -1)),
             (b"f7", (EntryState::Merged, 1337, 1337, -1)),
             (b"f8", (EntryState::Merged, 1337, 1337, 1337)),
             (b"f9", (EntryState::Merged, 1337, -2, 1337)),
             (b"fa", (EntryState::Added, 1337, -2, 1337)),
             (b"fb", (EntryState::Removed, 1337, -2, 1337)),
         ]
         .iter()
         .map(|(fname, (state, mode, size, mtime))| {
             (
                 HgPathBuf::from_bytes(fname.as_ref()),
                 DirstateEntry {
                     state: *state,
                     mode: *mode,
                     size: *size,
                     mtime: *mtime,
                 },
             )
         })
         .collect();
 
         let mut non_normal = [
             b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
         ]
         .iter()
         .map(|x| HgPathBuf::from_bytes(x.as_ref()))
         .collect();
 
         let mut other_parent = HashSet::new();
         other_parent.insert(HgPathBuf::from_bytes(b"f4"));
         let entries = map.get_non_normal_other_parent_entries();
 
         assert_eq!(
             (&mut non_normal, &mut other_parent),
             (entries.0, entries.1)
         );
     }
 }

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

@@ -1,142 +1,134 b''
 // dirs_multiset.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::dirs_multiset` file provided by the
 //! `hg-core` package.
 
 use std::cell::RefCell;
-use std::convert::TryInto;
 
 use cpython::{
-    exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult,
-    Python, UnsafePyLeaked,
+    exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyObject,
+    PyResult, Python, UnsafePyLeaked,
 };
 
 use crate::dirstate::extract_dirstate;
 use hg::{
-    errors::HgError,
     utils::hg_path::{HgPath, HgPathBuf},
     DirsMultiset, DirsMultisetIter, DirstateError, DirstateMapError,
-    EntryState,
 };
 
 py_class!(pub class Dirs |py| {
     @shared data inner: DirsMultiset;
 
     // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
     // a `list`)
     def __new__(
         _cls,
         map: PyObject,
-        skip: Option<PyObject> = None
+        only_tracked: Option<PyObject> = None
     ) -> PyResult<Self> {
-        let mut skip_state: Option<EntryState> = None;
-        if let Some(skip) = skip {
-            skip_state = Some(
-                skip.extract::<PyBytes>(py)?.data(py)[0]
-                    .try_into()
-                    .map_err(|e: HgError| {
-                        PyErr::new::<exc::ValueError, _>(py, e.to_string())
-                    })?,
-            );
-        }
+        let only_tracked_b = if let Some(only_tracked) = only_tracked {
+            only_tracked.extract::<PyBool>(py)?.is_true()
+        } else {
+            false
+        };
         let inner = if let Ok(map) = map.cast_as::<PyDict>(py) {
             let dirstate = extract_dirstate(py, &map)?;
             let dirstate = dirstate.iter().map(|(k, v)| Ok((k, *v)));
-            DirsMultiset::from_dirstate(dirstate, skip_state)
+            DirsMultiset::from_dirstate(dirstate, only_tracked_b)
                 .map_err(|e: DirstateError| {
                     PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 })?
         } else {
             let map: Result<Vec<HgPathBuf>, PyErr> = map
                 .iter(py)?
                 .map(|o| {
                     Ok(HgPathBuf::from_bytes(
                         o?.extract::<PyBytes>(py)?.data(py),
                     ))
                 })
                 .collect();
             DirsMultiset::from_manifest(&map?)
                 .map_err(|e| {
                     PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 })?
         };
 
         Self::create_instance(py, inner)
     }
 
     def addpath(&self, path: PyObject) -> PyResult<PyObject> {
         self.inner(py).borrow_mut().add_path(
             HgPath::new(path.extract::<PyBytes>(py)?.data(py)),
         ).and(Ok(py.None())).or_else(|e| {
             match e {
                 DirstateMapError::EmptyPath => {
                     Ok(py.None())
                 },
                 e => {
                     Err(PyErr::new::<exc::ValueError, _>(
                         py,
                         e.to_string(),
                     ))
                 }
             }
         })
     }
 
     def delpath(&self, path: PyObject) -> PyResult<PyObject> {
         self.inner(py).borrow_mut().delete_path(
             HgPath::new(path.extract::<PyBytes>(py)?.data(py)),
         )
             .and(Ok(py.None()))
             .or_else(|e| {
                 match e {
                     DirstateMapError::EmptyPath => {
                         Ok(py.None())
                     },
                     e => {
                         Err(PyErr::new::<exc::ValueError, _>(
                             py,
                             e.to_string(),
                         ))
                     }
                 }
             })
     }
     def __iter__(&self) -> PyResult<DirsMultisetKeysIterator> {
         let leaked_ref = self.inner(py).leak_immutable();
         DirsMultisetKeysIterator::from_inner(
             py,
             unsafe { leaked_ref.map(py, |o| o.iter()) },
         )
     }
 
     def __contains__(&self, item: PyObject) -> PyResult<bool> {
         Ok(self.inner(py).borrow().contains(HgPath::new(
             item.extract::<PyBytes>(py)?.data(py).as_ref(),
         )))
     }
 });
 
 impl Dirs {
     pub fn from_inner(py: Python, d: DirsMultiset) -> PyResult<Self> {
         Self::create_instance(py, d)
     }
 
     fn translate_key(
         py: Python,
         res: &HgPathBuf,
     ) -> PyResult<Option<PyBytes>> {
         Ok(Some(PyBytes::new(py, res.as_bytes())))
     }
 }
 
 py_shared_iterator!(
     DirsMultisetKeysIterator,
     UnsafePyLeaked<DirsMultisetIter<'static>>,
     Dirs::translate_key,
     Option<PyBytes>
 );