@harmoniclabs/pebble 0.1.3-dev8 → 0.1.4-dev0

package/dist/IR/IRNodes/IRHoisted.d.ts

@@ -24,6 +24,7 @@ export interface IRHoistedMeta {
 export interface IRHoistedMetadata extends IRMetadata {
     meta: IRHoistedMeta;
 }
+export declare function __unsafe_clear_hoisted_hash_to_symbol(): void;
 export declare class IRHoisted implements IIRTerm, Cloneable<IRHoisted>, IIRParent, ToJson, IRHoistedMetadata {
     readonly meta: IRHoistedMeta;
     get name(): symbol;

package/dist/IR/IRNodes/IRHoisted.js

@@ -19,6 +19,9 @@ const defaultHoistedMeta = freezeAll({
     forceHoist: false
 });
 const _hoisted_hash_to_symbol = new Map();
+export function __unsafe_clear_hoisted_hash_to_symbol() {
+    _hoisted_hash_to_symbol.clear();
+}
 export class IRHoisted {
     meta;
     get name() {

package/dist/IR/IRNodes/IRLetted.d.ts

@@ -34,6 +34,7 @@ export interface IRLettedMeta extends BaseIRMetadata {
 export interface IRLettedMetadata extends IRMetadata {
     meta: IRLettedMeta;
 }
+export declare function __unsafe_clear_letted_hash_to_symbol(): void;
 export declare class IRLetted implements IIRTerm, Cloneable<IRLetted>, IIRParent, ToJson, IRLettedMetadata {
     private _name;
     readonly meta: IRLettedMeta;

package/dist/IR/IRNodes/IRLetted.js

@@ -26,6 +26,9 @@ const defaultLettedMeta = freezeAll({
     isClosed: false
 });
 const _letted_hash_to_symbol = new Map();
+export function __unsafe_clear_letted_hash_to_symbol() {
+    _letted_hash_to_symbol.clear();
+}
 export class IRLetted {
     _name;
     meta;

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/IRNodes/utils/hashVarSym.d.ts

@@ -1 +1,2 @@
+export declare function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION(): void;
 export declare function hashVarSym(s: symbol): Uint8Array;

package/dist/IR/IRNodes/utils/hashVarSym.js

@@ -19,6 +19,11 @@ function _collectUnusedHashes() {
         }
     }
 }
+export function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION() {
+    _hash_to_sym.clear();
+    unusedHashes.length = 0;
+    _next_hash = MIN_SAFE_INTEGER;
+}
 export function hashVarSym(s) {
     const limitReached = _next_hash >= MAX_SAFE_INTEGER;
     if (_next_hash % 0xffff === 0

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.d.ts

@@ -1,2 +1,3 @@
 import { IRTerm } from "../../IRTerm.js";
+export declare function __unsafe_clear_hoisted_cache(): void;
 export declare function replaceHoistedWithLetted(term: IRTerm): void;

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.js

@@ -2,6 +2,9 @@ import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 const _hoisted_cache = new Map();
+export function __unsafe_clear_hoisted_cache() {
+    _hoisted_cache.clear();
+}
 export function replaceHoistedWithLetted(term) {
     // children first
     const children = term.children();

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/AstCompilationCtx.d.ts

@@ -11,6 +11,9 @@ export interface AstCompilationCtxFuncInfo {
     **/
     parentFunctionCtx: AstCompilationCtxFuncInfo | undefined;
     returnType: TirType;
+    /** when true, skip the return type assignability check
+     * and infer the return type from the returned expression */
+    inferReturnType?: boolean;
 }
 export interface IAstCompilationCtx {
     scope: AstScope;

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

@@ -5,8 +5,10 @@ import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.gener
 import { getUniqueInternalName } from "../../../internalVar.js";
 import { TirFuncExpr } from "../../../tir/expressions/TirFuncExpr.js";
 import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
+import { TirReturnStmt } from "../../../tir/statements/TirReturnStmt.js";
 import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
+import { void_t } from "../../../tir/program/stdScope/stdScope.js";
 import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
 import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileBlockStmt } from "../statements/_compileBlockStmt.js";
@@ -68,9 +70,17 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     }
     else {
         expectedFuncType = (isMethod ? undefined :
-            ctx.program.functions.get(expr.name.text)?.sig()) ?? getDataFuncSignature(ctx, expr.signature);
-        if (!(expectedFuncType instanceof TirFuncT))
-            return undefined;
+            ctx.program.functions.get(expr.name.text)?.sig());
+        if (!(expectedFuncType instanceof TirFuncT)) {
+            // if the return type annotation is missing,
+            // infer it from the body instead of erroring
+            if (!expr.signature.returnType) {
+                return _compileFuncExprInferReturnType(ctx, expr, isMethod);
+            }
+            expectedFuncType = getDataFuncSignature(ctx, expr.signature);
+            if (!(expectedFuncType instanceof TirFuncT))
+                return undefined;
+        }
     }
     const returnType = expectedFuncType.returnType;
     const funcCtx = ctx.newFunctionChildScope(returnType, isMethod);
@@ -97,6 +107,65 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
     return funcExpr;
 }
+/**
+ * compiles a function expression whose return type annotation is missing,
+ * inferring the return type from the body's return expressions.
+ *
+ * uses `inferReturnType` flag on the function context so that
+ * `_compileReturnStmt` skips the return type assignability check.
+ */
+function _compileFuncExprInferReturnType(ctx, expr, isMethod) {
+    // compile param types (reuse getDataFuncSignature logic for params only)
+    const funcParams = expr.signature.params;
+    const paramTypes = new Array(funcParams.length);
+    for (let i = 0; i < funcParams.length; i++) {
+        const param = funcParams[i];
+        if (!param.type)
+            return ctx.error(DiagnosticCode.Could_not_infer_function_signature_parameter_type_is_missing, param.range);
+        const type = _compileDataEncodedConcreteType(ctx, param.type, true);
+        if (!type)
+            return undefined;
+        paramTypes[i] = type;
+    }
+    // use void as a temporary return type; the real type will be inferred
+    // from the body's return expressions after compilation
+    const tempReturnType = void_t;
+    const tempFuncType = new TirFuncT(paramTypes, tempReturnType);
+    const funcCtx = ctx.newFunctionChildScope(tempReturnType, isMethod);
+    // mark the context as inferring so _compileReturnStmt
+    // skips the return type assignability check
+    funcCtx.functionCtx.inferReturnType = true;
+    funcCtx.scope.defineValue({
+        name: expr.name.text,
+        type: tempFuncType,
+        isConstant: true,
+    });
+    if (expr.typeParams.length > 0)
+        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
+    const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr, tempFuncType);
+    if (!destructuredParamsResult)
+        return undefined;
+    const { blockInitStmts, params } = destructuredParamsResult;
+    const astBody = expr.body instanceof BlockStmt ? expr.body :
+        new BlockStmt([new ReturnStmt(expr.body, expr.body.range)], expr.body.range);
+    const compileResult = _compileBlockStmt(funcCtx, astBody);
+    if (!compileResult)
+        return undefined;
+    const body = compileResult[0];
+    body.stmts.unshift(...blockInitStmts);
+    // infer return type from the first return statement in the body
+    const returnType = _inferReturnType(body.stmts) ?? tempReturnType;
+    const funcExpr = new TirFuncExpr(expr.name.text, params, returnType, body, expr.range);
+    return funcExpr;
+}
+function _inferReturnType(stmts) {
+    for (const stmt of stmts) {
+        if (stmt instanceof TirReturnStmt && stmt.value) {
+            return stmt.value.type;
+        }
+    }
+    return undefined;
+}
 function _getDestructuredParamsAsVarDecls(funcCtx, expr, expectedFuncType) {
     const blockInitStmts = [];
     const params = [];

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/internal/statements/_compileReturnStmt.js

@@ -7,11 +7,12 @@ export function _compileReturnStmt(ctx, stmt) {
     if (!ctx.functionCtx)
         return ctx.error(DiagnosticCode.A_return_statement_can_only_be_used_within_a_function_body, stmt.range);
     const hintReturn = ctx.functionCtx.returnType;
+    const inferring = ctx.functionCtx.inferReturnType === true;
     const expr = stmt.value ?
-        _compileExpr(ctx, stmt.value, hintReturn) : new TirLitVoidExpr(stmt.range);
+        _compileExpr(ctx, stmt.value, inferring ? undefined : hintReturn) : new TirLitVoidExpr(stmt.range);
     if (!expr)
         return undefined;
-    if (!canAssignTo(expr.type, hintReturn))
+    if (!inferring && !canAssignTo(expr.type, hintReturn))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.value?.range ?? stmt.range, expr.type.toString(), hintReturn.toString());
     return [new TirReturnStmt(expr, stmt.range)];
 }

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/Compiler.js

@@ -6,6 +6,11 @@ import { AstCompiler } from "./AstCompiler/AstCompiler.js";
 import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
 import { __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRHash.js";
+import { __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRNodes/utils/hashVarSym.js";
+import { __unsafe_clear_hoisted_hash_to_symbol } from "../IR/IRNodes/IRHoisted.js";
+import { __unsafe_clear_letted_hash_to_symbol } from "../IR/IRNodes/IRLetted.js";
+import { __unsafe_clear_hoisted_cache } from "../IR/toUPLC/subRoutines/replaceHoistedWithLetted.js";
+import { __unsafe_clear_mapToType_cache } from "./TirCompiler/expressify/expressifyVars.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
 export { SourceTypeMap } from "./SourceTypeMap.js";
 export class Compiler extends DiagnosticEmitter {
@@ -127,6 +132,11 @@ export class Compiler extends DiagnosticEmitter {
         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();
+        __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
+        __unsafe_clear_hoisted_hash_to_symbol();
+        __unsafe_clear_letted_hash_to_symbol();
+        __unsafe_clear_hoisted_cache();
+        __unsafe_clear_mapToType_cache();
         return serialized;
     }
 }

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.d.ts

@@ -8,3 +8,4 @@ import { ExpressifyCtx } from "./ExpressifyCtx.js";
  * @returns a the modified expression
 **/
 export declare function expressifyVars(ctx: ExpressifyCtx, expr: TirExpr): TirExpr;
+export declare function __unsafe_clear_mapToType_cache(): void;

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()}'`);
@@ -484,3 +531,6 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
     */
 }
 const _base_mapToType_cache = new Map();
+export function __unsafe_clear_mapToType_cache() {
+    _base_mapToType_cache.clear();
+}

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/compiler/tir/expressions/TirTraceExpr.js

@@ -1,4 +1,6 @@
 import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { hoisted_intToUtf8Bytes } from "../../../IR/tree_utils/intToUtf8Bytes.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
@@ -46,8 +48,11 @@ export class TirTraceExpr {
             // assume bytes
             bytesIR = this.traceExpr.toIR(ctx);
         }
-        return _ir_apps(IRNative.trace, 
-        // bytes -> string via decodeUtf8
-        _ir_apps(IRNative.decodeUtf8, bytesIR), this.continuation.toIR(ctx));
+        // Force(trace(msg, Delay(continuation)))
+        // Delay prevents the continuation from being evaluated
+        // as a trace argument; Force evaluates it after the
+        // trace call has logged the message.
+        // This gives correct trace order in loops and nested traces.
+        return new IRForced(_ir_apps(IRNative.trace, _ir_apps(IRNative.decodeUtf8, bytesIR), new IRDelayed(this.continuation.toIR(ctx))));
     }
 }

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-dev8",
+  "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",