gh-111178: Fix function signatures in tupleobject.c (#124804)

1 files changed, 64 insertions, 58 deletions

diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 4d8cca6..4713469 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -181,8 +181,9 @@ PyTuple_Pack(Py_ssize_t n, ...)
 /* Methods */
 
 static void
-tupledealloc(PyTupleObject *op)
+tuple_dealloc(PyObject *self)
 {
+    PyTupleObject *op = _PyTuple_CAST(self);
     if (Py_SIZE(op) == 0) {
         /* The empty tuple is statically allocated. */
         if (op == &_Py_SINGLETON(tuple_empty)) {
@@ -199,7 +200,7 @@ tupledealloc(PyTupleObject *op)
     }
 
     PyObject_GC_UnTrack(op);
-    Py_TRASHCAN_BEGIN(op, tupledealloc)
+    Py_TRASHCAN_BEGIN(op, tuple_dealloc)
 
     Py_ssize_t i = Py_SIZE(op);
     while (--i >= 0) {
@@ -214,29 +215,29 @@ tupledealloc(PyTupleObject *op)
 }
 
 static PyObject *
-tuplerepr(PyTupleObject *v)
+tuple_repr(PyObject *self)
 {
-    Py_ssize_t i, n;
-    _PyUnicodeWriter writer;
-
-    n = Py_SIZE(v);
-    if (n == 0)
+    PyTupleObject *v = _PyTuple_CAST(self);
+    Py_ssize_t n = PyTuple_GET_SIZE(v);
+    if (n == 0) {
         return PyUnicode_FromString("()");
+    }
 
     /* While not mutable, it is still possible to end up with a cycle in a
        tuple through an object that stores itself within a tuple (and thus
        infinitely asks for the repr of itself). This should only be
        possible within a type. */
-    i = Py_ReprEnter((PyObject *)v);
-    if (i != 0) {
-        return i > 0 ? PyUnicode_FromString("(...)") : NULL;
+    int res = Py_ReprEnter((PyObject *)v);
+    if (res != 0) {
+        return res > 0 ? PyUnicode_FromString("(...)") : NULL;
     }
 
+    _PyUnicodeWriter writer;
     _PyUnicodeWriter_Init(&writer);
     writer.overallocate = 1;
-    if (Py_SIZE(v) > 1) {
+    if (n > 1) {
         /* "(" + "1" + ", 2" * (len - 1) + ")" */
-        writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;
+        writer.min_length = 1 + 1 + (2 + 1) * (n - 1) + 1;
     }
     else {
         /* "(1,)" */
@@ -247,7 +248,7 @@ tuplerepr(PyTupleObject *v)
         goto error;
 
     /* Do repr() on each element. */
-    for (i = 0; i < n; ++i) {
+    for (Py_ssize_t i = 0; i < n; ++i) {
         PyObject *s;
 
         if (i > 0) {
@@ -316,13 +317,14 @@ error:
 /* Tests have shown that it's not worth to cache the hash value, see
    https://bugs.python.org/issue9685 */
 static Py_hash_t
-tuplehash(PyTupleObject *v)
+tuple_hash(PyObject *op)
 {
-    Py_ssize_t i, len = Py_SIZE(v);
+    PyTupleObject *v = _PyTuple_CAST(op);
+    Py_ssize_t len = Py_SIZE(v);
     PyObject **item = v->ob_item;
 
     Py_uhash_t acc = _PyHASH_XXPRIME_5;
-    for (i = 0; i < len; i++) {
+    for (Py_ssize_t i = 0; i < len; i++) {
         Py_uhash_t lane = PyObject_Hash(item[i]);
         if (lane == (Py_uhash_t)-1) {
             return -1;
@@ -342,25 +344,27 @@ tuplehash(PyTupleObject *v)
 }
 
 static Py_ssize_t
-tuplelength(PyTupleObject *a)
+tuple_length(PyObject *self)
 {
+    PyTupleObject *a = _PyTuple_CAST(self);
     return Py_SIZE(a);
 }
 
 static int
-tuplecontains(PyTupleObject *a, PyObject *el)
+tuple_contains(PyObject *self, PyObject *el)
 {
-    Py_ssize_t i;
-    int cmp;
-
-    for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
+    PyTupleObject *a = _PyTuple_CAST(self);
+    int cmp = 0;
+    for (Py_ssize_t i = 0; cmp == 0 && i < Py_SIZE(a); ++i) {
         cmp = PyObject_RichCompareBool(PyTuple_GET_ITEM(a, i), el, Py_EQ);
+    }
     return cmp;
 }
 
 static PyObject *
-tupleitem(PyTupleObject *a, Py_ssize_t i)
+tuple_item(PyObject *op, Py_ssize_t i)
 {
+    PyTupleObject *a = _PyTuple_CAST(op);
     if (i < 0 || i >= Py_SIZE(a)) {
         PyErr_SetString(PyExc_IndexError, "tuple index out of range");
         return NULL;
@@ -432,7 +436,7 @@ _PyTuple_FromArraySteal(PyObject *const *src, Py_ssize_t n)
 }
 
 static PyObject *
-tupleslice(PyTupleObject *a, Py_ssize_t ilow,
+tuple_slice(PyTupleObject *a, Py_ssize_t ilow,
            Py_ssize_t ihigh)
 {
     if (ilow < 0)
@@ -454,16 +458,13 @@ PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
         PyErr_BadInternalCall();
         return NULL;
     }
-    return tupleslice((PyTupleObject *)op, i, j);
+    return tuple_slice((PyTupleObject *)op, i, j);
 }
 
 static PyObject *
-tupleconcat(PyTupleObject *a, PyObject *bb)
+tuple_concat(PyObject *aa, PyObject *bb)
 {
-    Py_ssize_t size;
-    Py_ssize_t i;
-    PyObject **src, **dest;
-    PyTupleObject *np;
+    PyTupleObject *a = _PyTuple_CAST(aa);
     if (Py_SIZE(a) == 0 && PyTuple_CheckExact(bb)) {
         return Py_NewRef(bb);
     }
@@ -479,34 +480,38 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
         return Py_NewRef(a);
     }
     assert((size_t)Py_SIZE(a) + (size_t)Py_SIZE(b) < PY_SSIZE_T_MAX);
-    size = Py_SIZE(a) + Py_SIZE(b);
+    Py_ssize_t size = Py_SIZE(a) + Py_SIZE(b);
     if (size == 0) {
         return tuple_get_empty();
     }
 
-    np = tuple_alloc(size);
+    PyTupleObject *np = tuple_alloc(size);
     if (np == NULL) {
         return NULL;
     }
-    src = a->ob_item;
-    dest = np->ob_item;
-    for (i = 0; i < Py_SIZE(a); i++) {
+
+    PyObject **src = a->ob_item;
+    PyObject **dest = np->ob_item;
+    for (Py_ssize_t i = 0; i < Py_SIZE(a); i++) {
         PyObject *v = src[i];
         dest[i] = Py_NewRef(v);
     }
+
     src = b->ob_item;
     dest = np->ob_item + Py_SIZE(a);
-    for (i = 0; i < Py_SIZE(b); i++) {
+    for (Py_ssize_t i = 0; i < Py_SIZE(b); i++) {
         PyObject *v = src[i];
         dest[i] = Py_NewRef(v);
     }
+
     _PyObject_GC_TRACK(np);
     return (PyObject *)np;
 }
 
 static PyObject *
-tuplerepeat(PyTupleObject *a, Py_ssize_t n)
+tuple_repeat(PyObject *self, Py_ssize_t n)
 {
+    PyTupleObject *a = _PyTuple_CAST(self);
     const Py_ssize_t input_size = Py_SIZE(a);
     if (input_size == 0 || n == 1) {
         if (PyTuple_CheckExact(a)) {
@@ -621,17 +626,17 @@ tuple_count(PyTupleObject *self, PyObject *value)
 }
 
 static int
-tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
+tuple_traverse(PyObject *self, visitproc visit, void *arg)
 {
-    Py_ssize_t i;
-
-    for (i = Py_SIZE(o); --i >= 0; )
+    PyTupleObject *o = _PyTuple_CAST(self);
+    for (Py_ssize_t i = Py_SIZE(o); --i >= 0; ) {
         Py_VISIT(o->ob_item[i]);
+    }
     return 0;
 }
 
 static PyObject *
-tuplerichcompare(PyObject *v, PyObject *w, int op)
+tuple_richcompare(PyObject *v, PyObject *w, int op)
 {
     PyTupleObject *vt, *wt;
     Py_ssize_t i;
@@ -770,26 +775,27 @@ tuple_subtype_new(PyTypeObject *type, PyObject *iterable)
 }
 
 static PySequenceMethods tuple_as_sequence = {
-    (lenfunc)tuplelength,                       /* sq_length */
-    (binaryfunc)tupleconcat,                    /* sq_concat */
-    (ssizeargfunc)tuplerepeat,                  /* sq_repeat */
-    (ssizeargfunc)tupleitem,                    /* sq_item */
+    tuple_length,                               /* sq_length */
+    tuple_concat,                               /* sq_concat */
+    tuple_repeat,                               /* sq_repeat */
+    tuple_item,                                 /* sq_item */
     0,                                          /* sq_slice */
     0,                                          /* sq_ass_item */
     0,                                          /* sq_ass_slice */
-    (objobjproc)tuplecontains,                  /* sq_contains */
+    tuple_contains,                             /* sq_contains */
 };
 
 static PyObject*
-tuplesubscript(PyTupleObject* self, PyObject* item)
+tuple_subscript(PyObject *op, PyObject* item)
 {
+    PyTupleObject *self = _PyTuple_CAST(op);
     if (_PyIndex_Check(item)) {
         Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
         if (i == -1 && PyErr_Occurred())
             return NULL;
         if (i < 0)
             i += PyTuple_GET_SIZE(self);
-        return tupleitem(self, i);
+        return tuple_item(op, i);
     }
     else if (PySlice_Check(item)) {
         Py_ssize_t start, stop, step, slicelength, i;
@@ -843,7 +849,7 @@ static PyObject *
 tuple___getnewargs___impl(PyTupleObject *self)
 /*[clinic end generated code: output=25e06e3ee56027e2 input=1aeb4b286a21639a]*/
 {
-    return Py_BuildValue("(N)", tupleslice(self, 0, Py_SIZE(self)));
+    return Py_BuildValue("(N)", tuple_slice(self, 0, Py_SIZE(self)));
 }
 
 static PyMethodDef tuple_methods[] = {
@@ -855,8 +861,8 @@ static PyMethodDef tuple_methods[] = {
 };
 
 static PyMappingMethods tuple_as_mapping = {
-    (lenfunc)tuplelength,
-    (binaryfunc)tuplesubscript,
+    tuple_length,
+    tuple_subscript,
     0
 };
 
@@ -867,16 +873,16 @@ PyTypeObject PyTuple_Type = {
     "tuple",
     sizeof(PyTupleObject) - sizeof(PyObject *),
     sizeof(PyObject *),
-    (destructor)tupledealloc,                   /* tp_dealloc */
+    tuple_dealloc,                              /* tp_dealloc */
     0,                                          /* tp_vectorcall_offset */
     0,                                          /* tp_getattr */
     0,                                          /* tp_setattr */
     0,                                          /* tp_as_async */
-    (reprfunc)tuplerepr,                        /* tp_repr */
+    tuple_repr,                                 /* tp_repr */
     0,                                          /* tp_as_number */
     &tuple_as_sequence,                         /* tp_as_sequence */
     &tuple_as_mapping,                          /* tp_as_mapping */
-    (hashfunc)tuplehash,                        /* tp_hash */
+    tuple_hash,                                 /* tp_hash */
     0,                                          /* tp_call */
     0,                                          /* tp_str */
     PyObject_GenericGetAttr,                    /* tp_getattro */
@@ -886,9 +892,9 @@ PyTypeObject PyTuple_Type = {
         Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS |
         _Py_TPFLAGS_MATCH_SELF | Py_TPFLAGS_SEQUENCE,  /* tp_flags */
     tuple_new__doc__,                           /* tp_doc */
-    (traverseproc)tupletraverse,                /* tp_traverse */
+    tuple_traverse,                             /* tp_traverse */
     0,                                          /* tp_clear */
-    tuplerichcompare,                           /* tp_richcompare */
+    tuple_richcompare,                          /* tp_richcompare */
     0,                                          /* tp_weaklistoffset */
     tuple_iter,                                 /* tp_iter */
     0,                                          /* tp_iternext */