( )⚙ D11603 dirstate-item: drop the legacy new_from_p2 constructor

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11603

dirstate-item: drop the legacy new_from_p2 constructor
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG252d2f3f0d17: dirstate-item: drop the legacy new_from_p2 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:52 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
marmoute added a commit: rHG252d2f3f0d17: dirstate-item: drop the legacy new_from_p2 constructor.Oct 3 2021, 5:37 PM
Closed by commit rHG252d2f3f0d17: dirstate-item: drop the legacy new_from_p2 constructor (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30661

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 "from_p2" item
Should eventually be removed */
static PyObject *dirstate_item_new_from_p2(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_p2_info;
t->mode = 0;
t->size = 0;
t->mtime = 0;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "possibly" item /* constructor to help legacy API to build a new "possibly" item
Should eventually be removed */ Should eventually be removed */
static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype) static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
{ {
/* 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_from_p2", (PyCFunction)dirstate_item_new_from_p2,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"from_p2\" item"},
{"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty, {"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,
METH_NOARGS | METH_CLASS, METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"possibly_dirty\" item"}, "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\""},

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_from_p2(cls):
"""constructor to help legacy API to build a new "from_p2" item
Should eventually be removed
"""
return cls(wc_tracked=True, p2_info=True)
@classmethod
def new_possibly_dirty(cls): def new_possibly_dirty(cls):
"""constructor to help legacy API to build a new "possibly_dirty" item """constructor to help legacy API to build a new "possibly_dirty" item
Should eventually be removed Should eventually be removed
""" """
return cls(wc_tracked=True, p1_tracked=True) return cls(wc_tracked=True, p1_tracked=True)
@classmethod @classmethod

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_from_p2() -> Self {
Self {
// might be missing P1_TRACKED
flags: Flags::WDIR_TRACKED | Flags::P2_INFO,
mode_size: None,
mtime: None,
}
}
pub fn new_possibly_dirty() -> Self { pub fn new_possibly_dirty() -> Self {
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: None, mode_size: None,
mtime: None, mtime: None,
} }
} }

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_from_p2(_cls) -> PyResult<Self> {
let entry = DirstateEntry::new_from_p2();
DirstateItem::create_instance(py, Cell::new(entry))
}
@classmethod
def new_possibly_dirty(_cls) -> PyResult<Self> { def new_possibly_dirty(_cls) -> PyResult<Self> {
let entry = DirstateEntry::new_possibly_dirty(); let entry = DirstateEntry::new_possibly_dirty();
DirstateItem::create_instance(py, Cell::new(entry)) DirstateItem::create_instance(py, Cell::new(entry))
} }
@classmethod @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);