1 // RUN: %clang_cc1 -verify -std=c++11 %s 2 // RUN: %clang_cc1 -verify -std=c++11 -fdelayed-template-parsing %s 3 4 template<typename T> f0()5void f0() { 6 struct X; 7 typedef struct Y { 8 T (X::* f1())(int) { return 0; } 9 } Y2; 10 11 Y2 y = Y(); 12 } 13 14 template void f0<int>(); 15 16 // PR5764 17 namespace PR5764 { 18 struct X { 19 template <typename T> BarPR5764::X20 void Bar() { 21 typedef T ValueType; 22 struct Y { 23 Y() { V = ValueType(); } 24 25 ValueType V; 26 }; 27 28 Y y; 29 } 30 }; 31 test(X x)32 void test(X x) { 33 x.Bar<int>(); 34 } 35 } 36 37 // Instantiation of local classes with virtual functions. 38 namespace local_class_with_virtual_functions { 39 template <typename T> struct X { }; 40 template <typename T> struct Y { }; 41 42 template <typename T> f()43 void f() { 44 struct Z : public X<Y<T>*> { 45 virtual void g(Y<T>* y) { } 46 void g2(int x) {(void)x;} 47 }; 48 Z z; 49 (void)z; 50 } 51 52 struct S { }; test()53 void test() { f<S>(); } 54 } 55 56 namespace PR8801 { 57 template<typename T> foo()58 void foo() { 59 class X; 60 typedef int (X::*pmf_type)(); 61 class X : public T { }; 62 63 pmf_type pmf = &T::foo; 64 } 65 66 struct Y { int foo(); }; 67 68 template void foo<Y>(); 69 } 70 71 namespace TemplatePacksAndLambdas { 72 template <typename ...T> int g(T...); 73 struct S { __anon710bdb210102TemplatePacksAndLambdas::S74 template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {} 75 }; h()76 void h() { S::f<int, int, int>(); } 77 } 78 79 namespace PR9685 { forEach(Thing t)80 template <class Thing> void forEach(Thing t) { t.func(); } 81 doIt()82 template <typename T> void doIt() { 83 struct Functor { 84 void func() { (void)i; } 85 int i; 86 }; 87 88 forEach(Functor()); 89 } 90 call()91 void call() { 92 doIt<int>(); 93 } 94 } 95 96 namespace PR12702 { 97 struct S { applyPR12702::S98 template <typename F> bool apply(F f) { return f(); } 99 }; 100 101 template <typename> struct T { fooPR12702::T102 void foo() { 103 struct F { 104 int x; 105 106 bool operator()() { return x == 0; } 107 }; 108 109 S().apply(F()); 110 } 111 }; 112 call()113 void call() { T<int>().foo(); } 114 } 115 116 namespace PR17139 { foo(const T & t)117 template <class T> void foo(const T &t) { t.foo(); } 118 bar(F * f)119 template <class F> void bar(F *f) { 120 struct B { 121 F *fn; 122 void foo() const { fn(); } 123 } b = { f }; 124 foo(b); 125 } 126 go()127 void go() {} 128 test()129 void test() { bar(go); } 130 } 131 132 namespace PR17740 { 133 class C { 134 public: 135 template <typename T> static void foo(T function); 136 template <typename T> static void bar(T function); 137 template <typename T> static void func(T function); 138 }; 139 foo(T function)140template <typename T> void C::foo(T function) { function(); } 141 bar(T function)142template <typename T> void C::bar(T function) { 143 foo([&function]() { function(); }); 144 } 145 func(T function)146template <typename T> void C::func(T function) { 147 struct Struct { 148 T mFunction; 149 150 Struct(T function) : mFunction(function) {}; 151 152 void operator()() { 153 mFunction(); 154 }; 155 }; 156 157 bar(Struct(function)); 158 } 159 call()160void call() { 161 C::func([]() {}); 162 } 163 } 164 165 namespace PR14373 { 166 struct function { functionPR14373::function167 template <typename _Functor> function(_Functor __f) { __f(); } 168 }; exec_func(Func f)169 template <typename Func> function exec_func(Func f) { 170 struct functor { 171 functor(Func f) : func(f) {} 172 void operator()() const { func(); } 173 Func func; 174 }; 175 return functor(f); 176 } 177 struct Type { operator ()PR14373::Type178 void operator()() const {} 179 }; call()180 int call() { 181 exec_func(Type()); 182 return 0; 183 } 184 } 185 186 namespace PR18907 { 187 template <typename> 188 class C : public C<int> {}; // expected-error{{within its own definition}} 189 190 template <typename X> F()191void F() { 192 struct A : C<X> {}; 193 } 194 195 struct B { fPR18907::B196 void f() { F<int>(); } 197 }; 198 } 199 200 namespace PR23194 { 201 struct X { operator ()PR23194::X202 int operator()() const { return 0; } 203 }; 204 struct Y { YPR23194::Y205 Y(int) {} 206 }; make_seed_pair()207 template <bool = true> int make_seed_pair() noexcept { 208 struct state_t { 209 X x; 210 Y y{x()}; 211 }; 212 return 0; 213 } func()214 int func() { 215 return make_seed_pair(); 216 } 217 } 218 219 namespace PR18653 { 220 // Forward declarations 221 f1()222 template<typename T> void f1() { 223 void g1(struct x1); 224 struct x1 {}; 225 } 226 template void f1<int>(); 227 f1a()228 template<typename T> void f1a() { 229 void g1(union x1); 230 union x1 {}; 231 } 232 template void f1a<int>(); 233 f2()234 template<typename T> void f2() { 235 void g2(enum x2); // expected-error{{ISO C++ forbids forward references to 'enum' types}} 236 enum x2 { nothing }; 237 } 238 template void f2<int>(); 239 f3()240 template<typename T> void f3() { 241 void g3(enum class x3); 242 enum class x3 { nothing }; 243 } 244 template void f3<int>(); 245 246 f4()247 template<typename T> void f4() { 248 void g4(struct x4 {} x); // expected-error{{'x4' cannot be defined in a parameter type}} 249 } 250 template void f4<int>(); 251 f4a()252 template<typename T> void f4a() { 253 void g4(union x4 {} x); // expected-error{{'x4' cannot be defined in a parameter type}} 254 } 255 template void f4a<int>(); 256 257 258 template <class T> void f(); 259 template <class T> struct S1 { mPR18653::S1260 void m() { 261 f<class newclass>(); 262 f<union newunion>(); 263 } 264 }; 265 template struct S1<int>; 266 267 template <class T> struct S2 { mPR18653::S2268 void m() { 269 f<enum new_enum>(); // expected-error{{ISO C++ forbids forward references to 'enum' types}} 270 } 271 }; 272 template struct S2<int>; 273 274 template <class T> struct S3 { mPR18653::S3275 void m() { 276 f<enum class new_enum>(); 277 } 278 }; 279 template struct S3<int>; 280 281 template <class T> struct S4 { 282 struct local {}; mPR18653::S4283 void m() { 284 f<local>(); 285 } 286 }; 287 template struct S4<int>; 288 289 template <class T> struct S4a { 290 union local {}; mPR18653::S4a291 void m() { 292 f<local>(); 293 } 294 }; 295 template struct S4a<int>; 296 297 template <class T> struct S5 { 298 enum local { nothing }; mPR18653::S5299 void m() { 300 f<local>(); 301 } 302 }; 303 template struct S5<int>; 304 305 template <class T> struct S7 { 306 enum class local { nothing }; mPR18653::S7307 void m() { 308 f<local>(); 309 } 310 }; 311 template struct S7<int>; 312 313 314 template <class T> void fff(T *x); 315 template <class T> struct S01 { 316 struct local { }; mPR18653::S01317 void m() { 318 local x; 319 fff(&x); 320 } 321 }; 322 template struct S01<int>; 323 324 template <class T> struct S01a { 325 union local { }; mPR18653::S01a326 void m() { 327 local x; 328 fff(&x); 329 } 330 }; 331 template struct S01a<int>; 332 333 template <class T> struct S02 { 334 enum local { nothing }; mPR18653::S02335 void m() { 336 local x; 337 fff(&x); 338 } 339 }; 340 template struct S02<int>; 341 342 template <class T> struct S03 { 343 enum class local { nothing }; mPR18653::S03344 void m() { 345 local x; 346 fff(&x); 347 } 348 }; 349 template struct S03<int>; 350 351 352 template <class T> struct S04 { mPR18653::S04353 void m() { 354 struct { } x; 355 fff(&x); 356 } 357 }; 358 template struct S04<int>; 359 360 template <class T> struct S04a { mPR18653::S04a361 void m() { 362 union { } x; 363 fff(&x); 364 } 365 }; 366 template struct S04a<int>; 367 368 template <class T> struct S05 { mPR18653::S05369 void m() { 370 enum { nothing } x; 371 fff(&x); 372 } 373 }; 374 template struct S05<int>; 375 376 template <class T> struct S06 { mPR18653::S06377 void m() { 378 class { virtual void mmm() {} } x; 379 fff(&x); 380 } 381 }; 382 template struct S06<int>; 383 } 384 385 namespace PR20625 { 386 template <typename T> f()387void f() { 388 struct N { 389 static constexpr int get() { return 42; } 390 }; 391 constexpr int n = N::get(); 392 static_assert(n == 42, "n == 42"); 393 } 394 g()395void g() { f<void>(); } 396 } 397 398 399 namespace PR21332 { f1()400 template<typename T> void f1() { 401 struct S { // expected-note{{in instantiation of member class 'S' requested here}} 402 void g1(int n = T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} 403 }; 404 } 405 template void f1<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f1<int>' requested here}} 406 f2()407 template<typename T> void f2() { 408 struct S { // expected-note{{in instantiation of member class 'S' requested here}} 409 void g2() noexcept(T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} 410 }; 411 } 412 template void f2<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f2<int>' requested here}} 413 f3()414 template<typename T> void f3() { 415 enum S { 416 val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}} 417 }; 418 } 419 template void f3<int>(); //expected-note{{in instantiation of function template specialization 'PR21332::f3<int>' requested here}} 420 f4()421 template<typename T> void f4() { 422 enum class S { 423 val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}} 424 }; 425 } 426 template void f4<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f4<int>' requested here}} 427 f5()428 template<typename T> void f5() { 429 class S { // expected-note {{in instantiation of default member initializer 'PR21332::f5()::S::val' requested here}} 430 int val = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} 431 }; 432 } 433 template void f5<int>(); // expected-note {{in instantiation of function template specialization 'PR21332::f5<int>' requested here}} 434 f6()435 template<typename T> void f6() { 436 class S { // expected-note {{in instantiation of member function 'PR21332::f6()::S::get' requested here}} 437 void get() { 438 class S2 { // expected-note {{in instantiation of member class 'S2' requested here}} 439 void g1(int n = T::error); // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} 440 }; 441 } 442 }; 443 } 444 template void f6<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f6<int>' requested here}} 445 f7()446 template<typename T> void f7() { 447 struct S { void g() noexcept(undefined_val); }; // expected-error{{use of undeclared identifier 'undefined_val'}} 448 } 449 template void f7<int>(); 450 } 451 452 // rdar://23721638: Ensure that we correctly perform implicit 453 // conversions when instantiating the default arguments of local functions. 454 namespace rdar23721638 { 455 struct A { 456 A(const char *) = delete; // expected-note 2 {{explicitly marked deleted here}} 457 }; 458 foo()459 template <typename T> void foo() { 460 struct Inner { // expected-note {{in instantiation}} 461 void operator()(T a = "") {} // expected-error {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a deleted function}} 462 // expected-note@-1 {{passing argument to parameter 'a' here}} 463 // expected-note@-2 {{candidate function not viable}} 464 }; 465 Inner()(); // expected-error {{no matching function}} 466 } 467 template void foo<A>(); // expected-note 2 {{in instantiation}} 468 bar()469 template <typename T> void bar() { 470 auto lambda = [](T a = "") {}; // expected-error {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a deleted function}} 471 // expected-note@-1 {{passing argument to parameter 'a' here}} 472 // expected-note@-2 {{candidate function not viable}} 473 // expected-note@-3 {{conversion candidate of type}} 474 lambda(); // expected-error {{no matching function}} 475 } 476 template void bar<A>(); // expected-note {{in instantiation}} 477 } 478