@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -0,0 +1,777 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { Identifier } from "../../../../ast/nodes/common/Identifier.js";
+import { isBinaryExpr } from "../../../../ast/nodes/expr/binary/BinaryExpr.js";
+import { CaseExpr } from "../../../../ast/nodes/expr/CaseExpr.js";
+import { ElemAccessExpr } from "../../../../ast/nodes/expr/ElemAccessExpr.js";
+import { CallExpr } from "../../../../ast/nodes/expr/functions/CallExpr.js";
+import { FuncExpr } from "../../../../ast/nodes/expr/functions/FuncExpr.js";
+import { LitArrExpr } from "../../../../ast/nodes/expr/litteral/LitArrExpr.js";
+import { LitContextExpr } from "../../../../ast/nodes/expr/litteral/LitContextExpr.js";
+import { LitFailExpr } from "../../../../ast/nodes/expr/litteral/LitFailExpr.js";
+import { LitFalseExpr } from "../../../../ast/nodes/expr/litteral/LitFalseExpr.js";
+import { LitHexBytesExpr } from "../../../../ast/nodes/expr/litteral/LitHexBytesExpr.js";
+import { LitIntExpr } from "../../../../ast/nodes/expr/litteral/LitIntExpr.js";
+import { LitNamedObjExpr } from "../../../../ast/nodes/expr/litteral/LitNamedObjExpr.js";
+import { LitObjExpr } from "../../../../ast/nodes/expr/litteral/LitObjExpr.js";
+import { LitStrExpr } from "../../../../ast/nodes/expr/litteral/LitStrExpr.js";
+import { LitThisExpr } from "../../../../ast/nodes/expr/litteral/LitThisExpr.js";
+import { LitTrueExpr } from "../../../../ast/nodes/expr/litteral/LitTrueExpr.js";
+import { LitUndefExpr } from "../../../../ast/nodes/expr/litteral/LitUndefExpr.js";
+import { LitVoidExpr } from "../../../../ast/nodes/expr/litteral/LitVoidExpr.js";
+import { ParentesizedExpr } from "../../../../ast/nodes/expr/ParentesizedExpr.js";
+import { isPropAccessExpr } from "../../../../ast/nodes/expr/PropAccessExpr.js";
+import { TernaryExpr } from "../../../../ast/nodes/expr/TernaryExpr.js";
+import { TypeConversionExpr } from "../../../../ast/nodes/expr/TypeConversionExpr.js";
+import { isUnaryPrefixExpr } from "../../../../ast/nodes/expr/unary/UnaryPrefixExpr.js";
+import { AssertStmt } from "../../../../ast/nodes/statements/AssertStmt.js";
+import { isExplicitAssignmentStmt, isImplicitAssignmentStmt } from "../../../../ast/nodes/statements/AssignmentStmt.js";
+import { BlockStmt } from "../../../../ast/nodes/statements/BlockStmt.js";
+import { BreakStmt } from "../../../../ast/nodes/statements/BreakStmt.js";
+import { ContinueStmt } from "../../../../ast/nodes/statements/ContinueStmt.js";
+import { StructConstrDecl, StructDecl, StructDeclAstFlags } from "../../../../ast/nodes/statements/declarations/StructDecl.js";
+import { NamedDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/NamedDeconstructVarDecl.js";
+import { SimpleVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
+import { SingleDeconstructVarDecl } from "../../../../ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js";
+import { EmptyStmt } from "../../../../ast/nodes/statements/EmptyStmt.js";
+import { FailStmt } from "../../../../ast/nodes/statements/FailStmt.js";
+import { ForOfStmt } from "../../../../ast/nodes/statements/ForOfStmt.js";
+import { ForStmt } from "../../../../ast/nodes/statements/ForStmt.js";
+import { IfStmt } from "../../../../ast/nodes/statements/IfStmt.js";
+import { MatchStmtCase, MatchStmt, MatchStmtElseCase } from "../../../../ast/nodes/statements/MatchStmt.js";
+import { ReturnStmt } from "../../../../ast/nodes/statements/ReturnStmt.js";
+import { UsingStmt } from "../../../../ast/nodes/statements/UsingStmt.js";
+import { VarStmt } from "../../../../ast/nodes/statements/VarStmt.js";
+import { WhileStmt } from "../../../../ast/nodes/statements/WhileStmt.js";
+import { CommonFlags } from "../../../../common.js";
+import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { getUniqueInternalName } from "../../../internalVar.js";
+import { AstNamedTypeExpr } from "../../../../ast/nodes/types/AstNamedTypeExpr.js";
+import { NonNullExpr } from "../../../../ast/nodes/expr/unary/NonNullExpr.js";
+/**
+ *
+ * only returns the body of the main function
+ *
+ * function arguments (parameters and script context) must be handled outside
+ */
+export function _deriveContractBody(compiler, contractDecl, paramsInternalNamesMap, scriptContextName) {
+    const contractRange = contractDecl.range;
+    // no methods is always fail
+    if (contractDecl.spendMethods.length === 0
+        && contractDecl.mintMethods.length === 0
+        && contractDecl.certifyMethods.length === 0
+        && contractDecl.withdrawMethods.length === 0
+        && contractDecl.proposeMethods.length === 0
+        && contractDecl.voteMethods.length === 0)
+        return new BlockStmt([
+            new FailStmt(undefined, contractRange)
+        ], contractRange);
+    // contract body alwyas looks like:
+    //
+    // ```
+    // func main( ...params, ctx: ScriptContext ) : void {
+    //     const { tx, purpose, redeemer } = ctx;
+    // 
+    //     match( purpose ) {
+    //         when Spend{}: { ... }
+    //         when Mint{}: { ... }
+    //         when Withdraw{}: { ... }
+    //         when Certify{}: { ... }
+    //         when Propose{}: { ... }
+    //         when Vote{}: { ... }
+    //         else fail;
+    //     }
+    // 
+    //     fail; // unreachable
+    // }
+    // ```
+    // 
+    // so we only have 3 statements in the body
+    const bodyStmts = [];
+    const txUniqueName = getUniqueInternalName("tx");
+    const purposeUniqueName = getUniqueInternalName("purpose");
+    const redeemerUniqueName = getUniqueInternalName("redeemer");
+    bodyStmts.push(new VarStmt([new SingleDeconstructVarDecl(
+        // fields
+        new Map([
+            [
+                new Identifier("tx", contractRange),
+                SimpleVarDecl.onlyNameConst(txUniqueName, contractRange)
+            ],
+            [
+                new Identifier("purpose", contractRange),
+                SimpleVarDecl.onlyNameConst(purposeUniqueName, contractRange)
+            ],
+            [
+                new Identifier("redeemer", contractRange),
+                SimpleVarDecl.onlyNameConst(redeemerUniqueName, contractRange)
+            ],
+        ]), undefined, // rest
+        undefined, // type (inferred from initExpr)
+        new Identifier(scriptContextName, contractRange), // initExpr
+        CommonFlags.Const, contractRange)], contractRange));
+    /*
+    const { data: scriptInfo_t } = defineMultiConstructorStruct(
+        "ScriptInfo", {
+            Mint: {
+                policy: policyId_t
+            },
+            Spend: {
+                ref: txOutRef_t,
+                optionalDatum: opt_data_t
+            },
+            Withdraw: {
+                credential: credential_t
+            },
+            Certificate: {
+                certificateIndex: int_t,
+                certificate: credential_t
+            },
+            Vote: {
+                voter: voter_t
+            },
+            Propose: {
+                proposalIndex: int_t,
+                proposal: proposalProcedure_t
+            }
+        }, onlyData
+    );
+     */
+    const purposeMatchCases = [];
+    if (contractDecl.spendMethods.length > 0) {
+        const spendingRefUniqueName = getUniqueInternalName("spendingRef");
+        const optionalDatumUniqueName = getUniqueInternalName("optionalDatum");
+        const fields = new Map([
+            [
+                new Identifier("ref", contractRange),
+                SimpleVarDecl.onlyNameConst(spendingRefUniqueName, contractRange)
+            ],
+            [
+                new Identifier("optionalDatum", contractRange),
+                SimpleVarDecl.onlyNameConst(optionalDatumUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.spendMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            spendingRef: spendingRefUniqueName,
+            optionalDatum: optionalDatumUniqueName,
+        }), "SpendRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Spend", contractRange), fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
+    }
+    if (contractDecl.mintMethods.length > 0) {
+        const policyUniqueName = getUniqueInternalName("policy");
+        const fields = new Map([
+            [
+                new Identifier("policy", contractRange),
+                SimpleVarDecl.onlyNameConst(policyUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.mintMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            policy: policyUniqueName,
+        }), "MintRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Mint", contractRange), fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
+    }
+    if (contractDecl.withdrawMethods.length > 0) {
+        const credentialUniqueName = getUniqueInternalName("credential");
+        const fields = new Map([
+            [
+                new Identifier("credential", contractRange),
+                SimpleVarDecl.onlyNameConst(credentialUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.withdrawMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            policy: credentialUniqueName,
+        }), "WithdrawRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Withdraw", contractRange), fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
+    }
+    if (contractDecl.certifyMethods.length > 0) {
+        const indexUniqueName = getUniqueInternalName("certificateIndex");
+        const certificateUniqueName = getUniqueInternalName("certificate");
+        const fields = new Map([
+            [
+                new Identifier("certificateIndex", contractRange),
+                SimpleVarDecl.onlyNameConst(indexUniqueName, contractRange)
+            ],
+            [
+                new Identifier("certificate", contractRange),
+                SimpleVarDecl.onlyNameConst(certificateUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.certifyMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            certificateIndex: indexUniqueName,
+            certificate: certificateUniqueName,
+        }), "CertifyRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Certificate", contractRange), fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
+    }
+    if (contractDecl.proposeMethods.length > 0) {
+        const indexUniqueName = getUniqueInternalName("proposalIndex");
+        const proposalUniqueName = getUniqueInternalName("proposal");
+        const fields = new Map([
+            [
+                new Identifier("proposalIndex", contractRange),
+                SimpleVarDecl.onlyNameConst(indexUniqueName, contractRange)
+            ],
+            [
+                new Identifier("proposal", contractRange),
+                SimpleVarDecl.onlyNameConst(proposalUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.proposeMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            proposalIndex: indexUniqueName,
+            proposal: proposalUniqueName,
+        }), "ProposeRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Propose", contractRange), fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        CommonFlags.Const, contractRange), new BlockStmt(bodyStmts, contractRange), contractRange));
+    }
+    if (contractDecl.voteMethods.length > 0) {
+        const voterUniqueName = getUniqueInternalName("voter");
+        const fields = new Map([
+            [
+                new Identifier("voter", contractRange),
+                SimpleVarDecl.onlyNameConst(voterUniqueName, contractRange)
+            ],
+        ]);
+        const bodyStmts = _getMatchedPurposeBlockStatements(compiler, contractDecl.voteMethods, paramsInternalNamesMap, 
+        // contextVarsMapping
+        Object.freeze({
+            tx: txUniqueName,
+            purposeData: purposeUniqueName,
+            redeemerData: redeemerUniqueName,
+            voter: voterUniqueName,
+        }), "VoteRedeemer", contractRange);
+        if (!Array.isArray(bodyStmts))
+            return undefined;
+        purposeMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier("Vote", contractRange), 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 FailStmt(undefined, contractRange)); // unreachable in theory (else case)
+    return new BlockStmt(bodyStmts, contractRange);
+}
+function _getMatchedPurposeBlockStatements(compiler, methods, paramsInternalNamesMap, contextVarsMapping, baseRedeemerName, contractRange) {
+    // usually 0 methods is checked before calling
+    // but just in case it is not, we handle it here
+    if (methods.length === 0)
+        return [
+            new FailStmt(undefined, contractRange)
+        ];
+    const redeemerTypeDef = _deriveRedeemerTypeDef(baseRedeemerName, // "SpendRedeemer",
+    methods, contractRange);
+    compiler.registerInternalTypeDecl(redeemerTypeDef);
+    // if only one method, we can inline it
+    if (methods.length === 1) {
+        const method = methods[0];
+        const stmts = _getRedeemerMethodBlockStatemets(compiler, method, redeemerTypeDef, paramsInternalNamesMap, contextVarsMapping);
+        if (!Array.isArray(stmts))
+            return undefined;
+        return stmts;
+    }
+    // multiple methods, need to match redeemer
+    const redeemerMatchCases = [];
+    for (const method of methods) {
+        const stmts = _getRedeemerMethodBlockStatemets(compiler, method, redeemerTypeDef, paramsInternalNamesMap, contextVarsMapping);
+        if (!Array.isArray(stmts))
+            return undefined;
+        redeemerMatchCases.push(new MatchStmtCase(new NamedDeconstructVarDecl(new Identifier(method.expr.name.text, method.expr.name.range), new Map(redeemerTypeDef.constrs.find(c => c.name.text === method.expr.name.text).fields.map((fieldDef, i) => {
+            const param = method.expr.signature.params[i];
+            const range = param.range;
+            return [
+                new Identifier(fieldDef.name.text, range),
+                param
+            ];
+        })), undefined, // rest
+        undefined, // type (inferred from initExpr)
+        undefined, // initExpr
+        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 FailStmt(undefined, contractRange) // unreachable in theory (else case)
+    ];
+}
+function _getRedeemerMethodBlockStatemets(compiler, method, redeemerTypeDef, paramsInternalNamesMap, contextVarsMapping, 
+/**
+ * remember destructured context fields that have been renamed
+ */
+renamedVariables = {}) {
+    const redeemerTypeName = redeemerTypeDef.name.text;
+    const methodExpr = method.expr;
+    const redeemerTypeConstr = redeemerTypeDef.constrs.find(constr => constr.name.text === method.expr.name.text);
+    if (!redeemerTypeConstr)
+        throw new Error(`unreachable Internal Error: missing redeemer constructor ${method.expr.name.text}`);
+    if (redeemerTypeConstr.fields.length !== methodExpr.signature.params.length)
+        throw new Error(`unreachable Internal Error: redeemer constructor ${method.expr.name.text} fields length missmatch with method parameters length`);
+    const result = _getMatchedRedeemerBlockStatements(compiler, methodExpr.bodyBlockStmt().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+    if (!Array.isArray(result))
+        return undefined;
+    // prepend redeemer fields destructuring if single method for this purpose
+    if (redeemerTypeDef.constrs.length === 1
+        && methodExpr.signature.params.length > 0) {
+        const fields = new Map(redeemerTypeConstr.fields.map((fieldDef, i) => {
+            const param = methodExpr.signature.params[i];
+            const range = param.range;
+            return [
+                new Identifier(fieldDef.name.text, range),
+                param
+            ];
+        }));
+        result.unshift(new NamedDeconstructVarDecl(method.expr.name, fields, undefined, // rest
+        undefined, // type (inferred from initExpr)
+        new TypeConversionExpr(new Identifier(contextVarsMapping.redeemerData, method.range), new AstNamedTypeExpr(new Identifier(redeemerTypeName, method.range), [], // typeArgs
+        method.range)), // initExpr
+        CommonFlags.Const, method.range));
+    }
+    ;
+    // always add implicit return void (unit) at the end of a method
+    result.push(new ReturnStmt(new LitVoidExpr(methodExpr.range.atEnd()), methodExpr.range.atEnd()));
+    return result;
+}
+function _getMatchedRedeemerBlockStatements(compiler, stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables) {
+    const result = stmts.slice();
+    for (let i = 0; i < result.length; i++) {
+        const stmt = result[i];
+        if (stmt instanceof VarStmt) {
+            if (stmt.declarations.length !== 1) {
+                for (const varDecl of stmt.declarations) {
+                    if (varDecl.initExpr)
+                        varDecl.initExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, varDecl.initExpr, paramsInternalNamesMap, renamedVariables);
+                }
+                continue;
+            }
+            const varDecl = stmt.declarations[0];
+            if (!(varDecl.initExpr instanceof LitContextExpr)) {
+                // normal var decl
+                if (varDecl.initExpr)
+                    varDecl.initExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, varDecl.initExpr, paramsInternalNamesMap, renamedVariables);
+                continue;
+            }
+            // varDecl.initExpr is a LitContextExpr
+            // handle context destructuring
+            if (!(varDecl instanceof SingleDeconstructVarDecl))
+                return compiler.error(DiagnosticCode._context_can_only_be_destructured_as_an_unnamed_object, varDecl.range);
+            if (!varDecl.isConst())
+                return compiler.error(DiagnosticCode._context_can_only_be_destructured_in_a_constant_declaration, varDecl.range);
+            /**
+             * statements to push instead of the context destructuring
+             * (nested fields destructured)
+             **/
+            const newStmts = [];
+            const destructuredFieldsIds = [];
+            // introduce destructured variables as renamed variables
+            for (let [fieldIdentifier, fieldVarDecl] of varDecl.fields) {
+                if (!(contextVarsMapping && isObject(contextVarsMapping))) {
+                    return compiler.error(DiagnosticCode._context_can_only_be_accessed_in_a_contract_method, fieldIdentifier.range);
+                }
+                const realVarName = contextVarsMapping[fieldIdentifier.text];
+                if (!realVarName && typeof realVarName !== "string") {
+                    return compiler.error(DiagnosticCode._0_is_not_aviable_in_this_contract_method_context, fieldIdentifier.range, fieldIdentifier.text);
+                }
+                if (destructuredFieldsIds.includes(fieldIdentifier.text)) {
+                    return compiler.error(DiagnosticCode.Duplicate_identifier_0, fieldVarDecl.range, fieldIdentifier.text);
+                }
+                destructuredFieldsIds.push(fieldIdentifier.text);
+                if (!(fieldVarDecl instanceof SimpleVarDecl)) {
+                    const uniqueName = getUniqueInternalName(fieldIdentifier.text);
+                    // move nested field destructuring outside of this destructuring
+                    fieldVarDecl.initExpr = new Identifier(uniqueName, fieldIdentifier.range);
+                    fieldVarDecl.flags |= CommonFlags.Const;
+                    newStmts.push(fieldVarDecl);
+                    // replace destructured field with a simple renaming of the field
+                    fieldVarDecl = SimpleVarDecl.onlyNameConst(uniqueName, fieldIdentifier.range);
+                }
+                const introducedVarName = fieldVarDecl.name.text;
+                if (renamedVariables[introducedVarName])
+                    return compiler.error(DiagnosticCode.Duplicate_identifier_0, fieldVarDecl.range, fieldIdentifier.text);
+                // when reading `introducedVarName`, it will be replaced with `realVarName`
+                renamedVariables[introducedVarName] = realVarName;
+            }
+            // remove the context destrucuturing statement from the result
+            // push new ones if any
+            result.splice(i, 1, ...newStmts);
+            i--;
+            continue;
+        } // if( stmt instanceof VarStmt )
+        if (stmt instanceof BreakStmt
+            || stmt instanceof ContinueStmt
+            || stmt instanceof EmptyStmt
+            || stmt instanceof UsingStmt)
+            continue;
+        if (isImplicitAssignmentStmt(stmt))
+            continue;
+        if (isExplicitAssignmentStmt(stmt)) {
+            const newAssingedExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.assignedExpr, paramsInternalNamesMap, renamedVariables);
+            if (!newAssingedExpr)
+                return undefined;
+            stmt.assignedExpr = newAssingedExpr;
+            continue;
+        }
+        if (stmt instanceof BlockStmt) {
+            const nextBodyStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+            if (!Array.isArray(nextBodyStmts))
+                return undefined;
+            stmt.stmts = nextBodyStmts;
+            continue;
+        }
+        if (stmt instanceof ReturnStmt) {
+            if (!stmt.value)
+                continue;
+            const newReturnExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.value, paramsInternalNamesMap, renamedVariables);
+            if (!newReturnExpr)
+                return undefined;
+            stmt.value = newReturnExpr;
+            continue;
+        }
+        if (stmt instanceof IfStmt) {
+            const nextContidionExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.condition, paramsInternalNamesMap, renamedVariables);
+            if (!nextContidionExpr)
+                return undefined;
+            stmt.condition = nextContidionExpr;
+            const nextThenStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.thenBranchBlock().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+            if (!Array.isArray(nextThenStmts))
+                return undefined;
+            stmt.thenBranch = new BlockStmt(nextThenStmts, stmt.thenBranch.range);
+            if (stmt.elseBranch) {
+                const nextElseStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.elseBranchBlock().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+                if (!Array.isArray(nextElseStmts))
+                    return undefined;
+                stmt.elseBranch = new BlockStmt(nextElseStmts, stmt.elseBranch.range);
+            }
+            continue;
+        }
+        if (stmt instanceof MatchStmt) {
+            const nextMatchExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.matchExpr, paramsInternalNamesMap, renamedVariables);
+            if (!nextMatchExpr)
+                return undefined;
+            stmt.matchExpr = nextMatchExpr;
+            for (let i = 0; i < stmt.cases.length; i++) {
+                const c = stmt.cases[i];
+                const nextCaseBody = _getMatchedRedeemerBlockStatements(compiler, c.bodyBlockStmt().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+                if (!Array.isArray(nextCaseBody))
+                    return undefined;
+                c.body = new BlockStmt(nextCaseBody, c.body.range);
+            }
+            if (stmt.elseCase) {
+                const nextElseBody = _getMatchedRedeemerBlockStatements(compiler, stmt.elseCase.bodyBlockStmt().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+                if (!Array.isArray(nextElseBody))
+                    return undefined;
+                stmt.elseCase.body = new BlockStmt(nextElseBody, stmt.elseCase.body.range);
+            }
+            continue;
+        }
+        if (stmt instanceof FailStmt) {
+            if (!stmt.value)
+                continue;
+            const newFailExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.value, paramsInternalNamesMap, renamedVariables);
+            if (!newFailExpr)
+                return undefined;
+            stmt.value = newFailExpr;
+            continue;
+        }
+        if (stmt instanceof AssertStmt) {
+            const newConditionExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.condition, paramsInternalNamesMap, renamedVariables);
+            if (!newConditionExpr)
+                return undefined;
+            stmt.condition = newConditionExpr;
+            if (stmt.elseExpr) {
+                const newElseExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.elseExpr, paramsInternalNamesMap, renamedVariables);
+                if (!newElseExpr)
+                    return undefined;
+                stmt.elseExpr = newElseExpr;
+            }
+            continue;
+        }
+        if (stmt instanceof ForStmt) {
+            if (stmt.init) {
+                const nextInitStmts = _getMatchedRedeemerBlockStatements(compiler, [stmt.init], paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+                if (!(Array.isArray(nextInitStmts)
+                    && nextInitStmts.length === 1))
+                    return undefined;
+                const nextInit = nextInitStmts[0];
+                if (!(nextInit instanceof VarStmt))
+                    throw new Error("unreachable::_getMatchedRedeemerBlockStatements::ForStmt::init");
+                stmt.init = nextInit;
+            }
+            if (stmt.condition) {
+                const newConditionExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.condition, paramsInternalNamesMap, renamedVariables);
+                if (!newConditionExpr)
+                    return undefined;
+                stmt.condition = newConditionExpr;
+            }
+            for (let i = 0; i < stmt.updates.length; i++) {
+                const updateStmt = stmt.updates[i];
+                const nextUpdateStmts = _getMatchedRedeemerBlockStatements(compiler, [updateStmt], paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+                if (!(Array.isArray(nextUpdateStmts)
+                    && nextUpdateStmts.length === 1))
+                    return undefined;
+                const nextUpdateStmt = nextUpdateStmts[0];
+                if (!(isImplicitAssignmentStmt(nextUpdateStmt) || isExplicitAssignmentStmt(nextUpdateStmt)))
+                    throw new Error("unreachable::_getMatchedRedeemerBlockStatements::ForStmt::update");
+                stmt.updates[i] = nextUpdateStmt;
+            }
+            const nextBodyStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.bodyBlock().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+            if (!Array.isArray(nextBodyStmts))
+                return undefined;
+            stmt.body = new BlockStmt(nextBodyStmts, stmt.body.range);
+            continue;
+        }
+        if (stmt instanceof ForOfStmt) {
+            const newIterableExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.iterable, paramsInternalNamesMap, renamedVariables);
+            if (!newIterableExpr)
+                return undefined;
+            stmt.iterable = newIterableExpr;
+            const nextBodyStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.bodyBlock().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+            if (!Array.isArray(nextBodyStmts))
+                return undefined;
+            stmt.body = new BlockStmt(nextBodyStmts, stmt.body.range);
+            continue;
+        }
+        if (stmt instanceof WhileStmt) {
+            const newConditionExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, stmt.condition, paramsInternalNamesMap, renamedVariables);
+            if (!newConditionExpr)
+                return undefined;
+            stmt.condition = newConditionExpr;
+            const nextBodyStmts = _getMatchedRedeemerBlockStatements(compiler, stmt.bodyBlock().stmts, paramsInternalNamesMap, contextVarsMapping, renamedVariables);
+            if (!Array.isArray(nextBodyStmts))
+                return undefined;
+            stmt.body = new BlockStmt(nextBodyStmts, stmt.body.range);
+            continue;
+        }
+        const tsEnsureExhaustiveCheck = stmt;
+        throw new Error("unreachable::_getMatchedRedeemerBlockStatements::stmt::");
+    }
+    return result;
+}
+function _exprReplaceParamsAndAssertNoLitContext(compiler, expr, paramsInternalNamesMap, renamedVariables) {
+    if (expr instanceof LitContextExpr)
+        return compiler.error(DiagnosticCode._context_can_only_be_destructured_as_an_unnamed_object, expr.range);
+    if (isPropAccessExpr(expr) && expr.object instanceof LitThisExpr) {
+        const paramName = expr.prop.text;
+        const internalName = paramsInternalNamesMap.get(paramName);
+        if (!internalName)
+            return compiler.error(DiagnosticCode._0_is_not_a_contract_parameter, expr.prop.range, paramName);
+        return new Identifier(internalName, expr.range);
+    }
+    if (expr instanceof LitThisExpr)
+        return compiler.error(DiagnosticCode._this_in_a_contract_context_can_only_be_used_to_read_parameters_in_a_contract_method, expr.range);
+    if (expr instanceof Identifier) {
+        const renamed = renamedVariables[expr.text];
+        if (renamed)
+            return new Identifier(renamed, expr.range);
+        return expr;
+    }
+    if (isUnaryPrefixExpr(expr)
+        || expr instanceof NonNullExpr) {
+        const newOperand = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.operand, paramsInternalNamesMap, renamedVariables);
+        if (!newOperand)
+            return undefined;
+        expr.operand = newOperand;
+        return expr;
+    }
+    if (
+    // isLitteralExpr( expr )
+    expr instanceof LitVoidExpr
+        || expr instanceof LitUndefExpr
+        || expr instanceof LitTrueExpr
+        || expr instanceof LitFalseExpr
+        || expr instanceof LitThisExpr
+        || expr instanceof LitContextExpr
+        || expr instanceof LitArrExpr
+        || expr instanceof LitObjExpr
+        || expr instanceof LitNamedObjExpr
+        || expr instanceof LitStrExpr
+        || expr instanceof LitIntExpr
+        || expr instanceof LitHexBytesExpr
+        || expr instanceof LitFailExpr)
+        return expr;
+    if (isBinaryExpr(expr)) {
+        const newLeft = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.left, paramsInternalNamesMap, renamedVariables);
+        if (!newLeft)
+            return undefined;
+        expr.left = newLeft;
+        const newRight = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.right, paramsInternalNamesMap, renamedVariables);
+        if (!newRight)
+            return undefined;
+        expr.right = newRight;
+        return expr;
+    }
+    if (expr instanceof ParentesizedExpr) {
+        const newInner = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.expr, paramsInternalNamesMap, renamedVariables);
+        if (!newInner)
+            return undefined;
+        expr.expr = newInner;
+        return expr;
+    }
+    if (expr instanceof TypeConversionExpr) {
+        const newInner = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.expr, paramsInternalNamesMap, renamedVariables);
+        if (!newInner)
+            return undefined;
+        expr.expr = newInner;
+        return expr;
+    }
+    if (isPropAccessExpr(expr)) {
+        const newObject = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.object, paramsInternalNamesMap, renamedVariables);
+        if (!newObject)
+            return undefined;
+        expr.object = newObject;
+        return expr;
+    }
+    if (expr instanceof ElemAccessExpr) {
+        const newObj = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.arrLikeExpr, paramsInternalNamesMap, renamedVariables);
+        if (!newObj)
+            return undefined;
+        expr.arrLikeExpr = newObj;
+        const newIndex = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.indexExpr, paramsInternalNamesMap, renamedVariables);
+        if (!newIndex)
+            return undefined;
+        expr.indexExpr = newIndex;
+        return expr;
+    }
+    if (expr instanceof TernaryExpr) {
+        const newCondition = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.condition, paramsInternalNamesMap, renamedVariables);
+        if (!newCondition)
+            return undefined;
+        expr.condition = newCondition;
+        const newIfTrue = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.ifTrue, paramsInternalNamesMap, renamedVariables);
+        if (!newIfTrue)
+            return undefined;
+        expr.ifTrue = newIfTrue;
+        const newIfFalse = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.ifFalse, paramsInternalNamesMap, renamedVariables);
+        if (!newIfFalse)
+            return undefined;
+        expr.ifFalse = newIfFalse;
+        return expr;
+    }
+    if (expr instanceof CaseExpr) {
+        const newTestExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.matchExpr, paramsInternalNamesMap, renamedVariables);
+        if (!newTestExpr)
+            return undefined;
+        expr.matchExpr = newTestExpr;
+        for (let i = 0; i < expr.cases.length; i++) {
+            const c = expr.cases[i];
+            const newCaseBody = _exprReplaceParamsAndAssertNoLitContext(compiler, c.body, paramsInternalNamesMap, renamedVariables);
+            if (!newCaseBody)
+                return undefined;
+            c.body = newCaseBody;
+        }
+        if (expr.wildcardCase) {
+            const newWildcardBody = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.wildcardCase.body, paramsInternalNamesMap, renamedVariables);
+            if (!newWildcardBody)
+                return undefined;
+            expr.wildcardCase.body = newWildcardBody;
+        }
+        return expr;
+    }
+    if (expr instanceof CallExpr) {
+        const newCallee = _exprReplaceParamsAndAssertNoLitContext(compiler, expr.funcExpr, paramsInternalNamesMap, renamedVariables);
+        if (!newCallee)
+            return undefined;
+        expr.funcExpr = newCallee;
+        for (let i = 0; i < expr.args.length; i++) {
+            const arg = expr.args[i];
+            const newArg = _exprReplaceParamsAndAssertNoLitContext(compiler, arg, paramsInternalNamesMap, renamedVariables);
+            if (!newArg)
+                return undefined;
+            expr.args[i] = newArg;
+        }
+        return expr;
+    }
+    if (expr instanceof FuncExpr) {
+        const sigParams = expr.signature.params;
+        for (const param of sigParams) {
+            if (param.initExpr)
+                param.initExpr = _exprReplaceParamsAndAssertNoLitContext(compiler, param.initExpr, paramsInternalNamesMap, renamedVariables);
+        }
+        const nextBodyStmts = _getMatchedRedeemerBlockStatements(compiler, expr.bodyBlockStmt().stmts, paramsInternalNamesMap, undefined, // contextVarsMapping,
+        renamedVariables);
+        if (!Array.isArray(nextBodyStmts))
+            return undefined;
+        expr.body = new BlockStmt(nextBodyStmts, expr.body.range);
+        return expr;
+    }
+    const tsEnsureExhaustiveCheck = expr;
+    console.error(expr);
+    throw new Error("unreachable::_exprReplaceParamsAndAssertNoLitContext");
+}
+function _deriveRedeemerTypeDef(redeemerName, methods, contractRange) {
+    let defFlags = StructDeclAstFlags.onlyDataEncoding;
+    if (methods.length <= 1)
+        defFlags |= StructDeclAstFlags.untaggedSingleConstructor;
+    const uniqueName = getUniqueInternalName(redeemerName);
+    return new StructDecl(new Identifier(uniqueName, contractRange), [], // typeParams
+    methods.map(m => {
+        const methodParams = m.expr.signature.params;
+        if (!methodParams.every(p => p instanceof SimpleVarDecl && !p.initExpr && p.type))
+            throw new Error("Contract method parameters not simplified befor inferring redeemer definition.");
+        return new StructConstrDecl(new Identifier(m.expr.name.text, m.expr.name.range), methodParams, contractRange);
+    }), // contructors
+    defFlags, contractRange);
+    /*
+    return new TirDataStructType(
+        uniqueName,
+        "", // fileUid
+        methods.map( m =>
+            new TirStructConstr(
+                m.expr.name.text,
+                m.expr.signature.params.map( p =>
+                    new TirStructField(
+                        p.name.text,
+                        p.type!,
+                    )
+                )
+            )
+        ),
+        new Map(), // no methods
+        methods.length <= 1, // untagged if there is only one method
+    );
+    //*/
+}