@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,14 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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;
-            while (msg = this.diagnostics.shift()) {
-                this.io.stdout.write(msg.toString() + "\n");
-            }
-            throw new Error("compilation failed");
-        }
-        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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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[];
-}