@harmoniclabs/pebble 0.1.8 → 0.1.10

package/dist/ast/nodes/expr/IsExpr.d.ts

@@ -1 +1,10 @@
-export {};
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { PebbleExpr } from "./PebbleExpr.js";
+export declare class IsExpr implements HasSourceRange {
+    instanceExpr: PebbleExpr;
+    readonly ofConstr: Identifier;
+    readonly range: SourceRange;
+    constructor(instanceExpr: PebbleExpr, ofConstr: Identifier, range: SourceRange);
+}

package/dist/ast/nodes/expr/IsExpr.js

@@ -1,14 +1,10 @@
-export {};
-// TODO:
-// should optionally check for destructuring 
-/*
-export class IsExpr
-    implements HasSourceRange
-{
-    constructor(
-        readonly instanceExpr: PebbleExpr,
-        readonly ofType: Identifier,
-        readonly range: SourceRange
-    ) {}
+export class IsExpr {
+    instanceExpr;
+    ofConstr;
+    range;
+    constructor(instanceExpr, ofConstr, range) {
+        this.instanceExpr = instanceExpr;
+        this.ofConstr = ofConstr;
+        this.range = range;
+    }
 }
-    //*/ 

package/dist/ast/nodes/expr/PebbleExpr.d.ts

@@ -2,6 +2,7 @@ import { CaseExpr } from "./CaseExpr.js";
 import { ElemAccessExpr } from "./ElemAccessExpr.js";
 import { CallExpr } from "./functions/CallExpr.js";
 import { FuncExpr } from "./functions/FuncExpr.js";
+import { IsExpr } from "./IsExpr.js";
 import { LitteralExpr } from "./litteral/LitteralExpr.js";
 import { NonNullExpr } from "./unary/NonNullExpr.js";
 import { ParentesizedExpr } from "./ParentesizedExpr.js";
@@ -15,5 +16,5 @@ import { BinaryExpr } from "./binary/BinaryExpr.js";
  * an expression is anything that can be evaluated to a value
  * it must therefore have a type
  */
-export type PebbleExpr = UnaryPrefixExpr | NonNullExpr | LitteralExpr | ParentesizedExpr | FuncExpr | CallExpr | CaseExpr | TypeConversionExpr | NonNullExpr | ElemAccessExpr | TernaryExpr | Identifier | BinaryExpr | PropAccessExpr;
+export type PebbleExpr = UnaryPrefixExpr | NonNullExpr | LitteralExpr | ParentesizedExpr | FuncExpr | CallExpr | CaseExpr | TypeConversionExpr | NonNullExpr | IsExpr | ElemAccessExpr | TernaryExpr | Identifier | BinaryExpr | PropAccessExpr;
 export declare function isPebbleExpr(thing: any): thing is PebbleExpr;

package/dist/ast/nodes/expr/PebbleExpr.js

@@ -2,6 +2,7 @@ import { CaseExpr } from "./CaseExpr.js";
 import { ElemAccessExpr } from "./ElemAccessExpr.js";
 import { CallExpr } from "./functions/CallExpr.js";
 import { FuncExpr } from "./functions/FuncExpr.js";
+import { IsExpr } from "./IsExpr.js";
 import { isLitteralExpr } from "./litteral/LitteralExpr.js";
 import { NonNullExpr } from "./unary/NonNullExpr.js";
 import { ParentesizedExpr } from "./ParentesizedExpr.js";
@@ -21,7 +22,7 @@ export function isPebbleExpr(thing) {
         || thing instanceof CaseExpr
         || thing instanceof TypeConversionExpr
         || thing instanceof NonNullExpr
-        // || thing instanceof IsExpr
+        || thing instanceof IsExpr
         || thing instanceof ElemAccessExpr
         || thing instanceof TernaryExpr
         // || thing instanceof CommaExpr

package/dist/ast/nodes/statements/declarations/ContractDecl.d.ts

@@ -3,6 +3,7 @@ import { Identifier } from "../../common/Identifier.js";
 import { HasSourceRange } from "../../HasSourceRange.js";
 import { FuncDecl } from "./FuncDecl.js";
 import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
+import { StateDecl } from "./StateDecl.js";
 export declare class ContractDecl implements HasSourceRange {
     readonly name: Identifier;
     readonly params: SimpleVarDecl[];
@@ -12,6 +13,7 @@ export declare class ContractDecl implements HasSourceRange {
     readonly withdrawMethods: FuncDecl[];
     readonly proposeMethods: FuncDecl[];
     readonly voteMethods: FuncDecl[];
+    readonly stateDecls: StateDecl[];
     readonly range: SourceRange;
-    constructor(name: Identifier, params: SimpleVarDecl[], spendMethods: FuncDecl[], mintMethods: FuncDecl[], certifyMethods: FuncDecl[], withdrawMethods: FuncDecl[], proposeMethods: FuncDecl[], voteMethods: FuncDecl[], range: SourceRange);
+    constructor(name: Identifier, params: SimpleVarDecl[], spendMethods: FuncDecl[], mintMethods: FuncDecl[], certifyMethods: FuncDecl[], withdrawMethods: FuncDecl[], proposeMethods: FuncDecl[], voteMethods: FuncDecl[], stateDecls: StateDecl[], range: SourceRange);
 }

package/dist/ast/nodes/statements/declarations/ContractDecl.js

@@ -7,8 +7,9 @@ export class ContractDecl {
     withdrawMethods;
     proposeMethods;
     voteMethods;
+    stateDecls;
     range;
-    constructor(name, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, range) {
+    constructor(name, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, stateDecls, range) {
         this.name = name;
         this.params = params;
         this.spendMethods = spendMethods;
@@ -17,6 +18,7 @@ export class ContractDecl {
         this.withdrawMethods = withdrawMethods;
         this.proposeMethods = proposeMethods;
         this.voteMethods = voteMethods;
+        this.stateDecls = stateDecls;
         this.range = range;
     }
 }

package/dist/ast/nodes/statements/declarations/StateDecl.d.ts

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { FuncDecl } from "./FuncDecl.js";
+import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
+export declare class StateDecl implements HasSourceRange {
+    readonly name: Identifier;
+    readonly fields: SimpleVarDecl[];
+    readonly spendMethods: FuncDecl[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, fields: SimpleVarDecl[], spendMethods: FuncDecl[], range: SourceRange);
+}

package/dist/ast/nodes/statements/declarations/StateDecl.js

@@ -0,0 +1,12 @@
+export class StateDecl {
+    name;
+    fields;
+    spendMethods;
+    range;
+    constructor(name, fields, spendMethods, range) {
+        this.name = name;
+        this.fields = fields;
+        this.spendMethods = spendMethods;
+        this.range = range;
+    }
+}

package/dist/compiler/AstCompiler/internal/_deriveContractBody/_deriveContractBody.js

@@ -18,6 +18,7 @@ import { LitThisExpr } from "../../../../ast/nodes/expr/litteral/LitThisExpr.js"
 import { LitTrueExpr } from "../../../../ast/nodes/expr/litteral/LitTrueExpr.js";
 import { LitUndefExpr } from "../../../../ast/nodes/expr/litteral/LitUndefExpr.js";
 import { LitVoidExpr } from "../../../../ast/nodes/expr/litteral/LitVoidExpr.js";
+import { IsExpr } from "../../../../ast/nodes/expr/IsExpr.js";
 import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
 import { isPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
 import { TernaryExpr } from "../../../../ast/nodes/expr/TernaryExpr.js";
@@ -28,6 +29,8 @@ import { isExplicitAssignmentStmt, isImplicitAssignmentStmt } from "../../../../
 import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
 import { BreakStmt } from "../../../../ast/nodes/statements/BreakStmt.js";
 import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
+import { ArrowKind } from "../../../../ast/nodes/expr/functions/ArrowKind.js";
+import { AstFuncType, AstVoidType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
 import { StructConstrDecl, StructDecl, StructDeclAstFlags } from "../../../../ast/nodes/statements/declarations/StructDecl.js";
 import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
 import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
@@ -64,7 +67,8 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         && contractDecl.certifyMethods.length === 0
         && contractDecl.withdrawMethods.length === 0
         && contractDecl.proposeMethods.length === 0
-        && contractDecl.voteMethods.length === 0)
+        && contractDecl.voteMethods.length === 0
+        && contractDecl.stateDecls.length === 0)
         return new BlockStmt([
             new FailStmt(undefined, contractRange)
         ], contractRange);
@@ -143,7 +147,8 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
     );
      */
     const purposeMatchCases = [];
-    if (contractDecl.spendMethods.length > 0) {
+    if (contractDecl.spendMethods.length > 0
+        || contractDecl.stateDecls.length > 0) {
         const spendingRefUniqueName = getUniqueInternalName("spendingRef");
         const optionalDatumUniqueName = getUniqueInternalName("optionalDatum");
         const fields = new Map([
@@ -156,15 +161,14 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
                 SimpleVarDecl.onlyNameConst(optionalDatumUniqueName, mockRange)
             ],
         ]);
-        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.spendMethods, paramsInternalNamesMap, 
-        // contextVarsMapping
-        Object.freeze({
+        const baseContextVars = Object.freeze({
             tx: txUniqueName,
             purposeData: purposeUniqueName,
             redeemerData: redeemerUniqueName,
             spendingRef: spendingRefUniqueName,
             optionalDatum: optionalDatumUniqueName,
-        }), "SpendRedeemer", contractRange);
+        });
+        const bodyStmts = _buildSpendCaseBlock(compiler, contractDecl, paramsInternalNamesMap, baseContextVars, contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
         purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Spend", mockRange), fields, undefined, // rest
@@ -675,6 +679,13 @@ function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalN
         expr.expr = newInner;
         return expr;
     }
+    if (expr instanceof IsExpr) {
+        const newInner = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.instanceExpr, paramsInternalNamesMap, renamedVariables);
+        if (!newInner)
+            return undefined;
+        expr.instanceExpr = newInner;
+        return expr;
+    }
     if (isPropAccessExpr(expr)) {
         const newObject = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.object, paramsInternalNamesMap, renamedVariables);
         if (!newObject)
@@ -759,6 +770,143 @@ function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalN
     console.error(expr);
     throw new Error("unreachable::_exprReplaceParamsAndAssertNoLitContext");
 }
+function _deriveContractDatumTypeDef(contractName, stateDecls, contractRange) {
+    let defFlags = StructDeclAstFlags.onlyDataEncoding;
+    if (stateDecls.length <= 1)
+        defFlags |= StructDeclAstFlags.untaggedSingleConstructor;
+    return new StructDecl(new Identifier(contractName, contractRange), [], // typeParams
+    stateDecls.map(s => new StructConstrDecl(new Identifier(s.name.text, s.name.range), s.fields, s.range)), defFlags, contractRange);
+}
+function _buildSpendCaseBlock(compiler, contractDecl, paramsInternalNamesMap, baseContextVars, contractRange) {
+    const mockRange = SourceRange.mock;
+    const hasPlainSpend = contractDecl.spendMethods.length > 0;
+    const hasState = contractDecl.stateDecls.length > 0;
+    // legacy / pure-plain-spend behavior: identical UPLC to before
+    if (!hasState) {
+        return _getMatchedPurposeBlockStatements(compiler, contractDecl.spendMethods, paramsInternalNamesMap, baseContextVars, "SpendRedeemer", contractRange);
+    }
+    // synthetic union datum type
+    const datumTypeDef = _deriveContractDatumTypeDef(contractDecl.name.text, contractDecl.stateDecls, contractRange);
+    compiler.registerInternalTypeDecl(datumTypeDef);
+    const datumTypeName = datumTypeDef.name.text;
+    // build fallback (used when datum is absent or doesn't match any state)
+    // we bind the plain-spend redeemer match as a 0-arg function value, then
+    // call it via `return fallback();` at every fallback site. the 0-arg-func
+    // → delay lowering keeps the body emitted only once.
+    let fallbackBindStmt;
+    let fallbackFuncName;
+    const makeFallbackBody = () => {
+        if (hasPlainSpend) {
+            return [
+                new ReturnStmt(new CallExpr(new Identifier(fallbackFuncName, mockRange), undefined, // genericTypeArgs
+                [], mockRange), mockRange)
+            ];
+        }
+        return [new FailStmt(undefined, contractRange)];
+    };
+    if (hasPlainSpend) {
+        fallbackFuncName = getUniqueInternalName("unknownDatum");
+        // pure-plain-spend behavior: identical UPLC to before
+        const plainBody = _getMatchedPurposeBlockStatements(compiler, contractDecl.spendMethods, paramsInternalNamesMap, baseContextVars, "SpendRedeemer", contractRange);
+        if (!Array.isArray(plainBody))
+            return undefined;
+        fallbackBindStmt = new VarStmt([
+            new SimpleVarDecl(new Identifier(fallbackFuncName, mockRange), new AstFuncType([], // params
+            new AstVoidType(mockRange), mockRange), new FuncExpr(new Identifier(fallbackFuncName, mockRange), CommonFlags.None, [], // typeParams
+            new AstFuncType([], // params
+            new AstVoidType(mockRange), mockRange), new BlockStmt(plainBody, contractRange), ArrowKind.None, mockRange), // initExpr
+            CommonFlags.Const, mockRange)
+        ], mockRange);
+    }
+    const datumUniqueName = getUniqueInternalName("datum");
+    const datumAsUnionName = getUniqueInternalName("datumUnion");
+    // build per-state cases
+    const datumMatchCases = [];
+    for (const stateDecl of contractDecl.stateDecls) {
+        let stateBody;
+        // deconstruct each field of the state's constructor into a fresh
+        // internal placeholder so the existing match-compiler accepts the
+        // pattern (which requires every field to be specified)
+        const fieldExtracts = stateDecl.fields.map(f => ({
+            originalName: f.name.text,
+            extractName: getUniqueInternalName(`${stateDecl.name.text}_${f.name.text}`),
+            range: f.name.range,
+        }));
+        if (stateDecl.spendMethods.length === 0) {
+            // readonly-state: never spendable
+            stateBody = [new FailStmt(undefined, stateDecl.range)];
+        }
+        else {
+            // synthesize a per-state single-constructor struct so that
+            // `state.fieldName` is type-checked against a struct that has
+            // only this state's fields (the multi-ctor union would reject
+            // the access since fields differ across constructors).
+            const perStateStructDecl = new StructDecl(new Identifier(getUniqueInternalName(`${contractDecl.name.text}_${stateDecl.name.text}`), mockRange), [], // typeParams
+            [
+                new StructConstrDecl(new Identifier(stateDecl.name.text, mockRange), stateDecl.fields, stateDecl.range)
+            ], StructDeclAstFlags.onlyDataEncoding | StructDeclAstFlags.untaggedSingleConstructor, stateDecl.range);
+            compiler.registerInternalTypeDecl(perStateStructDecl);
+            const perStateStructName = perStateStructDecl.name.text;
+            // synthesize: const state = StateStruct{ field1: _f1, ... };
+            // - state has type StateStruct (single-ctor) so state.x type-checks
+            // - LitNamedObjExpr at expressify short-circuits property access
+            //   to the bound field value (the extracted variable)
+            const stateUniqueName = getUniqueInternalName(`state_${stateDecl.name.text}`);
+            const stateBindStmt = new VarStmt([
+                new SimpleVarDecl(new Identifier(stateUniqueName, mockRange), new AstNamedTypeExpr(new Identifier(perStateStructName, mockRange), [], // typeArgs
+                mockRange), new LitNamedObjExpr(new Identifier(stateDecl.name.text, mockRange), fieldExtracts.map(fe => new Identifier(fe.originalName, mockRange)), fieldExtracts.map(fe => new Identifier(fe.extractName, mockRange)), mockRange, new Identifier(perStateStructName, mockRange)), // initExpr
+                CommonFlags.Const, mockRange)
+            ], mockRange);
+            const perStateContextVars = Object.freeze({
+                ...baseContextVars,
+                state: stateUniqueName,
+            });
+            const redeemerStmts = _getMatchedPurposeBlockStatements(compiler, stateDecl.spendMethods, paramsInternalNamesMap, perStateContextVars, `${stateDecl.name.text}Redeemer`, stateDecl.range);
+            if (!Array.isArray(redeemerStmts))
+                return undefined;
+            stateBody = [stateBindStmt, ...redeemerStmts];
+        }
+        const fieldsMap = new Map(fieldExtracts.map(fe => [
+            new Identifier(fe.originalName, mockRange),
+            SimpleVarDecl.onlyNameConst(fe.extractName, mockRange)
+        ]));
+        datumMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier(stateDecl.name.text, mockRange), fieldsMap, undefined, // rest
+        undefined, // type
+        undefined, // initExpr
+        CommonFlags.Const, stateDecl.range), new BlockStmt(stateBody, stateDecl.range), stateDecl.range));
+    }
+    // bind: const datumUnion: ContractDatum = datum as ContractDatum;
+    // we match on this bound variable so the existing match-narrowing
+    // mechanism narrows it to the matched constructor inside each arm.
+    const datumAsUnionBindStmt = new VarStmt([
+        new SimpleVarDecl(new Identifier(datumAsUnionName, mockRange), new AstNamedTypeExpr(new Identifier(datumTypeName, mockRange), [], // typeArgs
+        mockRange), new TypeConversionExpr(new Identifier(datumUniqueName, mockRange), new AstNamedTypeExpr(new Identifier(datumTypeName, mockRange), [], // typeArgs
+        mockRange), mockRange), CommonFlags.Const, mockRange)
+    ], mockRange);
+    const datumMatchStmt = new MatchStmt(new Identifier(datumAsUnionName, mockRange), datumMatchCases, new MatchStmtElseCase(new BlockStmt(makeFallbackBody(), contractRange), contractRange), contractRange);
+    // outer match: optionalDatum -> Some{ value: datum } / Nothing
+    const optionalMatch = new MatchStmt(new Identifier(baseContextVars.optionalDatum, mockRange), [
+        new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Some", mockRange), new Map([
+            [
+                new Identifier("value", mockRange),
+                SimpleVarDecl.onlyNameConst(datumUniqueName, mockRange)
+            ]
+        ]), undefined, // rest
+        undefined, // type
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt([datumAsUnionBindStmt, datumMatchStmt], contractRange), contractRange),
+        new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("None", mockRange), new Map(), undefined, // rest
+        undefined, // type
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(makeFallbackBody(), contractRange), contractRange),
+    ], undefined, // elseCase
+    contractRange);
+    const result = [];
+    if (fallbackBindStmt)
+        result.push(fallbackBindStmt);
+    result.push(optionalMatch);
+    return result;
+}
 function _deriveRedeemerTypeDef(redeemerName, methods, contractRange) {
     let defFlags = StructDeclAstFlags.onlyDataEncoding;
     if (methods.length <= 1)

package/dist/compiler/AstCompiler/internal/exprs/_compileCaseExpr.d.ts

@@ -3,4 +3,4 @@ import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExp
 import { TirType } from "../../../tir/types/TirType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 export declare function _compileCaseExpr(ctx: AstCompilationCtx, expr: CaseExpr, typeHint: TirType | undefined): TirCaseExpr | undefined;
-export declare function _compileCaseExprMatcher(ctx: AstCompilationCtx, matcher: CaseExprMatcher, patternType: TirType, returnTypeHint: TirType | undefined): TirCaseMatcher | undefined;
+export declare function _compileCaseExprMatcher(ctx: AstCompilationCtx, matcher: CaseExprMatcher, patternType: TirType, returnTypeHint: TirType | undefined, matchedVarName?: string): TirCaseMatcher | undefined;

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

@@ -1,15 +1,21 @@
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
 import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
-import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { canAssignTo, getStructType } from "../../../tir/types/utils/canAssignTo.js";
 import { _compileVarDecl } from "../statements/_compileVarStmt.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileCaseExpr(ctx, expr, typeHint) {
     const matchExpr = _compileExpr(ctx, expr.matchExpr, typeHint);
     if (!matchExpr)
         return undefined;
-    const cases = expr.cases.map(branch => _compileCaseExprMatcher(ctx, branch, matchExpr.type, typeHint)); // we early return in case of undefined so this is safe
+    // if the matched expression is a plain variable, we can narrow its
+    // type inside each arm body to the matched constructor.
+    const matchedVarName = unwrapToIdentifierName(expr.matchExpr);
+    const cases = expr.cases.map(branch => _compileCaseExprMatcher(ctx, branch, matchExpr.type, typeHint, matchedVarName)); // we early return in case of undefined so this is safe
     if (cases.some(c => !c))
         return undefined;
     const returnType = cases[0]?.body.type ?? typeHint;
@@ -22,7 +28,7 @@ export function _compileCaseExpr(ctx, expr, typeHint) {
         return undefined;
     return new TirCaseExpr(matchExpr, cases, wildcardCase, returnType, expr.range);
 }
-export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHint) {
+export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHint, matchedVarName) {
     const pattern = _compileVarDecl(ctx, matcher.pattern, patternType);
     if (!pattern)
         return undefined;
@@ -30,7 +36,22 @@ export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHin
         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());
-    const body = _compileExpr(ctx, matcher.body, returnTypeHint);
+    let bodyCtx = ctx;
+    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();
+                if (parentStruct instanceof TirDataStructType
+                    || parentStruct instanceof TirSoPStructType) {
+                    bodyCtx.scope.narrowVariable(matchedVarName, parentStruct.narrowTo([parentIdx]));
+                }
+            }
+        }
+    }
+    const body = _compileExpr(bodyCtx, matcher.body, returnTypeHint);
     if (!body)
         return undefined;
     if (returnTypeHint && !canAssignTo(body.type, returnTypeHint))
@@ -45,3 +66,8 @@ function _compileCaseWildcardMatcher(ctx, wildcardCase, returnTypeHint) {
         return undefined;
     return new TirWildcardCaseMatcher(bodyExpr, wildcardCase.range);
 }
+function unwrapToIdentifierName(expr) {
+    while (expr instanceof ParentesizedExpr)
+        expr = expr.expr;
+    return expr instanceof Identifier ? expr.text : undefined;
+}

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

@@ -4,6 +4,7 @@ import { CaseExpr } from "../../../../ast/nodes/expr/CaseExpr.js";
 import { ElemAccessExpr } from "../../../../ast/nodes/expr/ElemAccessExpr.js";
 import { CallExpr } from "../../../../ast/nodes/expr/functions/CallExpr.js";
 import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
+import { IsExpr } from "../../../../ast/nodes/expr/IsExpr.js";
 import { isLitteralExpr } from "../../../../ast/nodes/expr/litteral/LitteralExpr.js";
 import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
 import { isPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
@@ -17,6 +18,7 @@ import { _compileCallExpr } from "./_compileCallExpr.js";
 import { _compileCaseExpr } from "./_compileCaseExpr.js";
 import { _compileElemAccessExpr } from "./_compileElemAccessExpr.js";
 import { _compileFuncExpr } from "./_compileFuncExpr.js";
+import { _compileIsExpr } from "./_compileIsExpr.js";
 import { _compileLitteralExpr } from "./_compileLitteralExpr.js";
 import { _compileNonNullExpr } from "./_compileNonNullExpr.js";
 import { _compilePropAccessExpr } from "./_compilePropAccessExpr.js";
@@ -63,7 +65,8 @@ typeHint) {
         return _compileTypeConversionExpr(ctx, expr, typeHint);
     if (expr instanceof NonNullExpr)
         return _compileNonNullExpr(ctx, expr, typeHint);
-    // if( expr instanceof IsExpr ) return _compileIsExpr( ctx, expr, typeHint );
+    if (expr instanceof IsExpr)
+        return _compileIsExpr(ctx, expr, typeHint);
     if (expr instanceof ElemAccessExpr)
         return _compileElemAccessExpr(ctx, expr, typeHint);
     if (expr instanceof TernaryExpr)

package/dist/compiler/AstCompiler/internal/exprs/_compileIsExpr.d.ts

@@ -1 +1,5 @@
-export {};
+import { IsExpr } from "../../../../ast/nodes/expr/IsExpr.js";
+import { TirIsExpr } from "../../../tir/expressions/TirIsExpr.js";
+import { TirType } from "../../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+export declare function _compileIsExpr(ctx: AstCompilationCtx, expr: IsExpr, _typeHint: TirType | undefined): TirIsExpr | undefined;

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

@@ -1,43 +1,22 @@
-export {};
-/*
-export function _compileIsExpr(
-    ctx: AstCompilationCtx,
-    expr: IsExpr,
-    _typeHint: TirType | undefined
-): TirIsExpr | undefined
-{
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirIsExpr } from "../../../tir/expressions/TirIsExpr.js";
+import { getStructType } from "../../../tir/types/utils/canAssignTo.js";
+import { _compileExpr } from "./_compileExpr.js";
+export function _compileIsExpr(ctx, expr, _typeHint) {
     const bool_t = ctx.program.stdTypes.bool;
-    
-    const target = _compileExpr( ctx, expr.instanceExpr, undefined );
-    if( !target ) return undefined;
-
-    const structType = getStructType( target.type );
-    if( !structType ) return ctx.error(
-        DiagnosticCode.Cannot_use_is_operator_on_a_value_that_is_not_a_struct_type,
-        expr.instanceExpr.range
-    );
-
-    const targetCtorId = expr.ofType;
-    const targetCtorName = targetCtorId.text;
-
-    const structCtors = structType.constructors;
-    const targetCtor = structCtors.find( ctor => ctor.name === targetCtorName );
-    if( !targetCtor ) return ctx.error(
-        DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1,
-        expr.ofType.range, targetCtorName, structType.toString()
-    );
-
-    if( structCtors.length === 1 )
-    ctx.warning(
-        DiagnosticCode.This_check_is_redundant_Struct_0_has_only_one_possible_constructor,
-        expr.range, structType.toString()
-    );
-
-    return new TirIsExpr(
-        target,
-        expr.ofType,
-        bool_t,
-        expr.range
-    );
+    const target = _compileExpr(ctx, expr.instanceExpr, undefined);
+    if (!target)
+        return undefined;
+    const structType = getStructType(target.type);
+    if (!structType)
+        return ctx.error(DiagnosticCode.Cannot_use_is_operator_on_a_value_that_is_not_a_struct_type, expr.instanceExpr.range);
+    const targetCtorName = expr.ofConstr.text;
+    const localIdx = structType.constructors.findIndex(ctor => ctor.name === targetCtorName);
+    if (localIdx < 0)
+        return ctx.error(DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1, expr.ofConstr.range, targetCtorName, structType.toString());
+    if (structType.constructors.length === 1) {
+        ctx.warning(DiagnosticCode.This_check_is_redundant_Struct_0_has_only_one_possible_constructor, expr.range, structType.toString());
+    }
+    const parentCtorIdx = structType.parentCtorIdx(localIdx);
+    return new TirIsExpr(target, targetCtorName, parentCtorIdx, expr.range, bool_t);
 }
-    //*/ 

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

@@ -1,6 +1,7 @@
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirTernaryExpr } from "../../../tir/expressions/TirTernaryExpr.js";
 import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { applyNarrowingsToScope, extractIsNarrowings } from "../../utils/extractIsNarrowings.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileTernaryExpr(ctx, expr, typeHint) {
     const bool_t = ctx.program.stdTypes.bool;
@@ -9,11 +10,15 @@ export function _compileTernaryExpr(ctx, expr, typeHint) {
         return undefined;
     if (!canAssignTo(cond.type, bool_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.condition.range, cond.type.toString(), bool_t.toString());
-    const thenExpr = _compileExpr(ctx, expr.ifTrue, typeHint);
+    const thenCtx = ctx.newBranchChildScope();
+    applyNarrowingsToScope(thenCtx.scope, extractIsNarrowings(cond, true));
+    const thenExpr = _compileExpr(thenCtx, expr.ifTrue, typeHint);
     if (!thenExpr)
         return undefined;
     const returnType = thenExpr.type;
-    const elseExpr = _compileExpr(ctx, expr.ifFalse, returnType);
+    const elseCtx = ctx.newBranchChildScope();
+    applyNarrowingsToScope(elseCtx.scope, extractIsNarrowings(cond, false));
+    const elseExpr = _compileExpr(elseCtx, expr.ifFalse, returnType);
     if (!elseExpr)
         return undefined;
     if (!canAssignTo(elseExpr.type, returnType))

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

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.gener
 import { TirTypeConversionExpr } from "../../../tir/expressions/TirTypeConversionExpr.js";
 import { TirAssertStmt } from "../../../tir/statements/TirAssertStmt.js";
 import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
+import { applyNarrowingsToScope, extractIsNarrowings } from "../../utils/extractIsNarrowings.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
 export function _compileAssertStmt(ctx, stmt) {
     const bool_t = ctx.program.stdTypes.bool;
@@ -26,5 +27,8 @@ export function _compileAssertStmt(ctx, stmt) {
         if (!canAssignTo(failMsgExpr.type, string_t))
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.elseExpr.range, failMsgExpr.type.toString(), string_t.toString());
     }
+    // After a successful `assert`, propagate any `is`-derived narrowings
+    // into the current scope so subsequent statements see narrowed types.
+    applyNarrowingsToScope(ctx.scope, extractIsNarrowings(tirCond, true));
     return [new TirAssertStmt(tirCond, failMsgExpr, stmt.range)];
 }

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

@@ -3,6 +3,7 @@ import { TirIfStmt } from "../../../tir/statements/TirIfStmt.js";
 import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
 import { bool_t } from "../../../tir/program/stdScope/stdScope.js";
 import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
+import { applyNarrowingsToScope, extractIsNarrowings } from "../../utils/extractIsNarrowings.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
 import { _compileStatement } from "./_compileStatement.js";
 export function _compileIfStmt(ctx, stmt) {
@@ -12,12 +13,16 @@ export function _compileIfStmt(ctx, stmt) {
     if (!canAssignTo(coditionExpr.type, bool_t)
         && !canAssignToOptional(coditionExpr.type))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, stmt.condition.range, coditionExpr.type.toString(), "boolean | Optional<T>");
-    const thenBranch = wrapManyStatements(_compileStatement(ctx.newBranchChildScope(), stmt.thenBranch), stmt.thenBranch.range);
+    const thenCtx = ctx.newBranchChildScope();
+    applyNarrowingsToScope(thenCtx.scope, extractIsNarrowings(coditionExpr, true));
+    const thenBranch = wrapManyStatements(_compileStatement(thenCtx, stmt.thenBranch), stmt.thenBranch.range);
     if (!thenBranch)
         return undefined;
     let elseBranch = undefined;
     if (stmt.elseBranch) {
-        elseBranch = wrapManyStatements(_compileStatement(ctx.newBranchChildScope(), stmt.elseBranch), stmt.elseBranch.range);
+        const elseCtx = ctx.newBranchChildScope();
+        applyNarrowingsToScope(elseCtx.scope, extractIsNarrowings(coditionExpr, false));
+        elseBranch = wrapManyStatements(_compileStatement(elseCtx, stmt.elseBranch), stmt.elseBranch.range);
         if (!elseBranch)
             return undefined;
     }

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.d.ts

@@ -3,4 +3,4 @@ import { TirMatchStmt, TirMatchStmtCase } from "../../../tir/statements/TirMatch
 import { DeconstructableTirType } from "../../../tir/types/utils/getDeconstructableType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 export declare function _compileMatchStmt(ctx: AstCompilationCtx, stmt: MatchStmt): [TirMatchStmt] | undefined;
-export declare function _compileTirMatchStmtCase(ctx: AstCompilationCtx, matchCase: MatchStmtCase, deconstructableType: DeconstructableTirType, constrNamesAlreadySpecified: string[]): TirMatchStmtCase | undefined;
+export declare function _compileTirMatchStmtCase(ctx: AstCompilationCtx, matchCase: MatchStmtCase, deconstructableType: DeconstructableTirType, constrNamesAlreadySpecified: string[], matchedVarName?: string): TirMatchStmtCase | undefined;