@scriptc/compiler 0.3.1 → 0.3.2

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

@@ -7,6 +7,7 @@ import { type Int32Local } from "./int32-locals.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
 import { type CallLifetimes } from "./call-lifetimes.js";
+import { type UnionSources } from "./local-union-storage.js";
 import { BlockBuilder } from "./blocks.js";
 import { NullableRefFields, type NullableRefField } from "./nullable-fields.js";
 import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js";
@@ -63,6 +64,10 @@ export declare class LlEmitter {
     private scalarStringSlices;
     readonly stringSlices: Map<string, StringSliceSnapshot>;
     private localStackUnions;
+    private localStackObjects;
+    private reassignedStackObjects;
+    /** The binding slot of each reassigned stack-object local. */
+    private stackObjectSlots;
     private localUnionStorageProofs;
     private localUnionStorage;
     integerArrayBindings: Set<string>;
@@ -74,13 +79,18 @@ export declare class LlEmitter {
      * operations and record views conservatively alias all of them. */
     private markFieldPointer;
     markMemoryPointer(ptr: string, field: string): void;
+    /** The alias tag of a runtime word that emitted code reads and writes
+     * outside every field (the lifetime-region count, owner and cursors). */
+    memoryAliasAttachment(category: string): string;
     fieldAliasAttachment(ptr: string): string;
     private fieldAliasMetadata;
     private readonly debug;
+    /** Projection-only scalar objects may live in frame storage (stack-objects.ts). */
+    readonly stackObjects: boolean;
     private debugScope;
     readonly sizeType: "i32" | "i64";
     readonly ffiExtendNarrowIntegers: boolean;
-    readonly cycleBufferedOffset: number;
+    readonly cycleBufOffset: number;
     /** Emitted ScrCycType descriptors so far (their collector statistics
      * indices; see ShapeHost.nextCycKind). */
     private cycKinds;
@@ -176,6 +186,8 @@ export declare class LlEmitter {
      * when inline RC is off. */
     private readonly rcHelpers;
     readonly fnByName: Map<string, IrFunction>;
+    /** 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
      * fiberless-async analysis scans it for suspension entry points. */
     private readonly fnDefText;
@@ -187,6 +199,8 @@ export declare class LlEmitter {
      * whose bindings end with the list (emitBlock and function bodies). */
     private stmtCursor;
     readonly optionalArrayReads: OptionalArrayReads;
+    /** Union sources a binding or projection can hold in a stack box. */
+    readonly unionSources: UnionSources;
     readonly checkedNarrows: CheckedNarrows;
     callArrayReads: Map<IrExpr, LocalArrayRead>;
     mapReadLifetimes: MapReadLifetimes;
@@ -278,6 +292,8 @@ export declare class LlEmitter {
      * typeKey → thunk symbol. */
     readonly resolveThunks: Map<string, string>;
     readonly resolveThunkDefs: string[];
+    /** Typed-ref recipe constants by type key (lazy receivers). */
+    readonly typedRefRecipes: Map<string, string>;
     /** ReadableStream.from adapters keep typed arrays by reference and box
      * one current element per pull. */
     readonly streamFromArrayAdapters: Map<string, string>;
@@ -399,9 +415,12 @@ export declare class LlEmitter {
     private tryStack;
     /** Return type of the function being emitted — the unwind path returns
      * a dummy of this type (never read: callers check the flag first). */
-    private currentReturnType;
+    currentReturnType: IrType;
     /** The current body returns its number result as i32. */
     private currentInt32Result;
+    /** The function's i32 entry returns its scalar union result as tag and
+     * payload bits (Int32Abi.union). */
+    private currentUnionResult;
     /** Active only while emitting a body lowered with LLVM's
      * switched-coroutine intrinsics (wasm32 async bodies and generators,
      * native synchronous generators; see coroLowered). */
@@ -421,6 +440,8 @@ export declare class LlEmitter {
         yieldT: IrType;
         nextT: IrType;
     } | null;
+    /** The function being emitted is an async generator body. */
+    private currentAsyncGenerator;
     /** Active optional-chain bind slots, by chain id (chainRecv reads). */
     readonly chainSlots: Map<string, LlValue>;
     logArgSlots: number;
@@ -802,6 +823,15 @@ export declare class LlEmitter {
      * that is not a direct call (closures, dispatch, adapters, the runtime)
      * enters here. A pending exception passes through to its caller. */
     private emitInt32AbiWrapper;
+    /** The SCALAR_UNION_RESULT pair of a `%ScrUnion` box of `type`. */
+    scalarUnionPair(box: string, type: IrType): string;
+    /** A private stack box holding a SCALAR_UNION_RESULT pair of `type`. */
+    stackScalarUnion(pair: string, type: IrType): LlValue;
+    /** A direct call whose i32 entry returns its scalar union in registers. */
+    scalarResultCall(e: IrExpr): boolean;
+    /** A fresh heap box (+1) for a SCALAR_UNION_RESULT pair of `type`; the
+     * exception dummy (tag -1) answers NULL. */
+    boxScalarUnion(pair: string, type: IrType): string;
     /** The i32 bits of a number proven an int32 (a direct call's i32
      * argument or an i32 result): its exact integer when the value carries
      * one, else the conversion the proof makes exact. */
@@ -854,6 +884,9 @@ export declare class LlEmitter {
      * runs afterwards with no handler in scope: a rejection settles the
      * function's promise instead of reaching its own catch clauses. */
     private emitAdoptingReturn;
+    /** An async generator completing without a further turn: its request
+     * settles as the body returns (scr_async_gen_hop_done). */
+    private emitAsyncGenSettled;
     /** `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;
@@ -960,6 +993,12 @@ export declare class LlEmitter {
     emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordHas" | "fieldAbsent">): 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;
+    /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
+     * Created with the class graph; null elsewhere. */
+    private regions;
+    /** LifetimeRegion's runtime calls: create answers the region id, enter
+     * and leave bracket run(), release condemns. */
+    private emitRegionIntrinsic;
     private publishWalkersCache;
     /** Per-type publication walkers, created on the first publish. */
     private get publishWalkers();
@@ -993,6 +1032,8 @@ export declare class LlEmitter {
      * their ordinary statement-frame ownership. The caller must retain any
      * reference result before evaluating another expression. */
     emitReadReceiver(e: IrExpr): LlValue;
+    /** The frame slot a reassigned stack-object local keeps for its value. */
+    private stackObjectSlot;
     /** A private stack union source with an independently owned payload. */
     canStackReceiver(e: IrExpr): boolean;
     /** True for union sources that emitReadReceiver can produce as a private