`ThreadTest` doesn't work on Windows on the latest master (freezing or crash)

[KvanTTT]

Also, compiler reports the following warning, probably it's related: 'ThreadSafeContainer<int>::waitPush<int>': recursive on all control paths, function will cause runtime stack overflow.

It's probably caused by 24e13a0#diff-fa6b41a09e20679c20ce275225540c56ed6f606c59e7d54fe40ee958952298ce

I use standard Visual Studio compiler.

[KvanTTT]

Claude 3.5 Sonnet suggest the following fix that seems robust:

Index: cpp/core/threadsafequeue.h
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/cpp/core/threadsafequeue.h b/cpp/core/threadsafequeue.h
--- a/cpp/core/threadsafequeue.h	(revision a5cabbf492bdccae7aed483853456048a0653d1c)
+++ b/cpp/core/threadsafequeue.h	(date 1762534953069)
@@ -107,7 +107,8 @@
   inline std::enable_if_t<std::is_copy_constructible<U>::value, bool>
   waitPush(const T& elt)
   {
-    return waitPush(T(elt));
+    T copy(elt);
+    return waitPush(std::move(copy));
   }
 
   // Push an element without blocking, but can exceed maxSize of the queue.
@@ -127,7 +128,8 @@
   inline std::enable_if_t<std::is_copy_constructible<U>::value, bool>
   forcePush(const T& elt)
   {
-    return forcePush(T(elt));
+    T copy(elt);
+    return forcePush(std::move(copy));
   }
 
   // Attempt to pop an element into buf without blocking.

The explanation is the following:

The issue was in the templated overload of that takes a const reference. It was creating an infinite recursion because: waitPush

1. The const reference version calls waitPush(T(elt))
2. T(elt) creates a temporary, which is an rvalue
3. But since it's inside the function call, it gets treated as an lvalue
4. This causes the const reference overload to be called again
5. And the cycle repeats, causing stack overflow

The fix:

1. First creates a copy of the element explicitly
2. Then uses std::move to call the rvalue reference overload
3. This breaks the recursion by ensuring we call the rvalue reference version

This change ensures that:

• For rvalue arguments (temporaries), they'll go directly to the rvalue reference overload
• For lvalue arguments (const references), they'll be copied once and then moved, avoiding the recursion

The warning should now be resolved, and the queue will work correctly for both lvalue and rvalue arguments.