@@ -816,10 +816,16 @@ def check_same_constant(const):
                       f2.__code__.co_consts[1])
 
         # {0} is converted to a constant frozenset({0}) by the peephole
-        # optimizer. Frozenset-bearing co_consts are intentionally not shared
-        # across code units because later string interning can replace them.
-        f1, f2 = lambda x: x in {0}, lambda x: x in {0}
-        self.assertIsNot(f1.__code__.co_consts, f2.__code__.co_consts)
+        # optimizer. In free-threaded builds, frozenset-bearing co_consts are
+        # not shared across code units because later string interning can
+        # replace them.
+        ns = {}
+        exec("f1, f2 = lambda x: x in {0}, lambda x: x in {0}", ns)
+        f1, f2 = ns["f1"], ns["f2"]
+        if support.Py_GIL_DISABLED:
+            self.assertIsNot(f1.__code__.co_consts, f2.__code__.co_consts)
+        else:
+            self.assertIs(f1.__code__.co_consts, f2.__code__.co_consts)
         self.check_constant(f1, frozenset({0}))
         self.check_constant(f2, frozenset({0}))
         self.assertTrue(f1(0))
 
@@ -405,6 +405,10 @@ def test_code_reference_tracking_does_not_depend_on_refcount(self):
                 )
                 self.assertIs(extra_reference, code.co_consts[0])
 
+    @unittest.skipUnless(
+        support.Py_GIL_DISABLED,
+        "free-threaded builds require compile-order-independent constants",
+    )
     def test_code_serialization_does_not_depend_on_compile_order(self):
         script = textwrap.dedent("""
             import marshal
 
@@ -1,4 +1,4 @@
 Make reference tracking for marshalled code objects in free-threaded builds
 independent of live reference counts. Avoid unstable sharing of immutable
-constants in all builds. This makes bytecode compilation deterministic across
-compilation order and concurrent free-threaded compilation.
+constants in free-threaded compiler output. This makes free-threaded bytecode
+compilation deterministic across compilation order and concurrent compilation.
@@ -342,14 +342,13 @@ _PyCompile_SetQualname(compiler *c)
 static int
 const_cache_contains_rebuilt_container(PyObject *o)
 {
+#ifdef Py_GIL_DISABLED
     if (PyFrozenSet_CheckExact(o)) {
         return 1;
     }
-#ifdef Py_GIL_DISABLED
     if (PySlice_Check(o)) {
         return 1;
     }
-#endif
     if (PyTuple_CheckExact(o)) {
         for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(o); i++) {
             if (const_cache_contains_rebuilt_container(
@@ -359,6 +358,9 @@ const_cache_contains_rebuilt_container(PyObject *o)
             }
         }
     }
+#else
+    (void)o;
+#endif
     return 0;
 }
Original file line number	Diff line number	Diff line change
`@@ -342,14 +342,13 @@ _PyCompile_SetQualname(compiler *c)`
`342`	`342`	`static int`
`343`	`343`	`const_cache_contains_rebuilt_container(PyObject *o)`
`344`	`344`	`{`
	`345`	`+#ifdef Py_GIL_DISABLED`
`345`	`346`	`if (PyFrozenSet_CheckExact(o)) {`
`346`	`347`	`return 1;`
`347`	`348`	`}`
`348`		`-#ifdef Py_GIL_DISABLED`
`349`	`349`	`if (PySlice_Check(o)) {`
`350`	`350`	`return 1;`
`351`	`351`	`}`
`352`		`-#endif`
`353`	`352`	`if (PyTuple_CheckExact(o)) {`
`354`	`353`	`for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(o); i++) {`
`355`	`354`	`if (const_cache_contains_rebuilt_container(`
`@@ -359,6 +358,9 @@ const_cache_contains_rebuilt_container(PyObject *o)`
`359`	`358`	`}`
`360`	`359`	`}`
`361`	`360`	`}`
	`361`	`+#else`
	`362`	`+ (void)o;`
	`363`	`+#endif`
`362`	`364`	`return 0;`
`363`	`365`	`}`
`364`	`366`