@scriptc/compiler 0.2.3 → 0.2.4

package/dist/backend/llvm/emitter.js

@@ -22,10 +22,13 @@ import { deflateRawSync } from "node:zlib";
 import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../../ir/analysis.js";
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, moduleRuntimeFeatures, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
-import { matchIntegerArrayForLoop, matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
+import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, matchIntegerCountedForLoop } from "../../ir/integer-loops.js";
+import { emitCountedLoopLimit } from "./counted-loops.js";
+import { findBytesBounds } from "./bytes-bounds.js";
 import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
 import { everyStmtList } from "../../ir/traverse.js";
 import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
+import { findIntegerViews } from "./integer-views.js";
 import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
@@ -34,9 +37,11 @@ import { mangleArgPack, mangleAsyncSpawn, mangleBorrowedFunction, mangleClassObj
 import { analyzeCallLifetimes } from "./call-lifetimes.js";
 import { emitStackUnion, findLocalStackUnions } from "./stack-unions.js";
 import { BlockBuilder } from "./blocks.js";
-import { emitLocalArrayRead, findArrayPreservingFunctions, findLocalArrayReads, findCallArrayReads, OptionalArrayReads } from "./local-array-reads.js";
+import { emitLocalArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads } from "./local-array-reads.js";
 import { emitStackMapRead, findMapReadLifetimes } from "./map-read-lifetimes.js";
 import { emitBorrowedFieldSequence } from "./borrowed-receivers.js";
+import { emitBorrowedInput } from "./borrowed-inputs.js";
+import { ReferenceEffects } from "./reference-effects.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
@@ -156,6 +161,7 @@ export class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     unitInstances = new Map();
+    immortalValues = new Set();
     /** 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
@@ -189,12 +195,13 @@ export class LlEmitter {
     needsBadKey = false;
     needsRetainBox = false;
     fnByName = new Map();
-    arrayPreservingFunctions;
+    referenceEffects;
     optionalArrayReads;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
     callLifetimes;
     borrowedParameters = new Set();
+    stableCallBindings = new Set();
     /** Manifest-bound native imports, used by ffiCall emission. */
     ffiByName = new Map();
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
@@ -276,9 +283,12 @@ export class LlEmitter {
     jumpTargets = [];
     currentLocals = new Map();
     captureIds = new Set();
-    /** Active canonical byte-loop induction bindings: local id → size_t slot. */
+    /** Active induction bindings retain their width independently of size_t. */
     integerLoopBindings = new Map();
+    countedLoopsEnabled = false;
     integerRanges = new Map();
+    bytesBounds = new Set();
+    integerViews = new Map();
     /** 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
@@ -345,7 +355,7 @@ export class LlEmitter {
         for (const u of mod.unions ?? [])
             this.unionsById.set(u.id, u);
         this.optionalArrayReads = new OptionalArrayReads(this.fnByName, this.unionsById);
-        this.arrayPreservingFunctions = findArrayPreservingFunctions(this.fnByName, this.unionsById, this.optionalArrayReads);
+        this.referenceEffects = new ReferenceEffects(this.fnByName, (call) => this.optionalArrayReads.get(call) !== null);
         this.callLifetimes = analyzeCallLifetimes(this.fnByName);
         for (const r of mod.records ?? [])
             this.recordsById.set(r.id, r);
@@ -1995,7 +2005,9 @@ export class LlEmitter {
             lit = { sym: `sc_lit_${this.literals.size}`, len: Buffer.byteLength(text, "utf8") };
             this.literals.set(text, lit);
         }
-        return `@${lit.sym}`;
+        const name = `@${lit.sym}`;
+        this.immortalValues.add(name);
+        return name;
     }
     /** Interned NUL-terminated C-string constant (the scr_jb_puts /
      * stringify-indent currency) — `@`-ref, first-use order. */
@@ -2025,7 +2037,9 @@ export class LlEmitter {
             sym = `sc_unit_${this.unitInstances.size}`;
             this.unitInstances.set(key, sym);
         }
-        return `@${sym}`;
+        const name = `@${sym}`;
+        this.immortalValues.add(name);
+        return name;
     }
     declare(decl) {
         this.decls.add(decl);
@@ -2041,7 +2055,7 @@ export class LlEmitter {
     }
     /** Registers an owned refcounted value on the current statement frame. */
     own(v) {
-        if (isRefCounted(v.type))
+        if (isRefCounted(v.type) && !this.immortalValues.has(v.name))
             this.currentFrame().push(v);
         return v;
     }
@@ -2053,7 +2067,7 @@ export class LlEmitter {
     }
     /** Strike a refcounted temp from its frame: ownership is being moved. */
     moveTemp(v) {
-        if (!isRefCounted(v.type))
+        if (!isRefCounted(v.type) || this.immortalValues.has(v.name))
             return;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             const idx = this.frames[i].findIndex((e) => e.name === v.name);
@@ -2067,6 +2081,8 @@ export class LlEmitter {
     /** The retained (+1) read of a refcounted value — type-directed through
      * the `_v` table (immortals skip, exactly the C retain calls). */
     retainValue(name, type) {
+        if (this.immortalValues.has(name))
+            return name;
         const t = this.B.tmp();
         this.B.line(`${t} = call ptr ${retainSym(this.shapeHost, type)}(ptr ${name})`);
         return t;
@@ -2074,6 +2090,8 @@ export class LlEmitter {
     /** The release call for one owned refcounted value — type-directed like
      * releaseCallC (all runtime releases are NULL-tolerant). */
     releaseValue(name, type) {
+        if (this.immortalValues.has(name))
+            return;
         this.B.line(`call void ${releaseSym(this.shapeHost, type)}(ptr ${name})`);
     }
     releaseFrame(frame) {
@@ -2912,20 +2930,24 @@ export class LlEmitter {
         this.jumpTargets = [];
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
         this.borrowedParameters.clear();
-        const borrowedParameterIndexes = this.callLifetimes.parameters.get(fn.name);
+        this.stableCallBindings = this.callLifetimes.bindings.get(fn.name) ?? new Set();
+        const borrowedParameterIndexes = this.callLifetimes.borrowed.get(fn.name);
         if (borrowedParameterIndexes) {
             for (const index of borrowedParameterIndexes)
                 this.borrowedParameters.add(fn.params[index].localId);
         }
         this.captureIds = new Set([...(fn.captures ?? []), ...(fn.classCaptures ?? [])].map((c) => c.localId));
         this.integerLoopBindings.clear();
+        this.countedLoopsEnabled = this.debug === null && !fn.async && !fn.generator;
+        this.integerViews.clear();
         this.fieldPointerTags.clear();
         this.integerArrayBindings.clear();
-        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.arrayPreservingFunctions, this.callLifetimes, this.optionalArrayReads);
-        this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.arrayPreservingFunctions, this.callLifetimes);
+        this.localArrayReads = findLocalArrayReads(fn, this.fnByName, this.unionsById, this.referenceEffects.functions, this.callLifetimes, this.optionalArrayReads);
+        this.callArrayReads = findCallArrayReads(fn, this.optionalArrayReads, this.referenceEffects.functions, this.callLifetimes);
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.unionsById, this.callLifetimes);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.unionsById);
         this.integerRanges = analyzeIntegerRanges(fn);
+        this.bytesBounds = findBytesBounds(fn, this.integerRanges);
         this.chainSlots.clear();
         this.finallyStack = [];
         this.tryStack = [];
@@ -2967,6 +2989,13 @@ export class LlEmitter {
             };
         }
         const paramIds = new Set(fn.params.map((p) => p.localId));
+        if (this.debug === null) {
+            for (const id of findIntegerViews(fn)) {
+                const slot = B.slot();
+                B.entryAllocas.push(`${slot} = alloca i32 ; integer view ${this.currentLocals.get(id).name}`);
+                this.integerViews.set(id, slot);
+            }
+        }
         for (const local of fn.locals) {
             // Boxed locals' slots hold their capture BOX (a ptr); captured
             // (env-borrowed) locals bind the incoming box below. A caught-typed
@@ -3016,7 +3045,7 @@ export class LlEmitter {
         // params (callees own their params — callers passed +1). Boxed params
         // allocate the shared binding and move the raw value in.
         const fnScope = [];
-        const borrowed = this.callLifetimes.parameters.get(fn.name);
+        const borrowed = this.callLifetimes.borrowed.get(fn.name);
         for (const [index, p] of fn.params.entries()) {
             const local = this.currentLocals.get(p.localId);
             const slot = `%${mangleLocal(p.localId)}`;
@@ -3029,6 +3058,7 @@ export class LlEmitter {
                 continue;
             }
             B.line(`store ${this.llType(p.type)} %p_${mangleLocal(p.localId)}, ptr ${slot}`);
+            this.storeIntegerView(p.localId, { name: `%p_${mangleLocal(p.localId)}`, type: p.type });
             if (isRefCounted(p.type) && !borrowed?.has(index))
                 fnScope.push({ slot, type: p.type });
         }
@@ -3132,7 +3162,7 @@ export class LlEmitter {
         B.terminate(ret === "void" ? "ret void" : `ret ${ret} %result`);
         return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${FN_ATTRS} {\n${B.render()}\n}`;
     }
-    /** A local immutable binding keeps its value alive while later arguments
+    /** 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) {
@@ -3142,7 +3172,7 @@ export class LlEmitter {
             return false;
         const binding = this.binding(value.localId);
         return binding.kind === "local" && binding.local !== undefined &&
-            (!binding.local.mutable || this.borrowedParameters.has(value.localId)) && !binding.local.boxed && !binding.local.tdz;
+            (!binding.local.mutable || this.stableCallBindings.has(value.localId) || this.borrowedParameters.has(value.localId)) && !binding.local.boxed && !binding.local.tdz;
     }
     // ── statements ──────────────────────────────────────────────────────────
     emitStmts(stmts) {
@@ -3248,9 +3278,20 @@ export class LlEmitter {
                     }
                     break;
                 }
+                // A lexical const alias cannot outlive its unchanged local owner.
+                // Whole-value uses still retain their own copies, so returning or
+                // storing the alias preserves the ordinary heap representation.
+                // Boxed captures, reassigned sources and projections need ownership.
+                if (b.kind === "local" && b.local && !b.local.mutable && isRefCounted(b.type) &&
+                    this.stableCallBindings.has(s.localId) && this.canBorrowCallArgument(s.init)) {
+                    const v = this.emitReadReceiver(s.init);
+                    B.line(`store ptr ${v.name}, ptr ${b.slot}`);
+                    break;
+                }
                 const v = this.emitExpr(s.init);
                 this.moveTemp(v);
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
+                this.storeIntegerView(s.localId, v, s.init);
                 if (isRefCounted(b.type)) {
                     this.scopes[this.scopes.length - 1].push({ slot: b.slot, type: b.type });
                 }
@@ -3281,6 +3322,7 @@ export class LlEmitter {
                     this.releaseValue(old, b.type);
                 }
                 B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`);
+                this.storeIntegerView(s.localId, v, s.value);
                 break;
             }
             case "exprStmt":
@@ -3290,7 +3332,7 @@ export class LlEmitter {
                 // Evaluation order matches JS: array, index, then value. Ownership
                 // of a refcounted value moves into the array (the runtime releases
                 // the replaced element itself).
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
                 if (s.arr.type.kind !== "array")
@@ -3304,7 +3346,7 @@ export class LlEmitter {
                 break;
             }
             case "arraySetLength": {
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const length = this.emitExpr(s.length);
                 if (s.arr.type.kind !== "array")
                     throw new InternalCompilerError("llvm emitter bug: arraySetLength on non-array");
@@ -3315,7 +3357,7 @@ export class LlEmitter {
             }
             case "arraySetUndefined":
             case "arrayDelete": {
-                const arr = this.emitExpr(s.arr);
+                const arr = emitBorrowedInput(this, s.arr);
                 const idx = this.emitExpr(s.index);
                 if (s.arr.type.kind !== "array")
                     throw new InternalCompilerError(`llvm emitter bug: ${s.kind} on non-array`);
@@ -3334,12 +3376,11 @@ export class LlEmitter {
                 // IrBytesElem is static, so never rediscover it through the
                 // generic runtime switch in a hot loop.
                 const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
-                const integerIndex = this.emitIntegerLoopIndex(s.index);
-                const idx = integerIndex ?? this.emitExpr(s.index).name;
+                const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
                 if (s.arr.type.kind !== "bytes")
                     throw new InternalCompilerError("llvm emitter bug: bytesSet on non-bytes");
-                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v.name, integerIndex !== null);
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx, v, s.index, s.value, this.bytesBounds.has(s));
                 break;
             }
             case "fieldSet":
@@ -3612,8 +3653,26 @@ export class LlEmitter {
                 // release it — scopeDepth captured after the push, C parity).
                 const integerArrayLoop = this.debug === null ? matchIntegerArrayForLoop(s, this.currentLocals, this.integerArrayBindings) : null;
                 const integerLoop = integerArrayLoop ?? (this.debug === null ? matchIntegerBytesForLoop(s, this.currentLocals) : null);
+                const countedLoop = !integerLoop && this.countedLoopsEnabled ? matchIntegerCountedForLoop(s, this.currentLocals, this.integerRanges) : null;
+                let countedJoin = null;
+                if (countedLoop?.guarded) {
+                    const bound = this.emitExpr(countedLoop.limit);
+                    const safe = B.tmp();
+                    const fast = B.newLabel("counted.fast");
+                    const slow = B.newLabel("counted.slow");
+                    countedJoin = B.newLabel("counted.done");
+                    B.line(`${safe} = fcmp ${countedLoop.step > 0 ? "ole" : "oge"} double ${bound.name}, ${f64Lit(countedLoop.guardLimit)}`);
+                    B.condBr(safe, fast, slow);
+                    B.startBlock(slow);
+                    this.countedLoopsEnabled = false;
+                    this.emitStmt(s);
+                    this.countedLoopsEnabled = true;
+                    B.br(countedJoin);
+                    B.startBlock(fast);
+                }
                 this.scopes.push([]);
                 let integerSlot = null;
+                let countedLimit = null;
                 if (integerLoop) {
                     integerSlot = B.slot();
                     B.entryAllocas.push(`${integerSlot} = alloca ${this.sizeType} ; integer induction ${this.currentLocals.get(integerLoop.localId).name}`);
@@ -3625,7 +3684,18 @@ export class LlEmitter {
                         this.integerArrayBindings.add(integerLoop.localId);
                     }
                     B.line(`store ${this.sizeType} ${start}, ptr ${integerSlot}`);
-                    this.integerLoopBindings.set(integerLoop.localId, integerSlot);
+                    this.integerLoopBindings.set(integerLoop.localId, { slot: integerSlot, type: this.sizeType,
+                        range: { min: 0, max: integerArrayLoop ? 4294967294 : Number.MAX_SAFE_INTEGER - 1 } });
+                }
+                else if (countedLoop) {
+                    integerSlot = B.slot();
+                    B.entryAllocas.push(`${integerSlot} = alloca i64 ; integer induction ${this.currentLocals.get(countedLoop.localId).name}`);
+                    const startNumber = this.emitExpr(countedLoop.start);
+                    const start = B.tmp();
+                    B.line(`${start} = fptosi double ${startNumber.name} to i64`);
+                    B.line(`store i64 ${start}, ptr ${integerSlot}`);
+                    this.integerLoopBindings.set(countedLoop.localId, { slot: integerSlot, type: "i64", signed: true, range: countedLoop.range });
+                    countedLimit = emitCountedLoopLimit(this, countedLoop);
                 }
                 else if (s.init) {
                     // A multi-declarator head shares the loop's scope. Emitting its
@@ -3680,6 +3750,13 @@ export class LlEmitter {
                     B.line(`${inBounds} = icmp ult ${this.sizeType} ${index}, ${len}`);
                     B.condBr(inBounds, lb, le);
                 }
+                else if (countedLoop && integerSlot && countedLimit) {
+                    const index = B.tmp();
+                    const inBounds = B.tmp();
+                    B.line(`${index} = load i64, ptr ${integerSlot}`);
+                    B.line(`${inBounds} = icmp ${countedLoop.step > 0 ? "slt" : "sgt"} i64 ${index}, ${countedLimit}`);
+                    B.condBr(inBounds, lb, le);
+                }
                 else if (s.cond)
                     B.condBr(this.emitCondition(s.cond), lb, le);
                 else
@@ -3707,6 +3784,13 @@ export class LlEmitter {
                         B.line(`${next} = add nuw ${this.sizeType} ${old}, 1`);
                         B.line(`store ${this.sizeType} ${next}, ptr ${integerSlot}`);
                     }
+                    else if (countedLoop && integerSlot) {
+                        const old = B.tmp();
+                        const next = B.tmp();
+                        B.line(`${old} = load i64, ptr ${integerSlot}`);
+                        B.line(`${next} = add nsw i64 ${old}, ${countedLoop.step}`);
+                        B.line(`store i64 ${next}, ptr ${integerSlot}`);
+                    }
                     else if (s.update)
                         this.emitStmt(s.update);
                     B.br(lc);
@@ -3715,8 +3799,14 @@ export class LlEmitter {
                 this.releaseScope(this.scopes.pop());
                 if (integerLoop)
                     this.integerLoopBindings.delete(integerLoop.localId);
+                if (countedLoop)
+                    this.integerLoopBindings.delete(countedLoop.localId);
                 if (integerArrayLoop)
                     this.integerArrayBindings.delete(integerArrayLoop.localId);
+                if (countedJoin) {
+                    B.br(countedJoin);
+                    B.startBlock(countedJoin);
+                }
                 break;
             }
             case "forOf": {
@@ -4202,12 +4292,15 @@ export 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, expr) {
+    emitBranchInto(slot, expr, integerSlot) {
         this.frames.push([]);
         const v = this.emitExpr(expr);
         this.moveTemp(v);
         this.B.line(`store ${this.llType(expr.type)} ${v.name}, ptr ${slot}`);
+        if (integerSlot !== undefined && v.uint32 !== undefined)
+            this.B.line(`store i32 ${v.uint32}, ptr ${integerSlot}`);
         this.releaseFrame(this.frames.pop());
+        return v.uint32 !== undefined;
     }
     // ── expressions ─────────────────────────────────────────────────────────
     emitLiteralExpr(e) {
@@ -4484,8 +4577,8 @@ export class LlEmitter {
     emitIntegerLoopIndex(expr) {
         return emitIntegerLoopIndex(this, expr);
     }
-    emitBytesIndex(receiver, index, integerIndex = false) {
-        return emitBytesIndex(this, receiver, index, integerIndex);
+    emitBytesIndex(receiver, index, expr, inBounds = false) {
+        return emitBytesIndex(this, receiver, index, expr, undefined, inBounds);
     }
     emitBytesData(receiver) {
         return emitBytesData(this, receiver);
@@ -4493,14 +4586,21 @@ export class LlEmitter {
     emitBytesLength(elem, receiver, bytes) {
         return emitBytesLength(this, elem, receiver, bytes);
     }
-    emitBytesGet(elem, receiver, index, integerIndex = false) {
-        return emitBytesGet(this, elem, receiver, index, integerIndex);
+    emitBytesGet(elem, receiver, index, expr, inBounds = false) {
+        return emitBytesGet(this, elem, receiver, index, expr, inBounds);
     }
-    emitToUint32(value, expr) {
-        return emitToUint32(this, value, expr);
+    emitToUint32(value, expr, uint32) {
+        return emitToUint32(this, value, expr, uint32);
+    }
+    storeIntegerView(localId, value, expr) {
+        const slot = this.integerViews.get(localId);
+        if (slot === undefined)
+            return;
+        const integer = this.emitToUint32(value.name, expr, value.uint32);
+        this.B.line(`store i32 ${integer}, ptr ${slot}`);
     }
-    emitBytesSet(elem, receiver, index, value, integerIndex = false) {
-        return emitBytesSet(this, elem, receiver, index, value, integerIndex);
+    emitBytesSet(elem, receiver, index, value, indexExpr, expr, inBounds = false) {
+        return emitBytesSet(this, elem, receiver, index, value, indexExpr, expr, inBounds);
     }
     emitBytesIntrinsic(e) {
         return emitBytesIntrinsic(this, e);