pythongh-100239: Propagate compact-int result type through BINARY_OP_EXTEND

Add a `result_compact_int` flag to _PyBinaryOpSpecializationDescr. When
set, the tier 2 optimizer emits `sym_new_compact_int` for the
_BINARY_OP_EXTEND result instead of a generic PyLong_Type symbol. This
lets downstream int-typed uops (_GUARD_TOS_INT / _GUARD_NOS_INT)
recognize that the value is already compact and elide their guards.

Mark the six compactlongs bitwise entries (OR/AND/XOR and inplace
variants) and the two RSHIFT entries as compact: bitwise ops and right
shift of compact longs always stay within compact range. LSHIFT is
left unmarked because `compact << rhs` with `rhs <= 16` can reach
~2^46, which is not compact.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: eendebakpt

Include/internal/pycore_code.h

@@ -515,6 +515,11 @@ typedef struct {
        types are already known. NULL means unknown/don't eliminate. */
     PyTypeObject *lhs_type;
     PyTypeObject *rhs_type;
+    /* Nonzero iff the guard+action together ensure the result is a
+       compact PyLong. Used by the tier 2 optimizer to propagate a
+       compact-int symbolic type (instead of generic PyLong_Type) so
+       downstream int-typed ops can elide their own guards. */
+    int result_compact_int;
 } _PyBinaryOpSpecializationDescr;
 
 /* Comparison bit masks. */

Python/optimizer_bytecodes.c

@@ -527,7 +527,14 @@ dummy_func(void) {
 
     op(_BINARY_OP_EXTEND, (descr/4, left, right -- res, l, r)) {
         _PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr *)descr;
-        if (d != NULL && d->result_type != NULL) {
+        if (d != NULL && d->result_compact_int) {
+            assert(d->result_type == &PyLong_Type);
+            res = sym_new_compact_int(ctx);
+            if (d->result_unique) {
+                res = PyJitRef_MakeUnique(res);
+            }
+        }
+        else if (d != NULL && d->result_type != NULL) {
             res = sym_new_type(ctx, d->result_type);
             if (d->result_unique) {
                 res = PyJitRef_MakeUnique(res);

Python/optimizer_cases.c.h

@@ -2308,20 +2308,25 @@ LONG_FLOAT_ACTION(compactlong_float_true_div, /)
 
 static _PyBinaryOpSpecializationDescr binaryop_extend_descrs[] = {
     /* long-long arithmetic: guards also check _PyLong_IsCompact, so
-       type alone is not sufficient to eliminate the guard. */
-    {NB_OR, compactlongs_guard, compactlongs_or, &PyLong_Type, 1, NULL, NULL},
-    {NB_AND, compactlongs_guard, compactlongs_and, &PyLong_Type, 1, NULL, NULL},
-    {NB_XOR, compactlongs_guard, compactlongs_xor, &PyLong_Type, 1, NULL, NULL},
-    {NB_INPLACE_OR, compactlongs_guard, compactlongs_or, &PyLong_Type, 1, NULL, NULL},
-    {NB_INPLACE_AND, compactlongs_guard, compactlongs_and, &PyLong_Type, 1, NULL, NULL},
-    {NB_INPLACE_XOR, compactlongs_guard, compactlongs_xor, &PyLong_Type, 1, NULL, NULL},
-
-    /* long-long shifts: guards also check rhs is non-negative and <= 16 to
-       avoid undefined behavior and overflow, so type alone is not sufficient. */
-    {NB_LSHIFT, shift_guard, compactlongs_lshift, &PyLong_Type, 1, NULL, NULL},
-    {NB_RSHIFT, shift_guard, compactlongs_rshift, &PyLong_Type, 1, NULL, NULL},
-    {NB_INPLACE_LSHIFT, shift_guard, compactlongs_lshift, &PyLong_Type, 1, NULL, NULL},
-    {NB_INPLACE_RSHIFT, shift_guard, compactlongs_rshift, &PyLong_Type, 1, NULL, NULL},
+       type alone is not sufficient to eliminate the guard. The result
+       is always a compact PyLong: bitwise OR/AND/XOR of two compacts
+       cannot exceed the operand magnitudes. */
+    {NB_OR,         compactlongs_guard, compactlongs_or,  &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_AND,        compactlongs_guard, compactlongs_and, &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_XOR,        compactlongs_guard, compactlongs_xor, &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_INPLACE_OR, compactlongs_guard, compactlongs_or,  &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_INPLACE_AND,compactlongs_guard, compactlongs_and, &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_INPLACE_XOR,compactlongs_guard, compactlongs_xor, &PyLong_Type, 1, NULL, NULL, 1},
+
+    /* long-long shifts: guards also check rhs is non-negative and <= 16
+       to avoid undefined behavior and overflow. RSHIFT result stays
+       compact (magnitude only shrinks); LSHIFT of a compact shifted
+       by up to 16 can reach ~2^46, so the result is typed PyLong
+       but not marked compact. */
+    {NB_LSHIFT,         shift_guard, compactlongs_lshift, &PyLong_Type, 1, NULL, NULL, 0},
+    {NB_RSHIFT,         shift_guard, compactlongs_rshift, &PyLong_Type, 1, NULL, NULL, 1},
+    {NB_INPLACE_LSHIFT, shift_guard, compactlongs_lshift, &PyLong_Type, 1, NULL, NULL, 0},
+    {NB_INPLACE_RSHIFT, shift_guard, compactlongs_rshift, &PyLong_Type, 1, NULL, NULL, 1},
 
     /* float-long arithmetic: guards also check NaN and compactness. */
     {NB_ADD, float_compactlong_guard, float_compactlong_add, &PyFloat_Type, 1, NULL, NULL},