@scriptc/compiler 0.1.1 → 0.1.2

package/dist/backend/c/exprs.js

@@ -1,5 +1,5 @@
 import { InternalCompilerError } from "../../errors.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
 import { boxAccess, BYTES_NUM_KIND_C, BYTES_NUM_VAR_C, bytesElemKindC, cDecl, cFnPtrCast, cNumberLiteral, cStringLiteral, cType, DV_GET_KIND_C, DV_SET_KIND_C, elemAccess, mapKeyAccess, mapKeyKindC, mapValKindC, releaseCallC, retainCallC, vAdapters } from "./types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordClone, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./shapes.js";
@@ -20,6 +20,23 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
         defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ScrArr *sc_target = (ScrArr *)sc_p;`, `  ScrArr *sc_next = ${emitter.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`, `  size_t sc_target_len = sc_target->len;`, `  size_t sc_target_cap = sc_target->cap;`, `  uint64_t *sc_target_data = sc_target->data;`, `  uint8_t *sc_target_present = sc_target->present;`, `  ScrArrSparseSlot *sc_target_sparse = sc_target->sparse;`, `  size_t sc_target_sparse_len = sc_target->sparse_len;`, `  size_t sc_target_sparse_cap = sc_target->sparse_cap;`, `  ScrArrProp *sc_target_props = sc_target->props;`, `  size_t sc_target_prop_len = sc_target->prop_len;`, `  size_t sc_target_prop_cap = sc_target->prop_cap;`, `  sc_target->len = sc_next->len;`, `  sc_target->cap = sc_next->cap;`, `  sc_target->data = sc_next->data;`, `  sc_target->present = sc_next->present;`, `  sc_target->sparse = sc_next->sparse;`, `  sc_target->sparse_len = sc_next->sparse_len;`, `  sc_target->sparse_cap = sc_next->sparse_cap;`, `  sc_target->props = sc_next->props;`, `  sc_target->prop_len = sc_next->prop_len;`, `  sc_target->prop_cap = sc_next->prop_cap;`, `  sc_next->len = sc_target_len;`, `  sc_next->cap = sc_target_cap;`, `  sc_next->data = sc_target_data;`, `  sc_next->present = sc_target_present;`, `  sc_next->sparse = sc_target_sparse;`, `  sc_next->sparse_len = sc_target_sparse_len;`, `  sc_next->sparse_cap = sc_target_sparse_cap;`, `  sc_next->props = sc_target_props;`, `  sc_next->prop_len = sc_target_prop_len;`, `  sc_next->prop_cap = sc_target_prop_cap;`, `  scr_arr_release(sc_next);`, `}`, ``);
         return `&${commit}`;
     }
+    if (isDynTypedRefType(t)) {
+        const meta = emitter.classMeta.get(t.className);
+        if (!meta) {
+            throw new InternalCompilerError(`emitter bug: typed-ref commit of unknown class ${t.className}`);
+        }
+        const commit = `${snapshot}_commit`;
+        emitter.walkerProtos.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d); /* commit unknown class ${typeKey(t)} */`);
+        defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ${cDecl(t, "sc_target")} = (${cType(t).trim()})sc_p;`);
+        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name))) {
+            const member = mangleField(field.name);
+            const keyLit = cStringLiteral(Buffer.from(field.name, "utf8"));
+            const keyLen = Buffer.byteLength(field.name, "utf8");
+            defs.push(`  {`, `    const ScrDyn *sc_member = scr_dyn_obj_get(sc_d, ${keyLit}, ${keyLen});`, `    ${cDecl(field.type, "sc_next")} = ${emitter.dynCheckHelper(field.type)}(sc_member ? sc_member : scr_dyn_undefined(), NULL);`, `    if (scr_exc_pending()) return;`, `    ${cDecl(field.type, "sc_old")} = sc_target->${member};`, `    sc_target->${member} = sc_next;`, ...(isRefCounted(field.type) ? [`    ${releaseCallC(field.type, "sc_old")};`] : ["    (void)sc_old;"]), `  }`);
+        }
+        defs.push(`}`, ``);
+        return `&${commit}`;
+    }
     if (t.kind !== "record")
         return "NULL";
     const shape = emitter.recordsById.get(t.shapeId);
@@ -39,6 +56,51 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     defs.push(`  ${releaseCallC(t, "sc_next")};`, `}`, ``);
     return `&${commit}`;
 }
+/** Boxes a union selected at runtime, preserving mutable/class arm identity
+ * while converting scalar and unit arms normally. It shares the enclosing
+ * adapter context so recursive class fields reuse the prototype already
+ * registered by streamTypedRefAdapter instead of recursing forever. */
+function nestedTypedRefUnionAdapter(emitter, t, ctx) {
+    const key = typeKey(t);
+    const unions = (ctx.unions ??= new Map());
+    const existing = unions.get(key);
+    if (existing)
+        return existing;
+    const def = emitter.unionsById.get(t.unionId);
+    if (!def)
+        throw new InternalCompilerError(`emitter bug: typed-ref union ${t.unionId} is undeclared`);
+    const sym = `${ctx.prefix}_union_${unions.size}`;
+    unions.set(key, sym);
+    emitter.walkerProtos.push(`static ScrDyn *${sym}(ScrUnion *sc_u); /* typed-ref union ${key} */`);
+    const lines = [`static ScrDyn *${sym}(ScrUnion *sc_u) {`, `  switch (sc_u->tag) {`];
+    def.arms.forEach((arm, tag) => {
+        if (streamTypedRefEligible(arm) || isDynTypedRefType(arm)) {
+            const adapter = streamTypedRefAdapter(emitter, arm, ctx);
+            const rc = vAdapters(arm);
+            const armKey = typeKey(arm);
+            const keyLit = cStringLiteral(Buffer.from(armKey, "utf8"));
+            lines.push(`  case ${tag}: return scr_dyn_new_typed_ref(scr_union_peek(sc_u), &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(armKey, "utf8")}, &${adapter.snapshot}, ${adapter.commit});`);
+        }
+        else if (arm.kind === "undefinedT") {
+            lines.push(`  case ${tag}: return scr_dyn_retain(scr_dyn_undefined());`);
+        }
+        else if (arm.kind === "nullT") {
+            lines.push(`  case ${tag}: return scr_dyn_new_null();`);
+        }
+        else if (arm.kind === "f64") {
+            lines.push(`  case ${tag}: return scr_dyn_new_num(scr_union_get_f64(sc_u));`);
+        }
+        else if (arm.kind === "bool") {
+            lines.push(`  case ${tag}: return scr_dyn_new_bool(scr_union_get_bool(sc_u));`);
+        }
+        else {
+            lines.push(`  case ${tag}: return ${emitter.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(sc_u));`);
+        }
+    });
+    lines.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
+    ctx.defs.push(...lines);
+    return sym;
+}
 /** Build the live dyn view of one typed stream value. Mutable reference
  * children are capsules of their own, so a write through `v.child.x` or
  * `v.items[0]` commits directly to that child's static source instead of
@@ -57,7 +119,11 @@ function streamTypedRefAdapter(emitter, t, ctx, preferredSnapshot) {
     emitter.walkerProtos.push(`static ScrDyn *${snapshot}(void *sc_p); /* materialize live stream value ${key} */`);
     adapter.commit = streamTypedRefCommitAdapter(emitter, t, snapshot, ctx.defs);
     const box = (child, expr) => {
-        if (!streamTypedRefEligible(child)) {
+        if (child.kind === "union" &&
+            (emitter.unionsById.get(child.unionId)?.arms.some((arm) => streamTypedRefEligible(arm) || isDynTypedRefType(arm)) ?? false)) {
+            return `${nestedTypedRefUnionAdapter(emitter, child, ctx)}(${expr})`;
+        }
+        if (!streamTypedRefEligible(child) && !isDynTypedRefType(child)) {
             return `${emitter.toDynHelper(child)}(${expr})`;
         }
         const nested = streamTypedRefAdapter(emitter, child, ctx);
@@ -70,7 +136,19 @@ function streamTypedRefAdapter(emitter, t, ctx, preferredSnapshot) {
         `static ScrDyn *${snapshot}(void *sc_p) { /* materialize live stream value ${key} */`,
         `  ${cDecl(t, "v")} = (${cType(t).trim()})sc_p;`,
     ];
-    if (t.kind === "record") {
+    if (isDynTypedRefType(t)) {
+        const meta = emitter.classMeta.get(t.className);
+        if (!meta) {
+            throw new InternalCompilerError(`emitter bug: typed-ref materialize of unknown class ${t.className}`);
+        }
+        lines.push(`  ScrDyn *d = scr_dyn_new_obj();`);
+        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name))) {
+            const keyLit = cStringLiteral(Buffer.from(field.name, "utf8"));
+            lines.push(`  scr_dyn_obj_set(d, ${keyLit}, ${Buffer.byteLength(field.name, "utf8")}, ${box(field.type, `v->${mangleField(field.name)}`)});`);
+        }
+        lines.push(`  return d;`);
+    }
+    else if (t.kind === "record") {
         const shape = emitter.recordsById.get(t.shapeId);
         if (!shape) {
             throw new InternalCompilerError(`emitter bug: stream typed-ref materialize of unknown shape ${t.shapeId}`);
@@ -132,7 +210,7 @@ function liveDynRefAdapter(emitter, t) {
     const existing = emitter.liveDynRefAdapters.get(key);
     if (existing)
         return existing;
-    if (!streamTypedRefEligible(t)) {
+    if (!streamTypedRefEligible(t) && !isDynTypedRefType(t)) {
         throw new InternalCompilerError(`emitter bug: live dyn ref of ${key}`);
     }
     const prefix = `sc_ldr_${emitter.liveDynRefAdapters.size}`;
@@ -157,7 +235,7 @@ function liveDynUnionRefAdapter(emitter, t) {
     }
     const mutableArms = union.arms
         .map((arm, tag) => ({ arm, tag }))
-        .filter(({ arm }) => streamTypedRefEligible(arm));
+        .filter(({ arm }) => streamTypedRefEligible(arm) || isDynTypedRefType(arm));
     if (mutableArms.length === 0) {
         throw new InternalCompilerError(`emitter bug: live dyn ref of immutable union ${key}`);
     }
@@ -179,7 +257,27 @@ function liveDynUnionRefAdapter(emitter, t) {
         const keyLit = cStringLiteral(Buffer.from(armKey, "utf8"));
         defs.push(`  case ${tag}:`, `    return scr_dyn_new_typed_ref(scr_union_peek(sc_u), &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(armKey, "utf8")}, &${adapter.snapshot}, ${adapter.commit});`);
     }
-    defs.push(`  default:`, `    return ${emitter.toDynHelper(t)}(sc_u);`, `  }`, `}`, ``);
+    const mutableTags = new Set(mutableArms.map(({ tag }) => tag));
+    union.arms.forEach((arm, tag) => {
+        if (mutableTags.has(tag))
+            return;
+        if (arm.kind === "undefinedT") {
+            defs.push(`  case ${tag}: return scr_dyn_retain(scr_dyn_undefined());`);
+        }
+        else if (arm.kind === "nullT") {
+            defs.push(`  case ${tag}: return scr_dyn_new_null();`);
+        }
+        else if (arm.kind === "f64") {
+            defs.push(`  case ${tag}: return scr_dyn_new_num(scr_union_get_f64(sc_u));`);
+        }
+        else if (arm.kind === "bool") {
+            defs.push(`  case ${tag}: return scr_dyn_new_bool(scr_union_get_bool(sc_u));`);
+        }
+        else {
+            defs.push(`  case ${tag}: return ${emitter.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(sc_u));`);
+        }
+    });
+    defs.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
     emitter.walkerDefs.push(...defs);
     return sym;
 }
@@ -2390,7 +2488,10 @@ function emitDynamicExpr(emitter, e) {
                     : "scr_dyn_new_null()");
             }
             const v = emitter.emitExpr(e.value);
-            if (e.liveRef) {
+            const identityRef = isDynTypedRefType(v.type) ||
+                (v.type.kind === "union" &&
+                    (emitter.unionsById.get(v.type.unionId)?.arms.some(isDynTypedRefType) ?? false));
+            if (e.liveRef || identityRef) {
                 if (v.type.kind === "union") {
                     const adapter = liveDynUnionRefAdapter(emitter, v.type);
                     return emitter.newTemp(e.type, `${adapter}(${v.name})`);
@@ -3072,6 +3173,8 @@ function emitAsyncExpr(emitter, e) {
                 throw new InternalCompilerError("emitter bug: yieldExpr with no operand (frontend fills undefined)");
             const v = emitter.emitExpr(e.value);
             const yt = e.value.type;
+            if (e.awaited)
+                emitter.line(`scr_async_gen_hop_done();`);
             if (yt.kind === "f64" || yt.kind === "date") {
                 emitter.line(`scr_gen_yield_f64(${v.name});${emitter.srcComment(e.loc)}`);
             }
@@ -3105,8 +3208,9 @@ function emitAsyncExpr(emitter, e) {
             const genT = e.gen.type;
             if (genT.kind !== "generator")
                 throw new InternalCompilerError("emitter bug: genResume on a non-generator");
-            if (e.type.kind !== "record")
-                throw new InternalCompilerError("emitter bug: genResume result is not a record");
+            const resultT = genT.async ? (e.type.kind === "promise" ? e.type.inner : null) : e.type;
+            if (resultT?.kind !== "record")
+                throw new InternalCompilerError("emitter bug: genResume result is not an IteratorResult record");
             const g = emitter.emitExpr(e.gen); // borrowed for the calls below
             const sendArg = (store) => {
                 const a = emitter.emitExpr(e.arg);
@@ -3114,6 +3218,76 @@ function emitAsyncExpr(emitter, e) {
                     emitter.moveTemp(a); // the slot takes ownership
                 emitter.line(store(a));
             };
+            if (genT.async) {
+                let call;
+                if (e.mode === "next") {
+                    if (e.arg === null) {
+                        if (genT.nextT.kind === "dyn") {
+                            call = `scr_async_gen_next_ref(${g.name}, scr_dyn_retain(scr_dyn_undefined()), scr_dyn_release_v)`;
+                        }
+                        else {
+                            call = `scr_async_gen_next_none(${g.name})`;
+                        }
+                    }
+                    else {
+                        const a = emitter.emitExpr(e.arg);
+                        const t = e.arg.type;
+                        if (isRefCounted(t))
+                            emitter.moveTemp(a);
+                        call = t.kind === "f64" || t.kind === "date"
+                            ? `scr_async_gen_next_f64(${g.name}, ${a.name})`
+                            : t.kind === "bool"
+                                ? `scr_async_gen_next_bool(${g.name}, ${a.name})`
+                                : `scr_async_gen_next_ref(${g.name}, ${a.name}, ${vAdapters(t).release})`;
+                    }
+                }
+                else if (e.mode === "return") {
+                    if (e.arg === null) {
+                        call = `scr_async_gen_return_none(${g.name})`;
+                    }
+                    else {
+                        const a = emitter.emitExpr(e.arg);
+                        const t = e.arg.type;
+                        if (isRefCounted(t))
+                            emitter.moveTemp(a);
+                        call = t.kind === "f64" || t.kind === "date"
+                            ? `scr_async_gen_return_f64(${g.name}, ${a.name})`
+                            : t.kind === "bool"
+                                ? `scr_async_gen_return_bool(${g.name}, ${a.name})`
+                                : `scr_async_gen_return_ref(${g.name}, ${a.name}, ${vAdapters(t).release})`;
+                    }
+                }
+                else {
+                    if (e.arg === null)
+                        throw new InternalCompilerError("emitter bug: async genResume throw with no payload");
+                    const a = emitter.emitExpr(e.arg);
+                    const t = e.arg.type;
+                    if (isRefCounted(t))
+                        emitter.moveTemp(a);
+                    if (t.kind === "date") {
+                        throw new InternalCompilerError("emitter bug: Date async-generator throw reached backend");
+                    }
+                    else if (t.kind === "f64") {
+                        emitter.line(`scr_throw_f64(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "bool") {
+                        emitter.line(`scr_throw_bool(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "string") {
+                        emitter.line(`scr_throw_str(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "object" && emitter.classMeta.get(t.className)?.hierarchy) {
+                        const rc = vAdapters(t);
+                        emitter.line(`scr_throw_obj(${a.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(e.loc)}`);
+                    }
+                    else {
+                        const rc = vAdapters(t);
+                        emitter.line(`scr_throw_ref(${a.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(e.loc)}`);
+                    }
+                    call = `scr_async_gen_throw(${g.name})`;
+                }
+                return emitter.newTemp(e.type, call);
+            }
             if (e.mode === "next") {
                 if (e.arg === null) {
                     // Valueless resume: dyn channels read JS's undefined; unit
@@ -3178,7 +3352,7 @@ function emitAsyncExpr(emitter, e) {
                 }
                 emitter.line(`scr_gen_resume_throw(${g.name});`);
             }
-            const helper = genResultThunkFor(emitter, genT, e.type);
+            const helper = genResultThunkFor(emitter, genT, resultT);
             // The record builds before the check so an unwind (a propagated
             // body exception) releases it as the frame's never-read dummy.
             return emitter.fallibleTemp(e.type, `${helper}(${g.name})`);
@@ -6747,6 +6921,38 @@ function emitProcessLibCall(state) {
             return finish(`scr_process_getuid()`);
         case "process.uptime":
             return finish(`scr_process_uptime()`);
+        case "module.registryInit":
+            return finish(`scr_module_registry_init(${arg(0)})`);
+        case "module.define":
+            return finish(`scr_module_define(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
+        case "module.enter":
+            return finish(`scr_module_enter(${arg(0)})`);
+        case "module.link":
+            return finish(`scr_module_link(${arg(0)}, ${arg(1)})`);
+        case "module.finish":
+            return finish(`scr_module_finish(${arg(0)})`);
+        case "module.fail":
+            return finish(`scr_module_fail(${arg(0)})`);
+        case "module.filename":
+            return finish(`scr_module_filename(${arg(0)})`);
+        case "module.id":
+            return finish(`scr_module_id(${arg(0)})`);
+        case "module.path":
+            return finish(`scr_module_path(${arg(0)})`);
+        case "module.paths":
+            return finish(`scr_module_paths(${arg(0)})`);
+        case "module.children":
+            return finish(`scr_module_children(${arg(0)})`);
+        case "module.parent":
+            return finish(`scr_module_parent(${arg(0)})`);
+        case "module.loaded":
+            return finish(`scr_module_loaded(${arg(0)})`);
+        case "module.cacheGet":
+            return finish(`scr_module_cache_get(${arg(0)})`);
+        case "module.cacheHas":
+            return finish(`scr_module_cache_has(${arg(0)})`);
+        case "module.cacheKeys":
+            return finish(`scr_module_cache_keys()`);
         case "process.availableMemory":
             return finish(`scr_available_memory()`);
         case "process.constrainedMemory":
@@ -7492,6 +7698,9 @@ function emitStreamLibCall(state) {
         case "stream.destroyErr":
             emitter.usesTimers = true;
             return finish(`(${cType(e.type).trim()})scr_stream_destroy((ScrStream *)${arg(0)}, ${arg(1)})`);
+        case "stream.iteratorClose":
+            emitter.usesTimers = true;
+            return finish(`(${cType(e.type).trim()})scr_stream_iterator_close((ScrStream *)${arg(0)})`);
         case "stream.prop": {
             // The property NAME is a compile-time literal; args[1]'s
             // emitted temp is unused (released with the statement's frame).
@@ -7791,6 +8000,7 @@ function emitLibCallExpr(emitter, e) {
             return emitAsyncContextLibCall(state);
         case "process":
         case "stdin":
+        case "module":
             return emitProcessLibCall(state);
         case "error":
         case "regex":