[libc++] reference_wrapper does not define nested types as described in C++11/14

[xingxue]

Summary

This patch tries to fix the issue that the implementation of reference_wrapper does not define nested types as described in C++11/14 standard section 20.8.3/20.9.3 [refwrap]. When T is a class with a nested type argument_type T1, the template instantiation reference_wrapper<T> shall define a nested type named argument_type as a synonym for T1. When T is a class with nested types named first_argument_type and second_argument_type of type T1 and T2, the template instantiation reference_wrapper<T> shall define two nested types named first_argument_type and second_argument_type as synonyms for T1 and T2, respectively. These types are deprecated in C++17 and removed in C++20.

The following test case demonstrates the issue.

#include <functional>

int main(void) {
  struct S{
    typedef int argument_type;
    typedef long first_argument_type;
    typedef float second_argument_type;
  };
  typedef std::reference_wrapper<S>::argument_type A1;
  typedef std::reference_wrapper<S>::first_argument_type A2;
  typedef std::reference_wrapper<S>::second_argument_type A3;
  static_assert(std::is_same<S::argument_type, A1>::value, "");
  static_assert(std::is_same<S::first_argument_type, A2>::value, "");
  static_assert(std::is_same<S::second_argument_type, A3>::value, "");
  return 0;
}

[xingxue]

Friendly ping.

[xingxue]

Gentle ping.

[xingxue]

Gentle ping.

[xingxue]

Gentle ping.

[EricWF]

@xingxue I apologize on behalf of the project for dropping this? Are you still willing to land it. If so, we can have it reviewed and completed this week.

[xingxue]

In D129229#4646238, @EricWF wrote:

@xingxue I apologize on behalf of the project for dropping this? Are you still willing to land it. If so, we can have it reviewed and completed this week.

Thanks very much @EricWF! Yeah, it will be appreciated if we could have it reviewed and completed at your convenience! This affects some test cases in Perennial.

[ldionne]

libcxx/include/__functional/weak_result_type.h

67–68

You should use __void_t instead, it is available in all Standard modes.

70

101

Plugging this here means that we also change the behavior of things like std::mem_fn. It looks like that's a good change, however we should also test it. Can you please make the fix not only for std::reference_wrapper but also for the other things like std::mem_fn that seem to be mis-behaving right now?

libcxx/test/libcxx/utilities/function.objects/refwrap/refwrap_types.pass.cpp

1

I would name this test libcxx/test/libcxx/utilities/function.objects/refwrap/argument_types.compile.pass.cpp or something like that. But at least let's make it a .compile.pass.cpp test since it is compile-only.

24

You should make this function just be void test() instead of main after moving it to .compile.pass.cpp. Those tests are never run, only compiled, and not having a main() function in a compile-only test helps avoid confusion about whether the test is run.

27

We should add a test that reference_wrapper<T> has no such nested types if T isn't a function type or a type with these types nested.

In other words, we want to positively assert that reference_wrapper<int> (for example) doesn't provide a meaningless argument_type typedef (and same for the other ones).

libcxx/test/std/depr/depr.function.objects/depr.base/refwrap_types.depr.verify.cpp

9–13

Let's move the REQUIRES above // <functional> to avoid breaking up the synopsis like that.

[xingxue]

Addressed comments.

• use __void_t instead of defining void_t
• rename test case to libcxx/test/libcxx/utilities/function.objects/refwrap/argument_types.verify
• rename test function from int main to void test
• test reference_wrapper<int> and verify compile time errors from typedefs of its argument_type and other members

[xingxue]

libcxx/include/__functional/weak_result_type.h

67–68

Changed as suggested, thanks!

70

Changed as suggested, thanks!

101

Can we fix std::mem_fn and other similar functions in a separate PR later? (working another item)

libcxx/test/libcxx/utilities/function.objects/refwrap/refwrap_types.pass.cpp

1

Changed the file name to libcxx/test/libcxx/utilities/function.objects/refwrap/argument_types.verify.cpp because the test now also verifies compile time errors.

24

Changed as suggested, thanks!

27

Added tests for reference_wrapper<int> and verify compile time errors from its argument_type and other typedefs.

libcxx/test/std/depr/depr.function.objects/depr.base/refwrap_types.depr.verify.cpp

9–13

Done, thanks!

libcxx/include/__functional/weak_result_type.h

template <class _A1, class _A2, class _Rp>
         static __binary_function<_A1, _A2, _Rp>
         __test(const volatile __binary_function<_A1, _A2, _Rp>*);
 
 public:
     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
     typedef decltype(__test((_Tp*)0)) type;
 };
 
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+template <typename...>
+using void_t = void;
+
+template <class _Tp, class = void_t<> >
+struct __maybe_has_argument_type {};
+
+template <class _Tp>
+struct __maybe_has_argument_type<_Tp, void_t<typename _Tp::argument_type> > {
+  using argument_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = typename _Tp::argument_type;
+};
+
+template <class _Tp, typename = void_t<>, typename = void_t<> >
+struct __maybe_has_first_and_second_argument_type {};
+
+template <class _Tp>
+struct __maybe_has_first_and_second_argument_type<
+    _Tp,
+    void_t<typename _Tp::first_argument_type>,
+    void_t<typename _Tp::second_argument_type> > {
+  using first_argument_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17  = typename _Tp::first_argument_type;
+  using second_argument_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = typename _Tp::second_argument_type;
+};
+
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+
 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
 struct __maybe_derive_from_unary_function  // bool is true
     : public __derives_from_unary_function<_Tp>::type
 {
 };
 
 template <class _Tp>
 struct __maybe_derive_from_unary_function<_Tp, false>
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    : public __maybe_has_argument_type<_Tp>
+#endif
 {
 };
 
 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
 struct __maybe_derive_from_binary_function  // bool is true
     : public __derives_from_binary_function<_Tp>::type
 {
 };
 
 template <class _Tp>
 struct __maybe_derive_from_binary_function<_Tp, false>
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    : public __maybe_has_first_and_second_argument_type<_Tp>
+#endif
 {
 };
 
 template <class _Tp, bool = __has_result_type<_Tp>::value>
 struct __weak_result_type_imp // bool is true
     : public __maybe_derive_from_unary_function<_Tp>,
       public __maybe_derive_from_binary_function<_Tp>
 {

libcxx/test/libcxx/utilities/function.objects/refwrap/refwrap_types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++11 || c++14 || c++17
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
+// <functional>
+
+// reference_wrapper
+
+// check for types of class reference_wrapper:
+//   argument_type, first_argument_type, second_argument_type
+// C++11 20.8.3 [refwrap]
+
+#include <functional>
+#include <type_traits>
+
+int main(int, char**) {
+  {
+    typedef float(F)(int);
+
+    typedef std::reference_wrapper<F>::argument_type A;
+    typedef std::reference_wrapper<F>::result_type R;
+    static_assert(std::is_same<A, int>::value, "");
+    static_assert(std::is_same<R, float>::value, "");
+  }
+  {
+    typedef double(F)(char, int);
+    typedef std::reference_wrapper<F>::first_argument_type A1;
+    typedef std::reference_wrapper<F>::second_argument_type A2;
+    typedef std::reference_wrapper<F>::result_type R;
+    static_assert(std::is_same<A1, char>::value, "");
+    static_assert(std::is_same<A2, int>::value, "");
+    static_assert(std::is_same<R, double>::value, "");
+  }
+  {
+    struct S {};
+    typedef long (S::*P)(void);
+    typedef std::reference_wrapper<P>::argument_type A;
+    static_assert(std::is_same<A, S*>::value, "");
+  }
+  {
+    struct S {};
+    typedef void (S::*P)(int);
+    typedef std::reference_wrapper<P>::first_argument_type A1;
+    typedef std::reference_wrapper<P>::second_argument_type A2;
+    static_assert(std::is_same<A1, S*>::value, "");
+    static_assert(std::is_same<A2, int>::value, "");
+  }
+  {
+    struct S {
+      typedef int argument_type;
+    };
+    typedef std::reference_wrapper<S>::argument_type A;
+    static_assert(std::is_same<S::argument_type, A>::value, "");
+  }
+  {
+    struct S {
+      typedef char first_argument_type;
+      typedef int second_argument_type;
+    };
+    typedef std::reference_wrapper<S>::first_argument_type A1;
+    typedef std::reference_wrapper<S>::second_argument_type A2;
+    static_assert(std::is_same<S::first_argument_type, A1>::value, "");
+    static_assert(std::is_same<S::second_argument_type, A2>::value, "");
+  }
+  return 0;
+}

libcxx/test/std/depr/depr.function.objects/depr.base/refwrap_types.depr.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+// REQUIRES: c++17
+// Types of class reference_wrapper were removed in C++20
+
+// check that types of class reference_wrapper are marked deprecated
+
+#include <functional>
+
+typedef float(F1)(int);
+typedef double(F2)(char, int);
+
+std::reference_wrapper<F1>::argument_type a;         // expected-warning {{'argument_type' is deprecated}}
+std::reference_wrapper<F1>::result_type r;           // expected-warning {{'result_type' is deprecated}}
+std::reference_wrapper<F2>::first_argument_type a1;  // expected-warning {{'first_argument_type' is deprecated}}
+std::reference_wrapper<F2>::second_argument_type a2; // expected-warning {{'second_argument_type' is deprecated}}
+std::reference_wrapper<F2>::result_type r1;          // expected-warning {{'result_type' is deprecated}}