@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev7

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

@@ -52,8 +52,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 +84,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 +186,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 +365,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 +415,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 +430,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;
     }
 }

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

@@ -90,13 +90,17 @@ export function expressifyVars(ctx, expr) {
         const resolvedVariable = ctx.getVariable(originalVarName);
         if (!resolvedVariable)
             return expr; // variable not found, keep the original expression
+        // if variable was shadowed
         if (isExpressifyFuncParam(resolvedVariable)) {
-            // variable was shadowed
+            // !!! IMPORTANT !!!
+            // we must clone the expression to avoid modifying other instances of it elsewhere
+            // THIS IS CRUCIAL I SPENT A DAY DEBUGGING THIS
+            expr = expr.clone();
             expr.resolvedValue.variableInfos.name = resolvedVariable.name;
             return expr;
         }
         // resovledVariable instanceof TirVariableAccessExpr
-        return resolvedVariable;
+        return resolvedVariable.clone();
     }
     if (isTirUnaryPrefixExpr(expr)) {
         const modifiedExpr = expressifyVars(ctx, expr.operand);
@@ -248,7 +252,7 @@ function expressifyPropAccess(ctx, propAccessExpr) {
         let varName = ctx.properties.get("this")?.get(prop);
         if (!varName)
             throw new Error(`Property '${prop}' does not exist on 'this'`);
-        varName = ctx.variables.get(varName)?.latestName ?? varName;
+        varName = ctx.getVariableSSA(varName)?.latestName ?? varName;
         const expr = ctx.getVariable(varName);
         if (isExpressifyFuncParam(expr)) {
             return new TirVariableAccessExpr({
@@ -288,7 +292,7 @@ function expressifyPropAccess(ctx, propAccessExpr) {
             || expr instanceof TirVariableAccessExpr) {
             let varName = ctx.properties.get(expr.varName)?.get(prop);
             if (varName) {
-                varName = ctx.variables.get(varName)?.latestName ?? varName;
+                varName = ctx.getVariableSSA(varName)?.latestName ?? varName;
                 const result = ctx.getVariable(varName);
                 if (isExpressifyFuncParam(result)) {
                     return new TirVariableAccessExpr({
@@ -421,6 +425,13 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
             throw new Error(`Method 'isEmpty' of type 'list' takes 0 arguments, ${methodCall.args.length} provided`);
         return new TirCallExpr(TirNativeFunc.nullList(elemsType), [objectExpr], methodCall.type, exprRange);
     }
+    if (methodName === "find") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'find' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        // const finalType = getUnaliased( methodCall.type );
+        // console.log( finalType );
+        return new TirCallExpr(TirNativeFunc._findSopOptional(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
     // TODO
     /*
     {

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

@@ -15,6 +15,7 @@ export function flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedD
         if (varDecl instanceof TirSimpleVarDecl) {
             restFields.set(fName, varDecl.name);
             ctx.introduceFuncParams([varDecl]);
+            ctx.setNewVariableName(fName, varDecl.name); // added to fix reassigned variables on non-terminating statements
             if (isSingleConstrStruct(varDecl.type)) {
                 const structType = getUnaliased(varDecl.type);
                 const constr = structType.constructors[0];

package/dist/compiler/internalVar.d.ts

@@ -6,8 +6,8 @@ export declare const PEBBLE_INTERNAL_IDENTIFIER_SEPARATOR = "#";
  * Creates and tracks unique internal variable names for the Pebble compiler
  */
 export declare class UidGenerator {
+    private counter;
     constructor();
-    private readonly uids;
     getUid(): string;
     /**
      * Generates a unique internal variable name

package/dist/compiler/internalVar.js

@@ -1,39 +1,46 @@
-import { isObject } from "@harmoniclabs/obj-utils";
-import { toHex } from "@harmoniclabs/uint8array-utils";
 /** invalid char for normal js identifiers */
 export const PEBBLE_INTERNAL_IDENTIFIER_PREFIX = "§";
 /** invalid char for normal js identifiers */
 export const PEBBLE_INTERNAL_IDENTIFIER_SEPARATOR = "#";
 // Keep getRandomBytes outside the class as requested
-let getRandomBytes = (bytes) => {
-    for (let i = 0; i < bytes.length; i++)
-        bytes[i] = ((Math.random() * 0x100) >>> 0);
-    return bytes;
-};
-try {
-    if (typeof globalThis !== "undefined"
-        && typeof globalThis.crypto !== "undefined"
-        && isObject(globalThis.crypto)
-        && typeof globalThis.crypto.getRandomValues === "function")
-        getRandomBytes = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
-}
-catch { }
-const uidSet = new Set();
+// let getRandomBytes = (bytes: Uint8Array) => {
+//     for (let i = 0; i < bytes.length; i++)
+//         bytes[i] = ((Math.random() * 0x100) >>> 0);
+//     return bytes;
+// }
+// 
+// try {
+//     if (
+//         typeof globalThis !== "undefined"
+//         && typeof globalThis.crypto !== "undefined"
+//         && isObject(globalThis.crypto)
+//         && typeof globalThis.crypto.getRandomValues === "function"
+//     ) getRandomBytes = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+// } catch {}
+// 
+// const uidSet = new Set<string>();
 /**
  * Creates and tracks unique internal variable names for the Pebble compiler
  */
 export class UidGenerator {
+    counter;
     constructor() {
-        this.uids = uidSet;
+        // this.uids = uidSet;
+        this.counter = 0n;
     }
-    uids;
+    // private readonly uids: Set<string>;
+    // getUid(): string {
+    //     const bytes = new Uint8Array(Math.max(1, Math.log1p(this.uids.size) >>> 0));
+    //     let uid: string;
+    //     do {
+    //         uid = toHex(getRandomBytes(bytes));
+    //     } while( this.uids.has( uid ) );
+    //     this.uids.add(uid);
+    //     return uid;
+    // }
     getUid() {
-        const bytes = new Uint8Array(Math.max(1, Math.log1p(this.uids.size) >>> 0));
-        let uid;
-        do {
-            uid = toHex(getRandomBytes(bytes));
-        } while (this.uids.has(uid));
-        this.uids.add(uid);
+        const uid = this.counter.toString(36);
+        this.counter++;
         return uid;
     }
     /**

package/dist/compiler/io/CompilerIoApi.d.ts

@@ -4,7 +4,7 @@ import { IOutputStream } from "./IOutputStream.js";
 /** Compiler API options. */
 export interface CompilerIoApi {
     /** Standard output stream to use. */
-    readonly stdout: IOutputStream;
+    stdout: IOutputStream;
     /** Standard error stream to use. */
     readonly stderr: IOutputStream;
     /** Reads a file from disk (or memory). */

package/dist/compiler/tir/expressions/TirCallExpr.d.ts

@@ -11,7 +11,7 @@ export declare class TirCallExpr implements ITirExpr {
     readonly range: SourceRange;
     constructor(func: TirExpr, args: TirExpr[], type: TirType, range: SourceRange);
     toString(): string;
-    pretty(indent: number): string;
+    pretty(indent?: number): string;
     clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;

package/dist/compiler/tir/expressions/TirCallExpr.js

@@ -14,7 +14,7 @@ export class TirCallExpr {
     toString() {
         return `${this.func.toString()}( ${this.args.map(a => a.toString()).join(", ")} )`;
     }
-    pretty(indent) {
+    pretty(indent = 1) {
         const singleIndent = "  ";
         const indent_base = singleIndent.repeat(indent);
         const indent_0 = "\n" + indent_base;

package/dist/compiler/tir/expressions/TirCaseExpr.js

@@ -69,6 +69,7 @@ export class TirCaseExpr {
     }
     get isConstant() { return false; }
     toIR(ctx) {
+        // console.log( this.pretty(2) );
         const matchExprType = getUnaliased(this.matchExpr.type);
         if (matchExprType instanceof TirSoPStructType
             || matchExprType instanceof TirSopOptT)
@@ -128,6 +129,7 @@ export class TirCaseExpr {
                     throw new Error("case pattern not expressified.");
                 introducedVars[i] = branchCtx.defineVar(varDecl.name);
             }
+            // console.log( nFields, introducedVars, branchCtx.allVariables() );
             if (nFields <= 0)
                 return branch.body.toIR(branchCtx);
             return new IRFunc(introducedVars, branch.body.toIR(branchCtx));

package/dist/compiler/tir/expressions/TirFromDataExpr.js

@@ -33,12 +33,12 @@ export class TirFromDataExpr {
         this.range = range;
     }
     toString() {
-        return `fromData(${this.dataExpr.toString()}) as ${this.type.toString()}`;
+        return `fromData<${this.type.toString()}>(${this.dataExpr.toString()})`;
     }
     pretty(indent) {
         const singleIndent = "  ";
         const indent_base = singleIndent.repeat(indent);
-        return `fromData(${this.dataExpr.pretty(indent)}) as ${this.type.toString()}`;
+        return `fromData<${this.type.toString()}>(${this.dataExpr.pretty(indent)})`;
     }
     clone() {
         return new TirFromDataExpr(this.dataExpr.clone(), this.type.clone(), this.range.clone());

package/dist/compiler/tir/expressions/TirFuncExpr.d.ts

@@ -18,7 +18,7 @@ export declare class TirFuncExpr implements ITirExpr {
     sig(): TirFuncT;
     constructor(name: string, params: TirSimpleVarDecl[], returnType: TirType, body: TirBlockStmt, range: SourceRange, _isLoop?: boolean);
     toString(): string;
-    pretty(indent: number): string;
+    pretty(indent?: number): string;
     clone(): TirExpr;
     isAnonymous(): boolean;
     private _deps;

package/dist/compiler/tir/expressions/TirFuncExpr.js

@@ -39,7 +39,7 @@ export class TirFuncExpr {
             `: ${this.returnType.toString()} ` +
             `${this.body.toString()}`);
     }
-    pretty(indent) {
+    pretty(indent = 1) {
         const singleIndent = "  ";
         const indent_base = singleIndent.repeat(indent);
         const indent_0 = "\n" + indent_base;

package/dist/compiler/tir/expressions/TirLettedExpr.d.ts

@@ -8,14 +8,14 @@ export declare class TirLettedExpr implements ITirExpr {
     readonly varName: string;
     expr: TirExpr;
     readonly range: SourceRange;
+    private _creationStack;
     get type(): TirType;
     private readonly _irVarSym;
-    constructor(varName: string, expr: TirExpr, range: SourceRange, _unsafeVarSym?: symbol | undefined);
+    constructor(varName: string, expr: TirExpr, range: SourceRange, _unsafeVarSym?: symbol | undefined, _creationStack?: string | undefined);
     toString(): string;
     pretty(indent: number): string;
     deps(): string[];
     clone(): TirExpr;
-    unsafeClone(): TirLettedExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

package/dist/compiler/tir/expressions/TirLettedExpr.js

@@ -3,17 +3,19 @@ export class TirLettedExpr {
     varName;
     expr;
     range;
+    _creationStack = undefined;
     get type() {
         return this.expr.type;
     }
     _irVarSym;
-    constructor(varName, expr, range, _unsafeVarSym) {
+    constructor(varName, expr, range, _unsafeVarSym, _creationStack) {
         this.varName = varName;
         this.expr = expr;
         this.range = range;
         if (!(typeof varName === "string"
             && varName.length > 0))
             throw new Error("TirLettedExpr: varName must be a non empty string");
+        this._creationStack = _creationStack ?? (new Error()).stack;
         this._irVarSym = (typeof _unsafeVarSym === "symbol"
             && _unsafeVarSym.description === varName) ? _unsafeVarSym : Symbol(varName);
     }
@@ -30,11 +32,7 @@ export class TirLettedExpr {
         return this.expr.deps();
     }
     clone() {
-        return new TirLettedExpr(this.varName, this.expr.clone(), this.range.clone(), this._irVarSym);
-    }
-    unsafeClone() {
-        return new TirLettedExpr(this.varName, this.expr, // this.expr.clone(),
-        this.range, this._irVarSym);
+        return new TirLettedExpr(this.varName, this.expr.clone(), this.range.clone(), this._irVarSym, this._creationStack);
     }
     get isConstant() { return this.expr.isConstant; }
     toIR(ctx) {