( )⚙ D11605 dirstate-item: drop the legacy new_possibly_dirty constructor

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

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 30610

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)