gcc/testsuite/g++.dg/torture/pr64312.C

   1 // { dg-do compile }
   2
   3 template <typename C> struct A
   4 {
   5   typedef typename C::iterator type;
   6 };
   7 template <typename T2> struct B
   8 {
   9   typedef T2 type;
  10 };
  11 template <typename F2> struct L
  12 {
  13   typedef typename B<F2>::type::type type;
  14 };
  15 template <typename C> struct M
  16 {
  17   typedef typename L<A<C> >::type type;
  18 };
  19 class C
  20 {
  21 public:
  22   typedef int iterator;
  23 };
  24 template <class IteratorT> class D
  25 {
  26 public:
  27   typedef IteratorT iterator;
  28   template <class Iterator> D (Iterator p1, Iterator) : m_Begin (p1), m_End (0)
  29   {
  30   }
  31   IteratorT m_Begin;
  32   IteratorT m_End;
  33 };
  34 template <class IteratorT> class I : public D<IteratorT>
  35 {
  36 protected:
  37   template <class Iterator>
  38   I (Iterator p1, Iterator p2)
  39       : D<IteratorT> (p1, p2)
  40   {
  41   }
  42 };
  43 class F
  44 {
  45 public:
  46   int elems[];
  47   int *
  48   m_fn1 ()
  49   {
  50     return elems;
  51   }
  52 };
  53 class G
  54 {
  55 public:
  56   void *
  57   m_fn2 (int)
  58   {
  59     return m_buffer.m_fn1 ();
  60   }
  61   F m_buffer;
  62 };
  63 struct any_incrementable_iterator_interface
  64 {
  65   virtual ~any_incrementable_iterator_interface () {}
  66 };
  67 class J : public any_incrementable_iterator_interface
  68 {
  69 public:
  70   J (int) : m_it () {}
  71   int m_it;
  72 };
  73 void *operator new(__SIZE_TYPE__, void *p2) { return p2; }
  74 template <class T> typename M<T>::type begin (T) { return 0; }
  75 template <class T> typename M<T>::type end (T) {}
  76 template <class> class any_iterator
  77 {
  78 public:
  79   template <class WrappedIterator> any_iterator (WrappedIterator)
  80   {
  81     void *ptr = m_buffer.m_fn2 (0);
  82     m_impl = new (ptr) J (0);
  83   }
  84   ~any_iterator ()
  85   {
  86     if (m_impl)
  87       m_impl->~any_incrementable_iterator_interface ();
  88   }
  89   G m_buffer;
  90   any_incrementable_iterator_interface *m_impl;
  91 };
  92 template <class Reference> class K : public I<any_iterator<Reference> >
  93 {
  94 public:
  95   template <class WrappedRange>
  96   K (WrappedRange p1)
  97       : I<any_iterator<Reference> > (begin (p1), end (p1))
  98   {
  99   }
 100 };
 101 template <class Reference> struct H
 102 {
 103   typedef K<Reference> type;
 104 };
 105 template <class, class, class, class, class, class TargetReference>
 106 void
 107 mix_values_impl ()
 108 {
 109   C test_data;
 110   H<int>::type source_data (test_data);
 111   typename H<TargetReference>::type t2 = source_data;
 112 }
 113 template <class>
 114 void
 115 mix_values_driver ()
 116 {
 117   mix_values_impl<int, int, int, int, int, int &> ();
 118 }
 119 void
 120 mix_values ()
 121 {
 122   mix_values_driver<int> ();
 123 }