@harmoniclabs/pebble 0.1.4-dev0 → 0.1.4

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

@@ -122,11 +122,11 @@ export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predica
 // case nil
 new IRConstr(1, []), // None
 // case cons
-new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
+new IRApp(new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
 // then => Some(head)
-new IRConstr(1, [new IRVar(findSop_head)]), // Some{ head }
+new IRConstr(0, [new IRVar(findSop_head)]), // Some{ head }
 // else => self(tail)
-_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))))))));
+_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))), new IRApp(IRNative.headList, new IRVar(findSop_list))))))));
 hoisted_findSopOptional.hash;
 // hoisted _lookupLinearMap
 // (key: data) -> (map: list<pair<data,data>>) -> SopOptional<data>
@@ -138,13 +138,13 @@ export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], ne
 // case nil => None
 new IRConstr(1, []), 
 // case cons
-new IRFunc([lookup_head], _ir_lazyIfThenElse(_ir_apps(IRNative.equalsData, _ir_apps(IRNative.fstPair, new IRVar(lookup_head)), new IRVar(lookup_key)), 
+new IRApp(new IRFunc([lookup_head], _ir_lazyIfThenElse(_ir_apps(IRNative.equalsData, _ir_apps(IRNative.fstPair, new IRVar(lookup_head)), new IRVar(lookup_key)), 
 // then => Some(sndPair(head))
-new IRConstr(1, [
+new IRConstr(0, [
     _ir_apps(IRNative.sndPair, new IRVar(lookup_head))
 ]), 
 // else => self(tailList(map))
-_ir_apps(new IRSelfCall(lookup_self), _ir_apps(IRNative.tailList, new IRVar(lookup_map))))))))));
+_ir_apps(new IRSelfCall(lookup_self), _ir_apps(IRNative.tailList, new IRVar(lookup_map))))), new IRApp(IRNative.headList, new IRVar(lookup_map))))))));
 hoisted_lookupLinearMap.hash;
 // hoisted _mkFindDataOptional
 const mkFind_elemToData = Symbol("elemToData");
@@ -351,12 +351,12 @@ new IRDelayed(IRConst.int(0)),
 // token map cons
 new IRDelayed(_ir_let(_ir_apps(IRNative.headList, new IRVar(amount_tokenMap)), pairDataTokenSym => new IRForced(_ir_apps(IRNative.strictIfThenElse, 
 // isTokenName( fst pairDataToken as bytes )
-_ir_apps(new IRVar(amount_isTokenName), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(pairDataTokenSym))), 
+_ir_apps(new IRVar(amount_isTokenName), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(pairDataTokenSym)))), 
 // then: return amount
 new IRDelayed(_ir_apps(IRNative.unIData, _ir_apps(IRNative.sndPair, new IRVar(pairDataTokenSym)))), 
 // else: recurse tail
 new IRDelayed(_ir_apps(new IRSelfCall(amount_tokenNameLoop), _ir_apps(IRNative.tailList, new IRVar(amount_tokenMap) // tokenMap list
-)))))))))))), 
+))))))))))), 
 // pass token map (snd pairData)
 _ir_apps(IRNative.unMapData, _ir_apps(IRNative.sndPair, new IRVar(pairDataSym)))))), 
 // else: recurse policyLoop on tail value list

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -231,8 +231,8 @@ export class AstCompiler extends DiagnosticEmitter {
                 console.log( msg.toString() );
                 //*/
             }
-            // return this.program;
-            throw new Error("AstCompiler.compile: failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+            return this.program;
+            // throw new Error("AstCompiler.compile: failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg );
         }
         const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
         if (this.program.contractTirFuncName === "" || !mainFuncExpr) {

package/dist/compiler/Compiler.js

@@ -73,7 +73,7 @@ export class Compiler extends DiagnosticEmitter {
             while (msg = this.diagnostics.shift()) {
                 this.io.stdout.write(msg.toString() + "\n");
             }
-            throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+            // throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg );
         }
         return this._compileBackend(cfg, program);
     }

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

@@ -36,7 +36,8 @@ 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 { bool_t, bytes_t, int_t, valueAmountOfName } from "../../tir/program/stdScope/stdScope.js";
+import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
 import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
@@ -378,10 +379,23 @@ function expressifyMethodCall(ctx, methodCall) {
             objectType = objectType.aliased;
             continue;
         }
+        const callRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+        // fast-path: `Value.amountOf(policy, name)` compiles directly to
+        // `_amountOfValue(eqByteString(policy))(value)(eqByteString(name))`
+        // skipping the wrapper function indirection.
+        if (tirMethodName === valueAmountOfName
+            && methodCall.args.length === 2) {
+            const [policyArg, nameArg] = methodCall.args;
+            const bytesToBoolT = new TirFuncT([bytes_t], bool_t);
+            const isPolicy = new TirLettedExpr("value_amountOf_isPolicy", new TirCallExpr(TirNativeFunc.equalsByteString, [policyArg], bytesToBoolT, policyArg.range), policyArg.range);
+            const isTokenName = new TirLettedExpr("value_amountOf_isTokenName", new TirCallExpr(TirNativeFunc.equalsByteString, [nameArg], bytesToBoolT, nameArg.range), nameArg.range);
+            const amountOfValueNative = new TirNativeFunc(IRNativeTag._amountOfValue, new TirFuncT([bytesToBoolT, objectExpr.type, bytesToBoolT], int_t));
+            return new TirCallExpr(amountOfValueNative, [isPolicy, objectExpr, isTokenName], int_t, callRange);
+        }
         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()));
+        return new TirCallExpr(funcExpr, [objectExpr, ...methodCall.args], methodCall.type, callRange);
     }
     if (objectType instanceof TirDataStructType
         || objectType instanceof TirSoPStructType) {

package/dist/compiler/path/getAbsolutePath.js

@@ -52,7 +52,8 @@ function addExtension(path, endsWithSlash) {
     return path + extension;
 }
 export function isAbsolutePath(path) {
-    return path.startsWith(PATH_DELIMITER);
+    // Support both Unix (/) and Windows (C:/, D:/) absolute paths
+    return path.startsWith(PATH_DELIMITER) || /^[A-Za-z]:[\\/]/.test(path);
 }
 export function getEnvRelativePath(filePath, projectRoot) {
     if (!(typeof filePath === 'string' &&

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

@@ -3,7 +3,6 @@ import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
-import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
@@ -87,17 +86,26 @@ export class TirCaseExpr {
             const someBranchCtx = ctx.newChild();
             const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
             let someBranchVarSym = Symbol("some_value_unused");
+            let someValueType = undefined;
             if (someBranch) {
                 const varDecl = someBranch.pattern.fields.values().next().value;
                 if (!(varDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
                 someBranchVarSym = someBranchCtx.defineVar(varDecl.name);
+                someValueType = varDecl.type;
             }
             const someBranchIR = someBranch?.body.toIR(someBranchCtx) ?? wildcardBodyIR;
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(ctx) ?? wildcardBodyIR;
+            // The SoP Optional wraps raw data values from lookups;
+            // apply _inlineFromData to convert to the expected native type
+            // (e.g., unMapData for LinearMap values)
+            const rawValueSym = Symbol("sop_opt_raw_value");
+            const someHandler = someValueType
+                ? new IRFunc([rawValueSym], new IRApp(new IRFunc([someBranchVarSym], someBranchIR), _inlineFromData(someValueType, new IRVar(rawValueSym))))
+                : new IRFunc([someBranchVarSym], someBranchIR);
             return new IRCase(this.matchExpr.toIR(ctx), [
                 // Some{ value }
-                new IRFunc([someBranchVarSym], someBranchIR),
+                someHandler,
                 // None
                 noneBranchIR
             ]);
@@ -160,14 +168,14 @@ export class TirCaseExpr {
                 )));
             }
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
-            return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
+            return _ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
             // condition
             _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(unConstrMatchSym) // unConstrData result
             )), 
             // then Just{ value }
             someBranchIR(unConstrMatchSym), 
             // else None
-            noneBranchIR)));
+            noneBranchIR));
         }
         // TirDataStructType
         const stmtCtx = ctx.newChild();

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

@@ -0,0 +1,30 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+/**
+ * Converts a SoP Optional value to a boolean at the IR level
+ * using `case(opt, [\_ -> true, false])`.
+ *
+ * This is needed because `ifThenElse` expects a boolean, but
+ * SoP Optional values are Constr nodes, not boolean constants.
+ */
+export declare class TirSopOptToBoolExpr implements ITirExpr {
+    readonly operand: TirExpr;
+    readonly range: SourceRange;
+    readonly type: TirType;
+    constructor(operand: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    /**
+     * Wraps the expression in TirSopOptToBoolExpr if its type is SoP Optional,
+     * otherwise returns it as-is.
+     */
+    static wrapIfNeeded(expr: TirExpr): TirExpr;
+}

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

@@ -0,0 +1,49 @@
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { bool_t } from "../program/stdScope/stdScope.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+/**
+ * Converts a SoP Optional value to a boolean at the IR level
+ * using `case(opt, [\_ -> true, false])`.
+ *
+ * This is needed because `ifThenElse` expects a boolean, but
+ * SoP Optional values are Constr nodes, not boolean constants.
+ */
+export class TirSopOptToBoolExpr {
+    operand;
+    range;
+    type = bool_t;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+    toString() { return `isSome(${this.operand.toString()})`; }
+    pretty(indent) { return `isSome(${this.operand.pretty(indent)})`; }
+    clone() {
+        return new TirSopOptToBoolExpr(this.operand.clone(), this.range.clone());
+    }
+    deps() { return this.operand.deps(); }
+    get isConstant() { return this.operand.isConstant; }
+    toIR(ctx) {
+        const unusedSym = Symbol("_some_val");
+        return new IRCase(this.operand.toIR(ctx), [
+            // Some{ value } => true
+            new IRFunc([unusedSym], IRConst.bool(true)),
+            // None => false
+            IRConst.bool(false)
+        ]);
+    }
+    /**
+     * Wraps the expression in TirSopOptToBoolExpr if its type is SoP Optional,
+     * otherwise returns it as-is.
+     */
+    static wrapIfNeeded(expr) {
+        const t = getUnaliased(expr.type);
+        if (t instanceof TirSopOptT) {
+            return new TirSopOptToBoolExpr(expr, expr.range);
+        }
+        return expr;
+    }
+}

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

@@ -4,6 +4,10 @@ import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
+import { IRCase } from "../../../IR/IRNodes/index.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
 export class TirTraceIfFalseExpr {
     condition;
     traceStrExpr;
@@ -34,6 +38,17 @@ export class TirTraceIfFalseExpr {
         return new TirTraceIfFalseExpr(this.condition.clone(), this.traceStrExpr.clone(), this.range.clone());
     }
     toIR(ctx) {
+        const condType = getUnaliased(this.condition.type);
+        // SoP Optional: use case expression to convert to bool
+        if (condType instanceof TirSopOptT) {
+            const unusedSym = Symbol("_some_val");
+            return new IRCase(this.condition.toIR(ctx), [
+                // Some{ value } => true
+                new IRFunc([unusedSym], IRConst.bool(true)),
+                // None => trace(msg, false)
+                _ir_apps(IRNative.trace, this.traceStrExpr.toIR(ctx), IRConst.bool(false))
+            ]);
+        }
         return _ir_lazyIfThenElse(
         // condition
         this.condition.toIR(ctx), 

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

@@ -11,5 +11,7 @@ export declare const string_t: TirStringT;
 export declare const bytes_t: TirBytesT;
 export declare const bool_t: TirBoolT;
 export declare const data_t: TirDataT;
+export declare const valueLovelacesName: string;
+export declare const valueAmountOfName: string;
 export declare function populateStdScope(program: TypedProgram): void;
 export declare function populatePreludeScope(program: TypedProgram): void;

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

@@ -15,12 +15,17 @@ import { SourceRange } from "../../../../ast/Source/SourceRange.js";
 import { TirInlineClosedIR } from "../../expressions/TirInlineClosedIR.js";
 import { TirFuncT } from "../../types/TirNativeType/index.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
+import { IRFunc } from "../../../../IR/IRNodes/IRFunc.js";
+import { IRVar } from "../../../../IR/IRNodes/IRVar.js";
+import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
 export const void_t = new TirVoidT();
 export const int_t = new TirIntT();
 export const string_t = new TirStringT();
 export const bytes_t = new TirBytesT();
 export const bool_t = new TirBoolT();
 export const data_t = new TirDataT();
+export const valueLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "sortedValueLovelaces";
+export const valueAmountOfName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "amountOfValue";
 export function populateStdScope(program) {
     const stdScope = program.stdScope;
     function _defineStdUnambigous(t) {
@@ -544,14 +549,35 @@ export function populatePreludeScope(program) {
     const map_policyId_map_tokenName_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [policyId_t, map_tokenName_int_t]);
     if (!map_policyId_map_tokenName_int_t)
         throw new Error("expected map_policyId_map_tokenName_int_t");
-    const valueLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "sortedValueLovelaces";
     const value_t = _defineUnambigousAlias("Value", map_policyId_map_tokenName_int_t, new Map([
         [
             "lovelaces",
             valueLovelacesName
         ],
+        [
+            "amountOf",
+            valueAmountOfName
+        ],
     ]));
     preludeScope.program.functions.set(valueLovelacesName, new TirInlineClosedIR(new TirFuncT([value_t], int_t), (ctx) => IRNative._sortedValueLovelaces, SourceRange.unknown));
+    // Value.amountOf( policy: PolicyId, name: bytes ): int
+    // The IR native _amountOfValue is curried as: (isPolicy)(value)(isTokenName) => int
+    // where isPolicy and isTokenName are equality-check predicates.
+    // This wrapper adapts (self, policy, tokenName) => _amountOfValue(p => equalsByteString(p, policy))(self)(tn => equalsByteString(tn, tokenName))
+    preludeScope.program.functions.set(valueAmountOfName, new TirInlineClosedIR(new TirFuncT([value_t, policyId_t, bytes_t], int_t), (ctx) => {
+        const self = Symbol("amtOf_self");
+        const policy = Symbol("amtOf_policy");
+        const tokenName = Symbol("amtOf_tokenName");
+        const p = Symbol("amtOf_p");
+        const tn = Symbol("amtOf_tn");
+        return new IRFunc([self, policy, tokenName], _ir_apps(_ir_apps(_ir_apps(IRNative._amountOfValue, 
+        // isPolicy predicate: \p -> equalsByteString(p, policy)
+        _ir_apps(IRNative.equalsByteString, new IRVar(policy))), 
+        // value (self)
+        new IRVar(self)), 
+        // isTokenName predicate: \tn -> equalsByteString(tn, tokenName)
+        _ir_apps(IRNative.equalsByteString, new IRVar(tokenName))));
+    }, SourceRange.unknown));
     /* // TODO
     untagged struct FlatValueEntry {
         policy: PolicyId,

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

@@ -1,5 +1,6 @@
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 import { TirTraceIfFalseExpr } from "../expressions/TirTraceIfFalseExpr.js";
+import { TirSopOptToBoolExpr } from "../expressions/TirSopOptToBoolExpr.js";
 export class TirAssertStmt {
     condition;
     elseExpr;
@@ -32,8 +33,9 @@ export class TirAssertStmt {
         return deps;
     }
     toSafeCondition() {
-        if (!this.elseExpr)
-            return this.condition;
+        if (!this.elseExpr) {
+            return TirSopOptToBoolExpr.wrapIfNeeded(this.condition);
+        }
         return new TirTraceIfFalseExpr(this.condition, this.elseExpr, this.range);
     }
 }

package/dist/tokenizer/Tokenizer.js

@@ -2,7 +2,7 @@ import { SourceRange } from "../ast/Source/SourceRange.js";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticCode } from "../diagnostics/diagnosticMessages.generated.js";
 import { assert } from "../utils/assert.js";
-import { isHighSurrogate, combineSurrogates, isIdentifierStart, numCodeUnits, isIdentifierPart, isWhiteSpace, isLineBreak, isDecimal, isOctal, isHexBase } from "../utils/text.js";
+import { isHighSurrogate, combineSurrogates, isIdentifierStart, numCodeUnits, isIdentifierPart, isWhiteSpace, isLineBreak, isDecimal, isOctal, isHexBase, isHexOrDecimal } from "../utils/text.js";
 import { IdentifierHandling } from "./IdentifierHandling.js";
 import { OnNewLine } from "./OnNewLine.js";
 import { Token } from "./Token.js";
@@ -926,7 +926,7 @@ export class Tokenizer extends DiagnosticEmitter {
         let length = 0;
         while (pos < end) {
             let c = text.charCodeAt(pos);
-            if (isHexBase(c)) {
+            if (isHexOrDecimal(c)) {
                 length++;
                 pos++;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.4-dev0",
+  "version": "0.1.4",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -63,6 +63,7 @@
   "devDependencies": {
     "@babel/preset-env": "^7.18.6",
     "@babel/preset-typescript": "^7.18.6",
+    "@harmoniclabs/buildooor": "^0.2.6",
     "@types/jest": "^28.1.4",
     "@types/node": "^18.14.6",
     "jest": "^29.4.3",