jz 0.5.0 → 0.6.0

package/src/{infer.js → compile/infer.js}

@@ -43,12 +43,15 @@
  * @module src/infer
  */
 
-import { ctx } from './ctx.js'
-import {
-  VAL, collectParamNames, valTypeOf,
-  updateRep, updateGlobalRep, analyzeValTypes, analyzeIntCertain,
-  staticObjectProps, typedElemCtor, ctorFromElemAux, shapeOfObjectLiteralAst,
-} from './analyze.js'
+import { ctx } from '../ctx.js'
+import { collectParamNames, ASSIGN_OPS } from '../ast.js'
+import { analyzeValTypes, analyzeIntCertain } from './analyze.js'
+import { staticObjectProps } from '../static.js'
+import { typedElemCtor } from '../type.js'
+import { ctorFromElemAux } from '../../layout.js'
+import { shapeOfObjectLiteralAst, valTypeOf } from '../kind.js'
+import { includeForStringValue } from '../autoload.js'
+import { VAL, updateRep, updateGlobalRep } from '../reps.js'
 
 // === typeof predicate helper ==============================================
 //
@@ -63,7 +66,7 @@ import {
 /** Match a `typeof name <op> lit` predicate. Returns `{ name, code, eq }` —
  *  `name` is the typeof's operand binding, `code` is either the raw type
  *  string ('string'|'number'|'function'|…) or the prepare-normalized typeof
- *  code (-1|-2|-3|-4|-5|-6, see TYPEOF_MAP in prepare.js), and `eq` is true
+ *  code (TYPEOF in ast.js), and `eq` is true
  *  for `==`/`===` (false for `!=`/`!==`). Returns null when the node isn't a
  *  typeof predicate. */
 export function typeofPredicate(node) {
@@ -80,91 +83,10 @@ export function typeofPredicate(node) {
   return { name: typeofSide[1], code, eq: op === '==' || op === '===' }
 }
 
-// === paramReps lattice primitives ==========================================
+// === paramReps lattice =====================================================
 //
-// `paramReps: Map<funcName, Map<paramIdx, ValueRep>>` is the cross-call fact
-// lattice. Evidence sources (body-walk and call-site `infer*`) produce
-// raw observations; these primitives apply them with sticky-null poison
-// semantics: undefined → observe (set); equal → stay; disagreement → null
-// (sticky). null is "no consensus" — readers treat it as missing.
-//
-// Lifecycle phases (chronological — readers should know which fields are
-// valid at which point):
-//
-//   1. prepare      ─ no paramReps yet. AST walk collects callSites with raw
-//                     arg lists; programFacts.paramReps is allocated empty.
-//
-//   2. collectProgramFacts ─ unchanged paramReps; aggregates module-global
-//                     callSites, valueUsed, hasSchemaLiterals into
-//                     programFacts. paramReps still empty here.
-//
-//   3. narrowSignatures phase D (call-site lattice) ─
-//                     runCallsiteLattice merges raw call-site facts via
-//                     mergeParamFact for fields: val, schemaId, intConst,
-//                     arrayElemSchema, arrayElemValType, typedCtor, wasm.
-//                     After D, these may be undefined/null/value.
-//                     Sticky-null reachable on any field whose call sites
-//                     disagreed.
-//
-//   4. validateIntConstParams ─ clears intConst on any param whose body
-//                     contains a write to it (intConst's contract is "no
-//                     writes after the call").
-//
-//   5. phase E / E2 / E3 (param ABI narrowing) ─
-//                     applyI32ParamSpecialization sets sig.params[k].type
-//                     to 'i32' based on rep.wasm consensus. Then
-//                     applyPointerParamAbi sets rep.ptrKind on
-//                     consistently-OBJECT/ARRAY/etc params; this prepares
-//                     the i32-offset ABI for unboxed pointer params.
-//
-//   6. phase F (signature fixpoint) ─ clearStickyNull on val + schemaId,
-//                     then re-runs D until stable. New evidence from
-//                     newly-narrowed return types (valResult) can unstick.
-//
-//   7. phase G (narrowReturnArrayElems) ─ propagates Array<T> element
-//                     facts back through return paths into caller param
-//                     reps. After G, arrayElemSchema/arrayElemValType
-//                     reflect the transitive closure.
-//
-//   8. phase H (applyTypedPointerParamAbi) ─ sets ptrKind=TYPED + ptrAux
-//                     (elem code) for params whose val converged to TYPED.
-//                     Depends on F having seeded val first.
-//
-//   9. phase I (resetParamWasmFacts + final i32 spec) ─ last WASM-level
-//                     pass. After H/I, sig.params[k].type and rep.ptrKind
-//                     are frozen for emit.
-//
-//  10. per-function compile (emit start) ─ each func reads its
-//                     paramReps[name][k] and folds the consensus facts
-//                     into ctx.func.localReps via updateRep. Locals and
-//                     params then share one ValueRep store for the
-//                     remainder of emit.
-
-/** Per-call-site fact merge into a param's ValueRep field. */
-export const mergeParamFact = (rep, key, observed) => {
-  if (rep[key] === null) return                        // sticky poison
-  if (observed == null) { rep[key] = null; return }    // unknown → poison
-  if (rep[key] === undefined) rep[key] = observed
-  else if (rep[key] !== observed) rep[key] = null
-}
-
-/** Get-or-create per-param rep at (funcName, paramIdx) on a paramReps map. */
-export const ensureParamRep = (paramReps, funcName, k) => {
-  let m = paramReps.get(funcName)
-  if (!m) { m = new Map(); paramReps.set(funcName, m) }
-  let r = m.get(k)
-  if (!r) { r = {}; m.set(k, r) }
-  return r
-}
-
-/** Reset sticky-null on a single field across all params program-wide.
- *  Used between fixpoint phases when newly-narrowed facts unblock previously-
- *  poisoned observations (e.g. valResult set after first pass). */
-export const clearStickyNull = (paramReps, key) => {
-  for (const m of paramReps.values()) for (const r of m.values()) {
-    if (r[key] === null) r[key] = undefined
-  }
-}
+// Primitives live in src/param-reps.js (cycle-free leaf). Lifecycle phases
+// below document when each field is valid during narrowSignatures.
 
 // === Source registry =======================================================
 
@@ -212,7 +134,7 @@ const STRING_ONLY_METHODS = new Set([
   'charCodeAt', 'charAt', 'codePointAt', 'startsWith', 'endsWith',
   'toUpperCase', 'toLowerCase', 'toLocaleLowerCase', 'normalize', 'localeCompare',
   'padStart', 'padEnd', 'repeat', 'trimStart', 'trimEnd', 'trim',
-  'matchAll', 'match', 'replace', 'replaceAll', 'split',
+  'matchAll', 'match', 'replace', 'replaceAll', 'split', 'lastIndexOf',
 ])
 const ARRAY_ONLY_POISON = new Set([
   'push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'fill', 'reverse',
@@ -312,9 +234,6 @@ const isLengthAccess = (n) =>
 const isIndexAccess = (n) =>
   Array.isArray(n) && n[0] === '[]' && typeof n[1] === 'string'
 
-const isAssignOp = (op) =>
-  typeof op === 'string' && (op === '=' || (op.length > 1 && op.endsWith('=') && op !== '==' && op !== '===' && op !== '!=' && op !== '!==' && op !== '<=' && op !== '>='))
-
 const isStringLiteralRhs = (rhs) =>
   Array.isArray(rhs) && (rhs[0] === 'str' || (rhs[0] == null && typeof rhs[1] === 'string'))
 
@@ -354,11 +273,11 @@ const notStringEvidence = (body, names) => {
       markStringy(node[1])
     }
     // Index write: `xs[i] = v` or compound `xs[i] op= v`.
-    if (isAssignOp(op) && isIndexAccess(node[1]) && scope.has(node[1][1]) && !stringy.has(node[1][1])) {
+    if (ASSIGN_OPS.has(op) && isIndexAccess(node[1]) && scope.has(node[1][1]) && !stringy.has(node[1][1])) {
       writes.add(node[1][1])
     }
     // Length mutation: `xs.length = n`, `xs.length += k`, `xs.length++`.
-    if (isAssignOp(op) && isLengthAccess(node[1]) && scope.has(node[1][1]) && !stringy.has(node[1][1])) {
+    if (ASSIGN_OPS.has(op) && isLengthAccess(node[1]) && scope.has(node[1][1]) && !stringy.has(node[1][1])) {
       writes.add(node[1][1])
     }
     if ((op === '++' || op === '--') && isLengthAccess(node[1]) && scope.has(node[1][1]) && !stringy.has(node[1][1])) {
@@ -426,7 +345,17 @@ export function recordGlobalRep(name, expr) {
   // resolve its source schema by walking the global rep's shape tree at the
   // spread site (see shape walk in analyze.js / resolveSchema in object.js).
   const sh = shapeOfObjectLiteralAst(expr)
-  if (sh) updateGlobalRep(name, { jsonShape: sh })
+  if (sh) {
+    updateGlobalRep(name, { jsonShape: sh })
+    // A module-global object is read via __dyn_get (its props live behind a
+    // runtime key, not a function-local schema slot), which emits a `['str', key]`
+    // node at compile time. Ensure the string module's `str` emitter is bound now
+    // — a string-literal-free program (`let g = {l:{a:1}}; export let f = () => g.l`)
+    // would otherwise abort late with "Unknown op: str". Scoped to globals that
+    // actually capture an object shape, so string-free local-object programs keep
+    // their minimal bundle (and golden-size pins).
+    includeForStringValue()
+  }
 }
 
 // === Call-site argument inference =========================================