jz 0.1.0 → 0.1.1

package/module/typedarray.js

@@ -7,7 +7,9 @@
  * @module typed
  */
 
-import { emit, typed, asF64, asI32, valTypeOf, lookupValType, VAL, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32 } from '../src/compile.js'
+import { typed, asF64, asI32, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",
@@ -25,10 +25,12 @@
     "test:segments": "nice -n 15 node scripts/test-segments.mjs 3000 files",
     "test:prefixes": "nice -n 15 node scripts/test-segments.mjs 3000 prefix",
     "test262": "node test/test262.js",
+    "test262:builtins": "node test/test262-builtins.js",
     "test262:runner": "node test/runner.js",
     "dev": "node cli.js",
     "build": "node cli.js compile examples/*.js",
     "bench": "node bench/bench.mjs",
+    "bench:compile": "node scripts/bench-compile.mjs",
     "bench:biquad": "node bench/bench.mjs biquad",
     "test:bench-pin": "node test/bench-pin.js"
   },
@@ -43,7 +45,7 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.3.3",
+    "subscript": "^10.3.5",
     "watr": "^4.5.1"
   },
   "keywords": [

package/src/analyze.js

@@ -237,7 +237,7 @@ export function valTypeOf(expr) {
   }
 
   if (op === '[') return VAL.ARRAY
-  if (op === 'str') return VAL.STRING
+  if (op === 'str' || op === 'strcat') return VAL.STRING
   if (op === '=>') return VAL.CLOSURE
   if (op === '//') return VAL.REGEX
   if (op === '{}' && args[0]?.[0] === ':') return VAL.OBJECT
@@ -1588,7 +1588,11 @@ export function analyzeDynKeys(...roots) {
   }
   for (const r of roots) walk(r)
   if (ctx.func.list) for (const f of ctx.func.list) if (f.body) walk(f.body)
-  if (ctx.module.moduleInits) for (const mi of ctx.module.moduleInits) walk(mi)
+  const initFacts = ctx.module.initFacts
+  if (initFacts?.anyDyn) {
+    anyDyn = true
+    for (const v of initFacts.dynVars) dynVars.add(v)
+  }
 
   ctx.types.dynKeyVars = dynVars
   ctx.types.anyDynKey = anyDyn
@@ -1752,6 +1756,7 @@ export function collectProgramFacts(ast) {
   const callSites = []
   const doSchema = ast && ctx.schema.register
   const doArity = !!ctx.closure.make
+  let hasSchemaLiterals = false
   let maxDef = 0, maxCall = 0, hasRest = false, hasSpread = false
   const isLiteralStr = idx => Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string'
   // Slot-type observation lives in the dedicated `observeProgramSlots` pass below;
@@ -1775,7 +1780,10 @@ export function collectProgramFacts(ast) {
     // to `[':', x, x]`) resolves x's val type via per-function locals, not just globals.
     if (op === '{}' && doSchema) {
       const parsed = staticObjectProps(args)
-      if (parsed) ctx.schema.register(parsed.names)
+      if (parsed) {
+        ctx.schema.register(parsed.names)
+        hasSchemaLiterals = true
+      }
     }
     // closure ABI arity
     if (doArity) {
@@ -1837,7 +1845,20 @@ export function collectProgramFacts(ast) {
   }
   walkFacts(ast, true, false, null)
   for (const func of ctx.func.list) if (func.body && !func.raw) walkFacts(func.body, true, false, func)
-  if (ctx.module.moduleInits) for (const mi of ctx.module.moduleInits) walkFacts(mi, false, false, null)
+  const initFacts = ctx.module.initFacts
+  if (initFacts) {
+    if (initFacts.anyDyn) {
+      anyDyn = true
+      for (const v of initFacts.dynVars) dynVars.add(v)
+    }
+    if (doArity) {
+      if (initFacts.maxDef > maxDef) maxDef = initFacts.maxDef
+      if (initFacts.maxCall > maxCall) maxCall = initFacts.maxCall
+      if (initFacts.hasRest) hasRest = true
+      if (initFacts.hasSpread) hasSpread = true
+    }
+    if (doSchema && initFacts.hasSchemaLiterals) hasSchemaLiterals = true
+  }
 
   // Slot-type observation pass: walk every `{}` literal with the right scope's
   // valTypes installed as `ctx.func.localValTypesOverlay` so shorthand `{x}`
@@ -1845,12 +1866,12 @@ export function collectProgramFacts(ast) {
   // through valTypeOf → lookupValType. Skips into closures — they're observed via
   // their own func.list entry. The overlay is the per-function analyzeBody.valTypes
   // map (already populated with the same overlay-aware walk).
-  if (doSchema) observeProgramSlots(ast)
+  if (doSchema && hasSchemaLiterals) observeProgramSlots(ast)
 
   return {
     dynVars, anyDyn, propMap, valueUsed, callSites,
     maxDef, maxCall, hasRest, hasSpread,
-    paramReps,
+    paramReps, hasSchemaLiterals,
   }
 }
 
@@ -1898,7 +1919,7 @@ export function observeProgramSlots(ast) {
     ctx.func.localValTypesOverlay = analyzeBody(func.body).valTypes
     visit(func.body)
   }
-  if (ctx.module.moduleInits) {
+  if (ctx.module.initFacts?.hasSchemaLiterals && ctx.module.moduleInits) {
     ctx.func.localValTypesOverlay = null
     for (const mi of ctx.module.moduleInits) visit(mi)
   }

package/src/autoload.js

@@ -0,0 +1,175 @@
+/** Runtime module autoload rules used by prepare(). */
+
+import { ctx, err } from './ctx.js'
+import * as mods from '../module/index.js'
+
+const dict = obj => Object.assign(Object.create(null), obj)
+
+export const PROP_MODULES = Object.assign(Object.create(null), {
+  push: ['core', 'array'], pop: ['core', 'array'], shift: ['core', 'array'], unshift: ['core', 'array'],
+  splice: ['core', 'array'], reverse: ['core', 'array'], sort: ['core', 'array'], fill: ['core', 'array'],
+  map: ['core', 'array'], filter: ['core', 'array'], reduce: ['core', 'array'], reduceRight: ['core', 'array'],
+  forEach: ['core', 'array'], find: ['core', 'array'], findIndex: ['core', 'array'],
+  findLast: ['core', 'array'], findLastIndex: ['core', 'array'],
+  every: ['core', 'array'], some: ['core', 'array'], flat: ['core', 'array'], flatMap: ['core', 'array'],
+  join: ['core', 'array'], copyWithin: ['core', 'array'], at: ['core', 'array'],
+  charAt: ['core', 'string'], charCodeAt: ['core', 'string'], codePointAt: ['core', 'string'],
+  toUpperCase: ['core', 'string'], toLowerCase: ['core', 'string'], trim: ['core', 'string'],
+  trimStart: ['core', 'string'], trimEnd: ['core', 'string'],
+  split: ['core', 'string'], replace: ['core', 'string'], replaceAll: ['core', 'string'],
+  repeat: ['core', 'string'], startsWith: ['core', 'string'], endsWith: ['core', 'string'],
+  padStart: ['core', 'string'], padEnd: ['core', 'string'], normalize: ['core', 'string'],
+  matchAll: ['core', 'string'], match: ['core', 'string'],
+  substring: ['core', 'string'], substr: ['core', 'string'],
+  add: ['core', 'collection'], clear: ['core', 'collection'],
+  slice: ['core', 'string', 'array'], concat: ['core', 'string', 'array'],
+  indexOf: ['core', 'string', 'array'], lastIndexOf: ['core', 'string', 'array'],
+  includes: ['core', 'string', 'array'],
+  length: ['core', 'string', 'array', 'typedarray'],
+})
+
+export const OP_MODULES = {
+  '?.': ['core', 'string', 'collection'],
+  '?.[]': ['core', 'array', 'collection'],
+  '?.()': ['core', 'fn'],
+  'u+': ['number', 'string'],
+  'in': ['core', 'collection', 'string'],
+  '==': ['core', 'string'],
+  '!=': ['core', 'string'],
+  'typeof': ['core', 'string'],
+  '[': ['core', 'array'],
+  '{': ['core', 'object', 'string', 'collection'],
+  '//': ['core', 'string', 'regex'],
+  '**': ['math'],
+}
+
+export const CALL_MODULES = dict({
+  ArrayBuffer: ['core', 'typedarray'],
+  DataView: ['core', 'typedarray'],
+  BigInt64Array: ['core', 'typedarray'],
+  BigUint64Array: ['core', 'typedarray'],
+  parseFloat: ['number', 'string'],
+  parseInt: ['number', 'string'],
+  String: ['core', 'string', 'number'],
+  Number: ['number', 'string'],
+  Boolean: ['number'],
+  TextEncoder: ['core', 'string'],
+  TextDecoder: ['core', 'string'],
+  Error: ['core', 'string'],
+  BigInt: ['number'],
+  'console.log': ['core', 'string', 'number', 'console'],
+  'console.warn': ['core', 'string', 'number', 'console'],
+  'console.error': ['core', 'string', 'number', 'console'],
+  'Object.fromEntries': ['collection', 'string'],
+  'Object.keys': ['string'],
+  'Object.entries': ['string'],
+  'Date.now': ['core', 'console'],
+  'performance.now': ['core', 'console'],
+  'String.fromCharCode': ['core', 'string'],
+  'String.fromCodePoint': ['core', 'string'],
+  'BigInt.asIntN': ['number'],
+  'BigInt.asUintN': ['number'],
+  'Float64Array.from': ['core', 'typedarray', 'array'],
+  'Float32Array.from': ['core', 'typedarray', 'array'],
+  'Int32Array.from': ['core', 'typedarray', 'array'],
+  'Uint32Array.from': ['core', 'typedarray', 'array'],
+  'Int16Array.from': ['core', 'typedarray', 'array'],
+  'Uint16Array.from': ['core', 'typedarray', 'array'],
+  'Int8Array.from': ['core', 'typedarray', 'array'],
+  'Uint8Array.from': ['core', 'typedarray', 'array'],
+  'ArrayBuffer.isView': ['core', 'typedarray'],
+})
+
+export const GENERIC_METHOD_MODULES = dict({
+  toString: ['core', 'string', 'number'],
+  toFixed: ['core', 'string', 'number'],
+  toPrecision: ['core', 'string', 'number'],
+  toExponential: ['core', 'string', 'number'],
+})
+
+export const CTORS = ['Float64Array','Float32Array','Int32Array','Uint32Array','Int16Array','Uint16Array','Int8Array','Uint8Array','BigInt64Array','BigUint64Array','Set','Map']
+export const TYPED_CTORS = ['Float64Array','Float32Array','Int32Array','Uint32Array','Int16Array','Uint16Array','Int8Array','Uint8Array','BigInt64Array','BigUint64Array','ArrayBuffer','DataView']
+export const COLLECTION_CTORS = ['Set', 'Map']
+export const TIMER_NAMES = new Set(['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'])
+
+export const MOD_ALIAS = { Number: 'number', Array: 'array', Object: 'object', Symbol: 'symbol', JSON: 'json', BigInt: 'number', Error: 'core', TextEncoder: 'string', TextDecoder: 'string' }
+
+const MOD_DEPS = {
+  number: ['core', 'string'],
+  string: ['core', 'number'],
+  array: ['core'],
+  object: ['core'],
+  collection: ['core', 'number'],
+  symbol: ['core'],
+  json: ['core', 'string', 'number', 'collection'],
+  console: ['core', 'string', 'number'],
+  regex: ['core', 'string', 'array'],
+}
+
+export const hasModule = name => Boolean(mods[MOD_ALIAS[name] || name])
+
+export const includeMods = (...names) => names.forEach(includeModule)
+
+export const includeForOp = op => {
+  const modules = OP_MODULES[op]
+  if (!modules) return false
+  includeMods(...modules)
+  return true
+}
+
+export const includeForCallableValue = () => includeMods('core', 'fn')
+export const includeForNumericCoercion = () => includeMods('number', 'string')
+export const includeForStringValue = () => includeMods('core', 'string', 'number')
+export const includeForStringOnly = () => includeMods('core', 'string')
+export const includeForArrayLiteral = () => includeMods('core', 'array')
+export const includeForArrayAccess = () => includeMods('core', 'array', 'collection')
+export const includeForArrayPattern = includeForArrayAccess
+export const includeForObjectLiteral = () => includeMods('core', 'object')
+export const includeForObjectPattern = () => includeMods('core', 'object', 'string', 'collection')
+export const includeForKnownKeyIteration = includeForStringOnly
+export const includeForRuntimeKeyIteration = () => includeMods('core', 'string', 'collection')
+export const includeForTimerRuntime = () => {
+  ctx.features.timers = true
+  includeModule('timer')
+  includeModule('fn')
+}
+
+export const includeForNamedCall = callee => {
+  const modules = CALL_MODULES[callee]
+  if (!modules) return false
+  includeMods(...modules)
+  return true
+}
+
+export const includeForGenericMethod = prop => {
+  const modules = GENERIC_METHOD_MODULES[prop]
+  if (!modules) return false
+  includeMods(...modules)
+  return true
+}
+
+export const includeForProperty = prop => {
+  if (prop === 'byteLength' || prop === 'byteOffset' || prop === 'buffer') includeMods('core', 'typedarray')
+  if (typeof prop === 'string' && PROP_MODULES[prop]) includeMods(...PROP_MODULES[prop])
+  else includeMods('core', 'object', 'array', 'string', 'collection')
+}
+
+export const runtimeCtorKind = name =>
+  TYPED_CTORS.includes(name) ? 'typedarray' : COLLECTION_CTORS.includes(name) ? 'collection' : null
+
+export const includeForRuntimeCtor = name => {
+  const kind = runtimeCtorKind(name)
+  if (kind === 'typedarray') includeMods('core', 'typedarray')
+  else if (kind === 'collection') includeMods('core', 'collection')
+  return kind
+}
+
+export function includeModule(name) {
+  const modName = MOD_ALIAS[name] || name
+  const init = mods[modName]
+  if (!init) return err(`Module not found: ${name}`)
+  if (ctx.module.modules[modName]) return
+  ctx.module.modules[modName] = true
+  for (const dep of MOD_DEPS[modName] || []) includeModule(dep)
+  init(ctx)
+}