@json-schema-engine/compiler 0.0.1

package/src/serialize/names.ts

@@ -0,0 +1,136 @@
+// Emitted identifier names and IR scans shared by the serializer's modules.
+
+import {
+  type LowerProduceValue,
+  type LowerStmt,
+} from "@json-schema-engine/core";
+import { type CodeChunk, id } from "../emit.js";
+import type { EmitOutput, UnitContext } from "./context.js";
+
+export const V = id("v"); // instance parameter
+export const D = id("d"); // depth parameter
+export const S = id("s"); // dynamic-scope parameter
+export const R = id("R"); // runtime closure
+export const T = id("T"); // interpreted-target table
+export const EV = id("ev"); // runtime coverage channel (region emission, phase B)
+export const EP = id("ep"); // evaluation-path prefix parameter (list emission)
+export const IP = id("ip"); // instance-pointer prefix parameter (list emission)
+export const ERRS = id("errs"); // error channel (list emission)
+export const ANNS = id("anns"); // annotation channel (annotation mode)
+export const ST = id("st"); // per-evaluation trace state (trace emission)
+export const TP = id("tp"); // parent application node parameter (trace emission)
+export const TN = id("tn"); // this application's node (trace emission)
+
+/** Which channels an emission threads through every application. */
+export interface ChannelShape {
+  output: EmitOutput;
+  annMode: boolean;
+  trace: boolean;
+}
+
+export const shapeOf = (ctx: UnitContext): ChannelShape => ({
+  output: ctx.output,
+  annMode: ctx.annMode,
+  trace: ctx.trace,
+});
+
+/**
+ * The arguments every application carries after the instance, depth, and
+ * scope: in list emission the two location prefixes and the record
+ * channels (the trace state and parent node under trace emission), and the
+ * coverage channel for an in-place region call. Unit signatures, unit
+ * calls, trampolines, and the root call all build from here, so the
+ * variants cannot drift apart. `locate` is called only in list emission —
+ * a flag-mode apply never computes its prefixes.
+ */
+export function channelArgs(
+  shape: ChannelShape,
+  locate: () => [CodeChunk, CodeChunk],
+  parent: CodeChunk,
+  ev: boolean,
+): CodeChunk[] {
+  const args: CodeChunk[] = [];
+  if (shape.output === "list") {
+    args.push(...locate());
+    if (shape.trace) args.push(ST, parent);
+    else {
+      args.push(ERRS);
+      if (shape.annMode) args.push(ANNS);
+    }
+  }
+  if (ev) args.push(EV);
+  return args;
+}
+
+/** The interpreter trampoline an emission calls for an interpreted target. */
+export function fragHelper(
+  shape: ChannelShape,
+  inPlaceRegion: boolean,
+): CodeChunk {
+  if (shape.output !== "list") return id(inPlaceRegion ? "h_fragc" : "h_frag");
+  if (shape.trace) return id("h_fragt");
+  return id(shape.annMode ? "h_fragla" : "h_fragl");
+}
+
+export const unitFn = (index: number): CodeChunk => id("u" + String(index));
+// Region-variant of a unit function: same body with the trailing coverage
+// channel threaded (COMPILED-CONSUMERS.md phase B). A distinct name so a unit
+// can carry both a plain and a channel-threaded emission.
+export const unitFnRegion = (index: number): CodeChunk =>
+  id("u" + String(index) + "c");
+export const bindingVar = (n: number): CodeChunk => id("b" + String(n));
+export const regexConst = (i: number): CodeChunk => id("r" + String(i));
+export const formatConst = (i: number): CodeChunk => id("fmt" + String(i));
+export const counterVar = (n: number): CodeChunk => id("c" + String(n));
+export const foldVar = (n: number): CodeChunk => id("f" + String(n));
+
+/** First `produce` node in a keyword's lowered statement list (searched into blocks). */
+export function findProduce(
+  stmts: readonly LowerStmt[],
+): LowerProduceValue | null {
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "produce":
+        return stmt.value;
+      case "if": {
+        const t = findProduce(stmt.then);
+        if (t) return t;
+        if (stmt.else) {
+          const e = findProduce(stmt.else);
+          if (e) return e;
+        }
+        break;
+      }
+      case "forEachKey":
+      case "forEachIndex": {
+        const b = findProduce(stmt.body);
+        if (b) return b;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return null;
+}
+
+/** True when a keyword's lowered statement list contains an `annotate` node (searched into blocks). */
+export function hasAnnotate(stmts: readonly LowerStmt[]): boolean {
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "annotate":
+        return true;
+      case "if":
+        if (hasAnnotate(stmt.then) || (stmt.else && hasAnnotate(stmt.else)))
+          return true;
+        break;
+      case "forEachKey":
+      case "forEachIndex":
+        if (hasAnnotate(stmt.body)) return true;
+        break;
+      default:
+        break;
+    }
+  }
+  return false;
+}

package/src/serialize/spans.ts

@@ -0,0 +1,88 @@
+// Channel spans at application boundaries: the annotation and coverage
+// channels mark before an application and truncate when it fails (rule 3).
+
+import { type CodeChunk, id, join, js } from "../emit.js";
+import { ANNS, EV, ST, TN } from "./names.js";
+import { UnitContext } from "./context.js";
+
+/** One marked channel: the annotation channel or the coverage channel. */
+export interface Span {
+  kind: "anns" | "ev";
+  m: CodeChunk;
+}
+
+/** The annotation channel's current length: the value a span mark takes. */
+export function annsLength(ctx: UnitContext): CodeChunk {
+  return ctx.trace ? js`${ST}.anns.length` : js`${ANNS}.length`;
+}
+
+/**
+ * Drop the annotations pushed since mark `m` (a failed application's).
+ * Trace emission routes the cut through the runtime, which discards or
+ * retains them by the artifact's level.
+ */
+export function annsCut(ctx: UnitContext, m: CodeChunk): CodeChunk {
+  return ctx.trace
+    ? js`${id("h_cutA")}(${ST}, ${m});`
+    : js`${ANNS}.length = ${m};`;
+}
+
+/** Push one annotation unit; trace emission records the application with it. */
+export function annsPush(ctx: UnitContext, unit: CodeChunk): CodeChunk {
+  return ctx.trace
+    ? js`${id("h_ann")}(${ST}, ${TN}, ${unit});`
+    : js`${ANNS}.push(${unit});`;
+}
+
+/**
+ * The channel spans active at an application boundary: `anns` in annotation
+ * mode, `ev` in region emission, both when composed, none otherwise. errs
+ * is not one of them: a failed application keeps its errors (they become
+ * irrelevant only when an enclosing KEYWORD accepts, draft-03 §12.2), so
+ * error truncation is keyword-scoped — see errMark() — not per branch.
+ */
+export function channelSpans(ctx: UnitContext, includeEv = true): Span[] {
+  const spans: Span[] = [];
+  if (ctx.annMode) {
+    spans.push({ kind: "anns", m: id("m" + String(ctx.counters.temp++)) });
+  }
+  if (ctx.regionMode && includeEv) {
+    spans.push({ kind: "ev", m: id("m" + String(ctx.counters.temp++)) });
+  }
+  return spans;
+}
+
+export function spanDecls(ctx: UnitContext, spans: Span[]): CodeChunk {
+  return join(
+    " ",
+    spans.map(({ kind, m }) =>
+      kind === "anns"
+        ? js`const ${m} = ${annsLength(ctx)};`
+        : js`const ${m} = ${EV}.length;`,
+    ),
+  );
+}
+
+export function spanResets(ctx: UnitContext, spans: Span[]): CodeChunk {
+  return join(
+    " ",
+    spans.map(({ kind, m }) =>
+      kind === "anns" ? annsCut(ctx, m) : js`${EV}.length = ${m};`,
+    ),
+  );
+}
+
+/**
+ * One grouped-fold branch: run `call`, apply `hit` on success, truncate the
+ * active channel spans on failure (a failed branch's records and
+ * coverage discard; a passing branch's merge — channel rule 3 per branch).
+ */
+export function branchSpan(
+  ctx: UnitContext,
+  call: CodeChunk,
+  hit: CodeChunk,
+): CodeChunk {
+  const spans = channelSpans(ctx);
+  if (spans.length === 0) return js`if (${call}) { ${hit} }`;
+  return js`{ ${spanDecls(ctx, spans)} if (${call}) { ${hit} } else { ${spanResets(ctx, spans)} } }`;
+}