jz 0.2.1 → 0.3.0

package/src/ast.js

@@ -0,0 +1,160 @@
+/**
+ * AST analysis predicates — pure functions over jz AST arrays.
+ *
+ * Extracted from emit.js to reduce the God File and enable reuse.
+ * These functions walk the jz AST (array-of-atoms format) and answer
+ * structural questions without emitting any IR.
+ *
+ * # Convention
+ * AST nodes are either:
+ *   - strings (identifiers / bare names)
+ *   - numbers (numeric literals)
+ *   - arrays where [0] is the operator tag: ['+', a, b], ['let', ...], ['=>', params, body], etc.
+ *   - [null, value] for parenthesized/boxed literals
+ *
+ * @module ast
+ */
+
+import { ASSIGN_OPS, intLiteralValue } from './analyze.js'
+import { ctx } from './ctx.js'
+
+/** Detect whether `name` is written to (=, +=, ++, --, etc.) anywhere within `body`.
+ *  Conservative over-reject: if unsure, treat as written.
+ *  `let`/`const` declarations are NOT reassignments — only the initializer expressions
+ *  inside them are scanned. */
+export function isReassigned(body, name) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (ASSIGN_OPS.has(op) && body[1] === name) return true
+  if ((op === '++' || op === '--') && body[1] === name) return true
+  if (op === 'let' || op === 'const') {
+    for (let i = 1; i < body.length; i++) {
+      const d = body[i]
+      if (Array.isArray(d) && d[0] === '=' && d[2] != null && isReassigned(d[2], name)) return true
+    }
+    return false
+  }
+  for (let i = 1; i < body.length; i++) if (isReassigned(body[i], name)) return true
+  return false
+}
+
+/** Does `body` contain a `continue` that targets THIS loop?
+ *  A `continue` inside a nested `for`/`while`/`do` targets the inner loop, so we don't count it. */
+export function hasOwnContinue(body) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (op === 'continue') return true
+  if (op === 'for' || op === 'while' || op === 'do') return false
+  for (let i = 1; i < body.length; i++) if (hasOwnContinue(body[i])) return true
+  return false
+}
+
+export function hasOwnBreakOrContinue(body) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (op === 'break' || op === 'continue') return true
+  if (op === 'for' || op === 'while' || op === 'do' || op === '=>') return false
+  for (let i = 1; i < body.length; i++) if (hasOwnBreakOrContinue(body[i])) return true
+  return false
+}
+
+export function containsNestedClosure(body) {
+  if (!Array.isArray(body)) return false
+  if (body[0] === '=>') return true
+  for (let i = 1; i < body.length; i++) if (containsNestedClosure(body[i])) return true
+  return false
+}
+
+export function containsNestedLoop(body) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (op === 'for' || op === 'while' || op === 'do') return true
+  if (op === '=>') return false
+  for (let i = 1; i < body.length; i++) if (containsNestedLoop(body[i])) return true
+  return false
+}
+
+/** Recursive loop size estimator — product of trip counts for nested `for (let i=0; i<N; i++)` loops. */
+export function nestedSmallLoopBudget(body) {
+  if (!Array.isArray(body)) return 1
+  if (body[0] === '=>') return 1
+  if (body[0] === 'for') {
+    const [, init, cond, step, loopBody] = body
+    const n = smallConstForTripCount(init, cond, step)
+    return n == null ? MAX_NESTED_FOR_UNROLL + 1 : n * nestedSmallLoopBudget(loopBody)
+  }
+  let max = 1
+  for (let i = 1; i < body.length; i++) max = Math.max(max, nestedSmallLoopBudget(body[i]))
+  return max
+}
+
+export function containsDeclOf(body, name) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (op === '=>') return false
+  if (op === 'let' || op === 'const') {
+    for (let i = 1; i < body.length; i++) {
+      const d = body[i]
+      if (d === name) return true
+      if (Array.isArray(d) && d[0] === '=' && d[1] === name) return true
+    }
+  }
+  for (let i = 1; i < body.length; i++) if (containsDeclOf(body[i], name)) return true
+  return false
+}
+
+/** Clone AST node, substituting bare-name matches with [null, value]. Skips into closures. */
+export function cloneWithSubst(node, name, value) {
+  if (node === name) return [null, value]
+  if (!Array.isArray(node)) return node
+  if (node[0] === '=>') return node
+  return node.map(x => cloneWithSubst(x, name, value))
+}
+
+export const MAX_SMALL_FOR_UNROLL = 8
+export const MAX_NESTED_FOR_UNROLL = 64
+
+/** Does `body` access a typed-array element by string name known to the type system? */
+export function containsKnownTypedArrayIndex(body) {
+  if (!Array.isArray(body)) return false
+  if (body[0] === '=>') return false
+  if (body[0] === '[]' && typeof body[1] === 'string' && ctx.types.typedElem?.has(body[1])) return true
+  for (let i = 1; i < body.length; i++) if (containsKnownTypedArrayIndex(body[i])) return true
+  return false
+}
+
+/** Analyze `for (let i=0; i<N; i++)` trip count. Returns N if structurally matches, else null. */
+export function smallConstForTripCount(init, cond, step) {
+  if (!Array.isArray(init) || init[0] !== 'let' || init.length !== 2) return null
+  const decl = init[1]
+  if (!Array.isArray(decl) || decl[0] !== '=' || typeof decl[1] !== 'string') return null
+  const name = decl[1]
+  const start = intLiteralValue(decl[2])
+  if (start !== 0) return null
+
+  if (!Array.isArray(cond) || cond[0] !== '<' || cond[1] !== name) return null
+  const end = intLiteralValue(cond[2])
+  if (end == null || end < 0 || end > MAX_SMALL_FOR_UNROLL) return null
+
+  const stepOk = Array.isArray(step) && (
+    (step[0] === '++' && step[1] === name) ||
+    (step[0] === '-' && Array.isArray(step[1]) && step[1][0] === '++' && step[1][1] === name && intLiteralValue(step[2]) === 1)
+  )
+  return stepOk ? end : null
+}
+
+/** Does `body` always exit the enclosing scope (return / throw / break / continue)? */
+export function isTerminator(body) {
+  if (!Array.isArray(body)) return false
+  const op = body[0]
+  if (op === 'return' || op === 'throw' || op === 'break' || op === 'continue') return true
+  if (op === '{}' || op === ';') {
+    for (let i = body.length - 1; i >= 1; i--) {
+      const s = body[i]
+      if (s == null) continue
+      return isTerminator(s)
+    }
+    return false
+  }
+  return false
+}

package/src/auto-config.js

@@ -0,0 +1,120 @@
+/**
+ * Auto-detect optimization tuning from source characteristics.
+ *
+ * Scans the prepared AST + ctx.func.list to infer program properties
+ * and returns suggested optimization overrides. When the user does not
+ * explicitly configure individual passes, these suggestions are merged
+ * in before resolveOptimize() so the compiler self-tunes.
+ *
+ * @module auto-config
+ */
+
+import { ctx } from './ctx.js'
+
+const LOOP_OPS = new Set(['for', 'while', 'do', 'do-while'])
+const TYPED_CTORS = new Set([
+  'new.Float32Array', 'new.Float64Array', 'new.Int8Array', 'new.Int16Array',
+  'new.Int32Array', 'new.Uint8Array', 'new.Uint16Array', 'new.Uint32Array',
+  'new.Uint8ClampedArray',
+])
+
+function nodeSize(node) {
+  if (!Array.isArray(node)) return 1
+  let n = 1
+  for (let i = 1; i < node.length; i++) n += nodeSize(node[i])
+  return n
+}
+
+function scanNode(node, stats, loopDepth) {
+  if (!Array.isArray(node)) return
+  const op = node[0]
+
+  if (LOOP_OPS.has(op)) {
+    stats.loopCount++
+    const d = loopDepth + 1
+    if (d > stats.maxLoopDepth) stats.maxLoopDepth = d
+    for (let i = 1; i < node.length; i++) scanNode(node[i], stats, d)
+    return
+  }
+
+  if (op === '()') {
+    stats.callSites++
+    const callee = node[1]
+    if (typeof callee === 'string' && TYPED_CTORS.has(callee)) {
+      stats.typedArrayCount++
+      const args = node[2]
+      const argList = args == null ? [] : (Array.isArray(args) && args[0] === ',') ? args.slice(1) : [args]
+      const lenLit = typeof argList[0] === 'number' ? argList[0] : null
+      if (lenLit != null && lenLit > stats.maxTypedArrayLen) stats.maxTypedArrayLen = lenLit
+    }
+  }
+
+  if (op === 'str') stats.stringLiteralCount++
+  if (op === '=>') stats.closureCount++
+
+  for (let i = 1; i < node.length; i++) scanNode(node[i], stats, loopDepth)
+}
+
+function scanStats(ast, code) {
+  const stats = {
+    sourceChars: code?.length || 0,
+    funcCount: 0,
+    maxFuncBodySize: 0,
+    loopCount: 0,
+    maxLoopDepth: 0,
+    typedArrayCount: 0,
+    maxTypedArrayLen: 0,
+    stringLiteralCount: 0,
+    closureCount: 0,
+    callSites: 0,
+  }
+
+  if (ctx.func?.list) {
+    stats.funcCount = ctx.func.list.length
+    for (const f of ctx.func.list) {
+      if (f.body) {
+        const sz = nodeSize(f.body)
+        if (sz > stats.maxFuncBodySize) stats.maxFuncBodySize = sz
+        scanNode(f.body, stats, 0)
+      }
+    }
+  }
+  if (ast) scanNode(ast, stats, 0)
+  return stats
+}
+
+/**
+ * Detect optimization config from source characteristics.
+ * Returns an object of pass overrides; empty object means "use defaults".
+ */
+export function detectOptimizeConfig(ast, code) {
+  const s = scanStats(ast, code)
+  const cfg = {}
+
+  // Machine-generated or large code: watr's WAT-level CSE/DCE/inline fights
+  // jz's already-optimized IR and inflates output. Disable it automatically.
+  const isLarge = s.sourceChars > 4000 || s.funcCount > 40 || s.maxFuncBodySize > 300
+  const isMachineLike = s.callSites > 300 && s.stringLiteralCount < 10
+  if (isLarge || isMachineLike) cfg.watr = false
+
+  // Typed-array heavy: tighten scalarization thresholds when we see large
+  // fixed-size arrays; keep defaults for small/dynamic ones.
+  if (s.typedArrayCount > 0 && s.maxTypedArrayLen > 0) {
+    cfg.scalarTypedArrayLen = Math.min(32, Math.max(8, s.maxTypedArrayLen + 4))
+    cfg.scalarTypedLoopUnroll = s.maxLoopDepth > 1 ? 8 : 16
+    cfg.scalarTypedNestedUnroll = s.maxLoopDepth > 1 ? 32 : 128
+  }
+
+  // String-heavy: ensure pool sorting is on (already default, but explicit).
+  if (s.stringLiteralCount > 30) {
+    cfg.sortStrPoolByFreq = true
+  }
+
+  // Closure-heavy: ptr hoists pay off.
+  if (s.closureCount > 4) {
+    cfg.hoistPtrType = true
+    cfg.hoistInvariantPtrOffset = true
+  }
+
+  return cfg
+}

package/src/autoload.js

@@ -66,7 +66,9 @@ export const CALL_MODULES = dict({
   'Object.entries': ['core', 'object', 'string'],
   'Object.assign': ['core', 'object'],
   'Object.create': ['core', 'object'],
+  'Object.defineProperty': ['core', 'object'],
   'Date.UTC': ['core', 'date'],
+  'Date.parse': ['core', 'date'],
   'Date.now': ['core', 'console'],
   'performance.now': ['core', 'console'],
   'readStdin': ['core', 'console'],
@@ -162,13 +164,14 @@ export const includeForProperty = prop => {
 }
 
 export const runtimeCtorKind = name =>
-  TYPED_CTORS.includes(name) ? 'typedarray' : COLLECTION_CTORS.includes(name) ? 'collection' : name === 'Date' ? 'date' : null
+  TYPED_CTORS.includes(name) ? 'typedarray' : COLLECTION_CTORS.includes(name) ? 'collection' : name === 'Date' ? 'date' : name === 'Array' ? 'array' : null
 
 export const includeForRuntimeCtor = name => {
   const kind = runtimeCtorKind(name)
   if (kind === 'typedarray') includeMods('core', 'typedarray')
   else if (kind === 'collection') includeMods('core', 'collection')
   else if (kind === 'date') includeMods('core', 'console', 'date')
+  else if (kind === 'array') includeMods('core', 'array')
   return kind
 }