add more tests, remove defensive code

Author: eendebakpt

Include/internal/pycore_interp_structs.h

@@ -525,8 +525,13 @@ struct _py_func_state {
 /****** type state *********/
 
 /* For now we hard-code this to a value for which we are confident
-   all the static builtin types will fit (for all builds). */
-#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES 203
+   all the static builtin types will fit (for all builds).
+   If you add a new static type to the standard library, you may have to
+   update one of these numbers.
+   */
+#define _Py_NUM_MANAGED_PREINITIALIZED_TYPES 120
+#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES \
+    (_Py_NUM_MANAGED_PREINITIALIZED_TYPES + 83)
 #define _Py_MAX_MANAGED_STATIC_EXT_TYPES 10
 #define _Py_MAX_MANAGED_STATIC_TYPES \
     (_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES + _Py_MAX_MANAGED_STATIC_EXT_TYPES)

InternalDocs/parser.md

@@ -819,6 +819,13 @@ directory on the CPython repository and manually call the parser generator by ex
 $ python -m pegen python <PATH TO YOUR GRAMMAR FILE>
 ```
 
+> [!CAUTION]
+> Python's grammar (the `Grammar/python.gram` file) is written for the
+> C backend. To experiment, you will need to write a grammar
+> without C-specific parts like actions and the trailer.
+> See [#133560](https://github.com/python/cpython/issues/133560) 
+> and [#96424](https://github.com/python/cpython/issues/96424) for more information.
+
 This will generate a file called `parse.py` in the same directory that you
 can use to parse some input:
 

Lib/pdb.py

@@ -376,7 +376,7 @@ def get_default_backend():
 
 def _pyrepl_available():
     """return whether pdb should use _pyrepl for input"""
-    if not os.getenv("PYTHON_BASIC_REPL"):
+    if os.getenv("PYTHON_BASIC_REPL"):
         CAN_USE_PYREPL = False
     else:
         try:

Lib/test/test_capi/test_opt.py

@@ -4819,6 +4819,46 @@ def f(n):
         # Every element must be False: the set is empty after discard()
         self.assertTrue(all(r is False for r in res))
 
+    def _check_to_bool_recorded_type(self, inner, value, guard_op):
+        """Recorded-type path: a value whose static type is unknown but whose
+        runtime type is recorded should emit `guard_op` + _TO_BOOL_SIZED."""
+        self.assertEqual(inner(value), TIER2_THRESHOLD)
+        ex_inner = get_first_executor(inner)
+        self.assertIsNotNone(ex_inner)
+        uops = get_opnames(ex_inner)
+        self.assertIn(guard_op, uops)
+        self.assertIn("_TO_BOOL_SIZED", uops)
+        self.assertNotIn("_TO_BOOL", uops)
+
+    def test_to_bool_bytes(self):
+        def inner(v):
+            cnt = 0
+            for _ in range(TIER2_THRESHOLD):
+                if v:
+                    cnt += 1
+            return cnt
+        self._check_to_bool_recorded_type(inner, b"hello", "_GUARD_TOS_BYTES")
+
+    def test_to_bool_bytearray(self):
+        def inner(v):
+            cnt = 0
+            for _ in range(TIER2_THRESHOLD):
+                if v:
+                    cnt += 1
+            return cnt
+        self._check_to_bool_recorded_type(
+            inner, bytearray(b"hello"), "_GUARD_TOS_BYTEARRAY")
+
+    def test_to_bool_frozenset(self):
+        def inner(v):
+            cnt = 0
+            for _ in range(TIER2_THRESHOLD):
+                if v:
+                    cnt += 1
+            return cnt
+        self._check_to_bool_recorded_type(
+            inner, frozenset({1, 2, 3}), "_GUARD_TOS_FROZENSET")
+
     def test_attr_promotion_failure(self):
         # We're not testing for any specific uops here, just
         # testing it doesn't crash.

Lib/test/test_pdb.py

@@ -4753,6 +4753,16 @@ def foo(self):
         stdout, stderr = self.run_pdb_script(script, commands)
         self.assertIn("The specified object 'C.foo' is not a function", stdout)
 
+    def test_pyrepl_available(self):
+        with patch.dict(os.environ, {"PYTHON_BASIC_REPL": "1"}):
+            self.assertFalse(pdb._pyrepl_available())
+
+        with patch.dict(os.environ, {}, clear=True):
+            mod = types.ModuleType("_pyrepl.main")
+            mod.CAN_USE_PYREPL = True
+            with patch.dict("sys.modules", {"_pyrepl.main": mod}):
+                self.assertTrue(pdb._pyrepl_available())
+
 
 class ChecklineTests(unittest.TestCase):
     def setUp(self):

Misc/NEWS.d/next/Build/2026-04-30-08-43-47.gh-issue-146475.1cL4hX.rst

@@ -0,0 +1,2 @@
+Block Apple Clang from being used to build the JIT as it ships without
+required LLVM tools.

Misc/NEWS.d/next/Library/2026-04-30-14-21-26.gh-issue-149173.KJqZm0.rst

@@ -0,0 +1,2 @@
+Fix inverted :envvar:`PYTHON_BASIC_REPL` environment check in
+``pdb._pyrepl_available``.

Objects/object.c

@@ -2526,7 +2526,7 @@ extern PyTypeObject _PyMemoryIter_Type;
 extern PyTypeObject _PyPositionsIterator;
 extern PyTypeObject _Py_GenericAliasIterType;
 
-static PyTypeObject* static_types[] = {
+static PyTypeObject* static_types[_Py_NUM_MANAGED_PREINITIALIZED_TYPES] = {
     // The two most important base types: must be initialized first and
     // deallocated last.
     &PyBaseObject_Type,
@@ -2644,6 +2644,9 @@ static PyTypeObject* static_types[] = {
     &_PyUnion_Type,
 #ifdef _Py_TIER2
     &_PyUOpExecutor_Type,
+#else
+    // The array should have the same size on all builds; see gh-149139
+    NULL,
 #endif
     &_PyWeakref_CallableProxyType,
     &_PyWeakref_ProxyType,
@@ -2668,6 +2671,9 @@ _PyTypes_InitTypes(PyInterpreterState *interp)
     // All other static types (unless initialized elsewhere)
     for (size_t i=0; i < Py_ARRAY_LENGTH(static_types); i++) {
         PyTypeObject *type = static_types[i];
+        if (type == NULL) {
+            continue;
+        }
         if (_PyStaticType_InitBuiltin(interp, type) < 0) {
             return _PyStatus_ERR("Can't initialize builtin type");
         }
@@ -2708,6 +2714,9 @@ _PyTypes_FiniTypes(PyInterpreterState *interp)
     // their base classes.
     for (Py_ssize_t i=Py_ARRAY_LENGTH(static_types)-1; i>=0; i--) {
         PyTypeObject *type = static_types[i];
+        if (type == NULL) {
+            continue;
+        }
         _PyStaticType_FiniBuiltin(interp, type);
     }
 }

Python/optimizer_bytecodes.c

@@ -714,11 +714,10 @@ dummy_func(void) {
                     REPLACE_OP(this_instr, _TO_BOOL_SIZED, 0, size_offset);
                 }
             }
-            else if (emitted_guard) {
-                // Defensive: we emitted a guard but didn't compute a
-                // size_offset (shouldn't happen with the table above).
-                // Ensure the original _TO_BOOL still reaches output.
-                ADD_OP(_TO_BOOL, 0, 0);
+            else {
+                // Every type that sets emitted_guard above is also in the
+                // size_offset table, so we never reach here with a guard.
+                assert(!emitted_guard);
             }
             res = sym_new_truthiness(ctx, value, true);
         }