Cython 3.3.0a2.dev0__py3-none-any.whl → 3.3.0b1__py3-none-any.whl

Cython/Build/Dependencies.py

@@ -12,7 +12,7 @@ from collections.abc import Iterable
 
 try:
     import pythran
-except:
+except Exception:
     pythran = None
 
 from .. import Utils
@@ -29,7 +29,8 @@ copy_once_if_newer = cached_function(copy_file_to_dir_if_newer)
 safe_makedirs_once = cached_function(safe_makedirs)
 
 
-def _make_relative(file_paths, base=None):
+@cython.cfunc
+def _make_relative(file_paths, base=None) -> list[str]:
     if not base:
         base = os.getcwd()
     if base[-1] != os.path.sep:
@@ -158,6 +159,7 @@ distutils_settings = {
 }
 
 
+@cython.cfunc
 def _legacy_strtobool(val):
     # Used to be "distutils.util.strtobool", adapted for deprecation warnings.
     if val == "True":
@@ -1183,12 +1185,15 @@ if os.environ.get('XML_RESULTS'):
     def record_results(func):
         def with_record(*args):
             t = time.time()
-            success = True
+            success = False
             try:
-                try:
-                    func(*args)
-                except:
-                    success = False
+                func(*args)
+                success = True
+            except Exception:
+                # It's not obvious that we should really swallow the exception here,
+                # rather than fail loudly after writing the XML result file,
+                # but that's how it's currently implemented.
+                pass
             finally:
                 t = time.time() - t
                 module = fully_qualified_name(args[0])

Cython/Build/SharedModule.py

@@ -5,9 +5,88 @@ from Cython.Compiler import (
 )
 from Cython.Compiler.StringEncoding import EncodedString
 from Cython.Compiler.Scanning import SharedUtilitySourceDescriptor
+from Cython.Compiler.Errors import warning
 
 
-def create_shared_library_pipeline(context, scope, options, result):
+def list_of_features(included=None, excluded=None, _list_of_features=[]):
+    if _list_of_features:
+        feature_names = _list_of_features[:]
+    else:
+        feature_names = sorted({feature_name for feature_name, _, _ in _iter_exports()})
+        _list_of_features[:] = feature_names
+
+    return _select_features(feature_names, included, excluded)
+
+
+def _select_features(all_names, included, excluded):
+    names = all_names
+    if included:
+        included = set(included)
+        unknown = included.difference(all_names)
+        if unknown:
+            warning(None, f"Unknown shared module features selected: {', '.join(sorted(unknown))}")
+
+        names = [name for name in names if name in included]
+
+    if excluded:
+        excluded = set(excluded)
+        unknown = excluded.difference(all_names)
+        if unknown:
+            warning(None, f"Unknown shared module features excluded: {', '.join(sorted(unknown))}")
+        unused = excluded.difference(names)
+        if unused:
+            warning(None, f"Shared module features excluded that was not included: {', '.join(sorted(unused))}")
+
+        names = [name for name in names if name not in excluded]
+
+    return names
+
+
+def _iter_exports(selected_features=None):
+    UtilityCode = Code.UtilityCode
+    match_special = UtilityCode.get_special_comment_matcher('/')
+
+    for c_utility_file in os.listdir(Code.get_utility_dir()):
+        if not c_utility_file.endswith('.c'):
+            continue
+
+        file_base_name = os.path.splitext(os.path.basename(c_utility_file))[0]
+        current_feature_name = file_base_name.partition('_')[0]
+
+        current_section = None
+        for line in Code.read_utilities_hook(c_utility_file):
+            if '//' not in line or not line.startswith('//'):
+                continue
+            match = match_special(line)
+            if match is None:
+                continue
+
+            name = match.group('name')
+            if name:
+                if current_section:
+                    if selected_features is None or current_section[0] in selected_features:
+                        yield current_section
+                current_section = None
+
+                section_title = UtilityCode.match_section_title(name) if '.export' in name else None
+                if section_title:
+                    name, section_type = section_title.groups()
+                    if section_type == 'export':
+                        current_section = [current_feature_name, name, c_utility_file]
+
+            elif (tag := match.group('tag')) and tag.startswith('feature') and current_section:
+                explicit_feature_name = tag.split(':', 1)[-1].strip()
+                assert current_section[0] == current_feature_name, (
+                    "Conflicting feature names given to the same utility code section: "
+                    f"{current_section[0]!r} and {explicit_feature_name!r}")
+                current_section[0] = explicit_feature_name
+
+        if current_section:
+            if selected_features is None or current_section[0] in selected_features:
+                yield current_section
+
+
+def create_shared_library_pipeline(context, scope, options, result, selected_features=None):
 
     parse = Pipeline.parse_stage_factory(context)
 
@@ -15,11 +94,13 @@ def create_shared_library_pipeline(context, scope, options, result):
         def generate_tree(compsrc):
             tree = parse(compsrc)
 
-            tree.scope.use_utility_code(
-                MemoryView.get_view_utility_code(options.shared_utility_qualified_name))
+            if selected_features is None or 'MemoryView' in selected_features:
+                tree.scope.use_utility_code(
+                    MemoryView.get_view_utility_code(options.shared_utility_qualified_name))
+
+                tree.scope.use_utility_code(MemoryView._get_memviewslice_declare_code())
+                tree.scope.use_utility_code(MemoryView._get_typeinfo_to_format_code())
 
-            tree.scope.use_utility_code(MemoryView._get_memviewslice_declare_code())
-            tree.scope.use_utility_code(MemoryView._get_typeinfo_to_format_code())
             context.include_directories.append(Code.get_utility_dir())
             return tree
 
@@ -27,18 +108,8 @@ def create_shared_library_pipeline(context, scope, options, result):
 
     def generate_c_utilities(module_node):
         UtilityCode = Code.UtilityCode
-        match_special = UtilityCode.get_special_comment_matcher('/')
-        for c_utility_file in os.listdir(Code.get_utility_dir()):
-            if not c_utility_file.endswith('.c'):
-                continue
-            for line in Code.read_utilities_hook(c_utility_file):
-                if not ((m := match_special(line)) and (name := m.group('name'))):
-                    continue
-                if not (section_title := UtilityCode.match_section_title(name)):
-                    continue
-                name, section_type = section_title.groups()
-                if section_type == 'export':
-                    module_node.scope.use_utility_code(UtilityCode.load_cached(name, c_utility_file))
+        for _, name, c_utility_file in _iter_exports(selected_features):
+            module_node.scope.use_utility_code(UtilityCode.load_cached(name, c_utility_file))
         return module_node
 
     orig_cimport_from_pyx = Options.cimport_from_pyx
@@ -71,6 +142,13 @@ def generate_shared_module(options):
     pyx_file = os.path.splitext(dest_c_file)[0] + '.pyx'
     module_name = os.path.splitext(os.path.basename(dest_c_file))[0]
 
+    selected_features = None
+    if options.shared_utility_features_enabled or options.shared_utility_features_disabled:
+        selected_features = list_of_features(
+            options.shared_utility_features_enabled,
+            options.shared_utility_features_disabled,
+        )
+
     context = Main.Context.from_options(options)
     scope = Symtab.ModuleScope('MemoryView', parent_module = None, context = context, is_package=False)
 
@@ -78,7 +156,10 @@ def generate_shared_module(options):
     comp_src = Main.CompilationSource(source_desc, EncodedString(module_name), os.getcwd())
     result = Main.create_default_resultobj(comp_src, options)
 
-    pipeline = create_shared_library_pipeline(context, scope, options, result)
+    pipeline = create_shared_library_pipeline(
+        context, scope, options, result,
+        selected_features=selected_features,
+    )
     err, enddata = Pipeline.run_pipeline(pipeline, comp_src)
 
     return err, enddata

Cython/Build/Tests/TestInline.py

@@ -8,7 +8,7 @@ from Cython.TestUtils import CythonTest, TimedTest
 try:
     import numpy
     has_numpy = True
-except:
+except Exception:
     has_numpy = False
 
 test_kwds = dict(force=True, quiet=True)

Cython/CodeWriter.py

@@ -673,7 +673,7 @@ class ExpressionWriter(TreeVisitor):
     def visit_CondExprNode(self, node):
         self.visit(node.true_val)
         self.put(" if ")
-        self.visit(node.test)
+        self.visit(node.condition)
         self.put(" else ")
         self.visit(node.false_val)
 
@@ -748,9 +748,19 @@ class ExpressionWriter(TreeVisitor):
         self.visit(node.expr)
 
     def visit_DictComprehensionAppendNode(self, node):
-        self.visit(node.key_expr)
-        self.put(": ")
-        self.visit(node.value_expr)
+        item = node.dict_item
+        if isinstance(item, DictItemNode):
+            self.visit(item.key)
+            self.put(": ")
+            self.visit(item.value)
+        else:
+            is_simple = item.is_name or item.is_attribute
+            self.put("**")
+            if not is_simple:
+                self.put("(")
+            self.visit(item)
+            if not is_simple:
+                self.put(")")
 
     def visit_ComprehensionNode(self, node):
         tpmap = {'list': "[]", 'dict': "{}", 'set': "{}"}

Cython/Compiler/Buffer.py

@@ -674,7 +674,6 @@ raise_indexerror_nogil = load_buffer_utility("BufferIndexErrorNogil")
 raise_buffer_fallback_code = load_buffer_utility("BufferFallbackError")
 
 acquire_utility_code = load_buffer_utility("BufferGetAndValidate", context=context)
-buffer_format_check_code = load_buffer_utility("BufferFormatCheck", context=context)
 
 # See utility code BufferFormatFromTypeInfo
 _typeinfo_to_format_code = load_buffer_utility("TypeInfoToFormat")

Cython/Compiler/Builtin.py

@@ -2,10 +2,11 @@
 #   Builtin Definitions
 #
 
+from itertools import chain
 
 from .StringEncoding import EncodedString
 from .Symtab import BuiltinScope, StructOrUnionScope, ModuleScope, Entry
-from .Code import UtilityCode, TempitaUtilityCode, KNOWN_PYTHON_BUILTINS, uncachable_builtins
+from .Code import UtilityCode, TempitaUtilityCode
 from .TypeSlots import Signature
 from . import PyrexTypes
 
@@ -349,6 +350,13 @@ builtin_function_table = [
 
 # Builtin types
 
+hidden_builtin_types = [
+    # These are not in the user visible 'builtins' namespace.
+    'dict_keys',
+    'dict_values',
+    'dict_items',
+]
+
 builtin_types_table = [
 
     ("type",    "&PyType_Type",     []),
@@ -357,6 +365,9 @@ builtin_types_table = [
 
     ("int",     "&PyLong_Type",     []),
     ("float",   "&PyFloat_Type",   []),
+    ("dict_keys", "&PyDictKeys_Type", []),
+    ("dict_values", "&PyDictValues_Type", []),
+    ("dict_items", "&PyDictItems_Type", []),
 
     ("complex", "&PyComplex_Type", [BuiltinAttribute('cval', field_type_name = 'Py_complex'),
                                     BuiltinAttribute('real', 'cval.real', field_type = PyrexTypes.c_double_type),
@@ -390,11 +401,14 @@ builtin_types_table = [
     ("dict",   "&PyDict_Type",     [BuiltinMethod("__contains__",  "TO",   "b", "PyDict_Contains"),
                                     BuiltinMethod("has_key",       "TO",   "b", "PyDict_Contains"),
                                     BuiltinMethod("items",  "T",   "O", "__Pyx_PyDict_Items",
-                                                  utility_code=UtilityCode.load("py_dict_items", "Builtins.c")),
+                                                  utility_code=UtilityCode.load("py_dict_items", "Builtins.c"),
+                                                  builtin_return_type='dict_items'),
                                     BuiltinMethod("keys",   "T",   "O", "__Pyx_PyDict_Keys",
-                                                  utility_code=UtilityCode.load("py_dict_keys", "Builtins.c")),
+                                                  utility_code=UtilityCode.load("py_dict_keys", "Builtins.c"),
+                                                  builtin_return_type='dict_keys'),
                                     BuiltinMethod("values", "T",   "O", "__Pyx_PyDict_Values",
-                                                  utility_code=UtilityCode.load("py_dict_values", "Builtins.c")),
+                                                  utility_code=UtilityCode.load("py_dict_values", "Builtins.c"),
+                                                  builtin_return_type='dict_values'),
                                     BuiltinMethod("iteritems",  "T",   "O", "__Pyx_PyDict_IterItems",
                                                   utility_code=UtilityCode.load("py_dict_iteritems", "Builtins.c")),
                                     BuiltinMethod("iterkeys",   "T",   "O", "__Pyx_PyDict_IterKeys",
@@ -443,8 +457,6 @@ builtin_types_table = [
                                     BuiltinMethod("add",     "TO", "r", "PySet_Add"),
                                     BuiltinMethod("pop",     "T",  "O", "PySet_Pop")]),
     ("frozenset", "&PyFrozenSet_Type", []),
-    ("BaseException", "((PyTypeObject*)PyExc_BaseException)", []),
-    ("Exception", "((PyTypeObject*)PyExc_Exception)", []),
     ("memoryview", "&PyMemoryView_Type", [
         # TODO - format would be nice, but hard to get
         # __len__ can be accessed through a direct lookup of the buffer (but probably in Optimize.c)
@@ -482,7 +494,7 @@ types_that_construct_their_instance = frozenset({
     'tuple', 'list', 'dict', 'frozendict', 'set', 'frozenset',
     'memoryview', 'range', 'slice', 'sentinel',
     # All builtin exception types create their own instance.
-    *filter(PyrexTypes.is_exception_type_name, KNOWN_PYTHON_BUILTINS),
+    *PyrexTypes.KNOWN_EXCEPTION_NAMES,
 
     # These types don't currently have a purpose and might become restrictive:
     #'object',
@@ -497,7 +509,10 @@ types_that_construct_their_instance = frozenset({
 # When updating this mapping, also update "unsafe_compile_time_methods" below
 # if methods are added that are not safe to evaluate at compile time.
 # 'T' - type identical to type in dictionary key
-# 'I' - type from subscript - e.g. for list[int], I is `int`
+# 'I' - type of index type:
+#     - value type from subscript - e.g. for list[int], I is `int`
+#     - for mappings this is the second subscripted type - e.g. for dict[int, str], I is `str`
+# 'K' - key type of dictionary - e.g. for dict[int, str], K is `int`
 inferred_method_return_types = {
     'complex': dict(
         conjugate='complex',
@@ -631,7 +646,7 @@ inferred_method_return_types = {
         tolist='list',
         toreadonly='T',
     ),
-    'set': dict(
+    'frozenset': dict(
         copy='T',
         difference='T',
         intersection='T',
@@ -640,17 +655,20 @@ inferred_method_return_types = {
         issuperset='bint',
         symmetric_difference='T',
         union='T',
-        pop='I',
     ),
-    'frozenset': dict(
-        # Inherited from 'set' below.
+    'set': dict(
+        # Inherited from 'frozenset' above.
+        pop='I',
     ),
     'dict': dict(
         copy='T',
         fromkeys='T',  # classmethod
-        popitem='tuple',
+        popitem='tuple[K,I]',
         pop='I',
         get='I',
+        keys='dict_keys[K]',
+        values='dict_values[I]',
+        items='dict_items[tuple[K,I]]'
     ),
     'frozendict': dict(
         copy='T',
@@ -659,36 +677,55 @@ inferred_method_return_types = {
 }
 
 inferred_method_return_types['bytearray'].update(inferred_method_return_types['bytes'])
-inferred_method_return_types['frozenset'].update(inferred_method_return_types['set'])
+inferred_method_return_types['set'].update(inferred_method_return_types['frozenset'])
+
+
+def _parse_atomic_signature(builtin_type, sig: str) -> PyrexTypes.PyrexType:
+    # Roughly ordered by frequency of occurrence to reduce lookup cost.
+    if sig == 'T':
+        return builtin_type
+    elif sig == 'bint':
+        return PyrexTypes.c_bint_type
+    elif sig == 'Py_ssize_t':
+        return PyrexTypes.c_py_ssize_t_type
+    elif sig == 'object':
+        return PyrexTypes.py_object_type
+    elif sig == 'I':
+        return builtin_type.infer_indexed_type() or PyrexTypes.py_object_type
+    elif sig == 'K' and builtin_type.is_pyanydict_type:
+        return builtin_type.infer_iterator_type() or PyrexTypes.py_object_type
+    entry = builtin_scope.lookup(sig)
+    if entry is None:
+        # Unnamed builtin.
+        return builtin_types[sig]
+    return entry.type
+
+
+def _parse_signature(pos, env, builtin_type, return_signature: str) -> PyrexTypes.PyrexType:
+    if '[' in return_signature:
+        container_name, _, subscript_signature = return_signature[:-1].partition('[')
+        container_entry = builtin_scope.lookup(container_name)
+        container_type = container_entry.type if container_entry is not None else builtin_types[container_name]
+
+        if container_name in ('tuple', 'dict', 'frozendict'):
+            parsed_subscripted_types = [
+                    _parse_signature(pos, env, builtin_type, sg)
+                    for sg in subscript_signature.split(',')
+            ]
+        else:
+            parsed_subscripted_types = [_parse_signature(pos, env, builtin_type, subscript_signature)]
+        return container_type.specialize_here(pos, env, parsed_subscripted_types)
+    return _parse_atomic_signature(builtin_type, return_signature)
 
 
-def find_return_type_of_builtin_method(pos, env, builtin_type, method_name):
+def find_return_type_of_builtin_method(pos, env, builtin_type, method_name) -> PyrexTypes.PyrexType:
     container_type = builtin_type.get_container_type()
     type_name = container_type.name if container_type else builtin_type.name
     if type_name in inferred_method_return_types:
         methods = inferred_method_return_types[type_name]
         if method_name in methods:
-            subscripted_type_names: str = ''
-            return_type_name = methods[method_name]
-            if '[' in return_type_name:
-                return_type_name, _, subscripted_type_names = return_type_name[:-1].partition('[')
-            if return_type_name == 'T':
-                return builtin_type
-            if return_type_name == 'I':
-                return builtin_type.infer_indexed_type() or PyrexTypes.py_object_type
-            if 'T' in subscripted_type_names:
-                subscripted_type_names = subscripted_type_names.replace('T', builtin_type.name)
-            if return_type_name == 'bint':
-                return PyrexTypes.c_bint_type
-            elif return_type_name == 'Py_ssize_t':
-                return PyrexTypes.c_py_ssize_t_type
-            container_type = builtin_scope.lookup(return_type_name).type
-            if subscripted_type_names:
-                subscripted_types = [
-                    entry.type if entry else PyrexTypes.py_object_type
-                    for entry in map(builtin_scope.lookup, subscripted_type_names.split(','))
-                ]
-                container_type = container_type.specialize_here(pos, env, subscripted_types)
+            return_type_signature: str = methods[method_name]
+            container_type = _parse_signature(pos, env, builtin_type, return_type_signature)
             return container_type
     return PyrexTypes.py_object_type
 
@@ -778,6 +815,11 @@ builtin_types = {}
 
 def init_builtin_types():
     global builtin_types
+
+    # Some builtin types are not available by name,
+    # so we declare them in a throw-away scope.
+    hidden_builtins_scope = BuiltinScope()
+
     for name, cname, methods in builtin_types_table:
         if name == 'frozenset':
             objstruct_cname = 'PySetObject'
@@ -789,15 +831,12 @@ def init_builtin_types():
             objstruct_cname = 'PyUnicodeObject'
         elif name == 'bool':
             objstruct_cname = 'PyLongObject'
-        elif name == 'BaseException':
-            objstruct_cname = "PyBaseExceptionObject"
-        elif name == 'Exception':
-            objstruct_cname = "PyBaseExceptionObject"
         else:
             objstruct_cname = 'Py%sObject' % name.capitalize()
 
         utility_code = None
         type_class = PyrexTypes.BuiltinObjectType
+        scope = builtin_scope
         if name in ['dict', 'list', 'set', 'frozenset', 'frozendict']:
             type_class = PyrexTypes.BuiltinTypeConstructorObjectType
             if name == 'frozendict':
@@ -806,8 +845,14 @@ def init_builtin_types():
             type_class = PyrexTypes.PythonTupleTypeConstructor
         elif name == 'range':
             utility_code = range_utility_code
+        elif name in hidden_builtin_types:
+            type_class = PyrexTypes.BuiltinTypeConstructorObjectType
+            scope = hidden_builtins_scope
+            # Make sure the 'type' base type is declared in the hidden scope.
+            if 'type' not in hidden_builtins_scope.entries:
+                hidden_builtins_scope.entries['type'] = builtin_scope.lookup('type')
 
-        the_type = builtin_scope.declare_builtin_type(
+        the_type = scope.declare_builtin_type(
             name, cname, objstruct_cname=objstruct_cname, type_class=type_class, utility_code=utility_code)
         builtin_types[name] = the_type
         for method in methods:
@@ -817,21 +862,81 @@ def init_builtin_types():
 def init_builtin_exceptions():
     """Declare known builtin Python exceptions as types.
     """
-    for name in KNOWN_PYTHON_BUILTINS:
-        if name in uncachable_builtins:
+    special_properties = {
+        'StopIteration': ['value'],
+        'NameError': ['name'],
+        'AttributeError': ['name', 'obj'],
+        'SystemExit': ['code'],
+    }
+    unicode_error_properties = ['encoding', 'object', 'reason']
+    for name in ['UnicodeError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeTranslateError']:
+        special_properties[name] = unicode_error_properties
+
+    type_check_utility_code = UtilityCode.load_cached("FastTypeChecks", "ModuleSetupCode.c")
+
+    for name in PyrexTypes.KNOWN_EXCEPTION_NAMES:
+        if name in PyrexTypes.uncachable_builtins:
             # Exclude builtins specific to later Python versions or platforms.
             continue
-        if not PyrexTypes.is_exception_type_name(name):
-            continue
-        if builtin_scope.lookup_here(name) is not None:
-            # Already declared as builtin type above in a more specialised way.
-            continue
-        utility_code = UtilityCode(
-            proto=f"#define __Pyx_PyExc_{name}_Check(obj)  __Pyx_TypeCheck(obj, PyExc_{name})",
-            name=f"Py{name}_Check",
+
+        objstruct_cname = None
+        if name == 'BaseException':
+            objstruct_cname = "PyBaseExceptionObject"
+            utility_code = UtilityCode(
+                proto="#define __Pyx_PyExc_BaseException_Check(obj)  PyExceptionInstance_Check(obj)",
+                name=f"Py{name}_Check",
+            )
+        else:
+            if name == 'Exception':
+                objstruct_cname = "PyBaseExceptionObject"
+            utility_code = UtilityCode(
+                proto=f"#define __Pyx_PyExc_{name}_Check(obj)  __Pyx_TypeCheck(obj, PyExc_{name})",
+                name=f"Py{name}_Check",
+                requires=[type_check_utility_code],
+            )
+
+        assert builtin_scope.lookup_here(name) is None  # should not be declared above
+        exc_type = builtin_types[name] = builtin_scope.declare_builtin_type(
+            name, f"((PyTypeObject*)PyExc_{name})",
+            objstruct_cname=objstruct_cname,
+            utility_code=utility_code,
         )
-        builtin_types[name] = builtin_scope.declare_builtin_type(
-            name, f"((PyTypeObject*)PyExc_{name})", utility_code=utility_code)
+
+        # Also cover known subtypes, but avoid overly long chains of type pointer comparisons.
+        subtypes = [
+            tpname for tpname in PyrexTypes.exception_subtypes.get(name, ())
+            if tpname not in PyrexTypes.uncachable_builtins
+        ]
+        if len(subtypes) > 4:
+            subtypes = ()
+
+        utility_code_config = {'EXC_NAME': name, 'SUBTYPES': subtypes, 'PROPERTY_NAME': ''}
+
+        for property_name in chain(('args', 'context', 'cause', 'traceback'), special_properties.get(name, ())):
+            utility_code_config['PROPERTY_NAME'] = property_name
+
+            exc_type.scope.declare_cproperty(
+                f'__{property_name}__' if property_name in ('context', 'cause', 'traceback') else property_name,
+                PyrexTypes.py_object_type,
+                f"__Pyx_Py{name}_get_{property_name}",
+                f"__Pyx_Py{name}_set_{property_name}",
+                utility_code=TempitaUtilityCode.load(
+                    f"ExceptionGetProperty", "Builtins.c", context=utility_code_config),
+                setter_utility_code=TempitaUtilityCode.load(
+                    f"ExceptionSetProperty", "Builtins.c", context=utility_code_config),
+            )
+
+    for name in PyrexTypes.KNOWN_EXCEPTION_NAMES:
+        parents = PyrexTypes.exception_supertypes.get(name)
+        if not parents or name not in builtin_types:
+            continue
+        exc_type = builtin_types[name]
+        exc_type.exception_supertypes = [
+            # Collect super types bottom up.
+            builtin_types.get(parent) for parent in reversed(parents)
+        ]
+        while None in exc_type.exception_supertypes:
+            exc_type.exception_supertypes.remove(None)
 
 
 def init_builtin_structs():