OpBuilder* builder) {
  builder->create<func::ReturnOp>(cluster_return_op.getLoc(),
                                  cluster_return_op.getOperands());
  cluster_return_op.erase();
}

// Builds a function that outlines region attached to cluster_op or launch_op,
// and inserts built function into given module.
template <typename ClusterOrLaunchOp>

        given:
        label.text = "long text"

        when:
        redraw()
        label.text = "text"
        redraw()

        then:
        1 * ansi.a("long text")
        1 * ansi.cursorLeft(9)
        1 * ansi.a("text")
        1 * ansi.eraseLine(Ansi.Erase.FORWARD)
        0 * ansi._
    }

  builder->create<tf_device::ReturnOp>(old_terminator->getLoc(),
                                       merged_execute_launch.getResults());
  old_terminator->erase();

  // Remove the original TPUExecute op.
  execute_launch.erase();

  // Move all regions from old parallel_execute to new parallel_execute.
  for (auto region : llvm::zip(new_parallel_execute_op->getRegions(),

        !cond.getArgument(i).use_empty()) {
      explicitly_consumed_ids.push_back(i);
    }
  }
  // Empty consumed_element_ids implies none of results is used.
  if (explicitly_consumed_ids.empty()) {
    while_op.erase();
    return true;
  }
  // If every element is consumed, one can't reduce any operand.
  if (explicitly_consumed_ids.size() == n) {
    return false;
  }

  // Build the dependency graph.

            checkForSingleBlocksOf(topLevelBlockIds, topLevelBlocks)

            checkForTopLevelBlockOrder(topLevelBlocks)

            val sourceWithoutComments =
                source.map { it.erase(comments) }

            val buildscriptFragment =
                topLevelBlocks
                    .singleSectionOf(TopLevelBlockId.buildscriptIdFor(target))
                    ?.let { sourceWithoutComments.fragment(it) }

    StringAttr op_device = op->getAttrOfType<StringAttr>(kDeviceAttr);
    if (should_fold_op_func(op.getOperand(), op_device)) {
      op.replaceAllUsesWith(op.getOperand());
      op.erase();
    }
    return WalkResult::advance();
  });

  func_op.walk([&should_fold_op_func](TF::IdentityNOp op) {
    StringAttr op_device = op->getAttrOfType<StringAttr>(kDeviceAttr);
    bool should_fold = llvm::all_of(

    tf_executor.graph {
      tf_executor.fetch
    }
    return
  }
}
// Save function should be erased.
// CHECK-NOT: @tf_quant__save

// Test that the contents of @tf_quant__save are copied to @main.
// CHECK: func.func @main

                                         StringPiece func_name);

  // Runs the decompose passes on the user_module.
  Status DecomposeGraph(mlir::ModuleOp user_module);

  // Erases the tfr_module created.
  void Destroy();

 private:
  mlir::ModuleOp tfr_module_;
  mlir::PassManager pm_;

  GraphExportConfig export_confs_;
};

    return std::get<TF::MlirLocalVarOp>(op).getResource();
  }
}

void LocalVarOp_erase(LocalVarOp &op) {
  if (auto var_handle_op = std::get_if<TF::VarHandleOp>(&op)) {
    var_handle_op->erase();
  } else {
    std::get<TF::MlirLocalVarOp>(op).erase();
  }
}

std::optional<LocalVarOp> IsLocalVarOp(Operation &op) {
  if (TF::MlirLocalVarOp mlir_local_var_op =
          llvm::dyn_cast<TF::MlirLocalVarOp>(&op)) {

    block.eraseArgument(argument_index_to_remove);
    argument_types.erase(argument_types.begin() + argument_index_to_remove);
  }

  // Rewrite return if there are variable writes.
  const int return_operands_size = return_operands.size();
  if (return_operands_size > num_results_before) {
    builder.create<func::ReturnOp>(return_op.getLoc(), return_operands);
    return_op.erase();
  }