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