CompileTimeConstantOperand<TF::GatherV2Op, 2>,     // $axis
      CompileTimeConstantOperand<TF::IRFFT2DOp, 1>,      // $fft_length
      CompileTimeConstantOperand<TF::IRFFT3DOp, 1>,      // $fft_length
      CompileTimeConstantOperand<TF::IRFFTOp, 1>,        // $fft_length
      CompileTimeConstantOperand<TF::InTopKV2Op, 2>,     // $k
      CompileTimeConstantOperand<TF::LinSpaceOp, 2>,     // $num

    return true;
  if ((op_name == "stablehlo.dynamic_slice" || op_name == "stablehlo.gather") &&
      field_name == "slice_sizes")
    return true;
  if (op_name == "stablehlo.fft" && field_name == "fft_length") return true;
  if ((op_name == "stablehlo.map" || op_name == "stablehlo.reduce" ||
       op_name == "stablehlo.reverse") &&
      field_name == "dimensions")
    return true;
  if (op_name == "stablehlo.pad" &&

    (convertIntAttrTo32Bit $new_axis_mask),
    (convertIntAttrTo32Bit $shrink_axis_mask),
    (GetBoolAttr<false>))>;

def LegalizeRfft2d : Pat<
  (TF_RFFT2DOp $input, $fft_length),
  (TFL_RFFT2dOp $input, $fft_length)>;

def LegalizeComplexAbs : Pat<(TF_ComplexAbsOp $arg), (TFL_ComplexAbsOp $arg)>;

def LegalizeReal : Pat<(TF_RealOp $arg), (TFL_RealOp $arg)>;

signal over the inner-most dimension of `input`.

The inner-most dimension of `input` is assumed to be the result of `RFFT`: the
`fft_length / 2 + 1` unique components of the DFT of a real-valued signal. If
`fft_length` is not provided, it is computed from the size of the inner-most
dimension of `input` (`fft_length = 2 * (inner - 1)`). If the FFT length used to
compute `input` is odd, it should be provided since it cannot be inferred
properly.

Since the DFT of a real signal is Hermitian-symmetric, `RFFT2D` only returns the
`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
of `output`: the zero-frequency term, followed by the `fft_length / 2`
positive-frequency terms.

Along each axis `RFFT2D` is computed on, if `fft_length` is smaller than the
corresponding dimension of `input`, the dimension is cropped. If it is larger,

  // CHECK: "mhlo.fft"(%arg0) <{fft_length = dense<8> : tensor<1xi64>, fft_type = #mhlo<fft_type RFFT>}> : (tensor<8xf32>
  %0 = "tf.RFFT"(%arg0, %fftlength) : (tensor<8xf32>, tensor<1xi32>) -> tensor<5xcomplex<f32>>
  func.return %0 : tensor<5xcomplex<f32>>
}

// -----

// CHECK-LABEL: func @rfft_1D_padded
func.func @rfft_1D_padded(%arg0: tensor<7xf32>) -> tensor<5xcomplex<f32>> {

      return failure();
    }
    int64_t fft_length;
    if (fft_length_attr.getNumElements() != 0) {
      fft_length = fft_length_attr.getValues<IntegerAttr>()[0].getInt();
    } else {
      return failure();
    }

    int64_t expected_dim = fft_length;
    std::string fft_string = "RFFT";
    if (typeid(OpTy) == typeid(TF::IRFFTOp)) {
      expected_dim = fft_length / 2 + 1;
      fft_string = "IRFFT";

  let hasCanonicalizer = 1;
}

def TFR_GetLengthOp : TFR_Op<"get_length", [Pure]> {
  let description = [{
    The `get_length` operation returns the number of tensors for a
    tfr.tensor_list.

    Example:

    ```mlir
    %2 = tfr.get_length(%1) : tfr.tensor -> index
    %2 = tfr.get_length %1 -> index
    ```
  }];

  let arguments = (ins TFR_TensorListType:$tensor_list);

// CHECK-NEXT: return %[[c]] : !tfr.attr
}

// -----

// CHECK-LABEL: get_length
func.func @get_length(%arg0: !tfr.tensor<A>, %arg1: !tfr.tensor<B>) -> index {
  %0 = "tfr.build_list"(%arg0, %arg1) : (!tfr.tensor<A>, !tfr.tensor<B>) -> !tfr.tensor_list
  %1 = "tfr.get_length"(%0) : (!tfr.tensor_list) -> index
  func.return %1 : index

// CHECK-NEXT: %[[c:.*]] = arith.constant 2 : index

  func.return %4 : !tfr.attr
}

// -----

// CHECK-LABEL: get_length
func.func @get_length(%arg0: !tfr.tensor<A>, %arg1: !tfr.tensor<B>) -> index {
  %0 = "tfr.build_list"(%arg0, %arg1) : (!tfr.tensor<A>, !tfr.tensor<B>) -> !tfr.tensor_list
  %1 = "tfr.get_length"(%0) : (!tfr.tensor_list) -> index
  func.return %1 : index
}

// -----

// CHECK-LABEL: tfr.func