This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			hgext/fsmonitor/__init__.py (2 lines)
M			mercurial/cext/parsers.c (45 lines)
M			mercurial/pure/parsers.py (24 lines)
M			rust/hg-cpython/src/dirstate/item.rs (39 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	32822		Apr 6 2022, 10:10 AM	★	★
Diff 2	32883	rHG6c9de02ed57c669c7d0b8d8f3164becd0d59adfa	Mar 22 2022, 11:33 AM	★	★
Diff 3	32919		Apr 8 2022, 12:29 PM	★	★

Status	Author	Revision
Closed	Alphare	D12478 rust-dirstatemap: add unit tests
Closed	Alphare	D12477 rust: add `Debug` trait to a bunch of structs
Closed	Alphare	D12476 rust-dirstatemap: use `&HgPath` instead of `HgPathBuf` in `copy_map_insert`
Closed	Alphare	D12475 rust-dirstatemap: use `DirstateEntry::tracked` directly
Closed	Alphare	D12474 rust-cpython: remove unused API to `drop_entry_and_copy_source`
Closed	Alphare	D12473 rust-dirstatemap: remove `set_dirstate_entry`/`set_entry` methods
Closed	Alphare	D12472 rust-dirstatemap: implement part of the `setparents` logic
Closed	Alphare	D12471 dirstate-item: add missing bit of docstring
Closed	Alphare	D12470 dirstatemap: move `_dirs_incr` and `_dirs_decr` methods out of the common
Closed	Alphare	D12469 dirstatemap: move `_refresh_entry` out of the common methods
Closed	Alphare	D12468 dirstatemap: move `_drop_entry` out of the common methods
Closed	Alphare	D12467 rust-dirstatemap: remove `_drop_entry`
Closed	Alphare	D12466 rust-dirstatemap: remove `__settitem__`
Closed	Alphare	D12465 rust-dirstatemap: remove unused `_refresh_entry` implementation
Closed	Alphare	D12464 rust-distatemap: remove `addfile` API
Closed	Alphare	D12463 rust-dirstatemap: remove `removefile` API
Closed	Alphare	D12462 rhg: use the new `set_clean` API
Closed	Alphare	D12461 dirstatemap: move `set_untracked` out of the common methods
Closed	Alphare	D12460 rust-dirstatemap: add `set_untracked` method
Closed	Alphare	D12459 dirstatemap: move `set_possibly_dirty` out of the common methods
Closed	Alphare	D12458 rust-dirstatemap: add `set_possibly_dirty` method
Closed	Alphare	D12457 dirstatemap: move `set_clean` out of common methods
Closed	Alphare	D12456 rust-dirstatemap: add `set_clean` method
Closed	Alphare	D12455 dirstatemap: remove `_insert_entry`
Closed	Alphare	D12454 dirstatemap: move `reset_state` out of common methods
Closed	Alphare	D12453 rust-dirstatemap: add Rust implementation of `reset_state`
Closed	Alphare	D12452 rust-dirstate: introduce intermediate struct for dirstate-v2 data
Closed	Alphare	D12451 dirstatemap: remove unused parameter from `reset_state`
Closed	Alphare	D12450 dirstatemap: move `set_tracked` out of common methods and plug in Rust
Closed	Alphare	D12449 rust-dirstatemap: add `set_tracked` method
Closed	Alphare	D12448 rust-dirstate: don't return a state for untracked entries
Closed	Alphare	D12447 dirstate: remove v1_* methods from Python/C/Rust shared API
Closed	Alphare	D12446 rust-dirstate-entry: fix typo in panic message
Closed	Alphare	D12445 test-issue660: add dirstate-v2 variant
Closed	Alphare	D12444 test-issue660: test inside a repository, not the test dir
Closed	Alphare	D12443 dirstate: fix some typos in docstrings

Diff 32883

hgext/fsmonitor/init.py

	dmap = self._map			dmap = self._map
	if util.safehasattr(dmap, b'_map'):			if util.safehasattr(dmap, b'_map'):
	# for better performance, directly access the inner dirstate map if the			# for better performance, directly access the inner dirstate map if the
	# standard dirstate implementation is in use.			# standard dirstate implementation is in use.
	dmap = dmap._map			dmap = dmap._map
	nonnormalset = {			nonnormalset = {
	f			f
	for f, e in self._map.items()			for f, e in self._map.items()
	if e.v1_state() != b"n" or e.v1_mtime() == -1			if e._v1_state() != b"n" or e._v1_mtime() == -1
	}			}

	copymap = self._map.copymap			copymap = self._map.copymap
	getkind = stat.S_IFMT			getkind = stat.S_IFMT
	dirkind = stat.S_IFDIR			dirkind = stat.S_IFDIR
	regkind = stat.S_IFREG			regkind = stat.S_IFREG
	lnkkind = stat.S_IFLNK			lnkkind = stat.S_IFLNK
	join = self._join			join = self._join

mercurial/cext/parsers.c

	}			}
	#else			#else
	flags &= ~dirstate_flag_mode_is_symlink;			flags &= ~dirstate_flag_mode_is_symlink;
	#endif			#endif
	return Py_BuildValue("iiii", flags, self->size, self->mtime_s,			return Py_BuildValue("iiii", flags, self->size, self->mtime_s,
	self->mtime_ns);			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 PyLong_FromLong(dirstate_item_c_v1_mode(self));
	};

	static PyObject dirstate_item_v1_size(dirstateItemObject self)
	{
	return PyLong_FromLong(dirstate_item_c_v1_size(self));
	};

	static PyObject dirstate_item_v1_mtime(dirstateItemObject self)
	{
	return PyLong_FromLong(dirstate_item_c_v1_mtime(self));
	};

	static PyObject dirstate_item_mtime_likely_equal_to(dirstateItemObject self,			static PyObject dirstate_item_mtime_likely_equal_to(dirstateItemObject self,
	PyObject *other)			PyObject *other)
	{			{
	int other_s;			int other_s;
	int other_ns;			int other_ns;
	int other_second_ambiguous;			int other_second_ambiguous;
	if (!PyArg_ParseTuple(other, "iii", &other_s, &other_ns,			if (!PyArg_ParseTuple(other, "iii", &other_s, &other_ns,
	&other_second_ambiguous)) {			&other_second_ambiguous)) {
	size, mtime, NULL);			size, mtime, NULL);
	Py_DECREF(t);			Py_DECREF(t);
	return NULL;			return NULL;
	}			}

	return t;			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,			static PyObject dirstate_item_from_v2_meth(PyTypeObject subtype,
	PyObject *args)			PyObject *args)
	{			{
	dirstateItemObject *t =			dirstateItemObject *t =
	PyObject_New(dirstateItemObject, &dirstateItemType);			PyObject_New(dirstateItemObject, &dirstateItemType);
	if (!t) {			if (!t) {
	return NULL;			return NULL;
	}			}
	self->mtime_s = 0;			self->mtime_s = 0;
	self->mtime_ns = 0;			self->mtime_ns = 0;
	}			}
	Py_RETURN_NONE;			Py_RETURN_NONE;
	}			}
	static PyMethodDef dirstate_item_methods[] = {			static PyMethodDef dirstate_item_methods[] = {
	{"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,			{"v2_data", (PyCFunction)dirstate_item_v2_data, METH_NOARGS,
	"return data suitable for v2 serialization"},			"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"},
	{"mtime_likely_equal_to", (PyCFunction)dirstate_item_mtime_likely_equal_to,			{"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"},			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,			{"from_v2_data", (PyCFunction)dirstate_item_from_v2_meth,
	METH_VARARGS \| METH_CLASS, "build a new DirstateItem object from V2 data"},			METH_VARARGS \| METH_CLASS, "build a new DirstateItem object from V2 data"},
	{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,			{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
	METH_NOARGS, "mark a file as \"possibly dirty\""},			METH_NOARGS, "mark a file as \"possibly dirty\""},
	{"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,			{"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
	"mark a file as \"clean\""},			"mark a file as \"clean\""},
	{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,			{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
	"mark a file as \"tracked\""},			"mark a file as \"tracked\""},

mercurial/pure/parsers.py

	self._p2_info = False			self._p2_info = False
	self._mode = None			self._mode = None
	self._size = None			self._size = None
	self._mtime_s = None			self._mtime_s = None
	self._mtime_ns = None			self._mtime_ns = None

	@property			@property
	def mode(self):			def mode(self):
	return self.v1_mode()			return self._v1_mode()

	@property			@property
	def size(self):			def size(self):
	return self.v1_size()			return self._v1_size()

	@property			@property
	def mtime(self):			def mtime(self):
	return self.v1_mtime()			return self._v1_mtime()

	def mtime_likely_equal_to(self, other_mtime):			def mtime_likely_equal_to(self, other_mtime):
	self_sec = self._mtime_s			self_sec = self._mtime_s
	if self_sec is None:			if self_sec is None:
	return False			return False
	self_ns = self._mtime_ns			self_ns = self._mtime_ns
	other_sec, other_ns, second_ambiguous = other_mtime			other_sec, other_ns, second_ambiguous = other_mtime
	if self_sec != other_sec:			if self_sec != other_sec:
	a marked for addition			a marked for addition

	XXX This "state" is a bit obscure and mostly a direct expression of the			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			dirstatev1 format. It would make sense to ultimately deprecate it in
	favor of the more "semantic" attributes.			favor of the more "semantic" attributes.
	"""			"""
	if not self.any_tracked:			if not self.any_tracked:
	return b'?'			return b'?'
	return self.v1_state()			return self._v1_state()

	@property			@property
	def has_fallback_exec(self):			def has_fallback_exec(self):
	"""True if "fallback" information are available for the "exec" bit			"""True if "fallback" information are available for the "exec" bit

	Fallback information can be stored in the dirstate to keep track of			Fallback information can be stored in the dirstate to keep track of
	filesystem attribute tracked by Mercurial when the underlying file			filesystem attribute tracked by Mercurial when the underlying file
	system or operating system does not support that property, (e.g.			system or operating system does not support that property, (e.g.
	if self._fallback_symlink:			if self._fallback_symlink:
	flags \|= DIRSTATE_V2_FALLBACK_SYMLINK			flags \|= DIRSTATE_V2_FALLBACK_SYMLINK

	# Note: we do not need to do anything regarding			# Note: we do not need to do anything regarding
	# DIRSTATE_V2_ALL_UNKNOWN_RECORDED and DIRSTATE_V2_ALL_IGNORED_RECORDED			# DIRSTATE_V2_ALL_UNKNOWN_RECORDED and DIRSTATE_V2_ALL_IGNORED_RECORDED
	# since we never set _DIRSTATE_V2_HAS_DIRCTORY_MTIME			# 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)			return (flags, self._size or 0, self._mtime_s or 0, self._mtime_ns or 0)

	def v1_state(self):			def _v1_state(self):
	"""return a "state" suitable for v1 serialization"""			"""return a "state" suitable for v1 serialization"""
	if not self.any_tracked:			if not self.any_tracked:
	# the object has no state to record, this is -currently-			# the object has no state to record, this is -currently-
	# unsupported			# unsupported
	raise RuntimeError('untracked item')			raise RuntimeError('untracked item')
	elif self.removed:			elif self.removed:
	return b'r'			return b'r'
	elif self._p1_tracked and self._p2_info:			elif self._p1_tracked and self._p2_info:
	return b'm'			return b'm'
	elif self.added:			elif self.added:
	return b'a'			return b'a'
	else:			else:
	return b'n'			return b'n'

	def v1_mode(self):			def _v1_mode(self):
	"""return a "mode" suitable for v1 serialization"""			"""return a "mode" suitable for v1 serialization"""
	return self._mode if self._mode is not None else 0			return self._mode if self._mode is not None else 0

	def v1_size(self):			def _v1_size(self):
	"""return a "size" suitable for v1 serialization"""			"""return a "size" suitable for v1 serialization"""
	if not self.any_tracked:			if not self.any_tracked:
	# the object has no state to record, this is -currently-			# the object has no state to record, this is -currently-
	# unsupported			# unsupported
	raise RuntimeError('untracked item')			raise RuntimeError('untracked item')
	elif self.removed and self._p1_tracked and self._p2_info:			elif self.removed and self._p1_tracked and self._p2_info:
	return NONNORMAL			return NONNORMAL
	elif self._p2_info:			elif self._p2_info:
	return FROM_P2			return FROM_P2
	elif self.removed:			elif self.removed:
	return 0			return 0
	elif self.added:			elif self.added:
	return NONNORMAL			return NONNORMAL
	elif self._size is None:			elif self._size is None:
	return NONNORMAL			return NONNORMAL
	else:			else:
	return self._size			return self._size

	def v1_mtime(self):			def _v1_mtime(self):
	"""return a "mtime" suitable for v1 serialization"""			"""return a "mtime" suitable for v1 serialization"""
	if not self.any_tracked:			if not self.any_tracked:
	# the object has no state to record, this is -currently-			# the object has no state to record, this is -currently-
	# unsupported			# unsupported
	raise RuntimeError('untracked item')			raise RuntimeError('untracked item')
	elif self.removed:			elif self.removed:
	return 0			return 0
	elif self._mtime_s is None:			elif self._mtime_s is None:
	cs = stringio()			cs = stringio()
	write = cs.write			write = cs.write
	write(b"".join(pl))			write(b"".join(pl))
	for f, e in dmap.items():			for f, e in dmap.items():
	if f in copymap:			if f in copymap:
	f = b"%s\0%s" % (f, copymap[f])			f = b"%s\0%s" % (f, copymap[f])
	e = _pack(			e = _pack(
	b">cllll",			b">cllll",
	e.v1_state(),			e._v1_state(),
	e.v1_mode(),			e._v1_mode(),
	e.v1_size(),			e._v1_size(),
	e.v1_mtime(),			e._v1_mtime(),
	len(f),			len(f),
	)			)
	write(e)			write(e)
	write(f)			write(f)
	return cs.getvalue()			return cs.getvalue()

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

	use cpython::exc;			use cpython::exc;
	use cpython::ObjectProtocol;			use cpython::ObjectProtocol;
	use cpython::PyBytes;			use cpython::PyBytes;
	use cpython::PyErr;			use cpython::PyErr;
	use cpython::PyNone;			use cpython::PyNone;
	use cpython::PyObject;			use cpython::PyObject;
	use cpython::PyResult;			use cpython::PyResult;
	use cpython::Python;			use cpython::Python;
	use cpython::PythonObject;			use cpython::PythonObject;
	use hg::dirstate::DirstateEntry;			use hg::dirstate::DirstateEntry;
	use hg::dirstate::EntryState;
	use hg::dirstate::TruncatedTimestamp;			use hg::dirstate::TruncatedTimestamp;
	use std::cell::Cell;			use std::cell::Cell;
	use std::convert::TryFrom;

	py_class!(pub class DirstateItem \|py\| {			py_class!(pub class DirstateItem \|py\| {
	data entry: Cell<DirstateEntry>;			data entry: Cell<DirstateEntry>;

	def __new__(			def __new__(
	_cls,			_cls,
	wc_tracked: bool = false,			wc_tracked: bool = false,
	p1_tracked: bool = false,			p1_tracked: bool = false,
	Ok(self.entry(py).get().maybe_clean())			Ok(self.entry(py).get().maybe_clean())
	}			}

	@property			@property
	def any_tracked(&self) -> PyResult<bool> {			def any_tracked(&self) -> PyResult<bool> {
	Ok(self.entry(py).get().any_tracked())			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 mtime_likely_equal_to(&self, other: (u32, u32, bool))			def mtime_likely_equal_to(&self, other: (u32, u32, bool))
	-> PyResult<bool> {			-> PyResult<bool> {
	if let Some(mtime) = self.entry(py).get().truncated_mtime() {			if let Some(mtime) = self.entry(py).get().truncated_mtime() {
	Ok(mtime.likely_equal(timestamp(py, other)?))			Ok(mtime.likely_equal(timestamp(py, other)?))
	} else {			} else {
	Ok(false)			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> {			def drop_merge_data(&self) -> PyResult<PyNone> {
	self.update(py, \|entry\| entry.drop_merge_data());			self.update(py, \|entry\| entry.drop_merge_data());
	Ok(PyNone)			Ok(PyNone)
	}			}

	def set_clean(			def set_clean(
	&self,			&self,
	mode: u32,			mode: u32,

This is an archive of the discontinued Mercurial Phabricator instance.

dirstate: remove v1_* methods from Python/C/Rust shared APIClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 32883

hgext/fsmonitor/__init__.py

mercurial/cext/parsers.c

mercurial/pure/parsers.py

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

dirstate: remove v1_* methods from Python/C/Rust shared API
ClosedPublic

Revision Contents
Changeset List

hgext/fsmonitor/init.py