'Cannot find the output tensor with name %s in the graph.'
              % tensor_info.name
          ) from exc

  return signature_def_map


def _find_op(
    graph: ops.Graph, op_name: Optional[str]
) -> Optional[ops.Operation]:
  """Finds the operation with `op_name`.

  Args:
    graph: The graph to find from.
    op_name: Name of the node.

  Returns:

      wrapper.CreateGraphOptimizationPassOptions(graph);

  PartiallyDeclusterPass pass;
  return pass.Run(opt_options);
}

Node* FindNodeByName(const Graph& graph, const string& name) {
  for (Node* node : graph.nodes()) {
    if (node->name() == name) {
      return node;
    }
  }
  return nullptr;
}

bool GetInputsForNode(const Graph& graph, const string& node_name,

  }
  func.return %graph#0, %graph#1 : tensor<*xi32>, tensor<i32>
}

// -----

// Test that external functions aren't processed (used to crash).

// CHECK-LABEL: func private @unused_external_func
func.func private @unused_external_func()

func.func @multiple_return(%arg0: tensor<*xi32>, %arg1: tensor<i32>) -> (tensor<*xi32>, tensor<*xi32>) {
  %graph:2 = tf_executor.graph {
    %island:3 = tf_executor.island {

Scope Scope::NewRootScope() {
  Graph* graph = new Graph(OpRegistry::Global());
  ShapeRefiner* refiner =
      new ShapeRefiner(graph->versions(), graph->op_registry());
  return Scope(new Impl(graph, new Status, new Impl::NameMap, refiner,
                        /* disable_shape_inference */ false));
}

Scope Scope::DisabledShapeInferenceScope() {
  Graph* graph = new Graph(OpRegistry::Global());
  ShapeRefiner* refiner =

Dependency resolution is a process that consists of two phases, which are repeated until the dependency graph is complete:

* When a new dependency is added to the graph, perform conflict resolution to determine which version should be added to the graph.
* When a specific dependency, that is a module with a version, is identified as part of the graph, retrieve its metadata so that its dependencies can be added in turn.

      : tensor<i32>, !tf_res,
        !tf_res
  }
  func.return %graph#0, %graph#1, %graph#2
     : tensor<i32>, !tf_res,
       !tf_res
}

// CHECK-LABEL: func @while_cond
func.func @while_cond(
  %arg0: tensor<i32>,
  %arg1: !tf_res,
  %arg2: !tf_res) -> tensor<32xf32> {
  %graph = tf_executor.graph {
    // CHECK: tf_executor.island
    %island:2 = tf_executor.island {

// CHECK-LABEL: func @empty_graph
func.func @empty_graph() {
  tf_executor.graph {
  }
  func.return

// CHECK:      tf_executor.graph {
// CHECK-NEXT:  tf_executor.fetch
// CHECK-NEXT: }

}

// CHECK-LABEL: func @graph_with_fetch(%{{.*}}: tensor<*xf32>)
func.func @graph_with_fetch(%0: tensor<*xf32>) -> tensor<*xf32> {
  %result = tf_executor.graph {
    tf_executor.fetch %0 : tensor<*xf32>
  }

string DescribeCycle(const GraphCycles* cycles, const Graph& graph, int src,
                     int dst) {
  int32_t max_path_size = graph.num_node_ids() + 1;
  std::vector<int32> path(max_path_size);
  int32_t path_size = cycles->FindPath(dst, src, max_path_size, path.data());
  if (path_size == 0) {
    return "";
  }

  auto node_name = [&graph](int node_id) {
    if (!FastBoundsCheck(node_id, graph.num_node_ids())) {

      VLOG(2) << "Run MLIR graph optimization pass: " << StringRefToView(name);
      VLOG(2) << "Graph #nodes " << (*graph)->num_nodes() << " #edges "
              << (*graph)->num_edges();
      timings.Reset({kTfMlirCategory, name.str()});
      pass_status = pass_registration.pass->Run(
          function_name, config_proto, *module_ref, **graph, *flib_def);
      timings.ReportAndStop();

// CHECK:      return %[[GRAPH]]#2, %[[GRAPH]]#1 : tensor<i1>, tensor<i1>


// Test single graph with an island and executor ops is unmodified.
// CHECK-LABEL: func @graph_with_island_and_executor_op
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<i1>)
func.func @graph_with_island_and_executor_op(%arg0 : tensor<i1>) -> (tensor<i1>, tensor<i1>) {
  %0:3 = tf_executor.graph {
    %1:4 = tf_executor.island {