TEST(SignatureFlatteningTest, ZeroRetOutputSignature) {
  std::vector<const TensorSpecProto*> flattened;
  StructuredValue value = testing::ZeroReturnOutputSignature();
  TF_EXPECT_OK(internal::FlattenSignature(value, &flattened));
  EXPECT_EQ(flattened.size(), 0);
}

TEST(SignatureFlatteningTest, SingleArgInputSignature) {
  std::vector<const TensorSpecProto*> flattened;
  StructuredValue value = testing::SingleArgInputSignature();

#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/protobuf/struct.pb.h"

namespace tensorflow {

// Note(bmzhao): TensorSpec deliberately does not store the "name" from a
// TensorSpecProto. From edloper@, "Names should really be associated with
// parameters, not the tensors inside those parameters. This would be
// inconsistent with the corresponding Python class, but I don't think that's

    : shape_(std::initializer_list<int64_t>()), dtype_(DT_FLOAT) {}

TensorSpec::TensorSpec(PartialTensorShape shape, DataType dtype)
    : shape_(std::move(shape)), dtype_(dtype) {}

TensorSpec::TensorSpec(const TensorSpecProto& proto)
    : shape_(proto.shape()), dtype_(proto.dtype()) {}

const PartialTensorShape& TensorSpec::shape() const { return shape_; }

DataType TensorSpec::dtype() const { return dtype_; }

// Flattens `signature` into a vector of TensorSpecProto pointers back into
// `signature`. `signature` must outlive flattened_specs. `signature` must also
// be the input or output signature of a SavedConcreteFunction (i.e. "nested
// structures of tensorspecs").
Status FlattenSignature(const StructuredValue& signature,
                        std::vector<const TensorSpecProto*>* flattened_specs);

// Converts an MLIR shaped type to a TensorFlow shape attribute.
mlir::TF::ShapeAttr ConvertTypeToTensorShapeAttr(const mlir::Type& type);

// Converts an MLIR shaped type to a Tensorflow tensor spec proto.
absl::StatusOr<TensorSpecProto> ConvertTypeToTensorSpecProto(
    const mlir::Type& type);

// Converts a TensorFlow shape attribute to an MLIR shape attribute.
absl::StatusOr<mlir::Attribute> ConvertTensorShapeProto(

using tensorflow::PartialTensorShape;
using tensorflow::SavedConcreteFunction;
using tensorflow::SavedObjectGraph;
using tensorflow::Status;
using tensorflow::StructuredValue;
using tensorflow::TensorSpecProto;
using tensorflow::libexport::TFPackage;
using tensorflow::protobuf::RepeatedPtrField;
using tensorflow::tracing::graph::GraphFunction;

TaggedValue MakeCallable(const std::string& fn_name, Function fn,

  const std::string& name = function_def->signature().name();

  const StructuredValue& input_signature =
      saved_concrete_function.canonicalized_input_signature();
  std::vector<const TensorSpecProto*> input_specs;
  TF_RETURN_IF_ERROR(FlattenSignature(input_signature, &input_specs));
  if (input_specs.size() + saved_concrete_function.bound_inputs_size() !=
      function_def->signature().input_arg_size()) {

  // Empty TensorShape indicates a scalar.
  return mlir::TF::ShapeAttr::get(type.getContext(), ArrayRef<int64_t>());
}

absl::StatusOr<TensorSpecProto> ConvertTypeToTensorSpecProto(
    const mlir::Type& type) {
  DataType dtype;
  TF_RETURN_IF_ERROR(ConvertToDataType(type, &dtype));
  TensorSpecProto tensor_spec;
  tensor_spec.set_dtype(dtype);
  *tensor_spec.mutable_shape() = ConvertTypeToTensorShape(type).AsProto();

namespace tensorflow {

namespace {

using StructuredValueDictEntry =
    protobuf::MapPair<std::string, StructuredValue>;

using NamedParamMap =
    gtl::FlatMap<StringPiece, const TensorSpecProto*, StringPieceHasher>;

Status AssertAllCreateResourceFunctionsHaveNoCaptures(
    const PartiallyRevivedObjects& objects) {
  for (const auto& id_and_resource : objects.restored_resources) {