// `lower_static_tensor_list` pass.
  return element_type->isF32() || element_type->isInteger(64) ||
         element_type->isInteger(32) || element_type->isInteger(1);
}

// Only legalize TensorFlow TensorList ops if all TensorList ops are supported
// natively.
class LegalizeTensorListPass
    : public impl::LegalizeTensorListPassBase<LegalizeTensorListPass> {
 public:

  [TF_UnsortedSegmentMaxOp, TFL_UnsortedSegmentMaxOp],
  [TF_UnsortedSegmentMinOp, TFL_UnsortedSegmentMinOp],
  [TF_UnsortedSegmentProdOp, TFL_UnsortedSegmentProdOp]] in {
  def Legalize#UnsortedSegmentOp[0] :
     Pat<(UnsortedSegmentOp[0] $data, $segment_ids, $num_segments),
              (UnsortedSegmentOp[1] $data, (CreateTFCastToInt32Op $segment_ids),

// COM: This file is there to check that the `tfl-legalize-hlo` pass exists in `odml-to-stablehlo-opt`.

// RUN: odml-to-stablehlo-opt %s -tfl-legalize-hlo -split-input-file | FileCheck %s --dump-input=fail

func.func @main(%arg0: tensor<5x7xf32>) -> tensor<5x7xf32> {
  func.return %arg0: tensor<5x7xf32>
// CHECK-LABEL: main
// CHECK: return %arg0 : tensor<5x7xf32>
}

// - transpose
//

        /*padding=*/state->padding,
        /*stride_h=*/state->stride_height,
        /*stride_w=*/state->stride_width);
  }

 private:
  // Legalize the given filter by converting it from TensorFlow filter data
  // format HWIO to TFLite Conv2D op filter data format OHWI and return Value
  // for the converted filter.  Requires that filter is verified by the match

}

// -----

func.func @tf_const_invalid_proto() -> tensor<2x!tf_type.qint32> {
  // expected-error@+2 {{failed to get DenseElementAttr}}
  // expected-error@+1 {{failed to legalize operation 'tf.Const'}}
  %0 = "tf.Const"() { value = #tf_type<tensor_proto : "0x2532"> : tensor<2x!tf_type.qint32> } : () -> tensor<2x!tf_type.qint32>
  func.return %0 :  tensor<2x!tf_type.qint32>
}

// -----

// (either defined in TensorArrayV3 or implied in the first write).
std::unique_ptr<OperationPass<ModuleOp>>
CreateTensorArrayOpsDecompositionPass();

// Create a pass that legalize TFG to TF dialect.
std::unique_ptr<Pass> CreateLegalizeTFGToTFEPass();

// Matches sequence of ops to TensorFlow fused kernels. This pass should not be

                        lower_to_xla_hlo);

  if (lower_to_xla_hlo) {
    // This pass operates on MHLO control flow ops so it should be legalized
    // after the control flow ops are legalized.
    pm.addPass(mlir::mhlo::CreateLegalizeTFCommunicationPass());

    // Everything should be MHLO after this.
    if (!allow_partial_conversion) {
      pm.addNestedPass<mlir::func::FuncOp>(

    bool prefer_tf2xla = false);

// Legalizes TF/XLA communication ops (TF dialect) to HLO dialect communication
// ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeTFCommunicationPass();

// Legalizes TF/XLA collective ops (TF dialect) to HLO dialect collective
// ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeTFCollectivePass();

  let summary = "Transform Einsum to other TF Ops for the supported variants";
  let constructor = "TF::CreateTransformEinsumPass()";
}

def LegalizeTFGToTFPass : Pass<"tfe-legalize-tfg", "ModuleOp"> {
  let summary = "Legalize from TFG to the TFE dialect";
  let constructor = "TF::CreateLegalizeTFGToTFEPass()";
}

def ReplicateToIslandPass : Pass<"tf-replicate-to-island", "mlir::func::FuncOp"> {

#include "tensorflow/core/lib/math/math_util.h"
#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/util/padding.h"

namespace mlir {
namespace odml {
namespace {

#define DEBUG_TYPE "tf-legalize-hlo"

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

class LegalizeHloToTf : public impl::LegalizeHloToTfPassBase<LegalizeHloToTf> {