Clang Project

clang_source_code/test/SemaTemplate/temp_arg_nontype.cpp
1// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wconversion -verify %s
2template<int N> struct A; // expected-note 5{{template parameter is declared here}}
3
4A<0> *a0;
5
6A<int()> *a1; // expected-error{{template argument for non-type template parameter is treated as function type 'int ()'}}
7
8A<int> *a2; // expected-error{{template argument for non-type template parameter must be an expression}}
9
10A<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:
13A<A> *a4; // expected-error{{must be an expression}}
14
15enum E { Enumerator = 17 };
16A<E> *a5; // expected-error{{template argument for non-type template parameter must be an expression}}
17template<E Value> struct A1; // expected-note{{template parameter is declared here}}
18A1<Enumerator> *a6; // okay
19A1<17> *a7; // expected-error{{non-type template argument of type 'int' cannot be converted to a value of type 'E'}}
20
21const long LongValue = 12345678;
22A<LongValue> *a8;
23const short ShortValue = 17;
24A<ShortValue> *a9;
25
26int f(int);
27A<f(17)> *a10; // expected-error{{non-type template argument of type 'int' is not an integral constant expression}}
28
29class X {
30public:
31  X();
32  X(int, int);
33  operator int() const;
34};
35A<X(17, 42)> *a11; // expected-error{{non-type template argument of type 'X' must have an integral or enumeration type}}
36
37float f(float);
38
39float g(float); // expected-note 2{{candidate function}}
40double g(double); // expected-note 2{{candidate function}}
41
42int h(int);
43float h2(float);
44
45template<int fp(int)> struct A3; // expected-note 1{{template parameter is declared here}}
46A3<h> *a14_1;
47A3<&h> *a14_2;
48A3<f> *a14_3;
49A3<&f> *a14_4;
50A3<h2> *a14_6;  // expected-error{{non-type template argument of type 'float (float)' cannot be converted to a value of type 'int (*)(int)'}}
51A3<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
52
53
54struct Y { } y;
55
56volatile X * X_volatile_ptr;
57template<X const &AnX> struct A4; // expected-note 2{{template parameter is declared here}}
58X an_X;
59A4<an_X> *a15_1; // okay
60A4<*X_volatile_ptr> *a15_2; // expected-error{{non-type template argument does not refer to any declaration}}
61A4<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
64template<int (&fr)(int)> struct A5; // expected-note{{template parameter is declared here}}
65A5<h> *a16_1;
66A5<f> *a16_3;
67A5<h2> *a16_6;  // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'float (float)'}}
68A5<g> *a14_7; // expected-error{{address of overloaded function 'g' does not match required type 'int (int)'}}
69
70struct 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};
82template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
83A6<&Z::foo> *a17_1;
84A6<&Z::bar> *a17_2;
85A6<&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
88template<int Z::*pm> struct A7;  // expected-note{{template parameter is declared here}}
89template<int Z::*pm> struct A7c;
90A7<&Z::int_member> *a18_1;
91A7c<&Z::int_member> *a18_2;
92A7<&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::*'}}
93A7c<(&Z::int_member)> *a18_4; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
94A7c<&Z::union_member> *a18_5;
95
96template<unsigned char C> struct Overflow; // expected-note{{template parameter is declared here}}
97
98Overflow<5> *overflow1; // okay
99Overflow<255> *overflow2; // okay
100Overflow<256> *overflow3; // expected-warning{{non-type template argument value '256' truncated to '0' for template parameter of type 'unsigned char'}}
101
102
103template<unsigned> struct Signedness; // expected-note{{template parameter is declared here}}
104Signedness<10> *signedness1; // okay
105Signedness<-10> *signedness2; // expected-warning{{non-type template argument with value '-10' converted to '4294967286' for unsigned template parameter of type 'unsigned int'}}
106
107template<signed char C> struct SignedOverflow; // expected-note 3 {{template parameter is declared here}}
108SignedOverflow<1> *signedoverflow1;
109SignedOverflow<-1> *signedoverflow2;
110SignedOverflow<-128> *signedoverflow3;
111SignedOverflow<-129> *signedoverflow4; // expected-warning{{non-type template argument value '-129' truncated to '127' for template parameter of type 'signed char'}}
112SignedOverflow<127> *signedoverflow5;
113SignedOverflow<128> *signedoverflow6; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
114SignedOverflow<(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.
117template<int (*)(int, int)> struct FuncPtr0;
118int func0(int, int);
119extern FuncPtr0<&func0> *fp0;
120template<int (*)(int, int)> struct FuncPtr0;
121extern FuncPtr0<&func0> *fp0;
122int func0(int, int);
123extern FuncPtr0<&func0> *fp0;
124
125// PR5350
126namespace 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
141namespace 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
156template<int (*)(float)> struct X0 { };
157
158struct X1 {
159    static int pfunc(float);
160};
161void test_X0_X1() {
162  X0<X1::pfunc> x01;
163}
164
165// PR6249
166namespace 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
175namespace 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]'}}
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.
191namespace EntityReferenced {
192  template<typename T, void (*)(T)> struct X { };
193
194  template<typename T>
195  struct Y {
196    static void f(T x) { 
197      x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
198    }
199  };
200
201  void g() {
202    typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}}
203  }
204}
205
206namespace 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
217namespace test8 {
218  template <int* ip> struct A {
219    int* p;
220    A() : p(ip) {}
221  };
222
223  void test0() {
224    extern int i00;
225    A<&i00> a00;
226  }
227
228  extern int i01;
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;
242    B() : p(cp) {}
243  };
244
245  void test2() {
246    extern C c02;
247    B<&c02> b02;
248  }
249
250  extern C c03;
251  void test3() {
252    B<&c03> b03;
253  }
254}
255
256namespace PR8372 {
257  template <int I> void foo() { } // expected-note{{template parameter is declared here}}
258  void bar() { foo <0x80000000> (); } // expected-warning{{non-type template argument value '2147483648' truncated to '-2147483648' for template parameter of type 'int'}}
259}
260
261namespace 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}}
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}}
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'?}}
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'?}}
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'?}}
271  void test_char_single_quote() { enable_if_char<'\''>::type i; } // expected-error{{enable_if_char<'\''>'; did you mean 'enable_if_char<'a'>::type'?}}
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
275namespace 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:
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
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
332template <int& I> struct PR10766 { static int *ip; };
333template <int& I> int* PR10766<I>::ip = &I;
334
335namespace 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];
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
349namespace rdar13806270 {
350  template <unsigned N> class X { };
351  const unsigned value = 32;
352  struct Y {
353    X<value + 1> x;
354  };
355  void foo() {}
356}
357
358namespace PR17696 {
359  struct a {
360    union {
361      int i;
362    };
363  };
364
365  template <int (a::*p)> struct b : a {
366    b() { this->*p = 0; }
367  };
368
369  b<&a::i> c; // okay
370}
371
372namespace 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
382namespace 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
416namespace 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
442namespace 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>); // expected-note 2{{candidate}}
449  void g() {
450    // FIXME: The first and second function templates above should be
451    // considered more specialized than the last two, 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
459namespace pointer_to_char_array {
460  typedef char T[4];
461  template<T *P> struct A { void f(); };
462  template<T *P> void A<P>::f() {}
463  T foo = "foo";
464  void g() { A<&foo>().f(); }
465}
466
CodeThinker, Enjoy your reading code