[libcxx] r287250 - Implement P0504R0: Revisiting in-place tag types for any/optional/variant

[Eric Fiselier via cfe-commits]

Author: ericwf
Date: Thu Nov 17 13:24:04 2016
New Revision: 287250

URL: http://llvm.org/viewvc/llvm-project?rev=287250&view=rev
Log:
Implement P0504R0: Revisiting in-place tag types for any/optional/variant

Modified:
    libcxx/trunk/include/any
    libcxx/trunk/include/utility

Modified: libcxx/trunk/include/any
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/any?rev=287250&r1=287249&r2=287250&view=diff
==============================================================================
--- libcxx/trunk/include/any (original)
+++ libcxx/trunk/include/any Thu Nov 17 13:24:04 2016
@@ -200,7 +200,7 @@ public:
     , class _Tp = decay_t<_ValueType>
     , class = enable_if_t<
         !is_same<_Tp, any>::value &&
-        !__is_inplace_type_tag<_ValueType>::value &&
+        !__is_inplace_type<_ValueType>::value &&
         is_copy_constructible<_Tp>::value>
     >
   _LIBCPP_INLINE_VISIBILITY
@@ -561,13 +561,13 @@ void swap(any & __lhs, any & __rhs) _NOE
 template <class _Tp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 any make_any(_Args&&... __args) {
-    return any(in_place<_Tp>, _VSTD::forward<_Args>(__args)...);
+    return any(in_place_type<_Tp>, _VSTD::forward<_Args>(__args)...);
 }
 
 template <class _Tp, class _Up, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 any make_any(initializer_list<_Up> __il, _Args&&... __args) {
-    return any(in_place<_Tp>, __il, _VSTD::forward<_Args>(__args)...);
+    return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...);
 }
 
 template <class _ValueType>

Modified: libcxx/trunk/include/utility
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?rev=287250&r1=287249&r2=287250&view=diff
==============================================================================
--- libcxx/trunk/include/utility (original)
+++ libcxx/trunk/include/utility Thu Nov 17 13:24:04 2016
@@ -173,17 +173,22 @@ template<class T, class U=T>
     T exchange(T& obj, U&& new_value);
 
 // 20.2.7, in-place construction // C++17
-struct in_place_tag { in_place_tag() = delete; }; // C++17
-using in_place_t = in_place_tag(&)(unspecified );
+struct in_place_t {
+  explicit in_place_t() = default;
+};
+inline constexpr in_place_t in_place{};
 template <class T>
-    using in_place_type_t = in_place_tag(&)(unspecified <T>);
-template <size_t I>
-    using in_place_index_t = in_place_tag(&)(unspecified <I>);
-in_place_tag in_place(unspecified );
+  struct in_place_type_t {
+    explicit in_place_type_t() = default;
+  };
 template <class T>
-    in_place_tag in_place(unspecified <T>);
+  inline constexpr in_place_type_t<T> in_place_type{};
 template <size_t I>
-    in_place_tag in_place(unspecified <I>);
+  struct in_place_index_t {
+    explicit in_place_index_t() = default;
+  };
+template <size_t I>
+  inline constexpr in_place_index_t<I> in_place_index{};
 
 }  // std
 
@@ -889,59 +894,30 @@ _T1 exchange(_T1& __obj, _T2 && __new_va
 
 #if _LIBCPP_STD_VER > 14
 
-struct _LIBCPP_TYPE_VIS_ONLY __in_place_tag {};
-template <class> struct _LIBCPP_TYPE_VIS_ONLY __in_place_type_tag {};
-template <size_t> struct _LIBCPP_TYPE_VIS_ONLY __in_place_index_tag {};
-
-struct _LIBCPP_TYPE_VIS_ONLY in_place_tag;
+struct _LIBCPP_TYPE_VIS in_place_t {
+    explicit in_place_t() = default;
+};
+inline constexpr in_place_t in_place{};
 
-using in_place_t = in_place_tag(&)(__in_place_tag);
 template <class _Tp>
-using in_place_type_t = in_place_tag(&)(__in_place_type_tag<_Tp>);
-template <size_t _Nx>
-using in_place_index_t = in_place_tag(&)(__in_place_index_tag<_Nx>);
-
-struct in_place_tag {
-  in_place_tag() = delete;
-private:
-  explicit in_place_tag(__in_place_tag) {}
-
-  friend inline in_place_tag in_place(__in_place_tag __t);
-  template <class _Tp>
-  friend inline in_place_tag in_place(__in_place_type_tag<_Tp>);
-  template <size_t _Nx>
-  friend inline in_place_tag in_place(__in_place_index_tag<_Nx>);
+struct _LIBCPP_TYPE_VIS in_place_type_t {
+    explicit in_place_type_t() = default;
 };
-
-inline in_place_tag in_place(__in_place_tag __t) {
-    _LIBCPP_ASSERT(false, "The in_place function cannot be invoked");
-    return in_place_tag(__t);
-}
 template <class _Tp>
-inline in_place_tag in_place(__in_place_type_tag<_Tp>) {
-    _LIBCPP_ASSERT(false, "The in_place function cannot be invoked");
-    return in_place_tag(__in_place_tag{});
-}
-template <size_t _Nx>
-inline in_place_tag in_place(__in_place_index_tag<_Nx>) {
-    _LIBCPP_ASSERT(false, "The in_place function cannot be invoked");
-    return in_place_tag(__in_place_tag{});
-}
-
-template <class _Tp>   struct __is_inplace_tag_imp : false_type {};
-template <>            struct __is_inplace_tag_imp<in_place_tag(__in_place_tag)> : true_type {};
-template <class _Tp>   struct __is_inplace_tag_imp<in_place_tag(__in_place_type_tag<_Tp>)> : true_type {};
-template <size_t _Idx> struct __is_inplace_tag_imp<in_place_tag(__in_place_index_tag<_Idx>)> : true_type {};
+inline constexpr in_place_type_t<_Tp> in_place_type{};
 
-template <class _Tp>
-using __is_inplace_tag = __is_inplace_tag_imp<remove_pointer_t<decay_t<_Tp>>>;
+template <size_t _Idx>
+struct _LIBCPP_TYPE_VIS in_place_index_t {
+    explicit in_place_index_t() = default;
+};
+template <size_t _Idx>
+inline constexpr in_place_index_t<_Idx> in_place_index{};
 
-template <class _Tp> struct __is_inplace_type_tag_imp : false_type {};
-template <class _Tp> struct __is_inplace_type_tag_imp<in_place_tag(__in_place_type_tag<_Tp>)> : true_type {};
+template <class _Tp> struct __is_inplace_type_imp : false_type {};
+template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
 
 template <class _Tp>
-using __is_inplace_type_tag = __is_inplace_type_tag_imp<remove_pointer_t<decay_t<_Tp>>>;
-
+using __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>;
 
 #endif // _LIBCPP_STD_VER > 14