jz 0.1.0 → 0.2.0

package/module/function.js

@@ -10,13 +10,54 @@
  * @module fn
  */
 
-import { emit, typed, asF64, asI32, T, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN, lookupValType, repOf } from '../src/compile.js'
-import { isReassigned } from '../src/emit.js'
-import { PTR, inc, err } from '../src/ctx.js'
+import { typed, asF64, asI32, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN } from '../src/ir.js'
+import { emit, isReassigned } from '../src/emit.js'
+import { T, lookupValType, repOf, findFreeVars } from '../src/analyze.js'
+import { PTR, LAYOUT, inc, err } from '../src/ctx.js'
+
+const intConstExpr = (node) => {
+  if (typeof node === 'number' && Number.isInteger(node)) return node
+  if (Array.isArray(node) && node[0] == null && Number.isInteger(node[1])) return node[1]
+  if (!Array.isArray(node)) return null
+  const [op, a, b] = node
+  const av = intConstExpr(a)
+  if (op === 'u-' || (op === '-' && b === undefined)) return av == null ? null : -av
+  const bv = intConstExpr(b)
+  if (av == null || bv == null) return null
+  switch (op) {
+    case '+': return av + bv
+    case '-': return av - bv
+    case '*': return av * bv
+    case '&': return av & bv
+    case '|': return av | bv
+    case '^': return av ^ bv
+    case '<<': return av << bv
+    case '>>': return av >> bv
+    case '>>>': return av >>> bv
+    default: return null
+  }
+}
+
+const topLevelIntConsts = (body) => {
+  const inner = Array.isArray(body) && body[0] === '{}' ? body[1] : body
+  const stmts = Array.isArray(inner) && inner[0] === ';' ? inner.slice(1) : []
+  const out = new Map()
+  for (const stmt of stmts) {
+    if (!Array.isArray(stmt) || (stmt[0] !== 'const' && stmt[0] !== 'let')) continue
+    for (let i = 1; i < stmt.length; i++) {
+      const decl = stmt[i]
+      if (!Array.isArray(decl) || decl[0] !== '=' || typeof decl[1] !== 'string') continue
+      if (stmt[0] === 'let' && isReassigned(body, decl[1])) continue
+      const v = intConstExpr(decl[2])
+      if (v != null && v >= -2147483648 && v <= 2147483647) out.set(decl[1], v)
+    }
+  }
+  return out
+}
 
 
 export default (ctx) => {
-  inc('__mkptr', '__alloc', '__len', '__ptr_offset')
+  inc('__mkptr', '__alloc', '__len', '__ptr_offset', '__ptr_type')
 
   // Uniform closure convention: (env f64, argc i32, a0..a{MAX-1} f64) → f64
   if (!ctx.closure.types) ctx.closure.types = new Set()
@@ -42,6 +83,13 @@ export default (ctx) => {
     if (restParam && fixedN >= MAX_CLOSURE_ARITY) err(`Closure with rest param needs at least one free slot — ${fixedN} fixed params leaves none (MAX_CLOSURE_ARITY=${MAX_CLOSURE_ARITY})`)
     // Generate closure body function name
     const fnName = `${T}closure${ctx.closure.table.length}`
+    const localIntConsts = ctx.func.body ? topLevelIntConsts(ctx.func.body) : new Map()
+    const captureIntConsts = new Map()
+    for (const name of captures) {
+      const v = ctx.scope.constInts?.get(name) ?? localIntConsts.get(name)
+      if (v != null && !ctx.func.boxed?.has(name)) captureIntConsts.set(name, v)
+    }
+    const envCaptures = captureIntConsts.size ? captures.filter(name => !captureIntConsts.has(name)) : captures
     const captureValTypes = new Map()
     const captureSchemaVars = new Map()
     const captureTypedElems = new Map()
@@ -50,7 +98,7 @@ export default (ctx) => {
     // call_indirect on the captured pointer). Gated on isReassigned over the inner body
     // so a local rewrite of the captured name disables propagation.
     const captureDirectClosures = new Map()
-    for (const name of captures) {
+    for (const name of envCaptures) {
       const vt = lookupValType(name)
       if (vt != null) captureValTypes.set(name, vt)
       const schemaId = ctx.schema.idOf(name)
@@ -61,13 +109,26 @@ export default (ctx) => {
       if (bodyName && !isReassigned(body, name)) captureDirectClosures.set(name, bodyName)
     }
 
+    const schemaNames = ctx.schema.vars?.size ? new Set(ctx.schema.vars.keys()) : null
+    if (schemaNames?.size) {
+      const refs = []
+      findFreeVars(body, new Set(params), refs, schemaNames)
+      for (const def of Object.values(defaults || {})) findFreeVars(def, new Set(params), refs, schemaNames)
+      for (const name of refs) {
+        if (captureSchemaVars.has(name)) continue
+        const schemaId = ctx.schema.idOf(name)
+        if (schemaId != null) captureSchemaVars.set(name, schemaId)
+      }
+    }
+
     // All closures use uniform convention: (env: f64, args_array: f64) → f64
     // The body unpacks individual params from the args array
-    const boxedCaptures = captures.filter(c => ctx.func.boxed?.has(c))
-    const bodyFn = { name: fnName, params, body, captures, arity: 1,
+    const boxedCaptures = envCaptures.filter(c => ctx.func.boxed?.has(c))
+    const bodyFn = { name: fnName, params, body, captures: envCaptures, arity: 1,
       ...(restParam && { rest: restParam }),
       ...(defaults && { defaults }),
       ...(boxedCaptures.length && { boxed: new Set(boxedCaptures) }),
+      ...(captureIntConsts.size && { intConsts: captureIntConsts }),
       ...(captureValTypes.size && { valTypes: captureValTypes }),
       ...(captureSchemaVars.size && { schemaVars: captureSchemaVars }),
       ...(captureTypedElems.size && { typedElems: captureTypedElems }),
@@ -80,7 +141,7 @@ export default (ctx) => {
     // Tag IR with .closureBodyName so emitDecl can register the binding for direct dispatch
     // (skip call_indirect on a const-bound, non-escaping closure local). See emit.js '()' handler.
     ctx.features.closure = true
-    if (captures.length === 0) {
+    if (envCaptures.length === 0) {
       // No captures — just a function reference
       const ir = mkPtrIR(PTR.CLOSURE, tableIdx, 0)
       ir.closureBodyName = fnName
@@ -91,16 +152,16 @@ export default (ctx) => {
     const t = tempI32('env')
 
     const block = [
-      ['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', captures.length * 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', envCaptures.length * 8]]],
     ]
     // Store captured values in env: boxed cells as raw i32 in low 4 bytes, others as f64.
     // Avoids i32↔f64 roundtrip; body loads via i32.load/f64.load using the same branch.
-    for (let i = 0; i < captures.length; i++) {
+    for (let i = 0; i < envCaptures.length; i++) {
       const addr = ['i32.add', ['local.get', `$${t}`], ['i32.const', i * 8]]
-      if (ctx.func.boxed?.has(captures[i]))
-        block.push(['i32.store', addr, ['local.get', `$${ctx.func.boxed.get(captures[i])}`]])
+      if (ctx.func.boxed?.has(envCaptures[i]))
+        block.push(['i32.store', addr, ['local.get', `$${ctx.func.boxed.get(envCaptures[i])}`]])
       else
-        block.push(['f64.store', addr, asF64(emit(captures[i]))])
+        block.push(['f64.store', addr, asF64(emit(envCaptures[i]))])
     }
     block.push(mkPtrIR(PTR.CLOSURE, tableIdx, ['local.get', `$${t}`]))
 
@@ -127,15 +188,15 @@ export default (ctx) => {
       const arrT = tempI32('sa')
       const lenL = tempI32('sl')
       const setup = [
-        ['local.set', `$${arrT}`, ['call', '$__ptr_offset', asF64(args[0])]],
-        ['local.set', `$${lenL}`, ['call', '$__len', ['local.get', `$${t}`]]],  // placeholder — set below
+        ['local.set', `$${arrT}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', asF64(args[0])]]],
+        ['local.set', `$${lenL}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],  // placeholder — set below
       ]
       // Rebuild setup properly since we need the array ptr before len call
       setup.length = 0
       const arrPtrF64 = temp('sp')
       setup.push(['local.set', `$${arrPtrF64}`, asF64(args[0])])
-      setup.push(['local.set', `$${arrT}`, ['call', '$__ptr_offset', ['local.get', `$${arrPtrF64}`]]])
-      setup.push(['local.set', `$${lenL}`, ['call', '$__len', ['local.get', `$${arrPtrF64}`]]])
+      setup.push(['local.set', `$${arrT}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${arrPtrF64}`]]]])
+      setup.push(['local.set', `$${lenL}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arrPtrF64}`]]]])
 
       const W = ctx.closure.width ?? MAX_CLOSURE_ARITY
       const slots = []
@@ -152,10 +213,10 @@ export default (ctx) => {
           ['local.get', `$${t}`],
           ['local.get', `$${lenL}`],
           ...slots,
-          // Inline __ptr_aux for CLOSURE pointer: aux = bits 32..46 holds funcIdx.
+          // Inline __ptr_aux for CLOSURE pointer: aux holds funcIdx.
           ['i32.wrap_i64', ['i64.and',
-            ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', 32]],
-            ['i64.const', 0x7FFF]]]]], 'f64')
+            ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+            ['i64.const', LAYOUT.AUX_MASK]]]]], 'f64')
     }
 
     // Inline path: emit each arg, pad missing slots with UNDEF
@@ -172,9 +233,9 @@ export default (ctx) => {
         ['local.get', `$${t}`],
         ['i32.const', n],
         ...slots,
-        // Inline __ptr_aux for CLOSURE pointer: aux = bits 32..46 holds funcIdx.
+        // Inline __ptr_aux for CLOSURE pointer: aux holds funcIdx.
         ['i32.wrap_i64', ['i64.and',
-          ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', 32]],
-          ['i64.const', 0x7FFF]]]]], 'f64')
+          ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+          ['i64.const', LAYOUT.AUX_MASK]]]]], 'f64')
   }
 }

package/module/index.js

@@ -12,4 +12,5 @@ import console from './console.js'
 import json from './json.js'
 import regex from './regex.js'
 import timer from './timer.js'
-export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer }
+import date from './date.js'
+export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer, date }