gh-155358: Convert sys structseq types to heap types

Include/internal/pycore_interp_structs.h

@@ -823,6 +823,17 @@ typedef _Py_CODEUNIT *(*_PyJitEntryFuncPtr)(struct _PyExecutorObject *exec, _PyI
 
 #define _PyInterpreterGuard_GUARDS_NOT_ALLOWED UINTPTR_MAX
 
+typedef struct {
+    PyTypeObject *async_gen_hooks_type;
+    PyTypeObject *flags_type;
+#if defined(MS_WINDOWS)
+    PyTypeObject *windows_version_type;
+#endif
+#ifdef __EMSCRIPTEN__
+    PyTypeObject *emscripten_info_type;
+#endif
+} _PySys_State;
+
 /* PyInterpreterState holds the global state for one of the runtime's
    interpreters.  Typically the initial (main) interpreter is the only one.
 
@@ -899,6 +910,7 @@ struct _is {
 
     // Dictionary of the sys module
     PyObject *sysdict;
+    _PySys_State sys_state;
 
     // Dictionary of the builtins module
     PyObject *builtins;

Lib/test/support/__init__.py

@@ -3464,3 +3464,9 @@ def skip_on_low_desktop_heap_memory_subprocess(returncode):
     if returncode == STATUS_DLL_INIT_FAILED:
         raise unittest.SkipTest('gh-150436: DLL init failed, likely because '
                                 'of low desktop heap memory')
+
+
+def check_immutable_type(testcase, type):
+    regex = r'cannot set .* attribute of immutable type'
+    with testcase.assertRaisesRegex(TypeError, regex):
+        setattr(type, 'custom_attr', 123)

Lib/test/test_decimal.py

@@ -32,6 +32,7 @@
 import unittest
 import numbers
 import locale
+from test import support
 from test.support import (is_resource_enabled,
                           requires_IEEE_754, requires_docstrings,
                           check_disallow_instantiation)
@@ -5806,8 +5807,7 @@ def test_c_immutable_types(self):
         )
         for tp in types:
             with self.subTest(tp=tp):
-                with self.assertRaisesRegex(TypeError, "immutable"):
-                    tp.foo = 1
+                support.check_immutable_type(self, tp)
 
     def test_c_disallow_instantiation(self):
         ContextManager = type(C.localcontext())

Lib/test/test_itertools.py

@@ -1541,8 +1541,7 @@ def test_immutable_types(self):
         )
         for tp in dataset:
             with self.subTest(tp=tp):
-                with self.assertRaisesRegex(TypeError, "immutable"):
-                    tp.foobar = 1
+                support.check_immutable_type(self, tp)
 
 
 class TestExamples(unittest.TestCase):

Lib/test/test_sys.py

@@ -425,6 +425,7 @@ def test_getwindowsversion(self):
         self.assertEqual(v[2], v.build)
         self.assertEqual(v[3], v.platform)
         self.assertEqual(v[4], v.service_pack)
+        support.check_immutable_type(self, type(v))
 
         # This is how platform.py calls it. Make sure tuple
         #  still has 5 elements
@@ -690,6 +691,7 @@ def test_attributes(self):
             self.assertEqual(algo, 0)
         self.assertGreaterEqual(sys.hash_info.cutoff, 0)
         self.assertLess(sys.hash_info.cutoff, 8)
+        support.check_immutable_type(self, type(sys.hash_info))
 
         self.assertIsInstance(sys.maxsize, int)
         self.assertIsInstance(sys.maxunicode, int)
@@ -893,11 +895,13 @@ def assert_raise_on_new_sys_type(self, sys_attr):
         # sys.flags, sys.version_info, and sys.getwindowsversion.
         support.check_disallow_instantiation(self, type(sys_attr), sys_attr)
 
-    def test_sys_flags_no_instantiation(self):
+    def test_sys_flags_type(self):
         self.assert_raise_on_new_sys_type(sys.flags)
+        support.check_immutable_type(self, type(sys.flags))
 
-    def test_sys_version_info_no_instantiation(self):
+    def test_sys_version_info_type(self):
         self.assert_raise_on_new_sys_type(sys.version_info)
+        support.check_immutable_type(self, type(sys.version_info))
 
     def test_sys_getwindowsversion_no_instantiation(self):
         # Skip if not being run on Windows.
@@ -1954,6 +1958,7 @@ def test_asyncgen_hooks(self):
         cur = sys.get_asyncgen_hooks()
         self.assertIsNone(cur.firstiter)
         self.assertIsNone(cur.finalizer)
+        support.check_immutable_type(self, type(cur))
 
         # gh-118473
         with self.assertRaises(TypeError):
@@ -1997,6 +2002,7 @@ def write(self, s):
         self.assertEqual(out, b"")
         self.assertEqual(err, b"")
 
+
 @test.support.support_remote_exec_only
 @test.support.cpython_only
 class TestRemoteExec(unittest.TestCase):

Lib/test/test_xml_etree_c.py

@@ -194,8 +194,7 @@ def test_immutable_types(self):
         )
         for tp in dataset:
             with self.subTest(tp=tp):
-                with self.assertRaisesRegex(TypeError, "immutable"):
-                    tp.foo = 1
+                support.check_immutable_type(self, tp)
 
     @support.cpython_only
     def test_disallow_instantiation(self):

Python/pylifecycle.c

@@ -2072,7 +2072,6 @@ finalize_interp_types(PyInterpreterState *interp)
 {
     _PyTypes_FiniExtTypes(interp);
     _PyUnicode_FiniTypes(interp);
-    _PySys_FiniTypes(interp);
     _PyXI_FiniTypes(interp);
     _PyExc_Fini(interp);
     _PyFloat_FiniType(interp);
@@ -2112,14 +2111,16 @@ finalize_interp_types(PyInterpreterState *interp)
 static void
 finalize_interp_clear(PyThreadState *tstate)
 {
-    int is_main_interp = _Py_IsMainInterpreter(tstate->interp);
+    PyInterpreterState *interp = tstate->interp;
+    int is_main_interp = _Py_IsMainInterpreter(interp);
 
-    _PyXI_Fini(tstate->interp);
-    _PyExc_ClearExceptionGroupType(tstate->interp);
-    _Py_clear_generic_types(tstate->interp);
-    _PyTypes_FiniCachedDescriptors(tstate->interp);
+    _PyXI_Fini(interp);
+    _PyExc_ClearExceptionGroupType(interp);
+    _Py_clear_generic_types(interp);
+    _PyTypes_FiniCachedDescriptors(interp);
+    _PySys_FiniTypes(interp);
 
-    /* Clear interpreter state and all thread states */
+    /* Clear interpreter state and all thread states: last GC collection! */
     _PyInterpreterState_Clear(tstate);
 
     /* Clear all loghooks */
@@ -2136,13 +2137,13 @@ finalize_interp_clear(PyThreadState *tstate)
         _PyPerfTrampoline_Fini();
     }
 
-    finalize_interp_types(tstate->interp);
+    finalize_interp_types(interp);
 
     /* Finalize dtoa at last so that finalizers calling repr of float doesn't crash */
-    _PyDtoa_Fini(tstate->interp);
+    _PyDtoa_Fini(interp);
 
     /* Free any delayed free requests immediately */
-    _PyMem_FiniDelayed(tstate->interp);
+    _PyMem_FiniDelayed(interp);
 
     /* finalize_interp_types may allocate Python objects so we may need to
        abandon mimalloc segments again */