1 // RUN: %clang_cc1 -std=c++98 -verify -fsyntax-only -Wno-c++11-extensions -Wno-c++1y-extensions %s -DPRECXX11 2 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s 3 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s 4 5 #ifdef PRECXX11 6 #define CONST const 7 #else 8 #define CONST constexpr 9 #endif 10 11 template<typename T> 12 T pi = T(3.1415926535897932385); // expected-note {{template is declared here}} 13 14 template<typename T> 15 CONST T cpi = T(3.1415926535897932385); // expected-note {{template is declared here}} 16 17 template<typename T> extern CONST T vc; 18 #ifndef PRECXX11 19 // expected-error@-2 {{constexpr variable declaration must be a definition}} 20 #endif 21 22 namespace use_in_top_level_funcs { 23 good()24 void good() { 25 int ipi = pi<int>; 26 int icpi = cpi<int>; 27 double dpi = pi<double>; 28 double dcpi = cpi<double>; 29 } 30 no_deduce()31 void no_deduce() { 32 // template arguments are not deduced for uses of variable templates. 33 int ipi = pi; // expected-error {{cannot refer to variable template 'pi' without a template argument list}} 34 int icpi = cpi; // expected-error {{cannot refer to variable template 'cpi' without a template argument list}} 35 } 36 37 template<typename T> circular_area(T r)38 T circular_area(T r) { 39 return pi<T> * r * r; 40 } 41 42 template<typename T> const_circular_area(T r)43 CONST T const_circular_area(T r) { 44 return cpi<T> * r * r; 45 } 46 use_circular_area(double r)47 double use_circular_area(double r) { 48 CONST float t = const_circular_area(2.0) - 12; 49 #ifndef PRECXX11 50 static_assert(const_circular_area(2) == 12, ""); 51 CONST int test = (t > 0) && (t < 1); 52 static_assert(test, ""); 53 #endif 54 return circular_area(r); 55 } 56 } 57 58 namespace shadow { foo()59 void foo() { 60 int ipi0 = pi<int>; 61 int pi; 62 int a = pi; 63 int ipi = pi<int>; // expected-error {{expected '(' for function-style cast or type construction}} \ 64 // expected-error {{expected expression}} 65 } 66 } 67 68 namespace odr_tmpl { 69 namespace pv_cvt { 70 int v; // expected-note {{previous definition is here}} 71 template<typename T> T v; // expected-error {{redefinition of 'v' as different kind of symbol}} 72 } 73 namespace pvt_cv { 74 template<typename T> T v; // expected-note {{previous definition is here}} 75 int v; // expected-error {{redefinition of 'v' as different kind of symbol}} 76 } 77 namespace pvt_cvt { 78 template<typename T> T v0; // expected-note {{previous definition is here}} 79 template<typename T> T v0; // expected-error {{redefinition of 'v0'}} 80 81 template<typename T> T v; // expected-note {{previous definition is here}} 82 template<typename T> int v; // expected-error {{redefinition of 'v'}} 83 84 template<typename T> extern int v1; // expected-note {{previous template declaration is here}} 85 template<int I> int v1; // expected-error {{template parameter has a different kind in template redeclaration}} 86 } 87 namespace pvt_use { 88 template<typename T> T v; 89 v = 10; // expected-error {{C++ requires a type specifier for all declarations}} 90 } 91 92 namespace pvt_diff_params { 93 template<typename T, typename> T v; // expected-note 2{{previous template declaration is here}} 94 template<typename T> T v; // expected-error {{too few template parameters in template redeclaration}} 95 template<typename T, typename, typename> T v; // expected-error {{too many template parameters in template redeclaration}} 96 } 97 98 namespace pvt_extern { 99 template<typename T> T v = T(); 100 template<typename T> extern T v; // redeclaration is allowed \ 101 // expected-note {{previous declaration is here}} 102 template<typename T> extern int v; // expected-error {{redeclaration of 'v' with a different type: 'int' vs 'T'}} 103 104 #ifndef PRECXX11 105 template<typename T> extern auto v; // expected-error {{declaration of variable 'v' with type 'auto' requires an initializer}} 106 #endif 107 108 template<typename T> T var = T(); // expected-note {{previous definition is here}} 109 extern int var; // expected-error {{redefinition of 'var' as different kind of symbol}} 110 } 111 112 #ifndef PRECXX11 113 namespace pvt_auto { 114 template<typename T> auto v0; // expected-error {{declaration of variable 'v0' with type 'auto' requires an initializer}} 115 template<typename T> auto v1 = T(); // expected-note {{previous definition is here}} 116 template<typename T> int v1; // expected-error {{redefinition of 'v1' with a different type: 'int' vs 'auto'}} 117 template<typename T> auto v2 = T(); // expected-note {{previous definition is here}} 118 template<typename T> T v2; // expected-error {{redefinition of 'v2'}} 119 template<typename T> auto v3 = T(); // expected-note {{previous definition is here}} 120 template<typename T> extern T v3; // expected-error {{redeclaration of 'v3' with a different type: 'T' vs 'auto'}} 121 template<typename T> auto v4 = T(); 122 template<typename T> extern auto v4; // expected-error {{declaration of variable 'v4' with type 'auto' requires an initializer}} 123 } 124 #endif 125 126 } 127 128 namespace explicit_instantiation { 129 template<typename T> 130 T pi0a = T(3.1415926535897932385); // expected-note {{variable template 'pi0a' declared here}} 131 template float pi0a<int>; // expected-error {{type 'float' of explicit instantiation of 'pi0a' does not match expected type 'int'}} 132 133 template<typename T> 134 T pi0b = T(3.1415926535897932385); // expected-note {{variable template 'pi0b' declared here}} 135 template CONST int pi0b<int>; // expected-error {{type 'const int' of explicit instantiation of 'pi0b' does not match expected type 'int'}} 136 137 template<typename T> 138 T pi0c = T(3.1415926535897932385); // expected-note {{variable template 'pi0c' declared here}} 139 template int pi0c<const int>; // expected-error {{type 'int' of explicit instantiation of 'pi0c' does not match expected type 'const int'}} 140 141 template<typename T> 142 T pi0 = T(3.1415926535897932385); 143 template int pi0<int>; // expected-note {{previous explicit instantiation is here}} 144 template int pi0<int>; // expected-error {{duplicate explicit instantiation of 'pi0<int>'}} 145 146 template<typename T> 147 CONST T pi1a = T(3.1415926535897932385); // expected-note {{variable template 'pi1a' declared here}} 148 template int pi1a<int>; // expected-error {{type 'int' of explicit instantiation of 'pi1a' does not match expected type 'const int'}} 149 150 template<typename T> 151 CONST T pi1b = T(3.1415926535897932385); // expected-note {{variable template 'pi1b' declared here}} 152 template int pi1b<const int>; // expected-error {{type 'int' of explicit instantiation of 'pi1b' does not match expected type 'const const int'}} 153 154 template<typename T> 155 CONST T pi1 = T(3.1415926535897932385); 156 template CONST int pi1<int>; // expected-note {{previous explicit instantiation is here}} 157 template CONST int pi1<int>; // expected-error {{duplicate explicit instantiation of 'pi1<int>'}} 158 159 #ifndef PRECXX11 160 namespace auto_var { 161 template<typename T> auto var0 = T(); 162 template auto var0<int>; // expected-error {{'auto' variable template instantiation is not allowed}} 163 164 template<typename T> auto var = T(); 165 template int var<int>; 166 } 167 #endif 168 169 template<typename=int> int missing_args; // expected-note {{here}} 170 template int missing_args; // expected-error {{must specify a template argument list}} 171 172 namespace extern_var { 173 // TODO: 174 } 175 } 176 177 namespace explicit_specialization { 178 179 namespace good { 180 template<typename T1, typename T2> 181 CONST int pi2 = 1; 182 183 template<typename T> 184 CONST int pi2<T,int> = 2; 185 186 template<typename T> 187 CONST int pi2<int,T> = 3; 188 189 template<> CONST int pi2<int,int> = 4; 190 191 #ifndef PRECXX11 foo()192 void foo() { 193 static_assert(pi2<int,int> == 4, ""); 194 static_assert(pi2<float,int> == 2, ""); 195 static_assert(pi2<int,float> == 3, ""); 196 static_assert(pi2<int,float> == pi2<int,double>, ""); 197 static_assert(pi2<float,float> == 1, ""); 198 static_assert(pi2<float,float> == pi2<float,double>, ""); 199 } 200 #endif 201 } 202 203 namespace ambiguous { 204 205 template<typename T1, typename T2> 206 CONST int pi2 = 1; 207 208 template<typename T> 209 CONST int pi2<T,int> = 2; // expected-note {{partial specialization matches [with T = int]}} 210 211 template<typename T> 212 CONST int pi2<int,T> = 3; // expected-note {{partial specialization matches [with T = int]}} 213 foo()214 void foo() { 215 int a = pi2<int,int>; // expected-error {{ambiguous partial specializations of 'pi2<int, int>'}} 216 } 217 } 218 219 namespace type_changes { 220 221 template<typename T> 222 T pi0 = T(3.1415926535897932385); 223 224 template<> float pi0<int> = 10; 225 template<> int pi0<const int> = 10; 226 227 template<typename T> 228 T pi1 = T(3.1415926535897932385); 229 template<> CONST int pi1<int> = 10; 230 231 template<typename T> 232 T pi2 = T(3.1415926535897932385); 233 template<> int pi2<const int> = 10; 234 235 template<typename T> 236 CONST T pi4 = T(3.1415926535897932385); 237 template<> int pi4<int> = 10; 238 } 239 240 namespace redefinition { 241 template<typename T> 242 T pi0 = T(3.1415926535897932385); 243 244 template<> int pi0<int> = 10; // expected-note 3{{previous definition is here}} 245 #ifndef PRECXX11 246 // expected-note@-2 {{previous definition is here}} 247 #endif 248 template<> int pi0<int> = 10; // expected-error {{redefinition of 'pi0<int>'}} 249 template<> CONST int pi0<int> = 10; // expected-error {{redefinition of 'pi0' with a different type: 'const int' vs 'int'}} 250 template<> float pi0<int> = 10; // expected-error {{redefinition of 'pi0' with a different type: 'float' vs 'int'}} 251 #ifndef PRECXX11 252 template<> auto pi0<int> = 10; // expected-error {{redefinition of 'pi0<int>'}} 253 #endif 254 255 256 template<typename T> 257 CONST T pi1 = T(3.1415926535897932385); 258 259 template<> CONST int pi1<int> = 10; // expected-note {{previous definition is here}} 260 template<> CONST int pi1<int> = 10; // expected-error {{redefinition of 'pi1<int>'}} 261 } 262 263 namespace before_instantiation { 264 template<typename T> 265 T pi0 = T(3.1415926535897932385); // expected-note {{variable template 'pi0' declared here}} 266 267 template<> int pi0<int> = 10; 268 template int pi0<int>; 269 template float pi0<int>; // expected-error {{type 'float' of explicit instantiation of 'pi0' does not match expected type}} 270 271 template<typename T1, typename T2> 272 CONST int pi2 = 1; 273 274 template<typename T> CONST int pi2<T,int> = 2; 275 template CONST int pi2<int,int>; 276 } 277 namespace after_instantiation { 278 template<typename T> 279 T pi0 = T(3.1415926535897932385); 280 281 template int pi0<int>; // expected-note 2{{explicit instantiation first required here}} 282 template<> int pi0<int> = 10; // expected-error {{explicit specialization of 'pi0' after instantiation}} 283 template<> float pi0<int>; // expected-error {{explicit specialization of 'pi0' after instantiation}} 284 285 template<typename T1, typename T2> 286 CONST int pi2 = 1; 287 288 template CONST int pi2<int,int>; 289 template<typename T> CONST int pi2<T,int> = 2; 290 } 291 292 #ifndef PRECXX11 293 namespace auto_var { 294 template<typename T, typename> auto var0 = T(); 295 template<typename T> auto var0<T,int> = T(); 296 template<> auto var0<int,int> = 7; 297 298 template<typename T, typename> auto var = T(); 299 template<typename T> T var<T,int> = T(5); 300 template<> int var<int,int> = 7; 301 foo()302 void foo() { 303 int i0 = var0<int,int>; 304 int b = var<int,int>; 305 } 306 } 307 #endif 308 309 namespace extern_var { 310 // TODO: 311 } 312 313 namespace diff_type { 314 // TODO: 315 template<typename T> T* var = new T(); 316 #ifndef PRECXX11 317 template<typename T> auto var<T*> = T(); // expected-note {{previous definition is here}} 318 template<typename T> T var<T*> = T(); // expected-error {{redefinition of 'var' with a different type: 'T' vs 'auto'}} 319 #endif 320 } 321 } 322 323 namespace narrowing { 324 template<typename T> T v = {1234}; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 1234 to}} 325 #ifndef PRECXX11 326 // expected-error@-2 {{constant expression evaluates to 1234 which cannot be narrowed to type 'char'}}\ 327 // expected-note@-2 {{insert an explicit cast to silence this issue}} 328 #endif 329 int k = v<char>; // expected-note {{in instantiation of variable template specialization 'narrowing::v<char>' requested here}} 330 } 331 332 namespace use_in_structs { 333 // TODO: 334 } 335 336 namespace attributes { 337 // TODO: 338 } 339 340 #ifndef PRECXX11 341 namespace arrays { 342 template<typename T> 343 T* arr = new T[10]{T(10), T(23)}; 344 345 float f = 10.5; 346 template<> float* arr<float> = &f; 347 bar()348 void bar() { 349 int *iarr = arr<int>; 350 iarr[0] = 1; 351 iarr[2] = 3; 352 iarr[6] = -2; 353 354 float ff = *arr<float>; 355 float nof = arr<float>[3]; // No bounds-check in C++ 356 } 357 } 358 #endif 359 360 namespace nested { 361 362 namespace n0a { 363 template<typename T> 364 T pi0a = T(3.1415926535897932385); 365 } 366 367 using namespace n0a; 368 int i0a = pi0a<int>; 369 370 template float pi0a<float>; 371 float f0a = pi0a<float>; 372 373 template<> double pi0a<double> = 5.2; 374 double d0a = pi0a<double>; 375 376 namespace n0b { 377 template<typename T> 378 T pi0b = T(3.1415926535897932385); 379 } 380 381 int i0b = n0b::pi0b<int>; 382 383 template float n0b::pi0b<float>; 384 float f0b = n0b::pi0b<float>; 385 386 template<> double n0b::pi0b<double> = 5.2; 387 double d0b = n0b::pi0b<double>; 388 389 namespace n1 { 390 template<typename T> 391 T pi1a = T(3.1415926535897932385); // expected-note {{explicitly specialized declaration is here}} 392 #ifndef PRECXX11 393 // expected-note@-2 {{explicit instantiation refers here}} 394 #endif 395 396 template<typename T> 397 T pi1b = T(3.1415926535897932385); // expected-note {{explicitly specialized declaration is here}} 398 #ifndef PRECXX11 399 // expected-note@-2 {{explicit instantiation refers here}} 400 #endif 401 } 402 403 namespace use_n1a { 404 using namespace n1; 405 int i1 = pi1a<int>; 406 407 template float pi1a<float>; 408 #ifndef PRECXX11 409 // expected-error@-2 {{explicit instantiation of 'pi1a<float>' not in a namespace enclosing 'n1'}} 410 #endif 411 float f1 = pi1a<float>; 412 413 template<> double pi1a<double> = 5.2; // expected-error {{variable template specialization of 'pi1a' must originally be declared in namespace 'n1'}} 414 double d1 = pi1a<double>; 415 } 416 417 namespace use_n1b { 418 int i1 = n1::pi1b<int>; 419 420 template float n1::pi1b<float>; 421 #ifndef PRECXX11 422 // expected-error@-2 {{explicit instantiation of 'pi1b<float>' not in a namespace enclosing 'n1'}} 423 #endif 424 float f1 = n1::pi1b<float>; 425 426 template<> double n1::pi1b<double> = 5.2; // expected-error {{cannot define or redeclare 'pi1b' here because namespace 'use_n1b' does not enclose namespace 'n1'}} \ 427 // expected-error {{variable template specialization of 'pi1b' must originally be declared in namespace 'n1'}} 428 double d1 = n1::pi1b<double>; 429 } 430 } 431 432 namespace nested_name { 433 template<typename T> int a; // expected-note {{variable template 'a' declared here}} 434 a<int>::b c; // expected-error {{qualified name refers into a specialization of variable template 'a'}} 435 436 class a<int> {}; // expected-error {{identifier followed by '<' indicates a class template specialization but 'a' refers to a variable template}} 437 enum a<int> {}; // expected-error {{expected identifier or '{'}} expected-warning {{does not declare anything}} 438 } 439 440 namespace PR18530 { 441 template<typename T> int a; 442 int a<int>; // expected-error {{requires 'template<>'}} 443 } 444 445 namespace PR19152 { 446 #ifndef PRECXX11 447 template<typename T> const auto x = 1; 448 static_assert(x<int> == 1, ""); 449 #endif 450 } 451 452 namespace PR19169 { 453 template <typename T> int* f(); 454 template <typename T> void f(); 455 template<> int f<double>; // expected-error {{no variable template matches specialization; did you mean to use 'f' as function template instead?}} 456 457 template <typename T> void g(); 458 template<> int g<double>; // expected-error {{no variable template matches specialization; did you mean to use 'g' as function template instead?}} 459 } 460 461 #ifndef PRECXX11 462 template <typename... Args> struct Variadic_t { }; 463 template <typename... Args> Variadic_t<Args...> Variadic; 464 auto variadic1 = Variadic<>; 465 auto variadic2 = Variadic<int, int>; 466 #endif 467