@scriptc/compiler 0.2.3 → 0.2.5

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

@@ -6,9 +6,11 @@ import { type CallLifetimes } from "./call-lifetimes.js";
 import { BlockBuilder } from "./blocks.js";
 import { type LocalArrayRead } from "./local-array-reads.js";
 import { type MapReadLifetimes } from "./map-read-lifetimes.js";
+import { ReferenceEffects } from "./reference-effects.js";
 import { type LlClassMeta } from "./classes.js";
 import { LlDyn, type DynHost } from "./dyn.js";
 import { LlWalkers } from "./walkers.js";
+import { type MapKeyAccess } from "./shapes.js";
 import type { ExprOf, LibCallExpr, LlStreamTypedRefAdapter, LlValue } from "./expr-context.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 export interface LlvmTargetOptions {
@@ -34,6 +36,8 @@ export declare class LlEmitter {
     readonly mod: IrModule;
     localArrayReads: Map<string, LocalArrayRead>;
     private localStackUnions;
+    private localUnionStorageProofs;
+    private localUnionStorage;
     integerArrayBindings: Set<string>;
     private readonly fieldAliasTags;
     private readonly fieldPointerTags;
@@ -60,6 +64,7 @@ export declare class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     private readonly unitInstances;
+    private readonly immortalValues;
     /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
      * source/flags literal refs } — one immortal ScrRegex template per distinct
      * (pattern, flags) pair; the bytecode slot starts null and the runtime
@@ -100,12 +105,13 @@ export declare class LlEmitter {
     needsBadKey: boolean;
     private needsRetainBox;
     readonly fnByName: Map<string, IrFunction>;
-    private readonly arrayPreservingFunctions;
+    readonly referenceEffects: ReferenceEffects;
     private readonly optionalArrayReads;
     callArrayReads: Map<IrExpr, LocalArrayRead>;
     mapReadLifetimes: MapReadLifetimes;
     readonly callLifetimes: CallLifetimes;
     private borrowedParameters;
+    private stableCallBindings;
     /** Manifest-bound native imports, used by ffiCall emission. */
     readonly ffiByName: Map<string, IrFfiImport>;
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
@@ -185,10 +191,23 @@ export declare class LlEmitter {
      * for blocks and switches. */
     private jumpTargets;
     private currentLocals;
+    private readonly initializerBindings;
+    private numericLocals;
     private captureIds;
-    /** Active canonical byte-loop induction bindings: local id → size_t slot. */
-    integerLoopBindings: Map<string, string>;
+    /** Active induction bindings retain their width independently of size_t. */
+    integerLoopBindings: Map<string, {
+        slot: string;
+        type: "i32" | "i64";
+        signed?: boolean;
+        range?: {
+            min: number;
+            max: number;
+        };
+    }>;
+    private countedLoopsEnabled;
     integerRanges: IntegerRanges;
+    bytesBounds: ReadonlySet<IrExpr | IrStmt>;
+    integerViews: Map<string, string>;
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
      * actual ret — the runtime ABI’s pending-return path, with the finally
@@ -440,9 +459,10 @@ export declare class LlEmitter {
      * borrowed parameters are released here on normal and exceptional exits.
      * The pending exception remains for the adapter's caller to handle. */
     private emitOwnedCallAdapter;
-    /** A local immutable binding keeps its value alive while later arguments
-     * and the callee execute. Global, captured, TDZ and mutable bindings need
-     * an owned snapshot, even when the callee only inspects the value. */
+    /** A local stable binding keeps its value alive while later arguments
+     * and the callee execute. A proven local union box cannot escape or be
+     * rebound during a call; its independent payload owner keeps it alive.
+     * Other writable bindings need an owned snapshot. */
     canBorrowCallArgument(value: IrExpr): boolean;
     private emitStmts;
     /** Emits a block in its own lexical scope (refcounted locals released at
@@ -479,7 +499,8 @@ export declare class LlEmitter {
     private emitTryCatch;
     /** JS-exact switch: lazily evaluated, arbitrary-expression case tests in
      * source order, bodies falling through in source order until a break —
-     * A chain of conditional branches. All case bodies
+     * Literal-only tests can use native dispatch; other tests keep a chain
+     * of conditional branches. All case bodies
      * share ONE scope; because dispatch can jump PAST a varDecl into a later
      * case, refcounted/boxed case-body locals are NULL-reset up front and
      * the scope-exit releases rely on NULL tolerance. */
@@ -493,7 +514,7 @@ export declare class LlEmitter {
      * branch and moves the result into `slot`: the chosen value's ownership
      * transfers, every other temp the arm allocated releases inside the
      * branch. The shared core of ternary/logical. */
-    emitBranchInto(slot: string, expr: IrExpr): void;
+    emitBranchInto(slot: string, expr: IrExpr, integerSlot?: string): boolean;
     emitLiteralExpr(e: ExprOf<"numLit" | "boolLit" | "strLit" | "moduleNsRef" | "unitLit" | "varRef">): LlValue;
     emitOperatorExpr(e: ExprOf<"bin" | "unary" | "incDec" | "fieldIncDec" | "assignExpr" | "seqExpr">): LlValue;
     emitControlExpr(e: ExprOf<"dynDestrCheck" | "dynIterN" | "toBool" | "logical" | "ternary" | "optChain" | "chainRecv" | "orDefault" | "nullish">): LlValue;
@@ -595,7 +616,7 @@ export declare class LlEmitter {
     emitMapNew(e: IrExpr & {
         kind: "mapNew";
     }): LlValue;
-    mapSet(m: string, kAcc: "f64" | "str" | "ref", vAcc: "f64" | "bool" | "ref", key: string, value: string): void;
+    mapSet(m: string, kAcc: MapKeyAccess, vAcc: "f64" | "bool" | "ref", key: string, value: string): void;
     emitMapLikeIntrinsic(e: Extract<IrExpr, {
         kind: "mapIntrinsic" | "setIntrinsic";
     }>): LlValue;
@@ -604,11 +625,12 @@ export declare class LlEmitter {
     }): LlValue;
     emitStableReceiver(receiver: IrExpr, following: IrExpr[]): LlValue;
     emitIntegerLoopIndex(expr: IrExpr): string | null;
-    emitBytesIndex(receiver: string, index: string, integerIndex?: boolean): string;
+    emitBytesIndex(receiver: string, index: LlValue, expr?: IrExpr, inBounds?: boolean): string;
     emitBytesData(receiver: string): string;
     emitBytesLength(elem: IrBytesElem, receiver: string, bytes: boolean): LlValue;
-    emitBytesGet(elem: IrBytesElem, receiver: string, index: string, integerIndex?: boolean): LlValue;
-    emitToUint32(value: string, expr?: IrExpr): string;
+    emitBytesGet(elem: IrBytesElem, receiver: string, index: LlValue, expr?: IrExpr, inBounds?: boolean): LlValue;
+    emitToUint32(value: string, expr?: IrExpr, uint32?: string): string;
+    storeIntegerView(localId: string, value: LlValue, expr?: IrExpr): void;
     private emitBytesSet;
     emitBytesIntrinsic(e: IrExpr & {
         kind: "bytesIntrinsic";