Bug#33302907 remove C++11 support from stdx/type_traits.h

Issue
=====

mysql/harness/stdx/*.h contain several types and templates that look
like their C++17 equivalents:

- stdx::conjunction, stdx::disjunction, stdx::negation
- stdx::void_t
- stdx::in_place_t and stdx::in_place

Change
======

- remove SUNPRO_CC specific defines from stdx::expected
- replaced stdx::conjunction with std::conjunction
- replaced stdx::disjunction with std::disjunction
- replaced stdx::negation with std::negation
- replaced stdx::in_place_t with std::in_place_t
- replaced stdx::void_t with std::void_t
- removed stdx::in_place_t
- removed stdx::void_t

RB: 26937

Author: weigon

router/src/harness/include/mysql/harness/net_ts/buffer.h

@@ -198,7 +198,7 @@ template <class T, class BufferType,
               std::declval<typename std::add_lvalue_reference<T>::type>()))>
 using buffer_sequence_requirements = std::integral_constant<
     bool,
-    stdx::conjunction<
+    std::conjunction<
         // check if buffer_sequence_begin(T &) and buffer_sequence_end(T &)
         // exist and return the same type
         std::is_same<Begin, End>,
@@ -212,7 +212,7 @@ struct is_buffer_sequence : std::false_type {};
 
 template <class T, class BufferType>
 struct is_buffer_sequence<
-    T, BufferType, stdx::void_t<buffer_sequence_requirements<T, BufferType>>>
+    T, BufferType, std::void_t<buffer_sequence_requirements<T, BufferType>>>
     : std::true_type {};
 
 template <class T>
@@ -246,7 +246,7 @@ struct is_dynamic_buffer : std::false_type {};
 template <class T, class U = std::remove_const_t<T>>
 auto dynamic_buffer_requirements(U *__x = nullptr, const U *__const_x = nullptr,
                                  size_t __n = 0)
-    -> std::enable_if_t<stdx::conjunction<
+    -> std::enable_if_t<std::conjunction<
         // is copy constructible
         std::is_copy_constructible<U>,
         // has a const_buffers_type that's a const_buffer_sequence

router/src/harness/include/mysql/harness/net_ts/executor.h

@@ -39,7 +39,6 @@
 
 #include "my_compiler.h"
 #include "mysql/harness/net_ts/netfwd.h"
-#include "mysql/harness/stdx/type_traits.h"  // conjunction, void_t
 
 namespace net {
 enum class fork_event { prepare, parent, child };
@@ -102,7 +101,7 @@ using associated_allocator_t =
 
 MY_COMPILER_DIAGNOSTIC_POP()
 
-template <class T, class ProtoAllocator, typename = stdx::void_t<>>
+template <class T, class ProtoAllocator, typename = std::void_t<>>
 struct associated_allocator_impl {
   using type = ProtoAllocator;
 
@@ -113,7 +112,7 @@ struct associated_allocator_impl {
 
 template <class T, class ProtoAllocator>
 struct associated_allocator_impl<T, ProtoAllocator,
-                                 stdx::void_t<typename T::allocator_type>> {
+                                 std::void_t<typename T::allocator_type>> {
   using type = typename T::allocator_type;
 
   static type __get(const T &t, const ProtoAllocator & /* a */) noexcept {
@@ -324,7 +323,7 @@ class execution_context::service {
 //
 namespace impl {
 
-template <class T, class = stdx::void_t<>>
+template <class T, class = std::void_t<>>
 struct is_executor : std::false_type {};
 
 // checker for the requirements of a executor
@@ -347,7 +346,7 @@ auto executor_requirements(U *__x = nullptr, const U *__const_x = nullptr,
                            void (*f)() = nullptr,
                            const std::allocator<int> &a = {})
     -> std::enable_if_t<
-        stdx::conjunction<
+        std::conjunction<
             std::is_copy_constructible<T>,
             // methods/operators must exist
             std::is_same<decltype(*__const_x == *__const_x), bool>,
@@ -359,7 +358,7 @@ auto executor_requirements(U *__x = nullptr, const U *__const_x = nullptr,
             std::is_void<decltype(__x->defer(std::move(f), a))>>::value,
 
         // context() may either return execution_context & or E&
-        stdx::void_t<decltype(__x->context()), void()>>;
+        std::void_t<decltype(__x->context()), void()>>;
 
 template <class T>
 struct is_executor<T, decltype(executor_requirements<T>())> : std::true_type {};
@@ -380,11 +379,11 @@ constexpr executor_arg_t executor_arg = executor_arg_t();
 
 namespace impl {
 
-template <class T, class Executor, typename = stdx::void_t<>>
+template <class T, class Executor, typename = std::void_t<>>
 struct uses_executor : std::false_type {};
 
 template <class T, class Executor>
-struct uses_executor<T, Executor, stdx::void_t<typename T::executor_type>>
+struct uses_executor<T, Executor, std::void_t<typename T::executor_type>>
     : std::is_convertible<Executor, typename T::executor_type> {};
 
 }  // namespace impl
@@ -396,7 +395,7 @@ template <class T, class Executor>
 constexpr bool uses_executor_v = uses_executor<T, Executor>::value;
 
 // 13.12 [async.assoc.exec]
-template <class T, class Executor, typename = stdx::void_t<>>
+template <class T, class Executor, typename = std::void_t<>>
 struct associated_executor_impl {
   using type = Executor;
 
@@ -407,7 +406,7 @@ struct associated_executor_impl {
 
 template <class T, class Executor>
 struct associated_executor_impl<T, Executor,
-                                stdx::void_t<typename T::executor_type>> {
+                                std::void_t<typename T::executor_type>> {
   using type = typename T::executor_type;
 
   static type __get(const T &t, const Executor & /* a */) noexcept {

router/src/harness/include/mysql/harness/net_ts/impl/resolver.h

@@ -41,7 +41,6 @@
 
 #include "mysql/harness/net_ts/impl/socket_error.h"  // socket::last_error_code
 #include "mysql/harness/stdx/expected.h"
-#include "mysql/harness/stdx/type_traits.h"  // stdx::in_place
 
 namespace net {
 namespace ip {
@@ -262,7 +261,7 @@ getaddrinfo(const char *node, const char *service,
 #endif
   }
 
-  return {stdx::in_place, ainfo, &::freeaddrinfo};
+  return {std::in_place, ainfo, &::freeaddrinfo};
 }
 
 inline stdx::expected<const char *, std::error_code> inetntop(int af,

router/src/harness/include/mysql/harness/net_ts/internet.h

@@ -412,7 +412,7 @@ inline stdx::expected<address_v6, std::error_code> make_address_v6(
     inet_pton_res = ::inet_pton(AF_INET6, str, &ipv6_addr);
   }
   if (inet_pton_res == 1) {
-    return {stdx::in_place_t(), ipv6_addr, scope_id};
+    return {std::in_place, ipv6_addr, scope_id};
   } else if (inet_pton_res == 0) {
     // parse failed
     return stdx::make_unexpected(make_error_code(std::errc::invalid_argument));

router/src/harness/include/mysql/harness/net_ts/socket.h

@@ -550,7 +550,7 @@ class basic_socket_impl : public basic_socket_impl_base {
                                                  endpoint_size);
     if (!res) return stdx::make_unexpected(res.error());
 
-    return {stdx::in_place, io_ctx, protocol_, std::move(res.value())};
+    return {std::in_place, io_ctx, protocol_, std::move(res.value())};
   }
 
   stdx::expected<socket_type, error_type> accept(io_context &io_ctx,

router/src/harness/include/mysql/harness/net_ts/win32_named_pipe.h

@@ -598,14 +598,14 @@ class basic_named_pipe_acceptor : public basic_named_pipe_impl<Protocol> {
       // ERROR_NO_DATA too, it just meands the pipe is already closed, but quite
       // likely readable.
       if (last_ec == ec_pipe_connected || last_ec == ec_no_data) {
-        return {stdx::in_place, get_executor().context(), protocol,
+        return {std::in_place, get_executor().context(), protocol,
                 release().value()};
       }
 
       return stdx::make_unexpected(last_ec);
     }
 
-    return {stdx::in_place, get_executor().context(), protocol,
+    return {std::in_place, get_executor().context(), protocol,
             release().value()};
   }
 

router/src/harness/include/mysql/harness/stdx/expected.h

@@ -32,8 +32,7 @@
 #include <new>      // ::operator new
 #include <utility>  // std::forward
 
-#include "mysql/harness/stdx/type_traits.h"
-#if defined(__GNUC__) || defined(__clang__) || defined(__SUNPRO_CC)
+#if defined(__GNUC__) || defined(__clang__)
 #define RESO_ASSUME(x) \
   if (!(x)) __builtin_unreachable();
 #elif defined(_MSC_VER)
@@ -133,7 +132,7 @@ union storage_t {
   template <class... Args,
             typename std::enable_if_t<
                 std::is_constructible<T, Args &&...>::value, void *> = nullptr>
-  void construct_value(in_place_t, Args &&... args) {
+  void construct_value(std::in_place_t, Args &&... args) {
     new (&value_) value_type(std::forward<Args>(args)...);
   }
 
@@ -147,7 +146,7 @@ union storage_t {
   // enable inplace construction of error, if the E supports it
   template <class... Args, typename std::enable_if_t<std::is_constructible<
                                E, Args &&...>::value> * = nullptr>
-  void construct_error(in_place_t, Args &&... args) {
+  void construct_error(std::in_place_t, Args &&... args) {
     new (&error_) error_type(std::forward<Args>(args)...);
   }
 
@@ -201,7 +200,7 @@ union storage_t<T, void> {
   template <class... Args,
             typename std::enable_if_t<
                 std::is_constructible<T, Args &&...>::value, void *> = nullptr>
-  void construct_value(in_place_t, Args &&... args) {
+  void construct_value(std::in_place_t, Args &&... args) {
     new (&value_) value_type(std::forward<Args>(args)...);
   }
 
@@ -243,7 +242,7 @@ union storage_t<void, E> {
   template <
       class... Args,
       std::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-  void construct_error(in_place_t, Args &&... args) {
+  void construct_error(std::in_place_t, Args &&... args) {
     new (&error_) error_type(std::forward<Args>(args)...);
   }
 
@@ -392,13 +391,13 @@ struct assign_base<member_policy::copy | member_policy::move> {
 };
 
 template <class B>
-using not_ = stdx::negation<B>;
+using not_ = std::negation<B>;
 
 template <class... B>
-using and_ = stdx::conjunction<B...>;
+using and_ = std::conjunction<B...>;
 
 template <class... B>
-using or_ = stdx::disjunction<B...>;
+using or_ = std::disjunction<B...>;
 
 // enable copy constructor if T and E are copy-constructible or void
 // enable move constructor if T and E are move-constructible or void
@@ -472,38 +471,11 @@ class ExpectedImpl : public ExpectedImplBase {
   }
 
   // enable inplace construction of value_type, if the T supports it
-  template <
-      class... Args
-#if !defined(__SUNPRO_CC)
-      // disabled the 'is_constructible' check as it triggers:
-      //
-      //  >> Assertion:   (../lnk/substitute.cc, line 1131)
-      //	      while processing ./test_expected.cc at line 4.
-      //
-      // with devstudio-12.6's CC
-      //
-      // That means:
-      //
-      // stdx::expected<std::string, void> res(stdx::in_place, 1.0); will report
-      // the error for:
-      //
-      //   Could not find a match for stdx::base::storage_t<std::string,
-      //   double>::construct_value(const stdx::in_place_t, double)
-      //
-      // Instead for
-      //
-      //   Could not find a match for stdx::base::ExpectedImpl<std::string,
-      //   double>::ExpectedImpl(const stdx::in_place_t, double)
-      //
-      // as the same check is done in construct_value() and does not trigger
-      // the assertion.
-      ,
-      typename std::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-          nullptr
-#endif
-      >
-  constexpr ExpectedImpl(in_place_t, Args &&... args) : ExpectedImplBase{true} {
-    storage_.construct_value(stdx::in_place, std::forward<Args>(args)...);
+  template <class... Args, typename std::enable_if_t<std::is_constructible<
+                               T, Args &&...>::value> * = nullptr>
+  constexpr ExpectedImpl(std::in_place_t, Args &&... args)
+      : ExpectedImplBase{true} {
+    storage_.construct_value(std::in_place, std::forward<Args>(args)...);
   }
 
   constexpr ExpectedImpl(const ExpectedImpl &other)
@@ -798,17 +770,11 @@ class ExpectedImpl<T, void> : public ExpectedImplBase {
   }
 
   // enable inplace construction of value_type, if the T supports it
-  template <class... Args
-#if !defined(__SUNPRO_CC)
-            // see the generic ExpectedImpl(in_place_t, ...) why this check is
-            // disabled.
-            ,
-            typename std::enable_if_t<
-                std::is_constructible<T, Args &&...>::value> * = nullptr
-#endif
-            >
-  constexpr ExpectedImpl(in_place_t, Args &&... args) : ExpectedImplBase{true} {
-    storage_.construct_value(stdx::in_place, std::forward<Args>(args)...);
+  template <class... Args, typename std::enable_if_t<std::is_constructible<
+                               T, Args &&...>::value> * = nullptr>
+  constexpr ExpectedImpl(std::in_place_t, Args &&... args)
+      : ExpectedImplBase{true} {
+    storage_.construct_value(std::in_place, std::forward<Args>(args)...);
   }
 
   constexpr ExpectedImpl(const ExpectedImpl &other)
@@ -993,74 +959,12 @@ class expected : public ExpectedImpl<T, E>,
                  private base::select_ctor_base<T, E> {
  public:
   static_assert(!std::is_reference<T>::value, "T must not be a reference");
-  static_assert(!std::is_same<T, std::remove_cv<in_place_t>>::value,
-                "T must not be in_place_t");
+  static_assert(!std::is_same<T, std::remove_cv<std::in_place_t>>::value,
+                "T must not be std::in_place_t");
   static_assert(!std::is_same<T, std::remove_cv<unexpected<E>>>::value,
                 "T must not be unexpected<E>");
   static_assert(!std::is_reference<E>::value, "E must not be a reference");
 
-#if defined(__SUNPRO_CC)
-  // sunpro generates a wrong default assign-move which forces use
-  // to declare all the implicit constructors/assign-ops explicitly
-  // as default which leads to slightly worse error-messages:
-  //
-  // clang:
-  //
-  //  call to implicitly-deleted default constructor of
-  //  'stdx::expected<no_default_construct, void>'
-  //
-  //  note: default constructor of
-  //  'expected<no_default_construct, void>' is implicitly deleted
-  //    because base class 'ExpectedImpl<no_default_construct, void>' has no
-  //    default constructor
-  //
-  // vs.
-  //
-  //  call to implicitly-deleted default constructor of
-  //  'stdx::expected<no_default_construct, void>'
-  //
-  //  explicitly defaulted function was implicitly deleted here
-  //  expected() = default;
-  //
-  //  note: default constructor of
-  //  'expected<no_default_construct, void>' is implicitly deleted
-  //    because base class 'ExpectedImpl<no_default_construct, void>' has no
-  //    default constructor
-  //
-  expected() = default;
-
-  expected(const expected &) = default;
-  expected &operator=(const expected &) = default;
-
-  // sunpro generates the default move-assign, move-construct which:
-  //
-  // 1. ExpectedImpl<T, E>::operator=(std::move(other))
-  // 2. memmove(this, &other, sizeof(other));
-  //
-  // where the memmove trashes the just moved value
-
-#if 0
-  // this constructor should be only visible if T and E and move-constructible
-  // but with sunpro it leads to
-  //
-  //    CC: Fatal error in .../developerstudio12.6/lib/compilers/bin/ccfe : Signal number = 139
-  //
-  // Therefore, it is left unconditionally enabled which makes this type
-  // look move-constructible even though it may not be.
-  template <
-      bool B = std::is_move_constructible<base::select_ctor_base<T, E>>::value,
-      std::enable_if_t<B> * = nullptr>
-#endif
-  expected(expected &&other) : ExpectedImpl<T, E>{std::move(other)} {}
-
-  template <bool B = std::is_move_assignable<T>::value,
-            std::enable_if_t<B> * = nullptr>
-  expected &operator=(expected &&other) {
-    ExpectedImpl<T, E>::operator=(std::move(other));
-    return *this;
-  }
-#endif
-
   // inherit all the constructors of our base
   using ExpectedImpl<T, E>::ExpectedImpl;
 };

router/src/harness/include/mysql/harness/stdx/expected_ostream.h

@@ -30,8 +30,6 @@
 #include <ostream>
 #include <type_traits>
 
-#include "mysql/harness/stdx/type_traits.h"
-
 // operator<< for std::expected
 //
 // the functions are kept in a separate header as it
@@ -46,7 +44,7 @@ struct is_to_stream_writable : std::false_type {};
 
 template <typename S, typename T>
 struct is_to_stream_writable<
-    S, T, stdx::void_t<decltype(std::declval<S &>() << std::declval<T>())>>
+    S, T, std::void_t<decltype(std::declval<S &>() << std::declval<T>())>>
     : std::true_type {};
 
 }  // namespace impl