// RUN: stablehlo-quant-opt %s -split-input-file -stablehlo-insert-weight-param | FileCheck %s

// Test that q/dq pair with per-tensor quantization parameter is inserted
// between constant and XlaCallModule op with empty `weight_only_ptq` method
// and function name containing conv.

func.func @qdq_for_conv_weight_empty(%arg0: tensor<1x3x2x3xf32>) -> tensor<1x2x2x2xf32> attributes {tf._original_func_name = "main_0"} {

// RUN:   -split-input-file -verify-diagnostics | FileCheck %s

// Tests that a `convolution(%activation, %weight)` with the activation tensor
// NCHW format is converted to NHWC convolution. Transpose ops are inserted to
// the activation and output to match the function signature. The weight
// constant is transposed.

// CHECK-LABEL: nchw_conv
// CHECK-SAME: %[[ARG:.+]]: tensor<1x8x4x4xf32>

int OpOrArgNameMapper::InitOpName(OpOrVal op_or_val, llvm::StringRef name) {
  auto it = name_to_count_.try_emplace(name, 0);
  auto inserted = op_or_val_to_name_.try_emplace(
      op_or_val, StringRefToView(it.first->first()));
  (void)inserted;
  // TODO(jpienaar): Debug cases where we expect this behavior.
  // assert(inserted.second && "op_or_val already initialized");
  return it.first->second++;
}

val copyOnWriteArrayListCodec: Codec<CopyOnWriteArrayList<Any?>> = codec(
    { writeCollection(it) },
    {
        // Avoid the overhead of copying the underlying array for each inserted element
        // by creating the COW data structure from a list.
        CopyOnWriteArrayList(readList())
    }
)


val treeSetCodec: Codec<TreeSet<Any?>> = codec(
    {
        write(it.comparator())

      "^.*(conv|dot_general).*");

  WeightOnlyPtq& weight_only_ptq_spec =
      *spec.mutable_method()->mutable_weight_only_ptq();
  if (auto [iter, inserted] =
          weight_only_ptq_spec.mutable_input_quantized_types()->try_emplace(1);
      inserted) {
    iter->second.mutable_dimension_specs();
  }
  return spec;
}

// Returns a `QuantizationSpec` for performing static-range PTQ on the

	universeComparable = Universe.Lookup("comparable")
}

// Objects with names containing blanks are internal and not entered into
// a scope. Objects with exported names are inserted in the unsafe package
// scope; other objects are inserted in the universe scope.
func def(obj Object) {
	assert(obj.color() == black)
	name := obj.Name()
	if strings.Contains(name, " ") {
		return // nothing to do
	}

	universeComparable = Universe.Lookup("comparable")
}

// Objects with names containing blanks are internal and not entered into
// a scope. Objects with exported names are inserted in the unsafe package
// scope; other objects are inserted in the universe scope.
func def(obj Object) {
	assert(obj.color() == black)
	name := obj.Name()
	if strings.Contains(name, " ") {
		return // nothing to do
	}

// does not have a name and if the result in the signature also does not have a name,
// then the signature and field are renamed to
//
//	fmt.Sprintf("#rv%d", i+1)`
//
// the newly named object is inserted into the signature's scope,
// and the object and new field name are returned.
//
// The intended use for RenameResult is to allow rangefunc to assign results within a closure.

    bool ignore_unregistered_attrs, AttrValueMap* attributes);

// Converts a MLIR operation to TensorFlow NodeDef with given node name. This
// name should be unique to the graph it is being inserted to. If the
// `ignore_unregistered_attrs` argument is set to true, the attributes which are
// not in the op registry will be ignored. If the `ignore_unregistered_attrs`

    for (auto attr : backend_config) {
      if (attr.getName() != kCalledFuncAttrName) {
        new_config.push_back(attr);
      }
    }

    auto [it, inserted] =
        called_indexes.insert({called_func, called_indexes.size()});
    if (inserted) {
      function_list.push_back(called_func);
    }

    // Set the `called_index` attribute to the TF function's name.
    new_config.push_back(builder.getNamedAttr(