Fix new type names and new tests.

Author: serhiy-storchaka

Lib/_pyrepl/fancycompleter.py

@@ -8,6 +8,7 @@
 from _colorize import ANSIColors, get_colors, get_theme
 import rlcompleter
 import keyword
+import re
 import types
 
 TYPE_CHECKING = False
@@ -43,6 +44,12 @@ def _color_for_obj(name: str, value: Any, theme: Theme) -> str:
 
 def _color_by_type(t, theme):
     typename = t.__name__
+    if t.__module__ == 'types' and typename.endswith('Type'):
+        # MethodWrapperType -> method_wrapper
+        # 1. Remove the "Type" suffix.
+        # 2. Insert "_" before each upper letter in the middle.
+        # 3. Convert to lower case.
+        typename = re.sub(r'(?<!\A)(?=[A-Z])', '_', typename[:-4]).lower()
     # this is needed e.g. to turn method-wrapper into method_wrapper,
     # because if we want _colorize.FancyCompleter to be "dataclassable"
     # our keys need to be valid identifiers.

Lib/json/encoder.py

@@ -71,6 +71,14 @@ def replace(match):
 encode_basestring_ascii = (
     c_encode_basestring_ascii or py_encode_basestring_ascii)
 
+def _T(obj):
+    cls = type(obj)
+    module = cls.__module__
+    if module in (None, 'builtins', '__main__'):
+        return cls.__qualname__
+    return f'{module}.{cls.__qualname__}'
+
+
 class JSONEncoder(object):
     """Extensible JSON <https://json.org> encoder for Python data structures.
 
@@ -316,7 +324,7 @@ def _iterencode_list(lst, _current_indent_level):
             except GeneratorExit:
                 raise
             except BaseException as exc:
-                exc.add_note(f'when serializing {type(lst).__name__} item {i}')
+                exc.add_note(f'when serializing {_T(lst)} item {i}')
                 raise
         if newline_indent is not None:
             _current_indent_level -= 1
@@ -403,7 +411,7 @@ def _iterencode_dict(dct, _current_indent_level):
             except GeneratorExit:
                 raise
             except BaseException as exc:
-                exc.add_note(f'when serializing {type(dct).__name__} item {key!r}')
+                exc.add_note(f'when serializing {_T(dct)} item {key!r}')
                 raise
         if not first and newline_indent is not None:
             _current_indent_level -= 1
@@ -443,7 +451,7 @@ def _iterencode(o, _current_indent_level):
             except GeneratorExit:
                 raise
             except BaseException as exc:
-                exc.add_note(f'when serializing {type(o).__name__} object')
+                exc.add_note(f'when serializing {_T(o)} object')
                 raise
             if markers is not None:
                 del markers[markerid]

Lib/test/pickletester.py

@@ -1340,15 +1340,15 @@ def test_find_class(self):
                 r"Can't resolve path 'log\.spam' on module 'math'") as cm:
             unpickler4.find_class('math', 'log.spam')
         self.assertEqual(str(cm.exception.__context__),
-            "'builtin_function_or_method' object has no attribute 'spam'")
+            "'types.BuiltinFunctionType' object has no attribute 'spam'")
         with self.assertRaisesRegex(AttributeError,
                 r"module 'math' has no attribute 'log\.<locals>\.spam'"):
             unpickler.find_class('math', 'log.<locals>.spam')
         with self.assertRaisesRegex(AttributeError,
                 r"Can't resolve path 'log\.<locals>\.spam' on module 'math'") as cm:
             unpickler4.find_class('math', 'log.<locals>.spam')
         self.assertEqual(str(cm.exception.__context__),
-            "'builtin_function_or_method' object has no attribute '<locals>'")
+            "'types.BuiltinFunctionType' object has no attribute '<locals>'")
         with self.assertRaisesRegex(AttributeError,
                 "module 'math' has no attribute ''"):
             unpickler.find_class('math', '')
@@ -3301,11 +3301,33 @@ def test_builtin_types(self):
                         self.assertIs(self.loads(s), t)
 
     def test_types_types(self):
+        if self.py_version < (3, 8):
+            self.skipTest('not supported in Python < 3.8')
+        # types with __module__ == 'types' added before 3.16
+        old_names = {
+            'EllipsisType': (3, 8),
+            'GenericAlias': (3, 9),
+            'NoneType': (3, 8),
+            'NotImplementedType': (3, 8),
+            'SimpleNamespace': (3, 8),
+            'Union': (3, 8),
+            'DynamicClassAttribute': (3, 8),
+            '_GeneratorWrapper': (3, 8),
+        }
+        # new types added after 3.16
+        new_names = {
+        }
         for t in types.__dict__.values():
             if isinstance(t, type):
+                if self.py_version < (3, 16):
+                    if t.__name__ not in old_names or self.py_version < old_names[t.__name__]:
+                        continue
+                elif t.__name__ in new_names and self.py_version < new_names[t.__name__]:
+                    continue
                 for proto in protocols:
-                    s = self.dumps(t, proto)
-                    self.assertIs(self.loads(s), t)
+                    with self.subTest(name=t.__name__, proto=proto):
+                        s = self.dumps(t, proto)
+                        self.assertIs(self.loads(s), t)
 
     def test_builtin_exceptions(self):
         new_names = {

Lib/test/test_call.py

@@ -227,29 +227,29 @@ def test_object_not_callable(self):
         self.assertRaisesRegex(TypeError, msg, object())
 
     def test_module_not_callable_no_suggestion_0(self):
-        msg = r"^'module' object is not callable$"
+        msg = r"^'types\.ModuleType' object is not callable$"
         self.assertRaisesRegex(TypeError, msg, types.ModuleType("mod"))
 
     def test_module_not_callable_no_suggestion_1(self):
-        msg = r"^'module' object is not callable$"
+        msg = r"^'types\.ModuleType' object is not callable$"
         mod = types.ModuleType("mod")
         mod.mod = 42
         self.assertRaisesRegex(TypeError, msg, mod)
 
     def test_module_not_callable_no_suggestion_2(self):
-        msg = r"^'module' object is not callable$"
+        msg = r"^'types\.ModuleType' object is not callable$"
         mod = types.ModuleType("mod")
         del mod.__name__
         self.assertRaisesRegex(TypeError, msg, mod)
 
     def test_module_not_callable_no_suggestion_3(self):
-        msg = r"^'module' object is not callable$"
+        msg = r"^'types\.ModuleType' object is not callable$"
         mod = types.ModuleType("mod")
         mod.__name__ = 42
         self.assertRaisesRegex(TypeError, msg, mod)
 
     def test_module_not_callable_suggestion(self):
-        msg = r"^'module' object is not callable\. Did you mean: 'mod\.mod\(\.\.\.\)'\?$"
+        msg = r"^'types\.ModuleType' object is not callable\. Did you mean: 'mod\.mod\(\.\.\.\)'\?$"
         mod = types.ModuleType("mod")
         mod.mod = lambda: ...
         self.assertRaisesRegex(TypeError, msg, mod)

Lib/test/test_crossinterp.py

@@ -61,6 +61,7 @@ def ignore_byteswarning():
 
 METHOD = defs.SpamOkay().okay
 BUILTIN_METHOD = [].append
+MEMBER_DESCRIPTOR = types.FunctionType.__globals__
 METHOD_DESCRIPTOR_WRAPPER = str.join
 METHOD_WRAPPER = object().__str__
 WRAPPER_DESCRIPTOR = object.__init__
@@ -69,7 +70,7 @@ def ignore_byteswarning():
     BUILTIN_METHOD: types.BuiltinMethodType,
     dict.__dict__['fromkeys']: types.ClassMethodDescriptorType,
     types.FunctionType.__code__: types.GetSetDescriptorType,
-    types.FunctionType.__globals__: types.MemberDescriptorType,
+    MEMBER_DESCRIPTOR: types.MemberDescriptorType,
     METHOD_DESCRIPTOR_WRAPPER: types.MethodDescriptorType,
     METHOD_WRAPPER: types.MethodWrapperType,
     WRAPPER_DESCRIPTOR: types.WrapperDescriptorType,
@@ -278,16 +279,11 @@ def ignore_byteswarning():
     *defs.TOP_CLASSES,
     *USER_TOP_INSTANCES,
     *USER_EXCEPTIONS,
-    # from OTHER_TYPES
-    types.NoneType,
-    types.EllipsisType,
-    types.NotImplementedType,
-    types.GenericAlias,
-    types.UnionType,
-    types.SimpleNamespace,
+    *OTHER_TYPES,
     # from BUILTIN_WRAPPERS
     METHOD,
     BUILTIN_METHOD,
+    MEMBER_DESCRIPTOR,
     METHOD_DESCRIPTOR_WRAPPER,
     METHOD_WRAPPER,
     WRAPPER_DESCRIPTOR,

Lib/test/test_exception_group.py

@@ -267,7 +267,7 @@ def __repr__(self):
         seq = MySeq(None)
         with self.assertRaisesRegex(
             TypeError,
-            r".*MySeq\.__repr__\(\) must return a str, not NoneType"
+            r".*MySeq\.__repr__\(\) must return a str, not types.NoneType"
         ):
             ExceptionGroup("test", seq)
 

Lib/test/test_frame.py

@@ -579,7 +579,7 @@ class ObjectSubclass:
     def test_constructor(self):
         FrameLocalsProxy = type([sys._getframe().f_locals
                                  for x in range(1)][0])
-        self.assertEqual(FrameLocalsProxy.__name__, 'FrameLocalsProxy')
+        self.assertEqual(FrameLocalsProxy.__name__, 'FrameLocalsProxyType')
 
         def make_frame():
             x = 1

Lib/test/test_gdb/test_backtrace.py

@@ -20,7 +20,7 @@ def test_bt(self):
         self.assertMultilineMatches(bt,
                                     r'''^.*
 Traceback \(most recent call first\):
-  <built-in method id of module object .*>
+  <built-in method id of types\.ModuleType object .*>
   File ".*gdb_sample.py", line 10, in baz
     id\(42\)
   File ".*gdb_sample.py", line 7, in bar

Lib/test/test_import/__init__.py

@@ -1262,7 +1262,7 @@ class Spec:
         self.assertIs(_imp.create_builtin(spec), sys)
 
         spec.name = None
-        with self.assertRaisesRegex(TypeError, 'name must be string, not NoneType'):
+        with self.assertRaisesRegex(TypeError, 'name must be string, not types.NoneType'):
             _imp.create_builtin(spec)
 
         # gh-142029

Lib/test/test_json/test_default.py

@@ -21,9 +21,9 @@ def default(obj):
         with self.assertRaises(ValueError) as cm:
             self.dumps(type, default=default)
         self.assertEqual(cm.exception.__notes__,
-                         ['when serializing ellipsis object',
+                         ['when serializing types.EllipsisType object',
                           'when serializing list item 0',
-                          'when serializing module object',
+                          'when serializing types.ModuleType object',
                           'when serializing type object'])
 
     def test_ordereddict(self):