}
};

}  // namespace

MlrtDialect::MlrtDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"mlrt", context,
                    mlir::TypeID::get<MlrtDialect>()) {
  addTypes<FutureType>();
  addTypes<PromiseType>();
  addTypes<AsyncHandleType>();
  addInterfaces<MlrtInlinerInterface>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/mlrt_ops.cpp.inc"
      >();
}

		return nil, err
	}
	d.unit = u
	return d, nil
}

// AddTypes will add one .debug_types section to the DWARF data. A
// typical object with DWARF version 4 debug info will have multiple
// .debug_types sections. The name is used for error reporting only,
// and serves to distinguish one .debug_types section from another.
func (d *Data) AddTypes(name string, types []byte) error {
	return d.parseTypes(name, types)
}

namespace tfrt {
namespace fallback {

FallbackDialect::FallbackDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfrt_fallback", context,
              TypeID::get<FallbackDialect>()) {
  addTypes<TFTensorType, TFAllocatorType>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.cpp.inc"
      >();
}

/// Parse a type registered to this dialect.

      .def(py::init([](mlir::Location loc, std::string name) {
        return mlir::OperationState(loc, llvm::StringRef(name));
      }))
      .def("addTypes",
           [](mlir::OperationState& state, std::vector<mlir::Type> tys) {
             state.addTypes(mlir::ArrayRef<mlir::Type>(tys));
           })
      .def("addOperands",
           [](mlir::OperationState& os, std::vector<mlir::Value> ops) {

};

}  // namespace

TensorflowMlrtDialect::TensorflowMlrtDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"tf_mlrt", context,
                    mlir::TypeID::get<TensorflowMlrtDialect>()) {
  addTypes<TFTensorType, TFDeviceType>();
  addInterfaces<TensorflowMlrtInlinerInterface>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_mlrt_ops.cpp.inc"
      >();

                         _FusedBatchNormExOp::getOperationName());
    state.addOperands(batch_norm.getOperands());
    if (side_input) state.operands.push_back(side_input);
    state.addTypes(batch_norm.getResultTypes());
    state.addAttributes(batch_norm->getAttrs());
    Operation *op = rewriter.create(state);
    rewriter.replaceOp(batch_norm, op->getResults());

class OperationState:
    def __init__(self, arg0: Location, arg1: str) -> None: ...
    def addOperands(self, arg0: list[Value]) -> None: ...
    def addRegion(self) -> Region: ...
    def addTypes(self, arg0: list[Type]) -> None: ...

class RankedTensorType(Type):
    def __init__(self, *args, **kwargs) -> None: ...
    def get(self, arg0: Type) -> RankedTensorType: ...

class Region:

#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_executor.cc.inc"
      >();

  addInterfaces<TensorFlowExecutorInlinerInterface,
                TensorFlowExecutorDialectFoldInterface>();

  addTypes<ControlType, TokenType>();
}

Type TensorFlowExecutorDialect::parseType(DialectAsmParser &parser) const {
  StringRef data_type;
  if (parser.parseKeyword(&data_type)) return Type();

  // Create the TF op
  const std::string tf_op_full_name = absl::StrCat("tf.", node_def.op());
  mlir::OperationState op_state(loc, tf_op_full_name);
  op_state.addOperands(func.getArguments());
  op_state.addTypes(output_tys);
  op_state.addAttributes(attrs);
  mlir::Operation* tf_op = op_builder.create(op_state);
  op_builder.create<mlir::func::ReturnOp>(loc, tf_op->getResults());

  // Run the decompose passes on the module

    llvm::SmallVector<mlir::Type, 4> output_tys;
    for (int i = 0; i < custom_op.getNumResults(); i++) {
      output_tys.push_back(custom_op.getType(i));
    }
    op_state.addTypes(output_tys);
    op_state.addAttributes(attr);
    auto stablehlo_op = builder.create(op_state);
    custom_op.replaceAllUsesWith(stablehlo_op);
    custom_op.erase();
  });
}