// 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);
}