// CHECK:      }
    %1:2 = tf_executor.island wraps "tf.Case"(%0#0) {Tin = [], Tout = ["tfdtype$DT_FLOAT"], branches = [@foo, @bar], device = "", output_shapes = [], is_stateless = false} : (tensor<i32>) -> tensor<*xf32> loc("Case")
    tf_executor.fetch
  }
  func.return
}

// CHECK-DAG: name: "foo"
func.func @foo() -> tensor<10xf32> {
  %0 = tf_executor.graph {

    %0:2 = tf_executor.graph {
      %outputs:2, %control = tf_executor.island wraps "tf.MaxPoolWithArgmax"(%arg0) {T = f32, Targmax = i32, include_batch_in_index = false, ksize = [1, 2, 2, 1], padding = "SAME", strides = [1, 2, 2, 1]} : (tensor<2x4x2x2xf32>) -> (tensor<2x2x1x2xf32>, tensor<2x2x1x2xi32>)
      tf_executor.fetch %outputs#1, %outputs#0 : tensor<2x2x1x2xi32>, tensor<2x2x1x2xf32>
    }

#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

namespace tensorflow {

// Returns whether all functions in module are of single tf_executor.graph and
// each tf_executor.island in tf_executor.graph only has a single op.
mlir::LogicalResult VerifyExportSuitable(mlir::ModuleOp module);

}  // namespace tensorflow

func.func @foo_grad(%arg0: tensor<*xf32>, %arg1: tensor<*xf32>) -> tensor<*xf32> {
  %graph = tf_executor.graph {
    tf_executor.fetch %arg0 : tensor<*xf32>
  }
  func.return %graph : tensor<*xf32>
}

func.func @foo(%arg0: tensor<*xf32>) -> tensor<*xf32>
  attributes  {tf.gradient = @foo_grad} {
  %graph = tf_executor.graph {
    tf_executor.fetch %arg0 : tensor<*xf32>
  }
  func.return %graph : tensor<*xf32>

# Match the island containing the "tf.Neg", capture the output
# CHECK:          %[[ISLAND_0:[a-z_0-9]*]], %[[ISLAND_0_control:[a-z_0-9]*]] = tf_executor.island wraps "tf.Neg"

# Check that the tf.Neg control is passed to the fetch
# CHECK:          tf_executor.fetch {{.*}} %[[ISLAND_0_control]] : tensor<*xf32>, !tf_executor.control

node {
  name: "const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }

    // CHECK: tf_executor.Enter
    // CHECK: {{%.*}}, %[[TOKEN:.*]], {{%.*}} = tf_executor.NextIteration.Source
    // CHECK: {{%.*}}, {{%.*}}, %[[CONTROL:.*]] = tf_executor.Merge
    // CHECK: tf_executor.island(%[[CONTROL]]) wraps "tf.Const"()
    // CHECK: tf_executor.LoopCond
    // CHECK: tf_executor.Switch
    // CHECK: tf_executor.NextIteration.Sink[%[[TOKEN]]]
    // CHECK: tf_executor.Exit

attributes {tf.entry_function = {inputs = "input0,input1", outputs = "Add"}} {
  %graph = tf_executor.graph {
    %2:2 = tf_executor.island wraps "tf.Add"(%arg0, %arg1) {T = "tfdtype$DT_INT32", device = ""} : (tensor<10xi32>, tensor<10xi32>) -> tensor<10xi32> loc("Add")
    tf_executor.fetch %2 : tensor<10xi32>
  }
  func.return %graph : tensor<10xi32>
}

// CHECK:      node {
// CHECK-NEXT:   name: "input0"

func.func @main() {
  tf_executor.graph {
    %outputs, %control = tf_executor.island wraps "tf.Const"() {device = "", dtype = "tfdtype$DT_INT32", name = "Constant", value = dense<0> : tensor<i32>} : () -> tensor<i32>
    %outputs_0, %control_1 = tf_executor.island wraps "tf.LegacyCall"(%outputs) {_tpu_replicate = "cluster", device = "", f = @foo0} : (tensor<i32>) -> tensor<i32>
    tf_executor.fetch
  }
  func.return
}

func.func @main(%arg0 : tensor<16xf32>) {
  tf_executor.graph {
    %1:2 = tf_executor.island wraps "tf.MlirPassthroughOp"(%arg0) {extra_type_attr = [tensor<5xi32>, tensor<16xf32>], Tinputs = [tensor<16xf32>], Toutputs = [tensor<16xf32>], mlir_module = ""} : (tensor<16xf32>) -> tensor<16xf32>
    tf_executor.fetch
  }
  func.return
}

func.func @plain() {
  tf_executor.graph {

      tf_executor.yield
    }
    tf_executor.fetch %island : !tf_executor.control
  }
  func.return
}

// -----
// Tests handling of Cast, Identity, and IdentityN

!tf_res = tensor<*x!tf_type.resource<tensor<32xf32>>>
// CHECK-LABEL: func @aliasing_identities
func.func @aliasing_identities(%arg0: tensor<32xf32>) -> () {
  tf_executor.graph {
    // CHECK: tf_executor.island