jz 0.3.0 → 0.4.0

package/module/object.js

@@ -32,7 +32,7 @@ export default (ctx) => {
       const merged = target ? ctx.schema.resolve(target) : null
       const schemaId = merged ? ctx.schema.idOf(target) : 0
       const cap = merged ? Math.max(1, merged.length) : 1
-      return mkPtrIR(PTR.OBJECT, schemaId, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', cap], ['i32.const', 8]])
+      return mkPtrIR(PTR.OBJECT, schemaId, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', cap]])
     }
 
     // Flatten comma-grouped props: [',', p1, p2] → [p1, p2]
@@ -82,7 +82,7 @@ export default (ctx) => {
     }
 
     const body = [
-      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)]]],
     ]
     for (let i = 0; i < values.length; i++)
       body.push(['f64.store', slotAddr(t, i), asF64(emit(values[i]))])
@@ -150,8 +150,9 @@ export default (ctx) => {
   }
 
   ctx.core.emit['Object.entries'] = (obj) => {
+    if (isHashTyped(obj)) return emitHashEntries(obj)
     const schema = resolveSchema(obj)
-    if (!schema) err('Object.entries requires object with known schema')
+    if (!schema) return emitRuntimeEntries(obj)
     const va = asF64(emit(obj))
     const n = schema.length
     const t = temp('oe'), pair = tempI32('op'), base = tempI32('eb')
@@ -160,7 +161,7 @@ export default (ctx) => {
       ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]]
     for (let i = 0; i < n; i++) {
       body.push(
-        ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2], ['i32.const', 8]]],
+        ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
         ['f64.store', slotAddr(pair, 0), emit(['str', schema[i]])],
         ['f64.store', slotAddr(pair, 1), ['f64.load', slotAddr(base, i)]],
         ['f64.store', slotAddr(out.local, i), mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])])
@@ -185,7 +186,7 @@ export default (ctx) => {
         updateRep(target, { schemaId })
         const t = tempI32('bx'), s = temp('bs')
         const body = [
-          ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, boxedSchema.length)], ['i32.const', 8]]],
+          ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, boxedSchema.length)]]],
           ['f64.store', ['local.get', `$${t}`], asF64(emit(target))],
         ]
         const sBase = tempI32('sb')
@@ -317,7 +318,7 @@ export default (ctx) => {
     const srcBase = tempI32('cb')
     const body = [
       ['local.set', `$${s}`, asF64(emit(proto))],
-      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, n)], ['i32.const', 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, n)]]],
       ['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]],
     ]
     // Copy all properties from proto
@@ -378,7 +379,7 @@ function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
   const ptr = temp('objp')
   const src = tempI32('osp')
 
-  const body = [['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]]]
+  const body = [['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)]]]]
 
   // Process props in order — later props override earlier (JS semantics)
   let srcF
@@ -462,6 +463,13 @@ function emitHashValues(obj) {
     hashValuesFromTemp(t)], 'f64')
 }
 
+function emitHashEntries(obj) {
+  const t = temp('he')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    hashEntriesFromTemp(t)], 'f64')
+}
+
 // Inline body of the HASH walk against an already-bound f64 local. Shared by
 // the static-HASH path and the runtime-dispatch path so both produce the same
 // IR shape from the same source — only difference is whether they enter from
@@ -520,6 +528,37 @@ function hashValuesFromTemp(t) {
     out.ptr]
 }
 
+function hashEntriesFromTemp(t) {
+  inc('__ptr_offset', '__cap', '__len', '__alloc_hdr')
+  const off = tempI32('heo'), cap = tempI32('hec'), n = tempI32('hen')
+  const i = tempI32('hei'), o = tempI32('hej'), slot = tempI32('hes'), pair = tempI32('hep')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'hea' })
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${n}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    out.init,
+    ['local.set', `$${off}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${cap}`, ['call', '$__cap', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['local.set', `$${o}`, ['i32.const', 0]],
+    ['block', `$ebrk${id}`, ['loop', `$eloop${id}`,
+      ['br_if', `$ebrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+      ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
+        ['i32.mul', ['local.get', `$${i}`], ['i32.const', 24]]]],
+      ['if', ['f64.ne', ['f64.load', ['local.get', `$${slot}`]], ['f64.const', 0]],
+        ['then',
+          ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+          ['f64.store', ['local.get', `$${pair}`],
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 8]]]],
+          ['f64.store', ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]],
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 16]]]],
+          elemStore(out.local, o, mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])),
+          ['local.set', `$${o}`, ['i32.add', ['local.get', `$${o}`], ['i32.const', 1]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$eloop${id}`]]],
+    out.ptr]
+}
+
 // Type-unknown receiver: bind the value, branch on ptr-type. HASH walks the
 // probe table; OBJECT loads the schema's key array (registered statically at
 // compile time or lazily at runtime by JSON.parse via __jp_schema_get); other
@@ -568,6 +607,26 @@ function emitRuntimeValues(obj) {
         ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
 }
 
+function emitRuntimeEntries(obj) {
+  inc('__ptr_type')
+  if (!ctx.scope.globals.has('__schema_tbl'))
+    ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  const t = temp('re'), tt = tempI32('ret')
+  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: 'ree' })
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['if', ['result', 'f64'],
+      ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.HASH]],
+      ['then', hashEntriesFromTemp(t)],
+      ['else', ['if', ['result', 'f64'],
+        ['i32.and',
+          ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.OBJECT]],
+          ['i32.ne', ['global.get', '$__schema_tbl'], ['i32.const', 0]]],
+        ['then', objectEntriesFromTemp(t)],
+        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
+}
+
 // Schema-keyed Object.keys: copy the schema's keys array (a jz Array of
 // STRINGs registered in __schema_tbl[sid]) into a fresh ARRAY so callers can
 // mutate without aliasing the schema substrate.
@@ -584,7 +643,7 @@ function objectKeysFromTemp(t) {
       ['i64.const', LAYOUT.OFFSET_MASK]]]],
     ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
     ['local.set', `$${out}`, ['call', '$__alloc_hdr',
-      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
     ['local.set', `$${i}`, ['i32.const', 0]],
     ['block', `$kbrk${id}`, ['loop', `$kloop${id}`,
       ['br_if', `$kbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
@@ -612,7 +671,7 @@ function objectValuesFromTemp(t) {
     ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
     ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
     ['local.set', `$${out}`, ['call', '$__alloc_hdr',
-      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
     ['local.set', `$${i}`, ['i32.const', 0]],
     ['block', `$ovbrk${id}`, ['loop', `$ovloop${id}`,
       ['br_if', `$ovbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
@@ -624,3 +683,39 @@ function objectValuesFromTemp(t) {
       ['br', `$ovloop${id}`]]],
     mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
 }
+
+function objectEntriesFromTemp(t) {
+  inc('__alloc_hdr', '__ptr_offset')
+  const sid = tempI32('oes'), src = tempI32('oesrc'), n = tempI32('oen')
+  const base = tempI32('oebase'), out = tempI32('oeo'), i = tempI32('oei'), pair = tempI32('oep')
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${sid}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+      ['i64.const', LAYOUT.AUX_MASK]]]],
+    ['local.set', `$${src}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.load', ['i32.add', ['global.get', '$__schema_tbl'], ['i32.shl', ['local.get', `$${sid}`], ['i32.const', 3]]]],
+      ['i64.const', LAYOUT.OFFSET_MASK]]]],
+    ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
+    ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${out}`, ['call', '$__alloc_hdr',
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['block', `$oebrk${id}`, ['loop', `$oeloop${id}`,
+      ['br_if', `$oebrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
+      ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+      ['i64.store',
+        ['local.get', `$${pair}`],
+        ['i64.load',
+          ['i32.add', ['local.get', `$${src}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]],
+        ['f64.load',
+          ['i32.add', ['local.get', `$${base}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${out}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]],
+        mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$oeloop${id}`]]],
+    mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
+}

package/module/string.js

@@ -752,12 +752,27 @@ export default (ctx) => {
       (br $next)))
     (f64.reinterpret_i64 (local.get $result)))`
 
+  // Empty separator: per JS spec, split into individual byte-chars
+  // ("abc".split("") -> ["a","b","c"], "".split("") -> []). Without this
+  // guard the main loop advances by plen=0 and spins forever.
   ctx.core.stdlib['__str_split'] = `(func $__str_split (param $str i64) (param $sep i64) (result f64)
     (local $slen i32) (local $plen i32) (local $count i32)
     (local $i i32) (local $j i32) (local $match i32)
     (local $arr i32) (local $piece_start i32) (local $piece_idx i32)
     (local.set $slen (call $__str_byteLen (local.get $str)))
     (local.set $plen (call $__str_byteLen (local.get $sep)))
+    (if (i32.eqz (local.get $plen)) (then
+      (local.set $arr (call $__alloc (i32.add (i32.const 8) (i32.shl (local.get $slen) (i32.const 3)))))
+      (i32.store (local.get $arr) (local.get $slen))
+      (i32.store (i32.add (local.get $arr) (i32.const 4)) (local.get $slen))
+      (local.set $arr (i32.add (local.get $arr) (i32.const 8)))
+      (block $de (loop $le
+        (br_if $de (i32.ge_s (local.get $i) (local.get $slen)))
+        (f64.store (i32.add (local.get $arr) (i32.shl (local.get $i) (i32.const 3)))
+          (call $__str_slice (local.get $str) (local.get $i) (i32.add (local.get $i) (i32.const 1))))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $le)))
+      (return (call $__mkptr (i32.const 1) (i32.const 0) (local.get $arr)))))
     (local.set $count (i32.const 1))
     (local.set $i (i32.const 0))
     (block $d1 (loop $l1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",
@@ -24,8 +24,11 @@
     "test262": "node test/test262.js",
     "test262:builtins": "node test/test262-builtins.js",
     "bench": "node bench/bench.mjs",
+    "bench:size": "node scripts/bench-size.mjs",
     "bench:compile": "node scripts/bench-compile.mjs",
-    "test:bench-pin": "node test/bench-pin.js"
+    "test:bench-pin": "node test/bench-pin.js",
+    "test:all": "npm test && npm run test:bench-pin",
+    "prepublishOnly": "npm run test:all"
   },
   "repository": {
     "type": "git",
@@ -38,8 +41,8 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.4.7",
-    "watr": "^4.5.3"
+    "subscript": "^10.4.8",
+    "watr": "^4.6.5"
   },
   "keywords": [
     "javascript",

package/src/analyze.js

@@ -37,9 +37,9 @@ export const STMT_OPS = new Set([';', 'let', 'const', 'return', 'if', 'for', 'fo
 export const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??='])
 
 /** Distinguish a function block body `{ ... }` from an expression-bodied object literal `({a:1})`.
- *  Both share the `'{}'` op tag; blocks have a non-`':'` first child (object literals start with key:val pairs). */
+ *  Both share the `'{}'` op tag; blocks start with statement ops, while object literals start with `:` or `...`. */
 export const isBlockBody = (body) =>
-  Array.isArray(body) && body[0] === '{}' && body[1]?.[0] !== ':'
+  Array.isArray(body) && body[0] === '{}' && (body.length === 1 || STMT_OPS.has(body[1]?.[0]))
 
 /** Extract integer value from AST literal node. Returns null if not a 32-bit integer. */
 export function intLiteralValue(expr) {

package/src/assemble.js

@@ -14,6 +14,25 @@
 
 import { parse as parseWat } from 'watr'
 import { ctx, inc, resolveIncludes, PTR, LAYOUT } from './ctx.js'
+
+// Stdlib WAT templates are fixed text (or feature-keyed text from a factory) —
+// `parseWat` of the same string always yields the same tree. Parsing is the
+// dominant cost when a program pulls heavy stdlib (Math pow/sqrt, JSON, regex):
+// it re-tokenizes ~KB of text every compile. Parse once per distinct resolved
+// string, then hand out a deep clone (downstream passes mutate nodes in place).
+// Module-level on purpose: the cache persists across compile() calls.
+const stdlibParseCache = new Map()  // resolved WAT string → pristine parsed tree
+const cloneTemplate = (node) => {
+  if (!Array.isArray(node)) return node
+  const copy = node.map(cloneTemplate)
+  if (node.loc != null) copy.loc = node.loc
+  return copy
+}
+const parseTemplate = (str) => {
+  let tmpl = stdlibParseCache.get(str)
+  if (tmpl === undefined) stdlibParseCache.set(str, tmpl = parseWat(str))
+  return cloneTemplate(tmpl)
+}
 import { T, VAL, analyzeValTypes } from './analyze.js'
 import { optimizeFunc, hoistConstantPool, specializeMkptr, specializePtrBase, sortStrPoolByFreq, arenaRewindModule } from './optimize.js'
 import { emit } from './emit.js'
@@ -36,7 +55,7 @@ const heapSetIR = value => ctx.memory.shared
   : ['global.set', '$__heap', value]
 
 const ARENA_SAFE_CALLS = new Set([
-  '$__alloc', '$__alloc_hdr', '$__mkptr',
+  '$__alloc', '$__alloc_hdr', '$__alloc_hdr_n', '$__mkptr',
   '$__ptr_offset', '$__ptr_type', '$__ptr_aux',
   '$__len', '$__cap', '$__typed_shift', '$__typed_data',
 ])
@@ -60,7 +79,7 @@ function applyArenaRewind(func, fn, safeCallees) {
     }
     if (op === 'call') {
       const name = node[1]
-      if (name === '$__alloc' || name === '$__alloc_hdr') hasAlloc = true
+      if (name === '$__alloc' || name === '$__alloc_hdr' || name === '$__alloc_hdr_n') hasAlloc = true
       if (!(safeCallees ?? ARENA_SAFE_CALLS).has(name)) {
         unsafe = true
         return
@@ -154,7 +173,7 @@ export function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
     for (const [name, { schemaId, schema }] of ctx.schema.autoBox) {
       inc('__alloc_hdr', '__mkptr')
       boxInit.push(
-        ['local.set', `$${bt}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
+        ['local.set', `$${bt}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)]]],
         ['f64.store', ['local.get', `$${bt}`],
           ctx.func.names.has(name) ? ['f64.const', 0] : ['global.get', `$${name}`]],
         ...schema.slice(1).map((_, i) =>
@@ -195,7 +214,7 @@ export function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
       const keys = ctx.schema.list[s]
       const n = keys.length
       schemaInit.push(
-        ['local.set', `$${sarr}`, ['call', '$__alloc_hdr', ['i32.const', n], ['i32.const', n], ['i32.const', 8]]])
+        ['local.set', `$${sarr}`, ['call', '$__alloc_hdr', ['i32.const', n], ['i32.const', n]]])
       for (let k = 0; k < n; k++)
         schemaInit.push(
           ['f64.store', ['i32.add', ['local.get', `$${sarr}`], ['i32.const', k * 8]],
@@ -384,7 +403,7 @@ export function pullStdlib(sec) {
     if (ctx.memory.shared) sec.imports.push(['import', '"env"', '"memory"', ['memory', pages]])
     else sec.memory.push(['memory', ['export', '"memory"'], pages])
     if (ctx.transform.alloc !== false && ctx.core._allocRawFuncs)
-      sec.funcs.push(...ctx.core._allocRawFuncs.map(s => parseWat(s)))
+      sec.funcs.push(...ctx.core._allocRawFuncs.map(parseTemplate))
   }
 
   const stdlibStr = (name) => {
@@ -394,14 +413,14 @@ export function pullStdlib(sec) {
   ctx.core.extImports ??= new Set()
   for (const name of Object.keys(ctx.core.stdlib)) {
     if (name.startsWith('__ext_') && ctx.core.includes.has(name)) {
-      const parsed = parseWat(stdlibStr(name))
+      const parsed = parseTemplate(stdlibStr(name))
       sec.extStdlib.push(parsed[0] === "module" ? parsed[1] : parsed)
       ctx.core.extImports.add(name)
       ctx.core.includes.delete(name)
     }
   }
   for (const n of ctx.core.includes) if (!ctx.core.stdlib[n]) console.error("MISSING stdlib:", n)
-  sec.stdlib.push(...[...ctx.core.includes].map(n => parseWat(stdlibStr(n))))
+  sec.stdlib.push(...[...ctx.core.includes].map(n => parseTemplate(stdlibStr(n))))
 }
 
 export function syncImports(sec) {
@@ -449,7 +468,11 @@ export function optimizeModule(sec) {
     }
   }
   if (!cfg || cfg.hoistConstantPool !== false)
-    hoistConstantPool([...sec.funcs, ...sec.stdlib, ...sec.start], (name, wat) => ctx.scope.globals.set(name, wat))
+    hoistConstantPool([...sec.funcs, ...sec.stdlib, ...sec.start], (name, wat) => {
+      ctx.scope.globals.set(name, wat)
+      const m = wat.match(/\(global\s+\$?\S+\s+(?:\(mut\s+)?(i32|i64|f64|f32)/)
+      if (m) ctx.scope.globalTypes.set(name, m[1])
+    })
 
   // Second promoteGlobals pass disabled: promoting hoistConstantPool's __fc*
   // globals regressed the watr perf micro-pin (WASM compile time increased).

package/src/codegen.js

@@ -0,0 +1,177 @@
+/**
+ * AST → jz source codegen.
+ *
+ * Pretty-prints a jzify-transformed AST back to jz source text. CLI-only
+ * (`jz jzify file.js` → `file.jz`); the compile path consumes the AST directly
+ * and never round-trips through source.
+ *
+ * @module codegen
+ */
+
+const INDENT = '  '
+const prec = { '=': 1, '+=': 1, '-=': 1, '*=': 1, '/=': 1, '%=': 1, '&=': 1, '|=': 1, '^=': 1, '>>=': 1, '<<=': 1, '>>>=': 1, '||=': 1, '&&=': 1,
+  '??': 2, '||': 3, '&&': 4, '|': 5, '^': 6, '&': 7, '===': 8, '!==': 8, '==': 8, '!=': 8,
+  '<': 9, '>': 9, '<=': 9, '>=': 9, '<<': 10, '>>': 10, '>>>': 10,
+  '+': 11, '-': 11, '*': 12, '/': 12, '%': 12, '**': 13 }
+
+/** Wrap statement in { } if not already a block */
+function wrapBlock(node, depth) {
+  if (Array.isArray(node) && node[0] === '{}') return codegen(node, depth)
+  return '{ ' + codegen(node, depth) + '; }'
+}
+
+/** Generate jz source from AST. Enforces semicolons. */
+export function codegen(node, depth = 0) {
+  if (node == null) return ''
+  if (typeof node === 'number') return String(node)
+  if (typeof node === 'bigint') return node + 'n'
+  if (typeof node === 'string') return node
+  if (!Array.isArray(node)) return String(node)
+
+  const [op, ...a] = node
+  const ind = INDENT.repeat(depth), ind1 = INDENT.repeat(depth + 1)
+
+  // Literal: [, value]
+  if (op == null) return typeof a[0] === 'string' ? JSON.stringify(a[0]) : a[0] == null ? 'null' : String(a[0]) + (typeof a[0] === 'bigint' ? 'n' : '')
+
+  // Statements
+  if (op === ';') return a.map(s => codegen(s, depth)).filter(Boolean).join(';\n' + ind) + ';'
+  if (op === '{}') {
+    // Discriminate object literal / destructuring pattern from block.
+    // Object: `:` key-value, `,` of object-pattern items (id / `:` / `...` / `= default`),
+    //         lone string shorthand. Empty `{}` outputs the same string either way.
+    const body = a[0]
+    const isObjItem = (n) => typeof n === 'string' ||
+      (Array.isArray(n) && (n[0] === ':' || n[0] === '...' || n[0] === 'as' ||
+        (n[0] === '=' && typeof n[1] === 'string')))
+    const isObj = body == null ? false
+      : typeof body === 'string' ? true
+      : Array.isArray(body) && (body[0] === ':' || body[0] === '...' || body[0] === 'as' ||
+          (body[0] === ',' && body.slice(1).every(isObjItem)))
+    if (isObj) {
+      if (typeof body === 'string') return '{ ' + body + ' }'
+      if (body[0] === ',') return '{ ' + body.slice(1).map(x => codegen(x)).join(', ') + ' }'
+      return '{ ' + codegen(body) + ' }'
+    }
+    // Block: body is null, a single statement, or [';', ...stmts]
+    const stmts = body == null ? [] : (Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body])
+    const rendered = stmts.map(s => codegen(s, depth + 1)).filter(Boolean).join(';\n' + ind1)
+    return '{\n' + ind1 + rendered + (rendered ? ';' : '') + '\n' + ind + '}'
+  }
+
+  // Declarations
+  if (op === 'let' || op === 'const') return op + ' ' + a.map(d => codegen(d, depth)).join(', ')
+  if (op === 'export') { const inner = codegen(a[0], depth); return inner ? 'export ' + inner : '' }
+  if (op === 'default') return 'default ' + codegen(a[0], depth)
+
+  // Control flow
+  if (op === 'if') {
+    const cond = codegen(a[0]), then = wrapBlock(a[1], depth)
+    return a[2] != null
+      ? 'if (' + cond + ') ' + then + ' else ' + wrapBlock(a[2], depth)
+      : 'if (' + cond + ') ' + then
+  }
+  if (op === 'while') return 'while (' + codegen(a[0]) + ') ' + wrapBlock(a[1], depth)
+  if (op === 'for') {
+    if (a.length === 2) { // ['for', head, body] — subscript shape
+      const [head, body] = a
+      if (Array.isArray(head) && (head[0] === 'of' || head[0] === 'in'))
+        return 'for (' + codegen(head[1]) + ' ' + head[0] + ' ' + codegen(head[2]) + ') ' + wrapBlock(body, depth)
+      // ['let'/'const', ['in'/'of', name, obj]] — subscript wraps var→let around in/of
+      if (Array.isArray(head) && (head[0] === 'let' || head[0] === 'const') && Array.isArray(head[1]) && (head[1][0] === 'in' || head[1][0] === 'of'))
+        return 'for (' + head[0] + ' ' + codegen(head[1][1]) + ' ' + head[1][0] + ' ' + codegen(head[1][2]) + ') ' + wrapBlock(body, depth)
+      // C-style head [';', init, cond, update] is positional — empty slots are valid,
+      // must not flow through the generic `;` joiner (which adds newlines + a trailing `;`).
+      if (Array.isArray(head) && head[0] === ';')
+        return 'for (' + (head[1] == null ? '' : codegen(head[1])) + '; ' + (head[2] == null ? '' : codegen(head[2])) + '; ' + (head[3] == null ? '' : codegen(head[3])) + ') ' + wrapBlock(body, depth)
+      return 'for (' + codegen(head) + ') ' + wrapBlock(body, depth)
+    }
+    return 'for (' + (codegen(a[0]) || '') + '; ' + (codegen(a[1]) || '') + '; ' + (codegen(a[2]) || '') + ') ' + wrapBlock(a[3], depth)
+  }
+  if (op === 'return') return 'return ' + codegen(a[0])
+  if (op === 'throw') return 'throw ' + codegen(a[0])
+  if (op === 'break') return 'break'
+  if (op === 'continue') return 'continue'
+  // catch with optional binding: ['catch', tryBlock, catchBody] or ['catch', tryBlock, paramName, catchBody]
+  if (op === 'catch') {
+    if (a.length === 3) return 'try ' + codegen(a[0], depth) + ' catch (' + a[1] + ') ' + codegen(a[2], depth)
+    return 'try ' + codegen(a[0], depth) + ' catch ' + codegen(a[1], depth)
+  }
+
+  // Arrow
+  if (op === '=>') {
+    // Params: already wrapped in () by parser, or bare name
+    const p = a[0]
+    const params = Array.isArray(p) && p[0] === '()' ? codegen(p) : '(' + codegen(p) + ')'
+    const body = a[1]
+    const isBlock = Array.isArray(body) && (body[0] === '{}' || body[0] === ';' || body[0] === 'return')
+    const bodyStr = Array.isArray(body) && body[0] !== '{}' && isBlock
+      ? '{ ' + codegen(body, depth) + '; }'
+      : codegen(body, depth)
+    return params + ' => ' + bodyStr
+  }
+
+  // Grouping parens / function call
+  if (op === '()') {
+    if (a.length === 1) return '(' + (a[0] == null ? '' : codegen(a[0])) + ')'
+    return codegen(a[0]) + '(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
+  }
+
+  // Property access
+  if (op === '.') return codegen(a[0]) + '.' + a[1]
+  if (op === '?.') return codegen(a[0]) + '?.' + a[1]
+  if (op === '?.[]') return codegen(a[0]) + '?.[' + codegen(a[1]) + ']'
+  if (op === '?.()') return codegen(a[0]) + '?.(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
+  if (op === '[]') {
+    // Array literal: ['[]', body] (length 2 → a.length 1). body may be null (empty),
+    // a single element, or a [',', ...items] sequence.
+    if (a.length === 1) {
+      if (a[0] == null) return '[]'
+      const body = a[0]
+      if (Array.isArray(body) && body[0] === ',') return '[' + body.slice(1).map(x => codegen(x)).join(', ') + ']'
+      return '[' + codegen(body) + ']'
+    }
+    // Subscript: ['[]', obj, idx]
+    return codegen(a[0]) + '[' + codegen(a[1]) + ']'
+  }
+  if (op === ':') return codegen(a[0]) + ': ' + codegen(a[1])
+  if (op === 'str') return JSON.stringify(a[0])
+  if (op === '//') return '/' + a[0] + '/' + (a[1] || '')
+
+  // Comma
+  if (op === ',') return a.map(x => codegen(x)).join(', ')
+  // Template literal: alternating string/expr parts. String parts are [null, "str"], expr parts are AST nodes.
+  if (op === '`') return '`' + a.map(p => {
+    if (Array.isArray(p) && p[0] == null && typeof p[1] === 'string') return p[1].replace(/[`\\$]/g, c => '\\' + c)
+    return '${' + codegen(p) + '}'
+  }).join('') + '`'
+
+  // Spread
+  if (op === '...') return '...' + codegen(a[0])
+
+  // Import / export rename
+  if (op === 'import') return 'import ' + codegen(a[0])
+  if (op === 'from') return codegen(a[0]) + ' from ' + codegen(a[1])
+  if (op === 'as') return codegen(a[0]) + ' as ' + codegen(a[1])
+
+  // Unary prefix
+  if (a.length === 1) {
+    if (op === '++' || op === '--') return a[0] == null ? op : op + codegen(a[0])
+    if (op === 'typeof') return 'typeof ' + codegen(a[0])
+    if (op === 'u-') return '-' + codegen(a[0])
+    if (op === 'u+') return '+' + codegen(a[0])
+    return op + codegen(a[0])
+  }
+
+  // Postfix
+  if (a.length === 2 && a[1] === null) return codegen(a[0]) + op
+
+  // Binary
+  if (a.length === 2 && prec[op]) return codegen(a[0]) + ' ' + op + ' ' + codegen(a[1])
+
+  // Ternary
+  if (op === '?' || op === '?:') return codegen(a[0]) + ' ? ' + codegen(a[1]) + ' : ' + codegen(a[2])
+
+  // Fallback
+  return op + '(' + a.map(x => codegen(x)).join(', ') + ')'
+}

package/src/compile.js

@@ -31,6 +31,7 @@ import {
   T, VAL, analyzeValTypes, analyzeIntCertain, analyzeLocals,
   analyzePtrUnboxable, typedElemAux, invalidateLocalsCache,
   analyzeBoxedCaptures, updateRep, inferStringParams,
+  isBlockBody,
 } from './analyze.js'
 import { optimizeFunc, treeshake } from './optimize.js'
 import { emit, emitter, emitFlat, emitBody } from './emit.js'
@@ -138,6 +139,17 @@ const tcoTailRewrite = (ir, resultType) => {
   return ir
 }
 
+const ensureThrowRuntime = (sec) => {
+  if (!ctx.runtime.throws) return
+
+  if (!ctx.scope.globals.has('__jz_last_err_bits'))
+    ctx.scope.globals.set('__jz_last_err_bits', '(global $__jz_last_err_bits (mut i64) (i64.const 0))')
+  if (!sec.tags.some(t => Array.isArray(t) && t[0] === 'tag' && t[1] === '$__jz_err'))
+    sec.tags.push(['tag', '$__jz_err', ['param', 'f64']])
+  if (!sec.tags.some(t => Array.isArray(t) && t[0] === 'export' && t[1] === '"__jz_last_err_bits"'))
+    sec.tags.push(['export', '"__jz_last_err_bits"', ['global', '$__jz_last_err_bits']])
+}
+
 // === Module compilation ===
 
 const cloneRepMap = map => map ? new Map([...map].map(([k, v]) => [k, { ...v }])) : null
@@ -158,7 +170,7 @@ function analyzeFuncForEmit(func, programFacts) {
   const { name, body, sig } = func
   enterFunc(func)
 
-  const block = Array.isArray(body) && body[0] === '{}' && body[1]?.[0] !== ':'
+  const block = isBlockBody(body)
   ctx.func.boxed = new Map()
   ctx.func.repByLocal = null
   ctx.types.typedElem = ctx.scope.globalTypedElem ? new Map(ctx.scope.globalTypedElem) : null
@@ -375,7 +387,8 @@ function emitFunc(func, funcFacts, programFacts) {
  *
  * Result rebox cases (then reinterpret to i64 at the boundary):
  *   - sig.ptrKind != null  → mkPtrIR(ptrKind, ptrAux ?? 0, callIR)
- *   - sig.results[0] = i32 → f64.convert_i32_s(callIR)
+ *   - sig.results[0] = i32 → f64.convert_i32_s(callIR), or `_u` when
+ *                            sig.unsignedResult (preserves `(x >>> 0)` ∈ [0, 2³²))
  *   - sig.results[0] = f64 → callIR (some params narrowed but result stayed f64)
  */
 function synthesizeBoundaryWrappers() {
@@ -408,7 +421,7 @@ function synthesizeBoundaryWrappers() {
       const ptrType = valKindToPtr(sig.ptrKind)
       body = mkPtrIR(ptrType, sig.ptrAux ?? 0, callIR)
     } else if (sig.results[0] === 'i32') {
-      body = ['f64.convert_i32_s', callIR]
+      body = [sig.unsignedResult ? 'f64.convert_i32_u' : 'f64.convert_i32_s', callIR]
     } else {
       body = callIR
     }
@@ -485,7 +498,7 @@ function emitClosureBody(cb) {
   }
 
   // Emit body
-  const block = Array.isArray(cb.body) && cb.body[0] === '{}' && cb.body[1]?.[0] !== ':'
+  const block = isBlockBody(cb.body)
   let bodyIR
   if (block) {
     invalidateLocalsCache(cb.body)
@@ -612,7 +625,7 @@ function emitClosureBody(cb) {
       ['then', ['local.set', `$${restLen}`, ['i32.const', restSlots]]]])
     fn.push(['local.set', `$${restOff}`,
       ['call', '$__alloc_hdr',
-        ['local.get', `$${restLen}`], ['local.get', `$${restLen}`], ['i32.const', 8]]])
+        ['local.get', `$${restLen}`], ['local.get', `$${restLen}`]]])
     for (let i = 0; i < restSlots; i++) {
       fn.push(['if', ['i32.gt_s', ['local.get', `$${restLen}`], ['i32.const', i]],
         ['then', ['f64.store',
@@ -775,12 +788,6 @@ export default function compile(ast, profiler) {
 
   // Memory section deferred — emitted after resolveIncludes() when __alloc is needed
 
-  if (ctx.runtime.throws) {
-    ctx.scope.globals.set('__jz_last_err_bits', '(global $__jz_last_err_bits (mut i64) (i64.const 0))')
-    sec.tags.push(['tag', '$__jz_err', ['param', 'f64']])
-    sec.tags.push(['export', '"__jz_last_err_bits"', ['global', '$__jz_last_err_bits']])
-  }
-
   if (ctx.closure.table?.length)
     sec.table.push(['table', ['export', '"__jz_table"'], ctx.closure.table.length, 'funcref'])
 
@@ -829,6 +836,8 @@ export default function compile(ast, profiler) {
 
   optimizeModule(sec)
 
+  ensureThrowRuntime(sec)
+
   // Populate globals (after __start — const folding may update declarations)
   sec.globals.push(...[...ctx.scope.globals.values()].filter(g => g).map(g => parseWat(g)))
 
@@ -918,7 +927,7 @@ export default function compile(ast, profiler) {
   const { callCount } = treeshake(
     [{ arr: sec.stdlib }, { arr: sec.funcs }, { arr: sec.start }],
     [...sec.start, ...sec.elem, ...sec.customs, ...sec.extStdlib, ...sec.imports],
-    { removeDead: !optCfg || optCfg.treeshake !== false }
+    { removeDead: !optCfg || optCfg.treeshake !== false, globals: sec.globals }
   )
 
   // Reorder non-import funcs by call count: hot callees get low LEB128 indices.