namespace tensorflow {

class Asset : public TensorHandleConvertible {
 public:
  static Status Create(ImmediateExecutionContext* ctx,
                       const std::string& saved_model_dir,
                       const std::string& asset_filename,
                       std::unique_ptr<Asset>* output);

  // Asset is movable, but not copyable.
  Asset(Asset&& other) = default;
  Asset& operator=(Asset&& other) = default;

#include "tensorflow/core/platform/path.h"

namespace tensorflow {

Asset::Asset(ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)) {}

Status Asset::Create(ImmediateExecutionContext* ctx,
                     const std::string& saved_model_dir,
                     const std::string& asset_filename,
                     std::unique_ptr<Asset>* output) {
  std::string abs_path =

class AssetModule(module.Module):

  def __init__(self):
    self.asset = asset.Asset(
        test.test_src_dir_path("cc/saved_model/testdata/test_asset.txt"))

  @def_function.function(input_signature=[])
  def read_file(self):
    return io_ops.read_file(self.asset)


class StaticHashTableModule(module.Module):
  """A module with an Asset, StaticHashTable, and a lookup function."""

  def __init__(self):

    for (int i = 0, e = func.getNumArguments(); i < e; ++i) {
      SmallVector<TF::InitializeTableFromTextFileV2Op, 4>
          init_table_from_text_file_ops_to_erase;
      auto asset = LookupBoundInputOfType<AssetOp>(func, i, symbol_table);

      if (!asset) continue;

      auto arg = func.getArgument(i);
      bool arg_is_deletable = true;
      for (auto user : arg.getUsers()) {
        if (auto read_op =

}

def AssetSinkingPass : Pass<"tf-saved-model-asset-sinking", "mlir::ModuleOp"> {
  let summary = "Sinks SavedModel asset filenames to constants";

  let description = [{
    This pass sinks arguments of SavedModel methods that are bounded to
    `tf_saved_model.asset` into constants in the methods. After the pass, unused
    asset ops are removed from the module.

        # Restricting visibility for now
        "//tensorflow/c/experimental/saved_model/core:__pkg__",
    ],
    licenses = ["notice"],
)

cc_library(
    name = "asset",
    srcs = [
        "asset.cc",
    ],
    hdrs = [
        "asset.h",
    ],
    deps = [
        ":tensorhandle_convertible",
        "//tensorflow/c:tensor_interface",
        "//tensorflow/c/eager:immediate_execution_context",

// RUN: tf-opt %s -split-input-file -tf-saved-model-asset-sinking='saved-model-dir=foo/bar' | FileCheck %s

// CHECK-LABEL: module @asset
module @asset attributes {tf_saved_model.semantics} {
  "tf_saved_model.session_initializer"() {initializers = [@init]} : () -> ()

  // CHECK-NOT: "tf_saved_model.asset"
  "tf_saved_model.asset"() {filename = "assets/test0.txt", sym_name = "asset0"} : () -> ()

      auto asset = LookupBoundInputOfType<AssetOp>(
          func, argument.getArgNumber(), symbol_table);
      if (asset == nullptr) {
        continue;
      }

      // Create a const op for the asset if it doesn't already exist.
      auto it = const_ops.find(asset.getSymName());
      if (it == const_ops.end()) {
        // Asset filenames are relative to the SavedModel directory.

    void recompiledClasses(String... classNames) {
        assert changedFileNames == asSet(classNames)
    }

    void recompiledFqn(String... classNames) {
        assert getChangedFileNames(true) == asSet(classNames)
    }

    //asserts files deleted since last snapshot.
    void deletedFiles(String... fileNames) {

                        std::vector<AssetFileDef>* asset_file_defs) {
  // With SavedModel v2, we write asset file def into metagraph instead of
  // collection, so read from metagraph first.
  if (meta_graph_def.asset_file_def_size() > 0) {
    for (const auto& asset : meta_graph_def.asset_file_def()) {
      asset_file_defs->push_back(asset);
    }
    return absl::OkStatus();
  }