LowerToAffineLoops.cpp

#include "TypeScript/Config.h"
#include "TypeScript/DataStructs.h"
#include "TypeScript/Passes.h"
#include "TypeScript/TypeScriptDialect.h"
#include "TypeScript/TypeScriptFunctionPass.h"
#include "TypeScript/TypeScriptOps.h"
#include "TypeScript/TypeScriptPassContext.h"

#include "TypeScript/MLIRLogic/MLIRRTTIHelperVC.h"

#include "TypeScript/LowerToLLVMLogic.h"

#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Async/IR/Async.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h"
#include "mlir/IR/Dialect.h"
#include "mlir/IR/IRMapping.h"
#include "llvm/Support/Debug.h"

#include "scanner_enums.h"

using namespace mlir;
using namespace ::typescript;
namespace mlir_ts = mlir::typescript;

#define ENABLE_SWITCH_STATE_PASS 1

#define DEBUG_TYPE "affine"

namespace
{

//===----------------------------------------------------------------------===//
// TypeScriptToAffine RewritePatterns
//===----------------------------------------------------------------------===//

struct EntryOpLowering : public TsPattern<mlir_ts::EntryOp>
{
    using TsPattern<mlir_ts::EntryOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::EntryOp op, PatternRewriter &rewriter) const final
    {
        auto location = op.getLoc();

        mlir::Value allocValue;
        mlir::Type returnType;
        auto anyResult = op.getNumResults() > 0;
        if (anyResult)
        {
            auto result = op.getResult(0);
            returnType = result.getType();
            allocValue = rewriter.create<mlir_ts::VariableOp>(
                location, returnType, mlir::Value(), rewriter.getBoolAttr(false), rewriter.getIndexAttr(0));
        }

        // create return block
        auto *opBlock = rewriter.getInsertionBlock();
        auto *region = opBlock->getParent();

        tsContext->returnBlock = rewriter.createBlock(region);

        if (anyResult)
        {
            auto loadedValue = rewriter.create<mlir_ts::LoadOp>(
                location, mlir::cast<mlir_ts::RefType>(returnType).getElementType(), allocValue);
            rewriter.create<mlir_ts::ReturnInternalOp>(location, mlir::ValueRange{loadedValue});
            rewriter.replaceOp(op, allocValue);
        }
        else
        {
            rewriter.create<mlir_ts::ReturnInternalOp>(location, mlir::ValueRange{});
            rewriter.eraseOp(op);
        }

        return success();
    }
};

struct ExitOpLowering : public TsPattern<mlir_ts::ExitOp>
{
    using TsPattern<mlir_ts::ExitOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ExitOp op, PatternRewriter &rewriter) const final
    {
        assert(tsContext->returnBlock);

        auto retBlock = tsContext->returnBlock;

        rewriter.create<mlir::cf::BranchOp>(op.getLoc(), retBlock);

        rewriter.eraseOp(op);
        return success();
    }
};

struct ReturnOpLowering : public TsPattern<mlir_ts::ReturnOp>
{
    using TsPattern<mlir_ts::ReturnOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReturnOp op, PatternRewriter &rewriter) const final
    {
        auto loc = op.getLoc();

        assert(tsContext->returnBlock);

        auto retBlock = tsContext->returnBlock;
        if (auto unwind = tsContext->unwind.lookup(op))
        {
            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }

        auto *opBlock = rewriter.getInsertionBlock();
        auto opPosition = rewriter.getInsertionPoint();
        auto *continuationBlock = rewriter.splitBlock(opBlock, opPosition);

        rewriter.setInsertionPointToEnd(opBlock);

        if (auto cleanup = tsContext->cleanup.lookup(op))
        {
            rewriter.create<mlir::cf::BranchOp>(loc, cleanup);
        }
        else
        {
            rewriter.create<mlir::cf::BranchOp>(loc, retBlock);
        }

        rewriter.setInsertionPointToStart(continuationBlock);

        rewriter.eraseOp(op);
        return success();
    }
};

struct ReturnValOpLowering : public TsPattern<mlir_ts::ReturnValOp>
{
    using TsPattern<mlir_ts::ReturnValOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReturnValOp op, PatternRewriter &rewriter) const final
    {
        auto loc = op.getLoc();

        assert(tsContext->returnBlock);

        auto retBlock = tsContext->returnBlock;

        // save value into return
        rewriter.create<mlir_ts::StoreOp>(op.getLoc(), op.getOperand(), op.getReference());
        if (auto unwind = tsContext->unwind.lookup(op))
        {
            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }
        
        // Split block at `assert` operation.
        auto *opBlock = rewriter.getInsertionBlock();
        auto opPosition = rewriter.getInsertionPoint();
        auto *continuationBlock = rewriter.splitBlock(opBlock, opPosition);

        rewriter.setInsertionPointToEnd(opBlock);

        if (auto cleanup = tsContext->cleanup.lookup(op))
        {
            rewriter.create<mlir::cf::BranchOp>(loc, cleanup);
        }
        else
        {
            rewriter.create<mlir::cf::BranchOp>(loc, retBlock);
        }

        rewriter.setInsertionPointToStart(continuationBlock);

        rewriter.eraseOp(op);
        return success();
    }
};

struct ParamOpLowering : public TsPattern<mlir_ts::ParamOp>
{
    using TsPattern<mlir_ts::ParamOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ParamOp paramOp, PatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<mlir_ts::VariableOp>(paramOp, paramOp.getType(), paramOp.getArgValue(),
                                                         paramOp.getCapturedAttr(), paramOp.getDiArgNumberAttr());
        return success();
    }
};

struct ParamOptionalOpLowering : public TsPattern<mlir_ts::ParamOptionalOp>
{
    using TsPattern<mlir_ts::ParamOptionalOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ParamOptionalOp paramOp, PatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);

        auto location = paramOp.getLoc();

        auto dataTypeIn = cast<mlir_ts::OptionalType>(paramOp.getArgValue().getType()).getElementType();
        auto storeType = cast<mlir_ts::RefType>(paramOp.getType()).getElementType();

        // ts.if
        auto hasValue = rewriter.create<mlir_ts::HasValueOp>(location, th.getBooleanType(), paramOp.getArgValue());
        auto ifOp = rewriter.create<mlir_ts::IfOp>(location, storeType, hasValue, true);

        // then block
        auto &thenRegion = ifOp.getThenRegion();

        rewriter.setInsertionPointToStart(&thenRegion.back());

        mlir::Value value = rewriter.create<mlir_ts::ValueOp>(location, storeType, paramOp.getArgValue());
        rewriter.create<mlir_ts::ResultOp>(location, value);

        // else block
        auto &elseRegion = ifOp.getElseRegion();

        rewriter.setInsertionPointToStart(&elseRegion.back());

        rewriter.inlineRegionBefore(paramOp.getDefaultValueRegion(), &ifOp.getElseRegion().back());
        // TODO: do I need next line?
        rewriter.eraseBlock(&ifOp.getElseRegion().back());

        rewriter.setInsertionPointAfter(ifOp);

        auto variable = rewriter.create<mlir_ts::VariableOp>(location, paramOp.getType(), ifOp.getResults().front(),
                                                             paramOp.getCapturedAttr(), paramOp.getDiArgNumberAttr());
        rewriter.replaceOp(paramOp, mlir::Value(variable));

        return success();
    }
};

struct ParamDefaultValueOpLowering : public TsPattern<mlir_ts::ParamDefaultValueOp>
{
    using TsPattern<mlir_ts::ParamDefaultValueOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ParamDefaultValueOp op, PatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<mlir_ts::ResultOp>(op, op.getResults());
        return success();
    }
};

struct OptionalValueOrDefaultOpLowering : public TsPattern<mlir_ts::OptionalValueOrDefaultOp>
{
    using TsPattern<mlir_ts::OptionalValueOrDefaultOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::OptionalValueOrDefaultOp optionalValueOrDefaultOp, PatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);

        auto location = optionalValueOrDefaultOp.getLoc();

        auto dataTypeIn = cast<mlir_ts::OptionalType>(optionalValueOrDefaultOp.getArgValue().getType()).getElementType();
        auto resultType = optionalValueOrDefaultOp.getType();

        // ts.if
        auto hasValue = rewriter.create<mlir_ts::HasValueOp>(location, th.getBooleanType(), optionalValueOrDefaultOp.getArgValue());
        auto ifOp = rewriter.create<mlir_ts::IfOp>(location, resultType, hasValue, true);

        // then block
        auto &thenRegion = ifOp.getThenRegion();

        rewriter.setInsertionPointToStart(&thenRegion.back());

        mlir::Value value = rewriter.create<mlir_ts::ValueOp>(location, resultType, optionalValueOrDefaultOp.getArgValue());
        rewriter.create<mlir_ts::ResultOp>(location, value);

        // else block
        auto &elseRegion = ifOp.getElseRegion();

        rewriter.setInsertionPointToStart(&elseRegion.back());

        rewriter.inlineRegionBefore(optionalValueOrDefaultOp.getDefaultValueRegion(), &ifOp.getElseRegion().back());
        // TODO: do I need next line?
        rewriter.eraseBlock(&ifOp.getElseRegion().back());

        rewriter.setInsertionPointAfter(ifOp);

        rewriter.replaceOp(optionalValueOrDefaultOp, ifOp.getResults().front());

        return success();
    }
};

struct PrefixUnaryOpLowering : public TsPattern<mlir_ts::PrefixUnaryOp>
{
    using TsPattern<mlir_ts::PrefixUnaryOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::PrefixUnaryOp op, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(op, rewriter);
        mlir::Value cst1 = rewriter.create<mlir_ts::ConstantOp>(op->getLoc(), rewriter.getI32IntegerAttr(1));

        SyntaxKind opCode = SyntaxKind::Unknown;
        switch ((SyntaxKind)op.getOpCode())
        {
        case SyntaxKind::PlusPlusToken:
            opCode = SyntaxKind::PlusToken;
            break;
        case SyntaxKind::MinusMinusToken:
            opCode = SyntaxKind::MinusToken;
            break;
        }

        auto value = op.getOperand1();
        auto effectiveType = op.getType();
        bool castBack = false;
        if (auto optType = dyn_cast<mlir_ts::OptionalType>(effectiveType))
        {
            castBack = true;
            effectiveType = optType.getElementType();
            value = rewriter.create<mlir_ts::CastOp>(value.getLoc(), effectiveType, value);
        }

        if (value.getType() != cst1.getType())
        {
            cst1 = rewriter.create<mlir_ts::CastOp>(value.getLoc(), value.getType(), cst1);
        }

        mlir::Value result = rewriter.create<mlir_ts::ArithmeticBinaryOp>(
            op->getLoc(), effectiveType, rewriter.getI32IntegerAttr(static_cast<int32_t>(opCode)), value, cst1);

        if (castBack)
        {
            result = rewriter.create<mlir_ts::CastOp>(value.getLoc(), op.getType(), result);
        }

        rewriter.replaceOp(op, result);

        clh.saveResult(op, op->getResult(0));

        return success();
    }
};

struct PostfixUnaryOpLowering : public TsPattern<mlir_ts::PostfixUnaryOp>
{
    using TsPattern<mlir_ts::PostfixUnaryOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::PostfixUnaryOp op, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(op, rewriter);
        mlir::Value cst1 = rewriter.create<mlir_ts::ConstantOp>(op->getLoc(), rewriter.getI32IntegerAttr(1));

        SyntaxKind opCode = SyntaxKind::Unknown;
        switch ((SyntaxKind)op.getOpCode())
        {
        case SyntaxKind::PlusPlusToken:
            opCode = SyntaxKind::PlusToken;
            break;
        case SyntaxKind::MinusMinusToken:
            opCode = SyntaxKind::MinusToken;
            break;
        }

        auto value = op.getOperand1();
        auto effectiveType = op.getType();
        bool castBack = false;
        if (auto optType = dyn_cast<mlir_ts::OptionalType>(effectiveType))
        {
            castBack = true;
            effectiveType = optType.getElementType();
            value = rewriter.create<mlir_ts::CastOp>(value.getLoc(), effectiveType, value);
        }

        if (value.getType() != cst1.getType())
        {
            cst1 = rewriter.create<mlir_ts::CastOp>(value.getLoc(), value.getType(), cst1);
        }

        mlir::Value result = rewriter.create<mlir_ts::ArithmeticBinaryOp>(
            op->getLoc(), effectiveType, rewriter.getI32IntegerAttr(static_cast<int32_t>(opCode)), value, cst1);
        if (castBack)
        {
            result = rewriter.create<mlir_ts::CastOp>(value.getLoc(), op.getType(), result);
        }

        clh.saveResult(op, result);

        rewriter.replaceOp(op, op.getOperand1());

        return success();
    }
};

struct IfOpLowering : public TsPattern<mlir_ts::IfOp>
{
    using TsPattern<mlir_ts::IfOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::IfOp ifOp, PatternRewriter &rewriter) const final
    {
        auto loc = ifOp.getLoc();

        // Start by splitting the block containing the 'ts.if' into two parts.
        // The part before will contain the condition, the part after will be the
        // continuation point.
        auto *condBlock = rewriter.getInsertionBlock();
        auto opPosition = rewriter.getInsertionPoint();
        auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
        mlir::Block *continueBlock;
        if (ifOp.getNumResults() == 0)
        {
            continueBlock = remainingOpsBlock;
        }
        else
        {
            continueBlock =
                rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes(),
                                     SmallVector<Location>(ifOp->getNumResults(), ifOp.getLoc()));
            rewriter.create<mlir::cf::BranchOp>(loc, remainingOpsBlock);
        }

        // Move blocks from the "then" region to the region containing 'ts.if',
        // place it before the continuation block, and branch to it.
        auto &thenRegion = ifOp.getThenRegion();
        auto *thenBlock = &thenRegion.front();
        Operation *thenTerminator = thenRegion.back().getTerminator();
        ValueRange thenTerminatorOperands = thenTerminator->getOperands();
        rewriter.setInsertionPointToEnd(&thenRegion.back());
        rewriter.create<mlir::cf::BranchOp>(loc, continueBlock, thenTerminatorOperands);
        rewriter.eraseOp(thenTerminator);
        rewriter.inlineRegionBefore(thenRegion, continueBlock);

        // Move blocks from the "else" region (if present) to the region containing
        // 'ts.if', place it before the continuation block and branch to it.  It
        // will be placed after the "then" regions.
        auto *elseBlock = continueBlock;
        auto &elseRegion = ifOp.getElseRegion();
        if (!elseRegion.empty())
        {
            elseBlock = &elseRegion.front();
            Operation *elseTerminator = elseRegion.back().getTerminator();
            ValueRange elseTerminatorOperands = elseTerminator->getOperands();
            rewriter.setInsertionPointToEnd(&elseRegion.back());
            rewriter.create<mlir::cf::BranchOp>(loc, continueBlock, elseTerminatorOperands);
            rewriter.eraseOp(elseTerminator);
            rewriter.inlineRegionBefore(elseRegion, continueBlock);
        }

        rewriter.setInsertionPointToEnd(condBlock);
        auto castToI1 = rewriter.create<mlir_ts::DialectCastOp>(loc, rewriter.getI1Type(), ifOp.getCondition());
        rewriter.create<mlir::cf::CondBranchOp>(loc, castToI1, thenBlock,
                                      /*trueArgs=*/ArrayRef<mlir::Value>(), elseBlock,
                                      /*falseArgs=*/ArrayRef<mlir::Value>());

        // Ok, we're done!
        rewriter.replaceOp(ifOp, continueBlock->getArguments());

        LLVM_DEBUG(llvm::dbgs() << "\n!! IfOpLowering AFTER DUMP: \n" << *ifOp->getParentOp() << "\n";);

        return success();
    }
};

struct ResultOpLowering : public TsPattern<mlir_ts::ResultOp>
{
    using TsPattern<mlir_ts::ResultOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ResultOp resultOp, PatternRewriter &rewriter) const final
    {
        rewriter.eraseOp(resultOp);
        return success();
    }
};

// Populates tsContext->jumps for break/continue ops that belong to this loop/label scope.
// An unlabeled break/continue binds to the *nearest* enclosing loop (continue) or
// loop/switch (break), so once the walk descends past such a boundary it must stop
// treating unlabeled break/continue as claimable by this (outer) scope -- otherwise it can
// steal a jump target that belongs to the nested scope, depending on which scope's pattern
// happens to run last in the dialect-conversion worklist. A nested Switch is a boundary for
// unlabeled break only (switch doesn't own continue -- that still passes through to the
// enclosing loop). Labeled break/continue matching this scope's own label must still be found
// no matter how many boundaries are crossed, since a label may target an outer loop from deep
// inside nested loops/switches (e.g. `outer: while(...) { while(...) { break outer; } }`).
static void visitBreakContinueInScope(mlir::Region &region, mlir::StringAttr scopeLabel,
                                       bool eligibleForUnlabeledBreak, bool eligibleForUnlabeledContinue,
                                       llvm::function_ref<void(Operation *, bool)> onMatch)
{
    for (auto &block : region)
    {
        for (auto &op : block)
        {
            if (auto breakOp = dyn_cast<mlir_ts::BreakOp>(&op))
            {
                auto opLabel = breakOp.getLabelAttr();
                auto hasOwnLabel = opLabel && opLabel.getValue().size() > 0;
                if ((eligibleForUnlabeledBreak && !hasOwnLabel) ||
                    (hasOwnLabel && MLIRHelper::matchLabelOrNotSet(scopeLabel, opLabel)))
                {
                    onMatch(&op, /*isBreak*/ true);
                }

                continue;
            }

            if (auto continueOp = dyn_cast<mlir_ts::ContinueOp>(&op))
            {
                auto opLabel = continueOp.getLabelAttr();
                auto hasOwnLabel = opLabel && opLabel.getValue().size() > 0;
                if ((eligibleForUnlabeledContinue && !hasOwnLabel) ||
                    (hasOwnLabel && MLIRHelper::matchLabelOrNotSet(scopeLabel, opLabel)))
                {
                    onMatch(&op, /*isBreak*/ false);
                }

                continue;
            }

            // not a LabelOp: an unlabelled break or continue never targets a labelled block
            auto isLoopBoundary = isa<mlir_ts::WhileOp, mlir_ts::DoWhileOp, mlir_ts::ForOp>(op);
            auto isSwitchBoundary = isa<mlir_ts::SwitchOp>(op);

            for (auto &nested : op.getRegions())
            {
                visitBreakContinueInScope(nested, scopeLabel,
                                           eligibleForUnlabeledBreak && !isLoopBoundary && !isSwitchBoundary,
                                           eligibleForUnlabeledContinue && !isLoopBoundary, onMatch);
            }
        }
    }
}

struct WhileOpLowering : public TsPattern<mlir_ts::WhileOp>
{
    using TsPattern<mlir_ts::WhileOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::WhileOp whileOp, PatternRewriter &rewriter) const final
    {
        OpBuilder::InsertionGuard guard(rewriter);
        Location loc = whileOp.getLoc();

        auto labelAttr = whileOp->getAttrOfType<StringAttr>(LABEL_ATTR_NAME);

        // Split the current block before the WhileOp to create the inlining point.
        auto *currentBlock = rewriter.getInsertionBlock();
        auto *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        auto *body = &whileOp.getBody().front();
        auto *bodyLast = &whileOp.getBody().back();
        auto *cond = &whileOp.getCond().front();
        auto *condLast = &whileOp.getCond().back();

        // logic to support continue/break

        visitBreakContinueInScope(whileOp.getBody(), labelAttr, /*eligibleForUnlabeledBreak*/ true,
                                   /*eligibleForUnlabeledContinue*/ true, [&](Operation *op, bool isBreak) {
                                       tsContext->jumps[op] = isBreak ? continuation : cond;
                                   });

        // end of logic for break/continue

        rewriter.inlineRegionBefore(whileOp.getBody(), continuation);
        rewriter.inlineRegionBefore(whileOp.getCond(), body);

        // Branch to the "before" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(loc, cond, whileOp.getInits());

        // Replace terminators with branches. Assuming bodies are SESE, which holds
        // given only the patterns from this file, we only need to look at the last
        // block. This should be reconsidered if we allow break/continue.
        rewriter.setInsertionPointToEnd(condLast);
        auto condOp = cast<mlir_ts::ConditionOp>(condLast->getTerminator());
        auto castToI1 = rewriter.create<mlir_ts::CastOp>(loc, rewriter.getI1Type(), condOp.getCondition());
        rewriter.replaceOpWithNewOp<mlir::cf::CondBranchOp>(condOp, castToI1, body, condOp.getArgs(), continuation, ValueRange());

        rewriter.setInsertionPointToEnd(bodyLast);
        auto yieldOp = cast<mlir_ts::ResultOp>(bodyLast->getTerminator());
        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(yieldOp, cond, yieldOp.getResults());

        // Replace the op with values "yielded" from the "before" region, which are
        // visible by dominance.
        rewriter.replaceOp(whileOp, condOp.getArgs());

        return success();
    }
};

/// Optimized version of the above for the case of the "after" region merely
/// forwarding its arguments back to the "before" region (i.e., a "do-while"
/// loop). This avoid inlining the "after" region completely and branches back
/// to the "before" entry instead.
struct DoWhileOpLowering : public TsPattern<mlir_ts::DoWhileOp>
{
    using TsPattern<mlir_ts::DoWhileOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::DoWhileOp doWhileOp, PatternRewriter &rewriter) const final
    {
        Location loc = doWhileOp.getLoc();

        auto labelAttr = doWhileOp->getAttrOfType<StringAttr>(LABEL_ATTR_NAME);

        // Split the current block before the WhileOp to create the inlining point.
        OpBuilder::InsertionGuard guard(rewriter);
        mlir::Block *currentBlock = rewriter.getInsertionBlock();
        mlir::Block *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        // Only the "before" region should be inlined.
        auto *body = &doWhileOp.getBody().front();
        auto *bodyLast = &doWhileOp.getBody().back();
        auto *cond = &doWhileOp.getCond().front();
        auto *condLast = &doWhileOp.getCond().back();

        // logic to support continue/break

        visitBreakContinueInScope(doWhileOp.getBody(), labelAttr, /*eligibleForUnlabeledBreak*/ true,
                                   /*eligibleForUnlabeledContinue*/ true, [&](Operation *op, bool isBreak) {
                                       tsContext->jumps[op] = isBreak ? continuation : cond;
                                   });

        // end of logic for break/continue

        rewriter.inlineRegionBefore(doWhileOp.getCond(), continuation);
        rewriter.inlineRegionBefore(doWhileOp.getBody(), cond);

        // Branch to the "before" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(doWhileOp.getLoc(), body, doWhileOp.getInits());

        rewriter.setInsertionPointToEnd(bodyLast);
        auto yieldOp = cast<mlir_ts::ResultOp>(bodyLast->getTerminator());
        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(yieldOp, cond, yieldOp.getResults());

        // Loop around the "before" region based on condition.
        rewriter.setInsertionPointToEnd(condLast);
        auto condOp = cast<mlir_ts::ConditionOp>(condLast->getTerminator());
        auto castToI1 = rewriter.create<mlir_ts::CastOp>(loc, rewriter.getI1Type(), condOp.getCondition());
        rewriter.replaceOpWithNewOp<mlir::cf::CondBranchOp>(condOp, castToI1, body, condOp.getArgs(), continuation, ValueRange());

        // Replace the op with values "yielded" from the "before" region, which are
        // visible by dominance.
        rewriter.replaceOp(doWhileOp, condOp.getArgs());

        return success();
    }
};

struct ForOpLowering : public TsPattern<mlir_ts::ForOp>
{
    using TsPattern<mlir_ts::ForOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ForOp forOp, PatternRewriter &rewriter) const final
    {
        OpBuilder::InsertionGuard guard(rewriter);
        Location loc = forOp.getLoc();

        auto labelAttr = forOp->getAttrOfType<StringAttr>(LABEL_ATTR_NAME);

        // Split the current block before the WhileOp to create the inlining point.
        auto *currentBlock = rewriter.getInsertionBlock();
        auto *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        auto *incr = &forOp.getIncr().front();
        auto *incrLast = &forOp.getIncr().back();
        auto *body = &forOp.getBody().front();
        auto *bodyLast = &forOp.getBody().back();
        auto *cond = &forOp.getCond().front();
        auto *condLast = &forOp.getCond().back();

        // logic to support continue/break

        visitBreakContinueInScope(forOp.getBody(), labelAttr, /*eligibleForUnlabeledBreak*/ true,
                                   /*eligibleForUnlabeledContinue*/ true, [&](Operation *op, bool isBreak) {
                                       tsContext->jumps[op] = isBreak ? continuation : incr;
                                   });

        // end of logic for break/continue

        rewriter.inlineRegionBefore(forOp.getIncr(), continuation);
        rewriter.inlineRegionBefore(forOp.getBody(), incr);
        rewriter.inlineRegionBefore(forOp.getCond(), body);

        // Branch to the "before" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(loc, cond, forOp.getInits());

        // Replace terminators with branches. Assuming bodies are SESE, which holds
        // given only the patterns from this file, we only need to look at the last
        // block. This should be reconsidered if we allow break/continue.
        rewriter.setInsertionPointToEnd(condLast);
        ValueRange args;
        if (auto condOp = dyn_cast_or_null<mlir_ts::ConditionOp>(condLast->getTerminator()))
        {
            args = condOp.getArgs();
            auto castToI1 = rewriter.create<mlir_ts::CastOp>(loc, rewriter.getI1Type(), condOp.getCondition());
            rewriter.replaceOpWithNewOp<mlir::cf::CondBranchOp>(condOp, castToI1, body, condOp.getArgs(), continuation,
                                                      ValueRange());
        }
        else
        {
            auto noCondOp = cast<mlir_ts::NoConditionOp>(condLast->getTerminator());
            args = noCondOp.getArgs();
            rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(noCondOp, body, noCondOp.getArgs());
        }

        rewriter.setInsertionPointToEnd(bodyLast);

        auto yieldOpBody = cast<mlir_ts::ResultOp>(bodyLast->getTerminator());
        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(yieldOpBody, incr, yieldOpBody.getResults());

        rewriter.setInsertionPointToEnd(incrLast);

        auto yieldOpIncr = cast<mlir_ts::ResultOp>(incrLast->getTerminator());
        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(yieldOpIncr, cond, yieldOpIncr.getResults());

        // Replace the op with values "yielded" from the "before" region, which are
        // visible by dominance.
        rewriter.replaceOp(forOp, args);

        return success();
    }
};

struct LabelOpLowering : public TsPattern<mlir_ts::LabelOp>
{
    using TsPattern<mlir_ts::LabelOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::LabelOp labelOp, PatternRewriter &rewriter) const final
    {
        // Split the current block before the WhileOp to create the inlining point.
        OpBuilder::InsertionGuard guard(rewriter);
        Location loc = labelOp.getLoc();

        mlir::Block *currentBlock = rewriter.getInsertionBlock();
        mlir::Block *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        auto *begin = &labelOp.getLabelRegion().front();

        auto labelAttr = labelOp.getLabelAttr();

        // logic to support continue/break

        // only its own label: in JS an unlabelled break or continue in a labelled block belongs to the
        // loop or switch around it
        visitBreakContinueInScope(labelOp.getLabelRegion(), labelAttr, /*eligibleForUnlabeledBreak*/ false,
                                   /*eligibleForUnlabeledContinue*/ false, [&](Operation *op, bool isBreak) {
                                       tsContext->jumps[op] = isBreak ? continuation : begin;
                                   });

        // end of logic for break/continue

        auto *labelRegion = &labelOp.getLabelRegion().front();

        auto *labelRegionWithMerge = &labelOp.getLabelRegion().back();
        for (auto &block : labelOp.getLabelRegion())
        {
            if (isa<mlir_ts::MergeOp>(block.getTerminator()))
            {
                labelRegionWithMerge = &block;
            }
        }

        // Branch to the "labelRegion" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(loc, labelRegion, ValueRange{});

        rewriter.inlineRegionBefore(labelOp.getLabelRegion(), continuation);

        // replace merge with br
        assert(labelRegionWithMerge);
        rewriter.setInsertionPointToEnd(labelRegionWithMerge);

        if (auto mergeOp = dyn_cast_or_null<mlir_ts::MergeOp>(labelRegionWithMerge->getTerminator()))
        {
            rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(mergeOp, continuation, ValueRange{});
        }
        else
        {
            return rewriter.notifyMatchFailure(labelOp, "label region's last block does not terminate with MergeOp");
        }

        rewriter.replaceOp(labelOp, continuation->getArguments());

        return success();
    }
};

struct BreakOpLowering : public TsPattern<mlir_ts::BreakOp>
{
    using TsPattern<mlir_ts::BreakOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::BreakOp breakOp, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(breakOp, rewriter);

        OpBuilder::InsertionGuard guard(rewriter);
        Location loc = breakOp.getLoc();

        auto jump = tsContext->jumps.lookup(breakOp);
        assert(jump);

        if (auto unwind = tsContext->unwind.lookup(breakOp))
        {
            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }

        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(breakOp, jump);
        clh.CutBlock();

        return success();
    }
};

struct ContinueOpLowering : public TsPattern<mlir_ts::ContinueOp>
{
    using TsPattern<mlir_ts::ContinueOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ContinueOp continueOp, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(continueOp, rewriter);

        OpBuilder::InsertionGuard guard(rewriter);
        Location loc = continueOp.getLoc();

        auto jump = tsContext->jumps.lookup(continueOp);
        assert(jump);

        if (auto unwind = tsContext->unwind.lookup(continueOp))
        {
            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }

        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(continueOp, jump);
        clh.CutBlock();

        return success();
    }
};

struct SwitchOpLowering : public TsPattern<mlir_ts::SwitchOp>
{
    using TsPattern<mlir_ts::SwitchOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::SwitchOp switchOp, PatternRewriter &rewriter) const final
    {
        Location loc = switchOp.getLoc();

        // Split the current block before the WhileOp to create the inlining point.
        OpBuilder::InsertionGuard guard(rewriter);
        mlir::Block *currentBlock = rewriter.getInsertionBlock();
        mlir::Block *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        auto *casesRegion = &switchOp.getCasesRegion().front();

        auto *casesRegionWithMerge = &switchOp.getCasesRegion().back();
        for (auto &block : switchOp.getCasesRegion())
        {
            if (isa<mlir_ts::MergeOp>(block.getTerminator()))
            {
                casesRegionWithMerge = &block;
            }
        }

        // Branch to the "casesRegion" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(loc, casesRegion, ValueRange{});

        rewriter.inlineRegionBefore(switchOp.getCasesRegion(), continuation);

        // replace merge with br
        assert(casesRegionWithMerge);
        rewriter.setInsertionPointToEnd(casesRegionWithMerge);

        if (auto mergeOp = dyn_cast_or_null<mlir_ts::MergeOp>(casesRegionWithMerge->getTerminator()))
        {
            rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(mergeOp, continuation, ValueRange{});
        }
        else
        {
            return rewriter.notifyMatchFailure(switchOp, "cases region's last block does not terminate with MergeOp");
        }

        rewriter.replaceOp(switchOp, continuation->getArguments());

        return success();
    }
};

struct AccessorOpLowering : public TsPattern<mlir_ts::AccessorOp>
{
    using TsPattern<mlir_ts::AccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::AccessorOp accessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = accessorOp.getLoc();

        if (accessorOp.getSetValue())
        {
            if (!accessorOp.getSetAccessor().has_value())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            auto callRes = rewriter.create<mlir_ts::CallOp>(loc, accessorOp.getSetAccessor().value(),
                                mlir::TypeRange{}, mlir::ValueRange{accessorOp.getSetValue()});        
        }

        if (accessorOp.getNumResults() > 0)
        {
            if (!accessorOp.getGetAccessor().has_value())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto callRes = rewriter.create<mlir_ts::CallOp>(loc, accessorOp.getGetAccessor().value(),
                                                            TypeRange{accessorOp.getType(0)}, ValueRange{});

            rewriter.replaceOp(accessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(accessorOp);
        }

        return success();
    }
};

struct ThisAccessorOpLowering : public TsPattern<mlir_ts::ThisAccessorOp>
{
    using TsPattern<mlir_ts::ThisAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThisAccessorOp thisAccessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = thisAccessorOp.getLoc();

        if (thisAccessorOp.getSetValue())
        {
            if (!thisAccessorOp.getSetAccessor().has_value())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            rewriter.create<mlir_ts::CallOp>(loc, thisAccessorOp.getSetAccessor().value(),
                mlir::TypeRange{}, mlir::ValueRange{thisAccessorOp.getThisVal(), thisAccessorOp.getSetValue()});
        }

        if (thisAccessorOp.getNumResults() > 0)
        {
            if (!thisAccessorOp.getGetAccessor().has_value())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto callRes =
                rewriter.create<mlir_ts::CallOp>(loc, thisAccessorOp.getGetAccessor().value(),
                    TypeRange{thisAccessorOp.getType(0)}, ValueRange{thisAccessorOp.getThisVal()});

            rewriter.replaceOp(thisAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(thisAccessorOp);
        }

        return success();
    }
};

struct ThisIndirectAccessorOpLowering : public TsPattern<mlir_ts::ThisIndirectAccessorOp>
{
    using TsPattern<mlir_ts::ThisIndirectAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThisIndirectAccessorOp thisIndirectAccessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = thisIndirectAccessorOp.getLoc();

        if (thisIndirectAccessorOp.getSetValue())
        {
            // set case
            if (thisIndirectAccessorOp.getSetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{}, 
                thisIndirectAccessorOp.getSetAccessor(), ValueRange{thisIndirectAccessorOp.getThisVal(), 
                thisIndirectAccessorOp.getSetValue()});                
        }

        if (thisIndirectAccessorOp.getNumResults() > 0)
        {
            // get case
            if (thisIndirectAccessorOp.getGetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto callRes = rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{thisIndirectAccessorOp.getType(0)}, 
                    thisIndirectAccessorOp.getGetAccessor(), ValueRange{thisIndirectAccessorOp.getThisVal()});

            rewriter.replaceOp(thisIndirectAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(thisIndirectAccessorOp);
        }

        return success();
    }
};

struct ThisIndexAccessorOpLowering : public TsPattern<mlir_ts::ThisIndexAccessorOp>
{
    using TsPattern<mlir_ts::ThisIndexAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThisIndexAccessorOp thisIndexAccessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = thisIndexAccessorOp.getLoc();

        if (thisIndexAccessorOp.getSetValue())
        {
            if (!thisIndexAccessorOp.getSetAccessor().has_value())
            {
                emitError(loc) << "property does not have an index set accessor";
                return mlir::failure();
            }

            rewriter.create<mlir_ts::CallOp>(loc, thisIndexAccessorOp.getSetAccessor().value(),
                mlir::TypeRange{}, mlir::ValueRange{thisIndexAccessorOp.getThisVal(), 
                    thisIndexAccessorOp.getIndex(), thisIndexAccessorOp.getSetValue()});
        }

        if (thisIndexAccessorOp.getNumResults() > 0)
        {
            if (!thisIndexAccessorOp.getGetAccessor().has_value())
            {
                emitError(loc) << "property does not have an index get accessor";
                return failure();
            }

            auto callRes =
                rewriter.create<mlir_ts::CallOp>(loc, thisIndexAccessorOp.getGetAccessor().value(),
                    TypeRange{thisIndexAccessorOp.getType(0)}, 
                        ValueRange{thisIndexAccessorOp.getThisVal(), thisIndexAccessorOp.getIndex()});

            rewriter.replaceOp(thisIndexAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(thisIndexAccessorOp);
        }

        return success();
    }
};

struct ThisIndirectIndexAccessorOpLowering : public TsPattern<mlir_ts::ThisIndirectIndexAccessorOp>
{
    using TsPattern<mlir_ts::ThisIndirectIndexAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThisIndirectIndexAccessorOp thisIndirectIndexAccessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = thisIndirectIndexAccessorOp.getLoc();

        if (thisIndirectIndexAccessorOp.getSetValue())
        {
            if (thisIndirectIndexAccessorOp.getSetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{}, thisIndirectIndexAccessorOp.getSetAccessor(),
                mlir::ValueRange{thisIndirectIndexAccessorOp.getThisVal(), 
                    thisIndirectIndexAccessorOp.getIndex(), thisIndirectIndexAccessorOp.getSetValue()});
        }

        if (thisIndirectIndexAccessorOp.getNumResults() > 0)
        {
            if (thisIndirectIndexAccessorOp.getGetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto callRes =
                rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{thisIndirectIndexAccessorOp.getType(0)}, thisIndirectIndexAccessorOp.getGetAccessor(), 
                        ValueRange{thisIndirectIndexAccessorOp.getThisVal(), thisIndirectIndexAccessorOp.getIndex()});

            rewriter.replaceOp(thisIndirectIndexAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(thisIndirectIndexAccessorOp);
        }

        return success();
    }
};

struct BoundIndirectAccessorOpLowering : public TsPattern<mlir_ts::BoundIndirectAccessorOp>
{
    using TsPattern<mlir_ts::BoundIndirectAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::BoundIndirectAccessorOp boundIndirectAccessorOp, PatternRewriter &rewriter) const final
    {
        auto loc = boundIndirectAccessorOp.getLoc();

        auto opaqueType = mlir_ts::OpaqueType::get(rewriter.getContext());
        if (boundIndirectAccessorOp.getSetValue())
        {
            // set case
            if (boundIndirectAccessorOp.getSetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            auto boundFuncType = boundIndirectAccessorOp.getSetAccessor().getType();
            auto funcType = mlir_ts::FunctionType::get(
                rewriter.getContext(), 
                boundFuncType.getInputs(), 
                boundFuncType.getResults());

            auto thisOp = rewriter.create<mlir_ts::GetThisOp>(loc, opaqueType, boundIndirectAccessorOp.getSetAccessor());
            auto methodOp = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, boundIndirectAccessorOp.getSetAccessor());

            rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{}, 
                methodOp, ValueRange{thisOp, boundIndirectAccessorOp.getSetValue()});                
        }

        if (boundIndirectAccessorOp.getNumResults() > 0)
        {
            // get case
            if (boundIndirectAccessorOp.getGetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto boundFuncType = boundIndirectAccessorOp.getGetAccessor().getType();
            auto funcType = mlir_ts::FunctionType::get(
                rewriter.getContext(), 
                boundFuncType.getInputs(), 
                boundFuncType.getResults());

            auto thisOp = rewriter.create<mlir_ts::GetThisOp>(loc, opaqueType, boundIndirectAccessorOp.getGetAccessor());
            auto methodOp = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, boundIndirectAccessorOp.getGetAccessor());

            auto callRes = rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{boundIndirectAccessorOp.getType(0)}, 
                    methodOp, ValueRange{thisOp});

            rewriter.replaceOp(boundIndirectAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(boundIndirectAccessorOp);
        }

        return success();
    }
};

struct BoundIndirectIndexAccessorOpLowering : public TsPattern<mlir_ts::BoundIndirectIndexAccessorOp>
{
    using TsPattern<mlir_ts::BoundIndirectIndexAccessorOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::BoundIndirectIndexAccessorOp boundIndirectIndexAccessorOp, PatternRewriter &rewriter) const final
    {
        Location loc = boundIndirectIndexAccessorOp.getLoc();
 
        auto opaqueType = mlir_ts::OpaqueType::get(rewriter.getContext());
        if (boundIndirectIndexAccessorOp.getSetValue())
        {
            if (boundIndirectIndexAccessorOp.getSetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have set accessor";
                return mlir::failure();
            }

            auto boundFuncType = boundIndirectIndexAccessorOp.getSetAccessor().getType();
            auto funcType = mlir_ts::FunctionType::get(
                rewriter.getContext(), 
                boundFuncType.getInputs(), 
                boundFuncType.getResults());

            auto thisOp = rewriter.create<mlir_ts::GetThisOp>(loc, opaqueType, boundIndirectIndexAccessorOp.getSetAccessor());
            auto methodOp = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, boundIndirectIndexAccessorOp.getSetAccessor());

            rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{}, methodOp, mlir::ValueRange{thisOp, 
                    boundIndirectIndexAccessorOp.getIndex(), boundIndirectIndexAccessorOp.getSetValue()});
        }

        if (boundIndirectIndexAccessorOp.getNumResults() > 0)
        {
            if (boundIndirectIndexAccessorOp.getGetAccessor().getDefiningOp<mlir_ts::UndefOp>())
            {
                emitError(loc) << "property does not have get accessor";
                return failure();
            }

            auto boundFuncType = boundIndirectIndexAccessorOp.getGetAccessor().getType();
            auto funcType = mlir_ts::FunctionType::get(
                rewriter.getContext(), 
                boundFuncType.getInputs(), 
                boundFuncType.getResults());

            auto thisOp = rewriter.create<mlir_ts::GetThisOp>(loc, opaqueType, boundIndirectIndexAccessorOp.getGetAccessor());
            auto methodOp = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, boundIndirectIndexAccessorOp.getGetAccessor());

            auto callRes =
                rewriter.create<mlir_ts::CallIndirectOp>(loc, TypeRange{boundIndirectIndexAccessorOp.getType(0)}, 
                methodOp, ValueRange{thisOp, boundIndirectIndexAccessorOp.getIndex()});

            rewriter.replaceOp(boundIndirectIndexAccessorOp, callRes.getResult(0));
        }
        else
        {
            rewriter.eraseOp(boundIndirectIndexAccessorOp);
        }

        return success();
    }
};


// Does this operation sit in the cleanup region of a scope nested inside the one being lowered?
//
// It matters because everything in a cleanup region runs while an exception is already on its
// way out. Giving a call written there an unwind edge to the enclosing scope's landing pad means
// that if it throws, whatever the inner cleanup had left to do is stepped over - and what it has
// left to do is give back the references its own locals took. The ownership verifier reports
// exactly that on the nested `using` scopes of `00break_continue_scope_exit.ts`; see section 9.62.
//
// The outermost cleanup of a function has never had such an edge, because nothing encloses it,
// so leaving these calls alone is what makes every cleanup agree with the one that was already
// right. The price is the C++ rule: a `[Symbol.dispose]()` that throws while unwinding
// terminates rather than continuing outwards.
//
// The walk goes all the way up rather than stopping at the scope being lowered - by this point
// that scope's blocks have been inlined into the enclosing region, so it is no longer an
// ancestor. That would misread a `TryOp` written *inside* a cleanup region, which nothing
// generates: cleanup regions hold scope exits only, and a `TryOp` in one is the construct
// section 9.11 records as already broken.
static bool isInsideNestedCleanupRegion(mlir::Operation *op)
{
    for (auto *region = op->getParentRegion(); region != nullptr; region = region->getParentRegion())
    {
        auto *owner = region->getParentOp();
        if (owner == nullptr)
        {
            break;
        }

        if (auto tryOp = dyn_cast<mlir_ts::TryOp>(owner))
        {
            if (region == &tryOp.getCleanup())
            {
                return true;
            }
        }
    }

    return false;
}

struct TryOpLowering : public TsPattern<mlir_ts::TryOp>
{
    using TsPattern<mlir_ts::TryOp>::TsPattern;

    TryOpLowering(MLIRContext *context, TSContext *tsContext, TSFunctionContext *tsFuncContext,
                  PatternBenefit benefit = 1)
        : TsPattern<mlir_ts::TryOp>(context, tsContext, tsFuncContext, benefit)
    {
        // a `try` nested inside its own `finally` block gets cloned (not just moved) as part
        // of lowering the outer TryOp, so the dialect-conversion driver legalizes the inner
        // TryOp recursively while the outer TryOp's own pattern application is still on the
        // stack. Without this, the conversion driver's single-pattern-instance recursion guard
        // refuses to reapply this same pattern object and the whole outer TryOp fails to
        // legalize. Recursion here is bounded: each application strictly consumes one TryOp.
        setHasBoundedRewriteRecursion();
    }

    // TODO: set 'loc' correctly to newly created ops
    LogicalResult matchAndRewrite(mlir_ts::TryOp tryOp, PatternRewriter &rewriter) const final
    {
        Location loc = tryOp.getLoc();

        LLVM_DEBUG(llvm::dbgs() << "\n!! BEFORE TRY OP DUMP: \n" << *tryOp->getParentOp() << "\n";);

        MLIRTypeHelper mth(rewriter.getContext(), tsContext->compileOptions);
        CodeLogicHelper clh(tryOp, rewriter);

        auto module = tryOp->getParentOfType<mlir::ModuleOp>();
        auto parentTryOp = tsContext->parentTryOp.lookup(tryOp.getOperation());

        // Where an exception this try does not catch has to go next within the function: the
        // parent's landing pad for a try in the parent's body, the parent's finally for one in
        // the parent's catch clause (whose exceptions the parent does not catch, but whose
        // finally still has to run), and nowhere - the caller - when no try around it takes it.
        //
        // Not just the parent: a try in the parent's catch clause (with no parent finally) or in
        // the parent's finally hands its exception on to wherever the *parent's* would go, and
        // so on up. Looking one level only, such a try sent it to the parent's own landing pad -
        // the handler already running, which on Windows caught it again, forever - or, finding
        // no finally, to the caller, past a try around the parent that was there to catch it.
        // Every try around this one has been lowered by now, so their blocks are known.
        mlir::Block *enclosingHandler = nullptr;
        for (Operation *child = tryOp.getOperation(), *parent = parentTryOp; parent;
             child = parent, parent = tsContext->parentTryOp.lookup(parent))
        {
            if (tsContext->inParentTryBody.lookup(child))
            {
                enclosingHandler = tsContext->landingBlockOf.lookup(parent);
            }
            else if (tsContext->inParentTryCatch.lookup(child))
            {
                enclosingHandler = tsContext->finallyBlockOf.lookup(parent);
            }

            if (enclosingHandler)
            {
                break;
            }
        }

        MLIRRTTIHelperVC rttih(rewriter, module, tsContext->compileOptions);
        auto i8PtrTy = mth.getOpaqueType();

        // Windows: which catch funclet this try's pads are nested in - the catch clause of the
        // nearest try around it that holds it in its catch, through any try bodies in between.
        // Win32ExceptionPass cannot tell that from the IR: a pad reached from inside a catch is
        // either a try nested in it or where exceptions leave it, and the two look alike. A try
        // in a finally is left at the top, as every pad was before.
        auto funcletParentId = 0;
        if (tsContext->compileOptions.isWindows)
        {
            for (Operation *child = tryOp.getOperation(), *parent = parentTryOp; parent;
                 child = parent, parent = tsContext->parentTryOp.lookup(parent))
            {
                if (tsContext->inParentTryCatch.lookup(child))
                {
                    funcletParentId = tsContext->catchPadIdOf.lookup(parent);
                    break;
                }

                if (!tsContext->inParentTryBody.lookup(child))
                {
                    break;
                }
            }
        }

        auto catchPadId = 0;
        auto tagPad = [&](mlir_ts::LandingPadOp landingPadOp, bool isCatchPad) {
            if (!tsContext->compileOptions.isWindows)
            {
                return;
            }

            if (isCatchPad && catchPadId)
            {
                landingPadOp->setAttr(EH_PAD_ID_ATTR_NAME, rewriter.getI32IntegerAttr(catchPadId));
            }

            if (funcletParentId)
            {
                landingPadOp->setAttr(EH_PAD_PARENT_ATTR_NAME, rewriter.getI32IntegerAttr(funcletParentId));
            }
        };

        // find catch var
        //
        // This region walk must stop at a nested `try`: a `try/catch` written inside a catch
        // clause puts a second CatchOp in this region, and picking it up here means setting the
        // RTTI type from the *inner* clause and pointing catchOpPtr at a catch that belongs to
        // another try. That is a wrong type filter on this try's landing pad, which faults at
        // run time in every memory model at every optimisation level (the debug assert below
        // fires on it first). A nested try is lowered by its own application of this pattern,
        // which finds its own catch there.
        //
        // Pre-order, because `skip()` only prunes the regions still to come - a post-order walk
        // has already visited them by the time the callback sees the TryOp.
        Operation *catchOpPtr = nullptr;
        mlir::Type catchVarType;
        auto visitorCatchContinue = [&](Operation *op) {
            if (op != tryOp.getOperation() && isa<mlir_ts::TryOp>(op))
            {
                return WalkResult::skip();
            }

            if (auto catchOp = dyn_cast_or_null<mlir_ts::CatchOp>(op))
            {
                catchVarType = cast<mlir_ts::RefType>(catchOp.getCatchArg().getType()).getElementType();
                rttih.setType(catchVarType);
                assert(!catchOpPtr);
                catchOpPtr = op;
            }

            return WalkResult::advance();
        };
        tryOp.getCatches().walk<mlir::WalkOrder::PreOrder>(visitorCatchContinue);

        // set TryOp -> child TryOp
        auto inBody = false;
        auto inCatch = false;
        auto visitorTryOps = [&](Operation *op) {
            if (auto childTryOp = dyn_cast_or_null<mlir_ts::TryOp>(op))
            {
                tsContext->parentTryOp[op] = tryOp.getOperation();
                tsContext->inParentTryBody[op] = inBody;
                tsContext->inParentTryCatch[op] = inCatch;
            }
        };
        inBody = true;
        tryOp.getBody().walk(visitorTryOps);
        inBody = false;
        inCatch = true;
        tryOp.getCatches().walk(visitorTryOps);
        inCatch = false;
        tryOp.getFinally().walk(visitorTryOps);

        mlir::SmallVector<Operation *> returns;
        auto visitorReturnOps = [&](Operation *op) {
            if (auto returnOp = dyn_cast_or_null<mlir_ts::ReturnOp>(op))
            {
                returns.push_back(op);
            }
            else if (auto returnValOp = dyn_cast_or_null<mlir_ts::ReturnValOp>(op))
            {
                returns.push_back(op);
            }
        };
        tryOp.getBody().walk(visitorReturnOps);
        tryOp.getCatches().walk(visitorReturnOps);

        // break/continue ops in the body/catches that jump OUT of this try already have their
        // tsContext->jumps entry resolved (the target loop/label encloses the try, so its
        // lowering ran first); ones targeting a construct inside the try don't have one yet.
        // Escaping jumps must run `finally` on the way out, the same way `return` does --
        // collected here (before the regions are inlined/emptied), rerouted through their own
        // finally copy below. Ops directly inside the finally region itself are deliberately
        // not collected: a break/continue there aborts the rest of the finally and jumps
        // straight out (and its wiring in the cloned copies is handled by the side-table
        // propagation below).
        mlir::SmallVector<Operation *> escapingJumpsBody;
        mlir::SmallVector<Operation *> escapingJumpsCatches;
        auto collectEscapingJumps = [&](mlir::Region &region, mlir::SmallVector<Operation *> &to) {
            region.walk([&](Operation *op) {
                if (isa<mlir_ts::BreakOp, mlir_ts::ContinueOp>(op) && tsContext->jumps.contains(op))
                {
                    to.push_back(op);
                }
            });
        };
        collectEscapingJumps(tryOp.getBody(), escapingJumpsBody);
        collectEscapingJumps(tryOp.getCatches(), escapingJumpsCatches);

        // inline structure
        OpBuilder::InsertionGuard guard(rewriter);
        mlir::Block *currentBlock = rewriter.getInsertionBlock();
        mlir::Block *continuation = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());

        auto cleanupHasOps =
            llvm::any_of(tryOp.getCleanup(), [](auto &block) { return &block.front() != block.getTerminator(); });
        auto catchHasOps =
            llvm::any_of(tryOp.getCatches(), [](auto &block) { return &block.front() != block.getTerminator(); });
        auto finallyHasOps =
            llvm::any_of(tryOp.getFinally(), [](auto &block) { return &block.front() != block.getTerminator(); });

        // body
        rewriter.inlineRegionBefore(tryOp.getBody(), continuation);
        auto bodyBlock = currentBlock->getNextNode();
        auto bodyBlockLast = continuation->getPrevNode();

        // Branch to the "body" region.
        rewriter.setInsertionPointToEnd(currentBlock);
        rewriter.create<mlir::cf::BranchOp>(loc, bodyBlock, ValueRange{});

        // cleanup
        auto linuxHasCleanups = cleanupHasOps && !tsContext->compileOptions.isWindows;
        mlir::Block * cleanupBlock = nullptr;
        mlir::Block * cleanupBlockLast = nullptr;
        if (cleanupHasOps)
        {
            rewriter.inlineRegionBefore(tryOp.getCleanup(), continuation);
            cleanupBlock = bodyBlockLast->getNextNode();
            cleanupBlockLast = continuation->getPrevNode();
        }
        else
        {
            while (!tryOp.getCleanup().empty())
            {
                rewriter.eraseBlock(&tryOp.getCleanup().front());
            }
        }

        // catch
        // in case of WIN32 we do not need catch logic if we have only finally
        mlir::Block * catchesBlock = nullptr;
        mlir::Block * catchesBlockLast = nullptr;
        if (catchHasOps)
        {
            rewriter.inlineRegionBefore(tryOp.getCatches(), continuation);
            catchesBlock = (cleanupBlockLast ? cleanupBlockLast : bodyBlockLast)->getNextNode();
            catchesBlockLast = continuation->getPrevNode();        

            // logic to set Invoke attribute CallOp
            auto visitorReturnOpContinue = [&](Operation *op) {
                if (auto returnOp = dyn_cast_or_null<mlir_ts::ReturnOp>(op))
                {
                    tsContext->unwind[op] = catchesBlock;
                }
                else if (auto returnValOp = dyn_cast_or_null<mlir_ts::ReturnValOp>(op))
                {
                    tsContext->unwind[op] = catchesBlock;
                }
                else if (auto throwOp = dyn_cast_or_null<mlir_ts::ThrowOp>(op))
                {
                    // A throw leaves the catch clause just as abruptly as a return does, and
                    // owes the same end-of-catch. It cannot be recorded in `unwind` with the
                    // others: for a throw that map already means its invoke destination, and
                    // the finally handling below writes exactly that into it.
                    //
                    // Only when there is no finally, though. With one, that same handling
                    // turns this throw into an invoke into the finally block, and the finally
                    // is what ends the catch - ending it here as well runs it twice and
                    // breaks the unwind (51exceptions.ts is the case that proves it).
                    //
                    // A throw inside a try nested in this catch does not leave the catch: the
                    // nested try's pad takes it, and on Windows Win32ExceptionPass nests that
                    // pad in this catch's funclet. It used to end the catch first, when the pass
                    // could not nest pads - which, with a `using` in the nested try, ended the
                    // catch between the using's first call and its throw, both unwinding to the
                    // same cleanup pad: one edge inside the funclet and one outside it, which
                    // the verifier rejects. The Itanium path has no funclets and keeps ending
                    // the catch there, as it always did.
                    auto inNestedTry = op->getParentOfType<mlir_ts::TryOp>() != nullptr;
                    auto leaves = tsContext->compileOptions.isWindows ? !finallyHasOps && !inNestedTry
                                                                     : !finallyHasOps || inNestedTry;
                    if (leaves)
                    {
                        tsContext->leavesCatch[op] = true;
                    }
                }
            };
            auto it = catchesBlock;
            do
            {
                it->walk(visitorReturnOpContinue);
                if (it != catchesBlockLast)
                {
                    it = it->getNextNode();
                    continue;
                }
            } while (false);
        }
        else
        {
            while (!tryOp.getCatches().empty())
            {
                rewriter.eraseBlock(&tryOp.getCatches().front());
            }
        }

        mlir::Block *finallyBlock = nullptr;
        mlir::Block *finallyBlockLast = nullptr;
        mlir::Block *exitBlockLast = nullptr;
        if (finallyHasOps)
        {
            // cloneRegionBefore makes brand-new Operation* instances, so any tsContext
            // side-table entry (jumps[], parentTryOp[]) keyed on the original finally
            // region's ops -- populated by visitorTryOps above, or by an enclosing loop's
            // break/continue-scope walk that ran before this try was lowered -- would
            // silently be missing for the clones. Re-propagate those entries onto each
            // clone via the IRMapping so a nested try/break/continue inside `finally`
            // keeps correct wiring in all copies, not just the final inlined one.
            auto propagateTsContextEntries = [&](const mlir::IRMapping &mapping) {
                for (auto &[oldOp, newOp] : mapping.getOperationMap())
                {
                    if (auto jump = tsContext->jumps.lookup(oldOp))
                    {
                        tsContext->jumps[newOp] = jump;
                    }

                    if (auto parent = tsContext->parentTryOp.lookup(oldOp))
                    {
                        tsContext->parentTryOp[newOp] = parent;
                        tsContext->inParentTryBody[newOp] = tsContext->inParentTryBody.lookup(oldOp);
                        tsContext->inParentTryCatch[newOp] = tsContext->inParentTryCatch.lookup(oldOp);
                    }
                }
            };

            auto beforeFinallyBlock = continuation->getPrevNode();
            mlir::IRMapping finallyMapping;
            rewriter.cloneRegionBefore(tryOp.getFinally(), *continuation->getParent(), continuation->getIterator(),
                                        finallyMapping);
            propagateTsContextEntries(finallyMapping);
            finallyBlock = beforeFinallyBlock->getNextNode();
            tsContext->finallyBlockOf[tryOp.getOperation()] = finallyBlock;
            finallyBlockLast = continuation->getPrevNode();

            // add clone for 'return'
            if (returns.size() > 0)
            {
                mlir::IRMapping returnFinallyMapping;
                rewriter.cloneRegionBefore(tryOp.getFinally(), *continuation->getParent(), continuation->getIterator(),
                                            returnFinallyMapping);
                propagateTsContextEntries(returnFinallyMapping);
                auto returnFinallyBlockLast = continuation->getPrevNode();
                rewriter.setInsertionPoint(returnFinallyBlockLast->getTerminator());
                auto resultOpOfReturnFinallyBlock = cast<mlir_ts::ResultOp>(returnFinallyBlockLast->getTerminator());
                rewriter.replaceOpWithNewOp<mlir_ts::ReturnOp>(resultOpOfReturnFinallyBlock);
                // if has returns we need to create return cleanup block
                for (auto retOp : returns)
                {
                    tsContext->cleanup[retOp] = returnFinallyBlockLast;
                }
            }

            // add clones for escaping break/continue, the same way as for 'return' above:
            // one finally copy per distinct jump target, terminated by a branch to that
            // target, and the escaping op is re-pointed at the copy -- so Break/Continue
            // lowering just branches into the finally copy, which then continues to the
            // real target. Nested try/finally chains compose naturally: this try lowers
            // before any nested one, so a nested try later re-points the same op at its
            // own finally copy, which branches here.
            if (escapingJumpsBody.size() > 0 || escapingJumpsCatches.size() > 0)
            {
                mlir::DenseMap<mlir::Block *, mlir::Block *> finallyCopyPerTarget;
                auto routeThroughFinally = [&](Operation *op) {
                    auto target = tsContext->jumps.lookup(op);
                    auto &finallyCopy = finallyCopyPerTarget[target];
                    if (!finallyCopy)
                    {
                        mlir::IRMapping jumpFinallyMapping;
                        rewriter.cloneRegionBefore(tryOp.getFinally(), *continuation->getParent(),
                                                    continuation->getIterator(), jumpFinallyMapping);
                        propagateTsContextEntries(jumpFinallyMapping);
                        auto jumpFinallyBlockLast = continuation->getPrevNode();
                        rewriter.setInsertionPoint(jumpFinallyBlockLast->getTerminator());
                        auto resultOpOfJumpFinallyBlock = cast<mlir_ts::ResultOp>(jumpFinallyBlockLast->getTerminator());
                        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(resultOpOfJumpFinallyBlock, target);
                        finallyCopy = jumpFinallyMapping.lookup(&tryOp.getFinally().front());
                    }

                    tsContext->jumps[op] = finallyCopy;
                };

                for (auto op : escapingJumpsBody)
                {
                    routeThroughFinally(op);
                }

                for (auto op : escapingJumpsCatches)
                {
                    routeThroughFinally(op);
                    // leaving a catch clause abruptly must end the active catch first,
                    // mirroring the return-from-catch handling
                    tsContext->unwind[op] = catchesBlock;
                }
            }

            rewriter.inlineRegionBefore(tryOp.getFinally(), continuation);
            exitBlockLast = continuation->getPrevNode();
        }
        else
        {
            while (!tryOp.getFinally().empty())
            {
                rewriter.eraseBlock(&tryOp.getFinally().front());
            }
        }

        auto exitBlock = finallyHasOps ? exitBlockLast : continuation;
        auto landingBlock = cleanupHasOps ? cleanupBlock : catchHasOps ? catchesBlock : finallyBlock;
        tsContext->landingBlockOf[tryOp.getOperation()] = landingBlock;
        if (landingBlock)
        {
            // TODO: check for nested ops for example in if block
            auto visitorCallOpContinue = [&](Operation *op) {
                if (isInsideNestedCleanupRegion(op))
                {
                    return;
                }

                if (auto callOp = dyn_cast_or_null<mlir_ts::CallOp>(op))
                {
                    tsContext->unwind[op] = landingBlock;
                }
                else if (auto callIndirectOp = dyn_cast_or_null<mlir_ts::CallIndirectOp>(op))
                {
                    tsContext->unwind[op] = landingBlock;
                }
                else if (auto throwOp = dyn_cast_or_null<mlir_ts::ThrowOp>(op))
                {
                    tsContext->unwind[op] = landingBlock;
                }
            };
            auto it = bodyBlock;
            do
            {
                it->walk(visitorCallOpContinue);
                if (it != bodyBlockLast)
                {
                    it = it->getNextNode();
                    continue;
                }
            } while (false);
        }

        // Body:catch vars
        rewriter.setInsertionPointToStart(bodyBlock);
        auto catch1 = rttih.hasType()
                          ? (mlir::Value)rttih.typeInfoPtrValue(loc)
                          : /*catch all*/ (mlir::Value)rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());

        // `catch (e: number)` has to take `throw 1` too - an integer literal is an int here - and
        // a thrown u32 or f32. On Windows their ThrowInfos list a `.N` entry that converts (see
        // copyThunkPrefix in LLVMRTTIHelperVCWin32Const.h); on the Itanium path the catch lists
        // their type_infos as further clauses, accepts any of them, and
        // linux::SaveCatchVarOpLowering converts.
        SmallVector<mlir::Value> widenedTypeInfos;
        if (!tsContext->compileOptions.isWindows && catchVarType && isa<mlir_ts::NumberType>(catchVarType))
        {
            for (auto typeInfoName : {::typescript::linux::I32Type::typeName, ::typescript::linux::U32Type::typeName,
                                      ::typescript::linux::F32Type::typeName})
            {
                widenedTypeInfos.push_back(rewriter.create<mlir_ts::ConstantOp>(
                    loc, mth.getRefType(mth.getOpaqueType()), mlir::FlatSymbolRefAttr::get(rewriter.getContext(), typeInfoName)));
            }
        }

        // A cleanup-only try (a `using` scope) nested inside another try in the same function
        // has to hand the exception on to that enclosing landing pad once it has disposed, and
        // on the Itanium path that is done by rethrowing rather than resuming - see the
        // linuxHasCleanups block at the end of this method. That rethrow needs a catch-all pad,
        // same as the nested-finally case beside it.
        auto linuxCleanupOnlyChainsToParent =
            linuxHasCleanups && !catchHasOps && !finallyHasOps && enclosingHandler;

        // A typed catch whose exception may belong to someone else in this same function - the
        // try's own finally, or the try around it - has to be entered for every exception, not
        // only a matching one. An Itanium landingpad that lists just the typed clause is skipped
        // by the personality for any other type, and since nothing in this frame unwinds to the
        // finally or the enclosing try's pad, the exception is not handled here at all:
        // std::terminate. So add a catch-all clause, and let the mismatch path below rethrow to
        // where the exception belongs (the same catch-all-and-rethrow the nested finally and
        // cleanup cases here already use). linuxHasCleanups adds the clause on its own.
        auto linuxTypedCatchChains = !tsContext->compileOptions.isWindows && catchHasOps && rttih.hasType() &&
                                     !linuxHasCleanups && (enclosingHandler || finallyHasOps);

        mlir::Value catchAll;
        if (enclosingHandler && finallyHasOps || linuxHasCleanups && rttih.hasType() ||
            linuxCleanupOnlyChainsToParent || linuxTypedCatchChains)
        {
            catchAll = (mlir::Value)rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());
        }

        mlir::Value undefArrayValue;
        if (finallyHasOps || cleanupHasOps)
        {
            // cleanup marker: an array-typed landing-pad operand becomes a *filter* clause at
            // the LLVM level, which (together with the cleanup flag) marks the pad as a cleanup
            // pad for the later LLVM passes; LandingPadFixPass strips it into a canonical
            // clause-less cleanup landingpad before any optimization runs. See
            // windows::LandingPadOpLowering in LowerToLLVM.cpp.
            auto arrTy = mth.getConstArrayValueType(mth.getOpaqueType(), 1);
            undefArrayValue = rewriter.create<mlir_ts::UndefOp>(loc, arrTy);
            auto nullVal = rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());
            // TODO: InsertPropertyOp review using ArrayAttr (should it be I64Array?)

            undefArrayValue = rewriter.create<mlir_ts::InsertPropertyOp>(loc, undefArrayValue.getType(), nullVal,
                                                                         undefArrayValue, MLIRHelper::getStructIndex(rewriter, 0));
        }

        rewriter.setInsertionPoint(bodyBlockLast->getTerminator());
        auto resultOp = cast<mlir_ts::ResultOp>(bodyBlockLast->getTerminator());
        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(resultOp, exitBlock, ValueRange{});

        if (cleanupHasOps && tsContext->compileOptions.isWindows)
        {
            rewriter.setInsertionPointToStart(cleanupBlock);

            auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                loc, rttih.getLandingPadType(), rewriter.getBoolAttr(true), ValueRange{undefArrayValue});
            tagPad(landingPadCleanupOp, false);
            auto beginCleanupCallInfo = rewriter.create<mlir_ts::BeginCleanupOp>(loc);

            rewriter.setInsertionPoint(cleanupBlockLast->getTerminator());
            mlir::SmallVector<mlir::Block *> unwindDests;
            // catchesBlock and finallyBlock both being null is a real case, not an oversight:
            // a cleanup-only try (a `using` with no explicit catch/finally) has nowhere of its
            // own to hand the unwind to. Leaving unwindDests empty here is what tells
            // EndCleanupOp to resume unwinding instead of branching to a block that does not
            // exist - the Linux cleanup-only case below already relies on the same fallback
            // chain, catchesBlock -> finallyBlock -> enclosingHandler -> resume.
            if (catchesBlock)
            {
                unwindDests.push_back(catchesBlock);
            }
            else if (finallyBlock)
            {
                unwindDests.push_back(finallyBlock);
            }
            else if (enclosingHandler)
            {
                unwindDests.push_back(enclosingHandler);
            }

            auto resultOpCleanup = cast<mlir_ts::ResultOp>(cleanupBlockLast->getTerminator());
            rewriter.replaceOpWithNewOp<mlir_ts::EndCleanupOp>(resultOpCleanup, landingPadCleanupOp, unwindDests);
        }

        if (catchHasOps && tsContext->compileOptions.isWindows)
        {
            catchPadId = ++tsContext->nextCatchPadId;
            tsContext->catchPadIdOf[tryOp.getOperation()] = catchPadId;
        }

        mlir::Value cmpValue;
        SmallVector<mlir::Value> cmpWidenedValues;
        if (catchHasOps)
        {
            // catches:landingpad
            rewriter.setInsertionPointToStart(linuxHasCleanups ? cleanupBlock : catchesBlock);

            SmallVector<mlir::Value> catchTypes{catch1};
            catchTypes.append(widenedTypeInfos.begin(), widenedTypeInfos.end());

            if (linuxHasCleanups && rttih.hasType() || linuxTypedCatchChains)
            {
                // we need to catch all exceptions for cleanup code
                catchTypes.push_back(catchAll);
            }

            auto landingPadOp = rewriter.create<mlir_ts::LandingPadOp>(loc, rttih.getLandingPadType(),
                                                                       rewriter.getBoolAttr(false), catchTypes);
            tagPad(landingPadOp, true);

            // On Windows a typed catch that does not match is left by the runtime, through the
            // catchswitch's unwind edge - but Win32ExceptionPass can only point that edge at the
            // enclosing try's pad if something inside the catch region already unwinds there.
            // A catch body with no call has nothing that does, so the enclosing pad has no
            // predecessor left, is deleted as unreachable, and an exception the outer try was
            // meant to catch leaves the function instead. The mismatch rethrow below is that
            // edge: CompareCatchTypeOp is always true on Windows (the filter has already
            // matched by the time the catch body runs), so the rethrow never executes, but it
            // keeps the enclosing pad alive until the funclet pass has wired it up.
            //
            // The same goes for this try's own `finally`, which a mismatched exception has to
            // run on its way out: without the edge the catchswitch unwinds straight past it.
            //
            // The enclosing pad is enclosingHandler: never the parent's own pad for a try in the
            // parent's catch or finally, which is already inside the handler that pad leads to.
            auto windowsNeedsParentEdge = tsContext->compileOptions.isWindows && (enclosingHandler || finallyHasOps);
            if (rttih.hasType() && (!tsContext->compileOptions.isWindows || windowsNeedsParentEdge))
            {
                if (linuxHasCleanups)
                {
                    // go into catchesBlock
                    rewriter.setInsertionPointToStart(catchesBlock);
                }

                cmpValue = rewriter.create<mlir_ts::CompareCatchTypeOp>(loc, mth.getBooleanType(), landingPadOp,
                                                                        rttih.throwInfoPtrValue(loc));
                for (auto widenedTypeInfo : widenedTypeInfos)
                {
                    cmpWidenedValues.push_back(
                        rewriter.create<mlir_ts::CompareCatchTypeOp>(loc, mth.getBooleanType(), landingPadOp, widenedTypeInfo));
                }
            }

            // catch: begin catch
            auto beginCatchCallInfo = rewriter.create<mlir_ts::BeginCatchOp>(loc, mth.getOpaqueType(), landingPadOp);
            if (catchOpPtr)
            {
                tsContext->catchOpData[catchOpPtr] = beginCatchCallInfo->getResult(0);
            }

            // catches: end catch
            rewriter.setInsertionPoint(catchesBlockLast->getTerminator());

            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }

        if (finallyHasOps)
        {
            auto linuxHasCleanupsForFinally = !catchHasOps && linuxHasCleanups;

            // point all throw in catch block to clean up block
            auto visitorCallOpContinueCleanup = [&](Operation *op) {
                if (auto callOp = dyn_cast_or_null<mlir_ts::CallOp>(op))
                {
                    tsContext->unwind[op] = finallyBlock;
                }
                else if (auto callIndirectOp = dyn_cast_or_null<mlir_ts::CallIndirectOp>(op))
                {
                    tsContext->unwind[op] = finallyBlock;
                }
                else if (auto throwOp = dyn_cast_or_null<mlir_ts::ThrowOp>(op))
                {
                    tsContext->unwind[op] = finallyBlock;
                }
            };

            if (catchesBlock)
            {
                auto it = catchesBlock;
                do
                {
                    it->walk(visitorCallOpContinueCleanup);
                    if (it != catchesBlockLast)
                    {
                        it = it->getNextNode();
                        continue;
                    }
                } while (false);
            }

            if (tsContext->compileOptions.isWindows)
            {
                rewriter.setInsertionPointToStart(finallyBlock);
    
                auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                    loc, rttih.getLandingPadType(), rewriter.getBoolAttr(true), ValueRange{undefArrayValue});
                tagPad(landingPadCleanupOp, false);
                auto beginCleanupCallInfo = rewriter.create<mlir_ts::BeginCleanupOp>(loc);

                rewriter.setInsertionPoint(finallyBlockLast->getTerminator());
                mlir::SmallVector<mlir::Block *> unwindDests;
                if (enclosingHandler)
                {
                    unwindDests.push_back(enclosingHandler);
                }

                auto resultOpFinally = cast<mlir_ts::ResultOp>(finallyBlockLast->getTerminator());
                rewriter.replaceOpWithNewOp<mlir_ts::EndCleanupOp>(resultOpFinally, landingPadCleanupOp, unwindDests);                
            }
            else
            {
                if (!enclosingHandler)
                {
                    rewriter.setInsertionPointToStart(linuxHasCleanupsForFinally ? cleanupBlock : finallyBlock);

                    auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                        loc, rttih.getLandingPadType(), rewriter.getBoolAttr(true), ValueRange{undefArrayValue});

                    if (linuxHasCleanupsForFinally)
                    {
                        rewriter.setInsertionPointToStart(finallyBlock);
                    }                        

                    auto beginCleanupCallInfo = rewriter.create<mlir_ts::BeginCleanupOp>(loc);

                    rewriter.setInsertionPoint(finallyBlockLast->getTerminator());
                    mlir::SmallVector<mlir::Block *> unwindDests;

                    if (catchHasOps)
                    {
                        rewriter.setInsertionPoint(finallyBlockLast->getTerminator());
                        rewriter.create<mlir_ts::EndCatchOp>(loc);
                    }

                    auto resultOpFinally = cast<mlir_ts::ResultOp>(finallyBlockLast->getTerminator());
                    rewriter.replaceOpWithNewOp<mlir_ts::EndCleanupOp>(resultOpFinally, landingPadCleanupOp, unwindDests);
                }
                else
                {
                    rewriter.setInsertionPointToStart(linuxHasCleanupsForFinally ? cleanupBlock : finallyBlock);

                    auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                        loc, rttih.getLandingPadType(), rewriter.getBoolAttr(false), ValueRange{catchAll});

                    if (linuxHasCleanupsForFinally)
                    {
                        rewriter.setInsertionPointToStart(finallyBlock);
                    }                        

                    auto beginCleanupCallInfo =
                        rewriter.create<mlir_ts::BeginCatchOp>(loc, mth.getOpaqueType(), landingPadCleanupOp);

                    // We do not need EndCatch as throw will redirect execution anyway
                    // rethrow
                    rewriter.setInsertionPoint(finallyBlockLast->getTerminator());
                    auto nullVal = rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());

                    auto resultOpOfFinally = cast<mlir_ts::ResultOp>(finallyBlockLast->getTerminator());
                    auto throwOp = rewriter.replaceOpWithNewOp<mlir_ts::ThrowOp>(resultOpOfFinally, nullVal);
                    tsContext->unwind[throwOp] = enclosingHandler;
                }
                // cleanup end
            }
        }

        if (catchHasOps)
        {
            // exit br
            rewriter.setInsertionPoint(catchesBlockLast->getTerminator());

            auto resultOpCatches = cast<mlir_ts::ResultOp>(catchesBlockLast->getTerminator());
            rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(resultOpCatches, exitBlock, ValueRange{});
        }

        if (cmpValue)
        {
            // condbr
            auto lastCmpValue = cmpWidenedValues.empty() ? cmpValue : cmpWidenedValues.back();
            rewriter.setInsertionPointAfterValue(lastCmpValue);

            mlir::Block *currentBlockBrCmp = rewriter.getInsertionBlock();
            mlir::Block *continuationBrCmp = rewriter.splitBlock(currentBlockBrCmp, rewriter.getInsertionPoint());

            // when the caught value's type does not match this catch clause, rethrow
            // instead of falling through to normal post-try control flow.
            auto *rethrowBlock = rewriter.createBlock(continuationBrCmp);
            rewriter.setInsertionPointToStart(rethrowBlock);
            if (!tsContext->compileOptions.isWindows)
            {
                // __cxa_rethrow needs the exception to have been caught first. With a `using` in
                // the try (linuxHasCleanups) the pad is a catch-all too, and its rethrow used to
                // run with nothing caught: "terminate called without an active exception".
                rewriter.create<mlir_ts::BeginCatchOp>(loc, mth.getOpaqueType(), cmpValue.getDefiningOp()->getOperand(0));
            }

            auto rethrowVal = rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());
            auto rethrowOp = rewriter.create<mlir_ts::ThrowOp>(loc, rethrowVal);
            // see windowsNeedsParentEdge / linuxTypedCatchChains: the finally's pad comes before
            // any enclosing try's. It went to the parent's pad even for a try in the parent's
            // catch clause, which is the handler already running.
            if (finallyHasOps)
            {
                tsContext->unwind[rethrowOp] = finallyBlock;
            }
            else if (enclosingHandler)
            {
                tsContext->unwind[rethrowOp] = enclosingHandler;
            }

            rewriter.setInsertionPointAfterValue(lastCmpValue);
            mlir::Value castToI1 = rewriter.create<mlir_ts::CastOp>(loc, rewriter.getI1Type(), cmpValue);
            for (auto cmpWidenedValue : cmpWidenedValues)
            {
                auto widenedToI1 = rewriter.create<mlir_ts::CastOp>(loc, rewriter.getI1Type(), cmpWidenedValue);
                castToI1 = rewriter.create<mlir_ts::ArithmeticBinaryOp>(
                    loc, rewriter.getI1Type(), rewriter.getI32IntegerAttr((int)SyntaxKind::BarToken), castToI1, widenedToI1);
            }

            rewriter.create<mlir::cf::CondBranchOp>(loc, castToI1, continuationBrCmp, rethrowBlock);
            // end of condbr
        }

        // end of jumps

        if (finallyHasOps)
        {
            // finally:exit
            rewriter.setInsertionPoint(exitBlockLast->getTerminator());

            auto resultOpOfFinallyBlock = cast<mlir_ts::ResultOp>(exitBlockLast->getTerminator());
            rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(resultOpOfFinallyBlock, continuation, resultOpOfFinallyBlock.getResults());
        }

        if (linuxHasCleanups)
        {
            if (catchHasOps || finallyHasOps)
            {
                auto resultOp = cast<mlir_ts::ResultOp>(cleanupBlockLast->getTerminator());
                rewriter.eraseOp(resultOp);

                if (catchHasOps)
                {
                    rewriter.mergeBlocks(catchesBlock, cleanupBlockLast);
                }
                else
                {
                    rewriter.mergeBlocks(finallyBlock, cleanupBlockLast);
                }
            }
            else if (linuxCleanupOnlyChainsToParent)
            {
                // cleanup-only try (a `using` scope) with another try around it in the same
                // function. Resuming here would unwind straight past that enclosing try - its
                // landing pad would be left with no predecessors at all and an exception the
                // function does mean to catch would leave it instead, which is what
                // 00using_nested_scopes.ts caught.
                //
                // The funclet path repairs this shape in Win32ExceptionPass by redirecting the
                // unwind edge, but there is no equivalent on the Itanium path: a landingpad is
                // only ever reachable as an invoke's unwind destination, so this cleanup cannot
                // simply branch into the enclosing pad. What it can do is catch the exception,
                // dispose, and throw it again with the enclosing pad as the unwind edge. That is
                // exactly the shape the nested-finally case above already lowers to - catch-all
                // pad, __cxa_begin_catch, the cleanup body, then a rethrow that unwinds to the
                // parent - so this reuses it rather than inventing a second one.
                //
                // No EndCatchOp: the rethrow leaves through the unwind edge, so control never
                // reaches an instruction after it.
                rewriter.setInsertionPointToStart(cleanupBlock);

                auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                    loc, rttih.getLandingPadType(), rewriter.getBoolAttr(false), ValueRange{catchAll});
                rewriter.create<mlir_ts::BeginCatchOp>(loc, mth.getOpaqueType(), landingPadCleanupOp);

                rewriter.setInsertionPoint(cleanupBlockLast->getTerminator());
                auto nullVal = rewriter.create<mlir_ts::NullOp>(loc, mth.getNullType());

                auto resultOpCleanup = cast<mlir_ts::ResultOp>(cleanupBlockLast->getTerminator());
                auto throwOp = rewriter.replaceOpWithNewOp<mlir_ts::ThrowOp>(resultOpCleanup, nullVal);
                tsContext->unwind[throwOp] = enclosingHandler;
            }
            else
            {
                // cleanup-only try at the top of its function: nothing encloses it, so once the
                // cleanup has run the exception carries on out of the function. The Windows path
                // sets up its own landing pad for this case unconditionally at
                // cleanupHasOps&&isWindows above; mirror that here so cleanupBlockLast keeps a
                // valid terminator instead of losing it.
                rewriter.setInsertionPointToStart(cleanupBlock);

                auto landingPadCleanupOp = rewriter.create<mlir_ts::LandingPadOp>(
                    loc, rttih.getLandingPadType(), rewriter.getBoolAttr(true), ValueRange{undefArrayValue});
                rewriter.create<mlir_ts::BeginCleanupOp>(loc);

                rewriter.setInsertionPoint(cleanupBlockLast->getTerminator());
                auto resultOpCleanup = cast<mlir_ts::ResultOp>(cleanupBlockLast->getTerminator());
                rewriter.replaceOpWithNewOp<mlir_ts::EndCleanupOp>(resultOpCleanup, landingPadCleanupOp,
                                                                   mlir::SmallVector<mlir::Block *>{});
            }
        }

        rewriter.replaceOp(tryOp, continuation->getArguments());

        LLVM_DEBUG(llvm::dbgs() << "\n!! AFTER - TRY_OP DUMP: \n" << *tryOp->getParentOp() << "\n";);

        return success();
    }
};

struct CatchOpLowering : public TsPattern<mlir_ts::CatchOp>
{
    using TsPattern<mlir_ts::CatchOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::CatchOp catchOp, PatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);

        Location loc = catchOp.getLoc();

        auto catchDataValue = tsContext->catchOpData.lookup(catchOp);
        if (catchDataValue)
        {
            rewriter.create<mlir_ts::SaveCatchVarOp>(loc, catchDataValue, catchOp.getCatchArg());
        }
        else
        {
            llvm_unreachable("missing catch data.");
            return failure();
        }

        rewriter.eraseOp(catchOp);

        return success();
    }
};

struct CallOpLowering : public TsPattern<mlir_ts::CallOp>
{
    using TsPattern<mlir_ts::CallOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::CallOp op, PatternRewriter &rewriter) const final
    {
        if (auto unwind = tsContext->unwind.lookup(op))
        {
            {
                OpBuilder::InsertionGuard guard(rewriter);
                CodeLogicHelper clh(op, rewriter);
                auto *continuationBlock = clh.CutBlockAndSetInsertPointToEndOfBlock();

                LLVM_DEBUG(llvm::dbgs() << "!! ...call -> invoke: " << op.getCalleeAttr() << "\n";);
                LLVM_DEBUG(for (auto opit
                                : op.getOperands()) llvm::dbgs()
                               << "!! ...call -> invoke operands: " << opit << "\n";);

                rewriter.replaceOpWithNewOp<mlir_ts::InvokeOp>(op, op.getResultTypes(), op.getCalleeAttr(),
                                                               op.getArgOperands(), continuationBlock, ValueRange{},
                                                               unwind, ValueRange{});
                return success();
            }

            rewriter.eraseOp(op);
            return success();
        }

        // just replace
        rewriter.replaceOpWithNewOp<mlir_ts::SymbolCallInternalOp>(op, op.getResultTypes(), op.getCalleeAttr(),
                                                                   op.getArgOperands());
        return success();
    }
};

struct CallIndirectOpLowering : public TsPattern<mlir_ts::CallIndirectOp>
{
    using TsPattern<mlir_ts::CallIndirectOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::CallIndirectOp op, PatternRewriter &rewriter) const final
    {
        if (auto unwind = tsContext->unwind.lookup(op))
        {
            {
                OpBuilder::InsertionGuard guard(rewriter);
                CodeLogicHelper clh(op, rewriter);
                auto *continuationBlock = clh.CutBlockAndSetInsertPointToEndOfBlock();

                LLVM_DEBUG(llvm::dbgs() << "!! ...! call indirect:\n";);
                LLVM_DEBUG(for (auto opit
                                : op.getOperands()) llvm::dbgs()
                               << "!! ...call -> invoke operands: " << opit << "\n";);

                auto callAttrs = getCallABIAttrs(op);
                auto res = rewriter.replaceOpWithNewOp<mlir_ts::InvokeOp>(
                    op, op.getResultTypes(), op.getOperands(), continuationBlock, ValueRange{}, unwind, ValueRange{});
                for (auto callAttr : callAttrs)
                {
                    res->setAttr(callAttr.getName(), callAttr.getValue());
                }

                return success();
            }

            rewriter.eraseOp(op);
            return success();
        }

        // just replace
        auto callAttrs = getCallABIAttrs(op);
        auto callInternalOp = rewriter.replaceOpWithNewOp<mlir_ts::CallInternalOp>(op, op.getResultTypes(), op.getOperands());
        for (auto callAttr : callAttrs)
        {
            callInternalOp->setAttr(callAttr.getName(), callAttr.getValue());
        }

        return success();
    }

    // what LowerToLLVM makes the call's argument attributes from (CPP_CALL_ATTR_NAME,
    // SRET_ARG_ATTR_NAME): the call they are on is replaced, and they go on its replacement
    static SmallVector<NamedAttribute> getCallABIAttrs(mlir_ts::CallIndirectOp op)
    {
        SmallVector<NamedAttribute> callAttrs;
        for (auto name : {CPP_CALL_ATTR_NAME, SRET_ARG_ATTR_NAME})
        {
            if (auto attr = op->getAttr(name))
            {
                callAttrs.push_back(NamedAttribute(StringAttr::get(op->getContext(), name), attr));
            }
        }

        return callAttrs;
    }
};

struct ThrowOpLowering : public TsPattern<mlir_ts::ThrowOp>
{
    using TsPattern<mlir_ts::ThrowOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThrowOp throwOp, PatternRewriter &rewriter) const final
    {
        // TODO: add it to CallOp, CallIndirectOp
        CodeLogicHelper clh(throwOp, rewriter);

        Location loc = throwOp.getLoc();

        // Throwing out of a catch clause has to end the active catch first, the same as a
        // return, break or continue leaving one. Without it the catch region is left with no
        // end marker at all - CutBlock below removes the one TryOpLowering placed before the
        // terminator - and Win32ExceptionPass then picks an end for itself, splitting the
        // block ahead of the throw and emitting the catchret before a call that still carries
        // the funclet token. That IR reaches the backend and crashes it.
        if (tsContext->leavesCatch.lookup(throwOp.getOperation()))
        {
            rewriter.create<mlir_ts::EndCatchOp>(loc);
        }

        if (auto unwind = tsContext->unwind.lookup(throwOp))
        {
            rewriter.replaceOpWithNewOp<mlir_ts::ThrowUnwindOp>(throwOp, throwOp.getException(), unwind);
        }
        else
        {
            rewriter.replaceOpWithNewOp<mlir_ts::ThrowCallOp>(throwOp, throwOp.getException());
        }

        clh.CutBlock();

        return success();
    }
};

struct StateLabelOpLowering : public TsPattern<mlir_ts::StateLabelOp>
{
    using TsPattern<mlir_ts::StateLabelOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::StateLabelOp op, PatternRewriter &rewriter) const final
    {
        mlir::Location loc = op.getLoc();

        CodeLogicHelper clh(op, rewriter);

        auto *continueBlock = clh.BeginBlock(loc);

        tsFuncContext->stateLabels.push_back(continueBlock);

        rewriter.eraseOp(op);

        return success();
    }
};

class SwitchStateOpLowering : public TsPattern<mlir_ts::SwitchStateOp>
{
  public:
    using TsPattern<mlir_ts::SwitchStateOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::SwitchStateOp switchStateOp, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(switchStateOp, rewriter);

        auto loc = switchStateOp->getLoc();

        assert(tsContext->returnBlock);

        auto retBlock = tsContext->returnBlock;

        auto returnBlock = retBlock;

        assert(returnBlock);

        LLVM_DEBUG(llvm::dbgs() << "\n!! return block: "; returnBlock->dump(); llvm::dbgs() << "\n";);

        auto defaultBlock = returnBlock;

        assert(defaultBlock != nullptr);

        SmallVector<mlir::Block *> caseDestinations;

        // Collect state labels in program (walk) order: dispatch below is positional
        // (case N -> caseDestinations[N-1]), so an order-scrambling container here
        // (e.g. SmallPtrSet, which only preserves insertion order below its inline
        // capacity) would silently corrupt generator resume dispatch.
        SmallVector<Operation *> stateLabels;

        // select all states
        auto visitorAllStateLabels = [&](Operation *op) {
            if (auto stateLabelOp = dyn_cast_or_null<mlir_ts::StateLabelOp>(op))
            {
                stateLabels.push_back(op);
            }
        };

        switchStateOp->getParentOp()->walk(visitorAllStateLabels);

        {
            mlir::OpBuilder::InsertionGuard insertGuard(rewriter);
            for (auto op : stateLabels)
            {
                auto stateLabelOp = dyn_cast_or_null<mlir_ts::StateLabelOp>(op);
                rewriter.setInsertionPoint(stateLabelOp);

                auto *continuationBlock = clh.BeginBlock(loc);

                rewriter.eraseOp(stateLabelOp);

                // add switch
                caseDestinations.push_back(continuationBlock);
            }
        }

        // insert 0 state label
        caseDestinations.insert(caseDestinations.begin(), switchStateOp.getDefaultDest());

        rewriter.replaceOpWithNewOp<mlir_ts::SwitchStateInternalOp>(
            switchStateOp, switchStateOp.getState(), defaultBlock ? defaultBlock : switchStateOp.getDefaultDest(),
            caseDestinations);

        return success();
    }
};

struct YieldReturnValOpLowering : public TsPattern<mlir_ts::YieldReturnValOp>
{
    using TsPattern<mlir_ts::YieldReturnValOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::YieldReturnValOp yieldReturnValOp, PatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(yieldReturnValOp, rewriter);

        auto loc = yieldReturnValOp->getLoc();

        assert(tsContext->returnBlock);

        auto retBlock = tsContext->returnBlock;

        rewriter.replaceOpWithNewOp<mlir_ts::StoreOp>(yieldReturnValOp, yieldReturnValOp.getOperand(),
                                                      yieldReturnValOp.getReference());

        rewriter.setInsertionPointAfter(yieldReturnValOp);
        clh.JumpTo(yieldReturnValOp.getLoc(), retBlock);

        return success();
    }
};

struct TypeOfOpLowering : public TsPattern<mlir_ts::TypeOfOp>
{
    using TsPattern<mlir_ts::TypeOfOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::TypeOfOp typeOfOp, PatternRewriter &rewriter) const final
    {
        TypeOfOpHelper toh(rewriter);
        auto typeOfValue = toh.typeOfLogic(typeOfOp->getLoc(), typeOfOp.getValue(), typeOfOp.getValue().getType(), tsContext->compileOptions);

        rewriter.replaceOp(typeOfOp, ValueRange{typeOfValue});
        return success();
    }
};

struct CaptureOpLowering : public TsPattern<mlir_ts::CaptureOp>
{
    using TsPattern<mlir_ts::CaptureOp>::TsPattern;

    LogicalResult matchAndRewrite(mlir_ts::CaptureOp captureOp, PatternRewriter &rewriter) const final
    {
        auto location = captureOp->getLoc();

        TypeHelper th(rewriter);

        auto captureRefType = captureOp.getType();

        LLVM_DEBUG(llvm::dbgs() << "\n!! ...capture result type: " << captureRefType << "\n\n";);

        assert(isa<mlir_ts::RefType>(captureRefType));
        auto captureStoreType = cast<mlir_ts::TupleType>(cast<mlir_ts::RefType>(captureRefType).getElementType());

        LLVM_DEBUG(llvm::dbgs() << "\n!! ...capture store type: " << captureStoreType << "\n\n";);

        // true => we need to allocate capture in heap memory
#ifdef ALLOC_CAPTURE_IN_HEAP
        auto inHeapMemory = true;
#else
        auto inHeapMemory = false;
#endif
        mlir::Value allocTempStorage = rewriter.create<mlir_ts::VariableOp>(
            location, captureRefType, mlir::Value(), rewriter.getBoolAttr(inHeapMemory), rewriter.getIndexAttr(0));

        // `captured` here only means "allocate in the heap". Saying so keeps the box from being
        // read as a captured variable's cell, which is the other reason a variable is heap
        // allocated and the one that comes with a frame's reference.
        allocTempStorage.getDefiningOp()->setAttr(CAPTURE_BOX_ATTR_NAME, rewriter.getUnitAttr());

        for (auto [index, val] : enumerate(captureOp.getCaptured()))
        {
            auto thisStoreFieldType = captureStoreType.getType(index);
            auto thisStoreFieldTypeRef = mlir_ts::RefType::get(thisStoreFieldType);
            auto fieldRef = rewriter.create<mlir_ts::PropertyRefOp>(location, thisStoreFieldTypeRef, allocTempStorage,
                                                                    th.getStructIndexAttrValue(index));

            LLVM_DEBUG(llvm::dbgs() << "\n!! ...storing val: [" << val << "] in (" << index << ") ref: " << fieldRef
                                    << "\n\n";);

            // dereference value in case of sending value by ref but stored as value
            // TODO: review capture logic
            if (auto valRefType = dyn_cast<mlir_ts::RefType>(val.getType()))
            {
                if (!isa<mlir_ts::RefType>(thisStoreFieldType) && thisStoreFieldType == valRefType.getElementType())
                {
                    // load value to dereference
                    val = rewriter.create<mlir_ts::LoadOp>(location, valRefType.getElementType(), val);
                }
            }

            assert(val.getType() == cast<mlir_ts::RefType>(fieldRef.getType()).getElementType());

            rewriter.create<mlir_ts::StoreOp>(location, val, fieldRef);
        }

        rewriter.replaceOp(captureOp, allocTempStorage);

        return success();
    }
};

} // end anonymous namespace

//===----------------------------------------------------------------------===//
// TypeScriptToAffineLoweringTSFuncPass
//===----------------------------------------------------------------------===//

/// This is a partial lowering to affine loops of the typescript operations that are
/// computationally intensive (like add+mul for example...) while keeping the
/// rest of the code in the TypeScript dialect.

namespace
{
struct TypeScriptToAffineLoweringTSFuncPass : public PassWrapper<TypeScriptToAffineLoweringTSFuncPass, TypeScriptFunctionPass>
{
    MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeScriptToAffineLoweringTSFuncPass)

    TSContext tsContext;

    TypeScriptToAffineLoweringTSFuncPass(CompileOptions &compileOptions) : tsContext(compileOptions)
    {
    }

    void getDependentDialects(DialectRegistry &registry) const override
    {
        registry.insert<arith::ArithDialect>();
        registry.insert<cf::ControlFlowDialect>();
        registry.insert<func::FuncDialect>();
    }

    void runOnFunction() final;
};
} // end anonymous namespace.

namespace
{
struct TypeScriptToAffineLoweringFuncPass : public PassWrapper<TypeScriptToAffineLoweringFuncPass, OperationPass<func::FuncOp>>
{
    MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeScriptToAffineLoweringFuncPass)

    TSContext tsContext;

    TypeScriptToAffineLoweringFuncPass(CompileOptions &compileOptions) : tsContext(compileOptions)
    {
    }

    void getDependentDialects(DialectRegistry &registry) const override
    {
        registry.insert<arith::ArithDialect>();
        registry.insert<cf::ControlFlowDialect>();
        registry.insert<func::FuncDialect>();
    }

    void runOnOperation() final;

};
} // end anonymous namespace.

namespace
{
struct TypeScriptToAffineLoweringModulePass : public PassWrapper<TypeScriptToAffineLoweringModulePass, OperationPass<ModuleOp>>
{
    MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeScriptToAffineLoweringModulePass)

    TSContext tsContext;

    TypeScriptToAffineLoweringModulePass(CompileOptions &compileOptions) : tsContext(compileOptions)
    {
    }

    void getDependentDialects(DialectRegistry &registry) const override
    {
        registry.insert<arith::ArithDialect>();
        registry.insert<cf::ControlFlowDialect>();
        registry.insert<func::FuncDialect>();
    }

    void runOnOperation() final;
};
} // end anonymous namespace.

static LogicalResult verifySuccessors(Operation *op)
{
    auto *parent = op->getParentRegion();

    // Verify that the operands lines up with the BB arguments in the successor.
    for (mlir::Block *succ : op->getSuccessors())
        if (succ->getParent() != parent)
        {
            LLVM_DEBUG(llvm::dbgs() << "\n!! reference to block defined in another region: "; op->dump();
                       llvm::dbgs() << "\n";);
            assert(false);
            return op->emitError("!! DEBUG TEST: reference to block defined in another region");
        }

    return success();
}

static LogicalResult verifyFunction(mlir::typescript::FuncOp &funcOp)
{
    for (auto &region : funcOp->getRegions())
    {
        for (auto &regionBlock : region)
        {
            for (auto &op : regionBlock)
            {
                if (failed(verifySuccessors(&op)))
                {
                    return failure();
                }
            }
        }
    }

    return success();
}

void finishSwitchState(mlir_ts::FuncOp f, TSFunctionContext &tsFuncContext)
{
    // change SwitchStateOp
    if (tsFuncContext.stateLabels.size() == 0)
    {
        return;
    }

    PatternRewriter rewriter(f.getContext());
    CodeLogicHelper clh(f, rewriter);
    auto switchStateOp = clh.FindOp<mlir_ts::SwitchStateOp>(f);
    assert(switchStateOp);

    mlir::SmallVector<mlir::Block *> stateLabels(tsFuncContext.stateLabels);

    rewriter.replaceOpWithNewOp<mlir_ts::SwitchStateInternalOp>(switchStateOp, switchStateOp.getState(),
                                                                switchStateOp.getDefaultDest(), stateLabels);
}

void cleanupEmptyBlocksWithoutPredecessors(mlir_ts::FuncOp f)
{
    auto any = false;
    do
    {
        any = false;
        SmallPtrSet<mlir::Block *, 16> workSet;
        for (auto &regionBlock : f.getRegion())
        {
            if (regionBlock.isEntryBlock())
            {
                continue;
            }

            if (regionBlock.getPredecessors().empty())
            {
                auto count = std::distance(regionBlock.begin(), regionBlock.end());
                if (count == 0 || count == 1 && (isa<mlir::cf::BranchOp>(regionBlock.begin()) ||
                                                 isa<mlir_ts::UnreachableOp>(regionBlock.begin())))
                {
                    workSet.insert(&regionBlock);
                }
            }
        }

        PatternRewriter rewriter(f.getContext());
        for (auto blockPtr : workSet)
        {
            blockPtr->dropAllDefinedValueUses();
            blockPtr->dropAllUses();
            blockPtr->dropAllReferences();
            rewriter.eraseBlock(blockPtr);
            any = true;
        }
    } while (any);
}

void AddTsAffineLegalOps(ConversionTarget &target)
{
    // We define the specific operations, or dialects, that are legal targets for
    // this lowering. In our case, we are lowering to a combination of the
    // `Affine` and `Standard` dialects.
    target.addLegalDialect<arith::ArithDialect>();
    target.addLegalDialect<cf::ControlFlowDialect>();
    target.addLegalDialect<func::FuncDialect>();

    // We also define the TypeScript dialect as Illegal so that the conversion will fail
    // if any of these operations are *not* converted. Given that we actually want
    // a partial lowering, we explicitly mark the TypeScript operations that don't want
    // to lower, `typescript.print`, as `legal`.
    target.addIllegalDialect<mlir_ts::TypeScriptDialect>();
    target.addLegalOp<
        mlir_ts::DialectCastOp,
        mlir_ts::AddressOfOp, mlir_ts::ArithmeticBinaryOp, mlir_ts::ArithmeticUnaryOp, mlir_ts::AssertOp, mlir_ts::CastOp, mlir_ts::ConstantOp, 
        mlir_ts::ElementRefOp, mlir_ts::PointerOffsetRefOp, mlir_ts::FuncOp, mlir_ts::GlobalOp, mlir_ts::GlobalResultOp, mlir_ts::DefaultOp, 
        mlir_ts::HasValueOp, mlir_ts::ValueOp, mlir_ts::ValueOrDefaultOp, mlir_ts::NullOp, mlir_ts::ParseFloatOp, mlir_ts::ParseIntOp, mlir_ts::IsNaNOp,
        mlir_ts::PrintOp, mlir_ts::ConvertFOp, mlir_ts::SizeOfOp, mlir_ts::TypeDescriptorOp, mlir_ts::RetainOp, mlir_ts::ReleaseOp, mlir_ts::RetainSlotOp, mlir_ts::ReleaseSlotOp, mlir_ts::RetainCellOp, mlir_ts::ReleaseCellOp, mlir_ts::StoreOp, mlir_ts::SymbolRefOp, mlir_ts::LengthOfOp, mlir_ts::SetLengthOfOp,
        mlir_ts::StringLengthOp, mlir_ts::StringResizeOp, mlir_ts::StringConcatOp, mlir_ts::StringCopyOp, mlir_ts::SharedNewOp, mlir_ts::SharedValueRefOp, mlir_ts::SharedCountOp, mlir_ts::StringCompareOp, mlir_ts::AnyCompareOp, 
        mlir_ts::LoadOp, mlir_ts::LoadSaveOp, mlir_ts::NewOp, mlir_ts::CreateTupleOp, mlir_ts::DeconstructTupleOp, mlir_ts::CreateArrayOp, 
        mlir_ts::NewEmptyArrayOp, mlir_ts::NewArrayOp, mlir_ts::DeleteOp, mlir_ts::PropertyRefOp, mlir_ts::InsertPropertyOp, 
        mlir_ts::ExtractPropertyOp, mlir_ts::LogicalBinaryOp, mlir_ts::UndefOp, mlir_ts::VariableOp, mlir_ts::DebugVariableOp, mlir_ts::AllocaOp, 
        mlir_ts::InvokeOp, /*mlir_ts::ResultOp,*/ mlir_ts::VirtualSymbolRefOp, mlir_ts::ThisVirtualSymbolRefOp, mlir_ts::InterfaceSymbolRefOp, 
        mlir_ts::ExtractInterfaceThisOp, mlir_ts::ExtractInterfaceVTableOp, mlir_ts::ArrayPushOp, mlir_ts::ArrayPopOp, 
        mlir_ts::ArrayUnshiftOp, mlir_ts::ArrayShiftOp, mlir_ts::ArraySpliceOp, mlir_ts::ArrayViewOp, 
        mlir_ts::NewInterfaceOp, mlir_ts::VTableOffsetRefOp, mlir_ts::GetThisOp, mlir_ts::GetMethodOp, mlir_ts::DebuggerOp,
        mlir_ts::LandingPadOp, mlir_ts::CompareCatchTypeOp, mlir_ts::BeginCatchOp, mlir_ts::SaveCatchVarOp,
        mlir_ts::EndCatchOp, mlir_ts::BeginCleanupOp, mlir_ts::EndCleanupOp, mlir_ts::ThrowUnwindOp,
        mlir_ts::ThrowCallOp, mlir_ts::SymbolCallInternalOp, mlir_ts::CallInternalOp, mlir_ts::ReturnInternalOp,
        mlir_ts::NoOp, mlir_ts::SwitchStateInternalOp, mlir_ts::UnreachableOp, mlir_ts::GlobalConstructorOp, mlir_ts::AppendToUsedOp,
        mlir_ts::CreateBoundFunctionOp, mlir_ts::TypeOfAnyOp, mlir_ts::BoxOp, mlir_ts::UnboxOp,
        mlir_ts::CreateUnionInstanceOp, mlir_ts::GetValueFromUnionOp, mlir_ts::GetTypeInfoFromUnionOp,
        mlir_ts::OptionalOp, mlir_ts::OptionalValueOp, mlir_ts::OptionalUndefOp,
        mlir_ts::LoadLibraryPermanentlyOp, mlir_ts::SearchForAddressOfSymbolOp,
        mlir_ts::AtomicRMWOp, mlir_ts::AtomicCmpXchgOp, mlir_ts::FenceOp, mlir_ts::InlineAsmOp, 
        mlir_ts::CallIntrinsicOp, mlir_ts::LinkerOptionsOp>();
#ifdef ENABLE_TYPED_GC
    target.addLegalOp<
        mlir_ts::GCMakeDescriptorOp, GCNewExplicitlyTypedOp>();
#endif

}

void AddTsAffinePatterns(MLIRContext &context, ConversionTarget &target, RewritePatternSet &patterns,
                         TSContext &tsContext, TSFunctionContext &tsFuncContext)
{
    // Now that the conversion target has been defined, we just need to provide
    // the set of patterns that will lower the TypeScript operations.

    patterns.insert<EntryOpLowering, ExitOpLowering, ReturnOpLowering, ReturnValOpLowering, ParamOpLowering,
                    ParamOptionalOpLowering, ParamDefaultValueOpLowering, OptionalValueOrDefaultOpLowering, 
                    PrefixUnaryOpLowering, PostfixUnaryOpLowering, IfOpLowering, /*ResultOpLowering,*/ 
                    DoWhileOpLowering, WhileOpLowering, ForOpLowering, BreakOpLowering, ContinueOpLowering, 
                    SwitchOpLowering, AccessorOpLowering, ThisAccessorOpLowering, ThisIndirectAccessorOpLowering, 
                    ThisIndexAccessorOpLowering, ThisIndirectIndexAccessorOpLowering,
                    BoundIndirectAccessorOpLowering, BoundIndirectIndexAccessorOpLowering, 
                    LabelOpLowering, CallOpLowering, CallIndirectOpLowering, TryOpLowering, ThrowOpLowering, CatchOpLowering, 
                    StateLabelOpLowering, SwitchStateOpLowering, YieldReturnValOpLowering, TypeOfOpLowering, CaptureOpLowering>(
        &context, &tsContext, &tsFuncContext);
}

void TypeScriptToAffineLoweringTSFuncPass::runOnFunction()
{
    auto function = getFunction();

    LLVM_DEBUG(llvm::dbgs() << "\n!! BEFORE FUNC DUMP: \n" << function << "\n";);

    // We only lower the main function as we expect that all other functions have been inlined.
    // The JIT calls `main` through a thunk with the C entry point's signature (see jit.cpp), which
    // can only adapt the shapes a C `main` has: `argc` as an integer or a number, `argv` as the C
    // `char **` itself, a `Ref<string>` (never a `string[]`: that is an array header, not C's
    // `char **`), and an exit code that is an integer or a number.
    //
    // A `string[]` argv is refused in every build where `main` is the entry point (all but a DLL):
    // ahead of time, the C runtime passes `char **` too, which would be read as an array header.
    // Any array-typed parameter is refused, not only a second one: `main(args: string[])` takes
    // `argc` as an array header and faulted ahead of time.
    if (!tsContext.compileOptions.isDLL && function.getName() == MAIN_ENTRY_NAME)
    {
        auto mainInputs = function.getFunctionType().getInputs();
        if (llvm::any_of(mainInputs, [](mlir::Type type) { return isa<mlir_ts::ArrayType>(type); }))
        {
            function.emitError("'main' takes argv as Ref<string> (C's char **), not string[]; read an argument with Deref(argv[i])");
            return signalPassFailure();
        }
    }

    if (tsContext.compileOptions.isJit && function.getName() == MAIN_ENTRY_NAME)
    {
        auto isArgc = [](mlir::Type type) { return isa<mlir::IntegerType>(type) || isa<mlir_ts::NumberType>(type); };
        auto isArgv = [](mlir::Type type) {
            auto refType = dyn_cast<mlir_ts::RefType>(type);
            return refType && isa<mlir_ts::StringType>(refType.getElementType());
        };
        auto isExitCode = [&](mlir::Type type) { return isa<mlir_ts::VoidType>(type) || isArgc(type); };

        auto inputs = function.getFunctionType().getInputs();
        auto results = function.getFunctionType().getResults();
        auto validInputs = inputs.size() <= 2
            && (inputs.size() < 1 || isArgc(inputs[0]))
            && (inputs.size() < 2 || isArgv(inputs[1]));
        auto validResults = results.size() <= 1 && llvm::all_of(results, isExitCode);
        if (!validInputs || !validResults)
        {
            function.emitError("expected 'main' to be 'main(argc?: i32 | number, argv?: Ref<string>): void | i32 | number'");
            return signalPassFailure();
        }
    }

    // The first thing to define is the conversion target. This will define the
    // final target for this lowering.
    ConversionTarget target(getContext());
    RewritePatternSet patterns(&getContext());

    TSFunctionContext tsFuncContext{};
    AddTsAffineLegalOps(target);
    tsContext.beginRun();
    AddTsAffinePatterns(getContext(), target, patterns, tsContext, tsFuncContext);

    // With the target and rewrite patterns defined, we can now attempt the
    // conversion. The conversion will signal failure if any of our `illegal`
    // operations were not converted successfully.
    if (failed(applyPartialConversion(function, target, std::move(patterns))))
    {
        signalPassFailure();
    }

    LLVM_DEBUG(llvm::dbgs() << "\n!! Processing function: \n" << function.getName() << "\n";);

    cleanupEmptyBlocksWithoutPredecessors(function);

    LLVM_DEBUG(llvm::dbgs() << "\n!! AFTER FUNC DUMP: \n" << function << "\n";);

    LLVM_DEBUG(verifyFunction(function););
}

void TypeScriptToAffineLoweringFuncPass::runOnOperation()
{
    auto function = getOperation();

    // The first thing to define is the conversion target. This will define the
    // final target for this lowering.
    ConversionTarget target(getContext());
    RewritePatternSet patterns(&getContext());

    TSFunctionContext tsFuncContext{};
    AddTsAffineLegalOps(target);
    tsContext.beginRun();
    AddTsAffinePatterns(getContext(), target, patterns, tsContext, tsFuncContext);

    // TODO: Hack to fix issue with Async
    target.addLegalOp<mlir::func::FuncOp>();

    // With the target and rewrite patterns defined, we can now attempt the
    // conversion. The conversion will signal failure if any of our `illegal`
    // operations were not converted successfully.
    if (failed(applyPartialConversion(function, target, std::move(patterns))))
    {
        signalPassFailure();
    }

    LLVM_DEBUG(llvm::dbgs() << "\n!! (FUNC) AFTER FUNC DUMP: \n" << function << "\n";);
}

void TypeScriptToAffineLoweringModulePass::runOnOperation()
{
    auto module = getOperation();

    // The first thing to define is the conversion target. This will define the
    // final target for this lowering.
    ConversionTarget target(getContext());
    RewritePatternSet patterns(&getContext());

    TSFunctionContext tsFuncContext{};
    AddTsAffineLegalOps(target);
    tsContext.beginRun();
    AddTsAffinePatterns(getContext(), target, patterns, tsContext, tsFuncContext);

    // + Global ops
    target.addLegalOp<ModuleOp>();    

    // TODO: Hack to fix issue with Async
    target.addLegalOp<mlir::func::FuncOp>();    
    target.addLegalDialect<mlir::async::AsyncDialect>();

    // With the target and rewrite patterns defined, we can now attempt the
    // conversion. The conversion will signal failure if any of our `illegal`
    // operations were not converted successfully.
    if (failed(applyFullConversion(module, target, std::move(patterns))))
    {
        signalPassFailure();
    }    
}

/// Create a pass for lowering operations in the `Affine` and `Std` dialects,
/// for a subset of the TypeScript IR.
std::unique_ptr<mlir::Pass> mlir_ts::createLowerToAffineTSFuncPass(CompileOptions &compileOptions)
{
    return std::make_unique<TypeScriptToAffineLoweringTSFuncPass>(compileOptions);
}

std::unique_ptr<mlir::Pass> mlir_ts::createLowerToAffineFuncPass(CompileOptions &compileOptions)
{
    return std::make_unique<TypeScriptToAffineLoweringFuncPass>(compileOptions);
}

std::unique_ptr<mlir::Pass> mlir_ts::createLowerToAffineModulePass(CompileOptions &compileOptions)
{
    return std::make_unique<TypeScriptToAffineLoweringModulePass>(compileOptions);
}