@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev7

package/dist/IR/IRNodes/IRNative/IRNativeTag.d.ts

@@ -131,6 +131,8 @@ export declare enum IRNativeTag {
     _exponentiateInteger = -40,
     _amountOfValue = -41,
     _isZero = -42,
-    _sortedValueLovelaces = -43
+    _sortedValueLovelaces = -43,
+    _getCredentialsHash = -44,
+    _findSopOptional = -45
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

package/dist/IR/IRNodes/IRNative/IRNativeTag.js

@@ -154,6 +154,8 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_amountOfValue"] = -41] = "_amountOfValue";
     IRNativeTag[IRNativeTag["_isZero"] = -42] = "_isZero";
     IRNativeTag[IRNativeTag["_sortedValueLovelaces"] = -43] = "_sortedValueLovelaces";
+    IRNativeTag[IRNativeTag["_getCredentialsHash"] = -44] = "_getCredentialsHash";
+    IRNativeTag[IRNativeTag["_findSopOptional"] = -45] = "_findSopOptional";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
@@ -164,6 +166,7 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._foldr: return "foldr";
         case IRNativeTag._foldl: return "foldl";
         case IRNativeTag._mkFindDataOptional: return "mkFind";
+        case IRNativeTag._findSopOptional: return "findSopOptional";
         case IRNativeTag._length: return "length";
         case IRNativeTag._some: return "some";
         case IRNativeTag._every: return "every";
@@ -195,6 +198,7 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._amountOfValue: return "amountOfValue";
         case IRNativeTag._isZero: return "isZero";
         case IRNativeTag._sortedValueLovelaces: return "sortedValueLovelaces";
+        case IRNativeTag._getCredentialsHash: return "getCredentialHash";
         default: return "";
     }
 }

package/dist/IR/IRNodes/IRNative/index.d.ts

@@ -161,6 +161,7 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _exponentiateInteger(): IRNative;
     static get _amountOfValue(): IRNative;
     static get _sortedValueLovelaces(): IRNative;
+    static get _getCredentialsHash(): IRNative;
     static equals(type: TirType): IRTerm;
     static equalListOf(type: TirType): IRHoisted;
 }

package/dist/IR/IRNodes/IRNative/index.js

@@ -216,6 +216,7 @@ export class IRNative {
     static get _exponentiateInteger() { return new IRNative(IRNativeTag._exponentiateInteger); }
     static get _amountOfValue() { return new IRNative(IRNativeTag._amountOfValue); }
     static get _sortedValueLovelaces() { return new IRNative(IRNativeTag._sortedValueLovelaces); }
+    static get _getCredentialsHash() { return new IRNative(IRNativeTag._getCredentialsHash); }
     static equals(type) {
         type = getUnaliased(type);
         if (type instanceof TirAliasType)

package/dist/IR/toUPLC/CompilerOptions.d.ts

@@ -33,6 +33,10 @@ export interface CompilerOptions {
      * path to the output directory
      */
     readonly outDir: string;
+    /**
+     * if `true` silences all compiler output
+     */
+    readonly silent: boolean;
     /**
      * uplc version (encoded in the script)
      */
@@ -76,5 +80,6 @@ export declare const extremeOptions: CompilerOptions;
 export declare const productionOptions: CompilerOptions;
 export declare const debugOptions: CompilerOptions;
 export declare const defaultOptions: CompilerOptions;
+export declare const testOptions: CompilerOptions;
 export declare const defulatCompilerOptions: CompilerOptions;
 export declare function completeCompilerOptions(options: Partial<CompilerOptions>, complete?: CompilerOptions): CompilerOptions;

package/dist/IR/toUPLC/CompilerOptions.js

@@ -36,6 +36,7 @@ export const extremeOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -46,6 +47,7 @@ export const productionOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -56,13 +58,20 @@ export const debugOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: false,
     delayHoists: false,
     uplcOptimizations: debugUplcOptimizations,
     addMarker: false
 });
-export const defaultOptions = productionOptions;
+export const defaultOptions = Object.freeze({
+    ...productionOptions,
+});
+export const testOptions = Object.freeze({
+    ...debugOptions,
+    silent: true
+});
 export const defulatCompilerOptions = defaultOptions;
 export function completeCompilerOptions(options, complete = defaultOptions) {
     let targetUplcVersion = options.targetUplcVersion instanceof UPLCVersion ? complete.targetUplcVersion : defaultUplcVersion;

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -165,7 +165,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // const srcmap = {};
     const uplc = term.toUPLC(ToUplcCtx.root());
     if (!isClosedTerm(uplc)) {
-        console.log(prettyUPLC(uplc));
+        console.error(prettyUPLC(uplc));
         throw new Error("compileIRToUPLC: final UPLC term is not closed:\n" +
             "This is a compiler internal error; please open an issue on github so we can fix this.");
     }

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -26,18 +26,10 @@ export class ToUplcCtx {
         const ctx = this.ctxMap.get(sym);
         const idx = ctx?._variables.indexOf(sym) ?? -1;
         if (idx <= -1) {
-            console.log(sym, ctx?.allVars());
+            console.error(sym, ctx?.allVars());
             throw new Error("Variable not found in its defining context");
         }
-        const declDbn = ctx._parentDbn + idx + 1;
-        if (declDbn === 5
-            && sym.description === "tailList") {
-            console.log({
-                ctxDbn: ctx.dbn,
-                idx
-            });
-        }
-        return declDbn;
+        return ctx._parentDbn + idx + 1;
     }
     getVarAccessDbn(sym) {
         const declDbn = this.getVarDeclDbn(sym);

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.js

@@ -65,8 +65,6 @@ export function getUnboundedIRVars(term) {
         }
         stack.push(...t.children());
     }
-    console.log("accessedVars", [...new Set(accessedVars.keys())]);
-    console.log("boundedVars", [...boundedVars]);
     for (const v of boundedVars)
         accessedVars.delete(v);
     return [...accessedVars.values()].flat();

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -22,6 +22,7 @@ export declare const hoisted_sub4: IRHoisted;
 export declare const hoisted_length: IRHoisted;
 export declare const hoisted_dropList: IRHoisted;
 export declare const hoisted_sizeofPositiveInt: IRHoisted;
+export declare const hoisted_findSopOptional: IRHoisted;
 export declare const hoisted_mkFindDataOptional: IRHoisted;
 export declare const hoisted_strictAnd: IRHoisted;
 export declare const hoisted_strictOr: IRHoisted;
@@ -42,5 +43,6 @@ export declare const hoisted_exponentiateInteger: IRHoisted;
 export declare function nativeToIR(native: IRNative): IRTerm;
 export declare const hoisted_mkEqualsList: IRHoisted;
 export declare const hoisted_mkMapList: IRHoisted;
+export declare const hoisted_getCredentialsHash: IRHoisted;
 export declare const hoisted_sortedValueLovelaces: IRHoisted;
 export declare const hoisted_amountOfValue: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -16,6 +16,7 @@ import { _ir_let } from "../../../tree_utils/_ir_let.js";
 import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
 import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
+import { IRConstr } from "../../../IRNodes/index.js";
 function _ir_strictAnd(left, right) {
     return _ir_apps(IRNative.strictIfThenElse, left, right, IRConst.bool(false));
 }
@@ -106,6 +107,22 @@ const foldl_head = Symbol("head");
 const foldl_tail = Symbol("tail");
 const hoiseted_foldl = new IRHoisted(new IRFunc([foldl_reduce], new IRRecursive(foldl_self, new IRFunc([foldl_acc], _ir_apps(hoisted_matchList.clone(), new IRDelayed(new IRVar(foldl_acc)), new IRFunc([foldl_head, foldl_tail], _ir_apps(new IRSelfCall(foldl_self), _ir_apps(new IRVar(foldl_reduce), new IRVar(foldl_acc), new IRVar(foldl_head)), new IRVar(foldl_tail))))))));
 hoiseted_foldl.hash;
+// hoisted _findSopOptional
+// (predicate: (a -> Bool)) -> (list: [a]) -> Optional<a>
+const findSop_predicate = Symbol("predicate");
+const findSop_self = Symbol("findOpt_self");
+const findSop_list = Symbol("list");
+const findSop_head = Symbol("head");
+export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predicate], new IRRecursive(findSop_self, new IRFunc([findSop_list], _ir_lazyChooseList(new IRVar(findSop_list), 
+// case nil
+new IRConstr(1, []), // None
+// case cons
+new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
+// then => Some(head)
+new IRConstr(1, [new IRVar(findSop_head)]), // Some{ head }
+// else => self(tail)
+_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))))))));
+hoisted_findSopOptional.hash;
 // hoisted _mkFindDataOptional
 const mkFind_elemToData = Symbol("elemToData");
 const mkFind_pred = Symbol("predicate");
@@ -195,6 +212,7 @@ export function nativeToIR(native) {
         case IRNativeTag._foldr: return hoisted_foldr.clone();
         case IRNativeTag._foldl: return hoiseted_foldl.clone();
         case IRNativeTag._mkFindDataOptional: return hoisted_mkFindDataOptional.clone();
+        case IRNativeTag._findSopOptional: return hoisted_findSopOptional.clone();
         case IRNativeTag._length: return hoisted_length.clone();
         case IRNativeTag._some: return hoisted_some.clone();
         case IRNativeTag._every: return hoisted_every.clone();
@@ -217,7 +235,8 @@ export function nativeToIR(native) {
         case IRNativeTag._exponentiateInteger: return hoisted_exponentiateInteger.clone();
         case IRNativeTag._amountOfValue: return hoisted_amountOfValue.clone();
         case IRNativeTag._isZero: return hoisted_isZero.clone();
-        case IRNativeTag._sortedValueLovelaces: return hoisted_sortedValueLovelaces.clone?.() ?? (() => { throw new Error("_sortedValueLovelaces hoisted const missing"); })();
+        case IRNativeTag._sortedValueLovelaces: return hoisted_sortedValueLovelaces.clone();
+        case IRNativeTag._getCredentialsHash: return hoisted_getCredentialsHash.clone();
         case IRNativeTag._dropList: return hoisted_dropList.clone();
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
@@ -256,6 +275,9 @@ _ir_apps(new IRVar(mkMap_mapFunc), new IRApp(IRNative.headList, new IRVar(mkMap_
 // recurse tail
 _ir_apps(new IRSelfCall(mkMap_map), new IRApp(IRNative.tailList, new IRVar(mkMap_list)))))))));
 hoisted_mkMapList.hash;
+const credHash_credentials = Symbol("credentials");
+export const hoisted_getCredentialsHash = new IRHoisted(new IRFunc([credHash_credentials], _ir_apps(IRNative.unBData, _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, new IRVar(credHash_credentials)))))));
+hoisted_getCredentialsHash.hash;
 // If _sortedValueLovelaces was previously inline, hoist it:
 const sorted_value = Symbol("value");
 export const hoisted_sortedValueLovelaces = new IRHoisted(new IRFunc([sorted_value], _ir_apps(IRNative.unIData, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.headList, _ir_apps(IRNative.unMapData, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.headList, new IRVar(sorted_value)))))))));

package/dist/IR/utils/isClosedIRTerm.js

@@ -54,7 +54,7 @@ function _isClosedIRTerm(term, boundedVars, parent) {
         return _isClosedIRTerm(term.delayed, boundedVars, term);
     const tsEnsureExhaustiveCheck = term;
     // not even an IRTerm
-    console.log(parent);
+    console.error(parent);
     throw new Error("`isClosedIRTerm` called on non-IR argument");
 }
 export function isClosedIRTerm(term) {

package/dist/IR/utils/positiveIntAsBytes.js

@@ -8,8 +8,6 @@ export function positiveIntAsBytes(n) {
         return positiveBigIntAsBytes(n);
     }
     if (!Number.isSafeInteger(n) || n < 0) {
-        console.log(n);
-        console.trace(); // some help
         throw new Error("how did you end up here? the name of the function explicitly says 'positiveIntAsBytes'");
     }
     let str = n.toString(16);
@@ -18,8 +16,6 @@ export function positiveIntAsBytes(n) {
 }
 export function positiveBigIntAsBytes(n) {
     if (n < 0 || typeof n !== "bigint") {
-        console.log(n);
-        console.trace(); // some help
         throw new Error("how did you end up here? the name of the function explicitly says 'positiveBigIntAsBytes'");
     }
     let strHex = n.toString(16);

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -56,6 +56,7 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _compileParsedSource;
     private _collectAllTopLevelSignatures;
     private _collectInterfaceImplSigs;
+    private _collectTopLevelConst;
     private _collectTopLevelFuncDeclSig;
     private _collectInterfaceDeclarations;
     registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl): void;

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -33,6 +33,8 @@ import { _compileFuncExpr } from "./internal/exprs/_compileFuncExpr.js";
 import { ContractDecl } from "../../ast/nodes/statements/declarations/ContractDecl.js";
 import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContractBody.js";
 import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
+import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
+import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -167,7 +169,7 @@ export class AstCompiler extends DiagnosticEmitter {
         this._srcDonelogUids.add(src.uid);
     }
     _collectAllTopLevelSignatures(stmts, srcUid, topLevelScope, srcExports, isEntryFile = false) {
-        for (let i = 0; i < stmts.length; i++) {
+        top_level_stmts_iter: for (let i = 0; i < stmts.length; i++) {
             let stmt = stmts[i];
             let exported = false;
             let exportRange = undefined;
@@ -178,8 +180,28 @@ export class AstCompiler extends DiagnosticEmitter {
             }
             if (!(stmt instanceof FuncDecl
                 || stmt instanceof TypeImplementsStmt
-                || stmt instanceof ContractDecl))
+                || stmt instanceof ContractDecl
+                || stmt instanceof VarStmt))
+                continue;
+            if (stmt instanceof VarStmt) {
+                const nDecl = stmt.declarations.length;
+                for (let dI = 0; dI < nDecl; dI++) {
+                    const decl = stmt.declarations[dI];
+                    if (!(decl.isConst()
+                        && decl instanceof SimpleVarDecl)) {
+                        this.error(DiagnosticCode.Only_constants_can_be_declared_outside_of_a_function, stmt.range);
+                        // remove from array so we don't process it again
+                        void stmts.splice(i, 1);
+                        i--;
+                        continue top_level_stmts_iter;
+                    }
+                    this._collectTopLevelConst(decl, srcUid, topLevelScope, srcExports, exportRange, isEntryFile);
+                }
+                // remove from array so we don't process it again
+                void stmts.splice(i, 1);
+                i--;
                 continue;
+            }
             if (exported && stmt instanceof TypeImplementsStmt)
                 this.error(DiagnosticCode.Interface_implementations_cannot_be_exported, exportRange ?? stmt.range);
             if (stmt instanceof ContractDecl) {
@@ -259,6 +281,21 @@ export class AstCompiler extends DiagnosticEmitter {
             this.program.functions.set(tirMethodName, funcExpr);
         }
     }
+    _collectTopLevelConst(decl, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isEntryFile = false) {
+        const astName = decl.name.text;
+        // const tirConstName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astName + "_" + srcUid;
+        const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
+        const tirVarDecl = _compileSimpleVarDecl(declContext, decl, undefined // type hint (extracted from init expr if explicit, or inferred from expression)
+        );
+        if (!tirVarDecl)
+            return undefined;
+        if (!tirVarDecl.initExpr)
+            return this.error(DiagnosticCode._const_declarations_must_be_initialized, tirVarDecl.range);
+        if (this.program.constants.has(astName)) {
+            throw new Error("not_implemented::AstCompiler::_collectTopLevelConst::const_redefinition_check");
+        }
+        this.program.constants.set(astName, tirVarDecl);
+    }
     _collectTopLevelFuncDeclSig(stmt, srcUid, topLevelScope, srcExports = undefined, exportRange = undefined, isEntryFile = false) {
         const astFuncExpr = stmt.expr;
         const astFuncName = astFuncExpr.name.text;

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -739,7 +739,7 @@ function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalN
         return expr;
     }
     const tsEnsureExhaustiveCheck = expr;
-    console.log(expr);
+    console.error(expr);
     throw new Error("unreachable::_exprReplaceParamsAndAssertNoLitContext");
 }
 function _deriveRedeemerTypeDef(redeemerName, methods, contractRange) {

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))

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/_compileTypeConversionExpr.js

@@ -7,7 +7,6 @@ export function _compileTypeConversionExpr(ctx, ast, typeHint) {
     const data_t = ctx.program.stdTypes.data;
     const possibleTargetTypeTirNames = ctx.scope.resolveType(ast.asType.toAstName());
     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);

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 tsEnsureExhautstiveCheck = 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);
@@ -140,7 +140,7 @@ export function _compileExplicitAssignmentStmt(ctx, 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/_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,8 +27,9 @@ 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)

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;

package/dist/compiler/Compiler.js

@@ -13,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 = {
@@ -31,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;

package/dist/compiler/TirCompiler/compileTirProgram.js

@@ -13,8 +13,9 @@ export function compileTypedProgram(cfg, tirProgram) {
     );
     //*/
     const mainFuncExpr = tirProgram.getMainOrThrow();
-    // console.log("main func expr:", mainFuncExpr.toString() );
+    // 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

@@ -33,11 +33,11 @@ export declare class ExpressifyCtx {
     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>;
@@ -50,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>>);
+    allVariablesNoLetted(): string[];
     allVariables(): string[];
     newChild(): ExpressifyCtx;
     setNewVariableName(oldName: string, newName: string): void;
@@ -66,6 +67,7 @@ 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;