@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev8

package/dist/IR/toUPLC/subRoutines/rewriteNativesAppliedToConstantsAndReturnRoot.js

@@ -1,3 +1,5 @@
+import { TirBoolT, TirIntT } from "../../../compiler/tir/types/TirNativeType/index.js";
+import { equalIrHash } from "../../IRHash.js";
 import { _ir_apps } from "../../IRNodes/IRApp.js";
 import { IRConst } from "../../IRNodes/IRConst.js";
 import { IRFunc } from "../../IRNodes/IRFunc.js";
@@ -9,13 +11,25 @@ import { IRVar } from "../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 import { getApplicationTerms } from "../utils/getApplicationTerms.js";
 import { _compTimeDropN } from "./_comptimeDropN.js";
+import { hoisted_isZero, hoisted_length, hoisted_not } from "./replaceNatives/nativeToIR.js";
 export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
     // traverse the tree, find applications of natives to constants
     // and replace them with the optimized equivalent
     const stack = [term];
+    function modifyTermAndPushToReprocess(current, newTerm) {
+        const parent = current.parent;
+        if (parent) {
+            _modifyChildFromTo(parent, current, newTerm);
+        }
+        else {
+            term = newTerm;
+            term.parent = undefined;
+        }
+        stack.unshift(newTerm); // reprocess new term for further optimizations (if any)
+    }
     while (stack.length > 0) {
         const current = stack.pop();
-        const parent = current.parent;
+        // const parent = current.parent;
         const appTerms = getApplicationTerms(current);
         if (!appTerms) {
             stack.unshift(...current.children());
@@ -25,16 +39,196 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
         const [fstArg, ...restArgs] = args;
         if (isId(func)
             && restArgs.length === 0) {
-            if (parent) {
-                _modifyChildFromTo(parent, current, fstArg);
-            }
-            else {
-                term = fstArg;
-                term.parent = undefined;
-            }
-            stack.unshift(fstArg);
+            modifyTermAndPushToReprocess(current, fstArg);
             continue;
         }
+        if (func instanceof IRNative) {
+            const tag = func.tag;
+            if (tag === IRNativeTag.strictIfThenElse
+                && restArgs.length === 2) {
+                const conditionArg = fstArg;
+                const condtionAppTerms = getApplicationTerms(conditionArg);
+                if (!condtionAppTerms) {
+                    const boolValue = getConstBool(conditionArg);
+                    if (typeof boolValue === "boolean") {
+                        const newTerm = boolValue ? restArgs[0] : restArgs[1];
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    stack.unshift(...current.children()); // normal processing
+                    continue;
+                }
+                const { func: condFunc, args: condArgs } = condtionAppTerms;
+                const thenArg = restArgs[0];
+                const elseArg = restArgs[1];
+                if (isNot(condFunc)
+                    && condArgs.length === 1) {
+                    // replace with swapped branches
+                    const newTerm = _ir_apps(IRNative.strictIfThenElse, condArgs[0], elseArg, thenArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (isLessThanOrEqualInteger(condFunc)
+                    && condArgs.length === 2) {
+                    const [lhs, rhs] = condArgs;
+                    const lhsInt = getConstInt(lhs);
+                    const rhsInt = getConstInt(rhs);
+                    if (typeof lhsInt === "bigint" && typeof rhsInt === "bigint") {
+                        // replace with constant
+                        const newTerm = (lhsInt <= rhsInt) ? thenArg : elseArg;
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof lhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanEqualInteger, lhs)), rhs), thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof rhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanInteger, rhs)), lhs), elseArg, thenArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                }
+                else if (isLessThanInteger(condFunc)
+                    && condArgs.length === 2) {
+                    const [lhs, rhs] = condArgs;
+                    const lhsInt = getConstInt(lhs);
+                    const rhsInt = getConstInt(rhs);
+                    if (typeof lhsInt === "bigint" && typeof rhsInt === "bigint") {
+                        // replace with constant
+                        const newTerm = (lhsInt < rhsInt) ? thenArg : elseArg;
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof lhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanInteger, lhs)), rhs), thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof rhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanEqualInteger, rhs)), lhs), elseArg, thenArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                }
+                else if (isEqualsZero(condFunc)
+                    && condArgs.length === 1) {
+                    const equalZeroArg = condArgs[0];
+                    const equalZeroArgAppTerms = getApplicationTerms(equalZeroArg);
+                    if (!equalZeroArgAppTerms) {
+                        // standard continuation
+                        stack.unshift(...current.children());
+                        continue;
+                    }
+                    const { func: eqZeroArgFunc, args: eqZeroArgArgs } = equalZeroArgAppTerms;
+                    if (isListLength(eqZeroArgFunc)
+                        && eqZeroArgArgs.length === 1) {
+                        const listTerm = eqZeroArgArgs[0];
+                        // replace with isNullList
+                        const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    // standard continuation
+                    stack.unshift(...current.children());
+                    continue;
+                } // if( x.length() === 0 )
+                else if (isNullList(condFunc)
+                    && condArgs.length === 1) {
+                    const listTerm = condArgs[0];
+                    // replace with isListLength
+                    const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                } // if( x.isEmpty() )
+            } // strictIfThenElse
+            else if (tag === IRNativeTag.equalsInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const fstInt = getConstInt(fstArg);
+                const sndInt = getConstInt(sndArg);
+                if (fstInt === BigInt(0)) {
+                    // replace as `isZero( sndArg )`
+                    const newTerm = _ir_apps(IRNative._isZero, sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (sndInt === BigInt(0)) {
+                    // replace as `isZero( fstArg )`
+                    const newTerm = _ir_apps(IRNative._isZero, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint" && typeof sndInt === "bigint") {
+                    // replace as constant
+                    const newTerm = IRConst.bool(fstInt === sndInt);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.equalsInteger, fstArg)), sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.equalsInteger, sndArg)), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            } // equalsInteger
+            else if (tag === IRNativeTag.addInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const fstInt = getConstInt(fstArg);
+                const sndInt = getConstInt(sndArg);
+                if (fstInt === BigInt(1)) {
+                    // replace as `incr( sndArg )`
+                    const newTerm = _ir_apps(IRNative._increment, sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (sndInt === BigInt(1)) {
+                    // replace as `incr( fstArg )`
+                    const newTerm = _ir_apps(IRNative._increment, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint" && typeof sndInt === "bigint") {
+                    // replace as constant
+                    const newTerm = IRConst.int(fstInt + sndInt);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, fstArg)), sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, sndArg)), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            } // addInteger
+            else if (tag === IRNativeTag.subtractInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const sndInt = getConstInt(sndArg);
+                if (sndInt === BigInt(1)) {
+                    // replace as `decr( fstArg )`
+                    const newTerm = _ir_apps(IRNative._decrement, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, IRConst.int(-sndInt))), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            }
+        }
+        // only optimizations if first argument is constant after this point
         if (!(fstArg instanceof IRConst)) {
             stack.unshift(...current.children());
             continue;
@@ -43,14 +237,7 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
             && (typeof fstArg.value === "bigint"
                 || typeof fstArg.value === "number")) {
             const newTerm = restArgs.length >= 1 ? _ir_apps(_compTimeDropN(fstArg.value), ...restArgs) : _compTimeDropN(fstArg.value);
-            if (parent) {
-                _modifyChildFromTo(parent, current, newTerm);
-            }
-            else {
-                term = newTerm;
-                term.parent = undefined;
-            }
-            stack.unshift(newTerm);
+            modifyTermAndPushToReprocess(current, newTerm);
             continue;
         }
         // const tsEnsureExhaustiveCheck: never = func;
@@ -83,3 +270,91 @@ function isId(term) {
         && term.body instanceof IRVar
         && term.body.name === term.params[0]));
 }
+function isNot(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._not) || (equalIrHash(hoisted_not.hoisted.hash, term.hash));
+}
+function isNullList(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.nullList);
+}
+function isEqualsZero(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._isZero) || (equalIrHash(hoisted_isZero.hash, term.hash));
+}
+function isLessThanOrEqualInteger(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.lessThanEqualInteger);
+}
+function isLessThanInteger(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.lessThanInteger);
+}
+function isListLength(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._length) || equalIrHash(hoisted_length.hash, term.hash);
+}
+function getConstInt(term) {
+    if (term instanceof IRConst
+        && term.type instanceof TirIntT
+        && typeof term.value === "bigint")
+        return term.value;
+    return undefined;
+}
+// function isConstIntOne( term: IRTerm ): boolean
+// {
+//     return (
+//         term instanceof IRConst
+//         && term.type instanceof TirIntT
+//         && term.value === BigInt( 1 )
+//     );
+// }
+function getConstBool(term) {
+    if (term instanceof IRConst
+        && term.type instanceof TirBoolT
+        && typeof term.value === "boolean")
+        return term.value;
+    return undefined;
+}

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

@@ -1,5 +1,5 @@
 import { fromHex } from "@harmoniclabs/uint8array-utils";
-import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
+import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 /**
  * writes the number in a new `Uint8Array` Big Endian
  */
@@ -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

@@ -41,6 +41,8 @@ export declare class AstCompiler extends DiagnosticEmitter {
     readonly parsedAstSources: Map<string, Source>;
     get rootPath(): string;
     constructor(cfg: CompilerOptions, io?: CompilerIoApi, diagnostics?: DiagnosticMessage[]);
+    private _isExporting;
+    export(funcName: string, modulePath?: string): Promise<TypedProgram>;
     /**
      * compiles the entry file specified in the config
      *
@@ -56,6 +58,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,9 @@ 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";
+import { isIdentifier } from "../../utils/text.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -82,6 +85,24 @@ export class AstCompiler extends DiagnosticEmitter {
         this.cfg = cfg;
         this.io = io;
         this.program = new TypedProgram(this.diagnostics);
+        this._isExporting = false;
+    }
+    _isExporting;
+    async export(funcName, modulePath) {
+        this._isExporting = true;
+        if (typeof funcName !== "string")
+            throw new Error("AstCompiler.export: funcName must be a string");
+        funcName = funcName.trim();
+        if (funcName === "" || !isIdentifier(funcName))
+            throw new Error("AstCompiler.export: funcName must be a valid function identifier");
+        if (typeof modulePath === "string") {
+            const nextEntryPath = modulePath;
+            if (!nextEntryPath)
+                throw new Error("AstCompiler.export: modulePath not found: " + modulePath);
+            this.cfg.entry = nextEntryPath;
+        }
+        this.program.contractTirFuncName = funcName;
+        return await this.compile();
     }
     /**
      * compiles the entry file specified in the config
@@ -113,6 +134,7 @@ export class AstCompiler extends DiagnosticEmitter {
         }
         const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
         if (this.program.contractTirFuncName === "" || !mainFuncExpr) {
+            console.log([...this.program.functions.keys()]);
             console.error(mainFuncExpr, `"${this.program.contractTirFuncName}"`);
             this.error(DiagnosticCode.Contract_is_missing, undefined);
             return this.program;
@@ -167,7 +189,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,13 +200,36 @@ 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) {
+                if (!(
                 // ignore contract declarations if not in the entry file
-                if (!isEntryFile) {
+                isEntryFile
+                    // ignore contract decalarations if we are exporting a specific function
+                    || this._isExporting)) {
                     // remove from array so we don't process it again
                     void stmts.splice(i, 1);
                     i--;
@@ -259,10 +304,28 @@ 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;
         const tirFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astFuncName + "_" + srcUid;
+        if (this._isExporting && astFuncName === this.program.contractTirFuncName) {
+            this.program.contractTirFuncName = tirFuncName;
+        }
         const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
         const funcExpr = _compileFuncExpr(declContext, astFuncExpr, undefined, // sig
         false // isMethod

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

@@ -74,10 +74,16 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     }
     const returnType = expectedFuncType.returnType;
     const funcCtx = ctx.newFunctionChildScope(returnType, isMethod);
+    // define value in case of recursion
+    funcCtx.scope.defineValue({
+        name: expr.name.text,
+        type: expectedFuncType,
+        isConstant: true,
+    });
     // 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 +97,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))