#include "tensorflow/compiler/mlir/tensorflow/transforms/test_passes.h.inc"

class ResourceAnalyzerTestPass
    : public impl::ResourceAnalyzerTestPassBase<ResourceAnalyzerTestPass> {
 public:
  void runOnOperation() override;
};

// A set of values that identifies a resource.
struct ResourceKey {
  StringRef device;
  StringRef container;
  StringRef shared_name;
};

 public:
  LiftVariablesTestPass() { session_ = new TF::test_util::FakeSession(); }

  ~LiftVariablesTestPass() override { delete session_; }

  void runOnOperation() override {
    ModuleOp module = getOperation();
    if (failed(tf_saved_model::LiftVariables(module, session_)))
      signalPassFailure();
  }

 private:
  Session* session_;
};

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OptimizeGraphPass)

  explicit OptimizeGraphPass() = default;

 private:
  void runOnOperation() override;
};

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/optimize_graph.inc"

void OptimizeGraphPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RuntimeVerifyPass)

  explicit RuntimeVerifyPass() {}

 private:
  void runOnOperation() override;
};

void RuntimeVerifyPass::runOnOperation() {
  getOperation().walk([&](TflRuntimeVerifyOpInterface op) {
    if (failed(op.VerifyTflRuntimeConstraints(
            op.getOperation(), /*emit_error_on_verify_fail=*/true)))

      : passes_(std::move(passes)) {}

 protected:
  void runOnOperation() override;

  // The passes to run on the module.
  std::vector<GraphOptimizationPass*> passes_;
};
}  // anonymous namespace

void GraphOptPass::runOnOperation() {
  mlir::ModuleOp module_in = getOperation();
  mlir::MLIRContext& ctx = getContext();

  // Convert MLIR to Graph

          TestPreCalibrationComponentPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPreCalibrationComponentPass)

 private:
  void runOnOperation() override;
};

void TestPreCalibrationComponentPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext& ctx = getContext();

  // Simply runs the PreCalibrationComponent with a default configuration.

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(XlaCallModuleToCallPass)

  explicit XlaCallModuleToCallPass() = default;

 private:
  void runOnOperation() override;
};

// Converts XlaCallModuleOps to func.call.
class XlaCallModuleOpToCallOp : public OpRewritePattern<TF::XlaCallModuleOp> {
 public:
  explicit XlaCallModuleOpToCallOp(MLIRContext* context)

#include "tensorflow/compiler/mlir/tensorflow/transforms/test_passes.h.inc"

struct TestClusteringPolicyPass
    : public impl::TestClusteringPolicyPassBase<TestClusteringPolicyPass> {
  void runOnOperation() override;
};

// Clustering policy for `test.OpA` and `test.OpB` operations;
class TestOpsClusteringPolicy : public ClusteringPolicy {
  LogicalResult MatchAndUpdateConstraints(

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

struct MoveTpuCompileToFrontPass
    : public impl::MoveTpuCompileToFrontPassBase<MoveTpuCompileToFrontPass> {
  void runOnOperation() override;
};

void MarkCompilationOps(Operation* func) {
  func->walk([&](Operation* op) {
    if (llvm::isa<TF::_TPUCompileMlirOp>(op)) {
      op->setAttr("_is_compilation", UnitAttr::get(func->getContext()));

  // Check if TF dialect ops exist over the module.
  void runOnOperation() override;

 private:
  std::vector<std::string> accepted_dialects_;
  std::vector<std::string> optional_accepted_dialects_;
};
}  // namespace

void CheckAcceptedOpsPass::runOnOperation() {
  getOperation()->walk([&](Operation *op) {
    auto dialect_name = op->getDialect()->getNamespace();