text: use a function call in (Eventually|Consistently)

    # https://github.com/kubernetes/kubernetes/issues/117288#issuecomment-1507012435
    - linters:
        - gocritic
      text: "ifElseChain: rewrite if-else to switch statement"

    # Only packages listed here opt into the strict "exported symbols must be documented".
    #

    const Type quantized_type =
        quant_type.castFromExpressedType(expressed_type);

    rewriter.setInsertionPointAfter(op);
    auto q = rewriter.create<quantfork::QuantizeCastOp>(
        op->getLoc(), quantized_type, op->getResult(0));
    auto dq = rewriter.create<quantfork::DequantizeCastOp>(op->getLoc(),
                                                           expressed_type, q);

      text: use a function call in (Eventually|Consistently)

    # https://github.com/kubernetes/kubernetes/issues/117288#issuecomment-1507012435
    - linters:
        - gocritic
      text: "ifElseChain: rewrite if-else to switch statement"

    # Only packages listed here opt into the strict "exported symbols must be documented".
    #

    TF_RETURN_IF_ERROR(root.status());

    // We already have a TensorFlow function call into the cluster -- the
    // original node we set out to rewrite.  We just wire in the correct control
    // deps and we're done.
    RemoveAllIncomingControlEdges(g, n);
    Operation inverse_predicate_as_control =
        DataToControl(root, inverse_predicated_compilation_key);

      /*attr_def=*/{}, /*node_def=*/{{{"out"}, "Identity", {"in"}}},
      /*ret_def=*/{{"out", "out:output:0"}});
  *fdef_lib.add_function() = std::move(func);
  return fdef_lib;
}

// This tests a rewrite that only makes sense and is active in a CUDA-enabled
// build.  Specifically we check that we insert an IdentityN op to avoid extra
// device-to-host copies.

    EmptyPatternRewriter pattern_rewriter(op_builder);

    LogicalResult result =
        Tf2XlaRewriter::RewriteOp(&op, pattern_rewriter,
                                  /*device_type=*/"XLA_CPU_JIT");
    if (!result.succeeded()) {
      return tsl::errors::Internal("Failed to rewrite op");
    }

    return absl::OkStatus();
  }

  Status LegalizeModule(std::string module_string = kMlirModuleStr) {

      text: use a function call in (Eventually|Consistently)

    # https://github.com/kubernetes/kubernetes/issues/117288#issuecomment-1507012435
    - linters:
        - gocritic
      text: "ifElseChain: rewrite if-else to switch statement"

    # Only packages listed here opt into the strict "exported symbols must be documented".
    #

  auto rewrite = [&](auto op_type) {
    auto empty = rewriter.getStringAttr("");
    ReplaceTfOpWithNewOp<typename decltype(op_type)::CallOp>(
        rewriter, op, op.getResultTypes(), op.getInput(), func,
        /*config=*/empty, /*config_proto=*/empty, /*executor_type=*/empty);
  };

  if (op.getIsStateless())
    rewrite(CallOpType<PartitionedCallOp>{});
  else

  let dependentDialects = ["tf_device::TensorFlowDeviceDialect"];
}

def XlaRewritePass : Pass<"tf-xla-rewrite", "mlir::ModuleOp"> {
  let summary = "Rewrites partition calls into Xla launch ops to make the attached function run on XLA.";

  let description = [{
    This pass rewrites `tf.PartitionedCall` and `tf.StatefulPartitionedCall`
    operations with `_xla_compile_device_type` attribute in a

  // runs, embedding attributes are stripped and the sequencing pass will have
  // no effect. If the pipelining pass doesn't run, embedding attributes are
  // preserved and the sequencing rewrite will trigger.
  pm.addPass(mlir::TFDevice::CreateEmbeddingPipeliningPass());
  pm.addPass(mlir::TFDevice::CreateEmbeddingSequencingPass());
  pm.addPass(tensorflow::tf2xla::internal::CreateTPUClusterFormationPass(