long: stay fixnum across the inline-tag boundary

prim_long was calling mino_int(), which auto-promotes to
MINO_BIGINT for values outside the inline-tagged 61-bit range.
That silently disables checked-arithmetic overflow on the
result: (* (long (/ Long/MIN_VALUE 2)) 3) returned a wider
bigint instead of throwing. Switch to mino_int_wrap(), the
fixnum-preserving constructor already used by unchecked-multiply,
inc, dec, and the bit primitives.

Caught by the external clojure-test-suite driver: star.cljc was
the only file failing assertions in the sweep.

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## v0.422.2 — `long` Coercion Stays Fixnum
+
+Fixes `(long x)` silently promoting to `:bigint` when the coerced
+value fell outside the inline-tagged 61-bit range (roughly
+`|x| > 2^60`). The primitive was calling the tower-aware
+`mino_int` constructor, which auto-promotes large fixnums to
+`MINO_BIGINT` so plain literals can keep using the numeric tower
+transparently. For `long` that promotion is wrong: a coerced long
+should observe checked-arithmetic overflow downstream, and a
+`MINO_BIGINT` silently disables that check. `prim_long` now uses
+`mino_int_wrap`, the same fixnum-preserving constructor that
+backs `unchecked-multiply`, `inc`, `dec`, and the bit
+primitives.
+
+Caught by the external `clojure-test-suite` driver
+(`tests/clojure_test_suite.clj`): `star.cljc` was failing two
+overflow assertions of the form
+`(thrown? (* (long (/ Long/MIN_VALUE 2)) 3))` because the inner
+`long` was returning a bigint, so the outer `*` happily produced
+a wider bigint instead of throwing.
+
 ## v0.422.1 — Amalgamate Symbol Collision Fix
 
 Renames the static `kw_match` helper in `src/prim/bits.c` to

src/mino.h

@@ -47,7 +47,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 422
-#define MINO_VERSION_PATCH 1
+#define MINO_VERSION_PATCH 2
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

src/prim/numeric_coerce.c

@@ -150,9 +150,11 @@ mino_val *prim_long(mino_state *S, mino_val *args, mino_env *env)
         snprintf(buf, sizeof(buf), "long: %s", err ? err : "expected a number");
         return prim_throw_classified(S, "eval/type", "MTY001", buf);
     }
-    /* mino's MINO_INT is int64 already, so the range check is the same
-     * one extract_integer_for_cast already did against long range. */
-    return mino_int(S, ll);
+    /* Keep the MINO_INT type even when the value falls outside the
+     * inline-tagged 61-bit range. mino_int would auto-promote to
+     * MINO_BIGINT in that band, which would then silently disable
+     * checked-arithmetic overflow on the coerced value. */
+    return mino_int_wrap(S, ll);
 }
 
 mino_val *prim_short(mino_state *S, mino_val *args, mino_env *env)

tests/numeric_edges_test.clj

@@ -41,6 +41,23 @@
   (is (= 9223372036854775807 (unchecked-long 9223372036854775807N)))
   (is (= -9223372036854775808 (unchecked-long -9223372036854775808N))))
 
+(deftest long-stays-fixnum-across-tag-boundary
+  ;; long must always produce a fixnum (:int), even when the value
+  ;; falls outside the inline-tagged 61-bit range. Promoting to bigint
+  ;; here would silently disable checked-arithmetic overflow on the
+  ;; result.
+  (is (= :int (type (long 5))))
+  (is (= :int (type (long 4611686018427387904))))
+  (is (= :int (type (long -4611686018427387904))))
+  (is (= :int (type (long 9223372036854775807))))
+  (is (= :int (type (long -9223372036854775808))))
+  ;; Bigint-shaped input that fits the long range coerces back to :int.
+  (is (= :int (type (long 4611686018427387904N))))
+  ;; Once coerced, downstream checked arithmetic must observe overflow
+  ;; rather than auto-promote.
+  (is (thrown? (* (long (/ -9223372036854775808 2)) 3)))
+  (is (thrown? (* 3 (long (/ -9223372036854775808 2))))))
+
 (deftest with-precision-basic
   (is (= 0.33333M (with-precision 5 (/ 1M 3M))))
   (is (= 0.667M (with-precision 3 (/ 2M 3M))))