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 };
  79 template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
  80 A6<&Z::foo> *a17_1;
  81 A6<&Z::bar> *a17_2;
  82 A6<&Z::baz> *a17_3; // expected-error{{non-type template argument of type 'double (Z::*)(double)' cannot be converted to a value of type 'int (Z::*)(int)'}}
  83
  84
  85 template<int Z::*pm> struct A7;  // expected-note{{template parameter is declared here}}
  86 template<int Z::*pm> struct A7c;
  87 A7<&Z::int_member> *a18_1;
  88 A7c<&Z::int_member> *a18_2;
  89 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::*'}}
  90 A7c<(&Z::int_member)> *a18_4; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
  91
  92 template<unsigned char C> struct Overflow; // expected-note{{template parameter is declared here}}
  93
  94 Overflow<5> *overflow1; // okay
  95 Overflow<255> *overflow2; // okay
  96 Overflow<256> *overflow3; // expected-warning{{non-type template argument value '256' truncated to '0' for template parameter of type 'unsigned char'}}
  97
  98
  99 template<unsigned> struct Signedness; // expected-note{{template parameter is declared here}}
 100 Signedness<10> *signedness1; // okay
 101 Signedness<-10> *signedness2; // expected-warning{{non-type template argument with value '-10' converted to '4294967286' for unsigned template parameter of type 'unsigned int'}}
 102
 103 template<signed char C> struct SignedOverflow; // expected-note 3 {{template parameter is declared here}}
 104 SignedOverflow<1> *signedoverflow1;
 105 SignedOverflow<-1> *signedoverflow2;
 106 SignedOverflow<-128> *signedoverflow3;
 107 SignedOverflow<-129> *signedoverflow4; // expected-warning{{non-type template argument value '-129' truncated to '127' for template parameter of type 'signed char'}}
 108 SignedOverflow<127> *signedoverflow5;
 109 SignedOverflow<128> *signedoverflow6; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
 110 SignedOverflow<(unsigned char)128> *signedoverflow7; // expected-warning{{non-type template argument value '128' truncated to '-128' for template parameter of type 'signed char'}}
 111
 112 // Check canonicalization of template arguments.
 113 template<int (*)(int, int)> struct FuncPtr0;
 114 int func0(int, int);
 115 extern FuncPtr0<&func0> *fp0;
 116 template<int (*)(int, int)> struct FuncPtr0;
 117 extern FuncPtr0<&func0> *fp0;
 118 int func0(int, int);
 119 extern FuncPtr0<&func0> *fp0;
 120
 121 // PR5350
 122 namespace ns {
 123   template <typename T>
 124   struct Foo {
 125     static const bool value = true;
 126   };
 127
 128   template <bool b>
 129   struct Bar {};
 130
 131   const bool value = false;
 132
 133   Bar<bool(ns::Foo<int>::value)> x;
 134 }
 135
 136 // PR5349
 137 namespace ns {
 138   enum E { k };
 139
 140   template <E e>
 141   struct Baz  {};
 142
 143   Baz<k> f1;  // This works.
 144   Baz<E(0)> f2;  // This too.
 145   Baz<static_cast<E>(0)> f3;  // And this.
 146
 147   Baz<ns::E(0)> b1;  // This doesn't work.
 148   Baz<static_cast<ns::E>(0)> b2;  // This neither.
 149 }
 150
 151 // PR5597
 152 template<int (*)(float)> struct X0 { };
 153
 154 struct X1 {
 155     static int pfunc(float);
 156 };
 157 void test_X0_X1() {
 158   X0<X1::pfunc> x01;
 159 }
 160
 161 // PR6249
 162 namespace pr6249 {
 163   template<typename T, T (*func)()> T f() {
 164     return func();
 165   }
 166
 167   int h();
 168   template int f<int, h>();
 169 }
 170
 171 namespace PR6723 {
 172   template<unsigned char C> void f(int (&a)[C]); // expected-note {{candidate template ignored}} \
 173   // expected-note{{substitution failure [with C = '\x00']}}
 174   void g() {
 175     int arr512[512];
 176     f(arr512); // expected-error{{no matching function for call}}
 177     f<512>(arr512); // expected-error{{no matching function for call}}
 178   }
 179 }
 180
 181 // Check that we instantiate declarations whose addresses are taken
 182 // for non-type template arguments.
 183 namespace EntityReferenced {
 184   template<typename T, void (*)(T)> struct X { };
 185
 186   template<typename T>
 187   struct Y {
 188     static void f(T x) {
 189       x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
 190     }
 191   };
 192
 193   void g() {
 194     typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}}
 195   }
 196 }
 197
 198 namespace PR6964 {
 199   template <typename ,int, int = 9223372036854775807L > // expected-warning 2{{non-type template argument value '9223372036854775807' truncated to '-1' for template parameter of type 'int'}} \
 200   // expected-note 2{{template parameter is declared here}}
 201   struct as_nview { };
 202
 203   template <typename Sequence, int I0>
 204   struct as_nview<Sequence, I0>  // expected-note{{while checking a default template argument used here}}
 205   { };
 206 }
 207
 208 // rdar://problem/8302138
 209 namespace test8 {
 210   template <int* ip> struct A {
 211     int* p;
 212     A() : p(ip) {}
 213   };
 214
 215   void test0() {
 216     extern int i00;
 217     A<&i00> a00;
 218   }
 219
 220   extern int i01;
 221   void test1() {
 222     A<&i01> a01;
 223   }
 224
 225
 226   struct C {
 227     int x;
 228     char y;
 229     double z;
 230   };
 231
 232   template <C* cp> struct B {
 233     C* p;
 234     B() : p(cp) {}
 235   };
 236
 237   void test2() {
 238     extern C c02;
 239     B<&c02> b02;
 240   }
 241
 242   extern C c03;
 243   void test3() {
 244     B<&c03> b03;
 245   }
 246 }
 247
 248 namespace PR8372 {
 249   template <int I> void foo() { } // expected-note{{template parameter is declared here}}
 250   void bar() { foo <0x80000000> (); } // expected-warning{{non-type template argument value '2147483648' truncated to '-2147483648' for template parameter of type 'int'}}
 251 }
 252
 253 namespace PR9227 {
 254   template <bool B> struct enable_if_bool { };
 255   template <> struct enable_if_bool<true> { typedef int type; };
 256   void test_bool() { enable_if_bool<false>::type i; } // expected-error{{enable_if_bool<false>}}
 257
 258   template <char C> struct enable_if_char { };
 259   template <> struct enable_if_char<'a'> { typedef int type; };
 260   void test_char_0() { enable_if_char<0>::type i; } // expected-error{{enable_if_char<'\x00'>}}
 261   void test_char_b() { enable_if_char<'b'>::type i; } // expected-error{{enable_if_char<'b'>}}
 262   void test_char_possibly_negative() { enable_if_char<'\x02'>::type i; } // expected-error{{enable_if_char<'\x02'>}}
 263   void test_char_single_quote() { enable_if_char<'\''>::type i; } // expected-error{{enable_if_char<'\''>}}
 264   void test_char_backslash() { enable_if_char<'\\'>::type i; } // expected-error{{enable_if_char<'\\'>}}
 265 }
 266
 267 namespace PR10579 {
 268   namespace fcppt
 269   {
 270     namespace container
 271     {
 272       namespace bitfield
 273       {
 274
 275         template<
 276           typename Enum,
 277           Enum Size
 278           >
 279         class basic;
 280
 281         template<
 282           typename Enum,
 283           Enum Size
 284           >
 285         class basic
 286         {
 287         public:
 288           basic()
 289           {
 290           }
 291         };
 292
 293       }
 294     }
 295   }
 296
 297   namespace
 298   {
 299
 300     namespace testenum
 301     {
 302       enum type
 303         {
 304           foo,
 305           bar,
 306           size
 307         };
 308     }
 309
 310   }
 311
 312   int main()
 313   {
 314     typedef fcppt::container::bitfield::basic<
 315     testenum::type,
 316       testenum::size
 317       > bitfield_foo;
 318
 319     bitfield_foo obj;
 320   }
 321
 322 }
 323
 324 template <int& I> struct PR10766 { static int *ip; };
 325 template <int& I> int* PR10766<I>::ip = &I;
 326
 327 namespace rdar13000548 {
 328   template<typename R, typename U, R F>
 329   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 *'}}
 330
 331   int g(int);
 332   int y[3];
 333   void test()
 334   {
 335     f<int(int), int (*)(int), g>(); // expected-note{{in instantiation of}}
 336     f<int[3], int*, y>(); // expected-note{{in instantiation of}}
 337   }
 338
 339 }
 340
 341 namespace rdar13806270 {
 342   template <unsigned N> class X { };
 343   const unsigned value = 32;
 344   struct Y {
 345     X<value + 1> x;
 346   };
 347   void foo() {}
 348 }