@scriptc/compiler 0.2.9 → 0.2.10

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. */
@@ -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
@@ -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>`). */