@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -3,20 +3,64 @@ import { getUniqueInternalName } from "../../internalVar.js";
 import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
 import { TirFuncExpr } from "../../tir/expressions/TirFuncExpr.js";
+import { TirPropAccessExpr } from "../../tir/expressions/TirPropAccessExpr.js";
 import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
+import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
+import { TirAssignmentStmt } from "../../tir/statements/TirAssignmentStmt.js";
 import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
 import { TirBreakStmt } from "../../tir/statements/TirBreakStmt.js";
 import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
+import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirIfStmt } from "../../tir/statements/TirIfStmt.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirBoolT } from "../../tir/types/TirNativeType/index.js";
 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";
-export function whileToFor(stmt) {
+import { expressifyVars } from "./expressifyVars.js";
+export function loopToForStmt(stmt) {
     if (stmt instanceof TirForStmt)
         return stmt;
+    if (stmt instanceof TirForOfStmt) {
+        // convert for of to for
+        const partialListName = getUniqueInternalName("for_of_partial_list");
+        const iterElemType = getListTypeArg(stmt.iterable.type);
+        if (!iterElemType)
+            throw new Error("Iterable type is not a list");
+        const varRange = stmt.elemDeclaration.range;
+        const partialListVar = new TirSimpleVarDecl(partialListName, // name
+        stmt.iterable.type, // type
+        stmt.iterable, // initial value
+        false, // is constant
+        varRange // range
+        );
+        const partialListVarAccess = new TirVariableAccessExpr({
+            isDefinedOutsideFuncScope: false,
+            variableInfos: {
+                name: partialListVar.name,
+                type: partialListVar.type,
+                isConstant: false,
+            },
+        }, varRange);
+        // `!partialList.isEmpty()`
+        const runCondition = new TirUnaryExclamation(new TirCallExpr(new TirPropAccessExpr(partialListVarAccess.clone(), new Identifier("isEmpty", varRange), new TirFuncT([], new TirBoolT()), varRange), [], // args
+        new TirBoolT(), varRange), new TirBoolT(), varRange);
+        const updatePartialList = new TirAssignmentStmt(partialListVarAccess.clone(), new TirCallExpr(new TirPropAccessExpr(partialListVarAccess.clone(), new Identifier("tail", varRange), new TirFuncT([], stmt.iterable.type), varRange), [], // args
+        stmt.iterable.type, varRange), varRange);
+        let body = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
+        const elemDecl = stmt.elemDeclaration;
+        elemDecl.initExpr = new TirCallExpr(new TirPropAccessExpr(partialListVarAccess.clone(), new Identifier("head", varRange), new TirFuncT([], iterElemType), varRange), [], // args
+        iterElemType, varRange);
+        body.stmts.unshift(elemDecl);
+        return new TirForStmt([partialListVar], // init
+        runCondition, // condition
+        [updatePartialList], // update
+        body, // loopBody
+        stmt.range);
+    }
     // convert while to for
     return new TirForStmt([], // no init
     stmt.condition, // condition
@@ -25,14 +69,24 @@ export function whileToFor(stmt) {
     stmt.range);
 }
 export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState) {
-    const loopBody = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
-    if (stmt.condition)
-        loopBody.stmts.unshift(new TirIfStmt(stmt.condition, 
-        // then
-        loopBody, 
-        // else
-        new TirBlockStmt([new TirBreakStmt(stmt.condition.range)], stmt.condition.range), stmt.condition.range));
+    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 = new TirBlockStmt([
+            new TirIfStmt(stmt.condition, 
+            // then
+            loopBody, 
+            // else
+            new TirBlockStmt([new TirBreakStmt(stmt.condition.range)], stmt.condition.range), stmt.condition.range)
+        ], loopBody.range);
+    }
     const loopFuncName = getUniqueInternalName("loop");
     const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), returnType);
     const loopReplacements = {
@@ -105,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/expressifyIfBranch.js

@@ -100,6 +100,6 @@ function replaceReturnStatements(body, wrapReturnExpr, sopType) {
             replaceReturnStatements(stmt.body.stmts, wrapReturnExpr, sopType);
             continue;
         }
-        const tsEnsureExsautstiveCheck = stmt;
+        const tsEnsureExhautstiveCheck = stmt;
     }
 }

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");
+        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";
@@ -9,26 +8,25 @@ export function expressifyVarDecl(ctx, 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

@@ -1,6 +1,7 @@
-import { isUnaryPrefixExpr } from "../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
 import { isTirBinaryExpr } from "../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirLitArrExpr } from "../../tir/expressions/litteral/TirLitArrExpr.js";
+import { TirLitFailExpr } from "../../tir/expressions/litteral/TirLitFailExpr.js";
 import { TirLitFalseExpr } from "../../tir/expressions/litteral/TirLitFalseExpr.js";
 import { TirLitHexBytesExpr } from "../../tir/expressions/litteral/TirLitHexBytesExpr.js";
 import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
@@ -32,11 +33,17 @@ import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessEx
 import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
 import { TirUnaryMinus } from "../../tir/expressions/unary/TirUnaryMinus.js";
 import { TirUnaryPlus } from "../../tir/expressions/unary/TirUnaryPlus.js";
+import { isTirUnaryPrefixExpr } from "../../tir/expressions/unary/TirUnaryPrefixExpr.js";
 import { TirUnaryTilde } from "../../tir/expressions/unary/TirUnaryTilde.js";
+import { bool_t } from "../../tir/program/stdScope/stdScope.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.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 { TirAliasType } from "../../tir/types/TirAliasType.js";
+import { TirFuncT, TirListT } from "../../tir/types/TirNativeType/index.js";
+import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
 import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
 import { expressify, expressifyFuncBody } from "./expressify.js";
 import { isExpressifyFuncParam } from "./ExpressifyCtx.js";
@@ -54,6 +61,7 @@ export function expressifyVars(ctx, expr) {
     if (
     // isTirLitteralExpr( expr )
     expr instanceof TirLitVoidExpr
+        || expr instanceof TirLitFailExpr
         || expr instanceof TirLitUndefExpr
         || expr instanceof TirLitTrueExpr
         || expr instanceof TirLitFalseExpr
@@ -75,22 +83,26 @@ export function expressifyVars(ctx, expr) {
     if (expr instanceof TirPropAccessExpr) {
         const objectExpr = expressifyVars(ctx, expr.object);
         expr.object = objectExpr;
-        return getVarAccessFromPropAccess(ctx, expr);
+        return expressifyPropAccess(ctx, expr);
     }
     if (expr instanceof TirVariableAccessExpr) {
         const originalVarName = expr.resolvedValue.variableInfos.name;
         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 (isUnaryPrefixExpr(expr)) {
+    if (isTirUnaryPrefixExpr(expr)) {
         const modifiedExpr = expressifyVars(ctx, expr.operand);
         expr.operand = modifiedExpr;
         return expr;
@@ -102,10 +114,19 @@ export function expressifyVars(ctx, expr) {
         return expr;
     }
     if (expr instanceof TirFuncExpr) {
-        expressify(expr, undefined, ctx);
+        expressify(expr, undefined, ctx.program, ctx);
         return expr;
     }
     if (expr instanceof TirCallExpr) {
+        while (expr.func instanceof TirParentesizedExpr)
+            expr.func = expr.func.expr;
+        if (expr.func instanceof TirPropAccessExpr) {
+            for (let i = 0; i < expr.args.length; i++) {
+                const arg = expressifyVars(ctx, expr.args[i]);
+                expr.args[i] = arg;
+            }
+            return expressifyMethodCall(ctx, expr);
+        }
         const func = expressifyVars(ctx, expr.func);
         expr.func = func;
         for (let i = 0; i < expr.args.length; i++) {
@@ -193,17 +214,18 @@ export function expressifyVars(ctx, expr) {
     }
     if (expr instanceof TirInlineClosedIR)
         return expr;
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::expressifyVars");
 }
-function getVarAccessFromPropAccess(ctx, propAccessExpr) {
+function expressifyPropAccess(ctx, propAccessExpr) {
     let expr = propAccessExpr.object;
     const prop = propAccessExpr.prop.text;
     while (expr instanceof TirParentesizedExpr)
         expr = expr.expr;
     if (expr instanceof TirLitVoidExpr
         || expr instanceof TirLitUndefExpr
+        || expr instanceof TirLitFailExpr
         || expr instanceof TirLitTrueExpr
         || expr instanceof TirLitFalseExpr
         // methods on these should have already been converted to functions
@@ -230,7 +252,7 @@ function getVarAccessFromPropAccess(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({
@@ -244,6 +266,7 @@ function getVarAccessFromPropAccess(ctx, propAccessExpr) {
         }
         return expr;
     }
+    // expressify as normal variable
     if (expr instanceof TirLitObjExpr
         || expr instanceof TirLitNamedObjExpr) {
         const valIdx = expr.fieldNames.findIndex(f => f.text === prop);
@@ -269,7 +292,7 @@ function getVarAccessFromPropAccess(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({
@@ -288,8 +311,10 @@ function getVarAccessFromPropAccess(ctx, propAccessExpr) {
         }
         const objType = getUnaliased(expr.type);
         if (!isSingleConstrStruct(objType)) {
-            console.log(objType);
-            throw new Error("cannot access property on non-struct type");
+            // IMPORTANT: we only care about fields here
+            // any methods should have already been converted to functions
+            console.error(objType, expr.toString());
+            throw new Error(`cannot access property '${prop}' on non-struct type`);
         }
         const ctor = objType.constructors[0];
         const fIdx = ctor.fields.findIndex(f => f.name === prop);
@@ -315,6 +340,114 @@ function getVarAccessFromPropAccess(ctx, propAccessExpr) {
         fType, propAccessExpr.range);
     }
     ;
-    const tsEnsureExsautstiveCheck = expr;
+    const tsEnsureExhautstiveCheck = expr;
     throw new Error("Invalid property access expression");
 }
+function expressifyMethodCall(ctx, methodCall) {
+    const methodPropAccess = methodCall.func;
+    if (!(methodPropAccess instanceof TirPropAccessExpr))
+        throw new Error("Invalid method call expression");
+    const methodIdentifierProp = methodPropAccess.prop;
+    const methodName = methodIdentifierProp.text;
+    const objectExpr = expressifyVars(ctx, methodPropAccess.object);
+    let objectType = objectExpr.type;
+    while (objectType instanceof TirAliasType) {
+        const aliasMethds = objectType.methodsNamesPtr;
+        const tirMethodName = aliasMethds.get(methodName);
+        if (!tirMethodName) {
+            objectType = objectType.aliased;
+            continue;
+        }
+        const funcExpr = ctx.program.functions.get(tirMethodName);
+        if (!funcExpr)
+            throw new Error(`Definition of method '${methodName}' on type '${objectType.toString()}' is missing.`);
+        return new TirCallExpr(funcExpr, [objectExpr, ...methodCall.args], methodCall.type, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
+    }
+    if (objectType instanceof TirDataStructType
+        || objectType instanceof TirSoPStructType) {
+        const structMethods = objectType.methodNamesPtr;
+        const tirMethodName = structMethods.get(methodName);
+        if (!tirMethodName)
+            throw new Error(`Method '${methodName}' does not exist on type '${objectType.toString()}'`);
+        const funcExpr = ctx.program.functions.get(tirMethodName);
+        if (!funcExpr)
+            throw new Error(`Definition of method '${methodName}' on type '${objectType.toString()}' is missing.`);
+        return new TirCallExpr(funcExpr, [objectExpr, ...methodCall.args], methodCall.type, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
+    }
+    if (objectType instanceof TirListT) {
+        const result = expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, objectType, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
+        if (result)
+            return result;
+    }
+    throw new Error(`not implemented::expressifyMethodCall for type '${objectType.toString()}' (method name: '${methodName}')`);
+    // const tsEnsureExhautstiveCheck: never = objectType;
+    throw new Error(`Cannot call method '${methodName}' on non-struct type '${objectType.toString()}'`);
+}
+function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listType, exprRange) {
+    const elemsType = getListTypeArg(listType);
+    if (!elemsType)
+        throw new Error("Invalid list type");
+    if (methodName === "length") {
+        if (methodCall.args.length !== 0)
+            throw new Error(`Method 'length' of type 'list' takes 0 arguments, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._length(elemsType), [objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "some") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'includes' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._some(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "every") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'every' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._every(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "includes") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'includes' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._some(elemsType), [
+            new TirCallExpr(TirNativeFunc._equals(elemsType), [methodCall.args[0]], new TirFuncT([elemsType], bool_t), methodCall.args[0].range),
+            objectExpr
+        ], methodCall.type, exprRange);
+    }
+    if (methodName === "head") {
+        if (methodCall.args.length !== 0)
+            throw new Error(`Method 'head' of type 'list' takes 0 arguments, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc.headList(elemsType), [objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "tail") {
+        if (methodCall.args.length !== 0)
+            throw new Error(`Method 'tail' of type 'list' takes 0 arguments, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc.tailList(elemsType), [objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "isEmpty") {
+        if (methodCall.args.length !== 0)
+            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
+    /*
+    {
+        isEmpty: new TirFuncT( [], bool_t ),
+        show: new TirFuncT( [], bytes_t ),
+        reverse: new TirFuncT( [], new TirListT( elemsType ) ),
+        find: new TirFuncT([
+            new TirFuncT( [elemsType], bool_t )
+        ], new TirSopOptT( elemsType ) ),
+        filter: new TirFuncT([
+            new TirFuncT( [elemsType], bool_t )
+        ], new TirListT( elemsType ) ),
+        prepend: new TirFuncT( [elemsType], new TirListT( elemsType ) ),
+        map: new TirFuncT([
+            new TirFuncT([ elemsType ], mapReturnT )
+        ], new TirListT( mapReturnT ) ),
+    };
+    */
+}

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/io/IOutputStream.d.ts

@@ -4,6 +4,7 @@ export interface IOutputStream {
     write(chunk: Uint8Array | string): void;
 }
 export declare class ConsoleLogStream implements IOutputStream {
+    private _pending;
     write(chunk: Uint8Array | string): void;
 }
 export declare class ConsoleErrorStream implements IOutputStream {

package/dist/compiler/io/IOutputStream.js

@@ -1,11 +1,26 @@
 import { fromUtf8, concatUint8Array, toUtf8 } from "@harmoniclabs/uint8array-utils";
 export class ConsoleLogStream {
+    _pending = "";
     write(chunk) {
-        if (chunk instanceof Uint8Array) {
-            console.log(toUtf8(chunk));
+        const newChunk = (chunk instanceof Uint8Array) ? toUtf8(chunk) : chunk.toString();
+        if (newChunk.includes("\n")) {
+            const parts = newChunk.split("\n");
+            if (parts.length === 1) {
+                // only one \n
+                console.log(this._pending + parts[0]);
+                this._pending = "";
+            }
+            else {
+                // multiple \n
+                console.log(this._pending + parts[0]);
+                for (let i = 1; i < parts.length - 1; i++) {
+                    console.log(parts[i]);
+                }
+                this._pending = parts[parts.length - 1];
+            }
         }
         else {
-            console.log(chunk.toString());
+            this._pending += newChunk;
         }
     }
 }

package/dist/compiler/path/getAbsolutePath.js

@@ -58,17 +58,15 @@ export function getEnvRelativePath(filePath, projectRoot) {
     if (!(typeof filePath === 'string' &&
         typeof projectRoot === 'string'))
         return undefined;
+    projectRoot = projectRoot.trim();
+    if (!projectRoot.endsWith(PATH_DELIMITER))
+        projectRoot += PATH_DELIMITER;
     if (isAbsolutePath(filePath))
         return filePath;
-    projectRoot = projectRoot.trim();
     filePath = getAbsolutePath(filePath.trim(), projectRoot);
     if (!filePath)
         return undefined;
-    if (!projectRoot.endsWith(PATH_DELIMITER))
-        projectRoot = projectRoot + PATH_DELIMITER;
-    while (filePath.startsWith(PATH_DELIMITER))
-        filePath = filePath.slice(PATH_DELIMITER.length);
-    return projectRoot + filePath;
+    return filePath.startsWith(projectRoot) ? filePath : projectRoot + filePath;
 }
 /**
  * Takes a relative path and an absolute path, and returns the absolute path

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

@@ -8,4 +8,6 @@ export interface ITirExpr extends HasSourceRange {
     deps: () => string[];
     toIR: (ctx: ToIRTermCtx) => IRTerm;
     clone: () => ITirExpr;
+    toString: () => string;
+    pretty: (indent: number) => string;
 }