@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev8

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

@@ -6,5 +6,12 @@ export declare class Compiler extends DiagnosticEmitter {
     readonly io: CompilerIoApi;
     readonly cfg: CompilerOptions;
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
-    compile(config?: Partial<CompilerOptions>): Promise<void>;
+    compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
+    export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
 }
+interface HasFuncitonName {
+    functionName: string;
+}
+export interface ExportOptions extends CompilerOptions, HasFuncitonName {
+}
+export {};

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;
@@ -39,6 +43,39 @@ export class Compiler extends DiagnosticEmitter {
         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;
+        return serialized;
+    }
+    async export(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            // NEVER generate markers when exporting a function
+            addMarker: false,
+        };
+        if (typeof cfg.functionName !== "string" || cfg.functionName.length === 0) {
+            throw new Error("Compiler::export - invalid function name in export options");
+        }
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        const program = await astCompiler.export(cfg.functionName, cfg.entry);
+        if (this.diagnostics.length > 0) {
+            let msg;
+            globalThis.console && console.log(this.diagnostics);
+            const fstErrorMsg = this.diagnostics[0].toString();
+            const nDiags = this.diagnostics.length;
+            while (msg = this.diagnostics.shift()) {
+                this.io.stdout.write(msg.toString() + "\n");
+            }
+            throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+        }
+        // backend starts here
+        const ir = compileTypedProgram(cfg, program);
+        const uplc = compileIRToUPLC(ir, cfg);
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const outDir = cfg.outDir;
+        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 serialized;
     }
 }

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;

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

@@ -5,6 +5,7 @@ import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
 import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
 import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
+import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
 import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
 import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
 import { data_t, int_t } from "../../tir/program/stdScope/stdScope.js";
@@ -48,12 +49,23 @@ export class ExpressifyCtx {
         this.funcParams = funcParams;
         this.lettedConstants = lettedConstants;
         this.properties = properties;
-        this.hoisted = hoisted ?? this.parent?.hoisted ?? new Map();
+        this.hoisted = (hoisted
+            ?? this.parent?.hoisted
+            ?? new Map([...program.constants.entries()].map(([name, decl]) => {
+                if (!decl.initExpr)
+                    throw new Error(`expected init expr in hoisted constant '${name}'`);
+                const expr = decl.initExpr instanceof TirHoistedExpr ? decl.initExpr : new TirHoistedExpr(name, decl.initExpr);
+                return [name, expr];
+            })));
+    }
+    allVariablesNoLetted() {
+        return (this.parent?.allVariablesNoLetted() ?? []).concat(...this.variables.keys());
     }
     allVariables() {
         const thisVars = new Set([
             ...this.variables.keys(),
-            ...this.lettedConstants.keys()
+            ...this.lettedConstants.keys(),
+            ...this.hoisted.keys(),
         ]);
         return (this.parent?.allVariables() ?? []).concat(...thisVars);
     }
@@ -64,26 +76,32 @@ export class ExpressifyCtx {
         let latestNameSSA = this.variables.get(oldName);
         if (!latestNameSSA)
             this.variables.set(oldName, { latestName: newName });
-        else
+        else {
+            const prevName = latestNameSSA.latestName;
+            if (prevName === newName)
+                return; // no change
             latestNameSSA.latestName = newName;
+            this.setNewVariableName(prevName, newName);
+            this.setNewVariableName(newName, newName);
+        }
     }
     setFuncParam(name, type) {
-        this.variables.set(name, { latestName: name });
+        this.setNewVariableName(name, name);
         this.funcParams.set(name, { name, type });
     }
     /**
      * `undefined` means the variable is not in the local context.
      */
     getLocalVariable(name) {
-        // declared as constant shortcut
-        const constResult = this.lettedConstants.get(name);
-        if (constResult)
-            return constResult;
         // declared as variable or param
         const latestConstName = this.variables.get(name)?.latestName;
-        // no such variable
-        if (!latestConstName)
-            return undefined;
+        // no such variable (mutable at least)
+        if (!latestConstName) {
+            // try to get var declared as constant
+            // return undefined if not present
+            return this.lettedConstants.get(name);
+        }
+        ;
         return (this.lettedConstants.get(latestConstName)
             ?? this.funcParams.get(latestConstName));
     }
@@ -101,11 +119,15 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            // console.log( this );
+            console.log("[error log]: allVariables", this.allVariables());
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;
     }
+    getVariableSSA(name) {
+        return (this.variables.get(name)
+            ?? this.parent?.getVariableSSA(name));
+    }
     introduceFuncParams(params) {
         for (const param of params) {
             param.isConst = true;
@@ -113,9 +135,13 @@ export class ExpressifyCtx {
         }
     }
     introduceLettedConstant(name, lettedExpr, declRange) {
+        // if( this.lettedConstants.has( name ) ) throw new Error(`constant '${name}' already introduced in the context`);
+        const existing = this.lettedConstants.get(name);
+        if (existing)
+            return existing.clone();
         const result = new TirLettedExpr(name, lettedExpr, declRange);
         this.lettedConstants.set(name, result);
-        return result.unsafeClone();
+        return result.clone();
     }
     introduceSopConstrFieldsAsProperties(sopName, destructuredPattern) {
         const fieldsMap = new Map();
@@ -182,7 +208,7 @@ export class ExpressifyCtx {
             assertions.push(new TirAssertStmt(new TirEqualExpr(new TirCallExpr(TirNativeFunc.unConstrDataResultIndex, [lettedUnconstr], int_t, stmt.range), new TirLitIntExpr(BigInt(constrIdx), stmt.range), stmt.range), undefined, // no trace message
             stmt.range));
         const lettedRawFieldsName = getUniqueInternalName(`${varName}_fields`);
-        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirLettedExpr(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [lettedUnconstr], new TirListT(data_t), stmt.range), stmt.range), stmt.range);
+        const lettedFields = this.introduceLettedConstant(lettedRawFieldsName, new TirCallExpr(TirNativeFunc.unConstrDataResultFields, [lettedUnconstr], new TirListT(data_t), stmt.range), stmt.range);
         const fieldsToIntroduce = [...stmt.fields.keys()];
         const hasRest = typeof stmt.rest === "string";
         const fieldsMap = new Map();
@@ -206,7 +232,7 @@ export class ExpressifyCtx {
             if (!fieldVarDecl)
                 throw new Error(`field '${fieldName}' not found in deconstruct data statement`);
             if (fieldVarDecl instanceof TirSimpleVarDecl) {
-                this.variables.set(fieldVarDecl.name, { latestName: lettedField.varName });
+                this.setNewVariableName(fieldVarDecl.name, lettedField.varName);
             }
             else {
                 // fieldVarDecl.type ??= fieldType;
@@ -246,7 +272,7 @@ export class ExpressifyCtx {
                 lettedExpr = new TirFromDataExpr(lettedExpr, elemVarDecl.type, elemVarDecl.range);
             const lettedElem = this.introduceLettedConstant(lettedElemName, lettedExpr, elemVarDecl.range);
             if (elemVarDecl instanceof TirSimpleVarDecl) {
-                this.variables.set(elemVarDecl.name, { latestName: lettedElem.varName });
+                this.setNewVariableName(elemVarDecl.name, lettedElem.varName);
                 if (lettedElem.type instanceof TirDataStructType
                     && lettedElem.type.constructors.length === 1) {
                     // if the element is a single-constructor data struct,

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

@@ -148,6 +148,8 @@ export function determineReassignedVariablesAndFlowInfos(stmt) {
             continue;
         }
         const tsEnsureExsaustiveCheck = stmt;
+        console.error("unexpected", stmt);
+        throw new Error("unexpected statement type");
     }
     let reassigned = [...reassignedSet].sort();
     reassigned = keepSortedStrArrInplace(reassigned, originalStmtDeps);

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

@@ -41,6 +41,8 @@ import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
 import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
 export function expressify(func, loopReplacements, program, parentCtx = undefined) {
     const ctx = new ExpressifyCtx(parentCtx, func.returnType, program);
+    // define in case of recursion
+    ctx.setFuncParam(func.name, func.type);
     ctx.introduceFuncParams(func.params);
     func.body.stmts = [
         new TirReturnStmt(expressifyFuncBody(ctx, func.body.stmts, loopReplacements), func.body.range)
@@ -52,8 +54,9 @@ loopReplacements, assertions = []) {
     bodyStmts = bodyStmts.slice();
     let stmt;
     while (stmt = bodyStmts.shift()) {
-        // console.log([stmt, ...bodyStmts].map(s => s.toString()));
-        // console.log( stmt );
+        // const isEdgeCase = stmt instanceof TirForStmt || stmt instanceof TirForOfStmt || stmt instanceof TirWhileStmt;
+        // if( isEdgeCase ) console.log([stmt, ...bodyStmts].map(s => s.toString()));
+        // if( isEdgeCase ) console.log( stmt );
         if (stmt instanceof TirBreakStmt) {
             if (typeof loopReplacements?.compileBreak !== "function")
                 throw new Error("break statement in function body.");
@@ -83,9 +86,8 @@ loopReplacements, assertions = []) {
                 throw new Error("simple var decl without init expr");
             const initExpr = expressifyVars(ctx, stmt.initExpr);
             stmt.initExpr = initExpr;
-            const lettedExpr = ctx.introduceLettedConstant(stmt.name, initExpr, stmt.range);
+            const lettedExpr = initExpr instanceof TirLettedExpr ? initExpr : ctx.introduceLettedConstant(stmt.name, initExpr, stmt.range);
             if (!stmt.isConst) {
-                // console.log("setting variable")
                 ctx.setNewVariableName(stmt.name, lettedExpr.varName);
             }
             if (!isSingleConstrStruct(stmt.type))
@@ -186,7 +188,18 @@ loopReplacements, assertions = []) {
             continue;
         }
         else if (stmt instanceof TirAssignmentStmt) {
-            bodyStmts.unshift(expressifyVarAssignmentStmt(ctx, stmt));
+            void expressifyVarAssignmentStmt(ctx, stmt);
+            // !!! IMPORTANT BUG !!!
+            // .unshift the resulting `TirSimpleVarDecl` into bodyStmts
+            // will cause the assigned expression to be re-expressified
+            // meaning that variables that depend on themselves (e.g. `x = x + 1`) will be processed twice
+            //
+            // x = (x + 1) --> const x_i = (x + 1) --> const x_i = (x_i/*x + 1*/ */ + 1) (??? BUG ???)
+            //
+            // so ultimately `x = x + 1` would be compiled as `x = x + 1 + 1`
+            //
+            // const constDecl = expressifyVarAssignmentStmt( ctx, stmt );
+            // bodyStmts.unshift( constDecl );
             continue;
         }
         else if (stmt instanceof TirBlockStmt) {
@@ -354,8 +367,10 @@ loopReplacements, assertions = []) {
             const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
             const forStmt = loopToForStmt(stmt);
             const { bodyStateType, initState } = getBodyStateType(returnTypeAndInvalidInit, forStmt);
-            const loopExpr = expressifyForStmt(ctx.newChild(), forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
-            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, definitelyTerminates ? loopExpr : wrapNonTerminatingFinalStmtAsCaseExpr(loopExpr, returnTypeAndInvalidInit.sop, ctx, stmt.range, reassignedAndFlow, bodyStmts, loopReplacements));
+            const loopExprCtx = ctx.newChild();
+            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+            const result = TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, definitelyTerminates ? loopExpr : wrapNonTerminatingFinalStmtAsCaseExpr(loopExpr, returnTypeAndInvalidInit.sop, ctx, stmt.range, reassignedAndFlow, bodyStmts, loopReplacements));
+            return result;
         }
         else {
             // const tsEnsureExhautstiveCheck: never = stmt;
@@ -402,6 +417,7 @@ function getNestedDestructsInSingleSopDestructPattern(pattern) {
     return result;
 }
 function wrapNonTerminatingFinalStmtAsCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
+    nextBodyStmts = nextBodyStmts.slice();
     const continuations = [];
     const contBranchCtx = ctx.newChild();
     const contConstr = sop.constructors[0];
@@ -416,9 +432,10 @@ function wrapNonTerminatingFinalStmtAsCaseExpr(finalStmtExpr, sop, ctx, stmtRang
     false, // not a constant
     stmtRange);
     const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(contPattern, contBranchCtx);
-    continuations.push(new TirCaseMatcher(contPattern, expressifyFuncBody(contBranchCtx, nestedDeconstructs
+    const mainContinuaiton = expressifyFuncBody(contBranchCtx, nestedDeconstructs
         .concat(nextBodyStmts), loopReplacements, [] // assertions are added before if statement exectution
-    ), stmtRange));
+    );
+    continuations.push(new TirCaseMatcher(contPattern, mainContinuaiton, stmtRange));
     if (reassignsAndReturns.returns) {
         const earlyRetConstr = sop.constructors[1];
         const earlyRetField = earlyRetConstr.fields[0];

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

@@ -20,6 +20,7 @@ import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
 import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
 import { expressifyFuncBody } from "./expressify.js";
 import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
+import { expressifyVars } from "./expressifyVars.js";
 export function loopToForStmt(stmt) {
     if (stmt instanceof TirForStmt)
         return stmt;
@@ -70,8 +71,14 @@ export function loopToForStmt(stmt) {
 export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState) {
     let loopBody = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
     loopBody = new TirBlockStmt(loopBody.stmts.slice(), loopBody.range);
+    // add final loop updates
+    if (Array.isArray(stmt.update))
+        for (const updateStmt of stmt.update) {
+            loopBody.stmts.push(updateStmt);
+        }
+    // ALWAYS add a final `continue;` to the end of the loop body
+    loopBody.stmts.push(new TirContinueStmt(loopBody.range.atEnd()));
     if (stmt.condition) {
-        loopBody.stmts.push(new TirContinueStmt(loopBody.range.atEnd()));
         loopBody = new TirBlockStmt([
             new TirIfStmt(stmt.condition, 
             // then
@@ -80,8 +87,6 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
             new TirBlockStmt([new TirBreakStmt(stmt.condition.range)], stmt.condition.range), stmt.condition.range)
         ], loopBody.range);
     }
-    // ALWAYS add a final `continue;` to the end of the loop body
-    loopBody.stmts.push(new TirContinueStmt(loopBody.range.atEnd()));
     const loopFuncName = getUniqueInternalName("loop");
     const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), returnType);
     const loopReplacements = {
@@ -154,11 +159,22 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
     for (const { name, type } of bodyStateType.constructors[0].fields) {
         loopCompilationCtx.setFuncParam(name, type);
     }
-    return new TirCallExpr(new TirFuncExpr(loopFuncName, bodyStateType.constructors[0].fields.map(f => new TirSimpleVarDecl(f.name, f.type, undefined, // no initial value
+    const loopFuncExpr = new TirFuncExpr(loopFuncName, // func name
+    // func params
+    bodyStateType.constructors[0].fields.map(f => new TirSimpleVarDecl(f.name, f.type, undefined, // no initial value
     false, // is constant
-    stmt.range)), returnType, new TirBlockStmt([
+    stmt.range)), 
+    // func return type
+    returnType, 
+    // func body
+    new TirBlockStmt([
         new TirReturnStmt(expressifyFuncBody(loopCompilationCtx, loopBody.stmts, loopReplacements, [] // assertions
         ), stmt.range)
-    ], stmt.range), stmt.range, true // is loop
-    ), initState.values, returnType, stmt.range);
+    ], stmt.range), 
+    // func range
+    stmt.range, true // is loop
+    );
+    return new TirCallExpr(loopFuncExpr, 
+    // loop call init args
+    initState.values.map(v => expressifyVars(ctx, v.clone())), returnType, stmt.range);
 }

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

@@ -1,4 +1,3 @@
 import { TirAssignmentStmt } from "../../tir/statements/TirAssignmentStmt.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
-export declare function expressifyVarAssignmentStmt(ctx: ExpressifyCtx, stmt: TirAssignmentStmt): TirSimpleVarDecl;
+export declare function expressifyVarAssignmentStmt(ctx: ExpressifyCtx, stmt: TirAssignmentStmt): void;

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

@@ -1,20 +1,27 @@
 import { getUniqueInternalName } from "../../internalVar.js";
-import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
-import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { expressifyVars } from "./expressifyVars.js";
 export function expressifyVarAssignmentStmt(ctx, stmt) {
+    // since we no longer return a new TirSimpleVarDecl,
+    // we need to expressify the assigned expression here
+    // 
+    // !!! IMPORTANT !!! we MUST NOT do it if we instead returned a new TirSimpleVarDecl,
+    // otherwise it would be re-processed, casing bugs
     const assignedExpr = expressifyVars(ctx, stmt.assignedExpr);
     const originalName = stmt.varIdentifier.resolvedValue.variableInfos.name;
-    const latestVarNameSSA = ctx.variables.get(originalName);
+    const latestVarNameSSA = ctx.getVariableSSA(originalName);
     if (!latestVarNameSSA) {
         throw new Error("re-assigning constant variable '" + originalName + "'");
     }
     const newUniqueName = getUniqueInternalName(originalName);
-    latestVarNameSSA.latestName = newUniqueName;
+    ctx.setNewVariableName(originalName, newUniqueName);
     // point to the same object
-    ctx.variables.set(newUniqueName, latestVarNameSSA);
-    ctx.lettedConstants.set(newUniqueName, new TirLettedExpr(newUniqueName, assignedExpr, stmt.range));
+    ctx.introduceLettedConstant(newUniqueName, assignedExpr, stmt.range);
     // will replace re-assignment in body
-    return new TirSimpleVarDecl(newUniqueName, stmt.varIdentifier.resolvedValue.variableInfos.type, assignedExpr, true, // isConst
-    stmt.range);
+    // return new TirSimpleVarDecl(
+    //     newUniqueName,
+    //     stmt.varIdentifier.resolvedValue.variableInfos.type,
+    //     assignedExpr,
+    //     true, // isConst
+    //     stmt.range,
+    // );
 }

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

@@ -1,4 +1,3 @@
-import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.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";
@@ -6,30 +5,28 @@ import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/Tir
 import { expressifyVars } from "./expressifyVars.js";
 export function expressifyVarDecl(ctx, stmt) {
     const isConst = stmt.isConst;
-    console.log("expressifyVarDecl", stmt);
     if (stmt.initExpr)
         expressifyVars(ctx, stmt.initExpr);
     if (stmt instanceof TirSimpleVarDecl) {
-        if (stmt.isConst) {
-            void ctx.variables.set(stmt.name, { latestName: stmt.name });
-            /// @ts-ignore Cannot assign to 'isConst' because it is a read-only property.
-            stmt.isConst = true;
+        if (!stmt.isConst) {
+            void ctx.setNewVariableName(stmt.name, stmt.name);
+            // stmt.isConst = true;
         }
-        ctx.lettedConstants.set(stmt.name, new TirLettedExpr(stmt.name, stmt.initExpr, stmt.range));
+        ctx.introduceLettedConstant(stmt.name, stmt.initExpr, stmt.range);
     }
     if (stmt instanceof TirNamedDeconstructVarDecl
         || stmt instanceof TirSingleDeconstructVarDecl) {
         for (const [_field, varDecl] of stmt.fields)
             expressifyVarDecl(ctx, varDecl);
         if (stmt.rest)
-            ctx.variables.set(stmt.rest, { latestName: stmt.rest });
+            ctx.setNewVariableName(stmt.rest, stmt.rest);
         return;
     }
     if (stmt instanceof TirArrayLikeDeconstr) {
         for (const varDecl of stmt.elements)
             expressifyVarDecl(ctx, varDecl);
         if (stmt.rest)
-            ctx.variables.set(stmt.rest, { latestName: stmt.rest });
+            ctx.setNewVariableName(stmt.rest, stmt.rest);
         return;
     }
 }