blob: 4fa376aed036b6f6d8fcaab961862eb4df8f4ec6 [file] [log] [blame]
// RUN: %clang_cc1 -fsyntax-only -fshow-overloads=best -verify -triple x86_64-linux-gnu %s
// RUN: %clang_cc1 -fsyntax-only -fshow-overloads=best -verify -triple x86_64-linux-gnu -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -fshow-overloads=best -verify -triple x86_64-linux-gnu -std=c++11 %s
struct yes;
struct no;
struct Short {
operator short();
};
struct Long {
operator long();
};
enum E1 { };
struct Enum1 {
operator E1();
};
enum E2 { };
struct Enum2 {
operator E2();
};
struct X {
void f();
};
typedef void (X::*pmf)();
struct Xpmf {
operator pmf();
};
yes& islong(long);
yes& islong(unsigned long); // FIXME: shouldn't be needed
no& islong(int);
void f(Short s, Long l, Enum1 e1, Enum2 e2, Xpmf pmf) {
// C++ [over.built]p8
int i1 = +e1;
int i2 = -e2;
// C++ [over.built]p10:
int i3 = ~s;
bool b1 = !s;
// C++ [over.built]p12
(void)static_cast<yes&>(islong(s + l));
(void)static_cast<no&>(islong(s + s));
// C++ [over.built]p16
(void)(pmf == &X::f);
(void)(pmf == 0);
// C++ [over.built]p17
(void)static_cast<yes&>(islong(s % l));
(void)static_cast<yes&>(islong(l << s));
(void)static_cast<no&>(islong(s << l));
(void)static_cast<yes&>(islong(e1 % l));
// FIXME: should pass (void)static_cast<no&>(islong(e1 % e2));
}
struct BoolRef {
operator bool&();
};
struct ShortRef { // expected-note{{candidate function (the implicit copy assignment operator) not viable}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note@-2 {{candidate function (the implicit move assignment operator) not viable}}
#endif
operator short&();
};
struct LongRef {
operator volatile long&();
};
struct FloatRef {
operator float&();
};
struct XpmfRef { // expected-note{{candidate function (the implicit copy assignment operator) not viable}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note@-2 {{candidate function (the implicit move assignment operator) not viable}}
#endif
operator pmf&();
};
struct E2Ref {
operator E2&();
};
void g(BoolRef br, ShortRef sr, LongRef lr, FloatRef fr, E2Ref e2_ref, XpmfRef pmf_ref) {
// C++ [over.built]p3
short s1 = sr++;
// C++ [over.built]p4
long l1 = lr--;
// C++ [over.built]p4
float f1 = fr--;
// C++ [over.built]p4
bool b2 = br--; // expected-error{{cannot decrement value of type 'BoolRef'}}
// C++ [over.built]p18
short& sr1 = (sr *= lr);
volatile long& lr1 = (lr *= sr);
// C++ [over.built]p20:
E2 e2r2;
e2r2 = e2_ref;
pmf &pmr = (pmf_ref = &X::f); // expected-error{{no viable overloaded '='}}
pmf pmr2;
pmr2 = pmf_ref;
// C++ [over.built]p22
short& sr2 = (sr %= lr);
volatile long& lr2 = (lr <<= sr);
bool b1 = (sr && lr) || (sr || lr);
}
struct VolatileIntPtr {
operator int volatile *();
};
struct ConstIntPtr {
operator int const *();
};
struct VolatileIntPtrRef {
operator int volatile *&();
};
struct ConstIntPtrRef {
operator int const *&();
};
void test_with_ptrs(VolatileIntPtr vip, ConstIntPtr cip, ShortRef sr,
VolatileIntPtrRef vipr, ConstIntPtrRef cipr) {
const int& cir1 = cip[sr];
const int& cir2 = sr[cip];
volatile int& vir1 = vip[sr];
volatile int& vir2 = sr[vip];
bool b1 = (vip == cip);
long p1 = vip - cip;
// C++ [over.built]p5:
int volatile *vip1 = vipr++;
int const *cip1 = cipr++;
int volatile *&vipr1 = ++vipr;
int const *&cipr1 = --cipr;
// C++ [over.built]p6:
int volatile &ivr = *vip;
// C++ [over.built]p8:
int volatile *vip2 = +vip;
int i1 = +sr;
int i2 = -sr;
// C++ [over.built]p13:
int volatile &ivr2 = vip[17];
int const &icr2 = 17[cip];
}
// C++ [over.match.open]p4
void test_assign_restrictions(ShortRef& sr) {
sr = (short)0; // expected-error{{no viable overloaded '='}}
}
struct Base { };
struct Derived1 : Base { };
struct Derived2 : Base { };
template<typename T>
struct ConvertibleToPtrOf {
operator T*();
};
bool test_with_base_ptrs(ConvertibleToPtrOf<Derived1> d1,
ConvertibleToPtrOf<Derived2> d2) {
return d1 == d2; // expected-error{{invalid operands}}
}
// DR425
struct A {
template< typename T > operator T() const;
};
void test_dr425(A a) {
// FIXME: lots of candidates here!
(void)(1.0f * a); // expected-error{{ambiguous}} \
// expected-note 4{{candidate}} \
// expected-note {{remaining 140 candidates omitted; pass -fshow-overloads=all to show them}}
}
// pr5432
enum e {X};
const int a[][2] = {{1}};
int test_pr5432() {
return a[X][X];
}
void f() {
(void)__extension__(A());
}
namespace PR7319 {
typedef enum { Enum1, Enum2, Enum3 } MyEnum;
template<typename X> bool operator>(const X &inX1, const X &inX2);
void f() {
MyEnum e1, e2;
if (e1 > e2) {}
}
}
namespace PR8477 {
struct Foo {
operator bool();
operator const char *();
};
bool doit() {
Foo foo;
long long zero = 0;
(void)(foo + zero);
(void)(foo - zero);
(void)(zero + foo);
(void)(zero[foo]);
(void)(foo - foo); // expected-error{{use of overloaded operator '-' is ambiguous}} \
// expected-note 4{{built-in candidate operator-}} \
// expected-note{{candidates omitted}}
return foo[zero] == zero;
}
}
namespace PR7851 {
struct X {
operator const void *() const;
operator void *();
operator const unsigned *() const;
operator unsigned *();
};
void f() {
X x;
x[0] = 1;
*x = 0;
(void)(x - x);
}
}
namespace PR12854 {
enum { size = 1 };
void plus_equals() {
int* __restrict py;
py += size;
}
struct RestrictInt {
operator int* __restrict &();
};
void user_conversions(RestrictInt ri) {
++ri;
--ri;
ri++;
ri--;
}
}
namespace PR12964 {
struct X { operator __int128() const; } x;
bool a = x == __int128(0);
bool b = x == 0;
struct Y { operator unsigned __int128() const; } y;
bool c = y == __int128(0);
bool d = y == 0;
bool e = x == y;
}