@harmoniclabs/pebble 0.3.1 → 0.3.2

package/dist/IR/toUPLC/_internal/_makeAllNegativeNativesHoisted.js

@@ -1,10 +1,20 @@
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { IRNative } from "../../IRNodes/IRNative/index.js";
 import { _modifyChildFromTo } from "./_modifyChildFromTo.js";
 import { iterTree } from "./iterTree.js";
 export function _makeAllNegativeNativesHoisted(term) {
     iterTree(term, elem => {
-        if (elem instanceof IRNative && !(elem.parent instanceof IRHoisted)) {
+        if (elem instanceof IRNative
+            // already wrapped in a sharing container
+            && !(elem.parent instanceof IRHoisted)
+            // A native that is the direct value of an `IRLetted` is already
+            // shared via the letting mechanism, and crucially `IRLetted.value`
+            // UNWRAPS any `IRHoisted` assigned to it (see IRLetted.set value).
+            // Wrapping such a native therefore never "sticks" — the wrapper is
+            // immediately stripped back to the bare native and we'd loop
+            // forever re-wrapping it. Leave it letted.
+            && !(elem.parent instanceof IRLetted)) {
             _modifyChildFromTo(elem.parent, elem, new IRHoisted(elem));
             return true;
         }

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -61,6 +61,13 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     term = replaceNativesAndReturnRoot(term);
     // re-call rewrite to optimize introduced hoisted
     term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
+    // the rewrite above can itself introduce custom (negative-tag) natives
+    // (eg. `equalsInteger(x, 0)` -> `_isZero(x)`, `addInteger(x, 1)` ->
+    // `_increment(x)`); lower those too, otherwise they survive as bare
+    // IRNatives and crash the later forcing pass with
+    // "getNRequiredForces ... input was: -<tag>". This only surfaced in
+    // contracts complex enough for the rewrite to fire on shared/hoisted bodies.
+    term = replaceNativesAndReturnRoot(term);
     // Lower `strictIfThenElse` triple-apps to `IRCase` BEFORE
     // `replaceForcedNativesWithHoisted` would otherwise hoist
     // `(force ifThenElse)` into a shared variable that's no longer

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -43,6 +43,9 @@ export declare class AstCompiler extends DiagnosticEmitter {
     get rootPath(): string;
     constructor(cfg: CompilerOptions, io?: CompilerIoApi, diagnostics?: DiagnosticMessage[]);
     private _isExporting;
+    /** scope used to resolve field types of synthetic internal type decls while a contract body is being derived */
+    private _internalDeclScope;
+    private _internalDeclSrcUid;
     export(funcName: string, modulePath?: string): Promise<TypedProgram>;
     /**
      * Parses the entry file, wraps all top-level statements
@@ -113,7 +116,7 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _collectNamespaceDeclarations;
     private _compileNamespaceDecl;
     private _collectInterfaceDeclarations;
-    registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl): void;
+    registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl, scope?: AstScope, srcUid?: string): void;
     private _collectTypeDeclarations;
     private _compileStructDecl;
     private _compileTypeAliasDecl;

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -101,6 +101,9 @@ export class AstCompiler extends DiagnosticEmitter {
         this._isExporting = false;
     }
     _isExporting;
+    /** scope used to resolve field types of synthetic internal type decls while a contract body is being derived */
+    _internalDeclScope = undefined;
+    _internalDeclSrcUid = "";
     async export(funcName, modulePath) {
         this._isExporting = true;
         if (typeof funcName !== "string")
@@ -357,7 +360,7 @@ export class AstCompiler extends DiagnosticEmitter {
                     i--;
                     continue;
                 }
-                const funcDeclContract = this._contractDeclToFuncDecl(stmt);
+                const funcDeclContract = this._contractDeclToFuncDecl(stmt, topLevelScope, srcUid);
                 if (!funcDeclContract) {
                     // remove from array so we don't process it again
                     void stmts.splice(i, 1);
@@ -665,8 +668,13 @@ export class AstCompiler extends DiagnosticEmitter {
             i--;
         }
     }
-    registerInternalTypeDecl(decl) {
-        this._collectTypeDeclarations([decl], "", this.preludeScope, this.preludeScope);
+    registerInternalTypeDecl(decl, 
+    // scope in which the decl's field types are resolved; defaults to the
+    // contract source scope while a contract body is being derived (so
+    // synthetic decls that reference user types — eg. a redeemer whose
+    // fields are the method params — resolve), otherwise the prelude.
+    scope = this._internalDeclScope ?? this.preludeScope, srcUid = this._internalDeclSrcUid) {
+        this._collectTypeDeclarations([decl], srcUid, scope, scope);
     }
     _collectTypeDeclarations(stmts, srcUid, topLevelScope, srcExports) {
         for (let i = 0; i < stmts.length; i++) {
@@ -990,7 +998,10 @@ export class AstCompiler extends DiagnosticEmitter {
         }
         ;
     }
-    _contractDeclToFuncDecl(contractDecl) {
+    _contractDeclToFuncDecl(contractDecl, 
+    // scope where user types referenced by the contract (eg. method param
+    // types used to derive the redeemer) are resolved
+    userScope = this.preludeScope, srcUid = "") {
         const funcName = getUniqueInternalName(contractDecl.name.text);
         const paramsInternalNamesMap = new Map();
         const funcParams = new Array(contractDecl.params.length + 1);
@@ -1015,7 +1026,21 @@ export class AstCompiler extends DiagnosticEmitter {
         funcParams[contractDecl.params.length] = new SimpleVarDecl(new Identifier(scriptContextName, contractDecl.name.range), new AstNamedTypeExpr(new Identifier("ScriptContext", contractDecl.name.range), [], contractDecl.name.range), undefined, // initExpr
         CommonFlags.Const, contractDecl.name.range);
         const funcSig = new AstFuncType(funcParams, new AstVoidType(contractDecl.name.range), contractDecl.name.range);
-        const contractBody = _deriveContractBody(this, contractDecl, paramsInternalNamesMap, scriptContextName);
+        // make user types referenced by synthetic internal type decls (the
+        // redeemer / datum / per-state structs derived below) resolvable in the
+        // contract's source scope, instead of only the prelude.
+        const prevInternalDeclScope = this._internalDeclScope;
+        const prevInternalDeclSrcUid = this._internalDeclSrcUid;
+        this._internalDeclScope = userScope;
+        this._internalDeclSrcUid = srcUid;
+        let contractBody;
+        try {
+            contractBody = _deriveContractBody(this, contractDecl, paramsInternalNamesMap, scriptContextName);
+        }
+        finally {
+            this._internalDeclScope = prevInternalDeclScope;
+            this._internalDeclSrcUid = prevInternalDeclSrcUid;
+        }
         if (!contractBody)
             return undefined;
         return new FuncDecl(new FuncExpr(new Identifier(funcName, contractDecl.name.range), CommonFlags.None, [], // typeParameters

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

@@ -2,7 +2,8 @@ import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { canAssignTo, isOptionalEncodingBridge } from "../../../tir/types/utils/canAssignTo.js";
+import { TirTypeConversionExpr } from "../../../tir/expressions/TirTypeConversionExpr.js";
 import { inferTypeArgs } from "../../../tir/types/utils/inferTypeArgs.js";
 import { substituteTypeParams } from "../../../tir/types/utils/substituteTypeParams.js";
 import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
@@ -147,8 +148,15 @@ export function _compileCallExpr(ctx, expr, typeHint) {
                 ? funcType.returnType
                 : new TirFuncT(funcType.argTypes.slice(tirArgs.length), funcType.returnType);
             for (let i = 0; i < tirArgs.length && i < funcType.argTypes.length; i++) {
-                if (!canAssignTo(tirArgs[i].type, funcType.argTypes[i]))
+                if (!canAssignTo(tirArgs[i].type, funcType.argTypes[i])) {
+                    // bridge the two incompatible `Optional` encodings with a
+                    // real conversion instead of erroring
+                    if (isOptionalEncodingBridge(tirArgs[i].type, funcType.argTypes[i])) {
+                        tirArgs[i] = new TirTypeConversionExpr(tirArgs[i], funcType.argTypes[i], expr.args[i].range);
+                        continue;
+                    }
                     return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, tirArgs[i].type.toString(), funcType.argTypes[i].toString());
+                }
             }
             return new TirCallExpr(callee, tirArgs, finalCallExprType, expr.range);
         }
@@ -167,8 +175,15 @@ export function _compileCallExpr(ctx, expr, typeHint) {
         const arg = args[i];
         if (!arg)
             return undefined;
-        if (!canAssignTo(arg.type, funcType.argTypes[i]))
+        if (!canAssignTo(arg.type, funcType.argTypes[i])) {
+            // the two `Optional` encodings are incompatible but bridgeable;
+            // insert a real encoding conversion instead of erroring
+            if (isOptionalEncodingBridge(arg.type, funcType.argTypes[i])) {
+                args[i] = new TirTypeConversionExpr(arg, funcType.argTypes[i], expr.args[i].range);
+                continue;
+            }
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, arg.type.toString(), funcType.argTypes[i].toString());
+        }
     }
     return new TirCallExpr(callee, args, finalCallExprType, expr.range);
 }

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

@@ -60,21 +60,26 @@ export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHin
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, matcher.body.range, body.type.toString(), returnTypeHint.toString());
         return new TirCaseMatcher(new TirNamedDeconstructVarDecl(memberName, new Map(), undefined, enumType, undefined, true, patternRange, ctorNameRange), body, matcher.range);
     }
-    const pattern = _compileVarDecl(ctx, matcher.pattern, patternType);
+    // each arm gets its own child scope so that the pattern binders are
+    // scoped to the arm and do NOT leak into the enclosing block (which would
+    // make two mutually-exclusive arms reusing a binder name collide as
+    // "duplicate identifier").
+    const armCtx = ctx.newBranchChildScope();
+    const pattern = _compileVarDecl(armCtx, matcher.pattern, patternType);
     if (!pattern)
         return undefined;
     if (pattern instanceof TirSimpleVarDecl)
         return ctx.error(DiagnosticCode._case_expression_must_decontructed_the_inspected_value, matcher.pattern.range);
     if (!canAssignTo(pattern.type, patternType))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, matcher.pattern.range, pattern.type.toString(), patternType.toString());
-    let bodyCtx = ctx;
+    let bodyCtx = armCtx;
     if (matchedVarName && pattern instanceof TirNamedDeconstructVarDecl) {
         const parentStruct = getStructType(patternType);
         if (parentStruct) {
             const localIdx = parentStruct.constructors.findIndex(c => c.name === pattern.constrName);
             if (localIdx >= 0) {
                 const parentIdx = parentStruct.parentCtorIdx(localIdx);
-                bodyCtx = ctx.newBranchChildScope();
+                bodyCtx = armCtx.newBranchChildScope();
                 if (parentStruct instanceof TirDataStructType
                     || parentStruct instanceof TirSoPStructType) {
                     bodyCtx.scope.narrowVariable(matchedVarName, parentStruct.narrowTo([parentIdx]));

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

@@ -148,6 +148,9 @@ function getLinearMapMethods(kT, vT) {
         lookup: new TirFuncT([kT], new TirSopOptT(vT)),
     };
 }
+// Method-form signatures: the receiver (the `bytes` value the method is
+// called on) is implicit and dropped from the argument list. These mirror the
+// `std.bytes.*` namespace functions registered in `populateStdNamespace`.
 const bytesMethods = Object.freeze({
     length: new TirFuncT([], int_t),
     subByteString: new TirFuncT([int_t, int_t], bytes_t),
@@ -155,6 +158,14 @@ const bytesMethods = Object.freeze({
     show: new TirFuncT([], bytes_t),
     decodeUtf8: new TirFuncT([], string_t),
     prepend: new TirFuncT([int_t], bytes_t),
+    concat: new TirFuncT([bytes_t], bytes_t),
+    indexAt: new TirFuncT([int_t], int_t),
+    equals: new TirFuncT([bytes_t], bool_t),
+    lessThan: new TirFuncT([bytes_t], bool_t),
+    lessThanEquals: new TirFuncT([bytes_t], bool_t),
+    greaterThan: new TirFuncT([bytes_t], bool_t),
+    greaterThanEquals: new TirFuncT([bytes_t], bool_t),
+    toInt: new TirFuncT([], int_t),
 });
 const stringMethods = Object.freeze({
     encodeUtf8: new TirFuncT([], bytes_t),

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

@@ -357,7 +357,29 @@ loopReplacements, assertions = []) {
                 //*/
                 );
             }
-            throw new Error("match statement with multiple non-terminating cases is not implemented yet (sorry)");
+            // more than one case does not terminate:
+            // each non-terminating case must merge its reassigned variables
+            // (and optional early return) into a common SoP state, then the
+            // rest of the body continues from that merged state.
+            // (mirrors the non-terminating `if` statement handling above)
+            // build a SoP type to return from each branch
+            const { sop } = getBranchStmtReturnType(reassignsAndReturns, ctx, stmt.range);
+            const reassignedNames = reassignsAndReturns.reassigned;
+            const finalExpression = new TirCaseExpr(expressifyVars(ctx, stmt.matchExpr), stmt.cases.map(_case => {
+                if (_case.pattern instanceof TirArrayLikeDeconstr)
+                    throw new Error("array-like deconstruction in match statement is not supported");
+                _case.pattern = toNamedDeconstructVarDecl(_case.pattern);
+                const caseCtx = ctx.newChild();
+                const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(_case.pattern, caseCtx);
+                const branchStmts = _case.body instanceof TirBlockStmt
+                    ? _case.body.stmts
+                    : [_case.body];
+                const branchBlock = new TirBlockStmt(nestedDeconstructs.concat(branchStmts), _case.body.range);
+                // expressify the branch so it returns the merged SoP state
+                const caseBody = expressifyIfBranch(caseCtx, branchBlock, reassignedNames, sop, loopReplacements);
+                return new TirCaseMatcher(_case.pattern, caseBody, _case.range);
+            }), stmt.wildcardCase ? new TirWildcardCaseMatcher(expressifyIfBranch(ctx.newChild(), stmt.wildcardCase.body, reassignedNames, sop, loopReplacements), stmt.wildcardCase.range) : undefined, sop, stmt.range);
+            return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, wrapNonTerminatingFinalStmtAsCaseExpr(finalExpression, sop, ctx, stmt.range, reassignsAndReturns, bodyStmts, loopReplacements));
         }
         // else if( stmt instanceof TirForOfStmt ) {
         // 

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

@@ -519,6 +519,31 @@ function expressifyMethodCall(ctx, methodCall) {
         if (methodName === "prepend") {
             return new TirCallExpr(TirNativeFunc.consByteString, [methodCall.args[0], objectExpr], bytes_t, exprRange);
         }
+        // receiver-first byte ops: `a.op( b )` -> native( a, b )
+        if (methodName === "concat") {
+            return new TirCallExpr(TirNativeFunc.appendByteString, [objectExpr, methodCall.args[0]], bytes_t, exprRange);
+        }
+        if (methodName === "indexAt") {
+            return new TirCallExpr(TirNativeFunc.indexByteString, [objectExpr, methodCall.args[0]], int_t, exprRange);
+        }
+        if (methodName === "equals") {
+            return new TirCallExpr(TirNativeFunc.equalsByteString, [objectExpr, methodCall.args[0]], bool_t, exprRange);
+        }
+        if (methodName === "lessThan") {
+            return new TirCallExpr(TirNativeFunc.lessThanByteString, [objectExpr, methodCall.args[0]], bool_t, exprRange);
+        }
+        if (methodName === "lessThanEquals") {
+            return new TirCallExpr(TirNativeFunc.lessThanEqualsByteString, [objectExpr, methodCall.args[0]], bool_t, exprRange);
+        }
+        if (methodName === "greaterThan") {
+            return new TirCallExpr(TirNativeFunc._gtBS, [objectExpr, methodCall.args[0]], bool_t, exprRange);
+        }
+        if (methodName === "greaterThanEquals") {
+            return new TirCallExpr(TirNativeFunc._gtEqBS, [objectExpr, methodCall.args[0]], bool_t, exprRange);
+        }
+        if (methodName === "toInt") {
+            return new TirCallExpr(TirNativeFunc._bytesToIntBE, [objectExpr], int_t, exprRange);
+        }
     }
     // Generic `.show()` fallback: any value whose type has a built-in
     // `_showIR` impl can be shown by emitting a TirShowExpr. User types

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

@@ -113,6 +113,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static get _strictOr(): TirNativeFunc;
     static get _gtBS(): TirNativeFunc;
     static get _gtEqBS(): TirNativeFunc;
+    static get _bytesToIntBE(): TirNativeFunc;
     static get _gtInt(): TirNativeFunc;
     static get _gtEqInt(): TirNativeFunc;
     static get fstPairData(): TirNativeFunc;

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

@@ -709,6 +709,11 @@ export class TirNativeFunc {
             bytes_t
         ], bool_t));
     }
+    static get _bytesToIntBE() {
+        return new TirNativeFunc(IRNativeTag._bytesToIntBE, new TirFuncT([
+            bytes_t
+        ], int_t));
+    }
     static get _gtInt() {
         return new TirNativeFunc(IRNativeTag._gtInt, new TirFuncT([
             int_t,

package/dist/compiler/tir/types/utils/canAssignTo.d.ts

@@ -15,6 +15,18 @@ export declare function getStructType(type: TirType | undefined): TirStructType
 export declare function getNamedDestructableType(type: TirType | undefined): TirNamedDestructableType | undefined;
 export declare function canAssignToOptional(type: TirType): type is TirDataOptT | TirSopOptT | TirAliasType<TirDataOptT | TirSopOptT>;
 export declare function canAssignToList(type: TirType): boolean;
+/**
+ * The two `Optional` representations (data-encoded `TirDataOptT` and
+ * SoP-encoded `TirSopOptT`) are **incompatible at runtime** and therefore not
+ * directly assignable. They can however be bridged by a real encoding
+ * conversion (`TirTypeConversionExpr`, lowered via `_inlineFromData` /
+ * `_inlineToData`).
+ *
+ * @returns `true` if `from` and `to` are Optionals of *different* encodings
+ *          whose type arguments are assignable — i.e. assigning `from` to `to`
+ *          only requires inserting such an encoding conversion.
+ */
+export declare function isOptionalEncodingBridge(from: TirType, to: TirType): boolean;
 /**
  * @returns `true` if `a` can be assigned to `b` **without** explicit cast
  *

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

@@ -60,6 +60,32 @@ export function canAssignToList(type) {
     // || type instanceof TirLinearMapT
     );
 }
+/**
+ * The two `Optional` representations (data-encoded `TirDataOptT` and
+ * SoP-encoded `TirSopOptT`) are **incompatible at runtime** and therefore not
+ * directly assignable. They can however be bridged by a real encoding
+ * conversion (`TirTypeConversionExpr`, lowered via `_inlineFromData` /
+ * `_inlineToData`).
+ *
+ * @returns `true` if `from` and `to` are Optionals of *different* encodings
+ *          whose type arguments are assignable — i.e. assigning `from` to `to`
+ *          only requires inserting such an encoding conversion.
+ */
+export function isOptionalEncodingBridge(from, to) {
+    from = getUnaliased(from);
+    to = getUnaliased(to);
+    const fromIsData = from instanceof TirDataOptT;
+    const fromIsSop = from instanceof TirSopOptT;
+    const toIsData = to instanceof TirDataOptT;
+    const toIsSop = to instanceof TirSopOptT;
+    if (!(fromIsData || fromIsSop) || !(toIsData || toIsSop))
+        return false;
+    // only bridge *across* encodings; same-encoding cases are handled by the
+    // normal assignability rules
+    if (fromIsData === toIsData)
+        return false;
+    return canAssignTo(from.typeArg, to.typeArg);
+}
 /**
  * @returns `true` if `a` can be assigned to `b` **without** explicit cast
  *

package/dist/parser/Parser.d.ts

@@ -53,6 +53,28 @@ interface ParseStmtOpts {
 }
 export declare class Parser extends DiagnosticEmitter {
     readonly tn: Tokenizer;
+    /**
+     * When set, the leading primary of the next parsed expression must NOT be
+     * interpreted as a named-object/struct literal (`Ident{ ... }`).
+     *
+     * This is needed for statements of the form `<keyword> <expr> { ... }`
+     * (eg. `match subject { ... }`) where the `{` introduces the statement
+     * block, not a struct literal body. The flag is consumed (and cleared) by
+     * the first `parseExprStart` call, so nested expressions still allow
+     * struct literals.
+     */
+    private _noStructLiteral;
+    /**
+     * When set (while parsing the subject / arm bodies of a `case` expression),
+     * the `is` keyword is treated as a low-precedence arm separator rather than
+     * the binary `is` (type-narrowing) operator. This lets an arm body absorb
+     * higher-precedence operators (comparisons, arithmetic, etc.) while still
+     * stopping before the next arm's `is`.
+     *
+     * Inside parentheses the body is re-parsed at a low precedence, so a binary
+     * `is` there is still recognised normally (eg. `=> ( x is Foo )`).
+     */
+    private _caseArmIsLowPrec;
     constructor(tokenizer: Tokenizer, diagnostics?: DiagnosticMessage[] | undefined);
     static parseFile(path: string, src: string, getUid?: () => string, isEntry?: boolean): [Source, DiagnosticMessage[]];
     static parseSource(src: Source, diagnostics?: DiagnosticMessage[]): DiagnosticMessage[];
@@ -142,6 +164,11 @@ export declare class Parser extends DiagnosticEmitter {
     private _parseTypeAndInitializer;
     parseTypeExpr(suppressErrors?: boolean): AstTypeExpr | undefined;
     parseParenthesizedExpr(startPos?: number | undefined): ParentesizedExpr | undefined;
+    /**
+     * Like {@link determinePrecedence} but context-sensitive: inside a `case`
+     * expression the `is` keyword acts as a low-precedence arm separator.
+     */
+    private precedenceOf;
     parseExpr(precedence?: Precedence): PebbleExpr | undefined;
     parseExprStart(): PebbleExpr | undefined;
     private joinPropertyCall;

package/dist/parser/Parser.js

@@ -81,6 +81,28 @@ import { LitContextExpr } from "../ast/nodes/expr/litteral/LitContextExpr.js";
 import { tokenIsAlsoIdentifier } from "../tokenizer/utils/tokenIsAlsoIdentifier.js";
 export class Parser extends DiagnosticEmitter {
     tn;
+    /**
+     * When set, the leading primary of the next parsed expression must NOT be
+     * interpreted as a named-object/struct literal (`Ident{ ... }`).
+     *
+     * This is needed for statements of the form `<keyword> <expr> { ... }`
+     * (eg. `match subject { ... }`) where the `{` introduces the statement
+     * block, not a struct literal body. The flag is consumed (and cleared) by
+     * the first `parseExprStart` call, so nested expressions still allow
+     * struct literals.
+     */
+    _noStructLiteral = false;
+    /**
+     * When set (while parsing the subject / arm bodies of a `case` expression),
+     * the `is` keyword is treated as a low-precedence arm separator rather than
+     * the binary `is` (type-narrowing) operator. This lets an arm body absorb
+     * higher-precedence operators (comparisons, arithmetic, etc.) while still
+     * stopping before the next arm's `is`.
+     *
+     * Inside parentheses the body is re-parsed at a low precedence, so a binary
+     * `is` there is still recognised normally (eg. `=> ( x is Foo )`).
+     */
+    _caseArmIsLowPrec = false;
     constructor(tokenizer, diagnostics = undefined) {
         super(diagnostics);
         this.tn = tokenizer;
@@ -1442,6 +1464,15 @@ export class Parser extends DiagnosticEmitter {
         }
         return new ParentesizedExpr(inner, tn.range(startPos, tn.pos));
     }
+    /**
+     * Like {@link determinePrecedence} but context-sensitive: inside a `case`
+     * expression the `is` keyword acts as a low-precedence arm separator.
+     */
+    precedenceOf(kind) {
+        if (kind === Token.Is && this._caseArmIsLowPrec)
+            return Precedence.CaseExpr;
+        return determinePrecedence(kind);
+    }
     parseExpr(precedence = Precedence.Comma) {
         const tn = this.tn;
         let expr = this.parseExprStart();
@@ -1459,7 +1490,7 @@ export class Parser extends DiagnosticEmitter {
         // see: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#climbing
         let nextPrecedence;
         let prevState;
-        outer_while: while ((nextPrecedence = determinePrecedence(tn.peek())) >= precedence) {
+        outer_while: while ((nextPrecedence = this.precedenceOf(tn.peek())) >= precedence) {
             prevState = tn.mark();
             const token = tn.next();
             // DO NOT DIRECTLY RETURN FROM HERE
@@ -1645,6 +1676,10 @@ export class Parser extends DiagnosticEmitter {
     }
     parseExprStart() {
         const tn = this.tn;
+        // consume the flag: only the leading primary of this expression is
+        // affected; any nested expression parsed below allows struct literals.
+        const noStructLiteral = this._noStructLiteral;
+        this._noStructLiteral = false;
         const token = tn.next(IdentifierHandling.Prefer);
         const startPos = tn.tokenPos;
         switch (token) {
@@ -1781,7 +1816,7 @@ export class Parser extends DiagnosticEmitter {
                 const identifier = new Identifier(identifierText, tn.range(startPos, tn.pos));
                 // LitNamedObjExpr
                 // eg: `Identifier{ a: 1, b: 2 }`
-                if (tn.peek() === Token.OpenBrace) {
+                if (!noStructLiteral && tn.peek() === Token.OpenBrace) {
                     const endPos = tn.pos;
                     const litObjExpr = this.parseExprStart();
                     if (!(litObjExpr instanceof LitObjExpr)) {
@@ -1792,7 +1827,7 @@ export class Parser extends DiagnosticEmitter {
                 }
                 // LitNamedObjExpr with type qualifier
                 // eg: `Type.Constructor{ a: 1, b: 2 }`
-                if (tn.peek() === Token.Dot) {
+                if (!noStructLiteral && tn.peek() === Token.Dot) {
                     const savedState = tn.mark();
                     tn.next(); // consume '.'
                     if (tn.skipIdentifier(IdentifierHandling.Always)) {
@@ -1902,47 +1937,53 @@ export class Parser extends DiagnosticEmitter {
         const tn = this.tn;
         // at 'case': Expression ('is' VarDecl '=>' Expression)+ ('else' Expression)?
         const startPos = tn.tokenPos;
-        // parse the matched expression at a precedence higher than `is`
-        // so the case-level `is` is left unconsumed
-        const expr = this.parseExpr(Precedence.Relational + 1);
-        if (!expr)
-            return undefined;
-        const cases = new Array();
-        while (tn.skip(Token.Is)) {
-            const startPos = tn.tokenPos;
-            const matcher = this._parseVarDecl(CommonFlags.Const);
-            if (!matcher)
-                return undefined;
-            // SimpleVarDecl patterns are validated by the AstCompiler, which
-            // has type info (enum-member promotion vs invalid catch-all).
-            if (matcher.initExpr || matcher.type)
-                return this.error(DiagnosticCode.Patterns_may_not_have_initializers_or_explicit_types, matcher.initExpr ? matcher.initExpr.range : matcher.type.range);
-            if (!tn.skip(Token.FatArrow))
-                return this.error(DiagnosticCode._0_expected, tn.range(), "=>");
-            // parse body at precedence higher than `is` so the next case-arm's
-            // `is` is left unconsumed (otherwise `is` would be greedily parsed
-            // as the binary `is` operator inside the body)
-            const body = this.parseExpr(Precedence.Relational + 1);
-            if (!body)
+        // within the case expression, `is` is a low-precedence arm separator
+        const prevCaseArmIsLowPrec = this._caseArmIsLowPrec;
+        this._caseArmIsLowPrec = true;
+        try {
+            // parse the matched expression at a precedence higher than `is`
+            // so the case-level `is` is left unconsumed
+            const expr = this.parseExpr(Precedence.Relational + 1);
+            if (!expr)
                 return undefined;
-            cases.push(new CaseExprMatcher(matcher, body, tn.range(startPos, tn.pos)));
+            const cases = new Array();
+            while (tn.skip(Token.Is)) {
+                const startPos = tn.tokenPos;
+                const matcher = this._parseVarDecl(CommonFlags.Const);
+                if (!matcher)
+                    return undefined;
+                // SimpleVarDecl patterns are validated by the AstCompiler, which
+                // has type info (enum-member promotion vs invalid catch-all).
+                if (matcher.initExpr || matcher.type)
+                    return this.error(DiagnosticCode.Patterns_may_not_have_initializers_or_explicit_types, matcher.initExpr ? matcher.initExpr.range : matcher.type.range);
+                if (!tn.skip(Token.FatArrow))
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "=>");
+                // parse the body absorbing all operators tighter than `is`; the
+                // low-precedence `is` (see `_caseArmIsLowPrec`) stops the body
+                // before the next case-arm's `is`
+                const body = this.parseExpr(Precedence.CaseExpr + 1);
+                if (!body)
+                    return undefined;
+                cases.push(new CaseExprMatcher(matcher, body, tn.range(startPos, tn.pos)));
+            }
+            let wildcardCase = undefined;
+            if (tn.skip(Token.Else)) {
+                const wildcardStart = tn.tokenPos;
+                // parse the body absorbing all operators tighter than `is`
+                const body = this.parseExpr(Precedence.CaseExpr + 1);
+                if (!body)
+                    return undefined;
+                wildcardCase = new CaseWildcardMatcher(body, tn.range(wildcardStart));
+            }
+            tn.skip(Token.Semicolon); // if any
+            const finalRange = tn.range(startPos, tn.pos);
+            if (cases.length < 1)
+                return this.error(DiagnosticCode.A_case_expression_must_have_at_least_one_clause, finalRange);
+            return new CaseExpr(expr, cases, wildcardCase, finalRange);
         }
-        let wildcardCase = undefined;
-        if (tn.skip(Token.Else)) {
-            const wildcardStart = tn.tokenPos;
-            // parse body at precedence higher than `is` so the next case-arm's
-            // `is` is left unconsumed (otherwise `is` would be greedily parsed
-            // as the binary `is` operator inside the body)
-            const body = this.parseExpr(Precedence.Relational + 1);
-            if (!body)
-                return undefined;
-            wildcardCase = new CaseWildcardMatcher(body, tn.range(wildcardStart));
+        finally {
+            this._caseArmIsLowPrec = prevCaseArmIsLowPrec;
         }
-        tn.skip(Token.Semicolon); // if any
-        const finalRange = tn.range(startPos, tn.pos);
-        if (cases.length < 1)
-            return this.error(DiagnosticCode.A_case_expression_must_have_at_least_one_clause, finalRange);
-        return new CaseExpr(expr, cases, wildcardCase, finalRange);
     }
     parseFunctionExpr() {
         const tn = this.tn;
@@ -2640,7 +2681,10 @@ export class Parser extends DiagnosticEmitter {
         const tn = this.tn;
         // at 'match': Expression '{' MatchStmtCase* '}' ';'
         const startPos = tn.pos;
+        // the `{` after the subject opens the match block, not a struct literal
+        this._noStructLiteral = true;
         const expr = this.parseExpr();
+        this._noStructLiteral = false;
         if (!expr)
             return this.error(DiagnosticCode.Expression_expected, tn.range(startPos - 5, startPos));
         if (!tn.skip(Token.OpenBrace))

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const COMPILER_VERSION = "0.3.1";
+export declare const COMPILER_VERSION = "0.3.2";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // This file is auto-generated by scripts/genVersion.js. Do not edit.
-export const COMPILER_VERSION = "0.3.1";
+export const COMPILER_VERSION = "0.3.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -68,7 +68,7 @@
     "@harmoniclabs/buildooor": "^0.2.6",
     "@types/jest": "^28.1.4",
     "@types/node": "^18.14.6",
-    "jest": "^29.4.3",
+    "jest": "^30.4.2",
     "jest-environment-jsdom": "^30.3.0",
     "tsc-alias": "^1.7.1",
     "typescript": "^4.6.3"