@scriptc/compiler 0.2.2 → 0.2.4

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

@@ -2,10 +2,15 @@ import type { IrBytesElem, IrExpr, IrFfiImport, IrFunction, IrLocal, IrModule, I
 import { type IntegerRanges } from "../../ir/integer-ranges.js";
 import { type ConstantNumericTable } from "../../ir/constant-tables.js";
 import { type FfiCallbackAdapter } from "../ffi-callbacks.js";
+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 {
@@ -29,6 +34,19 @@ export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOption
 export declare function emitLlvmModuleSource(mod: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare class LlEmitter {
     readonly mod: IrModule;
+    localArrayReads: Map<string, LocalArrayRead>;
+    private localStackUnions;
+    integerArrayBindings: Set<string>;
+    private readonly fieldAliasTags;
+    private readonly fieldPointerTags;
+    /** 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
+     * operations and record views conservatively alias all of them. */
+    private markFieldPointer;
+    markMemoryPointer(ptr: string, field: string): void;
+    fieldAliasAttachment(ptr: string): string;
+    private fieldAliasMetadata;
     private readonly debug;
     private debugScope;
     readonly sizeType: "i32" | "i64";
@@ -44,6 +62,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
@@ -84,6 +103,13 @@ export declare class LlEmitter {
     needsBadKey: boolean;
     private needsRetainBox;
     readonly fnByName: Map<string, IrFunction>;
+    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
@@ -164,9 +190,20 @@ export declare class LlEmitter {
     private jumpTargets;
     private currentLocals;
     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
@@ -412,6 +449,16 @@ export declare class LlEmitter {
     /** Move a clean async return value into the current fiber's promise. */
     private emitWasiFulfill;
     private emitFunction;
+    /** Keep the ordinary owned ABI for closures, virtual dispatch, generated
+     * runtime adapters and library exports. Only direct IR calls select the
+     * borrowing body. Ownership of other parameters moves into that body;
+     * 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 stable 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. */
+    canBorrowCallArgument(value: IrExpr): boolean;
     private emitStmts;
     /** Emits a block in its own lexical scope (refcounted locals released at
      * end). `setup` runs after the
@@ -461,7 +508,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;
@@ -487,6 +534,7 @@ export declare class LlEmitter {
      * their ordinary statement-frame ownership. The caller must retain any
      * reference result before evaluating another expression. */
     emitReadReceiver(e: IrExpr): LlValue;
+    canBorrowReceiver(e: IrExpr): boolean;
     emitExpr(e: IrExpr): LlValue;
     emitJsMarshal(e: IrExpr & {
         kind: "jsMarshal";
@@ -562,7 +610,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;
@@ -571,11 +619,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";