From: Eric Fiselier <eric@efcs.ca>
Date: Thu, 17 Nov 2016 19:24:04 +0000 (+0000)
Subject: Implement P0504R0: Revisiting in-place tag types for any/optional/variant
X-Git-Tag: llvmorg-4.0.0-rc1~4280
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=034555f1a245010b2b9b088e7613e60c94352dfa;p=platform%2Fupstream%2Fllvm.git

Implement P0504R0: Revisiting in-place tag types for any/optional/variant

llvm-svn: 287250
---

diff --git a/libcxx/include/any b/libcxx/include/any
index 229daca..1f70c4f 100644
--- a/libcxx/include/any
+++ b/libcxx/include/any
@@ -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) _NOEXCEPT
 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>
diff --git a/libcxx/include/utility b/libcxx/include/utility
index 5e55506..52c062d 100644
--- a/libcxx/include/utility
+++ b/libcxx/include/utility
@@ -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_value)
 
 #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{});
-}
+inline constexpr in_place_type_t<_Tp> in_place_type{};
 
-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 {};
-
-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