clang/test/SemaTemplate/current-instantiation.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2
   3 // This test concerns the identity of dependent types within the
   4 // canonical type system, specifically focusing on the difference
   5 // between members of the current instantiation and members of an
   6 // unknown specialization. This considers C++ [temp.type], which
   7 // specifies type equivalence within a template, and C++0x
   8 // [temp.dep.type], which defines what it means to be a member of the
   9 // current instantiation.
  10
  11 template<typename T, typename U>
  12 struct X0 {
  13   typedef T T_type;
  14   typedef U U_type;
  15
  16   void f0(T&); // expected-note{{previous}}
  17   void f0(typename X0::U_type&);
  18   void f0(typename X0::T_type&); // expected-error{{redecl}}
  19
  20   void f1(T&); // expected-note{{previous}}
  21   void f1(typename X0::U_type&);
  22   void f1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
  23
  24   void f2(T&); // expected-note{{previous}}
  25   void f2(typename X0::U_type&);
  26   void f2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
  27
  28   void f3(T&); // expected-note{{previous}}
  29   void f3(typename X0::U_type&);
  30   void f3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
  31
  32   struct X1 {
  33     typedef T my_T_type;
  34
  35     void g0(T&); // expected-note{{previous}}
  36     void g0(typename X0::U_type&);
  37     void g0(typename X0::T_type&); // expected-error{{redecl}}
  38
  39     void g1(T&); // expected-note{{previous}}
  40     void g1(typename X0::U_type&);
  41     void g1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
  42
  43     void g2(T&); // expected-note{{previous}}
  44     void g2(typename X0::U_type&);
  45     void g2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
  46
  47     void g3(T&); // expected-note{{previous}}
  48     void g3(typename X0::U_type&);
  49     void g3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
  50
  51     void g4(T&); // expected-note{{previous}}
  52     void g4(typename X0::U_type&);
  53     void g4(typename X1::my_T_type&); // expected-error{{redecl}}
  54
  55     void g5(T&); // expected-note{{previous}}
  56     void g5(typename X0::U_type&);
  57     void g5(typename X0::X1::my_T_type&); // expected-error{{redecl}}
  58
  59     void g6(T&); // expected-note{{previous}}
  60     void g6(typename X0::U_type&);
  61     void g6(typename X0<T, U>::X1::my_T_type&); // expected-error{{redecl}}
  62
  63     void g7(T&); // expected-note{{previous}}
  64     void g7(typename X0::U_type&);
  65     void g7(typename ::X0<typename X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
  66
  67     void g8(T&); // expected-note{{previous}}
  68     void g8(typename X0<U, T_type>::T_type&);
  69     void g8(typename ::X0<typename X0<T_type, U>::X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
  70   };
  71 };
  72
  73
  74 template<typename T, typename U>
  75 struct X0<T*, U*> {
  76   typedef T T_type;
  77   typedef U U_type;
  78   typedef T* Tptr;
  79   typedef U* Uptr;
  80
  81   void f0(T&); // expected-note{{previous}}
  82   void f0(typename X0::U_type&);
  83   void f0(typename X0::T_type&); // expected-error{{redecl}}
  84
  85   void f1(T&); // expected-note{{previous}}
  86   void f1(typename X0::U_type&);
  87   void f1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
  88
  89   void f2(T&); // expected-note{{previous}}
  90   void f2(typename X0::U_type&);
  91   void f2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
  92
  93   void f3(T&); // expected-note{{previous}}
  94   void f3(typename X0::U_type&);
  95   void f3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
  96
  97   void f4(T&); // expected-note{{previous}}
  98   void f4(typename X0::U_type&);
  99   void f4(typename ::X0<Tptr, Uptr>::T_type&); // expected-error{{redecl}}
 100
 101   void f5(X0*); // expected-note{{previous}}
 102   void f5(::X0<T, U>*);
 103   void f5(::X0<T*, U*>*); // expected-error{{redecl}}
 104
 105   struct X2 {
 106     typedef T my_T_type;
 107
 108     void g0(T&); // expected-note{{previous}}
 109     void g0(typename X0::U_type&);
 110     void g0(typename X0::T_type&); // expected-error{{redecl}}
 111
 112     void g1(T&); // expected-note{{previous}}
 113     void g1(typename X0::U_type&);
 114     void g1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
 115
 116     void g2(T&); // expected-note{{previous}}
 117     void g2(typename X0::U_type&);
 118     void g2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
 119
 120     void g3(T&); // expected-note{{previous}}
 121     void g3(typename X0::U_type&);
 122     void g3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
 123
 124     void g4(T&); // expected-note{{previous}}
 125     void g4(typename X0::U_type&);
 126     void g4(typename X2::my_T_type&); // expected-error{{redecl}}
 127
 128     void g5(T&); // expected-note{{previous}}
 129     void g5(typename X0::U_type&);
 130     void g5(typename X0::X2::my_T_type&); // expected-error{{redecl}}
 131
 132     void g6(T&); // expected-note{{previous}}
 133     void g6(typename X0::U_type&);
 134     void g6(typename X0<T*, U*>::X2::my_T_type&); // expected-error{{redecl}}
 135
 136     void g7(T&); // expected-note{{previous}}
 137     void g7(typename X0::U_type&);
 138     void g7(typename ::X0<typename X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
 139
 140     void g8(T&); // expected-note{{previous}}
 141     void g8(typename X0<U, T_type>::T_type&);
 142     void g8(typename ::X0<typename X0<T_type*, U*>::X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
 143   };
 144 };
 145
 146 template<typename T>
 147 struct X1 {
 148   static int *a;
 149   void f(float *b) {
 150     X1<T>::a = b; // expected-error{{incompatible}}
 151     X1<T*>::a = b;
 152   }
 153 };
 154
 155 namespace ConstantInCurrentInstantiation {
 156   template<typename T>
 157   struct X {
 158     static const int value = 2;
 159     static int array[value];
 160   };
 161
 162   template<typename T> const int X<T>::value;
 163
 164   template<typename T>
 165   int X<T>::array[X<T>::value] = { 1, 2 };
 166 }
 167
 168 namespace Expressions {
 169   template <bool b>
 170   struct Bool {
 171     enum anonymous_enum { value = b };
 172   };
 173   struct True : public Bool<true> {};
 174   struct False : public Bool<false> {};
 175
 176   template <typename T1, typename T2>
 177   struct Is_Same : public False {};
 178   template <typename T>
 179   struct Is_Same<T, T> : public True {};
 180
 181   template <bool b, typename T = void>
 182   struct Enable_If {};
 183   template <typename T>
 184   struct Enable_If<true, T>  {
 185     typedef T type;
 186   };
 187
 188   template <typename T>
 189   class Class {
 190   public:
 191     template <typename U>
 192     typename Enable_If<Is_Same<U, Class>::value, void>::type
 193     foo();
 194   };
 195
 196
 197   template <typename T>
 198   template <typename U>
 199   typename Enable_If<Is_Same<U, Class<T> >::value, void>::type
 200   Class<T>::foo() {}
 201 }
 202
 203 namespace PR9255 {
 204   template<typename T>
 205   class X0  {
 206   public:
 207     class Inner1;
 208
 209     class Inner2  {
 210     public:
 211       void f()
 212       {
 213         Inner1::f.g();
 214       }
 215     };
 216   };
 217 }
 218
 219 namespace rdar10194295 {
 220   template<typename XT>
 221   class X {
 222   public:
 223     enum Enum { Yes, No };
 224     template<Enum> void foo();
 225     template<Enum> class Inner;
 226   };
 227
 228   template<typename XT>
 229   template<typename X<XT>::Enum>
 230   void X<XT>::foo()
 231   {
 232   }
 233
 234   template<typename XT>
 235   template<typename X<XT>::Enum>
 236   class X<XT>::Inner { };
 237 }
 238
 239 namespace RebuildDependentScopeDeclRefExpr {
 240   template<int> struct N {};
 241   template<typename T> struct X {
 242     static const int thing = 0;
 243     N<thing> data();
 244     N<thing> foo();
 245   };
 246   template<typename T> N<X<T>::thing> X<T>::data() {}
 247   // FIXME: We should issue a typo-correction here.
 248   template<typename T> N<X<T>::think> X<T>::foo() {} // expected-error {{no member named 'think' in 'X<T>'}}
 249 }