[NFC][libc++] Remove __unexpected namespace

[yronglin]

Summary

Remove __unexpected namespace.

[yronglin]

Fix expected.h

[yronglin]

Fix unexpected.h

[philnik]

LGTM % nit. @huixie90 are you OK with this?

libcxx/include/__expected/expected.h

84–86

These aren't ADL lookups. Same for the other changes.

[huixie90]

In D141947#4060078, @philnik wrote:

LGTM % nit. @huixie90 are you OK with this?

LGTM

[yronglin]

Update

[yronglin]

Thanks for your review @philnik @huixie90 !

libcxx/include/__expected/expected.h

84–86

These aren't ADL lookups. Same for the other changes.

84–86

Good catch!

[yronglin]

Format

[yronglin]

Format

[yronglin]

Thanks for your review @ldionne !

libcxx/include/__expected/expected.h

 
 template <class _Tp, class _Err>
 class expected {
   static_assert(
       !is_reference_v<_Tp> &&
           !is_function_v<_Tp> &&
           !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
           !is_same_v<remove_cv_t<_Tp>, unexpect_t> &&
-          !__unexpected::__is_unexpected<remove_cv_t<_Tp>>::value &&
-          __unexpected::__valid_unexpected<_Err>::value
+          !__is_std_unexpected<remove_cv_t<_Tp>>::value &&
+          __valid_std_unexpected<_Err>::value
       ,
       "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
       "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
       "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
       "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
       "template argument for unexpected is ill-formed.");
 
   template <class _Up, class _OtherErr>
   friend class expected;
if (__has_val_) {
       std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
     } else {
       std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
     }
   }
 
   template <class _Up = _Tp>
     requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> &&
-             !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value && is_constructible_v<_Tp, _Up>)
+             !__is_std_unexpected<remove_cvref_t<_Up>>::value && is_constructible_v<_Tp, _Up>)
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>)
   expected(_Up&& __u)
     noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
       : __has_val_(true) {
     std::construct_at(std::addressof(__union_.__val_), std::forward<_Up>(__u));
   }
 
 
_LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
     // note: only reached if no exception+rollback was done inside __reinit_expected
     __has_val_ = __rhs.__has_val_;
     return *this;
   }
 
   template <class _Up = _Tp>
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v)
     requires(!is_same_v<expected, remove_cvref_t<_Up>> &&
-             !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value &&
+             !__is_std_unexpected<remove_cvref_t<_Up>>::value &&
              is_constructible_v<_Tp, _Up> &&
              is_assignable_v<_Tp&, _Up> &&
              (is_nothrow_constructible_v<_Tp, _Up> ||
               is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
     if (__has_val_) {
       __union_.__val_ = std::forward<_Up>(__v);
private:
   } __union_;
 
   bool __has_val_;
 };
 
 template <class _Tp, class _Err>
   requires is_void_v<_Tp>
 class expected<_Tp, _Err> {
-  static_assert(__unexpected::__valid_unexpected<_Err>::value,
+  static_assert(__valid_std_unexpected<_Err>::value,
                 "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a "
                 "valid argument for unexpected<E> is ill-formed");
 
   template <class, class>
   friend class expected;
 
   template <class _Up, class _OtherErr, class _OtherErrQual>
   using __can_convert =

libcxx/include/__expected/unexpected.h

 
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Err>
 class unexpected;
 
-namespace __unexpected {
-
 template <class _Tp>
-struct __is_unexpected : false_type {};
+struct __is_std_unexpected : false_type {};
 
 template <class _Err>
-struct __is_unexpected<unexpected<_Err>> : true_type {};
+struct __is_std_unexpected<unexpected<_Err>> : true_type {};
 
 template <class _Tp>
-using __valid_unexpected = _BoolConstant< //
-    is_object_v<_Tp> &&                   //
-    !is_array_v<_Tp> &&                   //
-    !__is_unexpected<_Tp>::value &&       //
-    !is_const_v<_Tp> &&                   //
-    !is_volatile_v<_Tp>                   //
+using __valid_std_unexpected = _BoolConstant< //
+    is_object_v<_Tp> &&                       //
+    !is_array_v<_Tp> &&                       //
+    !__is_std_unexpected<_Tp>::value &&       //
+    !is_const_v<_Tp> &&                       //
+    !is_volatile_v<_Tp>                       //
     >;
 
-} // namespace __unexpected
-
 template <class _Err>
 class unexpected {
-  static_assert(__unexpected::__valid_unexpected<_Err>::value,
+  static_assert(__valid_std_unexpected<_Err>::value,
                 "[expected.un.general] states a program that instantiates std::unexpected for a non-object type, an "
                 "array type, a specialization of unexpected, or a cv-qualified type is ill-formed.");
 
 public:
   _LIBCPP_HIDE_FROM_ABI constexpr unexpected(const unexpected&) = default;
   _LIBCPP_HIDE_FROM_ABI constexpr unexpected(unexpected&&)      = default;
 
   template <class _Error = _Err>