This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			mercurial/dirstate.py (2 lines)
M			mercurial/dirstatemap.py (10 lines)
M			rust/hg-core/src/dirstate/dirstate_map.rs (7 lines)
M			rust/hg-core/src/dirstate_tree/dirstate_map.rs (6 lines)
M			rust/hg-core/src/dirstate_tree/dispatch.rs (4 lines)
M			rust/hg-cpython/src/dirstate/dirstate_map.rs (7 lines)
M			rust/hg-cpython/src/dirstate/dispatch.rs (10 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	28787		Jul 4 2021, 5:51 PM	★	★
Diff 2	28868		Jul 6 2021, 2:09 PM	★	★
Diff 3	28905	rHG69a463a4f193aaa406910725789b7addc0ab636c	Jul 3 2021, 2:59 PM	★	★

Status	Author	Revision
Closed	marmoute	D11077 mergestate: use dirstate.update_file API in recordupdates()
Closed	marmoute	D11076 dirstate: add dedicated function for updating data of a file
Closed	marmoute	D11075 dirstate: add a `update_file` function
Closed	marmoute	D11074 resolve: use the `parentchange` context manager to apply merge action
Closed	marmoute	D11033 sparse: adjust the temporary includes within a `parentchange` context
Closed	marmoute	D11032 amend: adjust the dirstate within a `parentchange` context
Closed	marmoute	D11031 dirstate: use the right internal API in a test script
Closed	marmoute	D11029 sparse: clear rules in the context of a `parentchanges` context
Closed	marmoute	D11028 sparse: make sure we adjust the dirstate at the same time as the parent
Closed	marmoute	D11027 narrow: update narrow spec within a dirstate.parentchange context
Closed	marmoute	D11026 revert: use `set_untracked` instead of `drop` when applicable
Closed	marmoute	D11022 revert: use `set_untracked` when performing a revert
Closed	marmoute	D11021 mq: use `set_untracked` in `qrename`
Closed	marmoute	D11020 context: use `dirstate.set_untracked` in `context.forget`
Closed	marmoute	D11019 dirstate: add a `set_untracked` method for "hg remove"-like usage
Closed	marmoute	D11018 mq: use `set_tracked` in `qrename`
Closed	marmoute	D11017 mq: update the dirstate and its parent within a `parentchange` context
Closed	marmoute	D11016 context: use `dirstate.set_tracked` for `revert`
Closed	marmoute	D11015 context: use `dirstate.set_tracked` in context.copy
Closed	marmoute	D11014 context: use `dirstate.set_tracked` in `context.add`
Closed	marmoute	D11013 dirstate: add a `set_tracked` method for "hg add"-like usage
Closed	marmoute	D11012 dirstate: add a function to update tracking status while "moving" parents
Closed	marmoute	D11023 dirstate: introduce an internal `_drop` method
Closed	marmoute	D11011 dirstate: introduce an internal `_remove` method
Closed	marmoute	D11010 dirstate: introduce an internal `_add` method
Closed	marmoute	D10993 dirstatenonnormalcheck: fix some bytes formating on python3
Closed	marmoute	D10992 dirstate-item: deprecate tuple access on the class
Closed	marmoute	D10935 dirstate: document the dirstatetuple content
Closed	marmoute	D10982 dirstate-item: rename the class to DirstateItem
Closed	marmoute	D10981 dirstate-entry: add a `mtime` property
Closed	marmoute	D10980 dirstate-entry: add a `size` property
Closed	marmoute	D10979 dirstate-entry: add a `mode` property
Closed	marmoute	D10978 dirstate: no longer pass `oldstate` to the `dropfile`
Closed	marmoute	D10987 dirstate-item: use the properties in fakedirstatewritetime
Closed	marmoute	D10986 dirstate-item: use the properties in dirstatemap
Closed	marmoute	D10985 dirstate-item: use the properties in pathutil
Closed	marmoute	D10984 dirstate-item: use need_delay when packing dirstate
Closed	marmoute	D10991 dirstate-item: use the properties in `contrib/dirstatenonnormalcheck.py`
Closed	marmoute	D10990 dirstate-item: use the properties in largefiles
Closed	marmoute	D10989 dirstate-item: use the `state` property in debugpathcomplete
Closed	marmoute	D10988 dirstate-item: use the v1_serialization method in debugstate
Closed	marmoute	D10983 dirstate-item: also build DistateItem in dirstate.directories()
Closed	marmoute	D10977 dirstate: drop the last explicit `state` usage in the module
Closed	marmoute	D10976 dirstate: drop last explicite `state` usage in status
Closed	marmoute	D10975 dirstate: reorder "state" checking conditional
Closed	marmoute	D10974 dirstate-entry: add a `need_delay` method
Closed	marmoute	D10973 dirstate-entry: add a `tracked` property
Closed	marmoute	D10972 dirstate: drop `state` to `_addpath`
Closed	marmoute	D10971 dirstate: infer the 'n' state from `from_p2`
Closed	marmoute	D10970 dirstate: infer the 'n' state from `possibly_dirty`
Closed	marmoute	D10969 dirstate: use a `merged` parameter to _addpath
Closed	marmoute	D10968 dirstate-entry: add a `added` property
Closed	marmoute	D10967 dirstate: use a `added` parameter to _addpath
Closed	marmoute	D10966 dirstate: no longer pass the `oldstate` value to the dirstatemap
Closed	marmoute	D10965 dirstate: stop using `oldstate` in `dirstate._addpath`
Closed	marmoute	D10964 dirstate: drop the now unused magic constants for the dirstate module
Closed	marmoute	D10963 dirstate: move the handling of special case within the dirstatemap
Closed	marmoute	D10962 rust: bump rust-cpython version for 0.6.0
Closed	marmoute	D10961 rust-dirstate: make the MTIME_UNSET public
Closed	marmoute	D10960 rust-dirstatemap: expand the wrapping code a bit
Closed	marmoute	D10959 dirstate-entry: restrict `from_p2` property to tracked file
Closed	marmoute	D10958 dirstate-entry: `merged_removed` and `from_p2_removed` properties
Closed	marmoute	D10957 dirstate-entry: add a `removed` property
Closed	marmoute	D10956 dirstate-entry: add a `from_p2` property
Closed	marmoute	D10955 dirstate-entry: add a `merged` property
Closed	marmoute	D10954 dirstate-entry: add a `state` property (and use it)
Closed	marmoute	D10953 dirstate: move most of the `remove` logic with dirstatemap `removefile`
Closed	marmoute	D10952 dirstate: add a `in_merge` property
Closed	marmoute	D10951 dirstate-entry: introduce dedicated accessors for v1 serialization
Closed	marmoute	D10950 dirstate-entry: goes through the `dirstatetuple` constructor in all cases
Closed	marmoute	D10949 dirstate-entry: turn dirstate tuple into a real object (like in C)
Closed	marmoute	D10934 dirstate: split dirstatemap in its own file
Closed	marmoute	D10933 dirstate: explicitely deal with the `added` case in `_addpath`
Closed	marmoute	D10932 dirstate: add an explicit `possibly_dirty` parameter to `_addpath`
Closed	marmoute	D10931 dirstate: add an explicit `from_p2` parameter to `_addpath`
Closed	marmoute	D10930 dirstate: add default value to _addpath
Closed	marmoute	D10929 dirstate: move the _rangemask filtering closer to its storage
Closed	marmoute	D10928 dirstate: introduce a symbolic constant for the AMBIGUOUS_TIME marker
Closed	marmoute	D10927 dirstate: introduce a symbolic constant for the NONNORMAL marker
Closed	marmoute	D10926 dirstate: introduce a symbolic constant for the FROM_P2 marker
Closed	marmoute	D10925 dirstate: split a not-so-one-liner
Closed	marmoute	D10924 dirstate: split a not-so-one-liner
Closed	marmoute	D10923 dirstate: split a not-so-one-liner

Diff 28905

mercurial/dirstate.py

	f,			f,
	state,			state,
	mode,			mode,
	size=None,			size=None,
	mtime=None,			mtime=None,
	from_p2=False,			from_p2=False,
	possibly_dirty=False,			possibly_dirty=False,
	):			):
	oldstate = self[f]
	entry = self._map.get(f)			entry = self._map.get(f)
	if state == b'a' or entry is not None and entry.removed:			if state == b'a' or entry is not None and entry.removed:
	scmutil.checkfilename(f)			scmutil.checkfilename(f)
	if self._map.hastrackeddir(f):			if self._map.hastrackeddir(f):
	msg = _(b'directory %r already in dirstate')			msg = _(b'directory %r already in dirstate')
	msg %= pycompat.bytestr(f)			msg %= pycompat.bytestr(f)
	raise error.Abort(msg)			raise error.Abort(msg)
	# shadows			# shadows
	for d in pathutil.finddirs(f):			for d in pathutil.finddirs(f):
	if self._map.hastrackeddir(d):			if self._map.hastrackeddir(d):
	break			break
	entry = self._map.get(d)			entry = self._map.get(d)
	if entry is not None and not entry.removed:			if entry is not None and not entry.removed:
	msg = _(b'file %r in dirstate clashes with %r')			msg = _(b'file %r in dirstate clashes with %r')
	msg %= (pycompat.bytestr(d), pycompat.bytestr(f))			msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
	raise error.Abort(msg)			raise error.Abort(msg)
	self._dirty = True			self._dirty = True
	self._updatedfiles.add(f)			self._updatedfiles.add(f)
	self._map.addfile(			self._map.addfile(
	f,			f,
	oldstate,
	state=state,			state=state,
	mode=mode,			mode=mode,
	size=size,			size=size,
	mtime=mtime,			mtime=mtime,
	from_p2=from_p2,			from_p2=from_p2,
	possibly_dirty=possibly_dirty,			possibly_dirty=possibly_dirty,
	)			)

mercurial/dirstatemap.py


	def preload(self):			def preload(self):
	"""Loads the underlying data, if it's not already loaded"""			"""Loads the underlying data, if it's not already loaded"""
	self._map			self._map

	def addfile(			def addfile(
	self,			self,
	f,			f,
	oldstate,
	state,			state,
	mode,			mode,
	size=None,			size=None,
	mtime=None,			mtime=None,
	from_p2=False,			from_p2=False,
	possibly_dirty=False,			possibly_dirty=False,
	):			):
	"""Add a tracked file to the dirstate."""			"""Add a tracked file to the dirstate."""
	mtime = AMBIGUOUS_TIME			mtime = AMBIGUOUS_TIME
	else:			else:
	assert size != FROM_P2			assert size != FROM_P2
	assert size != NONNORMAL			assert size != NONNORMAL
	size = size & rangemask			size = size & rangemask
	mtime = mtime & rangemask			mtime = mtime & rangemask
	assert size is not None			assert size is not None
	assert mtime is not None			assert mtime is not None
	if oldstate in b"?r" and "_dirs" in self.__dict__:			old_entry = self.get(f)
				if (
				old_entry is None or old_entry.removed
				) and "_dirs" in self.__dict__:
	self._dirs.addpath(f)			self._dirs.addpath(f)
	if oldstate == b"?" and "_alldirs" in self.__dict__:			if old_entry is None and "_alldirs" in self.__dict__:
	self._alldirs.addpath(f)			self._alldirs.addpath(f)
	self._map[f] = dirstatetuple(state, mode, size, mtime)			self._map[f] = dirstatetuple(state, mode, size, mtime)
	if state != b'n' or mtime == AMBIGUOUS_TIME:			if state != b'n' or mtime == AMBIGUOUS_TIME:
	self.nonnormalset.add(f)			self.nonnormalset.add(f)
	if size == FROM_P2:			if size == FROM_P2:
	self.otherparentset.add(f)			self.otherparentset.add(f)

	def removefile(self, f, in_merge=False):			def removefile(self, f, in_merge=False):
	b"experimental",			b"experimental",
	b"dirstate-tree.in-memory",			b"dirstate-tree.in-memory",
	False,			False,
	)			)

	def addfile(			def addfile(
	self,			self,
	f,			f,
	oldstate,
	state,			state,
	mode,			mode,
	size=None,			size=None,
	mtime=None,			mtime=None,
	from_p2=False,			from_p2=False,
	possibly_dirty=False,			possibly_dirty=False,
	):			):
	return self._rustmap.addfile(			return self._rustmap.addfile(
	f,			f,
	oldstate,
	state,			state,
	mode,			mode,
	size,			size,
	mtime,			mtime,
	from_p2,			from_p2,
	possibly_dirty,			possibly_dirty,
	)			)

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

	self.non_normal_set = None;			self.non_normal_set = None;
	self.other_parent_set = None;			self.other_parent_set = None;
	}			}

	/// Add a tracked file to the dirstate			/// Add a tracked file to the dirstate
	pub fn add_file(			pub fn add_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,
	entry: DirstateEntry,			entry: DirstateEntry,
	// XXX once the dust settle this should probably become an enum			// XXX once the dust settle this should probably become an enum
	from_p2: bool,			from_p2: bool,
	possibly_dirty: bool,			possibly_dirty: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	let mut entry = entry;			let mut entry = entry;
	if entry.state == EntryState::Added {			if entry.state == EntryState::Added {
	assert!(!possibly_dirty);			assert!(!possibly_dirty);
	assert!(!from_p2);			assert!(!from_p2);
	entry.size = SIZE_NON_NORMAL;			entry.size = SIZE_NON_NORMAL;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else if from_p2 {			} else if from_p2 {
	assert!(!possibly_dirty);			assert!(!possibly_dirty);
	entry.size = SIZE_FROM_OTHER_PARENT;			entry.size = SIZE_FROM_OTHER_PARENT;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else if possibly_dirty {			} else if possibly_dirty {
	entry.size = SIZE_NON_NORMAL;			entry.size = SIZE_NON_NORMAL;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else {			} else {
	entry.size = entry.size & V1_RANGEMASK;			entry.size = entry.size & V1_RANGEMASK;
	entry.mtime = entry.mtime & 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 old_state == EntryState::Unknown \|\| old_state == EntryState::Removed
	{			{
	if let Some(ref mut dirs) = self.dirs {			if let Some(ref mut dirs) = self.dirs {
	dirs.add_path(filename)?;			dirs.add_path(filename)?;
	}			}
	}			}
	if old_state == EntryState::Unknown {			if old_state == EntryState::Unknown {
	if let Some(ref mut all_dirs) = self.all_dirs {			if let Some(ref mut all_dirs) = self.all_dirs {
	#[test]			#[test]
	fn test_add_file() {			fn test_add_file() {
	let mut map = DirstateMap::new();			let mut map = DirstateMap::new();

	assert_eq!(0, map.len());			assert_eq!(0, map.len());

	map.add_file(			map.add_file(
	HgPath::new(b"meh"),			HgPath::new(b"meh"),
	EntryState::Normal,
	DirstateEntry {			DirstateEntry {
	state: EntryState::Normal,			state: EntryState::Normal,
	mode: 1337,			mode: 1337,
	mtime: 1337,			mtime: 1337,
	size: 1337,			size: 1337,
	},			},
	false,			false,
	false,			false,

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

	self.root = Default::default();			self.root = Default::default();
	self.nodes_with_entry_count = 0;			self.nodes_with_entry_count = 0;
	self.nodes_with_copy_source_count = 0;			self.nodes_with_copy_source_count = 0;
	}			}

	fn add_file(			fn add_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,
	entry: DirstateEntry,			entry: DirstateEntry,
	from_p2: bool,			from_p2: bool,
	possibly_dirty: bool,			possibly_dirty: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	let mut entry = entry;			let mut entry = entry;
	if entry.state == EntryState::Added {			if entry.state == EntryState::Added {
	assert!(!possibly_dirty);			assert!(!possibly_dirty);
	assert!(!from_p2);			assert!(!from_p2);
	entry.size = SIZE_NON_NORMAL;			entry.size = SIZE_NON_NORMAL;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else if from_p2 {			} else if from_p2 {
	assert!(!possibly_dirty);			assert!(!possibly_dirty);
	entry.size = SIZE_FROM_OTHER_PARENT;			entry.size = SIZE_FROM_OTHER_PARENT;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else if possibly_dirty {			} else if possibly_dirty {
	entry.size = SIZE_NON_NORMAL;			entry.size = SIZE_NON_NORMAL;
	entry.mtime = MTIME_UNSET;			entry.mtime = MTIME_UNSET;
	} else {			} else {
	entry.size = entry.size & V1_RANGEMASK;			entry.size = entry.size & V1_RANGEMASK;
	entry.mtime = entry.mtime & V1_RANGEMASK;			entry.mtime = entry.mtime & V1_RANGEMASK;
	}			}

				let old_state = match self.get(filename)? {
				Some(e) => e.state,
				None => EntryState::Unknown,
				};

	Ok(self.add_or_remove_file(filename, old_state, entry)?)			Ok(self.add_or_remove_file(filename, old_state, entry)?)
	}			}

	fn remove_file(			fn remove_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	in_merge: bool,			in_merge: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {

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

	///			///
	/// `old_state` is the state in the entry that `get` would have returned			/// `old_state` is the state in the entry that `get` would have returned
	/// before this call, or `EntryState::Unknown` if there was no such entry.			/// before this call, or `EntryState::Unknown` if there was no such entry.
	///			///
	/// `entry.state` should never be `EntryState::Unknown`.			/// `entry.state` should never be `EntryState::Unknown`.
	fn add_file(			fn add_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,
	entry: DirstateEntry,			entry: DirstateEntry,
	from_p2: bool,			from_p2: bool,
	possibly_dirty: bool,			possibly_dirty: bool,
	) -> Result<(), DirstateError>;			) -> Result<(), DirstateError>;

	/// Mark a file as "removed" (as in `hg rm`).			/// Mark a file as "removed" (as in `hg rm`).
	///			///
	/// `old_state` is the state in the entry that `get` would have returned			/// `old_state` is the state in the entry that `get` would have returned
	impl DirstateMapMethods for DirstateMap {			impl DirstateMapMethods for DirstateMap {
	fn clear(&mut self) {			fn clear(&mut self) {
	self.clear()			self.clear()
	}			}

	fn add_file(			fn add_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,
	entry: DirstateEntry,			entry: DirstateEntry,
	from_p2: bool,			from_p2: bool,
	possibly_dirty: bool,			possibly_dirty: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	self.add_file(filename, old_state, entry, from_p2, possibly_dirty)			self.add_file(filename, entry, from_p2, possibly_dirty)
	}			}

	fn remove_file(			fn remove_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	in_merge: bool,			in_merge: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	self.remove_file(filename, in_merge)			self.remove_file(filename, in_merge)

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

	},			},
	None => Ok(default)			None => Ok(default)
	}			}
	}			}

	def addfile(			def addfile(
	&self,			&self,
	f: PyObject,			f: PyObject,
	oldstate: PyObject,
	state: PyObject,			state: PyObject,
	mode: PyObject,			mode: PyObject,
	size: PyObject,			size: PyObject,
	mtime: PyObject,			mtime: PyObject,
	from_p2: PyObject,			from_p2: PyObject,
	possibly_dirty: PyObject,			possibly_dirty: PyObject,
	) -> PyResult<PyObject> {			) -> PyResult<PyObject> {
	let f = f.extract::<PyBytes>(py)?;			let f = f.extract::<PyBytes>(py)?;
	let filename = HgPath::new(f.data(py));			let filename = HgPath::new(f.data(py));
	let oldstate = oldstate.extract::<PyBytes>(py)?.data(py)[0]
	.try_into()
	.map_err(\|e: HgError\| {
	PyErr::new::<exc::ValueError, _>(py, e.to_string())
	})?;
	let state = state.extract::<PyBytes>(py)?.data(py)[0]			let state = state.extract::<PyBytes>(py)?.data(py)[0]
	.try_into()			.try_into()
	.map_err(\|e: HgError\| {			.map_err(\|e: HgError\| {
	PyErr::new::<exc::ValueError, _>(py, e.to_string())			PyErr::new::<exc::ValueError, _>(py, e.to_string())
	})?;			})?;
	let mode = mode.extract(py)?;			let mode = mode.extract(py)?;
	let size = if size.is_none(py) {			let size = if size.is_none(py) {
	// fallback default value			// fallback default value
	mode: mode,			mode: mode,
	size: size,			size: size,
	mtime: mtime,			mtime: mtime,
	};			};
	let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();			let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();
	let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();			let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();
	self.inner(py).borrow_mut().add_file(			self.inner(py).borrow_mut().add_file(
	filename,			filename,
	oldstate,
	entry,			entry,
	from_p2,			from_p2,
	possibly_dirty			possibly_dirty
	).and(Ok(py.None())).or_else(\|e: DirstateError\| {			).and(Ok(py.None())).or_else(\|e: DirstateError\| {
	Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))			Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))
	})			})
	}			}

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

	impl DirstateMapMethods for OwningDirstateMap {			impl DirstateMapMethods for OwningDirstateMap {
	fn clear(&mut self) {			fn clear(&mut self) {
	self.get_mut().clear()			self.get_mut().clear()
	}			}

	fn add_file(			fn add_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,
	entry: DirstateEntry,			entry: DirstateEntry,
	from_p2: bool,			from_p2: bool,
	possibly_dirty: bool,			possibly_dirty: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	self.get_mut().add_file(			self.get_mut()
	filename,			.add_file(filename, entry, from_p2, possibly_dirty)
	old_state,
	entry,
	from_p2,
	possibly_dirty,
	)
	}			}

	fn remove_file(			fn remove_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	in_merge: bool,			in_merge: bool,
	) -> Result<(), DirstateError> {			) -> Result<(), DirstateError> {
	self.get_mut().remove_file(filename, in_merge)			self.get_mut().remove_file(filename, in_merge)

This is an archive of the discontinued Mercurial Phabricator instance.

dirstate: no longer pass the `oldstate` value to the dirstatemapClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 28905

mercurial/dirstate.py

mercurial/dirstatemap.py

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

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

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

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

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

dirstate: no longer pass the `oldstate` value to the dirstatemap
ClosedPublic

Revision Contents
Changeset List