Simplify TypeAliasType.__repr__

JelleZijlstra · JelleZijlstra · commit f7e62197927f · 2023-05-09T17:54:51.000-07:00
diff --git a/Lib/test/test_type_aliases.py b/Lib/test/test_type_aliases.py
@@ -140,38 +140,12 @@ def test_subscripting(self):
 
     def test_repr(self):
         type Simple = int
-        self.assertEqual(repr(Simple), "<type alias Simple: int>")
-
-        class FancyRepr:
-            def __repr__(self):
-                return "<fancy>"
-        type Fancy = FancyRepr()
-        self.assertEqual(repr(Fancy), "<type alias Fancy: <fancy>>")
-
-        class FancyMeta(type):
-            def __repr__(self):
-                return f"<fancy class {self.__name__!r}>"
-        class FancyCls(metaclass=FancyMeta):
-            pass
-        type Fancy2 = FancyCls
-        self.assertEqual(repr(Fancy2), "<type alias Fancy2: <fancy class 'FancyCls'>>")
-
-        type NoRepr = 1 / 0
-        self.assertEqual(repr(NoRepr), "<type alias NoRepr: <evaluation failed>>")
-
-        class FailingRepr:
-            def __repr__(self):
-                raise ValueError("nope")
-        type Failing = FailingRepr()
-        self.assertEqual(repr(Failing), "<type alias Failing: <value repr() failed>>")
-
-        type Generic[T, *Ts, **P] = int
-        self.assertEqual(repr(Generic), "<type alias Generic[T, *Ts, **P]: int>")
+        self.assertEqual(repr(Simple), "Simple")
 
     def test_recursive_repr(self):
         type Recursive = Recursive
-        self.assertEqual(repr(Recursive), "<type alias Recursive: ...>")
+        self.assertEqual(repr(Recursive), "Recursive")
 
         type X = list[Y]
         type Y = list[X]
-        self.assertEqual(repr(X), "<type alias X: list[<type alias Y: list[...]>]>")
+        self.assertEqual(repr(X), "X")
diff --git a/Objects/typevarobject.c b/Objects/typevarobject.c
@@ -1289,91 +1289,8 @@ typealias_get_value(typealiasobject *ta)
 static PyObject *
 typealias_repr(PyObject *self)
 {
-    Py_ssize_t res = Py_ReprEnter(self);
-    if (res > 0) {
-        return PyUnicode_FromString("...");
-    }
-    else if (res < 0) {
-        return NULL;
-    }
-
     typealiasobject *ta = (typealiasobject *)self;
-    PyObject *value_repr = NULL;
-    PyObject *value = typealias_get_value(ta);
-    if (value == NULL) {
-        PyErr_Clear();
-        value_repr = PyUnicode_FromString("<evaluation failed>");
-    }
-    // Show "int" instead of "<class 'int'>"
-    else if (PyType_Check(value) && Py_TYPE(value)->tp_repr == PyType_Type.tp_repr
-             && ((PyTypeObject *)value)->tp_name != NULL) {
-        value_repr = PyUnicode_FromString(((PyTypeObject *)value)->tp_name);
-        Py_DECREF(value);
-    }
-    else {
-        value_repr = PyObject_Repr(value);
-        Py_DECREF(value);
-        if (value_repr == NULL) {
-            PyErr_Clear();
-            value_repr = PyUnicode_FromString("<value repr() failed>");
-        }
-    }
-    if (value_repr == NULL) {
-        // PyUnicode_FromString failed
-        Py_ReprLeave(self);
-        return NULL;
-    }
-    PyObject *result = NULL;
-    if (ta->type_params != NULL) {
-        _PyUnicodeWriter writer;
-        _PyUnicodeWriter_Init(&writer);
-        PyTupleObject *type_params = (PyTupleObject *)ta->type_params;
-        Py_ssize_t count = PyTuple_GET_SIZE(type_params);
-        PyInterpreterState *interp = PyInterpreterState_Get();
-        for (Py_ssize_t i = 0; i < count; i++) {
-            PyObject *type_param = PyTuple_GET_ITEM(type_params, i);
-            if (i > 0 && _PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) {
-                _PyUnicodeWriter_Dealloc(&writer);
-                goto error;
-            }
-            if (Py_IS_TYPE(type_param, interp->cached_objects.paramspec_type)) {
-                if (_PyUnicodeWriter_WriteASCIIString(&writer, "**", 2) < 0) {
-                    _PyUnicodeWriter_Dealloc(&writer);
-                    goto error;
-                }
-            }
-            else if (Py_IS_TYPE(type_param, interp->cached_objects.typevartuple_type)) {
-                if (_PyUnicodeWriter_WriteASCIIString(&writer, "*", 1) < 0) {
-                    _PyUnicodeWriter_Dealloc(&writer);
-                    goto error;
-                }
-            }
-            PyObject *type_param_repr = PyObject_Repr(type_param);
-            if (type_param_repr == NULL) {
-                _PyUnicodeWriter_Dealloc(&writer);
-                goto error;
-            }
-            if (_PyUnicodeWriter_WriteStr(&writer, type_param_repr) < 0) {
-                Py_DECREF(type_param_repr);
-                _PyUnicodeWriter_Dealloc(&writer);
-                goto error;
-            }
-            Py_DECREF(type_param_repr);
-        }
-        PyObject *params_repr = _PyUnicodeWriter_Finish(&writer);
-        if (params_repr == NULL) {
-            goto error;
-        }
-        result = PyUnicode_FromFormat("<type alias %s[%U]: %U>", ta->name, params_repr, value_repr);
-        Py_DECREF(params_repr);
-    }
-    else {
-        result = PyUnicode_FromFormat("<type alias %s: %U>", ta->name, value_repr);
-    }
-error:
-    Py_ReprLeave(self);
-    Py_DECREF(value_repr);
-    return result;
+    return PyUnicode_FromString(ta->name);
 }
 
 static PyMemberDef typealias_members[] = {
