"Whether to serialize TPUCompileMetadataProto metadata in 'tf._TPUCompileMlir' op as a proto debug string">
  ];

  let dependentDialects = [
    "mlir::mhlo::MhloDialect",
    "mlir::tf_device::TensorFlowDeviceDialect"
  ];
  let constructor = "mlir::TFTPU::CreateTPURewritePass()";
}

namespace mlir {
namespace quant {
class QuantizationDialect;
}
namespace quantfork {
class QuantizationForkDialect;
}
namespace mhlo {
class MhloDialect;
}
namespace TF {
class TensorFlowDialect;
}
namespace TFL {
class TFLDialect;
typedef TFLDialect TensorFlowLiteDialect;
}  // namespace TFL
namespace func {
class FuncOp;
}
class ModuleOp;

  MLIRContext *ctx = &getContext();
  func::FuncOp func = getOperation();
  ConversionTarget target(*ctx);
  target.addLegalDialect<TF::TensorFlowDialect, mhlo::MhloDialect,
                         chlo::ChloDialect>();
  target.addIllegalOp<
      TF::UniformQuantizeOp, TF::UniformRequantizeOp, TF::UniformDequantizeOp,
      TF::UniformQuantizedDotOp, TF::UniformQuantizedDotHybridOp,

  let constructor = "CreatePrepareTFPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect",
    "mlir::quant::QuantizationDialect",
    "mlir::quantfork::QuantizationForkDialect",
    "mhlo::MhloDialect"
  ];
  let options = [
      Option<"unfold_batch_matmul_", "unfold_batchmatmul",
             "bool", "true",
             "Unfold BatchMatMul into individual MatMul ops.">,

class ConvertTfQuantToMhloIntTest : public Test {
 protected:
  void SetUp() override {
    DialectRegistry dialects;
    dialects.insert<TF::TensorFlowDialect, func::FuncDialect, chlo::ChloDialect,
                    mhlo::MhloDialect, quant::QuantizationDialect>();
    ctx_ = std::make_unique<MLIRContext>(dialects);
    ctx_->loadAllAvailableDialects();

    // Create a CPU client with 1 device.
    TF_ASSERT_OK_AND_ASSIGN(

 public:
  StablehloToOdmlTypeConverter() : vhlo::VhloTypeConverter() {
    addConversion([](Type type) {
      if (type.getDialect().getNamespace() ==
          vhlo::VhloDialect::getDialectNamespace()) {
        return type;
      }
      LLVM_DEBUG(llvm::dbgs() << "Invalid type: " << type << '\n');
      return Type();
    });
    addConversion([](stablehlo::TokenType token) {

 public:
  StablehloVhloTypeConverter() : mlir::vhlo::VhloTypeConverter() {
    addConversion([](mlir::Type type) -> mlir::Type {
      if (type.getDialect().getNamespace() ==
          mlir::vhlo::VhloDialect::getDialectNamespace()) {
        return type;
      }
      return {};
    });
    addConversion([](mlir::stablehlo::TokenType token) -> mlir::Type {
      return mlir::vhlo::TokenV1Type::get(token.getContext());

    return "Legalize TF_XlaCallModule Op to stablehlo";
  }
  void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<stablehlo::StablehloDialect, vhlo::VhloDialect,
                    quant::QuantizationDialect, shape::ShapeDialect>();
  }

  void runOnOperation() override {
    ModuleOp module_op = getOperation();
    RewritePatternSet patterns(&getContext());

def MergeFusionWithDequantizePass : Pass<"stablehlo-merge-fusion-with-dequantize", "mlir::ModuleOp"> {
  let summary = "Merge quantized conv/dot_general fusion with subsequent dequantize.";
  let dependentDialects = [
    "chlo::ChloDialect",
    "mlir::stablehlo::StablehloDialect",
  ];
}

def UnwrapXlaCallModuleOpPass : Pass<"stablehlo-unwrap-xla-call-module-op", "ModuleOp"> {