@harmoniclabs/pebble 0.1.3-dev3 → 0.1.3-dev6

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.d.ts

@@ -11,7 +11,11 @@ export declare class SimpleVarDecl implements HasSourceRange, HasInitExpr {
     initExpr: PebbleExpr | undefined;
     flags: CommonFlags;
     readonly range: SourceRange;
-    constructor(name: Identifier, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);
+    /** original source name when the identifier was renamed internally (for LSP) */
+    readonly sourceName?: string | undefined;
+    constructor(name: Identifier, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange, 
+    /** original source name when the identifier was renamed internally (for LSP) */
+    sourceName?: string | undefined);
     isConst(): boolean;
     static onlyIdentifier(identifier: Identifier, flags: CommonFlags): SimpleVarDecl;
     static onlyNameConst(name: string, range: SourceRange): SimpleVarDecl;

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js

@@ -6,12 +6,16 @@ export class SimpleVarDecl {
     initExpr;
     flags;
     range;
-    constructor(name, type, initExpr, flags, range) {
+    sourceName;
+    constructor(name, type, initExpr, flags, range, 
+    /** original source name when the identifier was renamed internally (for LSP) */
+    sourceName) {
         this.name = name;
         this.type = type;
         this.initExpr = initExpr;
         this.flags = flags;
         this.range = range;
+        this.sourceName = sourceName;
     }
     isConst() {
         return (this.flags & CommonFlags.Const) !== 0;

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

@@ -9,6 +9,7 @@ import { AstFuncName, AstScope, TirFuncName } from "./scope/AstScope.js";
 import { TypedProgram } from "../tir/program/TypedProgram.js";
 import { ResolveStackNode } from "./utils/deps/ResolveStackNode.js";
 import { TirType } from "../tir/types/TirType.js";
+import { CheckResult } from "../SourceTypeMap.js";
 export interface AstTypeDefCompilationResult {
     sop: TirType | undefined;
     data: TirType | undefined;
@@ -54,6 +55,20 @@ export declare class AstCompiler extends DiagnosticEmitter {
      * inside a function body.
      */
     run(): Promise<TypedProgram>;
+    /**
+     * like `run()` but omits the return type annotation on the wrapping function
+     * and turns the last non-declaration statement into a `return` expression,
+     * allowing the type to be inferred from the expression.
+     */
+    runRepl(): Promise<TypedProgram>;
+    /**
+     * runs the frontend only (parsing + semantic analysis + type checking)
+     * without requiring a contract and without throwing on diagnostics.
+     *
+     * returns `CheckResult` with diagnostics, the typed program,
+     * and a `SourceTypeMap` for querying types at source positions.
+     */
+    check(): Promise<CheckResult>;
     /**
      * compiles the entry file specified in the config
      *

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -35,6 +35,7 @@ import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContr
 import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
 import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
 import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
+import { SourceTypeMap } from "../SourceTypeMap.js";
 import { isIdentifier } from "../../utils/text.js";
 /*
 Handling type expressions that depend on other types
@@ -85,6 +86,12 @@ export class AstCompiler extends DiagnosticEmitter {
         this.cfg = cfg;
         this.io = io;
         this.program = new TypedProgram(this.diagnostics);
+        // normalize entry to absolute path so import resolution works correctly
+        if (typeof cfg.entry === "string" && typeof cfg.root === "string") {
+            const resolved = getEnvRelativePath(cfg.entry, cfg.root);
+            if (resolved)
+                cfg.entry = resolved;
+        }
         this._isExporting = false;
     }
     _isExporting;
@@ -115,9 +122,6 @@ export class AstCompiler extends DiagnosticEmitter {
      * inside a function body.
      */
     async run() {
-        const RUN_FUNC_NAME = "__pebble_run__";
-        this._isExporting = true;
-        this.program.contractTirFuncName = RUN_FUNC_NAME;
         const filePath = this.cfg.entry;
         if (!filePath) {
             this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
@@ -128,21 +132,86 @@ export class AstCompiler extends DiagnosticEmitter {
         const src = await this.getAbsoulteProjPathSource(filePath);
         if (!src)
             throw new Error("AstCompiler.run: could not read source: " + filePath);
+        const funcName = _uniqueFuncName("__pebble_run__", src.text);
+        this._isExporting = true;
+        this.program.contractTirFuncName = funcName;
         // 1) Rewrite the source text: wrap non-declaration statements in a function
-        src.text = _wrapSourceTextForRun(src.text, RUN_FUNC_NAME);
+        src.text = _wrapSourceTextForRun(src.text, funcName);
         // update range to match the new text length
         src.range.end = src.text.length;
         // 2) Use the normal compilation pipeline (parse + semantic analysis)
         //    which now sees the entry source as having a top-level function
         return await this.compile();
     }
+    /**
+     * like `run()` but omits the return type annotation on the wrapping function
+     * and turns the last non-declaration statement into a `return` expression,
+     * allowing the type to be inferred from the expression.
+     */
+    async runRepl() {
+        const filePath = this.cfg.entry;
+        if (!filePath) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
+            throw new Error("entry file not found");
+        }
+        if (!this.io.exsistSync(filePath))
+            throw new Error("AstCompiler.runRepl: entry file does not exist: " + filePath);
+        const src = await this.getAbsoulteProjPathSource(filePath);
+        if (!src)
+            throw new Error("AstCompiler.runRepl: could not read source: " + filePath);
+        const funcName = _uniqueFuncName("__pebble_repl__", src.text);
+        this._isExporting = true;
+        this.program.contractTirFuncName = funcName;
+        // 1) Rewrite the source text: wrap non-declaration statements in a function
+        //    with no return type annotation, and turn the last statement into a return
+        src.text = _wrapSourceTextForRepl(src.text, funcName);
+        // update range to match the new text length
+        src.range.end = src.text.length;
+        // 2) Use the normal compilation pipeline (parse + semantic analysis)
+        return await this.compile();
+    }
+    /**
+     * runs the frontend only (parsing + semantic analysis + type checking)
+     * without requiring a contract and without throwing on diagnostics.
+     *
+     * returns `CheckResult` with diagnostics, the typed program,
+     * and a `SourceTypeMap` for querying types at source positions.
+     */
+    async check() {
+        const filePath = this.cfg.entry;
+        if (!filePath) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
+            return {
+                diagnostics: this.diagnostics.slice(),
+                program: this.program,
+                sourceTypeMap: new SourceTypeMap(this.program)
+            };
+        }
+        if (!this.io.exsistSync(filePath)) {
+            this.error(DiagnosticCode.File_0_not_found, undefined, filePath);
+            return {
+                diagnostics: this.diagnostics.slice(),
+                program: this.program,
+                sourceTypeMap: new SourceTypeMap(this.program)
+            };
+        }
+        await this.compileFile(filePath, true);
+        // no contract check, no throw — just collect diagnostics
+        const typeMap = new SourceTypeMap(this.program);
+        typeMap.buildFromProgram();
+        return {
+            diagnostics: this.diagnostics.slice(),
+            program: this.program,
+            sourceTypeMap: typeMap
+        };
+    }
     /**
      * compiles the entry file specified in the config
      *
      * the result is store in `this.program`
      */
     async compile() {
-        const filePath = this.cfg.entry; // getEnvRelativePath( this.cfg.entry, this.rootPath );
+        const filePath = this.cfg.entry;
         if (!filePath) {
             this.error(DiagnosticCode.File_0_not_found, undefined, this.cfg.entry);
             throw new Error("entry file not found");
@@ -154,14 +223,15 @@ export class AstCompiler extends DiagnosticEmitter {
             let msg;
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
-            while (msg = this.diagnostics.shift()) {
-                /*
-                this.io.stdout.write( msg.toString() + "\n" );
+            for (msg of this.diagnostics) {
+                //*
+                this.io.stdout.write(msg.toString() + "\n");
                 /*/
-                console.log(msg);
-                console.log(msg.toString());
+                console.log( msg );
+                console.log( msg.toString() );
                 //*/
             }
+            // return this.program;
             throw new Error("AstCompiler.compile: failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
         }
         const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
@@ -690,7 +760,8 @@ export class AstCompiler extends DiagnosticEmitter {
             const internalName = getUniqueInternalName(param.name.text);
             paramsInternalNamesMap.set(astName, internalName);
             funcParams[i] = new SimpleVarDecl(new Identifier(internalName, param.name.range), astType, undefined, // initExpr
-            CommonFlags.Const, param.range);
+            CommonFlags.Const, param.range, astName // original source name for LSP
+            );
         }
         const scriptContextName = getUniqueInternalName("ctx");
         funcParams[contractDecl.params.length] = new SimpleVarDecl(new Identifier(scriptContextName, contractDecl.name.range), new AstNamedTypeExpr(new Identifier("ScriptContext", contractDecl.name.range), [], contractDecl.name.range), undefined, // initExpr
@@ -721,6 +792,18 @@ const _declKeywords = new Set([
     "data",
     "runtime",
 ]);
+/**
+ * Returns a function name that does not appear in the source text.
+ * Starts with `baseName` and appends an incrementing suffix if needed.
+ */
+function _uniqueFuncName(baseName, sourceText) {
+    let name = baseName;
+    let i = 0;
+    while (sourceText.includes(name)) {
+        name = baseName + "_" + (i++);
+    }
+    return name;
+}
 /**
  * Splits source text into declaration blocks and body blocks
  * using a simple character scanner, then wraps body blocks
@@ -842,6 +925,145 @@ function _wrapSourceTextForRun(text, funcName) {
         bodyParts.join("\n") + "\n" +
         "}\n");
 }
+/**
+ * Like `_wrapSourceTextForRun` but:
+ * - omits the return type annotation (no `: void`)
+ * - turns the last non-declaration statement into a `return` expression
+ *
+ * This allows the compiler to infer the return type from the expression,
+ * used by the REPL to evaluate and return expression values.
+ */
+function _wrapSourceTextForRepl(text, funcName) {
+    const len = text.length;
+    const ranges = [];
+    let pos = 0;
+    while (pos < len) {
+        // skip whitespace
+        while (pos < len && _isWhitespace(text.charCodeAt(pos)))
+            pos++;
+        if (pos >= len)
+            break;
+        const stmtStart = pos;
+        // read the first word to determine if this is a declaration
+        const word = _readWord(text, pos);
+        const isDecl = _declKeywords.has(word);
+        // find the end of this statement:
+        // track brace/paren depth, respect strings and comments
+        let braceDepth = 0;
+        let parenDepth = 0;
+        let ended = false;
+        while (pos < len && !ended) {
+            const ch = text.charCodeAt(pos);
+            // single-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F /* / */) {
+                pos += 2;
+                while (pos < len && text.charCodeAt(pos) !== 0x0A /* \n */)
+                    pos++;
+                continue;
+            }
+            // multi-line comment
+            if (ch === 0x2F /* / */ && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2A /* * */) {
+                pos += 2;
+                while (pos < len && !(text.charCodeAt(pos) === 0x2A && pos + 1 < len && text.charCodeAt(pos + 1) === 0x2F))
+                    pos++;
+                pos += 2; // skip */
+                continue;
+            }
+            // string literals
+            if (ch === 0x22 /* " */ || ch === 0x27 /* ' */ || ch === 0x60 /* ` */) {
+                pos++;
+                while (pos < len) {
+                    const sc = text.charCodeAt(pos);
+                    if (sc === 0x5C /* \ */) {
+                        pos += 2;
+                        continue;
+                    } // escaped char
+                    if (sc === ch) {
+                        pos++;
+                        break;
+                    }
+                    pos++;
+                }
+                continue;
+            }
+            if (ch === 0x28 /* ( */) {
+                parenDepth++;
+                pos++;
+            }
+            else if (ch === 0x29 /* ) */) {
+                parenDepth--;
+                pos++;
+            }
+            else if (ch === 0x7B /* { */) {
+                braceDepth++;
+                pos++;
+            }
+            else if (ch === 0x7D /* } */) {
+                braceDepth--;
+                pos++;
+                if (braceDepth <= 0 && parenDepth <= 0) {
+                    // consume optional trailing semicolon
+                    let p2 = pos;
+                    while (p2 < len && _isWhitespace(text.charCodeAt(p2)))
+                        p2++;
+                    if (p2 < len && text.charCodeAt(p2) === 0x3B /* ; */)
+                        pos = p2 + 1;
+                    ended = true;
+                }
+            }
+            else if (ch === 0x3B /* ; */ && braceDepth === 0 && parenDepth === 0) {
+                pos++;
+                ended = true;
+            }
+            else {
+                pos++;
+            }
+        }
+        const stmtEnd = pos;
+        // skip empty ranges
+        if (stmtEnd > stmtStart) {
+            ranges.push({ start: stmtStart, end: stmtEnd, isDecl });
+        }
+    }
+    // If there are no body ranges, nothing to wrap
+    if (ranges.every(r => r.isDecl)) {
+        return text;
+    }
+    // Build the new source text
+    const declarations = [];
+    const bodyParts = [];
+    for (const r of ranges) {
+        const slice = text.substring(r.start, r.end);
+        if (r.isDecl)
+            declarations.push(slice);
+        else
+            bodyParts.push(slice);
+    }
+    // turn the last body part into a return statement
+    // (if it isn't already one and doesn't start with a statement keyword)
+    if (bodyParts.length > 0) {
+        let last = bodyParts[bodyParts.length - 1].trim();
+        // remove trailing semicolon for wrapping
+        if (last.endsWith(";"))
+            last = last.slice(0, -1).trim();
+        const firstWord = last.match(/^([a-zA-Z_]\w*)/);
+        const isStmtKeyword = firstWord && _stmtKeywords.has(firstWord[1]);
+        if (!isStmtKeyword && !last.startsWith("return")) {
+            bodyParts[bodyParts.length - 1] = "return " + last + ";";
+        }
+    }
+    return (declarations.join("\n") +
+        (declarations.length > 0 ? "\n" : "") +
+        "function " + funcName + "() {\n" +
+        bodyParts.join("\n") + "\n" +
+        "}\n");
+}
+const _stmtKeywords = new Set([
+    "let", "var", "const", "using",
+    "if", "for", "while", "match",
+    "return", "break", "continue",
+    "trace", "assert", "fail", "test",
+]);
 function _isWhitespace(ch) {
     return ch === 0x20 || ch === 0x09 || ch === 0x0A || ch === 0x0D;
 }

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

@@ -44,6 +44,7 @@ import { TraceStmt } from "../../../../ast/nodes/statements/TraceStmt.js";
 import { 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";
 import { CommonFlags } from "../../../../common.js";
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
 import { getUniqueInternalName } from "../../../internalVar.js";
@@ -89,6 +90,9 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
     // 
     // so we only have 3 statements in the body
     const bodyStmts = [];
+    // generated identifiers/declarations use mock ranges so they don't
+    // produce SourceTypeMap entries (which would span the entire contract)
+    const mockRange = SourceRange.mock;
     const txUniqueName = getUniqueInternalName("tx");
     const purposeUniqueName = getUniqueInternalName("purpose");
     const redeemerUniqueName = getUniqueInternalName("redeemer");
@@ -96,20 +100,20 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         // fields
         new Map([
             [
-                new Identifier("tx", contractRange),
-                SimpleVarDecl.onlyNameConst(txUniqueName, contractRange)
+                new Identifier("tx", mockRange),
+                SimpleVarDecl.onlyNameConst(txUniqueName, mockRange)
             ],
             [
-                new Identifier("purpose", contractRange),
-                SimpleVarDecl.onlyNameConst(purposeUniqueName, contractRange)
+                new Identifier("purpose", mockRange),
+                SimpleVarDecl.onlyNameConst(purposeUniqueName, mockRange)
             ],
             [
-                new Identifier("redeemer", contractRange),
-                SimpleVarDecl.onlyNameConst(redeemerUniqueName, contractRange)
+                new Identifier("redeemer", mockRange),
+                SimpleVarDecl.onlyNameConst(redeemerUniqueName, mockRange)
             ],
         ]), undefined, // rest
         undefined, // type (inferred from initExpr)
-        new Identifier(scriptContextName, contractRange), // initExpr
+        new Identifier(scriptContextName, mockRange), // initExpr
         CommonFlags.Const, contractRange)], contractRange));
     /*
     const { data: scriptInfo_t } = defineMultiConstructorStruct(
@@ -144,12 +148,12 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const optionalDatumUniqueName = getUniqueInternalName("optionalDatum");
         const fields = new Map([
             [
-                new Identifier("ref", contractRange),
-                SimpleVarDecl.onlyNameConst(spendingRefUniqueName, contractRange)
+                new Identifier("ref", mockRange),
+                SimpleVarDecl.onlyNameConst(spendingRefUniqueName, mockRange)
             ],
             [
-                new Identifier("optionalDatum", contractRange),
-                SimpleVarDecl.onlyNameConst(optionalDatumUniqueName, contractRange)
+                new Identifier("optionalDatum", mockRange),
+                SimpleVarDecl.onlyNameConst(optionalDatumUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.spendMethods, paramsInternalNamesMap, 
@@ -163,7 +167,7 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "SpendRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Spend", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Spend", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
@@ -172,8 +176,8 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const policyUniqueName = getUniqueInternalName("policy");
         const fields = new Map([
             [
-                new Identifier("policy", contractRange),
-                SimpleVarDecl.onlyNameConst(policyUniqueName, contractRange)
+                new Identifier("policy", mockRange),
+                SimpleVarDecl.onlyNameConst(policyUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.mintMethods, paramsInternalNamesMap, 
@@ -186,7 +190,7 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "MintRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Mint", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Mint", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
@@ -195,8 +199,8 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const credentialUniqueName = getUniqueInternalName("credential");
         const fields = new Map([
             [
-                new Identifier("credential", contractRange),
-                SimpleVarDecl.onlyNameConst(credentialUniqueName, contractRange)
+                new Identifier("credential", mockRange),
+                SimpleVarDecl.onlyNameConst(credentialUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.withdrawMethods, paramsInternalNamesMap, 
@@ -209,7 +213,7 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "WithdrawRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Withdraw", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Withdraw", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
@@ -219,12 +223,12 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const certificateUniqueName = getUniqueInternalName("certificate");
         const fields = new Map([
             [
-                new Identifier("certificateIndex", contractRange),
-                SimpleVarDecl.onlyNameConst(indexUniqueName, contractRange)
+                new Identifier("certificateIndex", mockRange),
+                SimpleVarDecl.onlyNameConst(indexUniqueName, mockRange)
             ],
             [
-                new Identifier("certificate", contractRange),
-                SimpleVarDecl.onlyNameConst(certificateUniqueName, contractRange)
+                new Identifier("certificate", mockRange),
+                SimpleVarDecl.onlyNameConst(certificateUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.certifyMethods, paramsInternalNamesMap, 
@@ -238,7 +242,7 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "CertifyRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Certificate", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Certificate", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
@@ -248,12 +252,12 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const proposalUniqueName = getUniqueInternalName("proposal");
         const fields = new Map([
             [
-                new Identifier("proposalIndex", contractRange),
-                SimpleVarDecl.onlyNameConst(indexUniqueName, contractRange)
+                new Identifier("proposalIndex", mockRange),
+                SimpleVarDecl.onlyNameConst(indexUniqueName, mockRange)
             ],
             [
-                new Identifier("proposal", contractRange),
-                SimpleVarDecl.onlyNameConst(proposalUniqueName, contractRange)
+                new Identifier("proposal", mockRange),
+                SimpleVarDecl.onlyNameConst(proposalUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.proposeMethods, paramsInternalNamesMap, 
@@ -267,7 +271,7 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "ProposeRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Propose", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Propose", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
@@ -276,8 +280,8 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         const voterUniqueName = getUniqueInternalName("voter");
         const fields = new Map([
             [
-                new Identifier("voter", contractRange),
-                SimpleVarDecl.onlyNameConst(voterUniqueName, contractRange)
+                new Identifier("voter", mockRange),
+                SimpleVarDecl.onlyNameConst(voterUniqueName, mockRange)
             ],
         ]);
         const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.voteMethods, paramsInternalNamesMap, 
@@ -290,12 +294,12 @@ export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesM
         }), "VoteRedeemer", contractRange);
         if (!Array.isArray(bodyStmts))
             return undefined;
-        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Vote", contractRange), fields, undefined, // rest
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Vote", mockRange), fields, undefined, // rest
         undefined, // type (inferred from initExpr)
         undefined, // initExpr
         CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
     }
-    bodyStmts.push(new MatchStmt(new Identifier(purposeUniqueName, contractRange), purposeMatchCases, new MatchStmtElseCase(new FailStmt(undefined, contractRange), contractRange), contractRange));
+    bodyStmts.push(new MatchStmt(new Identifier(purposeUniqueName, mockRange), purposeMatchCases, new MatchStmtElseCase(new FailStmt(undefined, contractRange), contractRange), contractRange));
     bodyStmts.push(new FailStmt(undefined, contractRange)); // unreachable in theory (else case)
     return new BlockStmt(bodyStmts, contractRange);
 }
@@ -336,8 +340,9 @@ function _getMatchedPurposeBlockStatements(compiler, methods, paramsInternalName
         CommonFlags.Const, method.expr.name.range), new BlockStmt(stmts, contractRange), method.expr.range));
     }
     return [
-        new MatchStmt(new TypeConversionExpr(new Identifier(contextVarsMapping.redeemerData, contractRange), new AstNamedTypeExpr(new Identifier(redeemerTypeDef.name.text, contractRange), [], // typeArgs
-        contractRange)), redeemerMatchCases, new MatchStmtElseCase(new FailStmt(undefined, contractRange), contractRange), contractRange),
+        new MatchStmt(new TypeConversionExpr(new Identifier(contextVarsMapping.redeemerData, SourceRange.mock), new AstNamedTypeExpr(new Identifier(redeemerTypeDef.name.text, SourceRange.mock), [], // typeArgs
+        contractRange), SourceRange.mock // mock range: generated expression should not appear in SourceTypeMap
+        ), redeemerMatchCases, new MatchStmtElseCase(new FailStmt(undefined, contractRange), contractRange), contractRange),
         new FailStmt(undefined, contractRange) // unreachable in theory (else case)
     ];
 }
@@ -759,7 +764,7 @@ function _deriveRedeemerTypeDef(redeemerName, methods, contractRange) {
     if (methods.length <= 1)
         defFlags |= StructDeclAstFlags.untaggedSingleConstructor;
     const uniqueName = getUniqueInternalName(redeemerName);
-    return new StructDecl(new Identifier(uniqueName, contractRange), [], // typeParams
+    return new StructDecl(new Identifier(uniqueName, SourceRange.mock), [], // typeParams
     methods.map(m => {
         const methodParams = m.expr.signature.params;
         if (!methodParams.every(p => p instanceof SimpleVarDecl && !p.initExpr && p.type))

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

@@ -23,7 +23,11 @@ export declare function _compileSingleDeconstructVarDecl(ctx: AstCompilationCtx,
 export declare function _compileArrayLikeDeconstr(ctx: AstCompilationCtx, decl: ArrayLikeDeconstr, typeHint: TirType | undefined): TirArrayLikeDeconstr | undefined;
 export declare function _getDeconstructedFields(ctx: AstCompilationCtx, astDeconstruct: ISingleDeconstructVarDecl, ctorDef: TirStructConstr): [
     fields: Map<string, TirVarDecl>,
-    rest: string | undefined
+    rest: string | undefined,
+    fieldLabelRanges: Map<string, {
+        range: SourceRange;
+        type: TirType;
+    }>
 ] | undefined;
 export declare function _getVarDeclTypeAndExpr(ctx: AstCompilationCtx, decl: {
     type: AstTypeExpr | undefined;
@@ -31,5 +35,6 @@ export declare function _getVarDeclTypeAndExpr(ctx: AstCompilationCtx, decl: {
     range: SourceRange;
 }, deconstructTypeHint: TirType | undefined): [
     varType: TirType,
-    varInitExpr: TirExpr | undefined
+    varInitExpr: TirExpr | undefined,
+    typeAnnotationRange: SourceRange | undefined
 ] | undefined;