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