// given `rank`.
inline bool IsOfRankedFloatTensorType(RankedTensorType type, int rank) {
  return type && type.getRank() == rank &&
         mlir::isa<FloatType>(type.getElementType());
}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {
  RankedTensorType type = GetRankedTensorTypeForOperand(value);

                                                     res_attr);
  return success();
}

static LogicalResult FoldDivOp(stablehlo::DivOp op, PatternRewriter& rewriter) {
  auto etype = op.getType().getElementType();
  if (etype.isa<FloatType>()) {
    return FoldDivOpInternal<APFloat>(op, rewriter);
  }
  if (etype.isa<IntegerType>()) {
    return FoldDivOpInternal<APInt>(op, rewriter);
  }
  return failure();

  const int identity =
      (std::is_same<OpT, MulOp>::value || std::is_same<OpT, DivOp>::value ||
       std::is_same<OpT, RealDivOp>::value)
          ? 1
          : 0;

  Type element_ty = lhs_type.getElementType();
  Attribute identity_attr;
  if (auto ty = mlir::dyn_cast<FloatType>(element_ty)) {
    identity_attr = FloatAttr::get(ty, static_cast<double>(identity));

      shape[0] = ShapedType::kDynamic;
      auto extensions =
          mhlo::TypeExtensionsAttr::get(func->getContext(), bounds);
      auto resultType =
          RankedTensorType::get(shape, inputType.getElementType(), extensions);
      arg.setType(resultType);
    }
    llvm::SmallVector<Type, 8> arg_types;
    for (auto arg : func.getArguments()) arg_types.push_back(arg.getType());
    func.setType(

}

absl::StatusOr<std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>>
ProcessTensorSpec(mlir::TensorType type) {
  tensorflow::DataType dtype;
  TF_RETURN_IF_ERROR(
      ConvertScalarTypeToDataType(type.getElementType(), &dtype));

  if (!type.hasRank())
    return std::make_pair(dtype, tensorflow::PartialTensorShape());

  auto shape = type.getShape();
  llvm::SmallVector<int64_t, 4> dims;

                    Type type = Type.getObjectType(classDescriptor);
                    while (type.getSort() == Type.ARRAY) {
                        type = type.getElementType();
                    }
                    if (type.getSort() != Type.OBJECT) {
                        // A primitive type
                        continue;
                    }

        auto new_user_op_type = CloneTypeWithNewElementType(
            original_result_type,
            mlir::cast<ShapedType>(op_before_dequantize.getType())
                .getElementType());
        createNewDequantizeOp(rewriter, op, user_op, user_idx,
                              new_user_op_type);
      } else {
        createNewDequantizeOp(rewriter, op, user_op, user_idx,

  EXPECT_TRUE(isa<quantfork::DequantizeCastOp>(filter_dcast_op));
  EXPECT_TRUE(isa<UniformQuantizedPerAxisType>(
      mlir::cast<TensorType>(filter_qcast_op->getResult(0).getType())
          .getElementType()));
}

}  // namespace

  return false;
}

bool IsQuantizedTensorType(Type type) {
  if (!mlir::isa<TensorType>(type)) {
    return false;
  }
  Type element_type = mlir::cast<TensorType>(type).getElementType();
  return mlir::isa<QuantizedType>(element_type);
}

bool IsOpFullyQuantized(Operation* op) {
  return llvm::all_of(op->getOperandTypes(), IsQuantizedTensorType) &&

      const TensorType type, const ArrayRef<int64_t> permutation) const {
    const SmallVector<int64_t> after_shape =
        Permute<int64_t>(type.getShape(), permutation);
    return type.cloneWith(after_shape, type.getElementType());
  }
};

}  // namespace

void NchwConvolutionToNhwcPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();