pythongh-111178: fix UBSan failures in Modules/_sqlite (pythonGH-129087)

picnixz · srinivasreddy · commit c79cd63a8d0f · 2025-02-07T13:21:52.000+05:30
* fix UBSan failures for `pysqlite_Blob`
* fix UBSan failures for `pysqlite_Connection`
* fix UBSan failures for `pysqlite_Cursor`
* fix UBSan failures for `pysqlite_PrepareProtocol`
* fix UBSan failures for `pysqlite_Row`
* fix UBSan failures for `pysqlite_Statement`

* suppress unused return values
diff --git a/Modules/_sqlite/blob.c b/Modules/_sqlite/blob.c
@@ -9,6 +9,8 @@
 #include "clinic/blob.c.h"
 #undef clinic_state
 
+#define _pysqlite_Blob_CAST(op) ((pysqlite_Blob *)(op))
+
 /*[clinic input]
 module _sqlite3
 class _sqlite3.Blob "pysqlite_Blob *" "clinic_state()->BlobType"
@@ -29,32 +31,35 @@ close_blob(pysqlite_Blob *self)
 }
 
 static int
-blob_traverse(pysqlite_Blob *self, visitproc visit, void *arg)
+blob_traverse(PyObject *op, visitproc visit, void *arg)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     Py_VISIT(Py_TYPE(self));
     Py_VISIT(self->connection);
     return 0;
 }
 
 static int
-blob_clear(pysqlite_Blob *self)
+blob_clear(PyObject *op)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     Py_CLEAR(self->connection);
     return 0;
 }
 
 static void
-blob_dealloc(pysqlite_Blob *self)
+blob_dealloc(PyObject *op)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     PyTypeObject *tp = Py_TYPE(self);
     PyObject_GC_UnTrack(self);
 
     close_blob(self);
 
     if (self->in_weakreflist != NULL) {
-        PyObject_ClearWeakRefs((PyObject*)self);
+        PyObject_ClearWeakRefs(op);
     }
-    tp->tp_clear((PyObject *)self);
+    (void)tp->tp_clear(op);
     tp->tp_free(self);
     Py_DECREF(tp);
 }
@@ -373,8 +378,9 @@ blob_exit_impl(pysqlite_Blob *self, PyObject *type, PyObject *val,
 }
 
 static Py_ssize_t
-blob_length(pysqlite_Blob *self)
+blob_length(PyObject *op)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     if (!check_blob(self)) {
         return -1;
     }
@@ -449,8 +455,9 @@ subscript_slice(pysqlite_Blob *self, PyObject *item)
 }
 
 static PyObject *
-blob_subscript(pysqlite_Blob *self, PyObject *item)
+blob_subscript(PyObject *op, PyObject *item)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     if (!check_blob(self)) {
         return NULL;
     }
@@ -546,8 +553,9 @@ ass_subscript_slice(pysqlite_Blob *self, PyObject *item, PyObject *value)
 }
 
 static int
-blob_ass_subscript(pysqlite_Blob *self, PyObject *item, PyObject *value)
+blob_ass_subscript(PyObject *op, PyObject *item, PyObject *value)
 {
+    pysqlite_Blob *self = _pysqlite_Blob_CAST(op);
     if (!check_blob(self)) {
         return -1;
     }
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
@@ -135,6 +135,8 @@ sqlite3_int64_converter(PyObject *obj, sqlite3_int64 *result)
 #include "clinic/connection.c.h"
 #undef clinic_state
 
+#define _pysqlite_Connection_CAST(op)   ((pysqlite_Connection *)(op))
+
 /*[clinic input]
 module _sqlite3
 class _sqlite3.Connection "pysqlite_Connection *" "clinic_state()->ConnectionType"
@@ -384,8 +386,9 @@ do {                                \
 } while (0)
 
 static int
-connection_traverse(pysqlite_Connection *self, visitproc visit, void *arg)
+connection_traverse(PyObject *op, visitproc visit, void *arg)
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     Py_VISIT(Py_TYPE(self));
     Py_VISIT(self->statement_cache);
     Py_VISIT(self->cursors);
@@ -409,8 +412,9 @@ clear_callback_context(callback_context *ctx)
 }
 
 static int
-connection_clear(pysqlite_Connection *self)
+connection_clear(PyObject *op)
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     Py_CLEAR(self->statement_cache);
     Py_CLEAR(self->cursors);
     Py_CLEAR(self->blobs);
@@ -517,7 +521,7 @@ connection_dealloc(PyObject *self)
     }
     PyTypeObject *tp = Py_TYPE(self);
     PyObject_GC_UnTrack(self);
-    tp->tp_clear(self);
+    (void)tp->tp_clear(self);
     tp->tp_free(self);
     Py_DECREF(tp);
 }
@@ -1715,8 +1719,10 @@ int pysqlite_check_thread(pysqlite_Connection* self)
     return 1;
 }
 
-static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
+static PyObject *
+pysqlite_connection_get_isolation_level(PyObject *op, void *Py_UNUSED(closure))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
@@ -1726,16 +1732,20 @@ static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* se
     Py_RETURN_NONE;
 }
 
-static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
+static PyObject *
+pysqlite_connection_get_total_changes(PyObject *op, void *Py_UNUSED(closure))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
     return PyLong_FromLong(sqlite3_total_changes(self->db));
 }
 
-static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)
+static PyObject *
+pysqlite_connection_get_in_transaction(PyObject *op, void *Py_UNUSED(closure))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
@@ -1746,8 +1756,11 @@ static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* sel
 }
 
 static int
-pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))
+pysqlite_connection_set_isolation_level(PyObject *op,
+                                        PyObject *isolation_level,
+                                        void *Py_UNUSED(ignored))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (isolation_level == NULL) {
         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
         return -1;
@@ -1770,11 +1783,11 @@ pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* iso
 }
 
 static PyObject *
-pysqlite_connection_call(pysqlite_Connection *self, PyObject *args,
-                         PyObject *kwargs)
+pysqlite_connection_call(PyObject *op, PyObject *args, PyObject *kwargs)
 {
     PyObject* sql;
     pysqlite_Statement* statement;
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
 
     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         return NULL;
@@ -2525,8 +2538,9 @@ getconfig_impl(pysqlite_Connection *self, int op)
 }
 
 static PyObject *
-get_autocommit(pysqlite_Connection *self, void *Py_UNUSED(ctx))
+get_autocommit(PyObject *op, void *Py_UNUSED(closure))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         return NULL;
     }
@@ -2540,8 +2554,9 @@ get_autocommit(pysqlite_Connection *self, void *Py_UNUSED(ctx))
 }
 
 static int
-set_autocommit(pysqlite_Connection *self, PyObject *val, void *Py_UNUSED(ctx))
+set_autocommit(PyObject *op, PyObject *val, void *Py_UNUSED(closure))
 {
+    pysqlite_Connection *self = _pysqlite_Connection_CAST(op);
     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         return -1;
     }
@@ -2566,7 +2581,7 @@ set_autocommit(pysqlite_Connection *self, PyObject *val, void *Py_UNUSED(ctx))
 }
 
 static PyObject *
-get_sig(PyObject *self, void *Py_UNUSED(ctx))
+get_sig(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure))
 {
     return PyUnicode_FromString("(sql, /)");
 }
@@ -2576,11 +2591,12 @@ static const char connection_doc[] =
 PyDoc_STR("SQLite database connection object.");
 
 static PyGetSetDef connection_getset[] = {
-    {"isolation_level",  (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
-    {"total_changes",  (getter)pysqlite_connection_get_total_changes, (setter)0},
-    {"in_transaction",  (getter)pysqlite_connection_get_in_transaction, (setter)0},
-    {"autocommit",  (getter)get_autocommit, (setter)set_autocommit},
-    {"__text_signature__", get_sig, (setter)0},
+    {"isolation_level", pysqlite_connection_get_isolation_level,
+     pysqlite_connection_set_isolation_level},
+    {"total_changes",  pysqlite_connection_get_total_changes, NULL},
+    {"in_transaction", pysqlite_connection_get_in_transaction, NULL},
+    {"autocommit",  get_autocommit, set_autocommit},
+    {"__text_signature__", get_sig, NULL},
     {NULL}
 };
 
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
@@ -44,6 +44,8 @@ typedef enum {
 #include "clinic/cursor.c.h"
 #undef clinic_state
 
+#define _pysqlite_Cursor_CAST(op)   ((pysqlite_Cursor *)(op))
+
 static inline int
 check_cursor_locked(pysqlite_Cursor *cur)
 {
@@ -146,8 +148,9 @@ stmt_reset(pysqlite_Statement *self)
 }
 
 static int
-cursor_traverse(pysqlite_Cursor *self, visitproc visit, void *arg)
+cursor_traverse(PyObject *op, visitproc visit, void *arg)
 {
+    pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);
     Py_VISIT(Py_TYPE(self));
     Py_VISIT(self->connection);
     Py_VISIT(self->description);
@@ -159,8 +162,9 @@ cursor_traverse(pysqlite_Cursor *self, visitproc visit, void *arg)
 }
 
 static int
-cursor_clear(pysqlite_Cursor *self)
+cursor_clear(PyObject *op)
 {
+    pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);
     Py_CLEAR(self->connection);
     Py_CLEAR(self->description);
     Py_CLEAR(self->row_cast_map);
@@ -176,14 +180,15 @@ cursor_clear(pysqlite_Cursor *self)
 }
 
 static void
-cursor_dealloc(pysqlite_Cursor *self)
+cursor_dealloc(PyObject *op)
 {
+    pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);
     PyTypeObject *tp = Py_TYPE(self);
     PyObject_GC_UnTrack(self);
     if (self->in_weakreflist != NULL) {
-        PyObject_ClearWeakRefs((PyObject*)self);
+        PyObject_ClearWeakRefs(op);
     }
-    tp->tp_clear((PyObject *)self);
+    (void)tp->tp_clear(op);
     tp->tp_free(self);
     Py_DECREF(tp);
 }
@@ -1087,8 +1092,9 @@ pysqlite_cursor_executescript_impl(pysqlite_Cursor *self,
 }
 
 static PyObject *
-pysqlite_cursor_iternext(pysqlite_Cursor *self)
+pysqlite_cursor_iternext(PyObject *op)
 {
+    pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);
     if (!check_cursor(self)) {
         return NULL;
     }
@@ -1125,7 +1131,7 @@ pysqlite_cursor_iternext(pysqlite_Cursor *self)
     }
     if (!Py_IsNone(self->row_factory)) {
         PyObject *factory = self->row_factory;
-        PyObject *args[] = { (PyObject *)self, row, };
+        PyObject *args[] = { op, row, };
         PyObject *new_row = PyObject_Vectorcall(factory, args, 2, NULL);
         Py_SETREF(row, new_row);
     }
@@ -1144,7 +1150,7 @@ pysqlite_cursor_fetchone_impl(pysqlite_Cursor *self)
 {
     PyObject* row;
 
-    row = pysqlite_cursor_iternext(self);
+    row = pysqlite_cursor_iternext((PyObject *)self);
     if (!row && !PyErr_Occurred()) {
         Py_RETURN_NONE;
     }
@@ -1174,7 +1180,7 @@ pysqlite_cursor_fetchmany_impl(pysqlite_Cursor *self, int maxrows)
         return NULL;
     }
 
-    while ((row = pysqlite_cursor_iternext(self))) {
+    while ((row = pysqlite_cursor_iternext((PyObject *)self))) {
         if (PyList_Append(list, row) < 0) {
             Py_DECREF(row);
             break;
@@ -1212,7 +1218,7 @@ pysqlite_cursor_fetchall_impl(pysqlite_Cursor *self)
         return NULL;
     }
 
-    while ((row = pysqlite_cursor_iternext(self))) {
+    while ((row = pysqlite_cursor_iternext((PyObject *)self))) {
         if (PyList_Append(list, row) < 0) {
             Py_DECREF(row);
             break;
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
@@ -617,7 +617,7 @@ module_clear(PyObject *module)
 static void
 module_free(void *module)
 {
-    module_clear((PyObject *)module);
+    (void)module_clear((PyObject *)module);
 }
 
 #define ADD_TYPE(module, type)                 \
diff --git a/Modules/_sqlite/prepare_protocol.c b/Modules/_sqlite/prepare_protocol.c
@@ -24,8 +24,7 @@
 #include "prepare_protocol.h"
 
 static int
-pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol *self, PyObject *args,
-                               PyObject *kwargs)
+pysqlite_prepare_protocol_init(PyObject *self, PyObject *args, PyObject *kwargs)
 {
     return 0;
 }
@@ -38,7 +37,7 @@ pysqlite_prepare_protocol_traverse(PyObject *self, visitproc visit, void *arg)
 }
 
 static void
-pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol *self)
+pysqlite_prepare_protocol_dealloc(PyObject *self)
 {
     PyTypeObject *tp = Py_TYPE(self);
     PyObject_GC_UnTrack(self);
diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c
diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`#include "clinic/blob.c.h"`
`10`	`10`	`#undef clinic_state`
`11`	`11`
	`12`	`+#define _pysqlite_Blob_CAST(op) ((pysqlite_Blob *)(op))`
	`13`	`+`
`12`	`14`	`/*[clinic input]`
`13`	`15`	`module _sqlite3`
`14`	`16`	`class _sqlite3.Blob "pysqlite_Blob *" "clinic_state()->BlobType"`
`@@ -29,32 +31,35 @@ close_blob(pysqlite_Blob *self)`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`static int`
`32`		`-blob_traverse(pysqlite_Blob self, visitproc visit, void arg)`
	`34`	`+blob_traverse(PyObject op, visitproc visit, void arg)`
`33`	`35`	`{`
	`36`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`34`	`37`	`Py_VISIT(Py_TYPE(self));`
`35`	`38`	`Py_VISIT(self->connection);`
`36`	`39`	`return 0;`
`37`	`40`	`}`
`38`	`41`
`39`	`42`	`static int`
`40`		`-blob_clear(pysqlite_Blob *self)`
	`43`	`+blob_clear(PyObject *op)`
`41`	`44`	`{`
	`45`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`42`	`46`	`Py_CLEAR(self->connection);`
`43`	`47`	`return 0;`
`44`	`48`	`}`
`45`	`49`
`46`	`50`	`static void`
`47`		`-blob_dealloc(pysqlite_Blob *self)`
	`51`	`+blob_dealloc(PyObject *op)`
`48`	`52`	`{`
	`53`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`49`	`54`	`PyTypeObject *tp = Py_TYPE(self);`
`50`	`55`	`PyObject_GC_UnTrack(self);`
`51`	`56`
`52`	`57`	`close_blob(self);`
`53`	`58`
`54`	`59`	`if (self->in_weakreflist != NULL) {`
`55`		`- PyObject_ClearWeakRefs((PyObject*)self);`
	`60`	`+ PyObject_ClearWeakRefs(op);`
`56`	`61`	`}`
`57`		`- tp->tp_clear((PyObject *)self);`
	`62`	`+ (void)tp->tp_clear(op);`
`58`	`63`	`tp->tp_free(self);`
`59`	`64`	`Py_DECREF(tp);`
`60`	`65`	`}`
`@@ -373,8 +378,9 @@ blob_exit_impl(pysqlite_Blob self, PyObject type, PyObject *val,`
`373`	`378`	`}`
`374`	`379`
`375`	`380`	`static Py_ssize_t`
`376`		`-blob_length(pysqlite_Blob *self)`
	`381`	`+blob_length(PyObject *op)`
`377`	`382`	`{`
	`383`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`378`	`384`	`if (!check_blob(self)) {`
`379`	`385`	`return -1;`
`380`	`386`	`}`
`@@ -449,8 +455,9 @@ subscript_slice(pysqlite_Blob self, PyObject item)`
`449`	`455`	`}`
`450`	`456`
`451`	`457`	`static PyObject *`
`452`		`-blob_subscript(pysqlite_Blob self, PyObject item)`
	`458`	`+blob_subscript(PyObject op, PyObject item)`
`453`	`459`	`{`
	`460`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`454`	`461`	`if (!check_blob(self)) {`
`455`	`462`	`return NULL;`
`456`	`463`	`}`
`@@ -546,8 +553,9 @@ ass_subscript_slice(pysqlite_Blob self, PyObject item, PyObject *value)`
`546`	`553`	`}`
`547`	`554`
`548`	`555`	`static int`
`549`		`-blob_ass_subscript(pysqlite_Blob self, PyObject item, PyObject *value)`
	`556`	`+blob_ass_subscript(PyObject op, PyObject item, PyObject *value)`
`550`	`557`	`{`
	`558`	`+ pysqlite_Blob *self = _pysqlite_Blob_CAST(op);`
`551`	`559`	`if (!check_blob(self)) {`
`552`	`560`	`return -1;`
`553`	`561`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,6 +135,8 @@ sqlite3_int64_converter(PyObject obj, sqlite3_int64 result)`
`135`	`135`	`#include "clinic/connection.c.h"`
`136`	`136`	`#undef clinic_state`
`137`	`137`
	`138`	`+#define _pysqlite_Connection_CAST(op) ((pysqlite_Connection *)(op))`
	`139`	`+`
`138`	`140`	`/*[clinic input]`
`139`	`141`	`module _sqlite3`
`140`	`142`	`class _sqlite3.Connection "pysqlite_Connection *" "clinic_state()->ConnectionType"`
`@@ -384,8 +386,9 @@ do { \`
`384`	`386`	`} while (0)`
`385`	`387`
`386`	`388`	`static int`
`387`		`-connection_traverse(pysqlite_Connection self, visitproc visit, void arg)`
	`389`	`+connection_traverse(PyObject op, visitproc visit, void arg)`
`388`	`390`	`{`
	`391`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`389`	`392`	`Py_VISIT(Py_TYPE(self));`
`390`	`393`	`Py_VISIT(self->statement_cache);`
`391`	`394`	`Py_VISIT(self->cursors);`
`@@ -409,8 +412,9 @@ clear_callback_context(callback_context *ctx)`
`409`	`412`	`}`
`410`	`413`
`411`	`414`	`static int`
`412`		`-connection_clear(pysqlite_Connection *self)`
	`415`	`+connection_clear(PyObject *op)`
`413`	`416`	`{`
	`417`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`414`	`418`	`Py_CLEAR(self->statement_cache);`
`415`	`419`	`Py_CLEAR(self->cursors);`
`416`	`420`	`Py_CLEAR(self->blobs);`
`@@ -517,7 +521,7 @@ connection_dealloc(PyObject *self)`
`517`	`521`	`}`
`518`	`522`	`PyTypeObject *tp = Py_TYPE(self);`
`519`	`523`	`PyObject_GC_UnTrack(self);`
`520`		`- tp->tp_clear(self);`
	`524`	`+ (void)tp->tp_clear(self);`
`521`	`525`	`tp->tp_free(self);`
`522`	`526`	`Py_DECREF(tp);`
`523`	`527`	`}`
`@@ -1715,8 +1719,10 @@ int pysqlite_check_thread(pysqlite_Connection* self)`
`1715`	`1719`	`return 1;`
`1716`	`1720`	`}`
`1717`	`1721`
`1718`		`-static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)`
	`1722`	`+static PyObject *`
	`1723`	`+pysqlite_connection_get_isolation_level(PyObject op, void Py_UNUSED(closure))`
`1719`	`1724`	`{`
	`1725`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`1720`	`1726`	`if (!pysqlite_check_connection(self)) {`
`1721`	`1727`	`return NULL;`
`1722`	`1728`	`}`
`@@ -1726,16 +1732,20 @@ static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* se`
`1726`	`1732`	`Py_RETURN_NONE;`
`1727`	`1733`	`}`
`1728`	`1734`
`1729`		`-static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)`
	`1735`	`+static PyObject *`
	`1736`	`+pysqlite_connection_get_total_changes(PyObject op, void Py_UNUSED(closure))`
`1730`	`1737`	`{`
	`1738`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`1731`	`1739`	`if (!pysqlite_check_connection(self)) {`
`1732`	`1740`	`return NULL;`
`1733`	`1741`	`}`
`1734`	`1742`	`return PyLong_FromLong(sqlite3_total_changes(self->db));`
`1735`	`1743`	`}`
`1736`	`1744`
`1737`		`-static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)`
	`1745`	`+static PyObject *`
	`1746`	`+pysqlite_connection_get_in_transaction(PyObject op, void Py_UNUSED(closure))`
`1738`	`1747`	`{`
	`1748`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`1739`	`1749`	`if (!pysqlite_check_connection(self)) {`
`1740`	`1750`	`return NULL;`
`1741`	`1751`	`}`
`@@ -1746,8 +1756,11 @@ static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* sel`
`1746`	`1756`	`}`
`1747`	`1757`
`1748`	`1758`	`static int`
`1749`		`-pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))`
	`1759`	`+pysqlite_connection_set_isolation_level(PyObject *op,`
	`1760`	`+ PyObject *isolation_level,`
	`1761`	`+ void *Py_UNUSED(ignored))`
`1750`	`1762`	`{`
	`1763`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`1751`	`1764`	`if (isolation_level == NULL) {`
`1752`	`1765`	`PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");`
`1753`	`1766`	`return -1;`
`@@ -1770,11 +1783,11 @@ pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* iso`
`1770`	`1783`	`}`
`1771`	`1784`
`1772`	`1785`	`static PyObject *`
`1773`		`-pysqlite_connection_call(pysqlite_Connection self, PyObject args,`
`1774`		`- PyObject *kwargs)`
	`1786`	`+pysqlite_connection_call(PyObject op, PyObject args, PyObject *kwargs)`
`1775`	`1787`	`{`
`1776`	`1788`	`PyObject* sql;`
`1777`	`1789`	`pysqlite_Statement* statement;`
	`1790`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`1778`	`1791`
`1779`	`1792`	`if (!pysqlite_check_thread(self) \|\| !pysqlite_check_connection(self)) {`
`1780`	`1793`	`return NULL;`
`@@ -2525,8 +2538,9 @@ getconfig_impl(pysqlite_Connection *self, int op)`
`2525`	`2538`	`}`
`2526`	`2539`
`2527`	`2540`	`static PyObject *`
`2528`		`-get_autocommit(pysqlite_Connection self, void Py_UNUSED(ctx))`
	`2541`	`+get_autocommit(PyObject op, void Py_UNUSED(closure))`
`2529`	`2542`	`{`
	`2543`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`2530`	`2544`	`if (!pysqlite_check_thread(self) \|\| !pysqlite_check_connection(self)) {`
`2531`	`2545`	`return NULL;`
`2532`	`2546`	`}`
`@@ -2540,8 +2554,9 @@ get_autocommit(pysqlite_Connection self, void Py_UNUSED(ctx))`
`2540`	`2554`	`}`
`2541`	`2555`
`2542`	`2556`	`static int`
`2543`		`-set_autocommit(pysqlite_Connection self, PyObject val, void *Py_UNUSED(ctx))`
	`2557`	`+set_autocommit(PyObject op, PyObject val, void *Py_UNUSED(closure))`
`2544`	`2558`	`{`
	`2559`	`+ pysqlite_Connection *self = _pysqlite_Connection_CAST(op);`
`2545`	`2560`	`if (!pysqlite_check_thread(self) \|\| !pysqlite_check_connection(self)) {`
`2546`	`2561`	`return -1;`
`2547`	`2562`	`}`
`@@ -2566,7 +2581,7 @@ set_autocommit(pysqlite_Connection self, PyObject val, void *Py_UNUSED(ctx))`
`2566`	`2581`	`}`
`2567`	`2582`
`2568`	`2583`	`static PyObject *`
`2569`		`-get_sig(PyObject self, void Py_UNUSED(ctx))`
	`2584`	`+get_sig(PyObject Py_UNUSED(self), void Py_UNUSED(closure))`
`2570`	`2585`	`{`
`2571`	`2586`	`return PyUnicode_FromString("(sql, /)");`
`2572`	`2587`	`}`
`@@ -2576,11 +2591,12 @@ static const char connection_doc[] =`
`2576`	`2591`	`PyDoc_STR("SQLite database connection object.");`
`2577`	`2592`
`2578`	`2593`	`static PyGetSetDef connection_getset[] = {`
`2579`		`- {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},`
`2580`		`- {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0},`
`2581`		`- {"in_transaction", (getter)pysqlite_connection_get_in_transaction, (setter)0},`
`2582`		`- {"autocommit", (getter)get_autocommit, (setter)set_autocommit},`
`2583`		`- {"__text_signature__", get_sig, (setter)0},`
	`2594`	`+ {"isolation_level", pysqlite_connection_get_isolation_level,`
	`2595`	`+ pysqlite_connection_set_isolation_level},`
	`2596`	`+ {"total_changes", pysqlite_connection_get_total_changes, NULL},`
	`2597`	`+ {"in_transaction", pysqlite_connection_get_in_transaction, NULL},`
	`2598`	`+ {"autocommit", get_autocommit, set_autocommit},`
	`2599`	`+ {"__text_signature__", get_sig, NULL},`
`2584`	`2600`	`{NULL}`
`2585`	`2601`	`};`
`2586`	`2602`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,8 @@ typedef enum {`
`44`	`44`	`#include "clinic/cursor.c.h"`
`45`	`45`	`#undef clinic_state`
`46`	`46`
	`47`	`+#define _pysqlite_Cursor_CAST(op) ((pysqlite_Cursor *)(op))`
	`48`	`+`
`47`	`49`	`static inline int`
`48`	`50`	`check_cursor_locked(pysqlite_Cursor *cur)`
`49`	`51`	`{`
`@@ -146,8 +148,9 @@ stmt_reset(pysqlite_Statement *self)`
`146`	`148`	`}`
`147`	`149`
`148`	`150`	`static int`
`149`		`-cursor_traverse(pysqlite_Cursor self, visitproc visit, void arg)`
	`151`	`+cursor_traverse(PyObject op, visitproc visit, void arg)`
`150`	`152`	`{`
	`153`	`+ pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);`
`151`	`154`	`Py_VISIT(Py_TYPE(self));`
`152`	`155`	`Py_VISIT(self->connection);`
`153`	`156`	`Py_VISIT(self->description);`
`@@ -159,8 +162,9 @@ cursor_traverse(pysqlite_Cursor self, visitproc visit, void arg)`
`159`	`162`	`}`
`160`	`163`
`161`	`164`	`static int`
`162`		`-cursor_clear(pysqlite_Cursor *self)`
	`165`	`+cursor_clear(PyObject *op)`
`163`	`166`	`{`
	`167`	`+ pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);`
`164`	`168`	`Py_CLEAR(self->connection);`
`165`	`169`	`Py_CLEAR(self->description);`
`166`	`170`	`Py_CLEAR(self->row_cast_map);`
`@@ -176,14 +180,15 @@ cursor_clear(pysqlite_Cursor *self)`
`176`	`180`	`}`
`177`	`181`
`178`	`182`	`static void`
`179`		`-cursor_dealloc(pysqlite_Cursor *self)`
	`183`	`+cursor_dealloc(PyObject *op)`
`180`	`184`	`{`
	`185`	`+ pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);`
`181`	`186`	`PyTypeObject *tp = Py_TYPE(self);`
`182`	`187`	`PyObject_GC_UnTrack(self);`
`183`	`188`	`if (self->in_weakreflist != NULL) {`
`184`		`- PyObject_ClearWeakRefs((PyObject*)self);`
	`189`	`+ PyObject_ClearWeakRefs(op);`
`185`	`190`	`}`
`186`		`- tp->tp_clear((PyObject *)self);`
	`191`	`+ (void)tp->tp_clear(op);`
`187`	`192`	`tp->tp_free(self);`
`188`	`193`	`Py_DECREF(tp);`
`189`	`194`	`}`
`@@ -1087,8 +1092,9 @@ pysqlite_cursor_executescript_impl(pysqlite_Cursor *self,`
`1087`	`1092`	`}`
`1088`	`1093`
`1089`	`1094`	`static PyObject *`
`1090`		`-pysqlite_cursor_iternext(pysqlite_Cursor *self)`
	`1095`	`+pysqlite_cursor_iternext(PyObject *op)`
`1091`	`1096`	`{`
	`1097`	`+ pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);`
`1092`	`1098`	`if (!check_cursor(self)) {`
`1093`	`1099`	`return NULL;`
`1094`	`1100`	`}`
`@@ -1125,7 +1131,7 @@ pysqlite_cursor_iternext(pysqlite_Cursor *self)`
`1125`	`1131`	`}`
`1126`	`1132`	`if (!Py_IsNone(self->row_factory)) {`
`1127`	`1133`	`PyObject *factory = self->row_factory;`
`1128`		`- PyObject args[] = { (PyObject )self, row, };`
	`1134`	`+ PyObject *args[] = { op, row, };`
`1129`	`1135`	`PyObject *new_row = PyObject_Vectorcall(factory, args, 2, NULL);`
`1130`	`1136`	`Py_SETREF(row, new_row);`
`1131`	`1137`	`}`
`@@ -1144,7 +1150,7 @@ pysqlite_cursor_fetchone_impl(pysqlite_Cursor *self)`
`1144`	`1150`	`{`
`1145`	`1151`	`PyObject* row;`
`1146`	`1152`
`1147`		`- row = pysqlite_cursor_iternext(self);`
	`1153`	`+ row = pysqlite_cursor_iternext((PyObject *)self);`
`1148`	`1154`	`if (!row && !PyErr_Occurred()) {`
`1149`	`1155`	`Py_RETURN_NONE;`
`1150`	`1156`	`}`
`@@ -1174,7 +1180,7 @@ pysqlite_cursor_fetchmany_impl(pysqlite_Cursor *self, int maxrows)`
`1174`	`1180`	`return NULL;`
`1175`	`1181`	`}`
`1176`	`1182`
`1177`		`- while ((row = pysqlite_cursor_iternext(self))) {`
	`1183`	`+ while ((row = pysqlite_cursor_iternext((PyObject *)self))) {`
`1178`	`1184`	`if (PyList_Append(list, row) < 0) {`
`1179`	`1185`	`Py_DECREF(row);`
`1180`	`1186`	`break;`
`@@ -1212,7 +1218,7 @@ pysqlite_cursor_fetchall_impl(pysqlite_Cursor *self)`
`1212`	`1218`	`return NULL;`
`1213`	`1219`	`}`
`1214`	`1220`
`1215`		`- while ((row = pysqlite_cursor_iternext(self))) {`
	`1221`	`+ while ((row = pysqlite_cursor_iternext((PyObject *)self))) {`
`1216`	`1222`	`if (PyList_Append(list, row) < 0) {`
`1217`	`1223`	`Py_DECREF(row);`
`1218`	`1224`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -617,7 +617,7 @@ module_clear(PyObject *module)`
`617`	`617`	`static void`
`618`	`618`	`module_free(void *module)`
`619`	`619`	`{`
`620`		`- module_clear((PyObject *)module);`
	`620`	`+ (void)module_clear((PyObject *)module);`
`621`	`621`	`}`
`622`	`622`
`623`	`623`	`#define ADD_TYPE(module, type) \`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,7 @@`
`24`	`24`	`#include "prepare_protocol.h"`
`25`	`25`
`26`	`26`	`static int`
`27`		`-pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol self, PyObject args,`
`28`		`- PyObject *kwargs)`
	`27`	`+pysqlite_prepare_protocol_init(PyObject self, PyObject args, PyObject *kwargs)`
`29`	`28`	`{`
`30`	`29`	`return 0;`
`31`	`30`	`}`
`@@ -38,7 +37,7 @@ pysqlite_prepare_protocol_traverse(PyObject self, visitproc visit, void arg)`
`38`	`37`	`}`
`39`	`38`
`40`	`39`	`static void`
`41`		`-pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol *self)`
	`40`	`+pysqlite_prepare_protocol_dealloc(PyObject *self)`
`42`	`41`	`{`
`43`	`42`	`PyTypeObject *tp = Py_TYPE(self);`
`44`	`43`	`PyObject_GC_UnTrack(self);`