@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/compiler/AstCompiler/utils/resolveNamespacePath.js

@@ -0,0 +1,93 @@
+import { DiagnosticCode } from "../../../diagnostics/diagnosticMessages.generated.js";
+/**
+ * walks a dotted namespace path against the given scope.
+ *
+ * - returns the final `NamespaceSymbol` if every segment resolves to a namespace.
+ * - if the first segment is not a namespace, returns `undefined`
+ *   (no diagnostic emitted; the caller can fall back to a different
+ *   resolution strategy, e.g. struct lookup).
+ * - if a later segment is missing or is not a namespace, emits a
+ *   diagnostic and returns `undefined`.
+ */
+export function resolveNamespacePath(ctx, path) {
+    const segments = path.segments;
+    if (segments.length === 0)
+        return undefined;
+    const head = segments[0];
+    const first = ctx.scope.resolveNamespace(head.text);
+    if (!first)
+        return undefined;
+    const chain = [first];
+    let current = first;
+    for (let i = 1; i < segments.length; i++) {
+        const seg = segments[i];
+        const inner = current.publicScope.namespaces.get(seg.text);
+        if (!inner) {
+            ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, seg.range, current.name, seg.text);
+            return undefined;
+        }
+        chain.push(inner);
+        current = inner;
+    }
+    return { namespace: current, chain };
+}
+/**
+ * looks up a member name in a namespace's public scope.
+ *
+ * the member can be any of:
+ *   - a value (variable)
+ *   - a function
+ *   - a type
+ *   - an interface
+ *   - a nested namespace
+ *
+ * binds the resolved member into `target` (under either `originalName`
+ * or `aliasName` if provided). emits a diagnostic and returns `false`
+ * if no such member is exported, or if a conflicting binding already
+ * exists in `target`.
+ */
+export function bindNamespaceMember(ctx, ns, originalName, aliasName, target) {
+    const pub = ns.publicScope;
+    const name = originalName.text;
+    const localName = aliasName?.text ?? name;
+    const variable = pub.variables.get(name);
+    const fn = pub.functions.get(name);
+    const tirFunc = fn ? pub.program.functions.get(fn) : undefined;
+    const ty = pub.types.get(name);
+    const iface = pub.interfaces.get(name);
+    const nested = pub.namespaces.get(name);
+    if (!variable && !fn && !ty && !iface && !nested) {
+        ctx.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, originalName.range, ns.name, name);
+        return false;
+    }
+    let ok = true;
+    if (variable) {
+        ok = target.defineValue({ ...variable, name: localName }) && ok;
+    }
+    if (fn) {
+        target.functions.set(localName, fn);
+        if (tirFunc) {
+            target.defineValue({
+                isConstant: true,
+                name: localName,
+                type: tirFunc.type,
+            });
+        }
+    }
+    if (ty) {
+        ok = target.defineType(localName, ty) && ok;
+    }
+    if (iface) {
+        if (target.interfaces.has(localName))
+            ok = false;
+        else
+            target.interfaces.set(localName, iface);
+    }
+    if (nested) {
+        ok = target.defineNamespace({
+            name: localName,
+            publicScope: nested.publicScope
+        }) && ok;
+    }
+    return ok;
+}

package/dist/compiler/Compiler.d.ts

@@ -3,11 +3,13 @@ import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
 import { CompilerOptions } from "../IR/toUPLC/CompilerOptions.js";
 import { CompilerIoApi } from "./io/CompilerIoApi.js";
 import { CheckResult } from "./SourceTypeMap.js";
+import { TestResult } from "./test/TestResult.js";
 export { CheckResult, SourceTypeMap, TypeEntry, MemberInfo } from "./SourceTypeMap.js";
+export { TestBudget, TestIterationResult, TestResult, TestKind, } from "./test/TestResult.js";
 export declare class Compiler extends DiagnosticEmitter {
     readonly io: CompilerIoApi;
     readonly cfg: CompilerOptions;
-    constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
+    constructor(io: CompilerIoApi, cfg: CompilerOptions, diagnostics?: DiagnosticMessage[]);
     check(config?: Partial<CompilerOptions>): Promise<CheckResult>;
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
@@ -16,6 +18,12 @@ export declare class Compiler extends DiagnosticEmitter {
         budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;
         logs: string[];
     }>;
+    test(config?: Partial<CompilerOptions> & {
+        nameFilter?: string | RegExp;
+        propertyIterations?: number;
+        seed?: number;
+    }): Promise<TestResult[]>;
+    private _runOneTest;
     runRepl(config?: Partial<CompilerOptions>): Promise<{
         result: import("@harmoniclabs/plutus-machine").CEKValueObj;
         budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;

package/dist/compiler/Compiler.js

@@ -1,25 +1,35 @@
-import { compileUPLC, Force, parseUPLC, UPLCProgram } from "@harmoniclabs/uplc";
-import { Machine } from "@harmoniclabs/plutus-machine";
+import { Application, compileUPLC, Force, parseUPLC, UPLCConst, UPLCProgram } from "@harmoniclabs/uplc";
+import { CEKError, Machine } from "@harmoniclabs/plutus-machine";
+import { DiagnosticCategory } from "../diagnostics/DiagnosticCategory.js";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
-import { defaultOptions } from "../IR/toUPLC/CompilerOptions.js";
+import { COMPILER_VERSION } from "../version.generated.js";
+import { semverSatisfies } from "../utils/semverSatisfies.js";
 import { AstCompiler } from "./AstCompiler/AstCompiler.js";
 import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
-import { __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRHash.js";
-import { __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRNodes/utils/hashVarSym.js";
-import { __unsafe_clear_hoisted_hash_to_symbol } from "../IR/IRNodes/IRHoisted.js";
-import { __unsafe_clear_letted_hash_to_symbol } from "../IR/IRNodes/IRLetted.js";
-import { __unsafe_clear_hoisted_cache } from "../IR/toUPLC/subRoutines/replaceHoistedWithLetted.js";
-import { __unsafe_clear_mapToType_cache } from "./TirCompiler/expressify/expressifyVars.js";
+import { CompilationCtx, withCompilationCtx } from "../IR/CompilationCtx.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
+import { TirFuncExpr } from "./tir/expressions/TirFuncExpr.js";
+import { addBudget, zeroBudget, } from "./test/TestResult.js";
+import { PRNG } from "./test/fuzz/PRNG.js";
 export { SourceTypeMap } from "./SourceTypeMap.js";
 export class Compiler extends DiagnosticEmitter {
     io;
     cfg;
-    constructor(io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), cfg = defaultOptions, diagnostics) {
+    constructor(io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), cfg, diagnostics) {
         super(diagnostics);
         this.io = io;
         this.cfg = cfg;
+        const range = cfg?.compilerVersion;
+        if (typeof range !== "string" || range.length === 0) {
+            throw new Error(`Pebble compiler config is missing "compilerVersion". ` +
+                `Starting from @harmoniclabs/pebble@0.2.0 this field is required ` +
+                `and must be an npm-style semver range (e.g. "^0.2.0").`);
+        }
+        if (!semverSatisfies(COMPILER_VERSION, range)) {
+            throw new Error(`Pebble compiler version ${COMPILER_VERSION} does not satisfy ` +
+                `the configured "compilerVersion" range "${range}".`);
+        }
         if (cfg.silent === true) {
             this.io.stdout = { write() { } };
         }
@@ -42,7 +52,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.compile();
         if (this.diagnostics.length > 0) {
             let msg;
-            // globalThis.console && console.log( this.diagnostics );
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             for (msg of this.diagnostics) {
@@ -67,7 +76,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.export(cfg.functionName, cfg.entry);
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -88,7 +96,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.run();
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -102,6 +109,167 @@ export class Compiler extends DiagnosticEmitter {
         // compiles to `Delay(body)`; force it so the body executes.
         return Machine.eval(new Force(uplcProgram.body));
     }
+    async test(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            silent: true,
+            addMarker: false,
+        };
+        const nameFilter = config?.nameFilter;
+        const matches = (!nameFilter ? () => true :
+            typeof nameFilter === "string" ? (n) => n.includes(nameFilter) :
+                (n) => nameFilter.test(n));
+        const propertyIterations = Math.max(1, config?.propertyIterations ?? 100);
+        const seed = config?.seed ?? 0;
+        // 1) discovery pass: parse + check, populate program.tests.
+        //    diagnostics from this pass are surfaced once; subsequent per-test
+        //    passes use their own diagnostic arrays so we don't double-report.
+        const discovery = new AstCompiler(cfg, this.io, this.diagnostics);
+        const discoveryResult = await discovery.check();
+        const descriptors = discoveryResult.program.tests
+            .filter(t => matches(t.name))
+            .map(t => {
+            const fn = discoveryResult.program.functions.get(t.tirFuncName);
+            const paramNames = (fn instanceof TirFuncExpr) ? fn.params.map(p => p.sourceName ?? p.name) : [];
+            return {
+                name: t.name,
+                tirFuncName: t.tirFuncName,
+                sourceFile: t.sourceFile,
+                range: t.range,
+                paramNames,
+                fuzzerInfos: t.fuzzerInfos,
+            };
+        });
+        const results = new Array(descriptors.length);
+        for (let i = 0; i < descriptors.length; i++) {
+            results[i] = await this._runOneTest(cfg, descriptors[i], propertyIterations, seed);
+        }
+        return results;
+    }
+    async _runOneTest(cfg, desc, propertyIterations, seed) {
+        const isProperty = desc.fuzzerInfos.length > 0;
+        // fresh AstCompiler so the expressify pass starts from a clean program
+        const localDiagnostics = [];
+        const astCompiler = new AstCompiler(cfg, this.io, localDiagnostics);
+        await astCompiler.compileFile(cfg.entry, true);
+        if (localDiagnostics.some(d => d.category === DiagnosticCategory.Error)) {
+            return _failedTestResult(desc, "compile error: " + localDiagnostics.find(d => d.category === DiagnosticCategory.Error).toString(), isProperty ? "property" : "unit");
+        }
+        const fn = astCompiler.program.functions.get(desc.tirFuncName);
+        if (!(fn instanceof TirFuncExpr)) {
+            return _failedTestResult(desc, `test function "${desc.name}" not found after re-parse`, isProperty ? "property" : "unit");
+        }
+        astCompiler.program.contractTirFuncName = desc.tirFuncName;
+        let serialized;
+        try {
+            serialized = this._compileBackend(cfg, astCompiler.program, true);
+        }
+        catch (err) {
+            return _failedTestResult(desc, "backend error: " + (err instanceof Error ? err.message : String(err)), isProperty ? "property" : "unit");
+        }
+        const uplcProgram = parseUPLC(serialized);
+        if (!isProperty) {
+            const evalResult = Machine.eval(new Force(uplcProgram.body));
+            const isErr = evalResult.result instanceof CEKError;
+            const budget = {
+                cpu: BigInt(evalResult.budgetSpent.cpu),
+                mem: BigInt(evalResult.budgetSpent.mem),
+            };
+            const iter = {
+                passed: !isErr,
+                budgetSpent: budget,
+                logs: evalResult.logs.slice(),
+                error: isErr ? { msg: evalResult.result.msg } : undefined,
+            };
+            return {
+                name: desc.name,
+                sourceFile: desc.sourceFile,
+                range: desc.range,
+                kind: "unit",
+                passed: !isErr,
+                iterations: [iter],
+                totalBudget: addBudget(zeroBudget(), budget),
+            };
+        }
+        // ── Property test ──────────────────────────────────────────────
+        // Check that every parameter has an executable fuzzer in v1 (Phase 1).
+        const unsupported = desc.fuzzerInfos.find(fi => fi.kind === "unsupported" || fi.kind === "via_not_implemented");
+        if (unsupported) {
+            const reason = unsupported.kind === "via_not_implemented"
+                ? "user-defined fuzzers via the 'via' keyword are not yet executable (Phase 2)"
+                : unsupported.reason;
+            return {
+                name: desc.name,
+                sourceFile: desc.sourceFile,
+                range: desc.range,
+                kind: "property",
+                passed: false,
+                iterations: [],
+                totalBudget: zeroBudget(),
+                skippedReason: reason,
+                seed,
+            };
+        }
+        // Run N iterations with TS-side sampling.
+        const prng = new PRNG(seed);
+        const iterations = [];
+        let totalBudget = zeroBudget();
+        let passedAll = true;
+        for (let i = 0; i < propertyIterations; i++) {
+            const inputs = [];
+            const args = [];
+            for (let p = 0; p < desc.fuzzerInfos.length; p++) {
+                const fi = desc.fuzzerInfos[p];
+                if (fi.kind !== "primitive")
+                    throw new Error("unreachable: non-primitive after unsupported check");
+                const paramName = desc.paramNames[p] ?? `param${p}`;
+                if (fi.primitive === "int") {
+                    const v = prng.nextIntBiased();
+                    inputs.push({ name: paramName, value: v });
+                    args.push(UPLCConst.int(v));
+                }
+                else // bool
+                 {
+                    const v = prng.nextBool();
+                    inputs.push({ name: paramName, value: v });
+                    args.push(UPLCConst.bool(v));
+                }
+            }
+            let app = uplcProgram.body;
+            for (const arg of args)
+                app = new Application(app, arg);
+            const evalResult = Machine.eval(app);
+            const isErr = evalResult.result instanceof CEKError;
+            const budget = {
+                cpu: BigInt(evalResult.budgetSpent.cpu),
+                mem: BigInt(evalResult.budgetSpent.mem),
+            };
+            const iter = {
+                passed: !isErr,
+                budgetSpent: budget,
+                logs: evalResult.logs.slice(),
+                error: isErr ? { msg: evalResult.result.msg } : undefined,
+                inputs,
+            };
+            iterations.push(iter);
+            totalBudget = addBudget(totalBudget, budget);
+            if (isErr) {
+                passedAll = false;
+                break; // early exit on first failure (Phase 1; shrinking is Phase 2)
+            }
+        }
+        return {
+            name: desc.name,
+            sourceFile: desc.sourceFile,
+            range: desc.range,
+            kind: "property",
+            passed: passedAll,
+            iterations,
+            totalBudget,
+            seed,
+        };
+    }
     async runRepl(config) {
         const cfg = {
             ...this.cfg,
@@ -112,7 +280,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.runRepl();
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -126,21 +293,42 @@ export class Compiler extends DiagnosticEmitter {
         // compiles to `Delay(body)`; force it so the body executes.
         return Machine.eval(new Force(uplcProgram.body));
     }
-    _compileBackend(cfg, program) {
-        // backend starts here
-        const ir = compileTypedProgram(cfg, program);
-        const uplc = compileIRToUPLC(ir, cfg);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
-        const outDir = cfg.outDir;
-        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
-        this.io.writeFile(outPath, serialized, cfg.root);
-        this.io.stdout.write(`compiled program written to ${outPath}\n`);
-        __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        __unsafe_clear_hoisted_hash_to_symbol();
-        __unsafe_clear_letted_hash_to_symbol();
-        __unsafe_clear_hoisted_cache();
-        __unsafe_clear_mapToType_cache();
-        return serialized;
+    _compileBackend(cfg, program, skipFileOutput = false) {
+        // Run the whole backend under a fresh per-compilation context. All
+        // node-level caches (hoisted/letted naming, hoisted->letted lowering,
+        // the mapToType helper cache) live on this context, so they cannot
+        // leak into or be perturbed by any other compilation — and they are
+        // dropped automatically when this scope exits, even on throw. The
+        // content-addressed `IRHash` has no global state at all, so there is
+        // nothing else to reset.
+        return withCompilationCtx(new CompilationCtx(), () => {
+            const ir = compileTypedProgram(cfg, program);
+            const uplc = compileIRToUPLC(ir, cfg);
+            const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
+            if (!skipFileOutput) {
+                const outDir = cfg.outDir;
+                const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
+                this.io.writeFile(outPath, serialized, cfg.root);
+                this.io.stdout.write(`compiled program written to ${outPath}\n`);
+            }
+            return serialized;
+        });
     }
 }
+function _failedTestResult(desc, msg, kind = "unit") {
+    const budget = zeroBudget();
+    return {
+        name: desc.name,
+        sourceFile: desc.sourceFile,
+        range: desc.range,
+        kind,
+        passed: false,
+        iterations: [{
+                passed: false,
+                budgetSpent: budget,
+                logs: [],
+                error: { msg },
+            }],
+        totalBudget: budget,
+    };
+}

package/dist/compiler/TirCompiler/expressify/ExpressifyCtx.js

@@ -303,7 +303,7 @@ export class ExpressifyCtx {
         if (stmt.rest) {
             if (isDestructuredField)
                 throw new Error("rest is not implemented in destructured field array-like deconstruct. TODO: map data elems to elem type");
-            const lettedRest = this.introduceLettedConstant(stmt.rest, new TirCallExpr(TirNativeFunc._dropList(elemsType), [
+            const lettedRest = this.introduceLettedConstant(stmt.rest, new TirCallExpr(TirNativeFunc.dropList(elemsType), [
                 new TirLitIntExpr(BigInt(nElems), stmt.range),
                 lettedArrayExpr
             ], new TirListT(elemsType), stmt.range), stmt.range);

package/dist/compiler/TirCompiler/expressify/expressify.js

@@ -200,7 +200,7 @@ loopReplacements, assertions = []) {
             }
             if (stmt.rest) {
                 const uniqueRestName = getUniqueInternalName(stmt.rest);
-                const restLetted = ctx.introduceLettedConstant(uniqueRestName, new TirCallExpr(TirNativeFunc._dropList(elemType), [
+                const restLetted = ctx.introduceLettedConstant(uniqueRestName, new TirCallExpr(TirNativeFunc.dropList(elemType), [
                     new TirLitIntExpr(BigInt(stmt.elements.length % modTails), stmt.range),
                     lettedArr
                 ], listType, stmt.range), stmt.range);
@@ -395,8 +395,36 @@ loopReplacements, assertions = []) {
             const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
             const forStmt = loopToForStmt(stmt);
             const { bodyStateType, initState } = getBodyStateType(returnTypeAndInvalidInit, forStmt);
+            // Optimization: when the loop reassigns exactly one variable
+            // and has no user-written `return` inside, skip the SoP wrap
+            // around the loop's result. The recursive loop function then
+            // returns the bare variable's type, saving one `Reassigns{…}`
+            // constructor build per iteration and one IRCase at the exit.
+            // Requires the loop to be non-terminating (terminating loops
+            // are tail-positioned and their value must match the outer
+            // function's expected return type — we don't try to reconcile
+            // that here).
+            const canBareLower = (reassignedAndFlow.reassigned.length === 1
+                && !reassignedAndFlow.returns
+                && !definitelyTerminates);
             const loopExprCtx = ctx.newChild();
-            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+            const bareReturnType = canBareLower
+                ? bodyStateType.constructors[0].fields[0].type
+                : undefined;
+            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState, bareReturnType);
+            if (canBareLower) {
+                // Bind the loop's bare result as the variable's new SSA
+                // name, then evaluate the rest of the body. No outer
+                // case-match needed. Use a fresh internal name so the
+                // existing `letted[varName] = initialValue` binding (from
+                // the original `let varName = ...` statement) isn't
+                // shadowed by a no-op `introduceLettedConstant` call.
+                const [varName] = reassignedAndFlow.reassigned;
+                const loopResultName = getUniqueInternalName(varName);
+                const lettedExpr = ctx.introduceLettedConstant(loopResultName, loopExpr, stmt.range);
+                ctx.setNewVariableName(varName, lettedExpr.varName);
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, expressifyFuncBody(ctx, bodyStmts, loopReplacements));
+            }
             const result = TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, definitelyTerminates ? loopExpr : wrapNonTerminatingFinalStmtAsCaseExpr(loopExpr, returnTypeAndInvalidInit.sop, ctx, stmt.range, reassignedAndFlow, bodyStmts, loopReplacements));
             return result;
         }

package/dist/compiler/TirCompiler/expressify/expressifyForStmt.d.ts

@@ -4,6 +4,7 @@ import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
 import { TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { TirType } from "../../tir/types/TirType.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
 export declare function loopToForStmt(stmt: TirWhileStmt | TirForOfStmt | TirForStmt): TirForStmt;
-export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr): TirCallExpr;
+export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr, bareReturnType?: TirType): TirCallExpr;

package/dist/compiler/TirCompiler/expressify/expressifyForStmt.js

@@ -68,7 +68,16 @@ export function loopToForStmt(stmt) {
     stmt.body, // loopBody
     stmt.range);
 }
-export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState) {
+export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState, 
+// Optimization: when the loop has exactly one reassigned variable
+// and no user-written `return` inside its body, the SoP wrap
+// (`Reassigns{var}`) on every iteration is unnecessary. The caller
+// can opt into a bare-value lowering by passing the variable's type
+// here; the loop function then returns that type directly, and the
+// call site is expected to bind the result without a case-match.
+bareReturnType) {
+    const effectiveReturnType = bareReturnType ?? returnType;
+    const isBareMode = bareReturnType !== undefined;
     let loopBody = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
     loopBody = new TirBlockStmt(loopBody.stmts.slice(), loopBody.range);
     // add final loop updates
@@ -88,9 +97,27 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
         ], loopBody.range);
     }
     const loopFuncName = getUniqueInternalName("loop");
-    const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), returnType);
+    const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), effectiveReturnType);
     const loopReplacements = {
         compileBreak(ctx, stmt) {
+            if (isBareMode) {
+                // Bare-value mode: the loop's return type IS the single
+                // user variable's type. `break` yields that var's current
+                // value directly, no SoP construction.
+                const userVarField = bodyStateType.constructors[0].fields[0];
+                const resolved = ctx.getVariable(userVarField.name);
+                if (isExpressifyFuncParam(resolved)) {
+                    return new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: resolved.name,
+                            type: resolved.type,
+                            isConstant: false
+                        },
+                        isDefinedOutsideFuncScope: false
+                    }, stmt.range);
+                }
+                return resolved;
+            }
             // return first constructor of the return type
             const ctor = returnType.constructors[0];
             return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), ctor.fields.map(f => new Identifier(f.name, stmt.range)), bodyStateType.constructors[0].fields
@@ -111,10 +138,21 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
             }), returnType, stmt.range);
         },
         replaceReturnValue(ctx, stmt) {
-            // return second constructor of the return type
+            // Synthetic returns inserted by `expressifyIfBranch` (and
+            // analogous callers) carry the inner-if's SoP value as the
+            // continuation of the ternary they participate in — they are
+            // NOT user-written returns escaping the loop. When the loop
+            // has no user-written `return` in its body, `returnType` has
+            // only the "break/continue" constructor: in that case the
+            // value flowing through is already the right type and we
+            // must leave it untouched. (Previously this threw "No return
+            // constructor found in return type" when a for-of body
+            // contained an `if` that mutated a captured `let` — the
+            // synthesized branch-tail returns hit this path even though
+            // the user had no `return` inside the loop.)
             const ctor = returnType.constructors[1];
             if (!ctor) {
-                throw new Error("No return constructor found in return type");
+                return stmt.value;
             }
             return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), [new Identifier(ctor.fields[0].name, stmt.range)], [stmt.value], returnType, stmt.range);
         },
@@ -149,7 +187,7 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
                     }, stmt.range);
                 }
                 return resolved;
-            }), returnType, stmt.range);
+            }), effectiveReturnType, stmt.range);
         },
     };
     const loopCompilationCtx = ctx.newChild();
@@ -165,7 +203,7 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
     false, // is constant
     stmt.range)), 
     // func return type
-    returnType, 
+    effectiveReturnType, 
     // func body
     new TirBlockStmt([
         new TirReturnStmt(expressifyFuncBody(loopCompilationCtx, loopBody.stmts, loopReplacements, [] // assertions
@@ -176,5 +214,5 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
     );
     return new TirCallExpr(loopFuncExpr, 
     // loop call init args
-    initState.values.map(v => expressifyVars(ctx, v.clone())), returnType, stmt.range);
+    initState.values.map(v => expressifyVars(ctx, v.clone())), effectiveReturnType, stmt.range);
 }

package/dist/compiler/TirCompiler/expressify/expressifyVars.d.ts

@@ -8,4 +8,3 @@ import { ExpressifyCtx } from "./ExpressifyCtx.js";
  * @returns a the modified expression
 **/
 export declare function expressifyVars(ctx: ExpressifyCtx, expr: TirExpr): TirExpr;
-export declare function __unsafe_clear_mapToType_cache(): void;