remove deprecated std::aligned_storage & std::aligned_union

include/rapidcheck/Gen.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cassert>
+#include <exception>
 
 #include "rapidcheck/detail/Any.h"
 #include "rapidcheck/detail/ImplicitParam.h"

include/rapidcheck/Maybe.h

@@ -81,8 +81,7 @@ class Maybe {
   ~Maybe();
 
 private:
-  using Storage = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
-  Storage m_storage;
+  alignas(T) uint8_t m_storage[sizeof(T)];
   bool m_initialized;
 };
 

include/rapidcheck/Maybe.hpp

@@ -52,7 +52,7 @@ template <typename T>
 template <typename... Args>
 void Maybe<T>::init(Args &&... args) {
   reset();
-  new (&m_storage) T(std::forward<Args>(args)...);
+  new (m_storage) T(std::forward<Args>(args)...);
   m_initialized = true;
 }
 
@@ -66,27 +66,27 @@ void Maybe<T>::reset() {
 
 template <typename T>
 T &Maybe<T>::operator*() & {
-  return *reinterpret_cast<T *>(&m_storage);
+  return *reinterpret_cast<T *>(m_storage);
 }
 
 template <typename T>
 const T &Maybe<T>::operator*() const & {
-  return *reinterpret_cast<const T *>(&m_storage);
+  return *reinterpret_cast<const T *>(m_storage);
 }
 
 template <typename T>
 T &&Maybe<T>::operator*() && {
-  return std::move(*reinterpret_cast<T *>(&m_storage));
+  return std::move(*reinterpret_cast<T *>(m_storage));
 }
 
 template <typename T>
 T *Maybe<T>::operator->() {
-  return reinterpret_cast<T *>(&m_storage);
+  return reinterpret_cast<T *>(m_storage);
 }
 
 template <typename T>
 const T *Maybe<T>::operator->() const {
-  return reinterpret_cast<const T *>(&m_storage);
+  return reinterpret_cast<const T *>(m_storage);
 }
 
 template <typename T>

include/rapidcheck/detail/AlignedUnion.h

@@ -15,11 +15,5 @@ struct MaxOf<V1, V2, Vs...>
           std::size_t,
           (V1 > MaxOf<V2, Vs...>::value ? V1 : MaxOf<V2, Vs...>::value)> {};
 
-/// Replacement for std::aligned_union for compiles that do not have it.
-template <typename... Ts>
-using AlignedUnion =
-    typename std::aligned_storage<MaxOf<sizeof(Ts)...>::value,
-                                  MaxOf<alignof(Ts)...>::value>::type;
-
 } // namespace detail
 } // namespace rc

include/rapidcheck/detail/Traits.h

@@ -9,12 +9,12 @@ namespace detail {
 #define RC_SFINAE_TRAIT(Name, expression)                                      \
   struct Name##Impl {                                                          \
     template <typename T, typename = expression>                               \
-    static std::true_type test(const T &);                                     \
+    static std::true_type test(const T *);                                     \
     static std::false_type test(...);                                          \
   };                                                                           \
                                                                                \
   template <typename T>                                                        \
-  using Name = decltype(Name##Impl::test(std::declval<T>()));
+  using Name = decltype(Name##Impl::test(static_cast<T *>(nullptr)));
 
 RC_SFINAE_TRAIT(IsStreamInsertible, decltype(std::cout << std::declval<T>()))
 

include/rapidcheck/detail/Variant.h

@@ -90,8 +90,8 @@ class Variant {
   static constexpr bool isValidType();
 
   std::size_t m_typeIndex;
-  using Storage = AlignedUnion<Type, Types...>;
-  Storage m_storage;
+  alignas(MaxOf<alignof(Type), alignof(Types)...>::value)
+      uint8_t m_storage[MaxOf<sizeof(Type), sizeof(Types)...>::value];
 };
 
 template <typename Type, typename... Types>

include/rapidcheck/detail/Variant.hpp

@@ -32,7 +32,7 @@ Variant<Type, Types...>::Variant(T &&value) noexcept(
   static_assert(isValidType<Decay<T>>(),
                 "T is not a valid type of this variant");
 
-  new (&m_storage) Decay<T>(std::forward<T>(value));
+  new (m_storage) Decay<T>(std::forward<T>(value));
 }
 
 template <typename Type, typename... Types>
@@ -43,11 +43,11 @@ operator=(const T &value) noexcept {
 
   const auto newIndex = indexOfType<T>();
   if (newIndex == m_typeIndex) {
-    *reinterpret_cast<T *>(&m_storage) = value;
+    *reinterpret_cast<T *>(m_storage) = value;
   } else {
-    destroy(m_typeIndex, &m_storage);
+    destroy(m_typeIndex, m_storage);
     m_typeIndex = newIndex;
-    new (&m_storage) T(value);
+    new (m_storage) T(value);
   }
   return *this;
 }
@@ -60,11 +60,11 @@ operator=(T &&value) noexcept {
 
   const auto newIndex = indexOfType<T>();
   if (newIndex == m_typeIndex) {
-    *reinterpret_cast<T *>(&m_storage) = std::move(value);
+    *reinterpret_cast<T *>(m_storage) = std::move(value);
   } else {
-    destroy(m_typeIndex, &m_storage);
+    destroy(m_typeIndex, m_storage);
     m_typeIndex = newIndex;
-    new (&m_storage) T(std::move(value));
+    new (m_storage) T(std::move(value));
   }
   return *this;
 }
@@ -73,14 +73,14 @@ template <typename Type, typename... Types>
 template <typename T>
 T &Variant<Type, Types...>::get() & {
   assert(indexOfType<T>() == m_typeIndex);
-  return *reinterpret_cast<T *>(&m_storage);
+  return *reinterpret_cast<T *>(m_storage);
 }
 
 template <typename Type, typename... Types>
 template <typename T>
 const T &Variant<Type, Types...>::get() const & {
   assert(indexOfType<T>() == m_typeIndex);
-  return *reinterpret_cast<const T *>(&m_storage);
+  return *reinterpret_cast<const T *>(m_storage);
 }
 
 template <typename Type, typename... Types>
@@ -97,7 +97,7 @@ bool Variant<Type, Types...>::match(T &value) const {
     return false;
   }
 
-  value = *reinterpret_cast<const T *>(&m_storage);
+  value = *reinterpret_cast<const T *>(m_storage);
   return true;
 }
 
@@ -123,7 +123,7 @@ bool Variant<Type, Types...>::operator==(const Variant &rhs) const {
   static bool (*const equalsFuncs[])(const void *, const void *) = {
       &variantEqualsImpl<Type>, &variantEqualsImpl<Types>...};
 
-  return equalsFuncs[m_typeIndex](&m_storage, &rhs.m_storage);
+  return equalsFuncs[m_typeIndex](m_storage, rhs.m_storage);
 }
 
 template <typename T>
@@ -136,21 +136,21 @@ void Variant<Type, Types...>::printTo(std::ostream &os) const {
   static void (*printToFuncs[])(std::ostream &, const void *) = {
       &variantPrintToImpl<Type>, &variantPrintToImpl<Types>...};
 
-  printToFuncs[m_typeIndex](os, &m_storage);
+  printToFuncs[m_typeIndex](os, m_storage);
 }
 
 template <typename Type, typename... Types>
 Variant<Type, Types...>::Variant(const Variant &other) noexcept(
     AllIs<std::is_nothrow_copy_constructible, Type, Types...>::value)
     : m_typeIndex(other.m_typeIndex) {
-  copy(m_typeIndex, &m_storage, &other.m_storage);
+  copy(m_typeIndex, m_storage, other.m_storage);
 }
 
 template <typename Type, typename... Types>
 Variant<Type, Types...>::Variant(Variant &&other) noexcept(
     AllIs<std::is_nothrow_move_constructible, Type, Types...>::value)
     : m_typeIndex(other.m_typeIndex) {
-  move(m_typeIndex, &m_storage, &other.m_storage);
+  move(m_typeIndex, m_storage, other.m_storage);
 }
 
 template <typename Type, typename... Types>
@@ -163,12 +163,12 @@ operator=(const Variant &rhs) noexcept(
       "AllIs types must be nothrow move-constructible to use copy assignment");
 
   if (m_typeIndex == rhs.m_typeIndex) {
-    copyAssign(m_typeIndex, &m_storage, &rhs.m_storage);
+    copyAssign(m_typeIndex, m_storage, rhs.m_storage);
   } else {
-    Storage tmp;
-    copy(rhs.m_typeIndex, &tmp, &rhs.m_storage);
-    destroy(m_typeIndex, &m_storage);
-    move(rhs.m_typeIndex, &m_storage, &tmp);
+    decltype(m_storage) tmp;
+    copy(rhs.m_typeIndex, tmp, rhs.m_storage);
+    destroy(m_typeIndex, m_storage);
+    move(rhs.m_typeIndex, m_storage, tmp);
     m_typeIndex = rhs.m_typeIndex;
   }
 
@@ -184,19 +184,19 @@ operator=(Variant &&rhs) noexcept(
       "AllIs types must be nothrow move-constructible to use copy assignment");
 
   if (m_typeIndex == rhs.m_typeIndex) {
-    moveAssign(m_typeIndex, &m_storage, &rhs.m_storage);
+    moveAssign(m_typeIndex, m_storage, rhs.m_storage);
   } else {
-    destroy(m_typeIndex, &m_storage);
+    destroy(m_typeIndex, m_storage);
     m_typeIndex = rhs.m_typeIndex;
-    move(m_typeIndex, &m_storage, &rhs.m_storage);
+    move(m_typeIndex, m_storage, rhs.m_storage);
   }
 
   return *this;
 }
 
 template <typename Type, typename... Types>
 Variant<Type, Types...>::~Variant() noexcept {
-  destroy(m_typeIndex, &m_storage);
+  destroy(m_typeIndex, m_storage);
 }
 
 template <typename T>

test/detail/MulticastTestListenerTests.cpp

@@ -75,7 +75,7 @@ TEST_CASE("MulticastTestListener") {
     prop("passes on correct arguments",
          [](const TestMetadata &metadata, const TestResult &result) {
            MockTestListener mock;
-           mock.onTestFinishedCallback = [=](const TestMetadata &meta,
+           mock.onTestFinishedCallback = [&](const TestMetadata &meta,
                                              const TestResult &res) {
              RC_ASSERT(meta == metadata);
              RC_ASSERT(res == result);