@scriptc/compiler 0.3.3 → 0.3.5

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

@@ -1,10 +1,11 @@
 import { type ArraySearchKind } from "./array-search.js";
 import type { IrBytesElem, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
 import { type SplitSpan } from "./split-loops.js";
-import { type IntegerRanges } from "../../ir/integer-ranges.js";
+import { type IntegerRange, type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type Int32Slots } from "../../ir/int32-slots.js";
 import { type Int32Abi } from "./int32-abi.js";
 import { type Int32Local } from "./int32-locals.js";
+import { type IntegerClones } from "./integer-clones.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
 import { type CallLifetimes } from "./call-lifetimes.js";
@@ -15,6 +16,7 @@ import { InlineUnionFields } from "./inline-unions.js";
 import { OptionalArrayReads, type LocalArrayRead } from "./local-array-reads.js";
 import { CheckedNarrows } from "./checked-narrows.js";
 import { type MapReadLifetimes } from "./map-read-lifetimes.js";
+import { type MapEntryFusion } from "./map-entry-fusion.js";
 import { ReferenceEffects } from "./reference-effects.js";
 import { ReferenceWrites, type Writes } from "./reference-writes.js";
 import { StackCallbacks } from "./stack-callbacks.js";
@@ -89,6 +91,10 @@ 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 `!range` attachment of an array length load: a length is at most
+     * 2^32 - 1 (the runtime's SCR_ARR_MAX_LENGTH), so conversions to double
+     * and back fold. 32-bit targets load the full range anyway. */
+    get arrayLengthRange(): string;
     fieldAliasAttachment(ptr: string): string;
     private fieldAliasMetadata;
     private readonly debug;
@@ -173,6 +179,8 @@ export declare class LlEmitter {
     /** Interned NUL-terminated C-string constants (scr_jb_puts labels, the
      * stringify indent text): UTF-8 text → { symbol, byte length }. */
     private readonly cstrs;
+    /** Interned ScrMapOps descriptors (scr_map.h): initializer → symbol. */
+    private readonly mapOpsConsts;
     /** Type-directed walker functions (JSON serializers, the indent
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
@@ -215,6 +223,9 @@ export declare class LlEmitter {
     readonly checkedNarrows: CheckedNarrows;
     callArrayReads: Map<IrExpr, LocalArrayRead>;
     mapReadLifetimes: MapReadLifetimes;
+    readNumberMapWrites: ReadonlySet<IrExpr>;
+    /** The current function's fused string-key Map get-then-set pairs (map-entry-fusion.ts). */
+    mapEntryFusion: MapEntryFusion | null;
     readonly callLifetimes: CallLifetimes;
     readonly constantCallbacks: Map<string, Map<string, string>>;
     currentConstantCallbacks: ReadonlyMap<string, string>;
@@ -373,8 +384,18 @@ export declare class LlEmitter {
     private readonly initializerBindings;
     /** Whole-program int32 storage and parameter/result facts. */
     readonly int32Slots: Int32Slots;
+    /** The program has no runtime store into a checked-dynamic value
+     * (dynamicFieldStores), so live views of classes and records never
+     * commit back into their objects. Library builds keep their commits:
+     * their values cross a native boundary. */
+    readonly liveViewsReadOnly: boolean;
     /** Functions whose direct calls use i32 parameters or results. */
     readonly int32Abis: ReadonlyMap<string, Int32Abi>;
+    /** Pure number functions with speculative integer clones. */
+    readonly integerClones: IntegerClones;
+    /** The IR function being emitted. */
+    currentFunctionName: string;
+    integerParamRange(fnName: string, localId: string): IntegerRange | null;
     /** Immutable module constants (contract types) whose graphs become
      * immortal once initialized: their reads need no reference counting. */
     readonly immortalGlobals: ReadonlySet<string>;
@@ -406,6 +427,9 @@ export declare class LlEmitter {
     private byteWindowEntries;
     bytesBounds: ReadonlySet<IrExpr | IrStmt>;
     integerViews: Map<string, string>;
+    /** Module globals the current function owns outright (initializer
+     * bindings): their function-local slot, which stands in for the global. */
+    private privateGlobalSlots;
     /** Number locals of the current function stored only as an i32
      * (int32-locals.ts); their slots are `alloca i32`. */
     int32Locals: Map<string, Int32Local>;
@@ -446,7 +470,14 @@ export declare class LlEmitter {
         finalLabel: string;
         cleanupLabel: string;
         suspendLabel: string;
+        /** The generator's OUT slot (%ScrGenSlot) for a native body whose
+         * yield channel is a number or boolean, which its yields store into
+         * inline (see emitGenSlotStore); null otherwise. */
+        out: string | null;
     } | null;
+    /** Inline generator slot accesses need the %ScrGenHead/%ScrGenSlot
+     * mirrors in the module header. */
+    usesGenSlots: boolean;
     /** 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. */
@@ -463,6 +494,8 @@ export declare class LlEmitter {
     constructor(mod: IrModule, options: LlvmTargetOptions);
     /** 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. */
+    get optimizing(): boolean;
     /** The vtable entry for one implementation (VirtualBorrows.entry). */
     virtualEntry(implFn: string): string;
     private implSlotBorrowed;
@@ -581,6 +614,8 @@ export declare class LlEmitter {
      * stringify-indent currency) — `@`-ref, first-use order. */
     cstr(text: string): string;
     needBadTag(): void;
+    /** The ScrMapOps descriptor holding these operands (ShapeHost.mapOps). */
+    mapOps(operands: readonly string[]): string;
     /** The interned immortal instance for a UNIT arm of a union — asserts
      * the arm really is payload-less (undefined/null). Public: class
      * emission initializes undefined-admitting fields through it
@@ -687,6 +722,11 @@ export declare class LlEmitter {
      * conditions in expr-calls.ts). */
     private callTestsPending;
     private workerLoopBudget;
+    /** The amortized cancellation poll, emitted on the loop's back edge (the
+     * continue target), after the body. A poll in the header would be a loop
+     * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
+     * the body repeats on every iteration (a typed array's length, for one)
+     * stay in the loop. */
     private emitWorkerLoopCheck;
     /** Moves an already-evaluated value into the runtime's exception cell —
      * the `throw` statement's kind dispatch (stmts.ts's), shared with
@@ -846,11 +886,24 @@ export declare class LlEmitter {
      * whether the promise waiter list or the ready FIFO owns the continuation;
      * LLVM keeps all live locals in the coroutine frame. */
     emitWasiSuspend(promise: string | null): void;
+    /** A native generator's OUT slot (scr_async.c's ScrGen.out, mirrored by
+     * %ScrGenHead and %ScrGenSlot { kind, f64, b, payload, release_fn }). */
+    genOutSlot(gen: string): string;
+    /** A yield on a number or boolean channel: scr_gen_slot_f64/bool inline.
+     * Such a body's OUT never holds a reference at a yield (only its final
+     * completion can park one), so the slot needs no release first. */
+    emitGenSlotStore(slot: string, kind: "f64" | "bool", value: string): void;
+    /** scr_gen_take_out_f64/bool inline: the slot's value when it holds that
+     * kind (otherwise 0 or false), leaving the slot empty. */
+    emitGenSlotTake(slot: string, kind: "f64" | "bool"): string;
     /** Suspend after a target-specific runtime helper already queued the
      * continuation (used by module awaits, which skip the hop when settled). */
     emitCoroSuspendPrepared(): void;
     /** Move a clean async return value into the current fiber's promise. */
     private emitWasiFulfill;
+    /** Number locals declared as a copy of a capture or of a lazily boxed
+     * parameter, at the top of the body. */
+    private doubleCopies;
     private emitFunction;
     /** The double-ABI entry of a function with an i32 entry: every caller
      * that is not a direct call (closures, dispatch, adapters, the runtime)
@@ -1022,6 +1075,27 @@ export declare class LlEmitter {
      * `s += String.fromCharCode(c)` appends the character without building
      * the one-character string; null for any other suffix. */
     private emitSingleCharCode;
+    /**
+     * Lower `recv.f = recv.f + suffix` on a plain string field like
+     * emitStringSelfConcatAssign does for locals. The field's old value is
+     * snapshotted (+1) and the suffix evaluated in JavaScript order; then the
+     * field unlinks and releases its CURRENT value, so the snapshot is unique
+     * unless a real alias exists and the concat appends in place instead of
+     * copying the whole string on every append. Returns false (emitting
+     * nothing) for every other store.
+     */
+    private emitFieldSelfConcat;
+    /** A snapshot the current statement frames own (+1), or an immortal
+     * value: it stays valid after its container releases the same string. */
+    private ownsSnapshot;
+    /**
+     * `a[i] = a[i] + suffix` on a string array (the canonical statement form
+     * of `a[i] += suffix`): the old element is snapshotted (+1) and the
+     * suffix evaluated in JavaScript order; then, when the slot still holds
+     * the snapshot, the array lets go of it (emitDenseSlotUnlink) so the
+     * concat can append in place, and the result is stored as usual.
+     */
+    private emitArraySelfConcat;
     /** `local = local + suffix` when the suffix cannot read or write the
      * local (an unboxed binding is only reachable through this function's own
      * expressions): reading the binding after the suffix gives the value the
@@ -1036,6 +1110,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;
+    /** InternTable's runtime calls (scr_itable.c). Table and entry handles
+     * are f64 values carrying pointer bits; entry values are 64-bit slots
+     * (double bits, a bool, or a pointer to an immortal value) that the
+     * table neither retains nor releases. Lookups and inserts of array keys
+     * throw a TypeError for keys longer than a table accepts. */
+    private emitInternTableIntrinsic;
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     private regions;
@@ -1177,6 +1257,12 @@ export declare class LlEmitter {
         fn: string;
         shim: string;
     };
+    emitterOnceAdapter(boxerT: IrType & {
+        kind: "func";
+    }): {
+        fn: string;
+        shim: string;
+    };
     wrapEmitterListener(target: string, adapterFn: string): string;
     unwrapNullableClosure(u: string, funcTag: number): string;
     closeBindThunkFor(cbUnion: IrType, retServer: boolean): string;