@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev7

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

@@ -85,6 +85,7 @@ export declare class TirNativeFunc implements ITirExpr {
     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;

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";
@@ -673,6 +673,14 @@ export class TirNativeFunc {
             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<elemT>
+            new TirListT(elems_t)
+        ], new TirSopOptT(elems_t)));
+    }
     static _length(elemT) {
         return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
             // list

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,

package/dist/compiler/tir/statements/TirIfStmt.d.ts

@@ -6,7 +6,6 @@ export declare class TirIfStmt implements ITirStmt {
     thenBranch: TirStmt;
     elseBranch: TirStmt | undefined;
     readonly range: SourceRange;
-    private _creationStack?;
     constructor(condition: TirExpr, thenBranch: TirStmt, elseBranch: TirStmt | undefined, range: SourceRange);
     toString(): string;
     pretty(indent: number): string;

package/dist/compiler/tir/statements/TirIfStmt.js

@@ -4,13 +4,11 @@ export class TirIfStmt {
     thenBranch;
     elseBranch;
     range;
-    _creationStack;
     constructor(condition, thenBranch, elseBranch, range) {
         this.condition = condition;
         this.thenBranch = thenBranch;
         this.elseBranch = elseBranch;
         this.range = range;
-        this._creationStack = new Error().stack;
     }
     toString() {
         return (`if( ${this.condition.toString()} ) ` +
@@ -29,7 +27,6 @@ export class TirIfStmt {
             (this.elseBranch ? ` else ${this.elseBranch.pretty(indent)}` : ""));
     }
     definitelyTerminates() {
-        console.log(this._creationStack);
         return (this.thenBranch.definitelyTerminates()
             && (this.elseBranch?.definitelyTerminates() ?? false));
     }

package/dist/parser/Parser.js

@@ -1139,7 +1139,9 @@ export class Parser extends DiagnosticEmitter {
         // precedence climbing
         // see: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#climbing
         let nextPrecedence;
-        while ((nextPrecedence = determinePrecedence(tn.peek())) >= precedence) {
+        let prevState;
+        outer_while: while ((nextPrecedence = determinePrecedence(tn.peek())) >= precedence) {
+            prevState = tn.mark();
             const token = tn.next();
             // DO NOT DIRECTLY RETURN FROM HERE
             // we need to loop to support right associative operators
@@ -1320,6 +1322,11 @@ export class Parser extends DiagnosticEmitter {
                         expr = makeBinaryExpr(token, expr, next, tn.range(startPos, tn.pos));
                         break;
                     }
+                // comma operator handled in caller (only valid in for statements)
+                case Token.Comma: {
+                    tn.reset(prevState);
+                    break outer_while;
+                }
                 default: {
                     return this.error(DiagnosticCode.Expression_expected, tn.range());
                 }
@@ -2016,6 +2023,12 @@ export class Parser extends DiagnosticEmitter {
             case Token.Question_Question_Equals: {
                 return this.error(DiagnosticCode.Not_implemented_0, tn.range(), "??=");
             }
+            case Token.Plus_Plus: {
+                return makeAssignmentStmt(varIdentifier, Token.Plus_Equals, new LitIntExpr(BigInt(1), tn.range()), tn.range(startPos, tn.pos));
+            }
+            case Token.Minus_Minus: {
+                return makeAssignmentStmt(varIdentifier, Token.Minus_Equals, new LitIntExpr(BigInt(1), tn.range()), tn.range(startPos, tn.pos));
+            }
             default: {
                 return this.error(DiagnosticCode._0_expected, tn.range(), "=");
             }
@@ -2180,8 +2193,11 @@ export class Parser extends DiagnosticEmitter {
                     return this.error(DiagnosticCode.Invalid_for_statement_update, update.range);
                 updates.push(update);
             } while (tn.skip(Token.Comma)); // comma expression (allowed only in for update part)
-            if (!tn.skip(Token.CloseParen))
+            if (!tn.skip(Token.CloseParen)) {
+                const next = tn.peek();
+                console.error('next token after for updates:', Token[next]);
                 return this.error(DiagnosticCode._0_expected, tn.range(), ")");
+            }
         }
         const body = this.parseStatement();
         if (!body)

package/dist/parser/Precedence.js

@@ -89,6 +89,7 @@ export function determinePrecedence(kind) {
         case Token.Plus_Plus:
         case Token.Minus_Minus: return Precedence.UnaryPostfix;
         case Token.Dot:
+        case Token.Exclamation_Dot:
         case Token.Question_Dot:
         case Token.OpenBracket:
         case Token.Exclamation: return Precedence.MemberAccess;

package/dist/utils/array/keepSortedArrInplace.js

@@ -21,6 +21,7 @@ export function keepSortedStrArrInplace(target, source) {
                 target.length = i + 1; // truncate target to current index
                 return target; // no more elements to keep
             }
+            continue; // element is in source, check next without removing this
         }
         // not equal, remove the element
         target.splice(i, 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.0-dev6",
+  "version": "0.1.0-dev7",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,6 +20,7 @@
     "build-and-replace": "npm run build && cp -r ./dist ../pebble-cli/node_modules/@harmoniclabs/pebble",
     "genDiagnosticMessages": "node ./scripts/genDiagnosticMessages.js",
     "test": "jest",
+    "test-dbg": "node --nolazy --inspect-brk ./node_modules/jest/bin/jest.js --runInBand --colors --verbose",
     "test:debug": "node --nolazy --inspect-brk ./node_modules/jest/bin/jest.js --runInBand --colors --verbose",
     "clear-jest": "jest --clearCache",
     "test-watch": "jest --watchman",

package/dist/compiler/TirCompiler/internal/_compileHoistedDeps.d.ts

@@ -1,5 +0,0 @@
-import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
-import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
-import { TypedProgram } from "../../tir/program/TypedProgram.js";
-import { DepsNode } from "./deps/DepsNode.js";
-export declare function _compileHoistedDeps(program: TypedProgram, hoistedMap: Map<string, TirHoistedExpr | TirNativeFunc>, deps: string[], depsStack: DepsNode): void;

package/dist/compiler/TirCompiler/internal/_compileHoistedDeps.js

@@ -1,39 +0,0 @@
-import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
-import { ExpressifyCtx } from "../expressify/ExpressifyCtx.js";
-import { expressifyVars } from "../expressify/expressifyVars.js";
-export function _compileHoistedDeps(program, hoistedMap, deps, depsStack) {
-    let depName;
-    if (deps.some(dep => depsStack.includes(dep)))
-        throw new Error("Circular dependency in hoisted expressions NOT YET IMPLEMENTED");
-    while (depName = deps.pop()) {
-        const funcDecl = program.functions.get(depName);
-        if (funcDecl) {
-            _compileHoistedDeps(program, hoistedMap, funcDecl.deps(), depsStack.getNext(depName));
-            /*
-            const funcExpr = funcDecl instanceof TirInlineClosedIR ? funcDecl : expressify(
-                funcDecl,
-                undefined, // loopReplacements
-                program,
-                new ExpressifyCtx(
-                    undefined,
-                    funcDecl.returnType,
-                    program,
-                    hoistedMap
-                )
-            );
-            //*/
-            const hoistedExpr = new TirHoistedExpr(depName, funcDecl);
-            hoistedMap.set(depName, hoistedExpr);
-            continue;
-        }
-        const constDecl = program.constants.get(depName);
-        if (constDecl) {
-            _compileHoistedDeps(program, hoistedMap, constDecl.deps(), depsStack.getNext(depName));
-            const expr = expressifyVars(new ExpressifyCtx(undefined, constDecl.type, program, hoistedMap), constDecl);
-            const hoistedExpr = new TirHoistedExpr(depName, expr);
-            hoistedMap.set(depName, hoistedExpr);
-            continue;
-        }
-        throw new Error(`Hoisted dependency "${depName}" not found in program`);
-    }
-}