// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s

namespace std {
  class type_info {};
}

void one() { }
void two() { } // expected-note 4{{possible target for call}}
void two(int) { } // expected-note 4{{possible target for call}}

template<class T> void twoT() { } // expected-note 5{{possible target for call}}
template<class T> void twoT(int) { } // expected-note 5{{possible target for call}}

template<class T> void oneT() { }
template<class T, class U> void oneT(U) { }
/*
The target can be
 an object or reference being initialized (8.5, 8.5.3),
 the left side of an assignment (5.17),
 a parameter of a function (5.2.2),
 a parameter of a user-defined operator (13.5),
 the return value of a function, operator function, or conversion (6.6.3),
 an explicit type conversion (5.2.3, 5.2.9, 5.4), or
 a non-type template-parameter (14.3.2)
*/
//#include <typeinfo>
template<void (*p)(int)> struct test { };

int main()
{
   one;         // expected-warning {{expression result unused}}
   two;         // expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
   oneT<int>;  // expected-warning {{expression result unused}}
   twoT<int>;  // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
   typeid(oneT<int>); // expected-warning{{expression result unused}}
  sizeof(oneT<int>); // expected-error {{invalid application of 'sizeof' to a function type}}
  sizeof(twoT<int>); //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
  decltype(oneT<int>)* fun = 0;
  
  *one;    // expected-warning {{expression result unused}}
  *oneT<int>;   // expected-warning {{expression result unused}}
  *two;  //expected-error {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{indirection requires pointer operand}}
  *twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
  !oneT<int>;  // expected-warning {{expression result unused}} expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
  +oneT<int>;  // expected-warning {{expression result unused}}
  -oneT<int>;  //expected-error {{invalid argument type}}
  oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
                    // expected-note {{use '=' to turn this equality comparison into an assignment}} \
                    // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
                    // expected-note {{prefix with the address-of operator to silence this warning}}
  0 == oneT<int>;   // expected-warning {{equality comparison result unused}} \
                    // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
                    // expected-note {{prefix with the address-of operator to silence this warning}}
  0 != oneT<int>;   // expected-warning {{inequality comparison result unused}} \
                    // expected-warning {{comparison of function 'oneT<int>' not equal to a null pointer is always true}} \
                    // expected-note {{prefix with the address-of operator to silence this warning}}
  (false ? one : oneT<int>);   // expected-warning {{expression result unused}}
  void (*p1)(int); p1 = oneT<int>;
  
  int i = (int) (false ? (void (*)(int))twoT<int> : oneT<int>); //expected-error {{incompatible operand}}
  (twoT<int>) == oneT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
  bool b = oneT<int>; // expected-warning {{address of function 'oneT<int>' will always evaluate to 'true'}} expected-note {{prefix with the address-of operator to silence this warning}}
  void (*p)() = oneT<int>;
  test<oneT<int> > ti;
  void (*u)(int) = oneT<int>;

  b = (void (*)()) twoT<int>;
  
  one < one; //expected-warning {{self-comparison always evaluates to false}} \
             //expected-warning {{relational comparison result unused}}         

  oneT<int> < oneT<int>;  //expected-warning {{self-comparison always evaluates to false}} \
                          //expected-warning {{relational comparison result unused}}

  two < two; //expected-error 2 {{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{invalid operands to binary expression ('void' and 'void')}}
  twoT<int> < twoT<int>; //expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} {{cannot resolve overloaded function 'twoT' from context}}
  oneT<int> == 0;   // expected-warning {{equality comparison result unused}} \
                    // expected-note {{use '=' to turn this equality comparison into an assignment}} \
                    // expected-warning {{comparison of function 'oneT<int>' equal to a null pointer is always false}} \
                    // expected-note {{prefix with the address-of operator to silence this warning}}

}

struct rdar9108698 {
  template<typename> void f(); // expected-note{{possible target for call}}
};

void test_rdar9108698(rdar9108698 x) {
  x.f<int>; // expected-error{{reference to non-static member function must be called}}
}
