}
  });
}

void ResourceAnalyzerTestPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  TF::ResourceAnalyzer resource_analyzer(module_op);

  PrintAnalysisResults(resource_analyzer, module_op);
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateResourceAnalyzerTestPass() {
  return std::make_unique<ResourceAnalyzerTestPass>();
}

  return symbol_table.replaceAllSymbolUses(
      main_func_op, StringAttr::get(module_op.getContext(), new_func_name),
      module_op);
}

void InsertMainFunctionPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  if (failed(RenameExistingMainFunction(module_op))) {
    module_op->emitError("Failed to rename existing function `@main`.");
    signalPassFailure();
  }

}

// Creates and returns a new `FuncOp` named "tf_quant__save". The resulting
// `FuncOp`'s body has no ops.
func::FuncOp CreateEmptySaveFunc(ModuleOp module_op) {
  OpBuilder builder(module_op);
  builder.setInsertionPointToEnd(&module_op.getBodyRegion().front());

  auto filename_input_type = RankedTensorType::get(
      /*shape=*/{}, /*elementType=*/builder.getType<TF::StringType>());

}  // namespace

QuantizationReport::QuantizationReport(ModuleOp module_op)
    : quantization_results_(CollectResultsFromModuleOp(module_op)) {}

QuantizationResults QuantizationReport::CollectResultsFromModuleOp(
    ModuleOp module_op) const {
  QuantizationResults results{};

  PopulateQuantizedResults(module_op, results);
  PopulateNonQuantizedResults(module_op, results);

  return results;
}

  std::vector<std::string> exported_names = signature_keys;
  absl::StatusOr<OwningOpRef<ModuleOp>> module_op =
      SavedModelSignatureDefsToMlirImport(saved_model_path, tags,
                                          absl::MakeSpan(exported_names), &ctx,
                                          import_options, &bundle);
  if (!module_op.status().ok()) {
    return absl::InternalError(absl::StrCat("Failed to import SavedModel: ",

      return %0 : tensor<2x!quant.uniform<i8:f32, 1.000000e+00:0>>
    }
  )mlir";

  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(kFullyQuantizedAdd);
  ASSERT_TRUE(module_op);

  auto func_op = module_op->lookupSymbol<func::FuncOp>("fully_quantized_add");
  ASSERT_THAT(func_op, NotNull());

  auto add_op_itr = func_op.getBody().op_begin<mlir::stablehlo::AddOp>();

    mlir::ModuleOp module_op, mlir::MLIRContext* context,
    std::optional<Session*> session, bool run_tf_to_stablehlo,
    bool deserialize_xla_call_module,
    llvm::ArrayRef<llvm::ArrayRef<int64_t>> input_arg_shapes = {});

// Overload of `PreprocessAndFreezeGraph` that uses the default MLIR dump file
// prefix.
inline absl::Status PreprocessAndFreezeGraph(mlir::ModuleOp module_op,

  std::string checkpoint_dir = "";

  // Name used to identify the ModuleOp this is exporting. Only used for
  // debugging and does not modify the behavior of the export.
  std::string debug_name = "stablehlo_quant";
};

// Creates `ExportedModel` from `module_op`. `module_op` goes through post
// process passes before an `ExportModel` is created.

}

}  // namespace

absl::StatusOr<mlir::ModuleOp> RunQuantization(
    const SavedModelBundle* saved_model_bundle,
    const absl::string_view saved_model_dir,
    const std::unordered_set<std::string>& saved_model_tags,
    const QuantizationConfig& quantization_config,
    const PyFunctionLibrary* quantization_py_function_lib,
    mlir::ModuleOp module_op) {
  if (saved_model_bundle == nullptr) {

  mlir::OwningOpRef<mlir::ModuleOp> module_op = ParseModuleOpString(R"mlir(
    module attributes {tf_saved_model.semantics} {
      func.func @main() -> () attributes {tf_saved_model.exported_names = ["main"]} {
        tf_executor.graph {
          tf_executor.fetch
        }
        return
      }
    }
  )mlir");
  ASSERT_TRUE(module_op);