jz 0.5.1 → 0.7.0

package/src/param-reps.js

@@ -0,0 +1,65 @@
+/**
+ * Cross-call paramReps lattice — Map<funcName, Map<paramIdx, ValueRep fields>>.
+ *
+ * Cycle-free leaf consumed by narrow.js (fixpoint) and infer.js (call-site
+ * evidence producers).
+ *
+ * THE LATTICE (per field). Three states:
+ *   - BOTTOM = `undefined`  — unobserved / "no site has spoken yet".
+ *   - a value               — consensus across all sites seen so far.
+ *   - TOP    = `null`        — conflict: two sites disagreed. Sticky.
+ *
+ * The meet is monotone: meet(BOTTOM, x) = x, meet(x, x) = x, meet(x, y≠x) = TOP,
+ * meet(TOP, _) = TOP. Over a finite height-2 lattice it converges with NO resets —
+ * narrow.js's clearStickyNull (which used to un-stick a spurious "can't tell yet"
+ * poison) is gone entirely (root B closed). Two complementary policies keep it so:
+ *
+ *   - `val` runs SOFT (narrow.js mergeRule soft=true): a can't-tell-yet site is
+ *     skipped (stays BOTTOM), never poisoned, so a later pass — e.g. once pointer-
+ *     ABI enrichment puts VAL.TYPED into callerValTypes — simply fills it in. A
+ *     signature-mutating consumer (applyPointerParamAbi) can't trust this partial
+ *     soft value, so it re-folds the sites HARD (hardParamVal); a final hard sweep
+ *     settles `val` for emit + late readers (specializeBimorphicTyped, …).
+ *   - `schemaId` (and the others) stay HARD, but no longer get stuck: narrowValResults
+ *     is hoisted ABOVE the param lattice, so a call arg `f()` resolves to its VAL
+ *     result on the first pass and the can't-tell poison never forms.
+ *
+ * @module param-reps
+ */
+
+/** Build `paramName → fact` lookup for a caller's already-narrowed param facts. */
+export const paramFactsOf = (paramReps, callerFunc, key) => {
+  if (!callerFunc) return null
+  const m = paramReps.get(callerFunc.name)
+  if (!m) return null
+  let out = null
+  for (const [k, r] of m) {
+    const v = r[key]
+    if (v != null && k < callerFunc.sig.params.length) {
+      out ||= new Map()
+      out.set(callerFunc.sig.params[k].name, v)
+    }
+  }
+  return out
+}
+
+/** The meet itself: fold `observed` into a param's ValueRep field. BOTTOM
+ *  (undefined) → observed; equal → unchanged; disagreement → TOP (null, sticky).
+ *  A null `observed` is "can't tell" — whether that means BOTTOM (skip) or TOP
+ *  (poison) is the *caller's* policy: narrow.js's soft mergeRule skips before
+ *  calling here; the hard mergeRule / missing-arg path poisons by passing null. */
+export const mergeParamFact = (rep, key, observed) => {
+  if (rep[key] === null) return                                  // already TOP — sticky
+  if (observed == null) { rep[key] = null; return }              // caller chose to poison (hard path)
+  if (rep[key] === undefined) rep[key] = observed                // BOTTOM → first observation
+  else if (rep[key] !== observed) rep[key] = null                // disagreement → TOP
+}
+
+/** 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
+}

package/src/parse.js

@@ -0,0 +1,44 @@
+/**
+ * jz's parser entry — subscript's jessie dialect with one jz-specific override.
+ *
+ * `NaN` parses to the self-describing `['nan']` marker rather than subscript's
+ * default `[, NaN]` value-literal. A raw number-NaN (0x7FF8…) is ambiguous with
+ * jz's NaN-boxed value space: as the literal flows through the self-host kernel's
+ * parse/marshalling path it decodes back as a boxed value (object), so `() => NaN`
+ * would miscompile to `f64.const 0`. The string-tagged marker can't be mistaken
+ * for a number, survives intact, and emit() lowers it to the canonical quiet NaN
+ * (see compile/emit.js `op === 'nan'`). This mirrors subscript's own reason for
+ * encoding `undefined` as `[]` instead of `[, undefined]` (feature/literal.js).
+ * Infinity is 0x7FF0 — outside the NaN-box space — so it survives as a plain
+ * literal and needs no override.
+ */
+import { parse as jessieParse, token } from 'subscript/feature/jessie'
+
+// Strip a leading `#!` shebang line before subscript sees it. subscript registers the
+// shebang via `parse.comment['#!']='\n'` (feature/shebang.js) on a literal-seeded object,
+// then enumerates it — a cross-module dynamic-extension of a fixed-schema object that the
+// self-host kernel doesn't surface (the added key is stored but unenumerated). An explicit
+// strip is the conventional parser responsibility anyway (Node, V8 do the same), is
+// host/kernel-identical, and is independent of object-model internals.
+const parse = (src) => {
+  if (typeof src === 'string' && src.charCodeAt(0) === 35 && src.charCodeAt(1) === 33) {
+    const nl = src.indexOf('\n')
+    src = nl < 0 ? '' : src.slice(nl)
+  }
+  return jessieParse(src)
+}
+
+token('NaN', 200, a => !a && ['nan'])
+
+// `true`/`false` parse to the self-describing `['bool', 1|0]` marker rather than
+// subscript's `[, true]`/`[, false]` value-literal. The raw JS boolean degrades to
+// the bare number 1/0 as the literal flows through the self-host kernel's
+// parse/marshalling path, so `valTypeOf` reads VAL.NUMBER and the value loses its
+// VAL.BOOL kind — `typeof true` returns "number", `JSON.stringify(true)` yields "1".
+// The marker (op `'bool'`) is type-tagged by op, not by its degradable payload, so
+// valTypeOf returns VAL.BOOL unconditionally; emit lowers it to the same 0/1 carrier
+// (no perf cost). Same rationale as the `NaN` → `['nan']` override above.
+token('true', 200, a => !a && ['bool', 1])
+token('false', 200, a => !a && ['bool', 0])
+
+export { parse }