}

//===----------------------------------------------------------------------===//
// Gather op
//===----------------------------------------------------------------------===//

LogicalResult GatherOp::verify() {
  GatherOp op = *this;
  ShapedType params_type = op.getParams().getType().cast<ShapedType>();
  // TFLite gather kernel supports 1D string input only.
  if (params_type.getElementType().isa<mlir::TF::StringType>()) {

      ConversionPatternRewriter &rewriter) const override {
    Value input = adaptor.getOperands()[0];
    Value index = adaptor.getOperands()[1];
    rewriter.replaceOpWithNewOp<TF::GatherOp>(op, op.getType(), input, index,
                                              rewriter.getBoolAttr(true));
    return success();
  }
};

struct ConvertTensorListLength

  // Here we leave 'slice_sizes' as an Attr, without defining a new
  // DynamicGatherOp, since GatherDimensionNumbers has already provide enough
  // information for shape inference and code generation of mhlo::GatherOp. '?'
  // will be filled into slice_sizes for dimensions that are dynamic sized.
  // TODO(disc): To recover static special case's performance with folding and
  // canonicalization.

                                             converter);
  mhlo::PopulateLegalizeTfPatterns(context, &patterns);
  mlir::odml::PopulateLegalizeHloToTfPatterns(&patterns, context);
  mhlo::GatherOp::getCanonicalizationPatterns(patterns, context);

  return applyPartialConversion(func, target, std::move(patterns));
}

// Convert rfft to rfft2d.
// The transformation pattern looks like below:
//

  BufferOffset<flatbuffers::Vector<unsigned int>> BuildVhloPrecisionConfigV1(
      mlir::vhlo::ArrayV1Attr precisionConfig);

  std::optional<BufferOffset<tflite::Operator>> BuildStablehloGatherOp(
      mlir::stablehlo::GatherOp gather_op, const std::vector<int32_t>& operands,
      const std::vector<int32_t>& results);

  std::optional<BufferOffset<tflite::Operator>> BuildStablehloScatterOp(
      mlir::stablehlo::ScatterOp scatter_op,

namespace {
// If the input of TensorListGetItemOp is TensorListFromTensorOp and the
// TensorListFromTensorOp is only used by TensorListGetItemOp (not modified by
// other TensorList ops), we can convert it to a GatherOp.
class ConvertTensorListGetItemOpOfTensorListFromTensorOpToGather
    : public OpRewritePattern<TensorListGetItemOp> {
  using OpRewritePattern<TensorListGetItemOp>::OpRewritePattern;

                              << ") to be greater than or equal to batch_dims ("
                              << batch_dims << ")";
    }
  }
  return success();
}

void GatherOp::getCanonicalizationPatterns(RewritePatternSet& results,
                                           MLIRContext* context) {
  results.add<GatherToV2>(context);
}