jz 0.3.1 → 0.5.0

package/src/assemble.js

@@ -13,9 +13,28 @@
  */
 
 import { parse as parseWat } from 'watr'
-import { ctx, inc, resolveIncludes, PTR, LAYOUT } from './ctx.js'
+import { ctx, inc, resolveIncludes, err, 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 { optimizeFunc, collectVolatileGlobals, hoistConstantPool, specializeMkptr, specializePtrBase, sortStrPoolByFreq, arenaRewindModule } from './optimize.js'
 import { emit } from './emit.js'
 import { mkPtrIR, MAX_CLOSURE_ARITY, MEM_OPS, findBodyStart } from './ir.js'
 
@@ -27,16 +46,20 @@ const TAG_SHIFT_BIG = BigInt(LAYOUT.TAG_SHIFT)
 const AUX_SHIFT_BIG = BigInt(LAYOUT.AUX_SHIFT)
 const SSO_BIT_BIG = BigInt(LAYOUT.SSO_BIT)
 
-const heapGetIR = () => ctx.memory.shared
+// memory[1020] holds the heap pointer only for shared memory (wasm globals are
+// per-instance — see module/core.js comment). Non-shared memory uses $__heap.
+const heapUsesMem = () => ctx.memory.shared
+
+const heapGetIR = () => heapUsesMem()
   ? ['i32.load', ['i32.const', 1020]]
   : ['global.get', '$__heap']
 
-const heapSetIR = value => ctx.memory.shared
+const heapSetIR = value => heapUsesMem()
   ? ['i32.store', ['i32.const', 1020], value]
   : ['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 +83,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
@@ -109,7 +132,7 @@ function applyArenaRewind(func, fn, safeCallees) {
 
 export function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
   ctx.func.locals = new Map()
-  ctx.func.repByLocal = null
+  ctx.func.localReps = null
   ctx.func.boxed = new Map()
   ctx.func.stack = []
   ctx.func.current = { params: [], results: [] }
@@ -133,7 +156,7 @@ export function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
   const beforeLateClosures = closureFuncs.length
   const startCtx = {
     locals: ctx.func.locals,
-    repByLocal: ctx.func.repByLocal,
+    localReps: ctx.func.localReps,
     boxed: ctx.func.boxed,
     stack: ctx.func.stack,
     current: ctx.func.current,
@@ -154,7 +177,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) =>
@@ -165,17 +188,24 @@ export function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
 
   const schemaInit = []
   const hasJpObj = ctx.core.includes.has('__jp_obj') || ctx.core.includes.has('__jp')
-  const needsSchemaTbl = (ctx.schema.list.length && (
-    ctx.core.includes.has('__stringify') ||
+  const hasStringify = ctx.core.includes.has('__stringify')
+  // Empty object literals register a `[]` schema so their schemaId indexes a
+  // valid list entry. But __dyn_get already guards `$__schema_tbl == 0`, so a
+  // table holding only empty schemas is pure dead weight there. __json_obj has
+  // no such guard — it must read the table whenever stringify is in play.
+  const tblConsumed = hasStringify ||
     ctx.core.includes.has('__dyn_get') ||
     ctx.core.includes.has('__dyn_get_t') ||
     ctx.core.includes.has('__dyn_get_t_h') ||
     ctx.core.includes.has('__dyn_get_expr_t_h') ||
     ctx.core.includes.has('__dyn_get_any') ||
     ctx.core.includes.has('__dyn_get_any_t') ||
+    ctx.core.includes.has('__dyn_get_any_t_h') ||
     ctx.core.includes.has('__dyn_get_expr') ||
     ctx.core.includes.has('__dyn_get_expr_t') ||
-    ctx.core.includes.has('__dyn_get_or'))) ||
+    ctx.core.includes.has('__dyn_get_or')
+  const needsSchemaTbl = (ctx.schema.list.length && tblConsumed &&
+    (hasStringify || ctx.schema.list.some(s => s.length > 0))) ||
     hasJpObj
   if (needsSchemaTbl) {
     const nSchemas = ctx.schema.list.length
@@ -195,7 +225,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 +414,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 +424,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))))
+  for (const n of ctx.core.includes) if (!ctx.core.stdlib[n]) err(`internal: stdlib '${n}' was requested but never registered (this is a jz bug — feature pulled in something it can't deliver)`)
+  sec.stdlib.push(...[...ctx.core.includes].map(n => parseTemplate(stdlibStr(n))))
 }
 
 export function syncImports(sec) {
@@ -435,7 +465,9 @@ export function optimizeModule(sec) {
   }
   // Build global name→type map from ctx.scope.globalTypes (keys without $) for promoteGlobals
   const globalTypesMap = ctx.scope.globalTypes ? new Map([...ctx.scope.globalTypes].map(([k, v]) => [`$${k}`, v])) : null
-  for (const s of [...sec.funcs, ...sec.stdlib, ...sec.start]) optimizeFunc(s, cfg, globalTypesMap)
+  const allFuncs = [...sec.funcs, ...sec.stdlib, ...sec.start]
+  const volatileGlobals = collectVolatileGlobals(allFuncs)
+  for (const s of allFuncs) optimizeFunc(s, cfg, globalTypesMap, volatileGlobals)
   if (!cfg || cfg.arenaRewind !== false) {
     const safeCallees = arenaRewindModule([...sec.funcs, ...sec.stdlib, ...sec.start])
     const fnByName = new Map()
@@ -449,7 +481,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).
@@ -464,7 +500,9 @@ export function optimizeModule(sec) {
   const dataLen = ctx.runtime.data?.length || 0
   if (dataLen > 1024 && !ctx.memory.shared) {
     const heapBase = (dataLen + 7) & ~7
-    ctx.scope.globals.set('__heap', `(global $__heap (mut i32) (i32.const ${heapBase}))`)
+    // Non-shared memory always carries a $__heap global — start it past the
+    // static data so the bump allocator never overwrites a literal.
+    ctx.scope.globals.set('__heap', `(global $__heap (export "__heap") (mut i32) (i32.const ${heapBase}))`)
     ctx.scope.globalTypes.set('__heap', 'i32')
     if (ctx.scope.globals.has('__heap_start')) {
       ctx.scope.globals.set('__heap_start', `(global $__heap_start (mut i32) (i32.const ${heapBase}))`)

package/src/autoload.js

@@ -36,9 +36,12 @@ export const OP_MODULES = {
   'in': ['core', 'collection', 'string'],
   '==': ['core', 'string'],
   '!=': ['core', 'string'],
+  '===': ['core', 'string'],
+  '!==': ['core', 'string'],
   'typeof': ['core', 'string'],
   '[': ['core', 'array'],
   '{': ['core', 'object', 'string', 'collection'],
+  'delete': ['core', 'collection', 'string'],
   '//': ['core', 'string', 'regex'],
   '**': ['math'],
 }
@@ -50,6 +53,8 @@ export const CALL_MODULES = dict({
   BigUint64Array: ['core', 'typedarray'],
   parseFloat: ['number', 'string'],
   parseInt: ['number', 'string'],
+  encodeURIComponent: ['core', 'string', 'number'],
+  decodeURIComponent: ['core', 'string', 'number'],
   String: ['core', 'string', 'number'],
   Number: ['number', 'string'],
   Boolean: ['number'],
@@ -60,10 +65,13 @@ export const CALL_MODULES = dict({
   'console.log': ['core', 'string', 'number', 'console'],
   'console.warn': ['core', 'string', 'number', 'console'],
   'console.error': ['core', 'string', 'number', 'console'],
-  'Object.fromEntries': ['collection', 'string'],
+  'Object.fromEntries': ['core', 'object', 'collection', 'string'],
   'Object.keys': ['core', 'object', 'string'],
+  'Object.getOwnPropertyNames': ['core', 'object', 'string'],
   'Object.values': ['core', 'object', 'string'],
   'Object.entries': ['core', 'object', 'string'],
+  'Object.hasOwn': ['core', 'object', 'string', 'collection'],
+  'Object.freeze': ['core', 'object'],
   'Object.assign': ['core', 'object'],
   'Object.create': ['core', 'object'],
   'Object.defineProperty': ['core', 'object'],
@@ -85,6 +93,10 @@ export const CALL_MODULES = dict({
   'Int8Array.from': ['core', 'typedarray', 'array'],
   'Uint8Array.from': ['core', 'typedarray', 'array'],
   'ArrayBuffer.isView': ['core', 'typedarray'],
+  // instanceof Map / Set / TypedArray predicates (synthesized by jzify).
+  '__is_map': ['core', 'collection'],
+  '__is_set': ['core', 'collection'],
+  '__is_typed': ['core', 'typedarray'],
 })
 
 export const GENERIC_METHOD_MODULES = dict({

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(', ') + ')'
+}