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
