This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11605

dirstate-item: drop the legacy new_possibly_dirty constructor
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG20e41b367953: dirstate-item: drop the legacy new_possibly_dirty 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.

Event Timeline

marmoute created this revision.Oct 3 2021, 6:53 AM
Alphare accepted this revision.Oct 3 2021, 5:19 PM
This revision is now accepted and ready to land.Oct 3 2021, 5:19 PM

Revision Contents
Changeset List

Diff 30663

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 "possibly" item
Should eventually be removed */
static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
t->mode = 0;
t->size = 0;
t->mtime = 0;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "normal" item /* constructor to help legacy API to build a new "normal" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args) static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
{ {
/* We do all the initialization here and not a tp_init function because /* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */ * dirstate_item is immutable. */
dirstateItemObject *t; dirstateItemObject *t;
{"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_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"possibly_dirty\" item"},
{"new_normal", (PyCFunction)dirstate_item_new_normal, {"new_normal", (PyCFunction)dirstate_item_new_normal,
METH_VARARGS | METH_CLASS, METH_VARARGS | METH_CLASS,
"constructor to help legacy API to build a new \"normal\" item"}, "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,

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_possibly_dirty(cls):
"""constructor to help legacy API to build a new "possibly_dirty" item
Should eventually be removed
"""
return cls(wc_tracked=True, p1_tracked=True)
@classmethod
def new_normal(cls, mode, size, mtime): def new_normal(cls, mode, size, mtime):
"""constructor to help legacy API to build a new "normal" item """constructor to help legacy API to build a new "normal" item
Should eventually be removed Should eventually be removed
""" """
assert size != FROM_P2 assert size != FROM_P2
assert size != NONNORMAL assert size != NONNORMAL
return cls( return cls(

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_possibly_dirty() -> Self {
Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: None,
mtime: None,
}
}
pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self { pub fn new_normal(mode: i32, size: i32, mtime: i32) -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: Some((mode, size)), mode_size: Some((mode, size)),
mtime: Some(mtime), mtime: Some(mtime),
} }
} }

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

.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 @classmethod
def new_possibly_dirty(_cls) -> PyResult<Self> {
let entry = DirstateEntry::new_possibly_dirty();
DirstateItem::create_instance(py, Cell::new(entry))
}
@classmethod
def new_normal(_cls, mode: i32, size: i32, mtime: i32) -> PyResult<Self> { def new_normal(_cls, mode: i32, size: i32, mtime: i32) -> PyResult<Self> {
let entry = DirstateEntry::new_normal(mode, size, mtime); let entry = DirstateEntry::new_normal(mode, size, mtime);
DirstateItem::create_instance(py, Cell::new(entry)) 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)