StringRef shared_name = GetSharedName(hash_table);
  if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module_op)) {
    for (Operation& op : init_func_op.getBody().getOps()) {
      StringRef other_shared_name = GetSharedName(&op);
      if (IsHashTableOp(&op) && other_shared_name == shared_name) {

  // then fallback to shared_name attribute.
  if (auto loc = mlir::dyn_cast<NameLoc>(var_handle_op->getLoc()))
    return loc.getName().str();
  return var_handle_op.getSharedName().str();
}

std::vector<std::string> GetVariableNames(
    llvm::ArrayRef<TF::VarHandleOp> var_handle_ops) {
  std::vector<std::string> names;
  names.reserve(var_handle_ops.size());

      !status.ok()) {
    return status;
  }

  if (!bundle_writer.Add(/*key=*/var_handle_op.getSharedName(), const_tensor)
           .ok()) {
    return bundle_writer.status();
  }

  return var_handle_op.getSharedName().str();
}

}  // namespace

absl::StatusOr<std::vector<std::string>> SaveVariablesToCheckpoint(

  } else if (auto handle = llvm::dyn_cast<TF::VarHandleOp>(source)) {
    container = handle.getContainer();
    shared_name = handle.getSharedName();
  } else if (auto it = llvm::dyn_cast<TF::IteratorOp>(source)) {
    container = it.getContainer();
    shared_name = it.getSharedName();
  } else {
    // Can't happen, as long as this file and resource_dataflow.cc are in sync.
    return;
  }

  OpBuilder builder(op);

        {mlir::cast<TensorType>(ref_qtype)}, builder.getContext()));
    auto new_var_handle_op = builder.create<VarHandleOp>(
        var_handle_op.getLoc(), output_type, var_handle_op.getContainer(),
        var_handle_op.getSharedName());
    var_handle_op->replaceAllUsesWith(new_var_handle_op);
    var_handle_op.erase();
  }
}

void QuantizeVariablesPass::runOnOperation() {
  ResourceIdMap resource_id_map;

      resource_vec.push_back(GetResourceHandleValueAndIdBase(
          mlir::cast<mlir::StringAttr>(getContainer()[index]).getValue(),
          mlir::cast<mlir::StringAttr>(getSharedName()[index]).getValue(),
          device, getResults()[index], resource_handle_id_map, next_id));
    }
  }
  return resource_vec;
}

LogicalResult _TfrtGetResourceOp::verify() {

    // native resource design is based on integer keys to identify the
    // corresponding resource objects.
    auto table_id =
        static_cast<int32_t>(::llvm::hash_value(hashtable_op.getSharedName()));
    auto key_dtype = hashtable_op.getKeyDtype();
    auto value_dtype = hashtable_op.getValueDtype();

    rewriter.replaceOpWithNewOp<TFL::HashtableOp>(

namespace {

std::string GetVariableName(Operation* op) {
  if (auto handle = dyn_cast<TF::VarHandleOp>(op)) {
    std::string container = handle.getContainer().str();
    std::string shared_name = handle.getSharedName().str();
    if (container.empty()) {
      return absl::StrCat("vars.", shared_name);
    } else {
      return absl::StrCat("vars.", container, ".", shared_name);
    }

  SmallVector<std::string> tensor_names = {};
  SmallVector<Value> tensor_values = {};
  for (auto var_handle_op : var_handle_ops) {
    tensor_names.emplace_back(var_handle_op.getSharedName().str());

    auto read_var_op = builder.create<TF::ReadVariableOp>(
        var_handle_op.getLoc(), var_handle_op.resource_subtype(),
        var_handle_op);
    tensor_values.emplace_back(read_var_op.getResult());