// dimensions.
      ShapedType shaped_type =
          mlir::dyn_cast<ShapedType>(call_op->getOperand(0).getType());
      if (!shaped_type || !shaped_type.hasRank()) {
        return absl::InternalError("The input of BatchMatMul must have rank.");
      }
    } else if (function_name.contains("gather")) {
      // This op is guaranteed to be a constant as ODS checks IsConstTensor.

    return rewriter.notifyMatchFailure(op, "op's data format isn't NHWC");
  }

  // Allow dynamic width and height dimensions only.
  auto result_ty = mlir::cast<TensorType>(op.getResult().getType());
  if (!result_ty.hasRank() || result_ty.getRank() != 4 ||
      result_ty.isDynamicDim(0) || result_ty.isDynamicDim(3)) {
    return rewriter.notifyMatchFailure(
        op, "only dynamic width and height dimensions are allowed");
  }

    for (const auto& axis_int : perm.getValues<APInt>()) {
      int64_t axis = axis_int.getSExtValue();
      if (axis < 0) {
        axis += input_type.getRank();
      }
      if (axis < 0 || (input_type.hasRank() && axis >= input_type.getRank())) {
        return transpose_op.emitOpError("perm must be in [-rank, rank)");
      }
      if (std::count(axes.begin(), axes.end(), axis) > 0) {

  // Resolve constraints inferred from the tensor type.
  if (auto tensor = mlir::dyn_cast<TensorType>(value.getType())) {
    if (constraint == ValueConstraint::kRank && tensor.hasRank())
      return success();
    if (constraint == ValueConstraint::kShape && tensor.hasStaticShape())
      return success();
  }

  return failure();
}

      ConversionPatternRewriter &rewriter) const override {
    Value lhs = adaptor.getLhs();

    auto lhs_type = mlir::cast<ShapedType>(lhs.getType());
    if (!lhs_type.hasRank()) {
      return rewriter.notifyMatchFailure(
          op, "Legalization supports cases where only lhs rank known.");
    }

    auto lhs_quant_type = GetUniformQuantizedType(

    return failure();

  auto input = splitv_op.getValue();
  auto input_type = mlir::dyn_cast_or_null<RankedTensorType>(input.getType());
  if (!input_type || !input_type.hasRank()) return failure();

  for (auto result : splitv_op.getResults()) {
    auto result_type = mlir::dyn_cast<RankedTensorType>(result.getType());
    if (result_type == nullptr) return failure();
  }

      auto resource_type =
          mlir::TF::ResourceType::get({resource_subtype}, builder.getContext());

      auto tensor_type = mlir::cast<mlir::TensorType>(mlir_arg.getType());
      if (tensor_type.hasRank()) {
        mlir_arg.setType(
            GetTypeFromTFTensorShape(tensor_type.getShape(), resource_type));
      } else {
        mlir_arg.setType(mlir::UnrankedTensorType::get(resource_type));
      }