mercurial/debugcommands.py
995	How does this work once we move to append-only (I'm not seeing it in the next changesets)?
1004	nit: `hash` is a builtin function in Python
mercurial/dirstateutils/docket.py
43	Why pass around `nodeconstants`? Shouldn't they be directly imported?
rust/rhg/src/commands/status.rs
176	The opening of the `dirstate` maybe should be consolidated somehow so we don't duplicate the docket indirection in `rhg` and `hg-cpython`, but that's not that big of a deal.

mercurial/debugcommands.py
995	Scratch that, it's in the 3rd one.

mercurial/debugcommands.py
1004	Yes. Personally I don’t really mind variable shadowing, though once upon a time I worked on a code base where a linter complained about it. I’ll rename to `hash_bytes`.
rust/rhg/src/commands/status.rs
176	Yes, `rhg` is in sore need of refactoring to have reusable APIs for various things such as opening the dirstate, but that will be for another patch. The `hg-cpython` case is slightly different since (so far) we do all the I/O and docket handling on the Python side of FFI.

mercurial/debugcommands.py
1005	You probably want `ui.write` here

mercurial/debugcommands.py
997	do you mean `or nothing for distate-v1` ?
mercurial/dirstatemap.py
639	We should restrict that amount of data-read to docket.data_size, should we not ?
mercurial/dirstateutils/docket.py
31	We should not use `.d` extension here. There are too many part of Mercurial that assum `.d` is attached to a revlog and that will eventually lead to confusion.

mercurial/dirstatemap.py
639	never mind, this is done in the next changesets.

mercurial/dirstateutils/docket.py
31	why not `.docket` simply?

mercurial/dirstateutils/docket.py
31	This is the data, my bad.

mercurial/dirstatemap.py
669–670	Should this be a try/finally (and also the one in the `else`)? And is the may-or-may-not-be-closed state handled properly by the callers?
tests/test-help.t
1011–1012 ↗	(On Diff #29617)	For some reason, the next line of the help text is missing. Not sure if that means it's malformed.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	29209		Jul 12 2021, 11:52 AM	★	★
Diff 2	29214		Jul 12 2021, 4:57 PM	★	★
Diff 3	29215		Jul 12 2021, 5:10 PM	★	★
Diff 4	29218		Jul 12 2021, 6:39 PM	★	★
Diff 5	29235		Jul 13 2021, 3:50 PM	★	★
Diff 6	29341		Jul 16 2021, 11:17 AM	★	★
Diff 7	29606		Jul 20 2021, 3:41 PM	★	★
Diff 8	29617	rHGff97e793ed36f40a1e43f4991226e18d9a34616a	Jul 8 2021, 6:18 AM	★	★

Commit	Parents	Author	Summary	Date
c05918665181	6bceecb28806	Simon Sapin		Jul 8 2021, 6:18 AM

Status	Author	Revision
Closed	SimonSapin	D11101 dirstate-v2: Reserve a few bytes of space for future extensions
Closed	SimonSapin	D11099 dirstate-v2: Separate iterators for dirfoldmap and debugdirstate
Closed	SimonSapin	D11098 dirstate-v2: Move fixed-size tree metadata into the docket file
Closed	SimonSapin	D11097 dirstate-v2: Add heuristic for when to create a new data file
Closed	SimonSapin	D11096 dirstate-v2: Reuse existing paths when appending to a data file
Closed	SimonSapin	D11095 dirstate-v2: Reuse existing nodes when appending to a data file
Closed	SimonSapin	D11094 dirstate-v2: Support appending to the same data file
Closed	SimonSapin	D11091 dirstate-v2: shrink on-disk path lengths to 16-bits
Closed	SimonSapin	D11090 dirstate-v2: Rename Header to Root, move it to the end of the data file
Closed	SimonSapin	D11089 dirstate-v2: Enforce data size read from the docket file
Closed	SimonSapin	D11088 dirstate-v2: Introduce a docket file

Diff 29209

mercurial/debugcommands.py

	# debugcommands.py - command processing for debug* commands			# debugcommands.py - command processing for debug* commands
	#			#
	# Copyright 2005-2016 Olivia Mackall <olivia@selenic.com>			# Copyright 2005-2016 Olivia Mackall <olivia@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

				import binascii
	import codecs			import codecs
	import collections			import collections
	import contextlib			import contextlib
	import difflib			import difflib
	import errno			import errno
	import glob			import glob
	import operator			import operator
	import os			import os
	b"%c %s %10d %s%s\n"			b"%c %s %10d %s%s\n"
	% (ent.v1_state(), mode, ent.v1_size(), timestr, file_)			% (ent.v1_state(), mode, ent.v1_size(), timestr, file_)
	)			)
	for f in repo.dirstate.copies():			for f in repo.dirstate.copies():
	ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))			ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))


	@command(			@command(
				b'debugdirstateignorepatternshash',
				[],
				_(b''),
				)
				def debugdirstateignorepatternshash(ui, repo, **opts):
				AlphareUnsubmitted Done How does this work once we move to append-only (I'm not seeing it in the next changesets)? Alphare: How does this work once we move to append-only (I'm not seeing it in the next changesets)?
				AlphareUnsubmitted Done Scratch that, it's in the 3rd one. Alphare: Scratch that, it's in the 3rd one.
				"""show the hash of ignore patterns stored in dirstate if v2,
				or nothing for dirstate-v2
				marmouteUnsubmitted Not Done do you mean `or nothing for distate-v1` ? marmoute: do you mean `or nothing for distate-v1` ?
				"""
				if repo.dirstate._use_dirstate_v2:
				hash_offset = 16 # Four 32-bit integers before this field
				hash_len = 20 # 160 bits for SHA-1
				data_filename = repo.dirstate._map.docket.data_filename()
				with repo.vfs(data_filename) as f:
				hash = f.read(hash_offset + hash_len)[-hash_len:]
				AlphareUnsubmitted Not Done nit: `hash` is a builtin function in Python Alphare: nit: `hash` is a builtin function in Python
				SimonSapinAuthorUnsubmitted Done Yes. Personally I don’t really mind variable shadowing, though once upon a time I worked on a code base where a linter complained about it. I’ll rename to `hash_bytes`. SimonSapin: Yes. Personally I don’t really mind variable shadowing, though once upon a time I worked on a…
				print(binascii.hexlify(hash).decode())
				AlphareUnsubmitted Not Done You probably want `ui.write` here Alphare: You probably want `ui.write` here


				@command(
	b'debugdiscovery',			b'debugdiscovery',
	[			[
	(b'', b'old', None, _(b'use old-style discovery')),			(b'', b'old', None, _(b'use old-style discovery')),
	(			(
	b'',			b'',
	b'nonheads',			b'nonheads',
	None,			None,
	_(b'use old-style discovery with non-heads included'),			_(b'use old-style discovery with non-heads included'),

mercurial/dirstate.py

	# emulate that all 'dirstate.normal' results are written out			# emulate that all 'dirstate.normal' results are written out
	self._lastnormaltime = 0			self._lastnormaltime = 0
	self._updatedfiles.clear()			self._updatedfiles.clear()

	# delay writing in-memory changes out			# delay writing in-memory changes out
	tr.addfilegenerator(			tr.addfilegenerator(
	b'dirstate',			b'dirstate',
	(self._filename,),			(self._filename,),
	self._writedirstate,			lambda f: self._writedirstate(tr, f),
	location=b'plain',			location=b'plain',
	)			)
	return			return

	st = self._opener(filename, b"w", atomictemp=True, checkambig=True)			st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
	self._writedirstate(st)			self._writedirstate(tr, st)

	def addparentchangecallback(self, category, callback):			def addparentchangecallback(self, category, callback):
	"""add a callback to be called when the wd parents are changed			"""add a callback to be called when the wd parents are changed

	Callback will be called with the following arguments:			Callback will be called with the following arguments:
	dirstate, (oldp1, oldp2), (newp1, newp2)			dirstate, (oldp1, oldp2), (newp1, newp2)

	Category is a unique identifier to allow overwriting an old callback			Category is a unique identifier to allow overwriting an old callback
	with a newer callback.			with a newer callback.
	"""			"""
	self._plchangecallbacks[category] = callback			self._plchangecallbacks[category] = callback

	def _writedirstate(self, st):			def _writedirstate(self, tr, st):
	# notify callbacks about parents change			# notify callbacks about parents change
	if self._origpl is not None and self._origpl != self._pl:			if self._origpl is not None and self._origpl != self._pl:
	for c, callback in sorted(			for c, callback in sorted(
	pycompat.iteritems(self._plchangecallbacks)			pycompat.iteritems(self._plchangecallbacks)
	):			):
	callback(self, self._origpl, self._pl)			callback(self, self._origpl, self._pl)
	self._origpl = None			self._origpl = None
	# use the modification time of the newly created temporary file as the			# use the modification time of the newly created temporary file as the
	# multiple of n seconds			# multiple of n seconds
	clock = time.time()			clock = time.time()
	start = int(clock) - (int(clock) % delaywrite)			start = int(clock) - (int(clock) % delaywrite)
	end = start + delaywrite			end = start + delaywrite
	time.sleep(end - clock)			time.sleep(end - clock)
	now = end # trust our estimate that the end is near now			now = end # trust our estimate that the end is near now
	break			break

	self._map.write(st, now)			self._map.write(tr, st, now)
	self._lastnormaltime = 0			self._lastnormaltime = 0
	self._dirty = False			self._dirty = False

	def _dirignore(self, f):			def _dirignore(self, f):
	if self._ignore(f):			if self._ignore(f):
	return True			return True
	for p in pathutil.finddirs(f):			for p in pathutil.finddirs(f):
	if self._ignore(p):			if self._ignore(p):
	filename = self._actualfilename(tr)			filename = self._actualfilename(tr)
	assert backupname != filename			assert backupname != filename

	# use '_writedirstate' instead of 'write' to write changes certainly,			# use '_writedirstate' instead of 'write' to write changes certainly,
	# because the latter omits writing out if transaction is running.			# because the latter omits writing out if transaction is running.
	# output file will be used to create backup of dirstate at this point.			# output file will be used to create backup of dirstate at this point.
	if self._dirty or not self._opener.exists(filename):			if self._dirty or not self._opener.exists(filename):
	self._writedirstate(			self._writedirstate(
				tr,
	self._opener(filename, b"w", atomictemp=True, checkambig=True)			self._opener(filename, b"w", atomictemp=True, checkambig=True)
	)			)

	if tr:			if tr:
	# ensure that subsequent tr.writepending returns True for			# ensure that subsequent tr.writepending returns True for
	# changes written out above, even if dirstate is never			# changes written out above, even if dirstate is never
	# changed after this			# changed after this
	tr.addfilegenerator(			tr.addfilegenerator(
	b'dirstate',			b'dirstate',
	(self._filename,),			(self._filename,),
	self._writedirstate,			lambda f: self._writedirstate(tr, f),
	location=b'plain',			location=b'plain',
	)			)

	# ensure that pending file written above is unlinked at			# ensure that pending file written above is unlinked at
	# failure, even if tr.writepending isn't invoked until the			# failure, even if tr.writepending isn't invoked until the
	# end of this transaction			# end of this transaction
	tr.registertmp(filename, location=b'plain')			tr.registertmp(filename, location=b'plain')

mercurial/dirstatemap.py

	error,			error,
	pathutil,			pathutil,
	policy,			policy,
	pycompat,			pycompat,
	txnutil,			txnutil,
	util,			util,
	)			)

				from .dirstateutils import (
				docket as docketmod,
				)

	parsers = policy.importmod('parsers')			parsers = policy.importmod('parsers')
	rustmod = policy.importrust('dirstate')			rustmod = policy.importrust('dirstate')

	propertycache = util.propertycache			propertycache = util.propertycache

	DirstateItem = parsers.DirstateItem			DirstateItem = parsers.DirstateItem


	self._nodeconstants = nodeconstants			self._nodeconstants = nodeconstants
	self._ui = ui			self._ui = ui
	self._opener = opener			self._opener = opener
	self._root = root			self._root = root
	self._filename = b'dirstate'			self._filename = b'dirstate'
	self._nodelen = 20 # Also update Rust code when changing this!			self._nodelen = 20 # Also update Rust code when changing this!
	self._parents = None			self._parents = None
	self._dirtyparents = False			self._dirtyparents = False
				self._docket = None

	# for consistent view between _pl() and _read() invocations			# for consistent view between _pl() and _read() invocations
	self._pendingmode = None			self._pendingmode = None

	self._use_dirstate_tree = self._ui.configbool(			self._use_dirstate_tree = self._ui.configbool(
	b"experimental",			b"experimental",
	b"dirstate-tree.in-memory",			b"dirstate-tree.in-memory",
	False,			False,
	if self._pendingmode is not None and self._pendingmode != mode:			if self._pendingmode is not None and self._pendingmode != mode:
	fp.close()			fp.close()
	raise error.Abort(			raise error.Abort(
	_(b'working directory state may be changed parallelly')			_(b'working directory state may be changed parallelly')
	)			)
	self._pendingmode = mode			self._pendingmode = mode
	return fp			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):			def setparents(self, p1, p2):
	self._parents = (p1, p2)			self._parents = (p1, p2)
	self._dirtyparents = True			self._dirtyparents = True

	def parents(self):			def parents(self):
	if not self._parents:			if not self._parents:
	if self._use_dirstate_v2:			if self._use_dirstate_v2:
	offset = len(rustmod.V2_FORMAT_MARKER)			self._parents = self.docket.parents
	else:			else:
	offset = 0			read_len = self._nodelen * 2
	read_len = offset + self._nodelen * 2			st = self._readdirstatefile(read_len)
	try:
	fp = self._opendirstatefile()
	st = fp.read(read_len)
	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)			l = len(st)
	if l == read_len:			if l == read_len:
	st = st[offset:]
	self._parents = (			self._parents = (
	st[: self._nodelen],			st[: self._nodelen],
	st[self._nodelen : 2 * self._nodelen],			st[self._nodelen : 2 * self._nodelen],
	)			)
	elif l == 0:			elif l == 0:
	self._parents = (			self._parents = (
	self._nodeconstants.nullid,			self._nodeconstants.nullid,
	self._nodeconstants.nullid,			self._nodeconstants.nullid,
	)			)
	else:			else:
	raise error.Abort(			raise error.Abort(
	_(b'working directory state appears damaged!')			_(b'working directory state appears damaged!')
	)			)

	return self._parents			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			@propertycache
	def _rustmap(self):			def _rustmap(self):
	"""			"""
	Fills the Dirstatemap when called.			Fills the Dirstatemap when called.
	"""			"""
	# ignore HG_PENDING because identity is used only for writing			# ignore HG_PENDING because identity is used only for writing
	self.identity = util.filestat.frompath(			self.identity = util.filestat.frompath(
	self._opener.join(self._filename)			self._opener.join(self._filename)
	)			)

	try:			st = self._readdirstatefile()
	fp = self._opendirstatefile()			if self._use_dirstate_v2:
	try:			if self.docket.uuid:
	st = fp.read()			# TODO: use mmap when possible
				marmouteUnsubmitted Not Done We should restrict that amount of data-read to docket.data_size, should we not ? marmoute: We should restrict that amount of data-read to docket.data_size, should we not ?
				marmouteUnsubmitted Not Done never mind, this is done in the next changesets. marmoute: never mind, this is done in the next changesets.
	finally:			data = self._opener.read(self.docket.data_filename())
	fp.close()			else:
	except IOError as err:			data = b''
	if err.errno != errno.ENOENT:			self._rustmap = rustmod.DirstateMap.new_v2(data)
	raise			parents = self.docket.parents
	st = b''			else:
				self._rustmap, parents = rustmod.DirstateMap.new_v1(
	self._rustmap, parents = rustmod.DirstateMap.new(			self._use_dirstate_tree, st
	self._use_dirstate_tree, self._use_dirstate_v2, st
	)			)

	if parents and not self._dirtyparents:			if parents and not self._dirtyparents:
	self.setparents(*parents)			self.setparents(*parents)

	self.__contains__ = self._rustmap.__contains__			self.__contains__ = self._rustmap.__contains__
	self.__getitem__ = self._rustmap.__getitem__			self.__getitem__ = self._rustmap.__getitem__
	self.get = self._rustmap.get			self.get = self._rustmap.get
	return self._rustmap			return self._rustmap

	def write(self, st, now):			def write(self, tr, st, now):
	parents = self.parents()			if self._use_dirstate_v2:
	packed = self._rustmap.write(			packed = self._rustmap.write_v2(now)
	self._use_dirstate_v2, parents[0], parents[1], now			old_docket = self.docket
	)			new_docket = docketmod.DirstateDocket.with_new_uuid(
				self.parents(), len(packed)
				)
				self._opener.write(new_docket.data_filename(), packed)
				# Write the new docket after the new data file has been
				# written.
				# TODO: Doesn’t opening the docket file for writing truncate
				# it to zero size? Should we also do that after writing the
				# data file?
				mharbison72Unsubmitted Not Done Should this be a try/finally (and also the one in the `else`)? And is the may-or-may-not-be-closed state handled properly by the callers? mharbison72: Should this be a try/finally (and also the one in the `else`)? And is the may-or-may-not-be…
				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:
				self._opener.unlink(old_docket.data_filename())
				self._docket = new_docket
				else:
				p1, p2 = self.parents()
				packed = self._rustmap.write_v1(p1, p2, now)
	st.write(packed)			st.write(packed)
	st.close()			st.close()
	self._dirtyparents = False			self._dirtyparents = False

	@propertycache			@propertycache
	def filefoldmap(self):			def filefoldmap(self):
	"""Returns a dictionary mapping normalized case paths to their			"""Returns a dictionary mapping normalized case paths to their
	non-normalized versions.			non-normalized versions.
	"""			"""
	return self._rustmap.filefoldmapasdict()			return self._rustmap.filefoldmapasdict()

mercurial/dirstateutils/docket.py

This file was added.

				# dirstatedocket.py - docket file for dirstate-v2
				#
				# Copyright Mercurial Contributors
				#
				# This software may be used and distributed according to the terms of the
				# GNU General Public License version 2 or any later version.

				from __future__ import absolute_import

				import struct

				from ..revlogutils import docket as docket_mod


				V2_FORMAT_MARKER = b"dirstate-v2\n"

				# * 12 bytes: format marker
				# * 32 bytes: node ID of the working directory’s first parent
				# * 32 bytes: node ID of the working directory’s second parent
				# * 4 bytes: big-endian used size of the data file
				# * 1 byte: length of the data file’s UUID
				# * variable: data file’s UUID
				#
				# Node IDs are null-padded if shorter than 32 bytes.
				# A data file shorter than the specified used size is corrupted (truncated)
				HEADER = struct.Struct(">{}s32s32sLB".format(len(V2_FORMAT_MARKER)))


				class DirstateDocket(object):
				data_filename_pattern = b'dirstate.%s.d'

				marmouteUnsubmitted Not Done We should not use `.d` extension here. There are too many part of Mercurial that assum `.d` is attached to a revlog and that will eventually lead to confusion. marmoute: We should not use `.d` extension here. There are too many part of Mercurial that assum `.d` is…
				AlphareUnsubmitted Not Done why not `.docket` simply? Alphare: why not `.docket` simply?
				AlphareUnsubmitted Not Done This is the data, my bad. Alphare: This is the data, my bad.
				def __init__(self, parents, data_size, uuid):
				self.parents = parents
				self.data_size = data_size
				self.uuid = uuid

				@classmethod
				def with_new_uuid(cls, parents, data):
				return cls(parents, data, docket_mod.make_uid())

				@classmethod
				def parse(cls, data, nodeconstants):
				if not data:
				AlphareUnsubmitted Not Done Why pass around `nodeconstants`? Shouldn't they be directly imported? Alphare: Why pass around `nodeconstants`? Shouldn't they be directly imported?
				parents = (nodeconstants.nullid, nodeconstants.nullid)
				return cls(parents, 0, None)
				marker, p1, p2, data_size, uuid_size = HEADER.unpack_from(data)
				if marker != V2_FORMAT_MARKER:
				raise ValueError("expected dirstate-v2 marker")
				uuid = data[HEADER.size : HEADER.size + uuid_size]
				p1 = p1[:nodeconstants.nodelen]
				p2 = p2[:nodeconstants.nodelen]
				return cls((p1, p2), data_size, uuid)

				def serialize(self):
				p1, p2 = self.parents
				header = HEADER.pack(V2_FORMAT_MARKER, p1, p2, self.data_size, len(self.uuid))
				return header + self.uuid

				def data_filename(self):
				return self.data_filename_pattern % self.uuid

mercurial/upgrade_utils/engine.py

	)			)

	assert srcrepo.dirstate._use_dirstate_v2 == (old == b'v2')			assert srcrepo.dirstate._use_dirstate_v2 == (old == b'v2')
	srcrepo.dirstate._map._use_dirstate_tree = True			srcrepo.dirstate._map._use_dirstate_tree = True
	srcrepo.dirstate._map.preload()			srcrepo.dirstate._map.preload()
	srcrepo.dirstate._use_dirstate_v2 = new == b'v2'			srcrepo.dirstate._use_dirstate_v2 = new == b'v2'
	srcrepo.dirstate._map._use_dirstate_v2 = srcrepo.dirstate._use_dirstate_v2			srcrepo.dirstate._map._use_dirstate_v2 = srcrepo.dirstate._use_dirstate_v2
	srcrepo.dirstate._dirty = True			srcrepo.dirstate._dirty = True
				srcrepo.vfs.unlink(b'dirstate')
	srcrepo.dirstate.write(None)			srcrepo.dirstate.write(None)

	scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)			scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)

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

	root: ChildNodes::default(),			root: ChildNodes::default(),
	nodes_with_entry_count: 0,			nodes_with_entry_count: 0,
	nodes_with_copy_source_count: 0,			nodes_with_copy_source_count: 0,
	ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],			ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],
	}			}
	}			}

	#[timed]			#[timed]
	pub fn new_v2(			pub fn new_v2(on_disk: &'on_disk [u8]) -> Result<Self, DirstateError> {
	on_disk: &'on_disk [u8],
	) -> Result<(Self, Option<DirstateParents>), DirstateError> {
	Ok(on_disk::read(on_disk)?)			Ok(on_disk::read(on_disk)?)
	}			}

	#[timed]			#[timed]
	pub fn new_v1(			pub fn new_v1(
	on_disk: &'on_disk [u8],			on_disk: &'on_disk [u8],
	) -> Result<(Self, Option<DirstateParents>), DirstateError> {			) -> Result<(Self, Option<DirstateParents>), DirstateError> {
	let mut map = Self::empty(on_disk);			let mut map = Self::empty(on_disk);
	&mut packed,			&mut packed,
	);			);
	}			}
	}			}
	Ok(packed)			Ok(packed)
	}			}

	#[timed]			#[timed]
	fn pack_v2(			fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError> {
	&mut self,
	parents: DirstateParents,
	now: Timestamp,
	) -> Result<Vec<u8>, DirstateError> {
	// TODO:!how do we want to handle this in 2038?			// TODO:!how do we want to handle this in 2038?
	let now: i32 = now.0.try_into().expect("time overflow");			let now: i32 = now.0.try_into().expect("time overflow");
	let mut paths = Vec::new();			let mut paths = Vec::new();
	for node in self.iter_nodes() {			for node in self.iter_nodes() {
	let node = node?;			let node = node?;
	if let Some(entry) = node.entry()? {			if let Some(entry) = node.entry()? {
	if entry.mtime_is_ambiguous(now) {			if entry.mtime_is_ambiguous(now) {
	paths.push(			paths.push(
	node.full_path_borrowed(self.on_disk)?			node.full_path_borrowed(self.on_disk)?
	.detach_from_tree(),			.detach_from_tree(),
	)			)
	}			}
	}			}
	}			}
	// Borrow of `self` ends here since we collect cloned paths			// Borrow of `self` ends here since we collect cloned paths

	self.clear_known_ambiguous_mtimes(&paths)?;			self.clear_known_ambiguous_mtimes(&paths)?;

	on_disk::write(self, parents)			on_disk::write(self)
	}			}

	fn status<'a>(			fn status<'a>(
	&'a mut self,			&'a mut self,
	matcher: &'a (dyn Matcher + Sync),			matcher: &'a (dyn Matcher + Sync),
	root_dir: PathBuf,			root_dir: PathBuf,
	ignore_files: Vec<PathBuf>,			ignore_files: Vec<PathBuf>,
	options: StatusOptions,			options: StatusOptions,

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

	) -> Result<Vec<u8>, DirstateError>;			) -> Result<Vec<u8>, DirstateError>;

	/// Clear mtimes that are ambigous with `now` (similar to			/// Clear mtimes that are ambigous with `now` (similar to
	/// `clear_ambiguous_times` but for all files in the dirstate map), and			/// `clear_ambiguous_times` but for all files in the dirstate map), and
	/// serialize bytes to write the `.hg/dirstate` file to disk in dirstate-v2			/// serialize bytes to write the `.hg/dirstate` file to disk in dirstate-v2
	/// format.			/// format.
	///			///
	/// Note: this is only supported by the tree dirstate map.			/// Note: this is only supported by the tree dirstate map.
	fn pack_v2(			fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError>;
	&mut self,
	parents: DirstateParents,
	now: Timestamp,
	) -> Result<Vec<u8>, DirstateError>;

	/// Run the status algorithm.			/// Run the status algorithm.
	///			///
	/// This is not sematically a method of the dirstate map, but a different			/// This is not sematically a method of the dirstate map, but a different
	/// algorithm is used for the flat v.s. tree dirstate map so having it in			/// algorithm is used for the flat v.s. tree dirstate map so having it in
	/// this trait enables the same dynamic dispatch as with other methods.			/// this trait enables the same dynamic dispatch as with other methods.
	fn status<'a>(			fn status<'a>(
	&'a mut self,			&'a mut self,
	fn pack_v1(			fn pack_v1(
	&mut self,			&mut self,
	parents: DirstateParents,			parents: DirstateParents,
	now: Timestamp,			now: Timestamp,
	) -> Result<Vec<u8>, DirstateError> {			) -> Result<Vec<u8>, DirstateError> {
	self.pack(parents, now)			self.pack(parents, now)
	}			}

	fn pack_v2(			fn pack_v2(&mut self, _now: Timestamp) -> Result<Vec<u8>, DirstateError> {
	&mut self,
	_parents: DirstateParents,
	_now: Timestamp,
	) -> Result<Vec<u8>, DirstateError> {
	panic!(			panic!(
	"should have used dirstate_tree::DirstateMap to use the v2 format"			"should have used dirstate_tree::DirstateMap to use the v2 format"
	)			)
	}			}

	fn status<'a>(			fn status<'a>(
	&'a mut self,			&'a mut self,
	matcher: &'a (dyn Matcher + Sync),			matcher: &'a (dyn Matcher + Sync),

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

	use crate::errors::HgError;			use crate::errors::HgError;
	use crate::utils::hg_path::HgPath;			use crate::utils::hg_path::HgPath;
	use crate::DirstateEntry;			use crate::DirstateEntry;
	use crate::DirstateError;			use crate::DirstateError;
	use crate::DirstateParents;			use crate::DirstateParents;
	use crate::EntryState;			use crate::EntryState;
	use bytes_cast::unaligned::{I32Be, I64Be, U32Be};			use bytes_cast::unaligned::{I32Be, I64Be, U32Be};
	use bytes_cast::BytesCast;			use bytes_cast::BytesCast;
				use format_bytes::format_bytes;
	use std::borrow::Cow;			use std::borrow::Cow;
	use std::convert::TryFrom;			use std::convert::TryFrom;
	use std::time::{Duration, SystemTime, UNIX_EPOCH};			use std::time::{Duration, SystemTime, UNIX_EPOCH};

	/// Added at the start of `.hg/dirstate` when the "v2" format is used.			/// Added at the start of `.hg/dirstate` when the "v2" format is used.
	/// This a redundant sanity check more than an actual "magic number" since			/// This a redundant sanity check more than an actual "magic number" since
	/// `.hg/requires` already governs which format should be used.			/// `.hg/requires` already governs which format should be used.
	pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";			pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";

				/// Keep space for 256-bit hashes
				const STORED_NODE_ID_BYTES: usize = 32;

				/// … even though only 160 bits are used for now, with SHA-1
				const USED_NODE_ID_BYTES: usize = 20;

	pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;			pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;
	pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];			pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];

				// Must match `HEADER` in `mercurial/dirstateutils/docket.py`
	#[derive(BytesCast)]			#[derive(BytesCast)]
	#[repr(C)]			#[repr(C)]
	struct Header {			struct DocketHeader {
	marker: [u8; V2_FORMAT_MARKER.len()],			marker: [u8; V2_FORMAT_MARKER.len()],
				parent_1: [u8; STORED_NODE_ID_BYTES],
				parent_2: [u8; STORED_NODE_ID_BYTES],
				data_size: Size,
				uuid_size: u8,
				}

	/// `dirstatemap.parents()` in `mercurial/dirstate.py` relies on this			pub struct Docket<'on_disk> {
	/// `parents` field being at this offset, immediately after `marker`.			header: &'on_disk DocketHeader,
	parents: DirstateParents,			uuid: &'on_disk [u8],
				}

				#[derive(BytesCast)]
				#[repr(C)]
				struct Header {
	root: ChildNodes,			root: ChildNodes,
	nodes_with_entry_count: Size,			nodes_with_entry_count: Size,
	nodes_with_copy_source_count: Size,			nodes_with_copy_source_count: Size,

	/// If non-zero, a hash of ignore files that were used for some previous			/// If non-zero, a hash of ignore files that were used for some previous
	/// run of the `status` algorithm.			/// run of the `status` algorithm.
	///			///
	/// We define:			/// We define:
	/// A `HgPath` of `len` bytes			/// A `HgPath` of `len` bytes
	type PathSlice = Slice;			type PathSlice = Slice;

	/// Either nothing if `start == 0`, or a `HgPath` of `len` bytes			/// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
	type OptPathSlice = Slice;			type OptPathSlice = Slice;

	/// Make sure that size-affecting changes are made knowingly			/// Make sure that size-affecting changes are made knowingly
	fn _static_assert_size_of() {			fn _static_assert_size_of() {
	let _ = std::mem::transmute::<Header, [u8; 88]>;			let _ = std::mem::transmute::<DocketHeader, [u8; 81]>;
				let _ = std::mem::transmute::<Header, [u8; 36]>;
	let _ = std::mem::transmute::<Node, [u8; 49]>;			let _ = std::mem::transmute::<Node, [u8; 49]>;
	}			}

	/// Unexpected file format found in `.hg/dirstate` with the "v2" format.			/// Unexpected file format found in `.hg/dirstate` with the "v2" format.
	///			///
	/// This should only happen if Mercurial is buggy or a repository is corrupted.			/// This should only happen if Mercurial is buggy or a repository is corrupted.
	#[derive(Debug)]			#[derive(Debug)]
	pub struct DirstateV2ParseError;			pub struct DirstateV2ParseError;

	impl From<DirstateV2ParseError> for HgError {			impl From<DirstateV2ParseError> for HgError {
	fn from(_: DirstateV2ParseError) -> Self {			fn from(_: DirstateV2ParseError) -> Self {
	HgError::corrupted("dirstate-v2 parse error")			HgError::corrupted("dirstate-v2 parse error")
	}			}
	}			}

	impl From<DirstateV2ParseError> for crate::DirstateError {			impl From<DirstateV2ParseError> for crate::DirstateError {
	fn from(error: DirstateV2ParseError) -> Self {			fn from(error: DirstateV2ParseError) -> Self {
	HgError::from(error).into()			HgError::from(error).into()
	}			}
	}			}

	fn read_header(on_disk: &[u8]) -> Result<&Header, DirstateV2ParseError> {			impl<'on_disk> Docket<'on_disk> {
	let (header, _) =			pub fn parents(&self) -> DirstateParents {
	Header::from_bytes(on_disk).map_err(\|_\| DirstateV2ParseError)?;			use crate::Node;
	if header.marker == *V2_FORMAT_MARKER {			let p1 = Node::try_from(&self.header.parent_1[..USED_NODE_ID_BYTES])
	Ok(header)			.unwrap()
				.clone();
				let p2 = Node::try_from(&self.header.parent_2[..USED_NODE_ID_BYTES])
				.unwrap()
				.clone();
				DirstateParents { p1, p2 }
				}

				pub fn data_filename(&self) -> String {
				String::from_utf8(format_bytes!(b"dirstate.{}.d", self.uuid)).unwrap()
				}
				}

				pub fn read_docket(
				on_disk: &[u8],
				) -> Result<Docket<'_>, DirstateV2ParseError> {
				let (header, uuid) =
				DocketHeader::from_bytes(on_disk).map_err(\|_\| DirstateV2ParseError)?;
				let uuid_size = header.uuid_size as usize;
				if header.marker == *V2_FORMAT_MARKER && uuid.len() == uuid_size {
				Ok(Docket { header, uuid })
	} else {			} else {
	Err(DirstateV2ParseError)			Err(DirstateV2ParseError)
	}			}
	}			}

	pub(super) fn read<'on_disk>(			pub(super) fn read<'on_disk>(
	on_disk: &'on_disk [u8],			on_disk: &'on_disk [u8],
	) -> Result<			) -> Result<DirstateMap<'on_disk>, DirstateV2ParseError> {
	(DirstateMap<'on_disk>, Option<DirstateParents>),
	DirstateV2ParseError,
	> {
	if on_disk.is_empty() {			if on_disk.is_empty() {
	return Ok((DirstateMap::empty(on_disk), None));			return Ok(DirstateMap::empty(on_disk));
	}			}
	let header = read_header(on_disk)?;			let (header, _) =
				Header::from_bytes(on_disk).map_err(\|_\| DirstateV2ParseError)?;
	let dirstate_map = DirstateMap {			let dirstate_map = DirstateMap {
	on_disk,			on_disk,
	root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>(			root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>(
	on_disk,			on_disk,
	header.root,			header.root,
	)?),			)?),
	nodes_with_entry_count: header.nodes_with_entry_count.get(),			nodes_with_entry_count: header.nodes_with_entry_count.get(),
	nodes_with_copy_source_count: header			nodes_with_copy_source_count: header
	.nodes_with_copy_source_count			.nodes_with_copy_source_count
	.get(),			.get(),
	ignore_patterns_hash: header.ignore_patterns_hash,			ignore_patterns_hash: header.ignore_patterns_hash,
	};			};
	let parents = Some(header.parents.clone());			Ok(dirstate_map)
	Ok((dirstate_map, parents))
	}			}

	impl Node {			impl Node {
	pub(super) fn full_path<'on_disk>(			pub(super) fn full_path<'on_disk>(
	&self,			&self,
	on_disk: &'on_disk [u8],			on_disk: &'on_disk [u8],
	) -> Result<&'on_disk HgPath, DirstateV2ParseError> {			) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
	read_hg_path(on_disk, self.full_path)			read_hg_path(on_disk, self.full_path)
	let len = usize::try_from(slice.len.get()).unwrap_or(std::usize::MAX);			let len = usize::try_from(slice.len.get()).unwrap_or(std::usize::MAX);
	on_disk			on_disk
	.get(start..)			.get(start..)
	.and_then(\|bytes\| T::slice_from_bytes(bytes, len).ok())			.and_then(\|bytes\| T::slice_from_bytes(bytes, len).ok())
	.map(\|(slice, _rest)\| slice)			.map(\|(slice, _rest)\| slice)
	.ok_or_else(\|\| DirstateV2ParseError)			.ok_or_else(\|\| DirstateV2ParseError)
	}			}

	pub(crate) fn parse_dirstate_parents(
	on_disk: &[u8],
	) -> Result<&DirstateParents, HgError> {
	Ok(&read_header(on_disk)?.parents)
	}

	pub(crate) fn for_each_tracked_path<'on_disk>(			pub(crate) fn for_each_tracked_path<'on_disk>(
	on_disk: &'on_disk [u8],			on_disk: &'on_disk [u8],
	mut f: impl FnMut(&'on_disk HgPath),			mut f: impl FnMut(&'on_disk HgPath),
	) -> Result<(), DirstateV2ParseError> {			) -> Result<(), DirstateV2ParseError> {
	let header = read_header(on_disk)?;			let (header, _) =
				Header::from_bytes(on_disk).map_err(\|_\| DirstateV2ParseError)?;
	fn recur<'on_disk>(			fn recur<'on_disk>(
	on_disk: &'on_disk [u8],			on_disk: &'on_disk [u8],
	nodes: Slice,			nodes: Slice,
	f: &mut impl FnMut(&'on_disk HgPath),			f: &mut impl FnMut(&'on_disk HgPath),
	) -> Result<(), DirstateV2ParseError> {			) -> Result<(), DirstateV2ParseError> {
	for node in read_slice::<Node>(on_disk, nodes)? {			for node in read_slice::<Node>(on_disk, nodes)? {
	if let Some(state) = node.state()? {			if let Some(state) = node.state()? {
	if state.is_tracked() {			if state.is_tracked() {
	f(node.full_path(on_disk)?)			f(node.full_path(on_disk)?)
	}			}
	}			}
	recur(on_disk, node.children, f)?			recur(on_disk, node.children, f)?
	}			}
	Ok(())			Ok(())
	}			}
	recur(on_disk, header.root, &mut f)			recur(on_disk, header.root, &mut f)
	}			}

	pub(super) fn write(			pub(super) fn write(
	dirstate_map: &mut DirstateMap,			dirstate_map: &mut DirstateMap,
	parents: DirstateParents,
	) -> Result<Vec<u8>, DirstateError> {			) -> Result<Vec<u8>, DirstateError> {
	let header_len = std::mem::size_of::<Header>();			let header_len = std::mem::size_of::<Header>();

	// This ignores the space for paths, and for nodes without an entry.			// This ignores the space for paths, and for nodes without an entry.
	// TODO: better estimate? Skip the `Vec` and write to a file directly?			// TODO: better estimate? Skip the `Vec` and write to a file directly?
	let size_guess = header_len			let size_guess = header_len
	+ std::mem::size_of::<Node>()			+ std::mem::size_of::<Node>()
	* dirstate_map.nodes_with_entry_count as usize;			* dirstate_map.nodes_with_entry_count as usize;
	let mut out = Vec::with_capacity(size_guess);			let mut out = Vec::with_capacity(size_guess);

	// Keep space for the header. We’ll fill it out at the end when we know the			// Keep space for the header. We’ll fill it out at the end when we know the
	// actual offset for the root nodes.			// actual offset for the root nodes.
	out.resize(header_len, 0_u8);			out.resize(header_len, 0_u8);

	let root =			let root =
	write_nodes(dirstate_map, dirstate_map.root.as_ref(), &mut out)?;			write_nodes(dirstate_map, dirstate_map.root.as_ref(), &mut out)?;

	let header = Header {			let header = Header {
	marker: *V2_FORMAT_MARKER,
	parents: parents,
	root,			root,
	nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),			nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),
	nodes_with_copy_source_count: dirstate_map			nodes_with_copy_source_count: dirstate_map
	.nodes_with_copy_source_count			.nodes_with_copy_source_count
	.into(),			.into(),
	ignore_patterns_hash: dirstate_map.ignore_patterns_hash,			ignore_patterns_hash: dirstate_map.ignore_patterns_hash,
	};			};
	out[..header_len].copy_from_slice(header.as_bytes());			out[..header_len].copy_from_slice(header.as_bytes());

rust/hg-core/src/repo.rs

	pub fn dirstate_parents(			pub fn dirstate_parents(
	&self,			&self,
	) -> Result<crate::dirstate::DirstateParents, HgError> {			) -> Result<crate::dirstate::DirstateParents, HgError> {
	let dirstate = self.hg_vfs().mmap_open("dirstate")?;			let dirstate = self.hg_vfs().mmap_open("dirstate")?;
	if dirstate.is_empty() {			if dirstate.is_empty() {
	return Ok(crate::dirstate::DirstateParents::NULL);			return Ok(crate::dirstate::DirstateParents::NULL);
	}			}
	let parents = if self.has_dirstate_v2() {			let parents = if self.has_dirstate_v2() {
	crate::dirstate_tree::on_disk::parse_dirstate_parents(&dirstate)?			crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents()
	} else {			} else {
	crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?			crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
				.clone()
	};			};
	Ok(parents.clone())			Ok(parents)
	}			}
	}			}

	impl Vfs<'_> {			impl Vfs<'_> {
	pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {			pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
	self.base.join(relative_path)			self.base.join(relative_path)
	}			}

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

	// `RustDirstateMap`, rightfully so.			// `RustDirstateMap`, rightfully so.
	// All attributes also have to have a separate refcount data attribute for			// All attributes also have to have a separate refcount data attribute for
	// leaks, with all methods that go along for reference sharing.			// leaks, with all methods that go along for reference sharing.
	py_class!(pub class DirstateMap \|py\| {			py_class!(pub class DirstateMap \|py\| {
	@shared data inner: Box<dyn DirstateMapMethods + Send>;			@shared data inner: Box<dyn DirstateMapMethods + Send>;

	/// Returns a `(dirstate_map, parents)` tuple			/// Returns a `(dirstate_map, parents)` tuple
	@staticmethod			@staticmethod
	def new(			def new_v1(
	use_dirstate_tree: bool,			use_dirstate_tree: bool,
	use_dirstate_v2: bool,
	on_disk: PyBytes,			on_disk: PyBytes,
	) -> PyResult<PyObject> {			) -> PyResult<PyObject> {
	let dirstate_error = \|e: DirstateError\| {			let dirstate_error = \|e: DirstateError\| {
	PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))			PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
	};			};
	let (inner, parents) = if use_dirstate_tree \|\| use_dirstate_v2 {			let (inner, parents) = if use_dirstate_tree {
	let (map, parents) =			let (map, parents) = OwningDirstateMap::new_v1(py, on_disk)
	OwningDirstateMap::new(py, on_disk, use_dirstate_v2)
	.map_err(dirstate_error)?;			.map_err(dirstate_error)?;
	(Box::new(map) as _, parents)			(Box::new(map) as _, parents)
	} else {			} else {
	let bytes = on_disk.data(py);			let bytes = on_disk.data(py);
	let mut map = RustDirstateMap::default();			let mut map = RustDirstateMap::default();
	let parents = map.read(bytes).map_err(dirstate_error)?;			let parents = map.read(bytes).map_err(dirstate_error)?;
	(Box::new(map) as _, parents)			(Box::new(map) as _, parents)
	};			};
	let map = Self::create_instance(py, inner)?;			let map = Self::create_instance(py, inner)?;
	let parents = parents.map(\|p\| dirstate_parents_to_pytuple(py, &p));			let parents = parents.map(\|p\| dirstate_parents_to_pytuple(py, &p));
	Ok((map, parents).to_py_object(py).into_object())			Ok((map, parents).to_py_object(py).into_object())
	}			}

				/// Returns a DirstateMap
				@staticmethod
				def new_v2(
				on_disk: PyBytes,
				) -> PyResult<PyObject> {
				let dirstate_error = \|e: DirstateError\| {
				PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
				};
				let inner = OwningDirstateMap::new_v2(py, on_disk)
				.map_err(dirstate_error)?;
				let map = Self::create_instance(py, Box::new(inner))?;
				Ok(map.into_object())
				}

	def clear(&self) -> PyResult<PyObject> {			def clear(&self) -> PyResult<PyObject> {
	self.inner(py).borrow_mut().clear();			self.inner(py).borrow_mut().clear();
	Ok(py.None())			Ok(py.None())
	}			}

	def get(			def get(
	&self,			&self,
	key: PyObject,			key: PyObject,
	Ok(self.inner(py).borrow_mut()			Ok(self.inner(py).borrow_mut()
	.has_dir(HgPath::new(d.data(py)))			.has_dir(HgPath::new(d.data(py)))
	.map_err(\|e\| {			.map_err(\|e\| {
	PyErr::new::<exc::ValueError, _>(py, e.to_string())			PyErr::new::<exc::ValueError, _>(py, e.to_string())
	})?			})?
	.to_py_object(py))			.to_py_object(py))
	}			}

	def write(			def write_v1(
	&self,			&self,
	use_dirstate_v2: bool,
	p1: PyObject,			p1: PyObject,
	p2: PyObject,			p2: PyObject,
	now: PyObject			now: PyObject
	) -> PyResult<PyBytes> {			) -> PyResult<PyBytes> {
	let now = Timestamp(now.extract(py)?);			let now = Timestamp(now.extract(py)?);

				let mut inner = self.inner(py).borrow_mut();
	let parents = DirstateParents {			let parents = DirstateParents {
	p1: extract_node_id(py, &p1)?,			p1: extract_node_id(py, &p1)?,
	p2: extract_node_id(py, &p2)?,			p2: extract_node_id(py, &p2)?,
	};			};
				let result = inner.pack_v1(parents, now);
				match result {
				Ok(packed) => Ok(PyBytes::new(py, &packed)),
				Err(_) => Err(PyErr::new::<exc::OSError, _>(
				py,
				"Dirstate error".to_string(),
				)),
				}
				}

				def write_v2(
				&self,
				now: PyObject
				) -> PyResult<PyBytes> {
				let now = Timestamp(now.extract(py)?);

	let mut inner = self.inner(py).borrow_mut();			let mut inner = self.inner(py).borrow_mut();
	let result = if use_dirstate_v2 {			let result = inner.pack_v2(now);
	inner.pack_v2(parents, now)
	} else {
	inner.pack_v1(parents, now)
	};
	match result {			match result {
	Ok(packed) => Ok(PyBytes::new(py, &packed)),			Ok(packed) => Ok(PyBytes::new(py, &packed)),
	Err(_) => Err(PyErr::new::<exc::OSError, _>(			Err(_) => Err(PyErr::new::<exc::OSError, _>(
	py,			py,
	"Dirstate error".to_string(),			"Dirstate error".to_string(),
	)),			)),
	}			}
	}			}

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

	fn pack_v1(			fn pack_v1(
	&mut self,			&mut self,
	parents: DirstateParents,			parents: DirstateParents,
	now: Timestamp,			now: Timestamp,
	) -> Result<Vec<u8>, DirstateError> {			) -> Result<Vec<u8>, DirstateError> {
	self.get_mut().pack_v1(parents, now)			self.get_mut().pack_v1(parents, now)
	}			}

	fn pack_v2(			fn pack_v2(&mut self, now: Timestamp) -> Result<Vec<u8>, DirstateError> {
	&mut self,			self.get_mut().pack_v2(now)
	parents: DirstateParents,
	now: Timestamp,
	) -> Result<Vec<u8>, DirstateError> {
	self.get_mut().pack_v2(parents, now)
	}			}

	fn status<'a>(			fn status<'a>(
	&'a mut self,			&'a mut self,
	matcher: &'a (dyn Matcher + Sync),			matcher: &'a (dyn Matcher + Sync),
	root_dir: PathBuf,			root_dir: PathBuf,
	ignore_files: Vec<PathBuf>,			ignore_files: Vec<PathBuf>,
	options: StatusOptions,			options: StatusOptions,

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

	/// language cannot represent a lifetime referencing a sibling field.			/// language cannot represent a lifetime referencing a sibling field.
	/// This is not quite a self-referencial struct (moving this struct is not			/// This is not quite a self-referencial struct (moving this struct is not
	/// a problem as it doesn’t change the address of the bytes buffer owned			/// a problem as it doesn’t change the address of the bytes buffer owned
	/// by `PyBytes`) but touches similar borrow-checker limitations.			/// by `PyBytes`) but touches similar borrow-checker limitations.
	ptr: *mut (),			ptr: *mut (),
	}			}

	impl OwningDirstateMap {			impl OwningDirstateMap {
	pub fn new(			pub fn new_v1(
	py: Python,			py: Python,
	on_disk: PyBytes,			on_disk: PyBytes,
	use_dirstate_v2: bool,
	) -> Result<(Self, Option<DirstateParents>), DirstateError> {			) -> Result<(Self, Option<DirstateParents>), DirstateError> {
	let bytes: &'_ [u8] = on_disk.data(py);			let bytes: &'_ [u8] = on_disk.data(py);
	let (map, parents) = if use_dirstate_v2 {			let (map, parents) = DirstateMap::new_v1(bytes)?;
	DirstateMap::new_v2(bytes)?
	} else {
	DirstateMap::new_v1(bytes)?
	};

	// Like in `bytes` above, this `'_` lifetime parameter borrows from			// Like in `bytes` above, this `'_` lifetime parameter borrows from
	// the bytes buffer owned by `on_disk`.			// the bytes buffer owned by `on_disk`.
	let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));			let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));

	// Erase the pointed type entirely in order to erase the lifetime.			// Erase the pointed type entirely in order to erase the lifetime.
	let ptr: *mut () = ptr.cast();			let ptr: *mut () = ptr.cast();

	Ok((Self { on_disk, ptr }, parents))			Ok((Self { on_disk, ptr }, parents))
	}			}

				pub fn new_v2(
				py: Python,
				on_disk: PyBytes,
				) -> Result<Self, DirstateError> {
				let bytes: &'_ [u8] = on_disk.data(py);
				let map = DirstateMap::new_v2(bytes)?;

				// Like in `bytes` above, this `'_` lifetime parameter borrows from
				// the bytes buffer owned by `on_disk`.
				let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map));

				// Erase the pointed type entirely in order to erase the lifetime.
				let ptr: *mut () = ptr.cast();

				Ok(Self { on_disk, ptr })
				}

	pub fn get_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> {			pub fn get_mut<'a>(&'a mut self) -> &'a mut DirstateMap<'a> {
	// SAFETY: We cast the type-erased pointer back to the same type it had			// SAFETY: We cast the type-erased pointer back to the same type it had
	// in `new`, except with a different lifetime parameter. This time we			// in `new`, except with a different lifetime parameter. This time we
	// connect the lifetime to that of `self`. This cast is valid because			// connect the lifetime to that of `self`. This cast is valid because
	// `self` owns the same `PyBytes` whose buffer `DirstateMap`			// `self` owns the same `PyBytes` whose buffer `DirstateMap`
	// references. That buffer has a stable memory address because the byte			// references. That buffer has a stable memory address because the byte
	// string value of a `PyBytes` is immutable.			// string value of a `PyBytes` is immutable.
	let ptr: *mut DirstateMap<'a> = self.ptr.cast();			let ptr: *mut DirstateMap<'a> = self.ptr.cast();

rust/rhg/src/commands/status.rs

	// status.rs			// status.rs
	//			//
	// Copyright 2020, Georges Racinet <georges.racinets@octobus.net>			// Copyright 2020, Georges Racinet <georges.racinets@octobus.net>
	//			//
	// This software may be used and distributed according to the terms of the			// This software may be used and distributed according to the terms of the
	// GNU General Public License version 2 or any later version.			// GNU General Public License version 2 or any later version.

	use crate::error::CommandError;			use crate::error::CommandError;
	use crate::ui::Ui;			use crate::ui::Ui;
	use clap::{Arg, SubCommand};			use clap::{Arg, SubCommand};
	use hg;			use hg;
	use hg::dirstate_tree::dirstate_map::DirstateMap;			use hg::dirstate_tree::dirstate_map::DirstateMap;
				use hg::dirstate_tree::on_disk;
	use hg::errors::HgResultExt;			use hg::errors::HgResultExt;
	use hg::errors::IoResultExt;			use hg::errors::IoResultExt;
	use hg::matchers::AlwaysMatcher;			use hg::matchers::AlwaysMatcher;
	use hg::operations::cat;			use hg::operations::cat;
	use hg::repo::Repo;			use hg::repo::Repo;
	use hg::revlog::node::Node;			use hg::revlog::node::Node;
	use hg::utils::hg_path::{hg_path_to_os_string, HgPath};			use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
	use hg::StatusError;			use hg::StatusError;
	if requested.is_empty() {			if requested.is_empty() {
	DEFAULT_DISPLAY_STATES			DEFAULT_DISPLAY_STATES
	} else {			} else {
	requested			requested
	}			}
	};			};

	let repo = invocation.repo?;			let repo = invocation.repo?;
	let dirstate_data =			let dirstate_data_mmap;
	repo.hg_vfs().mmap_open("dirstate").io_not_found_as_none()?;
	let dirstate_data = match &dirstate_data {
	Some(mmap) => &**mmap,
	None => b"",
	};
	let (mut dmap, parents) = if repo.has_dirstate_v2() {			let (mut dmap, parents) = if repo.has_dirstate_v2() {
	DirstateMap::new_v2(dirstate_data)?			let parents;
				let dirstate_data;
				if let Some(docket_data) =
				repo.hg_vfs().read("dirstate").io_not_found_as_none()?
				{
				let docket = on_disk::read_docket(&docket_data)?;
				AlphareUnsubmitted Not Done The opening of the `dirstate` maybe should be consolidated somehow so we don't duplicate the docket indirection in `rhg` and `hg-cpython`, but that's not that big of a deal. Alphare: The opening of the `dirstate` maybe should be consolidated somehow so we don't duplicate the…
				SimonSapinAuthorUnsubmitted Done Yes, `rhg` is in sore need of refactoring to have reusable APIs for various things such as opening the dirstate, but that will be for another patch. The `hg-cpython` case is slightly different since (so far) we do all the I/O and docket handling on the Python side of FFI. SimonSapin: Yes, `rhg` is in sore need of refactoring to have reusable APIs for various things such as…
				parents = Some(docket.parents());
				dirstate_data_mmap = repo
				.hg_vfs()
				.mmap_open(docket.data_filename())
				.io_not_found_as_none()?;
				dirstate_data = dirstate_data_mmap.as_deref().unwrap_or(b"");
	} else {			} else {
				parents = None;
				dirstate_data = b"";
				}
				let dmap = DirstateMap::new_v2(dirstate_data)?;
				(dmap, parents)
				} else {
				dirstate_data_mmap =
				repo.hg_vfs().mmap_open("dirstate").io_not_found_as_none()?;
				let dirstate_data = dirstate_data_mmap.as_deref().unwrap_or(b"");
	DirstateMap::new_v1(dirstate_data)?			DirstateMap::new_v1(dirstate_data)?
	};			};

	let options = StatusOptions {			let options = StatusOptions {
	// TODO should be provided by the dirstate parsing and			// TODO should be provided by the dirstate parsing and
	// hence be stored on dmap. Using a value that assumes we aren't			// hence be stored on dmap. Using a value that assumes we aren't
	// below the time resolution granularity of the FS and the			// below the time resolution granularity of the FS and the
	// dirstate.			// dirstate.
	last_normal_time: 0,			last_normal_time: 0,
	// we're currently supporting file systems with exec flags only			// we're currently supporting file systems with exec flags only
	// anyway			// anyway

rust/rhg/src/error.rs

	use crate::ui::utf8_to_local;			use crate::ui::utf8_to_local;
	use crate::ui::UiError;			use crate::ui::UiError;
	use crate::NoRepoInCwdError;			use crate::NoRepoInCwdError;
	use format_bytes::format_bytes;			use format_bytes::format_bytes;
	use hg::config::{ConfigError, ConfigParseError, ConfigValueParseError};			use hg::config::{ConfigError, ConfigParseError, ConfigValueParseError};
				use hg::dirstate_tree::on_disk::DirstateV2ParseError;
	use hg::errors::HgError;			use hg::errors::HgError;
	use hg::exit_codes;			use hg::exit_codes;
	use hg::repo::RepoError;			use hg::repo::RepoError;
	use hg::revlog::revlog::RevlogError;			use hg::revlog::revlog::RevlogError;
	use hg::utils::files::get_bytes_from_path;			use hg::utils::files::get_bytes_from_path;
	use hg::{DirstateError, DirstateMapError, StatusError};			use hg::{DirstateError, DirstateMapError, StatusError};
	use std::convert::From;			use std::convert::From;

	impl From<DirstateError> for CommandError {			impl From<DirstateError> for CommandError {
	fn from(error: DirstateError) -> Self {			fn from(error: DirstateError) -> Self {
	match error {			match error {
	DirstateError::Common(error) => error.into(),			DirstateError::Common(error) => error.into(),
	DirstateError::Map(error) => error.into(),			DirstateError::Map(error) => error.into(),
	}			}
	}			}
	}			}

				impl From<DirstateV2ParseError> for CommandError {
				fn from(error: DirstateV2ParseError) -> Self {
				HgError::from(error).into()
				}
				}

tests/test-hgignore.t

	dir1/file2 is ignored			dir1/file2 is ignored
	(ignore rule in $TESTTMP\ignorerepo\.hgignore, line 4: 'dir1/file*')			(ignore rule in $TESTTMP\ignorerepo\.hgignore, line 4: 'dir1/file*')
	$ hg up -qC .			$ hg up -qC .

	#endif			#endif

	#if dirstate-v2			#if dirstate-v2

	Check the hash of ignore patterns written in the dirstate at offset			Check the hash of ignore patterns written in the dirstate
	12 + 20 + 20 + 4 + 4 + 4 + 4 = 68

	$ hg status > /dev/null			$ hg status > /dev/null
	$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo \| $TESTDIR/f --sha1			$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo \| $TESTDIR/f --sha1
	sha1=6e315b60f15fb5dfa02be00f3e2c8f923051f5ff			sha1=6e315b60f15fb5dfa02be00f3e2c8f923051f5ff
	>>> import binascii; print(binascii.hexlify(open(".hg/dirstate", "rb").read()[68:][:20]).decode())			$ hg debugdirstateignorepatternshash
	6e315b60f15fb5dfa02be00f3e2c8f923051f5ff			6e315b60f15fb5dfa02be00f3e2c8f923051f5ff

	$ echo rel > .hg/testhgignorerel			$ echo rel > .hg/testhgignorerel
	$ hg status > /dev/null			$ hg status > /dev/null
	$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo \| $TESTDIR/f --sha1			$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo \| $TESTDIR/f --sha1
	sha1=dea19cc7119213f24b6b582a4bae7b0cb063e34e			sha1=dea19cc7119213f24b6b582a4bae7b0cb063e34e
	>>> import binascii; print(binascii.hexlify(open(".hg/dirstate", "rb").read()[68:][:20]).decode())			$ hg debugdirstateignorepatternshash
	dea19cc7119213f24b6b582a4bae7b0cb063e34e			dea19cc7119213f24b6b582a4bae7b0cb063e34e

	#endif			#endif

		Path
M		mercurial/debugcommands.py (19 lines)
M		mercurial/dirstate.py (11 lines)
M		mercurial/dirstatemap.py (133 lines)
A	M	mercurial/dirstateutils/docket.py (60 lines)
M		mercurial/upgrade_utils/engine.py (1 line)
M		rust/hg-core/src/dirstate_tree/dirstate_map.rs (12 lines)
M		rust/hg-core/src/dirstate_tree/dispatch.rs (12 lines)
M		rust/hg-core/src/dirstate_tree/on_disk.rs (87 lines)
M		rust/hg-core/src/repo.rs (5 lines)
M		rust/hg-cpython/src/dirstate/dirstate_map.rs (48 lines)
M		rust/hg-cpython/src/dirstate/dispatch.rs (8 lines)
M		rust/hg-cpython/src/dirstate/owning.rs (26 lines)
M		rust/rhg/src/commands/status.rs (31 lines)
M		rust/rhg/src/error.rs (7 lines)
M		tests/test-hgignore.t (7 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

dirstate-v2: Introduce a docket file
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 29209

mercurial/debugcommands.py

mercurial/dirstate.py

mercurial/dirstatemap.py

mercurial/dirstateutils/docket.py

mercurial/upgrade_utils/engine.py

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

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

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

rust/hg-core/src/repo.rs

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

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

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

rust/rhg/src/commands/status.rs

rust/rhg/src/error.rs

tests/test-hgignore.t

This is an archive of the discontinued Mercurial Phabricator instance.

dirstate-v2: Introduce a docket fileClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 29209

mercurial/debugcommands.py

mercurial/dirstate.py

mercurial/dirstatemap.py

mercurial/dirstateutils/docket.py

mercurial/upgrade_utils/engine.py

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

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

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

rust/hg-core/src/repo.rs

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

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

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

rust/rhg/src/commands/status.rs

rust/rhg/src/error.rs

tests/test-hgignore.t

dirstate-v2: Introduce a docket file
ClosedPublic

Revision Contents
Changeset List