@scriptc/compiler 0.0.32 → 0.0.33

package/dist/backend/emission/emit-exprs.js

@@ -1,8 +1,9 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/nodes.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/nodes.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 "./emit-types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./emit-shapes.js";
 import { dynDestrCheckHelper, dynIterNHelper, dynKeyGetHelper } from "./emit-walkers.js";
+import { collectFfiRetainedOps, parseFfiCallbackKey } from "../ffi-callbacks.js";
 import { genResultThunkFor } from "./emit-async.js";
 function streamTypedRefCommitAdapter(E, t, snapshot, defs) {
     if (t.kind === "bytes") {
@@ -1885,7 +1886,34 @@ export function emitExpr(E, e) {
                 sourceArgs.set(abiIndex, arg);
                 if (isFfiCallbackParam(param))
                     callbackArgs.set(param.callback.id, arg);
+                if (isFfiReleaseParam(param))
+                    callbackArgs.set(param.callback.release, arg);
             });
+            const { registrations: retainedRegistrations, releases: retainedReleases } = collectFfiRetainedOps(entry, callbackArgs, (binding, id) => E.ffiCallbackAdapter(binding, id));
+            // Pin before registration. Raw retained descriptors are native
+            // singletons: the incoming closure is pinned (and an EMPTY slot
+            // armed) before the native set call, but a replaced registration
+            // stays live and dispatching until the call returns — a native
+            // setter may flush the outgoing callback one last time mid-replace.
+            // scr_ffi_commit_slot below repoints the slot and retires the
+            // superseded pins after the call.
+            for (const registration of retainedRegistrations) {
+                if (registration.global !== null) {
+                    E.line(`scr_ffi_retain_slot(&${registration.table}, &${registration.global}, ${registration.callback.name});`);
+                }
+                else if (registration.foreign) {
+                    E.line(`scr_ffi_retain_foreign(&${registration.table}, ${registration.callback.name});`);
+                }
+                else {
+                    E.line(`scr_ffi_retain(&${registration.table}, ${registration.callback.name});`);
+                }
+            }
+            // Validate releases BEFORE the native removal call runs: a bogus
+            // release traps without native code observing any side effect. The
+            // registration itself is unpinned only after the call returns.
+            for (const release of retainedReleases) {
+                E.line(`scr_ffi_require${release.foreign ? "_foreign" : ""}(&${release.table}, ${release.callback.name});`);
+            }
             // Raw C callback pointers carry no userdata. For the documented
             // call-scoped/same-thread policy, lend each one a distinct TLS
             // slot for the dynamic extent of this native call. Save/restore
@@ -1909,6 +1937,12 @@ export function emitExpr(E, e) {
                     nativeArgs.push(`&${adapter.symbol}`);
                     return;
                 }
+                if (isFfiReleaseParam(param)) {
+                    const { binding, id } = parseFfiCallbackKey(param.callback.release);
+                    const adapter = E.ffiCallbackAdapter(binding, id);
+                    nativeArgs.push(`&${adapter.symbol}`);
+                    return;
+                }
                 if (isFfiContextParam(param)) {
                     const callback = callbackArgs.get(param.context);
                     if (!callback)
@@ -1948,17 +1982,32 @@ export function emitExpr(E, e) {
                     E.line(`${saved.tls} = ${saved.previous.name};`);
                 }
             };
-            const callbacksMayThrow = callbackArgs.size > 0;
+            const finishRetainedReleases = () => {
+                // Commit raw replacements first (repoint the slot, retire the
+                // superseded pins), then unpin explicit releases — the runtime
+                // disarms the slot itself when the released closure holds it.
+                for (const registration of retainedRegistrations) {
+                    if (registration.global !== null) {
+                        E.line(`scr_ffi_commit_slot(&${registration.table}, ${registration.callback.name});`);
+                    }
+                }
+                for (const release of retainedReleases) {
+                    E.line(`scr_ffi_release${release.foreign ? "_foreign" : ""}(&${release.table}, ${release.callback.name});`);
+                }
+            };
+            const callbacksMayThrow = callbackArgs.size > 0 || E.ffiHasRetainedCallback;
             switch (entry.returns) {
                 case "void":
                     E.line(`${call};${E.srcComment(e.loc)}`);
                     restoreRawContexts();
+                    finishRetainedReleases();
                     if (callbacksMayThrow)
                         E.emitPendingCheck();
                     return { name: "", type: e.type };
                 case "f64": {
                     const result = E.newTemp(e.type, call);
                     restoreRawContexts();
+                    finishRetainedReleases();
                     if (callbacksMayThrow)
                         E.emitPendingCheck();
                     return result;
@@ -1966,6 +2015,7 @@ export function emitExpr(E, e) {
                 case "bool": {
                     const result = E.newTemp(e.type, `(${call} != 0)`);
                     restoreRawContexts();
+                    finishRetainedReleases();
                     if (callbacksMayThrow)
                         E.emitPendingCheck();
                     return result;
@@ -1975,6 +2025,7 @@ export function emitExpr(E, e) {
                 case "i32": {
                     const result = E.newTemp(e.type, `(double)${call}`);
                     restoreRawContexts();
+                    finishRetainedReleases();
                     if (callbacksMayThrow)
                         E.emitPendingCheck();
                     return result;