aboutsummaryrefslogtreecommitdiffstats
path: root/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch')
-rw-r--r--meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch776
1 files changed, 776 insertions, 0 deletions
diff --git a/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch b/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch
new file mode 100644
index 0000000000..1c507fe42c
--- /dev/null
+++ b/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0173-2011-04-23-Jonathan-Wakely-jwakely.gcc-gmail.com.patch
@@ -0,0 +1,776 @@
+From 0755fde6008ab7a7ae98f3b4c5967191408431f3 Mon Sep 17 00:00:00 2001
+From: redi <redi@138bc75d-0d04-0410-961f-82ee72b054a4>
+Date: Sat, 23 Apr 2011 17:51:31 +0000
+Subject: [PATCH 173/200] 2011-04-23 Jonathan Wakely <jwakely.gcc@gmail.com>
+
+ PR libstdc++/48521
+ * include/std/type_traits (result_of): Handle pointer to member.
+ * include/std/functional (__invoke): Likewise.
+ (_Function_to_function_pointer): Remove.
+ (_Reference_wrapper_base): Provide nested types independent of
+ unary_function and binary_function.
+ (reference_wrapper::operator()): DR 2017.
+ (ref(const A&&), cref(const A&&): Define as deleted.
+ * include/std/future (async): Simplify SFINAE and use result_of to
+ support pointer to member.
+ * testsuite/20_util/reference_wrapper/invoke.cc: Test pointer to
+ member.
+ * testsuite/20_util/reference_wrapper/24803.cc: Likewise.
+ * testsuite/20_util/reference_wrapper/typedefs.cc: Test for types
+ instead of derivation from unary_function and binary_function.
+ * testsuite/20_util/reference_wrapper/invoke-2.cc: New.
+ * testsuite/20_util/reference_wrapper/ref_neg.c: New.
+ * testsuite/20_util/reference_wrapper/typedefs-3.c: New.
+
+
+
+git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-4_6-branch@172901 138bc75d-0d04-0410-961f-82ee72b054a4
+
+index 660e371..57ec506 100644
+--- a/libstdc++-v3/include/std/functional
++++ b/libstdc++-v3/include/std/functional
+@@ -212,19 +212,6 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ static const bool value = sizeof(__test((_Tp*)0)) == 1;
+ };
+
+- /// Turns a function type into a function pointer type
+- template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value>
+- struct _Function_to_function_pointer
+- {
+- typedef _Tp type;
+- };
+-
+- template<typename _Tp>
+- struct _Function_to_function_pointer<_Tp, true>
+- {
+- typedef _Tp* type;
+- };
+-
+ /**
+ * Invoke a function object, which may be either a member pointer or a
+ * function object. The first parameter will tell which.
+@@ -235,20 +222,33 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ (!is_member_pointer<_Functor>::value
+ && !is_function<_Functor>::value
+ && !is_function<typename remove_pointer<_Functor>::type>::value),
+- typename result_of<_Functor(_Args...)>::type
++ typename result_of<_Functor(_Args&&...)>::type
+ >::type
+ __invoke(_Functor& __f, _Args&&... __args)
+ {
+ return __f(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 mem_fn(__f)(std::forward<_Args>(__args)...);
++ }
++
+ // 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
++ typename result_of<_Functor(_Args&&...)>::type
+ >::type
+ __invoke(_Functor __f, _Args&&... __args)
+ {
+@@ -263,40 +263,43 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ template<bool _Unary, bool _Binary, typename _Tp>
+ struct _Reference_wrapper_base_impl;
+
+- // Not a unary_function or binary_function, so try a weak result type.
++ // None of the nested argument types.
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<false, false, _Tp>
+ : _Weak_result_type<_Tp>
+ { };
+
+- // unary_function but not binary_function
++ // Nested argument_type only.
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<true, false, _Tp>
+- : unary_function<typename _Tp::argument_type,
+- typename _Tp::result_type>
+- { };
++ : _Weak_result_type<_Tp>
++ {
++ typedef typename _Tp::argument_type argument_type;
++ };
+
+- // binary_function but not unary_function
++ // Nested first_argument_type and second_argument_type only.
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<false, true, _Tp>
+- : binary_function<typename _Tp::first_argument_type,
+- typename _Tp::second_argument_type,
+- typename _Tp::result_type>
+- { };
++ : _Weak_result_type<_Tp>
++ {
++ typedef typename _Tp::first_argument_type first_argument_type;
++ typedef typename _Tp::second_argument_type second_argument_type;
++ };
+
+- // Both unary_function and binary_function. Import result_type to
+- // avoid conflicts.
++ // All the nested argument types.
+ template<typename _Tp>
+ struct _Reference_wrapper_base_impl<true, true, _Tp>
+- : unary_function<typename _Tp::argument_type,
+- typename _Tp::result_type>,
+- binary_function<typename _Tp::first_argument_type,
+- typename _Tp::second_argument_type,
+- typename _Tp::result_type>
++ : _Weak_result_type<_Tp>
+ {
+- typedef typename _Tp::result_type result_type;
++ typedef typename _Tp::argument_type argument_type;
++ typedef typename _Tp::first_argument_type first_argument_type;
++ typedef typename _Tp::second_argument_type second_argument_type;
+ };
+
++ _GLIBCXX_HAS_NESTED_TYPE(argument_type)
++ _GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
++ _GLIBCXX_HAS_NESTED_TYPE(second_argument_type)
++
+ /**
+ * Derives from unary_function or binary_function when it
+ * can. Specializations handle all of the easy cases. The primary
+@@ -306,8 +309,9 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ template<typename _Tp>
+ struct _Reference_wrapper_base
+ : _Reference_wrapper_base_impl<
+- _Derives_from_unary_function<_Tp>::value,
+- _Derives_from_binary_function<_Tp>::value,
++ __has_argument_type<_Tp>::value,
++ __has_first_argument_type<_Tp>::value
++ && __has_second_argument_type<_Tp>::value,
+ _Tp>
+ { };
+
+@@ -422,12 +426,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ class reference_wrapper
+ : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+ {
+- // If _Tp is a function type, we can't form result_of<_Tp(...)>,
+- // so turn it into a function pointer type.
+- typedef typename _Function_to_function_pointer<_Tp>::type
+- _M_func_type;
+-
+ _Tp* _M_data;
++
+ public:
+ typedef _Tp type;
+
+@@ -456,7 +456,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ { return *_M_data; }
+
+ template<typename... _Args>
+- typename result_of<_M_func_type(_Args...)>::type
++ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+ return __invoke(get(), std::forward<_Args>(__args)...);
+@@ -476,6 +476,12 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
+ cref(const _Tp& __t)
+ { return reference_wrapper<const _Tp>(__t); }
+
++ template<typename _Tp>
++ void ref(const _Tp&&) = delete;
++
++ template<typename _Tp>
++ void cref(const _Tp&&) = delete;
++
+ /// Partial specialization.
+ template<typename _Tp>
+ inline reference_wrapper<_Tp>
+diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future
+index 17d46db..970ce76 100644
+--- a/libstdc++-v3/include/std/future
++++ b/libstdc++-v3/include/std/future
+@@ -142,11 +142,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ future<typename result_of<_Fn(_Args...)>::type>
+ async(launch __policy, _Fn&& __fn, _Args&&... __args);
+
++ template<typename _FnCheck, typename _Fn, typename... _Args>
++ struct __async_sfinae_helper
++ {
++ typedef future<typename result_of<_Fn(_Args...)>::type> type;
++ };
++
++ template<typename _Fn, typename... _Args>
++ struct __async_sfinae_helper<launch, _Fn, _Args...>
++ { };
++
+ template<typename _Fn, typename... _Args>
+ typename
+- enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
+- future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
+- >::type
++ __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type
+ async(_Fn&& __fn, _Args&&... __args);
+
+ #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
+@@ -1366,9 +1374,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ /// async, potential overload
+ template<typename _Fn, typename... _Args>
+ inline typename
+- enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
+- future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
+- >::type
++ __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type
+ async(_Fn&& __fn, _Args&&... __args)
+ {
+ return async(launch::any, std::forward<_Fn>(__fn),
+diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
+index f5d867b..2361152 100644
+--- a/libstdc++-v3/include/std/type_traits
++++ b/libstdc++-v3/include/std/type_traits
+@@ -1140,12 +1140,92 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Signature>
+ class result_of;
+
++ template<typename _MemPtr, typename _Arg>
++ struct _Result_of_memobj;
++
++ template<typename _Res, typename _Class, typename _Arg>
++ struct _Result_of_memobj<_Res _Class::*, _Arg>
++ {
++ private:
++ typedef _Res _Class::* _Func;
++
++ template<typename _Tp>
++ static _Tp _S_get(const _Class&);
++ template<typename _Tp>
++ static decltype(*std::declval<_Tp>()) _S_get(...);
++
++ public:
++ typedef
++ decltype(_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>())
++ __type;
++ };
++
++ template<typename _MemPtr, typename _Arg, typename... _ArgTypes>
++ struct _Result_of_memfun;
++
++ template<typename _Res, typename _Class, typename _Arg, typename... _Args>
++ struct _Result_of_memfun<_Res _Class::*, _Arg, _Args...>
++ {
++ private:
++ typedef _Res _Class::* _Func;
++
++ template<typename _Tp>
++ static _Tp _S_get(const _Class&);
++ template<typename _Tp>
++ static decltype(*std::declval<_Tp>()) _S_get(...);
++
++ public:
++ typedef
++ decltype((_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>())
++ (std::declval<_Args>()...) )
++ __type;
++ };
++
++ template<bool, bool, typename _Functor, typename... _ArgTypes>
++ struct _Result_of_impl;
++
+ template<typename _Functor, typename... _ArgTypes>
+- struct result_of<_Functor(_ArgTypes...)>
++ struct _Result_of_impl<false, false, _Functor, _ArgTypes...>
+ {
+ typedef
+ decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
+- type;
++ __type;
++ };
++
++ template<typename _MemPtr, typename _Arg>
++ struct _Result_of_impl<true, false, _MemPtr, _Arg>
++ : _Result_of_memobj<typename remove_reference<_MemPtr>::type, _Arg>
++ {
++ typedef typename _Result_of_memobj<
++ typename remove_reference<_MemPtr>::type, _Arg>::__type
++ __type;
++ };
++
++ template<typename _MemPtr, typename _Arg, typename... _ArgTypes>
++ struct _Result_of_impl<false, true, _MemPtr, _Arg, _ArgTypes...>
++ : _Result_of_memfun<typename remove_reference<_MemPtr>::type, _Arg,
++ _ArgTypes...>
++ {
++ typedef typename _Result_of_memfun<
++ typename remove_reference<_MemPtr>::type, _Arg, _ArgTypes...>::__type
++ __type;
++ };
++
++ template<typename _Functor, typename... _ArgTypes>
++ struct result_of<_Functor(_ArgTypes...)>
++ : _Result_of_impl<is_member_object_pointer<
++ typename remove_reference<_Functor>::type >::value,
++ is_member_function_pointer<
++ typename remove_reference<_Functor>::type >::value,
++ _Functor, _ArgTypes...>
++ {
++ typedef typename _Result_of_impl<
++ is_member_object_pointer<
++ typename remove_reference<_Functor>::type >::value,
++ is_member_function_pointer<
++ typename remove_reference<_Functor>::type >::value,
++ _Functor, _ArgTypes...>::__type
++ type;
+ };
+
+ /**
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc
+index 598c5c8..4bf6148 100644
+--- a/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc
+@@ -1,7 +1,7 @@
+ // { dg-options "-std=gnu++0x" }
+ // { dg-do compile }
+
+-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
++// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ //
+ // This file is part of the GNU ISO C++ Library. This library is free
+ // software; you can redistribute it and/or modify it under the
+@@ -46,12 +46,18 @@ void verify_return_type(T, T)
+
+ void test01()
+ {
++ test_type* null_tt = 0;
++ const test_type* null_ttc = 0;
+ int zero;
+
+ std::reference_wrapper<double (int)>* pr1(0);
+ verify_return_type((*pr1)(0), double());
+ std::reference_wrapper<double (*)(int)>* pr2(0);
+ verify_return_type((*pr2)(0), double());
++ std::reference_wrapper<int (test_type::*)()>* pr3(0);
++ verify_return_type((*pr3)(null_tt), int());
++ std::reference_wrapper<int (test_type::*)()const>* pr4(0);
++ verify_return_type((*pr4)(null_ttc), int());
+ std::reference_wrapper<functor1>* pr5(0);
+
+ // libstdc++/24803
+@@ -62,6 +68,10 @@ void test01()
+ verify_return_type((*pr1b)(0, 0), double());
+ std::reference_wrapper<double (*)(int, char)>* pr2b(0);
+ verify_return_type((*pr2b)(0, 0), double());
++ std::reference_wrapper<int (test_type::*)(char)>* pr3b(0);
++ verify_return_type((*pr3b)(null_tt,zero), int());
++ std::reference_wrapper<int (test_type::*)()const>* pr4b(0);
++ verify_return_type((*pr4b)(null_ttc), int());
+ std::reference_wrapper<functor2>* pr5b(0);
+
+ // libstdc++/24803
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc
+new file mode 100644
+index 0000000..bd9aeb2
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc
+@@ -0,0 +1,47 @@
++// { dg-options "-std=gnu++0x" }
++// { dg-do compile}
++// Copyright (C) 2011 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 2, or (at your option)
++// any later version.
++//
++// This library is distributed in the hope that it will be useful,
++// but WITHOUT ANY WARRANTY; without even the implied warranty of
++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING. If not, write to the Free
++// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
++// USA.
++
++// 20.6.4 function object return types [func.ret]
++#include <functional>
++
++struct X
++{
++ int f(int) { return 0; }
++ int i;
++};
++
++void test01()
++{
++ typedef int (X::*mfp)(int);
++ typedef int X::*mp;
++ mfp m = &X::f;
++ mp m2 = &X::i;
++ X x = { };
++ std::ref(m)(x, 1);
++ std::ref(m)(&x, 1);
++ int& i1 = std::ref(m2)(x);
++ int& i2 = std::ref(m2)(&x);
++}
++
++int main()
++{
++ test01();
++ return 0;
++}
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc
+index b371f1c..7b694c7 100644
+--- a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc
+@@ -1,6 +1,6 @@
+ // { dg-options "-std=gnu++0x" }
+
+-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
++// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ //
+ // This file is part of the GNU ISO C++ Library. This library is free
+ // software; you can redistribute it and/or modify it under the
+@@ -36,6 +36,7 @@ struct X
+ int foo_c(float x) const { return truncate_float(x); }
+ int foo_v(float x) volatile { return truncate_float(x); }
+ int foo_cv(float x) const volatile { return truncate_float(x); }
++ int foo_varargs(float x, ...) { return truncate_float(x); }
+
+ int operator()(float x)
+ {
+@@ -69,6 +70,13 @@ void test01()
+
+ ::get_seventeen get_sev;
+ ::X x;
++ ::X* xp = &x;
++ int (::X::* p_foo)(float) = &::X::foo;
++ int (::X::* p_foo_c)(float) const = &::X::foo_c;
++ int (::X::* p_foo_v)(float) volatile = &::X::foo_v;
++ int (::X::* p_foo_cv)(float) const volatile = &::X::foo_cv;
++ int (::X::* p_foo_varargs)(float, ...) = &::X::foo_varargs;
++ int ::X::* p_bar = &::X::bar;
+
+ const float pi = 3.14;
+
+@@ -77,8 +85,26 @@ void test01()
+ VERIFY(ref(seventeen)() == 17);
+
+ // Function pointers
+- VERIFY(cref(&truncate_float)(pi) == 3);
+- VERIFY(cref(&seventeen)() == 17);
++ VERIFY(cref(truncate_float)(pi) == 3);
++ VERIFY(cref(seventeen)() == 17);
++
++ // Member function pointers
++ VERIFY(ref(p_foo)(x, pi) == 3);
++ VERIFY(ref(p_foo)(xp, pi) == 3);
++ VERIFY(ref(p_foo_c)(x, pi) == 3);
++ VERIFY(ref(p_foo_c)(xp, pi) == 3);
++ VERIFY(ref(p_foo_v)(x, pi) == 3);
++ VERIFY(ref(p_foo_v)(xp, pi) == 3);
++ VERIFY(ref(p_foo_cv)(x, pi) == 3);
++ VERIFY(ref(p_foo_cv)(xp, pi) == 3);
++ // VERIFY(ref(p_foo_varargs)(x, pi) == 3);
++ // VERIFY(ref(p_foo_varargs)(xp, pi, 1, 1) == 3);
++ // VERIFY(ref(p_foo_varargs)(x, pi, 1, 1) == 3);
++ // VERIFY(ref(p_foo_varargs)(xp, pi) == 3);
++
++ // Member data pointers
++ VERIFY(ref(p_bar)(x) == 17);
++ VERIFY(ref(p_bar)(xp) == 17);
+
+ // Function objects
+ VERIFY(ref(get_sev)() == 17);
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/ref_neg.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/ref_neg.cc
+new file mode 100644
+index 0000000..947a9b0
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/ref_neg.cc
+@@ -0,0 +1,44 @@
++// Copyright (C) 2011 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, or (at your option)
++// any later version.
++
++// This library is distributed in the hope that it will be useful,
++// but WITHOUT ANY WARRANTY; without even the implied warranty of
++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++// GNU General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// 20.8.3 Class template reference_wrapper
++
++// { dg-do compile }
++// { dg-options "-std=gnu++0x" }
++
++#include <functional>
++
++struct X { };
++X rval();
++X&& rvalref();
++
++void test01()
++{
++ std::ref(1); // { dg-error "deleted" }
++ std::cref(1); // { dg-error "deleted" }
++ std::ref( int() ); // { dg-error "deleted" }
++ std::cref( int() ); // { dg-error "deleted" }
++ std::ref(rval()); // { dg-error "deleted" }
++ std::cref(rvalref()); // { dg-error "deleted" }
++}
++
++int main()
++{
++ test02();
++}
++
++// { dg-excess-errors "" }
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs-3.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs-3.cc
+new file mode 100644
+index 0000000..2fea52e
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs-3.cc
+@@ -0,0 +1,148 @@
++// { dg-options "-std=gnu++0x" }
++// { dg-do compile }
++
++// Copyright (C) 2011 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, or (at your option)
++// any later version.
++//
++// This library is distributed in the hope that it will be useful,
++// but WITHOUT ANY WARRANTY; without even the implied warranty of
++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++#include <functional>
++#include <type_traits>
++
++struct S { };
++
++struct S0
++{
++ typedef int argument_type;
++};
++
++struct S1
++{
++ typedef float first_argument_type;
++};
++
++struct S2
++{
++ typedef char second_argument_type;
++};
++
++struct S01 : S0, S1 { };
++struct S02 : S0, S2 { };
++struct S12 : S1, S2 { };
++
++struct S012 : S0, S1, S2 { };
++
++using std::__sfinae_types;
++using std::integral_constant;
++using std::remove_cv;
++
++_GLIBCXX_HAS_NESTED_TYPE(argument_type)
++_GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
++_GLIBCXX_HAS_NESTED_TYPE(second_argument_type)
++
++template<typename T>
++ struct has_arg_type : __has_argument_type<T>
++ { };
++
++template<typename T>
++ struct has_1st_arg_type : __has_first_argument_type<T>
++ { };
++
++template<typename T>
++ struct has_2nd_arg_type : __has_second_argument_type<T>
++ { };
++
++template<typename T, bool = has_arg_type<T>::value>
++struct test_arg_type
++{
++ static_assert( !has_arg_type<std::reference_wrapper<T>>::value,
++ "reference_wrapper has no nested argument_type");
++};
++
++template<typename T>
++struct test_arg_type<T, true>
++{
++ typedef std::reference_wrapper<T> ref;
++
++ static_assert( has_arg_type<ref>::value,
++ "reference_wrapper has nested argument_type");
++
++ static_assert(
++ std::is_same< typename T::argument_type,
++ typename ref::argument_type >::value,
++ "reference_wrapper has the correct argument_type");
++};
++
++template<typename T,
++ bool = has_1st_arg_type<T>::value && has_2nd_arg_type<T>::value>
++struct test_1st_2nd_arg_types
++{
++ typedef std::reference_wrapper<T> ref;
++
++ static_assert( !has_1st_arg_type<ref>::value,
++ "reference_wrapper has no nested first_argument_type");
++
++ static_assert( !has_2nd_arg_type<ref>::value,
++ "reference_wrapper has no nested second_argument_type");
++};
++
++template<typename T>
++struct test_1st_2nd_arg_types<T, true>
++{
++ typedef std::reference_wrapper<T> ref;
++
++ static_assert( has_1st_arg_type<ref>::value,
++ "reference_wrapper has nested first_argument_type");
++
++ static_assert( has_2nd_arg_type<ref>::value,
++ "reference_wrapper has nested second_argument_type");
++
++ static_assert(
++ std::is_same< typename T::first_argument_type,
++ typename ref::first_argument_type>::value,
++ "reference_wrapper has correct first_argument_type");
++
++ static_assert(
++ std::is_same< typename T::second_argument_type,
++ typename ref::second_argument_type>::value,
++ "reference_wrapper has correct second_argument_type");
++};
++
++
++template<typename T>
++ void test()
++ {
++ test_arg_type<T> t;
++ test_arg_type<const T> tc;
++ test_arg_type<volatile T> tv;
++ test_arg_type<const volatile T> tcv;
++ test_1st_2nd_arg_types<T> t12;
++ test_1st_2nd_arg_types<const T> t12c;
++ test_1st_2nd_arg_types<volatile T> t12v;
++ test_1st_2nd_arg_types<const volatile T> t12cv;
++ }
++
++int main()
++{
++ test<S>();
++ test<S0>();
++ test<S1>();
++ test<S2>();
++ test<S01>();
++ test<S02>();
++ test<S12>();
++ test<S012>();
++}
++
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc
+index 56ee29e..815700f 100644
+--- a/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc
+@@ -1,6 +1,7 @@
++// { dg-do compile }
+ // { dg-options "-std=gnu++0x" }
+
+-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
++// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ //
+ // This file is part of the GNU ISO C++ Library. This library is free
+ // software; you can redistribute it and/or modify it under the
+@@ -19,10 +20,6 @@
+
+ #include <functional>
+ #include <type_traits>
+-#include <testsuite_hooks.h>
+-#include <testsuite_tr1.h>
+-
+-using namespace __gnu_test;
+
+ struct X {};
+
+@@ -41,43 +38,18 @@ struct derives_unary_binary
+
+ void test01()
+ {
+- bool test __attribute__((unused)) = true;
+-
+ using std::reference_wrapper;
+ using std::is_same;
+- using std::is_convertible;
+- using std::unary_function;
+- using std::binary_function;
+
+ // Check result_type typedef
+- VERIFY((is_same<reference_wrapper<int_result_type>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<derives_unary>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<derives_binary>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<derives_unary_binary>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<int(void)>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<int(*)(void)>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<int (::X::*)()>::result_type, int>::value));
+- VERIFY((is_same<reference_wrapper<int (::X::*)(float)>::result_type, int>::value));
+-
+- // Check derivation from unary_function
+- VERIFY((is_convertible<reference_wrapper<derives_unary>*, unary_function<int, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<derives_unary_binary>*, unary_function<int, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int(int)>*, unary_function<int, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int(*)(int)>*, unary_function<int, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)()>*, unary_function< ::X*, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)() const>*, unary_function<const ::X*, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)() volatile>*, unary_function<volatile ::X*, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)() const volatile>*, unary_function<const volatile ::X*, int>*>::value));
+-
+- // Check derivation from binary_function
+- VERIFY((is_convertible<reference_wrapper<derives_binary>*, binary_function<int, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<derives_unary_binary>*, binary_function<int, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int(int, float)>*, binary_function<int, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int(*)(int, float)>*, binary_function<int, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)(float)>*, binary_function< ::X*, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) const>*, binary_function<const ::X*, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) volatile>*, binary_function<volatile ::X*, float, int>*>::value));
+- VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) const volatile>*, binary_function<const volatile ::X*, float, int>*>::value));
++ static_assert( is_same<reference_wrapper<int_result_type>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<derives_unary>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<derives_binary>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<derives_unary_binary>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<int(void)>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<int(*)(void)>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<int (::X::*)()>::result_type, int>::value, "has result_type" );
++ static_assert( is_same<reference_wrapper<int (::X::*)(float)>::result_type, int>::value, "has result_type" );
+ }
+
+ int main()
+--
+1.7.0.4
+
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-06-25 14:28:19 +0000