}
  if (auto launch_op = dyn_cast<tf_device::LaunchOp>(op)) {
    auto terminator = launch_op.GetBody().getTerminator();
    return RefineTypeForPassThroughOperands(op, terminator->getOperands(),
                                            op->getResults());
  }
  if (auto cluster_op = dyn_cast<tf_device::ClusterOp>(op)) {
    auto terminator = cluster_op.GetBody().getTerminator();

};

using mhlo::DotDimensionNumbersAttr;

// Replaces `region`'s terminator to TF::Yield.
void ReplaceReturnOp(Region& region, PatternRewriter& rewriter) {
  OpBuilder::InsertionGuard guard(rewriter);

  for (auto& block : region.getBlocks()) {
    Operation* terminator = block.getTerminator();
    auto return_op = llvm::dyn_cast_or_null<mhlo::ReturnOp>(terminator);
    if (return_op == nullptr) continue;

                 false;
        }
        return fn.emitError("invalid TFLite type: ") << arg.getType(), false;
      }
    }

    // Verify that all operations except the terminator have exactly one
    // result of type supported by TFLite (or is a ControlType, which
    // will be removed later by ExtractControlEdges.)
    for (auto& inst : bb) {

        continue;
      }
      // Check if the same extern value is returned in each branch.
      for (Region* region : branches.drop_front()) {
        Operation* terminator = region->front().getTerminator();
        if (terminator->getOperand(index) != returned_val) return failure();
      }
      result_to_extern_value[result] = returned_val;
    }

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

  // Ensure that the terminator's operands and the control_node results match in
  // types.
  const int result_count =
      control_node.getNumResults() - 1;  // 1 for control token

// -----

// tf.IfRegion regions should be terminated with a tf.Yield
func.func @testIfRegionThenTerminator(%arg0: tensor<i1>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  // expected-error @+2 {{block with no terminator}}
  %0 = "tf.IfRegion"(%arg0) ({
     %t = "tf.Abs"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
   }, {
     %e = "tf.Acos"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     "tf.Yield"(%e) : (tensor<2xf32>) -> ()

}

def TFL_YieldOp : Op<TFL_Dialect, "yield",
  [Pure,
   Terminator,
   QuantizableResult,
   DeclareOpInterfaceMethods<TFL_RuntimeVerification>]> {
  let summary = "Yield operation";
  let description = [{
    The "yield" operation represents a return operation within the conditional
    and body of structured control flow (e.g., while), and a terminator for ControlNodeOp.

        RegionSuccessor(&getCond(), getCond().front().getArguments()));
  } else if (point.isParent()) {
    // The parent branches to 'cond'. It is also considered to branch to `body`
    // in case the terminator of `cond` doesn't forward the arguments of `cond`.
    regions.push_back(
        RegionSuccessor(&getCond(), getCond().front().getArguments()));
    regions.push_back(

                  << node.type_string()
                  << "` has resource operands/results but effects not modelled";
        }
      }
    }
  }

  // Add the terminator for the island
  island_builder.create<mlir::tf_executor::YieldOp>(result.location,
                                                    inner_op->getResults());
  return island.getOperation();
}