[libc++] Moves unwrap_reference to type_traits.

[Mordante]

Summary

This was discovered while working on modules.

[Mordante]

Fixes CI.

[philnik]

libcxx/include/__functional/unwrap_ref.h

24

At least according to cppreference, unwrap_ref_decay should also get defined by <type_traits>.

libcxx/include/__type_traits/unwrap_ref.h

25

What's wrong with forward-declaring reference_wrapper here?

[Mordante]

CI fixes.

[Mordante]

Trigger CI.

[Mordante]

Addresses review comment. Basically the patch is now a rename.

[Mordante]

CI fixes.

[philnik]

libcxx/include/__type_traits/unwrap_ref.h

45

Maybe make this _LIBCPP_STD_VER >= 20 while you're at it?

libcxx/include/module.modulemap.in

968–969

IMO we should only export the actually required parts, not all of type_traits.

[Mordante]

Thanks for the review!

libcxx/include/module.modulemap.in

968–969

That indeed seems to work too, in the past this didn't always work, not sure why.

[Mordante]

Addresses review comments.

[philnik]

LGTM!

[Mordante]

Rebased and resolved merge conflicts.

libcxx/include/CMakeLists.txt

set(files
   __functional/operations.h
   __functional/perfect_forward.h
   __functional/pointer_to_binary_function.h
   __functional/pointer_to_unary_function.h
   __functional/ranges_operations.h
   __functional/reference_wrapper.h
   __functional/unary_function.h
   __functional/unary_negate.h
-  __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __fwd/array.h
   __fwd/fstream.h
   __fwd/get.h
   __fwd/hash.h
   __fwd/ios.h
   __fwd/istream.h
   __fwd/memory_resource.h
set(files
   __type_traits/remove_pointer.h
   __type_traits/remove_reference.h
   __type_traits/remove_volatile.h
   __type_traits/result_of.h
   __type_traits/strip_signature.h
   __type_traits/type_identity.h
   __type_traits/type_list.h
   __type_traits/underlying_type.h
+  __type_traits/unwrap_ref.h
   __type_traits/void_t.h
   __undef_macros
   __utility/as_const.h
   __utility/auto_cast.h
   __utility/cmp.h
   __utility/convert_to_integral.h
   __utility/declval.h
   __utility/exception_guard.h

libcxx/include/__type_traits/unwrap_ref.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___FUNCTIONAL_UNWRAP_REF_H
-#define _LIBCPP___FUNCTIONAL_UNWRAP_REF_H
+#ifndef _LIBCPP___TYPE_TRAITS_UNWRAP_REF_H
+#define _LIBCPP___TYPE_TRAITS_UNWRAP_REF_H
 
 #include <__config>
 #include <__type_traits/decay.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct __unwrap_reference { typedef _LIBCPP_NODEBUG _Tp type; };
 
 template <class _Tp>
 class reference_wrapper;
 
 template <class _Tp>
 struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG _Tp& type; };
 
 template <class _Tp>
 struct decay;
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
 struct unwrap_reference : __unwrap_reference<_Tp> { };
 
 template <class _Tp>
 using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
 
 template <class _Tp>
 struct unwrap_ref_decay : unwrap_reference<__decay_t<_Tp> > { };
 
 template <class _Tp>
 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
-#endif // > C++17
+#endif // _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
 struct __unwrap_ref_decay
 #if _LIBCPP_STD_VER >= 20
     : unwrap_ref_decay<_Tp>
 #else
     : __unwrap_reference<__decay_t<_Tp> >
 #endif
 { };
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP___FUNCTIONAL_UNWRAP_REF_H
+#endif // _LIBCPP___TYPE_TRAITS_UNWRAP_REF_H

libcxx/include/__utility/pair.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_PAIR_H
 #define _LIBCPP___UTILITY_PAIR_H
 
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__concepts/different_from.h>
 #include <__config>
-#include <__functional/unwrap_ref.h>
 #include <__fwd/array.h>
 #include <__fwd/get.h>
 #include <__fwd/subrange.h>
 #include <__fwd/tuple.h>
 #include <__tuple/pair_like.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>

 #include <__type_traits/is_nothrow_copy_assignable.h>
 #include <__type_traits/is_nothrow_copy_constructible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/unwrap_ref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/functional

 #include <__functional/not_fn.h>
 #include <__functional/operations.h>
 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/unary_negate.h>
-#include <__functional/unwrap_ref.h>
+#include <__type_traits/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <memory> // TODO: find out why removing this breaks the modules build
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/module.modulemap.in

module std [system] {
   module fstream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     @requires_LIBCXX_ENABLE_FSTREAM@
     header "fstream"
     export *
   }
   module functional {
     header "functional"
+    // the contents of __type_traits/unwrap_ref.h should be available from functional too.
+    export type_traits.unwrap_ref
     export *
 
     module __functional {
       module binary_function            { private header "__functional/binary_function.h" }
       module binary_negate              { private header "__functional/binary_negate.h" }
       module bind                       { private header "__functional/bind.h" }
       module bind_back                  { private header "__functional/bind_back.h" }
       module bind_front                 { private header "__functional/bind_front.h" }
module __functional {
       module operations                 { private header "__functional/operations.h" }
       module perfect_forward            { private header "__functional/perfect_forward.h" }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
       module ranges_operations          { private header "__functional/ranges_operations.h" }
       module reference_wrapper          { private header "__functional/reference_wrapper.h" }
       module unary_function             { private header "__functional/unary_function.h" }
       module unary_negate               { private header "__functional/unary_negate.h" }
-      module unwrap_ref                 { private header "__functional/unwrap_ref.h" }
       module weak_result_type           { private header "__functional/weak_result_type.h" }
     }
   }
   module future {
     @requires_LIBCXX_ENABLE_THREADS@
     header "future"
     export *
   }
module tuple {
     module tuple_indices    { private header "__tuple/tuple_indices.h" }
     module tuple_like       { private header "__tuple/tuple_like.h" }
     module tuple_like_ext   { private header "__tuple/tuple_like_ext.h" }
     module tuple_size       { private header "__tuple/tuple_size.h" }
     module tuple_types      { private header "__tuple/tuple_types.h" }
   }
   module type_traits {
     header "type_traits"
-    export functional.__functional.unwrap_ref
     export *
 
     module add_const                                 { private header "__type_traits/add_const.h" }
     module add_cv                                    { private header "__type_traits/add_cv.h" }
     module add_lvalue_reference                      { private header "__type_traits/add_lvalue_reference.h" }
     module add_pointer                               { private header "__type_traits/add_pointer.h" }
     module add_rvalue_reference                      { private header "__type_traits/add_rvalue_reference.h" }
     module add_volatile                              { private header "__type_traits/add_volatile.h" }
module type_traits {
     module strip_signature                           { private header "__type_traits/strip_signature.h" }
     module type_identity                             { private header "__type_traits/type_identity.h" }
     module type_list                                 { private header "__type_traits/type_list.h" }
     module underlying_type                           {
       private header "__type_traits/underlying_type.h"
 
       export type_traits
     }
+    module unwrap_ref                                { private header "__type_traits/unwrap_ref.h" }
     module void_t                                    { private header "__type_traits/void_t.h" }
   }
   module typeindex {
     header "typeindex"
     export *
   }
   module typeinfo {
     header "typeinfo"

libcxx/include/tuple

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/invoke.h>
-#include <__functional/unwrap_ref.h>
 #include <__fwd/array.h>
 #include <__fwd/tuple.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple/make_tuple_types.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>

 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/lazy.h>
 #include <__type_traits/maybe_const.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
+#include <__type_traits/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <version>

libcxx/include/type_traits

 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_pointer.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/remove_volatile.h>
 #include <__type_traits/result_of.h>
 #include <__type_traits/type_identity.h>
 #include <__type_traits/underlying_type.h>
+#include <__type_traits/unwrap_ref.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <cstddef>
 #include <cstdint>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_TYPE_TRAITS

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__functional/operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/operations.h'}}
 #include <__functional/perfect_forward.h> // expected-error@*:* {{use of private header from outside its module: '__functional/perfect_forward.h'}}
 #include <__functional/pointer_to_binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_binary_function.h'}}
 #include <__functional/pointer_to_unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_unary_function.h'}}
 #include <__functional/ranges_operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/ranges_operations.h'}}
 #include <__functional/reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__functional/reference_wrapper.h'}}
 #include <__functional/unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_function.h'}}
 #include <__functional/unary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_negate.h'}}
-#include <__functional/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unwrap_ref.h'}}
 #include <__functional/weak_result_type.h> // expected-error@*:* {{use of private header from outside its module: '__functional/weak_result_type.h'}}
 #include <__fwd/array.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/array.h'}}
 #include <__fwd/fstream.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/fstream.h'}}
 #include <__fwd/get.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/get.h'}}
 #include <__fwd/hash.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/hash.h'}}
 #include <__fwd/ios.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/ios.h'}}
 #include <__fwd/istream.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/istream.h'}}
 #include <__fwd/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/memory_resource.h'}}

 #include <__type_traits/remove_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_pointer.h'}}
 #include <__type_traits/remove_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_reference.h'}}
 #include <__type_traits/remove_volatile.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_volatile.h'}}
 #include <__type_traits/result_of.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/result_of.h'}}
 #include <__type_traits/strip_signature.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/strip_signature.h'}}
 #include <__type_traits/type_identity.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/type_identity.h'}}
 #include <__type_traits/type_list.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/type_list.h'}}
 #include <__type_traits/underlying_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/underlying_type.h'}}
+#include <__type_traits/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/unwrap_ref.h'}}
 #include <__type_traits/void_t.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/void_t.h'}}
 #include <__utility/as_const.h> // expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
 #include <__utility/auto_cast.h> // expected-error@*:* {{use of private header from outside its module: '__utility/auto_cast.h'}}
 #include <__utility/cmp.h> // expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}
 #include <__utility/convert_to_integral.h> // expected-error@*:* {{use of private header from outside its module: '__utility/convert_to_integral.h'}}
 #include <__utility/declval.h> // expected-error@*:* {{use of private header from outside its module: '__utility/declval.h'}}
 #include <__utility/exception_guard.h> // expected-error@*:* {{use of private header from outside its module: '__utility/exception_guard.h'}}
 #include <__utility/exchange.h> // expected-error@*:* {{use of private header from outside its module: '__utility/exchange.h'}}

libcxx/utils/data/ignore_format.txt

 libcxx/include/__functional/operations.h
 libcxx/include/__functional/perfect_forward.h
 libcxx/include/__functional/pointer_to_binary_function.h
 libcxx/include/__functional/pointer_to_unary_function.h
 libcxx/include/__functional/ranges_operations.h
 libcxx/include/__functional/reference_wrapper.h
 libcxx/include/__functional/unary_function.h
 libcxx/include/__functional/unary_negate.h
-libcxx/include/__functional/unwrap_ref.h
 libcxx/include/__functional/weak_result_type.h
 libcxx/include/future
 libcxx/include/__fwd/get.h
 libcxx/include/__fwd/span.h
 libcxx/include/__fwd/string_view.h
 libcxx/include/__fwd/subrange.h
 libcxx/include/__hash_table
 libcxx/include/initializer_list

 libcxx/include/__type_traits/remove_pointer.h
 libcxx/include/__type_traits/remove_reference.h
 libcxx/include/__type_traits/remove_volatile.h
 libcxx/include/__type_traits/result_of.h
 libcxx/include/__type_traits/strip_signature.h
 libcxx/include/__type_traits/type_identity.h
 libcxx/include/__type_traits/type_list.h
 libcxx/include/__type_traits/underlying_type.h
+libcxx/include/__type_traits/unwrap_ref.h
 libcxx/include/__type_traits/void_t.h
 libcxx/include/uchar.h
 libcxx/include/unordered_map
 libcxx/include/unordered_set
 libcxx/include/__utility/as_const.h
 libcxx/include/__utility/cmp.h
 libcxx/include/__utility/convert_to_integral.h
 libcxx/include/__utility/exchange.h