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 {{candidate template ignored}} \ 177 // expected-note{{substitution failure [with C = '\x00']}} 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} 184 185// Check that we instantiate declarations whose addresses are taken 186// for non-type template arguments. 187namespace EntityReferenced { 188 template<typename T, void (*)(T)> struct X { }; 189 190 template<typename T> 191 struct Y { 192 static void f(T x) { 193 x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}} 194 } 195 }; 196 197 void g() { 198 typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}} 199 } 200} 201 202namespace PR6964 { 203 template <typename ,int, int = 9223372036854775807L > // expected-warning 2{{non-type template argument value '9223372036854775807' truncated to '-1' for template parameter of type 'int'}} \ 204 // expected-note 2{{template parameter is declared here}} 205 struct as_nview { }; 206 207 template <typename Sequence, int I0> 208 struct as_nview<Sequence, I0> // expected-note{{while checking a default template argument used here}} 209 { }; 210} 211 212// rdar://problem/8302138 213namespace test8 { 214 template <int* ip> struct A { 215 int* p; 216 A() : p(ip) {} 217 }; 218 219 void test0() { 220 extern int i00; 221 A<&i00> a00; 222 } 223 224 extern int i01; 225 void test1() { 226 A<&i01> a01; 227 } 228 229 230 struct C { 231 int x; 232 char y; 233 double z; 234 }; 235 236 template <C* cp> struct B { 237 C* p; 238 B() : p(cp) {} 239 }; 240 241 void test2() { 242 extern C c02; 243 B<&c02> b02; 244 } 245 246 extern C c03; 247 void test3() { 248 B<&c03> b03; 249 } 250} 251 252namespace PR8372 { 253 template <int I> void foo() { } // expected-note{{template parameter is declared here}} 254 void bar() { foo <0x80000000> (); } // expected-warning{{non-type template argument value '2147483648' truncated to '-2147483648' for template parameter of type 'int'}} 255} 256 257namespace PR9227 { 258 template <bool B> struct enable_if_bool { }; 259 template <> struct enable_if_bool<true> { typedef int type; }; // expected-note{{'enable_if_bool<true>::type' declared here}} 260 void test_bool() { enable_if_bool<false>::type i; } // expected-error{{enable_if_bool<false>'; did you mean 'enable_if_bool<true>::type'?}} 261 262 template <char C> struct enable_if_char { }; 263 template <> struct enable_if_char<'a'> { typedef int type; }; // expected-note 5{{'enable_if_char<'a'>::type' declared here}} 264 void test_char_0() { enable_if_char<0>::type i; } // expected-error{{enable_if_char<'\x00'>'; did you mean 'enable_if_char<'a'>::type'?}} 265 void test_char_b() { enable_if_char<'b'>::type i; } // expected-error{{enable_if_char<'b'>'; did you mean 'enable_if_char<'a'>::type'?}} 266 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'?}} 267 void test_char_single_quote() { enable_if_char<'\''>::type i; } // expected-error{{enable_if_char<'\''>'; did you mean 'enable_if_char<'a'>::type'?}} 268 void test_char_backslash() { enable_if_char<'\\'>::type i; } // expected-error{{enable_if_char<'\\'>'; did you mean 'enable_if_char<'a'>::type'?}} 269} 270 271namespace PR10579 { 272 namespace fcppt 273 { 274 namespace container 275 { 276 namespace bitfield 277 { 278 279 template< 280 typename Enum, 281 Enum Size 282 > 283 class basic; 284 285 template< 286 typename Enum, 287 Enum Size 288 > 289 class basic 290 { 291 public: 292 basic() 293 { 294 } 295 }; 296 297 } 298 } 299 } 300 301 namespace 302 { 303 304 namespace testenum 305 { 306 enum type 307 { 308 foo, 309 bar, 310 size 311 }; 312 } 313 314 } 315 316 int main() 317 { 318 typedef fcppt::container::bitfield::basic< 319 testenum::type, 320 testenum::size 321 > bitfield_foo; 322 323 bitfield_foo obj; 324 } 325 326} 327 328template <int& I> struct PR10766 { static int *ip; }; 329template <int& I> int* PR10766<I>::ip = &I; 330 331namespace rdar13000548 { 332 template<typename R, typename U, R F> 333 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 *'}} 334 335 int g(int); 336 int y[3]; 337 void test() 338 { 339 f<int(int), int (*)(int), g>(); // expected-note{{in instantiation of}} 340 f<int[3], int*, y>(); // expected-note{{in instantiation of}} 341 } 342 343} 344 345namespace rdar13806270 { 346 template <unsigned N> class X { }; 347 const unsigned value = 32; 348 struct Y { 349 X<value + 1> x; 350 }; 351 void foo() {} 352} 353 354namespace PR17696 { 355 struct a { 356 union { 357 int i; 358 }; 359 }; 360 361 template <int (a::*p)> struct b : a { 362 b() { this->*p = 0; } 363 }; 364 365 b<&a::i> c; // okay 366} 367