@harmoniclabs/pebble 0.1.10 → 0.3.0

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

@@ -14,6 +14,7 @@ import { LitIntExpr } from "../../../../ast/nodes/expr/litteral/LitIntExpr.js";
 import { LitNamedObjExpr } from "../../../../ast/nodes/expr/litteral/LitNamedObjExpr.js";
 import { LitObjExpr } from "../../../../ast/nodes/expr/litteral/LitObjExpr.js";
 import { LitStrExpr } from "../../../../ast/nodes/expr/litteral/LitStrExpr.js";
+import { TemplateStrExpr } from "../../../../ast/nodes/expr/litteral/TemplateStrExpr.js";
 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";
@@ -44,7 +45,7 @@ import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
 import { MatchStmtCase, MatchStmt, MatchStmtElseCase } from "../../../../ast/nodes/statements/MatchStmt.js";
 import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
 import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
-import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { UsingAliasStmt, UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
 import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
 import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
 import { SourceRange } from "../../../../ast/Source/SourceRange.js";
@@ -457,7 +458,8 @@ function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNames
         if (stmt instanceof BreakStmt
             || stmt instanceof ContinueStmt
             || stmt instanceof EmptyStmt
-            || stmt instanceof UsingStmt)
+            || stmt instanceof UsingStmt
+            || stmt instanceof UsingAliasStmt)
             continue;
         if (isImplicitAssignmentStmt(stmt))
             continue;
@@ -766,6 +768,15 @@ function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalN
         expr.body = new BlockStmt(nextBodyStmts, expr.body.range);
         return expr;
     }
+    if (expr instanceof TemplateStrExpr) {
+        for (let i = 0; i < expr.exprs.length; i++) {
+            const newSub = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.exprs[i], paramsInternalNamesMap, renamedVariables);
+            if (!newSub)
+                return undefined;
+            expr.exprs[i] = newSub;
+        }
+        return expr;
+    }
     const tsEnsureExhaustiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::_exprReplaceParamsAndAssertNoLitContext");
@@ -773,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);
 }
@@ -844,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, ... };
@@ -910,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

@@ -2,12 +2,13 @@ import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.gener
 import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
 import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { inferTypeArgs } from "../../../tir/types/utils/inferTypeArgs.js";
+import { substituteTypeParams } from "../../../tir/types/utils/substituteTypeParams.js";
+import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
+import { monomorphizeGeneric } from "../../utils/monomorphizeGeneric.js";
+import { _compileDataEncodedConcreteType } from "../types/_compileDataEncodedConcreteType.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileCallExpr(ctx, expr, typeHint) {
-    // TODO: expr.genericTypeArgs
-    // expr.funcExpr;
-    // expr.args;
-    // expr.range;
     if (!(typeHint instanceof TirFuncT))
         typeHint = undefined;
     const funcExpr = _compileExpr(ctx, expr.funcExpr, typeHint);
@@ -15,7 +16,97 @@ export function _compileCallExpr(ctx, expr, typeHint) {
         return undefined;
     if (!(funcExpr.type instanceof TirFuncT))
         return ctx.error(DiagnosticCode.Expression_is_not_callable, expr.funcExpr.range);
-    const funcType = funcExpr.type;
+    // ---- Generic-callee handling --------------------------------------
+    // If the callee resolved to a generic placeholder, the funcExpr is a
+    // `TirVariableAccessExpr` whose `variableInfos.genericTemplateName` names
+    // a template registered on `program.genericTemplates`. We instantiate it
+    // here with explicit or inferred type arguments and replace `funcExpr`
+    // with a synthetic access pointing at the concrete monomorphized instance.
+    let callee = funcExpr;
+    let funcType = funcExpr.type;
+    if (funcExpr instanceof TirVariableAccessExpr) {
+        const templateName = funcExpr.resolvedValue.variableInfos.genericTemplateName;
+        if (typeof templateName === "string") {
+            const template = ctx.program.genericTemplates.get(templateName);
+            if (!template)
+                return ctx.error(DiagnosticCode._0_is_not_defined, expr.funcExpr.range, templateName);
+            const nParams = template.typeParams.length;
+            // 1) Collect explicit type-args, if any
+            const explicitArgs = (Array.isArray(expr.genericTypeArgs)
+                ? new Array()
+                : undefined);
+            if (explicitArgs && expr.genericTypeArgs) {
+                for (const tArgExpr of expr.genericTypeArgs) {
+                    const t = _compileDataEncodedConcreteType(ctx, tArgExpr, true);
+                    if (!t)
+                        return undefined;
+                    explicitArgs.push(t);
+                }
+                if (explicitArgs.length !== nParams) {
+                    return ctx.error(DiagnosticCode.Expected_0_type_arguments_but_got_1, expr.funcExpr.range, String(nParams), String(explicitArgs.length));
+                }
+            }
+            // 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;
+            // 3) Determine final type arguments
+            let resolvedArgs;
+            if (explicitArgs) {
+                resolvedArgs = explicitArgs;
+            }
+            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());
+                    }
+                }
+                resolvedArgs = new Array(nParams);
+                for (let i = 0; i < nParams; i++) {
+                    const bound = env.get(template.typeParams[i].symbol);
+                    if (!bound) {
+                        return ctx.error(DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly, expr.funcExpr.range, template.typeParams[i].name);
+                    }
+                    resolvedArgs[i] = bound;
+                }
+            }
+            // 4) Monomorphize
+            const mono = monomorphizeGeneric(ctx, template, resolvedArgs, expr.range);
+            if (!mono)
+                return undefined;
+            funcType = mono.concreteFuncType;
+            // 5) Synthesize a TirVariableAccessExpr for the concrete instance.
+            //    The IR layer looks up by name on `program.functions`, so it
+            //    matches the entry registered by `monomorphizeGeneric`.
+            callee = new TirVariableAccessExpr({
+                variableInfos: {
+                    name: mono.tirFuncName,
+                    type: funcType,
+                    isConstant: true,
+                },
+                isDefinedOutsideFuncScope: true,
+            }, expr.funcExpr.range);
+            // 6) Re-validate argument assignability against concrete signature
+            const finalCallExprType = funcType.argTypes.length === tirArgs.length
+                ? funcType.returnType
+                : new TirFuncT(funcType.argTypes.slice(tirArgs.length), funcType.returnType);
+            for (let i = 0; i < tirArgs.length && i < funcType.argTypes.length; i++) {
+                if (!canAssignTo(tirArgs[i].type, funcType.argTypes[i]))
+                    return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, tirArgs[i].type.toString(), funcType.argTypes[i].toString());
+            }
+            return new TirCallExpr(callee, tirArgs, finalCallExprType, expr.range);
+        }
+    }
+    // ---- End generic-callee handling ----------------------------------
     for (let i = funcType.argTypes.length; i < expr.args.length; i++) {
         ctx.warning(DiagnosticCode.Unexpected_argument, expr.args[i].range); // not a big deal
     }
@@ -32,5 +123,5 @@ export function _compileCallExpr(ctx, expr, typeHint) {
         if (!canAssignTo(arg.type, funcType.argTypes[i]))
             return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.args[i].range, arg.type.toString(), funcType.argTypes[i].toString());
     }
-    return new TirCallExpr(funcExpr, args, finalCallExprType, expr.range);
+    return new TirCallExpr(callee, args, finalCallExprType, expr.range);
 }

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

@@ -9,7 +9,6 @@ import { TirReturnStmt } from "../../../tir/statements/TirReturnStmt.js";
 import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
 import { void_t } from "../../../tir/program/stdScope/stdScope.js";
-import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
 import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileBlockStmt } from "../statements/_compileBlockStmt.js";
 import { _compileVarDecl } from "../statements/_compileVarStmt.js";
@@ -91,8 +90,13 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
         isConstant: true,
     });
     // if( _hasDuplicateTypeParams( ctx, expr.typeParams ) ) return undefined;
+    // Generic functions are compiled per-instantiation by `monomorphizeGeneric`.
+    // The cloned `FuncExpr` it produces has `typeParams = []`, so we only need
+    // to refuse the (rare) case where someone directly calls `_compileFuncExpr`
+    // on a still-generic AST node (e.g. an anonymous lambda annotated with type
+    // params, which is not supported yet).
     if (expr.typeParams.length > 0)
-        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
+        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic lambda expressions (top-level generic functions are supported)");
     const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr, expectedFuncType);
     if (!destructuredParamsResult)
         return undefined;
@@ -140,8 +144,10 @@ function _compileFuncExprInferReturnType(ctx, expr, isMethod) {
         type: tempFuncType,
         isConstant: true,
     });
+    // Inferred-return-type variant: generics are not supported here because
+    // signature inference depends on knowing the type-param substitution.
     if (expr.typeParams.length > 0)
-        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");
+        return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions with inferred return type — annotate the return type");
     const destructuredParamsResult = _getDestructuredParamsAsVarDecls(funcCtx, expr, tempFuncType);
     if (!destructuredParamsResult)
         return undefined;
@@ -234,8 +240,9 @@ export function getDataFuncSignature(ctx, signature) {
     const returnType = signature.returnType instanceof AstFuncType ?
         getDataFuncSignature(ctx, signature.returnType) :
         _compileSopEncodedConcreteType(ctx, signature.returnType);
-    if (!returnType
-        || returnType instanceof TirTypeParam)
+    if (!returnType)
         return undefined;
+    // NOTE: a bare `TirTypeParam` return type is valid here — it marks the
+    // template position. `monomorphizeGeneric` substitutes it at call sites.
     return new TirFuncT(paramTypes, returnType);
 }

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

@@ -7,6 +7,7 @@ import { LitIntExpr } from "../../../../ast/nodes/expr/litteral/LitIntExpr.js";
 import { LitNamedObjExpr } from "../../../../ast/nodes/expr/litteral/LitNamedObjExpr.js";
 import { LitObjExpr } from "../../../../ast/nodes/expr/litteral/LitObjExpr.js";
 import { LitStrExpr } from "../../../../ast/nodes/expr/litteral/LitStrExpr.js";
+import { TemplateStrExpr } from "../../../../ast/nodes/expr/litteral/TemplateStrExpr.js";
 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";
@@ -66,6 +67,8 @@ export function _compileLitteralExpr(ctx, expr, typeHint) {
         return _compileLitteralNamedObjExpr(ctx, expr, typeHint);
     if (expr instanceof LitFailExpr)
         return new TirLitFailExpr(expr.range);
+    if (expr instanceof TemplateStrExpr)
+        return _compileTemplateStrExpr(ctx, expr);
     if (expr instanceof LitContextExpr)
         throw new Error("Litteral `context` should have been handled while desugaring.");
     const tsEnsureExhautstiveCheck = expr;
@@ -226,3 +229,59 @@ export function _compileLitteralArrayExpr(ctx, expr, typeHint) {
         return undefined;
     return new TirLitArrExpr([fstCompiledExpr, ...compiledRestElems], listType, expr.range);
 }
+/**
+ * Compile a template string `` `text ${e1} more ${e2} ...` `` into a chain
+ * of `appendByteString` calls.
+ *
+ * Each text fragment becomes a `TirLitHexBytesExpr` containing its UTF-8
+ * encoding. Each interpolation is compiled and, if its type is not already
+ * `bytes`, wrapped in a `TirShowExpr` so it lowers via the built-in `Show`
+ * interface (or the user's `type X implements Show { ... }` override).
+ *
+ * Empty fragments collapse out — we don't emit `appendByteString("", x)`.
+ */
+function _compileTemplateStrExpr(ctx, expr) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { fromUtf8 } = require("@harmoniclabs/uint8array-utils");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { TirShowExpr } = require("../../../tir/expressions/TirShowExpr.js");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { TirCallExpr } = require("../../../tir/expressions/TirCallExpr.js");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { TirNativeFunc } = require("../../../tir/expressions/TirNativeFunc.js");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { TirBytesT } = require("../../../tir/types/TirNativeType/native/bytes.js");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { bytes_t } = require("../../../tir/program/stdScope/stdScope.js");
+    const pieces = [];
+    for (let i = 0; i < expr.parts.length; i++) {
+        const text = expr.parts[i];
+        if (text.length > 0) {
+            pieces.push(new TirLitHexBytesExpr(fromUtf8(text), expr.range));
+        }
+        if (i < expr.exprs.length) {
+            const sub = _compileExpr(ctx, expr.exprs[i], undefined);
+            if (!sub)
+                return undefined;
+            const subType = getUnaliased(sub.type);
+            if (subType instanceof TirBytesT) {
+                // Already valid UTF-8 by convention — pass through.
+                pieces.push(sub);
+            }
+            else {
+                // Auto-show via the built-in Show interface dispatch.
+                pieces.push(new TirShowExpr(sub, expr.exprs[i].range));
+            }
+        }
+    }
+    if (pieces.length === 0) {
+        // Empty template — emit empty bytes.
+        return new TirLitHexBytesExpr(new Uint8Array(0), expr.range);
+    }
+    // Left-fold appendByteString.
+    let acc = pieces[0];
+    for (let i = 1; i < pieces.length; i++) {
+        acc = new TirCallExpr(TirNativeFunc.appendByteString, [acc, pieces[i]], bytes_t, expr.range);
+    }
+    return acc;
+}

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

@@ -1,9 +1,8 @@
 import { PropAccessExpr, OptionalPropAccessExpr, NonNullPropAccessExpr, DotPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
 import { TirExpr } from "../../../tir/expressions/TirExpr.js";
-import { TirPropAccessExpr } from "../../../tir/expressions/TirPropAccessExpr.js";
 import { TirType } from "../../../tir/types/TirType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
 export declare function _compilePropAccessExpr(ctx: AstCompilationCtx, expr: PropAccessExpr, typeHint: TirType | undefined): TirExpr | undefined;
 export declare function _compileOptionalPropAccessExpr(ctx: AstCompilationCtx, expr: OptionalPropAccessExpr, _typeHint: TirType | undefined): TirExpr | undefined;
-export declare function _compileNonNullPropAccessExpr(ctx: AstCompilationCtx, expr: NonNullPropAccessExpr, _typeHint: TirType | undefined): TirPropAccessExpr | undefined;
-export declare function _compileDotPropAccessExpr(ctx: AstCompilationCtx, expr: DotPropAccessExpr, _typeHint: TirType | undefined): TirPropAccessExpr | undefined;
+export declare function _compileNonNullPropAccessExpr(ctx: AstCompilationCtx, expr: NonNullPropAccessExpr, _typeHint: TirType | undefined): TirExpr | undefined;
+export declare function _compileDotPropAccessExpr(ctx: AstCompilationCtx, expr: DotPropAccessExpr, _typeHint: TirType | undefined): TirExpr | undefined;

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

@@ -1,18 +1,24 @@
 import { OptionalPropAccessExpr, NonNullPropAccessExpr, DotPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
 import { NonNullExpr } from "../../../../ast/nodes/expr/unary/NonNullExpr.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
 import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
+import { TirNativeFunc } from "../../../tir/expressions/TirNativeFunc.js";
 import { TirPropAccessExpr } from "../../../tir/expressions/TirPropAccessExpr.js";
 import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
 import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirUnConstrDataResultT } from "../../../tir/types/TirNativeType/index.js";
 import { getOptTypeArg } from "../../../tir/types/utils/getOptTypeArg.js";
 import { getPropAccessReturnType } from "../../utils/getPropAccessReturnType.js";
+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);
@@ -91,12 +97,70 @@ 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);
+    if (nsRes) {
+        if (nsRes.kind === "value")
+            return nsRes.expr;
+        if (nsRes.kind === "namespace")
+            return ctx.error(DiagnosticCode.Namespace_path_is_incomplete_expected_a_value_type_function_or_interface, expr.range);
+        // "incomplete" — diagnostic already emitted
+        return undefined;
+    }
     const objExpr = _compileExpr(ctx, expr.object, undefined);
     if (!objExpr)
         return undefined;
     const objType = objExpr.type;
+    // RawConstr (TirUnConstrDataResultT) field access lowers directly to
+    // fstPair / sndPair on the underlying pair(int, list(data)).
+    if (objType instanceof TirUnConstrDataResultT) {
+        if (expr.prop.text === "index") {
+            const fn = TirNativeFunc.unConstrDataResultIndex;
+            return new TirCallExpr(fn, [objExpr], fn.type.returnType, expr.range);
+        }
+        if (expr.prop.text === "fields") {
+            const fn = TirNativeFunc.unConstrDataResultFields;
+            return new TirCallExpr(fn, [objExpr], fn.type.returnType, expr.range);
+        }
+        return ctx.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, expr.prop.range, expr.prop.text, "RawConstr");
+    }
     const returnType = getPropAccessReturnType(ctx, objType, expr.prop);
     if (!returnType)
         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");
         }

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

@@ -3,6 +3,8 @@ import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAcces
 export function _compileVarAccessExpr(ctx, expr, typeHint) {
     const resolvedValue = ctx.scope.resolveValue(expr.text);
     if (!resolvedValue) {
+        if (ctx.scope.resolveNamespace(expr.text))
+            return ctx.error(DiagnosticCode.Namespace_path_is_incomplete_expected_a_value_type_function_or_interface, expr.range);
         console.trace(ctx.scope.allVariables(), expr.text);
         return ctx.error(DiagnosticCode._0_is_not_defined, expr.range, expr.text);
     }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileAddExpr.js

@@ -1,20 +1,33 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirAddExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileAddExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    // Probe the left first with no hint; if it turns out to be a Value, we
+    // accept the same on the right and lower to `unionValue` in TirAddExpr.
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, leftProbe.type);
+        if (!right)
+            return undefined;
+        if (!(getUnaliased(right.type) instanceof TirValueT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), "Value");
+        return new TirAddExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
     const right = _compileExpr(ctx, expr.right, int_t);
     if (!right)
         return undefined;
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirAddExpr(left, right, 
+    return new TirAddExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileEqualExpr.js

@@ -1,12 +1,14 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    const leftType = left.type;
+    // enums lower to ints at runtime, so allow comparing against ints
+    const leftType = normalizeEnumToInt(left.type, ctx.program.stdTypes.int);
     const right = _compileExpr(ctx, expr.right, leftType);
     if (!right)
         return undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanEqualExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 // only aviable for ints and bytes
 export function _compileGreaterThanEqualExpr(ctx, expr, typeHint) {
@@ -13,7 +14,7 @@ export function _compileGreaterThanEqualExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileGreaterThanExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
@@ -12,7 +13,7 @@ export function _compileGreaterThanExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);