static FunctionMetadata* wrap(TF_FunctionMetadata* p) {
    return reinterpret_cast<FunctionMetadata*>(p);
  }
  static TF_FunctionMetadata* unwrap(FunctionMetadata* p) {
    return reinterpret_cast<TF_FunctionMetadata*>(p);
  }
};

}  // namespace cc
}  // namespace experimental
}  // namespace tensorflow

// the function body.
std::optional<llvm::StringMap<FunctionMetadata>> GetFunctionMetadatas(
    func::FuncOp func_op) {
  llvm::StringMap<FunctionMetadata> metadatas;
  WalkResult result = func_op.getBody().walk([&](Operation *op) {
    std::string op_host = GetHost(op);
    FunctionMetadata &func_metadata = metadatas[op_host];
    func_metadata.original_name = func_op.getName();

                       FunctionMetadata metadata,
                       ImmediateExecutionContext* ctx,
                       std::unique_ptr<TFConcreteFunction>* out);

  // This method returns the "Call" Op used to execute the function.
  Status MakeCallOp(absl::Span<AbstractTensorHandle* const> inputs,
                    ImmediateOpPtr* out) const override;

  const FunctionMetadata& GetFunctionMetadata() const override;

 public:
  // TODO(bmzhao): Adding ConcreteFunction::Run in subsequent CL, since
  // it depends on tensorflow::cc::Tensor and tensorflow::cc::TensorHandle

  // Returns FunctionMetadata associated with this ConcreteFunction.
  const FunctionMetadata* GetFunctionMetadata();

 private:
  friend class SavedModelAPI;
  friend class ConcreteFunctionList;

  // TODO(bmzhao): Consider adding a macro for wrapping/unwrapping

TFConcreteFunction::TFConcreteFunction(std::unique_ptr<FlatTensorFunction> func,
                                       FunctionMetadata metadata)
    : func_(std::move(func)), metadata_(std::move(metadata)) {}

Status TFConcreteFunction::Create(
    const FunctionDef* function_def,
    std::vector<ImmediateExecutionTensorHandle*> captures,
    FunctionMetadata metadata, ImmediateExecutionContext* ctx,
    std::unique_ptr<TFConcreteFunction>* out) {

#ifndef TENSORFLOW_C_EXPERIMENTAL_SAVED_MODEL_CORE_FUNCTION_METADATA_H_
#define TENSORFLOW_C_EXPERIMENTAL_SAVED_MODEL_CORE_FUNCTION_METADATA_H_

namespace tensorflow {

class FunctionMetadata {
  // TODO(bmzhao): Fill in with fields as necessary
};

}  // namespace tensorflow

#include "tensorflow/c/experimental/saved_model/core/function_metadata.h"

typedef struct TF_FunctionMetadata TF_FunctionMetadata;

namespace tensorflow {

DEFINE_CONVERSION_FUNCTIONS(tensorflow::FunctionMetadata, TF_FunctionMetadata)

}  // namespace tensorflow

      compute_fn, compute_fn_inputs.data(), compute_fn_inputs.size(), status);
  EXPECT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  // TODO(bmzhao): Finish API on FunctionMetadata args, so we know how many
  // inputs + outputs a function has.
  TFE_TensorHandle* compute_fn_outputs[1] = {nullptr};
  int num_retvals = 1;

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

extern "C" {

TF_FunctionMetadata* TF_ConcreteFunctionGetMetadata(TF_ConcreteFunction* func) {
  return tensorflow::wrap(const_cast<tensorflow::FunctionMetadata*>(
      &tensorflow::unwrap(func)->GetFunctionMetadata()));
}

TFE_Op* TF_ConcreteFunctionMakeCallOp(TF_ConcreteFunction* func,
                                      TFE_TensorHandle** inputs, int num_inputs,

// TODO(bmzhao): Work together w/srbs@ to make sure this composes w/the
// C++ Unified Eager/Graph API's AbstractFunction
typedef struct TF_ConcreteFunction TF_ConcreteFunction;

// Returns FunctionMetadata associated with `func`. Metadata's lifetime is
// bound to `func`, which is bound to the TF_SavedModel it was loaded from.
TF_CAPI_EXPORT extern TF_FunctionMetadata* TF_ConcreteFunctionGetMetadata(