// TODO(danielellis): Fill in with implementations.

// Builds a vector of runtime representations of `SavedObject`s from a
// SavedModel. These are returned as a flat list.  The full hierarchy building
// and initialization should be done in a later pass.
tensorflow::StatusOr<std::vector<Handle>> BuildObjects(TFPackage& tf_package) {
  std::vector<Handle> objects;

                       module_out->getBody()->getOperations());
}

// Returns a vector of passes from their names. If a pass is not found, then the
// corresponding return entry is null.
static std::vector<GraphOptimizationPass*> FindRegisteredPassesByName(
    const std::vector<std::string>& pass_names) {
  std::vector<GraphOptimizationPass*> pass_ids(pass_names.size(), nullptr);

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "xla/client/local_client.h"

namespace tensorflow {
namespace {
std::vector<const xla::Shape*> GetShapePointers(
    absl::Span<const xla::Shape> shapes) {
  std::vector<const xla::Shape*> shape_ptrs;
  shape_ptrs.reserve(shapes.size());
  for (const auto& shape : shapes) {

#define TENSORFLOW_C_EAGER_TFE_TENSOR_DEBUG_INFO_INTERNAL_H_

#include <vector>

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

struct TFE_TensorDebugInfo {
  explicit TFE_TensorDebugInfo(const std::vector<int64_t>& dims)
      : dev_dims(dims) {}

  // Fully-padded, minor-to-major.
  std::vector<int64_t> dev_dims;
};

// license that can be found in the LICENSE file.

package main

type Element interface {
}

type Vector struct {
}

func (v *Vector) Insert(i int, e Element) {
}


func main() {
	type I struct { val int; };  // BUG: can't be local; works if global
	v := new(Vector);
	v.Insert(0, new(I));
}
/*
check: main_sigs_I: not defined

  explicit CheckAcceptedOpsPass(
      const std::vector<std::string> &optional_accepted_dialects)
      : accepted_dialects_(GetAcceptedStableHLODialects()),
        optional_accepted_dialects_(optional_accepted_dialects) {}

  // Check if TF dialect ops exist over the module.
  void runOnOperation() override;

 private:
  std::vector<std::string> accepted_dialects_;
  std::vector<std::string> optional_accepted_dialects_;
};

// var x A[int]
// var _ A
//
// type B = T[int]
// var y B = x
// var _ B /* ERROR "not a generic type" */ [int]

// test case from issue

type Vector[T any] []T
type VectorAlias = Vector // ERROR "cannot use generic type"

    s.graph()->AddControlEdge(ctrl_merge.node(), e->dst());
    s.graph()->RemoveControlEdge(e);
  }
}

struct XlaClusterInfo {
  std::vector<Output> constant_inputs;
  std::vector<Output> non_constant_inputs;
  std::vector<Output> resource_inputs;
  NameAttrList function;
};

Output IncomingEdgeAsOutput(const Edge* e) {
  return Output(e->src(), e->src_output());
}

  using UncompilableNodesMap =
      std::map<std::string,
               std::pair<NameAttrList, std::vector<UncompilableNodeInfo>>>;

  // Returns a map where the key is the function identifier(short debug
  // string) of the function encapsulating the uncompilable nodes, and the
  // value is a pair of NameAttrList of the function and a vector of
  // uncompilable node info. When uncompilable node is not inside any

    // their declared shapes for computations. Must be non-empty.
    std::vector<XlaShapeLayoutHelpers::ShapeDeterminationFns>
        shape_determination_fns;

    Options(std::string device_name_prefix, std::string device_name,
            int device_ordinal, std::string compilation_device_name,
            std::vector<XlaShapeLayoutHelpers::ShapeDeterminationFns>
                shape_determination_fns)