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