@scriptc/compiler 0.2.6 → 0.2.7

package/dist/backend/llvm/dyn.d.ts

@@ -22,6 +22,8 @@ export declare const DYN_KIND: {
  * unit instances (undefined-armed dynCheck targets build them). */
 export interface DynHost extends WalkerHost {
     unitInstanceRef(unionId: string, tag: number): string;
+    /** The immortal ABSENT field-slot state of an undefined-armed union. */
+    absentInstanceRef(unionId: string): string;
     liveDynRefAdapter(t: IrType): {
         snapshot: string;
         commit: string;
@@ -82,6 +84,19 @@ export declare class LlDyn {
     private undef;
     /** scr_dyn_obj_get with a compile-time key: borrowed member or null. */
     private objGetLit;
+    /** Branches past the caller's next emission when an undefined-armed
+     * field value is the ABSENT state. Returns the label the caller must branch
+     * to and start after its emission, or null when the type has no
+     * undefined arm. */
+    private skipIfAbsent;
+    /** A checked undefined-armed field value, or the field's ABSENT state
+     * when the value is undefined because the source object has no own
+     * property of that name (a missing JSON key stays missing; an explicit
+     * undefined stays present). Proxy sources answer through their reads, so
+     * they count as present. The checked value is a +1 union; replacing it
+     * with the immortal absent instance releases nothing (unit instances are
+     * immortal too). */
+    private presenceOf;
     /** Ordinary property lookup, including inherited data and accessors (+1). */
     private objReadLit;
     /** Appends a borrowed string, preserving its full byte length. */
@@ -99,6 +114,25 @@ export declare class LlDyn {
     private typedRefMatches;
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
     dynMatchHelper(t: IrType, preserveRefs?: boolean): string;
+    private readonly jsonSchemas;
+    private readonly jsonParsers;
+    /** Targets the one-pass parser (scr_json_parse_schema) can build
+     * directly: number, boolean and string leaves inside arrays and plain
+     * records (no tuple, index signature, internal '%' slot or `__proto__`
+     * member; 1..64 fields). Everything else keeps the checked-dynamic
+     * route alone. */
+    private jsonSchemaSupported;
+    /** The ScrJsonSchema constant for t (scr_runtime.h layout). Records list
+     * fields in declaration order — the order JSON.stringify writes — so the
+     * runtime's next-field guess usually matches without a scan. */
+    private jsonSchema;
+    /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
+     * is not a schema target. Tries the one-pass schema parser; when it
+     * declines (any input the checked route might reject or read
+     * differently), runs the checked-dynamic route — scr_json_parse plus the
+     * dynCheck builder — which reports the exact error. Returns +1, or null
+     * with the pending flag set. */
+    jsonParseHelper(t: IrType): string | null;
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
      * TypeError and return a dummy with the pending flag set. */

package/dist/backend/llvm/dyn.js

@@ -1,5 +1,5 @@
 import { typedRefConstructor } from "./shapes.js";
-import { BYTES_ELEM_NUM, f64Lit } from "./common.js";
+import { BYTES_ELEM_NUM, emitFieldAbsentTest, f64Lit } from "./common.js";
 import { InternalCompilerError } from "../../errors.js";
 import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
@@ -254,6 +254,64 @@ export class LlDyn {
         B.line(`${t} = call ptr @scr_dyn_obj_get(ptr ${d}, ptr ${this.host.cstr(key)}, ${this.S} ${len}) ; .${llvmCommentText(key)}`);
         return t;
     }
+    /** Branches past the caller's next emission when an undefined-armed
+     * field value is the ABSENT state. Returns the label the caller must branch
+     * to and start after its emission, or null when the type has no
+     * undefined arm. */
+    skipIfAbsent(B, value, t) {
+        const def = this.host.unionsById.get(t.unionId);
+        const utag = def ? def.arms.findIndex((arm) => arm.kind === "undefinedT") : -1;
+        if (utag < 0)
+            return null;
+        const absent = emitFieldAbsentTest(B, value, utag);
+        const lSkip = B.newLabel("tdr.absent");
+        const lSet = B.newLabel("tdr.set");
+        B.condBr(absent, lSkip, lSet);
+        B.startBlock(lSet);
+        return lSkip;
+    }
+    /** A checked undefined-armed field value, or the field's ABSENT state
+     * when the value is undefined because the source object has no own
+     * property of that name (a missing JSON key stays missing; an explicit
+     * undefined stays present). Proxy sources answer through their reads, so
+     * they count as present. The checked value is a +1 union; replacing it
+     * with the immortal absent instance releases nothing (unit instances are
+     * immortal too). */
+    presenceOf(B, d, key, t, value) {
+        const def = this.host.unionsById.get(t.unionId);
+        const utag = def ? def.arms.findIndex((arm) => arm.kind === "undefinedT") : -1;
+        if (utag < 0)
+            return value;
+        const tp = B.tmp();
+        const tag = B.tmp();
+        const isUndef = B.tmp();
+        B.line(`${tp} = getelementptr inbounds %ScrUnion, ptr ${value}, i64 0, i32 1`);
+        B.line(`${tag} = load i32, ptr ${tp}`);
+        B.line(`${isUndef} = icmp eq i32 ${tag}, ${utag}`);
+        const kind = this.kindOf(B, d);
+        const isObj = B.tmp();
+        B.line(`${isObj} = icmp eq i32 ${kind}, ${DYN_KIND.OBJ}`);
+        const probe = B.tmp();
+        B.line(`${probe} = and i1 ${isUndef}, ${isObj}`);
+        const slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca ptr`);
+        B.line(`store ptr ${value}, ptr ${slot}`);
+        const lProbe = B.newLabel("dcr.has");
+        const lJoin = B.newLabel("dcr.hasj");
+        B.condBr(probe, lProbe, lJoin);
+        B.startBlock(lProbe);
+        const own = this.objGetLit(B, d, key);
+        const missing = B.tmp();
+        const chosen = B.tmp();
+        B.line(`${missing} = icmp eq ptr ${own}, null`);
+        B.line(`${chosen} = select i1 ${missing}, ptr ${this.host.absentInstanceRef(t.unionId)}, ptr ${value}`);
+        B.line(`store ptr ${chosen}, ptr ${slot}`);
+        B.br(lJoin);
+        B.startBlock(lJoin);
+        const out = B.tmp();
+        B.line(`${out} = load ptr, ptr ${slot}`);
+        return out;
+    }
     /** Ordinary property lookup, including inherited data and accessors (+1). */
     objReadLit(B, d, key) {
         this.host.declare(`declare ptr @scr_dyn_obj_read(ptr, ptr, ${this.S})`);
@@ -676,6 +734,121 @@ export class LlDyn {
         this.defs.push(`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`, B.render(), `}`, ``);
         return name;
     }
+    /* ── schema-directed JSON.parse ───────────────────────────────── */
+    jsonSchemas = new Map();
+    jsonParsers = new Map();
+    /** Targets the one-pass parser (scr_json_parse_schema) can build
+     * directly: number, boolean and string leaves inside arrays and plain
+     * records (no tuple, index signature, internal '%' slot or `__proto__`
+     * member; 1..64 fields). Everything else keeps the checked-dynamic
+     * route alone. */
+    jsonSchemaSupported(t, visiting) {
+        switch (t.kind) {
+            case "f64":
+            case "bool":
+            case "string":
+                return true;
+            case "array":
+                return this.jsonSchemaSupported(t.elem, visiting);
+            case "record": {
+                if (visiting.has(t.shapeId))
+                    return true;
+                const shape = this.host.recordsById.get(t.shapeId);
+                if (!shape || shape.tuple || shape.indexValue)
+                    return false;
+                if (shape.fields.length === 0 || shape.fields.length > 64)
+                    return false;
+                visiting.add(t.shapeId);
+                return shape.fields.every((f) => !f.name.startsWith("%") &&
+                    f.name !== "__proto__" &&
+                    this.jsonSchemaSupported(f.type, visiting));
+            }
+            default:
+                return false;
+        }
+    }
+    /** The ScrJsonSchema constant for t (scr_runtime.h layout). Records list
+     * fields in declaration order — the order JSON.stringify writes — so the
+     * runtime's next-field guess usually matches without a scan. */
+    jsonSchema(t) {
+        const key = typeKey(t);
+        const existing = this.jsonSchemas.get(key);
+        if (existing)
+            return existing;
+        const host = this.host;
+        const S = host.sizeType;
+        const name = `sc_jsch_${this.jsonSchemas.size}`;
+        this.jsonSchemas.set(key, name);
+        let body;
+        switch (t.kind) {
+            case "f64":
+            case "bool":
+            case "string": {
+                const kind = t.kind === "f64" ? 0 : t.kind === "bool" ? 1 : 2;
+                body = `${S} ${kind}, ${S} 0, ptr null, ptr null, ptr null, ptr null, ptr null`;
+                break;
+            }
+            case "array": {
+                const elem = this.jsonSchema(t.elem);
+                const ctor = `${name}_new`;
+                this.defs.push(`define internal ptr @${ctor}(${S} %cap) ${FN_ATTRS} {`, `entry:`, `  %a = ${arrNewCall(host, t.elem, "%cap")}`, `  ret ptr %a`, `}`, ``);
+                body = `${S} 4, ${S} 0, ptr null, ptr @${elem}, ptr null, ptr @${ctor}, ptr ${vAdapters(host, t).release}`;
+                break;
+            }
+            case "record": {
+                const shape = host.recordsById.get(t.shapeId);
+                if (!shape)
+                    throw new InternalCompilerError(`llvm emitter bug: JSON schema of unknown shape ${t.shapeId}`);
+                const struct = mangleRecordStruct(t.shapeId);
+                const index = new Map(shape.fields.map((f, i) => [f.name, i + 1]));
+                const order = [...(shape.declaredOrder ?? []).filter((n) => index.has(n))];
+                for (const f of shape.fields)
+                    if (!order.includes(f.name))
+                        order.push(f.name);
+                const fieldTy = `{ ptr, ${S}, ${S}, ptr }`;
+                const entries = order.map((fieldName) => {
+                    const field = shape.fields[index.get(fieldName) - 1];
+                    const sub = this.jsonSchema(field.type);
+                    const offset = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i64 0, i32 ${index.get(fieldName)}) to ${S})`;
+                    return `${fieldTy} { ptr ${host.cstr(fieldName)}, ${S} ${Buffer.byteLength(fieldName, "utf8")}, ${S} ${offset}, ptr @${sub} }`;
+                });
+                const fields = `${name}_fields`;
+                this.defs.push(`@${fields} = internal constant [${entries.length} x ${fieldTy}] [${entries.join(", ")}]`, ``);
+                body = `${S} 3, ${S} ${entries.length}, ptr @${fields}, ptr null, ptr @${mangleRecordNew(t.shapeId)}, ptr null, ptr ${vAdapters(host, t).release}`;
+                break;
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: JSON schema of ${t.kind}`);
+        }
+        this.defs.push(`@${name} = internal constant { ${S}, ${S}, ptr, ptr, ptr, ptr, ptr } { ${body} }`, ``);
+        return name;
+    }
+    /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
+     * is not a schema target. Tries the one-pass schema parser; when it
+     * declines (any input the checked route might reject or read
+     * differently), runs the checked-dynamic route — scr_json_parse plus the
+     * dynCheck builder — which reports the exact error. Returns +1, or null
+     * with the pending flag set. */
+    jsonParseHelper(t) {
+        if (t.kind !== "record" && t.kind !== "array")
+            return null;
+        const key = typeKey(t);
+        const existing = this.jsonParsers.get(key);
+        if (existing)
+            return existing;
+        if (!this.jsonSchemaSupported(t, new Set()))
+            return null;
+        const host = this.host;
+        const name = `sc_jp_${this.jsonParsers.size}`;
+        this.jsonParsers.set(key, name);
+        const schema = this.jsonSchema(t);
+        const check = this.dynCheckHelper(t);
+        host.declare(`declare ptr @scr_json_parse_schema(ptr, ptr)`);
+        host.declare(`declare ptr @scr_json_parse(ptr)`);
+        host.declare(`declare void @scr_dyn_release(ptr)`);
+        this.defs.push(`define internal ptr @${name}(ptr %text) ${FN_ATTRS} { ; JSON.parse as ${llvmCommentText(key)}`, `entry:`, `  %fast = call ptr @scr_json_parse_schema(ptr %text, ptr @${schema})`, `  %hit = icmp ne ptr %fast, null`, `  br i1 %hit, label %done, label %slow`, `done:`, `  ret ptr %fast`, `slow:`, `  %d = call ptr @scr_json_parse(ptr %text)`, `  %bad = icmp eq ptr %d, null`, `  br i1 %bad, label %fail, label %check`, `fail:`, `  ret ptr null`, `check:`, `  %v = call ptr @${check}(ptr %d, ptr null)`, `  call void @scr_dyn_release(ptr %d)`, `  ret ptr %v`, `}`, ``);
+        return name;
+    }
     /* ── dynCheckHelper (walkers.ts, ported) ──────────────────────── */
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
@@ -1147,6 +1320,11 @@ export class LlDyn {
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     storeInto(f.name, f.type, value);
                     this.pendingBail(B, "dcr", releaseR, "ptr null");
+                    if (f.type.kind === "union") {
+                        const stored = this.presenceOf(B, "%d", f.name, f.type, value);
+                        if (stored !== value)
+                            storeInto(f.name, f.type, stored);
+                    }
                 }
                 // Index-signature shapes CAPTURE undeclared keys into the
                 // overflow map.
@@ -1457,6 +1635,10 @@ export class LlDyn {
                 B.line(`store ptr ${box}, ptr ${capp}`);
                 const rd = this.retainDyn(B, "%d");
                 B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${rd})`);
+                // The shim is the same JS function under another signature: it
+                // takes the boxed closure's identity (kept alive through caps[0]).
+                host.declare(`declare void @scr_dyn_adopt_identity(ptr, ptr)`);
+                B.line(`call void @scr_dyn_adopt_identity(ptr ${a}, ptr %d)`);
                 B.terminate(`ret ptr ${a}`);
                 break;
             }
@@ -1695,9 +1877,15 @@ export class LlDyn {
                 for (const f of dynFields) {
                     const klen = Buffer.byteLength(f.name, "utf8");
                     const fv = loadFieldOf(f.name, f.type);
+                    // An ABSENT optional field contributes no key.
+                    const lSkip = f.type.kind === "union" ? this.skipIfAbsent(B, fv, f.type) : null;
                     const conv = B.tmp();
                     B.line(`${conv} = call ptr @${this.toDynHelper(f.type)}(${this.valTy(f.type)} ${fv})`);
                     B.line(`call void @scr_dyn_obj_set(ptr ${d}, ptr ${host.cstr(f.name)}, ${host.sizeType} ${klen}, ptr ${conv}) ; ${llvmCommentText(f.name)}`);
+                    if (lSkip !== null) {
+                        B.br(lSkip);
+                        B.startBlock(lSkip);
+                    }
                 }
                 if (shape.indexValue) {
                     const iv = shape.indexValue;