@harmoniclabs/pebble 0.1.3 → 0.1.4-dev0

package/dist/IR/IRNodes/IRNative/IRNativeTag.d.ts

@@ -134,6 +134,7 @@ export declare enum IRNativeTag {
     _getCredentialsHash = -44,
     _findSopOptional = -45,
     _increment = -46,
-    _decrement = -47
+    _decrement = -47,
+    _lookupLinearMap = -48
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

package/dist/IR/IRNodes/IRNative/IRNativeTag.js

@@ -158,6 +158,7 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_findSopOptional"] = -45] = "_findSopOptional";
     IRNativeTag[IRNativeTag["_increment"] = -46] = "_increment";
     IRNativeTag[IRNativeTag["_decrement"] = -47] = "_decrement";
+    IRNativeTag[IRNativeTag["_lookupLinearMap"] = -48] = "_lookupLinearMap";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
@@ -203,6 +204,7 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._getCredentialsHash: return "getCredentialHash";
         case IRNativeTag._increment: return "increment";
         case IRNativeTag._decrement: return "decrement";
+        case IRNativeTag._lookupLinearMap: return "lookupLinearMap";
         default: return "";
     }
 }

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

@@ -24,6 +24,7 @@ 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;
 export declare const hoisted_strictAnd: IRHoisted;
 export declare const hoisted_strictOr: IRHoisted;

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

@@ -128,6 +128,24 @@ new IRConstr(1, [new IRVar(findSop_head)]), // Some{ head }
 // else => self(tail)
 _ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))))))));
 hoisted_findSopOptional.hash;
+// hoisted _lookupLinearMap
+// (key: data) -> (map: list<pair<data,data>>) -> SopOptional<data>
+const lookup_key = Symbol("lookup_key");
+const lookup_self = Symbol("lookup_self");
+const lookup_map = Symbol("lookup_map");
+const lookup_head = Symbol("lookup_head");
+export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], new IRRecursive(lookup_self, new IRFunc([lookup_map], _ir_lazyChooseList(new IRVar(lookup_map), 
+// 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)), 
+// then => Some(sndPair(head))
+new IRConstr(1, [
+    _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))))))))));
+hoisted_lookupLinearMap.hash;
 // hoisted _mkFindDataOptional
 const mkFind_elemToData = Symbol("elemToData");
 const mkFind_pred = Symbol("predicate");
@@ -265,6 +283,7 @@ export function nativeToIR(native) {
         // case IRNativeTag._equalPairData: ;
         case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         case IRNativeTag._negateInt: return hoisted_negateInteger.clone();
+        case IRNativeTag._lookupLinearMap: return hoisted_lookupLinearMap.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.d.ts

@@ -8,5 +8,9 @@ export declare class LitNamedObjExpr implements HasSourceRange, ILibObjExpr {
     readonly fieldNames: Identifier[];
     readonly values: PebbleExpr[];
     readonly range: SourceRange;
-    constructor(name: Identifier, fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange);
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    readonly typeName: Identifier | undefined;
+    constructor(name: Identifier, fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange, 
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    typeName?: Identifier | undefined);
 }

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.js

@@ -3,10 +3,14 @@ export class LitNamedObjExpr {
     fieldNames;
     values;
     range;
-    constructor(name, fieldNames, values, range) {
+    typeName;
+    constructor(name, fieldNames, values, range, 
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    typeName = undefined) {
         this.name = name;
         this.fieldNames = fieldNames;
         this.values = values;
         this.range = range;
+        this.typeName = typeName;
     }
 }

package/dist/compiler/AstCompiler/internal/exprs/_compileLitteralExpr.js

@@ -93,7 +93,23 @@ export function _compileLitteralNamedObjExpr(ctx, expr, typeHint) {
     else
         typeHint = undefined;
     const constructorName = expr.name.text;
-    const inferredStructType = getStructType(ctx.scope.inferStructTypeFromConstructorName(constructorName)?.structType);
+    let inferredStructType = undefined;
+    // Type.Constructor{ ... } syntax — resolve type directly
+    if (expr.typeName) {
+        const possibleTypes = ctx.scope.resolveType(expr.typeName.text);
+        if (possibleTypes) {
+            const dataTirName = possibleTypes.dataTirName;
+            const sopTirName = possibleTypes.sopTirName;
+            inferredStructType = getStructType((dataTirName ? ctx.program.types.get(dataTirName) : undefined)
+                ?? ctx.program.types.get(sopTirName));
+        }
+        if (!inferredStructType) {
+            return ctx.error(DiagnosticCode._0_is_not_defined, expr.typeName.range, expr.typeName.text);
+        }
+    }
+    else {
+        inferredStructType = getStructType(ctx.scope.inferStructTypeFromConstructorName(constructorName)?.structType);
+    }
     if (!inferredStructType) {
         return ctx.error(DiagnosticCode._0_is_not_defined, expr.name.range, constructorName);
     }
@@ -105,7 +121,11 @@ export function _compileLitteralNamedObjExpr(ctx, expr, typeHint) {
     structType = inferredStructType;
     if (!isTirType(typeHint))
         typeHint = structType ?? inferredStructType;
-    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, structType?.constructors.findIndex(c => c.name === constructorName) ?? -1);
+    const constructorIndex = structType?.constructors.findIndex(c => c.name === constructorName) ?? -1;
+    if (constructorIndex < 0) {
+        return ctx.error(DiagnosticCode._0_is_not_defined, expr.name.range, constructorName);
+    }
+    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, constructorIndex);
     if (!Array.isArray(fieldValues))
         return undefined;
     typeHint = getUnaliased(typeHint);

package/dist/compiler/AstCompiler/utils/getPropAccessReturnType.js

@@ -108,6 +108,15 @@ function getStructPropAccessReturnType(ctx, structType, propName) {
         if (field)
             return field.type;
     }
+    // constructor accessor methods for multi-constructor data structs
+    // e.g. ExtendedInteger.finite() returns int (the field of the Finite constructor)
+    if (structType.constructors.length > 1) {
+        const lowerPropName = propName.toLowerCase();
+        const ctor = structType.constructors.find(c => c.name.toLowerCase() === lowerPropName);
+        if (ctor && ctor.fields.length === 1) {
+            return new TirFuncT([], ctor.fields[0].type);
+        }
+    }
     return findPropInImpls(ctx, structType.methodNamesPtr, propName);
 }
 function findPropInImpls(ctx, methodsNamesPtr, propName) {

package/dist/compiler/SourceTypeMap.js

@@ -143,6 +143,19 @@ export class SourceTypeMap {
                 result.push({ name: field.name, type: field.type, kind: "field" });
             }
         }
+        // constructor accessor methods for multi-constructor structs
+        // e.g. ExtendedInteger.finite() returns int
+        if (type.constructors.length > 1) {
+            for (const ctor of type.constructors) {
+                if (ctor.fields.length === 1) {
+                    result.push({
+                        name: ctor.name.toLowerCase(),
+                        type: new TirFuncT([], ctor.fields[0].type),
+                        kind: "method"
+                    });
+                }
+            }
+        }
         // methods
         result.push(...this.methodsFromMap(type.methodNamesPtr));
         return result;

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

@@ -14,7 +14,7 @@ import { TirLitUndefExpr } from "../../tir/expressions/litteral/TirLitUndefExpr.
 import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.js";
 import { TirAssertAndContinueExpr } from "../../tir/expressions/TirAssertAndContinueExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
+import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
 import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
 import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
 import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
@@ -42,7 +42,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 { TirFuncT, TirListT } from "../../tir/types/TirNativeType/index.js";
+import { TirFuncT, TirListT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
+import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
 import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
 import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
 import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
@@ -67,9 +68,6 @@ export function expressifyVars(ctx, expr) {
         || expr instanceof TirLitTrueExpr
         || expr instanceof TirLitFalseExpr
         || expr instanceof TirLitThisExpr
-        || expr instanceof TirLitArrExpr
-        || expr instanceof TirLitObjExpr
-        || expr instanceof TirLitNamedObjExpr
         || expr instanceof TirLitStrExpr
         || expr instanceof TirLitIntExpr
         || expr instanceof TirLitHexBytesExpr
@@ -77,6 +75,19 @@ export function expressifyVars(ctx, expr) {
         // hoisted expressions are necessarily closed, so no external variables
         || expr instanceof TirHoistedExpr)
         return expr;
+    if (expr instanceof TirLitObjExpr
+        || expr instanceof TirLitNamedObjExpr) {
+        for (let i = 0; i < expr.values.length; i++) {
+            expr.values[i] = expressifyVars(ctx, expr.values[i]);
+        }
+        return expr;
+    }
+    if (expr instanceof TirLitArrExpr) {
+        for (let i = 0; i < expr.elems.length; i++) {
+            expr.elems[i] = expressifyVars(ctx, expr.elems[i]);
+        }
+        return expr;
+    }
     // every property access must be replaced with a variable access (or similar)
     // that is either letted/hoisted/nativeFunc/varAccess expression
     //
@@ -374,6 +385,29 @@ function expressifyMethodCall(ctx, methodCall) {
     }
     if (objectType instanceof TirDataStructType
         || objectType instanceof TirSoPStructType) {
+        // constructor accessor methods for multi-constructor structs
+        // e.g. ExtendedInteger.finite() asserts Finite and returns int
+        if (objectType.constructors.length > 1 && methodCall.args.length === 0) {
+            const lowerMethodName = methodName.toLowerCase();
+            const ctor = objectType.constructors.find(c => c.name.toLowerCase() === lowerMethodName);
+            if (ctor && ctor.fields.length === 1) {
+                const fName = ctor.fields[0].name;
+                const fType = ctor.fields[0].type;
+                const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+                return new TirCaseExpr(objectExpr, [
+                    new TirCaseMatcher(new TirNamedDeconstructVarDecl(ctor.name, new Map([
+                        [fName, new TirSimpleVarDecl(fName, fType, undefined, true, exprRange)]
+                    ]), undefined, objectExpr.type, undefined, true, exprRange), new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: fName,
+                            type: fType,
+                            isConstant: true,
+                        },
+                        isDefinedOutsideFuncScope: false,
+                    }, exprRange), exprRange)
+                ], new TirWildcardCaseMatcher(new TirFailExpr(undefined, fType, exprRange), exprRange), fType, exprRange);
+            }
+        }
         const structMethods = objectType.methodNamesPtr;
         const tirMethodName = structMethods.get(methodName);
         if (!tirMethodName)
@@ -388,6 +422,19 @@ function expressifyMethodCall(ctx, methodCall) {
         if (result)
             return result;
     }
+    if (objectType instanceof TirLinearMapT) {
+        const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+        if (methodName === "lookup") {
+            if (methodCall.args.length !== 1)
+                throw new Error(`Method 'lookup' of type 'LinearMap' takes 1 argument, ${methodCall.args.length} provided`);
+            return new TirCallExpr(TirNativeFunc._lookupLinearMap(objectType.keyTypeArg, objectType.valTypeArg), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+        }
+        // LinearMap is List<PairData> at UPLC level; delegate list methods
+        const listType = new TirListT(new TirPairDataT());
+        const result = expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listType, exprRange);
+        if (result)
+            return result;
+    }
     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/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 _findSopOptional(elems_t: TirType): TirNativeFunc;
+    static _lookupLinearMap(keyT: TirType, valT: TirType): TirNativeFunc;
     static _length(elemT: TirType): TirNativeFunc;
     static _some(elemT: TirType): TirNativeFunc;
     static _every(elemT: TirType): TirNativeFunc;

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

@@ -684,6 +684,14 @@ export class TirNativeFunc {
             new TirListT(elems_t)
         ], new TirSopOptT(elems_t)));
     }
+    static _lookupLinearMap(keyT, valT) {
+        return new TirNativeFunc(IRNativeTag._lookupLinearMap, new TirFuncT([
+            // key: data
+            data_t,
+            // map: list<pair<data,data>>
+            new TirLinearMapT(keyT, valT)
+        ], new TirSopOptT(valT)));
+    }
     static _length(elemT) {
         return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
             // list

package/dist/parser/Parser.js

@@ -1491,6 +1491,23 @@ export class Parser extends DiagnosticEmitter {
                     }
                     return new LitNamedObjExpr(identifier, litObjExpr.fieldNames, litObjExpr.values, SourceRange.join(identifier.range, litObjExpr.range));
                 }
+                // LitNamedObjExpr with type qualifier
+                // eg: `Type.Constructor{ a: 1, b: 2 }`
+                if (tn.peek() === Token.Dot) {
+                    const savedState = tn.mark();
+                    tn.next(); // consume '.'
+                    if (tn.skipIdentifier(IdentifierHandling.Always)) {
+                        const ctorIdentifier = new Identifier(tn.readIdentifier(), tn.range());
+                        if (tn.peek() === Token.OpenBrace) {
+                            const litObjExpr = this.parseExprStart();
+                            if (litObjExpr instanceof LitObjExpr) {
+                                return new LitNamedObjExpr(ctorIdentifier, litObjExpr.fieldNames, litObjExpr.values, SourceRange.join(identifier.range, litObjExpr.range), identifier // typeName
+                                );
+                            }
+                        }
+                    }
+                    tn.reset(savedState);
+                }
                 // param => ...
                 if (tn.peek() === Token.FatArrow
                 // && !tn.isNextTokenOnNewLine() // original impl had this, not sure why

package/package.json

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