@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -1,12 +1,12 @@
+import type { TargetCpu } from "../target-cpu.js";
 import { JsIcSites } from "../../ir/js-ic.js";
 import { type ArraySearchKind } from "./array-search.js";
 import type { IrBytesElem, IrExpr, IrFfiCallbackParam, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
 import { type RuntimeFeatures } from "../../ir/runtime-features.js";
-import { type DenseArrayLoop } from "./dense-array-loops.js";
-import { findInitializedByteLoopBindings } from "./byte-windows.js";
 import { matchBytesLoopVersion } from "./bytes-loop-versions.js";
-import type { IntegerCountedForLoop } from "../../ir/integer-loops.js";
+import type { IntegerCountedForLoop, IntegerPairedForLoop } from "../../ir/integer-loops.js";
 import { type SplitSpan, type StoredSplitSnapshot } from "./split-loops.js";
+import { type ChunkResult, EmitJournal } from "./emit-journal.js";
 import { type IntegerRange, type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type Int32Slots } from "../../ir/int32-slots.js";
 import { type FinalFields } from "../../ir/final-fields.js";
@@ -24,9 +24,11 @@ import { NullableRefFields, type NullableRefField } from "./nullable-fields.js";
 import { InlineUnionFields } from "./inline-unions.js";
 import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js";
 import { CheckedNarrows } from "./checked-narrows.js";
+import { type ArrayAccess } from "./dense-array-access.js";
 import { type MapReadLifetimes } from "./map-read-lifetimes.js";
 import { type MapEntryFusion } from "./map-entry-fusion.js";
 import { type WalkBorrowHost } from "./walk-borrows.js";
+import { IrNodeIndex } from "../../ir/node-index.js";
 import { ReferenceEffects } from "./reference-effects.js";
 import { ReferenceWrites, type Writes } from "./reference-writes.js";
 import { LlvmDebugInfo } from "./debug-info.js";
@@ -65,9 +67,31 @@ export interface LlScopeEntry {
      * environment, which skip the release call. */
     lazy?: boolean;
 }
+/** Process primitives for forked emission workers. */
+export interface ForkPrimitives {
+    /** 0 in the worker, the worker's pid in the parent, -1 on failure. */
+    fork(): number;
+    /** Ends the worker without running exit handlers. */
+    exit(code: number): void;
+    /** The worker's exit status, 128 plus a signal number, or -1. */
+    wait(pid: number): number;
+}
 export interface LlvmTargetOptions {
     /** C ABI target; omitted direct emission uses the host ABI. */
     targetTriple?: string;
+    /** Emit the function bodies in this many contiguous ranges, each by its
+     * own emitter, and merge them in function order (emit-journal.ts). The
+     * output is the same as one emitter's. Debug builds (`debugSources`)
+     * emit in one emitter. */
+    functionChunks?: number;
+    /** Emit the function bodies of a large module on this many forked worker
+     * processes at a time (emit-module.ts), forked with `forkPrimitives`. The
+     * output is the same as one emitter's. Debug builds (`debugSources`)
+     * emit in one emitter. */
+    functionWorkers?: number;
+    /** The host's process primitives, where it can fork (the native
+     * compiler's). */
+    forkPrimitives?: ForkPrimitives | undefined;
     /** Exact frontend sources for dev-build locations and variable metadata. */
     debugSources?: ReadonlyMap<string, string>;
     /** Pointer width of the target C ABI. Native targets are 64-bit today. */
@@ -104,6 +128,10 @@ export interface LlvmTargetOptions {
      * store the instance's address over 8 in 32 bits (classes.ts
      * compactRefLoadLines). Elsewhere they keep 8-byte pointers. */
     lowRegion?: boolean;
+    /** The x86-64 level the program's code may require (`--target-cpu`):
+     * every emitted function carries it as its `target-cpu`. Unset, code
+     * runs on any x86-64 CPU. */
+    targetCpu?: TargetCpu;
 }
 /** LlvmTargetOptions.lowRegion for an executable: Linux targets without
  * sanitizers, whose address space below 32 GiB is free (ASan keeps its
@@ -112,6 +140,9 @@ export interface LlvmTargetOptions {
  * `wasi`). */
 export declare function lowRegionTarget(platform: string, sanitize: boolean): boolean;
 export declare function emitLlvmModule(input: IrModule, options?: LlvmTargetOptions): string;
+/** emitLlvmModule's text as parts that concatenate to it, without the copy
+ * that joining them makes: a large program's text is 150 MB. */
+export declare function emitLlvmModuleParts(input: IrModule, options?: LlvmTargetOptions): string[];
 /** Keep large translation units below the host's single-string limit. */
 export declare function emitLlvmModuleSource(input: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare function llStrBytes(text: string): string;
@@ -141,6 +172,8 @@ export declare function boxSlotCount(fn: IrFunction): number;
 export declare const MAX_BYTES_LOOP_VERSION_DEPTH = 3;
 export declare class LlEmitter {
     readonly mod: IrModule;
+    /** Per-feature state (emitter-state.ts), indexed by each key's slot. */
+    readonly moduleStates: unknown[];
     localArrayReads: Map<string, LocalArrayRead>;
     loopArrayBorrows: ReadonlySet<IrStmt>;
     scalarStringSlices: Map<string, {
@@ -223,9 +256,11 @@ export declare class LlEmitter {
      * 32-bit references to compact class instances (LlClassMeta.compressed):
      * loadField/loadRef decode them and storeField/storeRef encode them. */
     readonly compressedFieldPtrs: Set<string>;
-    /** Whether a class has compressed fields: main reserves the region before
-     * compiled code runs (scr_plr_init). */
-    usesCompactRefs: boolean;
+    /** Compact class instances live in the program-lifetime region below
+     * 32 GiB (LlvmTargetOptions.lowRegion, and the program has compact
+     * classes): main reserves it before compiled code runs (scr_plr_init), and
+     * fields and arrays of compactRefType hold 32-bit references. */
+    compactRegion: boolean;
     /** Native class fields with different property names cannot occupy the
      * same slot of one object. Inherited views of the same property share a
      * tag. Array storage has its own disjoint categories; untagged runtime
@@ -235,9 +270,64 @@ export declare class LlEmitter {
     /** 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;
+    /** The current function's int32 array allocations: the array literals
+     * its int32 arrays are written with. They construct SCR_ELEM_I32 arrays. */
+    int32Allocations: Set<IrExpr>;
+    /** The fill temporaries (`new Array(n).fill(v)`) of those allocations:
+     * the same arrays, so int32 too. */
+    int32ArrayTemps: Set<string>;
+    /** The same for the current function's int32 arrays with checked stores,
+     * which are only allocated by fills (ir/int32-arrays.ts
+     * checkableInt32Allocations): their temporaries' literals, with the fill's
+     * length (a literal constructs SCR_ELEM_I32 storage when that length is at
+     * least CHECKED_INT32_MIN_LENGTH, SCR_ELEM_F64 otherwise), and their
+     * temporaries. */
+    checkedAllocations: Map<IrExpr, IrExpr>;
+    checkedArrayTemps: Set<string>;
+    /** The fill calls (`.fill(v)`) of those allocations: a value that is not
+     * an int32 widens the new array first. */
+    checkedFills: Set<IrExpr>;
+    /** Collect the int32 allocations of `fn`, about to be emitted. */
+    findInt32Allocations(fn: IrFunction): void;
+    /** Whether `arr` reads one of the int32 arrays (ir/int32-arrays.ts, kept
+     * by the int32 slot analysis): a local or parameter of the current
+     * function, or a module global. */
+    int32Array(arr: IrExpr): boolean;
+    /** Whether `arr` is one of the current function's int32 arrays with
+     * checked stores: int32 slots until a store widens it to doubles. Every
+     * access tests its kind (emitByElementKind), except in the fast copy of
+     * an int32 kind loop, which reads and writes it as an int32 array. */
+    checkedInt32Array(arr: IrExpr): boolean;
+    /** Whether the local `localId` holds one of the current function's int32
+     * arrays with checked stores. */
+    checkedInt32Local(localId: string): boolean;
+    /** Whether `arr` is an int32 array with checked stores that the fast copy
+     * of the int32 kind loop being emitted holds as an int32 array. */
+    int32KindArray(arr: IrExpr): boolean;
+    /** Before a store of `value` (of `expr`) into `arr`, in the fast copy of
+     * an int32 kind loop: continue when it is an int32 that is not -0, and
+     * otherwise leave for the statement's resume point, where it re-executes
+     * with kind tests. Returns the value as an i32 when it is at hand as an
+     * integer, or null when the store converts the double itself. */
+    emitInt32KindStoreCheck(arr: IrExpr, value: LlValue, expr: IrExpr): string | null;
+    /** Emit an access to the checked int32 array `array` once per element
+     * kind: `arm("i32", widened)` while it holds int32 slots and
+     * `arm("f64", widened)` after it widened, joined after both. `widened` is
+     * the label of the double arm, where an int32 arm's store of a value that
+     * is not an int32 continues after widening the array. Returns the phi of
+     * the arms' results (of LLVM type `ty`), or null when `ty` is null. */
+    emitByElementKind(array: string, ty: string | null, arm: (acc: "i32" | "f64", widened: string) => string | null): string | null;
+    /** Before storing the double `value` (of `expr`) into an int32 arm
+     * (emitByElementKind) of the checked int32 array `array`: continue in this
+     * arm when it is an int32 that is not -0, or widen the array and continue
+     * at `widened`. A value proven an int32 needs no test. */
+    emitCheckedInt32Store(array: string, value: string, expr: IrExpr, widened: string): void;
+    /** The access an element operation on `arr` (of element type `elem`)
+     * takes: int32 arrays read and write their 4-byte slots. */
+    arrayAccess(arr: IrExpr, elem: IrType): ArrayAccess;
     /** Whether an element access at `index` of `arr` lies in the hole-free
-     * prefix: the counter of a dense array loop's fast copy indexing one of
-     * the arrays its entry test covered. */
+     * prefix: a counter of a dense array loop's fast copy indexing one of the
+     * arrays its entry test covered. */
     provenDenseIndex(arr: IrExpr, index: IrExpr): boolean;
     fieldAliasAttachment(ptr: string): string;
     fieldAliasMetadata(): string[];
@@ -282,6 +372,7 @@ export declare class LlEmitter {
     readonly emitLibraryIdentity: boolean;
     readonly runtimeAbiMarker: boolean;
     readonly detachedExit: boolean;
+    readonly targetCpu: TargetCpu | undefined;
     readonly wasmBoundsChecks: boolean;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the runtime ABI’s determinism discipline. */
@@ -341,6 +432,10 @@ export declare class LlEmitter {
     }>;
     /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
     readonly mapOpsConsts: Map<string, string>;
+    /** Method-id slots of checked-dynamic method calls
+     * (scr_dyn_invoke_prepared_id): method name → symbol of an i32 the
+     * runtime fills with the name's id on the first call. */
+    readonly methodIdSlots: Map<string, string>;
     /** Type-directed walker functions (JSON serializers, the indent
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
@@ -389,6 +484,9 @@ export declare class LlEmitter {
     readonly callLifetimes: CallLifetimes;
     readonly constantCallbacks: Map<string, Map<string, string>>;
     currentConstantCallbacks: ReadonlyMap<string, string>;
+    /** The current function's running maximum and minimum updates, whose
+     * branches are weighted as rarely taken (running-extrema.ts). */
+    runningExtrema: ReadonlySet<IrStmt>;
     /** Callback bindings whose closures an enclosing callback loop version
      * proved to hold their known function: calls take the direct entry with
      * no fallback (emitCallbackVersionedLoop). */
@@ -437,6 +535,9 @@ export declare class LlEmitter {
     /** Module constants that keep one value once initialized
      * (immutability.ts stableGlobals). */
     stableGlobals: ReadonlySet<string>;
+    /** Every function body's nodes in walk order (ir/node-index.ts), for the
+     * constructor's analyses. */
+    readonly nodeIndex: IrNodeIndex;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
     /** Constant-key reads on checked-dynamic objects, each with its own
@@ -519,6 +620,9 @@ export declare class LlEmitter {
     readonly liveDynRefAdapters: Map<string, LlStreamTypedRefAdapter>;
     /** See moduleUsesDynBuiltinStream. */
     get usesDynBuiltinStream(): boolean;
+    /** A checked-dynamic for-await may hold a native stream: the program
+     * links the stream unit (and the dyn-async one the loop needs). */
+    get dynForAwaitStreams(): boolean;
     /** Runtime-arm dispatchers for live union values. */
     readonly liveDynUnionRefAdapters: Map<string, string>;
     readonly dynPromiseAdapters: Map<string, string>;
@@ -640,14 +744,6 @@ export declare class LlEmitter {
      * immortal from construction (classes.ts programLifetimeClass). */
     readonly programLifetime: ReadonlySet<string>;
     numericLocals: Map<string, IrLocal>;
-    /** Local arrays of the current function that no other binding can hold
-     * (ir/array-length-stability.ts). */
-    unaliasedArrays: ReadonlySet<string>;
-    /** Dense array loops (dense-array-loops.ts) run in this function. */
-    denseLoopsEnabled: boolean;
-    denseLoopEntries: ReturnType<typeof findInitializedByteLoopBindings>;
-    /** The fast copy of a dense array loop being emitted. */
-    denseLoop: DenseArrayLoop | null;
     captureIds: Set<string>;
     /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings: Map<string, {
@@ -672,7 +768,6 @@ export declare class LlEmitter {
      * async or generator body resumes with its locals in its frame, which
      * an entry alloca is not part of. */
     integerTempsEnabled: boolean;
-    countedLoopsEnabled: boolean;
     /** Speculative integer loops (speculative-integers.ts) run in this function. */
     speculativeLoopsEnabled: boolean;
     /** The fast copy of a speculative integer loop being emitted: its
@@ -699,6 +794,18 @@ export declare class LlEmitter {
      * (`enterLoopHeader`): records the ordinary copy's header, or sends the
      * third copy's header there. */
     speculationHeader: ((header: string) => void) | null;
+    /** A copy of an int32 kind loop (int32-kind-loops.ts) being emitted: the
+     * int32 arrays with checked stores it reads and writes as int32 arrays
+     * (the fast copy) or as double arrays (an ordinary copy entered only
+     * after they widened), as `function\0local` keys, and where each of the
+     * fast copy's writes resumes in the third copy. */
+    int32Kinds: {
+        int32: Set<string>;
+        wide: Set<string>;
+        resume: Map<IrStmt, string>;
+    } | null;
+    /** The resume label of the fast-copy write being emitted. */
+    int32KindResume: string | null;
     /** The function being emitted, for speculative globals. */
     speculativeFunction: string;
     /** Every function that writes each number global (computed on demand). */
@@ -716,20 +823,14 @@ export declare class LlEmitter {
     int32Elements: ((arr: IrExpr) => boolean) | null;
     /** Sums whose result only feeds 32-bit conversions (wrapping-sums.ts). */
     wrappingSums: Set<IrExpr>;
-    byteWindowsEnabled: boolean;
-    byteWindowEntries: ReturnType<typeof findInitializedByteLoopBindings>;
-    /** Typed-array loop versioning (bytes-loop-versions.ts) for the current
-     * function: off in debug and suspending functions and inside a copy. */
-    bytesLoopVersionsEnabled: boolean;
-    /** Loops being versioned around the statement being emitted: a loop is
-     * never versioned inside its own copies, and versions nest boundedly. */
-    readonly bytesLoopVersioning: Set<IrStmt>;
-    bytesLoopEntries: ReturnType<typeof findInitializedByteLoopBindings> | null;
-    bytesLoopFunction: IrFunction | null;
-    /** Counted loops whose integer-form safety test an enclosing version
-     * guard already passed. */
-    readonly provenCountedGuards: Set<IrStmt>;
+    /** Number locals of the current function that hold exact integers or NaN
+     * (findIntegerOrNaNLocals in wrapping-sums.ts). */
+    integerOrNaNLocals: ReadonlyMap<string, IntegerRange>;
     bytesBounds: ReadonlySet<IrExpr | IrStmt>;
+    /** The charCodeAt reads standing for charAt reads the emitter rewrote
+     * (one-unit tests and switches, charAtUnitRead), with the charAt each
+     * stands for: a loop version's proof for the charAt covers its read. */
+    readonly charAtUnitReads: Map<IrExpr, IrExpr>;
     /** Worker programs: typed-array accesses whose views an enclosing version
      * guard proved thread-owned. */
     bytesOwned: ReadonlySet<IrExpr | IrStmt>;
@@ -808,9 +909,17 @@ export declare class LlEmitter {
     readonly chainSlots: Map<string, LlValue>;
     logArgSlots: number;
     readonly stackTraces: boolean;
+    /** The options this emitter was built with (chunk emitters reuse them). */
+    readonly targetOptions: LlvmTargetOptions;
+    /** Records the module-level effects of emitting a range of functions,
+     * which the emitter that merges the range replays (emit-journal.ts). Null
+     * when this emitter emits the whole module itself. */
+    journal: EmitJournal | null;
+    /** The emitter's hosts forward to `journal` (journal set, or workers). */
+    private readonly journaled;
     /** Stack-trace mode: functions no capture can include (no frame push). */
     readonly unframedFunctions: ReadonlySet<string>;
-    constructor(mod: IrModule, options: LlvmTargetOptions);
+    constructor(mod: IrModule, options: LlvmTargetOptions, journal?: EmitJournal | null);
     /** The borrowed parameters of a hierarchy's vtable slot (empty: owned). */
     virtualSlotBorrowed(rootName: string, slotIndex: number): ReadonlySet<number>;
     /** Optimized emission: no debug-info (dev) posture. */
@@ -966,6 +1075,8 @@ export declare class LlEmitter {
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text: string): string;
+    /** The method-id slot for a constant method name (methodIdSlots). */
+    methodIdSlot(name: string): string;
     needBadTag(): void;
     /** The ScrMapOps descriptor holding these operands (ShapeHost.mapOps). */
     mapOps(operands: readonly string[]): string;
@@ -1147,6 +1258,10 @@ export declare class LlEmitter {
     private truthyOf;
     /** A union value's tag (i32): the box's tag word, or the NULL test of a
      * nullable union's pointer. */
+    /** A box's tag and payload words are written only where the box is
+     * built (runtime constructors and untagged stack stores), so their loads
+     * carry their own alias tags: element and field stores cannot change
+     * them, and loops keep them hoisted. */
     unionTag(uName: string, unionId: string): string;
     /** Guard for helpers that build or read a union's `%ScrUnion` box
      * directly (library-shaped unions with fixed arms): a nullable union
@@ -1184,6 +1299,12 @@ export declare class LlEmitter {
         inline: boolean;
         compressed: boolean;
     };
+    /** Whether values of `t` are NULL or a compact class instance: `C`,
+     * `C | undefined` or `C | null` for a compact class `C`. `C | null |
+     * undefined` is not: its null is a sentinel outside the region. */
+    compactRefType(t: IrType, isCompact?: (className: string) => boolean): boolean;
+    /** Whether arrays of `elem` hold 32-bit references (SCR_ELEM_CREF). */
+    compactArrayElem(elem: IrType): boolean;
     /** Loads the reference a field pointer addresses: a pointer, or the
      * decoded 32-bit reference of a compressed field (compressedFieldPtrs).
      * `tagged`: the load carries the field's alias tags. */
@@ -1244,8 +1365,8 @@ export declare class LlEmitter {
     /** A binding's storage: a module global, a plain local slot, or a boxed
      * local (the slot holds the capture BOX; access goes through it). */
     matchBytesLoopVersion(s: IrStmt & {
-        kind: "for";
-    }, counted: IntegerCountedForLoop | null): ReturnType<typeof matchBytesLoopVersion>;
+        kind: "for" | "while";
+    }, counted: IntegerCountedForLoop | null, paired?: IntegerPairedForLoop | null): ReturnType<typeof matchBytesLoopVersion>;
     /** The alias tag of a whole-slot load of a binding (module globals only). */
     slotAlias(id: string): string;
     binding(id: string): {
@@ -1343,6 +1464,26 @@ export declare class LlEmitter {
      * parameter, at the top of the body. */
     doubleCopies(fn: IrFunction): string[];
     emitFunction(fn: IrFunction): string;
+    /** What this range emitter (chunkEmitter) hands the merging emitter, as
+     * plain data a worker process can write: its journal and the sets and
+     * flags its functions set. */
+    chunkResult(): ChunkResult;
+    /** Merges a range emitter's result (chunkResult) into this emitter, in
+     * the range's order, and answers the rename of the range's text to this
+     * emitter's numbered helpers. Ranges merge in function order. */
+    mergeChunk(chunk: ChunkResult): (text: string) => string;
+    /** Adds a content-named constant a chunk interned. Its symbol is this
+     * emitter's own: a digest collision retries in first-use order, which a
+     * chunk alone does not know. */
+    private addContentEntry;
+    /** Applies a chunk's table entry (EmitJournal.entry) at its place in the
+     * chunk's order: a key this emitter lacks is added, numbered after its
+     * own entries where the table numbers them, and the chunk's name for it
+     * is renamed to this emitter's. */
+    applyJournalEntry(table: string, key: string, value: unknown, names: Map<string, string>, tags: Map<number, number>): void;
+    /** An emitter for a range of this module's functions: the same facts,
+     * empty module-level tables, and a journal of what the range adds. */
+    chunkEmitter(): LlEmitter;
     /** The double-ABI entry of a function with an i32 entry: every caller
      * that is not a direct call (closures, dispatch, adapters, the runtime)
      * enters here. A pending exception passes through to its caller. */
@@ -1583,6 +1724,11 @@ export declare class LlEmitter {
      * "compact": classes.ts COMPACT_PUBLISHED); leaves the builder in the cold
      * block and answers the continuation label. */
     private emitPublishedTest;
+    /** Branches on "the array `arr` is frozen" (SCR_ARR_FROZEN in its storage
+     * flags, scr_array.h), or published too when `published`; like
+     * emitPublishedTest, leaves the builder in the cold block and answers the
+     * continuation label. */
+    private emitFrozenArrayTest;
     private publishedNamesSym;
     /** The class-name table the hierarchy field guards index by preorder. */
     publishedClassNamesDefs(): string[];
@@ -1597,7 +1743,7 @@ export declare class LlEmitter {
     emitPublishedFieldGuard(obj: string, className: string | null, field: string): void;
     /** The frozen-array guard (scr_throw_published_array's ops): `index` and
      * `count` are doubles (the written index, the argument count). */
-    emitPublishedArrayGuard(arr: string, arrType: IrType, op: number, index?: string, count?: string): void;
+    emitPublishedArrayGuard(arr: string, arrType: IrType, op: number, index?: string, count?: string, third?: string | null): void;
     /** The published Map/Set guard: "Cannot modify a published Map/Set". */
     emitPublishedCollectionGuard(m: string, t: IrType): void;
     emitSerializationExpr(e: ExprOf<"jsonStringify" | "dynCheck">): LlValue;
@@ -1673,6 +1819,9 @@ export declare class LlEmitter {
     jsIcSite(): string;
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite(): string;
+    /** A fresh speculative loop site: the global that counts its bailing
+     * entries in a row. */
+    speculativeLoopSite(): string;
     dynKind(d: string): string;
     raceAdapterFor(from: IrType, to: IrType): string;
     genResultThunkFor(genT: IrType & {
@@ -1712,7 +1861,7 @@ export declare class LlEmitter {
     streamDataAdapter(cbT: IrType & {
         kind: "func";
     }): string;
-    streamDoneFnFor(kind: "w" | "f" | "d" | "t" | "l", doneT: IrType & {
+    streamDoneFnFor(kind: "w" | "f" | "d" | "t" | "l" | "c", doneT: IrType & {
         kind: "func";
     }): string;
     fsRenameThunkFor(cbT: IrType & {
@@ -1727,10 +1876,10 @@ export declare class LlEmitter {
     zlibBytesThunkFor(cbT: IrType & {
         kind: "func";
     }): string;
-    streamCbThunkFor(kind: "r" | "w" | "f" | "d" | "t" | "l" | "e", cbT: IrType): string;
+    streamCbThunkFor(kind: "r" | "w" | "f" | "d" | "t" | "l" | "e" | "c" | "v", cbT: IrType): string;
     resolveThunkFor(inner: IrType): string;
     tagInSet(uName: string, unionId: string, tags: number[]): string;
-    arrPush(arr: string, acc: "f64" | "bool" | "ref", value: string): string;
+    arrPush(arr: string, acc: ArrayAccess, value: string, element: IrType | null): string;
     emitArrayCopyLoop(dst: string, src: string, acc: "f64" | "bool" | "ref"): void;
     emitStrIntrinsic(e: IrExpr & {
         kind: "strIntrinsic";