1 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wconversion -verify %s
2 template<int N> struct A; // expected-note 5{{template parameter is declared here}}
3
4 A<0> *a0;
5
6 A<int()> *a1; // expected-error{{template argument for non-type template parameter is treated as function type 'int ()'}}
7
8 A<int> *a2; // expected-error{{template argument for non-type template parameter must be an expression}}
9
10 A<1 >> 2> *a3; // expected-warning{{use of right-shift operator ('>>') in template argument will require parentheses in C++11}}
11
12 // C++ [temp.arg.nontype]p5:
13 A<A> *a4; // expected-error{{must be an expression}}
14
15 enum E { Enumerator = 17 };
16 A<E> *a5; // expected-error{{template argument for non-type template parameter must be an expression}}
17 template<E Value> struct A1; // expected-note{{template parameter is declared here}}
18 A1<Enumerator> *a6; // okay
19 A1<17> *a7; // expected-error{{non-type template argument of type 'int' cannot be converted to a value of type 'E'}}
20
21 const long LongValue = 12345678;
22 A<LongValue> *a8;
23 const short ShortValue = 17;
24 A<ShortValue> *a9;
25
26 int f(int);
27 A<f(17)> *a10; // expected-error{{non-type template argument of type 'int' is not an integral constant expression}}
28
29 class X {
30 public:
31 X();
32 X(int, int);
33 operator int() const;
34 };
35 A<X(17, 42)> *a11; // expected-error{{non-type template argument of type 'X' must have an integral or enumeration type}}
36
37 float f(float);
38
39 float g(float); // expected-note 2{{candidate function}}
40 double g(double); // expected-note 2{{candidate function}}
41
42 int h(int);
43 float h2(float);
44
45 template<int fp(int)> struct A3; // expected-note 1{{template parameter is declared here}}
46 A3<h> *a14_1;
47 A3<&h> *a14_2;
48 A3<f> *a14_3;
49 A3<&f> *a14_4;
50 A3<h2> *a14_6; // expected-error{{non-type template argument of type 'float (float)' cannot be converted to a value of type 'int (*)(int)'}}
51 A3<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
52
53
54 struct Y { } y;
55
56 volatile X * X_volatile_ptr;
57 template<X const &AnX> struct A4; // expected-note 2{{template parameter is declared here}}
58 X an_X;
59 A4<an_X> *a15_1; // okay
60 A4<*X_volatile_ptr> *a15_2; // expected-error{{non-type template argument does not refer to any declaration}}
61 A4<y> *15_3; // expected-error{{non-type template parameter of reference type 'const X &' cannot bind to template argument of type 'struct Y'}} \
62 // FIXME: expected-error{{expected unqualified-id}}
63
64 template<int (&fr)(int)> struct A5; // expected-note{{template parameter is declared here}}
65 A5<h> *a16_1;
66 A5<f> *a16_3;
67 A5<h2> *a16_6; // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'float (float)'}}
68 A5<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
69
70 struct Z {
71 int foo(int);
72 float bar(float);
73 int bar(int);
74 double baz(double);
75
76 int int_member;
77 float float_member;
78 union {
79 int union_member;
80 };
81 };
82 template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
83 A6<&Z::foo> *a17_1;
84 A6<&Z::bar> *a17_2;
85 A6<&Z::baz> *a17_3; // expected-error-re{{non-type template argument of type 'double (Z::*)(double){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (Z::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
86
87
88 template<int Z::*pm> struct A7; // expected-note{{template parameter is declared here}}
89 template<int Z::*pm> struct A7c;
90 A7<&Z::int_member> *a18_1;
91 A7c<&Z::int_member> *a18_2;
92 A7<&Z::float_member> *a18_3; // expected-error{{non-type template argument of type 'float Z::*' cannot be converted to a value of type 'int Z::*'}}
93 A7c<(&Z::int_member)> *a18_4; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
94 A7c<&Z::union_member> *a18_5;
95
96 template<unsigned char C> struct Overflow; // expected-note{{template parameter is declared here}}
97
98 Overflow<5> *overflow1; // okay
99 Overflow<255> *overflow2; // okay
100 Overflow<256> *overflow3; // expected-warning{{non-type template argument value '256' truncated to '0' for template parameter of type 'unsigned char'}}
101
102
103 template<unsigned> struct Signedness; // expected-note{{template parameter is declared here}}
104 Signedness<10> *signedness1; // okay
105 Signedness<-10> *signedness2; // expected-warning{{non-type template argument with value '-10' converted to '4294967286' for unsigned template parameter of type 'unsigned int'}}
106
107 template<signed char C> struct SignedOverflow; // expected-note 3 {{template parameter is declared here}}
108 SignedOverflow<1> *signedoverflow1;
109 SignedOverflow<-1> *signedoverflow2;
110 SignedOverflow<-128> *signedoverflow3;
111 SignedOverflow<-129> *signedoverflow4; // expected-warning{{non-type template argument value '-129' truncated to '127' for template parameter of type 'signed char'}}
112 SignedOverflow<127> *signedoverflow5;
113 SignedOverflow<128> *signedoverflow6; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
114 SignedOverflow<(unsigned char)128> *signedoverflow7; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
115
116 // Check canonicalization of template arguments.
117 template<int (*)(int, int)> struct FuncPtr0;
118 int func0(int, int);
119 extern FuncPtr0<&func0> *fp0;
120 template<int (*)(int, int)> struct FuncPtr0;
121 extern FuncPtr0<&func0> *fp0;
122 int func0(int, int);
123 extern FuncPtr0<&func0> *fp0;
124
125 // PR5350
126 namespace ns {
127 template <typename T>
128 struct Foo {
129 static const bool value = true;
130 };
131
132 template <bool b>
133 struct Bar {};
134
135 const bool value = false;
136
137 Bar<bool(ns::Foo<int>::value)> x;
138 }
139
140 // PR5349
141 namespace ns {
142 enum E { k };
143
144 template <E e>
145 struct Baz {};
146
147 Baz<k> f1; // This works.
148 Baz<E(0)> f2; // This too.
149 Baz<static_cast<E>(0)> f3; // And this.
150
151 Baz<ns::E(0)> b1; // This doesn't work.
152 Baz<static_cast<ns::E>(0)> b2; // This neither.
153 }
154
155 // PR5597
156 template<int (*)(float)> struct X0 { };
157
158 struct X1 {
159 static int pfunc(float);
160 };
test_X0_X1()161 void test_X0_X1() {
162 X0<X1::pfunc> x01;
163 }
164
165 // PR6249
166 namespace pr6249 {
167 template<typename T, T (*func)()> T f() {
168 return func();
169 }
170
171 int h();
172 template int f<int, h>();
173 }
174
175 namespace PR6723 {
176 template<unsigned char C> void f(int (&a)[C]); // expected-note 3{{candidate template ignored: substitution failure [with C = '\x00']}}
177 // expected-note@-1 {{not viable: no known conversion from 'int [512]' to 'int (&)[0]'}}
g()178 void g() {
179 int arr512[512];
180 f(arr512); // expected-error{{no matching function for call}}
181 f<512>(arr512); // expected-error{{no matching function for call}}
182
183 int arr0[0];
184 f(arr0); // expected-error{{no matching function for call}}
185 f<0>(arr0); // expected-error{{no matching function for call}}
186 }
187 }
188
189 // Check that we instantiate declarations whose addresses are taken
190 // for non-type template arguments.
191 namespace EntityReferenced {
192 template<typename T, void (*)(T)> struct X { };
193
194 template<typename T>
195 struct Y {
fEntityReferenced::Y196 static void f(T x) {
197 x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
198 }
199 };
200
g()201 void g() {
202 typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}}
203 }
204 }
205
206 namespace PR6964 {
207 template <typename ,int, int = 9223372036854775807L > // expected-warning 2{{non-type template argument value '9223372036854775807' truncated to '-1' for template parameter of type 'int'}} \
208 // expected-note 2{{template parameter is declared here}}
209 struct as_nview { };
210
211 template <typename Sequence, int I0>
212 struct as_nview<Sequence, I0> // expected-note{{while checking a default template argument used here}}
213 { };
214 }
215
216 // rdar://problem/8302138
217 namespace test8 {
218 template <int* ip> struct A {
219 int* p;
Atest8::A220 A() : p(ip) {}
221 };
222
test0()223 void test0() {
224 extern int i00;
225 A<&i00> a00;
226 }
227
228 extern int i01;
test1()229 void test1() {
230 A<&i01> a01;
231 }
232
233
234 struct C {
235 int x;
236 char y;
237 double z;
238 };
239
240 template <C* cp> struct B {
241 C* p;
Btest8::B242 B() : p(cp) {}
243 };
244
test2()245 void test2() {
246 extern C c02;
247 B<&c02> b02;
248 }
249
250 extern C c03;
test3()251 void test3() {
252 B<&c03> b03;
253 }
254 }
255
256 namespace PR8372 {
foo()257 template <int I> void foo() { } // expected-note{{template parameter is declared here}}
bar()258 void bar() { foo <0x80000000> (); } // expected-warning{{non-type template argument value '2147483648' truncated to '-2147483648' for template parameter of type 'int'}}
259 }
260
261 namespace PR9227 {
262 template <bool B> struct enable_if_bool { };
263 template <> struct enable_if_bool<true> { typedef int type; }; // expected-note{{'enable_if_bool<true>::type' declared here}}
test_bool()264 void test_bool() { enable_if_bool<false>::type i; } // expected-error{{enable_if_bool<false>'; did you mean 'enable_if_bool<true>::type'?}}
265
266 template <char C> struct enable_if_char { };
267 template <> struct enable_if_char<'a'> { typedef int type; }; // expected-note 5{{'enable_if_char<'a'>::type' declared here}}
test_char_0()268 void test_char_0() { enable_if_char<0>::type i; } // expected-error{{enable_if_char<'\x00'>'; did you mean 'enable_if_char<'a'>::type'?}}
test_char_b()269 void test_char_b() { enable_if_char<'b'>::type i; } // expected-error{{enable_if_char<'b'>'; did you mean 'enable_if_char<'a'>::type'?}}
test_char_possibly_negative()270 void test_char_possibly_negative() { enable_if_char<'\x02'>::type i; } // expected-error{{enable_if_char<'\x02'>'; did you mean 'enable_if_char<'a'>::type'?}}
test_char_single_quote()271 void test_char_single_quote() { enable_if_char<'\''>::type i; } // expected-error{{enable_if_char<'\''>'; did you mean 'enable_if_char<'a'>::type'?}}
test_char_backslash()272 void test_char_backslash() { enable_if_char<'\\'>::type i; } // expected-error{{enable_if_char<'\\'>'; did you mean 'enable_if_char<'a'>::type'?}}
273 }
274
275 namespace PR10579 {
276 namespace fcppt
277 {
278 namespace container
279 {
280 namespace bitfield
281 {
282
283 template<
284 typename Enum,
285 Enum Size
286 >
287 class basic;
288
289 template<
290 typename Enum,
291 Enum Size
292 >
293 class basic
294 {
295 public:
basic()296 basic()
297 {
298 }
299 };
300
301 }
302 }
303 }
304
305 namespace
306 {
307
308 namespace testenum
309 {
310 enum type
311 {
312 foo,
313 bar,
314 size
315 };
316 }
317
318 }
319
main()320 int main()
321 {
322 typedef fcppt::container::bitfield::basic<
323 testenum::type,
324 testenum::size
325 > bitfield_foo;
326
327 bitfield_foo obj;
328 }
329
330 }
331
332 template <int& I> struct PR10766 { static int *ip; };
333 template <int& I> int* PR10766<I>::ip = &I;
334
335 namespace rdar13000548 {
336 template<typename R, typename U, R F>
337 U f() { return &F; } // expected-error{{cannot take the address of an rvalue of type 'int (*)(int)'}} expected-error{{cannot take the address of an rvalue of type 'int *'}}
338
339 int g(int);
340 int y[3];
test()341 void test()
342 {
343 f<int(int), int (*)(int), g>(); // expected-note{{in instantiation of}}
344 f<int[3], int*, y>(); // expected-note{{in instantiation of}}
345 }
346
347 }
348
349 namespace rdar13806270 {
350 template <unsigned N> class X { };
351 const unsigned value = 32;
352 struct Y {
353 X<value + 1> x;
354 };
foo()355 void foo() {}
356 }
357
358 namespace PR17696 {
359 struct a {
360 union {
361 int i;
362 };
363 };
364
365 template <int (a::*p)> struct b : a {
bPR17696::b366 b() { this->*p = 0; }
367 };
368
369 b<&a::i> c; // okay
370 }
371
372 namespace partial_order_different_types {
373 template<int, int, typename T, typename, T> struct A;
374 template<int N, typename T, typename U, T V> struct A<0, N, T, U, V>; // expected-note {{matches}}
375 // FIXME: It appears that this partial specialization should be ill-formed as
376 // it is not more specialized than the primary template. V is not deducible
377 // because it does not have the same type as the corresponding parameter.
378 template<int N, typename T, typename U, U V> struct A<0, N, T, U, V> {}; // expected-note {{matches}}
379 A<0, 0, int, int, 0> a; // expected-error {{ambiguous}}
380 }
381
382 namespace partial_order_references {
383 // FIXME: The standard does not appear to consider the second specialization
384 // to be more more specialized than the first! The problem is that deducing
385 // an 'int&' parameter from an argument 'R' results in a type mismatch,
386 // because the parameter has a reference type and the argument is an
387 // expression and thus does not have reference type. We resolve this by
388 // matching the type of an expression corresponding to the parameter rather
389 // than matching the parameter itself.
390 template <int, int, int &> struct A {};
391 template <int N, int &R> struct A<N, 0, R> {};
392 template <int &R> struct A<0, 0, R> {};
393 int N;
394 A<0, 0, N> a;
395
396 template<int, int &R> struct B; // expected-note 2{{template}}
397 template<const int &R> struct B<0, R> {};
398 // expected-error@-1 {{not more specialized than the primary}}
399 // expected-note@-2 {{'const int' vs 'int &'}}
400 B<0, N> b; // expected-error {{undefined}}
401
402 template<int, const int &R> struct C; // expected-note 2{{template}}
403 template<int &R> struct C<0, R> {};
404 // expected-error@-1 {{not more specialized than the primary}}
405 // expected-note@-2 {{'int' vs 'const int &'}}
406 C<0, N> c; // expected-error {{undefined}}
407
408 template<int, const int &R> struct D; // expected-note 2{{template}}
409 template<int N> struct D<0, N> {};
410 // expected-error@-1 {{not more specialized than the primary}}
411 // expected-note@-2 {{'int' vs 'const int &'}}
412 extern const int K = 5;
413 D<0, K> d; // expected-error {{undefined}}
414 }
415
416 namespace dependent_nested_partial_specialization {
417 template<typename> using X = int; // expected-warning {{C++11}}
418 template<typename T> using Y = T*; // expected-warning {{C++11}}
419 int n;
420
421 template<template<typename> class X> struct A {
422 template<typename T, X<T> N> struct B; // expected-note 2{{here}}
423 template<typename T> struct B<T, 0> {}; // expected-error {{specializes a template parameter with dependent type 'Y<T>'}}
424 };
425 A<X>::B<int, 0> ax;
426 A<Y>::B<int, &n> ay; // expected-error {{undefined}} expected-note {{instantiation of}}
427
428 template<template<typename> class X> struct C {
429 template<typename T, int N, int M> struct D; // expected-note {{here}}
430 template<typename T, X<T> N> struct D<T*, N, N + 1> {}; // expected-error {{type of specialized non-type template argument depends on}}
431 };
432 C<X>::D<int*, 0, 1> cx;
433 C<Y>::D<int*, 0, 1> cy; // expected-error {{undefined}} expected-note {{instantiation of}}
434
435 template<typename T> struct E {
436 template<typename U, U V> struct F; // expected-note {{template}}
437 template<typename W, T V> struct F<W, V> {}; // expected-error {{not more specialized than the primary}}
438 };
439 E<int>::F<int, 0> e1; // expected-note {{instantiation of}}
440 }
441
442 namespace nondependent_default_arg_ordering {
443 int n, m;
444 template<typename A, A B = &n> struct X {};
445 template<typename A> void f(X<A>); // expected-note {{candidate}}
446 template<typename A> void f(X<A, &m>); // expected-note {{candidate}}
447 template<typename A, A B> void f(X<A, B>); // expected-note 2{{candidate}}
448 template<template<typename U, U> class T, typename A, int *B> void f(T<A, B>);
g()449 void g() {
450 // FIXME: The first and second function templates above should be
451 // considered more specialized than the third, but during partial
452 // ordering we fail to check that we actually deduced template arguments
453 // that make the deduced A identical to A.
454 X<int *, &n> x; f(x); // expected-error {{ambiguous}}
455 X<int *, &m> y; f(y); // expected-error {{ambiguous}}
456 }
457 }
458
459 namespace pointer_to_char_array {
460 typedef char T[4];
461 template<T *P> struct A { void f(); };
f()462 template<T *P> void A<P>::f() {}
463 T foo = "foo";
g()464 void g() { A<&foo>().f(); }
465 }
466
467 namespace dependent_backreference {
468 struct Incomplete; // expected-note 2{{forward declaration}}
469 Incomplete f(int); // expected-note 2{{here}}
470 int f(short);
471
472 template<typename T, T Value, int(*)[sizeof(f(Value))]> struct X {}; // expected-error 2{{incomplete}}
473 int arr[sizeof(int)];
474 // When checking this template-id, we must not treat 'Value' as having type
475 // 'int'; its type is the dependent type 'T'.
f()476 template<typename T> void f() { X<T, 0, &arr> x; } // expected-note {{substituting}}
g()477 void g() { f<short>(); }
h()478 void h() { f<int>(); } // expected-note {{instantiation}}
479
480 // The second of these is OK to diagnose eagerly because 'Value' has the
481 // non-dependent type 'int'.
a()482 template<short S> void a() { X<short, S, &arr> x; }
b()483 template<short S> void b() { X<int, S, &arr> x; } // expected-note {{substituting}}
484 }
485
486 namespace instantiation_dependent {
487 template<typename T, __typeof(sizeof(T))> void f(int);
488 template<typename T, __typeof(sizeof(0))> int &f(...);
489 int &rf = f<struct incomplete, 0>(0);
490
491 int arr[sizeof(sizeof(int))];
492 template<typename T, int (*)[sizeof(sizeof(T))]> void g(int);
493 template<typename T, int (*)[sizeof(sizeof(int))]> int &g(...);
494 int &rg = g<struct incomplete, &arr>(0);
495 }
496
497 namespace complete_array_from_incomplete {
498 template <typename T, const char* const A[static_cast<int>(T::kNum)]>
499 class Base {};
500 template <class T, const char* const A[]>
501 class Derived : public Base<T, A> {};
502
503 struct T {
504 static const int kNum = 3;
505 };
506 extern const char *const kStrs[3] = {};
507 Derived<T, kStrs> d;
508 }
509