@harmoniclabs/pebble 0.2.0 → 0.3.1

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

@@ -0,0 +1,169 @@
+/**
+ * Case-over-Const lowering pass.
+ *
+ * The UPLC `Case` term accepts a constant scrutinee and reinterprets it
+ * as a tag-untagged constructor (bool → 0/1, int N → N, unit → 0,
+ * pair → constr 0 [fst, snd], list → constr 1 [] for `[]` or
+ * constr 0 [head, tail] for cons).
+ *
+ * This pass replaces canonical `strictIfThenElse(cond, then, else)`
+ * sequences with the equivalent `IRCase(cond, [else, then])` form. The
+ * machine resolves bool=false → constr 0, bool=true → constr 1.
+ * This subsumes the strict boolean helpers (`_not`, `_strictAnd`,
+ * `_strictOr`) whose hoisted bodies are themselves `strictIfThenElse`
+ * triple-apps — they get lowered inside their hoisted definitions.
+ *
+ * It also replaces the LAZY pattern emitted by `_ir_lazyIfThenElse`:
+ *
+ *     IRForced( strictIfThenElse cond (delay t) (delay e) )
+ *
+ * — which is how `&&`, `||` and pebble `if/else` are encoded today —
+ * with `IRCase(cond, [e, t])`. Branches under `Case` are naturally
+ * lazy, so the surrounding `force`/`delay` indirection is dropped.
+ *
+ * It also prunes trailing IRError continuations: a missing branch is
+ * semantically equivalent to an evaluation-failure branch, so dropping a
+ * trailing `IRError` reduces script size while preserving meaning.
+ *
+ * NOTE: `getApplicationTerms` sees through both raw `IRApp` chains AND
+ * the case-constr-app encoding produced earlier in `performUplc…`
+ * (i.e. `IRCase(IRConstr(0, [args]), [func])`). We therefore check the
+ * app-pattern *before* the IRCase trailing-error pruning so that a case
+ * that's really a function call gets unwrapped first.
+ */
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { IRDelayed } from "../../IRNodes/IRDelayed.js";
+import { IRError } from "../../IRNodes/IRError.js";
+import { IRForced } from "../../IRNodes/IRForced.js";
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRNative } from "../../IRNodes/IRNative/index.js";
+import { IRNativeTag } from "../../IRNodes/IRNative/IRNativeTag.js";
+import { IRFunc } from "../../IRNodes/IRFunc.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../utils/getApplicationTerms.js";
+/**
+ * `_makeAllNegativeNativesHoisted` wraps every `IRNative` reference in
+ * an `IRHoisted` (despite the name, it touches positive tags too), and
+ * subsequent sharing passes may further wrap in `IRLetted`. Unwrap so
+ * the pattern detector can see the underlying native tag.
+ */
+function unwrapToNative(t) {
+    while (t instanceof IRHoisted)
+        t = t.hoisted;
+    while (t instanceof IRLetted)
+        t = t.value;
+    return t;
+}
+export function rewriteToCaseOverConstAndReturnRoot(term) {
+    const stack = [term];
+    function modifyTermAndPushToReprocess(current, newTerm) {
+        const parent = current.parent;
+        if (parent) {
+            _modifyChildFromTo(parent, current, newTerm);
+        }
+        else {
+            term = newTerm;
+            term.parent = undefined;
+        }
+        stack.unshift(newTerm);
+    }
+    while (stack.length > 0) {
+        const current = stack.pop();
+        // LAZY pattern emitted by `_ir_lazyIfThenElse`:
+        //   force( strictIfThenElse cond (delay t) (delay e) )
+        // Rewrite to a bare `case cond [e, t]` (Case branches are lazy).
+        if (current instanceof IRForced) {
+            const innerApp = getApplicationTerms(current.forced);
+            const innerFunc = innerApp ? unwrapToNative(innerApp.func) : undefined;
+            if (innerApp
+                && innerFunc instanceof IRNative
+                && innerFunc.tag === IRNativeTag.strictIfThenElse
+                && innerApp.args.length === 3
+                && innerApp.args[1] instanceof IRDelayed
+                && innerApp.args[2] instanceof IRDelayed) {
+                const cond = innerApp.args[0];
+                const tBranch = innerApp.args[1].delayed;
+                const eBranch = innerApp.args[2].delayed;
+                const newTerm = new IRCase(cond, [eBranch, tBranch]);
+                modifyTermAndPushToReprocess(current, newTerm);
+                continue;
+            }
+            // `IRForced(IRCase(s, [b0, b1, …]))` where every branch is
+            // either `IRDelayed(v)` or `IRFunc(params, IRDelayed(v))` can
+            // be simplified by stripping the force/delay pair: case
+            // branches are naturally lazy in UPLC `case`. The
+            // wrap typically comes from `_ir_lazyIfThenElse` lowering an
+            // `if/else` whose condition then got rewritten to a list-case
+            // (e.g. `if(nullList(L)) ...`) — the outer force is left
+            // dangling around the resulting IRCase.
+            if (current.forced instanceof IRCase) {
+                const caseTerm = current.forced;
+                const conts = caseTerm.continuations;
+                const stripped = [];
+                let allOk = true;
+                for (let i = 0; i < conts.length; i++) {
+                    const c = conts[i];
+                    if (c instanceof IRDelayed) {
+                        stripped.push(c.delayed);
+                    }
+                    else if (c instanceof IRFunc
+                        && c.body instanceof IRDelayed) {
+                        stripped.push(new IRFunc(c.params.slice(), c.body.delayed));
+                    }
+                    else {
+                        allOk = false;
+                        break;
+                    }
+                }
+                if (allOk) {
+                    const newCase = new IRCase(caseTerm.constrTerm.clone(), stripped);
+                    modifyTermAndPushToReprocess(current, newCase);
+                    continue;
+                }
+            }
+            stack.unshift(...current.children());
+            continue;
+        }
+        // Application-pattern rewrites (raw IRApp chain OR case-constr-app
+        // encoding produced by `performUplcOptimizationsAndReturnRoot`).
+        const appTerms = getApplicationTerms(current);
+        if (appTerms) {
+            const { func, args } = appTerms;
+            const unwrappedFunc = unwrapToNative(func);
+            // strictIfThenElse cond then else  →  case cond [else, then]
+            if (unwrappedFunc instanceof IRNative
+                && unwrappedFunc.tag === IRNativeTag.strictIfThenElse
+                && args.length === 3) {
+                const [cond, thenBranch, elseBranch] = args;
+                const newTerm = new IRCase(cond, [elseBranch, thenBranch]);
+                modifyTermAndPushToReprocess(current, newTerm);
+                continue;
+            }
+            // No app-pattern match — but if the node is itself an IRCase
+            // (a case-constr-app encoding), we still want trailing-error
+            // pruning on the original case, so don't `continue` yet.
+            if (!(current instanceof IRCase)) {
+                stack.unshift(...current.children());
+                continue;
+            }
+        }
+        // Trailing-error pruning on any IRCase node we encounter.
+        if (current instanceof IRCase) {
+            const conts = current.continuations;
+            let lastNonError = conts.length;
+            while (lastNonError > 0 && conts[lastNonError - 1] instanceof IRError) {
+                lastNonError--;
+            }
+            if (lastNonError < conts.length && lastNonError > 0) {
+                const pruned = new IRCase(current.constrTerm.clone(), Array.from({ length: lastNonError }, (_, i) => conts[i].clone()));
+                modifyTermAndPushToReprocess(current, pruned);
+                continue;
+            }
+            stack.unshift(...current.children());
+            continue;
+        }
+        stack.unshift(...current.children());
+    }
+    return term;
+}

package/dist/IR/tree_utils/_ir_caseList.d.ts

@@ -0,0 +1,15 @@
+import { IRCase } from "../IRNodes/IRCase.js";
+import type { IRTerm } from "../IRTerm.js";
+/**
+ * case list of
+ *   h::t -> caseCons   (h, t are bound only if `consParams` is provided)
+ *   []   -> caseNil
+ *
+ * Lowers to UPLC `Case`. Branches are naturally lazy, so callers
+ * should pass plain (un-delayed) expressions — no `force` is needed around
+ * the result.
+ */
+export declare function _ir_caseList(listTerm: IRTerm, caseNil: IRTerm, caseCons: IRTerm, consParams?: {
+    head: symbol;
+    tail: symbol;
+}): IRCase;

package/dist/IR/tree_utils/_ir_caseList.js

@@ -0,0 +1,19 @@
+import { IRCase } from "../IRNodes/IRCase.js";
+import { IRFunc } from "../IRNodes/IRFunc.js";
+/**
+ * case list of
+ *   h::t -> caseCons   (h, t are bound only if `consParams` is provided)
+ *   []   -> caseNil
+ *
+ * Lowers to UPLC `Case`. Branches are naturally lazy, so callers
+ * should pass plain (un-delayed) expressions — no `force` is needed around
+ * the result.
+ */
+export function _ir_caseList(listTerm, caseNil, caseCons, consParams) {
+    const h = consParams?.head ?? Symbol("_caseList_h");
+    const t = consParams?.tail ?? Symbol("_caseList_t");
+    return new IRCase(listTerm, [
+        new IRFunc([h, t], caseCons),
+        caseNil
+    ]);
+}

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

@@ -4,9 +4,23 @@ import { HasSourceRange } from "../../HasSourceRange.js";
 import { SimpleVarDecl } from "./VarDecl/SimpleVarDecl.js";
 export declare enum StructDeclAstFlags {
     none = 0,
-    untaggedSingleConstructor = 1,
+    /**
+     * Hint that the user used the shortcut single-constructor syntax
+     * (`struct Foo { x: int }` rather than `struct Foo { Foo { x: int } }`).
+     * Whether the resulting Data encoding is tagged (`constrData(0, ...)`)
+     * or untagged (`listData(...)`) is decided by the compiler's
+     * `encodingStrategy` option — `"default"` keeps the tagged form for
+     * backwards compatibility; `"minimal"` opts shortcut forms in to the
+     * untagged form.
+     */
+    shortcutSingleConstructor = 1,
     onlyDataEncoding = 2,
-    onlySopEncoding = 4
+    onlySopEncoding = 4,
+    /**
+     * Explicit `untagged` modifier. Forces the untagged listData encoding
+     * regardless of `encodingStrategy`. Requires a single constructor.
+     */
+    untagged = 8
 }
 export declare class StructDecl implements HasSourceRange {
     readonly name: Identifier;

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

@@ -1,9 +1,23 @@
 export var StructDeclAstFlags;
 (function (StructDeclAstFlags) {
     StructDeclAstFlags[StructDeclAstFlags["none"] = 0] = "none";
-    StructDeclAstFlags[StructDeclAstFlags["untaggedSingleConstructor"] = 1] = "untaggedSingleConstructor";
+    /**
+     * Hint that the user used the shortcut single-constructor syntax
+     * (`struct Foo { x: int }` rather than `struct Foo { Foo { x: int } }`).
+     * Whether the resulting Data encoding is tagged (`constrData(0, ...)`)
+     * or untagged (`listData(...)`) is decided by the compiler's
+     * `encodingStrategy` option — `"default"` keeps the tagged form for
+     * backwards compatibility; `"minimal"` opts shortcut forms in to the
+     * untagged form.
+     */
+    StructDeclAstFlags[StructDeclAstFlags["shortcutSingleConstructor"] = 1] = "shortcutSingleConstructor";
     StructDeclAstFlags[StructDeclAstFlags["onlyDataEncoding"] = 2] = "onlyDataEncoding";
     StructDeclAstFlags[StructDeclAstFlags["onlySopEncoding"] = 4] = "onlySopEncoding";
+    /**
+     * Explicit `untagged` modifier. Forces the untagged listData encoding
+     * regardless of `encodingStrategy`. Requires a single constructor.
+     */
+    StructDeclAstFlags[StructDeclAstFlags["untagged"] = 8] = "untagged";
 })(StructDeclAstFlags || (StructDeclAstFlags = {}));
 export class StructDecl {
     name;

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

@@ -117,6 +117,7 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _collectTypeDeclarations;
     private _compileStructDecl;
     private _compileTypeAliasDecl;
+    private _compileEnumDecl;
     private _consumeImportsAddSymsInScope;
     private _readFile;
     /** MUST NOT be used as a "seen" log */

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -1,5 +1,6 @@
 import { StructDecl, StructDeclAstFlags } from "../../ast/nodes/statements/declarations/StructDecl.js";
 import { TypeAliasDecl } from "../../ast/nodes/statements/declarations/TypeAliasDecl.js";
+import { EnumDecl } from "../../ast/nodes/statements/declarations/EnumDecl.js";
 import { ExportStarStmt } from "../../ast/nodes/statements/ExportStarStmt.js";
 import { ImportStarStmt } from "../../ast/nodes/statements/ImportStarStmt.js";
 import { ImportStmt } from "../../ast/nodes/statements/ImportStmt.js";
@@ -12,6 +13,7 @@ import { createMemoryCompilerIoApi } from "../io/CompilerIoApi.js";
 import { TypedProgram } from "../tir/program/TypedProgram.js";
 import { TirAliasType } from "../tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType, TirStructConstr, TirStructField } from "../tir/types/TirStructType.js";
+import { TirEnumType } from "../tir/types/TirEnumType.js";
 import { ExportStmt } from "../../ast/nodes/statements/ExportStmt.js";
 import { ResolveStackNode } from "./utils/deps/ResolveStackNode.js";
 import { AstCompilationCtx } from "./AstCompilationCtx.js";
@@ -675,12 +677,15 @@ export class AstCompiler extends DiagnosticEmitter {
                 stmt = stmt.stmt;
             }
             if (!(stmt instanceof StructDecl
-                || stmt instanceof TypeAliasDecl))
+                || stmt instanceof TypeAliasDecl
+                || stmt instanceof EnumDecl))
                 continue;
-            const isGeneric = stmt.typeParams.length > 0;
+            const isGeneric = stmt instanceof EnumDecl ? false : stmt.typeParams.length > 0;
             const tirTypes = stmt instanceof StructDecl
                 ? this._compileStructDecl(stmt, srcUid, topLevelScope)
-                : this._compileTypeAliasDecl(stmt, srcUid, topLevelScope);
+                : stmt instanceof EnumDecl
+                    ? this._compileEnumDecl(stmt, srcUid, topLevelScope)
+                    : this._compileTypeAliasDecl(stmt, srcUid, topLevelScope);
             if (!tirTypes // undefined
                 || !(tirTypes.sop || tirTypes.data) // or both undefined
             )
@@ -743,6 +748,16 @@ export class AstCompiler extends DiagnosticEmitter {
         // data encoded type
         if (!stmt.hasFlag(StructDeclAstFlags.onlySopEncoding)) {
             let canEncodeToData = true;
+            // Untagged Data encoding (`listData(...)`) instead of
+            // `constrData(0, ...)`. Requires exactly one constructor and is
+            // enabled by either the explicit `untagged` keyword or the
+            // shortcut-form syntax when `encodingStrategy === "minimal"`.
+            const isUntagged = stmt.constrs.length === 1 && (stmt.hasFlag(StructDeclAstFlags.untagged)
+                || (stmt.hasFlag(StructDeclAstFlags.shortcutSingleConstructor)
+                    && this.cfg.encodingStrategy === "minimal"));
+            if (stmt.hasFlag(StructDeclAstFlags.untagged) && stmt.constrs.length !== 1) {
+                this.error(DiagnosticCode.Not_implemented_0, stmt.name.range, "`untagged` struct must have exactly one constructor");
+            }
             const dataType = new TirDataStructType(stmt.name.text, srcUid, stmt.constrs.map(ctor => new TirStructConstr(ctor.name.text, ctor.fields.map(field => {
                 if (!field.type)
                     return compiler.error(DiagnosticCode.Type_expected, field.name.range.atEnd());
@@ -756,7 +771,7 @@ export class AstCompiler extends DiagnosticEmitter {
                 }
                 return new TirStructField(field.name.text, fieldType);
             })
-                .filter(f => f instanceof TirStructField))), methodsNames);
+                .filter(f => f instanceof TirStructField))), methodsNames, isUntagged);
             if (canEncodeToData)
                 data = dataType;
             else if (stmt.hasFlag(StructDeclAstFlags.onlyDataEncoding))
@@ -779,6 +794,28 @@ export class AstCompiler extends DiagnosticEmitter {
         ) : undefined;
         return sop || data ? { sop, data, methodsNames } : undefined;
     }
+    _compileEnumDecl(stmt, srcUid, _topLevelScope) {
+        if (stmt.members.length === 0) {
+            this.error(DiagnosticCode.Enum_must_have_at_least_one_member, stmt.name.range);
+            return undefined;
+        }
+        const seen = new Set();
+        const memberNames = [];
+        for (const m of stmt.members) {
+            if (m.value !== undefined) {
+                this.error(DiagnosticCode.Enum_members_cannot_have_explicit_values, m.range);
+            }
+            if (seen.has(m.name.text)) {
+                this.error(DiagnosticCode.Duplicate_enum_member_0, m.name.range, m.name.text);
+                continue;
+            }
+            seen.add(m.name.text);
+            memberNames.push(m.name.text);
+        }
+        const methodsNames = new Map();
+        const enumType = new TirEnumType(stmt.name.text, srcUid, memberNames, methodsNames);
+        return { sop: enumType, data: enumType, methodsNames };
+    }
     _consumeImportsAddSymsInScope(stmts, srcAbsPath, srcImportsScope) {
         for (let i = 0; i < stmts.length; i++) {
             const stmt = stmts[i];

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

@@ -784,7 +784,7 @@ function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalN
 function _deriveContractDatumTypeDef(contractName, stateDecls, contractRange) {
     let defFlags = StructDeclAstFlags.onlyDataEncoding;
     if (stateDecls.length <= 1)
-        defFlags |= StructDeclAstFlags.untaggedSingleConstructor;
+        defFlags |= StructDeclAstFlags.shortcutSingleConstructor;
     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);
 }
@@ -855,7 +855,7 @@ function _buildSpendCaseBlock(compiler, contractDecl, paramsInternalNamesMap, ba
             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);
+            ], StructDeclAstFlags.onlyDataEncoding | StructDeclAstFlags.shortcutSingleConstructor, stateDecl.range);
             compiler.registerInternalTypeDecl(perStateStructDecl);
             const perStateStructName = perStateStructDecl.name.text;
             // synthesize: const state = StateStruct{ field1: _f1, ... };
@@ -921,7 +921,7 @@ function _buildSpendCaseBlock(compiler, contractDecl, paramsInternalNamesMap, ba
 function _deriveRedeemerTypeDef(redeemerName, methods, contractRange) {
     let defFlags = StructDeclAstFlags.onlyDataEncoding;
     if (methods.length <= 1)
-        defFlags |= StructDeclAstFlags.untaggedSingleConstructor;
+        defFlags |= StructDeclAstFlags.shortcutSingleConstructor;
     const uniqueName = getUniqueInternalName(redeemerName);
     return new StructDecl(new Identifier(uniqueName, SourceRange.mock), [], // typeParams
     methods.map(m => {

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

@@ -1,3 +1,4 @@
+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";
@@ -48,15 +49,62 @@ export function _compileCallExpr(ctx, expr, typeHint) {
             }
             // 2) Compile arguments. We need them anyway, and they're used for
             //    inference when no explicit args were given.
-            const tirArgs = expr.args.map((arg, i) => {
-                const expected = explicitArgs
-                    ? substituteTypeParams(funcType.argTypes[i], new Map(template.typeParams.map((tp, idx) => [tp.symbol, explicitArgs[idx]])))
-                    : undefined;
-                return _compileExpr(ctx, arg, expected);
-            });
-            for (const a of tirArgs)
-                if (!a)
-                    return undefined;
+            //
+            // For inferred-type-args calls, lambda arguments cannot be compiled
+            // without an expected function type (their param types would be
+            // unannotated). So we compile non-lambda args first, build an
+            // inference environment from them, then compile lambda args with
+            // the substituted expected type from `funcType.argTypes[i]`.
+            const tirArgs = new Array(expr.args.length);
+            const usable = Math.min(expr.args.length, funcType.argTypes.length);
+            if (explicitArgs) {
+                const explicitSubst = new Map(template.typeParams.map((tp, idx) => [tp.symbol, explicitArgs[idx]]));
+                for (let i = 0; i < expr.args.length; i++) {
+                    const expected = i < funcType.argTypes.length
+                        ? substituteTypeParams(funcType.argTypes[i], explicitSubst)
+                        : undefined;
+                    const compiled = _compileExpr(ctx, expr.args[i], expected);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                }
+            }
+            else {
+                const env = new Map();
+                // Pass 1: compile non-FuncExpr args (no type hint needed) and
+                // populate `env` from each arg's resolved type.
+                for (let i = 0; i < expr.args.length; i++) {
+                    if (expr.args[i] instanceof FuncExpr)
+                        continue;
+                    const compiled = _compileExpr(ctx, expr.args[i], undefined);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                    if (i < usable) {
+                        if (!inferTypeArgs(funcType.argTypes[i], compiled.type, env))
+                            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, compiled.type.toString(), funcType.argTypes[i].toString());
+                    }
+                }
+                // Pass 2: compile FuncExpr args with the substituted expected
+                // type so lambda param types can be inferred from context.
+                for (let i = 0; i < expr.args.length; i++) {
+                    if (!(expr.args[i] instanceof FuncExpr))
+                        continue;
+                    const expected = i < funcType.argTypes.length
+                        ? substituteTypeParams(funcType.argTypes[i], env)
+                        : undefined;
+                    const compiled = _compileExpr(ctx, expr.args[i], expected);
+                    if (!compiled)
+                        return undefined;
+                    tirArgs[i] = compiled;
+                    if (i < usable) {
+                        // re-run to capture type params bound only via the
+                        // lambda's return type (e.g. `map<T, A>(f: (T) -> A, ...)`)
+                        if (!inferTypeArgs(funcType.argTypes[i], compiled.type, env))
+                            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, compiled.type.toString(), funcType.argTypes[i].toString());
+                    }
+                }
+            }
             // 3) Determine final type arguments
             let resolvedArgs;
             if (explicitArgs) {
@@ -64,7 +112,6 @@ export function _compileCallExpr(ctx, expr, typeHint) {
             }
             else {
                 const env = new Map();
-                const usable = Math.min(tirArgs.length, funcType.argTypes.length);
                 for (let i = 0; i < usable; i++) {
                     if (!inferTypeArgs(funcType.argTypes[i], tirArgs[i].type, env)) {
                         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, tirArgs[i].type.toString(), funcType.argTypes[i].toString());

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

@@ -1,10 +1,13 @@
 import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
 import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
+import { NamedDeconstructVarDecl as AstNamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
+import { SimpleVarDecl as AstSimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.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 { TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { getEnumType } from "../../../tir/types/TirEnumType.js";
 import { canAssignTo, getStructType } from "../../../tir/types/utils/canAssignTo.js";
 import { _compileVarDecl } from "../statements/_compileVarStmt.js";
 import { _compileExpr } from "./_compileExpr.js";
@@ -29,6 +32,34 @@ export function _compileCaseExpr(ctx, expr, typeHint) {
     return new TirCaseExpr(matchExpr, cases, wildcardCase, returnType, expr.range);
 }
 export function _compileCaseExprMatcher(ctx, matcher, patternType, returnTypeHint, matchedVarName) {
+    const enumType = getEnumType(patternType);
+    if (enumType) {
+        const astPattern = matcher.pattern;
+        let memberName;
+        let patternRange = astPattern.range;
+        let ctorNameRange = astPattern.range;
+        if (astPattern instanceof AstSimpleVarDecl) {
+            memberName = astPattern.name.text;
+            patternRange = astPattern.name.range;
+            ctorNameRange = astPattern.name.range;
+        }
+        else if (astPattern instanceof AstNamedDeconstructVarDecl) {
+            if (astPattern.fields.size > 0 || astPattern.rest)
+                return ctx.error(DiagnosticCode.Enum_member_pattern_cannot_have_fields, astPattern.range);
+            memberName = astPattern.name.text;
+            ctorNameRange = astPattern.name.range;
+        }
+        else
+            return ctx.error(DiagnosticCode._case_expression_must_decontructed_the_inspected_value, astPattern.range);
+        if (enumType.indexOf(memberName) < 0)
+            return ctx.error(DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1, ctorNameRange, memberName, enumType.toString());
+        const body = _compileExpr(ctx, matcher.body, returnTypeHint);
+        if (!body)
+            return undefined;
+        if (returnTypeHint && !canAssignTo(body.type, returnTypeHint))
+            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);
     if (!pattern)
         return undefined;

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

@@ -1,5 +1,6 @@
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirIsExpr } from "../../../tir/expressions/TirIsExpr.js";
+import { getEnumType } from "../../../tir/types/TirEnumType.js";
 import { getStructType } from "../../../tir/types/utils/canAssignTo.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileIsExpr(ctx, expr, _typeHint) {
@@ -7,6 +8,17 @@ export function _compileIsExpr(ctx, expr, _typeHint) {
     const target = _compileExpr(ctx, expr.instanceExpr, undefined);
     if (!target)
         return undefined;
+    const enumType = getEnumType(target.type);
+    if (enumType) {
+        const memberName = expr.ofConstr.text;
+        const memberIdx = enumType.indexOf(memberName);
+        if (memberIdx < 0)
+            return ctx.error(DiagnosticCode.Constructor_0_is_not_part_of_the_definition_of_1, expr.ofConstr.range, memberName, enumType.toString());
+        if (enumType.members.length === 1) {
+            ctx.warning(DiagnosticCode.This_check_is_redundant_Struct_0_has_only_one_possible_constructor, expr.range, enumType.toString());
+        }
+        return new TirIsExpr(target, memberName, memberIdx, expr.range, bool_t);
+    }
     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);

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

@@ -15,8 +15,10 @@ import { tryResolveNamespaceChain } from "../../utils/resolveNamespaceChain.js";
 import { _compileExpr } from "./_compileExpr.js";
 import { _compileNonNullExpr } from "./_compileNonNullExpr.js";
 import { TirLitNamedObjExpr } from "../../../tir/expressions/litteral/TirLitNamedObjExpr.js";
+import { TirLitEnumMemberExpr } from "../../../tir/expressions/litteral/TirLitEnumMemberExpr.js";
 import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
 import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
+import { TirEnumType } from "../../../tir/types/TirEnumType.js";
 export function _compilePropAccessExpr(ctx, expr, typeHint) {
     if (expr instanceof OptionalPropAccessExpr)
         return _compileOptionalPropAccessExpr(ctx, expr, typeHint);
@@ -95,6 +97,12 @@ export function _compileNonNullPropAccessExpr(ctx, expr, _typeHint) {
     return _compileDotPropAccessExpr(ctx, new DotPropAccessExpr(nonNullObjExpr, expr.prop, expr.range), _typeHint);
 }
 export function _compileDotPropAccessExpr(ctx, expr, _typeHint) {
+    // Enum member access: `EnumName.Member`
+    if (expr.object instanceof Identifier) {
+        const enumRes = _tryResolveEnumMemberAccess(ctx, expr.object, expr.prop, expr);
+        if (enumRes)
+            return enumRes;
+    }
     // if the LHS is a (chain of) identifier(s) rooted at a namespace, resolve
     // the entire dotted chain through namespaces.
     const nsRes = tryResolveNamespaceChain(ctx, expr);
@@ -128,3 +136,31 @@ export function _compileDotPropAccessExpr(ctx, expr, _typeHint) {
         return ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, expr.prop.range, expr.prop.text, objType.toString());
     return new TirPropAccessExpr(objExpr, expr.prop, returnType, expr.range);
 }
+/**
+ * Returns a `TirLitEnumMemberExpr` if `objId` resolves to an enum type
+ * in scope and `propId` is one of its members.
+ * Emits a diagnostic and returns a placeholder failure (undefined) if the
+ * type is an enum but `propId` is not a member.
+ * Returns `undefined` (silently) if `objId` is not an enum-typed identifier
+ * — caller falls back to other resolution strategies.
+ */
+function _tryResolveEnumMemberAccess(ctx, objId, propId, fullExpr) {
+    // skip if the identifier names a value in scope (variables shadow types)
+    if (ctx.scope.resolveValue(objId.text))
+        return undefined;
+    const possibleTirTypes = ctx.scope.resolveType(objId.text);
+    if (!possibleTirTypes)
+        return undefined;
+    const tirType = ctx.program.types.get(possibleTirTypes.sopTirName)
+        ?? (possibleTirTypes.dataTirName
+            ? ctx.program.types.get(possibleTirTypes.dataTirName)
+            : undefined);
+    if (!(tirType instanceof TirEnumType))
+        return undefined;
+    const memberIdx = tirType.indexOf(propId.text);
+    if (memberIdx < 0) {
+        ctx.error(DiagnosticCode.Property_0_is_not_a_member_of_enum_1, propId.range, propId.text, tirType.name);
+        return undefined;
+    }
+    return new TirLitEnumMemberExpr(tirType, memberIdx, fullExpr.range);
+}

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

@@ -7,7 +7,9 @@ import { TirUnaryExclamation } from "../../../tir/expressions/unary/TirUnaryExcl
 import { TirUnaryMinus } from "../../../tir/expressions/unary/TirUnaryMinus.js";
 import { TirUnaryPlus } from "../../../tir/expressions/unary/TirUnaryPlus.js";
 import { TirUnaryTilde } from "../../../tir/expressions/unary/TirUnaryTilde.js";
+import { TirValueT } from "../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo, canAssignToOptional } from "../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileUnaryPrefixExpr(ctx, expr, _typeHint) {
     const bool_t = ctx.program.stdTypes.bool;
@@ -26,10 +28,20 @@ export function _compileUnaryPrefixExpr(ctx, expr, _typeHint) {
     }
     else if (expr instanceof UnaryPlus
         || expr instanceof UnaryMinus) {
-        const operand = _compileExpr(ctx, expr.operand, int_t);
+        // Probe without hint so we can spot `-Value` (TirValueT) before
+        // failing the int check.
+        const operand = _compileExpr(ctx, expr.operand, undefined);
         if (!operand)
             return undefined;
         const operandType = operand.type;
+        const unaliasedTy = getUnaliased(operandType);
+        if (unaliasedTy instanceof TirValueT) {
+            // unary plus on Value is the identity; unary minus negates it.
+            if (expr instanceof UnaryPlus)
+                return new TirUnaryPlus(operand, operandType, expr.range);
+            if (expr instanceof UnaryMinus)
+                return new TirUnaryMinus(operand, operandType, expr.range);
+        }
         if (!canAssignTo(operandType, int_t)) {
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.operand.range, operand.type.toString(), "int");
         }