diff options
Diffstat (limited to 'clang/test/CXX/expr/expr.post')
8 files changed, 157 insertions, 0 deletions
diff --git a/clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp b/clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp new file mode 100644 index 0000000..d51ba09 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +struct X1 { + X1(); +}; + +struct X2 { + X2(); + ~X2(); +}; + +void vararg(...); + +void f(X1 x1, X2 x2) { + vararg(x1); // okay + vararg(x2); // expected-error{{cannot pass object of non-trivial type 'X2' through variadic function; call will abort at runtime}} +} + + +namespace PR11131 { + struct S; + + S &getS(); + + void f(...); + + void g() { + (void)sizeof(f(getS())); + } +} diff --git a/clang/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp b/clang/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp new file mode 100644 index 0000000..6ba8d51 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// The result of the expression const_cast<T>(v) is of type T. If T is +// an lvalue reference to object type, the result is an lvalue; if T +// is an rvalue reference to object type, the result is an xvalue;. + +unsigned int f(int); + +template<typename T> T& lvalue(); +template<typename T> T&& xvalue(); +template<typename T> T prvalue(); + +void test_classification(const int *ptr) { + int *ptr0 = const_cast<int *&&>(ptr); + int *ptr1 = const_cast<int *&&>(xvalue<const int*>()); + int *ptr2 = const_cast<int *&&>(prvalue<const int*>()); +} diff --git a/clang/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp b/clang/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp new file mode 100644 index 0000000..cddd5cf --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct X { virtual ~X(); }; +struct Y : public X { }; +struct Z; // expected-note{{forward declaration of 'Z'}} + +void test(X &x, Y &y, Z &z) { + // If T is an rvalue reference type, v shall be an expression having + // a complete class type, and the result is an xvalue of the type + // referred to by T. + Y &&yr0 = dynamic_cast<Y&&>(x); + Y &&yr1 = dynamic_cast<Y&&>(static_cast<X&&>(x)); + Y &&yr2 = dynamic_cast<Y&&>(z); // expected-error{{'Z' is an incomplete type}} +} diff --git a/clang/test/CXX/expr/expr.post/expr.ref/p3.cpp b/clang/test/CXX/expr/expr.post/expr.ref/p3.cpp new file mode 100644 index 0000000..98771d3 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.ref/p3.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s + +template<typename T> struct Node { + int lhs; + void splay( ) + { + Node<T> n[1]; + (void)n->lhs; + } +}; + +void f() { + Node<int> n; + return n.splay(); +} diff --git a/clang/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp b/clang/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp new file mode 100644 index 0000000..22892a6 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// If T is an lvalue reference type or an rvalue reference to function +// type, the result is an lvalue; if T is an rvalue reference to +// object type, the result is an xvalue; + +unsigned int f(int); + +template<typename T> T&& xvalue(); +void test_classification(char *ptr) { + int (&fr0)(int) = reinterpret_cast<int (&&)(int)>(f); + int &&ir0 = reinterpret_cast<int &&>(*ptr); + int &&ir1 = reinterpret_cast<int &&>(0); + int &&ir2 = reinterpret_cast<int &&>('a'); + int &&ir3 = reinterpret_cast<int &&>(xvalue<char>()); +} diff --git a/clang/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp b/clang/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp new file mode 100644 index 0000000..9ef15e6 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// A glvalue of type "cv1 T1" can be cast to type "rvalue reference to +// cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1" (8.5.3). +struct A { }; +struct B : A { }; + +template<typename T> T& lvalue(); +template<typename T> T&& xvalue(); + +void test(A &a, B &b) { + A &&ar0 = static_cast<A&&>(a); + A &&ar1 = static_cast<A&&>(b); + A &&ar2 = static_cast<A&&>(lvalue<A>()); + A &&ar3 = static_cast<A&&>(lvalue<B>()); + A &&ar4 = static_cast<A&&>(xvalue<A>()); + A &&ar5 = static_cast<A&&>(xvalue<B>()); + const A &&ar6 = static_cast<const A&&>(a); + const A &&ar7 = static_cast<const A&&>(b); + const A &&ar8 = static_cast<const A&&>(lvalue<A>()); + const A &&ar9 = static_cast<const A&&>(lvalue<B>()); + const A &&ar10 = static_cast<const A&&>(xvalue<A>()); + const A &&ar11 = static_cast<const A&&>(xvalue<B>()); +} diff --git a/clang/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp b/clang/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp new file mode 100644 index 0000000..731c508 --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +enum class EC { ec1 }; + +void test0(EC ec) { + (void)static_cast<bool>(ec); + (void)static_cast<bool>(EC::ec1); + (void)static_cast<char>(ec); + (void)static_cast<char>(EC::ec1); + (void)static_cast<int>(ec); + (void)static_cast<int>(EC::ec1); + (void)static_cast<unsigned long>(ec); + (void)static_cast<unsigned long>(EC::ec1); + (void)static_cast<float>(ec); + (void)static_cast<float>(EC::ec1); + (void)static_cast<double>(ec); + (void)static_cast<double>(EC::ec1); +} + +namespace PR9107 { + enum E {}; + template <class _Tp> inline _Tp* addressof(_Tp& __x) { + return (_Tp*)&(char&)__x; + } + void test() { + E a; + addressof(a); + } +} diff --git a/clang/test/CXX/expr/expr.post/expr.type.conv/p1-0x.cpp b/clang/test/CXX/expr/expr.post/expr.type.conv/p1-0x.cpp new file mode 100644 index 0000000..253744e --- /dev/null +++ b/clang/test/CXX/expr/expr.post/expr.type.conv/p1-0x.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +struct foo { + foo(); + foo(int); +}; + +int func(foo& f) { + decltype(foo())(); + f = (decltype(foo()))5; + return decltype(3)(5); +} |