@harmoniclabs/pebble 0.1.4-dev1 → 0.1.4

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

@@ -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/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/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-dev1",
+  "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",