This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11687

dirstate: make DirstateItem constructor accept fallback value
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG948570aa7630: dirstate: make DirstateItem constructor accept fallback value
Summary

This could arguably goes in the previous changeset, but I wanted to keep that
previous changeset small to focus more on the user code and the documentation.

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
mharbison72 added a subscriber: mharbison72.Oct 18 2021, 11:40 PM

LGTM, but I need someone to look at the rust code here too

Alphare requested changes to this revision.Oct 19 2021, 4:19 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-core/src/dirstate/entry.rs
216–217

Same as the previous changeset, shouldn't this be in flags directly?

This revision now requires changes to proceed.Oct 19 2021, 4:19 AM
marmoute added inline comments.Oct 19 2021, 4:23 AM
rust/hg-core/src/dirstate/entry.rs
216–217

Yeah I actually it should (I remember saying this to myself and then forgetting about it).

marmoute updated this revision to Diff 30892.Oct 19 2021, 7:49 AM
Alphare accepted this revision.Oct 19 2021, 8:13 AM
This revision is now accepted and ready to land.Oct 19 2021, 8:13 AM

Revision Contents
Changeset List

Diff 30902

mercurial/cext/parsers.c

int p1_tracked; int p1_tracked;
int p2_info; int p2_info;
int has_meaningful_data; int has_meaningful_data;
int has_meaningful_mtime; int has_meaningful_mtime;
int mode; int mode;
int size; int size;
int mtime; int mtime;
PyObject *parentfiledata; PyObject *parentfiledata;
PyObject *fallback_exec;
PyObject *fallback_symlink;
static char *keywords_name[] = { static char *keywords_name[] = {
"wc_tracked", "wc_tracked", "p1_tracked", "p2_info",
"p1_tracked", "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",
"p2_info", "fallback_exec", "fallback_symlink", NULL,
"has_meaningful_data",
"has_meaningful_mtime",
"parentfiledata",
NULL,
}; };
wc_tracked = 0; wc_tracked = 0;
p1_tracked = 0; p1_tracked = 0;
p2_info = 0; p2_info = 0;
has_meaningful_mtime = 1; has_meaningful_mtime = 1;
has_meaningful_data = 1; has_meaningful_data = 1;
parentfiledata = Py_None; parentfiledata = Py_None;
if (!PyArg_ParseTupleAndKeywords( fallback_exec = Py_None;
args, kwds, "|iiiiiO", keywords_name, &wc_tracked, &p1_tracked, fallback_symlink = Py_None;
&p2_info, &has_meaningful_data, &has_meaningful_mtime, if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiOOO", keywords_name,
&parentfiledata)) { &wc_tracked, &p1_tracked, &p2_info,
&has_meaningful_data,
&has_meaningful_mtime, &parentfiledata,
&fallback_exec, &fallback_symlink)) {
return NULL; return NULL;
} }
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1); t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) { if (!t) {
return NULL; return NULL;
} }
t->flags = 0; t->flags = 0;
if (wc_tracked) { if (wc_tracked) {
t->flags |= dirstate_flag_wc_tracked; t->flags |= dirstate_flag_wc_tracked;
} }
if (p1_tracked) { if (p1_tracked) {
t->flags |= dirstate_flag_p1_tracked; t->flags |= dirstate_flag_p1_tracked;
} }
if (p2_info) { if (p2_info) {
t->flags |= dirstate_flag_p2_info; t->flags |= dirstate_flag_p2_info;
} }
if (fallback_exec != Py_None) {
t->flags |= dirstate_flag_has_fallback_exec;
if (PyObject_IsTrue(fallback_exec)) {
t->flags |= dirstate_flag_fallback_exec;
}
}
if (fallback_symlink != Py_None) {
t->flags |= dirstate_flag_has_fallback_symlink;
if (PyObject_IsTrue(fallback_symlink)) {
t->flags |= dirstate_flag_fallback_symlink;
}
}
if (parentfiledata != Py_None) { if (parentfiledata != Py_None) {
if (!PyTuple_CheckExact(parentfiledata)) { if (!PyTuple_CheckExact(parentfiledata)) {
PyErr_SetString( PyErr_SetString(
PyExc_TypeError, PyExc_TypeError,
"parentfiledata should be a Tuple or None"); "parentfiledata should be a Tuple or None");
return NULL; return NULL;
} }
mode = (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0)); mode = (int)PyLong_AsLong(PyTuple_GetItem(parentfiledata, 0));

mercurial/pure/parsers.py

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,
fallback_exec=None,
fallback_symlink=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_exec = fallback_exec
self._fallback_symlink = None self._fallback_symlink = fallback_symlink
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:

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

impl DirstateEntry { impl DirstateEntry {
pub fn from_v2_data( pub fn from_v2_data(
wdir_tracked: bool, wdir_tracked: bool,
p1_tracked: bool, p1_tracked: bool,
p2_info: bool, p2_info: bool,
mode_size: Option<(u32, u32)>, mode_size: Option<(u32, u32)>,
mtime: Option<u32>, mtime: Option<u32>,
fallback_exec: Option<bool>,
fallback_symlink: Option<bool>,
) -> Self { ) -> Self {
if let Some((mode, size)) = mode_size { if let Some((mode, size)) = mode_size {
// TODO: return an error for out of range values? // TODO: return an error for out of range values?
assert!(mode & !RANGE_MASK_31BIT == 0); assert!(mode & !RANGE_MASK_31BIT == 0);
assert!(size & !RANGE_MASK_31BIT == 0); assert!(size & !RANGE_MASK_31BIT == 0);
} }
if let Some(mtime) = mtime { if let Some(mtime) = mtime {
assert!(mtime & !RANGE_MASK_31BIT == 0); assert!(mtime & !RANGE_MASK_31BIT == 0);
} }
let mut flags = Flags::empty(); let mut flags = Flags::empty();
flags.set(Flags::WDIR_TRACKED, wdir_tracked); flags.set(Flags::WDIR_TRACKED, wdir_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked); flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_INFO, p2_info); flags.set(Flags::P2_INFO, p2_info);
if let Some(exec) = fallback_exec {
flags.insert(Flags::HAS_FALLBACK_EXEC);
if exec {
flags.insert(Flags::FALLBACK_EXEC);
}
}
if let Some(exec) = fallback_symlink {
flags.insert(Flags::HAS_FALLBACK_SYMLINK);
if exec {
flags.insert(Flags::FALLBACK_SYMLINK);
}
}
Self { Self {
flags, flags,
mode_size, mode_size,
mtime, mtime,
} }
AlphareUnsubmitted
Not Done

Same as the previous changeset, shouldn't this be in flags directly?

Alphare: Same as the previous changeset, shouldn't this be in flags directly?
marmouteAuthorUnsubmitted
Done

Yeah I actually it should (I remember saying this to myself and then forgetting about it).

marmoute: Yeah I actually it should (I remember saying this to myself and then forgetting about it).
} }
pub fn from_v1_data( pub fn from_v1_data(
state: EntryState, state: EntryState,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,
) -> Self { ) -> Self {

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

None None
}; };
DirstateEntry::from_v2_data( DirstateEntry::from_v2_data(
wdir_tracked, wdir_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size, mode_size,
mtime, mtime,
None,
None,
) )
} }
pub(super) fn entry( pub(super) fn entry(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
if self.has_entry() { if self.has_entry() {
Ok(Some(self.assume_entry())) Ok(Some(self.assume_entry()))

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

def __new__( def __new__(
_cls, _cls,
wc_tracked: bool = false, wc_tracked: bool = false,
p1_tracked: bool = false, p1_tracked: bool = false,
p2_info: bool = false, p2_info: bool = false,
has_meaningful_data: bool = true, has_meaningful_data: bool = true,
has_meaningful_mtime: bool = true, has_meaningful_mtime: bool = true,
parentfiledata: Option<(u32, u32, u32)> = None, parentfiledata: Option<(u32, u32, u32)> = None,
fallback_exec: Option<bool> = None,
fallback_symlink: Option<bool> = None,
) -> PyResult<DirstateItem> { ) -> PyResult<DirstateItem> {
let mut mode_size_opt = None; let mut mode_size_opt = None;
let mut mtime_opt = None; let mut mtime_opt = None;
if let Some((mode, size, mtime)) = parentfiledata { if let Some((mode, size, mtime)) = parentfiledata {
if has_meaningful_data { if has_meaningful_data {
mode_size_opt = Some((mode, size)) mode_size_opt = Some((mode, size))
} }
if has_meaningful_mtime { if has_meaningful_mtime {
mtime_opt = Some(mtime) mtime_opt = Some(mtime)
} }
} }
let entry = DirstateEntry::from_v2_data( let entry = DirstateEntry::from_v2_data(
wc_tracked, p1_tracked, p2_info, mode_size_opt, mtime_opt, wc_tracked,
p1_tracked,
p2_info,
mode_size_opt,
mtime_opt,
fallback_exec,
fallback_symlink,
); );
DirstateItem::create_instance(py, Cell::new(entry)) DirstateItem::create_instance(py, Cell::new(entry))
} }
@property @property
def state(&self) -> PyResult<PyBytes> { def state(&self) -> PyResult<PyBytes> {
let state_byte: u8 = self.entry(py).get().state().into(); let state_byte: u8 = self.entry(py).get().state().into();
Ok(PyBytes::new(py, &[state_byte])) Ok(PyBytes::new(py, &[state_byte]))