namespace mlir {
namespace TFL {

// A config that controls which passes get run as part TFLite converter.
struct PassConfig {
  explicit PassConfig(quant::QuantizationSpecs specs)
      : quant_specs(std::move(specs)) {}

  // If `emit_builtin_tflite_ops` is true, TF Lite legalization passes will be
  // added, which produces TF Lite ops.
  bool emit_builtin_tflite_ops = true;

  // Initialize for tests.
  void initializeForTest() {
    if (!test_mode_) return;

    tensorflow::quantization::QuantizationComponentSpec quant_spec;
    quant_spec.set_quantization_component(
        tensorflow::quantization::QuantizationComponentSpec::COMPONENT_WEIGHT);
    quant_spec.set_tensor_type(
        tensorflow::quantization::QuantizationComponentSpec::TENSORTYPE_INT_8);

        CreatePrepareQuantizePass(quant_specs, quantization_method_));
    pm.addNestedPass<func::FuncOp>(
        CreateQuantizePass(quant_specs, target_opset_));
    pm.addNestedPass<func::FuncOp>(CreatePostQuantizePass());
  } else {
    // Apply weight quantization.
    quant_specs.minimum_elements_for_weights = min_num_elements_for_weights_;
    quant_specs.weight_quantization = true;

std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass(
    QuantizationSpecs quant_specs,
    tensorflow::quantization::OpSet target_opset);

// Creates an instance of the PrepareQuantize pass, which will perform similar
// transformations as TFL::PrepareQuantizePass.
std::unique_ptr<OperationPass<func::FuncOp>> CreatePrepareQuantizePass(
    const QuantizationSpecs& quant_specs,
    tensorflow::quantization::QuantizationMethod::PresetMethod

// input arrays.
Status PopulateQuantizationSpecs(
    const toco::ModelFlags& model_flags, toco::TocoFlags& toco_flags,
    mlir::quant::QuantizationSpecs* quant_specs,
    std::vector<string>* node_names, std::vector<string>* node_dtypes,
    std::vector<std::optional<std::vector<int>>>* node_shapes,
    std::vector<std::optional<double>>* node_mins,

    absl::flat_hash_set<std::string> ops_blocklist =
        quant_params_.quant_spec.ops_blocklist;
    absl::flat_hash_set<std::string> nodes_blocklist =
        quant_params_.quant_spec.nodes_blocklist;
    CustomMap custom_map = quant_params_.quant_spec.custom_map;

    // Rewrite the floating-point ops to the quantized version, by fusing
    // preceding dequantize ops and succeding quantize ops.

                              absl::string_view max_values,
                              absl::string_view inference_type,
                              QuantizationSpecs* quant_specs);

// Gets the quantization specification for input arrays. The array names are not
// stored in the spec, and will be matched by position. The min/max will be

// RUN: tf-opt %s -tfl-prepare-quantize="is-qdq-conversion=true" | FileCheck --check-prefix=QDQ %s

// CHECK-LABEL: main
// Uses `main` function to match the default target function of QuantSpecs and
// execute the production code path.
func.func @main(%arg0: tensor<2x1xf32>, %arg1: tensor<2x3xf32>) -> (tensor<2x4xf32>) {