namespace tensorflow {
namespace tracing {
namespace graph {
GraphFunction::GraphFunction(FunctionDef fdef)
    : AbstractFunction(kGraph),
      func_record_(new FunctionRecord(std::move(fdef), {}, true)) {}
GraphFunction::~GraphFunction() {}
Status GraphFunction::GetFunctionDef(const FunctionDef **fdef) {
  *fdef = &(func_record_->fdef());
  return absl::OkStatus();
}
}  // namespace graph

struct TFSignatureDefFunctionRevivalState {
  // Index of the node in the SavedObjectGraph it was loaded from.
  int node_id = 0;

  // Pointer to the original functiondef. fdef_ is guaranteed to be
  // non-null.
  const FunctionDef* fdef = nullptr;

  // SavedConcreteFunction contains much of the metadata of the expected "types"
  // of the inputs and outputs of a function.

struct TFConcreteFunctionRevivalState {
  // Index of the node in the SavedObjectGraph it was loaded from.
  int node_id;

  // Pointer to the original functiondef. fdef_ is guaranteed to be
  // non-null.
  const FunctionDef* fdef;

  // TensorHandle captures for this funtion
  std::vector<ImmediateExecutionTensorHandle*> captures;

  op_builder.create<mlir::func::ReturnOp>(loc, tf_op->getResults());

  // Run the decompose passes on the module
  TF_RETURN_IF_ERROR(DecomposeGraph(module));

  // Export the result as a FunctionDef.
  FunctionDef func_def;
  TF_RETURN_IF_ERROR(
      ConvertMlirFunctionToFunctionLibraryDef(func, export_confs_, &func_def));
  module.erase();
  return func_def;
}

  graph.ToGraphDef(&graph_def);
  if (!function_library) return failure();
  for (const std::string& func_name :
       function_library->ReachableDefinitions(graph_def).ListFunctionNames()) {
    const FunctionDef* func_def = function_library->Find(func_name);
    std::unique_ptr<FunctionBody> func_body;
    absl::Status status = FunctionDefToBodyHelper(
        *func_def, AttrSlice(&func_def->attr()), function_library, &func_body);

 public:
  // Returns which subclass is this instance of.
  AbstractOpAttrsKind getKind() const { return kind_; }
  virtual ~AbstractOpAttrs() = default;

  // Returns the AbstractFunction as a FunctionDef.
  virtual void GetNameAttrList(
      tensorflow::NameAttrList* name_and_attrs) const = 0;

  virtual bool GetInt(absl::string_view, int64_t* result) const = 0;

  auto d = ops::_Retval(scope.WithOpName("D"), c, 0);
  TF_RETURN_IF_ERROR(scope.ToGraph(graph.get()));
  return graph;
}

StatusOr<FunctionDef> SampleFuntionAddXY(const std::string& name) {
  TF_ASSIGN_OR_RETURN(auto graph, SampleGraphAddXY());
  FunctionDef fdef;
  TF_RETURN_IF_ERROR(GraphToFunctionDef(*graph, name, &fdef));
  return fdef;
}

std::vector<XlaCompiler::Argument> SampleArgsForAddXY() {

  SessionOptions session_options;
};

// Helps set up devices for unit tests.
class DeviceSetup {
 public:
  void AddDevicesAndSetUp(
      const std::vector<std::string>& device_names,
      const std::optional<FunctionDef>& fdef = std::nullopt);
  Device* GetDevice(const string& device_name);
  FunctionLibraryRuntime* flr() { return flr_; }

 private:
  FunctionLibraryRuntime* flr_;
  std::unique_ptr<DeviceMgr> device_mgr_;

  // TODO(srbs): Provide a function execution API on ctx so that we do not
  // expose the internals of how functions are to be executed here.
  std::string fname;
  {
    const tensorflow::FunctionDef* fdef = nullptr;
    TF_RETURN_IF_ERROR(trace->GetFunctionDef(&fdef));
    fname = fdef->signature().name();
  }
  // TODO(srbs): Update RegisterFunction to accept AbstractFunctionPtr.

# RUN: tf-mlir-translate -graphdef-to-mlir -tf-enable-shape-inference-on-import=false %s -o - | FileCheck %s

# Verify that the _input_shapes attribute of the FunctionDef is respected.
# This also checks that the output type is correctly inferred based on
# that.
#CHECK: func private @identity_function0(%arg0: tensor<i32>) -> tensor<i32>

node {
  name: "Placeholder"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_BOOL