( )⚙ D11687 dirstate: make DirstateItem constructor accept fallback value

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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
203

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
203

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 30886

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);
Self { Self {
flags, flags,
mode_size, mode_size,
mtime, mtime,
fallback_exec: None, fallback_exec: fallback_exec,
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).
fallback_symlink: None, fallback_symlink: fallback_symlink,
} }
} }
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,

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]))