using OpRewritePattern<CallOp>::OpRewritePattern;

 public:
  explicit RewriteTFRCallOp(MLIRContext* context, const SymbolTable& table,
                            bool materialize_derived_attrs)
      : OpRewritePattern<CallOp>(context),
        symbol_table_(table),
        materialize_derived_attrs_(materialize_derived_attrs) {}

  LogicalResult matchAndRewrite(CallOp call_op,

          while_op.ResolveBodyFunction(&symbol_table_)
              .getFunctionType()
              .getInputs());
      return PropagateShapeToFunctions(
          module, compatible_types,
          {while_op.ResolveCondFunction(&symbol_table_),
           while_op.ResolveBodyFunction(&symbol_table_)},
          max_iterations);
    }
    return PropagateShapeToFunctions(

      const SymbolTable& symbol_table, FuncOp function,
      FunctionLibraryDefinition* flib_def,
      llvm::SmallDenseSet<FuncOp>& visited_functions,
      absl::flat_hash_set<Node*>* control_ret_nodes);

 private:
  explicit Exporter(const GraphExportConfig* configs, Graph* graph,
                    const Dialect* tf_dialect, const SymbolTable* symbol_table)
      : configs_(*configs),

      const SymbolTable& symbol_table, FuncOp function,
      FunctionLibraryDefinition* flib_def,
      llvm::SmallDenseSet<FuncOp>& visited_functions,
      absl::flat_hash_set<Node*>* control_ret_nodes);

 private:
  explicit Exporter(const GraphExportConfig* configs, Graph* graph,
                    const Dialect* tf_dialect, const SymbolTable* symbol_table)
      : configs_(*configs),

    }

    // Make a copy of the quantized function.
    auto module = call_op->getParentOfType<ModuleOp>();
    SymbolTable symbol_table(module);

    mlir::func::FuncOp float_func =
        dyn_cast<func::FuncOp>(symbol_table.lookup(f_attr.getValue()));
    rewriter.setInsertionPointAfter(float_func);

    // Applies only for hybrid ops in SRQ.
    const bool is_hybrid =

    // Set up the original function names in the imported TF MLIR.
    mlir::Builder builder(module->getContext());
    mlir::SymbolTable symbol_table(*module);
    for (const auto& [tf_name, mlir_name] : tf_name_to_mlir_name) {
      auto func_op = symbol_table.lookup<mlir::func::FuncOp>(mlir_name);
      TF_RET_CHECK(func_op)
          << "Graphdef importer should have created a function named "

      const auto uses = SymbolTable::getSymbolUses(op);
      if (!uses.has_value()) {
        op->emitOpError() << "contains a potentially unknown symbol table";
        return WalkResult::interrupt();
      }

      for (const SymbolTable::SymbolUse& use : *uses) {
        func::FuncOp called_func =
            symbol_table != nullptr
                ? symbol_table->lookupNearestSymbolFrom<func::FuncOp>(

FailureOr<StringAttr> RenameStablehloFunctions(
    MLIRContext *context, SymbolTableCollection &symbol_tables,
    ModuleOp tf_module, ModuleOp stablehlo_module) {
  SymbolTable &tf_symbol_table = symbol_tables.getSymbolTable(tf_module);
  // `stablehlo_module` is deleted right after the deserialization, so no need
  // to store its `SymbolTable` to `SymbolTableCollection`.
  SymbolTable stablehlo_symbol_table(stablehlo_module);

  Builder builder(context);

  ModuleOp module = getOperation();
  SymbolTable symbol_table(module);
  OpBuilder builder(module.getContext());
  module.walk([&](tf_device::ClusterOp cluster) {
    OutlineCluster(cluster, &symbol_table, &builder);
  });
}

void LaunchOutliningPass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTable symbol_table(module);
  OpBuilder builder(module.getContext());

    if (init_op == nullptr || init_op.getInitializers().empty()) {
      return;
    }

    SymbolTable symbol_table(module);
    for (auto initializer : init_op.getInitializers()) {
      auto func = symbol_table.lookup<func::FuncOp>(
          mlir::cast<FlatSymbolRefAttr>(initializer).getValue());
      RewriteFunction(symbol_table, func);
    }

    // Clean up unused asset ops.