bc: route bitwise BC fast paths through mino_int_wrap

Surfaced by mino-tests's gen.clj while building a seeded xorshift64*
RNG: a few iterations of (bit-xor x (bit-shift-left x1 25)) inside
a defn body raised MTY001 "bit-xor expects integers". Same code at
top level worked.

binop_int_fast in src/eval/bc/vm.c routed BAND / BOR / BXOR / SHL /
SHR / USHR results through tag_or_box_int, which falls back to
mino_int that promotes to MINO_BIGINT when bignum capability is
installed. The corresponding prims use mino_int_wrap which always
boxes as MINO_INT and never promotes. The two paths produced
different result types; a downstream bit-xor's fast-path check
refused the bigint -- hence the misleading MTY001.

Fix routes all bitwise BC fast paths through mino_int_wrap. ADD /
SUB / MUL keep tag_or_box_int since Clojure-correct overflow there
DOES promote to bigint.

Regression test in tests/bc_bitwise_test.clj: five bitwise ops at
i64 range plus the xorshift64* chain that surfaced the issue.
Suite: 1272 / 4549 green.

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

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## v0.255.5 — Fix: BC Bitwise Fast Path No Longer Promotes to Bigint
+
+Surfaced by mino-tests's `gen.clj` while building a seeded RNG: an
+xorshift64* step inside a `defn` body raised `MTY001 "bit-xor
+expects integers"` after a few iterations. The same code at the
+top level worked.
+
+Root cause: `binop_int_fast` in `src/eval/bc/vm.c` routed BAND /
+BOR / BXOR / SHL / SHR / USHR results through `tag_or_box_int`,
+which falls back to `mino_int` for values outside the inline-tag
+range. `mino_int` promotes to `MINO_BIGINT` when the bignum
+capability is installed. The corresponding prims
+(`prim_bit_shift_left`, `prim_bit_and`, ...) all use
+`mino_int_wrap`, which always boxes as a plain `MINO_INT` and never
+promotes. The two paths produced different result types for the
+same operation, and a downstream `bit-xor`'s fast-path check
+refused the bigint with `MTY001 "bit-xor expects integers"`.
+
+Fix: bitwise BC fast-path results now go through `mino_int_wrap`,
+matching the prim semantics exactly. Arithmetic (ADD / SUB / MUL)
+keeps `tag_or_box_int` since Clojure-correct overflow there
+DOES promote to bigint.
+
+Regression test in `tests/bc_bitwise_test.clj` covers all five
+bitwise ops at i64 range plus the xorshift64* chain that surfaced
+the original issue. Suite: 1272 / 4549 green.
+
 ## v0.255.4 — Hygiene: I/O Buffer Overflow + Safepoint Comment
 
 Two small cleanups closing the rest of the runtime-audit BUGS.md

src/eval/bc/vm.c

@@ -549,21 +549,29 @@ mino_val_t *binop_int_fast(mino_state_t *S, mino_val_t *lhs,
         r = a % b;
         if (subop == BINOP_MOD && r != 0 && ((r < 0) != (b < 0))) r += b;
         return tag_or_box_int(S, r);
-    case BINOP_BAND: return tag_or_box_int(S, a & b);
-    case BINOP_BOR:  return tag_or_box_int(S, a | b);
-    case BINOP_BXOR: return tag_or_box_int(S, a ^ b);
+    /* Bitwise ops are i64 operations -- the prims call mino_int_wrap
+     * which always boxes as MINO_INT, never promotes to bigint. Route
+     * the fast-path results through mino_int_wrap as well so a BC-
+     * compiled call has the same result type as the prim path. Using
+     * tag_or_box_int here promoted to bigint via mino_int's overflow
+     * branch when the bignum capability was installed, and the
+     * surface bug was a downstream bit-xor refusing the promoted
+     * bigint (MTY001 "bit-xor expects integers"). */
+    case BINOP_BAND: return mino_int_wrap(S, a & b);
+    case BINOP_BOR:  return mino_int_wrap(S, a | b);
+    case BINOP_BXOR: return mino_int_wrap(S, a ^ b);
     case BINOP_SHL:
         /* Shift amount must be in [0, 63]; route through unsigned so
          * that bit-shift-left of negative values matches the prim's
          * wrap-around result (and stays clear of signed-overflow UB). */
         if (b < 0 || b >= 64) return NULL;
-        return tag_or_box_int(S, (long long)((unsigned long long)a << b));
+        return mino_int_wrap(S, (long long)((unsigned long long)a << b));
     case BINOP_SHR:
         if (b < 0 || b >= 64) return NULL;
-        return tag_or_box_int(S, a >> b);
+        return mino_int_wrap(S, a >> b);
     case BINOP_USHR:
         if (b < 0 || b >= 64) return NULL;
-        return tag_or_box_int(S, (long long)((unsigned long long)a >> b));
+        return mino_int_wrap(S, (long long)((unsigned long long)a >> b));
     default:       return NULL;
     }
 }

src/mino.h

@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 255
-#define MINO_VERSION_PATCH 4
+#define MINO_VERSION_PATCH 5
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

tests/bc_bitwise_test.clj

@@ -0,0 +1,36 @@
+(require "tests/test")
+
+;; Regression: the BC compiler's BINOP_SHL / BAND / BOR / BXOR /
+;; SHR / USHR fast paths used to route their results through
+;; tag_or_box_int, which calls mino_int that promotes overflowing
+;; values to MINO_BIGINT when the bignum capability is installed.
+;; The corresponding prims used mino_int_wrap which always boxes as
+;; MINO_INT. The surface symptom: a downstream bit-xor against the
+;; promoted bigint raised MTY001 "bit-xor expects integers" --
+;; misleading, since the bigint IS an integer, just not the type the
+;; bit-xor fast path was looking for. Fix routes the bitwise BC fast
+;; paths through mino_int_wrap to match the prim's semantics.
+
+(deftest bc-bit-shift-left-stays-int
+  (testing "bit-shift-left of a large i64 stays :int in a BC-compiled fn"
+    (defn step [x] (bit-shift-left x 25))
+    (let [r (step 142452317671654462)]
+      (is (= :int (type r)))
+      (is (= 4728920382667489280 r))))
+  (testing "chained bit-shift-left + bit-xor in a fn body"
+    (defn xorshift [x]
+      (let [a (bit-xor x (unsigned-bit-shift-right x 12))
+            b (bit-xor a (bit-shift-left a 25))
+            c (bit-xor b (unsigned-bit-shift-right b 27))]
+        c))
+    (is (= :int (type (xorshift 142435135655313518))))))
+
+(deftest bc-bitwise-stays-int
+  (testing "bit-and, bit-or, bit-xor in BC-compiled fn stay :int"
+    (defn bw [a b]
+      [(bit-and a b) (bit-or a b) (bit-xor a b)])
+    (let [r (bw 142452317671654462 9223372036854775000)]
+      (is (every? #(= :int (type %)) r))))
+  (testing "unsigned-bit-shift-right in BC fn"
+    (defn ushr [x] (unsigned-bit-shift-right x 1))
+    (is (= :int (type (ushr 142452317671654462))))))

tests/run.clj

@@ -61,6 +61,7 @@
 (require "tests/bc_closure_test")
 (require "tests/reduce_perf_test")
 (require "tests/bc_let_fold_test")
+(require "tests/bc_bitwise_test")
 (require "tests/ifn_test")
 (require "tests/stack_test")
 (require "tests/sorted_test")