| // RUN: %clang_cc1 -fsyntax-only -verify %s |
| |
| // This is the function actually selected during overload resolution, and the |
| // only one defined. |
| template <typename T> void f(T*, int) {} |
| |
| template <typename T> struct S; |
| template <typename T> struct S_ : S<T> { typedef int type; }; // expected-note{{in instantiation}} |
| template <typename T> struct S { |
| // Force T to have a complete type here so we can observe instantiations with |
| // incomplete types. |
| T t; // expected-error{{field has incomplete type}} |
| }; |
| |
| // Provide a bad class and an overload that instantiates templates with it. |
| class NoDefinition; // expected-note{{forward declaration}} |
| template <typename T> S_<NoDefinition>::type f(T*, NoDefinition*); // expected-note{{in instantiation}} |
| |
| void test(int x) { |
| f(&x, 0); |
| } |
| |
| // Ensure that we instantiate an overloaded function if it's selected by |
| // overload resolution when initializing a function pointer. |
| template<typename T> struct X { |
| static T f() { T::error; } // expected-error {{has no members}} |
| static T f(bool); |
| }; |
| void (*p)() = &X<void>::f; // expected-note {{instantiation of}} |
| |
| namespace PR13098 { |
| struct A { |
| A(int); |
| void operator++() {} |
| void operator+(int) {} |
| void operator+(A) {} |
| void operator[](int) {} |
| void operator[](A) {} |
| }; |
| struct B : A { |
| using A::operator++; |
| using A::operator+; |
| using A::operator[]; |
| }; |
| template<typename T> void f(B b) { |
| ++b; |
| b + 0; |
| b[0]; |
| } |
| template void f<void>(B); |
| } |