@scriptc/compiler 0.2.9 → 0.3.0

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

@@ -11,6 +11,7 @@ import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js"
 import { CheckedNarrows } from "./checked-narrows.js";
 import { type MapReadLifetimes } from "./map-read-lifetimes.js";
 import { ReferenceEffects } from "./reference-effects.js";
+import { ReferenceWrites, type Writes } from "./reference-writes.js";
 import { StackCallbacks } from "./stack-callbacks.js";
 import { AmbientReceiverReaders } from "./constant-callbacks.js";
 import { type StringSliceSnapshot } from "./string-slices.js";
@@ -50,9 +51,9 @@ export interface LlvmTargetOptions {
      * Executables only; the runtime's weak default keeps it off. */
     detachedExit?: boolean;
 }
-export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOptions): string;
+export declare function emitLlvmModule(input: IrModule, options?: LlvmTargetOptions): string;
 /** Keep large translation units below the host's single-string limit. */
-export declare function emitLlvmModuleSource(mod: IrModule, options?: LlvmTargetOptions): string | readonly string[];
+export declare function emitLlvmModuleSource(input: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare class LlEmitter {
     readonly mod: IrModule;
     localArrayReads: Map<string, LocalArrayRead>;
@@ -159,6 +160,12 @@ export declare class LlEmitter {
      * fiberless-async analysis scans it for suspension entry points. */
     private readonly fnDefText;
     readonly referenceEffects: ReferenceEffects;
+    /** Field-sensitive reference writes (null in debug builds). */
+    referenceWrites: ReferenceWrites | null;
+    private readonly borrowedReturnKeyCache;
+    /** The statement list being emitted and the current index, for blocks
+     * whose bindings end with the list (emitBlock and function bodies). */
+    private stmtCursor;
     readonly optionalArrayReads: OptionalArrayReads;
     readonly checkedNarrows: CheckedNarrows;
     callArrayReads: Map<IrExpr, LocalArrayRead>;
@@ -202,6 +209,9 @@ export declare class LlEmitter {
     readonly ffiHasRetainedCallback: boolean;
     private readonly ffiHasForeignCallback;
     private readonly globalTypes;
+    /** Module constants that keep one value once initialized
+     * (immutability.ts stableGlobals). */
+    private stableGlobals;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
     /** May-throw analysis (computeMayThrow): pending
@@ -217,6 +227,13 @@ 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;
+    /** Construction-only class and record fields (immutability.ts); null
+     * where the facts are disabled. */
+    private readonly immutableFields;
+    /** Constructor function names: their bodies may still write their own
+     * `this`'s construction-only fields. */
+    private readonly constructorFunctions;
+    private inConstructor;
     /** Method names with at least one may-throw implementation — the
      * virtualCall pending check's key. */
     readonly mayThrowMethods: Set<string>;
@@ -292,6 +309,12 @@ export declare class LlEmitter {
     private readonly initializerBindings;
     /** Whole-program int32 storage and parameter/result facts. */
     readonly int32Slots: Int32Slots;
+    /** Immutable module constants (contract types) whose graphs become
+     * immortal once initialized: their reads need no reference counting. */
+    readonly immortalGlobals: ReadonlySet<string>;
+    /** ProgramLifetime hierarchy roots (contract types): their instances are
+     * immortal from construction (classes.ts programLifetimeClass). */
+    readonly programLifetime: ReadonlySet<string>;
     private numericLocals;
     private captureIds;
     /** Active induction bindings retain their width independently of size_t. */
@@ -406,8 +429,8 @@ export declare class LlEmitter {
      * mentions (transitively), contains no suspension entry point. Such a
      * body always completes before the call returns, which is exactly the
      * behavior of a fiber that never suspends. Excluded conservatively:
-     * wasm32 (its coroutine lowering owns async bodies), programs embedding
-     * the dynamic engine, module-evaluation bodies (their promise caches),
+     * wasm32 (its coroutine lowering owns async bodies), module-evaluation
+     * bodies (their promise caches),
      * `dyn` results (resolution may adopt a thenable), and every program
      * that uses node:test subtests — `t.test()` runs a subtest inline and
      * awaits it on the CURRENT fiber even from synchronous code. Worker
@@ -706,6 +729,42 @@ export declare class LlEmitter {
      * rebound during a call; its independent payload owner keeps it alive.
      * Other writable bindings need an owned snapshot. */
     canBorrowCallArgument(value: IrExpr): boolean;
+    /** A plain-pointer read of a construction-only field outside any
+     * constructor (ImmutableFields). */
+    private immutableRead;
+    /** A projection read whose locations nothing writes while a borrowed
+     * read of it is in use (ReferenceWrites), given the writes of that
+     * extent. The root binding itself must stay alive across it too, which
+     * its own location (`l:`, `g:`, `bx`) covers. */
+    unwrittenRead(e: IrExpr, writes: Writes): boolean;
+    /** A stable binding initialized by a projection can borrow it when the
+     * rest of its block (its whole lifetime) writes none of the projection's
+     * locations: the source edge then keeps the value alive, and uses that
+     * escape still retain their own copies. */
+    private unwrittenAlias;
+    /** An optional element read into a projection-only local can borrow the
+     * element when the rest of the block writes no array element and none of
+     * the locations keeping the array alive (which must itself be read
+     * without a frame owner). */
+    private unwrittenLocalArrayRead;
+    /** An optional element read passed to a projection-only parameter can
+     * borrow the element when the callee and later arguments (`writes`)
+     * write no array element and nothing keeping the array alive. */
+    unwrittenCallArrayRead(read: LocalArrayRead, writes: Writes): boolean;
+    /** `return x` of a local whose slot is an owned scope entry of the same
+     * type: the return can take over the local's reference. */
+    private movableReturn;
+    /** A walk host for a body that may write the heap: each walk must read
+     * only locations the whole body (with its callees) never writes;
+     * rebinding the walk locals themselves releases nothing. */
+    private unwrittenWalkHost;
+    /** emitReadReceiver yields a plain pointer for `e` that no statement
+     * frame owns, so it can outlive the statement (walk-borrows' walks, from
+     * any unboxed plain-pointer binding, plus element reads). */
+    private unownedWalk;
+    /** Every location a borrowed-return callee's walks can read (its body's
+     * field, record and element reads, through nested borrowed returns). */
+    private borrowedReturnKeys;
     private emitStmts;
     /** Emits a block in its own lexical scope (refcounted locals released at
      * end). `setup` runs after the
@@ -793,7 +852,7 @@ export declare class LlEmitter {
     emitContainerExpr(e: ExprOf<"arrayLit" | "arrayNewLen" | "arrayGet" | "arrayHas" | "arrayState" | "arrIntrinsic" | "bytesNew" | "bytesIntrinsic" | "mapNew" | "mapIntrinsic" | "setIntrinsic" | "setNew">): LlValue;
     emitCallExpr(e: ExprOf<"call" | "ffiCall" | "closure" | "callValue" | "selfRef" | "new" | "classRef" | "newValue" | "instanceOfValue" | "promiseVoidWiden" | "upcast" | "downcast" | "instanceOf" | "virtualCall">): LlValue;
     emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordHas" | "fieldAbsent">): LlValue;
-    emitDynamicExpr(e: ExprOf<"dynFrom" | "dynFromJsval" | "dynCall" | "dynInvoke" | "dynArrLit" | "dynObjLit" | "unionWrap" | "unionNarrow" | "unionDisc" | "unionKeyGet" | "unionIsTag" | "dynKeyGet" | "dynHasKey" | "dynScalarEq" | "dynTest" | "unionEq" | "unionFuncEq" | "caughtTest" | "caughtCheck" | "caughtNarrow" | "caughtToDyn">): LlValue;
+    emitDynamicExpr(e: ExprOf<"dynFrom" | "dynCall" | "dynInvoke" | "dynArrLit" | "dynObjLit" | "unionWrap" | "unionNarrow" | "unionDisc" | "unionKeyGet" | "unionIsTag" | "dynKeyGet" | "dynHasKey" | "dynScalarEq" | "dynTest" | "unionEq" | "unionFuncEq" | "caughtTest" | "caughtCheck" | "caughtNarrow" | "caughtToDyn">): LlValue;
     emitIntrinsicExpr(e: ExprOf<"intrinsic">): LlValue;
     private publishWalkersCache;
     /** Per-type publication walkers, created on the first publish. */
@@ -808,6 +867,9 @@ export declare class LlEmitter {
     private publishedNamesSym;
     /** The class-name table the hierarchy field guards index by preorder. */
     private publishedClassNamesDefs;
+    /** The frozen-object guard of a class field store, unless the store
+     * provably targets a still-private `this` (PublishedTypes.privateStores). */
+    private emitStoreGuard;
     /** The frozen-object guard of a class field or record field store:
      * Node's "Cannot assign to read only property" TypeError when the target
      * is published. `className` null means a record (`#<Object>`). */
@@ -819,7 +881,6 @@ export declare class LlEmitter {
     emitPublishedCollectionGuard(m: string, t: IrType): void;
     emitSerializationExpr(e: ExprOf<"jsonStringify" | "dynCheck">): LlValue;
     emitAsyncExpr(e: ExprOf<"yieldExpr" | "genResume" | "awaitExpr" | "awaitUnionExpr" | "newPromise" | "promiseWithResolvers">): LlValue;
-    emitJsInteropExpr(e: ExprOf<"jsMarshal" | "jsOp" | "jsExit" | "jsBridgePromise">): LlValue;
     /** Read a receiver whose value is consumed immediately by a field or tag
      * load. No user code may run between this read and its consumer. Locals
      * and their projections already have an owner; other expressions keep
@@ -896,19 +957,6 @@ export declare class LlEmitter {
     borrowableNullableWrap(e: IrExpr): "unit" | "ref" | null;
     materializeSplitLocal(localId: string): void;
     emitExpr(e: IrExpr): LlValue;
-    emitJsMarshal(e: IrExpr & {
-        kind: "jsMarshal";
-    }): LlValue;
-    emitJsOp(e: IrExpr & {
-        kind: "jsOp";
-    }): LlValue;
-    emitJsExit(e: IrExpr & {
-        kind: "jsExit";
-    }): LlValue;
-    islandAdapter(arity: number, retKind: "void" | "jsval" | "f64" | "bool" | "string"): string;
-    islandTypedAdapter(fn: IrType & {
-        kind: "func";
-    }): string;
     dynKind(d: string): string;
     raceAdapterFor(from: IrType, to: IrType): string;
     genResultThunkFor(genT: IrType & {