@scriptc/compiler 0.4.6 → 0.4.7

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

@@ -50,7 +50,7 @@ import { type LlClassMeta, type LlInlineTail } from "./classes.js";
 import { LifetimeRegions } from "./regions.js";
 import { type ArenaPlan } from "./arenas.js";
 import { type Node } from "./region-ir.js";
-import { LlDyn, type DynHost } from "./dyn.js";
+import { LlDyn, type DynHost, type JsEntryClosure } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
 import { NullableUnions } from "./nullable-unions.js";
 import { type InlineRcMode, type MapKeyAccess } from "./shapes.js";
@@ -540,6 +540,10 @@ export declare class LlEmitter {
     private readonly rcMode;
     private readonly rcHelpersNoinline;
     readonly fnByName: Map<string, IrFunction>;
+    /** Whether some closure has a jsval body (IrFunction.jsEntry): the
+     * dynamic tier's dynCall and dynInvoke sites then call a function value's
+     * jsval entry when it has one. */
+    jsEntries: boolean;
     /** Empty literals that construct with inline slots (appended-array-literals.ts). */
     appendedArrayLiterals: ReadonlySet<IrExpr>;
     /** Emitted LLVM text of every IR function body, by function name: the
@@ -659,6 +663,9 @@ export declare class LlEmitter {
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     readonly publishedTypes: PublishedTypes | null;
+    /** Constructor stores that write a field's first value (immutability.ts
+     * computeConstructionFacts): they store without releasing an old value. */
+    readonly freshFieldStores: ReadonlySet<IrStmt>;
     /** Construction-only class and record fields (immutability.ts); null
      * where the facts are disabled. */
     private readonly immutableFields;
@@ -1135,6 +1142,16 @@ export declare class LlEmitter {
     };
     emit(): string;
     emitParts(): string[];
+    /** The entry point and JavaScript name of each named function the
+     * module makes closures of: a declared function's wrapper (its interned
+     * closure's entry) or a lifted function's call target, with its
+     * displayName, else its sourceName. Function boxes without a static name
+     * look the closure's entry up in this table. */
+    private closureNameEntries;
+    closureNames(): readonly {
+        entry: string;
+        name: string;
+    }[];
     /** The dispose-observer gates the emitted frees and record writers test
      * (alloc.ts): defined after every helper is emitted, because dynCheck
      * builders, JSON schemas and weak collection constructors are requested
@@ -1676,6 +1693,10 @@ export declare class LlEmitter {
      * the fiber eagerly to its first suspension and returns the promise);
      * generator bodies via theirs (which only ALLOCATES the suspended
      * fiber and returns the generator object). */
+    private jsEntryClosureList;
+    /** The closures with a jsval body (IrFunction.jsEntry), on targets with
+     * jsval words. */
+    jsEntryClosures(): readonly JsEntryClosure[];
     callTarget(fnName: string): string;
     /** Queue the current wasm coroutine and suspend it. The runtime decides
      * whether the promise waiter list or the ready FIFO owns the continuation;
@@ -2039,7 +2060,7 @@ export declare class LlEmitter {
      * is produced without a union box where the value is a wrap, and as a
      * retained payload of a borrowed box otherwise. Unlink-then-release like
      * every field store. */
-    emitNullableFieldStore(obj: string, className: string, field: string, nullable: NullableRefField, value: IrExpr): void;
+    emitNullableFieldStore(obj: string, className: string, field: string, nullable: NullableRefField, value: IrExpr, fresh: boolean): void;
     /** A union binding whose slot may hold a private stack box: stack locals
      * and projection-only parameters (callers may pass stack boxes). Such a
      * box must only be projected: never retained, released, or stored. */
@@ -2178,6 +2199,12 @@ export declare class LlEmitter {
     fsRenameThunkFor(cbT: IrType & {
         kind: "func";
     }): string;
+    watchNameThunkFor(cbT: IrType & {
+        kind: "func";
+    }): string;
+    watchErrorThunkFor(cbT: IrType & {
+        kind: "func";
+    }): string;
     cryptoBytesThunkFor(cbT: IrType & {
         kind: "func";
     }, arrayBuffer?: boolean, valueMode?: BytesThunkValue): string;

package/dist/backend/llvm/emitter.js

@@ -2,7 +2,7 @@ import { loopEntryInlines } from "./loop-entry-versions.js";
 import { relieveHeapPressure } from "../../heap-pressure.js";
 import { analyzeFrameEscapes } from "./frame-escapes.js";
 import { wasmBoundsChecks } from "./wasm-modules.js";
-import { jsTruthy } from "./jsval.js";
+import { jsImmediates, jsTruthy } from "./jsval.js";
 import { JsIcSites } from "../../ir/js-ic.js";
 import {} from "./array-search.js";
 import { emitStringInputs } from "./string-lifetimes.js";
@@ -96,13 +96,13 @@ import { emitCallExpr } from "./expr-calls.js";
 import { emitDynamicExpr } from "./expr-dynamic.js";
 import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js";
 import { PublishWalkers } from "./publish.js";
-import { computeImmutableFields, stableGlobals } from "../immutability.js";
+import { computeConstructionFacts, computeImmutableFields, stableGlobals, } from "../immutability.js";
 import { computeCycleMutability, hierarchyUnitOfClass } from "../cycle-mutability.js";
 import { computePublishedTypes } from "../publication.js";
 import { emitExpr } from "./expr-dispatch.js";
 import { LOOPS } from "./loop-state.js";
 import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataDynThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, emitterOnceAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor, } from "./expr-callbacks.js";
-import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, cryptoIntThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor, } from "./expr-stream-callbacks.js";
+import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, cryptoIntThunkFor, fsRenameThunkFor, watchNameThunkFor, watchErrorThunkFor, streamCbThunkFor, zlibBytesThunkFor, } from "./expr-stream-callbacks.js";
 import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew, } from "./expr-containers.js";
 import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic, } from "./expr-bytes.js";
 import { borrowedRecordKeyGetOr, emitRecordKeyGet, emitRegexIntrinsic, immortalDefault, keyedRecordReadInto, pointerRecordKeyGet, } from "./expr-records.js";
@@ -382,6 +382,7 @@ const GLOBAL_WRITE_KINDS = ["assign", "varDecl", "assignExpr", "incDec"];
 const POLL_EVERY_ITERATION = "%worker.poll.every";
 /** Runtime library calls (readsLoopMetrics). */
 const LIB_CALL_KINDS = ["libCall"];
+const CLOSURE_KINDS = ["closure"];
 /** [A-Za-z0-9_] */
 function isIdentifierByte(code) {
     return ((code >= 48 && code <= 57) ||
@@ -912,6 +913,10 @@ export class LlEmitter {
     rcMode;
     rcHelpersNoinline;
     fnByName = new Map();
+    /** Whether some closure has a jsval body (IrFunction.jsEntry): the
+     * dynamic tier's dynCall and dynInvoke sites then call a function value's
+     * jsval entry when it has one. */
+    jsEntries = false;
     /** Empty literals that construct with inline slots (appended-array-literals.ts). */
     appendedArrayLiterals = new Set();
     /** Emitted LLVM text of every IR function body, by function name: the
@@ -1026,6 +1031,9 @@ export class LlEmitter {
     /** Static types whose values can be published (@scriptc/threads): their
      * stores carry the frozen-object guard. Null without publish calls. */
     publishedTypes;
+    /** Constructor stores that write a field's first value (immutability.ts
+     * computeConstructionFacts): they store without releasing an old value. */
+    freshFieldStores;
     /** Construction-only class and record fields (immutability.ts); null
      * where the facts are disabled. */
     immutableFields;
@@ -1504,8 +1512,11 @@ export class LlEmitter {
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
         this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
         this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
-        for (const fn of mod.functions)
+        for (const fn of mod.functions) {
             this.fnByName.set(fn.name, fn);
+            if (fn.jsEntry !== undefined)
+                this.jsEntries = true;
+        }
         this.appendedArrayLiterals = findAppendedArrayLiterals(mod, this.nodeIndex);
         for (const entry of mod.ffiImports ?? []) {
             this.ffiByName.set(entry.name, entry);
@@ -1514,7 +1525,9 @@ export class LlEmitter {
         // and per async fiber; WASI, Windows and library builds have none.
         const triple = (options.targetTriple ?? "").toLowerCase();
         const windows = triple === "" ? process.platform === "win32" : triple.includes("windows");
-        this.publishedTypes = computePublishedTypes(mod, this.nodeIndex);
+        const construction = computeConstructionFacts(mod, this.nodeIndex);
+        this.freshFieldStores = construction.freshStores;
+        this.publishedTypes = computePublishedTypes(mod, this.nodeIndex, construction);
         const mt = computeMayThrow(mod, {
             stackChecks: !this.wasi && mod.lib === undefined && !windows,
             published: this.publishedTypes,
@@ -1689,6 +1702,7 @@ export class LlEmitter {
                 ? undefined
                 : (table, key, value) => this.journal?.entry(table, key, value),
             compactArrayElem: (elem) => this.compactArrayElem(elem),
+            jsEntryClosures: () => this.jsEntryClosures(),
             compactRegion: () => this.compactRegion,
             sizeType: this.sizeType,
             cycleBufOffset: this.cycleBufOffset,
@@ -1746,6 +1760,7 @@ export class LlEmitter {
                     classValueAbiEquals(this.classMetaOf(sub).def, target, this.fnByName));
             },
             pendingTestLines: (dest) => this.pendingTestLines(dest),
+            closureNames: () => this.closureNames(),
             virtualEntry: (implFn) => this.virtualEntry(implFn),
             programLifetime: this.programLifetime,
             regionAliasTag: (word) => this.memoryAliasAttachment(`region.${word}`),
@@ -2044,6 +2059,34 @@ export class LlEmitter {
         const out = this.cpuDispatch ? cloneForCpuDispatch(bridged) : bridged;
         return this.heapCensus === null ? out : [...out, this.heapCensus.definitions().join("\n")];
     }
+    /** The entry point and JavaScript name of each named function the
+     * module makes closures of: a declared function's wrapper (its interned
+     * closure's entry) or a lifted function's call target, with its
+     * displayName, else its sourceName. Function boxes without a static name
+     * look the closure's entry up in this table. */
+    closureNameEntries;
+    closureNames() {
+        if (this.closureNameEntries !== undefined)
+            return this.closureNameEntries;
+        const entries = new Map();
+        const scan = this.nodeIndex.scan(CLOSURE_KINDS);
+        for (const fn of this.mod.functions) {
+            eachNodeOfKinds(fn, scan, (node) => {
+                if (node.kind !== "closure")
+                    return true;
+                const target = this.fnByName.get(node.fnName);
+                const name = target?.displayName ??
+                    (target?.sourceName !== "<anonymous>" ? target?.sourceName : undefined);
+                if (target === undefined || name === undefined || name === "")
+                    return true;
+                const entry = target.captures === undefined ? mangleWrapper(node.fnName) : this.callTarget(node.fnName);
+                if (!entries.has(entry))
+                    entries.set(entry, name);
+                return true;
+            });
+        }
+        return (this.closureNameEntries = [...entries].map(([entry, name]) => ({ entry, name })));
+    }
     /** The dispose-observer gates the emitted frees and record writers test
      * (alloc.ts): defined after every helper is emitted, because dynCheck
      * builders, JSON schemas and weak collection constructors are requested
@@ -4188,7 +4231,7 @@ export class LlEmitter {
         const base = this.nullableUnions.fieldBase(shapeId);
         let p;
         if (this.shapeHost.recordViews?.targets.has(shapeId) === true) {
-            p = recordViewFieldPtr(this.B, this.sizeType, mangleRecordStruct(shapeId), objName, idx + base, idx, (decl) => this.declare(decl), this.rcMode === undefined);
+            p = recordViewFieldPtr(this.B, this.sizeType, mangleRecordStruct(shapeId), objName, idx + base, idx, (decl) => this.declare(decl), this.rcMode === undefined, (text) => this.cstr(text), this.shapeHost.recordViews?.partialTargets.has(shapeId) === true);
         }
         else {
             p = this.B.tmp();
@@ -4638,6 +4681,30 @@ export class LlEmitter {
      * the fiber eagerly to its first suspension and returns the promise);
      * generator bodies via theirs (which only ALLOCATES the suspended
      * fiber and returns the generator object). */
+    jsEntryClosureList = null;
+    /** The closures with a jsval body (IrFunction.jsEntry), on targets with
+     * jsval words. */
+    jsEntryClosures() {
+        if (this.jsEntryClosureList !== null)
+            return this.jsEntryClosureList;
+        const list = [];
+        if (this.jsEntries && jsImmediates(this))
+            for (const fn of this.fnByName.values()) {
+                const body = fn.jsEntry === undefined ? undefined : this.fnByName.get(fn.jsEntry);
+                if (body === undefined)
+                    continue;
+                list.push({
+                    closure: this.callTarget(fn.name),
+                    params: fn.params.map((p) => p.type),
+                    ret: fn.returnType,
+                    body: this.callTarget(body.name),
+                    bodyParams: body.params.map((p) => p.type),
+                    bodyRet: body.returnType,
+                });
+            }
+        this.jsEntryClosureList = list;
+        return list;
+    }
     callTarget(fnName) {
         const fn = this.fnByName.get(fnName);
         if (fn?.generator !== undefined)
@@ -6503,7 +6570,7 @@ export class LlEmitter {
      * is produced without a union box where the value is a wrap, and as a
      * retained payload of a borrowed box otherwise. Unlink-then-release like
      * every field store. */
-    emitNullableFieldStore(obj, className, field, nullable, value) {
+    emitNullableFieldStore(obj, className, field, nullable, value, fresh) {
         let next;
         if (value.kind === "unionWrap" &&
             value.unionId === nullable.unionId &&
@@ -6529,6 +6596,10 @@ export class LlEmitter {
             next = this.unionToNullable(this.emitUnionProjection(value).name, nullable);
         }
         const { ptr } = this.classFieldPtr(obj, className, field, "compressed");
+        if (fresh) {
+            this.storeRef(ptr, next);
+            return;
+        }
         const old = this.loadRef(ptr, false);
         this.storeRef(ptr, next);
         this.releaseHeap(old, nullable.arm);
@@ -6930,6 +7001,12 @@ export class LlEmitter {
     fsRenameThunkFor(cbT) {
         return fsRenameThunkFor(this, cbT);
     }
+    watchNameThunkFor(cbT) {
+        return watchNameThunkFor(this, cbT);
+    }
+    watchErrorThunkFor(cbT) {
+        return watchErrorThunkFor(this, cbT);
+    }
     cryptoBytesThunkFor(cbT, arrayBuffer = false, valueMode = "buffer") {
         return cryptoBytesThunkFor(this, cbT, arrayBuffer, valueMode);
     }
@@ -7198,6 +7275,8 @@ for (const op of [
     "dyn.promiseDynAdapterHelper",
     "dyn.dynFuncThunkHelper",
     "dyn.dynFuncBoxHelper",
+    "dyn.jsEntryThunk",
+    "dyn.unnamedFuncBoxHelper",
     "dyn.dynFuncAdapterHelper",
     "dyn.dynToStrHelper",
     "dyn.dynIterNHelper",