test/SemaTemplate/temp_arg_nontype.cpp

   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 };
 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]'}}
 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 {
 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
 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;
 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
 256 namespace 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
 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}}
 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
 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:
 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
 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];
 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   };
 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 {
 366     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>); // 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
 459 namespace 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 }