@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/compiler/AstCompiler/utils/deps/ResolveStackNode.d.ts

@@ -0,0 +1,14 @@
+import { Source } from "../../../../ast/Source/Source.js";
+export declare class ResolveStackNode {
+    readonly parent: ResolveStackNode | undefined;
+    readonly dependent: Source;
+    constructor(parent: ResolveStackNode | undefined, dependent: Source);
+    static entry(dependent: Source): ResolveStackNode;
+    getNext(dependent: Source): ResolveStackNode;
+    includesInternalPath(path: string): boolean;
+    /**
+     *
+     * @returns an array of paths from the last path to the first.
+     */
+    toArray(): string[];
+}

package/dist/compiler/AstCompiler/utils/deps/ResolveStackNode.js

@@ -0,0 +1,36 @@
+export class ResolveStackNode {
+    parent;
+    dependent;
+    constructor(parent, dependent) {
+        this.parent = parent;
+        this.dependent = dependent;
+    }
+    static entry(dependent) {
+        return new ResolveStackNode(undefined, dependent);
+    }
+    getNext(dependent) {
+        return new ResolveStackNode(this, dependent);
+    }
+    includesInternalPath(path) {
+        let req = this;
+        while (req) {
+            if (req.dependent.absoluteProjPath === path)
+                return true;
+            req = req.parent;
+        }
+        return false;
+    }
+    /**
+     *
+     * @returns an array of paths from the last path to the first.
+     */
+    toArray() {
+        const arr = [];
+        let req = this;
+        while (req) {
+            arr.push(req.dependent.absoluteProjPath);
+            req = req.parent;
+        }
+        return arr;
+    }
+}

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

@@ -0,0 +1,4 @@
+import { Identifier } from "../../../ast/nodes/common/Identifier.js";
+import { TirType } from "../../tir/types/TirType.js";
+import { AstCompilationCtx } from "../AstCompilationCtx.js";
+export declare function getPropAccessReturnType(ctx: AstCompilationCtx, objType: TirType, propId: Identifier): TirType | undefined;

package/dist/compiler/AstCompiler/utils/getPropAccessReturnType.js

@@ -0,0 +1,121 @@
+import { TirAliasType } from "../../tir/types/TirAliasType.js";
+import { isTirStructType } from "../../tir/types/TirStructType.js";
+import { TirTypeParam } from "../../tir/types/TirTypeParam.js";
+import { int_t, bytes_t, bool_t, string_t } from "../../tir/program/stdScope/stdScope.js";
+import { TirUnConstrDataResultT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
+import { TirBoolT } from "../../tir/types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../../tir/types/TirNativeType/native/data.js";
+import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
+import { TirIntT } from "../../tir/types/TirNativeType/native/int.js";
+import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../../tir/types/TirNativeType/native/list.js";
+import { isTirOptType } from "../../tir/types/TirNativeType/native/Optional/isTirOptType.js";
+import { TirSopOptT } from "../../tir/types/TirNativeType/native/Optional/sop.js";
+import { TirStringT } from "../../tir/types/TirNativeType/native/string.js";
+import { TirVoidT } from "../../tir/types/TirNativeType/native/void.js";
+export function getPropAccessReturnType(ctx, objType, propId) {
+    const propName = propId.text;
+    while (objType instanceof TirAliasType
+        || objType instanceof TirTypeParam) {
+        if (objType instanceof TirTypeParam)
+            return undefined;
+        const result = findPropInImpls(ctx, objType.methodsNamesPtr, propName);
+        if (result)
+            return result;
+        objType = objType.aliased;
+    }
+    // if( objType instanceof TirAliasType ) return findPropInImpls( objType.impls, propName ) ?? getPropAccessReturnType( objType.aliased, propId );
+    if (isTirStructType(objType))
+        return getStructPropAccessReturnType(ctx, objType, propName);
+    if (objType instanceof TirVoidT)
+        return undefined;
+    if (objType instanceof TirBoolT)
+        return undefined;
+    if (objType instanceof TirIntT)
+        return undefined;
+    if (objType instanceof TirBytesT)
+        return bytesMethods[propName];
+    if (objType instanceof TirStringT)
+        return bytesMethods[propName];
+    if (objType instanceof TirDataT)
+        return undefined;
+    if (isTirOptType(objType))
+        return undefined;
+    if (objType instanceof TirFuncT)
+        return undefined;
+    if (objType instanceof TirListT)
+        return getListMethods(objType.typeArg)[propName];
+    if (objType instanceof TirLinearMapT)
+        return getLinearMapMethods(objType.keyTypeArg, objType.valTypeArg)[propName];
+    if (objType instanceof TirUnConstrDataResultT)
+        return undefined;
+    if (objType instanceof TirPairDataT)
+        return undefined;
+    const tsEnsureExhaustiveCheck = objType;
+    console.error(objType);
+    throw new Error("unreachable::getPropAccessReturnType");
+}
+function getListMethods(elemsType) {
+    const mapReturnT = new TirTypeParam("T");
+    return {
+        length: new TirFuncT([], int_t),
+        show: new TirFuncT([], bytes_t),
+        head: new TirFuncT([], elemsType),
+        tail: new TirFuncT([], new TirListT(elemsType)),
+        reverse: new TirFuncT([], new TirListT(elemsType)),
+        find: new TirFuncT([
+            new TirFuncT([elemsType], bool_t)
+        ], new TirSopOptT(elemsType)),
+        filter: new TirFuncT([
+            new TirFuncT([elemsType], bool_t)
+        ], new TirListT(elemsType)),
+        prepend: new TirFuncT([elemsType], new TirListT(elemsType)),
+        map: new TirFuncT([
+            new TirFuncT([elemsType], mapReturnT)
+        ], new TirListT(mapReturnT)),
+        every: new TirFuncT([
+            new TirFuncT([elemsType], bool_t)
+        ], bool_t),
+        some: new TirFuncT([
+            new TirFuncT([elemsType], bool_t)
+        ], bool_t)
+    };
+}
+function getLinearMapMethods(kT, vT) {
+    return {
+        // ...getListMethods( /* to add when adding support for pairs */ ),
+        lookup: new TirFuncT([kT], new TirSopOptT(vT))
+    };
+}
+const bytesMethods = Object.freeze({
+    length: new TirFuncT([], int_t),
+    subByteString: new TirFuncT([int_t, int_t], bytes_t),
+    slice: new TirFuncT([int_t, int_t], bytes_t),
+    show: new TirFuncT([], bytes_t),
+    decodeUtf8: new TirFuncT([], string_t),
+    prepend: new TirFuncT([int_t], bytes_t),
+});
+const stringMethods = Object.freeze({
+    encodeUtf8: new TirFuncT([], bytes_t),
+});
+function getStructPropAccessReturnType(ctx, structType, propName) {
+    if (structType.constructors.length === 1) {
+        const constr = structType.constructors[0];
+        const field = constr.fields.find(f => f.name === propName);
+        if (field)
+            return field.type;
+    }
+    return findPropInImpls(ctx, structType.methodNamesPtr, propName);
+}
+function findPropInImpls(ctx, methodsNamesPtr, propName) {
+    const tirFuncName = methodsNamesPtr.get(propName);
+    if (!tirFuncName)
+        return undefined;
+    const funcInfos = ctx.program.functions.get(tirFuncName);
+    if (!funcInfos)
+        return undefined;
+    const fullSig = funcInfos.sig();
+    const methodSig = new TirFuncT(fullSig.argTypes.slice(1), fullSig.returnType);
+    return methodSig;
+}

package/dist/compiler/AstCompiler/utils/getTirFuncSigTree/TirFuncSigTree.d.ts

@@ -0,0 +1,39 @@
+import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
+import { TirType } from "../../../tir/types/TirType.js";
+/** each branch is an overload */
+export type TirFuncSigTreeElem = TirFuncSigTreeNode | TirFuncSigTreeLeaf;
+/** each branch is an overload */
+export type TirFuncSigTree = TirFuncSigTreeRoot | TirFuncSigTreeElem;
+export declare function isTirFuncSigTree(node: any): node is TirFuncSigTree;
+export declare class TirFuncSigTreeRoot {
+    readonly children: TirFuncSigTreeElem[];
+    constructor(children: TirFuncSigTreeElem[]);
+    isLeaf(): this is TirFuncSigTreeLeaf;
+    toArrays(): TirType[][];
+    forgetChachedArrays(): void;
+    sigs(): TirFuncT[];
+    sopSig(): TirFuncT;
+    sopTypes(): TirType[];
+}
+export declare class TirFuncSigTreeNode {
+    readonly type: TirType;
+    readonly children: TirFuncSigTreeElem[];
+    constructor(type: TirType, children: TirFuncSigTreeElem[]);
+    isLeaf(): this is TirFuncSigTreeLeaf;
+    private _arrays;
+    toArrays(): TirType[][];
+    forgetChachedArrays(): void;
+    sopTypes(): TirType[];
+    private _isSop;
+    isSopNode(): boolean;
+}
+export declare class TirFuncSigTreeLeaf {
+    readonly type: TirType;
+    constructor(type: TirType);
+    isLeaf(): this is TirFuncSigTreeLeaf;
+    toArrays(): TirType[][];
+    forgetChachedArrays(): void;
+    sopTypes(): TirType[];
+    private _isSop;
+    isSopNode(): boolean;
+}

package/dist/compiler/AstCompiler/utils/getTirFuncSigTree/TirFuncSigTree.js

@@ -0,0 +1,129 @@
+import { TirAliasType } from "../../../tir/types/TirAliasType.js";
+import { TirFuncT } from "../../../tir/types/TirNativeType/native/function.js";
+import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
+import { TirVoidT } from "../../../tir/types/TirNativeType/native/void.js";
+import { TirDataStructType } from "../../../tir/types/TirStructType.js";
+import { TirTypeParam } from "../../../tir/types/TirTypeParam.js";
+export function isTirFuncSigTree(node) {
+    return (node instanceof TirFuncSigTreeRoot
+        || node instanceof TirFuncSigTreeNode
+        || node instanceof TirFuncSigTreeLeaf);
+}
+export class TirFuncSigTreeRoot {
+    children;
+    constructor(children) {
+        this.children = children;
+    }
+    isLeaf() {
+        return false;
+    }
+    toArrays() {
+        const result = this.children
+            .reduce((accum, child) => accum.concat(child.toArrays()), []);
+        this.forgetChachedArrays(); // free some memory
+        return result;
+    }
+    forgetChachedArrays() {
+        for (const child of this.children) {
+            if (child instanceof TirFuncSigTreeNode) {
+                child.forgetChachedArrays();
+            }
+        }
+    }
+    sigs() {
+        return this
+            .toArrays()
+            .map(variant => {
+            const paramTypes = variant.slice(0, variant.length - 1);
+            const returnType = variant[variant.length - 1];
+            return new TirFuncT(paramTypes, returnType);
+        });
+    }
+    sopSig() {
+        const sopTypes = this.sopTypes();
+        if (sopTypes.length === 0)
+            return new TirFuncT([], new TirVoidT());
+        return new TirFuncT(sopTypes.slice(0, sopTypes.length - 1), sopTypes[sopTypes.length - 1]);
+    }
+    sopTypes() {
+        return this.children
+            .find(child => child.isSopNode())?.sopTypes()
+            ?? this.children[0].sopTypes();
+    }
+}
+export class TirFuncSigTreeNode {
+    type;
+    children;
+    constructor(type, children) {
+        this.type = type;
+        this.children = children;
+    }
+    isLeaf() {
+        return false;
+    }
+    _arrays = undefined;
+    toArrays() {
+        if (Array.isArray(this._arrays))
+            return this._arrays;
+        const result = this.children
+            .reduce((accum, child) => accum.concat(child.toArrays().map(arr => arr.slice())), []);
+        for (let i = 0; i < result.length; i++) {
+            result[i].unshift(this.type);
+        }
+        this._arrays = result;
+        return result;
+    }
+    forgetChachedArrays() {
+        if (Array.isArray(this._arrays))
+            this._arrays.length = 0;
+        this._arrays = undefined;
+        for (const child of this.children) {
+            child.forgetChachedArrays();
+        }
+    }
+    sopTypes() {
+        return this.children
+            .find(child => child.isSopNode())?.sopTypes()
+            ?? this.children[0].sopTypes();
+    }
+    _isSop = undefined;
+    isSopNode() {
+        if (typeof this._isSop === "boolean")
+            return this._isSop;
+        let type = this.type;
+        while (type instanceof TirAliasType)
+            type = type.aliased;
+        this._isSop = !(type instanceof TirDataOptT
+            || type instanceof TirDataStructType
+            || type instanceof TirTypeParam);
+        return this._isSop;
+    }
+}
+export class TirFuncSigTreeLeaf {
+    type;
+    constructor(type) {
+        this.type = type;
+    }
+    isLeaf() {
+        return true;
+    }
+    toArrays() {
+        return [[this.type]];
+    }
+    forgetChachedArrays() { }
+    sopTypes() {
+        return [this.type];
+    }
+    _isSop = undefined;
+    isSopNode() {
+        if (typeof this._isSop === "boolean")
+            return this._isSop;
+        let type = this.type;
+        while (type instanceof TirAliasType)
+            type = type.aliased;
+        this._isSop = !(type instanceof TirDataOptT
+            || type instanceof TirDataStructType
+            || type instanceof TirTypeParam);
+        return this._isSop;
+    }
+}

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

@@ -0,0 +1,4 @@
+import { AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
+import { AstCompilationCtx } from "../../AstCompilationCtx.js";
+import { TirFuncSigTreeRoot } from "./TirFuncSigTree.js";
+export declare function getTirFuncSigTree(signature: AstFuncType, ctx: AstCompilationCtx): TirFuncSigTreeRoot;

package/dist/compiler/AstCompiler/utils/getTirFuncSigTree/getTirFuncSigTree.js

@@ -0,0 +1,49 @@
+import { AstFuncType } from "../../../../ast/nodes/types/AstNativeTypeExpr.js";
+import { isTirType } from "../../../tir/types/TirType.js";
+import { TirFuncSigTreeLeaf, TirFuncSigTreeNode, TirFuncSigTreeRoot } from "./TirFuncSigTree.js";
+export function getTirFuncSigTree(signature, ctx) {
+    const astTypes = signature.params.map(param => param.type);
+    let tmpSig = signature;
+    while (tmpSig.returnType instanceof AstFuncType) {
+        tmpSig = tmpSig.returnType;
+        astTypes.push(...tmpSig.params.map(p => p.type));
+    }
+    if (!tmpSig.returnType)
+        throw new Error("Function signature has no return type");
+    astTypes.push(tmpSig.returnType);
+    const astParamTypes = astTypes.slice(0, astTypes.length - 1);
+    const astReturnType = astTypes[astTypes.length - 1];
+    const returnType = resolveReturnType(astReturnType, ctx);
+    if (!returnType)
+        throw new Error("Could not resolve return type");
+    let treeBranches = [
+        new TirFuncSigTreeLeaf(returnType)
+    ];
+    for (let i = astParamTypes.length - 1; i >= 0; i--) {
+        const paramType = astParamTypes[i];
+        const paramTirTypes = resolveParamType(paramType, ctx);
+        if (!paramTirTypes)
+            throw new Error("Could not resolve parameter type");
+        treeBranches = paramTirTypes.map(paramTirType => new TirFuncSigTreeNode(paramTirType, treeBranches));
+    }
+    return new TirFuncSigTreeRoot(treeBranches);
+}
+function resolveReturnType(astType, ctx) {
+    const possibleTypes = ctx.scope.resolveType(astType.toAstName());
+    if (!possibleTypes)
+        return undefined;
+    // if there is a choice
+    // we ALWAYS return the SoP friendly one
+    // if we then happen to need the data encoded,
+    // the overhead introduced by returning SoP instead of data directly
+    // is negligible (~ 2 uplc nodes) 
+    return ctx.program.types.get(possibleTypes.sopTirName);
+}
+function resolveParamType(astType, ctx) {
+    const possibleTypes = ctx.scope.resolveType(astType.toAstName());
+    if (!possibleTypes)
+        return undefined;
+    return [possibleTypes.sopTirName, possibleTypes.dataTirName]
+        .map(tirName => tirName ? ctx.program.types.get(tirName) : undefined)
+        .filter(isTirType);
+}

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

@@ -0,0 +1,3 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirStmt } from "../../tir/statements/TirStmt.js";
+export declare function wrapManyStatements(stmts: TirStmt[] | undefined, range: SourceRange): TirStmt | undefined;

package/dist/compiler/AstCompiler/utils/wrapManyStatementsOrReturnSame.js

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirBlockStmt } from "../../tir/statements/TirBlockStmt.js";
+export function wrapManyStatements(stmts, range) {
+    if (!Array.isArray(stmts))
+        return undefined;
+    if (stmts.length === 0)
+        return new TirBlockStmt([], range);
+    if (stmts.length === 1)
+        return stmts[0];
+    else
+        return new TirBlockStmt(stmts, SourceRange.join(stmts[0].range, stmts[stmts.length - 1].range));
+}

package/dist/compiler/Compiler.d.ts

@@ -0,0 +1,10 @@
+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";
+export declare class Compiler extends DiagnosticEmitter {
+    readonly io: CompilerIoApi;
+    readonly cfg: CompilerOptions;
+    constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
+    compile(config?: Partial<CompilerOptions>): Promise<void>;
+}

package/dist/compiler/Compiler.js

@@ -0,0 +1,42 @@
+import { compileUPLC, UPLCProgram } from "@harmoniclabs/uplc";
+import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
+import { compileIRToUPLC } from "../IR/index.js";
+import { defaultOptions } from "../IR/toUPLC/CompilerOptions.js";
+import { AstCompiler } from "./AstCompiler/AstCompiler.js";
+import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
+import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
+export class Compiler extends DiagnosticEmitter {
+    io;
+    cfg;
+    constructor(io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), cfg = defaultOptions, diagnostics) {
+        super(diagnostics);
+        this.io = io;
+        this.cfg = cfg;
+    }
+    async compile(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config
+        };
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        const program = await astCompiler.compile();
+        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 ir = compileTypedProgram(cfg, program);
+        const uplc = compileIRToUPLC(ir);
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const outDir = cfg.outDir;
+        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
+        this.io.writeFile(outPath, serialized, cfg.root);
+        this.io.stdout.write(`compiled program written to ${outPath}\n`);
+        return;
+    }
+}

package/dist/compiler/TirCompiler/TirCompilerCtx.d.ts

@@ -0,0 +1,7 @@
+import { CompilerOptions } from "../../IR/toUPLC/CompilerOptions.js";
+import { TypedProgram } from "../tir/program/TypedProgram.js";
+export declare class TirCompilerCtx {
+    readonly cfg: CompilerOptions;
+    readonly program: TypedProgram;
+    constructor(cfg: CompilerOptions, program: TypedProgram);
+}

package/dist/compiler/TirCompiler/TirCompilerCtx.js

@@ -0,0 +1,8 @@
+export class TirCompilerCtx {
+    cfg;
+    program;
+    constructor(cfg, program) {
+        this.cfg = cfg;
+        this.program = program;
+    }
+}

package/dist/compiler/TirCompiler/compileTirProgram.d.ts

@@ -0,0 +1,9 @@
+import { IRTerm } from "../../IR/index.js";
+import { CompilerOptions } from "../../IR/toUPLC/CompilerOptions.js";
+import { TypedProgram } from "../tir/program/TypedProgram.js";
+/**
+ * compiles Typed IR to IRTerm (old plu-ts IR).
+ *
+ * TIR -> IRTerm
+ */
+export declare function compileTypedProgram(cfg: CompilerOptions, tirProgram: TypedProgram): IRTerm;

package/dist/compiler/TirCompiler/compileTirProgram.js

@@ -0,0 +1,18 @@
+import { ToIRTermCtx } from "../tir/expressions/ToIRTermCtx.js";
+import { expressify } from "./expressify/expressify.js";
+/**
+ * compiles Typed IR to IRTerm (old plu-ts IR).
+ *
+ * TIR -> IRTerm
+ */
+export function compileTypedProgram(cfg, tirProgram) {
+    /*
+    const ctx = new TirCompilerCtx(
+        cfg,
+        tirProgram,
+    );
+    //*/
+    const mainFuncExpr = tirProgram.getMainOrThrow();
+    void expressify(mainFuncExpr, undefined);
+    return mainFuncExpr.toIR(ToIRTermCtx.root());
+}

package/dist/compiler/TirCompiler/expressify/ExpressifyCtx.d.ts

@@ -0,0 +1,72 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { TirExpr } from "../../tir/expressions/TirExpr.js";
+import { TirHoistedExpr } from "../../tir/expressions/TirHoistedExpr.js";
+import { TirLettedExpr } from "../../tir/expressions/TirLettedExpr.js";
+import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
+import { TirAssertStmt } from "../../tir/statements/TirAssertStmt.js";
+import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
+import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirDataStructType } from "../../tir/types/TirStructType.js";
+import { TirType } from "../../tir/types/TirType.js";
+/**
+ * Static Single Assignment (SSA) variable name.
+ *
+ * while expressifying, we convert mutable variables to constants,
+ * where the latest shadows the previous ones.
+ *
+ * each new constant introduced is given a new name, added to the context map, pointing to the same `LatestVarNameSSA`.
+ * any following variable access that refers to the same variable, will be replaced to the latest name.
+ */
+export interface LatestVarNameSSA {
+    latestName: string;
+}
+export interface ExpressifyFuncParam {
+    name: string;
+    type: TirType;
+}
+export declare function isExpressifyFuncParam(thing: any): thing is ExpressifyFuncParam;
+export declare class ExpressifyCtx {
+    readonly parent: ExpressifyCtx | undefined;
+    returnType: TirType;
+    /** var name -> latest constant name */
+    readonly variables: Map<string, LatestVarNameSSA>;
+    /** constant name -> func param name (to build var access) */
+    readonly funcParams: Map<string, ExpressifyFuncParam>;
+    /** constant name -> letted expr */
+    readonly lettedConstants: Map<string, TirLettedExpr>;
+    /** var name -> prop name -> constant name (letted field extraction expr or var access for SoP)*/
+    readonly properties: Map<string, Map<string, string>>;
+    readonly hoisted: Map<string, TirHoistedExpr | TirNativeFunc>;
+    constructor(parent: ExpressifyCtx | undefined, returnType: TirType, hoisted?: Map<string, TirHoistedExpr | TirNativeFunc>, 
+    /** var name -> latest constant name */
+    variables?: Map<string, LatestVarNameSSA>, 
+    /** constant name -> func param name (to build var access) */
+    funcParams?: Map<string, ExpressifyFuncParam>, 
+    /** constant name -> letted expr */
+    lettedConstants?: Map<string, TirLettedExpr>, 
+    /** var name -> prop name -> constant name (letted field extraction expr or var access for SoP)*/
+    properties?: Map<string, Map<string, string>>);
+    newChild(): ExpressifyCtx;
+    setNewVariableName(oldName: string, newName: string): void;
+    setFuncParam(name: string, type: TirType): void;
+    /**
+     * `undefined` means the variable is not in the local context.
+     */
+    getLocalVariable(name: string): TirLettedExpr | ExpressifyFuncParam | undefined;
+    /**
+     *
+     * `undefined` means the variable is not in the function context.
+     *
+     * so it is assumed to be an external (hoisted) variable.
+     */
+    private _getNonHoistedVariable;
+    getVariable(name: string): ExpressifyFuncParam | TirHoistedExpr | TirNativeFunc | TirLettedExpr;
+    introduceFuncParams(params: readonly TirSimpleVarDecl[]): void;
+    introduceLettedConstant(name: string, lettedExpr: TirExpr, declRange: SourceRange): TirLettedExpr;
+    introduceSopConstrFieldsAsProperties(sopName: string, destructuredPattern: TirNamedDeconstructVarDecl): void;
+    introduceSopConstrFieldsAsParamsOnly(destructuredPattern: TirNamedDeconstructVarDecl): void;
+    introduceSingleConstrDataLettedFields(varName: string, structExpr: TirExpr, structType: TirDataStructType): void;
+    introduceDeconstrDataLettedFields(stmt: TirNamedDeconstructVarDecl): TirAssertStmt[];
+    introduceArrayDeconstr(stmt: TirArrayLikeDeconstr, isDestructuredField?: boolean): TirAssertStmt[];
+}