// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
int* f(int) { return 0; }
float* f(float) { return 0; }
void f();

void test_f(int iv, float fv) {
  float* fp = f(fv);
  int* ip = f(iv);
}

int* g(int, float, int); // expected-note {{candidate function}}
float* g(int, int, int); // expected-note {{candidate function}}
double* g(int, float, float); // expected-note {{candidate function}}
char* g(int, float, ...); // expected-note {{candidate function}}
void g();

void test_g(int iv, float fv) {
  int* ip1 = g(iv, fv, 0);
  float* fp1 = g(iv, iv, 0);
  double* dp1 = g(iv, fv, fv);
  char* cp1 = g(0, 0);
  char* cp2 = g(0, 0, 0, iv, fv);

  double* dp2 = g(0, fv, 1.5); // expected-error {{call to 'g' is ambiguous}}
}

double* h(double f);
int* h(int);

void test_h(float fv, unsigned char cv) {
  double* dp = h(fv);
  int* ip = h(cv);
}

int* i(int);
double* i(long);

void test_i(short sv, int iv, long lv, unsigned char ucv) {
  int* ip1 = i(sv);
  int* ip2 = i(iv);
  int* ip3 = i(ucv);
  double* dp1 = i(lv);
}

int* j(void*);
double* j(bool);

void test_j(int* ip) {
  int* ip1 = j(ip);
}

int* k(char*);
double* k(bool);

void test_k() {
  int* ip1 = k("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}}
  int* ip2 = k(("foo")); // expected-warning{{conversion from string literal to 'char *' is deprecated}}
  double* dp1 = k(L"foo");
}

int* l(wchar_t*);
double* l(bool);

void test_l() {
  int* ip1 = l(L"foo"); // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}}
  double* dp1 = l("foo");
}

int* m(const char*);
double* m(char*);

void test_m() {
  int* ip = m("foo");
}

int* n(char*);
double* n(void*);
class E;

void test_n(E* e) {
  char ca[7];
  int* ip1 = n(ca);
  int* ip2 = n("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}}

  float fa[7];
  double* dp1 = n(fa);

  double* dp2 = n(e);
}

enum PromotesToInt {
  PromotesToIntValue = -1
};

enum PromotesToUnsignedInt {
  PromotesToUnsignedIntValue = __INT_MAX__ * 2U
};

int* o(int);
double* o(unsigned int);
float* o(long);

void test_o() {
  int* ip1 = o(PromotesToIntValue);
  double* dp1 = o(PromotesToUnsignedIntValue);
}

int* p(int);
double* p(double);

void test_p() {
  int* ip = p((short)1);
  double* dp = p(1.0f);
}

struct Bits {
  signed short int_bitfield : 5;
  unsigned int uint_bitfield : 8;
};

int* bitfields(int, int);
float* bitfields(unsigned int, int);

void test_bitfield(Bits bits, int x) {
  int* ip = bitfields(bits.int_bitfield, 0);
  float* fp = bitfields(bits.uint_bitfield, 0u);
}

int* multiparm(long, int, long); // expected-note {{candidate function}}
float* multiparm(int, int, int); // expected-note {{candidate function}}
double* multiparm(int, int, short); // expected-note {{candidate function}}

void test_multiparm(long lv, short sv, int iv) {
  int* ip1 = multiparm(lv, iv, lv);
  int* ip2 = multiparm(lv, sv, lv);
  float* fp1 = multiparm(iv, iv, iv);
  float* fp2 = multiparm(sv, iv, iv);
  double* dp1 = multiparm(sv, sv, sv);
  double* dp2 = multiparm(iv, sv, sv);
  multiparm(sv, sv, lv); // expected-error {{call to 'multiparm' is ambiguous}}
}

// Test overloading based on qualification vs. no qualification
// conversion.
int* quals1(int const * p);
char* quals1(int * p);

int* quals2(int const * const * pp);
char* quals2(int * * pp);

int* quals3(int const * * const * ppp);
char* quals3(int *** ppp);

void test_quals(int * p, int * * pp, int * * * ppp) {
  char* q1 = quals1(p);
  char* q2 = quals2(pp);
  char* q3 = quals3(ppp);
}

// Test overloading based on qualification ranking (C++ 13.3.2)p3.
int* quals_rank1(int const * p);
float* quals_rank1(int const volatile *p);
char* quals_rank1(char*);
double* quals_rank1(const char*);

int* quals_rank2(int const * const * pp);
float* quals_rank2(int * const * pp);

void quals_rank3(int const * const * const volatile * p); // expected-note{{candidate function}}
void quals_rank3(int const * const volatile * const * p); // expected-note{{candidate function}}

void quals_rank3(int const *); // expected-note{{candidate function}}
void quals_rank3(int volatile *); // expected-note{{candidate function}}

void test_quals_ranking(int * p, int volatile *pq, int * * pp, int * * * ppp) {
  int* q1 = quals_rank1(p);
  float* q2 = quals_rank1(pq); 
  double* q3 = quals_rank1("string literal");
  char a[17];
  const char* ap = a;
  char* q4 = quals_rank1(a);
  double* q5 = quals_rank1(ap);

  float* q6 = quals_rank2(pp);

  quals_rank3(ppp); // expected-error {{call to 'quals_rank3' is ambiguous}}

  quals_rank3(p); // expected-error {{call to 'quals_rank3' is ambiguous}}
  quals_rank3(pq);
}

// Test overloading based on derived-to-base conversions
class A { };
class B : public A { };
class C : public B { };
class D : public C { };

int* derived1(A*);
char* derived1(const A*);
float* derived1(void*);

int* derived2(A*);
float* derived2(B*);

int* derived3(A*);
float* derived3(const B*);
char* derived3(C*);

void test_derived(B* b, B const* bc, C* c, const C* cc, void* v, D* d) {
  int* d1 = derived1(b);
  char* d2 = derived1(bc);
  int* d3 = derived1(c);
  char* d4 = derived1(cc);
  float* d5 = derived1(v);

  float* d6 = derived2(b);
  float* d7 = derived2(c);

  char* d8 = derived3(d);
}

void derived4(C*); // expected-note{{candidate function not viable: cannot convert from base class pointer 'A *' to derived class pointer 'C *' for 1st argument}}

void test_base(A* a) {
  derived4(a); // expected-error{{no matching function for call to 'derived4}}
}

// Test overloading of references. 
// (FIXME: tests binding to determine candidate sets, not overload 
//  resolution per se).
int* intref(int&);
float* intref(const int&);

void intref_test() {
  float* ir1 = intref(5);
  float* ir2 = intref(5.5); // expected-warning{{implicit conversion turns literal floating-point number into integer}}
}

void derived5(C&); // expected-note{{candidate function not viable: cannot bind base class object of type 'A' to derived class reference 'C &' for 1st argument}}

void test_base(A& a) {
  derived5(a); // expected-error{{no matching function for call to 'derived5}}
}

// Test reference binding vs. standard conversions.
int& bind_vs_conv(const double&);
float& bind_vs_conv(int);

void bind_vs_conv_test()
{
  int& i1 = bind_vs_conv(1.0f);
  float& f1 = bind_vs_conv((short)1);
}

// Test that cv-qualifiers get subsumed in the reference binding.
struct X { };
struct Y { };
struct Z : X, Y { };

int& cvqual_subsume(X&); // expected-note{{candidate function}}
float& cvqual_subsume(const Y&); // expected-note{{candidate function}}

int& cvqual_subsume2(const X&); // expected-note{{candidate function}}
float& cvqual_subsume2(const volatile Y&); // expected-note{{candidate function}}

Z get_Z();

void cvqual_subsume_test(Z z) {
  cvqual_subsume(z); // expected-error{{call to 'cvqual_subsume' is ambiguous}}
  int& x = cvqual_subsume2(get_Z()); // expected-error{{call to 'cvqual_subsume2' is ambiguous}}
}

// Test overloading with cv-qualification differences in reference
// binding.
int& cvqual_diff(X&);
float& cvqual_diff(const X&);

void cvqual_diff_test(X x, Z z) {
  int& i1 = cvqual_diff(x);
  int& i2 = cvqual_diff(z);
}

// Test overloading with derived-to-base differences in reference
// binding.
struct Z2 : Z { };

int& db_rebind(X&);
long& db_rebind(Y&);
float& db_rebind(Z&);

void db_rebind_test(Z2 z2) {
  float& f1 = db_rebind(z2);
}

class string { };
class opt : public string { };

struct SR {
  SR(const string&);
};

void f(SR) { }

void g(opt o) {
  f(o);
}


namespace PR5756 {
  int &a(void*, int);
  float &a(void*, float);
  void b() { 
    int &ir = a(0,0);
    (void)ir;
  }
}

// Tests the exact text used to note the candidates
namespace test1 {
  template <class T> void foo(T t, unsigned N); // expected-note {{candidate function [with T = int] not viable: no known conversion from 'const char [6]' to 'unsigned int' for 2nd argument}}
  void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'const char [6]' to 'char' for 2nd argument}} 
  void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}}
  void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}}
  void foo(int n, const char *s, int t, int u = 0); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}}

  // PR 11857
  void foo(int n); // expected-note {{candidate function not viable: requires single argument 'n', but 2 arguments were provided}}
  void foo(unsigned n = 10); // expected-note {{candidate function not viable: allows at most single argument 'n', but 2 arguments were provided}}
  void bar(int n, int u = 0); // expected-note {{candidate function not viable: requires at least argument 'n', but no arguments were provided}}
  void baz(int n = 0, int u = 0); // expected-note {{candidate function not viable: requires at most 2 arguments, but 3 were provided}}

  void test() {
    foo(4, "hello"); //expected-error {{no matching function for call to 'foo'}}
    bar(); //expected-error {{no matching function for call to 'bar'}}
    baz(3, 4, 5); // expected-error {{no matching function for call to 'baz'}}
  }
}

// PR 6014
namespace test2 {
  struct QFixed {
    QFixed(int i);
    QFixed(long i);
  };

  bool operator==(const QFixed &f, int i);

  class qrgb666 {
    inline operator unsigned int () const;

    inline bool operator==(const qrgb666 &v) const;
    inline bool operator!=(const qrgb666 &v) const { return !(*this == v); }
  };
}

// PR 6117
namespace test3 {
  struct Base {};
  struct Incomplete;

  void foo(Base *); // expected-note 2 {{cannot convert argument of incomplete type}}
  void foo(Base &); // expected-note 2 {{cannot convert argument of incomplete type}}

  void test(Incomplete *P) {
    foo(P); // expected-error {{no matching function for call to 'foo'}}
    foo(*P); // expected-error {{no matching function for call to 'foo'}}
  }
}

namespace DerivedToBaseVsVoid {
  struct A { };
  struct B : A { };
  
  float &f(void *);
  int &f(const A*);
  
  void g(B *b) {
    int &ir = f(b);
  }
}

// PR 6398 + PR 6421
namespace test4 {
  class A;
  class B {
    static void foo(); // expected-note {{not viable}}
    static void foo(int*); // expected-note {{not viable}}
    static void foo(long*); // expected-note {{not viable}}

    void bar(A *a) { 
      foo(a); // expected-error {{no matching function for call}}
    }
  };
}

namespace DerivedToBase {
  struct A { };
  struct B : A { };
  struct C : B { };
  
  int &f0(const A&);
  float &f0(B);
  
  void g() {
    float &fr = f0(C());
  }
}

namespace PR6483 {
  struct X0 {
    operator const unsigned int & () const;
  };

  struct X1 {
    operator unsigned int & () const;
  };

  void f0(const bool &);
  void f1(bool &); // expected-note 2{{not viable}}

  void g(X0 x0, X1 x1) {
    f0(x0);
    f1(x0); // expected-error{{no matching function for call}}
    f0(x1);
    f1(x1); // expected-error{{no matching function for call}}
  }  
}

namespace PR6078 {
  struct A {
    A(short); // expected-note{{candidate constructor}}
    A(long); // expected-note{{candidate constructor}}
  };
  struct S {
    typedef void ft(A);
    operator ft*();
  };

  void f() {
    S()(0); // expected-error{{conversion from 'int' to 'PR6078::A' is ambiguous}}
  }
}

namespace PR6177 {
  struct String { String(char const*); };

  void f(bool const volatile&); // expected-note{{passing argument to parameter here}}
  void f(String);

  void g() { f(""); } // expected-error{{volatile lvalue reference to type 'const volatile bool' cannot bind to a value of unrelated type 'const char [1]'}}
}

namespace PR7095 {
  struct X { };

  struct Y {
    operator const X*();

  private:
    operator X*();
  };

  void f(const X *);
  void g(Y y) { f(y); }
}

namespace PR7224 {
  class A {};
  class B : public A {};

  int &foo(A *const d);
  float &foo(const A *const d);

  void bar()
  {
    B *const d = 0;
    B const *const d2 = 0;
    int &ir = foo(d);
    float &fr = foo(d2);
  }
}

namespace NontrivialSubsequence {
  struct X0;

  class A {
    operator X0 *();
  public:
    operator const X0 *();
  };
 
  A a;
  void foo( void const * );

  void g() {
    foo(a);
  }
}

// rdar://rdar8499524
namespace rdar8499524 {
  struct W {};
  struct S {
      S(...);
  };

  void g(const S&);
  void f() {
    g(W());
  }
}

namespace rdar9173984 {
  template <typename T, unsigned long N> int &f(const T (&)[N]);
  template <typename T> float &f(const T *);

  void test() {
    int arr[2] = {0, 0};
    int *arrp = arr;
    int &ir = f(arr);
    float &fr = f(arrp);
  }
}

namespace PR9507 {
  void f(int * const&); // expected-note{{candidate function}}
  void f(int const(&)[1]); // expected-note{{candidate function}}
 
  int main() {
    int n[1];
    f(n); // expected-error{{call to 'f' is ambiguous}}
  }
}

namespace rdar9803316 {
  void foo(float);
  int &foo(int);

  void bar() {
    int &ir = (&foo)(0);
  }
}

namespace IncompleteArg {
  // Ensure that overload resolution attempts to complete argument types when
  // performing ADL.
  template<typename T> struct S {
    friend int f(const S&);
  };
  extern S<int> s;
  int k = f(s);

  template<typename T> struct Op {
    friend bool operator==(const Op &, const Op &);
  };
  extern Op<char> op;
  bool b = op == op;

  // ... and not in other cases! Nothing here requires U<int()> to be complete.
  // (Note that instantiating U<int()> will fail.)
  template<typename T> struct U {
    T t;
  };
  struct Consumer {
    template<typename T>
    int operator()(const U<T> &);
  };
  template<typename T> U<T> &make();
  Consumer c;
  int n = sizeof(c(make<int()>()));
}

namespace PR12142 {
  void fun(int (*x)[10]); // expected-note{{candidate function not viable: 1st argument ('const int (*)[10]') would lose const qualifier}}
  void g() { fun((const int(*)[10])0); } // expected-error{{no matching function for call to 'fun'}}
}