[libcxx] [test] In test/support/test_allocator.h, fix construct() to avoid moving immovable types.

[STL_MSFT]

Summary

In test/support/test_allocator.h, fix construct() to avoid moving immovable types.

This improves the allocator's conformance, and fixes compiler errors with MSVC's STL. The scenario is when the allocator is asked to construct an object of type X that's immovable (deleted copy/move ctors), but implicitly constructible from an argument type A. When perfectly forwarded, X can be (explicitly) constructed from A, and everything is fine. That's std::allocator's behavior, and the Standard's default when a user allocator's construct() doesn't exist. The previous implementation of construct() here mishandled this scenario. Passing A to this construct() would implicitly construct an X temporary, bound to (non-templated) T&&. Then construct() would attempt to move-construct X from that X temporary, but X is immovable, boom.

[EricWF]

test/support/test_allocator.h

83

#if TEST_STD_VER < 11

88

While your here this should have be ::new ((void*)p).

I learned that from you :-P

144

#if TEST_STD_VER < 11 please.

149

While your here this should have be ::new ((void*)p).

[STL_MSFT]

Inspect TEST_STD_VER and cast to void* as requested. I used a static_cast to avoid triggering any old-style cast warnings.

(I also just noticed that I deleted an empty line, but was too lazy to regenerate the diff. Oops.)

test/support/test_allocator.h

#endif
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new(n * sizeof(T));
         }
     void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p);}
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
+#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void construct(pointer p, const T& val)
         {::new(p) T(val);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void construct(pointer p, T&& val)
-        {::new(p) T(std::move(val));}
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    template <class U> void construct(pointer p, U&& val)
+        {::new(p) T(std::forward<U>(val));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void destroy(pointer p) {p->~T();}
 
     friend bool operator==(const test_allocator& x, const test_allocator& y)
         {return x.data_ == y.data_;}
     friend bool operator!=(const test_allocator& x, const test_allocator& y)
         {return !(x == y);}
 };
#endif
             ++time_to_throw;
             ++alloc_count;
             return (pointer)::operator new (n * sizeof(T));
         }
     void deallocate(pointer p, size_type)
         {assert(data_ >= 0); --alloc_count; ::operator delete((void*)p); }
     size_type max_size() const throw()
         {return UINT_MAX / sizeof(T);}
+#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void construct(pointer p, const T& val)
         {::new(p) T(val);}
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void construct(pointer p, T&& val)
-        {::new(p) T(std::move(val));}
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    template <class U> void construct(pointer p, U&& val)
+        {::new(p) T(std::forward<U>(val));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void destroy(pointer p) {p->~T();}
 
     friend bool operator==(const non_default_test_allocator& x, const non_default_test_allocator& y)
         {return x.data_ == y.data_;}
     friend bool operator!=(const non_default_test_allocator& x, const non_default_test_allocator& y)
         {return !(x == y);}
 };