%tmp2, %ctl2 = tfl.control_node(%ctl1) controls "tfl.neg"(%tmp1): (tensor<1xf32>) -> tensor<1xf32>
  %tmp3, %ctl3 = tfl.control_node(%ctl2) controls "tfl.neg"(%tmp2): (tensor<1xf32>) -> tensor<1xf32>
  func.return %tmp3: tensor<1xf32>
}
// CHECK-NEXT: %[[t0:.*]], %[[c0:.*]] = tfl.control_node controls "tfl.neg"(%arg0)

}
// CHECK-NEXT: %[[VAR:.*]], %[[CONTROL:.*]] = tfl.control_node controls "tfl.var_handle"
// CHECK-NEXT: return %[[VAR]]


// CHECK-LABEL: @tfl_call_once_gets_control_node
func.func @tfl_call_once_gets_control_node() -> () {
  "tfl.call_once"() { session_init_function = "noop" } : () -> ()
  func.return
}
// CHECK-NEXT: control_node controls "tfl.call_once"
// CHECK-NEXT: return

  %1,%control_1 = tfl.control_node controls "tfl.sub" (%arg0, %0) {fused_activation_function = "RELU6"} : (tensor<3x2xi32>, tensor<3x2xi32>) -> tensor<3x2xi32> loc("sub")
  %2 = "arith.constant" () {value = dense<10> : tensor<i32>} : () -> tensor<i32> loc("SameNameAsOutput")

  %1,%control_1 = tfl.control_node controls "tfl.sub" (%arg0, %0) {fused_activation_function = "RELU6"} : (tensor<3x2xi32>, tensor<3x2xi32>) -> tensor<3x2xi32> loc("sub")
  %2 = "arith.constant" () {value = dense<10> : tensor<i32>} : () -> tensor<i32> loc("SameNameAsOutput")

func.func @op_with_tfl_control_flow() -> (tensor<1xf32>, !tfl.control) {
  // CHECK: vhlo.constant_v1
  %0 = stablehlo.constant dense<1.000000e+00> : tensor<1xf32>
  // CHECK-NEXT: tfl.control_node
  %outputs, %control = tfl.control_node {
    %1 = "tfl.neg"(%0) : (tensor<1xf32>) -> tensor<1xf32>
    "tfl.yield"(%1) : (tensor<1xf32>) -> ()
  }
  return %outputs, %control : tensor<1xf32>, !tfl.control
}

// -----

#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

bool IsFlexDelegate(Operation *op) {
  // Unwrap from any ControlNodeOps or CustomTfOp.
  if (auto control_node = dyn_cast<mlir::TFL::ControlNodeOp>(*op)) {
    return IsFlexDelegate(&control_node.getBody().front().front());
  }
  if (auto custom_tf_op = dyn_cast<mlir::TFL::CustomTfOp>(*op)) {
    return IsFlexDelegate(&custom_tf_op.getBody().front().front());
  }

mlir::LogicalResult ControlNodeOp::verify() {
  ControlNodeOp control_node = *this;
  if (!control_node.GetBody().args_empty())
    return control_node.emitOpError() << "expects body without any arguments";

  Operation& yield = control_node.GetBody().back();
  if (!isa<YieldOp>(yield))
    return yield.emitOpError()
           << "invalid TFL.control_node terminator, yield expected";

                                         Location op_loc,
                                         ControlNodes* control_nodes) {
  const ControlNodes::iterator maybe_control_node =
      control_nodes->find(op_index);
  if (maybe_control_node == control_nodes->end()) {
    return op->getResults();
  }
  mlir::Region region;
  region.push_back(new mlir::Block);

    static bool isBuildableWith(Attribute value, Type type);
  }];
}

def TFL_ControlNodeOp : Op<TFL_Dialect, "control_node",
    [HasParent<"mlir::func::FuncOp">, RecursiveMemoryEffects, SingleBlockImplicitTerminator<"YieldOp">]> {
  let summary = [{
    The `TFL.control_node` operation wraps single-block operations in order to attach control edges.
  }];

  let description = [{

}

// -----

// CHECK-LABEL: testControlNodeLongForm
func.func @testControlNodeLongForm(%arg0: tensor<8xf32>, %arg1: tensor<8xf32>)->tensor<8xf32> {
  %0, %c0 = "tfl.control_node"() ({
    %1 = "tfl.add"(%arg0, %arg1) {fused_activation_function = "RELU6"} : (tensor<8xf32>, tensor<8xf32>)->tensor<8xf32>
    "tfl.yield"(%1) : (tensor<8xf32>) -> ()
    }) : () -> (tensor<8xf32>, !tfl.control)