test/SemaCXX/overloaded-operator.cpp

   1 // RUN: clang-cc -fsyntax-only -verify %s
   2 class X { };
   3
   4 X operator+(X, X);
   5
   6 void f(X x) {
   7   x = x + x;
   8 }
   9
  10 struct Y;
  11 struct Z;
  12
  13 struct Y {
  14   Y(const Z&);
  15 };
  16
  17 struct Z {
  18   Z(const Y&);
  19 };
  20
  21 Y operator+(Y, Y);
  22 bool operator-(Y, Y); // expected-note{{candidate function}}
  23 bool operator-(Z, Z); // expected-note{{candidate function}}
  24
  25 void g(Y y, Z z) {
  26   y = y + z;
  27   bool b = y - z; // expected-error{{use of overloaded operator '-' is ambiguous; candidates are:}}
  28 }
  29
  30 struct A {
  31   bool operator==(Z&); // expected-note{{candidate function}}
  32 };
  33
  34 A make_A();
  35
  36 bool operator==(A&, Z&); // expected-note{{candidate function}}
  37
  38 void h(A a, const A ac, Z z) {
  39   make_A() == z;
  40   a == z; // expected-error{{use of overloaded operator '==' is ambiguous; candidates are:}}
  41   ac == z; // expected-error{{invalid operands to binary expression ('struct A const' and 'struct Z')}}
  42 }
  43
  44 struct B {
  45   bool operator==(const B&) const;
  46
  47   void test(Z z) {
  48     make_A() == z;
  49   }
  50 };
  51
  52 enum Enum1 { };
  53 enum Enum2 { };
  54
  55 struct E1 {
  56   E1(Enum1) { }
  57 };
  58
  59 struct E2 {
  60   E2(Enum2);
  61 };
  62
  63 // C++ [over.match.oper]p3 - enum restriction.
  64 float& operator==(E1, E2);
  65
  66 void enum_test(Enum1 enum1, Enum2 enum2, E1 e1, E2 e2) {
  67   float &f1 = (e1 == e2);
  68   float &f2 = (enum1 == e2);
  69   float &f3 = (e1 == enum2);
  70   float &f4 = (enum1 == enum2);  // expected-error{{non-const lvalue reference to type 'float' cannot be initialized with a temporary of type 'bool'}}
  71 }
  72
  73
  74 struct PostInc {
  75   PostInc operator++(int);
  76   PostInc& operator++();
  77 };
  78
  79 struct PostDec {
  80   PostDec operator--(int);
  81   PostDec& operator--();
  82 };
  83
  84 void incdec_test(PostInc pi, PostDec pd) {
  85   const PostInc& pi1 = pi++;
  86   const PostDec& pd1 = pd--;
  87   PostInc &pi2 = ++pi;
  88   PostDec &pd2 = --pd;
  89 }
  90
  91 struct SmartPtr {
  92   int& operator*();
  93   long& operator*() const volatile;
  94 };
  95
  96 void test_smartptr(SmartPtr ptr, const SmartPtr cptr,
  97                    const volatile SmartPtr cvptr) {
  98   int &ir = *ptr;
  99   long &lr = *cptr;
 100   long &lr2 = *cvptr;
 101 }
 102
 103
 104 struct ArrayLike {
 105   int& operator[](int);
 106 };
 107
 108 void test_arraylike(ArrayLike a) {
 109   int& ir = a[17];
 110 }
 111
 112 struct SmartRef {
 113   int* operator&();
 114 };
 115
 116 void test_smartref(SmartRef r) {
 117   int* ip = &r;
 118 }
 119
 120 bool& operator,(X, Y);
 121
 122 void test_comma(X x, Y y) {
 123   bool& b1 = (x, y);
 124   X& xr = (x, x);
 125 }
 126
 127 struct Callable {
 128   int& operator()(int, double = 2.71828); // expected-note{{candidate function}}
 129   float& operator()(int, double, long, ...); // expected-note{{candidate function}}
 130
 131   double& operator()(float); // expected-note{{candidate function}}
 132 };
 133
 134 struct Callable2 {
 135   int& operator()(int i = 0);
 136   double& operator()(...) const;
 137 };
 138
 139 void test_callable(Callable c, Callable2 c2, const Callable2& c2c) {
 140   int &ir = c(1);
 141   float &fr = c(1, 3.14159, 17, 42);
 142
 143   c(); // expected-error{{no matching function for call to object of type 'struct Callable'; candidates are:}}
 144
 145   double &dr = c(1.0f);
 146
 147   int &ir2 = c2();
 148   int &ir3 = c2(1);
 149   double &fr2 = c2c();
 150 }
 151
 152 typedef float FLOAT;
 153 typedef int& INTREF;
 154 typedef INTREF Func1(FLOAT, double);
 155 typedef float& Func2(int, double);
 156
 157 struct ConvertToFunc {
 158   operator Func1*(); // expected-note{{conversion candidate of type 'INTREF (*)(FLOAT, double)'}}
 159   operator Func2&(); // expected-note{{conversion candidate of type 'float &(&)(int, double)'}}
 160   void operator()();
 161 };
 162
 163 void test_funcptr_call(ConvertToFunc ctf) {
 164   int &i1 = ctf(1.0f, 2.0);
 165   float &f2 = ctf((short int)1, 1.0f);
 166   ctf((long int)17, 2.0); // expected-error{{error: call to object of type 'struct ConvertToFunc' is ambiguous; candidates are:}}
 167   ctf();
 168 }
 169
 170 struct HasMember {
 171   int m;
 172 };
 173
 174 struct Arrow1 {
 175   HasMember* operator->();
 176 };
 177
 178 struct Arrow2 {
 179   Arrow1 operator->(); // expected-note{{candidate function}}
 180 };
 181
 182 void test_arrow(Arrow1 a1, Arrow2 a2, const Arrow2 a3) {
 183   int &i1 = a1->m;
 184   int &i2 = a2->m;
 185   a3->m; // expected-error{{no viable overloaded 'operator->'; candidate is}}
 186 }
 187
 188 struct CopyConBase {
 189 };
 190
 191 struct CopyCon : public CopyConBase {
 192   CopyCon(const CopyConBase &Base);
 193
 194   CopyCon(const CopyConBase *Base) {
 195     *this = *Base;
 196   }
 197 };
 198
 199 namespace N {
 200   struct X { };
 201 }
 202
 203 namespace M {
 204   N::X operator+(N::X, N::X);
 205 }
 206
 207 namespace M {
 208   void test_X(N::X x) {
 209     (void)(x + x);
 210   }
 211 }