gh-69639: add mixed-mode rules for complex arithmetic (C-like)

Include/internal/pycore_floatobject.h

@@ -54,7 +54,7 @@ extern PyObject* _Py_string_to_number_with_underscores(
 
 extern double _Py_parse_inf_or_nan(const char *p, char **endptr);
 
-extern int _Py_convert_to_double(PyObject **v, double *dbl);
+extern int _Py_convert_int_to_double(PyObject **v, double *dbl);
 
 
 #ifdef __cplusplus

Lib/test/test_complex.py

@@ -249,10 +249,12 @@ def test_sub(self):
     def test_mul(self):
         self.assertEqual(1j * int(20), complex(0, 20))
         self.assertEqual(1j * int(-1), complex(0, -1))
-        self.assertComplexesAreIdentical(complex(INF, NAN) * 2,
-                                         complex(INF, NAN))
-        self.assertComplexesAreIdentical(2 * complex(INF, NAN),
-                                         complex(INF, NAN))
+        for c, r in [(2, complex(INF, 2)), (INF, complex(INF, INF)),
+                     (0, complex(NAN, 0)), (-0.0, complex(NAN, -0.0)),
+                     (NAN, complex(NAN, NAN))]:
+            with self.subTest(c=c, r=r):
+                self.assertComplexesAreIdentical(complex(INF, 1) * c, r)
+                self.assertComplexesAreIdentical(c * complex(INF, 1), r)
         self.assertRaises(OverflowError, operator.mul, 1j, 10**1000)
         self.assertRaises(TypeError, operator.mul, 1j, None)
         self.assertRaises(TypeError, operator.mul, None, 1j)

Objects/complexobject.c

@@ -8,7 +8,7 @@
 #include "Python.h"
 #include "pycore_call.h"          // _PyObject_CallNoArgs()
 #include "pycore_complexobject.h" // _PyComplex_FormatAdvancedWriter()
-#include "pycore_floatobject.h"   // _Py_convert_to_double()
+#include "pycore_floatobject.h"   // _Py_convert_int_to_double()
 #include "pycore_long.h"          // _PyLong_GetZero()
 #include "pycore_object.h"        // _PyObject_Init()
 #include "pycore_pymath.h"        // _Py_ADJUST_ERANGE2()
@@ -475,31 +475,31 @@ complex_hash(PyComplexObject *v)
 }
 
 /* This macro may return! */
-#define TO_COMPLEX(obj, c) \
-    if (PyComplex_Check(obj)) \
-        c = ((PyComplexObject *)(obj))->cval; \
-    else if (to_complex(&(obj), &(c)) < 0) \
+#define TO_COMPLEX(obj, c)                      \
+    if (PyComplex_Check(obj))                   \
+        c = ((PyComplexObject *)(obj))->cval;   \
+    else if (real_to_complex(&(obj), &(c)) < 0) \
         return (obj)
 
 static int
-to_float(PyObject **pobj, double *dbl)
+real_to_float(PyObject **pobj, double *dbl)
 {
     PyObject *obj = *pobj;
 
     if (PyFloat_Check(obj)) {
         *dbl = PyFloat_AS_DOUBLE(obj);
     }
-    else if (_Py_convert_to_double(pobj, dbl) < 0) {
+    else if (_Py_convert_int_to_double(pobj, dbl) < 0) {
         return -1;
     }
     return 0;
 }
 
 static int
-to_complex(PyObject **pobj, Py_complex *pc)
+real_to_complex(PyObject **pobj, Py_complex *pc)
 {
     pc->imag = 0.0;
-    return to_float(pobj, &(pc->real));
+    return real_to_float(pobj, &(pc->real));
 }
 
 /* Complex arithmetic rules implement special mixed-mode case: combining
@@ -523,7 +523,7 @@ to_complex(PyObject **pobj, Py_complex *pc)
 static PyObject *
 complex_add(PyObject *v, PyObject *w)
 {
-    if (PyComplex_Check(w)) {
+    if (!PyComplex_Check(v)) {
         PyObject *tmp = v;
         v = w;
         w = tmp;
@@ -536,7 +536,7 @@ complex_add(PyObject *v, PyObject *w)
         Py_complex b = ((PyComplexObject *)(w))->cval;
         a = _Py_c_sum(a, b);
     }
-    else if (to_float(&w, &b) < 0) {
+    else if (real_to_float(&w, &b) < 0) {
         return w;
     }
     else {
@@ -556,22 +556,21 @@ complex_sub(PyObject *v, PyObject *w)
 
         if (PyComplex_Check(v)) {
             a = ((PyComplexObject *)(v))->cval;
-            errno = 0;
             a = _Py_c_diff(a, b);
         }
-        else if (to_float(&v, &a.real) < 0) {
+        else if (real_to_float(&v, &a.real) < 0) {
             return v;
         }
         else {
-            a = (Py_complex) {a.real, -b.imag};
             a.real -= b.real;
+            a.imag = -b.imag;
         }
     }
     else {
         a = ((PyComplexObject *)(v))->cval;
         double b;
 
-        if (to_float(&w, &b) < 0) {
+        if (real_to_float(&w, &b) < 0) {
             return w;
         }
         a.real -= b;
@@ -583,7 +582,7 @@ complex_sub(PyObject *v, PyObject *w)
 static PyObject *
 complex_mul(PyObject *v, PyObject *w)
 {
-    if (PyComplex_Check(w)) {
+    if (!PyComplex_Check(v)) {
         PyObject *tmp = v;
         v = w;
         w = tmp;
@@ -596,7 +595,7 @@ complex_mul(PyObject *v, PyObject *w)
         Py_complex b = ((PyComplexObject *)(w))->cval;
         a = _Py_c_prod(a, b);
     }
-    else if (to_float(&w, &b) < 0) {
+    else if (real_to_float(&w, &b) < 0) {
         return w;
     }
     else {
@@ -621,7 +620,7 @@ complex_div(PyObject *v, PyObject *w)
     else {
         double b;
 
-        if (to_float(&w, &b) < 0) {
+        if (real_to_float(&w, &b) < 0) {
             return w;
         }
         if (b) {

Objects/floatobject.c

@@ -306,16 +306,16 @@ PyFloat_AsDouble(PyObject *op)
    obj is not of float or int type, Py_NotImplemented is incref'ed,
    stored in obj, and returned from the function invoking this macro.
 */
-#define CONVERT_TO_DOUBLE(obj, dbl)                     \
-    if (PyFloat_Check(obj))                             \
-        dbl = PyFloat_AS_DOUBLE(obj);                   \
-    else if (_Py_convert_to_double(&(obj), &(dbl)) < 0) \
+#define CONVERT_TO_DOUBLE(obj, dbl)                         \
+    if (PyFloat_Check(obj))                                 \
+        dbl = PyFloat_AS_DOUBLE(obj);                       \
+    else if (_Py_convert_int_to_double(&(obj), &(dbl)) < 0) \
         return obj;
 
 /* Methods */
 
 int
-_Py_convert_to_double(PyObject **v, double *dbl)
+_Py_convert_int_to_double(PyObject **v, double *dbl)
 {
     PyObject *obj = *v;