jz 0.4.0 → 0.5.0

package/src/assemble.js

@@ -13,7 +13,7 @@
  */
 
 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
@@ -34,7 +34,7 @@ const parseTemplate = (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'
 
@@ -46,11 +46,15 @@ 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]
 
@@ -128,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: [] }
@@ -152,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,
@@ -184,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
@@ -419,7 +430,7 @@ export function pullStdlib(sec) {
       ctx.core.includes.delete(name)
     }
   }
-  for (const n of ctx.core.includes) if (!ctx.core.stdlib[n]) console.error("MISSING stdlib:", 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))))
 }
 
@@ -454,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()
@@ -487,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({