This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			mercurial/dirstate.py (10 lines)
M			rust/hg-core/src/dirstate_tree/dispatch.rs (63 lines)
M			rust/hg-cpython/src/dirstate/dirstate_map.rs (42 lines)
M			rust/hg-cpython/src/dirstate/non_normal_entries.rs (11 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	26816		Apr 12 2021, 8:23 AM	★	★
Diff 2	27047		Apr 19 2021, 11:02 AM	★	★
Diff 3	27314		May 3 2021, 6:23 AM	★	★
Diff 4	27638	rHGdfd8639a977adfe676218969ab6f34a90816127a	Apr 8 2021, 8:58 AM	★	★

Commit	Parents	Author	Summary	Date
6567fc8eb7de	77a3da807e55	Simon Sapin		Apr 8 2021, 8:58 AM

Status	Author	Revision
Closed	SimonSapin	D10560 dirstate-tree: Borrow paths from the "on disk" bytes
Closed	SimonSapin	D10559 dirstate-tree: Borrow copy source paths from the "on disk" bytes
Closed	SimonSapin	D10558 rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs
Closed	SimonSapin	D10557 dirstate-tree: Make `DirstateMap` borrow from a bytes buffer
Closed	SimonSapin	D10556 rust: Read dirstate from disk in DirstateMap constructor
Closed	SimonSapin	D10555 rust: Remove handling of `parents` in `DirstateMap`
Closed	SimonSapin	D10554 dirstate-tree: Fold "tracked descendants" counter update in main walk
Closed	SimonSapin	D10553 dirstate-tree: Use HashMap instead of BTreeMap
Closed	SimonSapin	D10552 dirstate-tree: Add #[timed] attribute to `status` and `DirstateMap::read`
Closed	SimonSapin	D10551 dirstate-tree: Paralellize the status algorithm with Rayon
Closed	SimonSapin	D10550 dirstate-tree: Avoid BTreeMap double-lookup when inserting a dirstate entry
Closed	SimonSapin	D10549 dirstate-tree: Handle I/O errors in status
Closed	SimonSapin	D10548 dirstate-tree: Ignore FIFOs etc. in the status algorithm
Closed	SimonSapin	D10547 dirstate-tree: Add the new `status()` algorithm
Closed	SimonSapin	D10546 dirstate-tree: Give to `status()` mutable access to the `DirstateMap`
Closed	SimonSapin	D10495 rust: Add doc-comments to DirstateStatus fields
Closed	SimonSapin	D10494 rust: Move "lookup" a.k.a. "unsure" paths into `DirstateStatus` struct
Closed	SimonSapin	D10493 rust: Remove DirstateMap::file_fold_map
Closed	SimonSapin	D10492 dirstate-tree: Add "non normal" and "from other parent" sets
Closed	SimonSapin	D10491 dirstate-tree: Add add_file, remove_file, and drop_file
Closed	SimonSapin	D10490 dirstate-tree: Add has_dir and has_tracked_dir
Closed	SimonSapin	D10489 dirstate-tree: Add clear_ambiguous_times in the new DirstateMap
Closed	SimonSapin	D10488 dirstate-tree: Add copy_map_insert and copy_map_remove
Closed	SimonSapin	D10487 dirstate-tree: Maintain a counter of DirstateEntry’s and copy sources
Closed	SimonSapin	D10486 dirstate-tree: Serialize to disk
Closed	SimonSapin	D10485 rust: Add a Timestamp struct instead of abusing Duration
Closed	SimonSapin	D10370 dirstate-tree: Add tree traversal/iteration
Closed	SimonSapin	D10369 dirstate-tree: Add map `get` and `contains_key` methods
Closed	SimonSapin	D10368 dirstate-tree: Add parsing only dirstate parents from disk
Closed	SimonSapin	D10367 dirstate-tree: Implement DirstateMap::read
Abandoned	SimonSapin	D10366 rust: Refactor parse_dirstate() to take a callback
Closed	SimonSapin	D10365 dirstate-tree: Add `WithBasename` wrapper for `HgPath`
Closed	SimonSapin	D10364 dirstate-tree: Empty shell for a second Rust DirstateMap implementation
Closed	SimonSapin	D10363 dirstate-tree: Abstract "non-normal" and "other parent" sets
Closed	SimonSapin	D10362 dirstate-tree: Make Rust DirstateMap bindings go through a trait object

Diff 27047

mercurial/dirstate.py


	self._dirty = True			self._dirty = True
	oldp2 = self._pl[1]			oldp2 = self._pl[1]
	if self._origpl is None:			if self._origpl is None:
	self._origpl = self._pl			self._origpl = self._pl
	self._map.setparents(p1, p2)			self._map.setparents(p1, p2)
	copies = {}			copies = {}
	if oldp2 != nullid and p2 == nullid:			if oldp2 != nullid and p2 == nullid:
	candidatefiles = self._map.nonnormalset.union(			candidatefiles = self._map.non_normal_or_other_parent_paths()
	self._map.otherparentset
	)
	for f in candidatefiles:			for f in candidatefiles:
	s = self._map.get(f)			s = self._map.get(f)
	if s is None:			if s is None:
	continue			continue

	# Discard 'm' markers when moving away from a merge state			# Discard 'm' markers when moving away from a merge state
	if s[0] == b'm':			if s[0] == b'm':
	source = self._map.copymap.get(f)			source = self._map.copymap.get(f)
	return nonnorm			return nonnorm

	@propertycache			@propertycache
	def otherparentset(self):			def otherparentset(self):
	nonnorm, otherparents = self.nonnormalentries()			nonnorm, otherparents = self.nonnormalentries()
	self.nonnormalset = nonnorm			self.nonnormalset = nonnorm
	return otherparents			return otherparents

				def non_normal_or_other_parent_paths(self):
				return self.nonnormalset.union(self.otherparentset)

	@propertycache			@propertycache
	def identity(self):			def identity(self):
	self._map			self._map
	return self.identity			return self.identity

	@propertycache			@propertycache
	def dirfoldmap(self):			def dirfoldmap(self):
	f = {}			f = {}
	nonnorm = self._rustmap.non_normal_entries()			nonnorm = self._rustmap.non_normal_entries()
	return nonnorm			return nonnorm

	@propertycache			@propertycache
	def otherparentset(self):			def otherparentset(self):
	otherparents = self._rustmap.other_parent_entries()			otherparents = self._rustmap.other_parent_entries()
	return otherparents			return otherparents

				def non_normal_or_other_parent_paths(self):
				return self._rustmap.non_normal_or_other_parent_paths()

	@propertycache			@propertycache
	def dirfoldmap(self):			def dirfoldmap(self):
	f = {}			f = {}
	normcase = util.normcase			normcase = util.normcase
	for name in self._dirs:			for name in self._dirs:
	f[normcase(name)] = name			f[normcase(name)] = name
	return f			return f

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

	use std::collections::HashSet;
	use std::path::PathBuf;			use std::path::PathBuf;
	use std::time::Duration;			use std::time::Duration;

	use crate::matchers::Matcher;			use crate::matchers::Matcher;
	use crate::utils::hg_path::{HgPath, HgPathBuf};			use crate::utils::hg_path::{HgPath, HgPathBuf};
	use crate::CopyMapIter;			use crate::CopyMapIter;
	use crate::DirstateEntry;			use crate::DirstateEntry;
	use crate::DirstateError;			use crate::DirstateError;
	fn drop_file(			fn drop_file(
	&mut self,			&mut self,
	filename: &HgPath,			filename: &HgPath,
	old_state: EntryState,			old_state: EntryState,
	) -> Result<bool, DirstateMapError>;			) -> Result<bool, DirstateMapError>;

	fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32);			fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32);

				fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool;

	fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;			fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool;

	fn non_normal_entries_union(			fn non_normal_or_other_parent_paths(
	&mut self,			&mut self,
	other: HashSet<HgPathBuf>,			) -> Box<dyn Iterator<Item = &HgPathBuf> + '_>;
	) -> Vec<HgPathBuf>;

	fn set_non_normal_other_parent_entries(&mut self, force: bool);			fn set_non_normal_other_parent_entries(&mut self, force: bool);

	fn get_non_normal_other_parent_entries_panic(			fn iter_non_normal_paths(
				&mut self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;

				fn iter_non_normal_paths_panic(
	&self,			&self,
	) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>);			) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;

	fn get_non_normal_other_parent_entries(			fn iter_other_parent_paths(
	&mut self,			&mut self,
	) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>);			) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_>;

	fn has_tracked_dir(			fn has_tracked_dir(
	&mut self,			&mut self,
	directory: &HgPath,			directory: &HgPath,
	) -> Result<bool, DirstateMapError>;			) -> Result<bool, DirstateMapError>;

	fn has_dir(			fn has_dir(
	&mut self,			&mut self,
	) -> Result<bool, DirstateMapError> {			) -> Result<bool, DirstateMapError> {
	self.drop_file(filename, old_state)			self.drop_file(filename, old_state)
	}			}

	fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) {			fn clear_ambiguous_times(&mut self, filenames: Vec<HgPathBuf>, now: i32) {
	self.clear_ambiguous_times(filenames, now)			self.clear_ambiguous_times(filenames, now)
	}			}

				fn non_normal_entries_contains(&mut self, key: &HgPath) -> bool {
				let (non_normal, _other_parent) =
				self.get_non_normal_other_parent_entries();
				non_normal.contains(key)
				}

	fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {			fn non_normal_entries_remove(&mut self, key: &HgPath) -> bool {
	self.non_normal_entries_remove(key)			self.non_normal_entries_remove(key)
	}			}

	fn non_normal_entries_union(			fn non_normal_or_other_parent_paths(
	&mut self,			&mut self,
	other: HashSet<HgPathBuf>,			) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
	) -> Vec<HgPathBuf> {			let (non_normal, other_parent) =
	self.non_normal_entries_union(other)			self.get_non_normal_other_parent_entries();
				Box::new(non_normal.union(other_parent))
	}			}

	fn set_non_normal_other_parent_entries(&mut self, force: bool) {			fn set_non_normal_other_parent_entries(&mut self, force: bool) {
	self.set_non_normal_other_parent_entries(force)			self.set_non_normal_other_parent_entries(force)
	}			}

	fn get_non_normal_other_parent_entries_panic(			fn iter_non_normal_paths(
				&mut self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
				let (non_normal, _other_parent) =
				self.get_non_normal_other_parent_entries();
				Box::new(non_normal.iter())
				}

				fn iter_non_normal_paths_panic(
	&self,			&self,
	) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) {			) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
	self.get_non_normal_other_parent_entries_panic()			let (non_normal, _other_parent) =
				self.get_non_normal_other_parent_entries_panic();
				Box::new(non_normal.iter())
	}			}

	fn get_non_normal_other_parent_entries(			fn iter_other_parent_paths(
	&mut self,			&mut self,
	) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) {			) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
	self.get_non_normal_other_parent_entries()			let (_non_normal, other_parent) =
				self.get_non_normal_other_parent_entries();
				Box::new(other_parent.iter())
	}			}

	fn has_tracked_dir(			fn has_tracked_dir(
	&mut self,			&mut self,
	directory: &HgPath,			directory: &HgPath,
	) -> Result<bool, DirstateMapError> {			) -> Result<bool, DirstateMapError> {
	self.has_tracked_dir(directory)			self.has_tracked_dir(directory)
	}			}

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

	.collect();			.collect();
	self.inner(py).borrow_mut()			self.inner(py).borrow_mut()
	.clear_ambiguous_times(files?, now.extract(py)?);			.clear_ambiguous_times(files?, now.extract(py)?);
	Ok(py.None())			Ok(py.None())
	}			}

	def other_parent_entries(&self) -> PyResult<PyObject> {			def other_parent_entries(&self) -> PyResult<PyObject> {
	let mut inner_shared = self.inner(py).borrow_mut();			let mut inner_shared = self.inner(py).borrow_mut();
	let (_, other_parent) =
	inner_shared.get_non_normal_other_parent_entries();

	let set = PySet::empty(py)?;			let set = PySet::empty(py)?;
	for path in other_parent.iter() {			for path in inner_shared.iter_other_parent_paths() {
	set.add(py, PyBytes::new(py, path.as_bytes()))?;			set.add(py, PyBytes::new(py, path.as_bytes()))?;
	}			}
	Ok(set.into_object())			Ok(set.into_object())
	}			}

	def non_normal_entries(&self) -> PyResult<NonNormalEntries> {			def non_normal_entries(&self) -> PyResult<NonNormalEntries> {
	NonNormalEntries::from_inner(py, self.clone_ref(py))			NonNormalEntries::from_inner(py, self.clone_ref(py))
	}			}

	def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {			def non_normal_entries_contains(&self, key: PyObject) -> PyResult<bool> {
	let key = key.extract::<PyBytes>(py)?;			let key = key.extract::<PyBytes>(py)?;
	Ok(self			Ok(self
	.inner(py)			.inner(py)
	.borrow_mut()			.borrow_mut()
	.get_non_normal_other_parent_entries().0			.non_normal_entries_contains(HgPath::new(key.data(py))))
	.contains(HgPath::new(key.data(py))))
	}			}

	def non_normal_entries_display(&self) -> PyResult<PyString> {			def non_normal_entries_display(&self) -> PyResult<PyString> {
	Ok(			Ok(
	PyString::new(			PyString::new(
	py,			py,
	&format!(			&format!(
	"NonNormalEntries: {:?}",			"NonNormalEntries: {}",
				hg::utils::join_display(
	self			self
	.inner(py)			.inner(py)
	.borrow_mut()			.borrow_mut()
	.get_non_normal_other_parent_entries().0			.iter_non_normal_paths(),
	.iter().map(\|o\| o))			", "
				)
				)
	)			)
	)			)
	}			}

	def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {			def non_normal_entries_remove(&self, key: PyObject) -> PyResult<PyObject> {
	let key = key.extract::<PyBytes>(py)?;			let key = key.extract::<PyBytes>(py)?;
	self			self
	.inner(py)			.inner(py)
	.borrow_mut()			.borrow_mut()
	.non_normal_entries_remove(HgPath::new(key.data(py)));			.non_normal_entries_remove(HgPath::new(key.data(py)));
	Ok(py.None())			Ok(py.None())
	}			}

	def non_normal_entries_union(&self, other: PyObject) -> PyResult<PyList> {			def non_normal_or_other_parent_paths(&self) -> PyResult<PyList> {
	let other: PyResult<_> = other.iter(py)?			let mut inner = self.inner(py).borrow_mut();
	.map(\|f\| {
	Ok(HgPathBuf::from_bytes(
	f?.extract::<PyBytes>(py)?.data(py),
	))
	})
	.collect();

	let res = self
	.inner(py)
	.borrow_mut()
	.non_normal_entries_union(other?);

	let ret = PyList::new(py, &[]);			let ret = PyList::new(py, &[]);
	for filename in res.iter() {			for filename in inner.non_normal_or_other_parent_paths() {
	let as_pystring = PyBytes::new(py, filename.as_bytes());			let as_pystring = PyBytes::new(py, filename.as_bytes());
	ret.append(py, as_pystring.into_object());			ret.append(py, as_pystring.into_object());
	}			}
	Ok(ret)			Ok(ret)
	}			}

	def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {			def non_normal_entries_iter(&self) -> PyResult<NonNormalEntriesIterator> {
	// Make sure the sets are defined before we no longer have a mutable			// Make sure the sets are defined before we no longer have a mutable
	// reference to the dmap.			// reference to the dmap.
	self.inner(py)			self.inner(py)
	.borrow_mut()			.borrow_mut()
	.set_non_normal_other_parent_entries(false);			.set_non_normal_other_parent_entries(false);

	let leaked_ref = self.inner(py).leak_immutable();			let leaked_ref = self.inner(py).leak_immutable();

	NonNormalEntriesIterator::from_inner(py, unsafe {			NonNormalEntriesIterator::from_inner(py, unsafe {
	leaked_ref.map(py, \|o\| {			leaked_ref.map(py, \|o\| {
	o.get_non_normal_other_parent_entries_panic().0.iter()			o.iter_non_normal_paths_panic()
	})			})
	})			})
	}			}

	def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {			def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
	let d = d.extract::<PyBytes>(py)?;			let d = d.extract::<PyBytes>(py)?;
	Ok(self.inner(py).borrow_mut()			Ok(self.inner(py).borrow_mut()
	.has_tracked_dir(HgPath::new(d.data(py)))			.has_tracked_dir(HgPath::new(d.data(py)))

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

	// non_normal_other_parent_entries.rs			// non_normal_other_parent_entries.rs
	//			//
	// Copyright 2020 Raphaël Gomès <rgomes@octobus.net>			// Copyright 2020 Raphaël Gomès <rgomes@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 cpython::{			use cpython::{
	exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,			exc::NotImplementedError, CompareOp, ObjectProtocol, PyBytes, PyClone,
	PyErr, PyList, PyObject, PyResult, PyString, Python, PythonObject,			PyErr, PyObject, PyResult, PyString, Python, PythonObject, ToPyObject,
	ToPyObject, UnsafePyLeaked,			UnsafePyLeaked,
	};			};

	use crate::dirstate::DirstateMap;			use crate::dirstate::DirstateMap;
	use hg::utils::hg_path::HgPathBuf;			use hg::utils::hg_path::HgPathBuf;
	use std::cell::RefCell;			use std::cell::RefCell;
	use std::collections::hash_set;

	py_class!(pub class NonNormalEntries \|py\| {			py_class!(pub class NonNormalEntries \|py\| {
	data dmap: DirstateMap;			data dmap: DirstateMap;

	def __contains__(&self, key: PyObject) -> PyResult<bool> {			def __contains__(&self, key: PyObject) -> PyResult<bool> {
	self.dmap(py).non_normal_entries_contains(py, key)			self.dmap(py).non_normal_entries_contains(py, key)
	}			}
	def remove(&self, key: PyObject) -> PyResult<PyObject> {			def remove(&self, key: PyObject) -> PyResult<PyObject> {
	self.dmap(py).non_normal_entries_remove(py, key)			self.dmap(py).non_normal_entries_remove(py, key)
	}			}
	def union(&self, other: PyObject) -> PyResult<PyList> {
	self.dmap(py).non_normal_entries_union(py, other)
	}
	def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> {			def __richcmp__(&self, other: PyObject, op: CompareOp) -> PyResult<bool> {
	match op {			match op {
	CompareOp::Eq => self.is_equal_to(py, other),			CompareOp::Eq => self.is_equal_to(py, other),
	CompareOp::Ne => Ok(!self.is_equal_to(py, other)?),			CompareOp::Ne => Ok(!self.is_equal_to(py, other)?),
	_ => Err(PyErr::new::<NotImplementedError, _>(py, ""))			_ => Err(PyErr::new::<NotImplementedError, _>(py, ""))
	}			}
	}			}
	def __repr__(&self) -> PyResult<PyString> {			def __repr__(&self) -> PyResult<PyString> {
	fn translate_key(			fn translate_key(
	py: Python,			py: Python,
	key: &HgPathBuf,			key: &HgPathBuf,
	) -> PyResult<Option<PyBytes>> {			) -> PyResult<Option<PyBytes>> {
	Ok(Some(PyBytes::new(py, key.as_bytes())))			Ok(Some(PyBytes::new(py, key.as_bytes())))
	}			}
	}			}

	type NonNormalEntriesIter<'a> = hash_set::Iter<'a, HgPathBuf>;			type NonNormalEntriesIter<'a> =
				Box<dyn Iterator<Item = &'a HgPathBuf> + Send + 'a>;

	py_shared_iterator!(			py_shared_iterator!(
	NonNormalEntriesIterator,			NonNormalEntriesIterator,
	UnsafePyLeaked<NonNormalEntriesIter<'static>>,			UnsafePyLeaked<NonNormalEntriesIter<'static>>,
	NonNormalEntries::translate_key,			NonNormalEntries::translate_key,
	Option<PyBytes>			Option<PyBytes>
	);			);

This is an archive of the discontinued Mercurial Phabricator instance.

dirstate-tree: Abstract "non-normal" and "other parent" setsClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 27047

mercurial/dirstate.py

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

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

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

dirstate-tree: Abstract "non-normal" and "other parent" sets
ClosedPublic

Revision Contents
Changeset List