jz 0.7.0 → 0.8.1

package/src/kind-traits.js

@@ -5,9 +5,13 @@
 
 import { VAL } from './reps.js'
 
-export const BOOL_OPS = new Set([
-  '!', '<', '<=', '>', '>=', '==', '!=', '===', '!==', 'in', 'instanceof',
-])
+// Comparison / logical-not ops — result is a 0|1 boolean carried as i32. The one
+// source of truth for "this operator yields a boolean": valTypeOf reads it as
+// VAL.BOOL, exprType/isIntExpr read it as integer-certain. `in`/`instanceof` also
+// yield a boolean but are membership ops, kept out of the integer-certainty set
+// (they throw on BigInt operands and never reach numeric analysis).
+export const CMP_OPS = new Set(['!', '<', '<=', '>', '>=', '==', '!=', '===', '!=='])
+export const BOOL_OPS = new Set([...CMP_OPS, 'in', 'instanceof'])
 
 export const NUMERIC_BINARY_OPS = ['-', 'u-', '*', '/', '%', '&', '|', '^', '<<', '>>']
 export const NUMERIC_UNARY_OPS = new Set(['**', '++', '--', '~', '>>>', 'u+'])

package/src/kind.js

@@ -137,7 +137,16 @@ VT['?:'] = (args) => {
   const truthy = literalTruthiness(args[0])
   if (truthy != null) return valTypeOf(truthy ? args[1] : args[2])
   const ta = valTypeOf(args[1]), tb = valTypeOf(args[2])
-  return ta && ta === tb ? ta : null
+  if (ta && ta === tb) return ta
+  // A boolean branch coerces to 0/1 in numeric context (same rule as &&/||/?? below):
+  // when the other branch has a known non-boolean type, the conditional carries it.
+  // Without this, `num + (cond ? num : num>k)` sees a null-typed operand and emits the
+  // polymorphic string-concat dispatch on two pure-numeric subexprs — which pins the
+  // whole number→string formatter (__str_concat → __to_str → __static_str), a pure-int
+  // program ballooning 1 → ~19 funcs (see test/wat-invariants.js, .work/todo.md).
+  if (ta === VAL.BOOL && tb && tb !== VAL.BOOL) return tb
+  if (tb === VAL.BOOL && ta && ta !== VAL.BOOL) return ta
+  return null
 }
 
 // Value-preserving logical: `&&`/`||` return one of their operands.
@@ -162,6 +171,10 @@ VT['&&'] = VT['||'] = VT['??'] = (args) => {
 // Index access:  `arr[i]` → ['[]', arr, i].
 VT['[]'] = (args) => {
   if (args.length < 2) return VAL.ARRAY
+  // A literal NEGATIVE index is always out of range → reads undefined, not the
+  // element type. Returning a numeric elem type here would let `a[-1] === undefined`
+  // fold to false (a NUMBER can't be undefined), silently dropping the guard.
+  { const li = intLiteralValue(args[1]); if (li != null && li < 0) return null }
   // SRoA flat-array slot read: `a[k]` (static index) where `a` dissolved into
   // scalar `a#i` locals (scanFlatObjects). A write-once slot's value-type is its
   // element literal's — same numeric-binding as the `VT['.']` object case, so

package/src/op-policy.js

@@ -22,7 +22,10 @@ export const REJECT_OPS = {
 }
 
 /** Bare identifiers prepare rejects (no jzify lowering). */
-export const REJECT_IDENTS = {
+// Prototype-less (Object.create(null)): a plain `{}` inherits Object.prototype in V8, so
+// `REJECT_IDENTS['valueOf']` would return the inherited method (truthy) and wrongly reject
+// a user identifier named like an Object method. Kernel objects are already prototype-less.
+export const REJECT_IDENTS = Object.assign(Object.create(null), {
   with: '`with` not supported',
   class: '`class` not supported',
   yield: '`yield` not supported',
@@ -36,7 +39,7 @@ export const REJECT_IDENTS = {
   // identifier in sloppy JS (`var let = 5`), so rejecting it would refuse valid JS
   // (test262 language/expressions/object/let-non-strict-*).
   const: '`const` is a reserved word, not a valid name',
-}
+})
 
 /** jzify-only errors for class lowering (no prepare counterpart). */
 export const JZIFY_CLASS_ERRORS = {

package/src/ops.js

@@ -0,0 +1,119 @@
+// === AST op tags — integer-tagged-union representation ===
+// internOps (prepare->compile boundary) converts array node[0] from op STRING to its
+// integer tag; the compile half then dispatches via integer-keyed (eventually array)
+// tables, removing the per-node string-hash lookup in the self-host kernel.
+// OP: string -> int (1-based; 0 reserved => a missing tag is falsy). OPS: int -> string.
+export const OP = {
+  "!": 1,
+  "!=": 2,
+  "!==": 3,
+  "%": 4,
+  "%=": 5,
+  "&": 6,
+  "&&": 7,
+  "&&=": 8,
+  "&=": 9,
+  "(": 10,
+  "()": 11,
+  "*": 12,
+  "**": 13,
+  "*=": 14,
+  "+": 15,
+  "++": 16,
+  "+=": 17,
+  ",": 18,
+  "-": 19,
+  "--": 20,
+  "-=": 21,
+  ".": 22,
+  "...": 23,
+  "/": 24,
+  "//": 25,
+  "/=": 26,
+  ";": 27,
+  "<": 28,
+  "<<": 29,
+  "<<=": 30,
+  "<=": 31,
+  "=": 32,
+  "==": 33,
+  "===": 34,
+  "=>": 35,
+  ">": 36,
+  ">=": 37,
+  ">>": 38,
+  ">>=": 39,
+  ">>>": 40,
+  ">>>=": 41,
+  "?": 42,
+  "?:": 43,
+  "??": 44,
+  "??=": 45,
+  "[": 46,
+  "[]": 47,
+  "^": 48,
+  "^=": 49,
+  "async": 50,
+  "await": 51,
+  "bigint": 52,
+  "block": 53,
+  "bool": 54,
+  "break": 55,
+  "call": 56,
+  "catch": 57,
+  "const": 58,
+  "continue": 59,
+  "default": 60,
+  "delete": 61,
+  "export": 62,
+  "finally": 63,
+  "for": 64,
+  "if": 65,
+  "import": 66,
+  "in": 67,
+  "instanceof": 68,
+  "label": 69,
+  "let": 70,
+  "nan": 71,
+  "new": 72,
+  "return": 73,
+  "spread": 74,
+  "str": 75,
+  "strcat": 76,
+  "switch": 77,
+  "throw": 78,
+  "typeof": 79,
+  "u+": 80,
+  "u-": 81,
+  "void": 82,
+  "while": 83,
+  "yield": 84,
+  "{": 85,
+  "{}": 86,
+  "|": 87,
+  "|=": 88,
+  "||": 89,
+  "||=": 90,
+  "~": 91,
+}
+export const OPS = [null, "!", "!=", "!==", "%", "%=", "&", "&&", "&&=", "&=", "(", "()", "*", "**", "*=", "+", "++", "+=", ",", "-", "--", "-=", ".", "...", "/", "//", "/=", ";", "<", "<<", "<<=", "<=", "=", "==", "===", "=>", ">", ">=", ">>", ">>=", ">>>", ">>>=", "?", "?:", "??", "??=", "[", "[]", "^", "^=", "async", "await", "bigint", "block", "bool", "break", "call", "catch", "const", "continue", "default", "delete", "export", "finally", "for", "if", "import", "in", "instanceof", "label", "let", "nan", "new", "return", "spread", "str", "strcat", "switch", "throw", "typeof", "u+", "u-", "void", "while", "yield", "{", "{}", "|", "|=", "||", "||=", "~"]
+export const OP_COUNT = 92
+
+// Normalize an op tag to its string form for op-Set membership / switch checks,
+// so `SET.has(opStr(node[0]))` and `switch (opStr(op))` work whether node[0] is
+// still a string (intern off / non-interned op like ':') or an integer (intern
+// on). Self-host-safe: the typeof guard avoids indexing the OPS array by a string
+// (jz arrays trap on non-integer indices), and it never grows a Set.
+export const opStr = (op) => typeof op === "number" ? OPS[op] : op
+
+// Convert array node[0] from op-STRING to integer tag, recursively. Once per node at
+// the prepare boundary. Unknown op-strings stay strings (dual-keyed tables handle them
+// until the int-only phase). node[0]===null (numeric literal) stays null; identifiers
+// (bare strings at n[1+]) untouched.
+export const internOps = (n) => {
+  if (!Array.isArray(n)) return n
+  const t = n[0]
+  if (typeof t === "string") { const id = OP[t]; if (id !== undefined) n[0] = id }
+  for (let i = 1; i < n.length; i++) if (Array.isArray(n[i])) internOps(n[i])
+  return n
+}