@scriptc/compiler 0.1.6 → 0.2.0

package/dist/backend/c/c-emitter.d.ts

@@ -1,531 +0,0 @@
-import type { IrBytesElem, IrGlobal, IrRecordShape, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
-import type { IntegerRanges } from "../../ir/integer-ranges.js";
-import { type ConstantNumericTable } from "../../ir/constant-tables.js";
-import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
-import { VtSlot, ClassMeta } from "./shapes.js";
-import { type StreamTypedRefAdapter } from "./exprs.js";
-export interface CEmitOptions {
-    /** Library archive assembly may move the volatile identity getters into a
-     * separate translation unit. Public/direct emission keeps them by default. */
-    emitLibraryIdentity?: boolean;
-}
-export declare function emitCModule(mod: IrModule, sourceText?: string, options?: CEmitOptions): string;
-/** A declared C value with its IR type — the unit frames and scopes track
- * so releases can be type-directed. */
-export interface Temp {
-    name: string;
-    type: IrType;
-}
-/** A scope entry: a refcounted local, either held directly or through a
- * capture box (boxed locals release their BOX; the box frees its contents). */
-export interface ScopeEntry extends Temp {
-    boxed?: boolean;
-}
-export declare class CEmitter {
-    readonly mod: IrModule;
-    private readonly options;
-    readonly lines: string[];
-    indent: number;
-    tempCounter: number;
-    /** Interned string literals: UTF-8 text → static symbol name. */
-    readonly literals: Map<string, string>;
-    /** Kind-specialized typed-array access helpers actually used by this
-     * program. Keeping these in the generated TU means unrelated binaries do
-     * not pay even debug/link metadata for byte-loop fast paths. */
-    readonly bytesElementHelpers: Set<"get:f32:f64" | "get:f32:u64" | "get:f64:f64" | "get:f64:u64" | "get:i32:f64" | "get:i32:u64" | "get:u32:f64" | "get:u32:u64" | "get:u8:f64" | "get:u8:u64" | "set:f32:f64" | "set:f32:u64" | "set:f64:f64" | "set:f64:u64" | "set:i32:f64" | "set:i32:u64" | "set:u32:f64" | "set:u32:u64" | "set:u8:f64" | "set:u8:u64">;
-    /** Interned unit-armed union instances: "unionId:tag" → static symbol.
-     * A unit arm (undefined/null) has no payload, so every instance of one
-     * (union, tag) pair is identical — ONE immortal (rc == SIZE_MAX) static
-     * serves them all. Immortals are skipped by retain/release and by the
-     * cycle collector's child filter (SCR_CYC_SKIP), so the missing cycle
-     * header is fine even when a traced container points at one. */
-    readonly unitInstances: Map<string, string>;
-    /** Interned regex literals: "<flags>/<pattern>" → static symbol. One
-     * immortal (rc == SIZE_MAX) ScrRegex per distinct (pattern, flags) pair —
-     * the bytecode slot starts NULL and the runtime compiles it lazily on
-     * first use. The source/flags strings ride the ordinary literal table. */
-    readonly regexInstances: Map<string, string>;
-    /** Interned tagged-template strings objects: per-site key → symbol +
-     * cooked spans. One immortal (rc == SIZE_MAX) ScrArr of interned string
-     * literals per template-literal SITE — the spec's per-occurrence
-     * identity: the same site evaluated twice hands the tag the same array,
-     * two sites never share even with identical text. */
-    readonly templateStringsInstances: Map<string, {
-        sym: string;
-        cooked: string[];
-    }>;
-    /** Class objects (classes as first-class values): className → static
-     * symbol. One immortal ScrClassObj per class some classRef names —
-     * preorder interval baked as constants, the .name string in the literal
-     * table, and a per-class construct thunk (void *sc_ct_*) newValue
-     * dispatches through. Registered during body emission (the regex
-     * pattern); the statics and thunks are assembled around the bodies. */
-    readonly classObjs: Map<string, string>;
-    /** Stack of statement frames: refcounted temps not yet released or moved. */
-    frames: Temp[][];
-    /** Stack of scopes: refcounted locals (with types) declared in each. */
-    scopes: ScopeEntry[][];
-    /** The function being emitted: local table (for boxedness) and whether
-     * each local arrived through the closure environment (env captures are
-     * borrowed — never declared, never released here). */
-    currentLocals: Map<string, IrLocal>;
-    captureIds: Set<string>;
-    /** Canonical byte-loop induction locals currently represented by an
-     * unsigned integer shadow. Ordinary number reads widen the shadow back to
-     * f64; direct byte indices consume it without a conversion round trip. */
-    integerLoopBindings: Map<string, string>;
-    integerRanges: IntegerRanges;
-    /** Declared functions referenced as values: each needs an env-signature
-     * wrapper + an interned immortal closure (so `f === f` holds). */
-    readonly fnValues: Set<string>;
-    /** Emitted ref-kind resolve thunks for new Promise, interned per inner
-     * typeKey → thunk symbol. */
-    readonly resolveThunks: Map<string, string>;
-    readonly genResThunks: Map<string, string>;
-    /** Emitted child exit adapters, interned per union id (childExitThunkFor). */
-    readonly childExitThunks: Map<string, string>;
-    /** Emitted child-stream data adapters, interned per union id
-     * (childDataThunkFor). */
-    readonly childDataThunks: Map<string, string>;
-    /** Emitted bound-close adapters, interned per union id
-     * (closeBindThunkFor). */
-    readonly closeBindThunks: Map<string, string>;
-    /** Emitted close-override wrappers, interned per (union id, ret kind)
-     * (closeOverrideWrapFor). */
-    readonly closeOverrideWraps: Map<string, string>;
-    /** Emitted dgram message adapters, interned per rinfo shape id
-     * (dgramMsgThunkFor). */
-    readonly dgramMsgThunks: Map<string, string>;
-    /** Emitted dns.lookup callback adapters, interned per union id + param
-     * count (dnsLookupThunkFor). */
-    readonly dnsLookupThunks: Map<string, string>;
-    /** Emitted fs.rename callback adapters, interned per callback type. */
-    readonly fsRenameThunks: Map<string, string>;
-    /** Emitted SNI answer-closure thunks, interned per cb func-type key
-     * (sniAnswerThunkFor). */
-    readonly sniAnswerThunks: Map<string, string>;
-    /** Emitted net.connect lookup answer thunks, interned per cb func-type
-     * key (netLookupAnswerThunkFor). */
-    readonly netLookupAnswerThunks: Map<string, string>;
-    /** Emitted EventEmitter listener invoke adapters, interned per listener
-     * func-type key (emitterInvokeThunkFor). */
-    readonly emitterInvokeThunks: Map<string, string>;
-    /** Emitted stream option-callback invoke adapters (read/write/final/
-     * destroy/transform/flush — the leading-`this` closures), interned per
-     * (kind, callback func-type) key (streamCbThunkFor). */
-    readonly streamCbThunks: Map<string, string>;
-    /** Emitted stream completion-callback closure fns (the `callback` a
-     * user's write/final/destroy/transform/flush receives and calls),
-     * interned per (kind, done func-type) key (streamDoneFnFor). */
-    readonly streamDoneFns: Map<string, string>;
-    /** Emitted CONNECT-listener union-socket adapters, interned per cb
-     * func-type key (connectSockThunkFor). */
-    readonly connectSockThunks: Map<string, string>;
-    /** Emitted Promise.race fulfillment adapters, interned per
-     * `entryInner=>resultInner` typeKey pair (raceAdapterFor). */
-    readonly raceThunks: Map<string, string>;
-    /** setTimeout appeared somewhere: main must run the event loop even in
-     * programs with no async functions. */
-    usesTimers: boolean;
-    readonly fnByName: Map<string, IrFunction>;
-    /** Manifest-bound native imports, used by ffiCall emission. */
-    readonly ffiByName: Map<string, IrFfiImport>;
-    /** One C-ABI trampoline per manifest callback entry. Raw function
-     * pointers additionally get a distinct TLS context slot, so two
-     * callbacks with the same signature never alias each other's closure. */
-    readonly ffiCallbackAdapters: Map<string, FfiCallbackAdapter>;
-    /** Module-level constant consulted per ffiCall: with a retained
-     * descriptor anywhere in the manifest, every native call is a
-     * pending-exception checkpoint (may-throw derives the same fact from
-     * the same helper). */
-    readonly ffiHasRetainedCallback: boolean;
-    readonly ffiHasForeignCallback: boolean;
-    readonly globalsById: Map<string, IrGlobal>;
-    readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
-    readonly unionsById: Map<string, IrUnionDef>;
-    /** Active optional-chain bind temps, by chain id (chainRecv reads). */
-    readonly chainTemps: Map<string, Temp>;
-    readonly recordsById: Map<string, IrRecordShape>;
-    /** Record shapes whose bodies emitted recordClone. Filled while function
-     * bodies emit, before emitStructDefs assembles per-shape helpers. */
-    readonly recordCloneShapes: Set<string>;
-    /** Type-directed JSON walkers, interned per typeKey — one serializer per
-     * type used in jsonStringify position (sc_jw_*), one match predicate
-     * (sc_dm_*) and one checked builder (sc_dc_*) per type used in dynCheck
-     * position. Emitted as prototypes + definitions after the struct block
-     * (they reference struct types, per-shape RC helpers, and each other, so
-     * the prototypes make definition order irrelevant). */
-    readonly jsonWriters: Map<string, string>;
-    /** The pretty-print re-indenter (type-independent, interned once):
-     * emitted on the first `JSON.stringify(v, null, space)` site. */
-    jsonIndentFn: string | null;
-    /** The dyn ToString pair (type-independent, interned once): emitted on
-     * the first String(unknown) / `${unknown}` site. */
-    dynToStrFn: string | null;
-    /** The caught→dyn converter (type-independent, interned once): emitted
-     * on the first catch binding flowing into an `unknown` slot. */
-    caughtToDynFn: string | null;
-    /** Interned per-union helpers: unionId → emitted function name. */
-    readonly unionTruthyFns: Map<string, string>;
-    readonly unionEqFns: Map<string, string>;
-    readonly unionToStrFns: Map<string, string>;
-    readonly unionJoinFns: Map<string, string>;
-    readonly dynMatchers: Map<string, string>;
-    readonly dynBuilders: Map<string, string>;
-    /** Static→dyn converters (sc_td_*), per typeKey; dynamic-keyed record
-     * read helpers (sc_rkg_*), per shapeId|result typeKey; dynamic-keyed
-     * write helpers (sc_rks_*), per shapeId. */
-    readonly toDynFns: Map<string, string>;
-    /** ReadableStream.from typed-array element adapters, per element
-     * typeKey. The runtime retains the original array and calls one of these
-     * for each pull, preserving iterator-time reads without teaching the
-     * runtime the compiler's program-specific record/union layouts. */
-    readonly streamFromArrayAdapters: Map<string, string>;
-    /** Identity-preserving static→dyn capsules for program classes and Web
-     * APIs whose values remain directly observable. */
-    readonly liveDynRefAdapters: Map<string, {
-        snapshot: string;
-        commit: string;
-    }>;
-    /** Runtime-arm dispatchers for live references whose static type is a
-     * union. Mutable arms become typed capsules; scalar/unit arms retain the
-     * ordinary static-to-dyn conversion. */
-    readonly liveDynUnionRefAdapters: Map<string, string>;
-    readonly dynPromiseAdapters: Map<string, string>;
-    /** The checked-dynamic function boundary's per-signature helpers (see
-     * walkers.ts): call thunks (sc_dfk_*), box builders (sc_dfb_*),
-     * and dynCheck adapters (sc_dfa_*), each per func typeKey. */
-    readonly dynFuncThunks: Map<string, string>;
-    readonly dynFuncBoxes: Map<string, string>;
-    readonly dynFuncAdapters: Map<string, string>;
-    /** dyn-promise settle adapters (sc_pda_*), per INNER typeKey: convert a
-     * typed fulfillment payload into the boxed destination's dyn payload
-     * (scr_dyn_new_promise_adapting's callback — toDynHelper's promise arm). */
-    readonly promiseDynAdapters: Map<string, string>;
-    readonly recordKeyGetFns: Map<string, string>;
-    readonly recordKeySetFns: Map<string, string>;
-    readonly walkerProtos: string[];
-    readonly walkerDefs: string[];
-    /** Island host-call adapters, interned per (arity, void-ness): the one
-     * uniform shape scr_jsval_from_closure calls — unpack the cell array,
-     * call the closure through its real ABI (which CONSUMES its params, so
-     * each cell is retained in), return the +1 result cell or NULL for void.
-     * Definitions ride walkerDefs (self-contained over the closure ABI). */
-    readonly islandAdapters: Map<string, string>;
-    /** TYPED island host-call adapters, interned per full signature (param
-     * typeKeys + return classification): each incoming engine argument
-     * converts to the param's static type through the exit machinery before
-     * the closure runs — see islandTypedAdapter (island.ts). */
-    readonly islandTypedAdapters: Map<string, string>;
-    /** Enclosing break/continue targets. An unlabeled `break` binds to the
-     * innermost loop-or-switch entry (labeled BLOCK entries are skipped); an
-     * unlabeled `continue` searches inward-out for the innermost LOOP,
-     * skipping switches and blocks. A LABELED jump binds to the entry whose
-     * `labels` contains its label: `break lbl` jumps to the target's
-     * endLabel (loops allocate one lazily via `usedEnd` — a C `break` only
-     * exits the innermost loop), `continue lbl` to the target loop's
-     * continueLabel. Loops: `continueLabel` is null when C `continue` is
-     * correct (unlabeled while/forOf); for/do-while loops need a goto label
-     * so `continue` still runs the update/condition, and LABELED loops of
-     * every shape allocate one up front (a labeled continue from a nested
-     * loop needs a goto). Switches are emitted as goto chains — never as C
-     * `switch` — so a C `break`/`continue` inside an emitted switch region
-     * still binds to the enclosing C loop; a break targeting the switch
-     * itself jumps to `endLabel` instead. Labeled blocks carry only an
-     * endLabel (`break lbl` is the only jump that can target them).
-     * `scopeDepth` = scopes.length at entry — a break/continue releases
-     * every scope pushed after that before jumping. `frameDepth` =
-     * frames.length at entry: statements the jump exits may still hold
-     * pending refcounted temps in their frames (a switch's discriminant,
-     * most notably), whose normal end-of-statement releases sit on the
-     * fall-through path the jump bypasses — the jump releases every frame
-     * pushed after the target's own before jumping. */
-    jumpTargets: ({
-        kind: "loop";
-        continueLabel: string | null;
-        usedContinue: boolean;
-        endLabel: string | null;
-        usedEnd: boolean;
-        labels?: string[];
-        scopeDepth: number;
-        frameDepth: number;
-        finallyDepth: number;
-    } | {
-        kind: "switch";
-        endLabel: string;
-        usedEnd: boolean;
-        labels?: string[];
-        scopeDepth: number;
-        frameDepth: number;
-        finallyDepth: number;
-    } | {
-        kind: "block";
-        endLabel: string;
-        usedEnd: boolean;
-        labels: string[];
-        scopeDepth: number;
-        frameDepth: number;
-        finallyDepth: number;
-    })[];
-    labelCounter: number;
-    readonly returnTypeByFn: Map<string, IrType>;
-    lineStarts: number[] | null;
-    /** May-throw analysis results (computeMayThrow): pending-exception checks
-     * are emitted only after calls that can actually raise. */
-    readonly mayThrow: Set<string>;
-    readonly indirectMayThrow: boolean;
-    /** Enclosing try contexts, innermost last — the compile-time analogue of
-     * the jump-target stack for UNWINDING: a pending check (or `throw`) inside
-     * a try releases frames/scopes down to the recorded depths and jumps to
-     * `label` (the catch, or the exception-path finally) instead of returning
-     * out of the function. Purely compile-time: entering a try emits no code. */
-    tryStack: {
-        label: string;
-        used: boolean;
-        frameDepth: number;
-        scopeDepth: number;
-    }[];
-    /** Enclosing try-with-finally regions, innermost last. Returns use the
-     * central pending-return copies; break/continue inline the crossed bodies
-     * with the same truncated ownership and exception context as LLVM. */
-    finallyStack: {
-        label: string;
-        used: boolean;
-        frameDepth: number;
-        scopeDepth: number;
-        tryDepth: number;
-        body: IrStmt[];
-    }[];
-    /** Scope entry protecting sc_pret while a pending-return finally copy
-     * runs. A return in that copy replaces the old completion: it evaluates
-     * first, releases the old slot, then removes this protection from its
-     * own unwind path before dispatching. */
-    pendingReturnScopeIndex: number | null;
-    /** Return type of the function being emitted — the unwind path returns a
-     * dummy of this type (never read: callers check the pending flag first). */
-    currentReturnType: IrType;
-    /** The generator channels of the function being emitted (null outside
-     * generator bodies): yieldExpr emission reads them, and emitTryCatch's
-     * catch prologue emits the GENRET sentinel re-unwind exactly here. */
-    currentGenerator: {
-        yieldT: IrType;
-        nextT: IrType;
-    } | null;
-    /** Cycle-capable shapes ("object:<name>" / "record:<id>") and unions
-     * (unionId): instances get a cycle header + emitted trace/teardown, and
-     * fields/payloads of these types are visited by container traces.
-     * Computed as a greatest fixpoint in the constructor — see there. */
-    readonly tracedShapes: Set<string>;
-    readonly tracedUnions: Set<string>;
-    /** The class graph (single inheritance): base/children links, hierarchy
-     * membership (extends anywhere ⇒ vtable word + dynamic release), the
-     * whole-program preorder numbering behind O(1) instanceof, and the
-     * per-hierarchy virtual slot lists (root classes only). Computed once in
-     * the constructor. */
-    readonly classMeta: Map<string, ClassMeta>;
-    /** Method names with at least one may-throw implementation: a
-     * virtualCall's pending check keys on this (same over-approximation as
-     * computeMayThrow's callee cover). */
-    readonly mayThrowMethods: Set<string>;
-    /** Vtable slot adapters to define after the function signatures (they
-     * call sc_f_* bodies): dedupe key "implClass.method". */
-    readonly vtAdapters: Map<string, {
-        impl: ClassMeta;
-        slot: VtSlot;
-    }>;
-    constructor(mod: IrModule, sourceText?: string, options?: CEmitOptions);
-    emit(): string;
-    emitLibEntries(out: string[], globals: IrGlobal[]): void;
-    emitAsyncScaffolding(out: string[]): void;
-    emitStructDefs(out: string[]): void;
-    vtEntriesFor(meta: ClassMeta): {
-        slot: VtSlot;
-        impl: ClassMeta | null;
-    }[];
-    vtSlotParams(slot: VtSlot, named: boolean): string[];
-    emitVtableDecls(out: string[], hierarchyClasses: ClassMeta[]): void;
-    emitVtableInstances(out: string[], hierarchyClasses: ClassMeta[]): void;
-    emitVtAdapterDefs(out: string[]): void;
-    emitHierarchyClassHelpers(out: string[], meta: ClassMeta, s: {
-        struct: string;
-        newFn: string;
-        retain: string;
-        release: string;
-        trace: string;
-        gcFree: string;
-        traced: boolean;
-        fields: {
-            name: string;
-            type: IrType;
-        }[];
-    }): void;
-    islandAdapter(arity: number, retKind: "void" | "jsval" | "f64" | "bool" | "string"): string;
-    islandTypedAdapter(fn: IrType & {
-        kind: "func";
-    }): string;
-    unionTruthyHelper(unionId: string): string;
-    unionEqHelper(unionId: string, sameValue: boolean): string;
-    unionToStrHelper(unionId: string): string;
-    unionJoinHelper(unionId: string): string;
-    jsonWriteHelper(t: IrType): string;
-    jsonIndentHelper(): string;
-    dynMatchHelper(t: IrType): string;
-    dynCheckHelper(t: IrType): string;
-    toDynHelper(t: IrType): string;
-    liveDynRefAdapter(t: IrType): StreamTypedRefAdapter;
-    dynFuncBoxHelper(t: IrType & {
-        kind: "func";
-    }): string;
-    recordKeyGetHelper(shapeId: string, t: IrType, overflowOnly?: boolean): string;
-    recordKeySetHelper(shapeId: string): string;
-    dynToStrHelper(): string;
-    caughtToDynHelper(): string;
-    traceAdapterC(t: IrType): string | null;
-    traceArgC(t: IrType): string;
-    boxNewC(t: IrType): string;
-    arrNewC(elem: IrType, capExpr: string | number): string;
-    integerLoopIndex(expr: IrExpr): string | null;
-    bytesElementHelper(op: "get" | "set", elem: IrBytesElem, integerIndex?: boolean): string;
-    private emitBytesElementHelpers;
-    line(text: string): void;
-    srcComment(loc: SrcLoc): string;
-    newTemp(type: IrType, init: string): Temp;
-    /** A borrowed compiler temp. Used only when a surrounding operation has
-     * proved that evaluation cannot overwrite the owning binding before the
-     * temp's last use. Unlike newTemp, this does not join the release frame. */
-    newBorrowedTemp(type: IrType, init: string): Temp;
-    /** newTemp for a MAY-THROW runtime call: the result joins its frame
-     * BEFORE the standard pending check, so an unwind releases the dummy
-     * (NULL for refcounted kinds) harmlessly and the value is only read past
-     * the check. The shared shape of every fallible boundary call — jsOp,
-     * jsExit, composite jsMarshal, dynCheck, await reads. */
-    fallibleTemp(type: IrType, call: string): Temp;
-    currentFrame(): Temp[];
-    /** Strike a refcounted temp from its frame: ownership is being moved. */
-    moveTemp(t: Temp): void;
-    /** The release call for one owned refcounted value. */
-    releaseValue(name: string, type: IrType): void;
-    releaseFrame(frame: ScopeEntry[]): void;
-    /** THE release-on-jump path (break/continue/return): pending statement
-     * frames and entered scopes down to (and excluding nothing above) the
-     * given depths, innermost first — everything whose normal fall-through
-     * releases the jump bypasses. The jump target's own frame/scope stay
-     * live: a loop's releases after the loop and a switch's after its end
-     * label are still on the jump's path (return passes 0/0 — it leaves the
-     * whole function). */
-    releaseForJump(frameDepth: number, scopeDepth: number): void;
-    /** Run the finally regions a break/continue exits, then release to its
-     * resolved target. Every body sees compile-time frame/scope/finally/try
-     * stacks truncated to the region boundary: a throw propagates outside
-     * the completing try, and a jump inside the finally replaces the pending
-     * jump without re-entering the same cleanup. */
-    emitFinallysForJump(finallyDepth: number, frameDepth: number, scopeDepth: number): void;
-    /** THE unwind path at a point where an exception is pending: release
-     * everything between here and the innermost try handler — or the whole
-     * function — via releaseForJump, then jump to the handler / return a
-     * dummy value (never read: callers of a may-throw function test the
-     * pending flag before using the result). Callers own the surrounding
-     * `if (scr_exc_pending())`; a `throw` unwinds unconditionally. */
-    emitUnwind(): void;
-    errorVtStampLines(): string[];
-    /** The C symbol a direct call or closure enters a function through:
-     * async bodies are entered via their emitted spawn wrapper (which runs
-     * 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). */
-    callTargetC(fnName: string): string;
-    /** The emitter contract for exceptions: after EVERY call that can throw
-     * (per the may-throw analysis), test the pending flag and unwind. */
-    emitPendingCheck(): void;
-    internLiteral(text: string): string;
-    /** The class object's static symbol (classes as values), registering it
-     * for assembly on first use and interning the .name literal while the
-     * literal table is still open (bodies emit before the file assembles —
-     * the regex-literal discipline). */
-    classObjSym(className: string): string;
-    /** The interned immortal instance for a UNIT arm of a union — asserts the
-     * arm really is payload-less (undefined/null). */
-    internUnitInstance(unionId: string, tag: number): string;
-    /** The C expression for that instance — the one pointer every unit-arm
-     * value of this (union, tag) is: rc == SIZE_MAX, so RC entry points and
-     * the collector both skip it and no retain is ever owed. */
-    unitInstanceRef(unionId: string, tag: number): string;
-    /** The class-newFn initialization line for a field whose type ADMITS
-     * undefined — such fields start as JS's `undefined`, never the calloc
-     * NULL: tsc's strictPropertyInitialization accepts them with no
-     * initializer and no constructor assignment (undefined is in the type),
-     * so a fresh instance is readable before any assignment runs — a method
-     * assigns later, a constructor branch skips it, a base constructor's
-     * virtual call reads a derived field before super() returns. Node reads
-     * `undefined` there; a NULL payload pointer would be a segfault (union
-     * fields) or a silent nothing (jsval fields). Undefined-armed unions get
-     * the interned immortal unit instance (free; releases skip it); jsval
-     * (`any`) fields get an engine undefined cell — such classes exist only
-     * in --dynamic builds, and the field's release balances it. Empty for
-     * every type that cannot hold undefined (tsc's SPI guards those) and for
-     * record shapes' construction paths, which write every field. */
-    undefFieldInitLineC(name: string, t: IrType): string[];
-    ffiCallbackAdapter(binding: string, id: string): FfiCallbackAdapter;
-    /** C-callable trampolines for format-2/3/4 callbacks. The external callback
-     * ABI is scalar C, format-3 copy-in string/byte slots, plus an optional
-     * exact-position context pointer; the internal side is scriptc's
-     * (ScrClosure *env, params...) convention. A raw callback borrows its
-     * closure through a distinct TLS slot for the dynamic extent of the outer
-     * call, or a process-global slot for retained replace semantics. */
-    emitFfiCallbackDefs(out: string[]): void;
-    signature(fn: IrFunction): string;
-    emitFunction(fn: IrFunction): void;
-    emitBlock(stmts: IrStmt[], setup?: (scope: ScopeEntry[]) => void): void;
-    emitStmts(stmts: IrStmt[]): void;
-    emitStmt(s: IrStmt): void;
-    /** A fresh loop jump-target entry. `continueLabel` null means "C
-     * continue is correct" (while/forOf) — but a LABELED loop always
-     * allocates one (a labeled continue arriving from a nested loop needs a
-     * goto), and every labeled loop gets a lazy end label for labeled break
-     * (a C break only exits the innermost loop). */
-    loopTarget(continueLabel: string | null, labels: string[] | undefined): (typeof this.jumpTargets)[number] & {
-        kind: "loop";
-    };
-    emitTryCatch(s: IrStmt & {
-        kind: "tryCatch";
-    }): void;
-    emitSwitch(s: IrStmt & {
-        kind: "switch";
-    }): void;
-    mergeBrace(emitBlockFn: () => void): void;
-    emitBranchInto(target: string, expr: IrExpr): void;
-    emitCondition(cond: IrExpr): string;
-    /** C expression testing JS truthiness of a temp (falsy: 0, -0, NaN, "").
-     * `x == x` rejects NaN, `x != 0` rejects both zeros; strings only need
-     * their length — no runtime call, no ownership change. */
-    truthyC(t: Temp): string;
-    emitExpr(e: IrExpr): Temp;
-    childExitThunkFor(param: IrType): string;
-    execFileThunkFor(cbT: IrType & {
-        kind: "func";
-    }): string;
-    ipcMessageThunkFor(cbT: IrType & {
-        kind: "func";
-    }): string;
-    ipcSendThunkFor(cbT: IrType & {
-        kind: "func";
-    }): string;
-    childDataThunkFor(param: IrType): string;
-    closeBindThunkFor(cbUnion: IrType, retServer: boolean): string;
-    closeOverrideWrapFor(cbUnion: IrType, retServer: boolean): string;
-    childExitSignalThunkFor(codeParam: IrType, sigParam: IrType): string;
-    dgramMsgThunkFor(param: IrType): string;
-    dnsLookupThunkFor(cbT: IrType): string;
-    fsRenameThunkFor(cbT: IrType): string;
-    cryptoBytesThunkFor(cbT: IrType): string;
-    zlibBytesThunkFor(cbT: IrType): string;
-    sniAnswerThunkFor(cbT: IrType): string;
-    netLookupAnswerThunkFor(cbT: IrType): string;
-    emitterInvokeThunkFor(cbT: IrType): string;
-    streamDataThunkFor(cbT: IrType): string;
-    streamCbThunkFor(kind: "r" | "w" | "f" | "d" | "t" | "l" | "e", cbT: IrType): string;
-    connectSockThunkFor(cbT: IrType): string;
-    connectResThunkFor(cbT: IrType): string;
-    raceAdapterFor(from: IrType, to: IrType): string;
-    resolveThunkFor(inner: IrType): string;
-}