572 lines · cpp
1// RUN: %clang_cc1 -verify -std=c++11 %s2// RUN: %clang_cc1 -verify -std=c++11 -fdelayed-template-parsing %s3// RUN: %clang_cc1 -verify -std=c++20 -fsyntax-only %s4 5template<typename T>6void f0() {7 struct X;8 typedef struct Y {9 T (X::* f1())(int) { return 0; }10 } Y2;11 12 Y2 y = Y();13}14 15template void f0<int>();16 17// PR576418namespace PR5764 {19 struct X {20 template <typename T>21 void Bar() {22 typedef T ValueType;23 struct Y {24 Y() { V = ValueType(); }25 26 ValueType V;27 };28 29 Y y;30 }31 };32 33 void test(X x) {34 x.Bar<int>();35 }36}37 38// Instantiation of local classes with virtual functions.39namespace local_class_with_virtual_functions {40 template <typename T> struct X { };41 template <typename T> struct Y { };42 43 template <typename T>44 void f() {45 struct Z : public X<Y<T>*> {46 virtual void g(Y<T>* y) { }47 void g2(int x) {(void)x;}48 };49 Z z;50 (void)z;51 }52 53 struct S { };54 void test() { f<S>(); }55}56 57namespace PR8801 {58 template<typename T>59 void foo() {60 class X;61 typedef int (X::*pmf_type)();62 class X : public T { };63 64 pmf_type pmf = &T::foo;65 }66 67 struct Y { int foo(); };68 69 template void foo<Y>();70}71 72namespace TemplatePacksAndLambdas {73 template <typename ...T> int g(T...);74 struct S {75 template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {}76 };77 void h() { S::f<int, int, int>(); }78}79 80namespace PR9685 {81 template <class Thing> void forEach(Thing t) { t.func(); }82 83 template <typename T> void doIt() {84 struct Functor {85 void func() { (void)i; }86 int i;87 };88 89 forEach(Functor());90 }91 92 void call() {93 doIt<int>();94 }95}96 97namespace PR12702 {98 struct S {99 template <typename F> bool apply(F f) { return f(); }100 };101 102 template <typename> struct T {103 void foo() {104 struct F {105 int x;106 107 bool operator()() { return x == 0; }108 };109 110 S().apply(F());111 }112 };113 114 void call() { T<int>().foo(); }115}116 117namespace PR17139 {118 template <class T> void foo(const T &t) { t.foo(); }119 120 template <class F> void bar(F *f) {121 struct B {122 F *fn;123 void foo() const { fn(); }124 } b = { f };125 foo(b);126 }127 128 void go() {}129 130 void test() { bar(go); }131}132 133namespace PR17740 {134class C {135public:136 template <typename T> static void foo(T function);137 template <typename T> static void bar(T function);138 template <typename T> static void func(T function);139};140 141template <typename T> void C::foo(T function) { function(); }142 143template <typename T> void C::bar(T function) {144 foo([&function]() { function(); });145}146 147template <typename T> void C::func(T function) {148 struct Struct {149 T mFunction;150 151 Struct(T function) : mFunction(function) {};152 153 void operator()() {154 mFunction();155 };156 };157 158 bar(Struct(function));159}160 161void call() {162 C::func([]() {});163}164}165 166namespace PR14373 {167 struct function {168 template <typename _Functor> function(_Functor __f) { __f(); }169 };170 template <typename Func> function exec_func(Func f) {171 struct functor {172 functor(Func f) : func(f) {}173 void operator()() const { func(); }174 Func func;175 };176 return functor(f);177 }178 struct Type {179 void operator()() const {}180 };181 int call() {182 exec_func(Type());183 return 0;184 }185}186 187namespace PR18907 {188template <typename>189class C : public C<int> {}; // expected-error{{within its own definition}}190 191template <typename X>192void F() {193 struct A : C<X> {};194}195 196struct B {197 void f() { F<int>(); }198};199}200 201namespace PR23194 {202 struct X {203 int operator()() const { return 0; }204 };205 struct Y {206 Y(int) {}207 };208 template <bool = true> int make_seed_pair() noexcept {209 struct state_t {210 X x;211 Y y{x()};212 };213 return 0;214 }215 int func() {216 return make_seed_pair();217 }218}219 220namespace PR18653 {221 // Forward declarations222 223 template<typename T> void f1() {224 void g1(struct x1);225 struct x1 {};226 }227 template void f1<int>();228 229 template<typename T> void f1a() {230 void g1(union x1);231 union x1 {};232 }233 template void f1a<int>();234 235 template<typename T> void f2() {236 void g2(enum x2); // expected-error{{ISO C++ forbids forward references to 'enum' types}}237 enum x2 { nothing };238 }239 template void f2<int>();240 241 template<typename T> void f3() {242 enum class x3;243 void g3(enum x3);244 enum class x3 { nothing };245 }246 template void f3<int>();247 248 249 template<typename T> void f4() {250 void g4(struct x4 {} x); // expected-error{{'x4' cannot be defined in a parameter type}}251 }252 template void f4<int>();253 254 template<typename T> void f4a() {255 void g4(union x4 {} x); // expected-error{{'x4' cannot be defined in a parameter type}}256 }257 template void f4a<int>();258 259 260 template <class T> void f();261 template <class T> struct S1 {262 void m() {263 f<class newclass>();264 f<union newunion>();265 }266 };267 template struct S1<int>;268 269 template <class T> struct S2 {270 void m() {271 f<enum new_enum>(); // expected-error{{ISO C++ forbids forward references to 'enum' types}}272 }273 };274 template struct S2<int>;275 276 template <class T> struct S3 {277 void m() {278 enum class new_enum;279 f<enum new_enum>();280 }281 };282 template struct S3<int>;283 284 template <class T> struct S4 {285 struct local {};286 void m() {287 f<local>();288 }289 };290 template struct S4<int>;291 292 template <class T> struct S4a {293 union local {};294 void m() {295 f<local>();296 }297 };298 template struct S4a<int>;299 300 template <class T> struct S5 {301 enum local { nothing };302 void m() {303 f<local>();304 }305 };306 template struct S5<int>;307 308 template <class T> struct S7 {309 enum class local { nothing };310 void m() {311 f<local>();312 }313 };314 template struct S7<int>;315 316 317 template <class T> void fff(T *x);318 template <class T> struct S01 {319 struct local { };320 void m() {321 local x;322 fff(&x);323 }324 };325 template struct S01<int>;326 327 template <class T> struct S01a {328 union local { };329 void m() {330 local x;331 fff(&x);332 }333 };334 template struct S01a<int>;335 336 template <class T> struct S02 {337 enum local { nothing };338 void m() {339 local x;340 fff(&x);341 }342 };343 template struct S02<int>;344 345 template <class T> struct S03 {346 enum class local { nothing };347 void m() {348 local x;349 fff(&x);350 }351 };352 template struct S03<int>;353 354 355 template <class T> struct S04 {356 void m() {357 struct { } x;358 fff(&x);359 }360 };361 template struct S04<int>;362 363 template <class T> struct S04a {364 void m() {365 union { } x;366 fff(&x);367 }368 };369 template struct S04a<int>;370 371 template <class T> struct S05 {372 void m() {373 enum { nothing } x;374 fff(&x);375 }376 };377 template struct S05<int>;378 379 template <class T> struct S06 {380 void m() {381 class { virtual void mmm() {} } x;382 fff(&x);383 }384 };385 template struct S06<int>;386}387 388namespace PR20625 {389template <typename T>390void f() {391 struct N {392 static constexpr int get() { return 42; }393 };394 constexpr int n = N::get();395 static_assert(n == 42, "n == 42");396}397 398void g() { f<void>(); }399}400 401 402namespace PR21332 {403 template<typename T> void f1() {404 struct S { // expected-note{{in instantiation of member class 'S' requested here}}405 void g1(int n = T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} \406 // expected-note {{in instantiation of default function argument expression for 'g1<int>' required here}}407 };408 }409 template void f1<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f1<int>' requested here}}410 411 template<typename T> void f2() {412 struct S { // expected-note{{in instantiation of member class 'S' requested here}}413 void g2() noexcept(T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}}414 };415 }416 template void f2<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f2<int>' requested here}}417 418 template<typename T> void f3() {419 enum S {420 val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}}421 };422 }423 template void f3<int>(); //expected-note{{in instantiation of function template specialization 'PR21332::f3<int>' requested here}}424 425 template<typename T> void f4() {426 enum class S {427 val = T::error; // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}}428 };429 }430 template void f4<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f4<int>' requested here}}431 432 template<typename T> void f5() {433 class S { // expected-note {{in instantiation of default member initializer 'PR21332::f5()::S::val' requested here}}434 int val = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}435 };436 }437 template void f5<int>(); // expected-note {{in instantiation of function template specialization 'PR21332::f5<int>' requested here}}438 439 template<typename T> void f6() {440 class S { // expected-note {{in instantiation of member function 'PR21332::f6()::S::get' requested here}}441 void get() {442 class S2 { // expected-note {{in instantiation of member class 'S2' requested here}}443 void g1(int n = T::error); // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} \444 // expected-note {{in instantiation of default function argument expression for 'g1<int>' required here}}445 };446 }447 };448 }449 template void f6<int>(); // expected-note{{in instantiation of function template specialization 'PR21332::f6<int>' requested here}}450 451 template<typename T> void f7() {452 struct S { void g() noexcept(undefined_val); }; // expected-error{{use of undeclared identifier 'undefined_val'}}453 }454 template void f7<int>();455}456 457// Ensure that we correctly perform implicit conversions when instantiating the458// default arguments of local functions.459namespace rdar23721638 {460 struct A {461 A(const char *) = delete; // expected-note 2 {{explicitly marked deleted here}}462 };463 464 template <typename T> void foo() {465 struct Inner { // expected-note {{in instantiation}}466 void operator()(T a = "") {} // expected-error {{conversion function from 'const char[1]' to 'rdar23721638::A' invokes a deleted function}} \467 // expected-note {{in instantiation of default function argument expression for 'operator()<rdar23721638::A>' required here}} \468 // expected-note {{passing argument to parameter 'a' here}}469 };470 Inner()();471 }472 template void foo<A>(); // expected-note {{in instantiation}}473 474 template <typename T> void bar() {475 auto lambda = [](T a = "") {}; // expected-error {{conversion function from 'const char[1]' to 'rdar23721638::A' invokes a deleted function}} \476 // expected-note {{in instantiation of default function argument expression for 'operator()<rdar23721638::A>' required here}} \477 // expected-note {{passing argument to parameter 'a' here}}478 lambda();479 }480 template void bar<A>(); // expected-note {{in instantiation}}481}482 483namespace anon_union_default_member_init {484 template<typename T> void f() {485 struct S {486 union {487 int i = 0;488 };489 };490 }491 void g() { f<int>(); }492}493 494namespace PR45000 {495 template <typename T>496 void f(int x = [](T x = nullptr) -> int { return x; }());497 // expected-error@-1 {{cannot initialize a parameter of type 'int' with an rvalue of type 'std::nullptr_t'}}498 // expected-note@-2 {{in instantiation of default function argument expression for 'operator()<int>' required here}}499 // expected-note@-3 {{passing argument to parameter 'x' here}}500 501 void g() { f<int>(); }502 // expected-note@-1 {{in instantiation of default function argument expression for 'f<int>' required here}}503}504 505namespace LambdaInDefaultMemberInitializer {506 template<typename T> void f() {507 struct S {508 void *p = [this] { return &p; }();509 };510 }511 template void f<int>();512}513 514#if __cplusplus >= 201703L515 516// Reduced from https://github.com/llvm/llvm-project/issues/98526517// This relies on the deferral instantiation of the local lambda, otherwise we would fail in DeduceReturnType().518namespace local_recursive_lambda {519 520template <typename F> struct recursive_lambda {521 template <typename... Args> auto operator()(Args &&...args) const {522 return fn(*this, args...);523 }524 F fn;525};526 527template <typename F> recursive_lambda(F) -> recursive_lambda<F>;528 529void foo() {530 recursive_lambda{[&](auto &self_fn, int) -> int {531 return self_fn(0);532 }}(0);533}534 535} // namespace local_recursive_lambda536 537#endif538 539namespace PR134038_Regression {540 541template <class T> class G {542public:543 template <class> class Iter {544 public:545 Iter();546 ~Iter();547 548 operator G<T>();549 };550};551 552template <class ObserverType>553template <class ContainerType>554G<ObserverType>::Iter<ContainerType>::Iter() {}555 556template <class ObserverType>557template <class ContainerType>558G<ObserverType>::Iter<ContainerType>::~Iter() {}559 560template <class ObserverType>561template <class ContainerType>562G<ObserverType>::Iter<ContainerType>::operator G<ObserverType>() {563 return G<ObserverType>{};564}565 566void NotifySettingChanged() {567 G<int>::Iter<int> Iter;568 G<int> g = Iter;569}570 571}572