@harmoniclabs/pebble 0.1.10 → 0.2.0

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

@@ -0,0 +1,31 @@
+import { VarStmt } from "../VarStmt.js";
+import { FuncDecl } from "./FuncDecl.js";
+import { InterfaceDecl } from "./InterfaceDecl.js";
+import { isPebbleTypeDecl } from "./PebbleTypeDecl.js";
+export function isNamespaceMemberStmt(thing) {
+    return (thing instanceof VarStmt
+        || thing instanceof FuncDecl
+        || isPebbleTypeDecl(thing)
+        || thing instanceof InterfaceDecl
+        || thing instanceof NamespaceDecl);
+}
+export class NamespaceMember {
+    isPrivate;
+    stmt;
+    range;
+    constructor(isPrivate, stmt, range) {
+        this.isPrivate = isPrivate;
+        this.stmt = stmt;
+        this.range = range;
+    }
+}
+export class NamespaceDecl {
+    name;
+    members;
+    range;
+    constructor(name, members, range) {
+        this.name = name;
+        this.members = members;
+        this.range = range;
+    }
+}

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

@@ -86,6 +86,32 @@ export declare class AstCompiler extends DiagnosticEmitter {
     private _collectInterfaceImplSigs;
     private _collectTopLevelConst;
     private _collectTopLevelFuncDeclSig;
+    /**
+     * Register a generic function template. Compile only the signature in a
+     * scope where each type parameter is bound to a `TirTypeParam`; the body
+     * is deferred until `monomorphizeGeneric` is invoked at a call site.
+     */
+    private _registerGenericTemplate;
+    /**
+     * Resolve a `<T implements I>` constraint clause to a `TypeParamConstraint`.
+     *
+     * - `decl.constraint` must be a bare `AstNamedTypeExpr` (no type args).
+     * - The named interface must be registered in `scope.interfaces`
+     *   (walking up the parent chain via `resolveInterface`).
+     *
+     * The returned object captures the AST method signatures verbatim so the
+     * monomorphizer doesn't have to re-resolve the interface each time.
+     */
+    private _resolveTypeParamConstraint;
+    /**
+     * walks `stmts` for `NamespaceDecl` (optionally wrapped in `ExportStmt`),
+     * compiles each one into a `NamespaceSymbol`, and registers it on
+     * `enclosingScope` (and `enclosingExports` when exported).
+     *
+     * removes processed `NamespaceDecl` statements from `stmts`.
+     */
+    private _collectNamespaceDeclarations;
+    private _compileNamespaceDecl;
     private _collectInterfaceDeclarations;
     registerInternalTypeDecl(decl: StructDecl | TypeAliasDecl): void;
     private _collectTypeDeclarations;

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -29,14 +29,18 @@ import { CommonFlags } from "../../common.js";
 import { SimpleVarDecl } from "../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
 import { Identifier } from "../../ast/nodes/common/Identifier.js";
 import { ArrowKind } from "../../ast/nodes/expr/functions/ArrowKind.js";
-import { _compileFuncExpr } from "./internal/exprs/_compileFuncExpr.js";
+import { _compileFuncExpr, getDataFuncSignature } from "./internal/exprs/_compileFuncExpr.js";
+import { TirTypeParam } from "../tir/types/TirTypeParam.js";
 import { ContractDecl } from "../../ast/nodes/statements/declarations/ContractDecl.js";
 import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContractBody.js";
 import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
 import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
 import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
+import { _compileTestStmt } from "./internal/statements/_compileTestStmt.js";
 import { SourceTypeMap } from "../SourceTypeMap.js";
 import { isIdentifier } from "../../utils/text.js";
+import { TestStmt } from "../../ast/nodes/statements/TestStmt.js";
+import { NamespaceDecl } from "../../ast/nodes/statements/declarations/NamespaceDecl.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -273,6 +277,9 @@ export class AstCompiler extends DiagnosticEmitter {
         this._consumeImportsAddSymsInScope(stmts, src.absoluteProjPath, importsScope);
         const topLevelScope = importsScope.newChildScope({ isFunctionDeclScope: false });
         const srcExports = this.preludeScope.newChildScope({ isFunctionDeclScope: false });
+        // collect namespace declarations (recursively) so that types/interfaces/signatures
+        // can refer to symbols defined inside namespaces.
+        this._collectNamespaceDeclarations(stmts, src.uid, topLevelScope, srcExports);
         // collect top level **type** (struct and aliases) declarations
         this._collectTypeDeclarations(stmts, src.uid, topLevelScope, srcExports);
         // collect top level **interface** declarations (NOT implementations)
@@ -300,6 +307,17 @@ export class AstCompiler extends DiagnosticEmitter {
                 exportRange = stmt.range;
                 stmt = stmt.stmt;
             }
+            if (stmt instanceof TestStmt) {
+                if (isEntryFile) {
+                    const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
+                    _compileTestStmt(declContext, stmt, srcUid, this.cfg.entry);
+                }
+                // tests from non-entry files are dropped on the floor:
+                // they will be collected when their own file is the entry.
+                void stmts.splice(i, 1);
+                i--;
+                continue;
+            }
             if (!(stmt instanceof FuncDecl
                 || stmt instanceof TypeImplementsStmt
                 || stmt instanceof ContractDecl
@@ -428,6 +446,14 @@ export class AstCompiler extends DiagnosticEmitter {
         if (this._isExporting && astFuncName === this.program.contractTirFuncName) {
             this.program.contractTirFuncName = tirFuncName;
         }
+        // Generic function declaration path: do NOT compile the body. Instead,
+        // compile the signature in a scope where each type parameter resolves
+        // to a fresh `TirTypeParam`, then register a `GenericTemplate` on the
+        // program. Call sites instantiate it via `monomorphizeGeneric`.
+        if (astFuncExpr.typeParams.length > 0) {
+            this._registerGenericTemplate(astFuncExpr, astFuncName, tirFuncName, topLevelScope, srcExports, exportRange);
+            return;
+        }
         const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
         const funcExpr = _compileFuncExpr(declContext, astFuncExpr, undefined, // sig
         false // isMethod
@@ -456,6 +482,160 @@ export class AstCompiler extends DiagnosticEmitter {
             && this.program.contractTirFuncName === "")
             this.program.contractTirFuncName = tirFuncName;
     }
+    /**
+     * Register a generic function template. Compile only the signature in a
+     * scope where each type parameter is bound to a `TirTypeParam`; the body
+     * is deferred until `monomorphizeGeneric` is invoked at a call site.
+     */
+    _registerGenericTemplate(astFuncExpr, astFuncName, tirFuncName, topLevelScope, srcExports, exportRange) {
+        if (topLevelScope.functions.has(astFuncName))
+            return this.error(DiagnosticCode._0_is_already_defined, astFuncExpr.name.range, astFuncName);
+        // Detect duplicate type-param names on the template
+        const seenParamNames = new Set();
+        const tirTypeParams = [];
+        for (const decl of astFuncExpr.typeParams) {
+            if (seenParamNames.has(decl.name.text)) {
+                return this.error(DiagnosticCode._0_is_already_defined, decl.name.range, decl.name.text);
+            }
+            seenParamNames.add(decl.name.text);
+            tirTypeParams.push(new TirTypeParam(decl.name.text));
+        }
+        // Build a child scope where each type-param name resolves to its
+        // TirTypeParam (via `_compileDataEncodedConcreteType`'s new lookup).
+        const templateScope = topLevelScope.newChildScope({
+            ...topLevelScope.infos,
+            isFunctionDeclScope: false,
+            isMethodScope: false
+        });
+        for (let i = 0; i < astFuncExpr.typeParams.length; i++) {
+            templateScope.defineTypeParam(astFuncExpr.typeParams[i].name.text, tirTypeParams[i]);
+        }
+        // Resolve constraints on each type param (the `implements I` clause).
+        // For each constrained param, record the constraint on the template
+        // so monomorphizeGeneric can inject the matching dictionary at call
+        // sites, and on the template scope so `getPropAccessReturnType` can
+        // resolve method calls on `T`-typed values inside the body.
+        const constraints = new Array(astFuncExpr.typeParams.length).fill(undefined);
+        for (let i = 0; i < astFuncExpr.typeParams.length; i++) {
+            const decl = astFuncExpr.typeParams[i];
+            if (!decl.constraint)
+                continue;
+            const con = this._resolveTypeParamConstraint(templateScope, decl);
+            if (!con)
+                return undefined;
+            constraints[i] = con;
+            templateScope.defineTypeParamConstraint(decl.name.text, con);
+        }
+        // Compile only the signature: yields a TirFuncT that may contain
+        // TirTypeParams in arg/return positions.
+        const templateCtx = AstCompilationCtx.fromScope(this.program, templateScope);
+        const placeholderFuncType = getDataFuncSignature(templateCtx, astFuncExpr.signature);
+        if (!placeholderFuncType)
+            return undefined;
+        // Register the template on the program
+        this.program.genericTemplates.set(astFuncName, {
+            kind: "user",
+            astFuncName,
+            astFuncExpr,
+            typeParams: tirTypeParams,
+            definingScope: topLevelScope,
+            canonicalTirName: tirFuncName,
+            placeholderFuncType,
+            constraints,
+        });
+        // Register the generic placeholder value in the top-level scope so
+        // identifier lookup at call sites finds it. The `genericTemplateName`
+        // field signals to `_compileCallExpr` that this is a template.
+        topLevelScope.functions.set(astFuncName, tirFuncName);
+        topLevelScope.defineValue({
+            name: astFuncName,
+            type: placeholderFuncType,
+            isConstant: true,
+            genericTemplateName: astFuncName,
+        });
+        if (exportRange && srcExports) {
+            if (srcExports.functions.has(astFuncName)
+                || srcExports.variables.has(astFuncName))
+                return this.error(DiagnosticCode._0_is_already_exported, exportRange, astFuncName);
+            srcExports.functions.set(astFuncName, tirFuncName);
+            srcExports.defineValue({
+                name: astFuncName,
+                type: placeholderFuncType,
+                isConstant: true,
+                genericTemplateName: astFuncName,
+            });
+        }
+    }
+    /**
+     * Resolve a `<T implements I>` constraint clause to a `TypeParamConstraint`.
+     *
+     * - `decl.constraint` must be a bare `AstNamedTypeExpr` (no type args).
+     * - The named interface must be registered in `scope.interfaces`
+     *   (walking up the parent chain via `resolveInterface`).
+     *
+     * The returned object captures the AST method signatures verbatim so the
+     * monomorphizer doesn't have to re-resolve the interface each time.
+     */
+    _resolveTypeParamConstraint(scope, decl) {
+        const constraint = decl.constraint;
+        if (!constraint)
+            return undefined;
+        if (!(constraint instanceof AstNamedTypeExpr))
+            return this.error(DiagnosticCode.Type_expected, constraint.range);
+        if (constraint.tyArgs.length > 0)
+            return this.error(DiagnosticCode.Not_implemented_0, constraint.range, "generic interface as a type-parameter constraint");
+        const interfaceName = constraint.name.text;
+        const methods = scope.resolveInterface(interfaceName);
+        if (!methods)
+            return this.error(DiagnosticCode._0_is_not_defined, constraint.name.range, interfaceName);
+        return { interfaceName, methods };
+    }
+    /**
+     * walks `stmts` for `NamespaceDecl` (optionally wrapped in `ExportStmt`),
+     * compiles each one into a `NamespaceSymbol`, and registers it on
+     * `enclosingScope` (and `enclosingExports` when exported).
+     *
+     * removes processed `NamespaceDecl` statements from `stmts`.
+     */
+    _collectNamespaceDeclarations(stmts, srcUid, enclosingScope, enclosingExports) {
+        for (let i = 0; i < stmts.length; i++) {
+            let stmt = stmts[i];
+            let exported = false;
+            if (stmt instanceof ExportStmt) {
+                exported = true;
+                stmt = stmt.stmt;
+            }
+            if (!(stmt instanceof NamespaceDecl))
+                continue;
+            this._compileNamespaceDecl(stmt, srcUid, enclosingScope, enclosingExports, exported);
+            void stmts.splice(i, 1);
+            i--;
+        }
+    }
+    _compileNamespaceDecl(decl, srcUid, enclosingScope, enclosingExports, isExported) {
+        const nsName = decl.name.text;
+        if (enclosingScope.namespaces.has(nsName))
+            return this.error(DiagnosticCode._0_is_already_defined, decl.name.range, nsName);
+        const compilationScope = enclosingScope.newChildScope({ isFunctionDeclScope: false });
+        const publicScope = enclosingScope.newChildScope({ isFunctionDeclScope: false });
+        const nsSrcUid = `${srcUid}::${nsName}`;
+        // build a synthetic top-level statement list from the namespace's members:
+        // wrap public members in ExportStmt so the existing passes route them
+        // to `publicScope` automatically; leave private members bare so they only
+        // live in `compilationScope`.
+        const fakeStmts = decl.members.map((m) => m.isPrivate
+            ? m.stmt
+            : new ExportStmt(m.stmt, m.range));
+        // recurse into nested namespaces first so subsequent passes can
+        // resolve `Inner.Member` references.
+        this._collectNamespaceDeclarations(fakeStmts, nsSrcUid, compilationScope, publicScope);
+        this._collectTypeDeclarations(fakeStmts, nsSrcUid, compilationScope, publicScope);
+        this._collectInterfaceDeclarations(fakeStmts, compilationScope, publicScope);
+        this._collectAllTopLevelSignatures(fakeStmts, nsSrcUid, compilationScope, publicScope, false);
+        enclosingScope.defineNamespace({ name: nsName, publicScope });
+        if (isExported)
+            enclosingExports.defineNamespace({ name: nsName, publicScope });
+    }
     _collectInterfaceDeclarations(stmts, topLevelScope, srcExports) {
         for (let i = 0; i < stmts.length; i++) {
             let stmt = stmts[i];
@@ -603,7 +783,23 @@ export class AstCompiler extends DiagnosticEmitter {
         for (let i = 0; i < stmts.length; i++) {
             const stmt = stmts[i];
             if (stmt instanceof ImportStarStmt) {
-                this.error(DiagnosticCode.Not_implemented_0, stmt.range, "import *");
+                const importAbsPath = getAbsolutePath(stmt.fromPath.string, srcAbsPath) ?? "";
+                const importedSymbols = this.program.getExportedSymbols(importAbsPath);
+                if (!importedSymbols) {
+                    this.error(DiagnosticCode.File_0_not_found, stmt.fromPath.range, importAbsPath);
+                    void stmts.splice(i, 1);
+                    i--;
+                    continue;
+                }
+                const aliasName = stmt.anIdentifier.text;
+                const ok = srcImportsScope.defineNamespace({
+                    name: aliasName,
+                    publicScope: importedSymbols
+                });
+                if (!ok)
+                    this.error(DiagnosticCode._0_is_already_defined, stmt.anIdentifier.range, aliasName);
+                void stmts.splice(i, 1);
+                i--;
                 continue;
             }
             if (!(stmt instanceof ImportStmt))
@@ -620,10 +816,12 @@ export class AstCompiler extends DiagnosticEmitter {
                 const isType = importedSymbols.types.has(declName);
                 const isFunction = importedSymbols.functions.has(declName);
                 const isInterface = importedSymbols.interfaces.has(declName);
+                const isNamespace = importedSymbols.namespaces.has(declName);
                 if (!(isValue
                     || isType
                     || isFunction
-                    || isInterface)) {
+                    || isInterface
+                    || isNamespace)) {
                     this.error(DiagnosticCode.Module_0_has_no_exported_member_1, importDecl.identifier.range, stmt.fromPath.string, declName);
                     continue;
                 }
@@ -647,6 +845,8 @@ export class AstCompiler extends DiagnosticEmitter {
                     srcImportsScope.types.set(declName, importedSymbols.types.get(declName));
                 if (isInterface)
                     srcImportsScope.interfaces.set(declName, importedSymbols.interfaces.get(declName));
+                if (isNamespace)
+                    srcImportsScope.defineNamespace(importedSymbols.namespaces.get(declName));
             }
             // remove from array so we don't process it again
             void stmts.splice(i, 1);

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");

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/_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/_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;