t-strings: Reduce undefined behaviour and general improvements (#72)

AA-Turner · picnixz · web-flow · commit 578289768820 · 2025-04-19T17:29:20.000+02:00
Co-authored-by: Bénédikt Tran &lt;10796600+picnixz@users.noreply.github.com&gt;
diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h
@@ -13,7 +13,6 @@ extern "C" {
 
 extern PyTypeObject _PyInterpolation_Type;
 
-#define _PyInterpolation_Check(op) PyObject_TypeCheck((op), &_PyInterpolation_Type)
 #define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type)
 
 PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values);
diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h
@@ -12,7 +12,6 @@ extern "C" {
 extern PyTypeObject _PyTemplate_Type;
 extern PyTypeObject _PyTemplateIter_Type;
 
-#define _PyTemplate_Check(op) PyObject_TypeCheck((op), &_PyTemplate_Type)
 #define _PyTemplate_CheckExact(op) Py_IS_TYPE((op), &_PyTemplate_Type)
 
 extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other);
diff --git a/Makefile.pre.in b/Makefile.pre.in
@@ -542,6 +542,7 @@ OBJECT_OBJS=	\
 		Objects/floatobject.o \
 		Objects/frameobject.o \
 		Objects/funcobject.o \
+		Objects/interpolationobject.o \
 		Objects/iterobject.o \
 		Objects/listobject.o \
 		Objects/longobject.o \
@@ -558,15 +559,14 @@ OBJECT_OBJS=	\
 		Objects/setobject.o \
 		Objects/sliceobject.o \
 		Objects/structseq.o \
+		Objects/templateobject.o \
 		Objects/tupleobject.o \
 		Objects/typeobject.o \
 		Objects/typevarobject.o \
 		Objects/unicodeobject.o \
 		Objects/unicodectype.o \
 		Objects/unionobject.o \
 		Objects/weakrefobject.o \
-		Objects/interpolationobject.o \
-		Objects/templateobject.o \
 		@PERF_TRAMPOLINE_OBJ@
 
 ##########################################################################
diff --git a/Modules/Setup.bootstrap.in b/Modules/Setup.bootstrap.in
@@ -21,12 +21,12 @@ _io _io/_iomodule.c _io/iobase.c _io/fileio.c _io/bytesio.c _io/bufferedio.c _io
 itertools itertoolsmodule.c
 _sre _sre/sre.c
 _sysconfig _sysconfig.c
+_templatelib _templatelibmodule.c
 _thread _threadmodule.c
 time timemodule.c
 _types _typesmodule.c
 _typing _typingmodule.c
 _weakref _weakref.c
-_templatelib _templatelibmodule.c
 
 # commonly used core modules
 _abc _abc.c
diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c
@@ -13,9 +13,8 @@ _conversion_converter(PyObject *arg, PyObject **conversion)
 
     if (!PyUnicode_Check(arg)) {
         PyErr_Format(PyExc_TypeError,
-            "%.200s() %.200s must be %.50s, not %.50s",
-            "Interpolation", "argument 'conversion'", "str",
-            arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
+            "Interpolation() argument 'conversion' must be str, not %T",
+            arg);
         return 0;
     }
 
@@ -46,6 +45,9 @@ typedef struct {
     PyObject *format_spec;
 } interpolationobject;
 
+#define interpolationobject_CAST(op) \
+    (assert(_PyInterpolation_CheckExact(op)), _Py_CAST(interpolationobject*, (op)))
+
 /*[clinic input]
 @classmethod
 Interpolation.__new__ as interpolation_new
@@ -75,8 +77,9 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value,
 }
 
 static void
-interpolation_dealloc(interpolationobject *self)
+interpolation_dealloc(PyObject *op)
 {
+    interpolationobject *self = interpolationobject_CAST(op);
     PyObject_GC_UnTrack(self);
     Py_CLEAR(self->value);
     Py_CLEAR(self->expression);
@@ -86,8 +89,9 @@ interpolation_dealloc(interpolationobject *self)
 }
 
 static int
-interpolation_traverse(interpolationobject *self, visitproc visit, void *arg)
+interpolation_traverse(PyObject *op, visitproc visit, void *arg)
 {
+    interpolationobject *self = interpolationobject_CAST(op);
     Py_VISIT(self->value);
     Py_VISIT(self->expression);
     Py_VISIT(self->conversion);
@@ -96,11 +100,11 @@ interpolation_traverse(interpolationobject *self, visitproc visit, void *arg)
 }
 
 static PyObject *
-interpolation_repr(interpolationobject *self)
+interpolation_repr(PyObject *op)
 {
-    return PyUnicode_FromFormat("%s(%R, %R, %R, %R)",
-                                _PyType_Name(Py_TYPE(self)),
-                                self->value, self->expression,
+    interpolationobject *self = interpolationobject_CAST(op);
+    return PyUnicode_FromFormat("%T(%R, %R, %R, %R)",
+                                self, self->value, self->expression,
                                 self->conversion, self->format_spec);
 }
 
@@ -119,13 +123,13 @@ PyTypeObject _PyInterpolation_Type = {
     .tp_basicsize = sizeof(interpolationobject),
     .tp_itemsize = 0,
     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
-    .tp_new = (newfunc) interpolation_new,
+    .tp_new = interpolation_new,
     .tp_alloc = PyType_GenericAlloc,
-    .tp_dealloc = (destructor) interpolation_dealloc,
+    .tp_dealloc = interpolation_dealloc,
     .tp_free = PyObject_GC_Del,
-    .tp_repr = (reprfunc) interpolation_repr,
+    .tp_repr = interpolation_repr,
     .tp_members = interpolation_members,
-    .tp_traverse = (traverseproc) interpolation_traverse,
+    .tp_traverse = interpolation_traverse,
 };
 
 static PyObject *
@@ -213,5 +217,5 @@ _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values)
 PyObject *
 _PyInterpolation_GetValue(PyObject *interpolation)
 {
-    return ((interpolationobject *) interpolation)->value;
+    return interpolationobject_CAST(interpolation)->value;
 }
diff --git a/Objects/templateobject.c b/Objects/templateobject.c
@@ -1,7 +1,7 @@
 /* t-string Template object implementation */
 
 #include "Python.h"
-#include "pycore_interpolation.h" // _PyInterpolation_Check()
+#include "pycore_interpolation.h" // _PyInterpolation_CheckExact()
 #include "pycore_template.h"
 
 typedef struct {
@@ -67,6 +67,9 @@ typedef struct {
     PyObject *interpolations;
 } templateobject;
 
+#define templateobject_CAST(op) \
+    (assert(_PyTemplate_CheckExact(op)), _Py_CAST(templateobject*, (op)))
+
 static templateobject *
 template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations)
 {
@@ -80,7 +83,7 @@ template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyOb
     return template;
 }
 
-static templateobject *
+static PyObject *
 template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     if (kwds != NULL) {
@@ -101,7 +104,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
             }
             last_was_str = 1;
         }
-        else if (_PyInterpolation_Check(item)) {
+        else if (_PyInterpolation_CheckExact(item)) {
             if (!last_was_str) {
                 stringslen++;
             }
@@ -149,7 +152,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
             }
             last_was_str = 1;
         }
-        else if (_PyInterpolation_Check(item)) {
+        else if (_PyInterpolation_CheckExact(item)) {
             if (!last_was_str) {
                 PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty));
             }
@@ -164,38 +167,42 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     templateobject *template = template_from_strings_interpolations(type, strings, interpolations);
     Py_DECREF(strings);
     Py_DECREF(interpolations);
-    return template;
+    return (PyObject *)template;
 }
 
 static void
-template_dealloc(templateobject *self)
+template_dealloc(PyObject *op)
 {
+    templateobject *self = templateobject_CAST(op);
     PyObject_GC_UnTrack(self);
     Py_CLEAR(self->strings);
     Py_CLEAR(self->interpolations);
     Py_TYPE(self)->tp_free(self);
 }
 
 static int
-template_traverse(templateobject *self, visitproc visit, void *arg)
+template_traverse(PyObject *op, visitproc visit, void *arg)
 {
+    templateobject *self = templateobject_CAST(op);
     Py_VISIT(self->strings);
     Py_VISIT(self->interpolations);
     return 0;
 }
 
 static PyObject *
-template_repr(templateobject *self)
+template_repr(PyObject *op)
 {
+    templateobject *self = templateobject_CAST(op);
     return PyUnicode_FromFormat("%s(strings=%R, interpolations=%R)",
                                 _PyType_Name(Py_TYPE(self)),
                                 self->strings,
                                 self->interpolations);
 }
 
-static templateiterobject *
-template_iter(templateobject *self)
+static PyObject *
+template_iter(PyObject *op)
 {
+    templateobject *self = templateobject_CAST(op);
     templateiterobject *iter = PyObject_GC_New(templateiterobject, &_PyTemplateIter_Type);
     if (iter == NULL) {
         return NULL;
@@ -218,7 +225,7 @@ template_iter(templateobject *self)
     iter->interpolationsiter = interpolationsiter;
     iter->from_strings = 1;
     PyObject_GC_Track(iter);
-    return iter;
+    return (PyObject *)iter;
 }
 
 static PyObject *
@@ -398,13 +405,13 @@ template_concat_str_template(templateobject *self, PyObject *other)
 PyObject *
 _PyTemplate_Concat(PyObject *self, PyObject *other)
 {
-    if (_PyTemplate_Check(self) && _PyTemplate_Check(other)) {
+    if (_PyTemplate_CheckExact(self) && _PyTemplate_CheckExact(other)) {
         return template_concat_templates((templateobject *) self, (templateobject *) other);
     }
-    else if ((_PyTemplate_Check(self)) && PyUnicode_Check(other)) {
+    else if ((_PyTemplate_CheckExact(self)) && PyUnicode_Check(other)) {
         return template_concat_template_str((templateobject *) self, other);
     }
-    else if (PyUnicode_Check(self) && (_PyTemplate_Check(other))) {
+    else if (PyUnicode_Check(self) && (_PyTemplate_CheckExact(other))) {
         return template_concat_str_template((templateobject *) other, self);
     }
     else {
@@ -413,8 +420,9 @@ _PyTemplate_Concat(PyObject *self, PyObject *other)
 }
 
 static PyObject *
-template_values_get(templateobject *self, void *Py_UNUSED(data))
+template_values_get(PyObject *op, void *Py_UNUSED(data))
 {
+    templateobject *self = templateobject_CAST(op);
     PyObject *values = PyTuple_New(PyTuple_GET_SIZE(self->interpolations));
     if (values == NULL) {
         return NULL;
@@ -448,7 +456,7 @@ static PyMemberDef template_members[] = {
 };
 
 static PyGetSetDef template_getset[] = {
-    {"values", (getter) template_values_get, NULL, "Values of interpolations", NULL},
+    {"values", template_values_get, NULL, "Values of interpolations", NULL},
     {NULL},
 };
 
@@ -464,15 +472,15 @@ PyTypeObject _PyTemplate_Type = {
     .tp_itemsize = 0,
     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
     .tp_as_sequence = &template_as_sequence,
-    .tp_new = (newfunc) template_new,
+    .tp_new = template_new,
     .tp_alloc = PyType_GenericAlloc,
-    .tp_dealloc = (destructor) template_dealloc,
+    .tp_dealloc = template_dealloc,
     .tp_free = PyObject_GC_Del,
-    .tp_repr = (reprfunc) template_repr,
+    .tp_repr = template_repr,
     .tp_members = template_members,
     .tp_getset = template_getset,
-    .tp_iter = (getiterfunc) template_iter,
-    .tp_traverse = (traverseproc) template_traverse,
+    .tp_iter = template_iter,
+    .tp_traverse = template_traverse,
 };
 
 PyObject *
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
@@ -11618,7 +11618,7 @@ PyUnicode_Concat(PyObject *left, PyObject *right)
         return NULL;
 
     if (!PyUnicode_Check(right)) {
-        if (_PyTemplate_Check(right)) {
+        if (_PyTemplate_CheckExact(right)) {
             // str + tstring is implemented in the tstring type
             return _PyTemplate_Concat(left, right);
         }

Original file line number	Diff line number	Diff line change
`@@ -11618,7 +11618,7 @@ PyUnicode_Concat(PyObject left, PyObject right)`
`11618`	`11618`	`return NULL;`
`11619`	`11619`
`11620`	`11620`	`if (!PyUnicode_Check(right)) {`
`11621`		`- if (_PyTemplate_Check(right)) {`
	`11621`	`+ if (_PyTemplate_CheckExact(right)) {`
`11622`	`11622`	`// str + tstring is implemented in the tstring type`
`11623`	`11623`	`return _PyTemplate_Concat(left, right);`
`11624`	`11624`	`}`