analyzer.IsPotentiallyWritten(var_handle_op.getResource())));
    }
  });
}

void ResourceAnalyzerTestPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  TF::ResourceAnalyzer resource_analyzer(module_op);

  PrintAnalysisResults(resource_analyzer, module_op);
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateResourceAnalyzerTestPass() {

  // third_party/tensorflow/compiler/mlir/tfrt/transforms/lower_saved_model.cc
  // with the original code trimmed and adapted as needed.
  void runOnOperation() override {
    auto module = getOperation();
    if (!tf_saved_model::HasTfSavedModelSemantics(module)) return;

    // Clean up functions from tf_saved_model attributes.
    OpBuilder builder(module);

      InsertCallOnceOpFromSessionInitializerPass)

 private:
  void runOnOperation() override;
};

void InsertCallOnceOpFromSessionInitializerPass::runOnOperation() {
  ModuleOp module = getOperation();

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module)) {
    for (auto func : module.getOps<func::FuncOp>()) {
      auto dict_attr =

  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.
  PreCalibrationComponent component(&ctx);
  QuantizationConfig quantization_config{};

    rewriter.replaceOpWithNewOp<func::CallOp>(op, entry_func_op, op.getArgs());
    return success();
  }
};

void XlaCallModuleToCallPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = module_op.getContext();
  RewritePatternSet patterns(&getContext());
  patterns.add<XlaCallModuleOpToCallOp>(ctx);
  if (failed(applyPatternsAndFoldGreedily(module_op, std::move(patterns)))) {

        operands.Insert(op->getOperand(0), ValueConstraint::kShape);
    }

    return success();
  }
};

void TestClusteringPolicyPass::runOnOperation() {
  func::FuncOp func = getOperation();
  ValuesConstraintSet constraints;

  ClusteringPolicySet policies;
  policies.Add<TestOpsClusteringPolicy>();

  // Initialize constraints based on the return type attributes.

  }

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MockSuccessPass)

  explicit MockSuccessPass() = default;

 private:
  void runOnOperation() override {
    getOperation().walk([](Operation* nestedOp) {
      nestedOp->emitError()
          << "Error at " << nestedOp->getName().getStringRef().str() << " op";
    });
  };
};

// MockFailurePass reports errors and fails.

class DedupBoundInputBindingPass
    : public impl::DedupBoundInputBindingPassBase<DedupBoundInputBindingPass> {
  void runOnOperation() final;
};

void DedupBoundInputBindingPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!mlir::tf_saved_model::IsExported(func)) return;
  llvm::SmallDenseMap<Attribute, unsigned, 8> unique_bound_inputs;
  llvm::BitVector arg_indices_to_erase(func.getNumArguments());

    : public impl::LegalizeVariablesPassBase<LegalizeVariablesPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LegalizeVariablesPass)

  void runOnOperation() override {
    auto module = getOperation();
    // If TFLite variable legalization is not allowed, then we skip this pass.
    if (auto legalize_tfl_variables_attr =
            module->getAttr(kLegalizeTflVariables)) {

  mlir::tf_device::LaunchOp launch = CreateLaunchForBlock(
      builder, cluster, /*before=*/false, launch_block, host_device);

  auto operand_not_in_launch = [&](mlir::OpOperand& operand) {
    return !launch.getOperation()->isProperAncestor(operand.getOwner());
  };
  for (auto result : llvm::zip(launch.GetBody().getTerminator()->getOperands(),
                               launch.getResults()))