}
  )mlir";

  Block block;
  ModuleOp module_op = ParseModuleOp(kModuleOpStr, block, ctx_);

  SmallVector<func::FuncOp, 2> init_func_ops =
      GetInitializerFunctions(module_op);

  EXPECT_THAT(init_func_ops, IsEmpty());
}

TEST_F(TfSavedModelTest,
       GetInitializerFunctionsEmptyWhenNoSessionInitializerOp) {
  constexpr StringRef kModuleOpStr =

  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 =
          func->getAttrOfType<mlir::DictionaryAttr>("tf.entry_function");
      if (!dict_attr) continue;

  // Erases the ops.
  for (auto op : erase_list) op->erase();
}

void RemoveVariablesInSessionInitializerPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  for (auto init_func_op : GetInitializerFunctions(module_op)) {
    if (!init_func_op) return;

    if (init_func_op.getBlocks().size() != 1) {
      init_func_op.emitError("expects exactly one block in the MLIR function");
      return signalPassFailure();
    }

          llvm::StringRef(tensorflow::kImportModelDefaultGraphFuncName) ||
      func.getSymName() == kTfQuantSaveFuncName) {
    return true;
  }

  for (func::FuncOp init_func :
       tf_saved_model::GetInitializerFunctions(module)) {
    if (func.getSymName() == init_func.getSymName()) {
      return true;
    }
  }
  return false;
}

// Checks if the function is only used by supported ops. Returns false when the

  init->setAttr("tf_saved_model.exported_names",
                builder.getStrArrayAttr({name}));

  builder.setInsertionPointToStart(init.addEntryBlock());

  for (func::FuncOp func : tf_saved_model::GetInitializerFunctions(module)) {
    if (func.getNumArguments() != 0) {
      session_initializer->emitWarning(
          "encountered session initializers with arguments");
      continue;
    }

// Returns initializer function ops. These functions' symbols are in the
// "initializers" attribute of the session initializer op.
SmallVector<func::FuncOp, 2> GetInitializerFunctions(ModuleOp module_op);

// Returns the initializer function whose `tf_saved_model.initializer_type`
// attribute matches `initializer_type`. Returns a null op if it doesn't exist.

namespace mlir {
namespace quant {
namespace {

using ::mlir::tf_executor::FetchOp;
using ::mlir::tf_executor::GraphOp;
using ::mlir::tf_executor::IslandOp;
using ::mlir::tf_saved_model::GetInitializerFunctions;
using ::mlir::tf_saved_model::GetSessionInitializerOp;
using ::mlir::tf_saved_model::kTfSavedModelInitializerInitType;
using ::mlir::tf_saved_model::kTfSavedModelInitializerRestoreType;

    auto exported_names = GetExportedNames(init_func_op);
    assert(exported_names.size() == 1);
    results.push_back(exported_names[0]);
  }

  return results;
}

SmallVector<func::FuncOp, 2> GetInitializerFunctions(ModuleOp module_op) {
  SessionInitializerOp session_initializer_op =
      GetSessionInitializerOp(module_op);
  if (!session_initializer_op) return {};

  SymbolTable symbol_table(module_op);

    module->emitError(
        absl::StrCat("failed to fetch device manager: ", status.message()));
    return failure();
  }

  SmallVector<func::FuncOp, 2> session_init_funcs =
      tf_saved_model::GetInitializerFunctions(module);
  func::FuncOp session_init_func =
      session_init_funcs.empty() ? nullptr : session_init_funcs[0];

  TF::ResourceAnalyzer analyzer(module, /*skip_session_init=*/true);