jz 0.2.0 → 0.3.0

package/src/ctx.js

@@ -209,6 +209,7 @@ export function reset(proto, globals) {
   ctx.error = {
     src: '',
     loc: null,
+    node: null,
   }
 
   ctx.transform = {
@@ -259,15 +260,42 @@ export function reset(proto, globals) {
 
 /** Throw with source location context. */
 export function err(msg) {
+  let detail = msg
+
   if (ctx.error.loc != null && ctx.error.src) {
     const before = ctx.error.src.slice(0, ctx.error.loc)
     const line = before.split('\n').length
     const col = ctx.error.loc - before.lastIndexOf('\n')
     const src = ctx.error.src.split('\n')[line - 1]
-    const detail = `${msg}\n  at line ${line}:${col}\n  ${src}\n  ${' '.repeat(col - 1)}^`
-    const e = new Error(detail)
-    e.stack = `${e.name}: ${detail}\n${e.stack.split('\n').slice(1).join('\n')}`
-    throw e
+    detail += `\n  at line ${line}:${col}\n  ${src}\n  ${' '.repeat(col - 1)}^`
+  }
+
+  if (ctx.func.current?.name) {
+    detail += `\n  in function: ${ctx.func.current.name}`
+  }
+
+  if (ctx.error.node != null) {
+    detail += `\n  current AST: ${formatErrorNode(ctx.error.node)}`
   }
-  throw new Error(msg)
+
+  const e = new Error(detail)
+  const stackLines = e.stack.split('\n')
+  const firstFrame = stackLines.findIndex(line => line.trimStart().startsWith('at '))
+  const frames = firstFrame >= 0 ? stackLines.slice(firstFrame) : stackLines.slice(1)
+  e.stack = `${e.name}: ${detail}\n${frames.join('\n')}`
+  throw e
+}
+
+function formatErrorNode(node) {
+  const seen = new WeakSet()
+  const json = JSON.stringify(node, (_key, value) => {
+    if (typeof value === 'bigint') return `${value}n`
+    if (typeof value === 'symbol') return value.toString()
+    if (Array.isArray(value)) {
+      if (seen.has(value)) return '[Circular]'
+      seen.add(value)
+    }
+    return value
+  })
+  return json.length > 2000 ? `${json.slice(0, 2000)}...` : json
 }

package/src/emit.js

@@ -23,7 +23,13 @@
  */
 
 import { ctx, err, inc, PTR } from './ctx.js'
-import { T, VAL, valTypeOf, lookupValType, extractParams, classifyParam, findFreeVars, STMT_OPS, repOf, updateRep, repOfGlobal, staticPropertyKey } from './analyze.js'
+import { T, VAL, nonNegIntLiteral, valTypeOf, lookupValType, extractParams, classifyParam, findFreeVars, STMT_OPS, repOf, updateRep, repOfGlobal, staticPropertyKey } from './analyze.js'
+import {
+  isReassigned, hasOwnContinue, hasOwnBreakOrContinue, containsNestedClosure,
+  containsNestedLoop, nestedSmallLoopBudget, containsDeclOf, cloneWithSubst,
+  containsKnownTypedArrayIndex, smallConstForTripCount, isTerminator,
+  MAX_SMALL_FOR_UNROLL, MAX_NESTED_FOR_UNROLL,
+} from './ast.js'
 import {
   typed, asF64, asI32, asI64, asPtrOffset, asParamType, toI32, fromI64,
   NULL_IR, nullExpr, undefExpr, MAX_CLOSURE_ARITY,
@@ -168,11 +174,6 @@ function stringLiteral(node) {
   return null
 }
 
-function nonNegIntLiteral(node) {
-  const n = intLiteralValue(node)
-  return n != null && n >= 0 ? n : null
-}
-
 function emitSingleCharIndexCmp(a, b, negate = false) {
   const leftLit = stringLiteral(a)
   const rightLit = stringLiteral(b)
@@ -269,142 +270,6 @@ function extractRefinements(cond, out, sense = true) {
   return out
 }
 
-/** Detect whether `name` is written to (=, +=, ++, --, etc.) anywhere within `body`.
- *  Conservative over-reject: if unsure, treat as written.
- *  `let`/`const` declarations are NOT reassignments — only the initializer expressions
- *  inside them are scanned. (Treating `let g = ...` as a write of `g` would defeat A3.) */
-export function isReassigned(body, name) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === '=' || op === '+=' || op === '-=' || op === '*=' || op === '/=' || op === '%='
-      || op === '&=' || op === '|=' || op === '^=' || op === '<<=' || op === '>>=' || op === '>>>='
-      || op === '||=' || op === '&&=' || op === '??=') {
-    if (body[1] === name) return true
-  }
-  if ((op === '++' || op === '--') && body[1] === name) return true
-  if (op === 'let' || op === 'const') {
-    // Each decl item is either a bare name (string) or `['=', pattern, init]`.
-    // Only the init expression can contain real reassignments — recurse into it only.
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (Array.isArray(d) && d[0] === '=' && d[2] != null && isReassigned(d[2], name)) return true
-    }
-    return false
-  }
-  for (let i = 1; i < body.length; i++) if (isReassigned(body[i], name)) return true
-  return false
-}
-
-/** Does `body` contain a `continue` that targets THIS loop?
- *  A `continue` inside a nested `for`/`while`/`do` targets the inner loop, so we don't count it. */
-function hasOwnContinue(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'continue') return true
-  if (op === 'for' || op === 'while' || op === 'do') return false
-  for (let i = 1; i < body.length; i++) if (hasOwnContinue(body[i])) return true
-  return false
-}
-
-function hasOwnBreakOrContinue(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'break' || op === 'continue') return true
-  if (op === 'for' || op === 'while' || op === 'do' || op === '=>') return false
-  for (let i = 1; i < body.length; i++) if (hasOwnBreakOrContinue(body[i])) return true
-  return false
-}
-
-function containsNestedClosure(body) {
-  if (!Array.isArray(body)) return false
-  if (body[0] === '=>') return true
-  for (let i = 1; i < body.length; i++) if (containsNestedClosure(body[i])) return true
-  return false
-}
-
-function containsNestedLoop(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'for' || op === 'while' || op === 'do') return true
-  if (op === '=>') return false
-  for (let i = 1; i < body.length; i++) if (containsNestedLoop(body[i])) return true
-  return false
-}
-
-function nestedSmallLoopBudget(body) {
-  if (!Array.isArray(body)) return 1
-  if (body[0] === '=>') return 1
-  if (body[0] === 'for') {
-    const [, init, cond, step, loopBody] = body
-    const n = smallConstForTripCount(init, cond, step)
-    return n == null ? MAX_NESTED_FOR_UNROLL + 1 : n * nestedSmallLoopBudget(loopBody)
-  }
-  let max = 1
-  for (let i = 1; i < body.length; i++) max = Math.max(max, nestedSmallLoopBudget(body[i]))
-  return max
-}
-
-function containsDeclOf(body, name) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === '=>') return false
-  if (op === 'let' || op === 'const') {
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (d === name) return true
-      if (Array.isArray(d) && d[0] === '=' && d[1] === name) return true
-    }
-  }
-  for (let i = 1; i < body.length; i++) if (containsDeclOf(body[i], name)) return true
-  return false
-}
-
-function intLiteralValue(expr) {
-  let v = null
-  if (typeof expr === 'number') v = expr
-  else if (Array.isArray(expr) && expr[0] == null && typeof expr[1] === 'number') v = expr[1]
-  else if (Array.isArray(expr) && expr[0] === 'u-' && typeof expr[1] === 'number') v = -expr[1]
-  else if (typeof expr === 'string') v = repOf(expr)?.intConst ?? ctx.scope.constInts?.get(expr) ?? null
-  return v != null && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647 ? v : null
-}
-
-function cloneWithSubst(node, name, value) {
-  if (node === name) return [null, value]
-  if (!Array.isArray(node)) return node
-  if (node[0] === '=>') return node
-  return node.map(x => cloneWithSubst(x, name, value))
-}
-
-const MAX_SMALL_FOR_UNROLL = 8
-const MAX_NESTED_FOR_UNROLL = 64
-
-function containsKnownTypedArrayIndex(body) {
-  if (!Array.isArray(body)) return false
-  if (body[0] === '=>') return false
-  if (body[0] === '[]' && typeof body[1] === 'string' && ctx.types.typedElem?.has(body[1])) return true
-  for (let i = 1; i < body.length; i++) if (containsKnownTypedArrayIndex(body[i])) return true
-  return false
-}
-
-function smallConstForTripCount(init, cond, step) {
-  if (!Array.isArray(init) || init[0] !== 'let' || init.length !== 2) return null
-  const decl = init[1]
-  if (!Array.isArray(decl) || decl[0] !== '=' || typeof decl[1] !== 'string') return null
-  const name = decl[1]
-  const start = intLiteralValue(decl[2])
-  if (start !== 0) return null
-
-  if (!Array.isArray(cond) || cond[0] !== '<' || cond[1] !== name) return null
-  const end = intLiteralValue(cond[2])
-  if (end == null || end < 0 || end > MAX_SMALL_FOR_UNROLL) return null
-
-  const stepOk = Array.isArray(step) && (
-    (step[0] === '++' && step[1] === name) ||
-    (step[0] === '-' && Array.isArray(step[1]) && step[1][0] === '++' && step[1][1] === name && intLiteralValue(step[2]) === 1)
-  )
-  return stepOk ? end : null
-}
-
 function unrollSmallConstFor(init, cond, step, body) {
   const end = smallConstForTripCount(init, cond, step)
   if (end == null) return null
@@ -422,21 +287,23 @@ function unrollSmallConstFor(init, cond, step, body) {
   return out
 }
 
-/** Does `body` always exit the enclosing scope (return / throw / break / continue)?
- *  Used for early-return refinement: after `if (!guard) return`, `guard` holds for the rest. */
-function isTerminator(body) {
+function canThrow(body, seen = new Set()) {
   if (!Array.isArray(body)) return false
   const op = body[0]
-  if (op === 'return' || op === 'throw' || op === 'break' || op === 'continue') return true
-  // Block body: {} or ; — terminator if it ends with a terminator statement.
-  if (op === '{}' || op === ';') {
-    for (let i = body.length - 1; i >= 1; i--) {
-      const s = body[i]
-      if (s == null) continue
-      return isTerminator(s)
+  if (op === 'throw') return true
+  if (op === '=>') return false
+  if (op === '()') {
+    const callee = body[1]
+    if (typeof callee === 'string') {
+      const bodyName = ctx.func.directClosures?.get(callee)
+      const f = ctx.func.map?.get(bodyName || callee)
+      if (f?.body && !f.raw && !seen.has(f.name)) {
+        seen.add(f.name)
+        if (canThrow(f.body, seen)) return true
+      }
     }
-    return false
   }
+  for (let i = 1; i < body.length; i++) if (canThrow(body[i], seen)) return true
   return false
 }
 
@@ -867,6 +734,20 @@ const cmpOp = (i32op, f64op, fn) => (a, b) => {
     inc('__str_cmp')
     return typed([`i32.${i32op}`, ['call', '$__str_cmp', asI64(va), asI64(vb)], ['i32.const', 0]], 'i32')
   }
+  if (vta === VAL.DATE || vtb === VAL.DATE) {
+    const dateNum = (node, v, vt) => {
+      if (vt !== VAL.DATE) return toNumF64(node, v)
+      const ptr = v.ptrKind === VAL.DATE
+        ? v
+        : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+      return typed(['f64.load', ptr], 'f64')
+    }
+    return typed([`f64.${f64op}`, dateNum(a, va, vta), dateNum(b, vb, vtb)], 'i32')
+  }
+  if (vtb === VAL.NUMBER && needsRelationalToNumber(a, vta))
+    return typed([`f64.${f64op}`, toNumF64(a, va), asF64(vb)], 'i32')
+  if (vta === VAL.NUMBER && needsRelationalToNumber(b, vtb))
+    return typed([`f64.${f64op}`, asF64(va), toNumF64(b, vb)], 'i32')
   const ai = intConstValue(a), bi = intConstValue(b)
   if (va.type === 'i32' && bi != null) return typed([`i32.${i32op}`, va, ['i32.const', bi]], 'i32')
   if (vb.type === 'i32' && ai != null) return typed([`i32.${i32op}`, ['i32.const', ai], vb], 'i32')
@@ -874,6 +755,33 @@ const cmpOp = (i32op, f64op, fn) => (a, b) => {
     ? typed([`i32.${i32op}`, va, vb], 'i32') : typed([`f64.${f64op}`, asF64(va), asF64(vb)], 'i32')
 }
 
+function needsRelationalToNumber(expr, vt) {
+  if (vt === VAL.STRING) return true
+  if (vt != null) return false
+  return mayReadBoxedValue(expr)
+}
+
+function needsLooseEqualityToNumber(expr, vt) {
+  if (vt === VAL.STRING) return true
+  if (vt != null) return false
+  return mayReadBoxedValue(expr)
+}
+
+function looseNumberEq(numIR, otherNode, otherIR, negate = false) {
+  const t = temp('eq')
+  const other = typed(['local.get', `$${t}`], 'f64')
+  const cmp = ['f64.eq', asF64(numIR), toNumF64(otherNode, other)]
+  return typed(['block', ['result', 'i32'],
+    ['local.set', `$${t}`, asF64(otherIR)],
+    ['if', ['result', 'i32'], isNullish(other),
+      ['then', ['i32.const', negate ? 1 : 0]],
+      ['else', negate ? ['i32.eqz', cmp] : cmp]]], 'i32')
+}
+
+function mayReadBoxedValue(expr) {
+  return Array.isArray(expr) && (expr[0] === '.' || expr[0] === '[]' || expr[0] === '?.' || expr[0] === '?.[]')
+}
+
 function intConstValue(expr) {
   if (typeof expr === 'number' && Number.isInteger(expr)) return expr
   if (Array.isArray(expr) && expr[0] == null && typeof expr[1] === 'number' && Number.isInteger(expr[1])) return expr[1]
@@ -942,10 +850,7 @@ export const emitter = {
   ';': (...args) => {
     const out = []
     for (const a of args) {
-      const r = emit(a, 'void')
-      if (r == null) continue
-      out.push(...flat(r))
-      if (r?.type && r.type !== 'void') out.push('drop')
+      out.push(...emitFlat(a))
     }
     return out
   },
@@ -989,6 +894,8 @@ export const emitter = {
   },
 
   'catch': (body, errName, handler) => {
+    if (!canThrow(body)) return emitFlat(body)
+
     ctx.runtime.throws = true
     const id = ctx.func.uniq++
     ctx.func.locals.set(errName, 'f64')
@@ -1007,6 +914,14 @@ export const emitter = {
   },
 
   'finally': (body, cleanup) => {
+    if (!canThrow(body)) {
+      const parentStack = ctx.func.finallyStack || []
+      const activeStack = parentStack.concat([cleanup])
+      const bodyIR = withFinallyStack(activeStack, () => emitFlat(body))
+      const cleanupIR = isTerminator(body) ? [] : withFinallyStack(parentStack, () => emitFlat(cleanup))
+      return [...bodyIR, ...cleanupIR]
+    }
+
     ctx.runtime.throws = true
     const id = ctx.func.uniq++
     const errLocal = temp('err')
@@ -1036,13 +951,14 @@ export const emitter = {
 
   'return': expr => {
     const finalizers = emitFinalizers()
+    const finalizerBlock = () => [['block', ...finalizers]]
     if (ctx.func.current?.results.length > 1 && Array.isArray(expr) && expr[0] === '[') {
       const vals = expr.slice(1).map(e => asF64(emit(e)))
       if (finalizers.length === 0) return typed(['return', ...vals], 'void')
       const names = vals.map(() => temp('ret'))
       return [
         ...vals.map((v, i) => ['local.set', `$${names[i]}`, v]),
-        ...finalizers,
+        ...finalizerBlock(),
         typed(['return', ...names.map(n => ['local.get', `$${n}`])], 'void'),
       ]
     }
@@ -1058,7 +974,7 @@ export const emitter = {
       const name = ty === 'i32' ? tempI32('ret') : ty === 'i64' ? tempI64('ret') : temp('ret')
       return [
         ['local.set', `$${name}`, ir],
-        ...finalizers,
+        ...finalizerBlock(),
         typed(['return', ['local.get', `$${name}`]], 'void'),
       ]
     }
@@ -1330,6 +1246,8 @@ export const emitter = {
 
   // Compound assignments: read-modify-write with type coercion
   '+=': (name, val) => {
+    // Complex LHS (obj.prop, arr[i]) → desugar to side-effect-safe `name = name + val`
+    if (typeof name !== 'string') return emit(['=', name, ['+', name, val]])
     // String concatenation: desugar to name = name + val (+ handler knows about strings).
     // Also desugar when either side has unknown type — the `+` operator picks runtime
     // string/numeric dispatch (`__is_str_key`); compoundAssign would force f64.add and
@@ -1342,17 +1260,24 @@ export const emitter = {
   },
   ...Object.fromEntries([
     ['-=', 'sub'], ['*=', 'mul'], ['/=', 'div'],
-  ].map(([op, fn]) => [op, (name, val) => compoundAssign(name, val,
-    (a, b) => typed([`f64.${fn}`, a, b], 'f64'),
-    fn === 'div' ? null : (a, b) => typed([`i32.${fn}`, a, b], 'i32')
-  )])),
-  '%=': (name, val) => compoundAssign(name, val, f64rem, (a, b) => typed(['i32.rem_s', a, b], 'i32')),
+  ].map(([op, fn]) => [op, (name, val) => {
+    if (typeof name !== 'string') return emit(['=', name, [op.slice(0, -1), name, val]])
+    return compoundAssign(name, val,
+      (a, b) => typed([`f64.${fn}`, a, b], 'f64'),
+      fn === 'div' ? null : (a, b) => typed([`i32.${fn}`, a, b], 'i32')
+    )
+  }])),
+  '%=': (name, val) => {
+    if (typeof name !== 'string') return emit(['=', name, ['%', name, val]])
+    return compoundAssign(name, val, f64rem, (a, b) => typed(['i32.rem_s', a, b], 'i32'))
+  },
 
   // Bitwise compound assignments: i32 normally, i64 when either operand is BigInt
   ...Object.fromEntries([
     ['&=', 'and'], ['|=', 'or'], ['^=', 'xor'],
     ['>>=', 'shr_s'], ['<<=', 'shl'], ['>>>=', 'shr_u'],
   ].map(([op, fn]) => [op, (name, val) => {
+    if (typeof name !== 'string') return emit(['=', name, [op.slice(0, -1), name, val]])
     if (valTypeOf(name) === VAL.BIGINT || valTypeOf(val) === VAL.BIGINT) {
       const void_ = _expect === 'void'
       const result = fromI64([`i64.${fn}`, asI64(readVar(name)), asI64(emit(val))])
@@ -1542,6 +1467,8 @@ export const emitter = {
     // Catches `closureVar === 34` in jzified hot loops where the unknown side has no VAL.
     const vta = resolveValType(a, valTypeOf, lookupValType)
     const vtb = resolveValType(b, valTypeOf, lookupValType)
+    if (vta === VAL.NUMBER && needsLooseEqualityToNumber(b, vtb)) return looseNumberEq(va, b, vb)
+    if (vtb === VAL.NUMBER && needsLooseEqualityToNumber(a, vta)) return looseNumberEq(vb, a, va)
     if (vta === VAL.NUMBER || vtb === VAL.NUMBER) return typed(['f64.eq', asF64(va), asF64(vb)], 'i32')
     // Reference-equal pointer kinds (same kind, non-STRING, non-BIGINT): i64 bit equality.
     // JS `==` on objects/arrays/sets/maps/etc. is pure reference equality — no content path.
@@ -1569,6 +1496,8 @@ export const emitter = {
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.ne', va, vb], 'i32')
     const vta = resolveValType(a, valTypeOf, lookupValType)
     const vtb = resolveValType(b, valTypeOf, lookupValType)
+    if (vta === VAL.NUMBER && needsLooseEqualityToNumber(b, vtb)) return looseNumberEq(va, b, vb, true)
+    if (vtb === VAL.NUMBER && needsLooseEqualityToNumber(a, vta)) return looseNumberEq(vb, a, va, true)
     if (vta === VAL.NUMBER || vtb === VAL.NUMBER) return typed(['f64.ne', asF64(va), asF64(vb)], 'i32')
     if (vta && vta === vtb && REF_EQ_KINDS.has(vta)) {
       return typed(['i64.ne', ['i64.reinterpret_f64', asF64(va)], ['i64.reinterpret_f64', asF64(vb)]], 'i32')
@@ -2490,7 +2419,10 @@ function liftOptionalChain(node) {
  */
 export function emit(node, expect) {
   _expect = expect || null
-  if (Array.isArray(node) && node.loc != null) ctx.error.loc = node.loc
+  if (Array.isArray(node)) {
+    ctx.error.node = node
+    if (node.loc != null) ctx.error.loc = node.loc
+  }
   if (node == null) return null
   if (node === true) return typed(['i32.const', 1], 'i32')
   if (node === false) return typed(['i32.const', 0], 'i32')

package/src/host.js

@@ -607,6 +607,18 @@ const installDefaultEnvImports = (mod, imports, state) => {
     imports.env.now = (clock) =>
       clock === 1 ? (typeof performance !== 'undefined' ? performance.now() : Date.now()) : Date.now()
   }
+  if (envFns.has('parseFloat') && !imports.env.parseFloat) {
+    imports.env.parseFloat = (valBig) => {
+      const s = state.mem.read(i64ToF64(valBig))
+      return parseFloat(s)
+    }
+  }
+  if (envFns.has('parseInt') && !imports.env.parseInt) {
+    imports.env.parseInt = (valBig, radix) => {
+      const s = state.mem.read(i64ToF64(valBig))
+      return parseInt(s, radix || undefined)
+    }
+  }
   // host: 'js' timer wiring. Wasm calls env.setTimeout/clearTimeout; we drive
   // callbacks back via the exported __invoke_closure trampoline (state.invoke).
   // Each id maps to a cancel thunk so set/clear share state without tagging.

package/src/ir.js

@@ -347,6 +347,12 @@ export function toNumF64(node, v) {
   if (v.type === 'i32' || isLit(v)) return asF64(v)
   const vt = keyValType(node)
   if (vt === VAL.NUMBER || vt === VAL.BIGINT) return asF64(v)
+  if (vt === VAL.DATE) {
+    const ptr = v.ptrKind === VAL.DATE
+      ? v
+      : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+    return typed(['f64.load', ptr], 'f64')
+  }
   // intCertain locals: every reachable def is integer-valued, so the binding
   // never carries a NaN-boxed pointer — skip the __to_num wrapper.
   if (typeof node === 'string' && repOf(node)?.intCertain === true) return asF64(v)
@@ -682,6 +688,19 @@ export const flat = ir => {
  * Reconstruct arguments with spreads inserted at correct positions.
  * Example: normal=[a, c], spreads=[{pos:1, expr:arr}] → [a, __spread(arr), c]
  */
+/** Find the index of the first body-content child in a (func ...) WAT node.
+ *  Skips $name, (export …), (import …), (type …), (param …), (result …), (local …).  */
+export function findBodyStart(fn) {
+  for (let i = 2; i < fn.length; i++) {
+    const c = fn[i]
+    if (!Array.isArray(c)) continue
+    if (c[0] === 'export' || c[0] === 'import' || c[0] === 'type' ||
+        c[0] === 'param' || c[0] === 'result' || c[0] === 'local') continue
+    return i
+  }
+  return fn.length
+}
+
 export function reconstructArgsWithSpreads(normal, spreads) {
   const combined = []
   let normalIdx = 0