@harmoniclabs/pebble 0.2.0 → 0.3.0

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanEqualExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { int_t, bytes_t } from "../../../../tir/program/stdScope/stdScope.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
@@ -11,7 +12,7 @@ export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
@@ -12,7 +13,7 @@ export function _compileLessThanExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileMultExpr.js

@@ -1,20 +1,38 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirMultExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileMultExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    // Probe both sides without hints so we can disambiguate
+    // (int * Value) / (Value * int) / (int * int).
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    const right = _compileExpr(ctx, expr.right, int_t);
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, int_t);
+        if (!right)
+            return undefined;
+        if (!canAssignTo(right.type, int_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
+    // left is int — right may be int (regular product) or Value (scaleValue).
+    const right = _compileExpr(ctx, expr.right, undefined);
     if (!right)
         return undefined;
+    const rightTy = getUnaliased(right.type);
+    if (rightTy instanceof TirValueT) {
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirMultExpr(left, right, 
+    return new TirMultExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileNotEqualExpr.js

@@ -1,12 +1,13 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirNotEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileNotEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    const leftType = left.type;
+    const leftType = normalizeEnumToInt(left.type, ctx.program.stdTypes.int);
     const right = _compileExpr(ctx, expr.right, leftType);
     if (!right)
         return undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileSubExpr.js

@@ -1,20 +1,31 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirSubExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileSubExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, leftProbe.type);
+        if (!right)
+            return undefined;
+        if (!(getUnaliased(right.type) instanceof TirValueT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), "Value");
+        return new TirSubExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
     const right = _compileExpr(ctx, expr.right, int_t);
     if (!right)
         return undefined;
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirSubExpr(left, right, 
+    return new TirSubExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.js

@@ -11,6 +11,7 @@ import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
 import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
 import { isTirStructType, TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { TirEnumType } from "../../../tir/types/TirEnumType.js";
 import { getDeconstructableType } from "../../../tir/types/utils/getDeconstructableType.js";
 import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
@@ -32,11 +33,13 @@ export function _compileMatchStmt(ctx, stmt) {
     if (!deconstructableType)
         return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed, stmt.matchExpr.range, matchExprType.toString());
     // TODO: add support for all deconstructable types
-    if (!isTirStructType(deconstructableType)) {
-        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs supported for now, sorry!");
+    if (!isTirStructType(deconstructableType) && !(deconstructableType instanceof TirEnumType)) {
+        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs and enums supported for now, sorry!");
     }
-    const ctors = deconstructableType.constructors;
-    const ctorNames = ctors.map(c => c.name);
+    const ctorNames = deconstructableType instanceof TirEnumType
+        ? deconstructableType.members.slice()
+        : deconstructableType.constructors.map(c => c.name);
+    const totalCtors = ctorNames.length;
     const missingCtors = ctorNames.slice();
     if (stmt.cases.length === 0)
         return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
@@ -70,7 +73,7 @@ export function _compileMatchStmt(ctx, stmt) {
             return undefined;
         wildcardCase = new TirMatchStmtWildcardCase(branchBody, matchCase.range);
     }
-    if (!wildcardCase && cases.length < ctors.length) {
+    if (!wildcardCase && cases.length < totalCtors) {
         return ctx.error(DiagnosticCode.Match_cases_are_not_exhaustive, stmt.range);
     }
     return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
@@ -82,23 +85,21 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
     //*/
     const pattern = matchCase.pattern;
     if (pattern instanceof SimpleVarDecl) {
-        /*
-        if( pattern.name.text === "_" ) {
+        // bare-name pattern: only valid for enum scrutinees (`when Apple: ...`)
+        if (deconstructableType instanceof TirEnumType) {
+            const memberName = pattern.name.text;
+            const memberIdx = deconstructableType.indexOf(memberName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), memberName);
+            if (constrNamesAlreadySpecified.includes(memberName))
+                return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, pattern.name.range, memberName);
+            constrNamesAlreadySpecified.push(memberName);
             const branchCtx = ctx.newBranchChildScope();
-            const branchBody = wrapManyStatements(
-                _compileStatement(
-                    branchCtx,
-                    matchCase.body
-                ),
-                matchCase.body.range
-            );
-            if( !branchBody ) return undefined;
-            return new TirMatchStmtWildcardCase(
-                branchBody,
-                matchCase.range
-            );
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(memberName, new Map(), undefined, deconstructableType, undefined, true, pattern.name.range, pattern.name.range), branchBody, matchCase.range);
         }
-        //*/
         return ctx.error(DiagnosticCode.The_argument_of_a_match_statement_branch_must_be_deconstructed, matchCase.pattern.range);
     }
     else if (pattern instanceof NamedDeconstructVarDecl) {
@@ -107,6 +108,18 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
         if (constrNamesAlreadySpecified.includes(deconstructedCtorName))
             return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, deconstructedCtorIdentifier.range, deconstructedCtorName);
         constrNamesAlreadySpecified.push(deconstructedCtorName);
+        if (deconstructableType instanceof TirEnumType) {
+            const memberIdx = deconstructableType.indexOf(deconstructedCtorName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
+            if (pattern.fields.size > 0 || pattern.rest)
+                return ctx.error(DiagnosticCode.Enum_member_pattern_cannot_have_fields, pattern.range);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(deconstructedCtorName, new Map(), undefined, deconstructableType, undefined, true, pattern.range, pattern.name.range), branchBody, matchCase.range);
+        }
         if (deconstructableType instanceof TirSoPStructType
             || deconstructableType instanceof TirDataStructType) {
             const localIdx = deconstructableType.constructors.findIndex(c => c.name === deconstructedCtorName);

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

@@ -1,5 +1,6 @@
 import { TirAliasType } from "../../tir/types/TirAliasType.js";
 import { isTirStructType } from "../../tir/types/TirStructType.js";
+import { TirEnumType } from "../../tir/types/TirEnumType.js";
 import { TirTypeParam } from "../../tir/types/TirTypeParam.js";
 import { int_t, bytes_t, bool_t, string_t } from "../../tir/program/stdScope/stdScope.js";
 import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirUnConstrDataResultT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
@@ -8,6 +9,8 @@ import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../../tir/types/TirNativeType/native/data.js";
 import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
 import { TirIntT } from "../../tir/types/TirNativeType/native/int.js";
+import { TirArrayT } from "../../tir/types/TirNativeType/native/array.js";
+import { TirValueT } from "../../tir/types/TirNativeType/native/value.js";
 import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../tir/types/TirNativeType/native/list.js";
@@ -84,6 +87,14 @@ export function getPropAccessReturnType(ctx, objType, propId) {
         return undefined;
     if (objType instanceof TirMlResultT)
         return undefined;
+    // Native Value / Array<T> — methods are reached through prelude/std
+    // aliases, not via direct prop-access on the native type.
+    if (objType instanceof TirValueT)
+        return undefined;
+    if (objType instanceof TirArrayT)
+        return undefined;
+    if (objType instanceof TirEnumType)
+        return undefined;
     const tsEnsureExhaustiveCheck = objType;
     console.error(objType);
     throw new Error("unreachable::getPropAccessReturnType");

package/dist/compiler/Compiler.js

@@ -7,12 +7,7 @@ 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";
@@ -57,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) {
@@ -82,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()) {
@@ -103,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()) {
@@ -288,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()) {
@@ -303,23 +294,25 @@ export class Compiler extends DiagnosticEmitter {
         return Machine.eval(new Force(uplcProgram.body));
     }
     _compileBackend(cfg, program, skipFileOutput = false) {
-        // backend starts here
-        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`);
-        }
-        __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;
+        // 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") {

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;

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

@@ -5,6 +5,7 @@ import { TirLitFailExpr } from "../../tir/expressions/litteral/TirLitFailExpr.js
 import { TirLitFalseExpr } from "../../tir/expressions/litteral/TirLitFalseExpr.js";
 import { TirLitHexBytesExpr } from "../../tir/expressions/litteral/TirLitHexBytesExpr.js";
 import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
+import { TirLitEnumMemberExpr } from "../../tir/expressions/litteral/TirLitEnumMemberExpr.js";
 import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
 import { TirLitObjExpr } from "../../tir/expressions/litteral/TirLitObjExpr.js";
 import { TirLitStrExpr } from "../../tir/expressions/litteral/TirLitStrExpr.js";
@@ -38,8 +39,9 @@ import { TirUnaryMinus } from "../../tir/expressions/unary/TirUnaryMinus.js";
 import { TirUnaryPlus } from "../../tir/expressions/unary/TirUnaryPlus.js";
 import { isTirUnaryPrefixExpr } from "../../tir/expressions/unary/TirUnaryPrefixExpr.js";
 import { TirUnaryTilde } from "../../tir/expressions/unary/TirUnaryTilde.js";
-import { bool_t, bytes_t, data_t, int_t, valueAmountOfName } from "../../tir/program/stdScope/stdScope.js";
+import { bool_t, bytes_t, data_t, int_t, valueMapAmountOfName } from "../../tir/program/stdScope/stdScope.js";
 import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
+import { currentCompilationCtx } from "../../../IR/CompilationCtx.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
 import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
@@ -76,6 +78,7 @@ export function expressifyVars(ctx, expr) {
         || expr instanceof TirLitThisExpr
         || expr instanceof TirLitStrExpr
         || expr instanceof TirLitIntExpr
+        || expr instanceof TirLitEnumMemberExpr
         || expr instanceof TirLitHexBytesExpr
         || expr instanceof TirNativeFunc
         // hoisted expressions are necessarily closed, so no external variables
@@ -266,6 +269,7 @@ function expressifyPropAccess(ctx, propAccessExpr) {
         || expr instanceof TirLitArrExpr
         || expr instanceof TirLitStrExpr
         || expr instanceof TirLitIntExpr
+        || expr instanceof TirLitEnumMemberExpr
         || expr instanceof TirLitHexBytesExpr
         || expr instanceof TirNativeFunc
         || expr instanceof TirPropAccessExpr // `expressifyVars` is called recursively on the object before this check
@@ -372,6 +376,20 @@ function expressifyPropAccess(ctx, propAccessExpr) {
             throw new Error(`Property '${prop}' does not exist on type '${objType.toString()}'`);
         const fName = ctor.fields[fIdx].name;
         const fType = ctor.fields[fIdx].type;
+        // Untagged data structs encode as `listData(fields)` rather than
+        // `constrData(0, fields)`. Field access lowers directly to
+        // `unIData (or _inlineFromData) <$> headList (dropList idx (unListData v))`
+        // — no case-rewrite needed, no constructor index to check.
+        if (objType instanceof TirDataStructType
+            && objType.untagged) {
+            const fieldsListT = new TirListT(data_t);
+            return new TirFromDataExpr(new TirCallExpr(TirNativeFunc.headList(data_t), [
+                new TirCallExpr(TirNativeFunc.dropList(data_t), [
+                    new TirLitIntExpr(BigInt(fIdx), propAccessExpr.range),
+                    new TirCallExpr(TirNativeFunc.unListData, [expr], fieldsListT, propAccessExpr.range)
+                ], fieldsListT, propAccessExpr.range)
+            ], data_t, propAccessExpr.range), fType, propAccessExpr.range);
+        }
         return new TirCaseExpr(expr, [
             new TirCaseMatcher(new TirNamedDeconstructVarDecl(ctor.name, new Map([
                 [fName, new TirSimpleVarDecl(fName, fType, undefined, true, propAccessExpr.range)]
@@ -412,7 +430,7 @@ function expressifyMethodCall(ctx, methodCall) {
         // fast-path: `Value.amountOf(policy, name)` compiles directly to
         // `_amountOfValue(eqByteString(policy))(value)(eqByteString(name))`
         // skipping the wrapper function indirection.
-        if (tirMethodName === valueAmountOfName
+        if (tirMethodName === valueMapAmountOfName
             && methodCall.args.length === 2) {
             const [policyArg, nameArg] = methodCall.args;
             const bytesToBoolT = new TirFuncT([bytes_t], bool_t);
@@ -582,7 +600,8 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
             throw new Error(`Argument 1 of method 'map' of type 'list' must be a function, got '${arg.type.toString()}'`);
         const mapReturnT = argFuncType.returnType;
         const elemTypeTirName = elemsType.toTirTypeKey();
-        let base_mapToType = _base_mapToType_cache.get(elemTypeTirName)?.clone();
+        const mapToTypeCache = currentCompilationCtx().mapToTypeCache;
+        let base_mapToType = mapToTypeCache.get(elemTypeTirName)?.clone();
         if (!base_mapToType) {
             base_mapToType = new TirHoistedExpr("_map_to_list_of_" + elemTypeTirName, new TirCallExpr(TirNativeFunc._mkMap(elemsType, mapReturnT), [new TirLitArrExpr([], new TirListT(mapReturnT), SourceRange.unknown)], new TirFuncT([
                 // mapping function
@@ -593,7 +612,7 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
                 new TirListT(elemsType)
             ], new TirListT(mapReturnT)), SourceRange.unknown));
             base_mapToType.varName; // precompute hash and symbol
-            _base_mapToType_cache.set(elemTypeTirName, base_mapToType.clone());
+            mapToTypeCache.set(elemTypeTirName, base_mapToType.clone());
         }
         return new TirCallExpr(base_mapToType, [methodCall.args[0], objectExpr], methodCall.type, exprRange);
     }
@@ -605,7 +624,3 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
     };
     */
 }
-const _base_mapToType_cache = new Map();
-export function __unsafe_clear_mapToType_cache() {
-    _base_mapToType_cache.clear();
-}

package/dist/compiler/tir/expressions/TirCaseExpr.d.ts

@@ -20,6 +20,15 @@ export declare class TirCaseExpr implements ITirExpr {
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
+    /**
+     * Lowers a `case` over an untagged data struct (single constructor;
+     * runtime form is `listData(fields)`). No constructor dispatch is
+     * needed — there's only one possible ctor — so the lowering is just
+     * "find the matching arm (or wildcard), extract any bound fields, run
+     * the body".
+     */
+    private _untaggedDataStructToIR;
+    private _enumToIR;
     private _sopStructToIR;
     private _dataStructToIR;
 }