Option<bool> skip_partitioned_calls_{
      *this, "skip-partitioned-calls",
      ::llvm::cl::desc(
          "Skip tf.StatefulPartitionedCall and tf.PartitionedCall")};
};

void TFToMhloPass::runOnOperation() {
  auto func = getOperation();
  MLIRContext *context = func->getContext();

  RewritePatternSet patterns(context);

// CHECK-NEXT: [[q_bias:%.+]] = "quantfork.qcast"([[bias]]) : (tensor<2xf32>) -> tensor<2x!quant.uniform<i32:f32, 0.044022349891595126>>

    up creating nested XLA launch ops.

    For example, the `tf.PartitionedCall` operation in the following code

    ```mlir
    func.func @convert_partitioned_call_with_resources(%arg0: tensor<!tf_type.resource>, %arg1: tensor<i32>) -> tensor<i32> {

  *library.add_function() = identity_func;

  Output in = ops::Placeholder(root, DT_FLOAT);
  NameAttrList b_name_attr;
  b_name_attr.set_name("IdentityFunc");
  ops::PartitionedCall call(root.WithOpName("call"), {in}, {DT_FLOAT},
                            b_name_attr);

  GraphDef graph_def;
  TF_ASSERT_OK(root.graph()->AddFunctionLibrary(library));
  TF_ASSERT_OK(root.ToGraphDef(&graph_def));

  auto grad = SymbolicGradient(scope, func_inputs, input_dtypes, f);
  for (int i = 0; i < num_inputs; i++) {
    grad_outputs->push_back(grad[i]);
  }

  return scope.status();
}

REGISTER_GRADIENT_OP("PartitionedCall", PartitionedCallGrad);
REGISTER_GRADIENT_OP("StatefulPartitionedCall", PartitionedCallGrad);

}  // anonymous namespace
}  // namespace ops

  return %arg0 : tensor<f32>
}

// CHECK-LABEL: handles_partitioned_function_calls
func.func @handles_partitioned_function_calls(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {
  // CHECK: PartitionedCall"()
  %1 = "tf.PartitionedCall"(%arg0, %arg1) {f = @f} : (tensor<f32>, tensor<f32>) -> tensor<f32>
  return %1 : tensor<f32>
}

// -----

func.func private @f(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {

    %2:2 = tf_executor.island wraps "tf.StatefulPartitionedCall"(%0#0, %arg1) {Tin = ["tfdtype$DT_FLOAT", "tfdtype$DT_RESOURCE"], Tout = ["tfdtype$DT_FLOAT"], _gradient_op_type = "PartitionedCall-1205", config = "", config_proto = "\0A\07\0A\03GPU\10\00\0A\07\0A\03CPU\10\012\02J\008\01", device = "", executor_type = "", f = @function0} : (tensor<f32>, tensor<*x!tf_type.resource<tensor<3x3x1x32xf32>>>) -> tensor<f32> loc("statefulpartitionedcall")...

    : (tensor<!tf_type.variant<tensor<f32>>>, tensor<i1>) -> tensor<!tf_type.variant<tensor<f32>>>
  // CHECK: %[[CALL2:.*]]:2 = "tf.PartitionedCall"(%[[INIT]],
  // CHECK-SAME: f = @callee_tensorlist_decomposed
  %call2 = "tf.PartitionedCall"(%tl, %arg0) {f = @callee, config = "", config_proto = "", executor_type = ""}
    : (tensor<!tf_type.variant<tensor<f32>>>, tensor<i1>) -> tensor<!tf_type.variant<tensor<f32>>>

}

void CreateSubgraphCallingFunctionWithRefVar(const Scope& s) {
  NameAttrList ref_float_function;
  ref_float_function.set_name("RefFloatFn");
  ops::PartitionedCall call(s.WithOpName("RefFloat"), {absl::Span<Input>{}},
                            {DT_FLOAT}, ref_float_function);
  Output constant =
      ops::Const(s.WithOpName("constant_ref_pco"), Input::Initializer(0.0));

  Output x = Placeholder(scope_, DT_FLOAT);
  NameAttrList f;
  f.set_name("XTimesTwo");
  (*f.mutable_attr())["T"].set_type(DT_FLOAT);
  auto results =
      PartitionedCall(scope_, std::initializer_list<Input>{x}, {DT_FLOAT}, f);
  RunTest(x, {}, results[0], {});

  auto stateful_results = StatefulPartitionedCall(
      scope_, std::initializer_list<Input>{x}, {DT_FLOAT}, f);