@harmoniclabs/pebble 0.1.8 → 0.1.9

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.js

@@ -1,3 +1,5 @@
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
 import { ArrayLikeDeconstr } from "../../../../ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js";
 import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
 import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
@@ -14,6 +16,11 @@ import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.j
 import { _compileExpr } from "../exprs/_compileExpr.js";
 import { _compileStatement } from "./_compileStatement.js";
 import { _compileNamedDeconstructVarDecl, _compileSingleDeconstructVarDecl } from "./_compileVarStmt.js";
+function unwrapToIdentifierName(expr) {
+    while (expr instanceof ParentesizedExpr)
+        expr = expr.expr;
+    return expr instanceof Identifier ? expr.text : undefined;
+}
 export function _compileMatchStmt(ctx, stmt) {
     if (!ctx.functionCtx)
         return ctx.error(DiagnosticCode.A_match_statement_can_only_be_used_within_a_function_body, stmt.range);
@@ -33,10 +40,11 @@ export function _compileMatchStmt(ctx, stmt) {
     const missingCtors = ctorNames.slice();
     if (stmt.cases.length === 0)
         return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
+    const matchedVarName = unwrapToIdentifierName(stmt.matchExpr);
     const cases = [];
     const constrNamesAlreadySpecified = [];
     for (const matchCase of stmt.cases) {
-        const branch = _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified);
+        const branch = _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified, matchedVarName);
         if (!branch)
             return undefined;
         /*
@@ -67,7 +75,7 @@ export function _compileMatchStmt(ctx, stmt) {
     }
     return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
 }
-export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified) {
+export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, constrNamesAlreadySpecified, matchedVarName) {
     /*
     const pattern = _compileVarDecl( ctx, matchCase.pattern, deconstructableType );
     if( !pattern ) return undefined;
@@ -101,10 +109,15 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
         constrNamesAlreadySpecified.push(deconstructedCtorName);
         if (deconstructableType instanceof TirSoPStructType
             || deconstructableType instanceof TirDataStructType) {
-            const ctorDef = deconstructableType.constructors.find(c => c.name === deconstructedCtorName);
-            if (!ctorDef)
+            const localIdx = deconstructableType.constructors.findIndex(c => c.name === deconstructedCtorName);
+            if (localIdx < 0)
                 return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
             const branchCtx = ctx.newBranchChildScope();
+            // narrow the matched variable (if it's a plain identifier) to the matched constructor
+            if (matchedVarName) {
+                const parentIdx = deconstructableType.parentCtorIdx(localIdx);
+                branchCtx.scope.narrowVariable(matchedVarName, deconstructableType.narrowTo([parentIdx]));
+            }
             const branchArg = _compileNamedDeconstructVarDecl(branchCtx, pattern, deconstructableType);
             if (!branchArg)
                 return undefined;

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

@@ -74,12 +74,24 @@ export declare class AstScope {
      * ast name -> variable infos (name, type, isConstant)
      */
     readonly variables: Map<string, IVariableInfos>;
+    /**
+     * Flow-sensitive type narrowings active in this scope.
+     * Variable name -> narrowed type (overrides the type recorded in `variables`
+     * or any parent scope's narrowing/binding when resolving this variable).
+     */
+    readonly narrowings: Map<string, TirType>;
     readonly aviableConstructors: Map<string, IAvaiableConstructor>;
     private _isReadonly;
     readonly infos: ScopeInfos;
     constructor(parent: AstScope | undefined, program: TypedProgram, infos: Partial<ScopeInfos>);
     defineValue(valueInfos: IVariableInfos): boolean;
     resolveValue(name: string): ResolveValueResult | undefined;
+    /**
+     * Records a flow-sensitive narrowing for `name` in THIS scope.
+     * Subsequent `resolveValue(name)` calls (in this scope or its
+     * descendants, until shadowed) will return the narrowed type.
+     */
+    narrowVariable(name: string, narrowedType: TirType): void;
     allVariables(): string[];
     defineUnambigousType(name: string, tirTypeKey: string, allowsDataEncoding: boolean, methodsNames: Map<AstFuncName, TirFuncName>): boolean;
     defineType(name: string, possibleTirTypes: PossibleTirTypes): boolean;

package/dist/compiler/AstCompiler/scope/AstScope.js

@@ -52,6 +52,12 @@ export class AstScope {
      * ast name -> variable infos (name, type, isConstant)
      */
     variables = new Map();
+    /**
+     * Flow-sensitive type narrowings active in this scope.
+     * Variable name -> narrowed type (overrides the type recorded in `variables`
+     * or any parent scope's narrowing/binding when resolving this variable).
+     */
+    narrowings = new Map();
     aviableConstructors = new Map();
     _isReadonly = false;
     infos;
@@ -75,10 +81,13 @@ export class AstScope {
         return true;
     }
     resolveValue(name) {
+        const narrowed = this.narrowings.get(name);
         const localValue = this.variables.get(name);
         if (localValue)
             return {
-                variableInfos: localValue,
+                variableInfos: narrowed
+                    ? { ...localValue, type: narrowed }
+                    : localValue,
                 isDefinedOutsideFuncScope: false
             };
         if (this.parent) {
@@ -86,12 +95,24 @@ export class AstScope {
             if (!parentValue)
                 return undefined;
             return {
-                variableInfos: parentValue.variableInfos,
+                variableInfos: narrowed
+                    ? { ...parentValue.variableInfos, type: narrowed }
+                    : parentValue.variableInfos,
                 isDefinedOutsideFuncScope: parentValue.isDefinedOutsideFuncScope || this.infos.isFunctionDeclScope
             };
         }
         return undefined;
     }
+    /**
+     * Records a flow-sensitive narrowing for `name` in THIS scope.
+     * Subsequent `resolveValue(name)` calls (in this scope or its
+     * descendants, until shadowed) will return the narrowed type.
+     */
+    narrowVariable(name, narrowedType) {
+        if (this._isReadonly)
+            return;
+        this.narrowings.set(name, narrowedType);
+    }
     allVariables() {
         return (this.parent?.allVariables() ?? []).concat(Array.from(this.variables.keys()));
     }
@@ -185,6 +206,8 @@ export class AstScope {
         const cloned = new AstScope(this.parent, this.program, this.infos);
         for (const [key, value] of this.variables)
             cloned.variables.set(key, { ...value });
+        for (const [key, value] of this.narrowings)
+            cloned.narrowings.set(key, value.clone());
         for (const [key, value] of this.functions)
             cloned.functions.set(key, value);
         for (const [key, value] of this.types)

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

@@ -0,0 +1,30 @@
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { TirStructType } from "../../tir/types/TirStructType.js";
+export interface IsNarrowing {
+    varName: string;
+    /** indexes (in the parent struct's `constructors` array) still possible after the check */
+    parentCtorIdxs: number[];
+    /** original variable type (before narrowing); the parent struct, used to build the narrowed clone */
+    parentStructType: TirStructType;
+}
+/**
+ * Walk a boolean expression and collect flow-sensitive narrowings that
+ * can be assumed true when the expression evaluates to `polarity`.
+ *
+ * Rules:
+ *  - `x is C` ⇒ on TRUE: x narrows to {C}; on FALSE: x narrows to "all but C"
+ *  - `!cond` ⇒ flip polarity and recurse
+ *  - `a && b` ⇒ on TRUE: union of narrowings from a and b; on FALSE: nothing
+ *  - `a || b` ⇒ on TRUE: nothing; on FALSE: union of FALSE-narrowings from a and b
+ *  - parens are transparent
+ *
+ * Multiple narrowings on the same variable intersect (most restrictive wins).
+ */
+export declare function extractIsNarrowings(expr: TirExpr, polarity: boolean): IsNarrowing[];
+/**
+ * Apply a list of narrowings to the current scope of `ctx`.
+ * Builds a narrowed clone of the parent struct and registers it
+ * via `scope.narrowVariable`.
+ */
+import type { AstScope } from "../scope/AstScope.js";
+export declare function applyNarrowingsToScope(scope: AstScope, narrowings: IsNarrowing[]): void;

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

@@ -0,0 +1,110 @@
+import { TirIsExpr } from "../../tir/expressions/TirIsExpr.js";
+import { TirParentesizedExpr } from "../../tir/expressions/TirParentesizedExpr.js";
+import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
+import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
+// NOTE: TirLogicalAndExpr / TirLogicalOrExpr come from TirBinaryExpr.ts which
+// pulls in the IR -> UPLC compiler. Importing them here at the top would
+// create a require-cycle (this file is loaded by `_compileAssertStmt.ts`
+// during ast-compilation, before `compileIRToUPLC` finishes initializing).
+// We detect them by constructor name instead.
+import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { getStructType } from "../../tir/types/utils/canAssignTo.js";
+/**
+ * Walk a boolean expression and collect flow-sensitive narrowings that
+ * can be assumed true when the expression evaluates to `polarity`.
+ *
+ * Rules:
+ *  - `x is C` ⇒ on TRUE: x narrows to {C}; on FALSE: x narrows to "all but C"
+ *  - `!cond` ⇒ flip polarity and recurse
+ *  - `a && b` ⇒ on TRUE: union of narrowings from a and b; on FALSE: nothing
+ *  - `a || b` ⇒ on TRUE: nothing; on FALSE: union of FALSE-narrowings from a and b
+ *  - parens are transparent
+ *
+ * Multiple narrowings on the same variable intersect (most restrictive wins).
+ */
+export function extractIsNarrowings(expr, polarity) {
+    const acc = [];
+    collect(expr, polarity, acc);
+    return mergeIntersect(acc);
+}
+function collect(expr, polarity, acc) {
+    if (expr instanceof TirParentesizedExpr) {
+        collect(expr.expr, polarity, acc);
+        return;
+    }
+    if (expr instanceof TirUnaryExclamation) {
+        collect(expr.operand, !polarity, acc);
+        return;
+    }
+    const ctorName = expr?.constructor?.name;
+    if (ctorName === "TirLogicalAndExpr") {
+        if (polarity) {
+            collect(expr.left, true, acc);
+            collect(expr.right, true, acc);
+        }
+        // FALSE side of `&&` tells us nothing
+        return;
+    }
+    if (ctorName === "TirLogicalOrExpr") {
+        if (!polarity) {
+            collect(expr.left, false, acc);
+            collect(expr.right, false, acc);
+        }
+        // TRUE side of `||` tells us nothing
+        return;
+    }
+    if (expr instanceof TirIsExpr) {
+        const inst = expr.instanceExpr;
+        if (!(inst instanceof TirVariableAccessExpr))
+            return;
+        const parentStructType = getStructType(inst.type);
+        if (!parentStructType)
+            return;
+        if (polarity) {
+            acc.push({
+                varName: inst.varName,
+                parentCtorIdxs: [expr.parentCtorIdx],
+                parentStructType
+            });
+        }
+        else {
+            // narrow to all OTHER parent constructor indexes still possible
+            const baseIdxs = parentStructType.narrowedFromParentCtorIdxs
+                ?? parentStructType.constructors.map((_, i) => i);
+            const remaining = baseIdxs.filter(idx => idx !== expr.parentCtorIdx);
+            if (remaining.length === 0)
+                return; // narrowed away entirely; type unchanged
+            acc.push({
+                varName: inst.varName,
+                parentCtorIdxs: remaining,
+                parentStructType
+            });
+        }
+        return;
+    }
+}
+/**
+ * Merge multiple narrowings: per variable, take the intersection of
+ * possible parent constructor indexes (most restrictive).
+ */
+function mergeIntersect(narrowings) {
+    const byVar = new Map();
+    for (const n of narrowings) {
+        const existing = byVar.get(n.varName);
+        if (!existing) {
+            byVar.set(n.varName, { ...n, parentCtorIdxs: [...n.parentCtorIdxs] });
+            continue;
+        }
+        existing.parentCtorIdxs = existing.parentCtorIdxs.filter(idx => n.parentCtorIdxs.includes(idx));
+    }
+    return [...byVar.values()].filter(n => n.parentCtorIdxs.length > 0);
+}
+export function applyNarrowingsToScope(scope, narrowings) {
+    for (const n of narrowings) {
+        if (!(n.parentStructType instanceof TirDataStructType)
+            && !(n.parentStructType instanceof TirSoPStructType))
+            continue;
+        const narrowed = n.parentStructType.narrowTo(n.parentCtorIdxs);
+        scope.narrowVariable(n.varName, narrowed);
+    }
+}

package/dist/compiler/Compiler.js

@@ -1,4 +1,4 @@
-import { compileUPLC, parseUPLC, UPLCProgram } from "@harmoniclabs/uplc";
+import { compileUPLC, Force, parseUPLC, UPLCProgram } from "@harmoniclabs/uplc";
 import { Machine } from "@harmoniclabs/plutus-machine";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
 import { defaultOptions } from "../IR/toUPLC/CompilerOptions.js";
@@ -98,7 +98,9 @@ export class Compiler extends DiagnosticEmitter {
         }
         const serialized = this._compileBackend(cfg, program);
         const uplcProgram = parseUPLC(serialized);
-        return Machine.eval(uplcProgram.body);
+        // the run-wrapper is always a 0-arg function, which now
+        // compiles to `Delay(body)`; force it so the body executes.
+        return Machine.eval(new Force(uplcProgram.body));
     }
     async runRepl(config) {
         const cfg = {
@@ -120,7 +122,9 @@ export class Compiler extends DiagnosticEmitter {
         }
         const serialized = this._compileBackend(cfg, program);
         const uplcProgram = parseUPLC(serialized);
-        return Machine.eval(uplcProgram.body);
+        // the repl-wrapper is always a 0-arg function, which now
+        // compiles to `Delay(body)`; force it so the body executes.
+        return Machine.eval(new Force(uplcProgram.body));
     }
     _compileBackend(cfg, program) {
         // backend starts here

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

@@ -15,6 +15,7 @@ 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, TirWildcardCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
+import { TirIsExpr } from "../../tir/expressions/TirIsExpr.js";
 import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
 import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
 import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
@@ -182,6 +183,10 @@ export function expressifyVars(ctx, expr) {
         expr.ifFalse = ifFalse;
         return expr;
     }
+    if (expr instanceof TirIsExpr) {
+        expr.instanceExpr = expressifyVars(ctx, expr.instanceExpr);
+        return expr;
+    }
     if (isTirBinaryExpr(expr)) {
         const left = expressifyVars(ctx, expr.left);
         const right = expressifyVars(ctx, expr.right);
@@ -260,6 +265,7 @@ function expressifyPropAccess(ctx, propAccessExpr) {
         || expr instanceof TirPropAccessExpr // `expressifyVars` is called recursively on the object before this check
         // these result to native types
         || expr instanceof TirUnaryExclamation // boolean
+        || expr instanceof TirIsExpr // boolean
         || expr instanceof TirUnaryPlus // int
         || expr instanceof TirUnaryMinus // int
         || expr instanceof TirUnaryTilde // bytes

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

@@ -1,4 +1,5 @@
 import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 export class TirCallExpr {
     func;
@@ -38,6 +39,9 @@ export class TirCallExpr {
     }
     get isConstant() { return false; }
     toIR(ctx) {
+        if (this.args.length === 0) {
+            return new IRForced(this.func.toIR(ctx));
+        }
         return _ir_apps(this.func.toIR(ctx), ...this.args.map(arg => arg.toIR(ctx)));
     }
 }

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

@@ -112,7 +112,14 @@ export class TirCaseExpr {
         }
         // TirSopStructType
         const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
-        const branches = matchExprType.constructors.map((ctor, ctorIdx) => {
+        // For narrowed SoP types, `matchExprType.constructors` may be a strict
+        // subset of the runtime universe. The IRCase branch array must be
+        // indexed by runtime (parent) ctor index, so we build it sized to the
+        // largest parent index we know about and fill missing slots with the
+        // wildcard / IRError.
+        const sopType = matchExprType instanceof TirSopOptT ? undefined : matchExprType;
+        const sopParentIdxs = sopType?.narrowedFromParentCtorIdxs;
+        const localBranches = matchExprType.constructors.map((ctor, ctorIdx) => {
             const nFields = ctor.fields.length;
             const branchCtx = ctx.newChild();
             const branch = this.cases.find(c => c.pattern.constrName === ctor.name);
@@ -142,6 +149,21 @@ export class TirCaseExpr {
                 return branch.body.toIR(branchCtx);
             return new IRFunc(introducedVars, branch.body.toIR(branchCtx));
         });
+        // Map local branches into runtime-indexed slots. For un-narrowed types
+        // this is identity.
+        let branches;
+        if (sopParentIdxs) {
+            const maxParent = sopParentIdxs.reduce((m, x) => x > m ? x : m, -1);
+            branches = new Array(maxParent + 1);
+            for (let i = 0; i < branches.length; i++)
+                branches[i] = wildcardBodyIR;
+            for (let localIdx = 0; localIdx < localBranches.length; localIdx++) {
+                branches[sopParentIdxs[localIdx]] = localBranches[localIdx];
+            }
+        }
+        else {
+            branches = localBranches;
+        }
         // branches at the end that are supposed to "just fail"
         // can be omitted, as the CEK machine will fail if no branch for
         // a given constructor is found
@@ -202,9 +224,12 @@ export class TirCaseExpr {
                 .filter(fName => pattern.fields.has(fName)));
             if (usedFieldsCtorNames.length <= 0) {
                 ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition
+                // condition (compare against the PARENT ctor index — the
+                // value's runtime tag is unaffected by narrowing)
                 _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(ctorIdx)), 
+                IRConst.int(matchExprType instanceof TirDataStructType
+                    ? matchExprType.parentCtorIdx(ctorIdx)
+                    : ctorIdx)), 
                 // then
                 body.toIR(stmtCtx), 
                 // else
@@ -229,9 +254,12 @@ export class TirCaseExpr {
                 IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
                 )))), body.toIR(thenCtx));
                 ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition
+                // condition (compare against the PARENT ctor index — the
+                // value's runtime tag is unaffected by narrowing)
                 _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(ctorIdx)), 
+                IRConst.int(matchExprType instanceof TirDataStructType
+                    ? matchExprType.parentCtorIdx(ctorIdx)
+                    : ctorIdx)), 
                 // then
                 thenCase, 
                 // else
@@ -257,9 +285,12 @@ export class TirCaseExpr {
             ), // fileds as data list
             _ir_apps(new IRFunc(introducedVars, body.toIR(thenCtx)), ...extractedFields));
             ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-            // condition
+            // condition (compare against the PARENT ctor index — the
+            // value's runtime tag is unaffected by narrowing)
             _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-            IRConst.int(ctorIdx)), 
+            IRConst.int(matchExprType instanceof TirDataStructType
+                ? matchExprType.parentCtorIdx(ctorIdx)
+                : ctorIdx)), 
             // then
             thenCase, 
             // else

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

@@ -20,5 +20,6 @@ import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.js";
 import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
-export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR);
+import { TirIsExpr } from "./TirIsExpr.js";
+export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirIsExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR);
 export declare function isTirExpr(thing: any): thing is TirExpr;

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

@@ -21,6 +21,7 @@ import { TirTraceIfFalseExpr } from "./TirTraceIfFalseExpr.js";
 import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
+import { TirIsExpr } from "./TirIsExpr.js";
 export function isTirExpr(thing) {
     return isObject(thing) && (isTirUnaryPrefixExpr(thing)
         || isTirLitteralExpr(thing)
@@ -29,7 +30,7 @@ export function isTirExpr(thing) {
         || thing instanceof TirCallExpr
         || thing instanceof TirCaseExpr
         || thing instanceof TirTypeConversionExpr
-        // || thing instanceof TirIsExpr
+        || thing instanceof TirIsExpr
         || thing instanceof TirElemAccessExpr
         || thing instanceof TirTernaryExpr
         || thing instanceof TirPropAccessExpr

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

@@ -4,6 +4,7 @@ import { IRRecursive } from "../../../IR/IRNodes/IRRecursive.js";
 import { TirReturnStmt } from "../statements/TirReturnStmt.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 export class TirFuncExpr {
     name;
     params;
@@ -101,7 +102,9 @@ export class TirFuncExpr {
         if (isRecursive)
             recursiveVarSym = ctx.defineRecursiveVar(this.name);
         const introuducedVars = this.params.map(param => ctx.defineVar(param.name));
-        let irFunc = new IRFunc(introuducedVars, expr.toIR(ctx));
+        let irFunc = this.params.length === 0
+            ? new IRDelayed(expr.toIR(ctx))
+            : new IRFunc(introuducedVars, expr.toIR(ctx));
         if (isRecursive)
             irFunc = new IRRecursive(recursiveVarSym, irFunc);
         return irFunc;

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

@@ -0,0 +1,23 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirBoolT } from "../types/TirNativeType/native/bool.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirIsExpr implements ITirExpr {
+    instanceExpr: TirExpr;
+    readonly ctorName: string;
+    /** index in the *parent* (un-narrowed) struct's `constructors` array */
+    readonly parentCtorIdx: number;
+    readonly range: SourceRange;
+    readonly type: TirBoolT;
+    constructor(instanceExpr: TirExpr, ctorName: string, 
+    /** index in the *parent* (un-narrowed) struct's `constructors` array */
+    parentCtorIdx: number, range: SourceRange, boolType: TirBoolT);
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirIsExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

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

@@ -0,0 +1,87 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+export class TirIsExpr {
+    instanceExpr;
+    ctorName;
+    parentCtorIdx;
+    range;
+    type;
+    constructor(instanceExpr, ctorName, 
+    /** index in the *parent* (un-narrowed) struct's `constructors` array */
+    parentCtorIdx, range, boolType) {
+        this.instanceExpr = instanceExpr;
+        this.ctorName = ctorName;
+        this.parentCtorIdx = parentCtorIdx;
+        this.range = range;
+        this.type = boolType;
+    }
+    toString() {
+        return `(${this.instanceExpr.toString()} is ${this.ctorName})`;
+    }
+    pretty(indent) {
+        return `(${this.instanceExpr.pretty(indent)} is ${this.ctorName})`;
+    }
+    clone() {
+        return new TirIsExpr(this.instanceExpr.clone(), this.ctorName, this.parentCtorIdx, this.range.clone(), this.type.clone());
+    }
+    deps() {
+        return this.instanceExpr.deps();
+    }
+    get isConstant() { return this.instanceExpr.isConstant; }
+    toIR(ctx) {
+        const structType = getUnaliased(this.instanceExpr.type);
+        if (structType instanceof TirDataStructType) {
+            // equalsInteger(parentCtorIdx, fstPair(unConstrData(<instance>)))
+            return _ir_apps(IRNative.equalsInteger, IRConst.int(this.parentCtorIdx), _ir_apps(IRNative.fstPair, _ir_apps(IRNative.unConstrData, this.instanceExpr.toIR(ctx))));
+        }
+        if (structType instanceof TirSoPStructType) {
+            // we need a branch in the IRCase per ORIGINAL parent constructor.
+            // the type system has narrowed `instanceExpr.type`, but at runtime
+            // the value is still a Constr from the parent universe; if the
+            // current type is narrowed, we use its parent-idx mapping.
+            const localToParent = structType.narrowedFromParentCtorIdxs
+                ?? structType.constructors.map((_, i) => i);
+            // We need to size the IRCase to the maximum parent index we know about.
+            // For pure narrowing of an SoP value at runtime, we still see ALL
+            // parent constructors. Without access to the un-narrowed type here,
+            // we trust the constructor list reflects the runtime layout when
+            // `structType` is un-narrowed; when narrowed we still ALSO need to
+            // produce a complete IRCase for the underlying value.
+            //
+            // For the un-narrowed case (structType.constructors enumerates all
+            // runtime variants) this is correct. For a narrowed SoP (where the
+            // local constructors array is smaller than the runtime arity), we
+            // must emit a branch for every original parent slot up to `max + 1`
+            // and treat anything outside the narrowed set as "false".
+            const maxParentIdx = localToParent.reduce((m, x) => x > m ? x : m, -1);
+            const branchCount = maxParentIdx + 1;
+            const branches = new Array(branchCount);
+            for (let parentIdx = 0; parentIdx < branchCount; parentIdx++) {
+                // find the local constructor for this parent index, if any
+                const localIdx = localToParent.indexOf(parentIdx);
+                const matches = parentIdx === this.parentCtorIdx;
+                const body = IRConst.bool(matches);
+                // we don't know the field arity for parent slots that have
+                // been narrowed away. Use the local ctor if present;
+                // otherwise no params (best-effort: narrowed-away slots
+                // shouldn't be reachable at runtime in well-typed code).
+                const fields = localIdx >= 0 ? structType.constructors[localIdx].fields.length : 0;
+                if (fields <= 0) {
+                    branches[parentIdx] = body;
+                }
+                else {
+                    const introduced = Array(fields).fill(0).map(() => Symbol("_"));
+                    branches[parentIdx] = new IRFunc(introduced, body);
+                }
+            }
+            return new IRCase(this.instanceExpr.toIR(ctx), branches);
+        }
+        throw new Error("`is` operator can only be applied to struct types; got: "
+            + this.instanceExpr.type.toString());
+    }
+}