@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev8

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({
@@ -380,7 +384,7 @@ function expressifyMethodCall(ctx, methodCall) {
     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);
+    const elemsType = getUnaliased(getListTypeArg(listType));
     if (!elemsType)
         throw new Error("Invalid list type");
     if (methodName === "length") {
@@ -421,22 +425,53 @@ 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);
+    }
+    if (methodName === "filter") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'filter' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._filter(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "prepend") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'prepend' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc.mkCons(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "map") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'map' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        const arg = methodCall.args[0];
+        const argFuncType = getUnaliased(arg.type);
+        if (!(argFuncType instanceof TirFuncT))
+            throw new Error(`Argument 1 of method 'map' of type 'list' must be a function, got '${arg.type.toString()}'`);
+        const mapReturnT = argFuncType.returnType;
+        const elemTypeTirName = elemsType.toTirTypeKey();
+        let base_mapToType = _base_mapToType_cache.get(elemTypeTirName)?.clone();
+        if (!base_mapToType) {
+            base_mapToType = new TirHoistedExpr("_map_to_list_of_" + elemTypeTirName, new TirCallExpr(TirNativeFunc._mkMap(elemsType, mapReturnT), [new TirLitArrExpr([], new TirListT(mapReturnT), SourceRange.unknown)], new TirFuncT([
+                // mapping function
+                new TirFuncT([
+                    elemsType
+                ], mapReturnT),
+                // list to map over
+                new TirListT(elemsType)
+            ], new TirListT(mapReturnT)), SourceRange.unknown));
+            base_mapToType.varName; // precompute hash and symbol
+            _base_mapToType_cache.set(elemTypeTirName, base_mapToType.clone());
+        }
+        return new TirCallExpr(base_mapToType, [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 ) ),
     };
     */
 }
+const _base_mapToType_cache = new Map();

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) {

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

@@ -84,11 +84,12 @@ export declare class TirNativeFunc implements ITirExpr {
     static _dropList(elemT: TirType): TirNativeFunc;
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
-    static _mkFindDataOptional(elems_t: TirType): TirNativeFunc;
+    static _findSopOptional(elems_t: TirType): TirNativeFunc;
     static _length(elemT: TirType): TirNativeFunc;
     static _some(elemT: TirType): TirNativeFunc;
     static _every(elemT: TirType): TirNativeFunc;
-    static _mkFilter(elemT: TirType): TirNativeFunc;
+    static _filter(elemT: TirType): TirNativeFunc;
+    static _mkMap(elemT: TirType, returnElemT: TirType): TirNativeFunc;
     static _id(t: TirType): TirNativeFunc;
     static get _not(): TirNativeFunc;
     static get _strictAnd(): TirNativeFunc;

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

@@ -2,7 +2,7 @@ import { SourceRange } from "../../../ast/Source/SourceRange.js";
 import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { bool_t, bytes_t, data_t, int_t, void_t } from "../program/stdScope/stdScope.js";
-import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT } from "../types/TirNativeType/index.js";
+import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT } from "../types/TirNativeType/index.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
 import { TirListT } from "../types/TirNativeType/native/list.js";
@@ -663,15 +663,26 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], returnT));
     }
-    static _mkFindDataOptional(elems_t) {
-        return new TirNativeFunc(IRNativeTag._mkFindDataOptional, new TirFuncT([
-            // elem -> data
-            new TirFuncT([elems_t], data_t),
-            // elem -> bool (predicate)
+    // static _mkFindDataOptional(elems_t: TirType): TirNativeFunc {
+    //     return new TirNativeFunc(
+    //         IRNativeTag._mkFindDataOptional,
+    //         new TirFuncT([
+    //             // elem -> data
+    //             new TirFuncT([ elems_t ], data_t),
+    //             // elem -> bool (predicate)
+    //             new TirFuncT([ elems_t ], bool_t),
+    //             // List<elem>
+    //             new TirListT(elems_t)
+    //         ], new TirDataOptT(elems_t))
+    //     );
+    // }
+    static _findSopOptional(elems_t) {
+        return new TirNativeFunc(IRNativeTag._findSopOptional, new TirFuncT([
+            // predicate: (elemT) => bool
             new TirFuncT([elems_t], bool_t),
-            // List<elem>
+            // list<elemT>
             new TirListT(elems_t)
-        ], new TirDataOptT(elems_t)));
+        ], new TirSopOptT(elems_t)));
     }
     static _length(elemT) {
         return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
@@ -697,10 +708,8 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], bool_t));
     }
-    static _mkFilter(elemT) {
-        return new TirNativeFunc(IRNativeTag._mkFilter, new TirFuncT([
-            // pnilOfType: an empty list with the right element type
-            new TirListT(elemT),
+    static _filter(elemT) {
+        return new TirNativeFunc(IRNativeTag._filter, new TirFuncT([
             // predicate
             new TirFuncT([
                 elemT
@@ -709,6 +718,18 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], new TirListT(elemT)));
     }
+    static _mkMap(elemT, returnElemT) {
+        return new TirNativeFunc(IRNativeTag._mkMapList, new TirFuncT([
+            // nil of return elem type
+            new TirListT(returnElemT),
+            // mapping function
+            new TirFuncT([
+                elemT
+            ], returnElemT),
+            // list to map over
+            new TirListT(elemT)
+        ], new TirListT(returnElemT)));
+    }
     static _id(t) {
         return new TirNativeFunc(IRNativeTag._id, new TirFuncT([t], t));
     }

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

@@ -32,7 +32,6 @@ export class TirPropAccessExpr {
     }
     get isConstant() { return false; }
     toIR(ctx) {
-        console.log(this);
-        throw new Error("property access cannot be translated to IR");
+        throw new Error("property access cannot be translated to IR (missed expressify). Expr: " + this.toString());
     }
 }

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

@@ -9,7 +9,6 @@ import { ToIRTermCtx } from "./ToIRTermCtx.js";
 export declare class TirVariableAccessExpr implements ITirExpr {
     readonly range: SourceRange;
     readonly resolvedValue: Readonly<ResolveValueResult>;
-    private readonly _creationStack;
     get type(): TirType;
     constructor(resolvedValue: ResolveValueResult, range: SourceRange);
     toString(): string;

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

@@ -3,14 +3,12 @@ import { IRVar } from "../../../IR/IRNodes/IRVar.js";
 export class TirVariableAccessExpr {
     range;
     resolvedValue;
-    _creationStack;
     get type() {
         return this.resolvedValue.variableInfos.type;
     }
     constructor(resolvedValue, range) {
         this.range = range;
         this.resolvedValue = Object.freeze(resolvedValue);
-        this._creationStack = (new Error()).stack;
     }
     toString() {
         return this.varName;
@@ -21,7 +19,14 @@ export class TirVariableAccessExpr {
         return `${this.varName}`;
     }
     clone() {
-        return new TirVariableAccessExpr(this.resolvedValue, this.range.clone());
+        return new TirVariableAccessExpr({
+            ...this.resolvedValue,
+            variableInfos: {
+                ...this.resolvedValue.variableInfos,
+                type: this.resolvedValue.variableInfos.type.clone()
+            },
+            // isDefinedOutsideFuncScope: this.resolvedValue.isDefinedOutsideFuncScope
+        }, this.range.clone());
     }
     get isConstant() { return false; }
     get varName() {
@@ -32,8 +37,7 @@ export class TirVariableAccessExpr {
         const ir = ctx.getVarAccessIR(this.varName);
         if (!(ir instanceof IRVar
             || ir instanceof IRSelfCall)) {
-            console.log(this.resolvedValue);
-            throw new Error(`variable '${this.varName}' is missing`);
+            throw new Error(`variable '${this.varName}' is missing in [${ctx.allVariables().join(", ")}]`);
         }
         return ir;
     }

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

@@ -2,9 +2,12 @@ import { IRVar } from "../../../IR/IRNodes/IRVar.js";
 import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
 export declare class ToIRTermCtx {
     readonly parent: ToIRTermCtx | undefined;
+    readonly _creationStack?: string | undefined;
     private readonly localVars;
     private _firstVariableIsRecursive;
+    _children: ToIRTermCtx[];
     constructor(parent: ToIRTermCtx | undefined);
+    localVariables(): string[];
     allVariables(): string[];
     static root(): ToIRTermCtx;
     newChild(): ToIRTermCtx;

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

@@ -3,19 +3,26 @@ import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
 const _1n = BigInt(1);
 export class ToIRTermCtx {
     parent;
+    _creationStack;
     localVars = new Map();
     _firstVariableIsRecursive = false;
+    _children = [];
     constructor(parent) {
         this.parent = parent;
+        this.parent?._children.push(this);
+        this._creationStack = new Error().stack;
         this.localVars = new Map();
         // DO NOT SET _parentDbn HERE
         // it must be a getter to reflect changes in parent
         // (parent dbn can change)
         this._firstVariableIsRecursive = false;
     }
+    localVariables() {
+        return [...this.localVars.keys()];
+    }
     allVariables() {
         return ((this.parent?.allVariables() ?? [])
-            .concat([...this.localVars.keys()]));
+            .concat([...this.localVariables()]));
     }
     static root() {
         return new ToIRTermCtx(undefined);

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.d.ts

@@ -105,6 +105,7 @@ export declare class TirAddExpr implements ITirBinaryExpr {
     left: TirExpr;
     right: TirExpr;
     readonly range: SourceRange;
+    private _creationStack;
     get type(): TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
     toString(): string;

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.js

@@ -277,15 +277,17 @@ export class TirNotEqualExpr {
         return deps;
     }
 }
+let n_logs = 0;
 export class TirAddExpr {
     left;
     right;
     range;
+    _creationStack;
     get type() {
         const leftType = getUnaliased(this.left.type);
         if (leftType instanceof TirIntT
             || leftType instanceof TirBytesT)
-            return this.type;
+            return leftType;
         throw new Error("invalid type for addition");
     }
     constructor(left, right, range) {
@@ -297,6 +299,9 @@ export class TirAddExpr {
         return `(${this.left.toString()} + ${this.right.toString()})`;
     }
     pretty(indent) {
+        n_logs++;
+        if (!(n_logs % 100))
+            console.log(this);
         const singleIndent = "  ";
         const indent_base = singleIndent.repeat(indent);
         return `(${this.left.pretty(indent)} + ${this.right.pretty(indent)})`;

package/dist/compiler/tir/program/TypedProgram.d.ts

@@ -2,9 +2,9 @@ import { DiagnosticEmitter } from "../../../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticMessage } from "../../../diagnostics/DiagnosticMessage.js";
 import { AstScope } from "../../AstCompiler/scope/AstScope.js";
 import { UidGenerator } from "../../internalVar.js";
-import { TirExpr } from "../expressions/TirExpr.js";
 import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
 import { TirInlineClosedIR } from "../expressions/TirInlineClosedIR.js";
+import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirType } from "../types/TirType.js";
 import { StdTypes } from "./stdScope/StdTypes.js";
 export interface IGenericType {
@@ -17,7 +17,7 @@ export interface IGenericType {
  * TODO: support libraries
  */
 export declare class TypedProgram extends DiagnosticEmitter {
-    readonly constants: Map<string, TirExpr>;
+    readonly constants: Map<string, TirSimpleVarDecl>;
     readonly functions: Map<string, TirFuncExpr | TirInlineClosedIR>;
     readonly types: Map<string, TirType>;
     private readonly genericTypes;

package/dist/compiler/tir/program/stdScope/stdScope.js

@@ -139,7 +139,7 @@ export function populatePreludeScope(program) {
         return { sop, data };
     }
     function defineMultiConstructorStruct(name, constrs, opts, methodsNames = new Map()) {
-        const { sop, data } = mkMultiConstructorStruct(name, constrs);
+        const { sop, data } = mkMultiConstructorStruct(name, constrs, methodsNames);
         const sop_key = sop.toTirTypeKey();
         const data_key = data.toTirTypeKey();
         if (opts.sop)
@@ -166,6 +166,7 @@ export function populatePreludeScope(program) {
         id: txHash_t,
         index: int_t
     }, onlyData);
+    const getCredentialHashFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "getCredentialHash";
     const { data: credential_t } = defineMultiConstructorStruct("Credential", {
         PubKey: {
             hash: pubKeyHash_t
@@ -173,28 +174,13 @@ export function populatePreludeScope(program) {
         Script: {
             hash: scriptHash_t
         }
-    }, onlyData);
-    // TODO: 
-    // understand how to describe function impls
-    // const credential_t_impl = new TirInterfaceType(
-    //     undefined,
-    //     [],
-    //     []
-    // )
-    // credential_t_impl.methods.push(
-    //     new TirInterfaceMethod(
-    //         credential_t_impl,
-    //         "hash",
-    //         [],
-    //         hash28_t
-    //     )
-    // );
-    // credential_t.impls.push(
-    //     new TirInterfaceImpl(
-    //         credential_t,
-    //         credential_t_impl
-    //     )
-    // );
+    }, onlyData, new Map([
+        [
+            "hash",
+            getCredentialHashFuncName
+        ],
+    ]));
+    preludeScope.program.functions.set(getCredentialHashFuncName, new TirInlineClosedIR(new TirFuncT([credential_t], hash28_t), (ctx) => IRNative._getCredentialsHash, SourceRange.unknown));
     const changeParams_t = _defineUnambigousAlias("ChangedParameters", map_int_data_t);
     const { data: rational_t } = defineSingleConstructorStruct("Rational", {
         numerator: int_t,