Sync pre-release CPython main branch from GitHub (2026-05-06)

Summary:
Imported python/cpython `3.15.0a8+` from upstream rev [`7cea70e`](https://www.github.com/python/cpython/commit/7cea70e14dac091cbd7e0601b96a59458f8c9bee) (committed 2026-05-06 16:07:43+00:00).

# Commit Info

Base: (`3.15.0a8+`) - [`5dd2161`](https://www.github.com/python/cpython/commit/5dd21617164cf69e848a70e3d7e32faf0bc3f279) (commit date: 2026-05-05 03:30:03+00:00)
Imported: (`3.15.0a8+`) - [`7cea70e`](https://www.github.com/python/cpython/commit/7cea70e14dac091cbd7e0601b96a59458f8c9bee) (commit date: 2026-05-06 16:07:43+00:00)

# Noteworthy file changes

- C files (9 added, 1 removed):
  ```
  + Include/internal/pycore_jit_publish.h
  + Include/internal/pycore_slots.h
  + Include/internal/pycore_slots_generated.h
  + Include/slots.h
  + Include/slots_generated.h
  + Modules/_testlimitedcapi/slots.c
  + Python/jit_publish.c
  + Python/slots.c
  + Python/slots_generated.c
  - Include/typeslots.h
  ```
- Stdlib files (1 added)
- Test files (2 added)
- Low-signal files (18 added) (NEWS.d, docs, .github)
- Other files (2 added, 2 removed)

Complete list of added/removed files: https://www.internalfb.com/intern/everpaste/?color=0&handle=GJw6XylIQbliXBcHAHGAA4Hid68gbr0LAAAz

Reviewed By: fried

Differential Revision: D104075893

fbshipit-source-id: 025b3adb8cef7d0268de744ef41d819835501cce

Author: itamaro

cinderx/Interpreter/3.15/Includes/Python/ceval_macros.h

@@ -640,3 +640,6 @@ gen_try_set_executing(PyGenObject *gen)
             (PyLongObject *)PyStackRef_AsPyObjectBorrow(left),           \
             (PyLongObject *)PyStackRef_AsPyObjectBorrow(right));         \
     }
+
+#define CALL_TP_ITERITEM_NO_ESCAPE(ITER, INDEX) \
+    Py_TYPE(ITER)->_tp_iteritem((ITER), (INDEX))

cinderx/Interpreter/3.15/Includes/generated_cases.c.h

@@ -3783,8 +3783,7 @@
             // _GUARD_NOS_NOT_NULL
             {
                 nos = stack_pointer[-2];
-                PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
-                if (o == NULL) {
+                if (PyStackRef_IsNull(nos)) {
                     UPDATE_MISS_STATS(CALL);
                     assert(_PyOpcode_Deopt[opcode] == (CALL));
                     JUMP_TO_PREDICTED(CALL);
@@ -5785,9 +5784,7 @@
                 int err = PyDict_Update(dict_o, update_o);
                 stack_pointer = _PyFrame_GetStackPointer(frame);
                 if (err < 0) {
-                    _PyFrame_SetStackPointer(frame, stack_pointer);
                     int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
-                    stack_pointer = _PyFrame_GetStackPointer(frame);
                     if (matches) {
                         _PyFrame_SetStackPointer(frame, stack_pointer);
                         PyObject *exc = _PyErr_GetRaisedException(tstate);
@@ -7868,23 +7865,22 @@
             next_instr += 2;
             INSTRUCTION_STATS(FOR_ITER_VIRTUAL);
             static_assert(INLINE_CACHE_ENTRIES_FOR_ITER == 1, "incorrect cache size");
-            _PyStackRef iter;
             _PyStackRef null_or_index;
+            _PyStackRef iter;
             _PyStackRef next;
             /* Skip 1 cache entry */
-            // _GUARD_NOS_ITER_VIRTUAL
+            // _GUARD_TOS_NOT_NULL
             {
-                iter = stack_pointer[-2];
-                PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
-                if (Py_TYPE(iter_o)->_tp_iteritem == NULL) {
+                null_or_index = stack_pointer[-1];
+                if (PyStackRef_IsNull(null_or_index)) {
                     UPDATE_MISS_STATS(FOR_ITER);
                     assert(_PyOpcode_Deopt[opcode] == (FOR_ITER));
                     JUMP_TO_PREDICTED(FOR_ITER);
                 }
             }
             // _FOR_ITER_VIRTUAL
             {
-                null_or_index = stack_pointer[-1];
+                iter = stack_pointer[-2];
                 PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
                 Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
                 _PyFrame_SetStackPointer(frame, stack_pointer);
@@ -9704,9 +9700,7 @@
                 PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
                 stack_pointer = _PyFrame_GetStackPointer(frame);
                 if (none_val == NULL) {
-                    _PyFrame_SetStackPointer(frame, stack_pointer);
                     int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
-                    stack_pointer = _PyFrame_GetStackPointer(frame);
                     if (matches &&
                         (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
                     {
@@ -12589,7 +12583,6 @@
                 v = stack_pointer[-1];
                 null_or_index = stack_pointer[-2];
                 PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
-                PyObject *retval_o;
                 assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
                 if (!IS_PEP523_HOOKED(tstate) &&
                     (Py_TYPE(receiver_o) == &PyGen_Type || Py_TYPE(receiver_o) == &PyCoro_Type) &&
@@ -12608,7 +12601,7 @@
                     gen_frame->previous = frame;
                     DISPATCH_INLINED(gen_frame);
                 }
-                if (!PyStackRef_IsNull(null_or_index)) {
+                if (!PyStackRef_IsNull(null_or_index) && PyStackRef_IsNone(v)) {
                     _PyFrame_SetStackPointer(frame, stack_pointer);
                     _PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, receiver, &null_or_index);
                     stack_pointer = _PyFrame_GetStackPointer(frame);
@@ -12623,51 +12616,89 @@
                     retval = item;
                 }
                 else {
-                    if (PyStackRef_IsNone(v) && PyIter_Check(receiver_o)) {
-                        _PyFrame_SetStackPointer(frame, stack_pointer);
-                        retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o);
-                        stack_pointer = _PyFrame_GetStackPointer(frame);
-                    }
-                    else {
-                        _PyFrame_SetStackPointer(frame, stack_pointer);
-                        retval_o = PyObject_CallMethodOneArg(receiver_o,
-                            &_Py_ID(send),
-                            PyStackRef_AsPyObjectBorrow(v));
-                        stack_pointer = _PyFrame_GetStackPointer(frame);
+                    PyObject *v_o = PyStackRef_AsPyObjectBorrow(v);
+                    _PyFrame_SetStackPointer(frame, stack_pointer);
+                    PySendResultPair res = _PyIter_Send(receiver_o, v_o);
+                    stack_pointer = _PyFrame_GetStackPointer(frame);
+                    if (res.kind == PYGEN_ERROR) {
+                        JUMP_TO_LABEL(error);
                     }
-                    if (retval_o == NULL) {
-                        _PyFrame_SetStackPointer(frame, stack_pointer);
-                        int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
-                        stack_pointer = _PyFrame_GetStackPointer(frame);
-                        if (matches) {
-                            _PyFrame_SetStackPointer(frame, stack_pointer);
-                            _PyEval_MonitorRaise(tstate, frame, this_instr);
-                            stack_pointer = _PyFrame_GetStackPointer(frame);
-                        }
-                        _PyFrame_SetStackPointer(frame, stack_pointer);
-                        int err = _PyGen_FetchStopIterationValue(&retval_o);
-                        stack_pointer = _PyFrame_GetStackPointer(frame);
-                        if (err == 0) {
-                            assert(retval_o != NULL);
-                            JUMPBY(oparg);
-                        }
-                        else {
-                            stack_pointer += -1;
-                            ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
-                            _PyFrame_SetStackPointer(frame, stack_pointer);
-                            PyStackRef_CLOSE(v);
-                            stack_pointer = _PyFrame_GetStackPointer(frame);
-                            JUMP_TO_LABEL(error);
-                        }
+                    stack_pointer += -1;
+                    ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+                    _PyFrame_SetStackPointer(frame, stack_pointer);
+                    PyStackRef_CLOSE(v);
+                    stack_pointer = _PyFrame_GetStackPointer(frame);
+                    retval = PyStackRef_FromPyObjectSteal(res.object);
+                    if (res.kind == PYGEN_RETURN) {
+                        JUMPBY(oparg);
                     }
-                    retval = PyStackRef_FromPyObjectSteal(retval_o);
+                    stack_pointer += 1;
+                }
+            }
+            stack_pointer[-2] = null_or_index;
+            stack_pointer[-1] = retval;
+            DISPATCH();
+        }
+
+        TARGET(SEND_ASYNC_GEN) {
+            #if _Py_TAIL_CALL_INTERP
+            int opcode = SEND_ASYNC_GEN;
+            (void)(opcode);
+            #endif
+            _Py_CODEUNIT* const this_instr = next_instr;
+            (void)this_instr;
+            frame->instr_ptr = next_instr;
+            next_instr += 2;
+            INSTRUCTION_STATS(SEND_ASYNC_GEN);
+            static_assert(INLINE_CACHE_ENTRIES_SEND == 1, "incorrect cache size");
+            _PyStackRef iter;
+            _PyStackRef null_in;
+            _PyStackRef v;
+            _PyStackRef asend;
+            _PyStackRef null_out;
+            _PyStackRef retval;
+            /* Skip 1 cache entry */
+            // _GUARD_3OS_ASYNC_GEN_ASEND
+            {
+                iter = stack_pointer[-3];
+                PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
+                if (!PyAsyncGenASend_CheckExact(iter_o)) {
+                    UPDATE_MISS_STATS(SEND);
+                    assert(_PyOpcode_Deopt[opcode] == (SEND));
+                    JUMP_TO_PREDICTED(SEND);
                 }
-                stack_pointer[-2] = null_or_index;
-                stack_pointer[-1] = retval;
+            }
+            // _SEND_ASYNC_GEN
+            {
+                v = stack_pointer[-1];
+                null_in = stack_pointer[-2];
+                PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
+                assert(PyAsyncGenASend_CheckExact(iter_o));
+                PyObject *val = PyStackRef_AsPyObjectBorrow(v);
+                PyObject *retval_o;
+                _PyFrame_SetStackPointer(frame, stack_pointer);
+                PySendResult what = _PyAsyncGenASend_Send(iter_o, val, &retval_o);
+                stack_pointer = _PyFrame_GetStackPointer(frame);
+                if (what == PYGEN_ERROR) {
+                    JUMP_TO_LABEL(error);
+                }
+                stack_pointer += -1;
+                ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
                 _PyFrame_SetStackPointer(frame, stack_pointer);
                 PyStackRef_CLOSE(v);
                 stack_pointer = _PyFrame_GetStackPointer(frame);
+                asend = iter;
+                null_out = null_in;
+                retval = PyStackRef_FromPyObjectSteal(retval_o);
+                if (what == PYGEN_RETURN) {
+                    JUMPBY(oparg);
+                }
             }
+            stack_pointer[-2] = asend;
+            stack_pointer[-1] = null_out;
+            stack_pointer[0] = retval;
+            stack_pointer += 1;
+            ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
             DISPATCH();
         }
 
@@ -12740,6 +12771,70 @@
             DISPATCH();
         }
 
+        TARGET(SEND_VIRTUAL) {
+            #if _Py_TAIL_CALL_INTERP
+            int opcode = SEND_VIRTUAL;
+            (void)(opcode);
+            #endif
+            _Py_CODEUNIT* const this_instr = next_instr;
+            (void)this_instr;
+            frame->instr_ptr = next_instr;
+            next_instr += 2;
+            INSTRUCTION_STATS(SEND_VIRTUAL);
+            static_assert(INLINE_CACHE_ENTRIES_SEND == 1, "incorrect cache size");
+            _PyStackRef val;
+            _PyStackRef nos;
+            _PyStackRef iter;
+            _PyStackRef null_or_index;
+            _PyStackRef none;
+            _PyStackRef next;
+            /* Skip 1 cache entry */
+            // _GUARD_TOS_IS_NONE
+            {
+                val = stack_pointer[-1];
+                if (!PyStackRef_IsNone(val)) {
+                    UPDATE_MISS_STATS(SEND);
+                    assert(_PyOpcode_Deopt[opcode] == (SEND));
+                    JUMP_TO_PREDICTED(SEND);
+                }
+            }
+            // _GUARD_NOS_NOT_NULL
+            {
+                nos = stack_pointer[-2];
+                if (PyStackRef_IsNull(nos)) {
+                    UPDATE_MISS_STATS(SEND);
+                    assert(_PyOpcode_Deopt[opcode] == (SEND));
+                    JUMP_TO_PREDICTED(SEND);
+                }
+            }
+            // _SEND_VIRTUAL
+            {
+                none = val;
+                null_or_index = nos;
+                iter = stack_pointer[-3];
+                PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
+                Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
+                _PyFrame_SetStackPointer(frame, stack_pointer);
+                _PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
+                stack_pointer = _PyFrame_GetStackPointer(frame);
+                PyObject *next_o = next_index.object;
+                index = next_index.index;
+                if (next_o == NULL) {
+                    if (index < 0) {
+                        JUMP_TO_LABEL(error);
+                    }
+                    next = none;
+                    JUMPBY(oparg);
+                    DISPATCH();
+                }
+                next = PyStackRef_FromPyObjectSteal(next_o);
+                null_or_index = PyStackRef_TagInt(index);
+            }
+            stack_pointer[-2] = null_or_index;
+            stack_pointer[-1] = next;
+            DISPATCH();
+        }
+
         TARGET(SETUP_ANNOTATIONS) {
             #if _Py_TAIL_CALL_INTERP
             int opcode = SETUP_ANNOTATIONS;

cinderx/Interpreter/3.15/cinderx_opcode_targets.h

@@ -202,7 +202,9 @@ static void *opcode_targets_table[256] = {
     &&TARGET_LOAD_SUPER_ATTR_METHOD,
     &&TARGET_RESUME_CHECK,
     &&TARGET_RESUME_CHECK_JIT,
+    &&TARGET_SEND_ASYNC_GEN,
     &&TARGET_SEND_GEN,
+    &&TARGET_SEND_VIRTUAL,
     &&TARGET_STORE_ATTR_INSTANCE_VALUE,
     &&TARGET_STORE_ATTR_SLOT,
     &&TARGET_STORE_ATTR_WITH_HINT,
@@ -231,8 +233,6 @@ static void *opcode_targets_table[256] = {
     &&_unknown_opcode,
     &&_unknown_opcode,
     &&_unknown_opcode,
-    &&_unknown_opcode,
-    &&_unknown_opcode,
     &&TARGET_INSTRUMENTED_END_FOR,
     &&TARGET_INSTRUMENTED_POP_ITER,
     &&TARGET_INSTRUMENTED_END_SEND,
@@ -476,8 +476,8 @@ static void *opcode_tracing_targets_table[256] = {
     &&TARGET_TRACE_RECORD,
     &&TARGET_TRACE_RECORD,
     &&TARGET_TRACE_RECORD,
-    &&_unknown_opcode,
-    &&_unknown_opcode,
+    &&TARGET_TRACE_RECORD,
+    &&TARGET_TRACE_RECORD,
     &&_unknown_opcode,
     &&_unknown_opcode,
     &&_unknown_opcode,
@@ -726,7 +726,9 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_RESUME_CHECK_JIT(TAIL_CALL_PARAM
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_RETURN_GENERATOR(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_RETURN_VALUE(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SEND(TAIL_CALL_PARAMS);
+static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SEND_ASYNC_GEN(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SEND_GEN(TAIL_CALL_PARAMS);
+static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SEND_VIRTUAL(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SETUP_ANNOTATIONS(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SET_ADD(TAIL_CALL_PARAMS);
 static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_SET_FUNCTION_ATTRIBUTE(TAIL_CALL_PARAMS);
@@ -971,7 +973,9 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = {
     [RETURN_GENERATOR] = _TAIL_CALL_RETURN_GENERATOR,
     [RETURN_VALUE] = _TAIL_CALL_RETURN_VALUE,
     [SEND] = _TAIL_CALL_SEND,
+    [SEND_ASYNC_GEN] = _TAIL_CALL_SEND_ASYNC_GEN,
     [SEND_GEN] = _TAIL_CALL_SEND_GEN,
+    [SEND_VIRTUAL] = _TAIL_CALL_SEND_VIRTUAL,
     [SETUP_ANNOTATIONS] = _TAIL_CALL_SETUP_ANNOTATIONS,
     [SET_ADD] = _TAIL_CALL_SET_ADD,
     [SET_FUNCTION_ATTRIBUTE] = _TAIL_CALL_SET_FUNCTION_ATTRIBUTE,
@@ -1016,8 +1020,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = {
     [124] = _TAIL_CALL_UNKNOWN_OPCODE,
     [125] = _TAIL_CALL_UNKNOWN_OPCODE,
     [127] = _TAIL_CALL_UNKNOWN_OPCODE,
-    [217] = _TAIL_CALL_UNKNOWN_OPCODE,
-    [218] = _TAIL_CALL_UNKNOWN_OPCODE,
     [219] = _TAIL_CALL_UNKNOWN_OPCODE,
     [220] = _TAIL_CALL_UNKNOWN_OPCODE,
     [221] = _TAIL_CALL_UNKNOWN_OPCODE,
@@ -1229,7 +1231,9 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = {
     [RETURN_GENERATOR] = _TAIL_CALL_TRACE_RECORD,
     [RETURN_VALUE] = _TAIL_CALL_TRACE_RECORD,
     [SEND] = _TAIL_CALL_TRACE_RECORD,
+    [SEND_ASYNC_GEN] = _TAIL_CALL_TRACE_RECORD,
     [SEND_GEN] = _TAIL_CALL_TRACE_RECORD,
+    [SEND_VIRTUAL] = _TAIL_CALL_TRACE_RECORD,
     [SETUP_ANNOTATIONS] = _TAIL_CALL_TRACE_RECORD,
     [SET_ADD] = _TAIL_CALL_TRACE_RECORD,
     [SET_FUNCTION_ATTRIBUTE] = _TAIL_CALL_TRACE_RECORD,
@@ -1274,8 +1278,6 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = {
     [124] = _TAIL_CALL_UNKNOWN_OPCODE,
     [125] = _TAIL_CALL_UNKNOWN_OPCODE,
     [127] = _TAIL_CALL_UNKNOWN_OPCODE,
-    [217] = _TAIL_CALL_UNKNOWN_OPCODE,
-    [218] = _TAIL_CALL_UNKNOWN_OPCODE,
     [219] = _TAIL_CALL_UNKNOWN_OPCODE,
     [220] = _TAIL_CALL_UNKNOWN_OPCODE,
     [221] = _TAIL_CALL_UNKNOWN_OPCODE,