auto &requantize = states_manager_.GetOperandRequantizeState(op, i);
      if (state.IsEmpty() && requantize.pos == RequantizeState::NO_REQUANTIZE) {
        input_specs.push_back(original_input_specs[i]);
      } else if (requantize.pos == RequantizeState::ON_OUTPUT) {
        input_specs.push_back(TypeAttr::get(requantize.params));
      } else {

  // ranges.
  bool SetInputNodesQuantizationParams(func::FuncOp func);

  // The function might contain more stats ops than required, and it will
  // introduce requantize if the calibration stats have conflicts. This method
  // tries to remove all the redundant stats ops.
  bool RemoveRedundantStats(func::FuncOp func);

  // Whether the func contains Quantize ops. This is used to determine whether
  // to use the quantization parameters from the fixed output range property.
  bool ContainsQuantizeOps(func::FuncOp func);

  QuantizationSpecs quant_specs_;

  Option<bool> enable_post_training_quantize_{
      *this, "post-training-quantize", llvm::cl::init(false),

struct RequantizeState {
  // Sometimes, we have to "requantize" the quantization result to satisfy all
  // the constraints. The "requantize" can happen either on the input or output
  // of the quantization result.
  enum RequantizePosition {
    NO_REQUANTIZE,
    ON_INPUT,
    ON_OUTPUT
  } pos = NO_REQUANTIZE;

  // Quantization parameters will be used to add the requantize ops.
  QuantParams params;
};

    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-quantize-weights";
  }

  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Quantize weights used by quantizable ops.";
  }

  void getDependentDialects(DialectRegistry& registry) const override {

    assert(scales_.size() == zero_points_.size());
  }

  // Quantize an Attribute by the quantization parameters. Return nullptr if
  // the conversion fails or the input array isn't an ElementsAttr.
  ElementsAttr convert(Attribute real_value);

 private:
  // Quantize an DenseFPElementsAttr by the quantization parameters.
  DenseElementsAttr convert(DenseFPElementsAttr attr);

  EXPECT_FALSE(IsOpFullyQuantized(*add_op_itr));
}

TEST_F(IsOpFullyQuantizedTest, FalseIfOpPartiallyQuantized) {
  constexpr absl::string_view kQuantizeOp = R"mlir(
    func.func @quantize(%arg0: tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32, 1.000000e+00:0>> {
      %0 = stablehlo.uniform_quantize %arg0 : (tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32, 1.000000e+00:0>>

    // 1. Collect quantizable ops.
    QuantizationUnits quantizable_ops = GetQuantizableOps(op);
    if (quantizable_ops.empty()) {
      return failure();
    }

    // 2. Quantize collected ops.
    if (!QuantizeOps(rewriter, op, quantizable_ops)) {
      return failure();
    }

    // 3. Complete the Q-DQ pair for each inference type.
    if (!ConvertToFloat16Constant(rewriter, op)) {

)

filegroup(
    name = "quantize_header",
    srcs = ["quantize.h"],
    visibility = ["//visibility:public"],
)

cc_library(
    name = "tfcompile_lib",
    srcs = [
        "codegen.cc",
        "compile.cc",
        "flags.cc",
    ],
    hdrs = [
        "codegen.h",
        "compile.h",
        "flags.h",
        "quantize.h",
    ],
    compatible_with = [],

// RUN: tf-quant-opt %s -split-input-file -quant-insert-quantized-functions='quantization-method=weight_only target-opset=XLA' -quant-quantize-composite-functions='quantization-method=weight_only target-opset=XLA enable-per-channel-quantization=true' -symbol-dce...