diff options
Diffstat (limited to 'clang/test/CXX/over')
20 files changed, 750 insertions, 0 deletions
diff --git a/clang/test/CXX/over/over.built/p1.cpp b/clang/test/CXX/over/over.built/p1.cpp new file mode 100644 index 0000000..6000f5b --- /dev/null +++ b/clang/test/CXX/over/over.built/p1.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +enum E1 { one }; +enum E2 { two }; + +bool operator >= (E1, E1) { + return false; +} + +bool operator >= (E1, const E2) { + return false; +} + +bool test(E1 a, E1 b, E2 c) { + return a >= b || a >= c; +} diff --git a/clang/test/CXX/over/over.built/p23.cpp b/clang/test/CXX/over/over.built/p23.cpp new file mode 100644 index 0000000..4125521 --- /dev/null +++ b/clang/test/CXX/over/over.built/p23.cpp @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +struct Variant { + template <typename T> operator T(); +}; + +Variant getValue(); + +void testVariant() { + bool ret1 = getValue() || getValue(); + bool ret2 = getValue() && getValue(); + bool ret3 = !getValue(); +} + +struct ExplicitVariant { + template <typename T> explicit operator T(); +}; + +ExplicitVariant getExplicitValue(); + +void testExplicitVariant() { + bool ret1 = getExplicitValue() || getExplicitValue(); + bool ret2 = getExplicitValue() && getExplicitValue(); + bool ret3 = !getExplicitValue(); +} diff --git a/clang/test/CXX/over/over.built/p25.cpp b/clang/test/CXX/over/over.built/p25.cpp new file mode 100644 index 0000000..aea3854 --- /dev/null +++ b/clang/test/CXX/over/over.built/p25.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +enum class Color { Red, Green, Blue }; + +struct ConvertsToColorA { + operator Color(); +}; + +struct ConvertsToColorB { + operator Color(); +}; + +Color foo(bool cond, ConvertsToColorA ca, ConvertsToColorB cb) { + return cond? ca : cb; +} diff --git a/clang/test/CXX/over/over.load/p2-0x.cpp b/clang/test/CXX/over/over.load/p2-0x.cpp new file mode 100644 index 0000000..cf38741 --- /dev/null +++ b/clang/test/CXX/over/over.load/p2-0x.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// Member function declarations with the same name and the same +// parameter-type-list as well as mem- ber function template +// declarations with the same name, the same parameter-type-list, and +// the same template parameter lists cannot be overloaded if any of +// them, but not all, have a ref-qualifier (8.3.5). + +class Y { + void h() &; + void h() const &; + void h() &&; + void i() &; // expected-note{{previous declaration}} + void i() const; // expected-error{{cannot overload a member function without a ref-qualifier with a member function with ref-qualifier '&'}} + + template<typename T> void f(T*) &; + template<typename T> void f(T*) &&; + + template<typename T> void g(T*) &; // expected-note{{previous declaration}} + template<typename T> void g(T*); // expected-error{{cannot overload a member function without a ref-qualifier with a member function with ref-qualifier '&'}} + + void k(); // expected-note{{previous declaration}} + void k() &&; // expected-error{{cannot overload a member function with ref-qualifier '&&' with a member function without a ref-qualifier}} +}; diff --git a/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp new file mode 100644 index 0000000..ea059ce --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// rdar://problem/11120365 +namespace test0 { + template <class T> struct A { + static void foo(const T &t) {} + static void foo(T &&t) { + t.foo(); // expected-error {{member reference base type 'int' is not a structure or union}} + } + }; + + void test() { + A<int>::foo({}); // expected-note {{requested here}} + } +} diff --git a/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp new file mode 100644 index 0000000..1c71468 --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +namespace PR6285 { + template<typename T> struct identity + { typedef T type; }; + + struct D { + template<typename T = short> + operator typename identity<T>::type(); // expected-note{{candidate}} + }; + + int f() { return D(); } // expected-error{{no viable conversion}} +} + diff --git a/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp b/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp new file mode 100644 index 0000000..3971acc --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s +namespace std_example { + int i; + int f1(); + int&& f2(); + int &g(const int &); + float &g(const int &&); + int &j = g(i); + float &k = g(f1()); + float &l = g(f2()); + + int &g2(const int &); + float &g2(int &&); + int &j2 = g2(i); + float &k2 = g2(f1()); + float &l2 = g2(f2()); + + // FIXME: We don't support ref-qualifiers yet. +#if 0 + struct A { + A& operator<<(int); + void p() &; + void p() &&; + }; + + A& operator<<(A&&, char); + A() << 1; + A() << 'c'; + A a; + a << 1; + a << 'c'; + A().p(); + a.p(); +#endif +} + +template<typename T> +struct remove_reference { + typedef T type; +}; + +template<typename T> +struct remove_reference<T&> { + typedef T type; +}; + +template<typename T> +struct remove_reference<T&&> { + typedef T type; +}; + +namespace FunctionReferencesOverloading { + template<typename T> int &f(typename remove_reference<T>::type&); + template<typename T> float &f(typename remove_reference<T>::type&&); + + void test_f(int (&func_ref)(int)) { + int &ir = f<int (&)(int)>(func_ref); + } +} diff --git a/clang/test/CXX/over/over.match/over.match.best/p1.cpp b/clang/test/CXX/over/over.match/over.match.best/p1.cpp new file mode 100644 index 0000000..5c315a7 --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.best/p1.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<typename T> int &f0(T*, int); +float &f0(void*, int); + +void test_f0(int* ip, void *vp) { + // One argument is better... + int &ir = f0(ip, 0); + + // Prefer non-templates to templates + float &fr = f0(vp, 0); +} + +// Partial ordering of function template specializations will be tested +// elsewhere +// FIXME: Initialization by user-defined conversion is tested elsewhere diff --git a/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp b/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp new file mode 100644 index 0000000..31a679f --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify + +namespace ExplicitConv { + struct X { }; // expected-note 2{{candidate constructor}} + + struct Y { + explicit operator X() const; + }; + + void test(const Y& y) { + X x(static_cast<X>(y)); + X x2((X)y); + X x3 = y; // expected-error{{no viable conversion from 'const ExplicitConv::Y' to 'ExplicitConv::X'}} + } +} + +namespace DR899 { + struct C { }; // expected-note 2 {{candidate constructor}} + + struct A { + explicit operator int() const; + explicit operator C() const; + }; + + struct B { + int i; + B(const A& a): i(a) { } + }; + + int main() { + A a; + int i = a; // expected-error{{no viable conversion}} + int j(a); + C c = a; // expected-error{{no viable conversion}} + C c2(a); + } +} diff --git a/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp b/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp new file mode 100644 index 0000000..3845af0 --- /dev/null +++ b/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp @@ -0,0 +1,70 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +template<typename T> T &lvalue(); +template<typename T> T &&xvalue(); +template<typename T> T prvalue(); + +struct X0 { + int &f() &; + float &f() &&; + + template<typename T> int &ft(T) &; + template<typename T> float &ft(T) &&; + + typedef int &(*func_int_ref)(); + typedef float &(*func_float_ref)(); + + operator func_int_ref() &; + operator func_float_ref() &&; + + void g(); + + int &operator+(const X0&) &; + float &operator+(const X0&) &&; + + template<typename T> int &operator+(const T&) &; + template<typename T> float &operator+(const T&) &&; + + int &h() const&; + float &h() &&; + int &h2() const&; + float &h2() const&&; +}; + +void X0::g() { + int &ir1 = f(); + int &ir2 = X0::f(); +} + +void test_ref_qualifier_binding() { + int &ir1 = lvalue<X0>().f(); + float &fr1 = xvalue<X0>().f(); + float &fr2 = prvalue<X0>().f(); + int &ir2 = lvalue<X0>().ft(1); + float &fr3 = xvalue<X0>().ft(2); + float &fr4 = prvalue<X0>().ft(3); +} + +void test_ref_qualifier_binding_with_surrogates() { + int &ir1 = lvalue<X0>()(); + float &fr1 = xvalue<X0>()(); + float &fr2 = prvalue<X0>()(); +} + +void test_ref_qualifier_binding_operators() { + int &ir1 = lvalue<X0>() + prvalue<X0>(); + float &fr1 = xvalue<X0>() + prvalue<X0>(); + float &fr2 = prvalue<X0>() + prvalue<X0>(); + int &ir2 = lvalue<X0>() + 1; + float &fr3 = xvalue<X0>() + 2; + float &fr4 = prvalue<X0>() + 3; +} + +void test_ref_qualifier_overloading() { + int &ir1 = lvalue<X0>().h(); + float &fr1 = xvalue<X0>().h(); + float &fr2 = prvalue<X0>().h(); + int &ir2 = lvalue<X0>().h2(); + float &fr3 = xvalue<X0>().h2(); + float &fr4 = prvalue<X0>().h2(); +} diff --git a/clang/test/CXX/over/over.oper/over.literal/p2.cpp b/clang/test/CXX/over/over.oper/over.literal/p2.cpp new file mode 100644 index 0000000..c012104 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p2.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +void operator "" _a(const char *); + +namespace N { + using ::operator "" _a; + + void operator "" _b(const char *); +} + +using N::operator "" _b; + +class C { + void operator "" _c(const char *); // expected-error {{must be in a namespace or global scope}} + + static void operator "" _c(unsigned long long); // expected-error {{must be in a namespace or global scope}} + + friend void operator "" _d(const char *); +}; + +int operator "" _e; // expected-error {{cannot be the name of a variable}} + +void f() { + int operator "" _f; // expected-error {{cannot be the name of a variable}} +} + +extern "C++" { + void operator "" _g(const char *); +} + +template<char...> void operator "" _h() {} + +template<> void operator "" _h<'a', 'b', 'c'>() {} + +template void operator "" _h<'a', 'b', 'c', 'd'>(); diff --git a/clang/test/CXX/over/over.oper/over.literal/p3.cpp b/clang/test/CXX/over/over.oper/over.literal/p3.cpp new file mode 100644 index 0000000..674ace9 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p3.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +using size_t = decltype(sizeof(int)); + +// Acceptable parameter declarations +char operator "" _a(const char *); +char operator "" _a(const char []); +char operator "" _a(unsigned long long); +char operator "" _a(long double); +char operator "" _a(char); +char operator "" _a(const volatile char); +char operator "" _a(wchar_t); +char operator "" _a(char16_t); +char operator "" _a(char32_t); +char operator "" _a(const char *, size_t); +char operator "" _a(const wchar_t *, size_t); +char operator "" _a(const char16_t *, size_t); +char operator "" _a(const char32_t *, size_t); +char operator "" _a(const char [32], size_t); + +// Unacceptable parameter declarations +char operator "" _b(); // expected-error {{parameter}} +char operator "" _b(const wchar_t *); // expected-error {{parameter}} +char operator "" _b(long long); // expected-error {{parameter}} +char operator "" _b(double); // expected-error {{parameter}} +char operator "" _b(short); // expected-error {{parameter}} +char operator "" _a(char, int = 0); // expected-error {{parameter}} +char operator "" _b(unsigned short); // expected-error {{parameter}} +char operator "" _b(signed char); // expected-error {{parameter}} +char operator "" _b(unsigned char); // expected-error {{parameter}} +char operator "" _b(const short *, size_t); // expected-error {{parameter}} +char operator "" _b(const unsigned short *, size_t); // expected-error {{parameter}} +char operator "" _b(const signed char *, size_t); // expected-error {{parameter}} +char operator "" _b(const unsigned char *, size_t); // expected-error {{parameter}} +char operator "" _a(const volatile char *, size_t); // expected-error {{parameter}} +char operator "" _a(volatile wchar_t *, size_t); // expected-error {{parameter}} +char operator "" _a(char16_t *, size_t); // expected-error {{parameter}} +char operator "" _a(const char32_t *, size_t, bool = false); // expected-error {{parameter}} +char operator "" _a(const char *, signed long); // expected-error {{parameter}} +char operator "" _a(const char *, size_t = 0); // expected-error {{default argument}} diff --git a/clang/test/CXX/over/over.oper/over.literal/p5.cpp b/clang/test/CXX/over/over.oper/over.literal/p5.cpp new file mode 100644 index 0000000..66f3f97 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p5.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +using size_t = decltype(sizeof(int)); +template<char...> struct S {}; + +template<char...> void operator "" _a(); +template<char... C> S<C...> operator "" _a(); + +template<typename T> struct U { + friend int operator "" _a(const char *, size_t); + // FIXME: It's not entirely clear whether this is intended to be legal. + friend U operator "" _a(const T *, size_t); // expected-error {{parameter}} +}; +template<char...> struct V { + friend void operator "" _b(); // expected-error {{parameter}} +}; + +template<char... C, int N = 0> void operator "" _b(); // expected-error {{parameter}} +template<char... C> void operator "" _b(int N = 0); // expected-error {{parameter}} +template<char, char...> void operator "" _b(); // expected-error {{parameter}} +template<typename T> T operator "" _b(const char *); // expected-error {{parameter}} +template<typename T> int operator "" _b(const T *, size_t); // expected-error {{parameter}} diff --git a/clang/test/CXX/over/over.oper/over.literal/p6.cpp b/clang/test/CXX/over/over.oper/over.literal/p6.cpp new file mode 100644 index 0000000..6bfb856 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p6.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +extern "C" void operator "" _a(const char *); // expected-error {{must have C++ linkage}} +extern "C" template<char...> void operator "" _b(); // expected-error {{must have C++ linkage}} + +extern "C" { + void operator "" _c(const char *); // expected-error {{must have C++ linkage}} + template<char...> void operator "" _d(); // expected-error {{must have C++ linkage}} + namespace N { + void operator "" _e(const char *); // expected-error {{must have C++ linkage}} + template<char...> void operator "" _f(); // expected-error {{must have C++ linkage}} + } +} diff --git a/clang/test/CXX/over/over.oper/over.literal/p7.cpp b/clang/test/CXX/over/over.oper/over.literal/p7.cpp new file mode 100644 index 0000000..72411b9 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p7.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +constexpr int operator "" _a(const char *c) { + return c[0]; +} + +static_assert(operator "" _a("foo") == 'f', ""); + +void puts(const char *); +static inline void operator "" _puts(const char *c) { + puts(c); +} +void f() { + operator "" _puts("foo"); + operator "" _puts("bar"); +} diff --git a/clang/test/CXX/over/over.oper/over.literal/p8.cpp b/clang/test/CXX/over/over.oper/over.literal/p8.cpp new file mode 100644 index 0000000..3f76082 --- /dev/null +++ b/clang/test/CXX/over/over.oper/over.literal/p8.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -std=c++11 %s -verify + +struct string; +namespace std { + using size_t = decltype(sizeof(int)); +} + +void operator "" _km(long double); // ok +string operator "" _i18n(const char*, std::size_t); // ok +// FIXME: This should be accepted once we support UCNs +template<char...> int operator "" \u03C0(); // ok, UCN for lowercase pi // expected-error {{expected identifier}} +float operator ""E(const char *); // expected-error {{C++11 requires a space between literal and identifier}} expected-warning {{reserved}} +float operator " " B(const char *); // expected-error {{must be '""'}} expected-warning {{reserved}} +string operator "" 5X(const char *, std::size_t); // expected-error {{expected identifier}} +double operator "" _miles(double); // expected-error {{parameter}} +template<char...> int operator "" j(const char*); // expected-error {{parameter}} + +// FIXME: Accept this as an extension, with a fix-it to add the space +float operator ""_E(const char *); // expected-error {{C++11 requires a space between the "" and the user-defined suffix in a literal operator}} diff --git a/clang/test/CXX/over/over.over/p1.cpp b/clang/test/CXX/over/over.over/p1.cpp new file mode 100644 index 0000000..10c60da --- /dev/null +++ b/clang/test/CXX/over/over.over/p1.cpp @@ -0,0 +1,94 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +template<typename T> T f0(T); +int f0(int); + +// -- an object or reference being initialized +struct S { + int (*f0)(int); + float (*f1)(float); +}; + +void test_init_f0() { + int (*f0a)(int) = f0; + int (*f0b)(int) = &f0; + int (*f0c)(int) = (f0); + float (*f0d)(float) = f0; + float (*f0e)(float) = &f0; + float (*f0f)(float) = (f0); + int (&f0g)(int) = f0; + int (&f0h)(int) = (f0); + float (&f0i)(float) = f0; + float (&f0j)(float) = (f0); + S s = { f0, f0 }; +} + +// -- the left side of an assignment (5.17), +void test_assign_f0() { + int (*f0a)(int) = 0; + float (*f0b)(float) = 0; + + f0a = f0; + f0a = &f0; + f0a = (f0); + f0b = f0; + f0b = &f0; + f0b = (f0); +} + +// -- a parameter of a function (5.2.2), +void eat_f0(int a(int), float (*b)(float), int (&c)(int), float (&d)(float)); + +void test_pass_f0() { + eat_f0(f0, f0, f0, f0); + eat_f0(&f0, &f0, (f0), (f0)); +} + +// -- a parameter of a user-defined operator (13.5), +struct X { }; +void operator+(X, int(int)); +void operator-(X, float(*)(float)); +void operator*(X, int (&)(int)); +void operator/(X, float (&)(float)); + +void test_operator_pass_f0(X x) { + x + f0; + x + &f0; + x - f0; + x - &f0; + x * f0; + x * (f0); + x / f0; + x / (f0); +} + +// -- the return value of a function, operator function, or conversion (6.6.3), +int (*test_return_f0_a())(int) { return f0; } +int (*test_return_f0_b())(int) { return &f0; } +int (*test_return_f0_c())(int) { return (f0); } +float (*test_return_f0_d())(float) { return f0; } +float (*test_return_f0_e())(float) { return &f0; } +float (*test_return_f0_f())(float) { return (f0); } + +// -- an explicit type conversion (5.2.3, 5.2.9, 5.4), or +void test_convert_f0() { + (void)((int (*)(int))f0); + (void)((int (*)(int))&f0); + (void)((int (*)(int))(f0)); + (void)((float (*)(float))f0); + (void)((float (*)(float))&f0); + (void)((float (*)(float))(f0)); +} + +// -- a non-type template-parameter(14.3.2). +template<int(int)> struct Y0 { }; +template<float(float)> struct Y1 { }; +template<int (&)(int)> struct Y2 { }; +template<float (&)(float)> struct Y3 { }; + +Y0<f0> y0; +Y0<&f0> y0a; +Y1<f0> y1; +Y1<&f0> y1a; +Y2<f0> y2; +Y3<f0> y3; diff --git a/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp b/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp new file mode 100644 index 0000000..e021711 --- /dev/null +++ b/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp @@ -0,0 +1,191 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-bool-conversion %s + +typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t; + +namespace DontResolveTooEarly_WaitForOverloadResolution +{ + template <class T> T* f(int); // #1 + template <class T, class U> T& f(U); // #2 + + void g() { + int *ip = f<int>(1); // calls #1 + } + + template <class T> + T* f2(int); + template <class T, class U> + T& f2(U); + + void g2() { + int*ip = (f2<int>)(1); // ok + } + +} // End namespace + +namespace DontAllowUnresolvedOverloadedExpressionInAnUnusedExpression +{ + void one() { } + template<class T> void oneT() { } + + void two() { } // expected-note 2 {{possible target for call}} + void two(int) { } // expected-note 2 {{possible target for call}} + template<class T> void twoT() { } // expected-note 2 {{possible target for call}} + template<class T> void twoT(T) { } // expected-note 2 {{possible target for call}} + + void check() + { + 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?}} + } + + // check the template function case + template<class T> void check() + { + 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?}} + + } + +} + + template<typename T> + void twoT() { } + template<typename T, typename U> + void twoT(T) { } + + + void two() { }; //expected-note 5{{candidate}} + void two(int) { }; //expected-note 5{{candidate}} + + + + void one() { } + template<class T> + void oneT() { } + + template<class T> + void cant_resolve() { } //expected-note 3{{candidate}} + + template<class T> void cant_resolve(T) { }//expected-note 3{{candidate}} + + +int main() +{ + + { static_cast<void>(one); } + { (void)(one); } + { static_cast<void>(oneT<int>); } + { (void)(oneT<int>); } + + { static_cast<void>(two); } // expected-error {{address of overloaded function 'two' cannot be static_cast to type 'void'}} + { (void)(two); } // expected-error {{address of overloaded function 'two' cannot be cast to type 'void'}} + { static_cast<void>(twoT<int>); } + { (void)(twoT<int>); } + + + { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(oneT<int>); } + { (void) reinterpret_cast<int (*)(char, double)>(oneT<int>); } + { (void) reinterpret_cast<ptrdiff_t>(one); } + { (void) reinterpret_cast<int (*)(char, double)>(one); } + + { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(twoT<int>); } + { (void) reinterpret_cast<int (*)(char, double)>(twoT<int>); } + { (void) reinterpret_cast<void (*)(int)>(two); } //expected-error {{reinterpret_cast}} + { (void) static_cast<void (*)(int)>(two); } //ok + + { (void) reinterpret_cast<int>(two); } //expected-error {{reinterpret_cast}} + { (void) reinterpret_cast<int (*)(char, double)>(two); } //expected-error {{reinterpret_cast}} + + { bool b = (twoT<int>); } + { bool b = (twoT<int, int>); } + + { bool b = &twoT<int>; //&foo<int>; } + b = &(twoT<int>); } + + { ptrdiff_t x = (ptrdiff_t) &twoT<int>; + x = (ptrdiff_t) &twoT<int>; } + + { ptrdiff_t x = (ptrdiff_t) twoT<int>; + x = (ptrdiff_t) twoT<int>; } + + + { ptrdiff_t x = (ptrdiff_t) &twoT<int,int>; + x = (ptrdiff_t) &twoT<int>; } + + { oneT<int>; &oneT<int>; } //expected-warning 2{{expression result unused}} + { static_cast<void>(cant_resolve<int>); } // expected-error {{address of overload}} + { bool b = cant_resolve<int>; } // expected-error {{address of overload}} + { (void) cant_resolve<int>; } // expected-error {{address of overload}} + +} + +namespace member_pointers { + struct S { + template <typename T> bool f(T) { return false; } + template <typename T> static bool g(T) { return false; } + + template <typename T> bool h(T) { return false; } // expected-note 3 {{possible target for call}} + template <int N> static bool h(int) { return false; } // expected-note 3 {{possible target for call}} + }; + + void test(S s) { + if (S::f<char>) return; // expected-error {{call to non-static member function without an object argument}} + if (S::f<int>) return; // expected-error {{call to non-static member function without an object argument}} + if (&S::f<char>) return; + if (&S::f<int>) return; + if (s.f<char>) return; // expected-error {{reference to non-static member function must be called}} + if (s.f<int>) return; // expected-error {{reference to non-static member function must be called}} + if (&s.f<char>) return; // expected-error {{cannot create a non-constant pointer to member function}} + if (&s.f<int>) return; // expected-error {{cannot create a non-constant pointer to member function}} + + if (S::g<char>) return; + if (S::g<int>) return; + if (&S::g<char>) return; + if (&S::g<int>) return; + if (s.g<char>) return; + if (s.g<int>) return; + if (&s.g<char>) return; + if (&s.g<int>) return; + + if (S::h<42>) return; + if (S::h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} + if (&S::h<42>) return; + if (&S::h<int>) return; + if (s.h<42>) return; + if (s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} + if (&s.h<42>) return; + if (&s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}} + + { bool b = S::f<char>; } // expected-error {{call to non-static member function without an object argument}} + { bool b = S::f<int>; } // expected-error {{call to non-static member function without an object argument}} + { bool b = &S::f<char>; } + { bool b = &S::f<int>; } + // These next two errors are terrible. + { bool b = s.f<char>; } // expected-error {{reference to non-static member function must be called}} + { bool b = s.f<int>; } // expected-error {{reference to non-static member function must be called}} + { bool b = &s.f<char>; } // expected-error {{cannot create a non-constant pointer to member function}} + { bool b = &s.f<int>; } // expected-error {{cannot create a non-constant pointer to member function}} + + { bool b = S::g<char>; } + { bool b = S::g<int>; } + { bool b = &S::g<char>; } + { bool b = &S::g<int>; } + { bool b = s.g<char>; } + { bool b = s.g<int>; } + { bool b = &s.g<char>; } + { bool b = &s.g<int>; } + + { bool b = S::h<42>; } + { bool b = S::h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + { bool b = &S::h<42>; } + { bool b = &S::h<int>; } + { bool b = s.h<42>; } + { bool b = s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + { bool b = &s.h<42>; } + { bool b = &s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + } +} diff --git a/clang/test/CXX/over/over.over/p2.cpp b/clang/test/CXX/over/over.over/p2.cpp new file mode 100644 index 0000000..3e8d0f1 --- /dev/null +++ b/clang/test/CXX/over/over.over/p2.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<typename T> T f0(T, T); //expected-note{{candidate}} + +void test_f0() { + int (*f0a)(int, int) = f0; + int (*f0b)(int, int) = &f0; + int (*f0c)(int, float) = f0; // expected-error{{address of overloaded function 'f0' does not match required type 'int (int, float)'}} +} diff --git a/clang/test/CXX/over/over.over/p4.cpp b/clang/test/CXX/over/over.over/p4.cpp new file mode 100644 index 0000000..27d070e --- /dev/null +++ b/clang/test/CXX/over/over.over/p4.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<typename T> T f0(T); // expected-note{{candidate function}} +int f0(int); // expected-note{{candidate function}} + +void test_f0() { + int (*fp0)(int) = f0; + int (*fp1)(int) = &f0; + float (*fp2)(float) = &f0; +} + +namespace N { + int f0(int); // expected-note{{candidate function}} +} + +void test_f0_2() { + using namespace N; + int (*fp0)(int) = f0; // expected-error{{address of overloaded function 'f0' is ambiguous}} + float (*fp1)(float) = f0; +} |