public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(NoOpPass)

  NoOpPass() = default;

  llvm::StringRef getArgument() const final { return "no-op-pass"; }

  void runOnOperation() override {
    // Noop pass does nothing on the operation.
  }
};

std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> CreateNoOpPass() {
  return std::make_unique<NoOpPass>();

namespace mlir {
namespace quant {
namespace {

constexpr StringRef kSharedNameAttr = "shared_name";

class LiftHashTableOpsAsArgsPass
    : public PassWrapper<LiftHashTableOpsAsArgsPass, OperationPass<ModuleOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LiftHashTableOpsAsArgsPass)
  explicit LiftHashTableOpsAsArgsPass() = default;

  StringRef getArgument() const final {

  let summary = "Insert CallOnce op when tf_saved_model's session initializer is give.";
  let constructor = "CreateInsertCallOnceOpFromSessionInitializerPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def LegalizeHashTablesPass : Pass<"tfl-legalize-hashtables-tf", "mlir::ModuleOp"> {

  // Load the TFR functions in a mlir::ModuleOp
  auto memory_buffer = llvm::MemoryBuffer::getMemBuffer(
      llvm::StringRef(tfr_raw_text.data(), tfr_raw_text.size()));
  llvm::SourceMgr source_mgr;
  source_mgr.AddNewSourceBuffer(std::move(memory_buffer), llvm::SMLoc());
  mlir::OwningOpRef<mlir::ModuleOp> module =
      mlir::parseSourceFile<mlir::ModuleOp>(source_mgr, mlir_ctx);
  // The MLIRContext owns the module

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// Functionalities for exporting MLIR ModuleOp to TensorFlow SavedModel.

#ifndef TENSORFLOW_COMPILER_MLIR_QUANTIZATION_STABLEHLO_CC_SAVED_MODEL_EXPORT_H_
#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_STABLEHLO_CC_SAVED_MODEL_EXPORT_H_

#include <optional>

namespace {

constexpr StringRef kTestClusterName = "tpu0";

absl::StatusOr<OwningOpRef<ModuleOp>> GetMlirModuleFromString(
    StringRef string, MLIRContext* context) {
  DialectRegistry mlir_registry;
  RegisterAllTensorFlowDialects(mlir_registry);
  context->appendDialectRegistry(mlir_registry);
  OwningOpRef<ModuleOp> mlir_module;
  auto status =
      tensorflow::DeserializeMlirModule(string, context, &mlir_module);

using ::mlir::MLIRContext;
using ::mlir::ModuleOp;
using ::mlir::OwningOpRef;
using ::tsl::StatusOr;

absl::StatusOr<OwningOpRef<ModuleOp>> GetMlirModuleFromString(
    absl::string_view module_string, MLIRContext* context) {
  DialectRegistry mlir_registry;
  RegisterCommonToolingDialects(mlir_registry);
  context->appendDialectRegistry(mlir_registry);

  OwningOpRef<ModuleOp> mlir_module;
  auto status =

// file; otherwise, load from a GraphDef.
// Setting prune_unused_nodes to true, would prune unreachable nodes if
// output_arrays is specified.
absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> LoadFromGraphdefOrMlirSource(
    const std::string& input_filename, bool input_mlir,
    bool use_splatted_constant, const std::vector<std::string>& extra_tf_opdefs,

}

}  // namespace
}  // namespace TF

namespace tf_test {
std::unique_ptr<OperationPass<ModuleOp>> CreateInitTextFileToImportTestPass() {
  return std::make_unique<TF::InitTextFileToImportTestPass>();
}
std::unique_ptr<OperationPass<ModuleOp>>
CreateInitTextFileToImportSavedModelTestPass() {
  return std::make_unique<TF::InitTextFileToImportSavedModelTestPass>();
}

class LiftVariablesTestPass
    : public PassWrapper<LiftVariablesTestPass, OperationPass<ModuleOp>> {
 public:
  LiftVariablesTestPass() { session_ = new FakeSession(); }

  ~LiftVariablesTestPass() override { delete session_; }

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

 private: