jz 0.4.0 → 0.5.0

package/src/ctx.js

@@ -7,6 +7,8 @@
  * Refactored into focused sub-contexts for better maintainability.
  */
 
+import { DEFAULTS as ABI_DEFAULTS } from './abi/index.js'
+
 // === Carrier layout ===
 // i64 carrier holds either:
 //   - raw f64 number bits (any non-NaN-shape pattern), discriminated by
@@ -26,6 +28,9 @@ export const LAYOUT = {
   NAN_PREFIX: 0x7FF8,      // top 13 bits of any NaN-shape pointer
   NAN_PREFIX_BITS: 0x7FF8000000000000n, // pre-shifted for i64 OR
   SSO_BIT: 0x4000,         // STRING aux bit 14: 1=inline (≤4 ASCII chars in offset), 0=heap
+  SLICE_BIT: 0x2000,       // STRING aux bit 13: 1=view (no length header — len in aux[12:0],
+                           //   offset points into a parent buffer), 0=own heap string.
+  SLICE_LEN_MASK: 0x1FFF,  // aux[12:0] — view length (≤8191; larger slices fall back to copy)
 }
 
 // === Tagged-pointer type codes ===
@@ -84,6 +89,10 @@ export const ctx = {
   memory: {},     // module memory config (pages, shared)
   error: {},      // source location carried through emit for err() messages
   transform: {},  // compile-time options (jzify, etc.)
+  abi: {},        // per-type rep lookup (see abi/index.js). { number: rep, string: rep, ... }
+                  // Set by reset() to the default carrier bundle. Read by codegen sites
+                  // that delegate rep-specific behavior — today just the optimizer's
+                  // peephole hook; expanding as per-site narrowing tags individual sites.
 }
 
 /** Create a child scope via shallow flat copy (metacircular-safe: no prototype chain).
@@ -93,17 +102,38 @@ export const derive = (parent) => ({ ...parent })
 /** Include stdlib names for emission. */
 export const inc = (...names) => names.forEach(n => ctx.core.includes.add(n))
 
+/** Wrap an emit handler with a declarative stdlib-dependency list. The deps
+ *  become data — exposed as `.deps` (tabulatable, analyzable) — and are `inc`'d
+ *  on every call, while the body `fn` stays a pure `args → IR` builder (also
+ *  reachable as `.pure`). Emitters with no stdlib needs skip the wrapper and
+ *  register as plain functions; behaviour is identical either way. */
+export const emitter = (deps, fn) => {
+  const run = (...args) => (inc(...deps), fn(...args))
+  run.deps = deps
+  run.pure = fn
+  // Preserve the body's arity: `typeof Math.x` folding keys off emitter `.length`
+  // to tell callable builtins (sin) from constant ones (PI). The rest-param
+  // wrapper would otherwise report 0 for everything.
+  Object.defineProperty(run, 'length', { value: fn.length, configurable: true })
+  return run
+}
+
 /** Expand ctx.core.includes transitively via ctx.core.stdlibDeps. Call before WASM assembly.
  *  Each module co-locates its own deps with its stdlib registrations at init time. */
 export function resolveIncludes() {
   const graph = ctx.core.stdlibDeps
-  const queue = [...ctx.core.includes]
-  while (queue.length) {
-    const name = queue.pop()
-    const entry = graph[name]
-    const deps = typeof entry === 'function' ? entry() : entry
-    if (deps) for (const dep of deps) {
-      if (!ctx.core.includes.has(dep)) { ctx.core.includes.add(dep); queue.push(dep) }
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const name of [...ctx.core.includes]) {
+      const entry = graph[name]
+      const deps = typeof entry === 'function' ? entry() : entry
+      if (deps) for (const dep of deps) {
+        if (!ctx.core.includes.has(dep)) {
+          ctx.core.includes.add(dep)
+          changed = true
+        }
+      }
     }
   }
 }
@@ -118,6 +148,10 @@ export function reset(proto, globals) {
     extImports: new Set(),  // __ext_* helpers actually emitted as env imports —
                             // pullStdlib() removes them from `includes` after wiring,
                             // so post-compile auditors (host: 'wasi') read this instead.
+    jsstring: new Set(),    // `wasm:js-string` builtin names referenced by emitted code.
+                            // Drained at module-assembly time into `(import "wasm:js-string" "name" …)`
+                            // nodes; host wires JS-side polyfills via interop's
+                            // env builder for engines without builtin support.
   }
 
 
@@ -141,7 +175,7 @@ export function reset(proto, globals) {
     globalTypes: new Map(),
     globalValTypes: null,
     globalTypedElem: null,
-    repByGlobal: null, // Map<name, ValueRep> — module-level pointer reps (TYPED const globals stored as raw i32 offset, etc.)
+    globalReps: null, // Map<name, ValueRep> — module-level pointer reps (TYPED const globals stored as raw i32 offset, etc.)
     consts: null,
   }
 
@@ -149,16 +183,24 @@ export function reset(proto, globals) {
     list: [],
     names: new Set(),  // Set<string> — known func names (list + imported funcs); populated at compile() start
     map: new Map(),    // Map<string, func> — name → func entry; populated at compile() start
+    multiProp: new Set(),  // Set<"obj.prop"> — function-properties assigned >1× (wrapper composition); suppresses the static fn.prop() direct call
     exports: {},
     current: null,
     locals: new Map(),
-    repByLocal: null,
-    refinements: new Map(),  // flow-sensitive: name → VAL.* inside a type-guarded branch
+    localReps: null,
+    refinements: new Map(),  // flow-sensitive: name → {val?: VAL.*, notString?: true} inside a type-guarded branch
     boxed: new Map(),
     stack: [],
     uniq: 0,
     inTry: false,
     localProps: null,
+    // Pass-scoped overlays installed by analyzeBody/observeSlots. While set,
+    // `lookupValType`/`typedElemCtor` consult the in-progress fact maps before
+    // falling back to global state — lets shorthand `{x}` / typed-array writes
+    // observe locals that haven't been promoted to ctx.types yet. Saved/restored
+    // by the pass owners so re-entrant analyzeBody calls don't clobber each other.
+    localValTypesOverlay: null,
+    localTypedElemsOverlay: null,
   }
 
   ctx.types = {
@@ -181,6 +223,21 @@ export function reset(proto, globals) {
                            // returns the slot's kind for `.prop` AST nodes, letting
                            // `+`/`===`/method dispatch elide `__is_str_key` checks
                            // on numeric properties of known shapes.
+    slotIntCertain: new Map(),  // schemaId → Array<boolean | undefined>
+                                //   undefined: no write observed, true: all observed
+                                //   writes are integer-shaped, false: poisoned by at
+                                //   least one non-int write. Populated by
+                                //   `analyzeSchemaSlotIntCertain` (whole-program
+                                //   walk over `{}` literals + `obj.prop = expr`
+                                //   writes). Read by `ctx.schema.slotIntCertainAt`
+                                //   so Math.floor/toNumF64/intIndexIR consumers fire
+                                //   on `.prop` reads of provably-integer slots.
+    inlineArray: new Set(),     // schemaId set — schemas whose `Array<S>` instances
+                                //   use the `structInline` SRoA carrier (K f64
+                                //   fields inlined per element, no per-row object).
+                                //   Populated whole-program by `analyzeStructInline`
+                                //   (default-disqualify); read by the array
+                                //   push/index/length codegen.
   }
 
   ctx.closure = {
@@ -199,6 +256,8 @@ export function reset(proto, globals) {
     strPool: null,         // shared-memory: accumulated raw bytes of string literals (no length prefix)
     strPoolDedup: new Map(),  // str → offset in strPool
     throws: false,
+    userThrows: false,  // user wrote `throw`/`try`/`catch`/`finally` — keep runtime declared
+                        // even when all throws are dead-code-eliminated (JS-side ABI contract).
   }
 
   ctx.memory = {
@@ -226,8 +285,15 @@ export function reset(proto, globals) {
                         // instantiation time. 'wasi': error at compile time if any `__ext_*` import
                         // would be emitted, since wasmtime/wasmer hosts have no JS runtime to satisfy
                         // them and silent fallback would corrupt output.
+    inspect: false,     // when true, compile() additionally populates ctx.inspect with the inferred
+                        // per-function signatures, locals, and JSON shapes — readable by editor
+                        // hosts for inlay hints / hover types without re-running the analyzer.
   }
 
+  // Inspection sink. Populated by compile() only when transform.inspect is true.
+  // Shape: { abi, functions: { [name]: { exported, params, results, ptrKind?, locals, callerReps } }, schemas }.
+  ctx.inspect = null
+
   // Feature flags: capabilities the compiled module may exercise at runtime.
   // Set true by producer sites (import points, auto-imports, dynamic call sites).
   // Read by stdlib template factories and deps graph at resolveIncludes() time to
@@ -243,16 +309,17 @@ export function reset(proto, globals) {
   //   (b) a capability needs an opt-in A/B switch against the default path
   //       (SSO is the planned first user — default string-literal emission
   //       currently forces SSO for ≤4 ASCII chars at string.js:49)
+  ctx.abi = ABI_DEFAULTS
+
+  // Only flags actually read by codegen live here. Hash/regex/json substrates
+  // are pulled organically by inc(__*) — no flag mediates them, so no flag exists.
   ctx.features = {
-    external: false,  // PTR.EXTERNAL possible — opts.imports, HOST_GLOBALS, or __ext_call site. WIRED.
-    hash: false,      // PTR.HASH + __dyn_* substrate. Organic: any inc(__hash_*/__dyn_*) implies on.
+    external: false,  // PTR.EXTERNAL possible — opts.imports, HOST_GLOBALS, or __ext_call site.
     sso: true,        // ≤4-ASCII string packing. Default on; flip off to A/B the heap-only path.
-    regex: false,     // RegExp literals + methods. Organic via inc(__regex_*).
-    json: false,      // JSON.parse/stringify. Organic via inc(__jp_*/__json_*).
-    typedarray: false,// Float64Array/Int32Array/etc. Organic via inc(__typed_*) + ctx.closure.floor.
-    set: false,       // Set. Organic via inc(__set_*).
-    map: false,       // Map. Organic via inc(__map_*).
-    closure: false,   // First-class functions. Organic via ctx.closure.table population.
+    typedarray: false,// Float64Array/Int32Array/etc. Set on typed-array construction; gates PTR.TYPED dispatch.
+    set: false,       // Set. Set on Set construction; gates PTR.SET dispatch.
+    map: false,       // Map. Set on Map construction; gates PTR.MAP dispatch.
+    closure: false,   // First-class functions. Set when ctx.closure.table is populated.
     timers: false,          // Set by prepare.js when timer module is included
     blockingTimers: false,   // wasmtime CLI: include __timer_loop in _start
   }