"  $0.getType().cast<RankedTensorType>().getRank() - 1)">]>>;

def IsNotComplexType : Constraint<And<[
  CPred<"$0.getType().isa<RankedTensorType>()">,
  CPred<"!$0.getType().cast<ShapedType>().getElementType().isa<ComplexType>()">
]>>;

// Only fuse multiplier if all dimensions other than the channel dimension
// are equal to 1.
def CanFuseMulAndConv2D :

bool IsExpressedTypeF32(QuantizedType quantized_type);

// Given a value, extract the `ElementType`.
// `value` should be a non-null `TensorType`.
inline Type GetElementType(const Value value) {
  return mlir::cast<TensorType>(value.getType()).getElementType();
}

// Returns true iff `type` is a uniform quantized type whose storage type is
// 8-bit integer and expressed type is f32.
bool IsI8F32UniformQuantizedType(Type type);

    Value iota = reduce_op.getInputs().back();
    if (!MatchIota(reduce_op.getDimensions(), iota)) return failure();

    // Match the reduction computation.
    const bool is_float = mlir::isa<FloatType>(operand_init.getElementType());
    if (failed(MatchReduceToArgMinMaxType1(reduce_op, is_float, is_argmax)) &&
        failed(MatchReduceToArgMinMaxType2(reduce_op, is_argmax)))
      return rewriter.notifyMatchFailure(

 public:
  using ConvertReduceOpToArgMinMax::ConvertReduceOpToArgMinMax;

  bool IsValueInitValue(const DenseElementsAttr& attr) const override {
    auto element_type = attr.getType().getElementType();
    if (attr.getNumElements() != 1 || !element_type.isIntOrFloat())
      return false;
    if (mlir::isa<FloatType>(element_type)) {
      auto value = *attr.value_begin<APFloat>();

UnrankedTensorType CreateUnknownShapeFromElementType(Type tensor_type) {
  if (!mlir::cast<TensorType>(tensor_type)) return UnrankedTensorType();
  return UnrankedTensorType::get(
      mlir::cast<TensorType>(tensor_type).getElementType());
}

}  // namespace quant

}

bool IsValueWithQuantizablePrecision(Value val) {
  auto type = mlir::dyn_cast<ShapedType>(val.getType());
  if (!type) return false;
  // Supported original tensor data types.
  if (type.getElementType().isF32() || type.getElementType().isBF16())
    return true;
  return false;
}

std::optional<tensorflow::quantization::QuantizationComponentSpec>
GetWeightComponentSpec(

    QuantizedType GetResultQuantizedType(int index) {
      auto op = this->getOperation();
      const auto result_type =
          op->getResult(index).getType().template cast<ShapedType>();
      if (!result_type.getElementType().template isa<FloatType>()) return {};
      Builder builder(op->getContext());
      const IntegerType storage_type = builder.getIntegerType(BitWidth);
      const double scale = static_cast<double>(ScaleMantissa) *

  return isa<FloatType>(type) && type.getIntOrFloatBitWidth() > 16;
}

Type ToBfloat16Type(Type type) {
  if (auto shaped = mlir::dyn_cast<ShapedType>(type)) {
    const Type elem = shaped.getElementType();
    if (IsLargeFloatType(elem)) {
      return shaped.clone(BFloat16Type::get(type.getContext()));
    }
  } else if (IsLargeFloatType(type)) {
    return BFloat16Type::get(type.getContext());
  }

    // arith ConstOp path.
    auto type =
        mlir::cast<ShapedType>(arith_const_op.getType()).getElementType();
    if (!type.isInteger(32) && !type.isInteger(64)) return false;
  } else if (auto const_op = dyn_cast_or_null<TFL::ConstOp>(op)) {
    // ConstOp path.
    auto type = mlir::cast<ShapedType>(const_op.getType()).getElementType();
    if (!type.isInteger(32) && !type.isInteger(64)) return false;
  } else {
    // QConstOp path.

        // TODO: We likely want to also immediately realize ChangingValue providers in the
        //  onValueChange callback above.
        if (subscriptionVerifier.isSubscribed(provider.getElementType())) {
            realize(Collections.singleton(collector));

            // Ugly backwards-compatibility hack. Previous implementations would notify listeners without