@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -11,6 +11,7 @@ import { TernaryExpr } from "../../../../ast/nodes/expr/TernaryExpr.js";
 import { TypeConversionExpr } from "../../../../ast/nodes/expr/TypeConversionExpr.js";
 import { NonNullExpr } from "../../../../ast/nodes/expr/unary/NonNullExpr.js";
 import { isUnaryPrefixExpr } from "../../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
+import { isTirExpr } from "../../../tir/expressions/TirExpr.js";
 import { _compileBinaryExpr } from "./_compileBinaryExpr.js";
 import { _compileCallExpr } from "./_compileCallExpr.js";
 import { _compileCaseExpr } from "./_compileCaseExpr.js";
@@ -41,6 +42,9 @@ export function _compileExpr(ctx, expr,
  * if that is the case, it needs to be checked OUTSIDE this function
 **/
 typeHint) {
+    // already compiled (TODO: how did we get here?)
+    if (isTirExpr(expr))
+        return expr;
     if (expr instanceof Identifier)
         return _compileVarAccessExpr(ctx, expr, typeHint);
     if (isUnaryPrefixExpr(expr))
@@ -71,7 +75,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/_compileFuncExpr.js

@@ -77,7 +77,7 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     // if( _hasDuplicateTypeParams( ctx, expr.typeParams ) ) return undefined;
     if (expr.typeParams.length > 0)
         return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
-    const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr);
+    const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr, expectedFuncType);
     if (!destructuredParamsResult)
         return undefined;
     const { blockInitStmts, params } = destructuredParamsResult;
@@ -91,11 +91,14 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
     return funcExpr;
 }
-function _getDestructuredParamsAsVarDecls(funcCtx, expr) {
+function _getDestructuredParamsAsVarDecls(funcCtx, expr, expectedFuncType) {
     const blockInitStmts = [];
     const params = [];
-    for (const astParam of expr.signature.params) {
-        const tirParam = _compileVarDecl(funcCtx, astParam, undefined);
+    const nParams = expr.signature.params.length;
+    for (let i = 0; i < nParams; i++) {
+        const astParam = expr.signature.params[i];
+        const paramTypeHint = expectedFuncType.argTypes[i];
+        const tirParam = _compileVarDecl(funcCtx, astParam, paramTypeHint);
         if (!tirParam)
             return undefined;
         if (tirParam instanceof TirSimpleVarDecl) {

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,9 @@ 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) {
         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/exprs/_compileVarAccessExpr.js

@@ -2,8 +2,10 @@ import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.gener
 import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
 export function _compileVarAccessExpr(ctx, expr, typeHint) {
     const resolvedValue = ctx.scope.resolveValue(expr.text);
-    if (!resolvedValue)
+    if (!resolvedValue) {
+        console.trace(ctx.scope.allVariables(), expr.text);
         return ctx.error(DiagnosticCode._0_is_not_defined, expr.range, expr.text);
+    }
     // const { variableInfos, isDefinedOutsideFuncScope } = resolvedValue;
     return new TirVariableAccessExpr(resolvedValue, expr.range);
 }

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

@@ -20,9 +20,9 @@ export function _compileAssignmentStmt(ctx, stmt) {
         if (!canAssignTo(varType, int_t))
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.varIdentifier.range, varType.toString(), int_t.toString());
         const varAccessExpr = new TirVariableAccessExpr(resolvedValue, stmt.varIdentifier.range);
-        return ([new TirAssignmentStmt(varAccessExpr, stmt instanceof IncrStmt ?
-                new TirAddExpr(varAccessExpr, new TirLitIntExpr(BigInt(1), stmt.range), stmt.range) :
-                new TirSubExpr(varAccessExpr, new TirLitIntExpr(BigInt(1), stmt.range), stmt.range), stmt.range)]);
+        return ([new TirAssignmentStmt(varAccessExpr.clone(), stmt instanceof IncrStmt ?
+                new TirAddExpr(varAccessExpr.clone(), new TirLitIntExpr(BigInt(1), stmt.range), stmt.range) :
+                new TirSubExpr(varAccessExpr.clone(), new TirLitIntExpr(BigInt(1), stmt.range), stmt.range), stmt.range)]);
     }
     if (isExplicitAssignmentStmt(stmt)) {
         const tirStmt = _compileExplicitAssignmentStmt(ctx, stmt);
@@ -31,7 +31,7 @@ export function _compileAssignmentStmt(ctx, stmt) {
         return [tirStmt];
     }
     else {
-        const tsEnsureExsautstiveCheck = stmt;
+        // const tsEnsureExhautstiveCheck: never = stmt;
         console.error(stmt);
         throw new Error("unreachable::AstCompiler::_compileForUpdateStmts");
     }
@@ -61,13 +61,13 @@ export function _compileExplicitAssignmentStmt(ctx, stmt) {
         expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
         if (!expr)
             return undefined;
-        expr = new TirAddExpr(varAccessExpr, expr, stmt.range);
+        expr = new TirAddExpr(varAccessExpr.clone(), expr.clone(), stmt.range);
     }
     else if (stmt instanceof SubAssignmentStmt) {
         expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
         if (!expr)
             return undefined;
-        expr = new TirSubExpr(varAccessExpr, expr, stmt.range);
+        expr = new TirSubExpr(varAccessExpr.clone(), expr.clone(), stmt.range);
     }
     else if (stmt instanceof ExpAssignmentStmt) {
         expr = __getBinOpAssignmentLeftArg(ctx, stmt, varType, int_t);
@@ -136,11 +136,11 @@ 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");
     }
-    return new TirAssignmentStmt(varAccessExpr, expr, stmt.range);
+    return new TirAssignmentStmt(varAccessExpr.clone(), expr, stmt.range);
 }
 export function __getBinOpAssignmentLeftArg(ctx, stmt, varType, exprType) {
     if (!canAssignTo(varType, exprType))

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.d.ts

@@ -10,13 +10,14 @@ import { SourceRange } from "../../../../ast/Source/SourceRange.js";
 import { TirExpr } from "../../../tir/expressions/TirExpr.js";
 import { TirArrayLikeDeconstr } from "../../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
 import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirVarDecl } from "../../../tir/statements/TirVarDecl/TirVarDecl.js";
 import { TirStructConstr } from "../../../tir/types/TirStructType.js";
 import { TirType } from "../../../tir/types/TirType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 export declare function _compileVarStmt(ctx: AstCompilationCtx, stmt: VarStmt): TirVarDecl[] | undefined;
 export declare function _compileVarDecl(ctx: AstCompilationCtx, decl: VarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
-export declare function _compileSimpleVarDecl(ctx: AstCompilationCtx, decl: SimpleVarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
+export declare function _compileSimpleVarDecl(ctx: AstCompilationCtx, decl: SimpleVarDecl, typeHint: TirType | undefined): TirSimpleVarDecl | undefined;
 export declare function _compileNamedDeconstructVarDecl(ctx: AstCompilationCtx, decl: NamedDeconstructVarDecl, typeHint: TirType | undefined): TirNamedDeconstructVarDecl | undefined;
 export declare function _compileSingleDeconstructVarDecl(ctx: AstCompilationCtx, decl: SingleDeconstructVarDecl, typeHint: TirType | undefined): TirVarDecl | undefined;
 export declare function _compileArrayLikeDeconstr(ctx: AstCompilationCtx, decl: ArrayLikeDeconstr, typeHint: TirType | undefined): TirArrayLikeDeconstr | undefined;

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

@@ -27,15 +27,16 @@ export function _compileVarStmt(ctx, stmt) {
     return tirVarDecls;
 }
 export function _compileVarDecl(ctx, decl, typeHint) {
-    if (decl instanceof SimpleVarDecl)
+    if (decl instanceof SimpleVarDecl) {
         return _compileSimpleVarDecl(ctx, decl, typeHint);
+    }
     if (decl instanceof NamedDeconstructVarDecl)
         return _compileNamedDeconstructVarDecl(ctx, decl, typeHint);
     if (decl instanceof SingleDeconstructVarDecl)
         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 +177,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.d.ts

@@ -80,6 +80,7 @@ export declare class AstScope {
     constructor(parent: AstScope | undefined, program: TypedProgram, infos: Partial<ScopeInfos>);
     defineValue(valueInfos: IVariableInfos): boolean;
     resolveValue(name: string): ResolveValueResult | undefined;
+    allVariables(): string[];
     defineUnambigousType(name: string, tirTypeKey: string, allowsDataEncoding: boolean, methodsNames: Map<AstFuncName, TirFuncName>): boolean;
     defineType(name: string, possibleTirTypes: PossibleTirTypes): boolean;
     resolveLocalType(name: string): PossibleTirTypes | undefined;

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

@@ -62,6 +62,8 @@ export class AstScope {
         this.parent = parent;
     }
     defineValue(valueInfos) {
+        if (valueInfos.name === "§tx_3")
+            console.log("Defining variable tx3");
         if (this._isReadonly)
             return false;
         if (invalidSymbolNames.has(valueInfos.name)
@@ -90,6 +92,9 @@ export class AstScope {
         }
         return undefined;
     }
+    allVariables() {
+        return (this.parent?.allVariables() ?? []).concat(Array.from(this.variables.keys()));
+    }
     defineUnambigousType(name, tirTypeKey, allowsDataEncoding, methodsNames) {
         if (this._isReadonly)
             return false;
@@ -99,7 +104,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 +112,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;
@@ -12,6 +13,9 @@ export class Compiler extends DiagnosticEmitter {
         super(diagnostics);
         this.io = io;
         this.cfg = cfg;
+        if (cfg.silent === true) {
+            this.io.stdout = { write() { } };
+        }
     }
     async compile(config) {
         const cfg = {
@@ -30,6 +34,7 @@ export class Compiler extends DiagnosticEmitter {
             }
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
+        // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir);
         const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
@@ -37,6 +42,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,9 @@ export function compileTypedProgram(cfg, tirProgram) {
     );
     //*/
     const mainFuncExpr = tirProgram.getMainOrThrow();
-    void expressify(mainFuncExpr, undefined);
+    // console.log("main func:", mainFuncExpr.pretty() );
+    void expressify(mainFuncExpr, undefined, // loopReplacements
+    tirProgram);
+    // console.log("main func expressified:", mainFuncExpr.pretty() );
     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,16 +31,17 @@ 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>;
+    private readonly variables;
     /** constant name -> func param name (to build var access) */
     readonly funcParams: Map<string, ExpressifyFuncParam>;
     /** constant name -> letted expr */
-    readonly lettedConstants: Map<string, TirLettedExpr>;
+    private readonly lettedConstants;
     /** 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,8 @@ 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>>);
+    allVariablesNoLetted(): string[];
+    allVariables(): string[];
     newChild(): ExpressifyCtx;
     setNewVariableName(oldName: string, newName: string): void;
     setFuncParam(name: string, type: TirType): void;
@@ -62,11 +67,18 @@ export declare class ExpressifyCtx {
      */
     private _getNonHoistedVariable;
     getVariable(name: string): ExpressifyFuncParam | TirHoistedExpr | TirNativeFunc | TirLettedExpr;
+    getVariableSSA(name: string): LatestVarNameSSA | undefined;
     introduceFuncParams(params: readonly TirSimpleVarDecl[]): void;
     introduceLettedConstant(name: string, lettedExpr: TirExpr, declRange: SourceRange): TirLettedExpr;
     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[];
+    };
 }