quantized_type.getStorageTypeIntegralWidth() == 8 &&
         !quantized_type.isSigned();
}

// Return true when the given element_type is QI32.
inline bool IsQI32Type(Type t) {
  auto quantized_type = quant::QuantizedType::getQuantizedElementType(t);
  return quantized_type != nullptr &&
         quantized_type.getStorageTypeIntegralWidth() == 32 &&
         quantized_type.isSigned();
}

}

bool IsStorageTypeI8(const QuantizedType quantized_type) {
  const Type storage_type = quantized_type.getStorageType();
  return storage_type.isInteger(/*width=*/8);
}

bool IsStorageTypeI32(const QuantizedType quantized_type) {
  const Type storage_type = quantized_type.getStorageType();
  return storage_type.isInteger(/*width=*/32);
}

bool IsExpressedTypeF32(const QuantizedType quantized_type) {

    Location loc, MLIRContext& context, ArrayRef<double> scales,
    ArrayRef<int64_t> zero_points, int quantization_dimension);

bool IsStorageTypeI8(QuantizedType quantized_type);

bool IsStorageTypeI32(QuantizedType quantized_type);

bool IsExpressedTypeF32(QuantizedType quantized_type);

// Given a value, extract the `ElementType`.
// `value` should be a non-null `TensorType`.
inline Type GetElementType(const Value value) {

    // populate `coeff_op_quant_dim`.
    for (const auto& [operand_idx, quantized_type] :
         static_range_ptq_spec.input_quantized_types()) {
      if (quantized_type.has_dimension_specs()) {
        spec.coeff_op_quant_dim[operand_idx] =
            quantized_type.dimension_specs().dimension();
      }
    }
  }
}

}  // namespace

// operand's tensor types.
def QI4 : QuantizedType<"Uniform", [4], 1>;
def QUI8 : QuantizedType<"Uniform", [8], 0>;
def QI8 : QuantizedType<"Uniform", [8], 1>;
def QUI16 : QuantizedType<"Uniform", [16], 0>;
def QI16 : QuantizedType<"Uniform", [16], 1>;
def QUI32 : QuantizedType<"Uniform", [32], 0>;
def QI32 : QuantizedType<"Uniform", [32], 1>;

//===----------------------------------------------------------------------===//

      allTypesFp &= !mlir::isa<quant::QuantizedType>(type.getElementType());
      allTypesQuantizedOrInt &=
          (mlir::isa<quant::QuantizedType>(type.getElementType()) ||
           mlir::isa<IntegerType>(type.getElementType()));
    }

    for (auto result : op->getResults()) {
      ShapedType type = mlir::cast<ShapedType>(result.getType());
      allTypesFp &= !mlir::isa<quant::QuantizedType>(type.getElementType());

/// corresponding storage attribute (typically FloatAttr -> IntegerAttr).
/// quantizedElementType is the QuantizedType that describes the expressed
/// origValue.
/// Returns a converter Attribute or nullptr if conversion is not possible.
static Attribute convertPrimitiveValueAttr(
    Attribute origRealValue, quant::QuantizedType quantizedElementType,
    const UniformQuantizedValueConverter &converter, Type &outConvertedType) {

    }

    quant::QuantizedType elementType =
        static_cast<const ConcreteRewriteClass *>(this)
            ->convertFakeQuantAttrsToType(op, converter.expressed_type);

    if (!elementType) {
      // Note that the fakeQuantAttrsToType will have emitted the error.
      return true;
    }

    Type quantizedType = converter.convert(elementType);
    assert(quantizedType &&

class Attribute;
class Type;

namespace quant {
class QuantizedType;
class UniformQuantizedType;
}  // namespace quant
namespace quantfork {
class UniformQuantizedValueConverter;

/// Converts an attribute from a type based on
/// quantizedElementType.getExpressedType() to one based on
/// quantizedElementType.getStorageType(), where quantizedElementType is as from
/// QuantizedType::getQuantizedElementType().

  // storage type is not supported.
  Type qbarrierResultType = qbarrier.getResult().getType();
  QuantizedType quantizedElementType =
      QuantizedType::getQuantizedElementType(qbarrierResultType);
  if (!quantizedElementType) {
    return failure();
  }
  if (!QuantizedType::castToStorageType(qbarrierResultType)) {
    return failure();
  }