@harmoniclabs/pebble 0.1.3-dev3 → 0.1.3-dev4

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

@@ -44,7 +44,7 @@ export function _compileSimpleVarDecl(ctx, decl, typeHint) {
     const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
     if (!typeAndExpr)
         return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
+    const [finalVarType, initExpr, typeAnnotationRange] = typeAndExpr;
     const success = ctx.scope.defineValue({
         name: decl.name.text,
         type: finalVarType,
@@ -52,7 +52,7 @@ export function _compileSimpleVarDecl(ctx, decl, typeHint) {
     });
     if (!success)
         return ctx.error(DiagnosticCode.Duplicate_identifier_0, decl.name.range, decl.name.text);
-    return new TirSimpleVarDecl(decl.name.text, finalVarType, initExpr, decl.isConst(), decl.range);
+    return new TirSimpleVarDecl(decl.name.text, finalVarType, initExpr, decl.isConst(), decl.range, typeAnnotationRange, decl.sourceName);
 }
 export function _compileNamedDeconstructVarDecl(ctx, decl, typeHint) {
     // const Spending{ ref, optionalDatum: datum as MyDatum } = purpose
@@ -71,7 +71,7 @@ export function _compileNamedDeconstructVarDecl(ctx, decl, typeHint) {
     const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
     if (!typeAndExpr)
         return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
+    const [finalVarType, initExpr, typeAnnotationRange] = typeAndExpr;
     const namedDestructableType = getNamedDestructableType(finalVarType);
     if (!namedDestructableType
         || !namedDestructableType.isConcrete())
@@ -86,8 +86,8 @@ export function _compileNamedDeconstructVarDecl(ctx, decl, typeHint) {
         ] : []));
         if (!deconstructedFields)
             return undefined;
-        const [fieds, rest] = deconstructedFields;
-        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
+        const [fieds, rest, fieldLabelRanges] = deconstructedFields;
+        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range, decl.name.range, fieldLabelRanges, typeAnnotationRange);
     }
     if (isTirStructType(namedDestructableType)) {
         const finalConstructorDef = namedDestructableType.constructors.find(ctor => ctor.name === decl.name.text);
@@ -96,15 +96,15 @@ export function _compileNamedDeconstructVarDecl(ctx, decl, typeHint) {
         const deconstructedFields = _getDeconstructedFields(ctx, decl, finalConstructorDef);
         if (!deconstructedFields)
             return undefined;
-        const [fieds, rest] = deconstructedFields;
-        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
+        const [fieds, rest, fieldLabelRanges] = deconstructedFields;
+        return new TirNamedDeconstructVarDecl(decl.name.text, fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range, decl.name.range, fieldLabelRanges, typeAnnotationRange);
     }
 }
 export function _compileSingleDeconstructVarDecl(ctx, decl, typeHint) {
     const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
     if (!typeAndExpr)
         return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
+    const [finalVarType, initExpr, typeAnnotationRange] = typeAndExpr;
     const finalStructType = getStructType(finalVarType);
     if (!finalStructType)
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.range, finalVarType.toString(), "Struct");
@@ -113,14 +113,14 @@ export function _compileSingleDeconstructVarDecl(ctx, decl, typeHint) {
     const deconstructedFields = _getDeconstructedFields(ctx, decl, finalStructType.constructors[0]);
     if (!deconstructedFields)
         return undefined;
-    const [fieds, rest] = deconstructedFields;
-    return new TirSingleDeconstructVarDecl(fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range);
+    const [fieds, rest, fieldLabelRanges] = deconstructedFields;
+    return new TirSingleDeconstructVarDecl(fieds, rest, finalVarType, initExpr, decl.isConst(), decl.range, fieldLabelRanges, typeAnnotationRange);
 }
 export function _compileArrayLikeDeconstr(ctx, decl, typeHint) {
     const typeAndExpr = _getVarDeclTypeAndExpr(ctx, decl, typeHint);
     if (!typeAndExpr)
         return undefined;
-    const [finalVarType, initExpr] = typeAndExpr;
+    const [finalVarType, initExpr, _typeAnnotationRange] = typeAndExpr;
     const elemsType = getListTypeArg(finalVarType);
     if (!elemsType)
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.range, finalVarType.toString(), "List");
@@ -146,6 +146,7 @@ export function _compileArrayLikeDeconstr(ctx, decl, typeHint) {
 }
 export function _getDeconstructedFields(ctx, astDeconstruct, ctorDef) {
     const tirFields = new Map();
+    const fieldLabelRanges = new Map();
     const ctorDefFieldNames = ctorDef.fields.map(f => f.name);
     const ctorNamesAlreadySpecified = [];
     for (const [fieldIdentifier, varDecl] of astDeconstruct.fields) {
@@ -155,8 +156,10 @@ export function _getDeconstructedFields(ctx, astDeconstruct, ctorDef) {
         if (ctorNamesAlreadySpecified.includes(fieldName))
             return ctx.error(DiagnosticCode.Duplicate_identifier_0, fieldIdentifier.range, fieldName);
         ctorNamesAlreadySpecified.push(fieldName);
+        const ctorFieldType = ctorDef.fields.find(f => f.name === fieldName).type;
+        fieldLabelRanges.set(fieldName, { range: fieldIdentifier.range, type: ctorFieldType });
         // adds to scope "simple" var decls
-        const tirVarDecl = _compileVarDecl(ctx, varDecl, ctorDef.fields.find(f => f.name === fieldName).type);
+        const tirVarDecl = _compileVarDecl(ctx, varDecl, ctorFieldType);
         if (!tirVarDecl)
             return undefined;
         tirFields.set(fieldName, tirVarDecl);
@@ -164,7 +167,7 @@ export function _getDeconstructedFields(ctx, astDeconstruct, ctorDef) {
     if (astDeconstruct.rest && ctorDefFieldNames.length === ctorNamesAlreadySpecified.length)
         return ctx.error(DiagnosticCode.Invalid_rest_parameter_there_are_no_more_fields, astDeconstruct.rest.range);
     let rest = astDeconstruct.rest ? astDeconstruct.rest.text : undefined;
-    return [tirFields, rest];
+    return [tirFields, rest, fieldLabelRanges];
 }
 export function _getVarDeclTypeAndExpr(ctx, decl, deconstructTypeHint) {
     const declarationType = decl.type ? _compileSopEncodedConcreteType(ctx, decl.type) : undefined;
@@ -204,5 +207,5 @@ export function _getVarDeclTypeAndExpr(ctx, decl, deconstructTypeHint) {
     const finalVarType = typeHint ?? initExpr?.type;
     if (!finalVarType)
         return ctx.error(DiagnosticCode.Cannot_infer_variable_type_Try_to_make_the_type_explicit, decl.range);
-    return [finalVarType, initExpr];
+    return [finalVarType, initExpr, decl.type?.range];
 }

package/dist/compiler/Compiler.d.ts

@@ -2,10 +2,13 @@ import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
 import { CompilerOptions } from "../IR/toUPLC/CompilerOptions.js";
 import { CompilerIoApi } from "./io/CompilerIoApi.js";
+import { CheckResult } from "./SourceTypeMap.js";
+export { CheckResult, SourceTypeMap, TypeEntry, MemberInfo } from "./SourceTypeMap.js";
 export declare class Compiler extends DiagnosticEmitter {
     readonly io: CompilerIoApi;
     readonly cfg: CompilerOptions;
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
+    check(config?: Partial<CompilerOptions>): Promise<CheckResult>;
     compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
     export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
     run(config?: Partial<CompilerOptions>): Promise<{
@@ -13,6 +16,11 @@ export declare class Compiler extends DiagnosticEmitter {
         budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;
         logs: string[];
     }>;
+    runRepl(config?: Partial<CompilerOptions>): Promise<{
+        result: import("@harmoniclabs/plutus-machine").CEKValueObj;
+        budgetSpent: import("@harmoniclabs/plutus-machine").ExBudget;
+        logs: string[];
+    }>;
     private _compileBackend;
 }
 interface HasFuncitonName {
@@ -20,4 +28,3 @@ interface HasFuncitonName {
 }
 export interface ExportOptions extends CompilerOptions, HasFuncitonName {
 }
-export {};

package/dist/compiler/Compiler.js

@@ -7,6 +7,7 @@ import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
 import { __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRHash.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
+export { SourceTypeMap } from "./SourceTypeMap.js";
 export class Compiler extends DiagnosticEmitter {
     io;
     cfg;
@@ -18,6 +19,15 @@ export class Compiler extends DiagnosticEmitter {
             this.io.stdout = { write() { } };
         }
     }
+    async check(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            silent: true,
+        };
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        return await astCompiler.check();
+    }
     async compile(config) {
         const cfg = {
             ...this.cfg,
@@ -30,9 +40,10 @@ export class Compiler extends DiagnosticEmitter {
             globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
-            while (msg = this.diagnostics.shift()) {
+            for (msg of this.diagnostics) {
                 this.io.stdout.write(msg.toString() + "\n");
             }
+            // return new Uint8Array();
             throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
         return this._compileBackend(cfg, program);
@@ -84,6 +95,28 @@ export class Compiler extends DiagnosticEmitter {
         const uplcProgram = parseUPLC(serialized);
         return Machine.eval(uplcProgram.body);
     }
+    async runRepl(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            addMarker: false,
+        };
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        const program = await astCompiler.runRepl();
+        if (this.diagnostics.length > 0) {
+            let msg;
+            globalThis.console && console.log(this.diagnostics);
+            const fstErrorMsg = this.diagnostics[0].toString();
+            const nDiags = this.diagnostics.length;
+            while (msg = this.diagnostics.shift()) {
+                this.io.stdout.write(msg.toString() + "\n");
+            }
+            throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+        }
+        const serialized = this._compileBackend(cfg, program);
+        const uplcProgram = parseUPLC(serialized);
+        return Machine.eval(uplcProgram.body);
+    }
     _compileBackend(cfg, program) {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);

package/dist/compiler/SourceTypeMap.d.ts

@@ -0,0 +1,43 @@
+import { DiagnosticMessage } from "../diagnostics/DiagnosticMessage.js";
+import { TirType } from "./tir/types/TirType.js";
+import { TypedProgram } from "./tir/program/TypedProgram.js";
+export interface TypeEntry {
+    start: number;
+    end: number;
+    type: TirType;
+    name?: string;
+    /** "type-reference" marks constructor/type names; default is "expression" */
+    kind?: "expression" | "type-reference";
+}
+export interface MemberInfo {
+    name: string;
+    type: TirType;
+    kind: "field" | "method";
+}
+export interface CheckResult {
+    diagnostics: DiagnosticMessage[];
+    program: TypedProgram;
+    sourceTypeMap: SourceTypeMap;
+}
+export declare class SourceTypeMap {
+    readonly program: TypedProgram;
+    private entries;
+    private sorted;
+    constructor(program: TypedProgram);
+    buildFromProgram(): void;
+    private addEntry;
+    private ensureSorted;
+    typeAtOffset(offset: number): TypeEntry | undefined;
+    allEntries(): readonly TypeEntry[];
+    membersOfType(type: TirType): MemberInfo[];
+    private structMembers;
+    private methodsFromMap;
+    private listMembers;
+    private bytesMembers;
+    private stringMembers;
+    private linearMapMembers;
+    private walkFuncExpr;
+    private walkExpr;
+    private walkStmt;
+    private walkVarDecl;
+}

package/dist/compiler/SourceTypeMap.js

@@ -0,0 +1,432 @@
+import { isInternalName } from "./internalVar.js";
+import { TirAliasType } from "./tir/types/TirAliasType.js";
+import { isTirStructType } from "./tir/types/TirStructType.js";
+import { TirFuncT } from "./tir/types/TirNativeType/native/function.js";
+import { TirListT } from "./tir/types/TirNativeType/native/list.js";
+import { TirLinearMapT } from "./tir/types/TirNativeType/native/linearMap.js";
+import { TirBytesT } from "./tir/types/TirNativeType/native/bytes.js";
+import { TirStringT } from "./tir/types/TirNativeType/native/string.js";
+import { TirBoolT } from "./tir/types/TirNativeType/native/bool.js";
+import { TirIntT } from "./tir/types/TirNativeType/native/int.js";
+import { TirDataT } from "./tir/types/TirNativeType/native/data.js";
+import { TirVoidT } from "./tir/types/TirNativeType/native/void.js";
+import { TirSopOptT } from "./tir/types/TirNativeType/native/Optional/sop.js";
+import { int_t, bool_t, bytes_t, string_t } from "./tir/program/stdScope/stdScope.js";
+import { TirFuncExpr } from "./tir/expressions/TirFuncExpr.js";
+import { TirBlockStmt } from "./tir/statements/TirBlockStmt.js";
+import { TirIfStmt } from "./tir/statements/TirIfStmt.js";
+import { TirReturnStmt } from "./tir/statements/TirReturnStmt.js";
+import { TirAssertStmt } from "./tir/statements/TirAssertStmt.js";
+import { TirForStmt } from "./tir/statements/TirForStmt.js";
+import { TirForOfStmt } from "./tir/statements/TirForOfStmt.js";
+import { TirWhileStmt } from "./tir/statements/TirWhileStmt.js";
+import { TirMatchStmt } from "./tir/statements/TirMatchStmt.js";
+import { TirAssignmentStmt } from "./tir/statements/TirAssignmentStmt.js";
+import { TirTraceStmt } from "./tir/statements/TirTraceStmt.js";
+import { TirSimpleVarDecl } from "./tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirNamedDeconstructVarDecl } from "./tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirSingleDeconstructVarDecl } from "./tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
+import { TirArrayLikeDeconstr } from "./tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
+import { TirCallExpr } from "./tir/expressions/TirCallExpr.js";
+import { TirPropAccessExpr } from "./tir/expressions/TirPropAccessExpr.js";
+import { TirVariableAccessExpr } from "./tir/expressions/TirVariableAccessExpr.js";
+import { TirCaseExpr } from "./tir/expressions/TirCaseExpr.js";
+import { TirElemAccessExpr } from "./tir/expressions/TirElemAccessExpr.js";
+import { TirTernaryExpr } from "./tir/expressions/TirTernaryExpr.js";
+import { TirParentesizedExpr } from "./tir/expressions/TirParentesizedExpr.js";
+import { TirTypeConversionExpr } from "./tir/expressions/TirTypeConversionExpr.js";
+import { TirLettedExpr } from "./tir/expressions/TirLettedExpr.js";
+import { TirHoistedExpr } from "./tir/expressions/TirHoistedExpr.js";
+import { TirFromDataExpr } from "./tir/expressions/TirFromDataExpr.js";
+import { TirToDataExpr } from "./tir/expressions/TirToDataExpr.js";
+import { TirAssertAndContinueExpr } from "./tir/expressions/TirAssertAndContinueExpr.js";
+import { TirTraceIfFalseExpr } from "./tir/expressions/TirTraceIfFalseExpr.js";
+import { TirTraceExpr } from "./tir/expressions/TirTraceExpr.js";
+import { isTirBinaryExpr } from "./tir/expressions/binary/TirBinaryExpr.js";
+import { isTirUnaryPrefixExpr } from "./tir/expressions/unary/TirUnaryPrefixExpr.js";
+import { TirTypeParam } from "./tir/types/TirTypeParam.js";
+import { isTirOptType } from "./tir/types/TirNativeType/native/Optional/isTirOptType.js";
+export class SourceTypeMap {
+    program;
+    entries = [];
+    sorted = false;
+    constructor(program) {
+        this.program = program;
+    }
+    buildFromProgram() {
+        this.entries = [];
+        for (const [name, func] of this.program.functions) {
+            if (func instanceof TirFuncExpr) {
+                this.walkFuncExpr(func);
+            }
+        }
+        for (const [name, cnst] of this.program.constants) {
+            this.walkVarDecl(cnst);
+        }
+        this.sorted = false;
+    }
+    addEntry(start, end, type, name, kind) {
+        if (start >= 0 && end > start) {
+            this.entries.push({ start, end, type, name, kind });
+        }
+    }
+    ensureSorted() {
+        if (!this.sorted) {
+            // sort by start ascending, then by range size ascending (smallest/most specific first for ties)
+            this.entries.sort((a, b) => a.start - b.start || (a.end - a.start) - (b.end - b.start));
+            this.sorted = true;
+        }
+    }
+    typeAtOffset(offset) {
+        this.ensureSorted();
+        // find the most specific (smallest range) entry containing the offset
+        let best = undefined;
+        for (const entry of this.entries) {
+            if (entry.start > offset)
+                break; // sorted by start, so no more matches
+            if (offset >= entry.start && offset < entry.end) {
+                if (!best || (entry.end - entry.start) < (best.end - best.start)) {
+                    best = entry;
+                }
+            }
+        }
+        return best;
+    }
+    allEntries() {
+        this.ensureSorted();
+        return this.entries;
+    }
+    membersOfType(type) {
+        // unwrap aliases
+        while (type instanceof TirAliasType) {
+            const aliasMembers = this.methodsFromMap(type.methodsNamesPtr);
+            if (aliasMembers.length > 0) {
+                // get fields from aliased + methods from alias
+                const innerMembers = this.membersOfType(type.aliased);
+                const fieldMembers = innerMembers.filter(m => m.kind === "field");
+                return [...fieldMembers, ...aliasMembers];
+            }
+            type = type.aliased;
+        }
+        if (type instanceof TirTypeParam)
+            return [];
+        if (isTirStructType(type))
+            return this.structMembers(type);
+        if (type instanceof TirVoidT)
+            return [];
+        if (type instanceof TirBoolT)
+            return [];
+        if (type instanceof TirIntT)
+            return [];
+        if (type instanceof TirBytesT)
+            return this.bytesMembers();
+        if (type instanceof TirStringT)
+            return this.stringMembers();
+        if (type instanceof TirDataT)
+            return [];
+        if (isTirOptType(type))
+            return [];
+        if (type instanceof TirFuncT)
+            return [];
+        if (type instanceof TirListT)
+            return this.listMembers(type.typeArg);
+        if (type instanceof TirLinearMapT)
+            return this.linearMapMembers(type.keyTypeArg, type.valTypeArg);
+        return [];
+    }
+    structMembers(type) {
+        const result = [];
+        // single-constructor structs expose fields directly
+        if (type.constructors.length === 1) {
+            const constr = type.constructors[0];
+            for (const field of constr.fields) {
+                result.push({ name: field.name, type: field.type, kind: "field" });
+            }
+        }
+        // methods
+        result.push(...this.methodsFromMap(type.methodNamesPtr));
+        return result;
+    }
+    methodsFromMap(methodsPtr) {
+        const result = [];
+        for (const [astName, tirName] of methodsPtr) {
+            const funcExpr = this.program.functions.get(tirName);
+            if (!funcExpr)
+                continue;
+            const fullSig = funcExpr.sig();
+            // method sig: drop first arg (self)
+            const methodSig = new TirFuncT(fullSig.argTypes.slice(1), fullSig.returnType);
+            result.push({ name: astName, type: methodSig, kind: "method" });
+        }
+        return result;
+    }
+    listMembers(elemType) {
+        const mapReturnT = new TirTypeParam("T");
+        return [
+            { name: "length", type: new TirFuncT([], int_t), kind: "method" },
+            { name: "isEmpty", type: new TirFuncT([], bool_t), kind: "method" },
+            { name: "show", type: new TirFuncT([], bytes_t), kind: "method" },
+            { name: "head", type: new TirFuncT([], elemType), kind: "method" },
+            { name: "tail", type: new TirFuncT([], new TirListT(elemType)), kind: "method" },
+            { name: "reverse", type: new TirFuncT([], new TirListT(elemType)), kind: "method" },
+            { name: "find", type: new TirFuncT([new TirFuncT([elemType], bool_t)], new TirSopOptT(elemType)), kind: "method" },
+            { name: "filter", type: new TirFuncT([new TirFuncT([elemType], bool_t)], new TirListT(elemType)), kind: "method" },
+            { name: "prepend", type: new TirFuncT([elemType], new TirListT(elemType)), kind: "method" },
+            { name: "map", type: new TirFuncT([new TirFuncT([elemType], mapReturnT)], new TirListT(mapReturnT)), kind: "method" },
+            { name: "every", type: new TirFuncT([new TirFuncT([elemType], bool_t)], bool_t), kind: "method" },
+            { name: "some", type: new TirFuncT([new TirFuncT([elemType], bool_t)], bool_t), kind: "method" },
+            { name: "includes", type: new TirFuncT([elemType], bool_t), kind: "method" },
+        ];
+    }
+    bytesMembers() {
+        return [
+            { name: "length", type: new TirFuncT([], int_t), kind: "method" },
+            { name: "subByteString", type: new TirFuncT([int_t, int_t], bytes_t), kind: "method" },
+            { name: "slice", type: new TirFuncT([int_t, int_t], bytes_t), kind: "method" },
+            { name: "show", type: new TirFuncT([], bytes_t), kind: "method" },
+            { name: "decodeUtf8", type: new TirFuncT([], string_t), kind: "method" },
+            { name: "prepend", type: new TirFuncT([int_t], bytes_t), kind: "method" },
+        ];
+    }
+    stringMembers() {
+        return [
+            ...this.bytesMembers(),
+            { name: "encodeUtf8", type: new TirFuncT([], bytes_t), kind: "method" },
+        ];
+    }
+    linearMapMembers(kT, vT) {
+        return [
+            { name: "lookup", type: new TirFuncT([kT], new TirSopOptT(vT)), kind: "method" },
+        ];
+    }
+    // --- TIR tree walkers ---
+    walkFuncExpr(func) {
+        // skip top-level entry for internal/compiler-generated functions
+        // (names starting with § or other internal prefixes)
+        // their range covers the whole contract body and pollutes typeAtOffset
+        if (!func.name || !func.name.startsWith("§")) {
+            this.addEntry(func.range.start, func.range.end, func.type, func.name);
+        }
+        for (const param of func.params) {
+            this.walkVarDecl(param);
+        }
+        this.walkStmt(func.body);
+    }
+    walkExpr(expr) {
+        if (!expr)
+            return;
+        // all expressions have range and type
+        try {
+            this.addEntry(expr.range.start, expr.range.end, expr.type);
+        }
+        catch { }
+        // recurse into sub-expressions
+        if (expr instanceof TirCallExpr) {
+            this.walkExpr(expr.func);
+            for (const arg of expr.args)
+                this.walkExpr(arg);
+        }
+        else if (expr instanceof TirPropAccessExpr) {
+            this.walkExpr(expr.object);
+        }
+        else if (expr instanceof TirVariableAccessExpr) {
+            // leaf — name is the variable name
+            this.addEntry(expr.range.start, expr.range.end, expr.type, expr.resolvedValue.variableInfos.name);
+        }
+        else if (expr instanceof TirFuncExpr) {
+            this.walkFuncExpr(expr);
+        }
+        else if (expr instanceof TirCaseExpr) {
+            this.walkExpr(expr.matchExpr);
+            for (const c of expr.cases) {
+                if (c.pattern)
+                    this.walkVarDecl(c.pattern);
+                this.walkExpr(c.body);
+            }
+            if (expr.wildcardCase) {
+                this.walkExpr(expr.wildcardCase.body);
+            }
+        }
+        else if (expr instanceof TirElemAccessExpr) {
+            this.walkExpr(expr.arrLikeExpr);
+            this.walkExpr(expr.indexExpr);
+        }
+        else if (expr instanceof TirTernaryExpr) {
+            this.walkExpr(expr.condition);
+            this.walkExpr(expr.ifTrue);
+            this.walkExpr(expr.ifFalse);
+        }
+        else if (expr instanceof TirParentesizedExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirTypeConversionExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirLettedExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirHoistedExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirFromDataExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirToDataExpr) {
+            this.walkExpr(expr.expr);
+        }
+        else if (expr instanceof TirAssertAndContinueExpr) {
+            this.walkExpr(expr.condition);
+            this.walkExpr(expr.continuation);
+        }
+        else if (expr instanceof TirTraceIfFalseExpr) {
+            this.walkExpr(expr.condition);
+            this.walkExpr(expr.traceMsg);
+        }
+        else if (expr instanceof TirTraceExpr) {
+            this.walkExpr(expr.traceMsg);
+            this.walkExpr(expr.continuation);
+        }
+        else if (isTirBinaryExpr(expr)) {
+            this.walkExpr(expr.left);
+            this.walkExpr(expr.right);
+        }
+        else if (isTirUnaryPrefixExpr(expr)) {
+            this.walkExpr(expr.operand);
+        }
+        // TirLitteralExpr, TirNativeFunc, TirFailExpr, TirInlineClosedIR — leaf nodes
+    }
+    walkStmt(stmt) {
+        if (!stmt)
+            return;
+        if (stmt instanceof TirBlockStmt) {
+            for (const s of stmt.stmts)
+                this.walkStmt(s);
+        }
+        else if (stmt instanceof TirIfStmt) {
+            this.walkExpr(stmt.condition);
+            this.walkStmt(stmt.thenBranch);
+            if (stmt.elseBranch)
+                this.walkStmt(stmt.elseBranch);
+        }
+        else if (stmt instanceof TirReturnStmt) {
+            this.walkExpr(stmt.value);
+        }
+        else if (stmt instanceof TirAssertStmt) {
+            this.walkExpr(stmt.condition);
+            if (stmt.elseExpr)
+                this.walkExpr(stmt.elseExpr);
+        }
+        else if (stmt instanceof TirForStmt) {
+            for (const v of stmt.init)
+                this.walkVarDecl(v);
+            if (stmt.condition)
+                this.walkExpr(stmt.condition);
+            if (stmt.update)
+                for (const s of stmt.update)
+                    this.walkStmt(s);
+            this.walkStmt(stmt.body);
+        }
+        else if (stmt instanceof TirForOfStmt) {
+            this.walkVarDecl(stmt.elemDeclaration);
+            this.walkExpr(stmt.iterable);
+            this.walkStmt(stmt.body);
+        }
+        else if (stmt instanceof TirWhileStmt) {
+            this.walkExpr(stmt.condition);
+            this.walkStmt(stmt.body);
+        }
+        else if (stmt instanceof TirMatchStmt) {
+            this.walkExpr(stmt.matchExpr);
+            for (const c of stmt.cases) {
+                this.walkVarDecl(c.pattern);
+                this.walkStmt(c.body);
+            }
+            if (stmt.wildcardCase)
+                this.walkStmt(stmt.wildcardCase.body);
+        }
+        else if (stmt instanceof TirAssignmentStmt) {
+            this.walkExpr(stmt.varIdentifier);
+            this.walkExpr(stmt.assignedExpr);
+        }
+        else if (stmt instanceof TirTraceStmt) {
+            this.walkExpr(stmt.expr);
+        }
+        else if (stmt instanceof TirSimpleVarDecl) {
+            this.walkVarDecl(stmt);
+        }
+        else if (stmt instanceof TirNamedDeconstructVarDecl) {
+            this.walkVarDecl(stmt);
+        }
+        else if (stmt instanceof TirSingleDeconstructVarDecl) {
+            this.walkVarDecl(stmt);
+        }
+        else if (stmt instanceof TirArrayLikeDeconstr) {
+            this.walkVarDecl(stmt);
+        }
+        // TirBreakStmt, TirContinueStmt, TirFailStmt — no sub-expressions to walk
+    }
+    walkVarDecl(decl, isDeconstructField = false) {
+        if (decl instanceof TirSimpleVarDecl) {
+            // skip full-range entry for deconstruct fields — their parent's fieldLabelRanges provides correct tight-range entries
+            if (!isDeconstructField) {
+                // internal-named params (§-prefixed) use sourceName if available
+                const displayName = decl.sourceName ?? (isInternalName(decl.name) ? undefined : decl.name);
+                if (displayName !== undefined) {
+                    this.addEntry(decl.range.start, decl.range.end, decl.type, displayName);
+                }
+            }
+            // add entry for explicit type annotation as a type reference
+            if (decl.typeAnnotationRange) {
+                this.addEntry(decl.typeAnnotationRange.start, decl.typeAnnotationRange.end, decl.type, undefined, "type-reference");
+            }
+            if (decl.initExpr)
+                this.walkExpr(decl.initExpr);
+        }
+        else if (decl instanceof TirNamedDeconstructVarDecl) {
+            // add entry for the constructor name as a type reference (for LSP coloring)
+            if (decl.constrNameRange) {
+                this.addEntry(decl.constrNameRange.start, decl.constrNameRange.end, decl.type, decl.constrName, "type-reference");
+            }
+            // add entry for explicit type annotation as a type reference
+            if (decl.typeAnnotationRange) {
+                this.addEntry(decl.typeAnnotationRange.start, decl.typeAnnotationRange.end, decl.type, undefined, "type-reference");
+            }
+            // add entries for field labels (hovering field name shows the field's type from the constructor definition)
+            if (decl.fieldLabelRanges) {
+                for (const [fieldName, labelInfo] of decl.fieldLabelRanges) {
+                    this.addEntry(labelInfo.range.start, labelInfo.range.end, labelInfo.type, fieldName);
+                }
+            }
+            if (decl.initExpr)
+                this.walkExpr(decl.initExpr);
+            for (const field of decl.fields.values()) {
+                this.walkVarDecl(field, true);
+            }
+        }
+        else if (decl instanceof TirSingleDeconstructVarDecl) {
+            // add entry for explicit type annotation as a type reference
+            if (decl.typeAnnotationRange) {
+                this.addEntry(decl.typeAnnotationRange.start, decl.typeAnnotationRange.end, decl.type, undefined, "type-reference");
+            }
+            // add entries for field labels (hovering field name shows the field's type from the constructor definition)
+            if (decl.fieldLabelRanges) {
+                for (const [fieldName, labelInfo] of decl.fieldLabelRanges) {
+                    this.addEntry(labelInfo.range.start, labelInfo.range.end, labelInfo.type, fieldName);
+                }
+            }
+            if (decl.initExpr)
+                this.walkExpr(decl.initExpr);
+            for (const field of decl.fields.values()) {
+                this.walkVarDecl(field, true);
+            }
+        }
+        else if (decl instanceof TirArrayLikeDeconstr) {
+            this.addEntry(decl.range.start, decl.range.end, decl.type);
+            if (decl.initExpr)
+                this.walkExpr(decl.initExpr);
+            for (const elem of decl.elements) {
+                this.walkVarDecl(elem);
+            }
+        }
+    }
+}