tensorflow::FunctionDef function_def;
  if (!function_def.ParseFromArray(serialized_function_def, size)) {
    status->status =
        tensorflow::errors::InvalidArgument("Invalid FunctionDef proto");
    return;
  }

  AnnotateEagerRuntimeConstructionContext(function_def);
  status->status = tensorflow::unwrap(ctx)->AddFunctionDef(function_def);
}

                              n->DebugString());
    }
  }
  return absl::OkStatus();
}

// Cheap check to tell whether FunctionDef contains a lifted argument.
bool HasLiftedArgs(const FunctionDef& function_def) {
  return absl::c_any_of(function_def.node_def(), [](const NodeDef& node_def) {
    return (node_def.op() == "Placeholder" &&
            node_def.attr().find(kXlaLiftedArgOutsideCompilationAttrName) !=

  // the graph def function library.
  for (const FunctionDef& function :
       bundle.meta_graph_def().graph_def().library().function()) {
    std::unique_ptr<TFConcreteFunction> concrete_function;
    TF_RETURN_IF_ERROR(TFConcreteFunction::Create(/*function_def=*/&function,
                                                  /*captures=*/{},

         {"f",
          FunctionDefHelper::FunctionRef("IdentityRef", {{"T", DT_FLOAT}})},
         {kXlaMustCompileAttr, true}}}},
      /*ret_def=*/{{"z", "func_call:output:0"}});

  *library.add_function() = identity_func;
  *library.add_function() = call_identity;

  Output in = ops::Placeholder(root, DT_FLOAT);
  NameAttrList b_name_attr;
  b_name_attr.set_name("CallIdentity");

                                            &capture_handle));
    captures.push_back(capture_handle);
  }
  // TODO(bmzhao): Create Metadata here
  return TFConcreteFunction::Create(/*function_def=*/builder.fdef,
                                    /*captures=*/std::move(captures),
                                    /*metadata=*/{},
                                    /*ctx=*/ctx,

  return std::make_shared<NodeProperties>(nullptr, std::move(node_def), dummy,
                                          dummy);
}

// Create a FunctionDef that takes one resource and one regular param
FunctionDef XTimesY() {
  return FunctionDefHelper::Define(
      // Name
      "XTimesY",
      // Args
      {"x: float", "y: resource"},
      // Return values
      {"z: float"},

  // Decomposes the op in the NodeDef to a set of primitive ops according to the
  // decompose library in the context. Wrap the decomposed result in a
  // FunctionDef.
  absl::StatusOr<FunctionDef> ExpandNode(const NodeDef& node_def,
                                         StringPiece func_name);

  // Runs the decompose passes on the user_module.
  Status DecomposeGraph(mlir::ModuleOp user_module);

namespace graph {
using tensorflow::AbstractFunction;
// Thin wrapper around a FunctionDef.
class GraphFunction : public AbstractFunction {
 public:
  explicit GraphFunction(FunctionDef fdef);
  ~GraphFunction() override;

  // GraphFunction maybe stay alive for the duration of the returned
  // FunctionDef.
  Status GetFunctionDef(const FunctionDef** fdef) override;

  // Returns a shared reference to the wrapped function.

  DummyCapture(ImmediateExecutionContext* ctx, int8_t value)
      : TensorHandleConvertible(
            testing::CreateTensorHandle(ctx, DT_FLOAT, {2, 4}, value)) {}
};

FunctionDef FuncDefWithNumInputsOutputs(int num_inputs, int num_outputs) {
  FunctionDef func;
  OpDef* signature = func.mutable_signature();
  for (int i = 0; i < num_inputs; ++i) {
    signature->add_input_arg();
  }
  for (int i = 0; i < num_outputs; ++i) {

  // Returns which subclass is this instance of.
  AbstractFunctionKind getKind() const { return kind_; }

  // Returns the AbstractFunction as a FunctionDef.
  virtual Status GetFunctionDef(const FunctionDef**) = 0;

  // Returns a shared reference to the wrapped function.
  virtual absl::StatusOr<core::RefCountPtr<FunctionRecord>>
  GetFunctionRecord() = 0;

 private:
  const AbstractFunctionKind kind_;
};

using AbstractFunctionPtr =