@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

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

@@ -34,6 +34,7 @@ export function determineReassignedVariablesAndReturn(stmt) {
             returns = true;
             continue;
         }
+        // TODO: can optimize list iterations
         if (stmt instanceof TirAssignmentStmt) {
             reassignedSet.add(stmt.varIdentifier.varName);
             continue;
@@ -235,8 +236,16 @@ export function getBodyStateType({ sop, initState }, stmt) {
     for (const { name, type, range, initExpr, isConst } of stmt.init) {
         if (!initExpr)
             throw new Error("loop init variable requires initialization expression");
-        // TODO: optimize for `isConst`
-        const uniqueFieldName = getUniqueInternalName(name);
+        // using `getUniqueInternalName` here messes up variable access later
+        // due to how for statements are expressified (see piece of code from expressifyForStmt)
+        // ```
+        // // define loop function parameters
+        // for( const { name, type } of bodyStateType.constructors[0].fields ) {
+        //     loopCompilationCtx.setFuncParam( name, type );
+        // }
+        // ```
+        // the introduced vars are taken from the bodyStateType that we derive here
+        const uniqueFieldName = name; // getUniqueInternalName( name );
         bodyStateConstr.fields.push(new TirStructField(uniqueFieldName, type));
         initState.fieldNames.push(new Identifier(uniqueFieldName, range));
         initState.values.push(initExpr);

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

@@ -6,7 +6,8 @@ import { TirContinueStmt } from "../../tir/statements/TirContinueStmt.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
 import { TirStmt } from "../../tir/statements/TirStmt.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
-export declare function expressify(func: TirFuncExpr, loopReplacements: LoopReplacements | undefined, parentCtx?: ExpressifyCtx | undefined): void;
+import { TypedProgram } from "../../tir/program/TypedProgram.js";
+export declare function expressify(func: TirFuncExpr, loopReplacements: LoopReplacements | undefined, program: TypedProgram, parentCtx?: ExpressifyCtx | undefined): void;
 export interface LoopReplacements {
     readonly replaceReturnValue: (ctx: ExpressifyCtx, stmt: TirReturnStmt) => TirExpr;
     readonly compileBreak: (ctx: ExpressifyCtx, stmt: TirBreakStmt) => TirExpr;

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

@@ -33,14 +33,14 @@ import { expressifyTerminatingIfStmt } from "./expressifyTerminatingIfStmt.js";
 import { determineReassignedVariablesAndFlowInfos, determineReassignedVariablesAndReturn, getBodyStateType, getBranchStmtReturnType } from "./determineReassignedVariablesAndReturn.js";
 import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
 import { expressifyIfBranch } from "./expressifyIfBranch.js";
-import { expressifyForStmt, whileToFor } from "./expressifyForStmt.js";
+import { expressifyForStmt, loopToForStmt } from "./expressifyForStmt.js";
 import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
 import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
 import { TirLitIntExpr } from "../../tir/expressions/litteral/TirLitIntExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
 import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
-export function expressify(func, loopReplacements, parentCtx = undefined) {
-    const ctx = new ExpressifyCtx(parentCtx, func.returnType);
+export function expressify(func, loopReplacements, program, parentCtx = undefined) {
+    const ctx = new ExpressifyCtx(parentCtx, func.returnType, program);
     ctx.introduceFuncParams(func.params);
     func.body.stmts = [
         new TirReturnStmt(expressifyFuncBody(ctx, func.body.stmts, loopReplacements), func.body.range)
@@ -52,6 +52,8 @@ loopReplacements, assertions = []) {
     bodyStmts = bodyStmts.slice();
     let stmt;
     while (stmt = bodyStmts.shift()) {
+        // console.log([stmt, ...bodyStmts].map(s => s.toString()));
+        // console.log( stmt );
         if (stmt instanceof TirBreakStmt) {
             if (typeof loopReplacements?.compileBreak !== "function")
                 throw new Error("break statement in function body.");
@@ -71,8 +73,9 @@ loopReplacements, assertions = []) {
                 stmt.value = modifiedExpr;
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, modifiedExpr);
             }
-            else
+            else {
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(stmt.range));
+            }
         }
         // if( isTirVarDecl( stmt ) ) expressifyVarDecl( ctx, stmt );
         else if (stmt instanceof TirSimpleVarDecl) {
@@ -81,6 +84,10 @@ loopReplacements, assertions = []) {
             const initExpr = expressifyVars(ctx, stmt.initExpr);
             stmt.initExpr = initExpr;
             const lettedExpr = ctx.introduceLettedConstant(stmt.name, initExpr, stmt.range);
+            if (!stmt.isConst) {
+                // console.log("setting variable")
+                ctx.setNewVariableName(stmt.name, lettedExpr.varName);
+            }
             if (!isSingleConstrStruct(stmt.type))
                 continue;
             if ((initExpr instanceof TirVariableAccessExpr || initExpr instanceof TirLettedExpr)
@@ -128,9 +135,12 @@ loopReplacements, assertions = []) {
                         .concat(bodyStmts), loopReplacements), stmt.range)], new TirWildcardCaseMatcher(new TirFailExpr(undefined, ctx.returnType, stmt.range), stmt.range), ctx.returnType, stmt.range));
             }
             else if (stmt.type instanceof TirDataStructType) {
-                assertions.push(...ctx.introduceDeconstrDataLettedFields(toNamedDeconstructVarDecl(stmt)));
+                const { implicitAssertions, nestedDeconstructs } = ctx.introduceDeconstrDataLettedFields(stmt, lettedExpr);
+                assertions.push(...implicitAssertions);
+                bodyStmts.unshift(...nestedDeconstructs);
                 continue;
             }
+            throw new Error("deconstruction of non-struct type" + stmt.type.toString());
         }
         else if (stmt instanceof TirArrayLikeDeconstr) {
             if (!stmt.initExpr)
@@ -175,8 +185,10 @@ loopReplacements, assertions = []) {
             bodyStmts.push(...nextDeclarations);
             continue;
         }
-        else if (stmt instanceof TirAssignmentStmt)
+        else if (stmt instanceof TirAssignmentStmt) {
             bodyStmts.unshift(expressifyVarAssignmentStmt(ctx, stmt));
+            continue;
+        }
         else if (stmt instanceof TirBlockStmt) {
             // inline the block
             bodyStmts = stmt.stmts.concat(bodyStmts);
@@ -188,8 +200,9 @@ loopReplacements, assertions = []) {
                 stmt.failMsgExpr = modifiedExpr;
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(modifiedExpr, ctx.returnType, stmt.range));
             }
-            else
+            else {
                 return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirFailExpr(undefined, ctx.returnType, stmt.range));
+            }
         }
         else if (stmt instanceof TirAssertStmt) {
             const condition = expressifyVars(ctx, stmt.condition);
@@ -239,7 +252,7 @@ loopReplacements, assertions = []) {
             const stmtExpr = new TirTernaryExpr(condition, expressifyIfBranch(ctx.newChild(), stmt.thenBranch, reassignsAndReturns.reassigned, sop, loopReplacements), stmt.elseBranch ? expressifyIfBranch(ctx.newChild(), stmt.elseBranch, reassignsAndReturns.reassigned, sop, loopReplacements) : initState, // no else branch means the variables stay unchanged
             sop, stmt.range);
             // expressify as ternary that returns the SoP type
-            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, getFinalStmtCaseExpr(stmtExpr, sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, wrapNonTerminatingFinalStmtAsCaseExpr(stmtExpr, sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
         }
         else if (stmt instanceof TirMatchStmt) {
             /**
@@ -272,9 +285,8 @@ loopReplacements, assertions = []) {
             const reassignsAndReturns = determineReassignedVariablesAndReturn(stmt);
             if (isDirectReturn) {
                 // build a SoP type to return
-                const { sop, initState } = getBranchStmtReturnType(reassignsAndReturns, ctx, stmt.range);
-                // expressify as ternary that returns the SoP type
-                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, getFinalStmtCaseExpr(new TirCaseExpr(expressifyVars(ctx, stmt.matchExpr), stmt.cases.map(_case => {
+                // const { sop, initState } = getBranchStmtReturnType( reassignsAndReturns, ctx, stmt.range );
+                const finalExpression = new TirCaseExpr(expressifyVars(ctx, stmt.matchExpr), stmt.cases.map(_case => {
                     if (_case.pattern instanceof TirArrayLikeDeconstr)
                         throw new Error("array-like deconstruction in match statement is not supported");
                     _case.pattern = toNamedDeconstructVarDecl(_case.pattern);
@@ -282,43 +294,77 @@ loopReplacements, assertions = []) {
                     flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(_case.pattern, caseCtx);
                     const caseBody = expressifyFuncBody(caseCtx, _case.body instanceof TirBlockStmt
                         ? _case.body.stmts
-                        : [_case.body], loopReplacements, assertions);
+                        : [_case.body], loopReplacements, []);
                     return new TirCaseMatcher(_case.pattern, caseBody, _case.range);
                 }), stmt.wildcardCase ? new TirWildcardCaseMatcher(expressifyFuncBody(ctx.newChild(), stmt.wildcardCase.body instanceof TirBlockStmt
                     ? stmt.wildcardCase.body.stmts
-                    : [stmt.wildcardCase.body], loopReplacements, []), stmt.wildcardCase.range) : undefined, ctx.returnType, stmt.range), sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
-            }
-        }
-        else if (stmt instanceof TirForOfStmt) {
-            // determine affected variables
-            // determine if we may have an early return
-            // determine if we can break or continue
-            const reassignedAndFlow = determineReassignedVariablesAndFlowInfos(stmt);
-            const { reassigned, returns, canBreak, canContinue } = reassignedAndFlow;
-            const { sop, initState } = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
-            if (!returns
-                && !canBreak
-            // && !canContinue
-            ) {
-                // **only for...of** can be optimized as a simple `.reduce`
-                // producing the new state in this case
-                // (`.reduce` has no way to break or early return (efficiently))
-                // continue is ok, because we only need to pass the state up to that point
+                    : [stmt.wildcardCase.body], loopReplacements, []), stmt.wildcardCase.range) : undefined, ctx.returnType, stmt.range);
+                // expressify as ternary that returns the SoP type
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, 
+                // isDirectReturn === true, so we don't need to wrap
+                finalExpression
+                /*
+                true ? finalExpression : wrapNonTerminatingFinalStmtAsCaseExpr(
+                    finalExpression,
+                    sop,
+                    ctx,
+                    stmt.range,
+                    reassignsAndReturns,
+                    bodyStmts,
+                    loopReplacements
+                )
+                //*/
+                );
             }
+            throw new Error("match statement with multiple non-terminating cases is not implemented yet (sorry)");
         }
+        // else if( stmt instanceof TirForOfStmt ) {
+        // 
+        //     const definitelyTerminates = stmt.definitelyTerminates();
+        // 
+        //     // determine affected variables
+        //     // determine if we may have an early return
+        //     // determine if we can break or continue
+        //     const reassignedAndFlow = determineReassignedVariablesAndFlowInfos( stmt );
+        //     const {
+        //         reassigned,
+        //         returns,
+        //         canBreak,
+        //         canContinue
+        //     } = reassignedAndFlow;
+        //     const { sop, initState } = getBranchStmtReturnType( reassignedAndFlow, ctx, stmt.range );
+        // 
+        //     if(
+        //         !returns
+        //         && !canBreak
+        //         // && !canContinue
+        //     ) {
+        //         // **only for...of** can be optimized as a simple `.reduce`
+        //         // producing the new state in this case
+        //         // (`.reduce` has no way to break or early return (efficiently))
+        //         // continue is ok, because we only need to pass the state up to that point
+        //     }
+        // 
+        // }
         else if (stmt instanceof TirForStmt
-            || stmt instanceof TirWhileStmt) {
+            || stmt instanceof TirWhileStmt
+            || stmt instanceof TirForOfStmt) {
+            const definitelyTerminates = stmt.definitelyTerminates();
             const reassignedAndFlow = determineReassignedVariablesAndFlowInfos(stmt);
             const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
-            const forStmt = whileToFor(stmt);
+            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));
         }
         else {
-            const tsEnsureExsautstiveCheck = stmt;
-            console.error(stmt);
-            throw new Error("unreachable::expressify::stmt");
+            // const tsEnsureExhautstiveCheck: never = stmt;
+            // console.error( stmt );
+            // throw new Error("unreachable::expressify::stmt");
         }
+        const tsEnsureExhautstiveCheck = stmt;
+        console.error(stmt);
+        throw new Error("unreachable::expressify::stmt");
     }
     return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, new TirLitVoidExpr(SourceRange.mock));
 }
@@ -355,7 +401,7 @@ function getNestedDestructsInSingleSopDestructPattern(pattern) {
     }
     return result;
 }
-function getFinalStmtCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
+function wrapNonTerminatingFinalStmtAsCaseExpr(finalStmtExpr, sop, ctx, stmtRange, reassignsAndReturns, nextBodyStmts, loopReplacements) {
     const continuations = [];
     const contBranchCtx = ctx.newChild();
     const contConstr = sop.constructors[0];

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

@@ -1,8 +1,9 @@
 import { TirLitNamedObjExpr } from "../../tir/expressions/litteral/TirLitNamedObjExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
+import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
 import { TirSoPStructType } from "../../tir/types/TirStructType.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
-export declare function whileToFor(stmt: TirWhileStmt | TirForStmt): TirForStmt;
+export declare function loopToForStmt(stmt: TirWhileStmt | TirForOfStmt | TirForStmt): TirForStmt;
 export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr): TirCallExpr;

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

@@ -3,20 +3,63 @@ 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) {
+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,13 +68,19 @@ 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);
+    if (stmt.condition) {
+        loopBody.stmts.push(new TirContinueStmt(loopBody.range.atEnd()));
+        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);
+    }
+    // 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);

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

@@ -7,7 +7,7 @@ export function expressifyVarAssignmentStmt(ctx, stmt) {
     const originalName = stmt.varIdentifier.resolvedValue.variableInfos.name;
     const latestVarNameSSA = ctx.variables.get(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;

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

@@ -6,6 +6,7 @@ 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) {

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,7 +83,7 @@ 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;
@@ -90,7 +98,7 @@ export function expressifyVars(ctx, expr) {
         // resovledVariable instanceof TirVariableAccessExpr
         return resolvedVariable;
     }
-    if (isUnaryPrefixExpr(expr)) {
+    if (isTirUnaryPrefixExpr(expr)) {
         const modifiedExpr = expressifyVars(ctx, expr.operand);
         expr.operand = modifiedExpr;
         return expr;
@@ -102,10 +110,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 +210,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
@@ -244,6 +262,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);
@@ -288,8 +307,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 +336,107 @@ 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);
+    }
+    // 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/internal/_compileHoistedDeps.js

@@ -13,9 +13,11 @@ export function _compileHoistedDeps(program, hoistedMap, deps, depsStack) {
             const funcExpr = funcDecl instanceof TirInlineClosedIR ? funcDecl : expressify(
                 funcDecl,
                 undefined, // loopReplacements
+                program,
                 new ExpressifyCtx(
                     undefined,
                     funcDecl.returnType,
+                    program,
                     hoistedMap
                 )
             );
@@ -27,7 +29,7 @@ export function _compileHoistedDeps(program, hoistedMap, deps, depsStack) {
         const constDecl = program.constants.get(depName);
         if (constDecl) {
             _compileHoistedDeps(program, hoistedMap, constDecl.deps(), depsStack.getNext(depName));
-            const expr = expressifyVars(new ExpressifyCtx(undefined, constDecl.type, hoistedMap), constDecl);
+            const expr = expressifyVars(new ExpressifyCtx(undefined, constDecl.type, program, hoistedMap), constDecl);
             const hoistedExpr = new TirHoistedExpr(depName, expr);
             hoistedMap.set(depName, hoistedExpr);
             continue;

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 {