@harmoniclabs/pebble 0.1.2 → 0.1.3-dev0

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -11,6 +11,7 @@ export declare const hoisted_isTwo: IRHoisted;
 export declare const hoisted_isThree: IRHoisted;
 export declare const hoisted_addOne: IRHoisted;
 export declare const hoisted_subOne: IRHoisted;
+export declare const hoisted_negateInteger: IRHoisted;
 export declare const hoisted_isPositive: IRHoisted;
 export declare const hoisted_isNonNegative: IRHoisted;
 export declare const hoisted_matchList: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -17,6 +17,7 @@ import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
 import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
 import { IRConstr } from "../../../IRNodes/index.js";
+import { _ir_and, _ir_or } from "../../../../compiler/tir/expressions/binary/TirBinaryExpr.js";
 function _ir_strictAnd(left, right) {
     return _ir_apps(IRNative.strictIfThenElse, left, right, IRConst.bool(false));
 }
@@ -43,6 +44,8 @@ export const hoisted_addOne = new IRHoisted(new IRApp(IRNative.addInteger, IRCon
 hoisted_addOne.hash;
 export const hoisted_subOne = new IRHoisted(new IRApp(IRNative.addInteger, IRConst.int(-1)));
 hoisted_subOne.hash;
+export const hoisted_negateInteger = new IRHoisted(new IRApp(IRNative.subtractInteger, IRConst.int(0)));
+hoisted_negateInteger.hash;
 export const hoisted_isPositive = new IRHoisted(new IRApp(IRNative.lessThanInteger, IRConst.int(0)));
 hoisted_isPositive.hash;
 export const hoisted_isNonNegative = new IRHoisted(new IRApp(IRNative.lessThanEqualInteger, IRConst.int(0)));
@@ -54,6 +57,7 @@ export const hoisted_matchList = new IRHoisted((() => {
     return new IRFunc([delayed_matchNil, matchCons, list], new IRForced(new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(list), new IRVar(delayed_matchNil), new IRDelayed(_ir_apps(new IRVar(matchCons), new IRApp(IRNative.headList, new IRVar(list)), new IRApp(IRNative.tailList, new IRVar(list))))))));
 })());
 hoisted_matchList.hash;
+//*
 // hoisted_recursiveList (needed by hoisted_foldr)
 const recList_matchNil = Symbol("matchNil");
 const recList_matchCons = Symbol("matchCons");
@@ -61,14 +65,15 @@ const recList_self = Symbol("recursiveList_self");
 const recList_lst = Symbol("lst");
 export const hoisted_recursiveList = new IRHoisted(new IRFunc([recList_matchNil, recList_matchCons], new IRRecursive(recList_self, new IRFunc([recList_lst], _ir_apps(hoisted_matchList.clone(), new IRApp(new IRVar(recList_matchNil), new IRSelfCall(recList_self)), new IRApp(new IRVar(recList_matchCons), new IRSelfCall(recList_self)), new IRVar(recList_lst))))));
 hoisted_recursiveList.hash;
+//*/
 // hoisted_foldr
-const foldr_reduce = Symbol("reduceFunc");
+const foldr_reducer = Symbol("reduceFunc");
 const foldr_acc = Symbol("accumulator");
 const foldr__dummy = Symbol("_self");
 const foldr_self = Symbol("self");
 const foldr_head = Symbol("head");
 const foldr_tail = Symbol("tail");
-export const hoisted_foldr = new IRHoisted(new IRFunc([foldr_reduce, foldr_acc], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([foldr__dummy], new IRDelayed(new IRVar(foldr_acc))), new IRFunc([foldr_self, foldr_head, foldr_tail], _ir_apps(new IRVar(foldr_reduce), new IRVar(foldr_head), new IRApp(new IRVar(foldr_self), new IRVar(foldr_tail)))))));
+export const hoisted_foldr = new IRHoisted(new IRFunc([foldr_reducer, foldr_acc], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([foldr__dummy], new IRDelayed(new IRVar(foldr_acc))), new IRFunc([foldr_self, foldr_head, foldr_tail], _ir_apps(new IRVar(foldr_reducer), new IRVar(foldr_head), new IRApp(new IRVar(foldr_self), new IRVar(foldr_tail)))))));
 hoisted_foldr.hash;
 export const hosited_lazyChooseList = new IRHoisted((() => {
     const list = Symbol("list");
@@ -142,19 +147,25 @@ export const hoisted_strictOr = new IRHoisted(new IRFunc([strictOr_a, strictOr_b
 hoisted_strictOr.hash;
 // hoisted _some
 const some_pred = Symbol("predicate");
-const some_dummy = Symbol("_self");
+const some_lst = Symbol("lst");
 const some_self = Symbol("self");
-const some_head = Symbol("head");
-const some_tail = Symbol("tail");
-export const hoisted_some = new IRHoisted(new IRFunc([some_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([some_dummy], new IRDelayed(IRConst.bool(false))), new IRFunc([some_self, some_head, some_tail], new IRForced(_ir_apps(hoisted_strictOr.clone(), new IRDelayed(new IRApp(new IRVar(some_pred), new IRVar(some_head))), new IRDelayed(new IRApp(new IRVar(some_self), new IRVar(some_tail)))))))));
+export const hoisted_some = new IRHoisted(new IRFunc([some_pred], new IRRecursive(some_self, new IRFunc([some_lst], _ir_lazyChooseList(new IRVar(some_lst), IRConst.bool(false), // case nil => false
+_ir_or(
+// either predicate(head) is true
+_ir_apps(new IRVar(some_pred), new IRApp(IRNative.headList, new IRVar(some_lst))), 
+// or self(tail) is true
+_ir_apps(new IRSelfCall(some_self), new IRApp(IRNative.tailList, new IRVar(some_lst)))))))));
 hoisted_some.hash;
 // hoisted _every
 const every_pred = Symbol("predicate");
-const every_dummy = Symbol("_self");
 const every_self = Symbol("self");
-const every_head = Symbol("head");
-const every_tail = Symbol("tail");
-export const hoisted_every = new IRHoisted(new IRFunc([every_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([every_dummy], new IRDelayed(IRConst.bool(true))), new IRFunc([every_self, every_head, every_tail], new IRForced(_ir_apps(hoisted_strictAnd.clone(), new IRDelayed(new IRApp(new IRVar(every_pred), new IRVar(every_head))), new IRDelayed(new IRApp(new IRVar(every_self), new IRVar(every_tail)))))))));
+const every_lst = Symbol("lst");
+export const hoisted_every = new IRHoisted(new IRFunc([every_pred], new IRRecursive(every_self, new IRFunc([every_lst], _ir_lazyChooseList(new IRVar(every_lst), IRConst.bool(true), // case nil => true
+_ir_and(
+// both predicate(head) is true
+_ir_apps(new IRVar(every_pred), new IRApp(IRNative.headList, new IRVar(every_lst))), 
+// AND self(tail) is true
+_ir_apps(new IRSelfCall(every_self), new IRApp(IRNative.tailList, new IRVar(every_lst)))))))));
 hoisted_every.hash;
 // hoisted _filter
 const filt_pred = Symbol("predicate");
@@ -249,6 +260,11 @@ export function nativeToIR(native) {
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
         case IRNativeTag._increment: return hoisted_addOne.clone();
         case IRNativeTag._decrement: return hoisted_subOne.clone();
+        // case IRNativeTag._bytesToIntBE: ;
+        // case IRNativeTag._equalBoolean: ;
+        // case IRNativeTag._equalPairData: ;
+        case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
+        case IRNativeTag._negateInt: return hoisted_negateInteger.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -333,9 +333,15 @@ export class AstCompiler extends DiagnosticEmitter {
         if (!funcExpr)
             return undefined;
         this.program.functions.set(tirFuncName, funcExpr);
+        this.program.functions.set(astFuncName, funcExpr);
         if (topLevelScope.functions.has(astFuncName))
             return this.error(DiagnosticCode._0_is_already_defined, astFuncExpr.name.range, astFuncName);
         topLevelScope.functions.set(astFuncName, tirFuncName);
+        topLevelScope.defineValue({
+            isConstant: true,
+            name: astFuncName,
+            type: funcExpr.type,
+        });
         if (exportRange && srcExports) {
             if (srcExports.functions.has(astFuncName)
                 || srcExports.variables.has(astFuncName))

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -32,6 +32,7 @@ import { StructConstrDecl, StructDecl, StructDeclAstFlags } from "../../../../as
 import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
 import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
 import { SingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
+import { isVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/VarDecl.js";
 import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
 import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
 import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
@@ -379,7 +380,9 @@ renamedVariables = {}) {
 function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables) {
     const result = stmts.slice();
     for (let i = 0; i < result.length; i++) {
-        const stmt = result[i];
+        let stmt = result[i];
+        if (isVarDecl(stmt))
+            stmt = new VarStmt([stmt], stmt.range);
         if (stmt instanceof VarStmt) {
             if (stmt.declarations.length !== 1) {
                 for (const varDecl of stmt.declarations) {
@@ -587,6 +590,7 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
             continue;
         }
         const tsEnsureExhaustiveCheck = stmt;
+        console.error(stmt);
         throw new Error("unreachable::_getMatchedRedeemerBlockStatements::stmt::");
     }
     return result;

package/dist/compiler/Compiler.d.ts

@@ -8,6 +8,7 @@ export declare class Compiler extends DiagnosticEmitter {
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
+    private _compileBackend;
 }
 interface HasFuncitonName {
     functionName: string;

package/dist/compiler/Compiler.js

@@ -34,16 +34,7 @@ export class Compiler extends DiagnosticEmitter {
             }
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
-        // backend starts here
-        const ir = compileTypedProgram(cfg, program);
-        const uplc = compileIRToUPLC(ir);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
-        const outDir = cfg.outDir;
-        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
-        this.io.writeFile(outPath, serialized, cfg.root);
-        this.io.stdout.write(`compiled program written to ${outPath}\n`);
-        __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        return serialized;
+        return this._compileBackend(cfg, program);
     }
     async export(config) {
         const cfg = {
@@ -67,6 +58,9 @@ export class Compiler extends DiagnosticEmitter {
             }
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
+        return this._compileBackend(cfg, program);
+    }
+    _compileBackend(cfg, program) {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir, cfg);

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

@@ -51,12 +51,16 @@ export class ExpressifyCtx {
         this.properties = properties;
         this.hoisted = (hoisted
             ?? this.parent?.hoisted
-            ?? new Map([...program.constants.entries()].map(([name, decl]) => {
+            ?? new Map([...program.constants.entries()]
+                .map(([name, decl]) => {
                 if (!decl.initExpr)
                     throw new Error(`expected init expr in hoisted constant '${name}'`);
                 const expr = decl.initExpr instanceof TirHoistedExpr ? decl.initExpr : new TirHoistedExpr(name, decl.initExpr);
                 return [name, expr];
-            })));
+            })
+                .concat([...program.functions.entries()].map(([name, func]) => {
+                return [name, new TirHoistedExpr(name, func)];
+            }))));
     }
     allVariablesNoLetted() {
         return (this.parent?.allVariablesNoLetted() ?? []).concat(...this.variables.keys());
@@ -119,7 +123,7 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            console.log("[error log]: allVariables", this.allVariables());
+            console.log("[error log]: allVariables", this.allVariables(), "; get:", name);
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;

package/dist/parser/Parser.js

@@ -72,6 +72,7 @@ import { Precedence, determinePrecedence } from "./Precedence.js";
 import { LitFailExpr } from "../ast/nodes/expr/litteral/LitFailExpr.js";
 import { ContractDecl } from "../ast/nodes/statements/declarations/ContractDecl.js";
 import { LitContextExpr } from "../ast/nodes/expr/litteral/LitContextExpr.js";
+import { tokenIsAlsoIdentifier } from "../tokenizer/utils/tokenIsAlsoIdentifier.js";
 export class Parser extends DiagnosticEmitter {
     tn;
     constructor(tokenizer, diagnostics = undefined) {
@@ -833,6 +834,12 @@ export class Parser extends DiagnosticEmitter {
     _parseVarDecl(flags, skipTypeAndInitializer = false) {
         const tn = this.tn;
         // ConstrName{ ... } || renamed
+        const identifierToken = tn.peek();
+        if (identifierToken !== Token.Identifier
+            && identifierToken !== Token.OpenBrace // valid var destructuring (single constr obj)
+            && identifierToken !== Token.OpenBracket // valid var destructuring (array-like)
+            && !tokenIsAlsoIdentifier(identifierToken))
+            return this.error(DiagnosticCode._0_keyword_cannot_be_used_here, tn.range(tn.nextTokenPos, tn.nextToken), Token[identifierToken]);
         const renamedField = this.parseIdentifier();
         if (tn.skip(Token.OpenBrace)) // ConstrName{ ... } || { ... }
          {

package/dist/parser/parseFile.d.ts

@@ -1,3 +1,5 @@
 import type { Source } from "../ast/Source/Source.js";
-export declare function parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[]];
-export declare function parseSource(src: Source): import("../diagnostics/DiagnosticMessage.js").DiagnosticMessage[];
+import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
+export declare function parseFilePure(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, DiagnosticMessage[]];
+export declare function parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): Source;
+export declare function parseSource(src: Source): DiagnosticMessage[];

package/dist/parser/parseFile.js

@@ -1,8 +1,15 @@
 import { defaultSymbolForge } from "../compiler/internalVar.js";
 import { Parser } from "./Parser.js";
-export function parseFile(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
+export function parseFilePure(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
     return Parser.parseFile(path, src, getUid, isEntry);
 }
+export function parseFile(path, src, getUid = defaultSymbolForge.getUid.bind(defaultSymbolForge), isEntry = false) {
+    const [source, diagnostics] = Parser.parseFile(path, src, getUid, isEntry);
+    if (diagnostics.length > 0) {
+        throw new Error(`Parsing errors:\n${diagnostics.map(d => d.toString()).join("\n")}`);
+    }
+    return source;
+}
 export function parseSource(src) {
     return Parser.parseSource(src);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.2",
+  "version": "0.1.3-dev0",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",