Use stack buffers for repr-mode float and complex formatting

float_repr() and complex_repr() now format into stack buffers via
_Py_double_repr_buffered() and call _PyUnicode_FromASCII() directly,
eliminating the per-call PyMem_Malloc/strlen/PyMem_Free round-trip
(and PyUnicode_FromFormat for complex).

float.__format__ and complex.__format__ short-circuit an empty format
spec to the corresponding repr for exact instances, skipping the
_PyUnicodeWriter setup.

format_float_internal() in unicode_formatter.c uses a stack buffer
when the effective format code is 'r' (no type code given), avoiding
the PyOS_double_to_string heap allocation for f"{x:>10}" and similar.
The write-only float_type local is removed; the equivalent dead
re_float_type/im_float_type in format_complex_internal are removed
while here.

The legacy _PY_SHORT_FLOAT_REPR == 0 paths are preserved under
#else for non-IEEE-754 platforms.

Author: gpshead

Objects/complexobject.c

@@ -12,6 +12,7 @@
 #include "pycore_long.h"          // _PyLong_GetZero()
 #include "pycore_object.h"        // _PyObject_Init()
 #include "pycore_pymath.h"        // _Py_ADJUST_ERANGE2()
+#include "pycore_ryu.h"           // _Py_double_repr_buffered()
 
 
 #define _PyComplexObject_CAST(op)   ((PyComplexObject *)(op))
@@ -573,10 +574,38 @@ PyComplex_AsCComplex(PyObject *op)
 static PyObject *
 complex_repr(PyObject *op)
 {
+    PyComplexObject *v = _PyComplexObject_CAST(op);
+#if _PY_SHORT_FLOAT_REPR == 1
+    char buf[2 * _Py_DOUBLE_REPR_BUFSIZE + 4];
+    char *p = buf;
+    Py_ssize_t n;
+
+    if (v->cval.real == 0. && copysign(1.0, v->cval.real) == 1.0) {
+        /* Real part is +0: just output the imaginary part and do not
+           include parens. */
+        n = _Py_double_repr_buffered(v->cval.imag, p, sizeof(buf), 0);
+        p += n;
+        *p++ = 'j';
+    }
+    else {
+        /* Format imaginary part with sign, real part without. Include
+           parens in the result. */
+        *p++ = '(';
+        n = _Py_double_repr_buffered(v->cval.real, p,
+                                     _Py_DOUBLE_REPR_BUFSIZE, 0);
+        p += n;
+        n = _Py_double_repr_buffered(v->cval.imag, p,
+                                     _Py_DOUBLE_REPR_BUFSIZE,
+                                     Py_DTSF_SIGN);
+        p += n;
+        *p++ = 'j';
+        *p++ = ')';
+    }
+    return _PyUnicode_FromASCII(buf, p - buf);
+#else
     int precision = 0;
     char format_code = 'r';
     PyObject *result = NULL;
-    PyComplexObject *v = _PyComplexObject_CAST(op);
 
     /* If these are non-NULL, they'll need to be freed. */
     char *pre = NULL;
@@ -625,6 +654,7 @@ complex_repr(PyObject *op)
     PyMem_Free(pre);
 
     return result;
+#endif
 }
 
 static Py_hash_t
@@ -913,6 +943,13 @@ complex___format___impl(PyComplexObject *self, PyObject *format_spec)
 {
     _PyUnicodeWriter writer;
     int ret;
+
+    if (PyUnicode_GET_LENGTH(format_spec) == 0
+        && Py_IS_TYPE(self, &PyComplex_Type))
+    {
+        return complex_repr((PyObject *)self);
+    }
+
     _PyUnicodeWriter_Init(&writer);
     ret = _PyComplex_FormatAdvancedWriter(
         &writer,

Objects/floatobject.c

@@ -13,6 +13,7 @@
 #include "pycore_modsupport.h"    // _PyArg_NoKwnames()
 #include "pycore_object.h"        // _PyObject_Init(), _PyDebugAllocatorStats()
 #include "pycore_pymath.h"        // _PY_SHORT_FLOAT_REPR
+#include "pycore_ryu.h"           // _Py_double_repr_buffered()
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "pycore_stackref.h"      // PyStackRef_AsPyObjectBorrow()
 #include "pycore_structseq.h"     // _PyStructSequence_FiniBuiltin()
@@ -339,6 +340,13 @@ static PyObject *
 float_repr(PyObject *op)
 {
     PyFloatObject *v = _PyFloat_CAST(op);
+#if _PY_SHORT_FLOAT_REPR == 1
+    char buf[_Py_DOUBLE_REPR_BUFSIZE];
+    Py_ssize_t len = _Py_double_repr_buffered(PyFloat_AS_DOUBLE(v),
+                                              buf, sizeof(buf),
+                                              Py_DTSF_ADD_DOT_0);
+    return _PyUnicode_FromASCII(buf, len);
+#else
     PyObject *result;
     char *buf;
 
@@ -351,6 +359,7 @@ float_repr(PyObject *op)
     result = _PyUnicode_FromASCII(buf, strlen(buf));
     PyMem_Free(buf);
     return result;
+#endif
 }
 
 /* Comparison is pretty much a nightmare.  When comparing float to float,
@@ -1729,6 +1738,12 @@ float___format___impl(PyObject *self, PyObject *format_spec)
     _PyUnicodeWriter writer;
     int ret;
 
+    if (PyUnicode_GET_LENGTH(format_spec) == 0
+        && Py_IS_TYPE(self, &PyFloat_Type))
+    {
+        return float_repr(self);
+    }
+
     _PyUnicodeWriter_Init(&writer);
     ret = _PyFloat_FormatAdvancedWriter(
         &writer,

Objects/unicode_formatter.c

@@ -5,6 +5,7 @@
 #include "Python.h"
 #include "pycore_fileutils.h"     // _Py_GetLocaleconvNumeric()
 #include "pycore_long.h"          // _PyLong_FormatWriter()
+#include "pycore_ryu.h"           // _Py_double_repr_buffered()
 #include "pycore_unicodeobject.h" // PyUnicode_MAX_CHAR_VALUE()
 #include <locale.h>
 
@@ -1375,6 +1376,7 @@ format_float_internal(PyObject *value,
                       _PyUnicodeWriter *writer)
 {
     char *buf = NULL;       /* buffer returned from PyOS_double_to_string */
+    int buf_allocated = 1;
     Py_ssize_t n_digits;
     Py_ssize_t n_remainder;
     Py_ssize_t n_frac;
@@ -1390,7 +1392,6 @@ format_float_internal(PyObject *value,
     int result = -1;
     Py_UCS4 maxchar = 127;
     Py_UCS4 sign_char = '\0';
-    int float_type; /* Used to see if we have a nan, inf, or regular float. */
     PyObject *unicode_tmp = NULL;
 
     /* Locale settings, either from the actual locale or
@@ -1440,11 +1441,23 @@ format_float_internal(PyObject *value,
     /* Cast "type", because if we're in unicode we need to pass an
        8-bit char. This is safe, because we've restricted what "type"
        can be. */
-    buf = PyOS_double_to_string(val, (char)type, precision, flags,
-                                &float_type);
-    if (buf == NULL)
-        goto done;
-    n_digits = strlen(buf);
+#if _PY_SHORT_FLOAT_REPR == 1
+    char repr_buf[_Py_DOUBLE_REPR_BUFSIZE];
+    if (type == 'r') {
+        n_digits = _Py_double_repr_buffered(val, repr_buf, sizeof(repr_buf),
+                                            flags);
+        buf = repr_buf;
+        buf_allocated = 0;
+    }
+    else
+#endif
+    {
+        buf = PyOS_double_to_string(val, (char)type, precision, flags,
+                                    NULL);
+        if (buf == NULL)
+            goto done;
+        n_digits = strlen(buf);
+    }
 
     if (add_pct) {
         /* We know that buf has a trailing zero (since we just called
@@ -1462,14 +1475,18 @@ format_float_internal(PyObject *value,
     {
         /* Fast path */
         result = _PyUnicodeWriter_WriteASCIIString(writer, buf, n_digits);
-        PyMem_Free(buf);
+        if (buf_allocated) {
+            PyMem_Free(buf);
+        }
         return result;
     }
 
     /* Since there is no unicode version of PyOS_double_to_string,
        just use the 8 bit version and then convert to unicode. */
     unicode_tmp = _PyUnicode_FromASCII(buf, n_digits);
-    PyMem_Free(buf);
+    if (buf_allocated) {
+        PyMem_Free(buf);
+    }
     if (unicode_tmp == NULL)
         goto done;
 
@@ -1556,8 +1573,6 @@ format_complex_internal(PyObject *value,
     void *rdata;
     Py_UCS4 re_sign_char = '\0';
     Py_UCS4 im_sign_char = '\0';
-    int re_float_type; /* Used to see if we have a nan, inf, or regular float. */
-    int im_float_type;
     int add_parens = 0;
     int skip_re = 0;
     Py_ssize_t lpad;
@@ -1628,11 +1643,11 @@ format_complex_internal(PyObject *value,
        8-bit char. This is safe, because we've restricted what "type"
        can be. */
     re_buf = PyOS_double_to_string(re, (char)type, precision, flags,
-                                   &re_float_type);
+                                   NULL);
     if (re_buf == NULL)
         goto done;
     im_buf = PyOS_double_to_string(im, (char)type, precision, flags,
-                                   &im_float_type);
+                                   NULL);
     if (im_buf == NULL)
         goto done;