From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001
From: upstream source tree <ports@midipix.org>
Date: Sun, 15 Mar 2015 20:14:05 -0400
Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified
 gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream
 tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
---
 gcc/testsuite/g++.dg/cpp0x/pr47416.C | 225 +++++++++++++++++++++++++++++++++++
 1 file changed, 225 insertions(+)
 create mode 100644 gcc/testsuite/g++.dg/cpp0x/pr47416.C

(limited to 'gcc/testsuite/g++.dg/cpp0x/pr47416.C')

diff --git a/gcc/testsuite/g++.dg/cpp0x/pr47416.C b/gcc/testsuite/g++.dg/cpp0x/pr47416.C
new file mode 100644
index 000000000..a11368a50
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/pr47416.C
@@ -0,0 +1,225 @@
+// PR c++/47416
+// { dg-do compile }
+// { dg-options "-std=c++0x" }
+
+namespace std
+{
+  template < typename _Tp, _Tp __v > struct integral_constant
+  {
+    static const _Tp value = __v;
+  };
+  typedef integral_constant < bool, false > false_type;
+    template < typename > struct is_array:false_type
+  {
+  };
+    template < typename > struct is_function:false_type
+  {
+  };
+    template < typename _Tp > struct remove_const
+  {
+    typedef _Tp type;
+  };
+    template < typename _Tp > struct remove_volatile
+  {
+    typedef _Tp type;
+  };
+    template < typename _Tp > struct remove_cv
+  {
+    typedef typename remove_const < typename remove_volatile <
+      _Tp >::type >::type type;
+  };
+    template < typename > struct remove_reference
+  {
+  };
+    template < typename _Tp > struct remove_reference <_Tp & >
+  {
+    typedef _Tp type;
+  };
+    template < typename _Up, bool = is_array < _Up >::value, bool =
+    is_function < _Up >::value > struct __decay_selector;
+    template < typename _Up > struct __decay_selector <_Up, false, false >
+  {
+    typedef typename remove_cv < _Up >::type __type;
+  };
+    template < typename _Tp > class decay
+  {
+    typedef typename remove_reference < _Tp >::type __remove_type;
+  public:typedef typename __decay_selector <
+      __remove_type >::__type type;
+  };
+  template < typename _Tp > struct __strip_reference_wrapper
+  {
+    typedef _Tp __type;
+  };
+  template < typename _Tp > struct __decay_and_strip
+  {
+    typedef typename __strip_reference_wrapper < typename decay <
+      _Tp >::type >::__type __type;
+  };
+  template < typename _Tp > _Tp forward (typename remove_reference <
+					 _Tp >::type &)
+  {
+  }
+  template < class _T1, class _T2 > struct pair
+  {
+    _T1 first;
+    _T2 second;
+    constexpr pair (_T1, _T2 &):first (), second (__b)	// { dg-error "was not declared in this scope" }
+    {
+    }
+  };
+  template < class _T1,
+    class _T2 > pair < typename __decay_and_strip < _T1 >::__type,
+    typename __decay_and_strip < _T2 >::__type > make_pair (_T1 && __x, _T2
+							    && __y)
+  {
+    typedef typename __decay_and_strip < _T1 >::__type __ds_type1;
+    typedef typename __decay_and_strip < _T2 >::__type __ds_type2;
+    typedef pair < __ds_type1, __ds_type2 > __pair_type;
+    __pair_type (forward < _T1 > (__x), std::forward < _T2 > (__y));
+  }
+}
+
+typedef long size_t;
+namespace std
+{
+  template < typename > class allocator;
+  template < class > struct char_traits;
+    template < typename _CharT, typename = char_traits < _CharT >, typename =
+    allocator < _CharT > >class basic_string;
+  typedef basic_string < char >string;
+}
+namespace __gnu_cxx
+{
+  template < bool > class __pool;
+  template < template < bool > class, bool > struct __common_pool
+  {
+  };
+    template < template < bool > class, bool > struct __common_pool_base;
+    template < template < bool > class _PoolTp >
+    struct __common_pool_base <_PoolTp, true >:__common_pool < _PoolTp, true >
+  {
+  };
+    template < template < bool > class _PoolTp,
+    bool _Thread > struct __common_pool_policy:__common_pool_base < _PoolTp,
+    _Thread >
+  {
+    template < typename, template < bool > class _PoolTp1 =
+      _PoolTp, bool _Thread1 = _Thread > struct _M_rebind
+    {
+      typedef __common_pool_policy < _PoolTp1, _Thread1 > other;
+    };
+  };
+    template < typename _Tp > class __mt_alloc_base
+  {
+  };
+template < typename _Tp, typename _Poolp = __common_pool_policy < __pool, true > >class __mt_alloc:public __mt_alloc_base <
+    _Tp
+    >
+  {
+  public:size_t size_type;
+    typedef _Tp value_type;
+    template < typename _Tp1, typename _Poolp1 = _Poolp > struct rebind
+    {
+      typedef typename _Poolp1::template _M_rebind < _Tp1 >::other pol_type;
+      typedef __mt_alloc < _Tp1, pol_type > other;
+    };
+  };
+}
+
+namespace std
+{
+  template < typename _Tp > class allocator:public __gnu_cxx::__mt_alloc <
+    _Tp >
+  {
+  };
+  template < typename, typename > struct unary_function
+  {
+  };
+  template < typename, typename, typename > struct binary_function
+  {
+  };
+  template < typename _Tp > struct equal_to:binary_function < _Tp, _Tp, bool >
+  {
+  };
+}
+
+namespace boost
+{
+  template < class > struct hash;
+    template < class K, class T, class = hash < K >, class =
+    std::equal_to < K >, class =
+    std::allocator < std::pair < const K, T > >>class unordered_map;
+    template < >struct hash <std::string >:std::unary_function < std::string,
+    size_t >
+  {
+  };
+  namespace unordered_detail
+  {
+    template < class Alloc, class T > struct rebind_wrap
+    {
+      typedef typename Alloc::template rebind < T >::other type;
+    };
+  }
+  namespace unordered_detail
+  {
+    size_t default_bucket_count;
+      template < class, class > struct map_extractor;
+    struct ungrouped
+    {
+    };
+      template < class T > class hash_table:T::buckets, T::buffered_functions
+    {
+    };
+      template < class, class, class H, class P, class A, class, class G > struct types
+    {
+      typedef H hasher;
+      typedef P key_equal;
+      typedef A value_allocator;
+    };
+      template < class T > class hash_unique_table:T
+    {
+    public:typedef typename T::hasher hasher;
+      typedef typename T::key_equal key_equal;
+      typedef typename T::value_allocator value_allocator;
+      typedef typename T::table table;
+        hash_unique_table (size_t n, hasher, key_equal,
+			   value_allocator & a):table (n, a)	// { dg-error "is not a direct base" }
+      {
+      }
+    };
+    template < class K, class H, class P, class A > struct map:types < K,
+      typename A::value_type, H, P, A, map_extractor < K,
+      typename A::value_type >, ungrouped >
+    {
+      typedef hash_unique_table < map < K, H, P, A > >impl;
+      typedef hash_table < map < K, H, P, A > >table;
+    };
+  }
+  template < class K, class T, class H, class P, class A > class unordered_map
+  {
+    typedef std::pair < const K, T > value_type;
+    typedef H hasher;
+    typedef P key_equal;
+    typedef A allocator_type;
+    typedef typename unordered_detail::rebind_wrap < allocator_type,
+      value_type >::type value_allocator;
+    typedef boost::unordered_detail::map < K, H, P, value_allocator > types;
+    typedef typename types::impl table;
+    typedef size_t size_type;
+  private:table table_;
+  public: unordered_map (size_type n = boost::unordered_detail::default_bucket_count,
+			 hasher hf = hasher (), key_equal eql = key_equal (),
+			 allocator_type a = allocator_type ()):table_ (n, hf, eql, a)	// { dg-message "instantiated" }
+    {
+    }
+  };
+};
+
+void
+foo (const int &a)
+{
+  typedef boost::unordered_map < std::string, int >Name2Port;
+  Name2Port b;			// { dg-message "instantiated" }
+  std::make_pair (a, b);
+}
-- 
cgit v1.2.3