clang/test/SemaTemplate/temp_class_spec.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 template<typename T>
   3 struct is_pointer {
   4   static const bool value = false;
   5 };
   6
   7 template<typename T>
   8 struct is_pointer<T*> {
   9   static const bool value = true;
  10 };
  11
  12 template<typename T>
  13 struct is_pointer<const T*> {
  14   static const bool value = true;
  15 };
  16
  17 int array0[is_pointer<int>::value? -1 : 1];
  18 int array1[is_pointer<int*>::value? 1 : -1];
  19 int array2[is_pointer<const int*>::value? 1 : -1];
  20
  21 template<typename T>
  22 struct is_lvalue_reference {
  23   static const bool value = false;
  24 };
  25
  26 template<typename T>
  27 struct is_lvalue_reference<T&> {
  28   static const bool value = true;
  29 };
  30
  31 int lvalue_ref0[is_lvalue_reference<int>::value? -1 : 1];
  32 int lvalue_ref1[is_lvalue_reference<const int&>::value? 1 : -1];
  33
  34 template<typename T>
  35 struct is_const {
  36   static const bool value = false;
  37 };
  38
  39 template<typename T>
  40 struct is_const<const T> {
  41   static const bool value = true;
  42 };
  43
  44 int is_const0[is_const<int>::value? -1 : 1];
  45 int is_const1[is_const<const int>::value? 1 : -1];
  46 int is_const2[is_const<const volatile int>::value? 1 : -1];
  47 int is_const3[is_const<const int [3]>::value? 1 : -1];
  48 int is_const4[is_const<const volatile int[3]>::value? 1 : -1];
  49 int is_const5[is_const<volatile int[3]>::value? -1 : 1];
  50
  51 template<typename T>
  52 struct is_volatile {
  53   static const bool value = false;
  54 };
  55
  56 template<typename T>
  57 struct is_volatile<volatile T> {
  58   static const bool value = true;
  59 };
  60
  61 int is_volatile0[is_volatile<int>::value? -1 : 1];
  62 int is_volatile1[is_volatile<volatile int>::value? 1 : -1];
  63 int is_volatile2[is_volatile<const volatile int>::value? 1 : -1];
  64 int is_volatile3[is_volatile<volatile char[3]>::value? 1 : -1];
  65
  66 template<typename T, typename U>
  67 struct is_same {
  68   static const bool value = false;
  69 };
  70
  71 template<typename T>
  72 struct is_same<T, T> {
  73   static const bool value = true;
  74 };
  75
  76 typedef int INT;
  77 typedef INT* int_ptr;
  78
  79 int is_same0[is_same<int, int>::value? 1 : -1];
  80 int is_same1[is_same<int, INT>::value? 1 : -1];
  81 int is_same2[is_same<const int, int>::value? -1 : 1];
  82 int is_same3[is_same<int_ptr, int>::value? -1 : 1];
  83
  84 template<typename T>
  85 struct remove_reference {
  86   typedef T type;
  87 };
  88
  89 template<typename T>
  90 struct remove_reference<T&> {
  91   typedef T type;
  92 };
  93
  94 int remove_ref0[is_same<remove_reference<int>::type, int>::value? 1 : -1];
  95 int remove_ref1[is_same<remove_reference<int&>::type, int>::value? 1 : -1];
  96
  97 template<typename T>
  98 struct remove_const {
  99   typedef T type;
 100 };
 101
 102 template<typename T>
 103 struct remove_const<const T> {
 104   typedef T type;
 105 };
 106
 107 int remove_const0[is_same<remove_const<const int>::type, int>::value? 1 : -1];
 108 int remove_const1[is_same<remove_const<const int[3]>::type, int[3]>::value? 1 : -1];
 109
 110 template<typename T>
 111 struct is_incomplete_array {
 112   static const bool value = false;
 113 };
 114
 115 template<typename T>
 116 struct is_incomplete_array<T[]> {
 117   static const bool value = true;
 118 };
 119
 120 int incomplete_array0[is_incomplete_array<int>::value ? -1 : 1];
 121 int incomplete_array1[is_incomplete_array<int[1]>::value ? -1 : 1];
 122 int incomplete_array2[is_incomplete_array<bool[]>::value ? 1 : -1];
 123 int incomplete_array3[is_incomplete_array<int[]>::value ? 1 : -1];
 124
 125 template<typename T>
 126 struct is_array_with_4_elements {
 127   static const bool value = false;
 128 };
 129
 130 template<typename T>
 131 struct is_array_with_4_elements<T[4]> {
 132   static const bool value = true;
 133 };
 134
 135 int array_with_4_elements0[is_array_with_4_elements<int[]>::value ? -1 : 1];
 136 int array_with_4_elements1[is_array_with_4_elements<int[1]>::value ? -1 : 1];
 137 int array_with_4_elements2[is_array_with_4_elements<int[4]>::value ? 1 : -1];
 138 int array_with_4_elements3[is_array_with_4_elements<int[4][2]>::value ? 1 : -1];
 139
 140 template<typename T>
 141 struct get_array_size;
 142
 143 template<typename T, unsigned N>
 144 struct get_array_size<T[N]> {
 145   static const unsigned value = N;
 146 };
 147
 148 int array_size0[get_array_size<int[12]>::value == 12? 1 : -1];
 149
 150 template<typename T>
 151 struct remove_extent {
 152   typedef T type;
 153 };
 154
 155 template<typename T>
 156 struct remove_extent<T[]> {
 157   typedef T type;
 158 };
 159
 160 template<typename T, unsigned N>
 161 struct remove_extent<T[N]> {
 162   typedef T type;
 163 };
 164
 165 int remove_extent0[is_same<remove_extent<int[][5]>::type, int[5]>::value? 1 : -1];
 166 int remove_extent1[is_same<remove_extent<const int[][5]>::type, const int[5]>::value? 1 : -1];
 167
 168 template<typename T>
 169 struct is_unary_function {
 170   static const bool value = false;
 171 };
 172
 173 template<typename T, typename U>
 174 struct is_unary_function<T (*)(U)> {
 175   static const bool value = true;
 176 };
 177
 178 int is_unary_function0[is_unary_function<int>::value ? -1 : 1];
 179 int is_unary_function1[is_unary_function<int (*)()>::value ? -1 : 1];
 180 int is_unary_function2[is_unary_function<int (*)(int, bool)>::value ? -1 : 1];
 181 int is_unary_function3[is_unary_function<int (*)(bool)>::value ? 1 : -1];
 182 int is_unary_function4[is_unary_function<int (*)(int)>::value ? 1 : -1];
 183
 184 template<typename T>
 185 struct is_unary_function_with_same_return_type_as_argument_type {
 186   static const bool value = false;
 187 };
 188
 189 template<typename T>
 190 struct is_unary_function_with_same_return_type_as_argument_type<T (*)(T)> {
 191   static const bool value = true;
 192 };
 193
 194 int is_unary_function5[is_unary_function_with_same_return_type_as_argument_type<int>::value ? -1 : 1];
 195 int is_unary_function6[is_unary_function_with_same_return_type_as_argument_type<int (*)()>::value ? -1 : 1];
 196 int is_unary_function7[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, bool)>::value ? -1 : 1];
 197 int is_unary_function8[is_unary_function_with_same_return_type_as_argument_type<int (*)(bool)>::value ? -1 : 1];
 198 int is_unary_function9[is_unary_function_with_same_return_type_as_argument_type<int (*)(int)>::value ? 1 : -1];
 199 int is_unary_function10[is_unary_function_with_same_return_type_as_argument_type<int (*)(int, ...)>::value ? -1 : 1];
 200 int is_unary_function11[is_unary_function_with_same_return_type_as_argument_type<int (* const)(int)>::value ? -1 : 1];
 201
 202 template<typename T>
 203 struct is_binary_function {
 204   static const bool value = false;
 205 };
 206
 207 template<typename R, typename T1, typename T2>
 208 struct is_binary_function<R(T1, T2)> {
 209   static const bool value = true;
 210 };
 211
 212 int is_binary_function0[is_binary_function<int(float, double)>::value? 1 : -1];
 213
 214 template<typename T>
 215 struct is_member_pointer {
 216   static const bool value = false;
 217 };
 218
 219 template<typename T, typename Class>
 220 struct is_member_pointer<T Class::*> {
 221   static const bool value = true;
 222 };
 223
 224 struct X { };
 225
 226 int is_member_pointer0[is_member_pointer<int X::*>::value? 1 : -1];
 227 int is_member_pointer1[is_member_pointer<const int X::*>::value? 1 : -1];
 228 int is_member_pointer2[is_member_pointer<int (X::*)()>::value? 1 : -1];
 229 int is_member_pointer3[is_member_pointer<int (X::*)(int) const>::value? 1 : -1];
 230 int is_member_pointer4[is_member_pointer<int (X::**)(int) const>::value? -1 : 1];
 231 int is_member_pointer5[is_member_pointer<int>::value? -1 : 1];
 232
 233 template<typename T>
 234 struct is_member_function_pointer {
 235   static const bool value = false;
 236 };
 237
 238 template<typename T, typename Class>
 239 struct is_member_function_pointer<T (Class::*)()> {
 240   static const bool value = true;
 241 };
 242
 243 template<typename T, typename Class>
 244 struct is_member_function_pointer<T (Class::*)() const> {
 245   static const bool value = true;
 246 };
 247
 248 template<typename T, typename Class>
 249 struct is_member_function_pointer<T (Class::*)() volatile> {
 250   static const bool value = true;
 251 };
 252
 253 template<typename T, typename Class>
 254 struct is_member_function_pointer<T (Class::*)() const volatile> {
 255   static const bool value = true;
 256 };
 257
 258 template<typename T, typename Class, typename A1>
 259 struct is_member_function_pointer<T (Class::*)(A1)> {
 260   static const bool value = true;
 261 };
 262
 263 template<typename T, typename Class, typename A1>
 264 struct is_member_function_pointer<T (Class::*)(A1) const> {
 265   static const bool value = true;
 266 };
 267
 268 template<typename T, typename Class, typename A1>
 269 struct is_member_function_pointer<T (Class::*)(A1) volatile> {
 270   static const bool value = true;
 271 };
 272
 273 template<typename T, typename Class, typename A1>
 274 struct is_member_function_pointer<T (Class::*)(A1) const volatile> {
 275   static const bool value = true;
 276 };
 277
 278 int is_member_function_pointer0[
 279                           is_member_function_pointer<int X::*>::value? -1 : 1];
 280 int is_member_function_pointer1[
 281                       is_member_function_pointer<int (X::*)()>::value? 1 : -1];
 282 int is_member_function_pointer2[
 283                       is_member_function_pointer<X (X::*)(X&)>::value? 1 : -1];
 284 int is_member_function_pointer3[
 285            is_member_function_pointer<int (X::*)() const>::value? 1 : -1];
 286 int is_member_function_pointer4[
 287            is_member_function_pointer<int (X::*)(float) const>::value? 1 : -1];
 288
 289 // Test substitution of non-dependent arguments back into the template
 290 // argument list of the class template partial specialization.
 291 template<typename T, typename ValueType = T>
 292 struct is_nested_value_type_identity {
 293   static const bool value = false;
 294 };
 295
 296 template<typename T>
 297 struct is_nested_value_type_identity<T, typename T::value_type> {
 298   static const bool value = true;
 299 };
 300
 301 template<typename T>
 302 struct HasValueType {
 303   typedef T value_type;
 304 };
 305
 306 struct HasIdentityValueType {
 307   typedef HasIdentityValueType value_type;
 308 };
 309
 310 struct NoValueType { };
 311
 312 int is_nested_value_type_identity0[
 313             is_nested_value_type_identity<HasValueType<int> >::value? -1 : 1];
 314 int is_nested_value_type_identity1[
 315           is_nested_value_type_identity<HasIdentityValueType>::value? 1 : -1];
 316 int is_nested_value_type_identity2[
 317                    is_nested_value_type_identity<NoValueType>::value? -1 : 1];
 318
 319
 320 // C++ [temp.class.spec]p4:
 321 template<class T1, class T2, int I> class A { }; //#1
 322 template<class T, int I> class A<T, T*, I> { }; //#2
 323 template<class T1, class T2, int I> class A<T1*, T2, I> { }; //#3
 324 template<class T> class A<int, T*, 5> { }; //#4
 325 template<class T1, class T2, int I> class A<T1, T2*, I> { }; //#5
 326
 327 // Redefinition of class template partial specializations
 328 template<typename T, T N, typename U> class A0;
 329
 330 template<typename T, T N> class A0<T, N, int> { }; // expected-note{{here}}
 331 template<typename T, T N> class A0<T, N, int>;
 332 template<typename T, T N> class A0<T, N, int> { }; // expected-error{{redef}}
 333
 334 namespace PR6025 {
 335   template< int N > struct A;
 336
 337   namespace N
 338   {
 339     template< typename F >
 340     struct B;
 341   }
 342
 343   template< typename Protect, typename Second >
 344   struct C;
 345
 346   template <class T>
 347   struct C< T, A< N::B<T>::value > >
 348   {
 349   };
 350 }
 351
 352 namespace PR6181 {
 353   template <class T>
 354   class a;
 355
 356   class s;
 357
 358   template <class U>
 359   class a<s> // expected-error{{partial specialization of 'a' does not use any of its template parameters}}
 360   {
 361   };
 362
 363 }
 364
 365 // Check that we do not crash on invalid code that leads to invalid base.
 366 namespace {
 367 template <typename X>
 368 class Foo {};
 369
 370 template <int Y>
 371 class Bar;
 372
 373 template <typename Z>
 374 class Bar<0> : public Foo<Z> { // expected-error{{partial specialization of 'Bar' does not use any of its template parameters}}
 375   Bar() : Foo<Z>() {}
 376 };
 377 } // namespace
 378
 379 namespace Crash {
 380 template<typename T>
 381 class Base {};
 382
 383 template<typename T> class Foo;
 384
 385 template <typename T>
 386 class Foo<int> : public Base<T> {}; // expected-error{{partial specialization of 'Foo' does not use any of its template parameters}}
 387
 388 // verify that getASTRecordLayout doesn't crash on the ClassTemplateSpecializationDecl.
 389 constexpr int s = sizeof(Foo<int>);
 390 }