}

  std::unordered_set<std::string> tag_set(tag_names.begin(), tag_names.end());
  return quant::stablehlo::SavedModelToMlirModuleOp(
      input_path, tag_set, exported_model_signatures, *context);
}

// Convert an TF module to a StableHLO module
absl::StatusOr<OwningOpRef<ModuleOp>> ConvertTFToStablehlo(
    quant::stablehlo::ImportedMlirModuleOp imported_module,
    absl::string_view input_path, MLIRContext* context,

  options.enable_per_channel_quantized_weight_ =
      enable_per_channel_quantized_weight_;
  // Change this to user-given bit width once we have custom configuration.
  options.bit_width_ = 8;

  // Insert quantization parameters for weights for ops with `weight_only_ptq`
  // attribute.
  pm.addNestedPass<func::FuncOp>(createInsertWeightParamPass());

  // PrepareQuantizePass uses SymbolTable to fetch relevant GEMM ops for

// RUN: tf-quant-opt %s -split-input-file -quant-convert-fake-quant-to-qdq -quant-lift-quantizable-spots-as-functions='target-opset=XLA' -quant-insert-quantized-functions -quant-quantize-composite-functions='target-opset=XLA' -symbol-dce -inline -tf-shape-inference -canonicalize -quant-replace-cast-hacks-with-tf-xla-ops -cse -quant-optimize | FileCheck %s

module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 1219 : i32}, tf_saved_model.semantics} {

// folding logic will use a "arith.constant" op to replace the
// "tf.FakeQuantWithMinMaxVarsOp", the "quant.qcast" op is used to preserve
// the quantization parameters as a TypeAttr and "quant.dcast" op used to
// convert the output type to the next op. Here are the transformations:
//
// input   min cst       max cst              input
//  \       |             |                     |
//   \  (tf.Identity) (tf.Identity)   =>   quant.qcast

package p

func f() {
	_ = bool("")      // ERROR "cannot convert .. \(.*untyped string.*\) to type bool|invalid type conversion"
	_ = bool(1)       // ERROR "cannot convert 1 \(.*untyped int.*\) to type bool|invalid type conversion"
	_ = bool(1.0)     // ERROR "cannot convert 1.* \(.*untyped float.*\) to type bool|invalid type conversion"
	_ = bool(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(.*untyped complex.*\) to type bool|invalid type conversion"

				},
				revert: func() {
					temp = temp - 1
				},
			},
			callbackTransaction{
				commit: func() {
					temp = temp + 2
				},
				revert: func() {
					temp = temp - 2
				},
			},
			callbackTransaction{
				commit: func() {
					temp = temp + 3
				},
				revert: func() {
					temp = temp - 3
				},
			},
		},
		want: 10,
	}, {
		name: "missing revert",

        def initialProperties = initialPropertiesConverter.convert(parsedCommandLine)
        def buildLayout = buildLayoutConverter.convert(initialProperties, parsedCommandLine, null) {
            it.gradleUserHomeDir = userHome // don't use the default
        }
        def properties = propertiesConverter.convert(initialProperties, buildLayout)

	const _ = string(true /* ERROR "cannot convert" */ )
	const _ = string(1.2 /* ERROR "cannot convert" */ )
	const _ = string(nil /* ERROR "cannot convert" */ )

	// issues 11357, 11353: argument must be of integer type
	_ = string(0.0 /* ERROR "cannot convert" */ )
	_ = string(0i /* ERROR "cannot convert" */ )
	_ = string(1 /* ERROR "cannot convert" */ + 2i)
}

func interface_conversions() {
	type E interface{}

               << "': " << error.message() << "\n";
    return 1;
  }

  // Load the MLIR module.
  mlir::DialectRegistry registry;
  registry.insert<mlir::TF::TensorFlowDialect, mlir::TFL::TensorFlowLiteDialect,
                  mlir::arith::ArithDialect, mlir::func::FuncDialect>();
  mlir::MLIRContext context(registry);

  llvm::SourceMgr source_mgr;

  // CHECK: %[[BITCAST:.*]] = stablehlo.bitcast_convert %arg0 : (tensor<1x256128xi32>) -> tensor<1x256128xf32>
  // CHECK: %[[CONVERT:.*]] = stablehlo.convert %[[BITCAST]] : (tensor<1x256128xf32>) -> tensor<1x256128xbf16>
  // CHECK: return %[[CONVERT]] : tensor<1x256128xbf16>
  %20 = stablehlo.bitcast_convert %arg0 : (tensor<1x256128xi32>) -> tensor<1x256128xf32>
  return %20 : tensor<1x256128xf32>
}

// -----