@scriptc/compiler 0.0.4 → 0.0.6

package/dist/backend/llvm/emitter.js

@@ -6,7 +6,7 @@ import { buildClassGraph, classFieldIndex, classStructSym, emitClassObjDefs, emi
 import { DK, LlDyn } from "./dyn.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
-import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, emitRecordShapes, FN_ATTRS, llFieldType, mapKeyAccess, mapKeyKindNum, mapValKindNum, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, emitRecordShapes, FN_ATTRS, llFieldType, mapKeyAccess, mapKeyKindNum, mapValKindNum, releaseSym, retainSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 export function emitLlvmModule(mod) {
     return new LlEmitter(mod).emit();
@@ -159,6 +159,8 @@ const LIB_FN_SYMS = {
     "assert.eqDyn": "scr_assert_eq_dyn",
     "assert.deepResult": "scr_assert_deep_result",
     "assert.sameValue": "scr_assert_same_value_f64",
+    "assert.deqEnter": "scr_assert_deq_enter",
+    "assert.deqLeave": "scr_assert_deq_leave",
     "assert.match": "scr_assert_match",
     "assert.throwsNone": "scr_assert_throws_none",
     "assert.throwsMismatch": "scr_assert_throws_mismatch",
@@ -229,6 +231,13 @@ const LIB_FN_SYMS = {
     "insp.key": "scr_insp_key",
     "insp.moreItems": "scr_insp_more_items",
     "insp.end": "scr_insp_end",
+    // Circular references over cycle-capable composites (Node's
+    // seen/circular machinery — none of these throw; refWrap borrows its
+    // string and answers +1).
+    "insp.circCheck": "scr_insp_circ_check",
+    "insp.seenPush": "scr_insp_seen_push",
+    "insp.refWrap": "scr_insp_ref_wrap",
+    "insp.circular": "scr_insp_circular",
     // WHATWG URL + URLSearchParams (scr_url.c / scr_url_params.c):
     // constructions +1; url.new, the fileURLToPath pair, the win32
     // pathToFileURL flavor, and sp.fromPairs throw catchably (may-throw).
@@ -1001,6 +1010,28 @@ class LlEmitter {
             this.declare(`declare void @scr_loop_run()`);
             this.declare(`declare zeroext i1 @scr_report_unhandled_rejections()`);
         }
+        // LIBRARY mode: the runtime entry points the generated library
+        // symbols delegate to — declared before the extern block flushes.
+        if (this.mod.lib !== undefined) {
+            this.declare(`declare void @scr_library_entry(i1 zeroext)`);
+            this.declare(`declare void @scr_library_reset()`);
+            this.declare(`declare void @scr_library_check_exc()`);
+            this.declare(`declare void @scr_library_set_sink(ptr, ptr)`);
+            this.declare(`declare void @scr_library_arena_reset()`);
+            this.declare(`declare void @scr_library_collect()`);
+            if (this.mod.lib.exports.some((e) => e.params.includes("string"))) {
+                this.declare(`declare ptr @scr_library_str_in(ptr, i64)`);
+            }
+            if (this.mod.lib.exports.some((e) => e.params.includes("bytes"))) {
+                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64)`);
+            }
+            if (this.mod.lib.exports.some((e) => e.returns === "string")) {
+                this.declare(`declare void @scr_library_str_out(ptr, ptr, ptr)`);
+            }
+            if (this.mod.lib.exports.some((e) => e.returns === "bytes")) {
+                this.declare(`declare void @scr_library_bytes_out(ptr, ptr, ptr)`);
+            }
+        }
         // Helpers assemble BEFORE the declaration table flushes (they add
         // write/abort declarations).
         const helpers = this.helperDefs();
@@ -1045,7 +1076,7 @@ class LlEmitter {
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
             `%ScrBox = type { i64, i32, ptr, ptr, ptr, i64 }`,
             // The stack buffer of the emitted JSON serializers { data, len, cap }.
-            `%ScrJsonBuf = type { ptr, i64, i64 }`,
+            `%ScrJsonBuf = type { ptr, i64, i64, ptr, i64, i64 }`,
             // The dynCheck error-path spine { parent, key, index } — the emitted
             // builders stack-allocate one per recursion level (dyn.ts).
             `%ScrDynPath = type { ptr, ptr, i64 }`,
@@ -1151,13 +1182,20 @@ class LlEmitter {
             out.push(`declare void @scr_error_set_traced()`, ``);
             stamps.push(`  call void @scr_error_set_traced()`);
         }
-        if (entryMayThrow || runsLoop) {
+        if ((entryMayThrow || runsLoop) && this.mod.lib === undefined) {
             // Declared inline: the extern block already flushed (LLVM is
             // order-free — the scr_error_set_traced precedent). Only the
             // printer emits here (nothing else declares it); scr_exc_pending
             // and the loop entry points rode the Set before the flush.
             out.push(`declare void @scr_exc_print_uncaught()`, ``);
         }
+        if (this.mod.lib !== undefined) {
+            // LIBRARY mode: no @main — the profile-declared external
+            // symbols instead, from the same IR facts the C emission consumes.
+            out.push(...this.emitLibDefs(globals, globalReleaseLines, stamps));
+            out.push(`attributes #0 = { sanitize_address }`, ``);
+            return out.join("\n");
+        }
         out.push(`define i32 @main(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, `  call void @scr_init()`, ...stamps, 
         // Event-surface programs (signal/exit listeners) fill the loop's
         // nullable event hooks before %main — scr_events.c links only when
@@ -1208,16 +1246,116 @@ class LlEmitter {
         `attributes #0 = { sanitize_address }`, ``);
         return out.join("\n");
     }
+    /** LIBRARY mode: the profile-declared external definitions — the
+     * export-map wrappers plus init / sink-registration / reset / collect.
+     * Plain `define` (not `define internal`) — the exact linkage distinction
+     * that separates the executable lane's @main from everything else. The
+     * bodies delegate every runtime half to scr_library.c, mirroring the C
+     * emission line for line, so the two lanes are identical by
+     * construction. */
+    emitLibDefs(globals, globalReleaseLines, stamps) {
+        const lib = this.mod.lib;
+        const autoReset = lib.resultResetSymbol === null;
+        const out = [``, `; ── library-mode entries (profile: ${lib.profileName}) ──`, ``];
+        // The init entry: full deterministic reset-and-reevaluate. Program
+        // globals release and zero first (run-once guards included), then the
+        // runtime session reset, the error-vt interval stamps verbatim from
+        // the executable main, %main itself, and the escaped-exception check.
+        const zeroStores = globals.map((g) => {
+            const ty = this.llType(g.type);
+            const zero = ty === "double" ? f64Lit(0) : ty === "ptr" ? "null" : "false";
+            return `  store ${ty} ${zero}, ptr @${mangleGlobal(g.id)} ; ${g.name}`;
+        });
+        out.push(`define void @${lib.initSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext true) ; init always resets the result arena`, ...globalReleaseLines("ci"), ...zeroStores, `  call void @scr_library_reset()`, ...stamps, `  call void @${mangleFunction(this.mod.entry)}()`, `  call void @scr_library_check_exc()`, `  ret void`, `}`, ``, `define void @${lib.sinkRegisterSymbol}(ptr %fn, ptr %ctx) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_set_sink(ptr %fn, ptr %ctx)`, `  ret void`, `}`, ``);
+        if (lib.resultResetSymbol !== null) {
+            out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false)`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
+        }
+        if (lib.collectSymbol !== null) {
+            out.push(`define void @${lib.collectSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false)`, `  call void @scr_library_collect() ; arena reset + a full cycle collection`, `  ret void`, `}`, ``);
+        }
+        for (const e of lib.exports) {
+            const params = [];
+            const body = [`  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"})`];
+            const args = [];
+            e.params.forEach((cls, i) => {
+                switch (cls) {
+                    case "f64":
+                        params.push(`double %a${i}`);
+                        args.push(`double %a${i}`);
+                        break;
+                    case "bool":
+                        params.push(`i8 %a${i}`);
+                        body.push(`  %c${i} = icmp ne i8 %a${i}, 0`);
+                        args.push(`i1 %c${i}`);
+                        break;
+                    case "u8":
+                        params.push(`i8 %a${i}`);
+                        body.push(`  %c${i} = uitofp i8 %a${i} to double`);
+                        args.push(`double %c${i}`);
+                        break;
+                    case "u32":
+                        params.push(`i32 %a${i}`);
+                        body.push(`  %c${i} = uitofp i32 %a${i} to double`);
+                        args.push(`double %c${i}`);
+                        break;
+                    case "i32":
+                        params.push(`i32 %a${i}`);
+                        body.push(`  %c${i} = sitofp i32 %a${i} to double`);
+                        args.push(`double %c${i}`);
+                        break;
+                    case "string":
+                        params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
+                        body.push(`  %c${i} = call ptr @scr_library_str_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
+                        args.push(`ptr %c${i}`);
+                        break;
+                    case "bytes":
+                        params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
+                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
+                        args.push(`ptr %c${i}`);
+                        break;
+                }
+            });
+            if (e.returns === "string" || e.returns === "bytes") {
+                params.push(`ptr %out`, `ptr %out_len`);
+            }
+            const target = `@${mangleFunction(e.fnName)}`;
+            const callArgs = args.join(", ");
+            let retType = "void";
+            switch (e.returns) {
+                case "void":
+                    body.push(`  call void ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  ret void`);
+                    break;
+                case "f64":
+                    retType = "double";
+                    body.push(`  %r = call double ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  ret double %r`);
+                    break;
+                case "bool":
+                    retType = "i8";
+                    body.push(`  %r = call i1 ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  %z = zext i1 %r to i8`, `  ret i8 %z`);
+                    break;
+                case "string":
+                    body.push(`  %r = call ptr ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  call void @scr_library_str_out(ptr %r, ptr %out, ptr %out_len)`, `  ret void`);
+                    break;
+                case "bytes":
+                    body.push(`  %r = call ptr ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  call void @scr_library_bytes_out(ptr %r, ptr %out, ptr %out_len)`, `  ret void`);
+                    break;
+            }
+            out.push(`define ${retType} @${e.symbol}(${params.join(", ")}) ${FN_ATTRS} { ; library export ${e.fnName}`, `entry:`, ...body, `}`, ``);
+        }
+        return out;
+    }
     /** The shared abort helpers (emitted only when referenced): the OOM
      * abort of untraced shape allocation and the invalid-union-tag abort —
      * both print the C emitter's exact message on fd 2 and abort. */
     helperDefs() {
         const defs = [];
         const msgHelper = (fnName, msgSym, msg) => {
+            // The message routes through the runtime's trap funnel: executable
+            // builds expand to the historical bytes-on-stderr + abort; library
+            // builds route to the registered panic sink (scr_runtime.h).
             const bytes = Buffer.byteLength(msg, "utf8");
-            this.declare(`declare i64 @write(i32, ptr, i64)`);
-            this.declare(`declare void @abort()`);
-            defs.push(`@${msgSym} = internal constant [${bytes} x i8] c"${llStrBytes(msg).slice(0, -3)}"`, `define internal void @${fnName}() ${FN_ATTRS} {`, `entry:`, `  %w = call i64 @write(i32 2, ptr @${msgSym}, i64 ${bytes})`, `  call void @abort()`, `  unreachable`, `}`, ``);
+            this.declare(`declare void @scr_trap(ptr)`);
+            defs.push(`@${msgSym} = internal constant [${bytes + 1} x i8] c"${llStrBytes(msg)}"`, `define internal void @${fnName}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_trap(ptr @${msgSym})`, `  unreachable`, `}`, ``);
         };
         if (this.needsOom)
             msgHelper("sc_oom", "sc_oom_msg", "scriptc: out of memory\n");
@@ -4582,6 +4720,12 @@ class LlEmitter {
                     const t = B.tmp();
                     B.line(`${t} = call ptr @scr_jb_finish(ptr ${buf})`);
                     compact = this.own({ name: t, type: e.type });
+                    // A cycle-capable root can throw the circular-structure
+                    // TypeError mid-walk: finish still runs (frees the buffer, the
+                    // partial string joins the frame and releases on unwind), then
+                    // the pending check unwinds — the C emitter's contract exactly.
+                    if (traceAdapter(this, e.value.type) !== null)
+                        this.emitPendingCheck();
                 }
                 // A pretty-print form (`stringify(v, null, 2)`): the frontend
                 // resolved the space to a compile-time indent string (Node's