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

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 30608

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