This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11686

dirstate: add a concept of "fallback" flags to dirstate item
ClosedPublic

Authored by marmoute on Oct 18 2021, 9:20 PM.

Download Raw Diff

Details

Reviewers

Alphare

Group Reviewers

hg-reviewers

Commits

rHG602c8e8411f5: dirstate: add a concept of "fallback" flags to dirstate item

Summary

The concept is defined and "used" by the flag code, but it is neither persisted
nor set anywhere yet. We currently focus on defining the semantic of the
attribute. More to come in the next changesets

Check the inline documentation for details.

Diff Detail

Repository

rHG Mercurial

Lint

Automatic diff as part of commit; lint not applicable.

Unit

Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Oct 18 2021, 9:20 PM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptOct 18 2021, 9:20 PM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

marmoute added a child revision: D11687: dirstate: make DirstateItem constructor accept fallback value.Oct 18 2021, 9:20 PM

Nice! I'd love an experimental UI for this if this is the last py2 release, but even if it's just used in the background so that rebasing/amending added files stops dropping these bits, it would be a major benefit.

I glossed over the rust code, so if someone familiar with it could make a pass, I'd appreciate it.

mercurial/dirstate.py
295–296	Is there a reason we don't need a similar `elif` for exec in the symlink case above? (What if there's a symlink fallback, but not exec fallback?) Also, is symlink and exec mutually exclusive? I'd think not for the platforms where it's read from the filesystem, but maybe that's sanitized away somewhere?
mercurial/pure/parsers.py
291	/True is/ True if/ (same issue below for symlink function)
324	This cast ends up masking out the `None`, which is not what `has_fallback_exec` seems to expect. Or am I misunderstanding? (Same comment for symlink below)

Adding my comments on top of Matt's.

mercurial/cext/parsers.c
512	Why are these called `_get_has_`? Is it a convention or just accidental?
rust/hg-core/src/dirstate/entry.rs
25	Shouldn't those be in the flags in the form of 4 total bits?

This revision now requires changes to proceed.Oct 19 2021, 4:15 AM

In D11686#179283, @mharbison72 wrote:

Nice! I'd love an experimental UI for this if this is the last py2 release,

I am not sure 6.0 would be the last py2 release since we still do not have python3 packaging for TortoiseHG …

but even if it's just used in the background so that rebasing/amending added files stops dropping these bits, it would be a major benefit.

I do not think we will have the time to do more than implement basic flag semantic in 6.0. Putting them to use will have to wait until 6.1 am I afraid.

I glossed over the rust code, so if someone familiar with it could make a pass, I'd appreciate it.

mercurial/cext/parsers.c
512	This is the `getter` of the `has_fallback_xxx` property. So the name is legitimate.
mercurial/dirstate.py
295–296	The "FS" code return `l` regarless of the `x` status if this is a symlink. The logic you comment comply with that. If we have a symlink_fallback but no symlink_flag, we still need to check for `x`. However if we have fallback for both but non set, we know we have no flag.
mercurial/pure/parsers.py
324	good catch, thanks.
rust/hg-core/src/dirstate/entry.rs
25	Yes they should. I remember thinking about it, but apparently then forgot about that. Fixing it.

marmoute updated this revision to Diff 30891.Oct 19 2021, 7:49 AM

Alphare accepted this revision.Oct 19 2021, 8:12 AM

This revision is now accepted and ready to land.Oct 19 2021, 8:12 AM

marmoute added a commit: rHG602c8e8411f5: dirstate: add a concept of "fallback" flags to dirstate item.Oct 19 2021, 1:01 PM

Closed by commit rHG602c8e8411f5: dirstate: add a concept of "fallback" flags to dirstate item (authored by marmoute). · Explain Why

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
M			mercurial/cext/parsers.c (96 lines)
M			mercurial/cext/util.h (4 lines)
M			mercurial/dirstate.py (23 lines)
M			mercurial/pure/parsers.py (84 lines)
M			rust/hg-core/src/dirstate/entry.rs (50 lines)
M			rust/hg-cpython/src/dirstate/item.rs (65 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	30885		Oct 18 2021, 9:20 PM	★	★
Diff 2	30891		Oct 19 2021, 7:49 AM	★	★
Diff 3	30901	rHG602c8e8411f55814a1d5b6f728c2f5ca792ab421	Oct 18 2021, 2:02 PM	★	★

Status	Author	Revision
Closed	marmoute	D11688 dirstate-v2: preserve the fallback values on disk
Closed	marmoute	D11687 dirstate: make DirstateItem constructor accept fallback value
Closed	marmoute	D11686 dirstate: add a concept of "fallback" flags to dirstate item
Closed	marmoute	D11682 dirstate-v2: adds two flag to track the presence of some unrecorded files
Closed	marmoute	D11681 dirstate-v2: adds a flag to mark a file as modified

Diff 30901

mercurial/cext/parsers.c

	return 'm';			return 'm';
	} else if (dirstate_item_c_added(self)) {			} else if (dirstate_item_c_added(self)) {
	return 'a';			return 'a';
	} else {			} else {
	return 'n';			return 'n';
	}			}
	}			}

				static inline bool dirstate_item_c_has_fallback_exec(dirstateItemObject *self)
				{
				return (bool)self->flags & dirstate_flag_has_fallback_exec;
				}

				static inline bool
				dirstate_item_c_has_fallback_symlink(dirstateItemObject *self)
				{
				return (bool)self->flags & dirstate_flag_has_fallback_symlink;
				}

	static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)			static inline int dirstate_item_c_v1_mode(dirstateItemObject *self)
	{			{
	if (self->flags & dirstate_flag_has_meaningful_data) {			if (self->flags & dirstate_flag_has_meaningful_data) {
	return self->mode;			return self->mode;
	} else {			} else {
	return 0;			return 0;
	}			}
	}			}
	};			};

	static PyObject dirstate_item_get_state(dirstateItemObject self)			static PyObject dirstate_item_get_state(dirstateItemObject self)
	{			{
	char state = dirstate_item_c_v1_state(self);			char state = dirstate_item_c_v1_state(self);
	return PyBytes_FromStringAndSize(&state, 1);			return PyBytes_FromStringAndSize(&state, 1);
	};			};

				static PyObject dirstate_item_get_has_fallback_exec(dirstateItemObject self)
				AlphareUnsubmitted Not Done Why are these called `_get_has_`? Is it a convention or just accidental? Alphare: Why are these called `_get_has_`? Is it a convention or just accidental?
				marmouteAuthorUnsubmitted Done This is the `getter` of the `has_fallback_xxx` property. So the name is legitimate. marmoute: This is the `getter` of the `has_fallback_xxx` property. So the name is legitimate.
				{
				if (dirstate_item_c_has_fallback_exec(self)) {
				Py_RETURN_TRUE;
				} else {
				Py_RETURN_FALSE;
				}
				};

				static PyObject dirstate_item_get_fallback_exec(dirstateItemObject self)
				{
				if (dirstate_item_c_has_fallback_exec(self)) {
				if (self->flags & dirstate_flag_fallback_exec) {
				Py_RETURN_TRUE;
				} else {
				Py_RETURN_FALSE;
				}
				} else {
				Py_RETURN_NONE;
				}
				};

				static int dirstate_item_set_fallback_exec(dirstateItemObject *self,
				PyObject *value)
				{
				if ((value == Py_None) \|\| (value == NULL)) {
				self->flags &= ~dirstate_flag_has_fallback_exec;
				} else {
				self->flags \|= dirstate_flag_has_fallback_exec;
				if (PyObject_IsTrue(value)) {
				self->flags \|= dirstate_flag_fallback_exec;
				} else {
				self->flags &= ~dirstate_flag_fallback_exec;
				}
				}
				return 0;
				};

				static PyObject *
				dirstate_item_get_has_fallback_symlink(dirstateItemObject *self)
				{
				if (dirstate_item_c_has_fallback_symlink(self)) {
				Py_RETURN_TRUE;
				} else {
				Py_RETURN_FALSE;
				}
				};

				static PyObject dirstate_item_get_fallback_symlink(dirstateItemObject self)
				{
				if (dirstate_item_c_has_fallback_symlink(self)) {
				if (self->flags & dirstate_flag_fallback_symlink) {
				Py_RETURN_TRUE;
				} else {
				Py_RETURN_FALSE;
				}
				} else {
				Py_RETURN_NONE;
				}
				};

				static int dirstate_item_set_fallback_symlink(dirstateItemObject *self,
				PyObject *value)
				{
				if ((value == Py_None) \|\| (value == NULL)) {
				self->flags &= ~dirstate_flag_has_fallback_symlink;
				} else {
				self->flags \|= dirstate_flag_has_fallback_symlink;
				if (PyObject_IsTrue(value)) {
				self->flags \|= dirstate_flag_fallback_symlink;
				} else {
				self->flags &= ~dirstate_flag_fallback_symlink;
				}
				}
				return 0;
				};

	static PyObject dirstate_item_get_tracked(dirstateItemObject self)			static PyObject dirstate_item_get_tracked(dirstateItemObject self)
	{			{
	if (dirstate_item_c_tracked(self)) {			if (dirstate_item_c_tracked(self)) {
	Py_RETURN_TRUE;			Py_RETURN_TRUE;
	} else {			} else {
	Py_RETURN_FALSE;			Py_RETURN_FALSE;
	}			}
	};			};
	}			}
	};			};

	static PyGetSetDef dirstate_item_getset[] = {			static PyGetSetDef dirstate_item_getset[] = {
	{"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},			{"mode", (getter)dirstate_item_get_mode, NULL, "mode", NULL},
	{"size", (getter)dirstate_item_get_size, NULL, "size", NULL},			{"size", (getter)dirstate_item_get_size, NULL, "size", NULL},
	{"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},			{"mtime", (getter)dirstate_item_get_mtime, NULL, "mtime", NULL},
	{"state", (getter)dirstate_item_get_state, NULL, "state", NULL},			{"state", (getter)dirstate_item_get_state, NULL, "state", NULL},
				{"has_fallback_exec", (getter)dirstate_item_get_has_fallback_exec, NULL,
				"has_fallback_exec", NULL},
				{"fallback_exec", (getter)dirstate_item_get_fallback_exec,
				(setter)dirstate_item_set_fallback_exec, "fallback_exec", NULL},
				{"has_fallback_symlink", (getter)dirstate_item_get_has_fallback_symlink,
				NULL, "has_fallback_symlink", NULL},
				{"fallback_symlink", (getter)dirstate_item_get_fallback_symlink,
				(setter)dirstate_item_set_fallback_symlink, "fallback_symlink", NULL},
	{"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},			{"tracked", (getter)dirstate_item_get_tracked, NULL, "tracked", NULL},
	{"p1_tracked", (getter)dirstate_item_get_p1_tracked, NULL, "p1_tracked",			{"p1_tracked", (getter)dirstate_item_get_p1_tracked, NULL, "p1_tracked",
	NULL},			NULL},
	{"added", (getter)dirstate_item_get_added, NULL, "added", NULL},			{"added", (getter)dirstate_item_get_added, NULL, "added", NULL},
	{"p2_info", (getter)dirstate_item_get_p2_info, NULL, "p2_info", NULL},			{"p2_info", (getter)dirstate_item_get_p2_info, NULL, "p2_info", NULL},
	{"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},			{"merged", (getter)dirstate_item_get_merged, NULL, "merged", NULL},
	{"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},			{"from_p2", (getter)dirstate_item_get_from_p2, NULL, "from_p2", NULL},
	{"maybe_clean", (getter)dirstate_item_get_maybe_clean, NULL, "maybe_clean",			{"maybe_clean", (getter)dirstate_item_get_maybe_clean, NULL, "maybe_clean",

mercurial/cext/util.h

	static const int dirstate_flag_has_meaningful_data = 1 << 3;			static const int dirstate_flag_has_meaningful_data = 1 << 3;
	static const int dirstate_flag_has_file_mtime = 1 << 4;			static const int dirstate_flag_has_file_mtime = 1 << 4;
	static const int dirstate_flag_has_directory_mtime = 1 << 5;			static const int dirstate_flag_has_directory_mtime = 1 << 5;
	static const int dirstate_flag_mode_exec_perm = 1 << 6;			static const int dirstate_flag_mode_exec_perm = 1 << 6;
	static const int dirstate_flag_mode_is_symlink = 1 << 7;			static const int dirstate_flag_mode_is_symlink = 1 << 7;
	static const int dirstate_flag_expected_state_is_modified = 1 << 8;			static const int dirstate_flag_expected_state_is_modified = 1 << 8;
	static const int dirstate_flag_all_unknown_recorded = 1 << 9;			static const int dirstate_flag_all_unknown_recorded = 1 << 9;
	static const int dirstate_flag_all_ignored_recorded = 1 << 10;			static const int dirstate_flag_all_ignored_recorded = 1 << 10;
				static const int dirstate_flag_fallback_exec = 1 << 11;
				static const int dirstate_flag_has_fallback_exec = 1 << 12;
				static const int dirstate_flag_fallback_symlink = 1 << 13;
				static const int dirstate_flag_has_fallback_symlink = 1 << 14;

	extern PyTypeObject dirstateItemType;			extern PyTypeObject dirstateItemType;
	#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType)			#define dirstate_tuple_check(op) (Py_TYPE(op) == &dirstateItemType)

	#ifndef MIN			#ifndef MIN
	#define MIN(a, b) (((a) < (b)) ? (a) : (b))			#define MIN(a, b) (((a) < (b)) ? (a) : (b))
	#endif			#endif
	/* VC9 doesn't include bool and lacks stdbool.h based on my searching */			/* VC9 doesn't include bool and lacks stdbool.h based on my searching */

mercurial/dirstate.py

	return f			return f

	fallback = buildfallback()			fallback = buildfallback()
	if self._checklink:			if self._checklink:

	def f(x):			def f(x):
	if os.path.islink(self._join(x)):			if os.path.islink(self._join(x)):
	return b'l'			return b'l'
	if b'x' in fallback(x):			entry = self.get_entry(x)
				if entry.has_fallback_exec:
				if entry.fallback_exec:
				return b'x'
				elif b'x' in fallback(x):
	return b'x'			return b'x'
	return b''			return b''

	return f			return f
	if self._checkexec:			if self._checkexec:

	def f(x):			def f(x):
	if b'l' in fallback(x):			if b'l' in fallback(x):
	return b'l'			return b'l'
				entry = self.get_entry(x)
				if entry.has_fallback_symlink:
				if entry.fallback_symlink:
				return b'l'
	if util.isexec(self._join(x)):			if util.isexec(self._join(x)):
	return b'x'			return b'x'
	return b''			return b''

	return f			return f
	else:			else:
	return fallback
				def f(x):
				entry = self.get_entry(x)
				if entry.has_fallback_symlink:
				if entry.fallback_symlink:
				return b'l'
				if entry.has_fallback_exec:
				if entry.fallback_exec:
				return b'x'
				elif entry.has_fallback_symlink:
				return b''
				mharbison72Unsubmitted Not Done Is there a reason we don't need a similar `elif` for exec in the symlink case above? (What if there's a symlink fallback, but not exec fallback?) Also, is symlink and exec mutually exclusive? I'd think not for the platforms where it's read from the filesystem, but maybe that's sanitized away somewhere? mharbison72: Is there a reason we don't need a similar `elif` for exec in the symlink case above? (What if…
				marmouteAuthorUnsubmitted Done The "FS" code return `l` regarless of the `x` status if this is a symlink. The logic you comment comply with that. If we have a symlink_fallback but no symlink_flag, we still need to check for `x`. However if we have fallback for both but non set, we know we have no flag. marmoute: The "FS" code return `l` regarless of the `x` status if this is a symlink. The logic you…
				return fallback(x)

	@propertycache			@propertycache
	def _cwd(self):			def _cwd(self):
	# internal config: ui.forcecwd			# internal config: ui.forcecwd
	forcecwd = self._ui.config(b'ui', b'forcecwd')			forcecwd = self._ui.config(b'ui', b'forcecwd')
	if forcecwd:			if forcecwd:
	return forcecwd			return forcecwd
	return encoding.getcwd()			return encoding.getcwd()

mercurial/pure/parsers.py

	"""			"""

	_wc_tracked = attr.ib()			_wc_tracked = attr.ib()
	_p1_tracked = attr.ib()			_p1_tracked = attr.ib()
	_p2_info = attr.ib()			_p2_info = attr.ib()
	_mode = attr.ib()			_mode = attr.ib()
	_size = attr.ib()			_size = attr.ib()
	_mtime = attr.ib()			_mtime = attr.ib()
				_fallback_exec = attr.ib()
				_fallback_symlink = attr.ib()

	def __init__(			def __init__(
	self,			self,
	wc_tracked=False,			wc_tracked=False,
	p1_tracked=False,			p1_tracked=False,
	p2_info=False,			p2_info=False,
	has_meaningful_data=True,			has_meaningful_data=True,
	has_meaningful_mtime=True,			has_meaningful_mtime=True,
	parentfiledata=None,			parentfiledata=None,
	):			):
	self._wc_tracked = wc_tracked			self._wc_tracked = wc_tracked
	self._p1_tracked = p1_tracked			self._p1_tracked = p1_tracked
	self._p2_info = p2_info			self._p2_info = p2_info

				self._fallback_exec = None
				self._fallback_symlink = None

	self._mode = None			self._mode = None
	self._size = None			self._size = None
	self._mtime = None			self._mtime = None
	if parentfiledata is None:			if parentfiledata is None:
	has_meaningful_mtime = False			has_meaningful_mtime = False
	has_meaningful_data = False			has_meaningful_data = False
	if has_meaningful_data:			if has_meaningful_data:
	self._mode = parentfiledata[0]			self._mode = parentfiledata[0]
	dirstatev1 format. It would make sense to ultimately deprecate it in			dirstatev1 format. It would make sense to ultimately deprecate it in
	favor of the more "semantic" attributes.			favor of the more "semantic" attributes.
	"""			"""
	if not self.any_tracked:			if not self.any_tracked:
	return b'?'			return b'?'
	return self.v1_state()			return self.v1_state()

	@property			@property
				def has_fallback_exec(self):
				"""True if "fallback" information are available for the "exec" bit
				mharbison72Unsubmitted Done /True is/ True if/ (same issue below for symlink function) mharbison72: /True is/ True if/ (same issue below for symlink function)

				Fallback information can be stored in the dirstate to keep track of
				filesystem attribute tracked by Mercurial when the underlying file
				system or operating system does not support that property, (e.g.
				Windows).

				Not all version of the dirstate on-disk storage support preserving this
				information.
				"""
				return self._fallback_exec is not None

				@property
				def fallback_exec(self):
				""" "fallback" information for the executable bit

				True if the file should be considered executable when we cannot get
				this information from the files system. False if it should be
				considered non-executable.

				See has_fallback_exec for details."""
				return self._fallback_exec

				@fallback_exec.setter
				def set_fallback_exec(self, value):
				"""control "fallback" executable bit

				Set to:
				- True if the file should be considered executable,
				- False if the file should be considered non-executable,
				- None if we do not have valid fallback data.

				See has_fallback_exec for details."""
				if value is None:
				mharbison72Unsubmitted Not Done This cast ends up masking out the `None`, which is not what `has_fallback_exec` seems to expect. Or am I misunderstanding? (Same comment for symlink below) mharbison72: This cast ends up masking out the `None`, which is not what `has_fallback_exec` seems to expect.
				marmouteAuthorUnsubmitted Done good catch, thanks. marmoute: good catch, thanks.
				self._fallback_exec = None
				else:
				self._fallback_exec = bool(value)

				@property
				def has_fallback_symlink(self):
				"""True if "fallback" information are available for symlink status

				Fallback information can be stored in the dirstate to keep track of
				filesystem attribute tracked by Mercurial when the underlying file
				system or operating system does not support that property, (e.g.
				Windows).

				Not all version of the dirstate on-disk storage support preserving this
				information."""
				return self._fallback_symlink is not None

				@property
				def fallback_symlink(self):
				""" "fallback" information for symlink status

				True if the file should be considered executable when we cannot get
				this information from the files system. False if it should be
				considered non-executable.

				See has_fallback_exec for details."""
				return self._fallback_symlink

				@fallback_symlink.setter
				def set_fallback_symlink(self, value):
				"""control "fallback" symlink status

				Set to:
				- True if the file should be considered a symlink,
				- False if the file should be considered not a symlink,
				- None if we do not have valid fallback data.

				See has_fallback_symlink for details."""
				if value is None:
				self._fallback_symlink = None
				else:
				self._fallback_symlink = bool(value)

				@property
	def tracked(self):			def tracked(self):
	"""True is the file is tracked in the working copy"""			"""True is the file is tracked in the working copy"""
	return self._wc_tracked			return self._wc_tracked

	@property			@property
	def any_tracked(self):			def any_tracked(self):
	"""True is the file is tracked anywhere (wc or parents)"""			"""True is the file is tracked anywhere (wc or parents)"""
	return self._wc_tracked or self._p1_tracked or self._p2_info			return self._wc_tracked or self._p1_tracked or self._p2_info

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

	/// The C implementation uses all signed types. This will be an issue			/// The C implementation uses all signed types. This will be an issue
	/// either when 4GB+ source files are commonplace or in 2038, whichever			/// either when 4GB+ source files are commonplace or in 2038, whichever
	/// comes first.			/// comes first.
	#[derive(Debug, PartialEq, Copy, Clone)]			#[derive(Debug, PartialEq, Copy, Clone)]
	pub struct DirstateEntry {			pub struct DirstateEntry {
	pub(crate) flags: Flags,			pub(crate) flags: Flags,
	mode_size: Option<(u32, u32)>,			mode_size: Option<(u32, u32)>,
	mtime: Option<u32>,			mtime: Option<u32>,
	}			}
				AlphareUnsubmitted Not Done Shouldn't those be in the flags in the form of 4 total bits? Alphare: Shouldn't those be in the flags in the form of 4 total bits?
				marmouteAuthorUnsubmitted Done Yes they should. I remember thinking about it, but apparently then forgot about that. Fixing it. marmoute: Yes they should. I remember thinking about it, but apparently then forgot about that. Fixing…

	bitflags! {			bitflags! {
	pub(crate) struct Flags: u8 {			pub(crate) struct Flags: u8 {
	const WDIR_TRACKED = 1 << 0;			const WDIR_TRACKED = 1 << 0;
	const P1_TRACKED = 1 << 1;			const P1_TRACKED = 1 << 1;
	const P2_INFO = 1 << 2;			const P2_INFO = 1 << 2;
				const HAS_FALLBACK_EXEC = 1 << 3;
				const FALLBACK_EXEC = 1 << 4;
				const HAS_FALLBACK_SYMLINK = 1 << 5;
				const FALLBACK_SYMLINK = 1 << 6;
	}			}
	}			}

	/// A Unix timestamp with nanoseconds precision			/// A Unix timestamp with nanoseconds precision
	#[derive(Copy, Clone)]			#[derive(Copy, Clone)]
	pub struct TruncatedTimestamp {			pub struct TruncatedTimestamp {
	truncated_seconds: u32,			truncated_seconds: u32,
	/// Always in the `0 .. 1_000_000_000` range.			/// Always in the `0 .. 1_000_000_000` range.
	self.v1_size()			self.v1_size()
	}			}

	// TODO: return Option?			// TODO: return Option?
	pub fn mtime(&self) -> i32 {			pub fn mtime(&self) -> i32 {
	self.v1_mtime()			self.v1_mtime()
	}			}

				pub fn get_fallback_exec(&self) -> Option<bool> {
				if self.flags.contains(Flags::HAS_FALLBACK_EXEC) {
				Some(self.flags.contains(Flags::FALLBACK_EXEC))
				} else {
				None
				}
				}

				pub fn set_fallback_exec(&mut self, value: Option<bool>) {
				match value {
				None => {
				self.flags.remove(Flags::HAS_FALLBACK_EXEC);
				self.flags.remove(Flags::FALLBACK_EXEC);
				}
				Some(exec) => {
				self.flags.insert(Flags::HAS_FALLBACK_EXEC);
				if exec {
				self.flags.insert(Flags::FALLBACK_EXEC);
				}
				}
				}
				}

				pub fn get_fallback_symlink(&self) -> Option<bool> {
				if self.flags.contains(Flags::HAS_FALLBACK_SYMLINK) {
				Some(self.flags.contains(Flags::FALLBACK_SYMLINK))
				} else {
				None
				}
				}

				pub fn set_fallback_symlink(&mut self, value: Option<bool>) {
				match value {
				None => {
				self.flags.remove(Flags::HAS_FALLBACK_SYMLINK);
				self.flags.remove(Flags::FALLBACK_SYMLINK);
				}
				Some(symlink) => {
				self.flags.insert(Flags::HAS_FALLBACK_SYMLINK);
				if symlink {
				self.flags.insert(Flags::FALLBACK_SYMLINK);
				}
				}
				}
				}

	pub fn drop_merge_data(&mut self) {			pub fn drop_merge_data(&mut self) {
	if self.flags.contains(Flags::P2_INFO) {			if self.flags.contains(Flags::P2_INFO) {
	self.flags.remove(Flags::P2_INFO);			self.flags.remove(Flags::P2_INFO);
	self.mode_size = None;			self.mode_size = None;
	self.mtime = None;			self.mtime = None;
	}			}
	}			}

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

	use cpython::exc;			use cpython::exc;
				use cpython::ObjectProtocol;
	use cpython::PyBytes;			use cpython::PyBytes;
	use cpython::PyErr;			use cpython::PyErr;
	use cpython::PyNone;			use cpython::PyNone;
	use cpython::PyObject;			use cpython::PyObject;
	use cpython::PyResult;			use cpython::PyResult;
	use cpython::Python;			use cpython::Python;
	use cpython::PythonObject;			use cpython::PythonObject;
	use hg::dirstate::DirstateEntry;			use hg::dirstate::DirstateEntry;
	}			}

	@property			@property
	def mtime(&self) -> PyResult<i32> {			def mtime(&self) -> PyResult<i32> {
	Ok(self.entry(py).get().mtime())			Ok(self.entry(py).get().mtime())
	}			}

	@property			@property
				def has_fallback_exec(&self) -> PyResult<bool> {
				match self.entry(py).get().get_fallback_exec() {
				Some(_) => Ok(true),
				None => Ok(false),
				}
				}

				@property
				def fallback_exec(&self) -> PyResult<Option<bool>> {
				match self.entry(py).get().get_fallback_exec() {
				Some(exec) => Ok(Some(exec)),
				None => Ok(None),
				}
				}

				@fallback_exec.setter
				def set_fallback_exec(&self, value: Option<PyObject>) -> PyResult<()> {
				match value {
				None => {self.entry(py).get().set_fallback_exec(None);},
				Some(value) => {
				if value.is_none(py) {
				self.entry(py).get().set_fallback_exec(None);
				} else {
				self.entry(py).get().set_fallback_exec(
				Some(value.is_true(py)?)
				);
				}},
				}
				Ok(())
				}

				@property
				def has_fallback_symlink(&self) -> PyResult<bool> {
				match self.entry(py).get().get_fallback_symlink() {
				Some(_) => Ok(true),
				None => Ok(false),
				}
				}

				@property
				def fallback_symlink(&self) -> PyResult<Option<bool>> {
				match self.entry(py).get().get_fallback_symlink() {
				Some(symlink) => Ok(Some(symlink)),
				None => Ok(None),
				}
				}

				@fallback_symlink.setter
				def set_fallback_symlink(&self, value: Option<PyObject>) -> PyResult<()> {
				match value {
				None => {self.entry(py).get().set_fallback_symlink(None);},
				Some(value) => {
				if value.is_none(py) {
				self.entry(py).get().set_fallback_symlink(None);
				} else {
				self.entry(py).get().set_fallback_symlink(
				Some(value.is_true(py)?)
				);
				}},
				}
				Ok(())
				}

				@property
	def tracked(&self) -> PyResult<bool> {			def tracked(&self) -> PyResult<bool> {
	Ok(self.entry(py).get().tracked())			Ok(self.entry(py).get().tracked())
	}			}

	@property			@property
	def p1_tracked(&self) -> PyResult<bool> {			def p1_tracked(&self) -> PyResult<bool> {
	Ok(self.entry(py).get().p1_tracked())			Ok(self.entry(py).get().p1_tracked())
	}			}