@scriptc/compiler 0.3.4 → 0.3.6

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. */
@@ -216,6 +224,8 @@ export declare class LlEmitter {
     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>;
@@ -263,6 +273,9 @@ export declare class LlEmitter {
     private stableGlobals;
     private readonly tdzGlobals;
     readonly constantNumericTables: ReadonlyMap<string, ConstantNumericTable>;
+    /** Constant-key reads on checked-dynamic objects, each with its own
+     * zero-initialized ScrDynReadIc (scr_runtime.h). */
+    private dynReadIcSites;
     /** May-throw analysis (computeMayThrow): pending
      * checks are emitted only after calls that can actually raise. */
     readonly mayThrow: Set<string>;
@@ -374,8 +387,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>;
@@ -395,6 +418,17 @@ export declare class LlEmitter {
         };
     }>;
     private countedLoopsEnabled;
+    /** Speculative integer loops (speculative-integers.ts) run in this function. */
+    private speculativeLoopsEnabled;
+    /** The fast copy of a speculative integer loop being emitted: its
+     * integer-computed writes and where each resumes in the ordinary copy. */
+    private speculation;
+    /** The ordinary copy being emitted: resume labels still to place. */
+    private speculationResume;
+    /** The function being emitted, for speculative globals. */
+    private speculativeFunction;
+    /** Every function that writes each number global (computed on demand). */
+    private globalWriters;
     /** Whole-program final reference fields (ir/final-fields.ts). */
     private finalFields;
     /** The current function may borrow final fields of borrowable objects:
@@ -407,6 +441,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>;
@@ -447,7 +484,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. */
@@ -464,6 +508,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;
@@ -582,6 +628,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
@@ -688,6 +736,31 @@ export declare class LlEmitter {
      * conditions in expr-calls.ts). */
     private callTestsPending;
     private workerLoopBudget;
+    /** Emit a loop's condition, body and update through `emitCopy`, twice
+     * when speculative-integers.ts plans a fast integer copy. Both copies
+     * share the loop's setup and exit; the ordinary copy comes first so the
+     * fast copy is only emitted when every resume point exists. */
+    private emitLoopCopies;
+    private writeBackSpeculativeGlobals;
+    /** A number local whose only storage is its own double slot, so an i64
+     * shadow beside it can stand for it within one loop. */
+    private speculativeLocal;
+    /** A module-level number written only by the file's top-level code that
+     * is emitting this loop. Calls may still read it: the fast copy keeps its
+     * double current. An init function runs once and is never re-entered, so
+     * no call from the loop can write the global behind the shadow. */
+    private speculativeGlobal;
+    /** A module-level number a loop of any function only reads, written by
+     * nothing but top-level code: an init function never runs during a loop
+     * of another function, so the entry value stays its value. */
+    private speculativeInvariantGlobal;
+    /** The functions writing a number global a shadow may stand for, or null
+     * when the global is not such a number. */
+    private numberGlobalWriters;
+    /** A speculated write in the fast copy: compute the value as a safe
+     * integer, store it to the shadow and its exact double to the local.
+     * Any failed check re-executes the statement in the ordinary copy. */
+    private emitSpeculativeWrite;
     /** 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
@@ -768,6 +841,9 @@ export declare class LlEmitter {
     };
     /** The overflow map's slot pointer on an index-signature shape. */
     recordOvfPtr(objName: string, shapeId: string): string;
+    /** The pointer to ScrMap.flags of an index-signature record's overflow
+     * map (byte offset sizeof(size_t) + 3; SCR_MAP_NULL_PROTO is bit 0). */
+    recordMapFlagsPtr(objName: string, shapeId: string): string;
     /** Loads a record field (i8-stored bools trunc to i1). An inline union
      * field answers a private stack box with the slot's own bits, ABSENT
      * included: it may only be borrowed. */
@@ -852,11 +928,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)
@@ -1028,6 +1117,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
@@ -1039,7 +1149,7 @@ export declare class LlEmitter {
     /** A direct async call an enclosing `await` consumes whole: emitted
      * through the callee's await-call entry, yielding the awaited value. */
     emitAwaitedCall(e: ExprOf<"call">, adopt?: boolean): LlValue;
-    emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordHas" | "fieldAbsent">): LlValue;
+    emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordNullProto" | "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
@@ -1164,6 +1274,8 @@ export declare class LlEmitter {
     borrowableNullableWrap(e: IrExpr): "unit" | "ref" | null;
     materializeSplitLocal(localId: string): void;
     emitExpr(e: IrExpr): LlValue;
+    /** A fresh read-site cache for one constant-key dyn read. */
+    dynReadIcSite(): string;
     dynKind(d: string): string;
     raceAdapterFor(from: IrType, to: IrType): string;
     genResultThunkFor(genT: IrType & {
@@ -1189,6 +1301,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;