1// RUN: %clang_cc1 -fsyntax-only -verify %s 2 3// This is the function actually selected during overload resolution, and the 4// only one defined. 5template <typename T> void f(T*, int) {} 6 7template <typename T> struct S; 8template <typename T> struct S_ : S<T> { typedef int type; }; // expected-note{{in instantiation}} 9template <typename T> struct S { 10 // Force T to have a complete type here so we can observe instantiations with 11 // incomplete types. 12 T t; // expected-error{{field has incomplete type}} 13}; 14 15// Provide a bad class and an overload that instantiates templates with it. 16class NoDefinition; // expected-note{{forward declaration}} 17template <typename T> S_<NoDefinition>::type f(T*, NoDefinition*); // expected-note{{in instantiation}} 18 19void test(int x) { 20 f(&x, 0); 21} 22 23// Ensure that we instantiate an overloaded function if it's selected by 24// overload resolution when initializing a function pointer. 25template<typename T> struct X { 26 static T f() { T::error; } // expected-error {{has no members}} 27 static T f(bool); 28}; 29void (*p)() = &X<void>::f; // expected-note {{instantiation of}} 30 31namespace PR13098 { 32 struct A { 33 A(int); 34 void operator++() {} 35 void operator+(int) {} 36 void operator+(A) {} 37 void operator[](int) {} 38 void operator[](A) {} 39 }; 40 struct B : A { 41 using A::operator++; 42 using A::operator+; 43 using A::operator[]; 44 }; 45 template<typename T> void f(B b) { 46 ++b; 47 b + 0; 48 b[0]; 49 } 50 template void f<void>(B); 51} 52