@harmoniclabs/pebble 0.1.5 → 0.1.7

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

@@ -22,7 +22,6 @@ export declare const hoisted_isMoreThanOrEqualTo4: IRHoisted;
 export declare const hoisted_sub4: IRHoisted;
 export declare const hoisted_length: IRHoisted;
 export declare const hoisted_dropList: IRHoisted;
-export declare const hoisted_sizeofPositiveInt: IRHoisted;
 export declare const hoisted_findSopOptional: IRHoisted;
 export declare const hoisted_lookupLinearMap: IRHoisted;
 export declare const hoisted_mkFindDataOptional: IRHoisted;

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

@@ -99,12 +99,6 @@ const drop_n = Symbol("n");
 const drop_lst = Symbol("lst");
 export const hoisted_dropList = new IRHoisted(new IRRecursive(drop_self, new IRFunc([drop_n, drop_lst], _ir_lazyIfThenElse(_ir_apps(hoisted_isMoreThanOrEqualTo4.clone(), new IRVar(drop_n)), _ir_apps(new IRSelfCall(drop_self), _ir_apps(hoisted_sub4.clone(), new IRVar(drop_n)), _ir_apps(hoisted_drop4.clone(), new IRVar(drop_lst))), _ir_lazyIfThenElse(_ir_apps(hoisted_isZero.clone(), new IRVar(drop_n)), new IRVar(drop_lst), _ir_lazyIfThenElse(_ir_apps(hoisted_isOne.clone(), new IRVar(drop_n)), _ir_apps(IRNative.tailList, new IRVar(drop_lst)), _ir_lazyIfThenElse(_ir_apps(hoisted_isTwo.clone(), new IRVar(drop_n)), _ir_apps(hoisted_drop2.clone(), new IRVar(drop_lst)), _ir_apps(hoisted_drop3.clone(), new IRVar(drop_lst)))))))));
 hoisted_dropList.hash;
-const MAX_WORD4 = 0xFFFFFFFF;
-// Added missing symbols & refactored hoisted_sizeofPositiveInt if previously numeric
-const sizeof_self = Symbol("sizeofPositiveInt_self");
-const sizeof_n = Symbol("n");
-const sizeof_countWords = Symbol("count_words");
-export const hoisted_sizeofPositiveInt = new IRHoisted(_ir_apps(new IRRecursive(sizeof_self, new IRFunc([sizeof_n, sizeof_countWords], new IRForced(_ir_apps(IRNative.strictIfThenElse, _ir_apps(hoisted_isZero.clone(), new IRVar(sizeof_n)), new IRDelayed(new IRForced(_ir_apps(IRNative.strictIfThenElse, _ir_apps(hoisted_isZero.clone(), new IRVar(sizeof_countWords)), new IRDelayed(IRConst.int(4)), new IRDelayed(_ir_apps(IRNative.multiplyInteger, IRConst.int(4), new IRVar(sizeof_countWords)))))), new IRDelayed(_ir_apps(new IRSelfCall(sizeof_self), _ir_apps(hoisted_addOne.clone(), new IRVar(sizeof_countWords)), _ir_apps(IRNative.divideInteger, new IRVar(sizeof_n), IRConst.int(MAX_WORD4)))))))), IRConst.int(0)));
 const foldl_reduce = Symbol("reduceFunc");
 const foldl_self = Symbol("foldl_self");
 const foldl_acc = Symbol("accum");
@@ -229,8 +223,25 @@ hoisted_pairDataFromData.hash;
 const boolSym = Symbol("bool");
 export const hoisted_boolToInt = new IRHoisted(new IRFunc([boolSym], _ir_apps(IRNative.strictIfThenElse, new IRVar(boolSym), IRConst.int(1), IRConst.int(0))));
 hoisted_boolToInt.hash;
-const intSym = Symbol("int");
-export const hoisted_intToBytesBE = new IRHoisted(new IRFunc([intSym], _ir_apps(IRNative.integerToByteString, IRConst.bool(true), _ir_apps(hoisted_sizeofPositiveInt.clone(), new IRVar(intSym)), new IRVar(intSym))));
+// const intSym = Symbol("int");
+export const hoisted_intToBytesBE = new IRHoisted(
+/*
+new IRFunc(
+    [ intSym ],
+    _ir_apps(
+        IRNative.integerToByteString,
+        IRConst.bool( true ),
+        _ir_apps(
+            hoisted_sizeofPositiveInt.clone(),
+            new IRVar( intSym )
+        ),
+        new IRVar( intSym )
+    )
+)
+/*/
+_ir_apps(IRNative.integerToByteString, IRConst.bool(true), IRConst.int(0))
+//*/
+);
 hoisted_intToBytesBE.hash;
 // hoisted exponentiateInteger
 const baseSym = Symbol("base");

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

@@ -43,6 +43,8 @@ import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLi
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirAliasType } from "../../tir/types/TirAliasType.js";
+import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
+import { TirStringT } from "../../tir/types/TirNativeType/native/string.js";
 import { TirFuncT, TirListT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
 import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
@@ -471,6 +473,18 @@ function expressifyMethodCall(ctx, methodCall) {
         if (result)
             return result;
     }
+    if (objectType instanceof TirBytesT || objectType instanceof TirStringT) {
+        const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+        if (methodName === "length") {
+            return new TirCallExpr(TirNativeFunc.lengthOfByteString, [objectExpr], int_t, exprRange);
+        }
+        if (methodName === "subByteString" || methodName === "slice") {
+            return new TirCallExpr(TirNativeFunc.sliceByteString, [methodCall.args[0], methodCall.args[1], objectExpr], bytes_t, exprRange);
+        }
+        if (methodName === "prepend") {
+            return new TirCallExpr(TirNativeFunc.consByteString, [methodCall.args[0], objectExpr], bytes_t, exprRange);
+        }
+    }
     throw new Error(`not implemented::expressifyMethodCall for type '${objectType.toString()}' (method name: '${methodName}')`);
     // const tsEnsureExhautstiveCheck: never = objectType;
     throw new Error(`Cannot call method '${methodName}' on non-struct type '${objectType.toString()}'`);

package/dist/compiler/tir/types/utils/canCastTo.js

@@ -67,10 +67,8 @@ export function canCastTo(a, b) {
             return true;
         if (a instanceof TirStringT)
             return true; // string -> bytes // decode utf8
-        // how do we handle this?
-        // in theory we can encode but only fixed size
-        // we have no idea of the size of ints
-        // if( a instanceof TirIntT ) return true;
+        if (a instanceof TirIntT)
+            return true; // int -> bytes // big endian encoding
         return false;
     }
     if (b instanceof TirStringT) {

package/dist/compiler/tir/types/utils/getListTypeArg.js

@@ -1,11 +1,14 @@
 import { TirAliasType } from "../TirAliasType.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
 export function getListTypeArg(list_t) {
     while (list_t instanceof TirAliasType)
         list_t = list_t.aliased;
     if (list_t instanceof TirListT)
         return list_t.typeArg;
+    if (list_t instanceof TirLinearMapT)
+        return new TirLinearMapEntryT(list_t.keyTypeArg, list_t.valTypeArg);
     return undefined;
 }
 export function getLinearMapTypeArgs(map_t) {

package/package.json

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