QuantizationUnits& quantizable_ops) const {
    bool quantized = false;

    for (auto& quant_op : quantizable_ops) {
      if (quant_specs_.inference_type == tensorflow::DT_QINT8) {
        quantized |= quantizeOpAsInt8(rewriter, op, quant_op);
      }
    }
    return quantized;
  }

 protected:
  QuantizationSpecs quant_specs_;
  OpSet op_set_;

// RUN: stablehlo-quant-opt %s -split-input-file -verify-diagnostics \
// RUN:     -stablehlo-quantize-composite-functions | FileCheck --check-prefix=CHECK %s

// Test that per-tensor weight-only quantized dot_general op is produced when
// empty `weight_only_ptq` is provided.

module attributes {tf_saved_model.semantics} {
  func.func private @quantize_dot_general_per_tensor(%arg0: tensor<1x2xf32>) -> tensor<1x3xf32> attributes {tf._original_func_name = "main_0"} {

    if bias_fn:
      self.assertTrue(re.search('stablehlo.add.*xi32>', module_str))
    # Consider if there is a way to check if activation fusion is properly
    # done in MLIR level.
    # Tests that the quantized graph outputs similar values. The rtol and atol
    # values are arbitrary.
    self.assertAllClose(new_outputs, expected_outputs, rtol=0.3, atol=0.2)

    # Due to other meta data, the compression is not exactly 1/4.

    }
    return false;
  }

  // Uses `quant_params` to quantize `value` and inserting a pair of
  // tfl.quantize and tfl.dequantize ops for this `value`.
  void QuantizeValue(OpBuilder builder, Value value,
                     quant::QuantParams quant_params);

  // If the value hasn't been quantized, the functions adds it to `values`.

// Decompose ops.
std::unique_ptr<OperationPass<func::FuncOp>> CreateDecomposeTFOpsPass(
    std::optional<ModuleOp> tfr_module = std::nullopt);

// Rewrites quantized operands and results with their storage types.
// This pass should be run at module level after decomposition, if there are
// quantized operands or results.
std::unique_ptr<OperationPass<ModuleOp>> CreateRewriteQuantizedIOPass();

// Raise to TF ops.

              Eq(TensorType_INT8));

  // Verify FC bias should be int32 quantized.
  ASSERT_THAT(float_graph->tensors()->Get(float_op->inputs()->Get(2))->type(),
              Eq(TensorType_FLOAT32));
  EXPECT_THAT(subgraph->tensors[op->inputs[2]].get()->type,
              Eq(TensorType_INT32));

  // The output tensor of FC should be int8 quantized.
  ASSERT_THAT(float_graph->tensors()->Get(float_op->outputs()->Get(0))->type(),

include "tensorflow/compiler/mlir/quantization/common/attrs_and_constraints.td"

// Re-orders the Identity op following a quantized composite function. This
// allows the QuantizeCompositeFunctionsPass to merge the DequantizeCast with
// the quantized composite function to optimize the requantization part.
def ReorderIdentityFollowingQuantizedFunction : Pat<
  (quantfork_DequantizeCastOp:$output

namespace mlir::quant::stablehlo {

// Performs post-calibration graph transformation as part of post-training
// static-range quantization.
//
// The resulting `ModuleOp` contains quantized StableHLO ops serialized in
// `TF::XlaCallModuleOp`s. They are quantized using the statistics collected
// after the calibration step, corresponding to each `TF::CustomAggregatorOp`s
// in the input module op.
class PostCalibrationComponent : public Component {

  }

  return nullptr;
}

/// Converts a real expressed DenseFPElementsAttr to a corresponding
/// DenseElementsAttr (typically DenseIntElementsAttr) containing quantized
/// storage values assuming the given quantizedElementType and converter.
static DenseElementsAttr convertDenseFPElementsAttr(
    DenseFPElementsAttr realFPElementsAttr,
    quant::QuantizedType quantizedElementType,

        op_set=target_opset,
    )

    if target_opset != quant_opts_pb2.XLA:
      # Uniform quantized opset is not supported for weight-only
      with self.assertRaisesRegex(
          ValueError, 'TF/Uniform quantized opset does not support weight-only.'
      ):
        converted_model = quantize_model.quantize(
            input_saved_model_path,
            output_directory,
            quantization_options,