LowerToLLVM.cpp

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

#include "mlir/Analysis/DataLayoutAnalysis.h"
#include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
#include "mlir/Conversion/LLVMCommon/Pattern.h"
#include "mlir/Conversion/ArithToLLVM/ArithToLLVM.h"
#include "mlir/Conversion/IndexToLLVM/IndexToLLVM.h"
#include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
#include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
#include "mlir/Dialect/Affine/IR/AffineOps.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/Math/IR/Math.h"
#include "mlir/Dialect/Index/IR/IndexDialect.h"
#include "mlir/Dialect/Index/IR/IndexOps.h"

#ifdef ENABLE_ASYNC
#include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
#endif
#include "mlir/Pass/Pass.h"
#include "mlir/Target/LLVMIR/ModuleTranslation.h"
#include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Debug.h"
#include "llvm/IR/DIBuilder.h"

#include "TypeScript/TypeScriptPassContext.h"
#include "TypeScript/LowerToLLVMLogic.h"
#include "TypeScript/LowerToLLVM/LLVMDebugInfo.h"
#include "TypeScript/LowerToLLVM/LLVMDebugInfoFixer.h"

#include "scanner_enums.h"

#define DISABLE_SWITCH_STATE_PASS 1
#define ENABLE_MLIR_INIT

#define DEBUG_TYPE "llvm"

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

//===----------------------------------------------------------------------===//
// TypeScriptToLLVM RewritePatterns
//===----------------------------------------------------------------------===//

namespace
{
struct TsLlvmContext
{
    TsLlvmContext(CompileOptions& compileOptions) : compileOptions(compileOptions) {};

    CompileOptions& compileOptions;

    // the priority of the next global's own constructor, above every one MLIRGen made: LLVM leaves
    // the order of equal priorities undefined, and a global may read one made before it (#446)
    int64_t nextGlobalConstructorPriority = LAST_GLOBAL_CONSTRUCTOR_PRIORITY;

    // the calls put into __mlir_gctors so far, with their priorities, to keep them in that order
    std::vector<std::pair<int64_t, mlir::Operation *>> globalConstructorCalls;
};

template <typename OpTy> class TsLlvmPattern : public OpConversionPattern<OpTy>
{
  public:
    using Adaptor = typename OpTy::Adaptor;

    TsLlvmPattern<OpTy>(mlir::LLVMTypeConverter &llvmTypeConverter, MLIRContext *context, TsLlvmContext *tsLlvmContext,
                        PatternBenefit benefit = 1)
        : OpConversionPattern<OpTy>::OpConversionPattern(llvmTypeConverter, context, benefit),
          tsLlvmContext(tsLlvmContext)
    {
    }

  protected:
    TsLlvmContext *tsLlvmContext;
};

class ConvertFOpLowering : public TsLlvmPattern<mlir_ts::ConvertFOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ConvertFOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ConvertFOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();

        auto i8PtrTy = th.getPtrType();
        auto llvmI32Type = tch.convertType(th.getI32Type());
        auto llvmIndexType = tch.convertType(rewriter.getIndexType());

#ifdef WIN32
        auto sprintfFuncOp = ch.getOrInsertFunction(
            "sprintf_s", th.getFunctionType(rewriter.getI32Type(), {th.getPtrType(), llvmIndexType, th.getPtrType()}, true));
#else
        auto sprintfFuncOp = ch.getOrInsertFunction(
            "snprintf", th.getFunctionType(rewriter.getI32Type(), {th.getPtrType(), llvmIndexType, th.getPtrType()}, true));
#endif

        auto bufferSizeValue = transformed.getBufferSize();
        auto newStringValue = ch.MemoryAlloc(bufferSizeValue, MemoryAllocSet::Atomic);

        auto formatSpecifierValue = transformed.getFormat();

        SmallVector<mlir::Value> values;
        values.push_back(newStringValue);
        values.push_back(bufferSizeValue);
        values.push_back(formatSpecifierValue);
        for (auto inputVal : transformed.getInputs()) values.push_back(inputVal);

        rewriter.create<LLVM::CallOp>(loc, sprintfFuncOp, values);

        // Notify the rewriter that this operation has been removed.
        rewriter.replaceOp(op, newStringValue);

        return success();
    }
};

class AssertOpLowering : public TsLlvmPattern<mlir_ts::AssertOp>
{
  public:
    using TsLlvmPattern<mlir_ts::AssertOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AssertOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        AssertLogic al(op, rewriter, tch, op->getLoc(), tsLlvmContext->compileOptions);
        return al.logic(transformed.getArg(), op.getMsg().str(), transformed.getMessage());
    }
};

// A string that is null reads as "null" where its text is used, as it prints and concatenates in
// JS; handed to puts/strlen as it is, it was a crash. The conversion to string keeps it null, so
// `let s: string = maybeNull` is still null afterwards.
static mlir::Value nullStringAsText(mlir::Location loc, mlir::Value text, ConversionPatternRewriter &rewriter,
                                    TypeConverterHelper &tch)
{
    auto ptrType = text.getType();
    auto strType = mlir_ts::StringType::get(rewriter.getContext());
    mlir::Value nullText = rewriter.create<mlir_ts::DialectCastOp>(
        loc, tch.convertType(strType), rewriter.create<mlir_ts::ConstantOp>(loc, strType, rewriter.getStringAttr(NULL_NAME)));
    auto nullPtr = rewriter.create<LLVM::ZeroOp>(loc, ptrType);
    auto isNull = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, text, nullPtr);
    return rewriter.create<LLVM::SelectOp>(loc, isNull, nullText, text);
}

class PrintOpLowering : public TsLlvmPattern<mlir_ts::PrintOp>
{
  public:
    using TsLlvmPattern<mlir_ts::PrintOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::PrintOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);

        auto loc = op->getLoc();

        auto i8PtrType = th.getPtrType();
        auto ptrType = th.getPtrType();

        // Get a symbol reference to the puts function, inserting it if necessary.
        // Note: declared as returning void (not the libc i32) to match the signature MLIR's
        // cf.assert-to-LLVM lowering expects when it reserves/looks up "puts" for its own use.
        auto putsFuncOp = ch.getOrInsertFunction("puts", th.getFunctionType(th.getVoidType(), ptrType, false));

        auto strType = mlir_ts::StringType::get(rewriter.getContext());

        SmallVector<mlir::Value> values;
        mlir::Value spaceString;
        for (auto item : transformed.getInputs())
        {
            assert(item.getType() == i8PtrType);
            if (values.size() > 0)
            {
                if (!spaceString)
                {
                    spaceString = rewriter.create<mlir_ts::ConstantOp>(loc, strType, rewriter.getStringAttr(" "));
                }

                values.push_back(spaceString);
            }

            values.push_back(item);
        }

        auto size = values.size();
        if (size > 1)
        {
            // TODO: review, why we need stack recovery here
            auto stack = rewriter.create<LLVM::StackSaveOp>(loc, i8PtrType);

            mlir::Value result =
                rewriter.create<mlir_ts::StringConcatOp>(loc, strType, values, rewriter.getBoolAttr(true));

            mlir::Value valueAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(strType), result);
            mlir::Value valueAsPtr = rewriter.create<LLVM::BitcastOp>(loc, ptrType, valueAsLLVMType);

            rewriter.create<LLVM::CallOp>(loc, putsFuncOp, valueAsPtr);

            rewriter.create<LLVM::StackRestoreOp>(loc, stack);
        }
        else if (size == 0)
        {
            mlir::Value valueAsPtr = rewriter.create<mlir_ts::ConstantOp>(loc, strType, rewriter.getStringAttr(""));
            mlir::Value valueAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(strType), valueAsPtr);
            rewriter.create<LLVM::CallOp>(loc, putsFuncOp, valueAsLLVMType);
        }
        else
        {
            mlir::Value valueAsPtr = rewriter.create<LLVM::BitcastOp>(loc, ptrType, values.front());
            rewriter.create<LLVM::CallOp>(loc, putsFuncOp, nullStringAsText(loc, valueAsPtr, rewriter, tch));
        }

        // Notify the rewriter that this operation has been removed.
        rewriter.eraseOp(op);

        return success();
    }
};

class ParseIntOpLowering : public TsLlvmPattern<mlir_ts::ParseIntOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ParseIntOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ParseIntOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        // A result wider than 32 bits (a bigint is an i64) needs the `long long` functions: `atoi`
        // returns an int, and `strtol` a `long`, which is also 32 bits on Windows.
        auto resultType = getTypeConverter()->convertType(op.getType());
        auto wide = resultType.isIntOrFloat() && resultType.getIntOrFloatBitWidth() > 32;
        auto parsedType = wide ? rewriter.getI64Type() : rewriter.getI32Type();

        // Insert the `atoi` declaration if necessary.
        auto i8PtrTy = th.getPtrType();
        LLVM::LLVMFuncOp parseIntFuncOp;
        if (transformed.getBase())
        {
            parseIntFuncOp = ch.getOrInsertFunction(
                wide ? "strtoll" : "strtol",
                th.getFunctionType(parsedType, {i8PtrTy, th.getPtrType(), rewriter.getI32Type()}));
            auto nullOp = rewriter.create<LLVM::ZeroOp>(op->getLoc(), th.getPtrType());
            rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, parseIntFuncOp,
                                                      ValueRange{transformed.getArg(), nullOp, transformed.getBase()});
        }
        else
        {
            parseIntFuncOp = ch.getOrInsertFunction(wide ? "atoll" : "atoi", th.getFunctionType(parsedType, {i8PtrTy}));
            rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, parseIntFuncOp, ValueRange{transformed.getArg()});
        }

        return success();
    }
};

class ParseFloatOpLowering : public TsLlvmPattern<mlir_ts::ParseFloatOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ParseFloatOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ParseFloatOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto loc = op->getLoc();

        // Insert the `atof` declaration if necessary.
        auto i8PtrTy = th.getPtrType();
        auto parseFloatFuncOp = ch.getOrInsertFunction("atof", th.getFunctionType(rewriter.getF64Type(), {i8PtrTy}));

        // atof gives a double whatever the result is: `<f32>"2.5"` wants a float
        auto funcCall = rewriter.create<LLVM::CallOp>(loc, parseFloatFuncOp, ValueRange{transformed.getArg()});
        auto resultType = getTypeConverter()->convertType(op.getType());
        if (resultType == rewriter.getF64Type())
        {
            rewriter.replaceOp(op, funcCall.getResult());
        }
        else
        {
            rewriter.replaceOpWithNewOp<LLVM::FPTruncOp>(op, resultType, funcCall.getResult());
        }

        return success();
    }
};

class LoadLibraryPermanentlyOpLowering : public TsLlvmPattern<mlir_ts::LoadLibraryPermanentlyOp>
{
  public:
    using TsLlvmPattern<mlir_ts::LoadLibraryPermanentlyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LoadLibraryPermanentlyOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto i8PtrTy = th.getPtrType();

        auto loadLibraryPermanentlyFuncOp = ch.getOrInsertFunction("tslang_load_library_permanently", th.getFunctionType(rewriter.getI32Type(), {i8PtrTy}));
        rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, loadLibraryPermanentlyFuncOp, ValueRange{transformed.getFilename()});

        return success();
    }
};

class SearchForAddressOfSymbolOpLowering : public TsLlvmPattern<mlir_ts::SearchForAddressOfSymbolOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SearchForAddressOfSymbolOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SearchForAddressOfSymbolOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto i8PtrTy = th.getPtrType();

        auto searchForAddressOfSymbolFuncOp = ch.getOrInsertFunction("tslang_search_for_address_of_symbol", th.getFunctionType(i8PtrTy, {i8PtrTy}));
        rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, searchForAddressOfSymbolFuncOp, ValueRange{transformed.getSymbolName()});

        return success();
    }
};

class IsNaNOpLowering : public TsLlvmPattern<mlir_ts::IsNaNOp>
{
  public:
    using TsLlvmPattern<mlir_ts::IsNaNOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::IsNaNOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        TypeHelper th(rewriter.getContext());

        // uno (unordered) self-compare is true iff the value is NaN; `one` here would
        // be constant false (ordered && x != x can never hold for a self-compare).
        auto cmpValue = rewriter.create<LLVM::FCmpOp>(loc, th.getLLVMBoolType(), LLVM::FCmpPredicate::uno,
                                                      transformed.getArg(), transformed.getArg());
        rewriter.replaceOp(op, ValueRange{cmpValue});
        return success();
    }
};

class TypeDescriptorOpLowering : public TsLlvmPattern<mlir_ts::TypeDescriptorOp>
{
  public:
    using TsLlvmPattern<mlir_ts::TypeDescriptorOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::TypeDescriptorOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeOfOpHelper toh(rewriter);

        auto descriptorType = op.getDescriptorType();
        auto name = toh.typeOfAsString(descriptorType);
        if (name.empty())
        {
            // TypeOfOpHelper::typeDescriptorValue only builds this op when the type has a
            // name, so an empty one here means a type grew a descriptor without growing a
            // typeOf name.
            op.emitError("no 'typeof' name for type: ") << descriptorType;
            return mlir::failure();
        }

        // generated first: the descriptor's initializer takes the routine's address, so the
        // symbol has to exist before the global is built
        OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        auto releaseRoutineName = orl.getOrCreateReleaseRoutine(descriptorType);
        // Under own nothing retains: the descriptor's retain slot is read only from inside
        // retain routines (retainViaDescriptor), none of which can run, and building one would
        // bring `__tslang_inc_ref` into a model that promises it is never referenced. A Shared<T>
        // handle is the exception: own counts it (spec 23.2), so its retain is kept.
        auto retainRoutineName =
            tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn &&
                    !MLIRTypeHelper::isSharedHandleType(descriptorType)
                ? std::string()
                : orl.getOrCreateRetainRoutine(descriptorType);

        rewriter.replaceOp(op, ch.getOrCreateTypeDescriptorName(descriptorType, name,
                                                               TypeOfOpHelper::typeKindFromName(name),
                                                               releaseRoutineName, retainRoutineName));

        return success();
    }
};

// Retain and Release lower to nothing at all unless the memory model is reference
// counting. That is what lets MLIRGen state ownership unconditionally: the ops carry the
// intent, and the model decides whether it costs anything. It also means the collected
// builds cannot be broken by where the ops are placed, only the counted ones can.
class RetainOpLowering : public TsLlvmPattern<mlir_ts::RetainOp>
{
  public:
    using TsLlvmPattern<mlir_ts::RetainOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::RetainOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        // A handle is counted under own too, and inference leaves its retains (spec 23.2).
        auto counted = MLIRTypeHelper::isSharedHandleType(op.getReference().getType());

        // Under own, ownership inference erased every retain it could prove, and reported the
        // rest; one that reaches here was neither, and erasing it would ship a double free.
        if (tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn && !counted)
        {
            return op.emitError("ownership inference left a retain behind");
        }

        if (tsLlvmContext->compileOptions.isRefCounted() || (tsLlvmContext->compileOptions.tracksOwnership() && counted))
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitRetainValue(op.getReference().getType(), transformed.getReference());
        }

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

class ReleaseOpLowering : public TsLlvmPattern<mlir_ts::ReleaseOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ReleaseOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReleaseOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        if (tsLlvmContext->compileOptions.tracksOwnership())
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitReleaseValue(op.getReference().getType(), transformed.getReference());
        }

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

// The slot-addressed forms. Same erasure rule, and erasing one of these takes the whole
// access with it - there is no load to leave behind in a collected build.
class RetainSlotOpLowering : public TsLlvmPattern<mlir_ts::RetainSlotOp>
{
  public:
    using TsLlvmPattern<mlir_ts::RetainSlotOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::RetainSlotOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        // A slot holding a handle is counted under own too, and inference leaves its retains
        // (spec 23.2).
        auto counted =
            MLIRTypeHelper::isSharedHandleType(cast<mlir_ts::RefType>(op.getSlot().getType()).getElementType());

        // Under own, ownership inference erased every retain it could prove, and reported the
        // rest; one that reaches here was neither, and erasing it would ship a double free.
        if (tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn && !counted)
        {
            return op.emitError("ownership inference left a retain behind");
        }

        if (tsLlvmContext->compileOptions.isRefCounted() || (tsLlvmContext->compileOptions.tracksOwnership() && counted))
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitRetainSlot(cast<mlir_ts::RefType>(op.getSlot().getType()).getElementType(), transformed.getSlot());
        }

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

class ReleaseSlotOpLowering : public TsLlvmPattern<mlir_ts::ReleaseSlotOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ReleaseSlotOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReleaseSlotOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        if (tsLlvmContext->compileOptions.tracksOwnership())
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitReleaseSlot(cast<mlir_ts::RefType>(op.getSlot().getType()).getElementType(), transformed.getSlot());
        }

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

// The cell-addressed forms. The slot is itself a heap block - a captured variable's storage -
// so these count owners of that block, where the two above count owners of the value in it.
class RetainCellOpLowering : public TsLlvmPattern<mlir_ts::RetainCellOp>
{
  public:
    using TsLlvmPattern<mlir_ts::RetainCellOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::RetainCellOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        // Under own, ownership inference erased every retain it could prove, and reported the
        // rest; one that reaches here was neither, and erasing it would ship a double free.
        if (tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn)
        {
            return op.emitError("ownership inference left a retain behind");
        }

        if (tsLlvmContext->compileOptions.isRefCounted())
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitRetainCell(transformed.getSlot());
        }

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

class ReleaseCellOpLowering : public TsLlvmPattern<mlir_ts::ReleaseCellOp>
{
  public:
    using TsLlvmPattern<mlir_ts::ReleaseCellOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReleaseCellOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        if (tsLlvmContext->compileOptions.tracksOwnership())
        {
            OwnershipRoutineLogic orl(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitReleaseCell(cast<mlir_ts::RefType>(op.getSlot().getType()).getElementType(),
                                transformed.getSlot(),
                                tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn &&
                                    op->hasAttr(OWN_CELL_BORROWS_ATTR_NAME));
        }

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

class SizeOfOpLowering : public TsLlvmPattern<mlir_ts::SizeOfOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SizeOfOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SizeOfOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();

        auto storageType = op.getType();
        // TODO: review usage SizeOf as for example when we allocate Array<Class1>  we use size of element but element is Pointer
        // if (auto classType = dyn_cast<mlir_ts::ClassType>(storageType))
        // {
        //     storageType = classType.getStorageType();
        // }
        // else if (auto valueRefType = dyn_cast<mlir_ts::ValueRefType>(storageType))
        // {
        //     storageType = valueRefType.getElementType();
        // }        
        // else if (auto objectType = dyn_cast<mlir_ts::ObjectType>(storageType))
        // {
        //     storageType = objectType.getStorageType();
        // }

        auto llvmStorageType = tch.convertType(storageType);
        mlir::Type llvmStorageTypePtr = th.getPtrType();
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto nullPtrToTypeValue = rewriter.create<LLVM::ZeroOp>(loc, llvmStorageTypePtr);

        LLVM_DEBUG(llvm::dbgs() << "\n!! size of - storage type: [" << storageType << "] llvm storage type: ["
                                << llvmStorageType << "] llvm ptr: [" << llvmStorageTypePtr << "]\n";);

        auto sizeOfSetAddr =
            rewriter.create<LLVM::GEPOp>(loc, llvmStorageTypePtr, llvmStorageType, nullPtrToTypeValue, ArrayRef<LLVM::GEPArg>{1});

        rewriter.replaceOpWithNewOp<LLVM::PtrToIntOp>(op, llvmIndexType, sizeOfSetAddr);

        return success();
    }
};

class LengthOfOpLowering : public TsLlvmPattern<mlir_ts::LengthOfOp>
{
  public:
    using TsLlvmPattern<mlir_ts::LengthOfOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LengthOfOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);

        auto loc = op->getLoc();

        rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(op, typeConverter->convertType(th.getIndexType()), transformed.getOp(),
                                                                MLIRHelper::getStructIndex(rewriter, ARRAY_SIZE_INDEX));

        return success();
    }
};

class SetLengthOfOpLowering : public TsLlvmPattern<mlir_ts::SetLengthOfOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SetLengthOfOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SetLengthOfOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(op, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = op.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(op.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());        

        LLVM_DEBUG(llvm::dbgs() << "arrayType: elementType: " << elementType << "\n";);
        LLVM_DEBUG(llvm::dbgs() << "arrayType: llvm: " << tch.convertType(arrayType) << "\n";);

        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);
        auto newCountAsIndexType = op.getNewLength();

        auto sizeOfTypeAsIndexType = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);

        auto multSizeOfTypeValue =
            rewriter.create<mlir::index::MulOp>(loc, th.getIndexType(), ValueRange{sizeOfTypeAsIndexType, newCountAsIndexType});

        auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);

        // `arr.length = n` on a grown array exposes slots the allocator has not written. They read
        // as zero: the default library's Set and Map grow their `int[]` buckets this way and take
        // an unwritten bucket for an empty one, and under rc and own a store into a slot gives up
        // what the slot held first (`isOwnedElementSlot`), so the release would read whatever was
        // last in that memory - `result.length = this.length` followed by `result[i] = ..` is the
        // default library's `Array.map`, and `arrS.map(e => e + "_")` crashed about one run in
        // three (§9.37).
        //
        // Every model but gc, whose collector hands back cleared memory - also when a block
        // shrunk in place grows again, GC_realloc having cleared what the shrink gave up.
        if (!tsLlvmContext->compileOptions.needsGCRuntime())
        {
            auto oldBytes = rewriter.create<mlir::index::MulOp>(loc, th.getIndexType(),
                                                                ValueRange{sizeOfTypeAsIndexType,
                                                                           rewriter.create<mlir::index::CastUOp>(
                                                                               loc, th.getIndexType(), countAsIndexType)});
            auto grew = rewriter.create<mlir::index::CmpOp>(loc, mlir::index::IndexCmpPredicate::UGT,
                                                            multSizeOfTypeValue, oldBytes);

            auto *currentBlock = rewriter.getInsertionBlock();
            auto *continuationBlock = rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());
            auto *zeroBlock = rewriter.createBlock(continuationBlock);

            rewriter.setInsertionPointToEnd(zeroBlock);
            auto tailStart = rewriter.create<LLVM::GEPOp>(loc, ptrType, th.getI8Type(), allocated,
                                                          ValueRange{rewriter.create<mlir::index::CastUOp>(
                                                              loc, llvmIndexType, oldBytes)});
            auto tailBytes = rewriter.create<mlir::index::SubOp>(loc, th.getIndexType(),
                                                                 multSizeOfTypeValue, oldBytes);
            rewriter.create<LLVM::MemsetOp>(
                loc, tailStart,
                rewriter.create<LLVM::ConstantOp>(loc, th.getI8Type(), rewriter.getI8IntegerAttr(0)),
                rewriter.create<mlir::index::CastUOp>(loc, llvmIndexType, tailBytes), /*isVolatile=*/false);
            rewriter.create<LLVM::BrOp>(loc, ValueRange{}, continuationBlock);

            rewriter.setInsertionPointToEnd(currentBlock);
            rewriter.create<LLVM::CondBrOp>(loc, grew, zeroBlock, continuationBlock);

            rewriter.setInsertionPointToStart(continuationBlock);
        }

        auto newCountAsLLVMType = rewriter.create<mlir::index::CastUOp>(loc, llvmIndexType, newCountAsIndexType);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsLLVMType, countAsIndexTypePtr);

        rewriter.eraseOp(op);

        return success();
    }
};

class StringLengthOpLowering : public TsLlvmPattern<mlir_ts::StringLengthOp>
{
  public:
    using TsLlvmPattern<mlir_ts::StringLengthOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StringLengthOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();
        auto i8PtrTy = th.getPtrType();
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto strlenFuncOp = ch.getOrInsertFunction("strlen", th.getFunctionType(llvmIndexType, {i8PtrTy}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, strlenFuncOp, transformed.getOp());
        return success();
    }
};

// A new block of `size` bytes with as much of the source as fits, its terminator included; the
// source is read and nothing else. A null source is copied as the empty string.
class StringResizeOpLowering : public TsLlvmPattern<mlir_ts::StringResizeOp>
{
  public:
    using TsLlvmPattern<mlir_ts::StringResizeOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StringResizeOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();
        auto i8PtrTy = th.getPtrType();
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto strType = mlir_ts::StringType::get(rewriter.getContext());
        mlir::Value source = transformed.getOp();
        mlir::Value emptyText = rewriter.create<mlir_ts::DialectCastOp>(
            loc, tch.convertType(strType), rewriter.create<mlir_ts::ConstantOp>(loc, strType, rewriter.getStringAttr("")));
        auto isNull = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, source,
                                                    rewriter.create<LLVM::ZeroOp>(loc, i8PtrTy));
        source = rewriter.create<LLVM::SelectOp>(loc, isNull, emptyText, source);

        mlir::Value size = transformed.getSize();
        auto newStringValue = ch.MemoryAlloc(size);

        auto strlenFuncOp = ch.getOrInsertFunction("strlen", th.getFunctionType(llvmIndexType, {i8PtrTy}));
        mlir::Value sourceBytes = rewriter.create<LLVM::CallOp>(loc, strlenFuncOp, ValueRange{source}).getResult();
        sourceBytes = rewriter.create<LLVM::AddOp>(
            loc, llvmIndexType,
            ValueRange{sourceBytes, rewriter.create<LLVM::ConstantOp>(loc, llvmIndexType, rewriter.getIntegerAttr(llvmIndexType, 1))});
        auto fits = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ult, sourceBytes, size);
        auto copyBytes = rewriter.create<LLVM::SelectOp>(loc, fits, sourceBytes, size);

        rewriter.create<LLVM::MemcpyOp>(loc, newStringValue, source, copyBytes, /*isVolatile=*/false);

        rewriter.replaceOp(op, ValueRange{newStringValue});
        return success();
    }
};

// LLVM's CoroSplit cannot spill variable-size allocas into the coroutine frame
// ("Coroutines cannot handle non static allocas yet"), so buffers inside a
// not-yet-split coroutine (async_execute_fn marked by the MLIR async lowering)
// must be heap-allocated instead.
static bool isInsidePresplitCoroutine(mlir::Operation *op)
{
    for (auto *parent = op->getParentOp(); parent; parent = parent->getParentOp())
    {
        if (auto passthrough = parent->getAttrOfType<mlir::ArrayAttr>("passthrough"))
        {
            for (auto attr : passthrough)
            {
                if (auto strAttr = dyn_cast<mlir::StringAttr>(attr))
                {
                    if (strAttr.getValue() == "presplitcoroutine")
                    {
                        return true;
                    }
                }
            }
        }
    }

    return false;
}

class StringConcatOpLowering : public TsLlvmPattern<mlir_ts::StringConcatOp>
{
  public:
    using TsLlvmPattern<mlir_ts::StringConcatOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StringConcatOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        CodeLogicHelper clh(op, rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();

        // TODO implement str concat
        auto i8PtrTy = th.getPtrType();
        auto i8PtrPtrTy = th.getPtrType();
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto strlenFuncOp = ch.getOrInsertFunction("strlen", th.getFunctionType(llvmIndexType, {i8PtrTy}));
        auto strcpyFuncOp = ch.getOrInsertFunction("strcpy", th.getFunctionType(i8PtrTy, {i8PtrTy, i8PtrTy}));
        auto strcatFuncOp = ch.getOrInsertFunction("strcat", th.getFunctionType(i8PtrTy, {i8PtrTy, i8PtrTy}));

        SmallVector<mlir::Value> opers;
        for (auto oper : transformed.getOps())
        {
            opers.push_back(nullStringAsText(loc, oper, rewriter, tch));
        }

        mlir::Value size = clh.createIndexConstantOf(llvmIndexType, 1);
        // calc size
        for (auto oper : opers)
        {
            auto size1 = rewriter.create<LLVM::CallOp>(loc, strlenFuncOp, oper);
            size = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{size, size1.getResult()});
        }

        auto allocInStack = op.getAllocInStack().has_value() && op.getAllocInStack().value()
                            && !isInsidePresplitCoroutine(op);

        mlir::Value newStringValue = allocInStack ? ch.Alloca(th.getI8Type(), size, true)
                                                  : ch.MemoryAlloc(size);

        // copy
        auto concat = false;
        auto result = newStringValue;
        for (auto oper : opers)
        {
            if (concat)
            {
                auto callResult = rewriter.create<LLVM::CallOp>(loc, strcatFuncOp, ValueRange{result, oper});
                result = callResult.getResult();
            }
            else
            {
                auto callResult = rewriter.create<LLVM::CallOp>(loc, strcpyFuncOp, ValueRange{result, oper});
                result = callResult.getResult();
            }

            concat = true;
        }

        rewriter.replaceOp(op, ValueRange{newStringValue});

        return success();
    }
};

// A copy of a string: `strlen + 1` bytes, from the allocator `ts.StringConcat` uses. A null string
// stays null and allocates nothing. An optional `{ptr, i1}` is copied only when it holds a value:
// a pointer whose flag says "none" may be anything.
class StringCopyOpLowering : public TsLlvmPattern<mlir_ts::StringCopyOp>
{
  public:
    using TsLlvmPattern<mlir_ts::StringCopyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StringCopyOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(op, rewriter);

        auto loc = op->getLoc();
        auto i8PtrTy = th.getPtrType();
        auto llvmIndexType = tch.convertType(th.getIndexType());
        auto llvmBoolType = th.getLLVMBoolType();
        auto strlenFuncOp = ch.getOrInsertFunction("strlen", th.getFunctionType(llvmIndexType, {i8PtrTy}));

        auto copyOf = [&](mlir::Value source, mlir::Value copyIt) {
            return clh.conditionalExpressionLowering(
                loc, i8PtrTy, copyIt,
                [&](OpBuilder &, Location) -> mlir::Value {
                    mlir::Value bytes = rewriter.create<LLVM::CallOp>(loc, strlenFuncOp, ValueRange{source}).getResult();
                    bytes = rewriter.create<LLVM::AddOp>(
                        loc, llvmIndexType,
                        ValueRange{bytes, rewriter.create<LLVM::ConstantOp>(loc, llvmIndexType, rewriter.getIntegerAttr(llvmIndexType, 1))});
                    auto copy = ch.MemoryAlloc(bytes);
                    rewriter.create<LLVM::MemcpyOp>(loc, copy, source, bytes, /*isVolatile=*/false);
                    return copy;
                },
                [&](OpBuilder &, Location) -> mlir::Value { return source; });
        };

        mlir::Value in = transformed.getIn();
        auto isSet = [&](mlir::Value pointer) -> mlir::Value {
            return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, pointer, rewriter.create<LLVM::ZeroOp>(loc, i8PtrTy));
        };

        if (mlir::isa<LLVM::LLVMPointerType>(in.getType()))
        {
            rewriter.replaceOp(op, ValueRange{copyOf(in, isSet(in))});
            return success();
        }

        // an optional: `{ptr, i1}`
        auto optionalType = mlir::dyn_cast<LLVM::LLVMStructType>(in.getType());
        if (!optionalType || optionalType.getBody().size() != 2 ||
            !mlir::isa<LLVM::LLVMPointerType>(optionalType.getBody()[0]) || !optionalType.getBody()[1].isInteger(1))
        {
            return rewriter.notifyMatchFailure(op, "ts.StringCopy takes a pointer or a { ptr, i1 } optional");
        }

        auto pointer = rewriter.create<LLVM::ExtractValueOp>(loc, in, ArrayRef<int64_t>{0});
        auto hasValue = rewriter.create<LLVM::ExtractValueOp>(loc, in, ArrayRef<int64_t>{1});
        auto copyIt = rewriter.create<LLVM::AndOp>(loc, llvmBoolType, hasValue, isSet(pointer));
        auto copied = copyOf(pointer, copyIt);
        rewriter.replaceOp(op, ValueRange{rewriter.create<LLVM::InsertValueOp>(loc, in, copied, ArrayRef<int64_t>{0})});
        return success();
    }
};

// `new Shared(x)` (own spec 23): a heap block with the header every block has (a count under rc
// and own, born 0 like any block), whose payload is the value.
class SharedNewOpLowering : public TsLlvmPattern<mlir_ts::SharedNewOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SharedNewOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SharedNewOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        auto elementType = mlir::cast<mlir_ts::SharedType>(op.getType()).getElementType();
        auto handle = ch.MemoryAlloc(elementType, MemoryAllocSet::Zero);
        rewriter.create<LLVM::StoreOp>(op->getLoc(), transformed.getValue(), handle);
        rewriter.replaceOp(op, ValueRange{handle});
        return success();
    }
};

// `s.value`: the payload starts at the handle.
class SharedValueRefOpLowering : public TsLlvmPattern<mlir_ts::SharedValueRefOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SharedValueRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SharedValueRefOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOp(op, ValueRange{transformed.getShared()});
        return success();
    }
};

// `Shared.count(s)`: the header word under rc and own; gc and none never write it.
class SharedCountOpLowering : public TsLlvmPattern<mlir_ts::SharedCountOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SharedCountOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SharedCountOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();
        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto numberType = tch.convertType(op.getType());
        if (!tsLlvmContext->compileOptions.tracksOwnership())
        {
            rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(op, numberType, rewriter.getFloatAttr(numberType, -1.0));
            return success();
        }

        auto llvmIndexType = tch.convertType(th.getIndexType());
        auto blockPtr = ch.getBlockPtrFromPayloadPtr(loc, transformed.getShared(), llvmIndexType);
        auto count = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, blockPtr);
        rewriter.replaceOpWithNewOp<LLVM::SIToFPOp>(op, numberType, count);
        return success();
    }
};

class StringCompareOpLowering : public TsLlvmPattern<mlir_ts::StringCompareOp>
{
  public:
    using TsLlvmPattern<mlir_ts::StringCompareOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StringCompareOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        CodeLogicHelper clh(op, rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        LLVMTypeConverterHelper llvmtch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));

        auto loc = op->getLoc();

        auto i8PtrTy = th.getPtrType();

        // compare bodies
        auto strcmpFuncOp = ch.getOrInsertFunction("strcmp", th.getFunctionType(th.getI32Type(), {i8PtrTy, i8PtrTy}));

        // compare ptrs first
        auto intPtrType = llvmtch.getIntPtrType(0);
        auto const0 = clh.createIConstantOf(llvmtch.getPointerBitwidth(0), 0);
        auto leftPtrValue = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, transformed.getOp1());
        auto rightPtrValue = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, transformed.getOp2());
        auto ptrCmpResult1 = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, leftPtrValue, const0);
        auto ptrCmpResult2 = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, rightPtrValue, const0);
        auto cmp32Result1 = rewriter.create<mlir_ts::CastOp>(loc, th.getI32Type(), ptrCmpResult1);
        auto cmp32Result2 = rewriter.create<mlir_ts::CastOp>(loc, th.getI32Type(), ptrCmpResult2);
        auto cmpResult = rewriter.create<LLVM::AndOp>(loc, cmp32Result1, cmp32Result2);
        auto const0I32 = clh.createI32ConstantOf(0);
        auto ptrCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, cmpResult, const0I32);

        auto result = clh.conditionalExpressionLowering(
            loc, th.getLLVMBoolType(), ptrCmpResult,
            [&](OpBuilder &builder, Location loc) {
                // both not null
                auto const0 = clh.createI32ConstantOf(0);
                auto compareResult =
                    rewriter.create<LLVM::CallOp>(loc, strcmpFuncOp, ValueRange{transformed.getOp1(), transformed.getOp2()});

                // else compare body
                mlir::Value bodyCmpResult;
                switch ((SyntaxKind)op.getCode())
                {
                case SyntaxKind::EqualsEqualsToken:
                case SyntaxKind::EqualsEqualsEqualsToken:
                    bodyCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, compareResult.getResult(), const0);
                    break;
                case SyntaxKind::ExclamationEqualsToken:
                case SyntaxKind::ExclamationEqualsEqualsToken:
                    bodyCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, compareResult.getResult(), const0);
                    break;
                case SyntaxKind::GreaterThanToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::GreaterThanEqualsToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sge,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::LessThanToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::LessThanEqualsToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sle,
                                                                  compareResult.getResult(), const0);
                    break;
                default:
                    // op's opcode always comes from LogicalBinaryOp, whose only construction
                    // sites (traced across the whole codebase) use one of the 8 relational
                    // operators handled above.
                    op->emitError("unsupported string comparison operator");
                    return mlir::Value();
                }

                return bodyCmpResult;
            },
            [&](OpBuilder &builder, Location loc) {
                // else compare body
                mlir::Value ptrCmpResult;
                switch ((SyntaxKind)op.getCode())
                {
                case SyntaxKind::EqualsEqualsToken:
                case SyntaxKind::EqualsEqualsEqualsToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, leftPtrValue, rightPtrValue);
                    break;
                case SyntaxKind::ExclamationEqualsToken:
                case SyntaxKind::ExclamationEqualsEqualsToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, leftPtrValue, rightPtrValue);
                    break;
                case SyntaxKind::GreaterThanToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt, leftPtrValue, rightPtrValue);
                    break;
                case SyntaxKind::GreaterThanEqualsToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sge, leftPtrValue, rightPtrValue);
                    break;
                case SyntaxKind::LessThanToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, leftPtrValue, rightPtrValue);
                    break;
                case SyntaxKind::LessThanEqualsToken:
                    ptrCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sle, leftPtrValue, rightPtrValue);
                    break;
                default:
                    // op's opcode always comes from LogicalBinaryOp, whose only construction
                    // sites (traced across the whole codebase) use one of the 8 relational
                    // operators handled above.
                    op->emitError("unsupported string comparison operator");
                    return mlir::Value();
                }

                return ptrCmpResult;
            });

        rewriter.replaceOp(op, result);

        return success();
    }
};

class AnyCompareOpLowering : public TsLlvmPattern<mlir_ts::AnyCompareOp>
{
  public:
    using TsLlvmPattern<mlir_ts::AnyCompareOp>::TsLlvmPattern;

    // same-representation compare: valid when both operands are known to hold the
    // same underlying kind (used both when the loose == / != tags actually match, and
    // for ===/!==/relational ops, which never coerce across kinds).
    mlir::Value sameKindCompare(mlir_ts::AnyCompareOp op, mlir::Value op1, mlir::Value op2, SyntaxKind code,
                                mlir::Location loc, AnyLogic &al, CodeLogicHelper &clh, TypeHelper &th,
                                LLVMCodeHelper &ch, LLVMTypeConverterHelper &llvmtch,
                                ConversionPatternRewriter &rewriter) const
    {
        auto i8PtrTy = th.getPtrType();

        auto compareResultWith0 = [&](mlir::Value compareResult) -> mlir::Value {
            auto const0 = clh.createI32ConstantOf(0);
            switch (code)
            {
            case SyntaxKind::EqualsEqualsToken:
            case SyntaxKind::EqualsEqualsEqualsToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, compareResult, const0);
            case SyntaxKind::ExclamationEqualsToken:
            case SyntaxKind::ExclamationEqualsEqualsToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, compareResult, const0);
            case SyntaxKind::GreaterThanToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt, compareResult, const0);
            case SyntaxKind::GreaterThanEqualsToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sge, compareResult, const0);
            case SyntaxKind::LessThanToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, compareResult, const0);
            case SyntaxKind::LessThanEqualsToken:
                return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sle, compareResult, const0);
            default:
                op->emitError("unsupported 'any' comparison operator");
                return mlir::Value();
            }
        };

        // two strings compare by their text: their payload is a pointer, and comparing its bytes
        // made two equal strings unequal unless they were the same literal
        TypeConverterHelper tch(getTypeConverter());
        TypeDescriptorLogic tdl(rewriter, tch, loc);
        auto bothStrings = rewriter.create<LLVM::AndOp>(loc, tdl.isKind(al.getTypeOfAny(op1), TYPE_KIND_STRING),
                                                        tdl.isKind(al.getTypeOfAny(op2), TYPE_KIND_STRING));
        return clh.conditionalExpressionLowering(
            loc, th.getLLVMBoolType(), bothStrings,
            [&](OpBuilder &, Location) {
                auto strcmpFuncOp = ch.getOrInsertFunction("strcmp", th.getFunctionType(th.getI32Type(), {i8PtrTy, i8PtrTy}));
                auto compareResult = rewriter.create<LLVM::CallOp>(
                    loc, strcmpFuncOp, ValueRange{al.UnboxAny(op1, i8PtrTy), al.UnboxAny(op2, i8PtrTy)});
                return compareResultWith0(compareResult.getResult());
            },
            [&](OpBuilder &, Location) { return compareBytes(op, op1, op2, code, loc, al, clh, th, ch, llvmtch, rewriter); });
    }

    // the payloads' bytes: for everything but a string, whose payload is a pointer
    mlir::Value compareBytes(mlir_ts::AnyCompareOp op, mlir::Value op1, mlir::Value op2, SyntaxKind code,
                             mlir::Location loc, AnyLogic &al, CodeLogicHelper &clh, TypeHelper &th,
                             LLVMCodeHelper &ch, LLVMTypeConverterHelper &llvmtch,
                             ConversionPatternRewriter &rewriter) const
    {
        auto i8PtrTy = th.getPtrType();
        auto llvmIndexType = llvmtch.typeConverter->convertType(th.getIndexType());

        auto memcmpFuncOp = ch.getOrInsertFunction("memcmp", th.getFunctionType(th.getI32Type(), {i8PtrTy, i8PtrTy, llvmIndexType}));

        auto sizeAny1 = al.getDataSizeOfAny(op1);
        auto sizeAny2 = al.getDataSizeOfAny(op2);

        auto sizesEqual = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, sizeAny1, sizeAny2);

        auto dataPtr1 = al.getDataPtrOfAny(op1);
        auto dataPtr2 = al.getDataPtrOfAny(op2);

        return clh.conditionalExpressionLowering(
            loc, th.getLLVMBoolType(), sizesEqual,
            [&](OpBuilder &builder, Location loc) {
                auto const0 = clh.createI32ConstantOf(0);
                // sizeAny1 equals sizeAny2
                auto compareResult =
                    rewriter.create<LLVM::CallOp>(loc, memcmpFuncOp, ValueRange{dataPtr1, dataPtr2, sizeAny1});

                // else compare body
                mlir::Value bodyCmpResult;
                switch (code)
                {
                case SyntaxKind::EqualsEqualsToken:
                case SyntaxKind::EqualsEqualsEqualsToken:
                    bodyCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, compareResult.getResult(), const0);
                    break;
                case SyntaxKind::ExclamationEqualsToken:
                case SyntaxKind::ExclamationEqualsEqualsToken:
                    bodyCmpResult =
                        rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, compareResult.getResult(), const0);
                    break;
                case SyntaxKind::GreaterThanToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::GreaterThanEqualsToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sge,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::LessThanToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt,
                                                                  compareResult.getResult(), const0);
                    break;
                case SyntaxKind::LessThanEqualsToken:
                    bodyCmpResult = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sle,
                                                                  compareResult.getResult(), const0);
                    break;
                default:
                    // code always comes from LogicalBinaryOp's opcode, whose only construction
                    // sites (traced across the whole codebase) use one of the 8 relational
                    // operators handled above.
                    op->emitError("unsupported 'any' comparison operator");
                    return mlir::Value();
                }

                return bodyCmpResult;
            },
            [&](OpBuilder &builder, Location loc) {
                // sizes (and therefore kinds) differ: == is false, != is true; ordering
                // ops and === / !== fall back to their pre-existing "false" behavior.
                if (code == SyntaxKind::ExclamationEqualsToken)
                {
                    return (mlir::Value)rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, sizeAny1, sizeAny2);
                }

                return (mlir::Value)sizesEqual;
            });
    }

    // JS loose equality across differing `any` payload kinds: number<->string,
    // number<->boolean, string<->boolean each coerce (number.toString()/parseFloat(),
    // boolean->0|1, boolean->"true"|"false") rather than comparing raw bytes. Only
    // reached for ==/!= once the runtime type tags are known to differ.
    mlir::Value coerceAndCompareMixedKinds(mlir::Value op1, mlir::Value op2, mlir::Value tag1, mlir::Value tag2,
                                           SyntaxKind code, mlir::Location loc, AnyLogic &al, CastLogicHelper &castLogic,
                                           CodeLogicHelper &clh, TypeHelper &th, LLVMCodeHelper &ch, TypeConverterHelper &tch,
                                           ConversionPatternRewriter &rewriter) const
    {
        auto isEquals = code == SyntaxKind::EqualsEqualsToken;

        auto numberTy = mlir_ts::NumberType::get(rewriter.getContext());
        auto stringTy = mlir_ts::StringType::get(rewriter.getContext());
        auto booleanTy = mlir_ts::BooleanType::get(rewriter.getContext());

        auto isTag = [&](mlir::Value tag, const char *name) {
            auto tagLiteral = ch.getOrCreateGlobalString(name, std::string(name));
            auto strcmpFuncOp = ch.getOrInsertFunction("strcmp", th.getFunctionType(th.getI32Type(), {th.getPtrType(), th.getPtrType()}));
            auto cmp = rewriter.create<LLVM::CallOp>(loc, strcmpFuncOp, ValueRange{tag, tagLiteral});
            auto const0 = clh.createI32ConstantOf(0);
            return (mlir::Value)rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, cmp.getResult(), const0);
        };

        // typeOfAsString reports concrete-width tags ("s32"/"s64"/...) for integer
        // literals and only uses "number" for float-typed values (see
        // TypeOfOpHelper::typeOfAsString), so "is this any numeric" cannot just test the
        // name "number". The descriptor behind every tag carries the category directly, so
        // this is one load and one compare rather than a chain of strcmps -- and it covers
        // every numeric width rather than the nine that were spelled out here before.
        TypeDescriptorLogic tdl(rewriter, tch, loc);
        auto isKind = [&](mlir::Value tag, int kind) { return tdl.isKind(tag, kind); };

        // unbox a numeric `any` (whatever its concrete boxed width/signedness) into
        // a normalized f64 for comparison, dispatching on the exact tag reported at
        // box time so we read back the same width that was stored. This one stays
        // name-based: the descriptor's kind says "numeric", not which width, and the
        // width is what decides how many bytes to read back.
        auto unboxNumericAsF64 = [&](mlir::Value numberSideAny, mlir::Value numberTag) {
            auto asF64 = [&](mlir::Type storedTy) {
                auto raw = al.UnboxAny(numberSideAny, tch.convertType(storedTy));
                return storedTy == numberTy ? raw : castLogic.cast(raw, storedTy, numberTy);
            };

            return clh.conditionalExpressionLowering(
                loc, th.getF64Type(), isTag(numberTag, "number"),
                [&](OpBuilder &, Location) { return asF64(numberTy); },
                [&](OpBuilder &, Location) {
                    return clh.conditionalExpressionLowering(
                        loc, th.getF64Type(), isTag(numberTag, "s64"),
                        [&](OpBuilder &, Location) { return asF64(mlir::IntegerType::get(rewriter.getContext(), 64, mlir::IntegerType::Signed)); },
                        [&](OpBuilder &, Location) { return asF64(mlir::IntegerType::get(rewriter.getContext(), 32, mlir::IntegerType::Signed)); });
                });
        };

        auto compareAsNumber = [&](mlir::Value numVal1, mlir::Value numVal2) {
            return (mlir::Value)rewriter.create<LLVM::FCmpOp>(
                loc, isEquals ? LLVM::FCmpPredicate::oeq : LLVM::FCmpPredicate::une, numVal1, numVal2);
        };

        auto compareAsString = [&](mlir::Value strVal1, mlir::Value strVal2) {
            auto strcmpFuncOp = ch.getOrInsertFunction("strcmp", th.getFunctionType(th.getI32Type(), {th.getPtrType(), th.getPtrType()}));
            auto cmp = rewriter.create<LLVM::CallOp>(loc, strcmpFuncOp, ValueRange{strVal1, strVal2});
            auto const0 = clh.createI32ConstantOf(0);
            return (mlir::Value)rewriter.create<LLVM::ICmpOp>(
                loc, isEquals ? LLVM::ICmpPredicate::eq : LLVM::ICmpPredicate::ne, cmp.getResult(), const0);
        };

        // number <-> string: coerce the string side with parseFloat
        auto numberStringCase = [&](mlir::Value numberSideAny, mlir::Value numberTag, mlir::Value stringSideAny) {
            auto numVal = unboxNumericAsF64(numberSideAny, numberTag);
            auto strVal = al.UnboxAny(stringSideAny, th.getPtrType());
            auto coercedNum = castLogic.cast(strVal, stringTy, numberTy);
            return compareAsNumber(numVal, coercedNum);
        };

        // boolean <-> number: coerce the boolean side to 0.0/1.0
        auto booleanNumberCase = [&](mlir::Value booleanSideAny, mlir::Value numberSideAny, mlir::Value numberTag) {
            auto boolVal = al.UnboxAny(booleanSideAny, th.getLLVMBoolType());
            auto numVal = unboxNumericAsF64(numberSideAny, numberTag);
            auto coercedNum = castLogic.cast(boolVal, booleanTy, numberTy);
            return compareAsNumber(coercedNum, numVal);
        };

        // boolean <-> string: coerce the boolean side to "true"/"false"
        auto booleanStringCase = [&](mlir::Value booleanSideAny, mlir::Value stringSideAny) {
            auto boolVal = al.UnboxAny(booleanSideAny, th.getLLVMBoolType());
            auto strVal = al.UnboxAny(stringSideAny, th.getPtrType());
            auto coercedStr = castLogic.cast(boolVal, booleanTy, stringTy);
            return compareAsString(coercedStr, strVal);
        };

        auto tag1IsNumber = isKind(tag1, TYPE_KIND_NUMBER);
        auto tag1IsString = isKind(tag1, TYPE_KIND_STRING);
        auto tag1IsBoolean = isKind(tag1, TYPE_KIND_BOOLEAN);
        auto tag2IsNumber = isKind(tag2, TYPE_KIND_NUMBER);
        auto tag2IsString = isKind(tag2, TYPE_KIND_STRING);
        auto tag2IsBoolean = isKind(tag2, TYPE_KIND_BOOLEAN);

        auto op1IsNumberOp2IsString = rewriter.create<LLVM::AndOp>(loc, tag1IsNumber, tag2IsString);
        auto op1IsStringOp2IsNumber = rewriter.create<LLVM::AndOp>(loc, tag1IsString, tag2IsNumber);
        auto op1IsBooleanOp2IsNumber = rewriter.create<LLVM::AndOp>(loc, tag1IsBoolean, tag2IsNumber);
        auto op1IsNumberOp2IsBoolean = rewriter.create<LLVM::AndOp>(loc, tag1IsNumber, tag2IsBoolean);
        auto op1IsBooleanOp2IsString = rewriter.create<LLVM::AndOp>(loc, tag1IsBoolean, tag2IsString);
        auto op1IsStringOp2IsBoolean = rewriter.create<LLVM::AndOp>(loc, tag1IsString, tag2IsBoolean);

        return clh.conditionalExpressionLowering(
            loc, th.getLLVMBoolType(), op1IsNumberOp2IsString,
            [&](OpBuilder &, Location loc) { return numberStringCase(op1, tag1, op2); },
            [&](OpBuilder &builder, Location loc) {
                return clh.conditionalExpressionLowering(
                    loc, th.getLLVMBoolType(), op1IsStringOp2IsNumber,
                    [&](OpBuilder &, Location loc) { return numberStringCase(op2, tag2, op1); },
                    [&](OpBuilder &builder, Location loc) {
                        return clh.conditionalExpressionLowering(
                            loc, th.getLLVMBoolType(), op1IsBooleanOp2IsNumber,
                            [&](OpBuilder &, Location loc) { return booleanNumberCase(op1, op2, tag2); },
                            [&](OpBuilder &builder, Location loc) {
                                return clh.conditionalExpressionLowering(
                                    loc, th.getLLVMBoolType(), op1IsNumberOp2IsBoolean,
                                    [&](OpBuilder &, Location loc) { return booleanNumberCase(op2, op1, tag1); },
                                    [&](OpBuilder &builder, Location loc) {
                                        return clh.conditionalExpressionLowering(
                                            loc, th.getLLVMBoolType(), op1IsBooleanOp2IsString,
                                            [&](OpBuilder &, Location loc) { return booleanStringCase(op1, op2); },
                                            [&](OpBuilder &builder, Location loc) {
                                                return clh.conditionalExpressionLowering(
                                                    loc, th.getLLVMBoolType(), op1IsStringOp2IsBoolean,
                                                    [&](OpBuilder &, Location loc) { return booleanStringCase(op2, op1); },
                                                    [&](OpBuilder &builder, Location loc) {
                                                        // no known coercion: kinds differ and are unequal
                                                        return (mlir::Value)clh.createI1ConstantOf(!isEquals);
                                                    });
                                            });
                                    });
                            });
                    });
            });
    }

    LogicalResult matchAndRewrite(mlir_ts::AnyCompareOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        CodeLogicHelper clh(op, rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());
        LLVMTypeConverterHelper llvmtch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));
        CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);

        auto loc = op->getLoc();
        auto code = (SyntaxKind)op.getCode();

        AnyLogic al(op, rewriter, tch, loc, tsLlvmContext->compileOptions);

        auto op1 = transformed.getOp1();
        auto op2 = transformed.getOp2();

        auto compareBoxes = [&]() -> mlir::Value {
            // only loose equality (==/!=) coerces across differing payload kinds; strict
            // equality and ordering compare the underlying bytes as before.
            if (code != SyntaxKind::EqualsEqualsToken && code != SyntaxKind::ExclamationEqualsToken)
            {
                return sameKindCompare(op, op1, op2, code, loc, al, clh, th, ch, llvmtch, rewriter);
            }

            auto tag1 = al.getTypeOfAny(op1);
            auto tag2 = al.getTypeOfAny(op2);

            auto strcmpFuncOp = ch.getOrInsertFunction("strcmp", th.getFunctionType(th.getI32Type(), {th.getPtrType(), th.getPtrType()}));
            auto tagCmp = rewriter.create<LLVM::CallOp>(loc, strcmpFuncOp, ValueRange{tag1, tag2});
            auto const0 = clh.createI32ConstantOf(0);
            auto tagsEqual = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, tagCmp.getResult(), const0);

            return clh.conditionalExpressionLowering(
                loc, th.getLLVMBoolType(), tagsEqual,
                [&](OpBuilder &builder, Location loc) { return sameKindCompare(op, op1, op2, code, loc, al, clh, th, ch, llvmtch, rewriter); },
                [&](OpBuilder &builder, Location loc) { return coerceAndCompareMixedKinds(op1, op2, tag1, tag2, code, loc, al, castLogic, clh, th, ch, tch, rewriter); });
        };

        // `undefined` and `null` in an `any`, answered before any box is opened: `u == undefined`
        // of an `any` holding undefined was false - the box's tag and bytes were compared against
        // `undefined` or `null` turned into an `any`, which is a null pointer rather than a box,
        // so its tag was read from address 8 - and a zeroed `any` slot is a null pointer too. A
        // null pointer is undefined; otherwise the tag's kind says. Loosely, undefined and null
        // equal each other and nothing else; strictly, each equals only itself.
        auto nullPtr = rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType());
        TypeDescriptorLogic tdl(rewriter, tch, loc);
        auto kindOf = [&](mlir::Value anyValue) {
            auto isNullPtr = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, anyValue, nullPtr);
            return clh.conditionalExpressionLowering(
                loc, th.getI32Type(), isNullPtr,
                [&](OpBuilder &, Location) { return (mlir::Value)clh.createI32ConstantOf(TYPE_KIND_UNDEFINED); },
                [&](OpBuilder &, Location) { return tdl.getKindFromTag(al.getTypeOfAny(anyValue)); });
        };

        auto isNullish = [&](mlir::Value kind) {
            auto isUndefined = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, kind, clh.createI32ConstantOf(TYPE_KIND_UNDEFINED));
            auto isNull = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, kind, clh.createI32ConstantOf(TYPE_KIND_NULL));
            return (mlir::Value)rewriter.create<LLVM::OrOp>(loc, isUndefined, isNull);
        };

        auto kind1 = kindOf(op1);
        auto kind2 = kindOf(op2);
        auto nullish1 = isNullish(kind1);
        auto nullish2 = isNullish(kind2);
        auto eitherNullish = rewriter.create<LLVM::OrOp>(loc, nullish1, nullish2);

        auto result = clh.conditionalExpressionLowering(
            loc, th.getLLVMBoolType(), eitherNullish,
            [&](OpBuilder &, Location) -> mlir::Value {
                switch (code)
                {
                case SyntaxKind::EqualsEqualsToken:
                    return rewriter.create<LLVM::AndOp>(loc, nullish1, nullish2);
                case SyntaxKind::ExclamationEqualsToken:
                    return rewriter.create<LLVM::XOrOp>(loc, rewriter.create<LLVM::AndOp>(loc, nullish1, nullish2),
                                                        clh.createI1ConstantOf(true));
                case SyntaxKind::EqualsEqualsEqualsToken:
                    return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, kind1, kind2);
                case SyntaxKind::ExclamationEqualsEqualsToken:
                    return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, kind1, kind2);
                default:
                    // an ordering against undefined or null: false, as before, without reading a box
                    return clh.createI1ConstantOf(false);
                }
            },
            [&](OpBuilder &, Location) { return compareBoxes(); });

        rewriter.replaceOp(op, result);

        return success();
    }
};

class CharToStringOpLowering : public TsLlvmPattern<mlir_ts::CharToStringOp>
{
  public:
    using TsLlvmPattern<mlir_ts::CharToStringOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CharToStringOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        CodeLogicHelper clh(op, rewriter);
        LLVMCodeHelper ch(op, rewriter, typeConverter, tsLlvmContext->compileOptions);

        auto loc = op->getLoc();

        auto charType = mlir_ts::CharType::get(rewriter.getContext());

        auto i8PtrTy = th.getPtrType();

        auto bufferSizeValue = clh.createI64ConstantOf(2);
        // TODO: review it, !! we can't allocate it in stack - otherwise when returned back from function, it will be poisned
        // TODO: maybe you need to add mechanizm to convert stack values to heap when returned from function
        //auto newStringValue = ch.Alloca(i8PtrTy, bufferSizeValue, true);
        auto newStringValue = ch.MemoryAlloc(bufferSizeValue);

        auto index0Value = clh.createI32ConstantOf(0);
        auto index1Value = clh.createI32ConstantOf(1);
        auto nullCharValue = clh.createI8ConstantOf(0);
        auto addr0 = ch.GetAddressOfArrayElement(charType, newStringValue.getType(), newStringValue, index0Value);
        rewriter.create<LLVM::StoreOp>(loc, transformed.getOp(), addr0);
        auto addr1 = ch.GetAddressOfArrayElement(charType, newStringValue.getType(), newStringValue, index1Value);
        rewriter.create<LLVM::StoreOp>(loc, nullCharValue, addr1);

        rewriter.replaceOp(op, ValueRange{newStringValue});

        return success();
    }
};

struct ConstantOpLowering : public TsLlvmPattern<mlir_ts::ConstantOp>
{
    using TsLlvmPattern<mlir_ts::ConstantOp>::TsLlvmPattern;

    template <typename T, typename TOp>
    void getArrayValue(TOp constantOp, T type, ConversionPatternRewriter &rewriter) const
    {
        LLVMCodeHelper ch(constantOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto elementType = cast<T>(type).getElementType();
        auto llvmElementType = tch.convertType(elementType);
        auto arrayAttr = dyn_cast_or_null<ArrayAttr>(constantOp.getValue());

        auto arrayValue =
            ch.getArrayValue(elementType, llvmElementType, arrayAttr.size(), arrayAttr);

        rewriter.replaceOp(constantOp, arrayValue);
    }

    template <typename T, typename TOp>
    void getOrCreateGlobalArray(TOp constantOp, T type, ConversionPatternRewriter &rewriter) const
    {
        LLVMCodeHelper ch(constantOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto elementType = cast<T>(type).getElementType();

        LLVM_DEBUG(llvm::dbgs() << "constArrayType: elementType: "; elementType.dump(); llvm::dbgs() << "\n";);

        auto llvmElementType = tch.convertType(elementType);

        LLVM_DEBUG(llvm::dbgs() << "constArrayType: llvmElementType: "; llvmElementType.dump(); llvm::dbgs() << "\n";);

        auto arrayAttr = dyn_cast_or_null<ArrayAttr>(constantOp.getValue());

        LLVM_DEBUG(llvm::dbgs() << "constArrayType: arrayAttr: "; arrayAttr.dump(); llvm::dbgs() << "\n";);

        auto arrayFirstElementAddrCst =
            ch.getOrCreateGlobalArray(elementType, arrayAttr.size(), arrayAttr);

        rewriter.replaceOp(constantOp, arrayFirstElementAddrCst);
    }

    template <typename TOp>
    void getOrCreateGlobalTuple(TOp constantOp, mlir::Type type, ConversionPatternRewriter &rewriter) const
    {
        auto location = constantOp->getLoc();

        LLVMCodeHelper ch(constantOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto arrayAttr = dyn_cast_or_null<ArrayAttr>(constantOp.getValue());

        auto convertedTupleType = tch.convertType(type);
        /*
        auto tupleConstPtr = ch.getOrCreateGlobalTuple(cast<mlir_ts::ConstTupleType>(type),
                                                       cast<LLVM::LLVMStructType>(convertedTupleType),
        arrayAttr);

        // optimize it and replace it with copy memory. (use canon. pass) check  "EraseRedundantAssertions"
        auto loadedValue = rewriter.create<LLVM::LoadOp>(constantOp->getLoc(), tupleConstPtr);
        */

        auto tupleVal = ch.getTupleFromArrayAttr(location, dyn_cast<mlir_ts::ConstTupleType>(type),
                                                 mlir::cast<LLVM::LLVMStructType>(convertedTupleType), arrayAttr);

        // rewriter.replaceOp(constantOp, ValueRange{loadedValue});
        rewriter.replaceOp(constantOp, ValueRange{tupleVal});
    }

    LogicalResult matchAndRewrite(mlir_ts::ConstantOp constantOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        // load address of const string
        auto type = constantOp.getType();
        if (auto literalType = dyn_cast<mlir_ts::LiteralType>(type))
        {
            type = literalType.getElementType();
        }

        if (isa<mlir_ts::StringType>(type))
        {
            LLVMCodeHelper ch(constantOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

            auto strValue = cast<StringAttr>(constantOp.getValue()).getValue().str();
            auto txtCst = ch.getOrCreateGlobalString(strValue);

            rewriter.replaceOp(constantOp, txtCst);

            return success();
        }

        TypeConverterHelper tch(getTypeConverter());
        if (auto constArrayType = dyn_cast<mlir_ts::ConstArrayType>(type))
        {
            LLVM_DEBUG(llvm::dbgs() << "constArrayType: type: "; type.dump(); llvm::dbgs() << "\n";);

            getOrCreateGlobalArray(constantOp, constArrayType, rewriter);
            return success();
        }

        if (auto constArrayValueType = dyn_cast<mlir_ts::ConstArrayValueType>(type))
        {
            if (auto arrayAttr = dyn_cast_or_null<ArrayAttr>(constantOp.getValue()))
            {
                getArrayValue(constantOp, constArrayValueType, rewriter);
                return success();
            }
        }

        if (auto arrayType = dyn_cast<mlir_ts::ArrayType>(type))
        {
            getOrCreateGlobalArray(constantOp, arrayType, rewriter);
            return success();
        }

        if (auto constTupleType = dyn_cast<mlir_ts::ConstTupleType>(type))
        {
            getOrCreateGlobalTuple(constantOp, constTupleType, rewriter);
            return success();
        }

        if (auto tupleType = dyn_cast<mlir_ts::TupleType>(type))
        {
            getOrCreateGlobalTuple(constantOp, tupleType, rewriter);
            return success();
        }

        if (auto enumType = dyn_cast<mlir_ts::EnumType>(type))
        {
            rewriter.eraseOp(constantOp);
            return success();
        }

        if (auto valAttr = dyn_cast<mlir::FlatSymbolRefAttr>(constantOp.getValue()))
        {
            rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(constantOp, tch.convertType(type), valAttr);
            return success();
        }

        rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(constantOp, tch.convertType(type), constantOp.getValue());
        return success();
    }
};

struct SymbolRefOpLowering : public TsLlvmPattern<mlir_ts::SymbolRefOp>
{
    using TsLlvmPattern<mlir_ts::SymbolRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SymbolRefOp symbolRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(symbolRefOp, tch.convertType(symbolRefOp.getType()),
                                                      symbolRefOp.getIdentifierAttr());
        return success();
    }
};

struct NullOpLowering : public TsLlvmPattern<mlir_ts::NullOp>
{
    using TsLlvmPattern<mlir_ts::NullOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::NullOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        rewriter.replaceOpWithNewOp<LLVM::ZeroOp>(op, tch.convertType(op.getType()));
        return success();
    }
};

class UndefOpLowering : public TsLlvmPattern<mlir_ts::UndefOp>
{
  public:
    using TsLlvmPattern<mlir_ts::UndefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::UndefOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        if (isa<mlir_ts::OptionalType>(op.getType()))
        {
            rewriter.replaceOpWithNewOp<mlir_ts::OptionalUndefOp>(op, op.getType());
            return success();
        }

        TypeConverterHelper tch(getTypeConverter());

        // `undefined` materialised as a value of a type that cannot hold it is zero, not undef.
        // It is read: an iterator's final `{ value: undefined, done: true }` is built exactly
        // this way, and an undef `value` printed whatever the register held (a Set<si32>'s
        // `values().drop(4).next()` gave `{ value: -971415704, done: true }`). Under reference
        // counting it matters twice over - whoever receives an owning value retains it, and
        // reaching an undef pointer's block header is undefined behaviour.
        rewriter.replaceOpWithNewOp<LLVM::ZeroOp>(op, tch.convertType(op.getType()));
        return success();
    }
};

struct ReturnInternalOpLowering : public TsLlvmPattern<mlir_ts::ReturnInternalOp>
{
    using TsLlvmPattern<mlir_ts::ReturnInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ReturnInternalOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, ValueRange{transformed.getRetOperands()});
        return success();
    }
};

// `llvm.signext` for s8/s16, `llvm.zeroext` for u8/u16 and boolean; empty for anything else,
// including signless i8/i16, whose extension no type says.
static StringRef getIntegerExtensionAttrName(mlir::Type type)
{
    if (isa<mlir_ts::BooleanType>(type))
    {
        return LLVM::LLVMDialect::getZExtAttrName();
    }

    if (auto intType = dyn_cast<mlir::IntegerType>(type); intType && intType.getWidth() < 32)
    {
        if (intType.isSigned())
        {
            return LLVM::LLVMDialect::getSExtAttrName();
        }

        if (intType.isUnsigned())
        {
            return LLVM::LLVMDialect::getZExtAttrName();
        }
    }

    return {};
}

struct FuncOpLowering : public TsLlvmPattern<mlir_ts::FuncOp>
{
    using TsLlvmPattern<mlir_ts::FuncOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::FuncOp funcOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto location = funcOp.getLoc();

        auto typeConverter = getTypeConverter();
        auto fnType = funcOp.getFunctionType();

        TypeConverter::SignatureConversion signatureInputsConverter(fnType.getNumInputs());
        for (auto argType : enumerate(funcOp.getFunctionType().getInputs()))
        {
            auto convertedType = typeConverter->convertType(argType.value());
            signatureInputsConverter.addInputs(argType.index(), convertedType);
        }

        TypeConverter::SignatureConversion signatureResultsConverter(fnType.getNumResults());
        for (auto argType : enumerate(funcOp.getFunctionType().getResults()))
        {
            auto convertedType = typeConverter->convertType(argType.value());
            signatureResultsConverter.addInputs(argType.index(), convertedType);
        }

        SmallVector<DictionaryAttr> argDictAttrs;
        if (ArrayAttr argAttrs = funcOp.getAllArgAttrs())
        {
            auto argAttrRange = argAttrs.template getAsRange<DictionaryAttr>();
            argDictAttrs.append(argAttrRange.begin(), argAttrRange.end());
        }

        auto convertedFuncType = rewriter.getFunctionType(signatureInputsConverter.getConvertedTypes(), signatureResultsConverter.getConvertedTypes());
        auto newFuncOp = rewriter.create<mlir::func::FuncOp>(location, funcOp.getName(), convertedFuncType, ArrayRef<NamedAttribute>{}, argDictAttrs);

        // C expects an 8- or 16-bit integer or a bool extended to 32 bits by whoever hands it
        // over: the caller for an argument, the callee for a result, and clang-compiled code
        // relies on it (x86-64 SysV). A declaration - implemented elsewhere, usually in C - says
        // so. A definition does not: a `signext` parameter makes the callee trust its caller, and
        // tslang's indirect calls carry no call-site attributes.
        if (funcOp.getBody().empty())
        {
            for (auto [index, type] : llvm::enumerate(fnType.getInputs()))
            {
                if (auto extension = getIntegerExtensionAttrName(type); !extension.empty())
                {
                    newFuncOp.setArgAttr(index, extension, rewriter.getUnitAttr());
                }
            }

            for (auto [index, type] : llvm::enumerate(fnType.getResults()))
            {
                if (auto extension = getIntegerExtensionAttrName(type); !extension.empty())
                {
                    newFuncOp.setResultAttr(index, extension, rewriter.getUnitAttr());
                }
            }
        }

        for (const auto &namedAttr : funcOp->getAttrs())
        {
            if (namedAttr.getName() == funcOp.getFunctionTypeAttrName())
            {
                continue;
            }

            if (namedAttr.getName() == SymbolTable::getSymbolAttrName())
            {
                //name = dyn_cast<mlir::StringAttr>(namedAttr.getValue()).getValue().str();
                continue;
            }

            newFuncOp->setAttr(namedAttr.getName(), namedAttr.getValue());
        }

        SmallVector<mlir::Attribute> funcAttrs;

        // mustprogress licenses standard -O2/-O3 loop transforms (LICM, unrolling,
        // vectorization of provably-finite loops) that otherwise stay conservative
        // without proof the loop can't spin forever with no observable effect. Every
        // ts loop with a call/store in its body already satisfies the (weaker)
        // mustprogress contract; a body-less `while(true){}` is the only case this
        // attribute changes the meaning of, same as in C/C++/Rust.
        funcAttrs.push_back(ATTR("mustprogress"));

        if (funcOp.getPersonality().has_value() && funcOp.getPersonality().value())
        {
            LLVMRTTIHelperVC rttih(funcOp, rewriter, typeConverter, tsLlvmContext->compileOptions);
            rttih.setPersonality(newFuncOp);

            funcAttrs.push_back(ATTR("noinline"));
        }

        // copy attributes over
        auto skipAttrs = mlir::func::FuncOp::getAttributeNames();
        for (auto attr : funcOp->getAttrs())
        {
            auto name = attr.getName();
            if (name == "specialization") {
                auto inlineLinkage = LLVM::linkage::Linkage::LinkonceODR;
                auto linkage = LLVM::LinkageAttr::get(getContext(), inlineLinkage);
                newFuncOp->setAttr("llvm.linkage", linkage);
                // TODO: dso_local somehow linked with -fno-pic
                //newFuncOp->setAttr("dso_local", rewriter.getUnitAttr());
                newFuncOp.setPrivate();

                addComdat(newFuncOp, rewriter);
                continue;
            }

            // module-local: a private symbol alone still comes out external
            if (name == "internal_linkage") {
                newFuncOp->setAttr("llvm.linkage", LLVM::LinkageAttr::get(getContext(), LLVM::linkage::Linkage::Internal));
                continue;
            }

            auto addAttr =
                std::find(skipAttrs.begin(), skipAttrs.end(), name) == skipAttrs.end();
            if (addAttr && name == DLL_NAME)
                funcAttrs.push_back(ArrayAttr::get(rewriter.getContext(), {name, attr.getValue()}));
            else if (addAttr)
                funcAttrs.push_back(name);
        }

#ifdef DISABLE_OPT
        // add LLVM attributes to fix issue with shift >> 32
        funcAttrs.append({
            ATTR("noinline"),
            // ATTR("norecurse"),
            // ATTR("nounwind"),
            ATTR("optnone"),
            // ATTR("uwtable"),
            // NAMED_ATTR("correctly-rounded-divide-sqrt-fp-math","false"),
            // NAMED_ATTR("disable-tail-calls","false"),
            // NAMED_ATTR("frame-pointer","none"),
            // NAMED_ATTR("less-precise-fpmad","false"),
            // NAMED_ATTR("min-legal-vector-width","0"),
            // NAMED_ATTR("no-infs-fp-math","false"),
            // NAMED_ATTR("no-jump-tables","false"),
            // NAMED_ATTR("no-nans-fp-math","false"),
            // NAMED_ATTR("no-signed-zeros-fp-math","false"),
            // NAMED_ATTR("no-trapping-math","true"),
            // NAMED_ATTR("stack-protector-buffer-size","8"),
            // NAMED_ATTR("target-cpu","x86-64"),
            // NAMED_ATTR("target-features","+cx8,+fxsr,+mmx,+sse,+sse2,+x87"),
            // NAMED_ATTR("tune-cpu","generic"),
            // NAMED_ATTR("unsafe-fp-math","false"),
            // NAMED_ATTR("use-soft-float","false"),
        }));
#endif

        if (funcAttrs.size() > 0)
        {
            newFuncOp->setAttr("passthrough", ArrayAttr::get(rewriter.getContext(), funcAttrs));
        }

        rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(), newFuncOp.end());
        if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), *typeConverter, &signatureInputsConverter)))
        {
            return failure();
        }

        rewriter.eraseOp(funcOp);

        return success();
    }

    static void addComdat(mlir::func::FuncOp &func,
                        mlir::ConversionPatternRewriter &rewriter) {
        auto module = func->getParentOfType<mlir::ModuleOp>();

        const char *comdatName = "__llvm_comdat";
        mlir::LLVM::ComdatOp comdatOp = module.lookupSymbol<mlir::LLVM::ComdatOp>(comdatName);
        if (!comdatOp) 
        {
            comdatOp = rewriter.create<mlir::LLVM::ComdatOp>(module.getLoc(), comdatName);
        }

        mlir::OpBuilder::InsertionGuard guard(rewriter);
        rewriter.setInsertionPointToEnd(&comdatOp.getBody().back());
        auto selectorOp = rewriter.create<mlir::LLVM::ComdatSelectorOp>(
            comdatOp.getLoc(), func.getSymName(),
            mlir::LLVM::comdat::Comdat::Any);
        func->setAttr("comdat", mlir::SymbolRefAttr::get(
            rewriter.getContext(), comdatName,
            mlir::FlatSymbolRefAttr::get(selectorOp.getSymNameAttr())));
    }
};

struct SymbolCallInternalOpLowering : public TsLlvmPattern<mlir_ts::SymbolCallInternalOp>
{
    using TsLlvmPattern<mlir_ts::SymbolCallInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SymbolCallInternalOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto moduleOp = op->getParentOfType<mlir::ModuleOp>();

        auto funcOp = moduleOp.lookupSymbol(op.getCallee());

        LLVM::LLVMFunctionType llvmFuncType;
        if (auto llvmFuncOp = dyn_cast_or_null<LLVM::LLVMFuncOp>(funcOp))
        {
            llvmFuncType = llvmFuncOp.getFunctionType();
        }
        else if (auto mlirFuncOp = dyn_cast_or_null<func::FuncOp>(funcOp))
        {
            auto funcType = mlirFuncOp.getFunctionType();
            llvmFuncType = tch.convertFunctionSignature(op.getContext(), funcType.getResults(), funcType.getInputs(), false);
        }
        else if (auto tsFuncOp = dyn_cast_or_null<mlir_ts::FuncOp>(funcOp))
        {
            auto tsFuncType = tsFuncOp.getFunctionType();
            llvmFuncType = tch.convertFunctionSignature(op.getContext(), tsFuncType.getResults(), tsFuncType.getInputs(), tsFuncType.isVarArg());
        }

        if (!llvmFuncType)
        {
            return rewriter.notifyMatchFailure(op, "unable to resolve callee symbol to a function type");
        }

        auto callRes = rewriter.create<LLVM::CallOp>(
            loc, llvmFuncType, ::mlir::FlatSymbolRefAttr::get(rewriter.getContext(), op.getCallee()), transformed.getCallOperands());
        
        auto returns = callRes.getResults();
        if (returns.size() > 0)
        {
            rewriter.replaceOp(op, returns);
        }
        else
        {
            rewriter.eraseOp(op);
        }        

        return success();
    }
};

struct CallInternalOpLowering : public TsLlvmPattern<mlir_ts::CallInternalOp>
{
    using TsLlvmPattern<mlir_ts::CallInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CallInternalOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
      

        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());
        SmallVector<mlir::Type> llvmTypes;
        for (auto type : op.getResultTypes())
        {
            if (isa<mlir_ts::VoidType>(type))
            {
                continue;
            }

            llvmTypes.push_back(tch.convertType(type));
        }

        // special case for HybridFunctionType
        LLVM_DEBUG(llvm::dbgs() << "\n!! CallInternalOp - arg #0:" << op.getOperand(0) << "\n");
        if (auto hybridFuncType = dyn_cast<mlir_ts::HybridFunctionType>(op.getOperand(0).getType()))
        {
            rewriter.replaceOpWithNewOp<mlir_ts::CallHybridInternalOp>(
                op, hybridFuncType.getResults(), op.getOperand(0),
                OperandRange(op.getOperands().begin() + 1, op.getOperands().end()));
            return success();
        }

        auto callRes = rewriter.create<LLVM::CallOp>(loc, llvmTypes, transformed.getOperands());
        // indirect call: callee pointer is operand #0, the rest are call arguments;
        // AttrSizedOperandSegments requires this split to be set explicitly, the
        // generic (TypeRange, ValueRange) builder above does not set it.
        callRes.getProperties().setOperandSegmentSizes({static_cast<int32_t>(transformed.getOperands().size()), 0});
        callRes.setOpBundleSizes({});

        auto returns = callRes.getResults();
        if (returns.size() > 0)
        {
            rewriter.replaceOp(op, returns);
        }
        else
        {
            rewriter.eraseOp(op);
        }

        return success();
    }
};

struct CallHybridInternalOpLowering : public TsLlvmPattern<mlir_ts::CallHybridInternalOp>
{
    using TsLlvmPattern<mlir_ts::CallHybridInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CallHybridInternalOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto hybridFuncType = cast<mlir_ts::HybridFunctionType>(op.getCallee().getType());

        SmallVector<mlir::Type> llvmTypes;
        for (auto type : op.getResultTypes())
        {
            if (isa<mlir_ts::VoidType>(type))
            {
                continue;
            }

            llvmTypes.push_back(tch.convertType(type));
        }

        mlir::ValueRange returns;
        mlir::OpBuilder::InsertionGuard insertGuard(rewriter);
        {
            CodeLogicHelper clh(loc, rewriter);

            // test 'this'
            auto thisType = mlir_ts::OpaqueType::get(rewriter.getContext());
            auto thisVal = rewriter.create<mlir_ts::GetThisOp>(loc, thisType, op.getOperand(0));
            auto thisAsBoolVal =
                rewriter.create<mlir_ts::CastOp>(loc, mlir_ts::BooleanType::get(rewriter.getContext()), thisVal);

            SmallVector<mlir::Type, 4> results;
            for (auto &resultType : hybridFuncType.getResults())
            {
                if (isa<mlir_ts::VoidType>(resultType))
                {
                    continue;
                }

                results.push_back(tch.convertType(resultType));
            }

            // no value yet.
            returns = clh.conditionalBlocksLowering(
                results, thisAsBoolVal,
                [&](OpBuilder &builder, Location loc) {
                    mlir::SmallVector<mlir::Type> inputs;
                    inputs.push_back(thisType);
                    inputs.append(hybridFuncType.getInputs().begin(), hybridFuncType.getInputs().end());

                    // with this
                    auto funcType =
                        mlir_ts::FunctionType::get(rewriter.getContext(), inputs, hybridFuncType.getResults());
                    auto methodPtr = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, op.getOperand(0));

                    auto methodPtrAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(funcType), methodPtr);
                    auto thisValAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(thisType), thisVal);

                    mlir::SmallVector<mlir::Value> ops;
                    ops.push_back(methodPtrAsLLVMType);
                    ops.push_back(thisValAsLLVMType);
                    ops.append(transformed.getOperands().begin() + 1, transformed.getOperands().end());
                    auto callRes = rewriter.create<LLVM::CallOp>(loc, llvmTypes, ops);
                    callRes.getProperties().setOperandSegmentSizes({static_cast<int32_t>(ops.size()), 0});
                    callRes.setOpBundleSizes({});
                    return callRes.getResults();
                },
                [&](OpBuilder &builder, Location loc) {
                    // no this
                    auto funcType = mlir_ts::FunctionType::get(rewriter.getContext(), hybridFuncType.getInputs(),
                                                               hybridFuncType.getResults());
                    auto methodPtr = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, op.getOperand(0));

                    auto methodPtrAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(funcType), methodPtr);

                    mlir::SmallVector<mlir::Value> ops;
                    ops.push_back(methodPtrAsLLVMType);
                    ops.append(transformed.getOperands().begin() + 1, transformed.getOperands().end());
                    auto callRes = rewriter.create<LLVM::CallOp>(loc, llvmTypes, ops);
                    callRes.getProperties().setOperandSegmentSizes({static_cast<int32_t>(ops.size()), 0});
                    callRes.setOpBundleSizes({});
                    return callRes.getResults();
                });
        }

        if (returns.size() > 0)
        {
            rewriter.replaceOp(op, returns);
        }
        else
        {
            rewriter.eraseOp(op);
        }

        return success();
    }
};

struct InvokeOpLowering : public TsLlvmPattern<mlir_ts::InvokeOp>
{
    using TsLlvmPattern<mlir_ts::InvokeOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::InvokeOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {

        if (!op.getCallee().has_value())
        {
            // special case for HybridFunctionType
            LLVM_DEBUG(llvm::dbgs() << "\n!! InvokeOp - arg #0:" << op.getOperand(0) << "\n");
            if (auto hybridFuncType = dyn_cast<mlir_ts::HybridFunctionType>(op.getOperand(0).getType()))
            {
                rewriter.replaceOpWithNewOp<mlir_ts::InvokeHybridOp>(
                    op, hybridFuncType.getResults(), op.getOperand(0),
                    OperandRange(op.getOperands().begin() + 1, op.getOperands().end()), op.getNormalDestOperands(),
                    op.getUnwindDestOperands(), op.getNormalDest(), op.getUnwindDest());
                return success();
            }
        }

        TypeConverterHelper tch(getTypeConverter());
        SmallVector<mlir::Type> llvmTypes;
        for (auto type : op.getResultTypes())
        {
            llvmTypes.push_back(tch.convertType(type));
        }

        // just replace
        if (op.getCalleeAttr())
        {
            rewriter.replaceOpWithNewOp<LLVM::InvokeOp>(op, llvmTypes, op.getCalleeAttr(), transformed.getCallOperands(),
                op.getNormalDest(), transformed.getNormalDestOperands(), op.getUnwindDest(),
                transformed.getUnwindDestOperands());
        }
        else
        {
            rewriter.replaceOpWithNewOp<LLVM::InvokeOp>(op, llvmTypes, mlir::FlatSymbolRefAttr(), transformed.getOperands(),
                op.getNormalDest(), transformed.getNormalDestOperands(), op.getUnwindDest(),
                transformed.getUnwindDestOperands());
        }
        
        return success();
    }
};

struct InvokeHybridOpLowering : public TsLlvmPattern<mlir_ts::InvokeHybridOp>
{
    using TsLlvmPattern<mlir_ts::InvokeHybridOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::InvokeHybridOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {

        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto hybridFuncType = cast<mlir_ts::HybridFunctionType>(op.getCallee().getType());

        SmallVector<mlir::Type> llvmTypes;
        for (auto type : op.getResultTypes())
        {
            llvmTypes.push_back(tch.convertType(type));
        }

        mlir::ValueRange returns;
        mlir::OpBuilder::InsertionGuard insertGuard(rewriter);
        {
            CodeLogicHelper clh(loc, rewriter);

            // test 'this'
            auto thisType = mlir_ts::OpaqueType::get(rewriter.getContext());
            auto thisVal = rewriter.create<mlir_ts::GetThisOp>(loc, thisType, op.getOperand(0));
            auto thisAsBoolVal =
                rewriter.create<mlir_ts::CastOp>(loc, mlir_ts::BooleanType::get(rewriter.getContext()), thisVal);

            SmallVector<mlir::Type, 4> results;
            for (auto &resultType : hybridFuncType.getResults())
            {
                if (isa<mlir_ts::VoidType>(resultType))
                {
                    continue;
                }

                results.push_back(tch.convertType(resultType));
            }

            // no value yet.
            returns = clh.conditionalBlocksLowering(
                results, thisAsBoolVal,
                [&](OpBuilder &builder, Location loc) {
                    mlir::SmallVector<mlir::Type> inputs;
                    inputs.push_back(thisType);
                    inputs.append(hybridFuncType.getInputs().begin(), hybridFuncType.getInputs().end());

                    // with this
                    auto funcType =
                        mlir_ts::FunctionType::get(rewriter.getContext(), inputs, hybridFuncType.getResults());
                    auto methodPtr = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, op.getOperand(0));

                    mlir::Value methodPtrAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(methodPtr.getType()), methodPtr);
                    mlir::Value thisValAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(thisVal.getType()), thisVal);

                    mlir::SmallVector<mlir::Value> ops;
                    ops.push_back(methodPtrAsLLVMType);
                    ops.push_back(thisValAsLLVMType);
                    ops.append(transformed.getOperands().begin() + 1, transformed.getOperands().end());

                    auto *continuationBlock = clh.CutBlockAndSetInsertPointToEndOfBlock();

                    auto callRes = rewriter.create<LLVM::InvokeOp>(loc, TypeRange(llvmTypes), mlir::FlatSymbolRefAttr(), ops, continuationBlock,
                                                                   transformed.getNormalDestOperands(), 
                                                                   op.getUnwindDest(), transformed.getUnwindDestOperands());

                    rewriter.setInsertionPointToStart(continuationBlock);

                    return callRes.getResults();
                },
                [&](OpBuilder &builder, Location loc) {
                    // no this
                    auto funcType = mlir_ts::FunctionType::get(rewriter.getContext(), hybridFuncType.getInputs(),
                                                               hybridFuncType.getResults());
                    auto methodPtr = rewriter.create<mlir_ts::GetMethodOp>(loc, funcType, op.getOperand(0));

                    mlir::Value methodPtrAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(methodPtr.getType()), methodPtr);

                    mlir::SmallVector<mlir::Value> ops;
                    ops.push_back(methodPtrAsLLVMType);
                    ops.append(transformed.getOperands().begin() + 1, transformed.getOperands().end());

                    auto *continuationBlock = clh.CutBlockAndSetInsertPointToEndOfBlock();

                    auto callRes = rewriter.create<LLVM::InvokeOp>(loc, TypeRange(llvmTypes), mlir::FlatSymbolRefAttr(), ops, continuationBlock,
                                                                   transformed.getNormalDestOperands(), op.getUnwindDest(),
                                                                   transformed.getUnwindDestOperands());

                    rewriter.setInsertionPointToStart(continuationBlock);

                    return callRes.getResults();
                });

            rewriter.create<LLVM::BrOp>(loc, ValueRange{}, op.getNormalDest());
        }

        if (returns.size() > 0)
        {
            rewriter.replaceOp(op, returns);
        }
        else
        {
            rewriter.eraseOp(op);
        }

        return success();
    }
};

struct DialectCastOpLowering : public TsLlvmPattern<mlir_ts::DialectCastOp>
{
    using TsLlvmPattern<mlir_ts::DialectCastOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DialectCastOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        

        TypeConverterHelper tch(getTypeConverter());

        auto in = transformed.getIn();
        auto resType = op.getRes().getType();

        CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);
        auto [result, converted] = castLogic.dialectCast(in, in.getType(), resType);
        if (!converted)
        {
            rewriter.replaceOp(op, in);
            return success();
        }

        if (!result)
        {
            return failure();
        }

        rewriter.replaceOp(op, result);
        return success();
    }
};

struct CastOpLowering : public TsLlvmPattern<mlir_ts::CastOp>
{
    using TsLlvmPattern<mlir_ts::CastOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CastOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto in = transformed.getIn();
        auto resType = op.getRes().getType();

        CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);
        // in case of Union we need mlir_ts::UnionType value
        auto result = castLogic.cast(isa<mlir_ts::UnionType>(op.getIn().getType()) ? op.getIn() : in, op.getIn().getType(), resType);
        if (!result)
        {
            return failure();
        }

        rewriter.replaceOp(op, result);

        return success();
    }
};

struct BoxOpLowering : public TsLlvmPattern<mlir_ts::BoxOp>
{
    using TsLlvmPattern<mlir_ts::BoxOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BoxOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto in = transformed.getIn();

        AnyLogic al(op, rewriter, tch, loc, tsLlvmContext->compileOptions);
        auto result = al.castToAny(in, transformed.getTypeInfo(), in.getType());

        rewriter.replaceOp(op, result);

        return success();
    }
};

struct UnboxOpLowering : public TsLlvmPattern<mlir_ts::UnboxOp>
{
    using TsLlvmPattern<mlir_ts::UnboxOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::UnboxOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = op->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto in = transformed.getIn();
        auto resType = op.getRes().getType();

        AnyLogic al(op, rewriter, tch, loc, tsLlvmContext->compileOptions);
        auto result = al.UnboxAny(in, tch.convertType(resType));

        rewriter.replaceOp(op, result);

        return success();
    }
};

struct CreateUnionInstanceOpLowering : public TsLlvmPattern<mlir_ts::CreateUnionInstanceOp>
{
    using TsLlvmPattern<mlir_ts::CreateUnionInstanceOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CreateUnionInstanceOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = op->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(op, rewriter);
        MLIRTypeHelper mth(rewriter.getContext(), tsLlvmContext->compileOptions);

        CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);

        auto in = transformed.getIn();

        auto i8PtrTy = th.getPtrType();
        auto valueType = in.getType();
        auto resType = tch.convertType(op.getRes().getType());

        mlir::SmallVector<mlir::Type> types;
        types.push_back(i8PtrTy);
        types.push_back(valueType);
        auto unionPartialType = LLVM::LLVMStructType::getLiteral(rewriter.getContext(), types, UNION_TYPE_PACKED);
        if (!mth.isUnionTypeNeedsTag(loc, cast<mlir_ts::UnionType>(op.getType())))
        {
            // this is union of tuples, no need to add Tag to it
            // create tagged union
            auto casted = castLogic.castLLVMTypes(in, in.getType(), op.getType(), resType);
            if (!casted)
            {
                return mlir::failure();
            }

            rewriter.replaceOp(op, ValueRange{casted});
        }
        else
        {
            // create tagged union
            auto udefVal = rewriter.create<LLVM::UndefOp>(loc, unionPartialType);
            auto val0 =
                rewriter.create<LLVM::InsertValueOp>(loc, udefVal, transformed.getTypeInfo(), MLIRHelper::getStructIndex(rewriter, UNION_TAG_INDEX));
            auto val1 = rewriter.create<LLVM::InsertValueOp>(loc, val0, in, MLIRHelper::getStructIndex(rewriter, UNION_VALUE_INDEX));

            auto casted = castLogic.castLLVMTypes(val1, unionPartialType, op.getType(), resType, /*sizesMayDiffer=*/true);
            if (!casted)
            {
                return mlir::failure();
            }

            rewriter.replaceOp(op, ValueRange{casted});
        }

        return success();
    }
};

struct GetValueFromUnionOpLowering : public TsLlvmPattern<mlir_ts::GetValueFromUnionOp>
{
    using TsLlvmPattern<mlir_ts::GetValueFromUnionOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GetValueFromUnionOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = op->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(op, rewriter);
        MLIRTypeHelper mth(rewriter.getContext(), tsLlvmContext->compileOptions);

        bool needTag = mth.isUnionTypeNeedsTag(loc, cast<mlir_ts::UnionType>(op.getIn().getType()));
        if (needTag)
        {
            auto in = transformed.getIn();

            auto i8PtrTy = th.getPtrType();
            auto valueType = tch.convertType(op.getType());

            mlir::SmallVector<mlir::Type> types;
            types.push_back(i8PtrTy);
            types.push_back(valueType);
            auto unionPartialType = LLVM::LLVMStructType::getLiteral(rewriter.getContext(), types, UNION_TYPE_PACKED);

            // TODO: should not cast anything
            CastLogicHelper castLogic(op, rewriter, tch, tsLlvmContext->compileOptions);
            auto casted = castLogic.castLLVMTypes(transformed.getIn(), transformed.getIn().getType(), unionPartialType,
                                                  unionPartialType, /*sizesMayDiffer=*/true);
            if (!casted)
            {
                return mlir::failure();
            }

            auto val1 = rewriter.create<LLVM::ExtractValueOp>(loc, valueType, casted, MLIRHelper::getStructIndex(rewriter, UNION_VALUE_INDEX));

            rewriter.replaceOp(op, ValueRange{val1});
        }
        else
        {
            rewriter.replaceOp(op, ValueRange{transformed.getIn()});
        }

        return success();
    }
};

struct GetTypeInfoFromUnionOpLowering : public TsLlvmPattern<mlir_ts::GetTypeInfoFromUnionOp>
{
    using TsLlvmPattern<mlir_ts::GetTypeInfoFromUnionOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GetTypeInfoFromUnionOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(op, rewriter);
        MLIRTypeHelper mth(rewriter.getContext(), tsLlvmContext->compileOptions);

        auto loc = op->getLoc();

        mlir::Type baseType;
        bool needTag = mth.isUnionTypeNeedsTag(loc, cast<mlir_ts::UnionType>(op.getIn().getType()), baseType);
        if (needTag)
        {
            auto val0 = rewriter.create<LLVM::ExtractValueOp>(loc, tch.convertType(op.getType()), transformed.getIn(),
                                                              MLIRHelper::getStructIndex(rewriter, UNION_TAG_INDEX));

            rewriter.replaceOp(op, ValueRange{val0});
        }
        else
        {
            auto typeOfValue = rewriter.create<mlir_ts::TypeOfOp>(loc, mlir_ts::StringType::get(rewriter.getContext()), transformed.getIn());

            rewriter.replaceOp(op, ValueRange{typeOfValue});
        }

        return success();
    }
};

struct VariableOpLowering : public TsLlvmPattern<mlir_ts::VariableOp>
{
    using TsLlvmPattern<mlir_ts::VariableOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::VariableOp varOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(varOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(varOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto location = varOp.getLoc();

        auto referenceType = varOp.getType();
        auto storageType = tch.convertType(referenceType.getElementType());

#ifdef ALLOC_ALL_VARS_IN_HEAP
        auto isCaptured = true;
#elif ALLOC_CAPTURED_VARS_IN_HEAP
        auto isCaptured = varOp.getCaptured().has_value() && varOp.getCaptured().value();
#else
        auto isCaptured = false;
#endif

        LLVM_DEBUG(llvm::dbgs() << "\n!! variable op: " << varOp
                                << "\n";);

        LLVM_DEBUG(llvm::dbgs() << "\n!! variable allocation: " << storageType << " is captured: " << isCaptured
                                << "\n";);

        mlir::Value allocated;
        if (!isCaptured)
        {
            auto count = 1;
            if (varOp->hasAttrOfType<mlir::IntegerAttr>(INSTANCES_COUNT_ATTR_NAME))
            {
                auto intAttr = varOp->getAttrOfType<mlir::IntegerAttr>(INSTANCES_COUNT_ATTR_NAME);
                count = intAttr.getValue().getZExtValue();
            }

            allocated = ch.Alloca(storageType, count);
        }
        else
        {

            allocated = ch.MemoryAlloc(storageType);

            // A captured variable's storage is a heap block - a cell - shared by the frame that
            // declared it and by every capture box that captured it. Unlike a value block, which
            // is born unowned because a receiver is about to take it (§9.24), a cell is born
            // owned: the frame is its first owner, and the frame's scope exit is what gives that
            // reference back. A box is the one heap variable with no frame owner, and says so.
            // Under own the frame owns the cell outright; there is no count to start at one.
            if (tsLlvmContext->compileOptions.isRefCounted() && !varOp->hasAttr(CAPTURE_BOX_ATTR_NAME))
            {
                OwnershipRoutineLogic orl(varOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
                orl.emitRetainCell(allocated);
            }
        }

#ifdef GC_ENABLE
        // register root which is in stack, if you call Malloc - it is not in stack anymore
        if (!isCaptured)
        {
            auto  tsStorageType = referenceType.getElementType();
            if (isa<mlir_ts::ClassType>(tsStorageType) ||
                isa<mlir_ts::SharedType>(tsStorageType) ||
                isa<mlir_ts::StringType>(tsStorageType) ||
                isa<mlir_ts::ArrayType>(tsStorageType) ||
                isa<mlir_ts::ObjectType>(tsStorageType) ||
                isa<mlir_ts::AnyType>(tsStorageType))
            {
                TypeHelper th(rewriter);

                auto gcRootOp = ch.getOrInsertFunction(
                    "llvm.gcroot", th.getFunctionType(th.getVoidType(), {th.getPtrType(), th.getPtrType()}));
                auto nullPtr = rewriter.create<LLVM::ZeroOp>(location, th.getPtrType());
                rewriter.create<LLVM::CallOp>(location, gcRootOp, ValueRange{allocated, nullPtr});
            }
        }
#endif

        LLVM::DILocalVariableAttr varInfo;
        if (tsLlvmContext->compileOptions.generateDebugInfo)
        {
            if (auto localVarAttrFusedLoc = dyn_cast<mlir::FusedLocWith<LLVM::DILocalVariableAttr>>(location))
            {
                varInfo = localVarAttrFusedLoc.getMetadata();
                rewriter.create<LLVM::DbgDeclareOp>(location, allocated, varInfo);

                // TODO: do I need it? does it have an effect?
                allocated.getDefiningOp()->setLoc(mlir::FusedLoc::get(rewriter.getContext(), {allocated.getDefiningOp()->getLoc()}, varInfo));
            }            
        }

        auto value = transformed.getInitializer();
        auto isUnwrittenCell = isCaptured && !varOp->hasAttr(CAPTURE_BOX_ATTR_NAME);
        if (!value && tsLlvmContext->compileOptions.tracksOwnership() &&
            (varOp->hasAttr(OWNED_LOCAL_ATTR_NAME) || isUnwrittenCell))
        {
            // An owned local with no initializer here is one whose storage was hoisted out in
            // front of a TryOp; its initializing store stayed behind at the declaration. The
            // unwind edge can reach the cleanup region before that store runs, and the release
            // waiting there reads whatever the frame happened to hold. Null is the one value
            // the release routines treat as nothing to do, so the slot starts as null.
            //
            // A cell needs it for the plainer reason that it is a *heap* block, so what it holds
            // before its first store is whatever the allocator last had there. `let x: string;`
            // captured by a closure that only assigns on a path never taken is the case: the
            // scope exit releases the cell, the cell releases its contents, and the contents were
            // never written. Not a corner - it is any captured declaration without an
            // initializer, which an owned local can never be (§9.36).
            //
            // Only under -mm=rc: nothing reads the slot before its store in any other model, and
            // a collected build is meant to come out of this step byte-identical.
            rewriter.create<LLVM::StoreOp>(location, rewriter.create<LLVM::ZeroOp>(location, storageType), allocated);
        }

        if (value)
        {
            rewriter.create<LLVM::StoreOp>(location, value, allocated);

#ifdef DBG_INFO_ADD_VALUE_OP            
            if (tsLlvmContext->compileOptions.generateDebugInfo && varInfo)
            {                
                rewriter.create<LLVM::DbgValueOp>(location, value, varInfo);
            }
#endif            

            // A cell owns the value in it: giving up the last reference to the cell releases
            // what it holds (`emitReleaseCell`), and every store into one hands the count over
            // (`isOwningSlot`). So the first value has to be taken too, unless the frame has
            // already taken it - which is what an owned local's mark says, and what a captured
            // parameter's storage is precisely missing, the argument being the caller's.
            //
            // Not under own, which has no count to take: such a cell borrows the value, and its
            // release frees the cell alone (OWN_CELL_BORROWS_ATTR_NAME, which ownership inference
            // sets, or rejects the program).
            // A handle is counted under own too (spec 23.2).
            auto counted = MLIRTypeHelper::isSharedHandleType(referenceType.getElementType());
            if (isCaptured &&
                (tsLlvmContext->compileOptions.isRefCounted() || (tsLlvmContext->compileOptions.tracksOwnership() && counted)) &&
                !varOp->hasAttr(CAPTURE_BOX_ATTR_NAME) && !varOp->hasAttr(OWNED_LOCAL_ATTR_NAME))
            {
                OwnershipRoutineLogic orl(varOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
                orl.emitRetainSlot(referenceType.getElementType(), allocated);
            }
        }

        rewriter.replaceOp(varOp, ValueRange{allocated});
        return success();
    }
};

struct DebugVariableOpLowering : public TsLlvmPattern<mlir_ts::DebugVariableOp>
{
    using TsLlvmPattern<mlir_ts::DebugVariableOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DebugVariableOp debugVarOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(debugVarOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(debugVarOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto location = debugVarOp.getLoc();

        LLVM_DEBUG(llvm::dbgs() << "\n!! debug variable: " << debugVarOp << "\n";);

        //DIScopeAttr scope, StringAttr name, DIFileAttr file, unsigned line, unsigned arg, unsigned alignInBits, DITypeAttr type
        LocationHelper lh(rewriter.getContext());
        if (auto localVarAttrFusedLoc = dyn_cast<mlir::FusedLocWith<LLVM::DILocalVariableAttr>>(location))
        {
            auto value = transformed.getInitializer();

            auto varInfo = localVarAttrFusedLoc.getMetadata();

            auto allocated = ch.Alloca(value.getType(), 1);

            rewriter.create<LLVM::DbgDeclareOp>(location, allocated, varInfo);

            rewriter.create<LLVM::StoreOp>(location, value, allocated);     
#ifdef DBG_INFO_ADD_VALUE_OP                                   
            rewriter.create<LLVM::DbgValueOp>(location, value, varInfo);
#endif
        }

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

struct AllocaOpLowering : public TsLlvmPattern<mlir_ts::AllocaOp>
{
    using TsLlvmPattern<mlir_ts::AllocaOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AllocaOp varOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(varOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(varOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto location = varOp.getLoc();

        auto referenceType = cast<mlir_ts::RefType>(varOp.getReference().getType());
        auto storageType = referenceType.getElementType();
        auto llvmStorageType = tch.convertType(storageType);

        LLVM_DEBUG(llvm::dbgs() << "\n!! alloca: " << storageType << " llvm: " << llvmStorageType << "\n";);

        mlir::Value count;
        if (transformed.getCount())
        {
            count = transformed.getCount();
        }
        else
        {
            count = clh.createI32ConstantOf(1);
        }

        mlir::Value allocated = rewriter.create<LLVM::AllocaOp>(location, th.getPtrType(), llvmStorageType, count);

        // TODO: call MemSet

        rewriter.replaceOp(varOp, ValueRange{allocated});
        return success();
    }
};

struct NewOpLowering : public TsLlvmPattern<mlir_ts::NewOp>
{
    using TsLlvmPattern<mlir_ts::NewOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::NewOp newOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(newOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(newOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = newOp.getLoc();

        mlir::Type storageType = newOp.getInstance().getType();
        if (auto classType = dyn_cast_or_null<mlir_ts::ClassType>(storageType))
        {
            storageType = classType.getStorageType();
        }
        else if (auto valueRef = dyn_cast<mlir_ts::ValueRefType>(storageType))
        {
            storageType = valueRef.getElementType();
        }

        mlir::Value value;
        if (newOp.getStackAlloc().has_value() && newOp.getStackAlloc().value())
        {
            value = ch.Alloca(tch.convertType(storageType), 1);
        }
        else
        {
            value = ch.MemoryAlloc(storageType, MemoryAllocSet::Zero);
        }

        rewriter.replaceOp(newOp, ValueRange{value});
        return success();
    }
};

struct CreateTupleOpLowering : public TsLlvmPattern<mlir_ts::CreateTupleOp>
{
    using TsLlvmPattern<mlir_ts::CreateTupleOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CreateTupleOp createTupleOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(createTupleOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(createTupleOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = createTupleOp.getLoc();
        auto tupleType = cast<mlir_ts::TupleType>(createTupleOp.getType());

        auto tupleVar = rewriter.create<mlir_ts::VariableOp>(
            loc, mlir_ts::RefType::get(tupleType), mlir::Value(), rewriter.getBoolAttr(false), rewriter.getIndexAttr(0));

        // set values here
        auto ptrType = th.getPtrType();
        auto llvmTupleType = tch.convertType(tupleType);
        for (auto [index, itemPair] : enumerate(llvm::zip(transformed.getItems(), createTupleOp.getItems())))
        {
            auto item = std::get<0>(itemPair);
            auto itemOrig = std::get<1>(itemPair);

            auto llvmValueType = tch.convertType(itemOrig.getType());

            mlir::Value tupleVarAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, ptrType, tupleVar);

            LLVM_DEBUG(llvm::dbgs() << "\n!! CreateTuple: type - " << tupleType << " llvm: " << llvmTupleType << "\n";);

            auto offset = rewriter.create<LLVM::GEPOp>(
                loc, ptrType, llvmTupleType, tupleVarAsLLVMType, ArrayRef<LLVM::GEPArg>{0, static_cast<int32_t>(index)});

            LLVM_DEBUG(llvm::dbgs() << "\n!! CreateTuple: op " << offset << "\n";);

            // cast item if needed
            auto destItemType = tupleType.getFields()[index].type;
            auto llvmDestValueType = tch.convertType(destItemType);

            mlir::Value itemValue = item;

            // TODO: Op should ensure that in ops types are equal result types
            if (llvmDestValueType != llvmValueType)
            {
                CastLogicHelper castLogic(createTupleOp, rewriter, tch, tsLlvmContext->compileOptions);
                itemValue =
                    castLogic.cast(itemValue, itemOrig.getType(), llvmValueType, destItemType, llvmDestValueType);
                if (!itemValue)
                {
                    return failure();
                }

                itemValue = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(itemValue.getType()), itemValue);
            }

            rewriter.create<LLVM::StoreOp>(loc, itemValue, offset);
        }

        auto loadedValue = rewriter.create<mlir_ts::LoadOp>(loc, tupleType, tupleVar);

        rewriter.replaceOp(createTupleOp, ValueRange{loadedValue});
        return success();
    }
};

struct DeconstructTupleOpLowering : public TsLlvmPattern<mlir_ts::DeconstructTupleOp>
{
    using TsLlvmPattern<mlir_ts::DeconstructTupleOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DeconstructTupleOp deconstructTupleOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        CodeLogicHelper clh(deconstructTupleOp, rewriter);

        auto loc = deconstructTupleOp.getLoc();
        auto tupleVar = transformed.getInstance();
        auto tupleType = cast<LLVM::LLVMStructType>(tupleVar.getType());

        // values
        SmallVector<mlir::Value> results;

        // set values here
        for (auto [index, item] : enumerate(tupleType.getBody()))
        {
            auto llvmValueType = item;
            auto value =
                rewriter.create<LLVM::ExtractValueOp>(loc, llvmValueType, tupleVar, MLIRHelper::getStructIndex(rewriter, index));

            results.push_back(value);
        }

        rewriter.replaceOp(deconstructTupleOp, ValueRange{results});
        return success();
    }
};

struct CreateArrayOpLowering : public TsLlvmPattern<mlir_ts::CreateArrayOp>
{
    using TsLlvmPattern<mlir_ts::CreateArrayOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CreateArrayOp createArrayOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(createArrayOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(createArrayOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = createArrayOp.getLoc();

        auto arrayType = createArrayOp.getType();
        auto elementType = arrayType.getElementType();
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto newCountAsIndexType = clh.createIndexConstantOf(llvmIndexType, createArrayOp.getItems().size());

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsIndexType});

        auto allocated = ch.MemoryAlloc(multSizeOfTypeValue);

        mlir::Value index = clh.createIndexConstantOf(llvmIndexType, 0);
        auto next = false;
        mlir::Value value1;
        for (auto item : transformed.getItems())
        {
            if (next)
            {
                if (!value1)
                {
                    value1 = clh.createIndexConstantOf(llvmIndexType, 1);
                }

                index = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{index, value1});
            }

            // save new element
            auto offset = rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, allocated, ValueRange{index});

            auto effectiveItem = item;
            if (llvmElementType != item.getType())
            {
                // effectiveItem = rewriter.create<mlir_ts::CastOp>(loc, llvmElementType, item);
                llvm_unreachable("type mismatch");
                return failure();
            }

            auto save = rewriter.create<LLVM::StoreOp>(loc, effectiveItem, offset);
            next = true;
        }

        // create array type
        auto llvmRtArrayStructType = tch.convertType(arrayType);

        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmRtArrayStructType);
        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue, allocated,
                                                                 MLIRHelper::getStructIndex(rewriter, 0));

        auto structValue3 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue2,
                                                                 newCountAsIndexType, MLIRHelper::getStructIndex(rewriter, 1));

        rewriter.replaceOp(createArrayOp, ValueRange{structValue3});
        return success();
    }
};

struct NewEmptyArrayOpLowering : public TsLlvmPattern<mlir_ts::NewEmptyArrayOp>
{
    using TsLlvmPattern<mlir_ts::NewEmptyArrayOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::NewEmptyArrayOp newEmptyArrOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(newEmptyArrOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(newEmptyArrOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = newEmptyArrOp.getLoc();

        auto arrayType = newEmptyArrOp.getType();
        auto elementType = arrayType.getElementType();

        mlir::Type storageType = elementType;
        // TODO: find out if the following is correct
        // storageType = MLIRHelper::getStorageTypeFrom(elementType);

        auto llvmElementType = tch.convertType(elementType);

        auto allocated = rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType());

        // create array type
        auto llvmRtArrayStructType = tch.convertType(arrayType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmRtArrayStructType);
        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue, allocated,
                                                                 MLIRHelper::getStructIndex(rewriter, 0));

        auto size0 = clh.createIndexConstantOf(llvmIndexType, 0);
        auto structValue3 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue2, size0,
                                                                 MLIRHelper::getStructIndex(rewriter, 1));

        rewriter.replaceOp(newEmptyArrOp, ValueRange{structValue3});
        return success();
    }
};

struct NewArrayOpLowering : public TsLlvmPattern<mlir_ts::NewArrayOp>
{
    using TsLlvmPattern<mlir_ts::NewArrayOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::NewArrayOp newArrOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(newArrOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(newArrOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = newArrOp.getLoc();

        auto arrayType = newArrOp.getType();
        auto elementType = arrayType.getElementType();
        auto llvmIndexType = tch.convertType(th.getIndexType());
        auto llvmElementType = tch.convertType(elementType);

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto countAsIndexTypeMLIR = rewriter.create<mlir_ts::CastOp>(loc, th.getIndexType(), transformed.getCount());
        auto countAsIndexType = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, countAsIndexTypeMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, countAsIndexType});

        // zeroed: its elements are not set yet, and under `-mm=rc` the first store into one
        // releases what the slot held - `malloc`'s leftovers would be released as a reference
        auto allocated = ch.MemoryAlloc(multSizeOfTypeValue, MemoryAllocSet::Zero);

        // create array type
        auto llvmRtArrayStructType = tch.convertType(arrayType);

        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmRtArrayStructType);
        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue, allocated,
                                                                 MLIRHelper::getStructIndex(rewriter, ARRAY_DATA_INDEX));

        auto structValue3 = rewriter.create<LLVM::InsertValueOp>(loc, llvmRtArrayStructType, structValue2,
                                                                 transformed.getCount(), MLIRHelper::getStructIndex(rewriter, ARRAY_SIZE_INDEX));

        rewriter.replaceOp(newArrOp, ValueRange{structValue3});
        return success();
    }
};

struct ArrayPushOpLowering : public TsLlvmPattern<mlir_ts::ArrayPushOp>
{
    using TsLlvmPattern<mlir_ts::ArrayPushOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArrayPushOp pushOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(pushOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(pushOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = pushOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(pushOp.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        // TODO: use GetAddressOfArrayElement method to sync code
        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);

        auto incSize = clh.createIndexConstantOf(llvmIndexType, transformed.getItems().size());
        auto newCountAsIndexType =
            rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{countAsIndexType, incSize});

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsIndexType});

        auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

        mlir::Value index = countAsIndexType;
        auto next = false;
        mlir::Value value1;
        for (auto itemPair : llvm::zip(transformed.getItems(), pushOp.getItems()))
        {
            auto item = std::get<0>(itemPair);
            auto itemOrig = std::get<1>(itemPair);

            if (next)
            {
                if (!value1)
                {
                    value1 = clh.createIndexConstantOf(llvmIndexType, 1);
                }

                index = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{index, value1});
            }

            // save new element
            auto offset = rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, allocated, ValueRange{index});

            auto effectiveItem = item;
            if (elementType != itemOrig.getType())
            {
                LLVM_DEBUG(llvm::dbgs() << "\n!! push cast: store type: " << elementType
                                        << " value type: " << item.getType() << "\n";);
                llvm_unreachable("cast must happen earlier");
                // effectiveItem = rewriter.create<mlir_ts::CastOp>(loc, elementType, item);
                return failure();
            }

            auto save = rewriter.create<LLVM::StoreOp>(loc, effectiveItem, offset);
            next = true;
        }

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsIndexType, countAsIndexTypePtr);

        rewriter.replaceOp(pushOp, ValueRange{newCountAsIndexType});
        return success();
    }
};

struct ArrayPopOpLowering : public TsLlvmPattern<mlir_ts::ArrayPopOp>
{
    using TsLlvmPattern<mlir_ts::ArrayPopOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArrayPopOp popOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(popOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(popOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = popOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(popOp.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();
        
        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);

        auto incSize = clh.createIndexConstantOf(llvmIndexType, 1);
        auto newCountAsIndexType =
            rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, incSize});

        // load last element
        auto offset =
            rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, currentPtr, ValueRange{newCountAsIndexType});
        auto loadedElement = rewriter.create<LLVM::LoadOp>(loc, llvmElementType, offset);

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsIndexType});

        auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsIndexType, countAsIndexTypePtr);

        rewriter.replaceOp(popOp, ValueRange{loadedElement});
        return success();
    }
};

struct ArrayUnshiftOpLowering : public TsLlvmPattern<mlir_ts::ArrayUnshiftOp>
{
    using TsLlvmPattern<mlir_ts::ArrayUnshiftOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArrayUnshiftOp unshiftOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(unshiftOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(unshiftOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = unshiftOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(unshiftOp.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);

        auto incSize = clh.createIndexConstantOf(llvmIndexType, transformed.getItems().size());
        auto newCountAsIndexType =
            rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{countAsIndexType, incSize});

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsIndexType});

        auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

        // realloc
        auto offset0 = allocated;
        auto offsetN = rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, allocated, ValueRange{incSize});

        // shift the existing elements up: only the old count is there to move - moving the new count wrote
        // `incSize` elements past the end of the block (caught by the debug heap under -mm=rc)
        auto moveBytes = rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, countAsIndexType});
        auto moveBytesAdapt = rewriter.create<mlir_ts::DialectCastOp>(loc, th.getIndexType(), moveBytes);
        rewriter.create<mlir_ts::MemoryMoveOp>(loc, offsetN, offset0, moveBytesAdapt);

        mlir::Value index = clh.createIndexConstantOf(llvmIndexType, 0);
        auto next = false;
        mlir::Value value1;
        for (auto itemPair : llvm::zip(transformed.getItems(), unshiftOp.getItems()))
        {
            auto item = std::get<0>(itemPair);
            auto itemOrig = std::get<1>(itemPair);

            if (next)
            {
                if (!value1)
                {
                    value1 = clh.createIndexConstantOf(llvmIndexType, 1);
                }

                index = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{index, value1});
            }

            // save new element
            auto offset = rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, allocated, ValueRange{index});

            auto effectiveItem = item;
            if (elementType != itemOrig.getType())
            {
                LLVM_DEBUG(llvm::dbgs() << "\n!! push cast: store type: " << elementType
                                        << " value type: " << item.getType() << "\n";);
                llvm_unreachable("cast must happen earlier");
                // effectiveItem = rewriter.create<mlir_ts::CastOp>(loc, elementType, item);
                return failure();
            }

            auto save = rewriter.create<LLVM::StoreOp>(loc, effectiveItem, offset);
            next = true;
        }

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsIndexType, countAsIndexTypePtr);

        rewriter.replaceOp(unshiftOp, ValueRange{newCountAsIndexType});
        return success();
    }
};

struct ArrayShiftOpLowering : public TsLlvmPattern<mlir_ts::ArrayShiftOp>
{
    using TsLlvmPattern<mlir_ts::ArrayShiftOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArrayShiftOp shiftOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(shiftOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(shiftOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = shiftOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(shiftOp.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        mlir::Type storageType = elementType;
        // storageType = MLIRHelper::getStorageTypeFrom(elementType);

        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);

        auto incSize = clh.createIndexConstantOf(llvmIndexType, 1);
        auto newCountAsIndexType =
            rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, incSize});

        // load last element
        auto offset0 =
            rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, currentPtr, ValueRange{clh.createIndexConstantOf(llvmIndexType, 0)});
        auto loadedElement = rewriter.create<LLVM::LoadOp>(loc, llvmElementType, offset0);

        auto offset1 =
            rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), llvmElementType, currentPtr, ValueRange{incSize});

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), storageType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsIndexType});

        auto multSizeOfTypeValueAdapt = rewriter.create<mlir_ts::DialectCastOp>(loc, th.getIndexType(), multSizeOfTypeValue);
        rewriter.create<mlir_ts::MemoryMoveOp>(loc, offset0, offset1, multSizeOfTypeValueAdapt);

        auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsIndexType, countAsIndexTypePtr);

        rewriter.replaceOp(shiftOp, ValueRange{loadedElement});
        return success();
    }
};

struct ArraySpliceOpLowering : public TsLlvmPattern<mlir_ts::ArraySpliceOp>
{
    using TsLlvmPattern<mlir_ts::ArraySpliceOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArraySpliceOp spliceOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(spliceOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(spliceOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = spliceOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = cast<mlir_ts::ArrayType>(cast<mlir_ts::RefType>(spliceOp.getOp().getType()).getElementType());
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmElementType = tch.convertType(elementType);
        auto indexType = th.getIndexType();
        auto llvmIndexType = tch.convertType(indexType);

        auto currentPtrPtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                          ArrayRef<LLVM::GEPArg>{0, ARRAY_DATA_INDEX});
        auto currentPtr = rewriter.create<LLVM::LoadOp>(loc, ptrType, currentPtrPtr);

        auto countAsIndexTypePtr = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmArrayType, transformed.getOp(),
                                                              ArrayRef<LLVM::GEPArg>{0, ARRAY_SIZE_INDEX});
        auto countAsIndexType = rewriter.create<LLVM::LoadOp>(loc, llvmIndexType, countAsIndexTypePtr);

        auto startIndexAsIndexType = spliceOp.getStart();
        auto decSizeAsIndexType = spliceOp.getDeleteCount();

        mlir::Value startIndexAsLLVMType = rewriter.create<mlir::index::CastUOp>(loc, llvmIndexType, startIndexAsIndexType);
        mlir::Value decSizeAsLLVMType = rewriter.create<mlir::index::CastUOp>(loc, llvmIndexType, decSizeAsIndexType);

        // Start and delete count arrive signed (mlirGenArraySplice). As JavaScript has it, a
        // negative start counts from the end and stops at 0, a start past the end is the end, and
        // a negative delete count deletes nothing. `a.splice(-1, 1)` used to take -1 as the largest
        // unsigned index and fault.
        {
            auto zero = clh.createIndexConstantOf(llvmIndexType, 0);
            auto startIsNegative =
                rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, startIndexAsLLVMType, zero);
            auto fromEnd = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{startIndexAsLLVMType, countAsIndexType});
            auto fromEndIsNegative = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, fromEnd, zero);
            auto negativeStart = rewriter.create<LLVM::SelectOp>(loc, fromEndIsNegative, zero, fromEnd);
            auto startPastEnd =
                rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt, startIndexAsLLVMType, countAsIndexType);
            auto positiveStart = rewriter.create<LLVM::SelectOp>(loc, startPastEnd, countAsIndexType, startIndexAsLLVMType);
            startIndexAsLLVMType = rewriter.create<LLVM::SelectOp>(loc, startIsNegative, negativeStart, positiveStart);

            auto deleteIsNegative =
                rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, decSizeAsLLVMType, zero);
            decSizeAsLLVMType = rewriter.create<LLVM::SelectOp>(loc, deleteIsNegative, zero, decSizeAsLLVMType);
        }

        auto incSizeAsLLVMType = clh.createIndexConstantOf(llvmIndexType, transformed.getItems().size());

        // Give back what the removed elements were holding, before anything moves or frees them.
        //
        // `splice` memmoves the tail over the deleted range and reallocs; the references those
        // slots held are simply overwritten, so under `-mm=rc` every element it removes leaked.
        // Measured on a loop that splices two of three boxed strings away: 16.4 MB against 4.1
        // for the same program without the splice. See §9.74.
        //
        // This runs on `currentPtr` and before `conditionalExpressionLowering` below, which is
        // the only correct place: the growing branch reallocs *first*, and a realloc may move the
        // block, so releasing afterwards would read the deleted elements through a stale pointer.
        //
        // The delete count is first clamped to what is actually in the array, which JavaScript's
        // `splice` also does ("if greater than the number of elements after start, then all of
        // the elements from start onwards will be deleted"). It was not clamped here, and the
        // subtraction below then underflowed an unsigned index: `["p","q"].splice(1, 10)` asked
        // `memmove` for about 2^64 bytes and faulted. That reproduces under every memory model
        // and long predates any of this - it simply had to be settled before releasing anything,
        // since a release loop walking off the end reads freed memory rather than merely
        // computing a wrong size.
        auto availableAsLLVMType =
            rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, startIndexAsLLVMType});
        auto deleteFits =
            rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ule, decSizeAsLLVMType, availableAsLLVMType);
        decSizeAsLLVMType = rewriter.create<LLVM::SelectOp>(loc, deleteFits, decSizeAsLLVMType, availableAsLLVMType);

        {
            OwnershipRoutineLogic orl(spliceOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitReleaseArrayElements(elementType, currentPtr, startIndexAsLLVMType, decSizeAsLLVMType);
        }

        // Keep all arithmetic in the already-LLVM-converted domain (llvmIndexType), matching
        // every sibling array-mutation lowering (ArrayPushOp/ArrayUnshiftOp/ArrayShiftOp) --
        // mlir::index::*Op ops require genuinely `index`-typed operands, but countAsIndexType
        // (despite its name) is loaded as llvmIndexType, and incSizeAsLLVMType is already
        // LLVM-typed, so mixing them into index:: ops here was a dialect-operand mismatch.
        mlir::Value newCountAsLLVMType = rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, decSizeAsLLVMType});
        newCountAsLLVMType = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{newCountAsLLVMType, incSizeAsLLVMType});

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, indexType, elementType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto multSizeOfTypeValue =
            rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, newCountAsLLVMType});

        auto increaseArrayFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
            auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);

            auto moveCountAsLLVMType =
                rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, startIndexAsLLVMType});
            moveCountAsLLVMType =
                rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{moveCountAsLLVMType, decSizeAsLLVMType});

            // realloc
            auto offsetStart = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, allocated, ValueRange{startIndexAsLLVMType});
            auto offsetFrom = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, offsetStart, ValueRange{decSizeAsLLVMType});
            auto offsetTo = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, offsetStart, ValueRange{incSizeAsLLVMType});
            auto moveBytes = rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, moveCountAsLLVMType});
            auto moveBytesAdapt = rewriter.create<mlir_ts::DialectCastOp>(loc, indexType, moveBytes);
            rewriter.create<mlir_ts::MemoryMoveOp>(loc, offsetTo, offsetFrom, moveBytesAdapt);

            return allocated;
        };

        auto decreaseArrayFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {

            auto moveCountAsLLVMType =
                rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{countAsIndexType, startIndexAsLLVMType});
            moveCountAsLLVMType =
                rewriter.create<LLVM::SubOp>(loc, llvmIndexType, ValueRange{moveCountAsLLVMType, decSizeAsLLVMType});

            // realloc
            auto offsetStart = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, currentPtr, ValueRange{startIndexAsLLVMType});
            auto offsetFrom = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, offsetStart, ValueRange{decSizeAsLLVMType});
            auto offsetTo = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, offsetStart, ValueRange{incSizeAsLLVMType});

            auto moveBytes = rewriter.create<LLVM::MulOp>(loc, llvmIndexType, ValueRange{sizeOfTypeValue, moveCountAsLLVMType});
            auto moveBytesAdapt = rewriter.create<mlir_ts::DialectCastOp>(loc, indexType, moveBytes);
            rewriter.create<mlir_ts::MemoryMoveOp>(loc, offsetTo, offsetFrom, moveBytesAdapt);

            auto allocated = ch.MemoryRealloc(currentPtr, multSizeOfTypeValue);
            return allocated;
        };

        auto cond = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ugt, incSizeAsLLVMType, decSizeAsLLVMType);
        auto allocated = clh.conditionalExpressionLowering(loc, ptrType, cond, increaseArrayFunc, decreaseArrayFunc);

        mlir::Value indexAsLLVMType = startIndexAsLLVMType;
        auto next = false;
        mlir::Value value1;
        for (auto itemPair : llvm::zip(transformed.getItems(), spliceOp.getItems()))
        {
            auto item = std::get<0>(itemPair);
            auto itemOrig = std::get<1>(itemPair);

            if (next)
            {
                if (!value1)
                {
                    value1 = clh.createIndexConstantOf(llvmIndexType, 1);
                }

                indexAsLLVMType = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, ValueRange{indexAsLLVMType, value1});
            }

            // save new element
            auto offset = rewriter.create<LLVM::GEPOp>(loc, ptrType, llvmElementType, allocated, ValueRange{indexAsLLVMType});

            auto effectiveItem = item;
            if (elementType != itemOrig.getType())
            {
                LLVM_DEBUG(llvm::dbgs() << "\n!! push cast: store type: " << elementType
                                        << " value type: " << item.getType() << "\n";);
                llvm_unreachable("cast must happen earlier");
                // effectiveItem = rewriter.create<mlir_ts::CastOp>(loc, elementType, item);
                return failure();
            }

            auto save = rewriter.create<LLVM::StoreOp>(loc, effectiveItem, offset);
            next = true;
        }

        rewriter.create<LLVM::StoreOp>(loc, allocated, currentPtrPtr);
        rewriter.create<LLVM::StoreOp>(loc, newCountAsLLVMType, countAsIndexTypePtr);

        rewriter.replaceOp(spliceOp, ValueRange{newCountAsLLVMType});
        return success();
    }
};

struct ArrayViewOpLowering : public TsLlvmPattern<mlir_ts::ArrayViewOp>
{
    using TsLlvmPattern<mlir_ts::ArrayViewOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArrayViewOp arrayViewOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper ch(arrayViewOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(arrayViewOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter);

        auto loc = arrayViewOp.getLoc();

        auto ptrType = th.getPtrType();
        auto arrayType = arrayViewOp.getOp().getType();
        auto elementType = arrayType.getElementType();

        auto llvmArrayType = tch.convertType(arrayType);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        // TODO: add size check !!!

        auto arrayPtr = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(),
                transformed.getOp(), MLIRHelper::getStructIndex(rewriter, ARRAY_DATA_INDEX));

        auto arrayOffset = ch.GetAddressOfPointerOffset(elementType, arrayPtr, transformed.getOffset());
        // create array type
        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmArrayType);
        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmArrayType, structValue, arrayOffset,
                                                                 MLIRHelper::getStructIndex(rewriter, ARRAY_DATA_INDEX));

        auto structValue3 = rewriter.create<LLVM::InsertValueOp>(loc, llvmArrayType, structValue2,
                                                                 transformed.getCount(), MLIRHelper::getStructIndex(rewriter, ARRAY_SIZE_INDEX));

        rewriter.replaceOp(arrayViewOp, ValueRange{structValue3});
        return success();
    }
};

struct DeleteOpLowering : public TsLlvmPattern<mlir_ts::DeleteOp>
{
    using TsLlvmPattern<mlir_ts::DeleteOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DeleteOp deleteOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        // Under reference counting `delete` drops a reference rather than freeing outright:
        // the object goes only if this was the last one, and what it owns is released with it.
        // That also keeps `delete` off an immortal block, which a bare free would not.
        if (tsLlvmContext->compileOptions.tracksOwnership())
        {
            OwnershipRoutineLogic orl(deleteOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            orl.emitReleaseValue(deleteOp.getReference().getType(), transformed.getReference());

            rewriter.eraseOp(deleteOp);
            return mlir::success();
        }

        LLVMCodeHelper ch(deleteOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        if (mlir::failed(ch.MemoryFree(transformed.getReference())))
        {
            return mlir::failure();
        }

        rewriter.eraseOp(deleteOp);
        return mlir::success();
    }
};

LogicalResult NegativeOpValue(mlir_ts::ArithmeticUnaryOp &unaryOp, mlir::Value oper, mlir::PatternRewriter &builder)
{
    CodeLogicHelper clh(unaryOp, builder);

    auto type = oper.getType();
    if (type.isIntOrIndex())
    {
        builder.replaceOpWithNewOp<arith::SubIOp>(unaryOp, type, clh.createIConstantOf(type.getIntOrFloatBitWidth(), 0), oper);
        return mlir::success();
    }
    else if (!type.isIntOrIndex() && type.isIntOrIndexOrFloat())
    {
        builder.replaceOpWithNewOp<arith::SubFOp>(unaryOp, type, clh.createFConstantOf(type.getIntOrFloatBitWidth(), 0.0),
                                           oper);
        return mlir::success();
    }
    else
    {
        unaryOp->emitError("unary '-'/'+' is not supported for this operand type");
        return mlir::failure();
    }

    return mlir::failure();
}

LogicalResult NegativeOpBin(mlir_ts::ArithmeticUnaryOp &unaryOp, mlir::Value oper, mlir::PatternRewriter &builder)
{
    CodeLogicHelper clh(unaryOp, builder);

    auto type = oper.getType();
    if (type.isIntOrIndex())
    {
        mlir::Value lhs;
        if (type.isInteger(1))
        {
            lhs = clh.createI1ConstantOf(true);
        }
        else
        {
            // lhs = clh.createI32ConstantOf(-1);
            lhs = clh.createIConstantOf(type.getIntOrFloatBitWidth(), -1);
        }

        builder.replaceOpWithNewOp<LLVM::XOrOp>(unaryOp, type, oper, lhs);
        return mlir::success();
    }
    else
    {
        unaryOp->emitError("unary '!'/'~' is not supported for this operand type");
        return mlir::failure();
    }

    return mlir::failure();
}

struct ArithmeticUnaryOpLowering : public TsLlvmPattern<mlir_ts::ArithmeticUnaryOp>
{
    using TsLlvmPattern<mlir_ts::ArithmeticUnaryOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ArithmeticUnaryOp arithmeticUnaryOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto opCode = (SyntaxKind)arithmeticUnaryOp.getOpCode();
        switch (opCode)
        {
        case SyntaxKind::ExclamationToken:
            return NegativeOpBin(arithmeticUnaryOp, transformed.getOperand1(), rewriter);
        case SyntaxKind::PlusToken:
            rewriter.replaceOp(arithmeticUnaryOp, transformed.getOperand1());
            return success();
        case SyntaxKind::MinusToken:
            return NegativeOpValue(arithmeticUnaryOp, transformed.getOperand1(), rewriter);
        case SyntaxKind::TildeToken:
            return NegativeOpBin(arithmeticUnaryOp, transformed.getOperand1(), rewriter);
        default:
            // `+ - ~ !` are the complete set of opcodes MLIRGen ever constructs this op
            // with (mlirGen(PrefixUnaryExpression) routes `++`/`--` to a different op,
            // PrefixUnaryOp, and rejects any other operator before reaching codegen).
            arithmeticUnaryOp->emitError("unsupported unary operator");
            return failure();
        }
    }
};

struct ArithmeticBinaryOpLowering : public TsLlvmPattern<mlir_ts::ArithmeticBinaryOp>
{
    using TsLlvmPattern<mlir_ts::ArithmeticBinaryOp>::TsLlvmPattern;

    // JS shift operators (<<, >>, >>>) use only the low 5 bits of the shift amount
    // (i.e. count & 31 for 32-bit operands). LLVM's shl/ashr/lshr are undefined
    // behavior when the shift amount >= the operand's bit width, so without this
    // mask, optimized (-O) builds can produce garbage for e.g. `10 << 100`.
    static mlir::Value maskShiftAmount(mlir::Location loc, mlir::Value shiftAmount, ConversionPatternRewriter &rewriter)
    {
        auto intType = dyn_cast<mlir::IntegerType>(shiftAmount.getType());
        if (!intType)
        {
            return shiftAmount;
        }

        auto mask = rewriter.create<arith::ConstantOp>(
            loc, intType, rewriter.getIntegerAttr(intType, intType.getWidth() - 1));
        return rewriter.create<arith::AndIOp>(loc, shiftAmount, mask);
    }

    LogicalResult matchAndRewrite(mlir_ts::ArithmeticBinaryOp arithmeticBinaryOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {


        auto opCode = (SyntaxKind)arithmeticBinaryOp.getOpCode();
        switch (opCode)
        {
        case SyntaxKind::PlusToken:
            if (isa<mlir_ts::StringType>(arithmeticBinaryOp.getOperand1().getType()))
            {
                rewriter.replaceOpWithNewOp<mlir_ts::StringConcatOp>(
                    arithmeticBinaryOp, mlir_ts::StringType::get(rewriter.getContext()),
                    ValueRange{transformed.getOperand1(), transformed.getOperand2()});
                return success();
            }

            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::AddIOp, arith::AddFOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                                transformed.getOperand2(), rewriter);

        case SyntaxKind::MinusToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::SubIOp, arith::SubFOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                               transformed.getOperand2(), rewriter);

        case SyntaxKind::AsteriskToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::MulIOp, arith::MulFOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                               transformed.getOperand2(), rewriter);

        case SyntaxKind::SlashToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::DivSIOp, arith::DivFOp, arith::DivUIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                               transformed.getOperand2(), rewriter);

        case SyntaxKind::GreaterThanGreaterThanToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::ShRSIOp, arith::ShRSIOp, arith::ShRUIOp>(
                arithmeticBinaryOp, transformed.getOperand1(), maskShiftAmount(arithmeticBinaryOp->getLoc(), transformed.getOperand2(), rewriter), rewriter);

        case SyntaxKind::GreaterThanGreaterThanGreaterThanToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::ShRUIOp, arith::ShRUIOp>(
                arithmeticBinaryOp, transformed.getOperand1(), maskShiftAmount(arithmeticBinaryOp->getLoc(), transformed.getOperand2(), rewriter), rewriter);

        case SyntaxKind::LessThanLessThanToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::ShLIOp, arith::ShLIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                                         maskShiftAmount(arithmeticBinaryOp->getLoc(), transformed.getOperand2(), rewriter), rewriter);

        case SyntaxKind::AmpersandToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::AndIOp, arith::AndIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                             transformed.getOperand2(), rewriter);

        case SyntaxKind::BarToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::OrIOp, arith::OrIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                           transformed.getOperand2(), rewriter);

        case SyntaxKind::CaretToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::XOrIOp, arith::XOrIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                             transformed.getOperand2(), rewriter);

        case SyntaxKind::PercentToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, arith::RemSIOp, arith::RemFOp, arith::RemUIOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                               transformed.getOperand2(), rewriter);

        case SyntaxKind::AsteriskAsteriskToken:
            return BinOp<mlir_ts::ArithmeticBinaryOp, math::PowFOp, math::PowFOp>(arithmeticBinaryOp, transformed.getOperand1(),
                                                                           transformed.getOperand2(), rewriter);

        default:
            // every ArithmeticBinaryOp construction site (MLIRGenExpressions.cpp's
            // binaryOpLogic default branch, plus a handful of synthetic-codegen sites in
            // MLIRGenClasses.cpp/MLIRGenVariables.cpp/MLIRGenImpl.h) only ever uses one of
            // the opcodes already handled above.
            arithmeticBinaryOp->emitError("unsupported arithmetic operator");
            return failure();
        }
    }
};

struct LogicalBinaryOpLowering : public TsLlvmPattern<mlir_ts::LogicalBinaryOp>
{
    using TsLlvmPattern<mlir_ts::LogicalBinaryOp>::TsLlvmPattern;

    template <arith::CmpIPredicate v1, arith::CmpFPredicate v2>
    mlir::Value logicOp(mlir_ts::LogicalBinaryOp logicalBinaryOp, SyntaxKind op, mlir::Value left,
                        mlir::Type leftTypeOrig, mlir::Value right, mlir::Type rightTypeOrig,
                        PatternRewriter &builder) const
    {
        return LogicOp<arith::CmpIOp, arith::CmpIPredicate, v1, arith::CmpFOp, arith::CmpFPredicate, v2>(
            logicalBinaryOp, op, left, leftTypeOrig, right, rightTypeOrig, builder, *(const LLVMTypeConverter *)getTypeConverter(),
            tsLlvmContext->compileOptions);
    }

    LogicalResult matchAndRewrite(mlir_ts::LogicalBinaryOp logicalBinaryOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto op = (SyntaxKind)logicalBinaryOp.getOpCode();

        auto op1 = transformed.getOperand1();
        auto op2 = transformed.getOperand2();
        auto opType1 = logicalBinaryOp.getOperand1().getType();
        auto opType2 = logicalBinaryOp.getOperand2().getType();

        // mlir_ts::BooleanType lowers to a signless i1, so isUnsignedInteger() (which
        // only recognizes mlir::IntegerType's unsigned flavor) is false for it, and
        // ordering comparisons fell to the signed predicate -- where i1 `true` (bit
        // pattern 1) reads as -1, making `true > false` compare as `-1 > 0` (false).
        // Booleans compare as unsigned 0/1, so treat them as such here explicitly.
        auto isUnsignedOrBoolean = [](mlir::Type type) {
            return type.isUnsignedInteger() || isa<mlir_ts::BooleanType>(type);
        };
        auto useUnsignedCompare = isUnsignedOrBoolean(opType1) && isUnsignedOrBoolean(opType2);

        // int and float
        mlir::Value value;
        switch (op)
        {
        case SyntaxKind::EqualsEqualsToken:
        case SyntaxKind::EqualsEqualsEqualsToken:
            value = logicOp<arith::CmpIPredicate::eq, arith::CmpFPredicate::OEQ>(logicalBinaryOp, op, op1, opType1, op2, opType2,
                                                                   rewriter);
            break;
        case SyntaxKind::ExclamationEqualsToken:
        case SyntaxKind::ExclamationEqualsEqualsToken:
            // UNE, not ONE: JS `!=`/`!==` is the negation of `==`, so NaN != x must be
            // true. ONE (ordered) yields false when either side is NaN, and `x != x`
            // (the idiomatic NaN test) folds to constant false.
            value = logicOp<arith::CmpIPredicate::ne, arith::CmpFPredicate::UNE>(logicalBinaryOp, op, op1, opType1, op2, opType2,
                                                                   rewriter);
            break;
        case SyntaxKind::GreaterThanToken:

            if (useUnsignedCompare)
            {
                value = logicOp<arith::CmpIPredicate::ugt, arith::CmpFPredicate::OGT>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }
            else
            {
                value = logicOp<arith::CmpIPredicate::sgt, arith::CmpFPredicate::OGT>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }
            break;
        case SyntaxKind::GreaterThanEqualsToken:
            if (useUnsignedCompare)
            {
                value = logicOp<arith::CmpIPredicate::uge, arith::CmpFPredicate::OGE>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }
            else
            {
                value = logicOp<arith::CmpIPredicate::sge, arith::CmpFPredicate::OGE>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }

            break;
        case SyntaxKind::LessThanToken:
            if (useUnsignedCompare)
            {
                value = logicOp<arith::CmpIPredicate::ult, arith::CmpFPredicate::OLT>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }
            else
            {
                value = logicOp<arith::CmpIPredicate::slt, arith::CmpFPredicate::OLT>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }

            break;
        case SyntaxKind::LessThanEqualsToken:
            if (useUnsignedCompare)
            {
                value = logicOp<arith::CmpIPredicate::ule, arith::CmpFPredicate::OLE>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }
            else
            {
                value = logicOp<arith::CmpIPredicate::sle, arith::CmpFPredicate::OLE>(
                    logicalBinaryOp, op, op1, opType1, op2, opType2, rewriter);
            }

            break;
        default:
            // every LogicalBinaryOp construction site (traced across the whole codebase)
            // only ever uses one of the 8 relational operators handled above.
            logicalBinaryOp->emitError("unsupported relational operator");
            return failure();
        }

        rewriter.replaceOp(logicalBinaryOp, value);
        return success();
    }
};

struct LoadOpLowering : public TsLlvmPattern<mlir_ts::LoadOp>
{
    using TsLlvmPattern<mlir_ts::LoadOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LoadOp loadOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(loadOp, rewriter);

        auto loc = loadOp.getLoc();

        mlir::Type elementType;
        mlir::Type elementTypeConverted;

        auto elementRefType = loadOp.getReference().getType();
        auto resultType = loadOp.getType();

        if (auto refType = dyn_cast<mlir_ts::RefType>(elementRefType))
        {
            elementType = refType.getElementType();
            elementTypeConverted = tch.convertType(elementType);
        }
        else if (auto valueRefType = dyn_cast<mlir_ts::ValueRefType>(elementRefType))
        {
            elementType = valueRefType.getElementType();
            elementTypeConverted = tch.convertType(elementType);
        }

        auto isOptional = false;
        if (auto optType = dyn_cast<mlir_ts::OptionalType>(resultType))
        {
            isOptional = optType.getElementType() == elementType;
        }

        mlir::Value loadedValue;
        auto loadedValueFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
            mlir::Value loadedValue;
            if (elementType)
            {
                auto alignment = 0;
                auto isVolatile = false;
                auto isNonTemporal = false;
                auto isInvariant = false;
                auto ordering = LLVM::AtomicOrdering::not_atomic;
                StringRef syncscope = {};

                if (auto atomicAttr = loadOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
                {
                    if (atomicAttr.getValue()) 
                    {
                        auto orderingAttr = loadOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                        auto syncScopeAttr = loadOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                        if (orderingAttr && syncScopeAttr)
                        {
                            ordering = (LLVM::AtomicOrdering) orderingAttr.getValue().getZExtValue();
                            if (ordering == LLVM::AtomicOrdering::release || ordering == LLVM::AtomicOrdering::acq_rel)
                            {
                                ordering = LLVM::AtomicOrdering::acquire;
                            }

                            syncscope = syncScopeAttr.getValue();
                            LLVMTypeConverterHelper ltch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));
                            alignment = ltch.getTypeAlignSizeInBits(elementTypeConverted);
                        }
                    }
                }

                if (auto volatileAttr = loadOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
                {
                    isVolatile = volatileAttr.getValue();
                }

                if (auto nonTemporalAttr = loadOp->getAttrOfType<mlir::BoolAttr>(NONTEMPORAL_ATTR_NAME))
                {
                    isNonTemporal = nonTemporalAttr.getValue();
                }    

                if (auto invariantAttr = loadOp->getAttrOfType<mlir::BoolAttr>(INVARIANT_ATTR_NAME))
                {
                    isInvariant = invariantAttr.getValue();
                }    

                const bool isInvariantGroup = false; // TODO: Determine if this should be set based on some condition
                loadedValue = rewriter.create<LLVM::LoadOp>(loc, elementTypeConverted, transformed.getReference(), alignment, isVolatile, isNonTemporal, isInvariant, isInvariantGroup, ordering, syncscope);
            }
            else if (auto boundRefType = dyn_cast<mlir_ts::BoundRefType>(elementRefType))
            {
                auto loadRoundRef = rewriter.create<mlir_ts::LoadBoundRefOp>(loc, resultType, loadOp.getReference());

                // copy attrs over
                if (auto atomicAttr = loadOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
                {
                    auto orderingAttr = loadOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                    auto syncScopeAttr = loadOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                    loadRoundRef->setAttr(ATOMIC_ATTR_NAME, atomicAttr);
                    loadRoundRef->setAttr(ORDERING_ATTR_NAME, orderingAttr);
                    loadRoundRef->setAttr(SYNCSCOPE_ATTR_NAME, syncScopeAttr);
                }

                if (auto volatileAttr = loadOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
                {
                    loadRoundRef->setAttr(VOLATILE_ATTR_NAME, volatileAttr);
                }    

                if (auto nonTemporalAttr = loadOp->getAttrOfType<mlir::BoolAttr>(NONTEMPORAL_ATTR_NAME))
                {
                    loadRoundRef->setAttr(NONTEMPORAL_ATTR_NAME, nonTemporalAttr);
                }    

                if (auto invariantAttr = loadOp->getAttrOfType<mlir::BoolAttr>(INVARIANT_ATTR_NAME))
                {
                    loadRoundRef->setAttr(INVARIANT_ATTR_NAME, invariantAttr);
                }    

                loadedValue = loadRoundRef;            
            }

            return loadedValue;
        };

        if (isOptional)
        {
            auto resultTypeLlvm = tch.convertType(resultType);

            auto undefOptionalFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                mlir::Value val = rewriter.create<mlir_ts::OptionalUndefOp>(loc, resultType);
                mlir::Value valAsLLVMType = builder.create<mlir_ts::DialectCastOp>(loc, resultTypeLlvm, val);
                return valAsLLVMType;
            };

            auto createOptionalFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                auto dataValue = loadedValueFunc(builder, location);
                mlir::Value val = rewriter.create<mlir_ts::OptionalValueOp>(loc, resultType, dataValue);
                mlir::Value valAsLLVMType = builder.create<mlir_ts::DialectCastOp>(loc, resultTypeLlvm, val);
                return valAsLLVMType;
            };

            LLVMTypeConverterHelper llvmtch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));

            auto intPtrType = llvmtch.getIntPtrType(0);

            // not null condition
            auto dataIntPtrValue = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, transformed.getReference());
            auto const0 = clh.createIConstantOf(llvmtch.getPointerBitwidth(0), 0);
            auto ptrCmpResult1 = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, dataIntPtrValue, const0);

            loadedValue =
                clh.conditionalExpressionLowering(loc, resultTypeLlvm, ptrCmpResult1, createOptionalFunc, undefOptionalFunc);
        }
        else
        {
            loadedValue = loadedValueFunc(rewriter, loc);
        }

        if (!loadedValue)
        {
            // LoadOp's `reference` operand is TableGen-constrained to
            // TypeScript_RefOrBoundRefOrValueRef (RefType|BoundRefType|ValueRefType),
            // enforced by the verifier - every case is handled above.
            loadOp->emitError("unsupported reference type in load");
            return failure();
        }

        rewriter.replaceOp(loadOp, ValueRange{loadedValue});

        //LLVM_DEBUG(llvm::dbgs() << "\n!! LoadOp Ref value: \n" << transformed.getReference() << "\n";);
        //LLVM_DEBUG(llvm::dbgs() << "\n!! LoadOp DUMP: \n" << *loadOp->getParentOp() << "\n";);

        return success();
    }
};

struct StoreOpLowering : public TsLlvmPattern<mlir_ts::StoreOp>
{
    using TsLlvmPattern<mlir_ts::StoreOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StoreOp storeOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        if (auto boundRefType = dyn_cast<mlir_ts::BoundRefType>(storeOp.getReference().getType()))
        {
            auto storeBoundRefOp = rewriter.create<mlir_ts::StoreBoundRefOp>(storeOp->getLoc(), storeOp.getValue(), storeOp.getReference());

            // copy attrs over
            if (auto atomicAttr = storeOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
            {
                auto orderingAttr = storeOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                auto syncScopeAttr = storeOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                storeBoundRefOp->setAttr(ATOMIC_ATTR_NAME, atomicAttr);
                storeBoundRefOp->setAttr(ORDERING_ATTR_NAME, orderingAttr);
                storeBoundRefOp->setAttr(SYNCSCOPE_ATTR_NAME, syncScopeAttr);
            }

            if (auto volatileAttr = storeOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
            {
                storeBoundRefOp->setAttr(VOLATILE_ATTR_NAME, volatileAttr);
            }    

            if (auto nonTemporalAttr = storeOp->getAttrOfType<mlir::BoolAttr>(NONTEMPORAL_ATTR_NAME))
            {
                storeBoundRefOp->setAttr(NONTEMPORAL_ATTR_NAME, nonTemporalAttr);
            }    

            // if (auto invariantAttr = storeOp->getAttrOfType<mlir::BoolAttr>(INVARIANT_ATTR_NAME))
            // {
            //     storeBoundRefOp->setAttr(INVARIANT_ATTR_NAME, invariantAttr);
            // }   

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

        // atomic attributes
        auto alignment = 0;
        auto isVolatile = false;
        auto isNonTemporal = false;
        auto ordering = LLVM::AtomicOrdering::not_atomic;
        StringRef syncscope = {};

        if (auto atomicAttr = storeOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
        {
            if (atomicAttr.getValue()) 
            {
                auto orderingAttr = storeOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                auto syncScopeAttr = storeOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                if (orderingAttr && syncScopeAttr)
                {
                    ordering = (LLVM::AtomicOrdering) orderingAttr.getValue().getZExtValue();
                    if (ordering == LLVM::AtomicOrdering::acquire || ordering == LLVM::AtomicOrdering::acq_rel)
                    {
                        ordering = LLVM::AtomicOrdering::release;
                    }

                    syncscope = syncScopeAttr.getValue();
                    LLVMTypeConverterHelper ltch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));
                    alignment = ltch.getTypeAlignSizeInBits(transformed.getValue().getType());
                }
            }
        }

        if (auto volatileAttr = storeOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
        {
            isVolatile = volatileAttr.getValue();
        }        

        if (auto nonTemporalAttr = storeOp->getAttrOfType<mlir::BoolAttr>(NONTEMPORAL_ATTR_NAME))
        {
            isNonTemporal = nonTemporalAttr.getValue();
        }    

        // if (auto invariantAttr = storeOp->getAttrOfType<mlir::BoolAttr>(INVARIANT_ATTR_NAME))
        // {
        //     isInvariant = invariantAttr.getValue();
        // }           

        const bool isInvariantGroup = false; // TODO: Determine if this should be set based on some condition
        rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, transformed.getValue(), transformed.getReference(), alignment, isVolatile, isNonTemporal, isInvariantGroup, ordering, syncscope);
#ifdef DBG_INFO_ADD_VALUE_OP        
        if (tsLlvmContext->compileOptions.generateDebugInfo)
        {
            if (auto varInfo = dyn_cast<mlir::FusedLocWith<LLVM::DILocalVariableAttr>>(transformed.getReference().getDefiningOp()->getLoc()))
            {
                rewriter.create<LLVM::DbgValueOp>(storeOp->getLoc(), transformed.getValue(), varInfo.getMetadata());
            }
        }
#endif        

        return success();
    }
};

struct ElementRefOpLowering : public TsLlvmPattern<mlir_ts::ElementRefOp>
{
    using TsLlvmPattern<mlir_ts::ElementRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ElementRefOp elementOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(elementOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto elementType = MLIRHelper::getElementTypeOrSelf(elementOp.getArray().getType());

        auto addr = ch.GetAddressOfArrayElement(elementType, elementOp.getArray().getType(),
                                                transformed.getArray(), transformed.getIndex());
        rewriter.replaceOp(elementOp, addr);
        return success();
    }
};

struct PointerOffsetRefOpLowering : public TsLlvmPattern<mlir_ts::PointerOffsetRefOp>
{
    using TsLlvmPattern<mlir_ts::PointerOffsetRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::PointerOffsetRefOp elementOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(elementOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto addr = ch.GetAddressOfPointerOffset(elementOp.getResult().getType().getElementType(), 
            transformed.getRef(), transformed.getIndex());
        rewriter.replaceOp(elementOp, addr);
        return success();
    }
};

struct ExtractPropertyOpLowering : public TsLlvmPattern<mlir_ts::ExtractPropertyOp>
{
    using TsLlvmPattern<mlir_ts::ExtractPropertyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ExtractPropertyOp extractPropertyOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        rewriter.replaceOpWithNewOp<LLVM::ExtractValueOp>(extractPropertyOp,
                                                          tch.convertType(extractPropertyOp.getType()),
                                                          transformed.getObject(), extractPropertyOp.getPosition());
        return success();
    }
};

struct InsertPropertyOpLowering : public TsLlvmPattern<mlir_ts::InsertPropertyOp>
{
    using TsLlvmPattern<mlir_ts::InsertPropertyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::InsertPropertyOp insertPropertyOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        auto loc = insertPropertyOp->getLoc();

        rewriter.replaceOpWithNewOp<LLVM::InsertValueOp>(
            insertPropertyOp, tch.convertType(insertPropertyOp.getObject().getType()), transformed.getObject(),
            transformed.getValue(), insertPropertyOp.getPosition());

        return success();
    }
};

struct PropertyRefOpLowering : public TsLlvmPattern<mlir_ts::PropertyRefOp>
{
    using TsLlvmPattern<mlir_ts::PropertyRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::PropertyRefOp propertyRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        assert(propertyRefOp.getPosition() != -1);

        LLVMCodeHelper ch(propertyRefOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto addr =
            ch.GetAddressOfStructElement(propertyRefOp.getObjectRef().getType(), transformed.getObjectRef(), propertyRefOp.getPosition());

        if (auto boundRefType = dyn_cast<mlir_ts::BoundRefType>(propertyRefOp.getType()))
        {
            auto boundRef = rewriter.create<mlir_ts::CreateBoundRefOp>(propertyRefOp->getLoc(), boundRefType,
                                                                       propertyRefOp.getObjectRef(), addr);
            addr = boundRef;
        }

        rewriter.replaceOp(propertyRefOp, addr);

        return success();
    }
};

struct GlobalOpLowering : public TsLlvmPattern<mlir_ts::GlobalOp>
{
    using TsLlvmPattern<mlir_ts::GlobalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GlobalOp globalOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = globalOp->getLoc();

        LLVMCodeHelper lch(globalOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto createAsGlobalConstructor = false;
        // TODO: we need to write correct attributes to Ops and detect which ops should be in GlobalConstructor
        auto visitorAllOps = [&](Operation *op) {
            if (isa<mlir_ts::NewOp>(op) || isa<mlir_ts::NewInterfaceOp>(op) || isa<mlir_ts::NewArrayOp>(op) ||
                isa<mlir_ts::SymbolCallInternalOp>(op) || isa<mlir_ts::CallInternalOp>(op) ||
                isa<mlir_ts::CallHybridInternalOp>(op) || isa<mlir_ts::VariableOp>(op) || isa<mlir_ts::AllocaOp>(op) ||
                isa<mlir_ts::CreateArrayOp>(op) || isa<mlir_ts::NewEmptyArrayOp>(op) || isa<mlir_ts::CreateTupleOp>(op) ||
                isa<mlir_ts::LoadOp>(op) || isa<mlir_ts::StoreOp>(op) ||
                isa<mlir_ts::LoadLibraryPermanentlyOp>(op) || isa<mlir_ts::SearchForAddressOfSymbolOp>(op) ||
                isa<mlir_ts::ArrayPushOp>(op) || isa<mlir_ts::ArrayUnshiftOp>(op) || isa<mlir_ts::ArraySpliceOp>(op) ||
                isa<mlir_ts::ArrayPopOp>(op) || isa<mlir_ts::ArrayShiftOp>(op) || isa<mlir_ts::DeleteOp>(op) ||
                isa<mlir_ts::SetLengthOfOp>(op) || isa<mlir_ts::StringResizeOp>(op) ||
                isa<mlir_ts::StringConcatOp>(op) || isa<mlir_ts::CharToStringOp>(op) ||
                // a tagged union's value goes in and out through memory (an alloca and a copy),
                // which a global's initializer cannot hold
                isa<mlir_ts::CreateUnionInstanceOp>(op) || isa<mlir_ts::GetValueFromUnionOp>(op))
            {
                createAsGlobalConstructor = true;
            }
            else if (auto binaryOp = dyn_cast<mlir_ts::ArithmeticBinaryOp>(op);
                     binaryOp && isa<mlir_ts::StringType>(binaryOp.getResult().getType()))
            {
                // `"text" + 4` is a string concatenation, which allocates, even when every operand
                // is a constant (#469)
                createAsGlobalConstructor = true;
            }
            else if (auto castOp = dyn_cast<mlir_ts::CastOp>(op))
            {
                auto castType = castOp.getRes().getType();
                auto inType = castOp.getIn().getType();
                if (auto literalType = dyn_cast<mlir_ts::LiteralType>(inType))
                {
                    inType = literalType.getElementType();
                }

                if (isa<mlir_ts::ArrayType>(castType) || isa<mlir_ts::TupleType>(castType))
                {
                   createAsGlobalConstructor = true;
                }
                else if (isa<mlir_ts::StringType>(castType) && !isa<mlir_ts::StringType>(inType))
                {
                    // a number or a boolean made into a string allocates it (#469)
                    createAsGlobalConstructor = true;
                }
                else
                {
                    // see CreateUnionInstanceOp above: a cast to or from a tagged union lowers to
                    // one of those ops
                    MLIRTypeHelper mth(rewriter.getContext(), tsLlvmContext->compileOptions);
                    for (auto type : {castType, castOp.getIn().getType()})
                    {
                        if (auto unionType = dyn_cast<mlir_ts::UnionType>(type))
                        {
                            if (mth.isUnionTypeNeedsTag(castOp->getLoc(), unionType))
                            {
                                createAsGlobalConstructor = true;
                            }
                        }
                    }
                }
            }

            // TODO: error in try-catch
            // if it has memory side effect - can't be in global init.
            // auto iface = dyn_cast<MemoryEffectOpInterface>(op);
            // if (!iface || !iface.hasNoEffect())
            // {
            //     createAsGlobalConstructor = true;
            // }
        };

        globalOp.getInitializerRegion().walk(visitorAllOps);

        // a branch in the initializer (a conditional, an optional widened into a union) has left
        // it more than one block, which only a function can hold (#462)
        if (!globalOp.getInitializerRegion().empty() && !globalOp.getInitializerRegion().hasOneBlock())
        {
            createAsGlobalConstructor = true;
        }

        auto linkage = globalOp.getLinkage();
        LLVM::GlobalOp llvmGlobalOp;
        if (createAsGlobalConstructor)
        {
            // we can't have constant here as we need to initialize it in global construct
            llvmGlobalOp = lch.createUndefGlobalVarIfNew(
                globalOp.getSymName(), getTypeConverter()->convertType(globalOp.getType()),
                globalOp.getValueAttr(), false /*globalOp.getConstant()*/, linkage);

            auto name = globalOp.getSymName().str();
            name.append("__cctor");
            // this synthesized per-global constructor function is compiler-internal glue, not
            // user source - it must NOT be created with `loc` (the GlobalOp's own location):
            // globalOp can be a lazily-triggered vtable/global whose location is wherever the
            // triggering expression happened to be (e.g. a cast expression deep inside an
            // unrelated function's body), and giving the new FuncOp that same "live" source
            // location causes the debug-info pass to attach that enclosing function's
            // DISubprogram to __cctor too - LLVM's verifier then rejects the module
            // ("DISubprogram attached to more than one function") since a DISubprogram must
            // identify exactly one function. Same "no debug info for this synthetic function"
            // precedent as setDISubProgramTypesToFormOp's bodiless-declaration handling above.
            lch.createFunctionFromRegion(mlir::UnknownLoc::get(rewriter.getContext()), name, globalOp.getInitializerRegion(), globalOp.getSymName());

            {
                OpBuilder::InsertionGuard insertGuard(rewriter);
                
                auto parentModule = globalOp->getParentOfType<ModuleOp>();
                rewriter.setInsertionPointToStart(parentModule.getBody());

                lch.seekLastOp<mlir_ts::GlobalConstructorOp>(parentModule.getBody());

                rewriter.create<mlir_ts::GlobalConstructorOp>(loc, 
                    FlatSymbolRefAttr::get(rewriter.getContext(), StringRef(name)),
                    rewriter.getIndexAttr(tsLlvmContext->nextGlobalConstructorPriority++));
            }
        }
        else
        {
            llvmGlobalOp = lch.createGlobalVarIfNew(globalOp.getSymName(), getTypeConverter()->convertType(globalOp.getType()),
                                     globalOp.getValueAttr(), globalOp.getConstant(), globalOp.getInitializerRegion(),
                                     linkage);
        }

        // copy attributes over
        if (llvmGlobalOp)
        {
            auto attrs = globalOp->getAttrs();

            for (auto &attr : attrs)
            {
                if (attr.getName() == "export")
                {
                    llvmGlobalOp.setSection("export");
                    llvmGlobalOp.setPublic();
                }

                if (attr.getName() == "import")
                {
                    llvmGlobalOp.setSection("import");
                }

                if (attr.getName() == DLL_EXPORT)
                {
                    llvmGlobalOp.setSection(DLL_EXPORT);
                }

                if (attr.getName() == DLL_IMPORT)
                {
                    llvmGlobalOp.setSection(DLL_IMPORT);
                }
            }

            if (globalOp.getLinkage() == LLVM::Linkage::LinkonceODR || globalOp.getComdat().has_value())
            {
                auto comdat = globalOp.getComdat().has_value() 
                    ? static_cast<mlir::LLVM::comdat::Comdat>(globalOp.getComdat().value()) 
                    : mlir::LLVM::comdat::Comdat::Any;
                addComdat(llvmGlobalOp, rewriter, comdat);
            }

            if (tsLlvmContext->compileOptions.generateDebugInfo)
            {
                LocationHelper lh(rewriter.getContext());
                if (auto globalVarAttrFusedLoc = dyn_cast<mlir::FusedLocWith<LLVM::DIGlobalVariableAttr>>(loc))
                {
                    auto varInfo = globalVarAttrFusedLoc.getMetadata();
                    LLVM::DIExpressionAttr exprAttr;
                    llvmGlobalOp.setDbgExprsAttr(ArrayAttr::get(rewriter.getContext(), {LLVM::DIGlobalVariableExpressionAttr::get(rewriter.getContext(), varInfo, exprAttr)}));
                }
            }
        }

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

    static void addComdat(mlir::LLVM::GlobalOp &global,
                        mlir::ConversionPatternRewriter &rewriter, mlir::LLVM::comdat::Comdat comdat = mlir::LLVM::comdat::Comdat::Any) {
        auto module = global->getParentOfType<mlir::ModuleOp>();

        const char *comdatName = "__llvm_comdat";
        mlir::LLVM::ComdatOp comdatOp =
            module.lookupSymbol<mlir::LLVM::ComdatOp>(comdatName);
        if (!comdatOp) 
        {
            comdatOp = rewriter.create<mlir::LLVM::ComdatOp>(module.getLoc(), comdatName);
        }

        // TODO: add check if name already added
        mlir::OpBuilder::InsertionGuard guard(rewriter);
        rewriter.setInsertionPointToEnd(&comdatOp.getBody().back());
        auto selectorOp = rewriter.create<mlir::LLVM::ComdatSelectorOp>(
            comdatOp.getLoc(), global.getSymName(), comdat);
        global.setComdatAttr(mlir::SymbolRefAttr::get(
            rewriter.getContext(), comdatName,
            mlir::FlatSymbolRefAttr::get(selectorOp.getSymNameAttr())));
    }
};

struct GlobalResultOpLowering : public TsLlvmPattern<mlir_ts::GlobalResultOp>
{
    using TsLlvmPattern<mlir_ts::GlobalResultOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GlobalResultOp globalResultOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<mlir::func::ReturnOp>(globalResultOp, transformed.getResults());
        return success();
    }
};

struct AddressOfOpLowering : public TsLlvmPattern<mlir_ts::AddressOfOp>
{
    using TsLlvmPattern<mlir_ts::AddressOfOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AddressOfOp addressOfOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        LLVMCodeHelper lch(addressOfOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto actualType = addressOfOp.getType();
        if (isa<mlir_ts::OpaqueType>(actualType))
        {
            // load type from symbol
            auto module = addressOfOp->getParentOfType<mlir::ModuleOp>();
            assert(module);
            auto globalOp = module.lookupSymbol<LLVM::GlobalOp>(addressOfOp.getGlobalName());
            if (!globalOp)
            {
                LLVM_DEBUG(llvm::dbgs() << "\n!! NOT found symbol: " << addressOfOp.getGlobalName() << "\n";);
                assert(globalOp);
                return mlir::failure();
            }

            LLVM_DEBUG(llvm::dbgs() << "\n!! found symbol: " << globalOp << "\n";);
            actualType = mlir_ts::RefType::get(globalOp.getType());

            auto value = lch.getAddressOfGlobalVar(addressOfOp.getGlobalName(), tch.convertType(actualType),
                                                   addressOfOp.getOffset() ? addressOfOp.getOffset().value() : 0);

            mlir::Value castedValue =
                rewriter.create<LLVM::BitcastOp>(addressOfOp->getLoc(), tch.convertType(addressOfOp.getType()), value);

            rewriter.replaceOp(addressOfOp, castedValue);
        }
        else
        {
            auto value = lch.getAddressOfGlobalVar(addressOfOp.getGlobalName(), tch.convertType(actualType),
                                                   addressOfOp.getOffset() ? addressOfOp.getOffset().value() : 0);
            rewriter.replaceOp(addressOfOp, value);
        }
        return success();
    }
};

struct DefaultOpLowering : public TsLlvmPattern<mlir_ts::DefaultOp>
{
    using TsLlvmPattern<mlir_ts::DefaultOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DefaultOp defaultOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = defaultOp->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        DefaultLogic dl(defaultOp, rewriter, tch, loc, tsLlvmContext->compileOptions);

        auto valueType = defaultOp.getRes().getType();
        auto llvmValueType = tch.convertType(valueType);

        mlir::Value defaultValue = dl.getDefaultValueForOrUndef(llvmValueType);

        rewriter.replaceOp(defaultOp, {defaultValue});

        return success();
    }
};

struct OptionalOpLowering : public TsLlvmPattern<mlir_ts::OptionalOp>
{
    using TsLlvmPattern<mlir_ts::OptionalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::OptionalOp optionalOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = optionalOp->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(optionalOp, rewriter);

        auto boxedType = cast<mlir_ts::OptionalType>(optionalOp.getRes().getType()).getElementType();
        auto llvmBoxedType = tch.convertType(boxedType);
        auto llvmOptType = tch.convertType(optionalOp.getRes().getType());

        auto valueOrigType = optionalOp.getIn().getType();

        LLVM_DEBUG(llvm::dbgs() << "\n!! Optional : " << optionalOp.getIn() << " flag: " << optionalOp.getFlag() << "\n";);

        auto value = transformed.getIn();
        auto valueLLVMType = value.getType();

        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmOptType);

        // TODO: it should be tested by OP that value is equal to value in optional type
        if (valueLLVMType != llvmBoxedType)
        {
            LLVM_DEBUG(llvm::dbgs() << "\n!! Optional value types : " << valueLLVMType
                                    << " optional type: " << llvmBoxedType << "\n";);

            // cast value to box
            CastLogicHelper castLogic(optionalOp, rewriter, tch, tsLlvmContext->compileOptions);
            value = castLogic.cast(value, valueOrigType, valueLLVMType, boxedType, llvmBoxedType);
            if (!value)
            {
                return failure();
            }

            value = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmBoxedType, value);
        }

        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmOptType, structValue, value,
                                                                 MLIRHelper::getStructIndex(rewriter, OPTIONAL_VALUE_INDEX));

        rewriter.replaceOpWithNewOp<LLVM::InsertValueOp>(optionalOp, llvmOptType, structValue2, transformed.getFlag(),
                                                         MLIRHelper::getStructIndex(rewriter, OPTIONAL_HASVALUE_INDEX));

        return success();
    }
};

struct ValueOptionalOpLowering : public TsLlvmPattern<mlir_ts::OptionalValueOp>
{
    using TsLlvmPattern<mlir_ts::OptionalValueOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::OptionalValueOp createOptionalOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = createOptionalOp->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(createOptionalOp, rewriter);

        auto boxedType = cast<mlir_ts::OptionalType>(createOptionalOp.getRes().getType()).getElementType();
        auto llvmBoxedType = tch.convertType(boxedType);
        auto llvmOptType = tch.convertType(createOptionalOp.getRes().getType());

        auto valueOrigType = createOptionalOp.getIn().getType();

        LLVM_DEBUG(llvm::dbgs() << "\n!! CreateOptional : " << createOptionalOp.getIn() << "\n";);

        auto value = transformed.getIn();
        auto valueLLVMType = value.getType();

        auto structValue = rewriter.create<LLVM::UndefOp>(loc, llvmOptType);

        // TODO: it should be tested by OP that value is equal to value in optional type
        if (valueLLVMType != llvmBoxedType)
        {
            LLVM_DEBUG(llvm::dbgs() << "\n!! CreateOptional value types : " << valueLLVMType
                                    << " optional type: " << llvmBoxedType << "\n";);

            // cast value to box
            CastLogicHelper castLogic(createOptionalOp, rewriter, tch, tsLlvmContext->compileOptions);
            value = castLogic.cast(value, valueOrigType, valueLLVMType, boxedType, llvmBoxedType);
            if (!value)
            {
                return failure();
            }

            value = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmBoxedType, value);
        }

        auto structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmOptType, structValue, value,
                                                                 MLIRHelper::getStructIndex(rewriter, OPTIONAL_VALUE_INDEX));

        auto trueValue = clh.createI1ConstantOf(true);
        rewriter.replaceOpWithNewOp<LLVM::InsertValueOp>(createOptionalOp, llvmOptType, structValue2, trueValue,
                                                         MLIRHelper::getStructIndex(rewriter, OPTIONAL_HASVALUE_INDEX));

        return success();
    }
};

struct UndefOptionalOpLowering : public TsLlvmPattern<mlir_ts::OptionalUndefOp>
{
    using TsLlvmPattern<mlir_ts::OptionalUndefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::OptionalUndefOp undefOptionalOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = undefOptionalOp->getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(undefOptionalOp, rewriter);
        DefaultLogic dl(undefOptionalOp, rewriter, tch, loc, tsLlvmContext->compileOptions);

        auto boxedType = cast<mlir_ts::OptionalType>(undefOptionalOp.getRes().getType()).getElementType();
        auto llvmBoxedType = tch.convertType(boxedType);
        auto llvmOptType = tch.convertType(undefOptionalOp.getRes().getType());

        mlir::Value structValue = rewriter.create<LLVM::UndefOp>(loc, llvmOptType);
        auto structValue2 = structValue;

        // default value
        mlir::Value defaultValue = dl.getDefaultValueForOrUndef(llvmBoxedType);
        if (defaultValue)
        {
            structValue2 = rewriter.create<LLVM::InsertValueOp>(loc, llvmOptType, structValue, defaultValue,
                                                                MLIRHelper::getStructIndex(rewriter, OPTIONAL_VALUE_INDEX));
        }

        auto falseValue = clh.createI1ConstantOf(false);
        rewriter.replaceOpWithNewOp<LLVM::InsertValueOp>(undefOptionalOp, llvmOptType, structValue2, falseValue,
                                                         MLIRHelper::getStructIndex(rewriter, OPTIONAL_HASVALUE_INDEX));

        return success();
    }
};

struct HasValueOpLowering : public TsLlvmPattern<mlir_ts::HasValueOp>
{
    using TsLlvmPattern<mlir_ts::HasValueOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::HasValueOp hasValueOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = hasValueOp->getLoc();

        TypeHelper th(rewriter);

        rewriter.replaceOpWithNewOp<LLVM::ExtractValueOp>(hasValueOp, th.getLLVMBoolType(), transformed.getIn(),
                                                          MLIRHelper::getStructIndex(rewriter, OPTIONAL_HASVALUE_INDEX));

        return success();
    }
};

struct ValueOpLowering : public TsLlvmPattern<mlir_ts::ValueOp>
{
    using TsLlvmPattern<mlir_ts::ValueOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ValueOp valueOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = valueOp->getLoc();

        TypeConverterHelper tch(getTypeConverter());

        auto valueType = valueOp.getRes().getType();
        auto llvmValueType = tch.convertType(valueType);

        rewriter.replaceOpWithNewOp<LLVM::ExtractValueOp>(valueOp, llvmValueType, transformed.getIn(),
                                                          MLIRHelper::getStructIndex(rewriter, OPTIONAL_VALUE_INDEX));

        return success();
    }
};

struct ValueOrDefaultOpLowering : public TsLlvmPattern<mlir_ts::ValueOrDefaultOp>
{
    using TsLlvmPattern<mlir_ts::ValueOrDefaultOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ValueOrDefaultOp valueOrDefaultOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = valueOrDefaultOp->getLoc();

        valueOrDefaultOp->emitWarning("casting from optional (undefined) value");

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        DefaultLogic dl(valueOrDefaultOp, rewriter, tch, loc, tsLlvmContext->compileOptions);

        auto valueType = valueOrDefaultOp.getRes().getType();
        auto llvmValueType = tch.convertType(valueType);

        auto hasValue = rewriter.create<LLVM::ExtractValueOp>(loc, th.getLLVMBoolType(), transformed.getIn(),
                                                          MLIRHelper::getStructIndex(rewriter, OPTIONAL_HASVALUE_INDEX));
        auto value = rewriter.create<LLVM::ExtractValueOp>(loc, llvmValueType, transformed.getIn(),
                                                          MLIRHelper::getStructIndex(rewriter, OPTIONAL_VALUE_INDEX));

        mlir::Value defaultValue = dl.getDefaultValueForOrUndef(llvmValueType);

        rewriter.replaceOpWithNewOp<LLVM::SelectOp>(valueOrDefaultOp, hasValue, value, defaultValue);

        return success();
    }
};

struct LoadSaveValueLowering : public TsLlvmPattern<mlir_ts::LoadSaveOp>
{
    using TsLlvmPattern<mlir_ts::LoadSaveOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LoadSaveOp loadSaveOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = loadSaveOp->getLoc();

        auto value = rewriter.create<LLVM::LoadOp>(loc, transformed.getSrc().getType(), transformed.getSrc());
        rewriter.create<LLVM::StoreOp>(loc, value, transformed.getDst());

        rewriter.eraseOp(loadSaveOp);

        return success();
    }
};

struct CopyStructOpLowering : public TsLlvmPattern<mlir_ts::CopyStructOp>
{
    using TsLlvmPattern<mlir_ts::CopyStructOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CopyStructOp memoryCopyOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = memoryCopyOp->getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(memoryCopyOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(memoryCopyOp, rewriter);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto copyMemFuncOp = ch.getOrInsertFunction(
            llvmIndexType.getIntOrFloatBitWidth() == 32 
                ? "llvm.memcpy.p0.p0.i32" 
                : "llvm.memcpy.p0.p0.i64", 
            th.getFunctionType(th.getVoidType(), {th.getPtrType(), th.getPtrType(), llvmIndexType, th.getLLVMBoolType()}));

        mlir::SmallVector<mlir::Value, 4> values;
        values.push_back(transformed.getDst());
        values.push_back(transformed.getSrc());

        LLVM_DEBUG(llvm::dbgs() << "[CopyStructOp(1)] from type: " << memoryCopyOp.getSrc().getType() << " to type: " << memoryCopyOp.getDst().getType()
                                << "\n";);        

        assert(isa<LLVM::LLVMPointerType>(transformed.getSrc().getType()));
        auto srcStorageType = MLIRHelper::getElementTypeOrSelf(memoryCopyOp.getSrc().getType());
        auto srcSizeMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), srcStorageType);
        auto srcSize = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, srcSizeMLIR);

        assert(isa<LLVM::LLVMPointerType>(transformed.getDst().getType()));
        auto dstStorageType = MLIRHelper::getElementTypeOrSelf(memoryCopyOp.getDst().getType());
        auto dstSizeMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), dstStorageType);
        auto dstSize = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, dstSizeMLIR);

        auto cmpVal = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ult, srcSize, dstSize);
        auto minSize = rewriter.create<LLVM::SelectOp>(loc, cmpVal, srcSize, dstSize);

        values.push_back(minSize);

        auto immarg = clh.createI1ConstantOf(false);
        values.push_back(immarg);

        rewriter.create<LLVM::CallOp>(loc, copyMemFuncOp, values);

        // Notify the rewriter that this operation has been removed.
        rewriter.eraseOp(memoryCopyOp);

        return success();
    }
};

struct MemoryCopyOpLowering : public TsLlvmPattern<mlir_ts::MemoryCopyOp>
{
    using TsLlvmPattern<mlir_ts::MemoryCopyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::MemoryCopyOp memoryCopyOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = memoryCopyOp->getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(memoryCopyOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(memoryCopyOp, rewriter);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto copyMemFuncOp = ch.getOrInsertFunction(
            llvmIndexType.getIntOrFloatBitWidth() == 32 
                ? "llvm.memcpy.p0.p0.i32" 
                : "llvm.memcpy.p0.p0.i64", 
            th.getFunctionType(th.getVoidType(), {th.getPtrType(), th.getPtrType(), llvmIndexType, th.getLLVMBoolType()}));

        mlir::SmallVector<mlir::Value, 4> values;
        values.push_back(transformed.getDst());
        values.push_back(transformed.getSrc());

        auto countIndexType = transformed.getCount();

        values.push_back(countIndexType);

        auto immarg = clh.createI1ConstantOf(false);
        values.push_back(immarg);

        rewriter.create<LLVM::CallOp>(loc, copyMemFuncOp, values);

        // Notify the rewriter that this operation has been removed.
        rewriter.eraseOp(memoryCopyOp);

        return success();
    }
};

struct MemoryMoveOpLowering : public TsLlvmPattern<mlir_ts::MemoryMoveOp>
{
    using TsLlvmPattern<mlir_ts::MemoryMoveOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::MemoryMoveOp memoryMoveOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = memoryMoveOp->getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(memoryMoveOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(memoryMoveOp, rewriter);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto moveMemFuncOp = ch.getOrInsertFunction(
            llvmIndexType.getIntOrFloatBitWidth() == 32 
                ? "llvm.memmove.p0.p0.i32" 
                : "llvm.memmove.p0.p0.i64", 
            th.getFunctionType(th.getVoidType(), {th.getPtrType(), th.getPtrType(), llvmIndexType, th.getLLVMBoolType()}));

        mlir::SmallVector<mlir::Value, 4> values;
        values.push_back(transformed.getDst());
        values.push_back(transformed.getSrc());

        // the count is in bytes, as for MemoryCopyOp: the operands are plain pointers, so the element
        // size is only known to the caller. Scaling by the size of the source's type scaled by a
        // pointer's size, which moved half of every 16-byte element (e.g. a tuple) in shift/unshift/splice.
        values.push_back(transformed.getCount());

        auto immarg = clh.createI1ConstantOf(false);
        values.push_back(immarg);
        
        rewriter.create<LLVM::CallOp>(loc, moveMemFuncOp, values);

        // Notify the rewriter that this operation has been removed.
        rewriter.eraseOp(memoryMoveOp);

        return success();
    }
};

struct UnreachableOpLowering : public TsLlvmPattern<mlir_ts::UnreachableOp>
{
    using TsLlvmPattern<mlir_ts::UnreachableOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::UnreachableOp unreachableOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = unreachableOp.getLoc();
        CodeLogicHelper clh(unreachableOp, rewriter);

        auto unreachable = clh.FindUnreachableBlockOrCreate();

        rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(unreachableOp, unreachable);

        // no need for cut if this is last op in block
        auto terminator = rewriter.getInsertionBlock()->getTerminator();
        if (terminator != unreachableOp && terminator != unreachableOp->getNextNode())
        {
            clh.CutBlock();
        }

        return success();
    }
};

struct ThrowCallOpLowering : public TsLlvmPattern<mlir_ts::ThrowCallOp>
{
    using TsLlvmPattern<mlir_ts::ThrowCallOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThrowCallOp throwCallOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());

        ThrowLogic tl(throwCallOp, rewriter, tch, throwCallOp.getLoc(), tsLlvmContext->compileOptions);
        tl.logic(transformed.getException(), throwCallOp.getException().getType(), nullptr);

        rewriter.eraseOp(throwCallOp);

        return success();
    }
};

struct ThrowUnwindOpLowering : public TsLlvmPattern<mlir_ts::ThrowUnwindOp>
{
    using TsLlvmPattern<mlir_ts::ThrowUnwindOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThrowUnwindOp throwUnwindOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeConverterHelper tch(getTypeConverter());
        ThrowLogic tl(throwUnwindOp, rewriter, tch, throwUnwindOp.getLoc(), tsLlvmContext->compileOptions);
        tl.logic(transformed.getException(), throwUnwindOp.getException().getType(), throwUnwindOp.getUnwindDest());

        rewriter.eraseOp(throwUnwindOp);

        return success();
    }
};

namespace windows {

struct LandingPadOpLowering : public TsLlvmPattern<mlir_ts::LandingPadOp>
{
    using TsLlvmPattern<mlir_ts::LandingPadOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LandingPadOp landingPadOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        Location loc = landingPadOp.getLoc();

        // the funclet nesting TryOpLowering worked out, for Win32ExceptionPass: a call right
        // after the pad, ts.internal.eh_pad(this catch pad's id, id of the catch it is nested
        // in), 0 for none. The pass reads it and removes it.
        auto padId = landingPadOp->getAttrOfType<mlir::IntegerAttr>(EH_PAD_ID_ATTR_NAME);
        auto padParent = landingPadOp->getAttrOfType<mlir::IntegerAttr>(EH_PAD_PARENT_ATTR_NAME);
        auto tagPad = [&](LLVM::LandingpadOp newLandingPadOp) {
            if (!padId && !padParent)
            {
                return;
            }

            TypeHelper th(rewriter);
            LLVMCodeHelper ch(landingPadOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
            CodeLogicHelper clh(landingPadOp, rewriter);

            auto ehPadFunc = ch.getOrInsertFunction(
                "ts.internal.eh_pad", th.getFunctionType(th.getVoidType(), {th.getI32Type(), th.getI32Type()}));

            mlir::OpBuilder::InsertionGuard guard(rewriter);
            rewriter.setInsertionPointAfter(newLandingPadOp);
            rewriter.create<LLVM::CallOp>(loc, ehPadFunc,
                                          ValueRange{clh.createI32ConstantOf(padId ? padId.getInt() : 0),
                                                     clh.createI32ConstantOf(padParent ? padParent.getInt() : 0)});
        };

        if (!landingPadOp.getCleanup())
        {
            auto catch1 = transformed.getCatches().front();
            mlir::Type llvmLandingPadTy = getTypeConverter()->convertType(landingPadOp.getType());
            tagPad(rewriter.replaceOpWithNewOp<LLVM::LandingpadOp>(landingPadOp, llvmLandingPadTy, false, ValueRange{catch1}));
        }
        else
        {
            // cleanup marker contract: the operand here is the undef-array value built by
            // TryOpLowering, and being array-typed it becomes a *filter* clause on the LLVM
            // landingpad -- a deliberate marker (alongside the cleanup flag) identifying
            // cleanup pads across the LLVM-level passes. LandingPadFixPass rewrites any
            // filter-bearing landingpad to a canonical clause-less `landingpad { cleanup }`
            // and Win32ExceptionPass then replaces pads with SEH funclets -- both run before
            // any optimization, so the filter never reaches EH-table emission.
            auto cleanupMarker = transformed.getCatches().front();

            mlir::Type llvmLandingPadTy = getTypeConverter()->convertType(landingPadOp.getType());
            tagPad(rewriter.replaceOpWithNewOp<LLVM::LandingpadOp>(landingPadOp, llvmLandingPadTy, true,
                                                                   ValueRange{cleanupMarker}));
        }

        return success();
    }
};

struct CompareCatchTypeOpLowering : public TsLlvmPattern<mlir_ts::CompareCatchTypeOp>
{
    using TsLlvmPattern<mlir_ts::CompareCatchTypeOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CompareCatchTypeOp compareCatchTypeOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        CodeLogicHelper clh(compareCatchTypeOp, rewriter);

        auto trueVal = clh.createI1ConstantOf(true);
        rewriter.replaceOp(compareCatchTypeOp, ValueRange{trueVal});

        return success();
    }
};

struct BeginCatchOpLowering : public TsLlvmPattern<mlir_ts::BeginCatchOp>
{
    using TsLlvmPattern<mlir_ts::BeginCatchOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BeginCatchOp beginCatchOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = beginCatchOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(beginCatchOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(beginCatchOp, rewriter);

        auto i8PtrTy = th.getPtrType();

        // catches:extract
        auto loadedI8PtrValue = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getLandingPad(),
                                                                      MLIRHelper::getStructIndex(rewriter, 0));

        auto beginCatchFuncName = "__cxa_begin_catch";
        auto beginCatchFunc = ch.getOrInsertFunction(beginCatchFuncName, th.getFunctionType(i8PtrTy, {i8PtrTy}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(beginCatchOp, beginCatchFunc, ValueRange{loadedI8PtrValue});

        return success();
    }
};

struct SaveCatchVarOpLowering : public TsLlvmPattern<mlir_ts::SaveCatchVarOp>
{
    using TsLlvmPattern<mlir_ts::SaveCatchVarOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SaveCatchVarOp saveCatchVarOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = saveCatchVarOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(saveCatchVarOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto ptr = rewriter.create<mlir_ts::CastOp>(loc, th.getPtrType(), transformed.getVarStore());

        auto saveCatchFuncName = "ts.internal.save_catch_var";
        auto saveCatchFunc = ch.getOrInsertFunction(
            saveCatchFuncName,
            th.getFunctionType(th.getVoidType(), ArrayRef<mlir::Type>{getTypeConverter()->convertType(
                                                                          /*saveCatchVarOp*/transformed.getExceptionInfo().getType()),
                                                                      ptr.getType()}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(saveCatchVarOp, saveCatchFunc,
                                                  ValueRange{/*saveCatchVarOp*/transformed.getExceptionInfo(), ptr});

        return success();
    }
};

struct EndCatchOpLowering : public TsLlvmPattern<mlir_ts::EndCatchOp>
{
    using TsLlvmPattern<mlir_ts::EndCatchOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::EndCatchOp endCatchOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = endCatchOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(endCatchOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto endCatchFuncName = "__cxa_end_catch";
        auto endCatchFunc =
            ch.getOrInsertFunction(endCatchFuncName, th.getFunctionType(th.getVoidType(), ArrayRef<mlir::Type>{}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(endCatchOp, endCatchFunc, ValueRange{});

        return success();
    }
};

struct BeginCleanupOpLowering : public TsLlvmPattern<mlir_ts::BeginCleanupOp>
{
    using TsLlvmPattern<mlir_ts::BeginCleanupOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BeginCleanupOp beginCleanupOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.eraseOp(beginCleanupOp);

        return success();
    }
};

struct EndCleanupOpLowering : public TsLlvmPattern<mlir_ts::EndCleanupOp>
{
    using TsLlvmPattern<mlir_ts::EndCleanupOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::EndCleanupOp endCleanupOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = endCleanupOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(endCleanupOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(endCleanupOp, rewriter);

        auto endCatchFuncName = "__cxa_end_catch";
        if (!endCleanupOp.getUnwindDest().empty())
        {
            clh.Invoke(loc, [&](mlir::Block *continueBlock) {
                rewriter.replaceOpWithNewOp<LLVM::InvokeOp>(
                    endCleanupOp, mlir::TypeRange{},
                    ::mlir::FlatSymbolRefAttr::get(rewriter.getContext(), endCatchFuncName), ValueRange{},
                    continueBlock, ValueRange{}, endCleanupOp.getUnwindDest().front(), ValueRange{});
            });
            rewriter.setInsertionPointAfter(endCleanupOp);
        }
        else
        {
            auto endCatchFunc =
                ch.getOrInsertFunction(endCatchFuncName, th.getFunctionType(th.getVoidType(), ArrayRef<mlir::Type>{}));
            rewriter.replaceOpWithNewOp<LLVM::CallOp>(endCleanupOp, endCatchFunc, ValueRange{});
            rewriter.setInsertionPointAfter(endCleanupOp);
        }

        rewriter.create<LLVM::ResumeOp>(loc, transformed.getLandingPad());

        // no need for cut if this is last op in block
        auto terminator = rewriter.getInsertionBlock()->getTerminator();
        if (terminator != endCleanupOp && terminator != endCleanupOp->getNextNode())
        {
            clh.CutBlock();
        }

        // add resume

        return success();
    }
};

} // namespace windows

namespace linux {
struct LandingPadOpLowering : public TsLlvmPattern<mlir_ts::LandingPadOp>
{
    using TsLlvmPattern<mlir_ts::LandingPadOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LandingPadOp landingPadOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = landingPadOp.getLoc();

        TypeHelper th(rewriter);

        // every clause TryOpLowering attached, not just the first: a typed catch's catch-all
        // clause comes second (linuxHasCleanups, linuxTypedCatchChains), and dropping it left
        // the pad unentered for any other exception type
        mlir::Type llvmLandingPadTy = getTypeConverter()->convertType(landingPadOp.getType());
        rewriter.replaceOpWithNewOp<LLVM::LandingpadOp>(landingPadOp, llvmLandingPadTy, false, transformed.getCatches());

        return success();
    }
};

struct CompareCatchTypeOpLowering : public TsLlvmPattern<mlir_ts::CompareCatchTypeOp>
{
    using TsLlvmPattern<mlir_ts::CompareCatchTypeOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CompareCatchTypeOp compareCatchTypeOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = compareCatchTypeOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(compareCatchTypeOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(compareCatchTypeOp, rewriter);

        auto i8PtrTy = th.getPtrType();

        auto loadedI32Value = rewriter.create<LLVM::ExtractValueOp>(loc, th.getI32Type(), transformed.getLandingPad(),
                                                                    MLIRHelper::getStructIndex(rewriter, 1));

        auto typeIdFuncName = "llvm.eh.typeid.for.p0";
        auto typeIdFunc = ch.getOrInsertFunction(typeIdFuncName, th.getFunctionType(th.getI32Type(), {i8PtrTy}));

        auto callInfo =
            rewriter.create<LLVM::CallOp>(loc, typeIdFunc, ValueRange{transformed.getThrowTypeInfo()});
        auto typeIdValue = callInfo.getResult();

        // icmp
        auto cmpValue = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, loadedI32Value, typeIdValue);
        rewriter.replaceOp(compareCatchTypeOp, ValueRange{cmpValue});

        return success();
    }
};

struct BeginCatchOpLowering : public TsLlvmPattern<mlir_ts::BeginCatchOp>
{
    using TsLlvmPattern<mlir_ts::BeginCatchOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BeginCatchOp beginCatchOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = beginCatchOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(beginCatchOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(beginCatchOp, rewriter);

        auto i8PtrTy = th.getPtrType();

        // catches:extract
        auto loadedI8PtrValue = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getLandingPad(),
                                                                      MLIRHelper::getStructIndex(rewriter, 0));

        auto beginCatchFuncName = "__cxa_begin_catch";
        auto beginCatchFunc = ch.getOrInsertFunction(beginCatchFuncName, th.getFunctionType(i8PtrTy, {i8PtrTy}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(beginCatchOp, beginCatchFunc, ValueRange{loadedI8PtrValue});

        return success();
    }
};

struct SaveCatchVarOpLowering : public TsLlvmPattern<mlir_ts::SaveCatchVarOp>
{
    using TsLlvmPattern<mlir_ts::SaveCatchVarOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SaveCatchVarOp saveCatchVarOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = saveCatchVarOp.getLoc();

        TypeHelper th(rewriter);

        auto catchRefType = cast<mlir_ts::RefType>(saveCatchVarOp.getVarStore().getType());
        auto catchType = catchRefType.getElementType();
        auto llvmCatchType = getTypeConverter()->convertType(catchType);

        mlir::Value catchVal;
        if (isa<mlir_ts::AnyType>(catchType))
        {
            catchVal = boxCaughtException(saveCatchVarOp, transformed.getExceptionInfo(), rewriter);
        }
        else if (isa<mlir_ts::NumberType>(catchType))
        {
            catchVal = loadCaughtNumber(saveCatchVarOp, transformed.getExceptionInfo(), llvmCatchType, rewriter);
        }
        else if (!isa<LLVM::LLVMPointerType>(llvmCatchType))
        {
            auto ptrVal =
                rewriter.create<LLVM::BitcastOp>(loc, th.getPtrType(), transformed.getExceptionInfo());
            catchVal = rewriter.create<LLVM::LoadOp>(loc, llvmCatchType, ptrVal);
        }
        else
        {
            catchVal = rewriter.create<LLVM::BitcastOp>(loc, llvmCatchType, transformed.getExceptionInfo());
        }

        rewriter.replaceOpWithNewOp<mlir_ts::StoreOp>(saveCatchVarOp, catchVal, transformed.getVarStore());

        return success();
    }

    // A `catch (e: number)` also catches a thrown int (TryOpLowering lists its type_info as a
    // second clause), which has to be widened rather than read as a double.
    mlir::Value loadCaughtNumber(mlir_ts::SaveCatchVarOp saveCatchVarOp, mlir::Value exceptionInfo, mlir::Type llvmNumberType,
                                 ConversionPatternRewriter &rewriter) const
    {
        auto loc = saveCatchVarOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(saveCatchVarOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(saveCatchVarOp, rewriter);

        auto ptrTy = th.getPtrType();
        auto typeFunc = ch.getOrInsertFunction("__cxa_current_exception_type", th.getFunctionType(ptrTy, ArrayRef<mlir::Type>{}));
        auto typeInfo = rewriter.create<LLVM::CallOp>(loc, typeFunc, ValueRange{}).getResult();
        auto intTypeInfo = rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, ::typescript::linux::I32Type::typeName);
        auto isInt = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, typeInfo, intTypeInfo);

        return clh.conditionalExpressionLowering(
            loc, llvmNumberType, isInt,
            [&](OpBuilder &, Location) -> mlir::Value {
                auto intValue = rewriter.create<LLVM::LoadOp>(loc, th.getI32Type(), exceptionInfo);
                return rewriter.create<LLVM::SIToFPOp>(loc, llvmNumberType, intValue);
            },
            [&](OpBuilder &, Location) -> mlir::Value {
                auto uintTypeInfo = rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, ::typescript::linux::U32Type::typeName);
                auto isUInt = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, typeInfo, uintTypeInfo);
                return clh.conditionalExpressionLowering(
                    loc, llvmNumberType, isUInt,
                    [&](OpBuilder &, Location) -> mlir::Value {
                        auto uintValue = rewriter.create<LLVM::LoadOp>(loc, th.getI32Type(), exceptionInfo);
                        return rewriter.create<LLVM::UIToFPOp>(loc, llvmNumberType, uintValue);
                    },
                    [&](OpBuilder &, Location) -> mlir::Value {
                        auto floatTypeInfo = rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, ::typescript::linux::F32Type::typeName);
                        auto isFloat = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, typeInfo, floatTypeInfo);
                        return clh.conditionalExpressionLowering(
                            loc, llvmNumberType, isFloat,
                            [&](OpBuilder &, Location) -> mlir::Value {
                                auto floatValue = rewriter.create<LLVM::LoadOp>(loc, rewriter.getF32Type(), exceptionInfo);
                                return rewriter.create<LLVM::FPExtOp>(loc, llvmNumberType, floatValue);
                            },
                            [&](OpBuilder &, Location) -> mlir::Value {
                                return rewriter.create<LLVM::LoadOp>(loc, llvmNumberType, exceptionInfo);
                            });
                    });
            });
    }

    // The value an untyped `catch (e)` / `catch (e: any)` binds, boxed into an `any`. Such a
    // catch is a catch-all, so the exception's type is only known at run time: compare its
    // type_info with each type tslang throws and box the thrown object accordingly.
    // `exceptionInfo` is __cxa_begin_catch's result, which for a catch-all is the address of
    // the thrown object. (The Win64 equivalent is done by the CRT, through the copy thunks in
    // the `.PEAX` CatchableType records - see copyThunkPrefix in LLVMRTTIHelperVCWin32Const.h.)
    mlir::Value boxCaughtException(mlir_ts::SaveCatchVarOp saveCatchVarOp, mlir::Value exceptionInfo,
                                   ConversionPatternRewriter &rewriter) const
    {
        auto loc = saveCatchVarOp.getLoc();
        auto &compileOptions = tsLlvmContext->compileOptions;

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        LLVMCodeHelper ch(saveCatchVarOp, rewriter, getTypeConverter(), compileOptions);
        CodeLogicHelper clh(saveCatchVarOp, rewriter);

        auto ptrTy = th.getPtrType();
        auto ctx = rewriter.getContext();

        auto typeFuncName = "__cxa_current_exception_type";
        auto typeFunc = ch.getOrInsertFunction(typeFuncName, th.getFunctionType(ptrTy, ArrayRef<mlir::Type>{}));
        auto typeInfo = rewriter.create<LLVM::CallOp>(loc, typeFunc, ValueRange{}).getResult();

        auto isThrownType = [&](const char *typeInfoName) -> mlir::Value {
            auto typeInfoAddress = rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, typeInfoName);
            return rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, typeInfo, typeInfoAddress);
        };

        auto boxThrown = [&](mlir::Type type) -> mlir::Value {
            auto llvmType = tch.convertType(type);
            auto value = rewriter.create<LLVM::LoadOp>(loc, llvmType, exceptionInfo);
            TypeOfOpHelper toh(rewriter);
            auto boxed = rewriter.create<mlir_ts::BoxOp>(loc, mlir_ts::AnyType::get(ctx), value, toh.typeOfLogic(loc, type));
            return rewriter.create<mlir_ts::DialectCastOp>(loc, ptrTy, boxed);
        };

        // each type tslang throws, by the type_info a throw of it carries
        SmallVector<std::pair<std::string, mlir::Type>> candidates{
            {::typescript::linux::I32Type::typeName, mlir::IntegerType::get(ctx, 32, mlir::IntegerType::Signed)},
            {::typescript::linux::U32Type::typeName, mlir::IntegerType::get(ctx, 32, mlir::IntegerType::Unsigned)},
            {::typescript::linux::F64Type::typeName, mlir_ts::NumberType::get(ctx)},
            {::typescript::linux::F32Type::typeName, mlir::Float32Type::get(ctx)},
            {::typescript::linux::BoolType::typeName, mlir_ts::BooleanType::get(ctx)},
            {::typescript::linux::I64Type::typeName, mlir_ts::BigIntType::get(ctx)},
            {::typescript::linux::StringType::typeName, mlir_ts::StringType::get(ctx)},
            // a thrown `any` is already a box
            {::typescript::linux::I8PtrType::typeName, mlir_ts::AnyType::get(ctx)}};

        // A class needs its own type descriptor in the box - unboxing checks for a class tag,
        // and the descriptor carries the class's release routine - and the class may be one this
        // module has never heard of, thrown from another. So the thrower supplies the box: a
        // class is thrown as a pointer, and its __pointer_type_info carries a thunk that boxes
        // the instance (see linux::ClassType::boxThunkPrefix). Anything else - a foreign C++
        // exception - is boxed as a plain object.
        auto boxClass = [&]() -> mlir::Value {
            auto pointerTypeInfoVtable = rewriter.create<LLVM::GEPOp>(
                loc, ptrTy, ptrTy,
                rewriter.create<LLVM::AddressOfOp>(loc, ptrTy, ::typescript::linux::ClassType::pointerTypeInfoName),
                ArrayRef<LLVM::GEPArg>{2});
            auto typeInfoVtable = rewriter.create<LLVM::LoadOp>(loc, ptrTy, typeInfo);
            auto isPointer = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, typeInfoVtable, pointerTypeInfoVtable);
            return clh.conditionalExpressionLowering(
                loc, ptrTy, isPointer,
                [&](OpBuilder &, Location) -> mlir::Value {
                    auto pointerTypeInfoType = LLVM::LLVMStructType::getLiteral(
                        ctx, {ptrTy, ptrTy, th.getI32Type(), ptrTy, ptrTy}, false);
                    // only a type_info whose flags say so has the thunk field - see boxThunkFlag;
                    // the field is not read for any other, since it may lie past the object's end
                    auto flagsAddress = rewriter.create<LLVM::GEPOp>(
                        loc, ptrTy, pointerTypeInfoType, typeInfo,
                        ArrayRef<LLVM::GEPArg>{0, ::typescript::linux::ClassType::flagsField});
                    auto flags = rewriter.create<LLVM::LoadOp>(loc, th.getI32Type(), flagsAddress);
                    auto flagBit = rewriter.create<LLVM::ConstantOp>(
                        loc, th.getI32Type(), rewriter.getI32IntegerAttr(::typescript::linux::ClassType::boxThunkFlag));
                    auto flagged = rewriter.create<LLVM::ICmpOp>(
                        loc, LLVM::ICmpPredicate::ne, rewriter.create<LLVM::AndOp>(loc, flags, flagBit),
                        rewriter.create<LLVM::ConstantOp>(loc, th.getI32Type(), rewriter.getI32IntegerAttr(0)));
                    return clh.conditionalExpressionLowering(
                        loc, ptrTy, flagged,
                        [&](OpBuilder &, Location) -> mlir::Value {
                            auto thunkAddress = rewriter.create<LLVM::GEPOp>(
                                loc, ptrTy, pointerTypeInfoType, typeInfo,
                                ArrayRef<LLVM::GEPArg>{0, ::typescript::linux::ClassType::boxThunkField});
                            auto thunk = rewriter.create<LLVM::LoadOp>(loc, ptrTy, thunkAddress);
                            auto hasThunk = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, thunk,
                                                                          rewriter.create<LLVM::ZeroOp>(loc, ptrTy));
                            return clh.conditionalExpressionLowering(
                                loc, ptrTy, hasThunk,
                                [&](OpBuilder &, Location) -> mlir::Value {
                                    auto anyType = mlir_ts::AnyType::get(ctx);
                                    auto boxSlot = rewriter.create<mlir_ts::VariableOp>(
                                        loc, mlir_ts::RefType::get(anyType), mlir::Value(), rewriter.getBoolAttr(false),
                                        rewriter.getIndexAttr(0));
                                    auto boxSlotPtr = rewriter.create<mlir_ts::DialectCastOp>(loc, ptrTy, boxSlot);
                                    // void thunk(ref<any> dest, ref<class> src); exceptionInfo is the
                                    // address of the thrown pointer
                                    auto thunkType = LLVM::LLVMFunctionType::get(th.getVoidType(), {ptrTy, ptrTy});
                                    rewriter.create<LLVM::CallOp>(loc, thunkType, ValueRange{thunk, boxSlotPtr, exceptionInfo});
                                    auto boxed = rewriter.create<mlir_ts::LoadOp>(loc, anyType, boxSlot);
                                    return rewriter.create<mlir_ts::DialectCastOp>(loc, ptrTy, boxed);
                                },
                                [&](OpBuilder &, Location) { return boxThrown(mlir_ts::OpaqueType::get(ctx)); });
                        },
                        [&](OpBuilder &, Location) { return boxThrown(mlir_ts::OpaqueType::get(ctx)); });
                },
                [&](OpBuilder &, Location) { return boxThrown(mlir_ts::OpaqueType::get(ctx)); });
        };

        std::function<mlir::Value(size_t)> dispatch = [&](size_t index) -> mlir::Value {
            if (index == candidates.size())
            {
                return boxClass();
            }

            auto [typeInfoName, type] = candidates[index];
            return clh.conditionalExpressionLowering(
                loc, ptrTy, isThrownType(typeInfoName.c_str()),
                [&, type = type](OpBuilder &, Location) -> mlir::Value {
                    if (isa<mlir_ts::AnyType>(type))
                    {
                        return rewriter.create<LLVM::LoadOp>(loc, ptrTy, exceptionInfo);
                    }

                    return boxThrown(type);
                },
                [&, index = index](OpBuilder &, Location) { return dispatch(index + 1); });
        };

        return dispatch(0);
    }
};

struct EndCatchOpLowering : public TsLlvmPattern<mlir_ts::EndCatchOp>
{
    using TsLlvmPattern<mlir_ts::EndCatchOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::EndCatchOp endCatchOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = endCatchOp.getLoc();

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(endCatchOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto endCatchFuncName = "__cxa_end_catch";
        auto endCatchFunc =
            ch.getOrInsertFunction(endCatchFuncName, th.getFunctionType(th.getVoidType(), ArrayRef<mlir::Type>{}));

        rewriter.replaceOpWithNewOp<LLVM::CallOp>(endCatchOp, endCatchFunc, ValueRange{});

        return success();
    }
};

struct BeginCleanupOpLowering : public TsLlvmPattern<mlir_ts::BeginCleanupOp>
{
    using TsLlvmPattern<mlir_ts::BeginCleanupOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BeginCleanupOp beginCleanupOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.eraseOp(beginCleanupOp);

        return success();
    }
};

struct EndCleanupOpLowering : public TsLlvmPattern<mlir_ts::EndCleanupOp>
{
    using TsLlvmPattern<mlir_ts::EndCleanupOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::EndCleanupOp endCleanupOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = endCleanupOp.getLoc();

        CodeLogicHelper clh(endCleanupOp, rewriter);

        // getUnwindDest() is deliberately not read here, unlike the windows lowering above. A
        // landingpad is only reachable as an invoke's unwind destination, so there is no way to
        // hand the exception to another pad from here - resume is the only exit. TryOpLowering
        // knows this and never gives an EndCleanupOp an unwind destination on this path: a
        // cleanup that does have an enclosing pad to reach is lowered to a catch-all pad and a
        // rethrow instead (linuxCleanupOnlyChainsToParent).
        rewriter.replaceOpWithNewOp<LLVM::ResumeOp>(endCleanupOp, transformed.getLandingPad());

        auto terminator = rewriter.getInsertionBlock()->getTerminator();
        if (terminator != endCleanupOp && terminator != endCleanupOp->getNextNode())
        {
            clh.CutBlock();
        }

        // add resume

        return success();
    }
};

} // namespace linux

struct VTableOffsetRefOpLowering : public TsLlvmPattern<mlir_ts::VTableOffsetRefOp>
{
    using TsLlvmPattern<mlir_ts::VTableOffsetRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::VTableOffsetRefOp vtableOffsetRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = vtableOffsetRefOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(vtableOffsetRefOp, rewriter);

        auto ptrToArrOfPtrs = rewriter.create<mlir_ts::CastOp>(loc, th.getPtrType(), transformed.getVtable());

        auto index = clh.createI32ConstantOf(vtableOffsetRefOp.getIndex());
        auto methodOrInterfacePtrPtr =
            rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), th.getPtrType(), ptrToArrOfPtrs, ValueRange{index});
        auto methodOrInterfacePtr = rewriter.create<LLVM::LoadOp>(loc, th.getPtrType(), methodOrInterfacePtrPtr);

        rewriter.replaceOp(vtableOffsetRefOp, ValueRange{methodOrInterfacePtr});

        return success();
    }
};

struct VirtualSymbolRefOpLowering : public TsLlvmPattern<mlir_ts::VirtualSymbolRefOp>
{
    using TsLlvmPattern<mlir_ts::VirtualSymbolRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::VirtualSymbolRefOp virtualSymbolRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        assert(virtualSymbolRefOp.getIndex() != -1);

        Location loc = virtualSymbolRefOp.getLoc();

        TypeHelper th(rewriter);

        auto methodOrFieldPtr = rewriter.create<mlir_ts::VTableOffsetRefOp>(
            loc, th.getPtrType(), transformed.getVtable(), virtualSymbolRefOp.getIndex());

        if (auto funcType = dyn_cast<mlir_ts::FunctionType>(virtualSymbolRefOp.getType()))
        {
            auto methodTyped = rewriter.create<mlir_ts::CastOp>(loc, funcType, methodOrFieldPtr);
            rewriter.replaceOp(virtualSymbolRefOp, ValueRange{methodTyped});
        }
        else if (auto fieldType = dyn_cast<mlir_ts::RefType>(virtualSymbolRefOp.getType()))
        {
            auto fieldTyped = rewriter.create<mlir_ts::CastOp>(loc, fieldType, methodOrFieldPtr);
            rewriter.replaceOp(virtualSymbolRefOp, ValueRange{fieldTyped});
        }
        else
        {
            // every VirtualSymbolRefOp construction site (traced across the whole
            // codebase) only ever passes an explicit RefType or a FunctionType-typed
            // FunctionEntry/MethodInfo field, despite the op's TableGen result-type
            // constraint (TypeScript_AnyRefOrCallable) technically allowing more.
            virtualSymbolRefOp->emitError("unsupported virtual symbol reference type");
            return failure();
        }

        return success();
    }
};

struct ThisVirtualSymbolRefOpLowering : public TsLlvmPattern<mlir_ts::ThisVirtualSymbolRefOp>
{
    using TsLlvmPattern<mlir_ts::ThisVirtualSymbolRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ThisVirtualSymbolRefOp thisVirtualSymbolRefOp,
                                  Adaptor transformed, ConversionPatternRewriter &rewriter) const final
    {
        

        assert(thisVirtualSymbolRefOp.getIndex() != -1);

        Location loc = thisVirtualSymbolRefOp.getLoc();

        TypeHelper th(rewriter);

        auto methodPtr = rewriter.create<mlir_ts::VTableOffsetRefOp>(loc, th.getPtrType(), transformed.getVtable(),
                                                                     thisVirtualSymbolRefOp.getIndex());
        // auto methodTyped = rewriter.create<mlir_ts::CastOp>(loc, thisVirtualSymbolRefOp.getType(), methodPtr);

        if (auto boundFunc = dyn_cast<mlir_ts::BoundFunctionType>(thisVirtualSymbolRefOp.getType()))
        {
            auto thisOpaque = rewriter.create<mlir_ts::CastOp>(loc, mlir_ts::OpaqueType::get(rewriter.getContext()),
                                                               transformed.getThisVal());
            auto methodTyped = rewriter.create<mlir_ts::CastOp>(
                loc, mlir_ts::FunctionType::get(rewriter.getContext(), boundFunc.getInputs(), boundFunc.getResults()),
                methodPtr);
            auto boundFuncVal =
                rewriter.create<mlir_ts::CreateBoundFunctionOp>(loc, boundFunc, thisOpaque, methodTyped);
            rewriter.replaceOp(thisVirtualSymbolRefOp, ValueRange{boundFuncVal});
        }
        else
        {
            // the sole construction site always passes getBoundFunctionType(...)'s
            // (strongly BoundFunctionType-typed) result, despite the op's TableGen
            // result-type constraint technically allowing more.
            thisVirtualSymbolRefOp->emitError("unsupported this-virtual symbol reference type");
            return failure();
        }

        return success();
    }
};

struct InterfaceSymbolRefOpLowering : public TsLlvmPattern<mlir_ts::InterfaceSymbolRefOp>
{
    using TsLlvmPattern<mlir_ts::InterfaceSymbolRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::InterfaceSymbolRefOp interfaceSymbolRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        assert(interfaceSymbolRefOp.getIndex() != -1);

        Location loc = interfaceSymbolRefOp.getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(interfaceSymbolRefOp, rewriter);
        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto fieldLLVMTypeRef = tch.convertType(interfaceSymbolRefOp.getType());

        auto isOptional = interfaceSymbolRefOp.getOptional().has_value() && interfaceSymbolRefOp.getOptional().value();

        auto vtable = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getInterfaceVal(),
                                                            MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));
        auto thisVal = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getInterfaceVal(),
                                                             MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        // the vtable starts with the implementer's `.instanceOf` - see INTERFACE_VTABLE_HEADER_SLOTS
        auto methodOrFieldPtr = rewriter.create<mlir_ts::VTableOffsetRefOp>(
            loc, th.getPtrType(), vtable, interfaceSymbolRefOp.getIndex() + INTERFACE_VTABLE_HEADER_SLOTS);

        if (auto boundFunc = dyn_cast<mlir_ts::BoundFunctionType>(interfaceSymbolRefOp.getType()))
        {
            mlir::Value thisValEffective = thisVal;
            if (isOptional)
            {
                // an optional (`?`) interface method the object literal doesn't provide
                // is patched with a -1 sentinel in the vtable slot (see
                // mlirGenObjectVirtualTableDefinitionForInterface's missing-method
                // branch), same convention as the FIELD case below. Select a null
                // `this` when the slot is that sentinel, so the resulting bound_func
                // has a null `this` pointer - a real bound method's `this` is never
                // null - giving a later undefined-comparison something concrete to
                // check instead of always reading as "present". A branchless
                // LLVM::SelectOp is used here rather than CodeLogicHelper's
                // conditionalExpressionLowering (block-splitting control flow) since
                // this pattern - used successfully elsewhere in this file, e.g.
                // ValueOrDefaultOpLowering - is simpler and carries no risk of a
                // malformed/dangling basic block.
                // Both sides take the target width from compileOptions, not from the type converter's data layout, which is not yet target-derived.
                auto intPtrType = rewriter.getIntegerType(tsLlvmContext->compileOptions.sizeBits());
                auto negative1 = rewriter.create<LLVM::ConstantOp>(loc, intPtrType, rewriter.getIntegerAttr(intPtrType, -1));
                auto methodOrFieldIntPtrValue = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, methodOrFieldPtr);
                auto isMissing =
                    rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, methodOrFieldIntPtrValue, negative1);
                auto nullThisVal = rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType());
                thisValEffective = rewriter.create<LLVM::SelectOp>(loc, isMissing, nullThisVal, thisVal);
            }

            auto thisOpaque =
                rewriter.create<mlir_ts::CastOp>(loc, mlir_ts::OpaqueType::get(rewriter.getContext()), thisValEffective);
            auto methodTypedPtr = rewriter.create<mlir_ts::CastOp>(
                loc, mlir_ts::FunctionType::get(rewriter.getContext(), boundFunc.getInputs(), boundFunc.getResults()),
                methodOrFieldPtr);
            auto boundFuncVal =
                rewriter.create<mlir_ts::CreateBoundFunctionOp>(loc, boundFunc, thisOpaque, methodTypedPtr);
            rewriter.replaceOp(interfaceSymbolRefOp, ValueRange{boundFuncVal});
        }
        else
        {
            auto calcFieldTotalAddrFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                // BoundRef
                auto p1 = rewriter.create<LLVM::PtrToIntOp>(loc, llvmIndexType, thisVal);
                auto p2 = rewriter.create<LLVM::PtrToIntOp>(loc, llvmIndexType, methodOrFieldPtr);
                auto padded = rewriter.create<LLVM::AddOp>(loc, llvmIndexType, p1, p2);
                auto typedPtr = rewriter.create<LLVM::IntToPtrOp>(loc, fieldLLVMTypeRef, padded.getResult());

                // no need to BoundRef
                // auto boundRefVal = rewriter.create<mlir_ts::CreateBoundRefOp>(loc, thisVal, typedPtr);
                return typedPtr;
            };

            mlir::Value fieldAddr;
            if (isOptional)
            {
                auto nullAddrFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                    auto typedPtr = rewriter.create<LLVM::ZeroOp>(loc, fieldLLVMTypeRef);
                    return typedPtr;
                };

                // Both sides take the target width from compileOptions, not from the type converter's data layout, which is not yet target-derived.
                auto sizeBits = tsLlvmContext->compileOptions.sizeBits();
                auto intPtrType = rewriter.getIntegerType(sizeBits);
                auto negative1 = rewriter.create<LLVM::ConstantOp>(loc, intPtrType, rewriter.getIntegerAttr(intPtrType, -1));
                auto methodOrFieldIntPtrValue = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, methodOrFieldPtr);
                auto condVal =
                    rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, methodOrFieldIntPtrValue, negative1);

                // a slot tagged INTERFACE_OPTIONAL_STORAGE_TAG: the field is stored as optional<T> (a class's `v?: T`),
                // present only when its flag is set. A write through the interface sets the flag (clears it for
                // `= undefined`), marked by MLIRGen with INTERFACE_OPTIONAL_WRITE_ATTR.
                auto writeAttr = interfaceSymbolRefOp->getAttrOfType<mlir::BoolAttr>(INTERFACE_OPTIONAL_WRITE_ATTR);
                auto storedAsOptionalAddrFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                    auto tag = rewriter.create<LLVM::ConstantOp>(
                        loc, intPtrType, rewriter.getIntegerAttr(intPtrType, INTERFACE_OPTIONAL_STORAGE_TAG(sizeBits)));
                    auto offset = rewriter.create<LLVM::SubOp>(loc, intPtrType, methodOrFieldIntPtrValue, tag);
                    auto thisInt = rewriter.create<LLVM::PtrToIntOp>(loc, intPtrType, thisVal);
                    auto addrInt = rewriter.create<LLVM::AddOp>(loc, intPtrType, thisInt, offset);
                    mlir::Value addr = rewriter.create<LLVM::IntToPtrOp>(loc, fieldLLVMTypeRef, addrInt.getResult());

                    auto valueType = mlir::cast<mlir_ts::RefType>(interfaceSymbolRefOp.getType()).getElementType();
                    auto optionalLLVMType = tch.convertType(mlir_ts::OptionalType::get(valueType));
                    auto flagPtr = rewriter.create<LLVM::GEPOp>(loc, th.getPtrType(), optionalLLVMType, addr,
                                                                ArrayRef<LLVM::GEPArg>{0, OPTIONAL_HASVALUE_INDEX});
                    if (writeAttr)
                    {
                        auto flagValue = rewriter.create<LLVM::ConstantOp>(loc, rewriter.getI1Type(),
                                                                           rewriter.getBoolAttr(writeAttr.getValue()));
                        rewriter.create<LLVM::StoreOp>(loc, flagValue, flagPtr);
                        return addr;
                    }

                    auto hasValue = rewriter.create<LLVM::LoadOp>(loc, rewriter.getI1Type(), flagPtr);
                    auto nullAddr = rewriter.create<LLVM::ZeroOp>(loc, fieldLLVMTypeRef);
                    return rewriter.create<LLVM::SelectOp>(loc, hasValue, addr, nullAddr);
                };

                auto presentAddrFunc = [&](OpBuilder &builder, Location location) -> mlir::Value {
                    auto tag = rewriter.create<LLVM::ConstantOp>(
                        loc, intPtrType, rewriter.getIntegerAttr(intPtrType, INTERFACE_OPTIONAL_STORAGE_TAG(sizeBits)));
                    auto tagBit = rewriter.create<LLVM::AndOp>(loc, intPtrType, methodOrFieldIntPtrValue, tag);
                    auto zero = rewriter.create<LLVM::ConstantOp>(loc, intPtrType, rewriter.getIntegerAttr(intPtrType, 0));
                    auto isStoredAsOptional = rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, tagBit, zero);
                    return clh.conditionalExpressionLowering(loc, fieldLLVMTypeRef, isStoredAsOptional,
                                                             storedAsOptionalAddrFunc, calcFieldTotalAddrFunc);
                };

                auto result =
                    clh.conditionalExpressionLowering(loc, fieldLLVMTypeRef, condVal, nullAddrFunc, presentAddrFunc);
                fieldAddr = result;
            }
            else
            {
                auto typedPtr = calcFieldTotalAddrFunc(rewriter, loc);
                fieldAddr = typedPtr;
            }

            rewriter.replaceOp(interfaceSymbolRefOp, ValueRange{fieldAddr});
        }

        return success();
    }
};

struct NewInterfaceOpLowering : public TsLlvmPattern<mlir_ts::NewInterfaceOp>
{
    using TsLlvmPattern<mlir_ts::NewInterfaceOp>::TsLlvmPattern;

    // The runtime type tag for whatever `this` points at, to go in INTERFACE_TYPE_INDEX.
    //
    // Null when that type owns no heap memory - which covers `null` and `undefined` cast to
    // an interface, where `this` is a null pointer and there would be nothing to release
    // anyway. A null tag states that positively, the same way a null descriptor slot does.
    //
    // The descriptor this returns is keyed by the concrete type, not by the `typeof` name, so
    // two object literals of different shapes get their own records rather than sharing the
    // one every "object" would otherwise map to.
    mlir::Value getTypeTag(mlir_ts::NewInterfaceOp newInterfaceOp, ConversionPatternRewriter &rewriter) const
    {
        TypeHelper th(rewriter);
        auto loc = newInterfaceOp.getLoc();
        auto thisType = newInterfaceOp.getThisVal().getType();

        MLIRTypeHelper mth(rewriter.getContext(), tsLlvmContext->compileOptions);
        if (!mth.ownsHeapMemory(loc, thisType))
        {
            return rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType());
        }

        TypeOfOpHelper toh(rewriter);
        auto name = toh.typeOfAsString(thisType);
        if (name.empty())
        {
            // an interface over a type with no `typeof` name: nothing to key a descriptor on,
            // so it goes untracked and leaks rather than guessing at a record
            return rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType());
        }

        // generated first: the descriptor's initializer takes their addresses
        OwnershipRoutineLogic orl(newInterfaceOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        auto releaseRoutineName = orl.getOrCreateReleaseRoutine(thisType);
        // under own nothing retains: see TypeDescriptorOpLowering
        auto retainRoutineName = tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn
                                     ? std::string()
                                     : orl.getOrCreateRetainRoutine(thisType);

        LLVMCodeHelper ch(newInterfaceOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        return ch.getOrCreateTypeDescriptorName(thisType, name, TypeOfOpHelper::typeKindFromName(name),
                                                releaseRoutineName, retainRoutineName);
    }

    LogicalResult matchAndRewrite(mlir_ts::NewInterfaceOp newInterfaceOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = newInterfaceOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(newInterfaceOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto llvmInterfaceType = tch.convertType(newInterfaceOp.getType());

        auto structVal = rewriter.create<LLVM::UndefOp>(loc, llvmInterfaceType);
        auto structVal2 = rewriter.create<LLVM::InsertValueOp>(
            loc, structVal, transformed.getInterfaceVTable(), MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));
        auto structVal3 = rewriter.create<LLVM::InsertValueOp>(loc, structVal2, transformed.getThisVal(),
                                                               MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        // Every interface value in the program is built here - a cast from a class, from an
        // object literal, and even `null`/`undefined` as an interface all end up at this op
        // (CastLogicHelper) - which is what makes the type tag safe to rely on: there is no
        // other way to produce an interface value with the slot left undefined.
        auto structVal4 = rewriter.create<LLVM::InsertValueOp>(loc, structVal3, getTypeTag(newInterfaceOp, rewriter),
                                                               MLIRHelper::getStructIndex(rewriter, INTERFACE_TYPE_INDEX));

        rewriter.replaceOp(newInterfaceOp, ValueRange{structVal4});

        return success();
    }
};

struct ExtractInterfaceThisOpLowering : public TsLlvmPattern<mlir_ts::ExtractInterfaceThisOp>
{
    using TsLlvmPattern<mlir_ts::ExtractInterfaceThisOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ExtractInterfaceThisOp extractInterfaceThisOp,
                                  Adaptor transformed, ConversionPatternRewriter &rewriter) const final
    {
        

        // TODO: hack, if NullOp, return null

        Location loc = extractInterfaceThisOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(extractInterfaceThisOp, rewriter);

        LLVM_DEBUG(llvm::dbgs() << "\n!! ExtractInterfaceThis from: " << extractInterfaceThisOp.getInterfaceVal() << "\n");

        auto vtable = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getInterfaceVal(),
                                                            MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        rewriter.replaceOp(extractInterfaceThisOp, ValueRange{vtable});

        return success();
    }
};

struct ExtractInterfaceVTableOpLowering : public TsLlvmPattern<mlir_ts::ExtractInterfaceVTableOp>
{
    using TsLlvmPattern<mlir_ts::ExtractInterfaceVTableOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::ExtractInterfaceVTableOp extractInterfaceVTableOp,
                                  Adaptor transformed, ConversionPatternRewriter &rewriter) const final
    {
        

        // TODO: hack, if NullOp, return null

        Location loc = extractInterfaceVTableOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(extractInterfaceVTableOp, rewriter);

        LLVM_DEBUG(llvm::dbgs() << "\n!! ExtractInterfaceVTable from: " << transformed.getInterfaceVal()
                                << "\n");

        auto vtable = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getInterfaceVal(),
                                                            MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));

        rewriter.replaceOp(extractInterfaceVTableOp, ValueRange{vtable});

        return success();
    }
};

struct LoadBoundRefOpLowering : public TsLlvmPattern<mlir_ts::LoadBoundRefOp>
{
    using TsLlvmPattern<mlir_ts::LoadBoundRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LoadBoundRefOp loadBoundRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = loadBoundRefOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(loadBoundRefOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto boundRefType = cast<mlir_ts::BoundRefType>(loadBoundRefOp.getReference().getType());

        auto llvmType = tch.convertType(boundRefType.getElementType());
        auto ptrType = th.getPtrType();

        auto thisVal = rewriter.create<LLVM::ExtractValueOp>(loc, ptrType, transformed.getReference(),
                                                             MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));
        auto valueRefVal = rewriter.create<LLVM::ExtractValueOp>(loc, ptrType, transformed.getReference(),
                                                                 MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));

        // atomic access attrs
        auto alignment = 0;
        auto isVolatile = false;
        auto isNonTemporal = false;
        auto isInvariant = false;
        auto ordering = LLVM::AtomicOrdering::not_atomic;
        StringRef syncscope = {};

        if (auto atomicAttr = loadBoundRefOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
        {
            if (atomicAttr.getValue()) 
            {
                auto orderingAttr = loadBoundRefOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                auto syncScopeAttr = loadBoundRefOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                if (orderingAttr && syncScopeAttr)
                {
                    ordering = (LLVM::AtomicOrdering) orderingAttr.getValue().getZExtValue();
                    if (ordering == LLVM::AtomicOrdering::release || ordering == LLVM::AtomicOrdering::acq_rel)
                    {
                        ordering = LLVM::AtomicOrdering::acquire;
                    }

                    syncscope = syncScopeAttr.getValue();
                    LLVMTypeConverterHelper ltch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));
                    alignment = ltch.getTypeAlignSizeInBits(llvmType);
                }
            }
        }

        if (auto volatileAttr = loadBoundRefOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
        {
            isVolatile = volatileAttr.getValue();
        }

        mlir::Value loadedValue = rewriter.create<LLVM::LoadOp>(loc, llvmType, valueRefVal, alignment, isVolatile, isNonTemporal, isInvariant, /*isInvariantGroup*/ false, ordering, syncscope);

        if (auto funcType = dyn_cast<mlir_ts::FunctionType>(boundRefType.getElementType()))
        {
            mlir::Value boundMethodValue =
                rewriter.create<mlir_ts::CreateBoundFunctionOp>(loc, loadBoundRefOp.getType(), thisVal, loadedValue);

            LLVM_DEBUG(llvm::dbgs() << "\n!! LoadOp Bound Ref: LLVM Type :" << tch.convertType(loadBoundRefOp.getType())
                                    << "\n";);

            rewriter.replaceOp(loadBoundRefOp, boundMethodValue);
        }
        else
        {
            rewriter.replaceOp(loadBoundRefOp, loadedValue);
        }

        return success();
    }
};

struct StoreBoundRefOpLowering : public TsLlvmPattern<mlir_ts::StoreBoundRefOp>
{
    using TsLlvmPattern<mlir_ts::StoreBoundRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::StoreBoundRefOp storeBoundRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        auto loc = storeBoundRefOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(storeBoundRefOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto boundRefType = cast<mlir_ts::BoundRefType>(storeBoundRefOp.getReference().getType());

        auto llvmType = tch.convertType(boundRefType.getElementType());
        auto llvmRefType = th.getPtrType();

        auto valueRefVal = rewriter.create<LLVM::ExtractValueOp>(loc, llvmRefType, transformed.getReference(),
                                                                 MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));

        // atomic attributes
        auto alignment = 0;
        auto isVolatile = false;
        auto isNonTemporal = false;
        auto ordering = LLVM::AtomicOrdering::not_atomic;
        StringRef syncscope = {};

        if (auto atomicAttr = storeBoundRefOp->getAttrOfType<mlir::BoolAttr>(ATOMIC_ATTR_NAME))
        {
            if (atomicAttr.getValue()) 
            {
                auto orderingAttr = storeBoundRefOp->getAttrOfType<mlir::IntegerAttr>(ORDERING_ATTR_NAME);
                auto syncScopeAttr = storeBoundRefOp->getAttrOfType<mlir::StringAttr>(SYNCSCOPE_ATTR_NAME);
                if (orderingAttr && syncScopeAttr)
                {
                    ordering = (LLVM::AtomicOrdering) orderingAttr.getValue().getZExtValue();
                    if (ordering == LLVM::AtomicOrdering::acquire || ordering == LLVM::AtomicOrdering::acq_rel)
                    {
                        ordering = LLVM::AtomicOrdering::release;
                    }

                    syncscope = syncScopeAttr.getValue();
                    LLVMTypeConverterHelper ltch(static_cast<const LLVMTypeConverter *>(getTypeConverter()));
                    alignment = ltch.getTypeAlignSizeInBits(transformed.getValue().getType());
                }
            }
        }

        if (auto volatileAttr = storeBoundRefOp->getAttrOfType<mlir::BoolAttr>(VOLATILE_ATTR_NAME))
        {
            isVolatile = volatileAttr.getValue();
        } 

        rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeBoundRefOp, transformed.getValue(), valueRefVal, alignment, isVolatile, isNonTemporal, /*isInvariantGroup*/ false, ordering, syncscope);
        return success();
    }
};

struct CreateBoundRefOpLowering : public TsLlvmPattern<mlir_ts::CreateBoundRefOp>
{
    using TsLlvmPattern<mlir_ts::CreateBoundRefOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CreateBoundRefOp createBoundRefOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = createBoundRefOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(createBoundRefOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        auto llvmBoundRefType = tch.convertType(createBoundRefOp.getType());

        auto structVal = rewriter.create<mlir_ts::UndefOp>(loc, llvmBoundRefType);
        auto structVal2 = rewriter.create<LLVM::InsertValueOp>(loc, structVal, transformed.getValueRef(),
                                                               MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));
        auto structVal3 = rewriter.create<LLVM::InsertValueOp>(loc, structVal2, transformed.getThisVal(),
                                                               MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        rewriter.replaceOp(createBoundRefOp, ValueRange{structVal3});

        return success();
    }
};

struct CreateBoundFunctionOpLowering : public TsLlvmPattern<mlir_ts::CreateBoundFunctionOp>
{
    using TsLlvmPattern<mlir_ts::CreateBoundFunctionOp>::TsLlvmPattern;

    // The runtime type tag of the capture box, for CLOSURE_TYPE_INDEX.
    //
    // Null unless MLIRGen marked this closure as owning its `this` - a bound method's receiver
    // belongs to whoever holds the object, and giving the closure a tag for it would have `obj.m`
    // take a reference to `obj` and hand it back when the bound value dies.
    //
    // The box arrives as a `ref` to its tuple, which owns nothing by itself (a reference into
    // storage is not ownership). What has to be released is the block, so the tag names the
    // ObjectType over that tuple: its routine decrefs, releases whatever the box holds, and
    // frees - which is exactly what a capture box needs.
    mlir::Value getCaptureTypeTag(mlir_ts::CreateBoundFunctionOp createBoundFunctionOp,
                                  ConversionPatternRewriter &rewriter) const
    {
        TypeHelper th(rewriter);
        auto loc = createBoundFunctionOp.getLoc();
        auto nullTag = [&]() -> mlir::Value { return rewriter.create<LLVM::ZeroOp>(loc, th.getPtrType()); };

        if (!createBoundFunctionOp->hasAttr(OWNS_CAPTURE_ATTR_NAME))
        {
            return nullTag();
        }

        auto captureRefType = dyn_cast<mlir_ts::RefType>(createBoundFunctionOp.getThisVal().getType());
        if (!captureRefType || !isa<mlir_ts::TupleType>(captureRefType.getElementType()))
        {
            return nullTag();
        }

        auto boxType = mlir_ts::ObjectType::get(captureRefType.getElementType());

        TypeOfOpHelper toh(rewriter);
        auto name = toh.typeOfAsString(boxType);
        if (name.empty())
        {
            return nullTag();
        }

        // generated first: the descriptor's initializer takes their addresses.
        //
        // The box has routines of its own rather than an object's, because a captured
        // variable's field holds the address of that variable's *cell* - a heap block the box
        // co-owns - and a RefType field owns nothing anywhere else in the compiler. Keyed by
        // the capture's `ref<tuple<..>>` for the same reason, so neither the routines nor the
        // descriptor can be reused for a plain object of the same shape.
        //
        // Under own, a closure that does not escape borrows what its box holds
        // (OWN_BORROWS_CAPTURES_ATTR_NAME), so its routine frees the box and nothing else.
        OwnershipRoutineLogic orl(createBoundFunctionOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        auto borrows = tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn &&
                       createBoundFunctionOp->hasAttr(OWN_BORROWS_CAPTURES_ATTR_NAME);
        auto releaseRoutineName = borrows ? orl.getOrCreateCaptureBoxFreeRoutine(captureRefType)
                                          : orl.getOrCreateCaptureBoxReleaseRoutine(captureRefType);
        // under own nothing retains: see TypeDescriptorOpLowering
        auto retainRoutineName = tsLlvmContext->compileOptions.memoryModel == MemoryModelOwn
                                     ? std::string()
                                     : orl.getOrCreateCaptureBoxRetainRoutine(captureRefType);

        LLVMCodeHelper ch(createBoundFunctionOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        return ch.getOrCreateTypeDescriptorName(captureRefType, name, TypeOfOpHelper::typeKindFromName(name),
                                                releaseRoutineName, retainRoutineName, borrows ? "b" : "");
    }

    LogicalResult matchAndRewrite(mlir_ts::CreateBoundFunctionOp createBoundFunctionOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = createBoundFunctionOp.getLoc();

        TypeHelper th(rewriter);
        CodeLogicHelper clh(createBoundFunctionOp, rewriter);
        TypeConverterHelper tch(getTypeConverter());

        assert(createBoundFunctionOp.getType());
        assert(isa<mlir_ts::BoundFunctionType>(createBoundFunctionOp.getType()) ||
               isa<mlir_ts::HybridFunctionType>(createBoundFunctionOp.getType()));

        auto llvmBoundFunctionType = tch.convertType(createBoundFunctionOp.getType());

        LLVM_DEBUG(llvm::dbgs() << "\n!! CreateBoundFunction: LLVM Type :" << llvmBoundFunctionType << "\n";);
        LLVM_DEBUG(llvm::dbgs() << "\n!! CreateBoundFunction: Func Type :"
                                << tch.convertType(createBoundFunctionOp.getFunc().getType()) << "\n";);
        LLVM_DEBUG(llvm::dbgs() << "\n!! CreateBoundFunction: This Type :" << createBoundFunctionOp.getThisVal().getType()
                                << "\n";);

        auto structVal = rewriter.create<mlir_ts::UndefOp>(loc, llvmBoundFunctionType);
        auto structVal2 = rewriter.create<LLVM::InsertValueOp>(loc, structVal, transformed.getFunc(),
                                                               MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));
        auto structVal3 = rewriter.create<LLVM::InsertValueOp>(loc, structVal2, transformed.getThisVal(),
                                                               MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        // Every bound or hybrid function value in the program is built here, which is what makes
        // the tag safe to read - the same property NewInterface has (§9.31).
        auto structVal4 = rewriter.create<LLVM::InsertValueOp>(
            loc, structVal3, getCaptureTypeTag(createBoundFunctionOp, rewriter),
            MLIRHelper::getStructIndex(rewriter, CLOSURE_TYPE_INDEX));

        rewriter.replaceOp(createBoundFunctionOp, ValueRange{structVal4});

        return success();
    }
};

struct GetThisOpLowering : public TsLlvmPattern<mlir_ts::GetThisOp>
{
    using TsLlvmPattern<mlir_ts::GetThisOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GetThisOp getThisOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = getThisOp.getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(getThisOp, rewriter);

        auto llvmThisType = tch.convertType(getThisOp.getType());

        mlir::Value thisVal = rewriter.create<LLVM::ExtractValueOp>(loc, th.getPtrType(), transformed.getBoundFunc(),
                                                                    MLIRHelper::getStructIndex(rewriter, THIS_VALUE_INDEX));

        auto thisValCasted = rewriter.create<LLVM::BitcastOp>(loc, llvmThisType, thisVal);

        rewriter.replaceOp(getThisOp, thisValCasted);

        return success();
    }
};

struct GetMethodOpLowering : public TsLlvmPattern<mlir_ts::GetMethodOp>
{
    using TsLlvmPattern<mlir_ts::GetMethodOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GetMethodOp getMethodOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = getMethodOp.getLoc();

        TypeHelper th(rewriter);
        TypeConverterHelper tch(getTypeConverter());
        CodeLogicHelper clh(getMethodOp, rewriter);
        CastLogicHelper castLogic(getMethodOp, rewriter, tch, tsLlvmContext->compileOptions);

        auto origType = getMethodOp.getBoundFunc().getType();

        mlir_ts::FunctionType funcType;
        mlir::Type llvmMethodType;
        if (auto boundType = dyn_cast<mlir_ts::BoundFunctionType>(origType))
        {
            funcType = mlir_ts::FunctionType::get(rewriter.getContext(), boundType.getInputs(), boundType.getResults());
            llvmMethodType = tch.convertType(funcType);
        }
        else if (auto hybridType = dyn_cast<mlir_ts::HybridFunctionType>(origType))
        {
            funcType =
                mlir_ts::FunctionType::get(rewriter.getContext(), hybridType.getInputs(), hybridType.getResults());
            llvmMethodType = tch.convertType(funcType);
        }
        else if (auto structType = dyn_cast<LLVM::LLVMStructType>(origType))
        {
            auto ptrType = cast<LLVM::LLVMPointerType>(structType.getBody().front());
            //assert(isa<LLVM::LLVMFunctionType>(ptrType.getElementType()));
            llvmMethodType = ptrType;
        }
        else
        {
            // GetMethodOp's `boundFunc` operand is TableGen-constrained to
            // TypeScript_BoundFunctionLike (BoundFunctionType|HybridFunctionType),
            // enforced by the verifier - the LLVMStructType case above is already
            // stricter than that constraint requires.
            LLVM_DEBUG(llvm::dbgs() << "\n!! GetMethodOp: " << getMethodOp << " result type: " << getMethodOp.getType()
                                    << "\n");
            getMethodOp->emitError("unsupported bound-function type in GetMethod");
            return failure();
        }

        mlir::Value methodVal = rewriter.create<LLVM::ExtractValueOp>(loc, llvmMethodType, transformed.getBoundFunc(),
                                                                      MLIRHelper::getStructIndex(rewriter, DATA_VALUE_INDEX));

        if (methodVal.getType() != getMethodOp.getType())
        {
            methodVal = castLogic.cast(methodVal, methodVal.getType(), getMethodOp.getType());
        }

        rewriter.replaceOp(getMethodOp, ValueRange{methodVal});
        return success();
    }
};

// TODO: review it, i need it for Union type
struct TypeOfOpLowering : public TsLlvmPattern<mlir_ts::TypeOfOp>
{
    using TsLlvmPattern<mlir_ts::TypeOfOp>::TsLlvmPattern;

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

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

struct TypeOfAnyOpLowering : public TsLlvmPattern<mlir_ts::TypeOfAnyOp>
{
    using TsLlvmPattern<mlir_ts::TypeOfAnyOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::TypeOfAnyOp typeOfAnyOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        Location loc = typeOfAnyOp.getLoc();

        TypeConverterHelper tch(getTypeConverter());

        LLVM_DEBUG(llvm::dbgs() << "\n!! TypeOf: " << typeOfAnyOp.getValue() << "\n";);

        AnyLogic al(typeOfAnyOp, rewriter, tch, loc, tsLlvmContext->compileOptions);
        auto typeOfValue = al.getTypeOfAny(transformed.getValue());

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

class DebuggerOpLowering : public TsLlvmPattern<mlir_ts::DebuggerOp>
{
  public:
    using TsLlvmPattern<mlir_ts::DebuggerOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::DebuggerOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        TypeHelper th(rewriter);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        TypeConverterHelper tch(getTypeConverter());

        auto loc = op->getLoc();

        // Get a symbol reference to the printf function, inserting it if necessary.
        auto debugtrapFuncOp = ch.getOrInsertFunction("llvm.debugtrap", th.getFunctionType({}));

        rewriter.create<LLVM::CallOp>(loc, debugtrapFuncOp, ValueRange{});

        rewriter.eraseOp(op);

        return success();
    }
};

#ifndef DISABLE_SWITCH_STATE_PASS

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

    LogicalResult matchAndRewrite(mlir_ts::StateLabelOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        CodeLogicHelper clh(op, rewriter);

        clh.BeginBlock(op.getLoc());

        rewriter.eraseOp(op);

        return success();
    }
};

#define MLIR_SWITCH 1
class SwitchStateOpLowering : public TsLlvmPattern<mlir_ts::SwitchStateOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SwitchStateOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SwitchStateOp switchStateOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        CodeLogicHelper clh(switchStateOp, rewriter);

        auto loc = switchStateOp->getLoc();

        auto returnBlock = clh.FindReturnBlock(true);

        assert(returnBlock);

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

        auto defaultBlock = returnBlock;

        assert(defaultBlock != nullptr);

        SmallVector<int32_t> caseValues;
        SmallVector<mlir::Block *> caseDestinations;

        SmallPtrSet<Operation *, 16> stateLabels;

        auto index = 1;

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

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

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

                auto *continuationBlock = clh.BeginBlock(loc);

                rewriter.eraseOp(stateLabelOp);

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

        // make switch to be terminator
        rewriter.setInsertionPointAfter(switchStateOp);
        auto *continuationBlock = clh.CutBlockAndSetInsertPointToEndOfBlock();

        // insert 0 state label
        caseValues.insert(caseValues.begin(), 0);
        caseDestinations.insert(caseDestinations.begin(), continuationBlock);

        rewriter.replaceOpWithNewOp<LLVM::SwitchOp>(switchStateOp, transformed.state(),
                                                    defaultBlock ? defaultBlock : continuationBlock, ValueRange{},
                                                    caseValues, caseDestinations);

        LLVM_DEBUG(llvm::dbgs() << "\n!! SWITCH DUMP: \n" << *switchStateOp->getParentOp() << "\n";);

        return success();
    }
};

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

    LogicalResult matchAndRewrite(mlir_ts::YieldReturnValOp yieldReturnValOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        CodeLogicHelper clh(yieldReturnValOp, rewriter);

        auto returnBlock = clh.FindReturnBlock();

        assert(returnBlock);

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

        auto retBlock = returnBlock;

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

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

        LLVM_DEBUG(llvm::dbgs() << "\n!! YIELD DUMP: \n" << *yieldReturnValOp->getParentOp() << "\n";);

        return success();
    }
};

#endif

class SwitchStateInternalOpLowering : public TsLlvmPattern<mlir_ts::SwitchStateInternalOp>
{
  public:
    using TsLlvmPattern<mlir_ts::SwitchStateInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::SwitchStateInternalOp switchStateOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        

        CodeLogicHelper clh(switchStateOp, rewriter);

        auto loc = switchStateOp->getLoc();

        SmallVector<int32_t> caseValues;
        SmallVector<mlir::Block *> caseDestinations;
        SmallVector<ValueRange> caseOperands;

        for (auto [index, case1] : enumerate(switchStateOp.getCases()))
        {
            caseValues.push_back(index);
            caseDestinations.push_back(case1);
            caseOperands.push_back(ValueRange());
        }

        rewriter.replaceOpWithNewOp<LLVM::SwitchOp>(switchStateOp, transformed.getState(), switchStateOp.getDefaultDest(),
                                                    ValueRange{}, caseValues, caseDestinations, caseOperands);

        LLVM_DEBUG(llvm::dbgs() << "\n!! SWITCH DUMP: \n" << *switchStateOp->getParentOp() << "\n";);

        return success();
    }
};

// the body of __mlir_gctors, whichever function op it is by now
static mlir::Region *gctorsBodyOf(mlir::Operation *op)
{
    if (auto llvmFunc = dyn_cast_or_null<LLVM::LLVMFuncOp>(op))
    {
        return &llvmFunc.getBody();
    }

    if (auto tsFunc = dyn_cast_or_null<mlir_ts::FuncOp>(op))
    {
        return &tsFunc.getBody();
    }

    if (auto func = dyn_cast_or_null<func::FuncOp>(op))
    {
        return &func.getBody();
    }

    return nullptr;
}

struct GlobalConstructorOpLowering : public TsLlvmPattern<mlir_ts::GlobalConstructorOp>
{
    using TsLlvmPattern<mlir_ts::GlobalConstructorOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GlobalConstructorOp globalConstructorOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        if (tsLlvmContext->compileOptions.appendGCtorsToMethod)
        {
            auto loc = globalConstructorOp->getLoc();

            auto priority = globalConstructorOp.getPriority().getLimitedValue();

            auto parentModule = globalConstructorOp->getParentOfType<ModuleOp>();
            //auto mlirGCtors = parentModule.lookupSymbol<func::FuncOp>(MLIR_GCTORS);
            auto mlirGCtors = parentModule.lookupSymbol(MLIR_GCTORS);
            if (!mlirGCtors)
            {
                OpBuilder::InsertionGuard insertGuard(rewriter);

                // create dummy __mlir_gctors for JIT
                rewriter.setInsertionPointToEnd(parentModule.getBody());
                auto llvmFnType = mlir::FunctionType::get(rewriter.getContext(), {}, {});
                auto initFunc = rewriter.create<func::FuncOp>(loc, MLIR_GCTORS, llvmFnType);
                initFunc.setPublic();                
                auto linkage = LLVM::LinkageAttr::get(rewriter.getContext(), LLVM::Linkage::External);
                initFunc->setAttr("llvm.linkage", linkage);
                if (true || tsLlvmContext->compileOptions.isDLL)
                {
                    SmallVector<mlir::Attribute> funcAttrs;
                    funcAttrs.push_back(ATTR("export"));
                    initFunc->setAttr("passthrough", ArrayAttr::get(rewriter.getContext(), funcAttrs));
                }

                auto &entryBlock = *initFunc.addEntryBlock();
                rewriter.setInsertionPointToEnd(&entryBlock);

                auto callOp = rewriter.create<LLVM::CallOp>(loc, TypeRange{}, globalConstructorOp.getGlobalNameAttr(), ValueRange{});
                tsLlvmContext->globalConstructorCalls.push_back({(int64_t)priority, callOp});
                rewriter.create<LLVM::ReturnOp>(loc, ValueRange{});
            }
            else if (auto *gctorsBody = gctorsBodyOf(mlirGCtors))
            {
                // in priority order, each after the ones before it (#446): before the first call
                // already here with a higher priority, else after the last one here
                OpBuilder::InsertionGuard insertGuard(rewriter);
                auto &calls = tsLlvmContext->globalConstructorCalls;
                auto later = llvm::find_if(calls, [&](auto &entry) { return entry.first > (int64_t)priority; });
                if (later != calls.end())
                {
                    rewriter.setInsertionPoint(later->second);
                }
                else if (!calls.empty())
                {
                    rewriter.setInsertionPointAfter(calls.back().second);
                }
                else if (priority <= 1000)
                {
                    rewriter.setInsertionPointToStart(&gctorsBody->front());
                }
                else
                {
                    rewriter.setInsertionPoint(gctorsBody->back().getTerminator());
                }

                auto callOp = rewriter.create<LLVM::CallOp>(loc, TypeRange{}, globalConstructorOp.getGlobalNameAttr(), ValueRange{});
                calls.insert(later, {(int64_t)priority, callOp});
            }
            else 
            {
                assert(false);
                return mlir::failure();
            }

            rewriter.eraseOp(globalConstructorOp);
        }
        else
        {
            rewriter.replaceOpWithNewOp<LLVM::GlobalCtorsOp>(
                globalConstructorOp,
                rewriter.getArrayAttr({ globalConstructorOp.getGlobalNameAttr() }),
                rewriter.getArrayAttr({ rewriter.getI32IntegerAttr(globalConstructorOp.getPriority().getLimitedValue()) }),
                rewriter.getArrayAttr({ LLVM::ZeroAttr::get(rewriter.getContext()) }));
        }

        return success();
    }
};

struct AppendToUsedOpLowering : public TsLlvmPattern<mlir_ts::AppendToUsedOp>
{
    using TsLlvmPattern<mlir_ts::AppendToUsedOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AppendToUsedOp appendToUsedOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto loc = appendToUsedOp->getLoc();

        LLVMCodeHelper lch(appendToUsedOp, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        
        lch.createGlobalVarRegionWithAppendingSymbolRef("llvm.used", appendToUsedOp.getGlobalNameAttr(), "llvm.metadata");

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

struct BodyInternalOpLowering : public TsLlvmPattern<mlir_ts::BodyInternalOp>
{
    using TsLlvmPattern<mlir_ts::BodyInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BodyInternalOp bodyInternalOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter);
        CodeLogicHelper clh(bodyInternalOp, rewriter);

        auto location = bodyInternalOp.getLoc();

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

        mlir::Block *beforeBody = &bodyInternalOp.getBody().front();
        mlir::Block *afterBody = &bodyInternalOp.getBody().back();
        rewriter.inlineRegionBefore(bodyInternalOp.getBody(), continuationBlock);

        rewriter.setInsertionPointToEnd(opBlock);
        rewriter.create<LLVM::BrOp>(location, ValueRange(), beforeBody);

        rewriter.setInsertionPointToEnd(afterBody);
        auto bodyResultInternalOp = cast<mlir_ts::BodyResultInternalOp>(afterBody->getTerminator());
        auto branchOp = rewriter.replaceOpWithNewOp<LLVM::BrOp>(bodyResultInternalOp, bodyResultInternalOp.getResults(),
                                                                continuationBlock);

        rewriter.setInsertionPoint(branchOp);

        rewriter.replaceOp(bodyInternalOp, continuationBlock->getArguments());

        return success();
    }
};

struct BodyResultInternalOpLowering : public TsLlvmPattern<mlir_ts::BodyResultInternalOp>
{
    using TsLlvmPattern<mlir_ts::BodyResultInternalOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::BodyResultInternalOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOp(op, op.getResults());
        return success();
    }
};

struct NoOpLowering : public TsLlvmPattern<mlir_ts::NoOp>
{
    using TsLlvmPattern<mlir_ts::NoOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::NoOp noOp, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.eraseOp(noOp);
        return success();
    }
};

#ifdef ENABLE_TYPED_GC
class GCMakeDescriptorOpLowering : public TsLlvmPattern<mlir_ts::GCMakeDescriptorOp>
{
  public:
    using TsLlvmPattern<mlir_ts::GCMakeDescriptorOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GCMakeDescriptorOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        TypeHelper th(rewriter, tsLlvmContext->compileOptions);
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);

        auto i64PtrTy = th.getPtrType();

        // target-width: GC_make_descriptor returns GC_descr, a typedef of GC_word, which gc.h defines
        // as the unsigned integer the size of `void *`; its second parameter is a `size_t` bit count
        // (3rdParty/gc-8.2.12/include/gc_typed.h:52). Neither is a fixed 64 bits.
        auto gcMakeDescriptorFunc = ch.getOrInsertFunction("GC_make_descriptor", th.getFunctionType(th.getSizeType(), {i64PtrTy, th.getSizeType()}));
        rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, gcMakeDescriptorFunc, ValueRange{transformed.getTypeBitmap(), transformed.getSizeOfBitmapInElements()});

        return success();
    }
};

// GC_malloc_explicitly_typed is a fresh-pointer-per-call allocator, just like GC_malloc
// (see GCPass.cpp markAsAllocatorIfNeeded for the full rationale). memory_effects alone
// doesn't stop GVN/EarlyCSE at -O3 from merging two `new` sites with identical (size,
// typeDescr) args - e.g. two instances of the same class - into one shared allocation;
// the `allockind` LLVM attribute is what actually blocks that call-CSE.
static void markGCMallocExplicitlyTypedAsAllocator(LLVM::LLVMFuncOp funcOp)
{
    auto *context = funcOp->getContext();

    // AllocFnKind::Alloc = 1<<0; not marking Zeroed since GC_malloc_explicitly_typed's
    // contents are then explicitly initialized by the caller.
    auto kindEntry = mlir::ArrayAttr::get(
        context, {mlir::StringAttr::get(context, "allockind"), mlir::StringAttr::get(context, "1")});

    llvm::SmallVector<mlir::Attribute> passthrough;
    if (auto existing = funcOp.getPassthroughAttr())
    {
        passthrough.append(existing.begin(), existing.end());
    }
    passthrough.push_back(kindEntry);
    funcOp.setPassthroughAttr(mlir::ArrayAttr::get(context, passthrough));
}

class GCNewExplicitlyTypedOpLowering : public TsLlvmPattern<mlir_ts::GCNewExplicitlyTypedOp>
{
  public:
    using TsLlvmPattern<mlir_ts::GCNewExplicitlyTypedOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::GCNewExplicitlyTypedOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        LLVMCodeHelper ch(op, rewriter, getTypeConverter(), tsLlvmContext->compileOptions);
        CodeLogicHelper clh(op, rewriter);
        TypeConverterHelper tch(getTypeConverter());
        TypeHelper th(rewriter, tsLlvmContext->compileOptions);

        auto llvmIndexType = tch.convertType(th.getIndexType());

        auto loc = op.getLoc();

        mlir::Type storageType = op.getInstance().getType();
        if (auto classType = dyn_cast_or_null<mlir_ts::ClassType>(storageType))
        {
            storageType = classType.getStorageType();
        }
        else if (auto valueRef = dyn_cast<mlir_ts::ValueRefType>(storageType))
        {
            storageType = valueRef.getElementType();
        }

        auto resultType = tch.convertType(op.getType());

        auto sizeOfTypeValueMLIR = rewriter.create<mlir_ts::SizeOfOp>(loc, th.getIndexType(), storageType);
        auto sizeOfTypeValue = rewriter.create<mlir_ts::DialectCastOp>(loc, llvmIndexType, sizeOfTypeValueMLIR);

        auto i8PtrTy = th.getPtrType();

        // target-width: GC_malloc_explicitly_typed(size_t size_in_bytes, GC_descr d) - a byte count and
        // a GC_descr (= GC_word, the integer the size of `void *`), per gc_typed.h:81. Neither is fixed at 64.
        auto gcMallocExplicitlyTypedFunc = ch.getOrInsertFunction("GC_malloc_explicitly_typed", th.getFunctionType(i8PtrTy, {th.getSizeType(), th.getSizeType()}));
        // Without this, two `new` sites with identical (size, typeDescr) args - e.g. two
        // instances of the same class - look like redundant calls to GVN/EarlyCSE at -O3
        // and get merged into one shared allocation. See GCPass.cpp markAsAllocatorIfNeeded, and
        // the allocator's state as inaccessible memory it reads and writes, which is what stops it.
        gcMallocExplicitlyTypedFunc.setMemoryEffectsAttr(LLVM::MemoryEffectsAttr::get(
            rewriter.getContext(), LLVM::ModRefInfo::Mod, LLVM::ModRefInfo::NoModRef, LLVM::ModRefInfo::ModRef,
            LLVM::ModRefInfo::NoModRef, LLVM::ModRefInfo::NoModRef, LLVM::ModRefInfo::NoModRef));
        markGCMallocExplicitlyTypedAsAllocator(gcMallocExplicitlyTypedFunc);
        auto value = rewriter.create<LLVM::CallOp>(loc, gcMallocExplicitlyTypedFunc, ValueRange{sizeOfTypeValue, transformed.getTypeDescr()});

        rewriter.replaceOpWithNewOp<LLVM::BitcastOp>(op, resultType, value.getResult());

        return success();
    }
};

#endif

struct UnrealizedConversionCastOpLowering : public ConvertOpToLLVMPattern<UnrealizedConversionCastOp>
{
    using ConvertOpToLLVMPattern<UnrealizedConversionCastOp>::ConvertOpToLLVMPattern;

    LogicalResult matchAndRewrite(UnrealizedConversionCastOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const override
    {
        SmallVector<mlir::Type> convertedTypes;
        if (succeeded(typeConverter->convertTypes(op.getOutputs().getTypes(), convertedTypes)) &&
            convertedTypes == adaptor.getInputs().getTypes())
        {
            rewriter.replaceOp(op, adaptor.getInputs());
            return success();
        }

        convertedTypes.clear();
        if (succeeded(typeConverter->convertTypes(adaptor.getInputs().getTypes(), convertedTypes)) &&
            convertedTypes == op.getOutputs().getType())
        {
            rewriter.replaceOp(op, adaptor.getInputs());
            return success();
        }
        return failure();
    }
};

// internals
struct AtomicRMWOpLowering : public TsLlvmPattern<mlir_ts::AtomicRMWOp>
{
    using TsLlvmPattern<mlir_ts::AtomicRMWOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AtomicRMWOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<LLVM::AtomicRMWOp>(
            op, 
            (LLVM::AtomicBinOp)transformed.getBinOp(), 
            transformed.getPtr(), 
            transformed.getValue(), 
            (LLVM::AtomicOrdering)transformed.getOrdering(),
            transformed.getSyncscope().value_or(StringRef()),
            transformed.getAlignment().value_or(0),
            transformed.getVolatile_());
        return success();
    }
};

struct AtomicCmpXchgOpLowering : public TsLlvmPattern<mlir_ts::AtomicCmpXchgOp>
{
    using TsLlvmPattern<mlir_ts::AtomicCmpXchgOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::AtomicCmpXchgOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<LLVM::AtomicCmpXchgOp>(
            op, 
            transformed.getPtr(), 
            transformed.getCmp(), 
            transformed.getValue(), 
            (LLVM::AtomicOrdering)transformed.getSuccessOrdering(),
            (LLVM::AtomicOrdering)transformed.getFailureOrdering(),
            transformed.getSyncscope().value_or(StringRef()),
            transformed.getAlignment().value_or(0),
            transformed.getWeak(),
            transformed.getVolatile_());
        return success();
    }
};

struct FenceOpLowering : public TsLlvmPattern<mlir_ts::FenceOp>
{
    using TsLlvmPattern<mlir_ts::FenceOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::FenceOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        rewriter.replaceOpWithNewOp<LLVM::FenceOp>(
            op, 
            (LLVM::AtomicOrdering)transformed.getOrdering(),
            transformed.getSyncscope().value_or(StringRef())
        );
        return success();
    }
};

struct InlineAsmOpLowering : public TsLlvmPattern<mlir_ts::InlineAsmOp>
{
    using TsLlvmPattern<mlir_ts::InlineAsmOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::InlineAsmOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        SmallVector<mlir::Type> convertedTypes;
        if (failed(typeConverter->convertTypes(op->getResultTypes(), convertedTypes)))
        {
            return failure();
        }

        rewriter.replaceOpWithNewOp<LLVM::InlineAsmOp>(
            op, 
            TypeRange(convertedTypes), 
            transformed.getOperands(),
            transformed.getAsmString(), 
            transformed.getConstraints(), 
            transformed.getHasSideEffects(),
            transformed.getIsAlignStack(),
            LLVM::tailcallkind::TailCallKind::None,
            LLVM::AsmDialectAttr::get(rewriter.getContext(), transformed.getAsmDialect().value_or(0) == 0
                ? LLVM::AsmDialect::AD_ATT : LLVM::AsmDialect::AD_Intel),
            transformed.getOperandAttrsAttr());

        return success();
    }
};

struct CallIntrinsicOpLowering : public TsLlvmPattern<mlir_ts::CallIntrinsicOp>
{
    using TsLlvmPattern<mlir_ts::CallIntrinsicOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::CallIntrinsicOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        SmallVector<mlir::Type> convertedTypes;
        if (failed(typeConverter->convertTypes(op->getResultTypes(), convertedTypes)))
        {
            return failure();
        }

        rewriter.replaceOpWithNewOp<LLVM::CallIntrinsicOp>(
            op,
            TypeRange(convertedTypes),
            transformed.getIntrin(),
            transformed.getOperands(),
            (LLVM::FastmathFlags)transformed.getFastmathFlags(),
            ArrayRef<ValueRange>{},
            /*op_bundle_tags*/ nullptr,
            /*arg_attrs*/ nullptr,
            /*res_attrs*/ nullptr);

        return success();
    }
};

struct LinkerOptionsOpLowering : public TsLlvmPattern<mlir_ts::LinkerOptionsOp>
{
    using TsLlvmPattern<mlir_ts::LinkerOptionsOp>::TsLlvmPattern;

    LogicalResult matchAndRewrite(mlir_ts::LinkerOptionsOp op, Adaptor transformed,
                                  ConversionPatternRewriter &rewriter) const final
    {
        auto module = op->getParentOfType<mlir::ModuleOp>();
        auto sp = rewriter.saveInsertionPoint();
        rewriter.setInsertionPointToStart(module.getBody());
        rewriter.create<LLVM::LinkerOptionsOp>(op->getLoc(), transformed.getOptions());
        rewriter.restoreInsertionPoint(sp);

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

static void populateTypeScriptConversionPatterns(LLVMTypeConverter &converter, mlir::ModuleOp &m,
                                                 mlir::SmallPtrSet<mlir::Type, 32> &usedTypes, CompileOptions& compileOptions)
{
    converter.addConversion(
        [&](mlir_ts::AnyType type) { return LLVM::LLVMPointerType::get(m.getContext()); });

    converter.addConversion(
        [&](mlir_ts::NullType type) { return LLVM::LLVMPointerType::get(m.getContext()); });

    converter.addConversion([&](mlir_ts::OpaqueType type) { return LLVM::LLVMPointerType::get(m.getContext()); });

    converter.addConversion([&](mlir_ts::VoidType type) { return LLVM::LLVMVoidType::get(m.getContext()); });

    converter.addConversion([&](mlir_ts::BooleanType type) {
        TypeHelper th(m.getContext());
        return th.getLLVMBoolType();
    });

    converter.addConversion([&](mlir_ts::TypePredicateType type) {
        TypeHelper th(m.getContext());
        return th.getLLVMBoolType();
    });

    converter.addConversion([&](mlir_ts::CharType type) {
        return mlir::IntegerType::get(m.getContext(), 8 /*, mlir::IntegerType::SignednessSemantics::Unsigned*/);
    });

    converter.addConversion([&](mlir_ts::ByteType type) {
        return mlir::IntegerType::get(m.getContext(), 8 /*, mlir::IntegerType::SignednessSemantics::Unsigned*/);
    });

    converter.addConversion([&](mlir_ts::NumberType type) {
#ifdef NUMBER_F64
        return Float64Type::get(m.getContext());
#else
        return Float32Type::get(m.getContext());
#endif
    });

    converter.addConversion([&](mlir_ts::BigIntType type) {
        return mlir::IntegerType::get(m.getContext(), 64 /*, mlir::IntegerType::SignednessSemantics::Signed*/);
    });

    converter.addConversion([&](mlir_ts::StringType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::EnumType type) { return converter.convertType(type.getElementType()); });

    converter.addConversion([&](mlir_ts::ConstArrayType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::ConstArrayValueType type) {
        return LLVM::LLVMArrayType::get(converter.convertType(type.getElementType()), type.getSize());
    });

    converter.addConversion([&](mlir_ts::ArrayType type) {
        TypeHelper th(m.getContext());

        SmallVector<mlir::Type> rtArrayType;
        // pointer to data type
        rtArrayType.push_back(th.getPtrType());
        // field which store length of array
        rtArrayType.push_back(converter.convertType(th.getIndexType()));

        return LLVM::LLVMStructType::getLiteral(type.getContext(), rtArrayType, false);
    });

    converter.addConversion([&](mlir_ts::RefType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    // Shared<T> (own spec 23): a pointer to the handle's payload
    converter.addConversion([&](mlir_ts::SharedType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::ValueRefType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::ConstTupleType type) {
        SmallVector<mlir::Type> convertedTypes;
        for (auto subType : type.getFields())
        {
            convertedTypes.push_back(converter.convertType(subType.type));
        }

        return LLVM::LLVMStructType::getLiteral(type.getContext(), convertedTypes, TUPLE_TYPE_PACKED);
    });

    converter.addConversion([&](mlir_ts::TupleType type) {
        SmallVector<mlir::Type> convertedTypes;
        for (auto subType : type.getFields())
        {
            convertedTypes.push_back(converter.convertType(subType.type));
        }

        return LLVM::LLVMStructType::getLiteral(type.getContext(), convertedTypes, TUPLE_TYPE_PACKED);
    });

    converter.addConversion([&](mlir_ts::BoundRefType type) {
        SmallVector<mlir::Type> llvmStructType;
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        return LLVM::LLVMStructType::getLiteral(type.getContext(), llvmStructType, false);
    });

    converter.addConversion([&](mlir_ts::FunctionType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::ConstructFunctionType type) {
        return LLVM::LLVMPointerType::get(m.getContext());    
    });

    converter.addConversion([&](mlir_ts::BoundFunctionType type) {
        SmallVector<mlir::Type> llvmStructType;
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        // type tag of the capture box, when this value is a closure - see CLOSURE_TYPE_INDEX
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        return LLVM::LLVMStructType::getLiteral(type.getContext(), llvmStructType, false);
    });

    converter.addConversion([&](mlir_ts::HybridFunctionType type) {
        SmallVector<mlir::Type> llvmStructType;
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        // as above
        llvmStructType.push_back(LLVM::LLVMPointerType::get(m.getContext()));
        return LLVM::LLVMStructType::getLiteral(type.getContext(), llvmStructType, false);
    });

    converter.addConversion([&](mlir_ts::ObjectType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::ObjectStorageType type) {
        auto identStruct = LLVM::LLVMStructType::getIdentified(type.getContext(), type.getName().getValue());
        if (!usedTypes.contains(identStruct))
        {
            usedTypes.insert(identStruct);
            SmallVector<mlir::Type> convertedTypes;
            for (auto subType : type.getFields())
            {
                convertedTypes.push_back(converter.convertType(subType.type));
            }

            identStruct.setBody(convertedTypes, false);
        }

        return identStruct;
    });    

    converter.addConversion([&](mlir_ts::UnknownType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::SymbolType type) { 
        return  LLVM::LLVMStructType::getOpaque("Symbol", type.getContext()); 
     });

    converter.addConversion([&](mlir_ts::UndefinedType type) { 
        auto identStruct = LLVM::LLVMStructType::getIdentified(type.getContext(), UNDEFINED_NAME);
        SmallVector<mlir::Type> undefBodyTypes;
        // TODO: review size of int here, should it be 8?
        undefBodyTypes.push_back(mlir::IntegerType::get(m.getContext(), 1));
        identStruct.setBody(undefBodyTypes, false);
        return identStruct;
    });

    converter.addConversion([&](mlir_ts::ClassStorageType type) {
        auto identStruct = LLVM::LLVMStructType::getIdentified(type.getContext(), type.getName().getValue());
        if (!usedTypes.contains(identStruct))
        {
            usedTypes.insert(identStruct);
            SmallVector<mlir::Type> convertedTypes;
            for (auto subType : type.getFields())
            {
                convertedTypes.push_back(converter.convertType(subType.type));
            }

            identStruct.setBody(convertedTypes, false);
        }

        return identStruct;
    });

    converter.addConversion([&](mlir_ts::ClassType type) {
        return LLVM::LLVMPointerType::get(m.getContext());
    });

    converter.addConversion([&](mlir_ts::InterfaceType type) {
        TypeHelper th(m.getContext());

        SmallVector<mlir::Type> rtInterfaceType;
        // vtable
        rtInterfaceType.push_back(th.getPtrType());
        // this
        rtInterfaceType.push_back(th.getPtrType());
        // runtime type tag of what `this` points at - see INTERFACE_TYPE_INDEX
        rtInterfaceType.push_back(th.getPtrType());

        return LLVM::LLVMStructType::getLiteral(type.getContext(), rtInterfaceType, false);
    });

    converter.addConversion([&](mlir_ts::OptionalType type) {
        SmallVector<mlir::Type> convertedTypes;

        TypeHelper th(m.getContext());

        // wrapped type
        convertedTypes.push_back(converter.convertType(type.getElementType()));
        // field which shows undefined state
        convertedTypes.push_back(th.getLLVMBoolType());

        return LLVM::LLVMStructType::getLiteral(type.getContext(), convertedTypes, false);
    });

    converter.addConversion([&](mlir_ts::UnionType type) {
        TypeHelper th(m.getContext());
        LLVMTypeConverterHelper ltch(&converter);
        MLIRTypeHelper mth(m.getContext(), compileOptions);

        bool needTag = mth.isUnionTypeNeedsTag(mlir::UnknownLoc::get(type.getContext()), type);

        // With a tag, the value field is padding-free storage as large as the largest member
        // (packed words plus a byte tail, see getUnionStorageType), not that member's struct
        // type. A value copy of a struct does not carry its padding, and another member's field
        // can sit in that padding: at 32-bit a member's f64 lands in the storage member's padding
        // after a 4-byte pointer, and it read back as garbage once the union was copied. Without
        // a tag there is no real union - the members share one base type - and that type is kept
        // as it is.
        mlir::Type selectedType = needTag ? ltch.getUnionStorageType(type) : ltch.findMaxSizeType(type);

        LLVM_DEBUG(llvm::dbgs() << "\n!! storage type in union: " << selectedType
                                << "\n size: " << ltch.getTypeAllocSizeInBytes(selectedType) << "\n Tag: " << (needTag ? "yes" : "no")
                                << "\n union type: " << type << "\n";);

        SmallVector<mlir::Type> convertedTypes;
        if (needTag)
        {
            convertedTypes.push_back(th.getPtrType());
        }

        convertedTypes.push_back(selectedType);
        if (convertedTypes.size() == 1)
        {
            return convertedTypes.front();
        }

        mlir::Type structType = LLVM::LLVMStructType::getLiteral(type.getContext(), convertedTypes, UNION_TYPE_PACKED);
        return structType;
    });

    converter.addConversion([&](mlir_ts::NeverType type) { return LLVM::LLVMVoidType::get(type.getContext()); });

    converter.addConversion([&](mlir_ts::LiteralType type) { return converter.convertType(type.getElementType()); });

    converter.addConversion([&](mlir_ts::IntersectionType type) {
        llvm_unreachable("type usage (IntersectionType) is not implemented");
        return mlir::Type();
    }); 

    /*
    converter.addSourceMaterialization(
        [&](OpBuilder &builder, mlir::Type resultType, ValueRange inputs, Location loc) -> std::optional<mlir::Value> {
            if (inputs.size() != 1)
                return std::nullopt;

            LLVM_DEBUG(llvm::dbgs() << "\n!! Materialization (Source): " << loc << " result type: " << resultType; for (auto inputType : inputs) llvm::dbgs() << "\n <- input: " << inputType;);

            mlir::Value val = builder.create<mlir_ts::DialectCastOp>(loc, resultType, inputs[0]);
            return val;
            //return inputs[0];
        });
    converter.addTargetMaterialization(
        [&](OpBuilder &builder, mlir::Type resultType, ValueRange inputs, Location loc) -> std::optional<mlir::Value> {
            if (inputs.size() != 1)
                return std::nullopt;

            LLVM_DEBUG(llvm::dbgs() << "\n!! Materialization (Target): " << loc << " result type: " << resultType; for (auto inputType : inputs) llvm::dbgs() << "\n <- input: " << inputType;);

            mlir::Value val = builder.create<mlir_ts::DialectCastOp>(loc, resultType, inputs[0]);
            return val;
            //return inputs[0];
        });
    */
}

} // end anonymous namespace

//===----------------------------------------------------------------------===//
// TypeScriptToLLVMLoweringPass
//===----------------------------------------------------------------------===//

namespace
{

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

    TSContext tsContext;    

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

    void getDependentDialects(DialectRegistry &registry) const override
    {
        registry.insert<
            LLVM::LLVMDialect, 
            mlir::math::MathDialect, 
            mlir::arith::ArithDialect, 
            mlir::cf::ControlFlowDialect, 
            mlir::func::FuncDialect,
            mlir::index::IndexDialect>();            
    }

    void runOnOperation() final;
};

} // end anonymous namespace

static LogicalResult verifyTerminatorSuccessors(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 verifyAlloca(mlir::Block *block)
{
    auto beginAlloca = true;
    auto failed = false;
    auto withingStackSaveRestore = false;
    auto visitorAllOps = [&](Operation *op) {
        if (failed)
        {
            return;
        }

        if (isa<LLVM::ConstantOp>(op))
        {
            // ignore it
            return;
        }

        if (auto allocaOp = dyn_cast<LLVM::AllocaOp>(op))
        {
            if (beginAlloca)
            {
                return;
            }

            // check only alloca with const size
            auto sizeOp = allocaOp.getArraySize().getDefiningOp();
            if (!isa<mlir_ts::ConstantOp>(sizeOp) && !isa<mlir::arith::ConstantOp>(sizeOp))
            {
                return;
            }

            if (!withingStackSaveRestore)
            {
                failed = true;
                LLVM_DEBUG(llvm::dbgs() << "\n!! operator change stack without restoring it: "; op->dump();
                           llvm::dbgs() << "\n";);
                LLVM_DEBUG(llvm::dbgs() << "\n!! in func: \n"; op->getParentOfType<LLVM::LLVMFuncOp>()->dump();
                           llvm::dbgs() << "\n";);
                assert(false);
                op->emitError("DEBUG TEST: operator change stack without restoring it");
                return;
            }
        }

        if (isa<LLVM::StackSaveOp>(op))
        {
            withingStackSaveRestore = true;
        }

        if (isa<LLVM::StackRestoreOp>(op))
        {
            withingStackSaveRestore = false;
        }

        beginAlloca = false;
    };

    block->walk(visitorAllOps);

    if (failed)
    {
        return failure();
    }

    return success();
}

static LogicalResult verifyModule(mlir::ModuleOp &module)
{
    for (auto &block : module.getBodyRegion())
    {
        for (auto &op : block.getOperations())
        {
            if (auto funcOp = dyn_cast<LLVM::LLVMFuncOp>(op))
            {
                for (auto &region : funcOp->getRegions())
                {
                    for (auto &regionBlock : region)
                    {
                        if (failed(verifyTerminatorSuccessors(regionBlock.getTerminator())))
                        {
                            assert(false);
                            return failure();
                        }

                        if (failed(verifyAlloca(&regionBlock)))
                        {
                            assert(false);
                            return failure();
                        }
                    }
                }
            }
        }
    }

    return success();
}

static void selectAllVariablesAndDebugVariables(mlir::ModuleOp &module, SmallPtrSet<Operation *, 16> &workSet)
{
    auto visitorVariablesAndDebugVariablesOp = [&](Operation *op) {
        if (auto variableOp = dyn_cast_or_null<VariableOp>(op))
        {
            if (variableOp->getParentOfType<mlir_ts::GlobalOp>())
            {
                return;
            }

            workSet.insert(variableOp);
        }
        else if (auto debugVariableOp = dyn_cast_or_null<DebugVariableOp>(op))
        {
            workSet.insert(debugVariableOp);
        }        
        else if (auto globalOp = dyn_cast_or_null<GlobalOp>(op))
        {
            workSet.insert(globalOp);
        }        
    };

    module.walk(visitorVariablesAndDebugVariablesOp);
}

static void selectAllFuncOp(mlir::ModuleOp &module, SmallPtrSet<Operation *, 16> &workSet)
{
    auto visitorFuncOp = [&](Operation *op) {
        if (auto funcOp = dyn_cast_or_null<mlir_ts::FuncOp>(op))
        {
            workSet.insert(op);
        }
    };

    module.walk(visitorFuncOp);
}

static LogicalResult preserveTypesForDebugInfo(mlir::ModuleOp &module, LLVMTypeConverter &llvmTypeConverter, CompileOptions& compileOptions)
{
    SmallPtrSet<Operation *, 16> workSet;
    selectAllVariablesAndDebugVariables(module, workSet);

    for (auto op : workSet)
    {
        LLVM_DEBUG(llvm::dbgs() << "\n!! workSet DI: " << *op << "\n");

        auto location = op->getLoc();
        //DIScopeAttr scope, StringAttr name, DIFileAttr file, unsigned line, unsigned arg, unsigned alignInBits, DITypeAttr type
        if (auto scopeFusedLoc = dyn_cast<mlir::FusedLocWith<LLVM::DIScopeAttr>>(location))
        {
            if (auto namedLoc = dyn_cast_or_null<mlir::NameLoc>(scopeFusedLoc.getLocations().front()))
            {
                LocationHelper lh(location.getContext());
                // we don't need TypeConverter here
                LLVMTypeConverterHelper llvmtch(&llvmTypeConverter);
                LLVMDebugInfoHelper di(location.getContext(), llvmtch, compileOptions);

                auto [file, lineAndColumn] = lh.getLineAndColumnAndFile(namedLoc);
                auto [line, column] = lineAndColumn;

                if (!file)
                {
                    continue;
                }

                mlir::Type dataType;
                auto argIndex = 0;
                auto isGlobal = false;
                auto isGlobalDefined = true;
                mlir::StringAttr linkageNameAttr;
                if (auto variableOp = dyn_cast<mlir_ts::VariableOp>(op))
                {
                    dataType = variableOp.getType().getElementType();
                    auto argVal = variableOp.getDiArgNumber();
                    argIndex = argVal.has_value() ? argVal.value().getLimitedValue() : 0;
                }
                else if (auto debugVariableOp = dyn_cast<mlir_ts::DebugVariableOp>(op))
                {
                    dataType = debugVariableOp.getInitializer().getType();
                }
                else if (auto globalOp = dyn_cast<mlir_ts::GlobalOp>(op))
                {
                    dataType = globalOp.getType();
                    linkageNameAttr = globalOp.getSymNameAttr();
                    isGlobal = true;
                    // an external declaration (no initializer value and empty initializer region) is not
                    // defined here - marking it as defined makes the debug info emit a dangling address
                    // relocation to a symbol that never gets emitted (e.g. static members of a class
                    // expression used only as a default-parameter type).
                    auto &initRegion = globalOp.getInitializerRegion();
                    isGlobalDefined = globalOp.getValueAttr() != nullptr ||
                                      (!initRegion.empty() && !initRegion.front().empty());

                    // skip debug info for external declarations - attaching a global-variable
                    // expression to a declaration global makes LLVM emit a DW_OP_addr relocation to
                    // a symbol that never gets defined (link error). This happens for static members
                    // of a class expression used only as a default-parameter type.
                    if (!isGlobalDefined)
                    {
                        continue;
                    }
                }

                // TODO: finish the DI logic
                unsigned alignInBits = llvmTypeConverter.getPointerBitwidth();
                auto diType = di.getDIType(location, mlir::Type(), dataType, file, line, file);

                // MLIRTypeHelper mth(module.getContext());
                // if ((mth.isAnyFunctionType(dataType) || isa<mlir_ts::TupleType>(dataType)) && argIndex > 0) {
                //     diType = di.getDIPointerType(diType, file, line);
                // }

                auto name = namedLoc.getName();
                auto scope = scopeFusedLoc.getMetadata();
                
                LLVM_DEBUG(llvm::dbgs() << "\n!! name: " << name << " scope: " << scope << "\n");

                if (isGlobal)
                {
                    // recreate globalVar later to set correct LinkageAttr and isDefined
                    auto varInfo = LLVM::DIGlobalVariableAttr::get(
                        location.getContext(), scope, name, linkageNameAttr,
                        file, line, diType, false, isGlobalDefined, alignInBits);
                    op->setLoc(mlir::FusedLoc::get(location.getContext(), {location}, varInfo));
                }
                else
                {
                    auto varInfo = LLVM::DILocalVariableAttr::get(
                        location.getContext(), scope, name, file, line, argIndex, alignInBits, diType, LLVM::DIFlags::Zero);
                    op->setLoc(mlir::FusedLoc::get(location.getContext(), {location}, varInfo));
                }
            }
        }
    }    

    return success();
}

static LogicalResult setDISubProgramTypesToFormOp(mlir::ModuleOp &module, LLVMTypeConverter &llvmTypeConverter, CompileOptions& compileOptions)
{
    // fixes for FuncOps, and it should be first
    SmallPtrSet<Operation *, 16> workSetFuncOps;

    selectAllFuncOp(module, workSetFuncOps);

    for (auto op : workSetFuncOps)
    {
        if (auto funcOp = dyn_cast<mlir_ts::FuncOp>(op)) {
            // debug info - adding return type
            auto hasBody = !funcOp.getBody().empty();
            if ((funcOp.getResultTypes().size() > 0 || funcOp.getArgumentTypes().size() > 0) && hasBody)
            {
                LLVM_DEBUG(llvm::dbgs() << "\n!! function fix: " << funcOp.getName() << "\n");

                LLVMDebugInfoHelperFixer ldif(funcOp, &llvmTypeConverter, compileOptions);
                ldif.fix();
            } else if (!hasBody) {
                // func declaration, we do not need Debug info for it
                funcOp->setLoc(mlir::UnknownLoc::get(funcOp->getContext()));
            }
        }
    }

    return success();
}

static void selectAllUnrealizedConversionCast(mlir::ModuleOp &module, SmallPtrSet<Operation *, 16> &workSet)
{
    auto visitorUnrealizedConversionCast = [&](Operation *op) {
        if (auto unrealizedConversionCastOp = dyn_cast_or_null<UnrealizedConversionCastOp>(op))
        {
            workSet.insert(unrealizedConversionCastOp);
        }
    };

    module.walk(visitorUnrealizedConversionCast);
}

static LogicalResult cleanupUnrealizedConversionCast(mlir::ModuleOp &module)
{
    SmallPtrSet<Operation *, 16> workSet;

    selectAllUnrealizedConversionCast(module, workSet);

    SmallPtrSet<Operation *, 16> removed;

    for (auto op : workSet)
    {
        if (removed.find(op) != removed.end())
        {
            continue;
        }

        auto unrealizedConversionCastOp = cast<UnrealizedConversionCastOp>(op);

        LLVM_DEBUG(llvm::dbgs() << "\nUnrealizedConversionCastOp to analyze: \n" << unrealizedConversionCastOp << "\n";);

        auto hasAnyUse = false;
        for (auto user : unrealizedConversionCastOp.getResult(0).getUsers())
        {
            hasAnyUse = true;
            auto nextUnrealizedConversionCastOp = dyn_cast_or_null<UnrealizedConversionCastOp>(user);
            if (nextUnrealizedConversionCastOp)
            {
                LLVM_DEBUG(llvm::dbgs() 
                    << "\n -> Next UnrealizedConversionCastOp: \n" 
                    << nextUnrealizedConversionCastOp 
                    << " <- result type: " 
                    << nextUnrealizedConversionCastOp.getResult(0).getType() 
                    << " -> input: " << unrealizedConversionCastOp.getOperand(0).getType() 
                    << "\n";);

                if (nextUnrealizedConversionCastOp.getResult(0).getType() == unrealizedConversionCastOp.getOperand(0).getType())
                {
                    // remove both
                    nextUnrealizedConversionCastOp->getResult(0).replaceAllUsesWith(unrealizedConversionCastOp.getOperand(0));
                    
                    removed.insert(nextUnrealizedConversionCastOp);
                    if (removed.find(unrealizedConversionCastOp) == removed.end())
                    {
                        removed.insert(unrealizedConversionCastOp);
                    }                    
                }
            }
        }

        if (!hasAnyUse)
        {
            removed.insert(unrealizedConversionCastOp);
        }
    }    

    for (auto removedOp : removed)
    {
        removedOp->erase();
    }

    return success();
}

// A TypeScript `main` returning nothing lowers to `void @main()`, and the C runtime that calls it
// reads an exit code out of the return register regardless. Whatever the last instruction happened
// to leave there became the process's exit code: zero under `gc` and `none` by luck, and 1 under
// `rc`, where the last thing `main` does is give back a reference. So an ahead-of-time `rc` build
// of `function main() { print(1); }` printed the right answer and told the shell it had failed.
//
// Give the entry point the signature its caller assumes: `i32 @main()` returning 0. Only for a
// `main` that returns nothing and takes nothing - a `main` returning a value is left alone here,
// and is a separate question (today it lowers to `double @main()`, which is wrong in the same way
// and for the same reason).
//
// The test for "will be linked into an executable" is not `isExecutable`: that is only true for
// `--emit=exe`, and everything that links a program here compiles with `--emit=obj` and calls the
// linker itself, which is how this went unnoticed once already. A JIT run has no C runtime reading
// a return register, and a DLL's `main` is not an entry point and may be something an importer
// resolves, so those two are the exclusions.
static void giveEntryPointAnExitCode(mlir::ModuleOp m, CompileOptions &compileOptions)
{
    if (compileOptions.isJit || compileOptions.isDLL)
    {
        return;
    }

    auto funcOp = dyn_cast_or_null<LLVM::LLVMFuncOp>(m.lookupSymbol(MAIN_ENTRY_NAME));
    if (!funcOp || funcOp.getBody().empty())
    {
        return;
    }

    auto funcType = funcOp.getFunctionType();
    if (funcType.getNumParams() != 0 || !isa<LLVM::LLVMVoidType>(funcType.getReturnType()))
    {
        return;
    }

    // A call inside the module would be left calling a signature that no longer matches. Nothing
    // generates one today - `main` is the entry point, and top-level code that needs to run before
    // it becomes a global constructor - but a silent type mismatch is not the failure to risk.
    auto hasInternalCaller = false;
    m.walk([&](LLVM::CallOp callOp) {
        if (callOp.getCallee() && callOp.getCallee().value() == MAIN_ENTRY_NAME)
        {
            hasInternalCaller = true;
        }
    });

    if (hasInternalCaller)
    {
        return;
    }

    mlir::OpBuilder builder(funcOp);
    auto i32Type = builder.getI32Type();
    funcOp.setFunctionType(LLVM::LLVMFunctionType::get(i32Type, {}, false));

    SmallVector<LLVM::ReturnOp> returns;
    funcOp.walk([&](LLVM::ReturnOp returnOp) {
        if (returnOp.getNumOperands() == 0)
        {
            returns.push_back(returnOp);
        }
    });

    for (auto returnOp : returns)
    {
        mlir::OpBuilder returnBuilder(returnOp);
        auto zero = returnBuilder.create<LLVM::ConstantOp>(returnOp.getLoc(), i32Type,
                                                           returnBuilder.getI32IntegerAttr(0));
        returnBuilder.create<LLVM::ReturnOp>(returnOp.getLoc(), mlir::ValueRange{zero});
        returnOp.erase();
    }
}

void TypeScriptToLLVMLoweringPass::runOnOperation()
{
    auto m = getOperation();

    // The type converter sizes pointers, structs and unions and computes alignment with this layout,
    // so it has to be the target's. MLIRGenModule has already put the TargetMachine's layout on the
    // module. LLVM's default layout - what this used before - has 8-byte pointers and a 4-byte-aligned
    // i64, wrong for i686 in the first and for x64 in the second, so a module without the attribute is
    // an error rather than a fallback. SizeOfOp does not read this layout (it emits getelementptr
    // null, 1, which LLVM folds with the module's layout), but union storage sizing
    // (getUnionStorageSize), getIntPtrType and debug-info offsets do. Checked before anything else, so
    // the pass fails before it has changed the module (the @dllname renames below).
    auto dataLayoutAttr = m->getAttrOfType<mlir::StringAttr>(mlir::LLVM::LLVMDialect::getDataLayoutAttrName());
    if (!dataLayoutAttr)
    {
        m.emitError() << "module has no '" << mlir::LLVM::LLVMDialect::getDataLayoutAttrName()
                      << "' attribute; MLIRGenModule sets it from the target triple's TargetMachine, and lowering "
                         "will not guess a layout";
        signalPassFailure();
        return;
    }

    auto parsedDataLayout = llvm::DataLayout::parse(dataLayoutAttr.getValue());
    if (!parsedDataLayout)
    {
        m.emitError() << "invalid data layout '" << dataLayoutAttr.getValue()
                      << "': " << llvm::toString(parsedDataLayout.takeError());
        signalPassFailure();
        return;
    }

    // @dllname on a global: unlike a function, an LLVM global carries no string attribute
    // ExportFixPass could rename it by, so rename the symbol and its uses here instead
    SmallVector<mlir_ts::GlobalOp> renamedGlobals;
    m.walk([&](mlir_ts::GlobalOp globalOp) {
        if (globalOp->hasAttr(DLL_NAME))
        {
            renamedGlobals.push_back(globalOp);
        }
    });

    for (auto globalOp : renamedGlobals)
    {
        auto dllName = globalOp->getAttrOfType<mlir::StringAttr>(DLL_NAME);
        globalOp->removeAttr(DLL_NAME);
        if (failed(SymbolTable::replaceAllSymbolUses(globalOp, dllName, m)))
        {
            globalOp.emitError("can't rename global to @dllname '") << dllName.getValue() << "'";
            signalPassFailure();
            return;
        }

        SymbolTable::setSymbolName(globalOp, dllName);
    }

    // @dllname/@linkname on a function: renamed here rather than in ExportFixPass, where LLVM's
    // setName silently makes a taken name unique ("strlen.1") and the call binds nothing.
    // Several TS declarations may bind one C symbol; the ones with the same TS type collapse into
    // one op. The type is compared as the TS type, not the LLVM one: string and Opaque both lower
    // to ptr, but the calls are still TS-typed here, and redirecting one to a callee of another
    // signature would fail the verifier.
    SmallVector<mlir_ts::FuncOp> renamedFuncs;
    // every name a rename moves a function away from, and where it goes: binding one of these
    // would bind whichever function holds the name when the loop gets there, so it is an error
    // whatever the order of the two declarations
    llvm::DenseMap<mlir::StringAttr, mlir::StringAttr> vacatedNames;
    m.walk([&](mlir_ts::FuncOp funcOp) {
        auto dllName = funcOp->getAttrOfType<mlir::StringAttr>(DLL_NAME);
        if (!dllName)
        {
            return;
        }

        // naming the symbol the function already has is a no-op; dropped up front so the loop
        // below never meets a still-attributed op under the target name
        if (dllName == funcOp.getSymNameAttr())
        {
            funcOp->removeAttr(DLL_NAME);
            return;
        }

        renamedFuncs.push_back(funcOp);
        vacatedNames[funcOp.getSymNameAttr()] = dllName;
    });

    for (auto funcOp : renamedFuncs)
    {
        auto dllName = funcOp->getAttrOfType<mlir::StringAttr>(DLL_NAME);
        funcOp->removeAttr(DLL_NAME);

        auto vacated = vacatedNames.find(dllName);
        if (vacated != vacatedNames.end())
        {
            funcOp.emitError("'") << funcOp.getSymName() << "' binds symbol '" << dllName.getValue()
                                  << "', which @dllname/@linkname renames to '" << vacated->second.getValue() << "'";
            signalPassFailure();
            return;
        }

        auto existingSymbol = SymbolTable::lookupSymbolIn(m, dllName);
        if (existingSymbol)
        {
            auto existingFunc = dyn_cast<mlir_ts::FuncOp>(existingSymbol);
            if (!existingFunc)
            {
                funcOp.emitError("'") << funcOp.getSymName() << "' binds symbol '" << dllName.getValue()
                                      << "', which is not a function";
                signalPassFailure();
                return;
            }

            if (existingFunc.getFunctionType() != funcOp.getFunctionType())
            {
                funcOp.emitError("'") << funcOp.getSymName() << "' binds symbol '" << dllName.getValue()
                                      << "' with type " << funcOp.getFunctionType() << ", but '"
                                      << existingFunc.getSymName() << "' declares it with type "
                                      << existingFunc.getFunctionType();
                signalPassFailure();
                return;
            }

            if (!funcOp.isExternal() && !existingFunc.isExternal())
            {
                funcOp.emitError("'") << funcOp.getSymName() << "' and '" << existingFunc.getSymName()
                                      << "' both define symbol '" << dllName.getValue() << "'";
                signalPassFailure();
                return;
            }

            if (failed(SymbolTable::replaceAllSymbolUses(funcOp, dllName, m)))
            {
                funcOp.emitError("can't rename function to @dllname '") << dllName.getValue() << "'";
                signalPassFailure();
                return;
            }

            // keep whichever of the two has the body
            if (funcOp.isExternal())
            {
                funcOp.erase();
            }
            else
            {
                existingFunc.erase();
                SymbolTable::setSymbolName(funcOp, dllName);
            }

            continue;
        }

        if (failed(SymbolTable::replaceAllSymbolUses(funcOp, dllName, m)))
        {
            funcOp.emitError("can't rename function to @dllname '") << dllName.getValue() << "'";
            signalPassFailure();
            return;
        }

        SymbolTable::setSymbolName(funcOp, dllName);
    }

    // The first thing to define is the conversion target. This will define the
    // final target for this lowering. For this lowering, we are only targeting
    // the LLVM dialect.
    LLVMConversionTarget target(getContext());
    target.addLegalOp<ModuleOp>();

    // During this lowering, we will also be lowering the MemRef types, that are
    // currently being operated on, to a representation in LLVM. To perform this
    // conversion we use a TypeConverter as part of the lowering. This converter
    // details how one type maps to another. This is necessary now that we will be
    // doing more complicated lowerings, involving loop region arguments.
    mlir::DataLayout dl(m);
    LowerToLLVMOptions options(&getContext(), dl);
    options.dataLayout = *parsedDataLayout;

    options.allocLowering = LowerToLLVMOptions::AllocLowering::AlignedAlloc;
    DataLayoutAnalysis analysis(m);
    LLVMTypeConverter typeConverter(&getContext(), options, &analysis);

    // Now that the conversion target has been defined, we need to provide the
    // patterns used for lowering. At this point of the compilation process, we
    // have a combination of `typescript`, `affine`, and `std` operations. Luckily, there
    // are already exists a set of patterns to transform `affine` and `std`
    // dialects. These patterns lowering in multiple stages, relying on transitive
    // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
    // patterns must be applied to fully transform an illegal operation into a
    // set of legal ones.
    RewritePatternSet patterns(&getContext());
    populateAffineToStdConversionPatterns(patterns);
    arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
    index::populateIndexToLLVMConversionPatterns(typeConverter, patterns);
    cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
    cf::populateAssertToLLVMConversionPattern(typeConverter, patterns);
    populateMathToLLVMConversionPatterns(typeConverter, patterns);
    populateFuncToLLVMConversionPatterns(typeConverter, patterns);

#ifdef ENABLE_ASYNC
    populateAsyncStructuralTypeConversionsAndLegality(typeConverter, patterns, target);
#endif

    // The only remaining operation to lower from the `typescript` dialect, is the PrintOp.
    TsLlvmContext tsLlvmContext{tsContext.compileOptions};
    for (auto existing : m.getBody()->getOps<mlir_ts::GlobalConstructorOp>())
    {
        tsLlvmContext.nextGlobalConstructorPriority =
            std::max<int64_t>(tsLlvmContext.nextGlobalConstructorPriority, existing.getPriority().getSExtValue() + 1);
    }

    patterns.insert<
        AddressOfOpLowering, ArithmeticUnaryOpLowering, ArithmeticBinaryOpLowering,
        AssertOpLowering, CastOpLowering, ConstantOpLowering, DefaultOpLowering, 
        OptionalOpLowering, ValueOptionalOpLowering, UndefOptionalOpLowering, HasValueOpLowering, ValueOpLowering, 
        ValueOrDefaultOpLowering, SymbolRefOpLowering, GlobalOpLowering, GlobalResultOpLowering,
        FuncOpLowering, LoadOpLowering, ElementRefOpLowering, PropertyRefOpLowering, ExtractPropertyOpLowering,
        PointerOffsetRefOpLowering, LogicalBinaryOpLowering, NullOpLowering, NewOpLowering, CreateTupleOpLowering,
        DeconstructTupleOpLowering, CreateArrayOpLowering, NewEmptyArrayOpLowering, NewArrayOpLowering, ArrayPushOpLowering,
        ArrayPopOpLowering, ArrayUnshiftOpLowering, ArrayShiftOpLowering, ArraySpliceOpLowering, ArrayViewOpLowering, DeleteOpLowering, 
        ParseFloatOpLowering, ParseIntOpLowering, IsNaNOpLowering, PrintOpLowering, ConvertFOpLowering, StoreOpLowering, SizeOfOpLowering, TypeDescriptorOpLowering, RetainOpLowering, ReleaseOpLowering, RetainSlotOpLowering, ReleaseSlotOpLowering, RetainCellOpLowering, ReleaseCellOpLowering, 
        InsertPropertyOpLowering, LengthOfOpLowering, SetLengthOfOpLowering, StringLengthOpLowering, StringResizeOpLowering, StringConcatOpLowering, StringCopyOpLowering,
        SharedNewOpLowering, SharedValueRefOpLowering, SharedCountOpLowering,
        StringCompareOpLowering, AnyCompareOpLowering, CharToStringOpLowering, UndefOpLowering, CopyStructOpLowering, MemoryCopyOpLowering, MemoryMoveOpLowering, 
        LoadSaveValueLowering, ThrowUnwindOpLowering, ThrowCallOpLowering, VariableOpLowering, DebugVariableOpLowering, AllocaOpLowering, InvokeOpLowering, 
        InvokeHybridOpLowering, VirtualSymbolRefOpLowering, ThisVirtualSymbolRefOpLowering, InterfaceSymbolRefOpLowering, 
        NewInterfaceOpLowering, VTableOffsetRefOpLowering, LoadBoundRefOpLowering, StoreBoundRefOpLowering, CreateBoundRefOpLowering, 
        CreateBoundFunctionOpLowering, GetThisOpLowering, GetMethodOpLowering, TypeOfOpLowering, TypeOfAnyOpLowering, DebuggerOpLowering,
        UnreachableOpLowering, SymbolCallInternalOpLowering, CallInternalOpLowering, CallHybridInternalOpLowering, 
        ReturnInternalOpLowering, NoOpLowering, GlobalConstructorOpLowering, AppendToUsedOpLowering, ExtractInterfaceThisOpLowering, 
        ExtractInterfaceVTableOpLowering, BoxOpLowering, UnboxOpLowering, DialectCastOpLowering, CreateUnionInstanceOpLowering,
        GetValueFromUnionOpLowering, GetTypeInfoFromUnionOpLowering, BodyInternalOpLowering, BodyResultInternalOpLowering
#ifndef DISABLE_SWITCH_STATE_PASS
        ,
        SwitchStateOpLowering, StateLabelOpLowering, YieldReturnValOpLowering
#endif
        ,
        SwitchStateInternalOpLowering, LoadLibraryPermanentlyOpLowering, SearchForAddressOfSymbolOpLowering,
        AtomicRMWOpLowering, AtomicCmpXchgOpLowering, FenceOpLowering, InlineAsmOpLowering, CallIntrinsicOpLowering, LinkerOptionsOpLowering>(
            typeConverter, &getContext(), &tsLlvmContext);

    if (tsLlvmContext.compileOptions.isWindows)
    {
        using namespace windows;

        patterns.insert<
            LandingPadOpLowering, CompareCatchTypeOpLowering, BeginCatchOpLowering,
            SaveCatchVarOpLowering, EndCatchOpLowering, BeginCleanupOpLowering, EndCleanupOpLowering>(
                typeConverter, &getContext(), &tsLlvmContext);        
    }
    else
    {
        using namespace linux;

        patterns.insert<
            LandingPadOpLowering, CompareCatchTypeOpLowering, BeginCatchOpLowering,
            SaveCatchVarOpLowering, EndCatchOpLowering, BeginCleanupOpLowering, EndCleanupOpLowering>(
                typeConverter, &getContext(), &tsLlvmContext);        
    }

#ifdef ENABLE_TYPED_GC
    patterns.insert<
        GCMakeDescriptorOpLowering, GCNewExplicitlyTypedOpLowering>(typeConverter, &getContext(), &tsLlvmContext);
#endif        

    mlir::SmallPtrSet<mlir::Type, 32> usedTypes;
    populateTypeScriptConversionPatterns(typeConverter, m, usedTypes, tsContext.compileOptions);

    // in processing ops types will be changed by LLVM versions overtime, we need to have actual information about types 
    // when generate Debug Info
    if (tsLlvmContext.compileOptions.generateDebugInfo)
    {
        setDISubProgramTypesToFormOp(m, typeConverter, tsContext.compileOptions);
        preserveTypesForDebugInfo(m, typeConverter, tsContext.compileOptions);
    }

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

    if (failed(applyFullConversion(m, target, std::move(patterns))))
    {
        signalPassFailure();
    }

    LLVM_DEBUG(llvm::dbgs() << "\n!! AFTER DUMP - BEFORE CLEANUP: \n" << m << "\n";);

    cleanupUnrealizedConversionCast(m);

    giveEntryPointAnExitCode(m, tsContext.compileOptions);

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

    LLVM_DEBUG(verifyModule(m););
}

/// Create a pass for lowering operations the remaining `TypeScript` operations, as
/// well as `Affine` and `Std`, to the LLVM dialect for codegen.
std::unique_ptr<mlir::Pass> mlir::typescript::createLowerToLLVMPass(CompileOptions &compileOptions)
{
    return std::make_unique<TypeScriptToLLVMLoweringPass>(compileOptions);
}