return function_aliases;
}

void UpdateFunctionAliases(
    absl::flat_hash_map<FunctionName, FunctionAlias>& function_aliases,
    ModuleOp module_op) {
  absl::flat_hash_set<FunctionName> existing_func_names;
  module_op->walk([&](func::FuncOp func_op) {
    FunctionName func_name = func_op.getSymName().str();
    existing_func_names.insert(func_name);

    const std::vector<std::string>& signature_keys,
    MLIRContext& ctx ABSL_ATTRIBUTE_LIFETIME_BOUND);

// Gets the function aliases from the SavedModel.
absl::StatusOr<absl::flat_hash_map<FunctionName, FunctionAlias>>
GetFunctionAliases(absl::string_view saved_model_path,
                   const std::unordered_set<std::string>& tags);

// Updates the function aliases. `module_op` may have different

      absl::Nonnull<MLIRContext*> ctx,
      absl::Nonnull<const tensorflow::quantization::PyFunctionLibrary*>
          py_function_lib,
      absl::string_view src_saved_model_path,
      absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases,
      std::unordered_set<std::string> tags,
      absl::flat_hash_map<std::string, tensorflow::SignatureDef>
          signature_def_map,
      std::vector<std::string> signature_keys);

    std::vector<std::string> signature_keys,
    std::unordered_set<std::string> tags,
    absl::flat_hash_map<std::string, SignatureDef> signature_def_map,
    absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases)
    : ctx_(ctx) {
  // Initialize the three sub-components.
  sub_components_[0] = std::make_unique<PreCalibrationComponent>(ctx_);

using ::mlir::quant::stablehlo::CreateMlirContextForQuantization;
using ::mlir::quant::stablehlo::ExportOptions;
using ::mlir::quant::stablehlo::FunctionAlias;
using ::mlir::quant::stablehlo::FunctionName;
using ::mlir::quant::stablehlo::GetFunctionAliases;
using ::mlir::quant::stablehlo::kExportStepSuffix;
using ::mlir::quant::stablehlo::PostCalibrationComponent;
using ::mlir::quant::stablehlo::PreCalibrationComponent;

  return input_args_.front();
}

ArgView OpView::OnlyOutput() const {
  CHECK_EQ(output_args_.size(), 1);  // Crash OK
  return output_args_.front();
}

string OpView::FunctionName() const { return op_.name(); }

string OpView::OpNameString() const { return Quoted(op_.name()); }

string OpView::VariableName() const { return "op_ptr"; }

std::vector<string> OpView::Description() const {

              quantization_config.tf_saved_model().tags().end());

  std::unique_ptr<MLIRContext> ctx = CreateMlirContextForQuantization();

  absl::StatusOr<absl::flat_hash_map<FunctionName, FunctionAlias>>
      function_aliases = GetFunctionAliases(src_saved_model_path, tags);
  if (!function_aliases.ok()) {
    return absl::InternalError(absl::StrCat(

    ): List<FunctionResolutionAndBinding> {
        val receiverType = getDataType(receiver) as? DataClass
            ?: return emptyList()
        val functionName = functionCall.name
        val matchingMembers = receiverType.memberFunctions.filter { it.simpleName == functionName }
        // TODO: support optional parameters?
        // TODO: support at least minimal overload resolution?
        val args = functionCall.args

CalibrationComponent::CalibrationComponent(
    absl::Nonnull<MLIRContext*> ctx,
    absl::Nonnull<const PyFunctionLibrary*> py_function_lib,
    const absl::string_view src_saved_model_path,
    absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases,
    std::unordered_set<std::string> tags,
    absl::flat_hash_map<std::string, SignatureDef> signature_def_map,
    std::vector<std::string> signature_keys)

         *
         * TODO: once we have identity-aware configuring functions, include the arguments in this key.
         */
        data class CanMergeBlock(
            val functionName: String,
            val configuredTypeName: FqName
        ) : MergeKey
    }

    fun interface MergeKeyMapper {
        fun mapNodeToMergeKey(node: DeclarativeDocument.DocumentNode): MergeKey
    }
}