This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11608

dirstate-item: drop the legacy new_normal constructor
ClosedPublic

Authored by marmoute on Oct 3 2021, 6:53 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1ab4523afe12: dirstate-item: drop the legacy new_normal constructor
Summary

Nobody is calling it anymore. Its purposes has been filled.

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.

Revision Contents
Changeset List

Diff 30666

mercurial/cext/parsers.c

char state; char state;
int size, mode, mtime; int size, mode, mtime;
if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) { if (!PyArg_ParseTuple(args, "ciii", &state, &mode, &size, &mtime)) {
return NULL; return NULL;
} }
return (PyObject *)dirstate_item_from_v1_data(state, mode, size, mtime); return (PyObject *)dirstate_item_from_v1_data(state, mode, size, mtime);
}; };
/* constructor to help legacy API to build a new "normal" item
Should eventually be removed */
static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL;
}
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->flags = (dirstate_flag_wc_tracked | dirstate_flag_p1_tracked);
t->mode = mode;
t->size = size;
t->mtime = mtime;
return (PyObject *)t;
};
/* This means the next status call will have to actually check its content /* This means the next status call will have to actually check its content
to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_has_meaningful_mtime; self->flags &= ~dirstate_flag_has_meaningful_mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
{"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O, {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,
"True if the stored mtime would be ambiguous with the current time"}, "True if the stored mtime would be ambiguous with the current time"},
{"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"}, METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
{"new_normal", (PyCFunction)dirstate_item_new_normal,
METH_VARARGS | METH_CLASS,
"constructor to help legacy API to build a new \"normal\" item"},
{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty, {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
METH_NOARGS, "mark a file as \"possibly dirty\""}, METH_NOARGS, "mark a file as \"possibly dirty\""},
{"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS, {"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
"mark a file as \"clean\""}, "mark a file as \"clean\""},
{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS, {"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
"mark a file as \"tracked\""}, "mark a file as \"tracked\""},
{"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS, {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
"mark a file as \"untracked\""}, "mark a file as \"untracked\""},

mercurial/pure/parsers.py

has_meaningful_data = False has_meaningful_data = False
if has_meaningful_data: if has_meaningful_data:
self._mode = parentfiledata[0] self._mode = parentfiledata[0]
self._size = parentfiledata[1] self._size = parentfiledata[1]
if has_meaningful_mtime: if has_meaningful_mtime:
self._mtime = parentfiledata[2] self._mtime = parentfiledata[2]
@classmethod @classmethod
def new_normal(cls, mode, size, mtime):
"""constructor to help legacy API to build a new "normal" item
Should eventually be removed
"""
assert size != FROM_P2
assert size != NONNORMAL
return cls(
wc_tracked=True,
p1_tracked=True,
parentfiledata=(mode, size, mtime),
)
@classmethod
def from_v1_data(cls, state, mode, size, mtime): def from_v1_data(cls, state, mode, size, mtime):
"""Build a new DirstateItem object from V1 data """Build a new DirstateItem object from V1 data
Since the dirstate-v1 format is frozen, the signature of this function Since the dirstate-v1 format is frozen, the signature of this function
is not expected to change, unlike the __init__ one. is not expected to change, unlike the __init__ one.
""" """
if state == b'm': if state == b'm':
return cls(wc_tracked=True, p1_tracked=True, p2_info=True) return cls(wc_tracked=True, p1_tracked=True, p2_info=True)

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

| Flags::P1_TRACKED // might not be true because of rename ? | Flags::P1_TRACKED // might not be true because of rename ?
| Flags::P2_INFO, // might not be true because of rename ? | Flags::P2_INFO, // might not be true because of rename ?
mode_size: None, mode_size: None,
mtime: None, mtime: None,
}, },
} }
} }
pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self {
Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: Some((mode, size)),
mtime: Some(mtime),
}
}
/// Creates a new entry in "removed" state. /// Creates a new entry in "removed" state.
/// ///
/// `size` is expected to be zero, `SIZE_NON_NORMAL`, or /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
/// `SIZE_FROM_OTHER_PARENT` /// `SIZE_FROM_OTHER_PARENT`
pub fn new_removed(size: i32) -> Self { pub fn new_removed(size: i32) -> Self {
Self::from_v1_data(EntryState::Removed, 0, size, 0) Self::from_v1_data(EntryState::Removed, 0, size, 0)
} }

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

let state = <[u8; 1]>::try_from(state.data(py)) let state = <[u8; 1]>::try_from(state.data(py))
.ok() .ok()
.and_then(|state| EntryState::try_from(state[0]).ok()) .and_then(|state| EntryState::try_from(state[0]).ok())
.ok_or_else(|| PyErr::new::<exc::ValueError, _>(py, "invalid state"))?; .ok_or_else(|| PyErr::new::<exc::ValueError, _>(py, "invalid state"))?;
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime); let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
DirstateItem::create_instance(py, Cell::new(entry)) DirstateItem::create_instance(py, Cell::new(entry))
} }
@classmethod
def new_normal(_cls, mode: i32, size: i32, mtime: i32) -> PyResult<Self> {
let entry = DirstateEntry::new_normal(mode, size, mtime);
DirstateItem::create_instance(py, Cell::new(entry))
}
def drop_merge_data(&self) -> PyResult<PyNone> { def drop_merge_data(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.drop_merge_data()); self.update(py, |entry| entry.drop_merge_data());
Ok(PyNone) Ok(PyNone)
} }
def set_clean( def set_clean(
&self, &self,
mode: i32, mode: i32,