This is the mail archive of the libstdc++@gcc.gnu.org mailing list for the libstdc++ project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch] Define std::invoke()


This implements C++17's std::invoke(), as a call to std::__invoke() so
we can also use it in C++11 and C++14.

This includes the resolution of LWG 2219 which was just passed in
Kona.

Tested powerpc64le-linux, committed to trunk.


commit 9eb38ac574c84c515c98db57abc73581d50a45dd
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Oct 22 22:08:01 2015 +0100

    Implement C++17 std::invoke and LWG DR 2219
    
    	* include/std/functional (__invoke_impl): New overloads.
    	(__invoke): Replace with a single function calling __invoke_impl.
    	(invoke): Add C++17 std::invoke.
    	(reference_wrapper::operator()): Qualify call to __invoke.
    	(_Mem_fn_traits_base, _Mem_fn_traits): Remove unused typedefs.
    	(_Mem_fn_base): Remove unused typedefs and implement call operator in
    	terms of __invoke.
    	* include/std/future (__future_base::_Async_state_commonV2): Do not
    	pass reference_wrapper as object argument to call_once.
    	* include/std/type_traits (result_of): Define nested __invoke_type.
    	Handle reference_wrapper as per LWG 2219.
    	* testsuite/20_util/bind/ref_neg.cc: Adjust dg-error directives.
    	* testsuite/20_util/function_objects/mem_fn/55463.cc: Remove tests
    	using member functions of reference_wrapper.

diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 7dd149a..f1dc839 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -184,48 +184,77 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
     { };
 
-  /**
-   * Invoke a function object, which may be either a member pointer or a
-   * function object. The first parameter will tell which.
-   */
-  template<typename _Functor, typename... _Args>
-    inline
-    typename enable_if<
-	     (!is_member_pointer<_Functor>::value
-	      && !is_function<_Functor>::value
-	      && !is_function<typename remove_pointer<_Functor>::type>::value),
-	     typename result_of<_Functor&(_Args&&...)>::type
-	   >::type
-    __invoke(_Functor& __f, _Args&&... __args)
+  template<typename _Res, typename _Fn, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...)))
+    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
+		  _Args&&... __args)
+    noexcept(noexcept((forward<_Tp>(__t).*__f)(forward<_Args>(__args)...)))
+    { return (forward<_Tp>(__t).*__f)(forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f,
+		  reference_wrapper<_Tp> __t, _Args&&... __args)
+    noexcept(noexcept((__t.get().*__f)(forward<_Args>(__args)...)))
+    { return (__t.get().*__f)(forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
+		  _Args&&... __args)
+    noexcept(noexcept(((*forward<_Tp>(__t)).*__f)(forward<_Args>(__args)...)))
+    { return ((*forward<_Tp>(__t)).*__f)(forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memobj_ref, _MemFun&& __f, _Tp&& __t)
+    noexcept(noexcept(forward<_Tp>(__t).*__f))
+    { return forward<_Tp>(__t).*__f; }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memobj_ref, _MemFun&& __f,
+		  reference_wrapper<_Tp> __t)
+    noexcept(noexcept(__t.get().*__f))
+    { return __t.get().*__f; }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    inline _Res
+    __invoke_impl(__invoke_memobj_deref, _MemFun&& __f, _Tp&& __t,
+		  _Args&&... __args)
+    noexcept(noexcept((*forward<_Tp>(__t)).*__f))
+    { return (*forward<_Tp>(__t)).*__f; }
+
+  /// Invoke a callable object.
+  template<typename _Callable, typename... _Args>
+    inline typename result_of<_Callable&&(_Args&&...)>::type
+    __invoke(_Callable&& __fn, _Args&&... __args)
     {
-      return __f(std::forward<_Args>(__args)...);
+      using __result_of = result_of<_Callable&&(_Args&&...)>;
+      using __type = typename __result_of::type;
+      using __tag = typename __result_of::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+					std::forward<_Args>(__args)...);
     }
 
-  template<typename _Functor, typename... _Args>
-    inline
-    typename enable_if<
-             (is_member_pointer<_Functor>::value
-              && !is_function<_Functor>::value
-              && !is_function<typename remove_pointer<_Functor>::type>::value),
-             typename result_of<_Functor(_Args&&...)>::type
-           >::type
-    __invoke(_Functor& __f, _Args&&... __args)
-    {
-      return std::mem_fn(__f)(std::forward<_Args>(__args)...);
-    }
+#if __cplusplus > 201402L
+# define __cpp_lib_invoke 201411
 
-  // To pick up function references (that will become function pointers)
-  template<typename _Functor, typename... _Args>
-    inline
-    typename enable_if<
-	     (is_pointer<_Functor>::value
-	      && is_function<typename remove_pointer<_Functor>::type>::value),
-	     typename result_of<_Functor(_Args&&...)>::type
-	   >::type
-    __invoke(_Functor __f, _Args&&... __args)
+  /// Invoke a callable object.
+  template<typename _Callable, typename... _Args>
+    inline result_of_t<_Callable&&(_Args&&...)>
+    invoke(_Callable&& __fn, _Args&&... __args)
     {
-      return __f(std::forward<_Args>(__args)...);
+      return std::__invoke(std::forward<_Callable>(__fn),
+			   std::forward<_Args>(__args)...);
     }
+#endif
 
   /**
    *  Knowing which of unary_function and binary_function _Tp derives
@@ -425,7 +454,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	typename result_of<_Tp&(_Args&&...)>::type
 	operator()(_Args&&... __args) const
 	{
-	  return __invoke(get(), std::forward<_Args>(__args)...);
+	  return std::__invoke(get(), std::forward<_Args>(__args)...);
 	}
     };
 
@@ -504,8 +533,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct _Mem_fn_traits_base
     {
       using __result_type = _Res;
-      using __class_type =  _Class;
-      using __arg_types = _Pack<_ArgTypes...>;
       using __maybe_type
 	= _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
       using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
@@ -516,18 +543,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF>	\
     : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>		\
     {									\
-      using __pmf_type  = _Res (_Class::*)(_ArgTypes...) _CV _REF;	\
-      using __lvalue = _LVAL;						\
-      using __rvalue = _RVAL;						\
       using __vararg = false_type;					\
     };									\
   template<typename _Res, typename _Class, typename... _ArgTypes>	\
     struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF>	\
     : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>		\
     {									\
-      using __pmf_type  = _Res (_Class::*)(_ArgTypes... ...) _CV _REF;	\
-      using __lvalue = _LVAL;						\
-      using __rvalue = _RVAL;						\
       using __vararg = true_type;					\
     };
 
@@ -551,173 +572,51 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
     {
       using _Traits = _Mem_fn_traits<_MemFunPtr>;
 
-      using _Class = typename _Traits::__class_type;
-      using _ArgTypes = typename _Traits::__arg_types;
-      using _Pmf = typename _Traits::__pmf_type;
-
       using _Arity = typename _Traits::__arity;
       using _Varargs = typename _Traits::__vararg;
 
       template<typename _Func, typename... _BoundArgs>
 	friend struct _Bind_check_arity;
 
-      // for varargs functions we just check the number of arguments,
-      // otherwise we also check they are convertible.
-      template<typename _Args>
-	using _CheckArgs = typename conditional<_Varargs::value,
-	  __bool_constant<(_Args::value >= _ArgTypes::value)>,
-	  _AllConvertible<_Args, _ArgTypes>
-	>::type;
+      _MemFunPtr _M_pmf;
 
     public:
+
       using result_type = typename _Traits::__result_type;
 
-      explicit constexpr _Mem_fn_base(_Pmf __pmf) : _M_pmf(__pmf) { }
+      explicit constexpr
+      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
 
-      // Handle objects
-      template<typename... _Args, typename _Req
-               = _Require<typename _Traits::__lvalue,
-                          _CheckArgs<_Pack<_Args...>>>>
-	result_type
-	operator()(_Class& __object, _Args&&... __args) const
-	{ return (__object.*_M_pmf)(std::forward<_Args>(__args)...); }
-
-      template<typename... _Args, typename _Req
-               = _Require<typename _Traits::__rvalue,
-                          _CheckArgs<_Pack<_Args...>>>>
-	result_type
-	operator()(_Class&& __object, _Args&&... __args) const
-	{
-	  return (std::move(__object).*_M_pmf)(std::forward<_Args>(__args)...);
-	}
-
-      // Handle pointers
-      template<typename... _Args, typename _Req
-               = _Require<typename _Traits::__lvalue,
-                          _CheckArgs<_Pack<_Args...>>>>
-	result_type
-	operator()(_Class* __object, _Args&&... __args) const
-	{ return (__object->*_M_pmf)(std::forward<_Args>(__args)...); }
-
-      // Handle smart pointers, references and pointers to derived
-      template<typename _Tp, typename... _Args, typename _Req
-               = _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
-                          _CheckArgs<_Pack<_Args...>>>>
-	result_type
-	operator()(_Tp&& __object, _Args&&... __args) const
-	{
-	  return _M_call(std::forward<_Tp>(__object), &__object,
-	      std::forward<_Args>(__args)...);
-	}
-
-      // Handle reference wrappers
-      template<typename _Tp, typename... _Args, typename _Req
-               = _Require<is_base_of<_Class, _Tp>, typename _Traits::__lvalue,
-                          _CheckArgs<_Pack<_Args...>>>>
-	result_type
-	operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
-	{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
-
-    private:
-      template<typename _Tp, typename... _Args>
-	result_type
-	_M_call(_Tp&& __object, const volatile _Class *,
-		_Args&&... __args) const
-	{
-	  return (std::forward<_Tp>(__object).*_M_pmf)
-	    (std::forward<_Args>(__args)...);
-	}
-
-      template<typename _Tp, typename... _Args>
-	result_type
-	_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
-	{ return ((*__ptr).*_M_pmf)(std::forward<_Args>(__args)...); }
-
-      _Pmf _M_pmf;
+      template<typename... _Args>
+	auto
+	operator()(_Args&&... __args) const
+	noexcept(noexcept(std::__invoke(_M_pmf, forward<_Args>(__args)...)))
+	-> decltype(std::__invoke(_M_pmf, forward<_Args>(__args)...))
+	{ return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
     };
 
   // Partial specialization for member object pointers.
-  template<typename _Res, typename _Class>
-    class _Mem_fn_base<_Res _Class::*, false>
+  template<typename _MemObjPtr>
+    class _Mem_fn_base<_MemObjPtr, false>
     {
-      using __pm_type = _Res _Class::*;
-
-      // This bit of genius is due to Peter Dimov, improved slightly by
-      // Douglas Gregor.
-      // Made less elegant to support perfect forwarding and noexcept.
-      template<typename _Tp>
-	auto
-	_M_call(_Tp&& __object, const _Class *) const noexcept
-	-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
-	{ return std::forward<_Tp>(__object).*_M_pm; }
-
-      template<typename _Tp, typename _Up>
-	auto
-	_M_call(_Tp&& __object, _Up * const *) const noexcept
-	-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
-	{ return (*std::forward<_Tp>(__object)).*_M_pm; }
-
-      template<typename _Tp>
-	auto
-	_M_call(_Tp&& __ptr, const volatile void*) const
-	noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
-	-> decltype((*__ptr).*std::declval<__pm_type&>())
-	{ return (*__ptr).*_M_pm; }
-
       using _Arity = integral_constant<size_t, 0>;
       using _Varargs = false_type;
 
       template<typename _Func, typename... _BoundArgs>
 	friend struct _Bind_check_arity;
 
+      _MemObjPtr _M_pm;
+
     public:
       explicit constexpr
-      _Mem_fn_base(_Res _Class::*__pm) noexcept : _M_pm(__pm) { }
+      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
 
-      // Handle objects
-      _Res&
-      operator()(_Class& __object) const noexcept
-      { return __object.*_M_pm; }
-
-      const _Res&
-      operator()(const _Class& __object) const noexcept
-      { return __object.*_M_pm; }
-
-      _Res&&
-      operator()(_Class&& __object) const noexcept
-      { return std::forward<_Class>(__object).*_M_pm; }
-
-      const _Res&&
-      operator()(const _Class&& __object) const noexcept
-      { return std::forward<const _Class>(__object).*_M_pm; }
-
-      // Handle pointers
-      _Res&
-      operator()(_Class* __object) const noexcept
-      { return __object->*_M_pm; }
-
-      const _Res&
-      operator()(const _Class* __object) const noexcept
-      { return __object->*_M_pm; }
-
-      // Handle smart pointers and derived
-      template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
+      template<typename _Tp>
 	auto
-	operator()(_Tp&& __unknown) const
-	noexcept(noexcept(std::declval<_Mem_fn_base*>()->_M_call
-			  (std::forward<_Tp>(__unknown), &__unknown)))
-	-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
-	{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
-
-      template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
-	auto
-	operator()(reference_wrapper<_Tp> __ref) const
-	noexcept(noexcept(std::declval<_Mem_fn_base&>()(__ref.get())))
-	-> decltype((*this)(__ref.get()))
-	{ return (*this)(__ref.get()); }
-
-    private:
-      _Res _Class::*_M_pm;
+	operator()(_Tp&& __obj) const
+	noexcept(noexcept(std::__invoke(_M_pm, forward<_Tp>(__obj))))
+	-> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
+	{ return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
     };
 
   template<typename _Res, typename _Class>
diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future
index 216a921..5d9a1d3 100644
--- a/libstdc++-v3/include/std/future
+++ b/libstdc++-v3/include/std/future
@@ -1641,7 +1641,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     // the shared state, whichever happens first.
     virtual void _M_complete_async() { _M_join(); }
 
-    void _M_join() { std::call_once(_M_once, &thread::join, ref(_M_thread)); }
+    void _M_join() { std::call_once(_M_once, &thread::join, &_M_thread); }
 
     thread _M_thread;
     once_flag _M_once;
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index e291047..e08131b 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -2219,13 +2219,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #define __cpp_lib_result_of_sfinae 201210
 
+  struct __invoke_memfun_ref { };
+  struct __invoke_memfun_deref { };
+  struct __invoke_memobj_ref { };
+  struct __invoke_memobj_deref { };
+  struct __invoke_other { };
+
+  // Associate a tag type with a specialization of __success_type.
+  template<typename _Tp, typename _Tag>
+    struct __result_of_success : __success_type<_Tp>
+    { using __invoke_type = _Tag; };
+
   // [func.require] paragraph 1 bullet 1:
   struct __result_of_memfun_ref_impl
   {
     template<typename _Fp, typename _Tp1, typename... _Args>
-      static __success_type<decltype(
+      static __result_of_success<decltype(
       (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
-      )> _S_test(int);
+      ), __invoke_memfun_ref> _S_test(int);
 
     template<typename...>
       static __failure_type _S_test(...);
@@ -2242,9 +2253,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   struct __result_of_memfun_deref_impl
   {
     template<typename _Fp, typename _Tp1, typename... _Args>
-      static __success_type<decltype(
+      static __result_of_success<decltype(
       ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
-      )> _S_test(int);
+      ), __invoke_memfun_deref> _S_test(int);
 
     template<typename...>
       static __failure_type _S_test(...);
@@ -2261,9 +2272,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   struct __result_of_memobj_ref_impl
   {
     template<typename _Fp, typename _Tp1>
-      static __success_type<decltype(
+      static __result_of_success<decltype(
       std::declval<_Tp1>().*std::declval<_Fp>()
-      )> _S_test(int);
+      ), __invoke_memobj_ref> _S_test(int);
 
     template<typename, typename>
       static __failure_type _S_test(...);
@@ -2280,9 +2291,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   struct __result_of_memobj_deref_impl
   {
     template<typename _Fp, typename _Tp1>
-      static __success_type<decltype(
+      static __result_of_success<decltype(
       (*std::declval<_Tp1>()).*std::declval<_Fp>()
-      )> _S_test(int);
+      ), __invoke_memobj_deref> _S_test(int);
 
     template<typename, typename>
       static __failure_type _S_test(...);
@@ -2327,6 +2338,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       >::type::type type;
     };
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2219.  INVOKE-ing a pointer to member with a reference_wrapper
+  //        as the object expression
+  template<typename> struct reference_wrapper;
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
+    : __result_of_memobj<_Res _Class::*, _Arg>
+    {
+      typedef typename
+	__result_of_memobj_ref<_Res _Class::*, _Arg&>::type type;
+    };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&>
+    : __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>&&>
+    : __result_of_memobj<_Res _Class::*, reference_wrapper<_Arg>>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
+    : __result_of_memfun<_Res _Class::*, _Arg&, _Args...>
+    {
+      typedef typename
+	__result_of_memfun_ref<_Res _Class::*, _Arg&, _Args...>::type type;
+    };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&,
+			      _Args...>
+    : __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
+    { };
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>&&,
+			      _Args...>
+    : __result_of_memfun<_Res _Class::*, reference_wrapper<_Arg>, _Args...>
+    { };
+
   template<bool, bool, typename _Functor, typename... _ArgTypes>
     struct __result_of_impl
     {
@@ -2347,9 +2401,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   struct __result_of_other_impl
   {
     template<typename _Fn, typename... _Args>
-      static __success_type<decltype(
+      static __result_of_success<decltype(
       std::declval<_Fn>()(std::declval<_Args>()...)
-      )> _S_test(int);
+      ), __invoke_other> _S_test(int);
 
     template<typename...>
       static __failure_type _S_test(...);
diff --git a/libstdc++-v3/testsuite/20_util/bind/ref_neg.cc b/libstdc++-v3/testsuite/20_util/bind/ref_neg.cc
index 73eabf9..a09788a 100644
--- a/libstdc++-v3/testsuite/20_util/bind/ref_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/bind/ref_neg.cc
@@ -30,10 +30,6 @@ void test01()
 {
   const int dummy = 0;
   std::bind(&inc, _1)(0);               // { dg-error  "no match" }
-  // { dg-error "rvalue|const" "" { target *-*-* } 1125 }
-  // { dg-error "rvalue|const" "" { target *-*-* } 1139 }
-  // { dg-error "rvalue|const" "" { target *-*-* } 1153 }
-  // { dg-error "rvalue|const" "" { target *-*-* } 1167 }
   std::bind(&inc, std::ref(dummy))();	// { dg-error  "no match" }
 }
 
@@ -50,8 +46,15 @@ void test02()
   const int dummy = 0;
   std::bind(Inc(), _1)(dummy);                  // { dg-error  "no match" }
   std::bind(&Inc::f, Inc(), std::ref(dummy))(); // { dg-error  "no match" }
+  // { dg-error "no match" "" { target *-*-* } 594 }
+  // { dg-error "no type" "" { target *-*-* } 237 }
 }
 
+// { dg-error "rvalue|const" "" { target *-*-* } 1024 }
+// { dg-error "rvalue|const" "" { target *-*-* } 1038 }
+// { dg-error "rvalue|const" "" { target *-*-* } 1052 }
+// { dg-error "rvalue|const" "" { target *-*-* } 1066 }
+
 int main()
 {
   test01();
diff --git a/libstdc++-v3/testsuite/20_util/function_objects/mem_fn/55463.cc b/libstdc++-v3/testsuite/20_util/function_objects/mem_fn/55463.cc
index 2eba902..c67731a 100644
--- a/libstdc++-v3/testsuite/20_util/function_objects/mem_fn/55463.cc
+++ b/libstdc++-v3/testsuite/20_util/function_objects/mem_fn/55463.cc
@@ -98,15 +98,3 @@ void test01()
   int& pval __attribute__((unused)) = std::mem_fn( &X::data )( X_ptr() );
   int& sval __attribute__((unused)) = std::mem_fn( &X::data )( smart_ptr() );
 }
-
-void test02()
-{
-  std::reference_wrapper<X> r = ref();
-  X& x1 __attribute__((unused))
-    = std::mem_fn( &std::reference_wrapper<X>::get )( r );
-  const std::reference_wrapper<X> cr = ref();
-  const X& x3 __attribute__((unused))
-    = std::mem_fn( &std::reference_wrapper<X>::get )( cr );
-  X& x2 __attribute__((unused))
-    = std::mem_fn( &std::reference_wrapper<X>::get )( ref() );
-}

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]