|
111
|
1 // PR c++/47416
|
|
|
2 // { dg-do compile { target c++11 } }
|
|
131
|
3 // { dg-additional-options "-Wno-return-type" }
|
|
111
|
4
|
|
|
5 namespace std
|
|
|
6 {
|
|
|
7 template < typename _Tp, _Tp __v > struct integral_constant
|
|
|
8 {
|
|
|
9 static const _Tp value = __v;
|
|
|
10 };
|
|
|
11 typedef integral_constant < bool, false > false_type;
|
|
|
12 template < typename > struct is_array:false_type
|
|
|
13 {
|
|
|
14 };
|
|
|
15 template < typename > struct is_function:false_type
|
|
|
16 {
|
|
|
17 };
|
|
|
18 template < typename _Tp > struct remove_const
|
|
|
19 {
|
|
|
20 typedef _Tp type;
|
|
|
21 };
|
|
|
22 template < typename _Tp > struct remove_volatile
|
|
|
23 {
|
|
|
24 typedef _Tp type;
|
|
|
25 };
|
|
|
26 template < typename _Tp > struct remove_cv
|
|
|
27 {
|
|
|
28 typedef typename remove_const < typename remove_volatile <
|
|
|
29 _Tp >::type >::type type;
|
|
|
30 };
|
|
|
31 template < typename > struct remove_reference
|
|
|
32 {
|
|
|
33 };
|
|
|
34 template < typename _Tp > struct remove_reference <_Tp & >
|
|
|
35 {
|
|
|
36 typedef _Tp type;
|
|
|
37 };
|
|
|
38 template < typename _Up, bool = is_array < _Up >::value, bool =
|
|
|
39 is_function < _Up >::value > struct __decay_selector;
|
|
|
40 template < typename _Up > struct __decay_selector <_Up, false, false >
|
|
|
41 {
|
|
|
42 typedef typename remove_cv < _Up >::type __type;
|
|
|
43 };
|
|
|
44 template < typename _Tp > class decay
|
|
|
45 {
|
|
|
46 typedef typename remove_reference < _Tp >::type __remove_type;
|
|
|
47 public:typedef typename __decay_selector <
|
|
|
48 __remove_type >::__type type;
|
|
|
49 };
|
|
|
50 template < typename _Tp > struct __strip_reference_wrapper
|
|
|
51 {
|
|
|
52 typedef _Tp __type;
|
|
|
53 };
|
|
|
54 template < typename _Tp > struct __decay_and_strip
|
|
|
55 {
|
|
|
56 typedef typename __strip_reference_wrapper < typename decay <
|
|
|
57 _Tp >::type >::__type __type;
|
|
|
58 };
|
|
|
59 template < typename _Tp > _Tp forward (typename remove_reference <
|
|
|
60 _Tp >::type &)
|
|
|
61 {
|
|
|
62 }
|
|
|
63 template < class _T1, class _T2 > struct pair
|
|
|
64 {
|
|
|
65 _T1 first;
|
|
|
66 _T2 second;
|
|
|
67 constexpr pair (_T1, _T2 &):first (), second (__b) // { dg-error "was not declared in this scope" }
|
|
|
68 {
|
|
|
69 }
|
|
|
70 };
|
|
|
71 template < class _T1,
|
|
|
72 class _T2 > pair < typename __decay_and_strip < _T1 >::__type,
|
|
|
73 typename __decay_and_strip < _T2 >::__type > make_pair (_T1 && __x, _T2
|
|
|
74 && __y)
|
|
|
75 {
|
|
|
76 typedef typename __decay_and_strip < _T1 >::__type __ds_type1;
|
|
|
77 typedef typename __decay_and_strip < _T2 >::__type __ds_type2;
|
|
|
78 typedef pair < __ds_type1, __ds_type2 > __pair_type;
|
|
|
79 __pair_type (forward < _T1 > (__x), std::forward < _T2 > (__y));
|
|
|
80 }
|
|
|
81 }
|
|
|
82
|
|
|
83 typedef long size_t;
|
|
|
84 namespace std
|
|
|
85 {
|
|
|
86 template < typename > class allocator;
|
|
|
87 template < class > struct char_traits;
|
|
|
88 template < typename _CharT, typename = char_traits < _CharT >, typename =
|
|
|
89 allocator < _CharT > >class basic_string;
|
|
|
90 typedef basic_string < char >string;
|
|
|
91 }
|
|
|
92 namespace __gnu_cxx
|
|
|
93 {
|
|
|
94 template < bool > class __pool;
|
|
|
95 template < template < bool > class, bool > struct __common_pool
|
|
|
96 {
|
|
|
97 };
|
|
|
98 template < template < bool > class, bool > struct __common_pool_base;
|
|
|
99 template < template < bool > class _PoolTp >
|
|
|
100 struct __common_pool_base <_PoolTp, true >:__common_pool < _PoolTp, true >
|
|
|
101 {
|
|
|
102 };
|
|
|
103 template < template < bool > class _PoolTp,
|
|
|
104 bool _Thread > struct __common_pool_policy:__common_pool_base < _PoolTp,
|
|
|
105 _Thread >
|
|
|
106 {
|
|
|
107 template < typename, template < bool > class _PoolTp1 =
|
|
|
108 _PoolTp, bool _Thread1 = _Thread > struct _M_rebind
|
|
|
109 {
|
|
|
110 typedef __common_pool_policy < _PoolTp1, _Thread1 > other;
|
|
|
111 };
|
|
|
112 };
|
|
|
113 template < typename _Tp > class __mt_alloc_base
|
|
|
114 {
|
|
|
115 };
|
|
|
116 template < typename _Tp, typename _Poolp = __common_pool_policy < __pool, true > >class __mt_alloc:public __mt_alloc_base <
|
|
|
117 _Tp
|
|
|
118 >
|
|
|
119 {
|
|
|
120 public:size_t size_type;
|
|
|
121 typedef _Tp value_type;
|
|
|
122 template < typename _Tp1, typename _Poolp1 = _Poolp > struct rebind
|
|
|
123 {
|
|
|
124 typedef typename _Poolp1::template _M_rebind < _Tp1 >::other pol_type;
|
|
|
125 typedef __mt_alloc < _Tp1, pol_type > other;
|
|
|
126 };
|
|
|
127 };
|
|
|
128 }
|
|
|
129
|
|
|
130 namespace std
|
|
|
131 {
|
|
|
132 template < typename _Tp > class allocator:public __gnu_cxx::__mt_alloc <
|
|
|
133 _Tp >
|
|
|
134 {
|
|
|
135 };
|
|
|
136 template < typename, typename > struct unary_function
|
|
|
137 {
|
|
|
138 };
|
|
|
139 template < typename, typename, typename > struct binary_function
|
|
|
140 {
|
|
|
141 };
|
|
|
142 template < typename _Tp > struct equal_to:binary_function < _Tp, _Tp, bool >
|
|
|
143 {
|
|
|
144 };
|
|
|
145 }
|
|
|
146
|
|
|
147 namespace boost
|
|
|
148 {
|
|
|
149 template < class > struct hash;
|
|
|
150 template < class K, class T, class = hash < K >, class =
|
|
|
151 std::equal_to < K >, class =
|
|
|
152 std::allocator < std::pair < const K, T > >>class unordered_map;
|
|
|
153 template < >struct hash <std::string >:std::unary_function < std::string,
|
|
|
154 size_t >
|
|
|
155 {
|
|
|
156 };
|
|
|
157 namespace unordered_detail
|
|
|
158 {
|
|
|
159 template < class Alloc, class T > struct rebind_wrap
|
|
|
160 {
|
|
|
161 typedef typename Alloc::template rebind < T >::other type;
|
|
|
162 };
|
|
|
163 }
|
|
|
164 namespace unordered_detail
|
|
|
165 {
|
|
|
166 size_t default_bucket_count;
|
|
|
167 template < class, class > struct map_extractor;
|
|
|
168 struct ungrouped
|
|
|
169 {
|
|
|
170 };
|
|
|
171 template < class T > class hash_table:T::buckets, T::buffered_functions
|
|
|
172 {
|
|
|
173 };
|
|
|
174 template < class, class, class H, class P, class A, class, class G > struct types
|
|
|
175 {
|
|
|
176 typedef H hasher;
|
|
|
177 typedef P key_equal;
|
|
|
178 typedef A value_allocator;
|
|
|
179 };
|
|
|
180 template < class T > class hash_unique_table:T
|
|
|
181 {
|
|
|
182 public:typedef typename T::hasher hasher;
|
|
|
183 typedef typename T::key_equal key_equal;
|
|
|
184 typedef typename T::value_allocator value_allocator;
|
|
|
185 typedef typename T::table table;
|
|
|
186 hash_unique_table (size_t n, hasher, key_equal,
|
|
|
187 value_allocator & a):table (n, a) // { dg-error "is not a direct base" }
|
|
|
188 {
|
|
|
189 }
|
|
|
190 };
|
|
|
191 template < class K, class H, class P, class A > struct map:types < K,
|
|
|
192 typename A::value_type, H, P, A, map_extractor < K,
|
|
|
193 typename A::value_type >, ungrouped >
|
|
|
194 {
|
|
|
195 typedef hash_unique_table < map < K, H, P, A > >impl;
|
|
|
196 typedef hash_table < map < K, H, P, A > >table;
|
|
|
197 };
|
|
|
198 }
|
|
|
199 template < class K, class T, class H, class P, class A > class unordered_map
|
|
|
200 {
|
|
|
201 typedef std::pair < const K, T > value_type;
|
|
|
202 typedef H hasher;
|
|
|
203 typedef P key_equal;
|
|
|
204 typedef A allocator_type;
|
|
|
205 typedef typename unordered_detail::rebind_wrap < allocator_type,
|
|
|
206 value_type >::type value_allocator;
|
|
|
207 typedef boost::unordered_detail::map < K, H, P, value_allocator > types;
|
|
|
208 typedef typename types::impl table;
|
|
|
209 typedef size_t size_type;
|
|
|
210 private:table table_;
|
|
|
211 public: unordered_map (size_type n = boost::unordered_detail::default_bucket_count,
|
|
|
212 hasher hf = hasher (), key_equal eql = key_equal (),
|
|
|
213 allocator_type a = allocator_type ()):table_ (n, hf, eql, a) // { dg-message "required" }
|
|
|
214 {
|
|
|
215 }
|
|
|
216 };
|
|
|
217 }
|
|
|
218
|
|
|
219 void
|
|
|
220 foo (const int &a)
|
|
|
221 {
|
|
|
222 typedef boost::unordered_map < std::string, int >Name2Port;
|
|
|
223 Name2Port b; // { dg-message "required" }
|
|
|
224 std::make_pair (a, b);
|
|
|
225 }
|
