|
150
|
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 }
|
|
221
|
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 }
|
