Revert "src: modernize cleanup queue to use c++20"

This reverts commit 581b444.

PR-URL: #56846
Refs: #56063
Reviewed-By: Luigi Pinca <[email protected]>
Reviewed-By: Colin Ihrig <[email protected]>
Reviewed-By: Michaël Zasso <[email protected]>
Reviewed-By: Yagiz Nizipli <[email protected]>
Reviewed-By: James M Snell <[email protected]>

Author: richardlau

src/cleanup_queue-inl.h

@@ -3,8 +3,6 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include <compare>
-
 #include "cleanup_queue.h"
 #include "util.h"
 
@@ -31,18 +29,6 @@ void CleanupQueue::Remove(Callback cb, void* arg) {
   cleanup_hooks_.erase(search);
 }
 
-constexpr std::strong_ordering CleanupQueue::CleanupHookCallback::operator<=>(
-    const CleanupHookCallback& other) const noexcept {
-  if (insertion_order_counter_ > other.insertion_order_counter_) {
-    return std::strong_ordering::greater;
-  }
-
-  if (insertion_order_counter_ < other.insertion_order_counter_) {
-    return std::strong_ordering::less;
-  }
-  return std::strong_ordering::equivalent;
-}
-
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

src/cleanup_queue.cc

@@ -1,6 +1,5 @@
 #include "cleanup_queue.h"  // NOLINT(build/include_inline)
 #include <algorithm>
-#include <ranges>
 #include <vector>
 #include "cleanup_queue-inl.h"
 
@@ -9,20 +8,27 @@ namespace node {
 std::vector<CleanupQueue::CleanupHookCallback> CleanupQueue::GetOrdered()
     const {
   // Copy into a vector, since we can't sort an unordered_set in-place.
-  std::vector callbacks(cleanup_hooks_.begin(), cleanup_hooks_.end());
+  std::vector<CleanupHookCallback> callbacks(cleanup_hooks_.begin(),
+                                             cleanup_hooks_.end());
   // We can't erase the copied elements from `cleanup_hooks_` yet, because we
   // need to be able to check whether they were un-scheduled by another hook.
 
-  // Sort in descending order so that the most recently inserted callbacks are
-  // run first.
-  std::ranges::sort(callbacks, std::greater());
+  std::sort(callbacks.begin(),
+            callbacks.end(),
+            [](const CleanupHookCallback& a, const CleanupHookCallback& b) {
+              // Sort in descending order so that the most recently inserted
+              // callbacks are run first.
+              return a.insertion_order_counter_ > b.insertion_order_counter_;
+            });
 
   return callbacks;
 }
 
 void CleanupQueue::Drain() {
-  for (const CleanupHookCallback& cb : GetOrdered()) {
-    if (!cleanup_hooks_.contains(cb)) {
+  std::vector<CleanupHookCallback> callbacks = GetOrdered();
+
+  for (const CleanupHookCallback& cb : callbacks) {
+    if (cleanup_hooks_.count(cb) == 0) {
       // This hook was removed from the `cleanup_hooks_` set during another
       // hook that was run earlier. Nothing to do here.
       continue;

src/cleanup_queue.h

@@ -3,7 +3,6 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <unordered_set>
@@ -42,9 +41,6 @@ class CleanupQueue : public MemoryRetainer {
           arg_(arg),
           insertion_order_counter_(insertion_order_counter) {}
 
-    constexpr std::strong_ordering operator<=>(
-        const CleanupHookCallback& other) const noexcept;
-
     // Only hashes `arg_`, since that is usually enough to identify the hook.
     struct Hash {
       size_t operator()(const CleanupHookCallback& cb) const;