@harmoniclabs/pebble 0.2.0 → 0.3.1

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;
 }

package/dist/compiler/tir/expressions/TirCaseExpr.js

@@ -1,20 +1,19 @@
 import { IRApp, _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
-import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRLetted } from "../../../IR/IRNodes/IRLetted.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
-import { _ir_let, _ir_let_sym } from "../../../IR/tree_utils/_ir_let.js";
+import { _ir_let_sym } from "../../../IR/tree_utils/_ir_let.js";
 import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
-import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 import { _inlineFromData } from "./TirFromDataExpr.js";
 export class TirCaseExpr {
@@ -73,13 +72,83 @@ export class TirCaseExpr {
         if (matchExprType instanceof TirSoPStructType
             || matchExprType instanceof TirSopOptT)
             return this._sopStructToIR(matchExprType, ctx);
+        if (matchExprType instanceof TirDataStructType
+            && matchExprType.untagged)
+            return this._untaggedDataStructToIR(matchExprType, ctx);
         if (matchExprType instanceof TirDataStructType
             || matchExprType instanceof TirDataOptT)
             return this._dataStructToIR(matchExprType, ctx);
+        if (matchExprType instanceof TirEnumType)
+            return this._enumToIR(matchExprType, ctx);
         console.error(this);
         throw new Error("`case` expressions are only supported on Sum-of-Products or Data Struct types; got: "
             + this.matchExpr.type.toString());
     }
+    /**
+     * 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".
+     */
+    _untaggedDataStructToIR(matchExprType, ctx) {
+        if (matchExprType.constructors.length !== 1) {
+            throw new Error("untagged data struct must have exactly one constructor");
+        }
+        const ctor = matchExprType.constructors[0];
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+        const matchedArm = this.cases.find(c => c.pattern.constrName === ctor.name);
+        if (!matchedArm) {
+            // no matching arm: just run the wildcard body (the scrutinee is
+            // evaluated for side-effects via `unListData` only if any field
+            // would have been bound; here, nothing).
+            return wildcardBodyIR;
+        }
+        const pattern = matchedArm.pattern;
+        const usedFields = ctor.fields
+            .map((f, idx) => ({ name: f.name, type: f.type, idx }))
+            .filter(f => pattern.fields.has(f.name));
+        // 0 bound fields → just run the body; no extraction.
+        if (usedFields.length === 0)
+            return matchedArm.body.toIR(ctx);
+        // fields-list = unListData(scrutinee), bound once and reused via
+        // IRLetted so the let-handling pass elides or shares as appropriate.
+        const fieldsListLetted = new IRLetted(Symbol("untaggedFields"), _ir_apps(IRNative.unListData, this.matchExpr.toIR(ctx)));
+        const branchCtx = ctx.newChild();
+        // bind each used field with a let in declaration order.
+        // sort by ctor field index so earlier extractions don't need to
+        // re-drop past already-bound fields.
+        usedFields.sort((a, b) => a.idx - b.idx);
+        const bindings = usedFields.map(f => {
+            const varDecl = pattern.fields.get(f.name);
+            if (!(varDecl instanceof TirSimpleVarDecl))
+                throw new Error("case pattern not expressified.");
+            const sym = branchCtx.defineVar(varDecl.name);
+            return {
+                sym,
+                extract: _inlineFromData(f.type, _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(f.idx), fieldsListLetted.clone())))
+            };
+        });
+        // build nested let-bindings around the body
+        let result = matchedArm.body.toIR(branchCtx);
+        for (let i = bindings.length - 1; i >= 0; i--) {
+            const { sym, extract } = bindings[i];
+            result = _ir_let_sym(sym, extract, result);
+        }
+        return result;
+    }
+    _enumToIR(enumType, ctx) {
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+        const branches = enumType.members.map(memberName => {
+            const branch = this.cases.find(c => c.pattern.constrName === memberName);
+            return branch ? branch.body.toIR(ctx) : wildcardBodyIR;
+        });
+        while (branches.length > 0 && branches[branches.length - 1] instanceof IRError)
+            branches.pop();
+        return branches.length > 0
+            ? new IRCase(this.matchExpr.toIR(ctx), branches)
+            : new IRError();
+    }
     _sopStructToIR(matchExprType, ctx) {
         if (matchExprType instanceof TirSopOptT) {
             const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
@@ -172,134 +241,87 @@ export class TirCaseExpr {
         return branches.length > 0 ? new IRCase(this.matchExpr.toIR(ctx), branches) : new IRError(); // all branches fail, so the whole expression fails
     }
     _dataStructToIR(matchExprType, ctx) {
-        if (matchExprType instanceof TirDataOptT) {
-            const stmtCtx = ctx.newChild();
-            stmtCtx.pushUnusedVar(); // debrujin un constr data result
-            const wildcardBodyIR = this.wildcardCase?.body.toIR(stmtCtx) ?? new IRError();
-            const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
-            let someBranchIR = () => new IRFunc([Symbol("unused_some_value")], wildcardBodyIR);
-            if (someBranch) {
-                const pattern = someBranch.pattern;
-                const valueDecl = pattern.fields.get("value");
-                if (valueDecl
-                    && !(valueDecl instanceof TirSimpleVarDecl))
-                    throw new Error("case pattern not expressified.");
-                const someBranchCtx = stmtCtx.newChild();
-                const someBranchVarSym = valueDecl ? someBranchCtx.defineVar(valueDecl.name) : Symbol("some_value_unused");
-                someBranchIR = (unConstrMatchSym) => new IRApp(new IRFunc([someBranchVarSym], someBranch.body.toIR(someBranchCtx)), _inlineFromData(getOptTypeArg(matchExprType), _ir_apps(IRNative.sndPair, new IRVar(unConstrMatchSym) // unConstrData result
-                )));
-            }
-            const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
-            return _ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
-            // condition
-            _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(unConstrMatchSym) // unConstrData result
-            )), 
-            // then Just{ value }
-            someBranchIR(unConstrMatchSym), 
-            // else None
-            noneBranchIR));
-        }
-        // TirDataStructType
-        const stmtCtx = ctx.newChild();
-        const unConstrStructSym = stmtCtx.pushUnusedVar("unconstrStruct"); // unconstrStruct
-        const isConstrIdxSym = stmtCtx.pushUnusedVar("isConstrIdx"); // isConstrIdx
-        const noVarsWildcardBodyIR = (this.wildcardCase?.body.toIR(stmtCtx)
-            ?? new IRError());
-        const delayedNoVarWildcardBodyIR = new IRDelayed(noVarsWildcardBodyIR);
-        let ifThenElseMatchingStatements = noVarsWildcardBodyIR;
+        // TirDataOptT extends TirDataStructType (constructors Some{value}, None{}),
+        // so the same logic handles it.
+        //
+        // Lowering structure (UPLC `Case` accepts pair / int scrutinees
+        // as untagged constructors):
+        //
+        //   Case (unConstrData scrutinee) [
+        //       \idxSym fieldsSym ->
+        //           Case idxSym [body_0, body_1, ..., body_(maxParent)]
+        //   ]
+        //
+        // - The outer `Case` over the `pair(int, list<data>)` returned by
+        //   `unConstrData` extracts both halves via a single 2-arg branch
+        //   (pair is treated as `constr 0 [fst, snd]`).
+        // - The inner `Case` over `idxSym` dispatches by tag in O(1) —
+        //   no `equalsInteger` chain, no `lazyIfThenElse`.
+        // - Each inner branch takes 0 args (an int N is treated as
+        //   `constr N []`). The branch body extracts fields lazily from
+        //   `fieldsSym` via deferred access on `thenCtx`, wrapped in
+        //   `IRLetted` so the letted-handling pass dedups, inlines or
+        //   elides as appropriate.
         if (this.cases.some(({ pattern }) => matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName) < 0))
             throw new Error("case expression includes unknown constructor.");
-        const cases = this.cases.sort((a, b) => {
-            const a_idx = matchExprType.constructors.findIndex(ctor => ctor.name === a.pattern.constrName);
-            const b_idx = matchExprType.constructors.findIndex(ctor => ctor.name === b.pattern.constrName);
-            return a_idx - b_idx;
-        });
-        for (let i = cases.length - 1; i >= 0; i--) {
-            const { pattern, body } = cases[i];
+        const stmtCtx = ctx.newChild();
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(stmtCtx) ?? new IRError();
+        // outer destructuring binders — symbols allocated up-front so
+        // per-arm deferred accesses (closures) reference the same syms
+        const idxSym = Symbol("ctorIdx");
+        const fieldsListSym = Symbol("fieldsList");
+        // The runtime value's ctor tag spans all parent indices known to
+        // this type — not just the indices that appear as arm patterns.
+        // Size the inner-Case branch array to cover all of them and fill
+        // missing slots with the wildcard.
+        const armsByParentIdx = new Map();
+        // TirDataOptT extends TirDataStructType, so both have parentCtorIdx
+        const allParentIdxs = matchExprType.constructors.map((_, i) => matchExprType.parentCtorIdx(i));
+        let maxParentIdx = allParentIdxs.reduce((m, x) => x > m ? x : m, -1);
+        for (const matchCase of this.cases) {
+            const { pattern, body } = matchCase;
             const ctorIdx = matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName);
-            if (ctorIdx < 0)
-                throw new Error("case expression includes unknown constructor."); // unreachable
             const ctor = matchExprType.constructors[ctorIdx];
-            const usedFieldsCtorNames = (ctor.fields.map(f => f.name)
-                .filter(fName => pattern.fields.has(fName)));
-            if (usedFieldsCtorNames.length <= 0) {
-                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition (compare against the PARENT ctor index — the
-                // value's runtime tag is unaffected by narrowing)
-                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(matchExprType instanceof TirDataStructType
-                    ? matchExprType.parentCtorIdx(ctorIdx)
-                    : ctorIdx)), 
-                // then
-                body.toIR(stmtCtx), 
-                // else
-                ifThenElseMatchingStatements);
-                continue;
-            }
-            function indexOfField(fieldName) {
-                const idx = ctor.fields.findIndex(f => f.name === fieldName);
-                if (idx < 0)
-                    throw new Error("case pattern not expressified.");
-                return idx;
-            }
-            if (usedFieldsCtorNames.length === 1) {
-                const thenCtx = stmtCtx.newChild();
-                const fName = usedFieldsCtorNames[0];
+            const parentCtorIdx = matchExprType instanceof TirDataStructType
+                ? matchExprType.parentCtorIdx(ctorIdx)
+                : ctorIdx;
+            // bind each pattern-named field as a deferred access on
+            // `fieldsListSym`. Each access produces an `IRLetted`
+            // wrapping `_inlineFromData(type, headList(_dropList(idx, fields)))`.
+            const armCtx = stmtCtx.newChild();
+            const usedFieldsCtorNames = ctor.fields
+                .map(f => f.name)
+                .filter(fName => pattern.fields.has(fName));
+            for (const fName of usedFieldsCtorNames) {
                 const patternVarDecl = pattern.fields.get(fName);
                 if (!(patternVarDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
-                const introVar = thenCtx.defineVar(patternVarDecl.name);
-                const thenCase = _ir_let_sym(introVar, _inlineFromData(patternVarDecl.type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
-                _ir_apps(// fileds as data list
-                IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
-                )))), body.toIR(thenCtx));
-                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition (compare against the PARENT ctor index — the
-                // value's runtime tag is unaffected by narrowing)
-                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(matchExprType instanceof TirDataStructType
-                    ? matchExprType.parentCtorIdx(ctorIdx)
-                    : ctorIdx)), 
-                // then
-                thenCase, 
-                // else
-                ifThenElseMatchingStatements);
-                continue;
-            } // single field used edge case
-            // multiple fields used
-            const thenCtx = stmtCtx.newChild();
-            const fieldsAsDataList = thenCtx.pushUnusedVar(); // fileds as data list
-            const sortedUsedFields = [...usedFieldsCtorNames].sort((a, b) => indexOfField(a) - indexOfField(b));
-            const introducedVars = new Array(sortedUsedFields.length);
-            for (let fIdx = 0; fIdx < sortedUsedFields.length; fIdx++) {
-                const fName = sortedUsedFields[fIdx];
-                const patternVarDecl = pattern.fields.get(fName);
-                if (!(patternVarDecl instanceof TirSimpleVarDecl))
+                const fieldIdx = ctor.fields.findIndex(f => f.name === fName);
+                if (fieldIdx < 0)
                     throw new Error("case pattern not expressified.");
-                introducedVars[fIdx] = thenCtx.defineVar(patternVarDecl.name);
+                const fieldType = patternVarDecl.type;
+                armCtx.defineDeferredAccess(patternVarDecl.name, () => new IRLetted(Symbol(`${ctor.name}_${fName}`), _inlineFromData(fieldType, _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(fieldIdx), new IRVar(fieldsListSym))))));
             }
-            const extractedFields = sortedUsedFields.map(fName => _inlineFromData(ctor.fields.find(f => f.name === fName).type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
-            new IRVar(fieldsAsDataList) // fileds as data list
-            ))));
-            const thenCase = _ir_let_sym(fieldsAsDataList, _ir_apps(IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
-            ), // fileds as data list
-            _ir_apps(new IRFunc(introducedVars, body.toIR(thenCtx)), ...extractedFields));
-            ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-            // condition (compare against the PARENT ctor index — the
-            // value's runtime tag is unaffected by narrowing)
-            _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-            IRConst.int(matchExprType instanceof TirDataStructType
-                ? matchExprType.parentCtorIdx(ctorIdx)
-                : ctorIdx)), 
-            // then
-            thenCase, 
-            // else
-            ifThenElseMatchingStatements);
+            armsByParentIdx.set(parentCtorIdx, body.toIR(armCtx));
+        }
+        // build inner-Case branches sized to `maxParentIdx + 1`, filling
+        // missing slots with the wildcard body
+        const innerBranches = new Array(maxParentIdx + 1);
+        for (let i = 0; i < innerBranches.length; i++) {
+            innerBranches[i] = armsByParentIdx.get(i) ?? wildcardBodyIR;
         }
-        return _ir_let_sym(unConstrStructSym, _ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), // unconstrStruct
-        _ir_let_sym(isConstrIdxSym, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrStructSym) // unConstrData result
-        )), // isConstrIdx
-        ifThenElseMatchingStatements));
+        // trailing `IRError` branches can be omitted — the CEK machine
+        // fails naturally if no branch exists for the runtime tag
+        while (innerBranches.length > 0
+            && innerBranches[innerBranches.length - 1] instanceof IRError)
+            innerBranches.pop();
+        const innerCase = innerBranches.length > 0
+            ? new IRCase(new IRVar(idxSym), innerBranches)
+            : new IRError();
+        // outer Case over the pair: single branch destructures (idx, fields)
+        return new IRCase(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), [
+            new IRFunc([idxSym, fieldsListSym], innerCase)
+        ]);
     }
 }
 export class TirCaseMatcher {

package/dist/compiler/tir/expressions/TirElemAccessExpr.js

@@ -44,8 +44,8 @@ export class TirElemAccessExpr {
             const result = Machine.evalSimple(compileIRToUPLC(irIndex));
             if ((result instanceof CEKConst)
                 && (typeof result.value === "number" || typeof result.value === "bigint"))
-                return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(result.value), irArr));
+                return _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(result.value), irArr));
         }
-        return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, irIndex, irArr));
+        return _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, irIndex, irArr));
     }
 }