gcc/testsuite/g++.dg/cpp0x/pr47416.C

   1 // PR c++/47416
   2 // { dg-do compile }
   3 // { dg-options "-std=c++0x" }
   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 "instantiated" }
 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 "instantiated" }
 224   std::make_pair (a, b);
 225 }