@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

package/dist/compiler/AstCompiler/internal/exprs/_compileBinaryExpr.js

@@ -60,7 +60,7 @@ export function _compileBinaryExpr(ctx, expr, typeHint) {
         return _compileLogicalOrExpr(ctx, expr, typeHint);
     if (expr instanceof OptionalDefaultExpr)
         return _compileOptionalDefaultExpr(ctx, expr, typeHint);
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::AstCompiler::_compileBinaryExpr");
 }

package/dist/compiler/AstCompiler/internal/exprs/_compileExpr.js

@@ -71,7 +71,7 @@ typeHint) {
     //*/
     if (isLitteralExpr(expr))
         return _compileLitteralExpr(ctx, expr, typeHint);
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::AstCompiler::_compileExpr");
 }

package/dist/compiler/AstCompiler/internal/exprs/_compileLitteralExpr.js

@@ -1,4 +1,6 @@
 import { LitArrExpr } from "../../../../ast/nodes/expr/litteral/LitArrExpr.js";
+import { LitContextExpr } from "../../../../ast/nodes/expr/litteral/LitContextExpr.js";
+import { LitFailExpr } from "../../../../ast/nodes/expr/litteral/LitFailExpr.js";
 import { LitFalseExpr } from "../../../../ast/nodes/expr/litteral/LitFalseExpr.js";
 import { LitHexBytesExpr } from "../../../../ast/nodes/expr/litteral/LitHexBytesExpr.js";
 import { LitIntExpr } from "../../../../ast/nodes/expr/litteral/LitIntExpr.js";
@@ -11,6 +13,7 @@ import { LitUndefExpr } from "../../../../ast/nodes/expr/litteral/LitUndefExpr.j
 import { LitVoidExpr } from "../../../../ast/nodes/expr/litteral/LitVoidExpr.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirLitArrExpr } from "../../../tir/expressions/litteral/TirLitArrExpr.js";
+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";
@@ -61,8 +64,11 @@ export function _compileLitteralExpr(ctx, expr, typeHint) {
         return _compileLitteralObjExpr(ctx, expr, typeHint);
     if (expr instanceof LitNamedObjExpr)
         return _compileLitteralNamedObjExpr(ctx, expr, typeHint);
-    // never
-    // expr;
+    if (expr instanceof LitFailExpr)
+        return new TirLitFailExpr(expr.range);
+    if (expr instanceof LitContextExpr)
+        throw new Error("Litteral `context` should have been handled while desugaring.");
+    const tsEnsureExhautstiveCheck = expr;
     throw new Error("unreachable::AstCompiler::_compileLitteralExpr");
 }
 export function _compileLitteralUndefExpr(ctx, expr, typeHint) {

package/dist/compiler/AstCompiler/internal/exprs/_compilePropAccessExpr.js

@@ -20,7 +20,7 @@ export function _compilePropAccessExpr(ctx, expr, typeHint) {
         return _compileNonNullPropAccessExpr(ctx, expr, typeHint);
     if (expr instanceof DotPropAccessExpr)
         return _compileDotPropAccessExpr(ctx, expr, typeHint);
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::AstCompiler::_compilePropAccessExpr");
 }

package/dist/compiler/AstCompiler/internal/exprs/_compileTypeConversionExpr.js

@@ -6,8 +6,10 @@ import { _compileExpr } from "./_compileExpr.js";
 export function _compileTypeConversionExpr(ctx, ast, typeHint) {
     const data_t = ctx.program.stdTypes.data;
     const possibleTargetTypeTirNames = ctx.scope.resolveType(ast.asType.toAstName());
-    if (!possibleTargetTypeTirNames)
+    if (!possibleTargetTypeTirNames) {
+        console.log(ctx.scope);
         return ctx.error(DiagnosticCode._0_is_not_defined, ast.asType.range, ast.asType.toAstName());
+    }
     const sopTargetType = ctx.program.types.get(possibleTargetTypeTirNames.sopTirName);
     if (!sopTargetType)
         return ctx.error(DiagnosticCode._0_is_not_defined, ast.asType.range, ast.asType.toAstName());

package/dist/compiler/AstCompiler/internal/exprs/_compileUnaryPrefixExpr.js

@@ -48,7 +48,7 @@ export function _compileUnaryPrefixExpr(ctx, expr, _typeHint) {
         }
         return new TirUnaryTilde(operand, int_t, expr.range);
     }
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::AstCompiler::_compileUnaryPrefixExpr");
 }

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

@@ -31,7 +31,7 @@ export function _compileAssignmentStmt(ctx, stmt) {
         return [tirStmt];
     }
     else {
-        const tsEnsureExsautstiveCheck = stmt;
+        const tsEnsureExhautstiveCheck = stmt;
         console.error(stmt);
         throw new Error("unreachable::AstCompiler::_compileForUpdateStmts");
     }
@@ -136,7 +136,7 @@ export function _compileExplicitAssignmentStmt(ctx, stmt) {
         expr = new TirLogicalOrExpr(varAccessExpr, expr, stmt.range);
     }
     else {
-        const tsEnsureExsautstiveCheck = stmt;
+        const tsEnsureExhautstiveCheck = stmt;
         console.error(stmt);
         throw new Error("unreachable::AstCompiler::_compileExplicitAssignmentStmt");
     }

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.d.ts

@@ -1,6 +1,6 @@
 import { MatchStmt, MatchStmtCase } from "../../../../ast/nodes/statements/MatchStmt.js";
-import { TirMatchStmt, TirMatchStmtCase, TirMatchStmtWildcardCase } from "../../../tir/statements/TirMatchStmt.js";
+import { TirMatchStmt, TirMatchStmtCase } from "../../../tir/statements/TirMatchStmt.js";
 import { DeconstructableTirType } from "../../../tir/types/utils/getDeconstructableType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 export declare function _compileMatchStmt(ctx: AstCompilationCtx, stmt: MatchStmt): [TirMatchStmt] | undefined;
-export declare function _compileTirMatchStmtCase(ctx: AstCompilationCtx, matchCase: MatchStmtCase, deconstructableType: DeconstructableTirType, constrNamesAlreadySpecified: string[]): TirMatchStmtCase | TirMatchStmtWildcardCase | undefined;
+export declare function _compileTirMatchStmtCase(ctx: AstCompilationCtx, matchCase: MatchStmtCase, deconstructableType: DeconstructableTirType, constrNamesAlreadySpecified: string[]): TirMatchStmtCase | undefined;

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

@@ -13,7 +13,7 @@ import { getDeconstructableType } from "../../../tir/types/utils/getDeconstructa
 import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
 import { _compileStatement } from "./_compileStatement.js";
-import { _compileNamedDeconstructVarDecl, _compileSingleDeconstructVarDecl, _compileVarDecl } from "./_compileVarStmt.js";
+import { _compileNamedDeconstructVarDecl, _compileSingleDeconstructVarDecl } from "./_compileVarStmt.js";
 export function _compileMatchStmt(ctx, stmt) {
     if (!ctx.functionCtx)
         return ctx.error(DiagnosticCode.A_match_statement_can_only_be_used_within_a_function_body, stmt.range);
@@ -34,16 +34,18 @@ export function _compileMatchStmt(ctx, stmt) {
     if (stmt.cases.length === 0)
         return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
     const cases = [];
-    let wildcardCase = undefined;
     const constrNamesAlreadySpecified = [];
     for (const matchCase of stmt.cases) {
         const branch = _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified);
         if (!branch)
             return undefined;
-        if (branch instanceof TirMatchStmtWildcardCase) {
+        /*
+        if( branch instanceof TirMatchStmtWildcardCase )
+        {
             wildcardCase = branch;
             break; // wildcard case catches any branch specified after it
         }
+        //*/
         const indexOfCtor = missingCtors.indexOf(branch.pattern.constrName);
         if (indexOfCtor === -1) {
             return ctx.error(DiagnosticCode.Unknown_0_constructor_1, branch.pattern.range, deconstructableType.toString(), branch.pattern.constrName);
@@ -51,23 +53,44 @@ export function _compileMatchStmt(ctx, stmt) {
         missingCtors.splice(indexOfCtor, 1);
         cases.push(branch);
     }
+    let wildcardCase = undefined;
+    if (stmt.elseCase) {
+        const matchCase = stmt.elseCase;
+        const branchCtx = ctx.newBranchChildScope();
+        const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+        if (!branchBody)
+            return undefined;
+        wildcardCase = new TirMatchStmtWildcardCase(branchBody, matchCase.range);
+    }
     if (!wildcardCase && cases.length < ctors.length) {
         return ctx.error(DiagnosticCode.Match_cases_are_not_exhaustive, stmt.range);
     }
     return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
 }
 export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified) {
-    const pattern = _compileVarDecl(ctx, matchCase.pattern, deconstructableType);
-    if (!pattern)
-        return undefined;
+    /*
+    const pattern = _compileVarDecl( ctx, matchCase.pattern, deconstructableType );
+    if( !pattern ) return undefined;
+    //*/
+    const pattern = matchCase.pattern;
     if (pattern instanceof SimpleVarDecl) {
-        if (pattern.name.text === "_") {
+        /*
+        if( pattern.name.text === "_" ) {
             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 TirMatchStmtWildcardCase(
+                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) {
@@ -76,14 +99,11 @@ 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 TirDataT) {
-            if (!(deconstructedCtorName === "Constr" // { index, fields, ...rest }
-                || deconstructedCtorName === "Map" // { map, ...rest }
-                || deconstructedCtorName === "List" // { list, ...rest }
-                || deconstructedCtorName === "B" // { bytes, ...rest }
-                || deconstructedCtorName === "I" // { int, ...rest }
-            ))
-                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, "data", deconstructedCtorName);
+        if (deconstructableType instanceof TirSoPStructType
+            || deconstructableType instanceof TirDataStructType) {
+            const ctorDef = deconstructableType.constructors.find(c => c.name === deconstructedCtorName);
+            if (!ctorDef)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
             const branchCtx = ctx.newBranchChildScope();
             const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
             if (!branchArg)
@@ -108,11 +128,14 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
                 return undefined;
             return new TirMatchStmtCase(branchArg, branchBody, matchCase.range);
         }
-        else if (deconstructableType instanceof TirSoPStructType
-            || deconstructableType instanceof TirDataStructType) {
-            const ctorDef = deconstructableType.constructors.find(c => c.name === deconstructedCtorName);
-            if (!ctorDef)
-                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
+        else if (deconstructableType instanceof TirDataT) {
+            if (!(deconstructedCtorName === "Constr" // { index, fields, ...rest }
+                || deconstructedCtorName === "Map" // { map, ...rest }
+                || deconstructedCtorName === "List" // { list, ...rest }
+                || deconstructedCtorName === "B" // { bytes, ...rest }
+                || deconstructedCtorName === "I" // { int, ...rest }
+            ))
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, "data", deconstructedCtorName);
             const branchCtx = ctx.newBranchChildScope();
             const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
             if (!branchArg)
@@ -179,4 +202,5 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
         );
         //*/
     }
+    throw new Error("unreachable::AstCompiler::_compileTirMatchStmtCase");
 }

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

@@ -3,6 +3,7 @@ import { isAssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStm
 import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
 import { BreakStmt } from "../../../../ast/nodes/statements/BreakStmt.js";
 import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
+import { isVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
 import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
 import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
 import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
@@ -37,6 +38,8 @@ import { _compileWhileStmt } from "./_compileWhileStmt.js";
 export function _compileStatement(ctx, stmt) {
     if (stmt instanceof IfStmt)
         return _compileIfStmt(ctx, stmt);
+    if (isVarDecl(stmt))
+        stmt = new VarStmt([stmt], stmt.range); // sometime these slip through
     if (stmt instanceof VarStmt)
         return _compileVarStmt(ctx, stmt);
     if (stmt instanceof ForStmt)
@@ -67,7 +70,7 @@ export function _compileStatement(ctx, stmt) {
     // if( stmt instanceof ExprStmt ) return _compileExprStmt( ctx, stmt );
     if (stmt instanceof UsingStmt)
         return _compileUsingStmt(ctx, stmt);
-    const tsEnsureExsautstiveCheck = stmt;
+    const tsEnsureExhautstiveCheck = stmt;
     console.error(stmt);
     throw new Error("unreachable::AstCompiler::_compileStatement");
 }

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

@@ -35,7 +35,7 @@ export function _compileVarDecl(ctx, decl, typeHint) {
         return _compileSingleDeconstructVarDecl(ctx, decl, typeHint);
     if (decl instanceof ArrayLikeDeconstr)
         return _compileArrayLikeDeconstr(ctx, decl, typeHint);
-    const tsEnsureExsautstiveCheck = decl;
+    const tsEnsureExhautstiveCheck = decl;
     console.error(decl);
     throw new Error("unreachable::AstCompiler::_compileVarDecl");
 }
@@ -176,7 +176,7 @@ export function _getVarDeclTypeAndExpr(ctx, decl, deconstructTypeHint) {
     //     //     stmtIdx
     //     // )
     // );
-    const typeHint = deconstructTypeHint ?? declarationType;
+    const typeHint = declarationType ?? deconstructTypeHint;
     // even in deconstructions
     // we allow for `as` type assertions
     // and we store the type to be converted to in the var decl type

package/dist/compiler/AstCompiler/internal/types/_compileDataEncodedConcreteType.js

@@ -55,7 +55,7 @@ export function _compileDataEncodedConcreteType(ctx, typeExpr, optionalsAsSop =
             return undefined;
         return ctx.program.types.get(possibleTirNames.dataTirName);
     }
-    const tsEnsureExsautstiveCheck = typeExpr;
+    const tsEnsureExhautstiveCheck = typeExpr;
     console.error(typeExpr);
     throw new Error("unreachable::AstCompiler::_compileDataEncodedConcreteType");
 }

package/dist/compiler/AstCompiler/internal/types/_compileSopEncodedConcreteType.js

@@ -52,8 +52,11 @@ export function _compileSopEncodedConcreteType(ctx, typeExpr) {
         if (typeof possibleTirNames.dataTirName !== "string")
             return undefined;
         return ctx.program.types.get(possibleTirNames.dataTirName);
+        // const result = ctx.program.types.get( possibleTirNames.dataTirName );
+        // console.log( "possibleTirNames", possibleTirNames, result );
+        // return result;
     }
-    const tsEnsureExsautstiveCheck = typeExpr;
+    const tsEnsureExhautstiveCheck = typeExpr;
     console.error(typeExpr);
     throw new Error("unreachable::AstCompiler::_compileSopEncodedConcreteType");
 }

package/dist/compiler/AstCompiler/scope/AstScope.js

@@ -99,7 +99,7 @@ export class AstScope {
             return false; // already defined
         this.types.set(name, {
             sopTirName: tirTypeKey,
-            dataTirName: allowsDataEncoding ? undefined : tirTypeKey,
+            dataTirName: allowsDataEncoding ? tirTypeKey : undefined,
             allTirNames: new Set([tirTypeKey]),
             methodsNames,
             isGeneric: false
@@ -107,8 +107,9 @@ export class AstScope {
         return true;
     }
     defineType(name, possibleTirTypes) {
-        if (this._isReadonly)
-            return false;
+        if (this._isReadonly) {
+            throw new Error("Cannot define type on readonly scope");
+        }
         if (invalidSymbolNames.has(name))
             return false;
         if (this.types.has(name))

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

@@ -60,6 +60,7 @@ function getListMethods(elemsType) {
     const mapReturnT = new TirTypeParam("T");
     return {
         length: new TirFuncT([], int_t),
+        isEmpty: new TirFuncT([], bool_t),
         show: new TirFuncT([], bytes_t),
         head: new TirFuncT([], elemsType),
         tail: new TirFuncT([], new TirListT(elemsType)),
@@ -79,7 +80,8 @@ function getListMethods(elemsType) {
         ], bool_t),
         some: new TirFuncT([
             new TirFuncT([elemsType], bool_t)
-        ], bool_t)
+        ], bool_t),
+        includes: new TirFuncT([elemsType], bool_t),
     };
 }
 function getLinearMapMethods(kT, vT) {
@@ -112,10 +114,10 @@ function findPropInImpls(ctx, methodsNamesPtr, propName) {
     const tirFuncName = methodsNamesPtr.get(propName);
     if (!tirFuncName)
         return undefined;
-    const funcInfos = ctx.program.functions.get(tirFuncName);
-    if (!funcInfos)
+    const funcExpr = ctx.program.functions.get(tirFuncName);
+    if (!funcExpr)
         return undefined;
-    const fullSig = funcInfos.sig();
+    const fullSig = funcExpr.sig();
     const methodSig = new TirFuncT(fullSig.argTypes.slice(1), fullSig.returnType);
     return methodSig;
 }

package/dist/compiler/Compiler.js

@@ -1,10 +1,11 @@
 import { compileUPLC, UPLCProgram } from "@harmoniclabs/uplc";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
-import { compileIRToUPLC } from "../IR/index.js";
 import { defaultOptions } from "../IR/toUPLC/CompilerOptions.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 { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
 export class Compiler extends DiagnosticEmitter {
     io;
     cfg;
@@ -37,6 +38,7 @@ export class Compiler extends DiagnosticEmitter {
         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();
         return;
     }
 }

package/dist/compiler/TirCompiler/compileTirProgram.js

@@ -13,6 +13,8 @@ export function compileTypedProgram(cfg, tirProgram) {
     );
     //*/
     const mainFuncExpr = tirProgram.getMainOrThrow();
-    void expressify(mainFuncExpr, undefined);
+    // console.log("main func expr:", mainFuncExpr.toString() );
+    void expressify(mainFuncExpr, undefined, // loopReplacements
+    tirProgram);
     return mainFuncExpr.toIR(ToIRTermCtx.root());
 }

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

@@ -9,6 +9,8 @@ import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirN
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirDataStructType } from "../../tir/types/TirStructType.js";
 import { TirType } from "../../tir/types/TirType.js";
+import { TypedProgram } from "../../tir/program/TypedProgram.js";
+import { TirVarDecl } from "../../tir/statements/TirVarDecl/TirVarDecl.js";
 /**
  * Static Single Assignment (SSA) variable name.
  *
@@ -29,6 +31,7 @@ export declare function isExpressifyFuncParam(thing: any): thing is ExpressifyFu
 export declare class ExpressifyCtx {
     readonly parent: ExpressifyCtx | undefined;
     returnType: TirType;
+    readonly program: TypedProgram;
     /** var name -> latest constant name */
     readonly variables: Map<string, LatestVarNameSSA>;
     /** constant name -> func param name (to build var access) */
@@ -38,7 +41,7 @@ export declare class ExpressifyCtx {
     /** var name -> prop name -> constant name (letted field extraction expr or var access for SoP)*/
     readonly properties: Map<string, Map<string, string>>;
     readonly hoisted: Map<string, TirHoistedExpr | TirNativeFunc>;
-    constructor(parent: ExpressifyCtx | undefined, returnType: TirType, hoisted?: Map<string, TirHoistedExpr | TirNativeFunc>, 
+    constructor(parent: ExpressifyCtx | undefined, returnType: TirType, program: TypedProgram, hoisted?: Map<string, TirHoistedExpr | TirNativeFunc>, 
     /** var name -> latest constant name */
     variables?: Map<string, LatestVarNameSSA>, 
     /** constant name -> func param name (to build var access) */
@@ -47,6 +50,7 @@ export declare class ExpressifyCtx {
     lettedConstants?: Map<string, TirLettedExpr>, 
     /** var name -> prop name -> constant name (letted field extraction expr or var access for SoP)*/
     properties?: Map<string, Map<string, string>>);
+    allVariables(): string[];
     newChild(): ExpressifyCtx;
     setNewVariableName(oldName: string, newName: string): void;
     setFuncParam(name: string, type: TirType): void;
@@ -67,6 +71,12 @@ export declare class ExpressifyCtx {
     introduceSopConstrFieldsAsProperties(sopName: string, destructuredPattern: TirNamedDeconstructVarDecl): void;
     introduceSopConstrFieldsAsParamsOnly(destructuredPattern: TirNamedDeconstructVarDecl): void;
     introduceSingleConstrDataLettedFields(varName: string, structExpr: TirExpr, structType: TirDataStructType): void;
-    introduceDeconstrDataLettedFields(stmt: TirNamedDeconstructVarDecl): TirAssertStmt[];
-    introduceArrayDeconstr(stmt: TirArrayLikeDeconstr, isDestructuredField?: boolean): TirAssertStmt[];
+    introduceDeconstrDataLettedFields(stmt: TirNamedDeconstructVarDecl, lettedInitExpr: TirLettedExpr): {
+        implicitAssertions: TirAssertStmt[];
+        nestedDeconstructs: TirVarDecl[];
+    };
+    introduceArrayDeconstr(stmt: TirArrayLikeDeconstr, isDestructuredField?: boolean): {
+        implicitAssertions: TirAssertStmt[];
+        nestedDeconstructs: TirVarDecl[];
+    };
 }

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

@@ -26,12 +26,13 @@ export function isExpressifyFuncParam(thing) {
 export class ExpressifyCtx {
     parent;
     returnType;
+    program;
     variables;
     funcParams;
     lettedConstants;
     properties;
     hoisted;
-    constructor(parent, returnType, hoisted, 
+    constructor(parent, returnType, program, hoisted, 
     /** var name -> latest constant name */
     variables = new Map(), 
     /** constant name -> func param name (to build var access) */
@@ -42,14 +43,22 @@ export class ExpressifyCtx {
     properties = new Map()) {
         this.parent = parent;
         this.returnType = returnType;
+        this.program = program;
         this.variables = variables;
         this.funcParams = funcParams;
         this.lettedConstants = lettedConstants;
         this.properties = properties;
         this.hoisted = hoisted ?? this.parent?.hoisted ?? new Map();
     }
+    allVariables() {
+        const thisVars = new Set([
+            ...this.variables.keys(),
+            ...this.lettedConstants.keys()
+        ]);
+        return (this.parent?.allVariables() ?? []).concat(...thisVars);
+    }
     newChild() {
-        return new ExpressifyCtx(this, this.returnType);
+        return new ExpressifyCtx(this, this.returnType, this.program);
     }
     setNewVariableName(oldName, newName) {
         let latestNameSSA = this.variables.get(oldName);
@@ -92,7 +101,7 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            console.log(this);
+            // console.log( this );
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;
@@ -130,7 +139,7 @@ export class ExpressifyCtx {
         if (constr.fields.length === 0)
             return; // no fields to extract
         const lettedRawFieldsName = getUniqueInternalName(`${varName}_fields`);
-        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), structExpr.range)], new TirListT(data_t), structExpr.range), structExpr.range);
+        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirLettedExpr(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), structExpr.range)], new TirListT(data_t), structExpr.range), structExpr.range), structExpr.range);
         const fieldsMap = new Map();
         for (let i = 0; i < constr.fields.length; i++) {
             const field = constr.fields[i];
@@ -150,36 +159,37 @@ export class ExpressifyCtx {
         }
         this.properties.set(varName, fieldsMap);
     }
-    introduceDeconstrDataLettedFields(stmt) {
+    introduceDeconstrDataLettedFields(stmt, lettedInitExpr) {
         const structType = stmt.type;
         if (!(stmt.initExpr))
             throw new Error("expected init expr in deconstruct data statement");
         if (!(structType instanceof TirDataStructType))
             throw new Error("expected data struct type in deconstruct data statement");
-        const varName = getUniqueInternalName(structType.toString().toLowerCase());
+        const varName = lettedInitExpr.varName ?? getUniqueInternalName(structType.toString().toLowerCase());
         const constrName = stmt.constrName;
         const constrIdx = structType.constructors.findIndex(c => c.name === constrName);
         if (constrIdx < 0)
             throw new Error(`constructor ${constrName} not found in data struct ${structType.name}`);
         const constr = structType.constructors[constrIdx];
         if (constr.fields.length === 0)
-            return []; // no fields to extract, no assertions
-        const structExpr = stmt.initExpr;
+            return { implicitAssertions: [], nestedDeconstructs: [] }; // no fields to extract, no assertions
+        const structExpr = lettedInitExpr ?? stmt.initExpr;
         const lettedUnconstrName = getUniqueInternalName(`${varName}_unconstrPair`);
-        const lettedUnconstr = this.introduceLettedConstant(lettedUnconstrName, new TirCallExpr(TirNativeFunc.unBData, [stmt.initExpr], new TirUnConstrDataResultT(), stmt.range), stmt.range);
+        const lettedUnconstr = this.introduceLettedConstant(lettedUnconstrName, new TirCallExpr(TirNativeFunc.unConstrData, [structExpr], new TirUnConstrDataResultT(), stmt.range), stmt.range);
         const assertions = [];
-        if (structType.constructors.length > 0)
+        const nestedDeconstructs = [];
+        if (structType.constructors.length > 1)
             assertions.push(new TirAssertStmt(new TirEqualExpr(new TirCallExpr(TirNativeFunc.unConstrDataResultIndex, [lettedUnconstr], int_t, stmt.range), new TirLitIntExpr(BigInt(constrIdx), stmt.range), stmt.range), undefined, // no trace message
             stmt.range));
         const lettedRawFieldsName = getUniqueInternalName(`${varName}_fields`);
-        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [lettedUnconstr], new TirListT(data_t), stmt.range), stmt.range);
+        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirLettedExpr(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [lettedUnconstr], new TirListT(data_t), stmt.range), stmt.range), stmt.range);
         const fieldsToIntroduce = [...stmt.fields.keys()];
         const hasRest = typeof stmt.rest === "string";
         const fieldsMap = new Map();
         for (let i = 0; i < constr.fields.length; i++) {
             const field = constr.fields[i];
             const fieldName = field.name;
-            const fieldType = field.type;
+            let fieldType = field.type;
             const isFieldToIntroduce = fieldsToIntroduce.includes(fieldName);
             if (!hasRest && !isFieldToIntroduce)
                 continue; // skip unused field
@@ -198,32 +208,18 @@ export class ExpressifyCtx {
             if (fieldVarDecl instanceof TirSimpleVarDecl) {
                 this.variables.set(fieldVarDecl.name, { latestName: lettedField.varName });
             }
-            // data structs cannot have sop-encoded fields (thanks god)
-            // recursively introduce letted fields for nested single-constructor data structs
-            if (!(fieldType instanceof TirDataStructType))
-                continue;
-            // if the field is simply introduced but still a single constr struct
-            // we need to introduce its fields as well
-            if (fieldVarDecl instanceof TirSimpleVarDecl
-                && fieldType.constructors.length === 1) {
-                this.introduceSingleConstrDataLettedFields(fieldVarName, lettedField, fieldType);
-            }
-            else if (fieldVarDecl instanceof TirNamedDeconstructVarDecl
-                || fieldVarDecl instanceof TirSingleDeconstructVarDecl) {
-                // if the field is destructured, we need to introduce its fields as well
-                const namedVarDecl = toNamedDeconstructVarDecl(fieldVarDecl);
-                namedVarDecl.initExpr = lettedField;
-                assertions.push(...this.introduceDeconstrDataLettedFields(namedVarDecl));
-            }
-            else if (fieldVarDecl instanceof TirArrayLikeDeconstr) {
+            else {
+                // fieldVarDecl.type ??= fieldType;
                 fieldVarDecl.initExpr = lettedField;
-                assertions.push(...this.introduceArrayDeconstr(fieldVarDecl, true // is destructured field
-                ));
+                nestedDeconstructs.push(fieldVarDecl);
             }
         }
         if (hasRest)
             this.properties.set(stmt.rest, fieldsMap);
-        return assertions;
+        return {
+            implicitAssertions: assertions,
+            nestedDeconstructs
+        };
     }
     introduceArrayDeconstr(stmt, isDestructuredField = false) {
         if (!(stmt.initExpr))
@@ -240,6 +236,7 @@ export class ExpressifyCtx {
             lettedArrayExpr = this.introduceLettedConstant(lettedArrayName, stmt.initExpr, stmt.range);
         }
         const assertions = [];
+        const nestedDeconstructs = [];
         const nElems = stmt.elements.length;
         for (let i = 0; i < nElems; i++) {
             const elemVarDecl = stmt.elements[i];
@@ -261,12 +258,16 @@ export class ExpressifyCtx {
                 || elemVarDecl instanceof TirSingleDeconstructVarDecl) {
                 const namedVarDecl = toNamedDeconstructVarDecl(elemVarDecl);
                 namedVarDecl.initExpr = lettedElem;
-                assertions.push(...this.introduceDeconstrDataLettedFields(namedVarDecl));
+                const introduceFieldsResult = this.introduceDeconstrDataLettedFields(namedVarDecl, lettedElem);
+                assertions.push(...introduceFieldsResult.implicitAssertions);
+                nestedDeconstructs.push(...introduceFieldsResult.nestedDeconstructs);
             }
             else if (elemVarDecl instanceof TirArrayLikeDeconstr) {
                 elemVarDecl.initExpr = lettedElem;
-                assertions.push(...this.introduceArrayDeconstr(elemVarDecl, true // is destructured field
-                ));
+                const introduceFieldsResult = this.introduceArrayDeconstr(elemVarDecl, true // is destructured field
+                );
+                assertions.push(...introduceFieldsResult.implicitAssertions);
+                nestedDeconstructs.push(...introduceFieldsResult.nestedDeconstructs);
             }
         }
         if (stmt.rest) {
@@ -277,6 +278,9 @@ export class ExpressifyCtx {
                 lettedArrayExpr
             ], new TirListT(elemsType), stmt.range), stmt.range);
         }
-        return assertions;
+        return {
+            implicitAssertions: assertions,
+            nestedDeconstructs
+        };
     }
 }