diff options
Diffstat (limited to 'test/SemaCXX')
85 files changed, 3865 insertions, 633 deletions
diff --git a/test/SemaCXX/MicrosoftExtensions.cpp b/test/SemaCXX/MicrosoftExtensions.cpp index 30ad4d0..2d620b6 100644 --- a/test/SemaCXX/MicrosoftExtensions.cpp +++ b/test/SemaCXX/MicrosoftExtensions.cpp @@ -1,24 +1,16 @@ -// RUN: %clang_cc1 %s -fsyntax-only -Wmicrosoft -verify -fms-extensions -fexceptions +// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -verify -fms-extensions -fexceptions -fcxx-exceptions // ::type_info is predeclared with forward class declartion void f(const type_info &a); -// The following three are all equivalent when ms-extensions are on -void foo() throw(int); -void foo() throw(int, long); -void foo() throw(...); -void foo(); // expected-note {{previous declaration}} - -// Only nothrow specification is treated specially. -void foo() throw(); // expected-error {{exception specification in declaration does not match previous declaration}} -// throw(...) -void r3(); -void r3() throw(...); +// Microsoft doesn't validate exception specification. +void foo(); // expected-note {{previous declaration}} +void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}} -void r6() throw(...); -void r6() throw(int); // okay +void r6() throw(...); // expected-note {{previous declaration}} +void r6() throw(int); // expected-warning {{exception specification in declaration does not match previous declaration}} struct Base { virtual void f2(); @@ -122,3 +114,69 @@ struct X0 { enum : long long { // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}} SomeValue = 0x100000000 }; + + +class AAA { +__declspec(dllimport) void f(void) { } +void f2(void); +}; + +__declspec(dllimport) void AAA::f2(void) { // expected-error {{dllimport attribute can be applied only to symbol}} + +} + + + +template <class T> +class BB { +public: + void f(int g = 10 ); // expected-note {{previous definition is here}} +}; + +template <class T> +void BB<T>::f(int g = 0) { } // expected-warning {{redefinition of default argument}} + + +namespace MissingTypename { + +template<class T> class A { +public: + typedef int TYPE; +}; + +template<class T> class B { +public: + typedef int TYPE; +}; + + +template<class T, class U> +class C : private A<T>, public B<U> { +public: + typedef A<T> Base1; + typedef B<U> Base2; + typedef A<U> Base3; + + A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}} + Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}} + + B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}} + Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}} + + A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}} + Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}} + }; + +} + + + + +extern void static_func(); +void static_func(); // expected-note {{previous declaration is here}} + + +static void static_func() // expected-warning {{static declaration of 'static_func' follows non-static declaration}} +{ + +}
\ No newline at end of file diff --git a/test/SemaCXX/PR9459.cpp b/test/SemaCXX/PR9459.cpp new file mode 100644 index 0000000..dfb242d --- /dev/null +++ b/test/SemaCXX/PR9459.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Don't crash. + +template<typename>struct ae_same; +template<typename>struct ts{}ap() +{ts<a>::ap<ae_same<int>::&ae_same<>>::p(a); }; // expected-error {{use of undeclared identifier 'a'}} diff --git a/test/SemaCXX/PR9460.cpp b/test/SemaCXX/PR9460.cpp new file mode 100644 index 0000000..2cc435e --- /dev/null +++ b/test/SemaCXX/PR9460.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Don't crash. + +template<typename aT> +struct basic_string{ + a; // expected-error {{requires a type specifier}} + basic_string(aT*); +}; + +struct runtime_error{ // expected-note {{candidate constructor}} + runtime_error( // expected-note {{candidate constructor}} +basic_string<char> struct{ // expected-error {{cannot combine with previous 'type-name' declaration specifier}} +a(){ // expected-error {{requires a type specifier}} + runtime_error(0); // expected-error {{no matching conversion}} +} +} +); +}; diff --git a/test/SemaCXX/PR9461.cpp b/test/SemaCXX/PR9461.cpp new file mode 100644 index 0000000..ce17931 --- /dev/null +++ b/test/SemaCXX/PR9461.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Don't crash. + +template<typename,typename=int,typename=int>struct basic_string; + +typedef basic_string<char> string; + + + +template<typename aT,typename,typename oc> +struct basic_string +{ +int us; +basic_string(const aT*,const oc&a=int()); + +int _S_construct(); + +int _S_construct(int); + +_S_construct(); // expected-error {{requires}} +}; + +template<typename _CharT,typename _Traits,typename _Alloc> +basic_string<_CharT,_Traits,_Alloc>::basic_string(const _CharT*,const _Alloc&) +:us(_S_construct) +{string a;} + +struct runtime_error{runtime_error(string);}; // expected-note 2 {{candidate constructor}} + +struct system_error:runtime_error{ // expected-note {{to match}} expected-note {{specified here}} +system_error():time_error("" // expected-error 4 {{expected}} expected-error {{initializer}} expected-note {{to match}} expected-error {{no matching constructor}} diff --git a/test/SemaCXX/PR9572.cpp b/test/SemaCXX/PR9572.cpp new file mode 100644 index 0000000..d1b7077 --- /dev/null +++ b/test/SemaCXX/PR9572.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class Base { + virtual ~Base(); +}; +struct Foo : public Base { + const int kBlah = 3; // expected-error{{fields can only be initialized in constructors}} + Foo(); +}; +struct Bar : public Foo { + Bar() { } +}; +struct Baz { + Foo f; + Baz() { } +}; diff --git a/test/SemaCXX/__try.cpp b/test/SemaCXX/__try.cpp new file mode 100644 index 0000000..cb5d38a --- /dev/null +++ b/test/SemaCXX/__try.cpp @@ -0,0 +1,58 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fborland-extensions -fcxx-exceptions %s + +// This test is from http://docwiki.embarcadero.com/RADStudio/en/Try + +int puts(const char *); + +template<typename T> +int printf(const char *, T); + +const char * strdup(const char *); + +void free(const void *); + +#define EXCEPTION_EXECUTE_HANDLER 1 + +class Exception +{ +public: + Exception(const char* s = "Unknown"){what = strdup(s); } + Exception(const Exception& e ){what = strdup(e.what); } + ~Exception() {free(what); } + const char* msg() const {return what; } +private: + const char* what; +}; + +int main() +{ + float e, f, g; + try + { + try + { + f = 1.0; + g = 0.0; + try + { + puts("Another exception:"); + + e = f / g; + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + puts("Caught a C-based exception."); + throw(Exception("Hardware error: Divide by 0")); + } + } + catch(const Exception& e) + { + printf("Caught C++ Exception: %s :\n", e.msg()); + } + } + __finally + { + puts("C++ allows __finally too!"); + } + return e; +} diff --git a/test/SemaCXX/addr-of-overloaded-function.cpp b/test/SemaCXX/addr-of-overloaded-function.cpp index a1079ff..a36fd58 100644 --- a/test/SemaCXX/addr-of-overloaded-function.cpp +++ b/test/SemaCXX/addr-of-overloaded-function.cpp @@ -57,11 +57,12 @@ struct B struct C { C &getC() { - return makeAC; // expected-error{{address of overloaded function 'makeAC'}} + // FIXME: this error message is terrible + return makeAC; // expected-error{{cannot bind to a value of unrelated type}} } - C &makeAC(); //expected-note{{candidate function}} - const C &makeAC() const; //expected-note{{candidate function}} + C &makeAC(); + const C &makeAC() const; static void f(); // expected-note{{candidate function}} static void f(int); // expected-note{{candidate function}} diff --git a/test/SemaCXX/address-space-conversion.cpp b/test/SemaCXX/address-space-conversion.cpp new file mode 100644 index 0000000..d21d419 --- /dev/null +++ b/test/SemaCXX/address-space-conversion.cpp @@ -0,0 +1,197 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// This test checks for the various conversions and casting operations +// with address-space-qualified pointers. + +struct A { virtual ~A() {} }; +struct B : A { }; + +typedef void *void_ptr; +typedef void __attribute__((address_space(1))) *void_ptr_1; +typedef void __attribute__((address_space(2))) *void_ptr_2; + +typedef int *int_ptr; +typedef int __attribute__((address_space(1))) *int_ptr_1; +typedef int __attribute__((address_space(2))) *int_ptr_2; + +typedef A *A_ptr; +typedef A __attribute__((address_space(1))) *A_ptr_1; +typedef A __attribute__((address_space(2))) *A_ptr_2; + +typedef B *B_ptr; +typedef B __attribute__((address_space(1))) *B_ptr_1; +typedef B __attribute__((address_space(2))) *B_ptr_2; + +void test_const_cast(int_ptr ip, int_ptr_1 ip1, int_ptr_2 ip2, + A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + const int *cip, + const int __attribute__((address_space(1))) *cip1) { + // Cannot use const_cast to cast between address spaces, add an + // address space, or remove an address space. + (void)const_cast<int_ptr>(ip1); // expected-error{{is not allowed}} + (void)const_cast<int_ptr>(ip2); // expected-error{{is not allowed}} + (void)const_cast<int_ptr_1>(ip); // expected-error{{is not allowed}} + (void)const_cast<int_ptr_1>(ip2); // expected-error{{is not allowed}} + (void)const_cast<int_ptr_2>(ip); // expected-error{{is not allowed}} + (void)const_cast<int_ptr_2>(ip1); // expected-error{{is not allowed}} + + (void)const_cast<A_ptr>(ap1); // expected-error{{is not allowed}} + (void)const_cast<A_ptr>(ap2); // expected-error{{is not allowed}} + (void)const_cast<A_ptr_1>(ap); // expected-error{{is not allowed}} + (void)const_cast<A_ptr_1>(ap2); // expected-error{{is not allowed}} + (void)const_cast<A_ptr_2>(ap); // expected-error{{is not allowed}} + (void)const_cast<A_ptr_2>(ap1); // expected-error{{is not allowed}} + + // It's acceptable to cast away constness. + (void)const_cast<int_ptr>(cip); + (void)const_cast<int_ptr_1>(cip1); +} + +void test_static_cast(void_ptr vp, void_ptr_1 vp1, void_ptr_2 vp2, + A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2) { + // Well-formed upcast + (void)static_cast<A_ptr>(bp); + (void)static_cast<A_ptr_1>(bp1); + (void)static_cast<A_ptr_2>(bp2); + + // Well-formed downcast + (void)static_cast<B_ptr>(ap); + (void)static_cast<B_ptr_1>(ap1); + (void)static_cast<B_ptr_2>(ap2); + + // Well-formed cast to/from void + (void)static_cast<void_ptr>(ap); + (void)static_cast<void_ptr_1>(ap1); + (void)static_cast<void_ptr_2>(ap2); + (void)static_cast<A_ptr>(vp); + (void)static_cast<A_ptr_1>(vp1); + (void)static_cast<A_ptr_2>(vp2); + + // Ill-formed upcasts + (void)static_cast<A_ptr>(bp1); // expected-error{{is not allowed}} + (void)static_cast<A_ptr>(bp2); // expected-error{{is not allowed}} + (void)static_cast<A_ptr_1>(bp); // expected-error{{is not allowed}} + (void)static_cast<A_ptr_1>(bp2); // expected-error{{is not allowed}} + (void)static_cast<A_ptr_2>(bp); // expected-error{{is not allowed}} + (void)static_cast<A_ptr_2>(bp1); // expected-error{{is not allowed}} + + // Ill-formed downcasts + (void)static_cast<B_ptr>(ap1); // expected-error{{casts away qualifiers}} + (void)static_cast<B_ptr>(ap2); // expected-error{{casts away qualifiers}} + (void)static_cast<B_ptr_1>(ap); // expected-error{{casts away qualifiers}} + (void)static_cast<B_ptr_1>(ap2); // expected-error{{casts away qualifiers}} + (void)static_cast<B_ptr_2>(ap); // expected-error{{casts away qualifiers}} + (void)static_cast<B_ptr_2>(ap1); // expected-error{{casts away qualifiers}} + + // Ill-formed cast to/from void + (void)static_cast<void_ptr>(ap1); // expected-error{{is not allowed}} + (void)static_cast<void_ptr>(ap2); // expected-error{{is not allowed}} + (void)static_cast<void_ptr_1>(ap); // expected-error{{is not allowed}} + (void)static_cast<void_ptr_1>(ap2); // expected-error{{is not allowed}} + (void)static_cast<void_ptr_2>(ap); // expected-error{{is not allowed}} + (void)static_cast<void_ptr_2>(ap1); // expected-error{{is not allowed}} + (void)static_cast<A_ptr>(vp1); // expected-error{{casts away qualifiers}} + (void)static_cast<A_ptr>(vp2); // expected-error{{casts away qualifiers}} + (void)static_cast<A_ptr_1>(vp); // expected-error{{casts away qualifiers}} + (void)static_cast<A_ptr_1>(vp2); // expected-error{{casts away qualifiers}} + (void)static_cast<A_ptr_2>(vp); // expected-error{{casts away qualifiers}} + (void)static_cast<A_ptr_2>(vp1); // expected-error{{casts away qualifiers}} +} + +void test_dynamic_cast(A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2) { + // Well-formed upcast + (void)dynamic_cast<A_ptr>(bp); + (void)dynamic_cast<A_ptr_1>(bp1); + (void)dynamic_cast<A_ptr_2>(bp2); + + // Well-formed downcast + (void)dynamic_cast<B_ptr>(ap); + (void)dynamic_cast<B_ptr_1>(ap1); + (void)dynamic_cast<B_ptr_2>(ap2); + + // Ill-formed upcasts + (void)dynamic_cast<A_ptr>(bp1); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<A_ptr>(bp2); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<A_ptr_1>(bp); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<A_ptr_1>(bp2); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<A_ptr_2>(bp); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<A_ptr_2>(bp1); // expected-error{{casts away qualifiers}} + + // Ill-formed downcasts + (void)dynamic_cast<B_ptr>(ap1); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<B_ptr>(ap2); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<B_ptr_1>(ap); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<B_ptr_1>(ap2); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<B_ptr_2>(ap); // expected-error{{casts away qualifiers}} + (void)dynamic_cast<B_ptr_2>(ap1); // expected-error{{casts away qualifiers}} +} + +void test_reinterpret_cast(void_ptr vp, void_ptr_1 vp1, void_ptr_2 vp2, + A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2, + const void __attribute__((address_space(1))) *cvp1) { + // reinterpret_cast can be used to cast to a different address space. + (void)reinterpret_cast<A_ptr>(ap1); + (void)reinterpret_cast<A_ptr>(ap2); + (void)reinterpret_cast<A_ptr>(bp); + (void)reinterpret_cast<A_ptr>(bp1); + (void)reinterpret_cast<A_ptr>(bp2); + (void)reinterpret_cast<A_ptr>(vp); + (void)reinterpret_cast<A_ptr>(vp1); + (void)reinterpret_cast<A_ptr>(vp2); + (void)reinterpret_cast<A_ptr_1>(ap); + (void)reinterpret_cast<A_ptr_1>(ap2); + (void)reinterpret_cast<A_ptr_1>(bp); + (void)reinterpret_cast<A_ptr_1>(bp1); + (void)reinterpret_cast<A_ptr_1>(bp2); + (void)reinterpret_cast<A_ptr_1>(vp); + (void)reinterpret_cast<A_ptr_1>(vp1); + (void)reinterpret_cast<A_ptr_1>(vp2); + + // ... but don't try to cast away constness! + (void)reinterpret_cast<A_ptr_2>(cvp1); // expected-error{{casts away qualifiers}} +} + +void test_cstyle_cast(void_ptr vp, void_ptr_1 vp1, void_ptr_2 vp2, + A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2, + const void __attribute__((address_space(1))) *cvp1) { + // C-style casts are the wild west of casts. + (void)(A_ptr)(ap1); + (void)(A_ptr)(ap2); + (void)(A_ptr)(bp); + (void)(A_ptr)(bp1); + (void)(A_ptr)(bp2); + (void)(A_ptr)(vp); + (void)(A_ptr)(vp1); + (void)(A_ptr)(vp2); + (void)(A_ptr_1)(ap); + (void)(A_ptr_1)(ap2); + (void)(A_ptr_1)(bp); + (void)(A_ptr_1)(bp1); + (void)(A_ptr_1)(bp2); + (void)(A_ptr_1)(vp); + (void)(A_ptr_1)(vp1); + (void)(A_ptr_1)(vp2); + (void)(A_ptr_2)(cvp1); +} + +void test_implicit_conversion(void_ptr vp, void_ptr_1 vp1, void_ptr_2 vp2, + A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2, + B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2) { + // Well-formed conversions + void_ptr vpA = ap; + void_ptr_1 vp_1A = ap1; + void_ptr_2 vp_2A = ap2; + A_ptr ap_A = bp; + A_ptr_1 ap_A1 = bp1; + A_ptr_2 ap_A2 = bp2; + + // Ill-formed conversions + void_ptr vpB = ap1; // expected-error{{cannot initialize a variable of type}} + void_ptr_1 vp_1B = ap2; // expected-error{{cannot initialize a variable of type}} + A_ptr ap_B = bp1; // expected-error{{cannot initialize a variable of type}} + A_ptr_1 ap_B1 = bp2; // expected-error{{cannot initialize a variable of type}} +} diff --git a/test/SemaCXX/address-space-newdelete.cpp b/test/SemaCXX/address-space-newdelete.cpp new file mode 100644 index 0000000..b809cd3 --- /dev/null +++ b/test/SemaCXX/address-space-newdelete.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void* operator new (__SIZE_TYPE__ size, void* ptr); +void* operator new[](__SIZE_TYPE__ size, void* ptr); + +typedef int __attribute__((address_space(1))) int_1; + +void test_new(void *p) { + (void)new int_1; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new __attribute__((address_space(1))) int; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new int_1 [5]; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new __attribute__((address_space(1))) int [5]; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + + // Placement new + (void)new (p) int_1; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new (p) __attribute__((address_space(1))) int; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new (p) int_1 [5]; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} + (void)new (p) __attribute__((address_space(1))) int [5]; // expected-error{{'new' cannot allocate objects of type 'int' in address space '1'}} +} + +void test_delete(int_1 *ip1) { + delete ip1; // expected-error{{'delete' cannot delete objects of type 'int' in address space '1'}} + delete [] ip1; // expected-error{{'delete' cannot delete objects of type 'int' in address space '1'}} +} diff --git a/test/SemaCXX/address-space-references.cpp b/test/SemaCXX/address-space-references.cpp new file mode 100644 index 0000000..f5a63d2 --- /dev/null +++ b/test/SemaCXX/address-space-references.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef int __attribute__((address_space(1))) int_1; +typedef int __attribute__((address_space(2))) int_2; + +void f0(int_1 &); // expected-note{{candidate function not viable: 1st argument ('int') is in address space 0, but parameter must be in address space 1}} \ +// expected-note{{candidate function not viable: 1st argument ('int_2' (aka '__attribute__((address_space(2))) int')) is in address space 2, but parameter must be in address space 1}} +void f0(const int_1 &); // expected-note{{candidate function not viable: 1st argument ('int') is in address space 0, but parameter must be in address space 1}} \ +// expected-note{{candidate function not viable: 1st argument ('int_2' (aka '__attribute__((address_space(2))) int')) is in address space 2, but parameter must be in address space 1}} + +void test_f0() { + int i; + static int_1 i1; + static int_2 i2; + + f0(i); // expected-error{{no matching function for call to 'f0'}} + f0(i1); + f0(i2); // expected-error{{no matching function for call to 'f0'}} +} diff --git a/test/SemaCXX/alignof-sizeof-reference.cpp b/test/SemaCXX/alignof-sizeof-reference.cpp index 761edfc..b517e43 100644 --- a/test/SemaCXX/alignof-sizeof-reference.cpp +++ b/test/SemaCXX/alignof-sizeof-reference.cpp @@ -8,8 +8,8 @@ void test() { static_assert(sizeof(r) == 1, "bad size"); } -void f(); -void f(int); +void f(); // expected-note{{candidate function}} +void f(int); // expected-note{{candidate function}} void g() { - sizeof(&f); // expected-error{{cannot resolve overloaded function from context}} + sizeof(&f); // expected-error{{cannot resolve overloaded function 'f' from context}} } diff --git a/test/SemaCXX/altivec.cpp b/test/SemaCXX/altivec.cpp index 921bb73..504eb1b 100644 --- a/test/SemaCXX/altivec.cpp +++ b/test/SemaCXX/altivec.cpp @@ -2,6 +2,36 @@ typedef int V4i __attribute__((vector_size(16))); +void test_vec_step(vector short arg1) { + vector bool char vbc; + vector signed char vsc; + vector unsigned char vuc; + vector bool short vbs; + vector short vs; + vector unsigned short vus; + vector pixel vp; + vector bool int vbi; + vector int vi; + vector unsigned int vui; + vector float vf; + + vector int *pvi; + + int res1[vec_step(arg1) == 8 ? 1 : -1]; + int res2[vec_step(vbc) == 16 ? 1 : -1]; + int res3[vec_step(vsc) == 16 ? 1 : -1]; + int res4[vec_step(vuc) == 16 ? 1 : -1]; + int res5[vec_step(vbs) == 8 ? 1 : -1]; + int res6[vec_step(vs) == 8 ? 1 : -1]; + int res7[vec_step(vus) == 8 ? 1 : -1]; + int res8[vec_step(vp) == 8 ? 1 : -1]; + int res9[vec_step(vbi) == 4 ? 1 : -1]; + int res10[vec_step(vi) == 4 ? 1 : -1]; + int res11[vec_step(vui) == 4 ? 1 : -1]; + int res12[vec_step(vf) == 4 ? 1 : -1]; + int res13[vec_step(*pvi) == 4 ? 1 : -1]; +} + void f(V4i a) { } diff --git a/test/SemaCXX/array-bounds.cpp b/test/SemaCXX/array-bounds.cpp index 80646c7..3bd6c354 100644 --- a/test/SemaCXX/array-bounds.cpp +++ b/test/SemaCXX/array-bounds.cpp @@ -120,3 +120,56 @@ int test_pr9296() { return array[true]; // no-warning } +int test_sizeof_as_condition(int flag) { + int arr[2] = { 0, 0 }; // expected-note {{array 'arr' declared here}} + if (flag) + return sizeof(char) != sizeof(char) ? arr[2] : arr[1]; + return sizeof(char) == sizeof(char) ? arr[2] : arr[1]; // expected-warning {{array index of '2' indexes past the end of an array (that contains 2 elements)}} +} + +void test_switch() { + switch (4) { + case 1: { + int arr[2]; + arr[2] = 1; // no-warning + break; + } + case 4: { + int arr[2]; // expected-note {{array 'arr' declared here}} + arr[2] = 1; // expected-warning {{array index of '2' indexes past the end of an array (that contains 2 elements)}} + break; + } + default: { + int arr[2]; + arr[2] = 1; // no-warning + break; + } + } +} + +// Test nested switch statements. +enum enumA { enumA_A, enumA_B, enumA_C, enumA_D, enumA_E }; +enum enumB { enumB_X, enumB_Y, enumB_Z }; +static enum enumB myVal = enumB_X; +void test_nested_switch() +{ + switch (enumA_E) { // expected-warning {{no case matching constant}} + switch (myVal) { // expected-warning {{enumeration values 'enumB_X' and 'enumB_Z' not handled in switch}} + case enumB_Y: ; + } + } +} + +// Test that if all the values of an enum covered, that the 'default' branch +// is unreachable. +enum Values { A, B, C, D }; +void test_all_enums_covered(enum Values v) { + int x[2]; + switch (v) { + case A: return; + case B: return; + case C: return; + case D: return; + } + x[2] = 0; // no-warning +} diff --git a/test/SemaCXX/attr-nonnull.cpp b/test/SemaCXX/attr-nonnull.cpp index 19d6642..09c054c1 100644 --- a/test/SemaCXX/attr-nonnull.cpp +++ b/test/SemaCXX/attr-nonnull.cpp @@ -1,5 +1,7 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s struct S { + S(const char *) __attribute__((nonnull(2))); + static void f(const char*, const char*) __attribute__((nonnull(1))); // GCC has a hidden 'this' argument in member functions, so the middle @@ -10,7 +12,9 @@ struct S { expected-error{{invalid for the implicit this argument}} }; -void test(S s) { +void test() { + S s(0); // expected-warning{{null passed}} + s.f(0, ""); // expected-warning{{null passed}} s.f("", 0); s.g("", 0, ""); // expected-warning{{null passed}} diff --git a/test/SemaCXX/attr-unavailable.cpp b/test/SemaCXX/attr-unavailable.cpp index fe3e8b1..5f34ed9 100644 --- a/test/SemaCXX/attr-unavailable.cpp +++ b/test/SemaCXX/attr-unavailable.cpp @@ -25,6 +25,6 @@ namespace radar9046492 { void foo() FOO; // expected-note {{candidate function has been explicitly made unavailable}} void bar() { - foo(); // expected-error {{call to unavailable function 'foo' not available - replaced}} + foo(); // expected-error {{call to unavailable function 'foo': not available - replaced}} } } diff --git a/test/SemaCXX/auto-subst-failure.cpp b/test/SemaCXX/auto-subst-failure.cpp new file mode 100644 index 0000000..442c7e8 --- /dev/null +++ b/test/SemaCXX/auto-subst-failure.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x + +void f() { + auto a = f(); // expected-error {{variable has incomplete type 'void'}} + auto &b = f(); // expected-error {{cannot form a reference to 'void'}} + auto *c = f(); // expected-error {{incompatible initializer of type 'void'}} + + auto d(f()); // expected-error {{variable has incomplete type 'void'}} + auto &&e(f()); // expected-error {{cannot form a reference to 'void'}} + auto *g(f()); // expected-error {{incompatible initializer of type 'void'}} + + (void)new auto(f()); // expected-error {{allocation of incomplete type 'void'}} + (void)new auto&(f()); // expected-error {{cannot form a reference to 'void'}} + (void)new auto*(f()); // expected-error {{incompatible constructor argument of type 'void'}} +} diff --git a/test/SemaCXX/conditional-expr.cpp b/test/SemaCXX/conditional-expr.cpp index 1da9a17..b95700e 100644 --- a/test/SemaCXX/conditional-expr.cpp +++ b/test/SemaCXX/conditional-expr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify -std=c++0x -Wsign-compare %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++0x -Wsign-compare %s // C++ rules for ?: are a lot stricter than C rules, and have to take into // account more conversion options. diff --git a/test/SemaCXX/conversion-function.cpp b/test/SemaCXX/conversion-function.cpp index 61c8ada..aa47ae0 100644 --- a/test/SemaCXX/conversion-function.cpp +++ b/test/SemaCXX/conversion-function.cpp @@ -353,3 +353,28 @@ namespace PR8034 { }; int x = C().operator int(); } + +namespace PR9336 { + template<class T> + struct generic_list + { + template<class Container> + operator Container() + { + Container ar; + T* i; + ar[0]=*i; + return ar; + } + }; + + template<class T> + struct array + { + T& operator[](int); + const T& operator[](int)const; + }; + + generic_list<generic_list<int> > l; + array<array<int> > a = l; +} diff --git a/test/SemaCXX/cxx0x-constexpr-const.cpp b/test/SemaCXX/cxx0x-constexpr-const.cpp new file mode 100644 index 0000000..79e6dda --- /dev/null +++ b/test/SemaCXX/cxx0x-constexpr-const.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +constexpr int x = 1; +constexpr int id(int x) { return x; } + +void foo(void) { + x = 2; // expected-error {{read-only variable is not assignable}} + int (*idp)(int) = id; +} + diff --git a/test/SemaCXX/cxx0x-delegating-ctors.cpp b/test/SemaCXX/cxx0x-delegating-ctors.cpp new file mode 100644 index 0000000..b211cb1 --- /dev/null +++ b/test/SemaCXX/cxx0x-delegating-ctors.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++0x -verify %s + +struct foo { + int i; + foo(); + foo(int); + foo(int, int); + foo(bool); + foo(char); + foo(float*); + foo(float&); +}; + +// Good +foo::foo (int i) : i(i) { +} +// Good +foo::foo () : foo(-1) { +} +// Good +foo::foo (int, int) : foo() { +} + +foo::foo (bool) : foo(true) { // expected-error{{delegates to itself}} +} + +// Good +foo::foo (float* f) : foo(*f) { +} + +// FIXME: This should error +foo::foo (float &f) : foo(&f) { +} + +foo::foo (char) : i(3), foo(3) { // expected-error{{must appear alone}} +} diff --git a/test/SemaCXX/cxx0x-return-init-list.cpp b/test/SemaCXX/cxx0x-return-init-list.cpp new file mode 100644 index 0000000..2005a7f --- /dev/null +++ b/test/SemaCXX/cxx0x-return-init-list.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// This test checks for a teeny tiny subset of the functionality in +// the C++0x generalized initializer lists feature, which happens to +// be used in libstdc++ 4.5. We accept only this syntax so that Clang +// can handle the libstdc++ 4.5 headers. + +int test0(int i) { + return { i }; // expected-warning{{generalized initializer lists are a C++0x extension unsupported in Clang}} +} + +template<typename T, typename U> +T test1(U u) { + return { u }; // expected-warning{{generalized initializer lists are a C++0x extension unsupported in Clang}} +} + +template int test1(char); +template long test1(int); diff --git a/test/SemaCXX/decltype-98.cpp b/test/SemaCXX/decltype-98.cpp new file mode 100644 index 0000000..db52565 --- /dev/null +++ b/test/SemaCXX/decltype-98.cpp @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify %s +extern int x; +__decltype(1) x = 3; diff --git a/test/SemaCXX/decltype-overloaded-functions.cpp b/test/SemaCXX/decltype-overloaded-functions.cpp index c11a47e..f4aacd6 100644 --- a/test/SemaCXX/decltype-overloaded-functions.cpp +++ b/test/SemaCXX/decltype-overloaded-functions.cpp @@ -1,12 +1,15 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x -void f(); -void f(int); -decltype(f) a; // expected-error{{cannot resolve overloaded function from context}} +void f(); // expected-note{{candidate function}} +void f(int); // expected-note{{candidate function}} +decltype(f) a; // expected-error{{cannot resolve overloaded function 'f' from context}} template<typename T> struct S { - decltype(T::f) * f; // expected-error{{cannot resolve overloaded function from context}} + decltype(T::f) * f; // expected-error{{cannot resolve overloaded function 'f' from context}} }; -struct K { void f(); void f(int); }; +struct K { + void f(); // expected-note{{candidate function}} + void f(int); // expected-note{{candidate function}} +}; S<K> b; // expected-note{{in instantiation of template class 'S<K>' requested here}} diff --git a/test/SemaCXX/destructor.cpp b/test/SemaCXX/destructor.cpp index 14a4fb8..01f21de 100644 --- a/test/SemaCXX/destructor.cpp +++ b/test/SemaCXX/destructor.cpp @@ -177,3 +177,16 @@ namespace PR9238 { class B { public: ~B(); }; class C : virtual B { public: ~C() { } }; } + +namespace PR7900 { + struct A { // expected-note 2{{type 'PR7900::A' is declared here}} + }; + struct B : public A { + }; + void foo() { + B b; + b.~B(); + b.~A(); // expected-error{{destructor type 'PR7900::A' in object destruction expression does not match the type 'PR7900::B' of the object being destroyed}} + (&b)->~A(); // expected-error{{destructor type 'PR7900::A' in object destruction expression does not match the type 'PR7900::B' of the object being destroyed}} + } +} diff --git a/test/SemaCXX/enum-scoped.cpp b/test/SemaCXX/enum-scoped.cpp index cf579e1..8c4bfe7 100644 --- a/test/SemaCXX/enum-scoped.cpp +++ b/test/SemaCXX/enum-scoped.cpp @@ -103,3 +103,9 @@ enum : long { enum : long x; // expected-error{{unnamed enumeration must be a definition}} \ // expected-warning{{declaration does not declare anything}} + +void PR9333() { + enum class scoped_enum { yes, no, maybe }; + scoped_enum e = scoped_enum::yes; + if (e == scoped_enum::no) { } +} diff --git a/test/SemaCXX/exception-spec-no-exceptions.cpp b/test/SemaCXX/exception-spec-no-exceptions.cpp index 1fe45b0..2e18070 100644 --- a/test/SemaCXX/exception-spec-no-exceptions.cpp +++ b/test/SemaCXX/exception-spec-no-exceptions.cpp @@ -1,7 +1,8 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s -// Note: this is intentionally -fno-exceptions, not just accidentally -// so because that's the current -cc1 default. +// Note that we're specifically excluding -fcxx-exceptions in the command line above. + +// That this should work even with -fobjc-exceptions is PR9358 // PR7243: redeclarations namespace test0 { diff --git a/test/SemaCXX/exception-spec.cpp b/test/SemaCXX/exception-spec.cpp deleted file mode 100644 index b4bc78a..0000000 --- a/test/SemaCXX/exception-spec.cpp +++ /dev/null @@ -1,193 +0,0 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions %s - -// Straight from the standard: -// Plain function with spec -void f() throw(int); -// Pointer to function with spec -void (*fp)() throw (int); -// Function taking reference to function with spec -void g(void pfa() throw(int)); -// Typedef for pointer to function with spec -typedef int (*pf)() throw(int); // expected-error {{specifications are not allowed in typedefs}} - -// Some more: -// Function returning function with spec -void (*h())() throw(int); -// Ultimate parser thrill: function with spec returning function with spec and -// taking pointer to function with spec. -// The actual function throws int, the return type double, the argument float. -void (*i() throw(int))(void (*)() throw(float)) throw(double); -// Pointer to pointer to function taking function with spec -void (**k)(void pfa() throw(int)); // no-error -// Pointer to pointer to function with spec -void (**j)() throw(int); // expected-error {{not allowed beyond a single}} -// Pointer to function returning pointer to pointer to function with spec -void (**(*h())())() throw(int); // expected-error {{not allowed beyond a single}} - -struct Incomplete; // expected-note 3 {{forward declaration}} - -// Exception spec must not have incomplete types, or pointers to them, except -// void. -void ic1() throw(void); // expected-error {{incomplete type 'void' is not allowed in exception specification}} -void ic2() throw(Incomplete); // expected-error {{incomplete type 'Incomplete' is not allowed in exception specification}} -void ic3() throw(void*); -void ic4() throw(Incomplete*); // expected-error {{pointer to incomplete type 'Incomplete' is not allowed in exception specification}} -void ic5() throw(Incomplete&); // expected-error {{reference to incomplete type 'Incomplete' is not allowed in exception specification}} - -// Redeclarations -typedef int INT; -void r1() throw(int); -void r1() throw(int); - -void r2() throw(int); -void r2() throw(INT); - -// throw-any spec and no spec at all are semantically equivalent -void r4() throw(int, float); -void r4() throw(float, int); - -void r5() throw(int); // expected-note {{previous declaration}} -void r5(); // expected-warning {{missing exception specification}} - -void r7() throw(int); // expected-note {{previous declaration}} -void r7() throw(float); // expected-error {{exception specification in declaration does not match}} - -// Top-level const doesn't matter. -void r8() throw(int); -void r8() throw(const int); - -// Multiple appearances don't matter. -void r9() throw(int, int); -void r9() throw(int, int); - -struct A -{ -}; - -struct B1 : A -{ -}; - -struct B2 : A -{ -}; - -struct D : B1, B2 -{ -}; - -struct P : private A -{ -}; - -struct Base -{ - virtual void f1() throw(); - virtual void f4() throw(int, float); - - virtual void f5() throw(int, float); - virtual void f6() throw(A); - virtual void f7() throw(A, int, float); - virtual void f8(); - - virtual void g1() throw(); // expected-note {{overridden virtual function is here}} - virtual void g2() throw(int); // expected-note {{overridden virtual function is here}} - virtual void g3() throw(A); // expected-note {{overridden virtual function is here}} - virtual void g4() throw(B1); // expected-note {{overridden virtual function is here}} - virtual void g5() throw(A); // expected-note {{overridden virtual function is here}} -}; -struct Derived : Base -{ - virtual void f1() throw(); - virtual void f4() throw(float, int); - - virtual void f5() throw(float); - virtual void f6() throw(B1); - virtual void f7() throw(B1, B2, int); - virtual void f8() throw(B2, B2, int, float, char, double, bool); - - virtual void g1() throw(int); // expected-error {{exception specification of overriding function is more lax}} - virtual void g2(); // expected-error {{exception specification of overriding function is more lax}} - virtual void g3() throw(D); // expected-error {{exception specification of overriding function is more lax}} - virtual void g4() throw(A); // expected-error {{exception specification of overriding function is more lax}} - virtual void g5() throw(P); // expected-error {{exception specification of overriding function is more lax}} -}; - -// Some functions to play with below. -void s1() throw(); -void s2() throw(int); -void s3() throw(A); -void s4() throw(B1); -void s5() throw(D); -void s6(); -void s7() throw(int, float); -void (*s8())() throw(B1); // s8 returns a pointer to function with spec -void s9(void (*)() throw(B1)); // s9 takes pointer to function with spec - -void fnptrs() -{ - // Assignment and initialization of function pointers. - void (*t1)() throw() = &s1; // valid - t1 = &s2; // expected-error {{not superset}} expected-error {{incompatible type}} - t1 = &s3; // expected-error {{not superset}} expected-error {{incompatible type}} - void (&t2)() throw() = s2; // expected-error {{not superset}} - void (*t3)() throw(int) = &s2; // valid - void (*t4)() throw(A) = &s1; // valid - t4 = &s3; // valid - t4 = &s4; // valid - t4 = &s5; // expected-error {{not superset}} expected-error {{incompatible type}} - void (*t5)() = &s1; // valid - t5 = &s2; // valid - t5 = &s6; // valid - t5 = &s7; // valid - t1 = t3; // expected-error {{not superset}} expected-error {{incompatible type}} - t3 = t1; // valid - void (*t6)() throw(B1); - t6 = t4; // expected-error {{not superset}} expected-error {{incompatible type}} - t4 = t6; // valid - t5 = t1; // valid - t1 = t5; // expected-error {{not superset}} expected-error {{incompatible type}} - - // return types and arguments must match exactly, no inheritance allowed - void (*(*t7)())() throw(B1) = &s8; // valid - void (*(*t8)())() throw(A) = &s8; // expected-error {{return types differ}} - void (*(*t9)())() throw(D) = &s8; // expected-error {{return types differ}} - void (*t10)(void (*)() throw(B1)) = &s9; // valid expected-warning{{disambiguated}} - void (*t11)(void (*)() throw(A)) = &s9; // expected-error {{argument types differ}} expected-warning{{disambiguated}} - void (*t12)(void (*)() throw(D)) = &s9; // expected-error {{argument types differ}} expected-warning{{disambiguated}} -} - -// Member function stuff - -struct Str1 { void f() throw(int); }; // expected-note {{previous declaration}} -void Str1::f() // expected-warning {{missing exception specification}} -{ -} - -void mfnptr() -{ - void (Str1::*pfn1)() throw(int) = &Str1::f; // valid - void (Str1::*pfn2)() = &Str1::f; // valid - void (Str1::*pfn3)() throw() = &Str1::f; // expected-error {{not superset}} -} - -// Don't suppress errors in template instantiation. -template <typename T> struct TEx; // expected-note {{template is declared here}} - -void tf() throw(TEx<int>); // expected-error {{implicit instantiation of undefined template}} - -// DR 437, class throws itself. -struct DR437 { - void f() throw(DR437); - void g() throw(DR437*); - void h() throw(DR437&); -}; - -// DR 437 within a nested class -struct DR437_out { - struct DR437_in { - void f() throw(DR437_out); - void g() throw(DR437_out*); - void h() throw(DR437_out&); - }; -}; diff --git a/test/SemaCXX/exceptions.cpp b/test/SemaCXX/exceptions.cpp index bda4a3d..e2bfe18 100644 --- a/test/SemaCXX/exceptions.cpp +++ b/test/SemaCXX/exceptions.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s struct A; // expected-note 4 {{forward declaration of 'A'}} diff --git a/test/SemaCXX/expression-traits.cpp b/test/SemaCXX/expression-traits.cpp new file mode 100644 index 0000000..4555192 --- /dev/null +++ b/test/SemaCXX/expression-traits.cpp @@ -0,0 +1,620 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions %s + +// +// Tests for "expression traits" intrinsics such as __is_lvalue_expr. +// +// For the time being, these tests are written against the 2003 C++ +// standard (ISO/IEC 14882:2003 -- see draft at +// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/). +// +// C++0x has its own, more-refined, idea of lvalues and rvalues. +// If/when we need to support those, we'll need to track both +// standard documents. + +#if !__has_feature(cxx_static_assert) +# define CONCAT_(X_, Y_) CONCAT1_(X_, Y_) +# define CONCAT1_(X_, Y_) X_ ## Y_ + +// This emulation can be used multiple times on one line (and thus in +// a macro), except at class scope +# define static_assert(b_, m_) \ + typedef int CONCAT_(sa_, __LINE__)[b_ ? 1 : -1] +#endif + +// Tests are broken down according to section of the C++03 standard +// (ISO/IEC 14882:2003(E)) + +// Assertion macros encoding the following two paragraphs +// +// basic.lval/1 Every expression is either an lvalue or an rvalue. +// +// expr.prim/5 A parenthesized expression is a primary expression whose type +// and value are identical to those of the enclosed expression. The +// presence of parentheses does not affect whether the expression is +// an lvalue. +// +// Note: these asserts cannot be made at class scope in C++03. Put +// them in a member function instead. +#define ASSERT_LVALUE(expr) \ + static_assert(__is_lvalue_expr(expr), "should be an lvalue"); \ + static_assert(__is_lvalue_expr((expr)), \ + "the presence of parentheses should have" \ + " no effect on lvalueness (expr.prim/5)"); \ + static_assert(!__is_rvalue_expr(expr), "should be an lvalue"); \ + static_assert(!__is_rvalue_expr((expr)), \ + "the presence of parentheses should have" \ + " no effect on lvalueness (expr.prim/5)") + +#define ASSERT_RVALUE(expr); \ + static_assert(__is_rvalue_expr(expr), "should be an rvalue"); \ + static_assert(__is_rvalue_expr((expr)), \ + "the presence of parentheses should have" \ + " no effect on lvalueness (expr.prim/5)"); \ + static_assert(!__is_lvalue_expr(expr), "should be an rvalue"); \ + static_assert(!__is_lvalue_expr((expr)), \ + "the presence of parentheses should have" \ + " no effect on lvalueness (expr.prim/5)") + +enum Enum { Enumerator }; + +int ReturnInt(); +void ReturnVoid(); +Enum ReturnEnum(); + +void basic_lval_5() +{ + // basic.lval/5: The result of calling a function that does not return + // a reference is an rvalue. + ASSERT_RVALUE(ReturnInt()); + ASSERT_RVALUE(ReturnVoid()); + ASSERT_RVALUE(ReturnEnum()); +} + +int& ReturnIntReference(); +extern Enum& ReturnEnumReference(); + +void basic_lval_6() +{ + // basic.lval/6: An expression which holds a temporary object resulting + // from a cast to a nonreference type is an rvalue (this includes + // the explicit creation of an object using functional notation + struct IntClass + { + explicit IntClass(int = 0); + IntClass(char const*); + operator int() const; + }; + + struct ConvertibleToIntClass + { + operator IntClass() const; + }; + + ConvertibleToIntClass b; + + // Make sure even trivial conversions are not detected as lvalues + int intLvalue = 0; + ASSERT_RVALUE((int)intLvalue); + ASSERT_RVALUE((short)intLvalue); + ASSERT_RVALUE((long)intLvalue); + + // Same tests with function-call notation + ASSERT_RVALUE(int(intLvalue)); + ASSERT_RVALUE(short(intLvalue)); + ASSERT_RVALUE(long(intLvalue)); + + char charLValue = 'x'; + ASSERT_RVALUE((signed char)charLValue); + ASSERT_RVALUE((unsigned char)charLValue); + + ASSERT_RVALUE(static_cast<int>(IntClass())); + IntClass intClassLValue; + ASSERT_RVALUE(static_cast<int>(intClassLValue)); + ASSERT_RVALUE(static_cast<IntClass>(ConvertibleToIntClass())); + ConvertibleToIntClass convertibleToIntClassLValue; + ASSERT_RVALUE(static_cast<IntClass>(convertibleToIntClassLValue)); + + + typedef signed char signed_char; + typedef unsigned char unsigned_char; + ASSERT_RVALUE(signed_char(charLValue)); + ASSERT_RVALUE(unsigned_char(charLValue)); + + ASSERT_RVALUE(int(IntClass())); + ASSERT_RVALUE(int(intClassLValue)); + ASSERT_RVALUE(IntClass(ConvertibleToIntClass())); + ASSERT_RVALUE(IntClass(convertibleToIntClassLValue)); +} + +void conv_ptr_1() +{ + // conv.ptr/1: A null pointer constant is an integral constant + // expression (5.19) rvalue of integer type that evaluates to + // zero. + ASSERT_RVALUE(0); +} + +void expr_6() +{ + // expr/6: If an expression initially has the type “reference to T” + // (8.3.2, 8.5.3), ... the expression is an lvalue. + int x = 0; + int& referenceToInt = x; + ASSERT_LVALUE(referenceToInt); + ASSERT_LVALUE(ReturnIntReference()); +} + +void expr_prim_2() +{ + // 5.1/2 A string literal is an lvalue; all other + // literals are rvalues. + ASSERT_LVALUE("foo"); + ASSERT_RVALUE(1); + ASSERT_RVALUE(1.2); + ASSERT_RVALUE(10UL); +} + +void expr_prim_3() +{ + // 5.1/3: The keyword "this" names a pointer to the object for + // which a nonstatic member function (9.3.2) is invoked. ...The + // expression is an rvalue. + struct ThisTest + { + void f() { ASSERT_RVALUE(this); } + }; +} + +extern int variable; +void Function(); + +struct BaseClass +{ + virtual ~BaseClass(); + + int BaseNonstaticMemberFunction(); + static int BaseStaticMemberFunction(); + int baseDataMember; +}; + +struct Class : BaseClass +{ + static void function(); + static int variable; + + template <class T> + struct NestedClassTemplate {}; + + template <class T> + static int& NestedFuncTemplate() { return variable; } // expected-note{{candidate function}} + + template <class T> + int& NestedMemfunTemplate() { return variable; } + + int operator*() const; + + template <class T> + int operator+(T) const; + + int NonstaticMemberFunction(); + static int StaticMemberFunction(); + int dataMember; + + int& referenceDataMember; + static int& staticReferenceDataMember; + static int staticNonreferenceDataMember; + + enum Enum { Enumerator }; + + operator long() const; + + Class(); + Class(int,int); + + void expr_prim_4() + { + // 5.1/4: The operator :: followed by an identifier, a + // qualified-id, or an operator-function-id is a primary- + // expression. ...The result is an lvalue if the entity is + // a function or variable. + ASSERT_LVALUE(::Function); // identifier: function + ASSERT_LVALUE(::variable); // identifier: variable + + // the only qualified-id form that can start without "::" (and thus + // be legal after "::" ) is + // + // ::<sub>opt</sub> nested-name-specifier template<sub>opt</sub> unqualified-id + ASSERT_LVALUE(::Class::function); // qualified-id: function + ASSERT_LVALUE(::Class::variable); // qualified-id: variable + + // The standard doesn't give a clear answer about whether these + // should really be lvalues or rvalues without some surrounding + // context that forces them to be interpreted as naming a + // particular function template specialization (that situation + // doesn't come up in legal pure C++ programs). This language + // extension simply rejects them as requiring additional context + __is_lvalue_expr(::Class::NestedFuncTemplate); // qualified-id: template \ + // expected-error{{cannot resolve overloaded function 'NestedFuncTemplate' from context}} + + __is_lvalue_expr(::Class::NestedMemfunTemplate); // qualified-id: template \ + // expected-error{{a bound member function may only be called}} + + __is_lvalue_expr(::Class::operator+); // operator-function-id: template \ + // expected-error{{a bound member function may only be called}} + + //ASSERT_RVALUE(::Class::operator*); // operator-function-id: member function + } + + void expr_prim_7() + { + // expr.prim/7 An identifier is an id-expression provided it has been + // suitably declared (clause 7). [Note: ... ] The type of the + // expression is the type of the identifier. The result is the + // entity denoted by the identifier. The result is an lvalue if + // the entity is a function, variable, or data member... (cont'd) + ASSERT_LVALUE(Function); // identifier: function + ASSERT_LVALUE(StaticMemberFunction); // identifier: function + ASSERT_LVALUE(variable); // identifier: variable + ASSERT_LVALUE(dataMember); // identifier: data member + //ASSERT_RVALUE(NonstaticMemberFunction); // identifier: member function + + // (cont'd)...A nested-name-specifier that names a class, + // optionally followed by the keyword template (14.2), and then + // followed by the name of a member of either that class (9.2) or + // one of its base classes... is a qualified-id... The result is + // the member. The type of the result is the type of the + // member. The result is an lvalue if the member is a static + // member function or a data member. + ASSERT_LVALUE(Class::dataMember); + ASSERT_LVALUE(Class::StaticMemberFunction); + //ASSERT_RVALUE(Class::NonstaticMemberFunction); // identifier: member function + + ASSERT_LVALUE(Class::baseDataMember); + ASSERT_LVALUE(Class::BaseStaticMemberFunction); + //ASSERT_RVALUE(Class::BaseNonstaticMemberFunction); // identifier: member function + } +}; + +void expr_call_10() +{ + // expr.call/10: A function call is an lvalue if and only if the + // result type is a reference. This statement is partially + // redundant with basic.lval/5 + basic_lval_5(); + + ASSERT_LVALUE(ReturnIntReference()); + ASSERT_LVALUE(ReturnEnumReference()); +} + +namespace Namespace +{ + int x; + void function(); +} + +void expr_prim_8() +{ + // expr.prim/8 A nested-name-specifier that names a namespace + // (7.3), followed by the name of a member of that namespace (or + // the name of a member of a namespace made visible by a + // using-directive ) is a qualified-id; 3.4.3.2 describes name + // lookup for namespace members that appear in qualified-ids. The + // result is the member. The type of the result is the type of the + // member. The result is an lvalue if the member is a function or + // a variable. + ASSERT_LVALUE(Namespace::x); + ASSERT_LVALUE(Namespace::function); +} + +void expr_sub_1(int* pointer) +{ + // expr.sub/1 A postfix expression followed by an expression in + // square brackets is a postfix expression. One of the expressions + // shall have the type “pointer to T” and the other shall have + // enumeration or integral type. The result is an lvalue of type + // “T.” + ASSERT_LVALUE(pointer[1]); + + // The expression E1[E2] is identical (by definition) to *((E1)+(E2)). + ASSERT_LVALUE(*(pointer+1)); +} + +void expr_type_conv_1() +{ + // expr.type.conv/1 A simple-type-specifier (7.1.5) followed by a + // parenthesized expression-list constructs a value of the specified + // type given the expression list. ... If the expression list + // specifies more than a single value, the type shall be a class with + // a suitably declared constructor (8.5, 12.1), and the expression + // T(x1, x2, ...) is equivalent in effect to the declaration T t(x1, + // x2, ...); for some invented temporary variable t, with the result + // being the value of t as an rvalue. + ASSERT_RVALUE(Class(2,2)); +} + +void expr_type_conv_2() +{ + // expr.type.conv/2 The expression T(), where T is a + // simple-type-specifier (7.1.5.2) for a non-array complete object + // type or the (possibly cv-qualified) void type, creates an + // rvalue of the specified type, + ASSERT_RVALUE(int()); + ASSERT_RVALUE(Class()); + ASSERT_RVALUE(void()); +} + + +void expr_ref_4() +{ + // Applies to expressions of the form E1.E2 + + // If E2 is declared to have type “reference to T”, then E1.E2 is + // an lvalue;.... Otherwise, one of the following rules applies. + ASSERT_LVALUE(Class().staticReferenceDataMember); + ASSERT_LVALUE(Class().referenceDataMember); + + // — If E2 is a static data member, and the type of E2 is T, then + // E1.E2 is an lvalue; ... + ASSERT_LVALUE(Class().staticNonreferenceDataMember); + ASSERT_LVALUE(Class().staticReferenceDataMember); + + + // — If E2 is a non-static data member, ... If E1 is an lvalue, + // then E1.E2 is an lvalue... + Class lvalue; + ASSERT_LVALUE(lvalue.dataMember); + ASSERT_RVALUE(Class().dataMember); + + // — If E1.E2 refers to a static member function, ... then E1.E2 + // is an lvalue + ASSERT_LVALUE(Class().StaticMemberFunction); + + // — Otherwise, if E1.E2 refers to a non-static member function, + // then E1.E2 is not an lvalue. + //ASSERT_RVALUE(Class().NonstaticMemberFunction); + + // — If E2 is a member enumerator, and the type of E2 is T, the + // expression E1.E2 is not an lvalue. The type of E1.E2 is T. + ASSERT_RVALUE(Class().Enumerator); + ASSERT_RVALUE(lvalue.Enumerator); +} + + +void expr_post_incr_1(int x) +{ + // expr.post.incr/1 The value obtained by applying a postfix ++ is + // the value that the operand had before applying the + // operator... The result is an rvalue. + ASSERT_RVALUE(x++); +} + +void expr_dynamic_cast_2() +{ + // expr.dynamic.cast/2: If T is a pointer type, v shall be an + // rvalue of a pointer to complete class type, and the result is + // an rvalue of type T. + Class instance; + ASSERT_RVALUE(dynamic_cast<Class*>(&instance)); + + // If T is a reference type, v shall be an + // lvalue of a complete class type, and the result is an lvalue of + // the type referred to by T. + ASSERT_LVALUE(dynamic_cast<Class&>(instance)); +} + +void expr_dynamic_cast_5() +{ + // expr.dynamic.cast/5: If T is “reference to cv1 B” and v has type + // “cv2 D” such that B is a base class of D, the result is an + // lvalue for the unique B sub-object of the D object referred + // to by v. + typedef BaseClass B; + typedef Class D; + D object; + ASSERT_LVALUE(dynamic_cast<B&>(object)); +} + +// expr.dynamic.cast/8: The run-time check logically executes as follows: +// +// — If, in the most derived object pointed (referred) to by v, v +// points (refers) to a public base class subobject of a T object, and +// if only one object of type T is derived from the sub-object pointed +// (referred) to by v, the result is a pointer (an lvalue referring) +// to that T object. +// +// — Otherwise, if v points (refers) to a public base class sub-object +// of the most derived object, and the type of the most derived object +// has a base class, of type T, that is unambiguous and public, the +// result is a pointer (an lvalue referring) to the T sub-object of +// the most derived object. +// +// The mention of "lvalue" in the text above appears to be a +// defect that is being corrected by the response to UK65 (see +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2841.html). + +#if 0 +void expr_typeid_1() +{ + // expr.typeid/1: The result of a typeid expression is an lvalue... + ASSERT_LVALUE(typeid(1)); +} +#endif + +void expr_static_cast_1(int x) +{ + // expr.static.cast/1: The result of the expression + // static_cast<T>(v) is the result of converting the expression v + // to type T. If T is a reference type, the result is an lvalue; + // otherwise, the result is an rvalue. + ASSERT_LVALUE(static_cast<int&>(x)); + ASSERT_RVALUE(static_cast<int>(x)); +} + +void expr_reinterpret_cast_1() +{ + // expr.reinterpret.cast/1: The result of the expression + // reinterpret_cast<T>(v) is the result of converting the + // expression v to type T. If T is a reference type, the result is + // an lvalue; otherwise, the result is an rvalue + ASSERT_RVALUE(reinterpret_cast<int*>(0)); + char const v = 0; + ASSERT_LVALUE(reinterpret_cast<char const&>(v)); +} + +void expr_unary_op_1(int* pointer, struct incomplete* pointerToIncompleteType) +{ + // expr.unary.op/1: The unary * operator performs indirection: the + // expression to which it is applied shall be a pointer to an + // object type, or a pointer to a function type and the result is + // an lvalue referring to the object or function to which the + // expression points. + ASSERT_LVALUE(*pointer); + ASSERT_LVALUE(*Function); + + // [Note: a pointer to an incomplete type + // (other than cv void ) can be dereferenced. ] + ASSERT_LVALUE(*pointerToIncompleteType); +} + +void expr_pre_incr_1(int operand) +{ + // expr.pre.incr/1: The operand of prefix ++ ... shall be a + // modifiable lvalue.... The value is the new value of the + // operand; it is an lvalue. + ASSERT_LVALUE(++operand); +} + +void expr_cast_1(int x) +{ + // expr.cast/1: The result of the expression (T) cast-expression + // is of type T. The result is an lvalue if T is a reference type, + // otherwise the result is an rvalue. + ASSERT_LVALUE((void(&)())expr_cast_1); + ASSERT_LVALUE((int&)x); + ASSERT_RVALUE((void(*)())expr_cast_1); + ASSERT_RVALUE((int)x); +} + +void expr_mptr_oper() +{ + // expr.mptr.oper/6: The result of a .* expression is an lvalue + // only if its first operand is an lvalue and its second operand + // is a pointer to data member... (cont'd) + typedef Class MakeRValue; + ASSERT_RVALUE(MakeRValue().*(&Class::dataMember)); + //ASSERT_RVALUE(MakeRValue().*(&Class::NonstaticMemberFunction)); + Class lvalue; + ASSERT_LVALUE(lvalue.*(&Class::dataMember)); + //ASSERT_RVALUE(lvalue.*(&Class::NonstaticMemberFunction)); + + // (cont'd)...The result of an ->* expression is an lvalue only + // if its second operand is a pointer to data member. If the + // second operand is the null pointer to member value (4.11), the + // behavior is undefined. + ASSERT_LVALUE((&lvalue)->*(&Class::dataMember)); + //ASSERT_RVALUE((&lvalue)->*(&Class::NonstaticMemberFunction)); +} + +void expr_cond(bool cond) +{ + // 5.16 Conditional operator [expr.cond] + // + // 2 If either the second or the third operand has type (possibly + // cv-qualified) void, then the lvalue-to-rvalue (4.1), + // array-to-pointer (4.2), and function-to-pointer (4.3) standard + // conversions are performed on the second and third operands, and one + // of the following shall hold: + // + // — The second or the third operand (but not both) is a + // throw-expression (15.1); the result is of the type of the other and + // is an rvalue. + + Class classLvalue; + ASSERT_RVALUE(cond ? throw 1 : (void)0); + ASSERT_RVALUE(cond ? (void)0 : throw 1); + ASSERT_RVALUE(cond ? throw 1 : classLvalue); + ASSERT_RVALUE(cond ? classLvalue : throw 1); + + // — Both the second and the third operands have type void; the result + // is of type void and is an rvalue. [Note: this includes the case + // where both operands are throw-expressions. ] + ASSERT_RVALUE(cond ? (void)1 : (void)0); + ASSERT_RVALUE(cond ? throw 1 : throw 0); + + // expr.cond/4: If the second and third operands are lvalues and + // have the same type, the result is of that type and is an + // lvalue. + ASSERT_LVALUE(cond ? classLvalue : classLvalue); + int intLvalue = 0; + ASSERT_LVALUE(cond ? intLvalue : intLvalue); + + // expr.cond/5:Otherwise, the result is an rvalue. + typedef Class MakeRValue; + ASSERT_RVALUE(cond ? MakeRValue() : classLvalue); + ASSERT_RVALUE(cond ? classLvalue : MakeRValue()); + ASSERT_RVALUE(cond ? MakeRValue() : MakeRValue()); + ASSERT_RVALUE(cond ? classLvalue : intLvalue); + ASSERT_RVALUE(cond ? intLvalue : int()); +} + +void expr_ass_1(int x) +{ + // expr.ass/1: There are several assignment operators, all of + // which group right-to-left. All require a modifiable lvalue as + // their left operand, and the type of an assignment expression is + // that of its left operand. The result of the assignment + // operation is the value stored in the left operand after the + // assignment has taken place; the result is an lvalue. + ASSERT_LVALUE(x = 1); + ASSERT_LVALUE(x += 1); + ASSERT_LVALUE(x -= 1); + ASSERT_LVALUE(x *= 1); + ASSERT_LVALUE(x /= 1); + ASSERT_LVALUE(x %= 1); + ASSERT_LVALUE(x ^= 1); + ASSERT_LVALUE(x &= 1); + ASSERT_LVALUE(x |= 1); +} + +void expr_comma(int x) +{ + // expr.comma: A pair of expressions separated by a comma is + // evaluated left-to-right and the value of the left expression is + // discarded... result is an lvalue if its right operand is. + + // Can't use the ASSERT_XXXX macros without adding parens around + // the comma expression. + static_assert(__is_lvalue_expr(x,x), "expected an lvalue"); + static_assert(__is_rvalue_expr(x,1), "expected an rvalue"); + static_assert(__is_lvalue_expr(1,x), "expected an lvalue"); + static_assert(__is_rvalue_expr(1,1), "expected an rvalue"); +} + +#if 0 +template<typename T> void f(); + +// FIXME These currently fail +void expr_fun_lvalue() +{ + ASSERT_LVALUE(&f<int>); +} + +void expr_fun_rvalue() +{ + ASSERT_RVALUE(f<int>); +} +#endif + +template <int NonTypeNonReferenceParameter, int& NonTypeReferenceParameter> +void check_temp_param_6() +{ + ASSERT_RVALUE(NonTypeNonReferenceParameter); + ASSERT_LVALUE(NonTypeReferenceParameter); +} + +int AnInt = 0; + +void temp_param_6() +{ + check_temp_param_6<3,AnInt>(); +} diff --git a/test/SemaCXX/flexible-array-test.cpp b/test/SemaCXX/flexible-array-test.cpp index 95d8bb1..e6c3132 100644 --- a/test/SemaCXX/flexible-array-test.cpp +++ b/test/SemaCXX/flexible-array-test.cpp @@ -51,5 +51,19 @@ class A { union B { int s; - char c[]; // expected-error {{field has incomplete type 'char []'}} + char c[]; +}; + +namespace rdar9065507 { + +struct StorageBase { + long ref_count; + unsigned size; + unsigned capacity; }; + +struct Storage : StorageBase { + int data[]; +}; + +} diff --git a/test/SemaCXX/for-range-examples.cpp b/test/SemaCXX/for-range-examples.cpp new file mode 100644 index 0000000..810f1de --- /dev/null +++ b/test/SemaCXX/for-range-examples.cpp @@ -0,0 +1,150 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x + +namespace value_range_detail { + template<typename T> + class value_range_iter { + T t; + public: + value_range_iter(const T &t) : t(t) {} + T operator*() const { return t; } + bool operator!=(const value_range_iter &o) const { return t != o.t; } + value_range_iter &operator++() { ++t; return *this; } + }; + + template<typename T> + struct value_range { + value_range(const T &a, const T &b) : begin_(a), end_(b) {} + value_range_iter<T> begin_, end_; + }; + + template<typename T> + value_range_iter<T> begin(const value_range<T> &r) { return r.begin_; } + template<typename T> + value_range_iter<T> end(const value_range<T> &r) { return r.end_; } + + + struct end_t {}; + + template<typename T> + class value_range_step_iter { + T it, step; + public: + value_range_step_iter(const T &it, const T &step) : it(it), step(step) {} + T operator*() const { return it; } + bool operator!=(value_range_step_iter end) const { return it != end.it; } + value_range_step_iter &operator++() { it += step; return *this; } + }; + + template<typename T> + class value_range_step { + T it, step, end_; + public: + value_range_step(const T &it, const T &end, const T &step) : + it(it), end_(end), step(step) {} + typedef value_range_step_iter<T> iterator; + iterator begin() const { return iterator(it, step); } + iterator end() const { return iterator(end_, step); } + }; +} + +template<typename T> +value_range_detail::value_range<T> range(const T &a, const T &b) { return value_range_detail::value_range<T>(a, b); } + +template<typename T> +value_range_detail::value_range_step<T> range(const T &a, const T &b, const T &step) { return value_range_detail::value_range_step<T>(a, b, step); } + + +namespace map_range { + template<typename T> + class vector { + T storage[100]; + decltype(sizeof(char)) size; + public: + vector() : size() {} + void push_back(T t) { storage[size++] = t; } + T *begin() { return storage; } + T *end() { return storage + size; } + }; + + template<typename T> struct tuple_elem { + T t; + tuple_elem() {} + tuple_elem(T t) : t(t) {} + }; + template<typename... A> + struct tuple : tuple_elem<A>... { + tuple() : tuple_elem<A>()... {} + tuple(A... a) : tuple_elem<A>(a)... {} + template<typename B> B &get() { return tuple_elem<B>::t; } + }; + + template<typename F, typename I> + class map_iter { + F f; + I i; + public: + map_iter(F f, I i) : f(f), i(i) {} + auto operator*() const -> decltype(f(*i)) { return f(*i); } + bool operator!=(const map_iter &o) const { return i != o.i; } + map_iter &operator++() { ++i; return *this; } + }; + + template<typename T> + struct iter_pair { + T begin_, end_; + iter_pair(T begin, T end) : begin_(begin), end_(end) {} + }; + template<typename T> T begin(iter_pair<T> p) { return p.begin_; } + template<typename T> T end(iter_pair<T> p) { return p.end_; } + + template<typename...> class mem_fun_impl; + template<typename R, typename T, typename... A> + class mem_fun_impl<R (T::*)(A...)> { + typedef R (T::*F)(A...); + F f; + public: + mem_fun_impl(F f) : f(f) {} + R operator()(T &t, A &&...a) const { return (t.*f)(static_cast<A&&>(a)...); } + }; + template<typename F> mem_fun_impl<F> mem_fun(F f) { return mem_fun_impl<F>(f); } + + template<typename F, typename T> + auto map(const F &f, T &t) -> iter_pair<map_iter<F, decltype(t.begin())>> { + typedef map_iter<F, decltype(t.begin())> iter; + return iter_pair<iter>(iter(f, t.begin()), iter(f, t.end())); + } +} + +#define assert(b) if (!b) { return 1; } +int main() { + int total = 0; + + for (auto n : range(1, 5)) { + total += n; + } + assert(total == 10); + + for (auto n : range(10, 100, 10)) { + total += n; + } + assert(total == 460); + + map_range::vector<char> chars; + chars.push_back('a'); + chars.push_back('b'); + chars.push_back('c'); + for (char c : chars) { + ++total; + } + assert(total == 463); + + typedef map_range::tuple<int, double> T; + map_range::vector<T> pairs; + pairs.push_back(T(42, 12.9)); + pairs.push_back(T(6, 4.2)); + pairs.push_back(T(9, 1.1)); + for (auto a : map(map_range::mem_fun(&T::get<int>), pairs)) { + total += a; + } + assert(total == 500); +} diff --git a/test/SemaCXX/for-range-no-std.cpp b/test/SemaCXX/for-range-no-std.cpp new file mode 100644 index 0000000..8cc71e5 --- /dev/null +++ b/test/SemaCXX/for-range-no-std.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x + +struct S { + int *begin(); + int *end(); +}; + +struct T { +}; + +struct Range {}; +int begin(Range); // expected-note {{not viable}} +int end(Range); + +namespace NS { + struct ADL {}; + struct iter { + int operator*(); + bool operator!=(iter); + void operator++(); + }; + iter begin(ADL); // expected-note {{not viable}} + iter end(ADL); + + struct NoADL {}; +} +NS::iter begin(NS::NoADL); // expected-note {{not viable}} +NS::iter end(NS::NoADL); + +void f() { + int a[] = {1, 2, 3}; + for (auto b : S()) {} // ok + for (auto b : T()) {} // expected-error {{no matching function for call to 'begin'}} expected-note {{range has type}} + for (auto b : a) {} // ok + for (int b : NS::ADL()) {} // ok + for (int b : NS::NoADL()) {} // expected-error {{no matching function for call to 'begin'}} expected-note {{range has type}} +} diff --git a/test/SemaCXX/friend.cpp b/test/SemaCXX/friend.cpp index 1222dd0..b1ef220 100644 --- a/test/SemaCXX/friend.cpp +++ b/test/SemaCXX/friend.cpp @@ -64,11 +64,11 @@ namespace test4 { } namespace rdar8529993 { -struct A { ~A(); }; // expected-note {{nearly matches}} +struct A { ~A(); }; struct B : A { - template<int> friend A::~A(); // expected-error {{does not match}} + template<int> friend A::~A(); // expected-error {{destructor cannot be declared as a template}} }; } diff --git a/test/SemaCXX/generic-selection.cpp b/test/SemaCXX/generic-selection.cpp new file mode 100644 index 0000000..b171fce --- /dev/null +++ b/test/SemaCXX/generic-selection.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +template <typename T, typename U = void*> +struct A { + enum { + id = _Generic(T(), // expected-error {{controlling expression type 'char' not compatible with any generic association type}} + int: 1, // expected-note {{compatible type 'int' specified here}} + float: 2, + U: 3) // expected-error {{type 'int' in generic association compatible with previously specified type 'int'}} + }; +}; + +static_assert(A<int>::id == 1, "fail"); +static_assert(A<float>::id == 2, "fail"); +static_assert(A<double, double>::id == 3, "fail"); + +A<char> a1; // expected-note {{in instantiation of template class 'A<char, void *>' requested here}} +A<short, int> a2; // expected-note {{in instantiation of template class 'A<short, int>' requested here}} + +template <typename T, typename U> +struct B { + enum { + id = _Generic(T(), + int: 1, // expected-note {{compatible type 'int' specified here}} + int: 2, // expected-error {{type 'int' in generic association compatible with previously specified type 'int'}} + U: 3) + }; +}; + +template <unsigned Arg, unsigned... Args> struct Or { + enum { result = Arg | Or<Args...>::result }; +}; + +template <unsigned Arg> struct Or<Arg> { + enum { result = Arg }; +}; + +template <class... Args> struct TypeMask { + enum { + result = Or<_Generic(Args(), int: 1, long: 2, short: 4, float: 8)...>::result + }; +}; + +static_assert(TypeMask<int, long, short>::result == 7, "fail"); +static_assert(TypeMask<float, short>::result == 12, "fail"); +static_assert(TypeMask<int, float, float>::result == 9, "fail"); diff --git a/test/SemaCXX/goto.cpp b/test/SemaCXX/goto.cpp new file mode 100644 index 0000000..d8d5ec5 --- /dev/null +++ b/test/SemaCXX/goto.cpp @@ -0,0 +1,105 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wall -fblocks %s + +// PR9463 +double *end; +void f(bool b1, bool b2) { + { + do { + int end = 0; + if (b2) { + do { + goto end; + } while (b2); + } + end = 1; + } while (b1); + } + + end: + return; +} + +namespace N { + float* end; + void f(bool b1, bool b2) { + { + do { + int end = 0; + if (b2) { + do { + goto end; + } while (b2); + } + end = 1; + } while (b1); + } + + end: + return; + } +} + +void g() { + end = 1; // expected-error{{assigning to 'double *' from incompatible type 'int'}} +} + +void h(int end) { + { + goto end; // expected-error{{use of undeclared label 'end'}} + } +} + +void h2(int end) { + { + __label__ end; + goto end; + + end: + ::end = 0; + } + end: // expected-warning{{unused label 'end'}} + end = 1; +} + +class X { +public: + X(); +}; + +void rdar9135994() +{ +X: + goto X; +} + +namespace PR9495 { + struct NonPOD { NonPOD(); ~NonPOD(); }; + + void f(bool b) { + NonPOD np; + if (b) { + goto undeclared; // expected-error{{use of undeclared label 'undeclared'}} + } + } + + void g() { + (void)^(bool b){ + NonPOD np; + if (b) { + goto undeclared; // expected-error{{use of undeclared label 'undeclared'}} + } + }; + } +} + +extern "C" { + void exit(int); +} + +void f() { + { + goto exit; + } + exit: + return; +} diff --git a/test/SemaCXX/goto2.cpp b/test/SemaCXX/goto2.cpp new file mode 100644 index 0000000..01ea031 --- /dev/null +++ b/test/SemaCXX/goto2.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +//PR9463 +int subfun(const char *text) { + const char *tmp = text; + return 0; +} + +void fun(const char* text) { + int count = 0; + bool check = true; + + if (check) + { + const char *end = text; + + if (check) + { + do + { + if (check) + { + count = subfun(end); + goto end; + } + + check = !check; + } + while (check); + } + // also works, after commenting following line of source code + int e = subfun(end); + } + end: + if (check) + ++count; +} + +const char *text = "some text"; + +int main() { + const char *ptr = text; + + fun(ptr); + + return 0; +} diff --git a/test/SemaCXX/init-priority-attr.cpp b/test/SemaCXX/init-priority-attr.cpp index 7605ee6..6facebf 100644 --- a/test/SemaCXX/init-priority-attr.cpp +++ b/test/SemaCXX/init-priority-attr.cpp @@ -19,7 +19,7 @@ extern Two koo[]; Two foo __attribute__((init_priority(101))) ( 5, 6 ); -Two goo __attribute__((init_priority(2,3))) ( 5, 6 ); // expected-error {{attribute requires 1 argument(s)}} +Two goo __attribute__((init_priority(2,3))) ( 5, 6 ); // expected-error {{attribute takes one argument}} Two coo[2] __attribute__((init_priority(3))); // expected-error {{init_priority attribute requires integer constant between 101 and 65535 inclusive}} diff --git a/test/SemaCXX/libstdcxx_is_pod_hack.cpp b/test/SemaCXX/libstdcxx_is_pod_hack.cpp index 2e92032..3581c79 100644 --- a/test/SemaCXX/libstdcxx_is_pod_hack.cpp +++ b/test/SemaCXX/libstdcxx_is_pod_hack.cpp @@ -11,3 +11,19 @@ struct __is_pod { }; __is_pod<int> ipi; + +// Ditto for __is_same. +template<typename T> +struct __is_same { +}; + +__is_same<int> isi; + +// Another, similar egregious hack for __is_signed, which is a type +// trait in Embarcadero's compiler but is used as an identifier in +// libstdc++. +struct test_is_signed { + static const bool __is_signed = true; +}; + +bool check_signed = test_is_signed::__is_signed; diff --git a/test/SemaCXX/literal-type.cpp b/test/SemaCXX/literal-type.cpp index 142dd75..6a61823 100644 --- a/test/SemaCXX/literal-type.cpp +++ b/test/SemaCXX/literal-type.cpp @@ -1,10 +1,71 @@ // RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s static_assert(__is_literal(int), "fail"); +static_assert(__is_literal_type(int), "fail"); // alternate spelling for GCC static_assert(__is_literal(void*), "fail"); enum E { E1 }; static_assert(__is_literal(E), "fail"); static_assert(__is_literal(decltype(E1)), "fail"); typedef int IAR[10]; static_assert(__is_literal(IAR), "fail"); -// FIXME: Records +typedef int Vector __attribute__((vector_size(16))); +typedef int VectorExt __attribute__((ext_vector_type(4))); +static_assert(__is_literal(Vector), "fail"); +static_assert(__is_literal(VectorExt), "fail"); + +// C++0x [basic.types]p10: +// A type is a literal type if it is: +// [...] +// -- a class type that has all of the following properties: +// -- it has a trivial destructor +// -- every constructor call and full-expression in the +// brace-or-equal-initializers for non-static data members (if an) is +// a constant expression, +// -- it is an aggregate type or has at least one constexpr constructor +// or constructor template that is not a copy or move constructor, and +// -- it has all non-static data members and base classes of literal +// types +struct Empty {}; +struct LiteralType { + int x; + E e; + IAR arr; + Empty empty; + int method(); +}; +struct HasDtor { ~HasDtor(); }; + +class NonAggregate { int x; }; +struct HasNonLiteralBase : NonAggregate {}; +struct HasNonLiteralMember { HasDtor x; }; + +static_assert(__is_literal(Empty), "fail"); +static_assert(__is_literal(LiteralType), "fail"); +static_assert(!__is_literal(HasDtor), "fail"); +static_assert(!__is_literal(NonAggregate), "fail"); +static_assert(!__is_literal(HasNonLiteralBase), "fail"); +static_assert(!__is_literal(HasNonLiteralMember), "fail"); + +// FIXME: Test constexpr constructors and non-static members with initializers +// when Clang supports them: +#if 0 +extern int f(); +struct HasNonConstExprMemInit { + int x = f(); + constexpr HasNonConstExprMemInit(int y) {} +}; +static_assert(!__is_literal(HasNonConstExprMemInit), "fail"); + +class HasConstExprCtor { + int x; +public: + constexpr HasConstExprCtor(int x) : x(x) {} +}; +template <typename T> class HasConstExprCtorTemplate { + T x; +public: + template <typename U> constexpr HasConstExprCtorTemplate(U y) : x(y) {} +}; +static_assert(__is_literal(HasConstExprCtor), "fail"); +static_assert(__is_literal(HasConstExprCtorTemplate), "fail"); +#endif diff --git a/test/SemaCXX/member-expr.cpp b/test/SemaCXX/member-expr.cpp index 3c3eb04..68af415 100644 --- a/test/SemaCXX/member-expr.cpp +++ b/test/SemaCXX/member-expr.cpp @@ -135,4 +135,9 @@ namespace PR9025 { int g3() { return fun3.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}} } + + template <typename T> S fun4(); + int g4() { + return fun4.x; // expected-error{{base of member reference is a function; perhaps you meant to call it?}} + } } diff --git a/test/SemaCXX/member-pointers-2.cpp b/test/SemaCXX/member-pointers-2.cpp index 4b3b82c..6c39282 100644 --- a/test/SemaCXX/member-pointers-2.cpp +++ b/test/SemaCXX/member-pointers-2.cpp @@ -34,3 +34,18 @@ void test0() { Test0 mytest; mytest.test(); } + +namespace rdar9065289 { + typedef void (*FuncPtr)(); + struct X0 { }; + + struct X1 + { + X0* x0; + FuncPtr X0::*fptr; + }; + + void f(X1 p) { + (p.x0->*(p.fptr))(); + } +} diff --git a/test/SemaCXX/neon-vector-types.cpp b/test/SemaCXX/neon-vector-types.cpp new file mode 100644 index 0000000..aa82b11 --- /dev/null +++ b/test/SemaCXX/neon-vector-types.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// rdar://9208404 + +typedef int MP4Err; +typedef float Float32; +typedef float float32_t; +typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t; +typedef float vFloat __attribute__((__vector_size__(16))); +typedef vFloat VFLOAT; +typedef unsigned long UInt32; + +extern int bar (float32x4_t const *p); + +int foo (const Float32 *realBufPtr) { + float32x4_t const *vRealPtr = (VFLOAT *)&realBufPtr[0]; + return bar(vRealPtr); +} + +MP4Err autoCorrelation2nd_Neon(Float32 *alphar, Float32 *alphai, + const Float32 *realBufPtr, + const Float32 *imagBufPtr, + const UInt32 len) +{ + float32x4_t const *vRealPtr = (VFLOAT *)&realBufPtr[0]; + return 0; +} + diff --git a/test/SemaCXX/nested-name-spec-locations.cpp b/test/SemaCXX/nested-name-spec-locations.cpp index 25914df..048d4ba 100644 --- a/test/SemaCXX/nested-name-spec-locations.cpp +++ b/test/SemaCXX/nested-name-spec-locations.cpp @@ -65,6 +65,98 @@ void PseudoDestructorExprCheck( template<typename T> struct DependentScopedDeclRefExpr { void f() { - outer_alias::inner::X0<T>::value = 17; + outer_alias::inner::X0<typename add_reference<T>::type + * // expected-error{{as a pointer to a reference of type}} + >::value = 17; } }; + +void DependentScopedDeclRefExprCheck(DependentScopedDeclRefExpr<int> t) { + t.f(); // expected-note{{in instantiation of member function}} +} + + +template<typename T> +struct TypenameTypeTester { + typedef typename outer::inner::X0< + typename add_reference<T>::type + * // expected-error{{declared as a pointer to a reference of type}} + >::type type; +}; + +TypenameTypeTester<int> TypenameTypeCheck; // expected-note{{in instantiation of template class}} + +template<typename T, typename U> +struct DependentTemplateSpecializationTypeTester { + typedef typename T::template apply<typename add_reference<U>::type + * // expected-error{{declared as a pointer to a reference of type}} + >::type type; +}; + +struct HasApply { + template<typename T> + struct apply { + typedef T type; + }; +}; + +DependentTemplateSpecializationTypeTester<HasApply, int> DTSTCheck; // expected-note{{in instantiation of template class}} + +template<typename T, typename U> +struct DependentTemplateSpecializationTypeTester2 { + typedef typename T::template apply<typename add_reference<U>::type + * // expected-error{{declared as a pointer to a reference of type}} + > type; +}; + +DependentTemplateSpecializationTypeTester2<HasApply, int> DTSTCheck2; // expected-note{{in instantiation of template class}} + +template<typename T, typename U> +struct DependentTemplateSpecializationTypeTester3 : + T::template apply<typename add_reference<U>::type + * // expected-error{{declared as a pointer to a reference of type}} + > +{}; + +DependentTemplateSpecializationTypeTester3<HasApply, int> DTSTCheck3; // expected-note{{in instantiation of template class}} + +template<typename T, typename U> +struct DependentTemplateSpecializationTypeTester4 { + typedef class T::template apply<typename add_reference<U>::type + * // expected-error{{declared as a pointer to a reference of type}} + > type; +}; + +DependentTemplateSpecializationTypeTester4<HasApply, int> DTSTCheck4; // expected-note{{in instantiation of template class}} + +template<template<class T> class TTP> +struct AcceptedTemplateTemplateParameter { +}; + +template<typename T, typename U> +struct DependentTemplateTemplateArgumentTester { + typedef AcceptedTemplateTemplateParameter< + T:: + template apply< + typename add_reference<U>::type + * // expected-error{{declared as a pointer to a reference of type}} + >:: + template X> + type; +}; + +DependentTemplateTemplateArgumentTester<HasApply, int> DTTACheck; // expected-note{{in instantiation of template class}} + +namespace PR9388 { + namespace std { + template<typename T> class vector { + }; + } + template<typename T> static void foo(std::vector<T*> &V) { + __PRETTY_FUNCTION__; // expected-warning{{expression result unused}} + } + void bar(std::vector<int*> &Blocks) { + foo(Blocks); // expected-note{{in instantiation of}} + } + +} diff --git a/test/SemaCXX/nullptr.cpp b/test/SemaCXX/nullptr.cpp index 01f3d93..84c80aa 100644 --- a/test/SemaCXX/nullptr.cpp +++ b/test/SemaCXX/nullptr.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify -std=c++0x -ffreestanding %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++0x -ffreestanding %s #include <stdint.h> typedef decltype(nullptr) nullptr_t; diff --git a/test/SemaCXX/operator-arrow-temporary.cpp b/test/SemaCXX/operator-arrow-temporary.cpp new file mode 100644 index 0000000..8e79609 --- /dev/null +++ b/test/SemaCXX/operator-arrow-temporary.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR9615 + +struct Resource { + void doit(); +}; + +template<int x> struct Lock { + ~Lock() { int a[x]; } // expected-error {{declared as an array with a negative size}} + Resource* operator->() { return 0; } +}; + +struct Accessor { + Lock<-1> operator->(); +}; + +// Make sure we try to instantiate the destructor for Lock here +void f() { Accessor acc; acc->doit(); } // expected-note {{requested here}} + diff --git a/test/SemaCXX/overloaded-name.cpp b/test/SemaCXX/overloaded-name.cpp index 289d5c9..5a87cc8 100644 --- a/test/SemaCXX/overloaded-name.cpp +++ b/test/SemaCXX/overloaded-name.cpp @@ -1,14 +1,14 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s -int ovl(int); -float ovl(float); +int ovl(int); // expected-note 3{{candidate function}} +float ovl(float); // expected-note 3{{candidate function}} -template<typename T> T ovl(T); +template<typename T> T ovl(T); // expected-note 3{{candidate function}} void test(bool b) { - (void)((void)0, ovl); // expected-error{{cannot resolve overloaded function from context}} + (void)((void)0, ovl); // expected-error{{cannot resolve overloaded function 'ovl' from context}} // PR7863 - (void)(b? ovl : &ovl); // expected-error{{cannot resolve overloaded function from context}} - (void)(b? ovl<float> : &ovl); // expected-error{{cannot resolve overloaded function from context}} + (void)(b? ovl : &ovl); // expected-error{{cannot resolve overloaded function 'ovl' from context}} + (void)(b? ovl<float> : &ovl); // expected-error{{cannot resolve overloaded function 'ovl' from context}} (void)(b? ovl<float> : ovl<float>); } diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp index 4399a02..44d013f 100644 --- a/test/SemaCXX/overloaded-operator.cpp +++ b/test/SemaCXX/overloaded-operator.cpp @@ -384,3 +384,18 @@ void test_lookup_through_using() { N::X2 x; x << 17; } + +namespace rdar9136502 { + struct X { + int i(); + int i(int); + }; + + struct Y { + Y &operator<<(int); // expected-note{{candidate function not viable: no known conversion from '<bound member function type>' to 'int'}} + }; + + void f(X x, Y y) { + y << x.i; // expected-error{{a bound member function may only be called}} + } +} diff --git a/test/SemaCXX/pascal-strings.cpp b/test/SemaCXX/pascal-strings.cpp new file mode 100644 index 0000000..89194b5 --- /dev/null +++ b/test/SemaCXX/pascal-strings.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fpascal-strings +const wchar_t *pascalString = L"\pThis is a Pascal string"; + +unsigned char a[3] = "\pa"; +unsigned char b[3] = "\pab"; +unsigned char c[3] = "\pabc"; // expected-error {{initializer-string for char array is too long}} diff --git a/test/SemaCXX/pseudo-destructors.cpp b/test/SemaCXX/pseudo-destructors.cpp index 30d9faa..d71304e 100644 --- a/test/SemaCXX/pseudo-destructors.cpp +++ b/test/SemaCXX/pseudo-destructors.cpp @@ -2,7 +2,7 @@ struct A {}; enum Foo { F }; -typedef Foo Bar; +typedef Foo Bar; // expected-note{{type 'Bar' (aka 'Foo') is declared here}} typedef int Integer; typedef double Double; @@ -23,10 +23,9 @@ void f(A* a, Foo *f, int *i, double *d) { a->~A(); a->A::~A(); - a->~foo(); // expected-error{{identifier 'foo' in pseudo-destructor expression does not name a type}} + a->~foo(); // expected-error{{identifier 'foo' in object destruction expression does not name a type}} - // FIXME: the diagnostic below isn't wonderful - a->~Bar(); // expected-error{{does not name a type}} + a->~Bar(); // expected-error{{destructor type 'Bar' (aka 'Foo') in object destruction expression does not match the type 'A' of the object being destroyed}} f->~Bar(); f->~Foo(); diff --git a/test/SemaCXX/ptrtomember.cpp b/test/SemaCXX/ptrtomember.cpp index 1038de9..c391733 100644 --- a/test/SemaCXX/ptrtomember.cpp +++ b/test/SemaCXX/ptrtomember.cpp @@ -27,6 +27,7 @@ void f3(S3* p, void (S3::*m)()) { (void)(void*)(p->*m); // expected-error {{a bound member function may only be called}} (void)reinterpret_cast<void*>(p->*m); // expected-error {{a bound member function may only be called}} if (p->*m) {} // expected-error {{a bound member function may only be called}} - - p->m; // expected-error {{a bound member function may only be called}} + if (!(p->*m)) {} // expected-error {{a bound member function may only be called}} + if (p->m) {}; // expected-error {{a bound member function may only be called}} + if (!p->m) {}; // expected-error {{a bound member function may only be called}} } diff --git a/test/SemaCXX/reinterpret-cast.cpp b/test/SemaCXX/reinterpret-cast.cpp index 74dbc01..f526249 100644 --- a/test/SemaCXX/reinterpret-cast.cpp +++ b/test/SemaCXX/reinterpret-cast.cpp @@ -45,9 +45,9 @@ void constness() // Valid: T1* -> T2 const* int const *icp = reinterpret_cast<int const*>(ipppc); // Invalid: T1 const* -> T2* - (void)reinterpret_cast<int*>(icp); // expected-error {{reinterpret_cast from 'const int *' to 'int *' casts away constness}} + (void)reinterpret_cast<int*>(icp); // expected-error {{reinterpret_cast from 'const int *' to 'int *' casts away qualifiers}} // Invalid: T1*** -> T2 const* const** - int const *const **icpcpp = reinterpret_cast<int const* const**>(ipppc); // expected-error {{reinterpret_cast from 'int ***' to 'const int *const **' casts away constness}} + int const *const **icpcpp = reinterpret_cast<int const* const**>(ipppc); // expected-error {{reinterpret_cast from 'int ***' to 'const int *const **' casts away qualifiers}} // Valid: T1* -> T2* int *ip = reinterpret_cast<int*>(icpcpp); // Valid: T* -> T const* @@ -77,7 +77,7 @@ void memptrs() { const int structure::*psi = 0; (void)reinterpret_cast<const float structure::*>(psi); - (void)reinterpret_cast<int structure::*>(psi); // expected-error {{reinterpret_cast from 'const int structure::*' to 'int structure::*' casts away constness}} + (void)reinterpret_cast<int structure::*>(psi); // expected-error {{reinterpret_cast from 'const int structure::*' to 'int structure::*' casts away qualifiers}} void (structure::*psf)() = 0; (void)reinterpret_cast<int (structure::*)()>(psf); @@ -105,6 +105,14 @@ void const_arrays() { const STRING *s; const char *c; - (void)reinterpret_cast<char *>(s); // expected-error {{reinterpret_cast from 'const STRING *' (aka 'char const (*)[10]') to 'char *' casts away constness}} + (void)reinterpret_cast<char *>(s); // expected-error {{reinterpret_cast from 'const STRING *' (aka 'char const (*)[10]') to 'char *' casts away qualifiers}} (void)reinterpret_cast<const STRING *>(c); } + +namespace PR9564 { + struct a { int a : 10; }; a x; + int *y = &reinterpret_cast<int&>(x.a); // expected-error {{not allowed}} + + __attribute((ext_vector_type(4))) typedef float v4; + float& w(v4 &a) { return reinterpret_cast<float&>(a[1]); } // expected-error {{not allowed}} +} diff --git a/test/SemaCXX/return-noreturn.cpp b/test/SemaCXX/return-noreturn.cpp index 7e0a69c..53ed0d7 100644 --- a/test/SemaCXX/return-noreturn.cpp +++ b/test/SemaCXX/return-noreturn.cpp @@ -1,18 +1,69 @@ // RUN: %clang_cc1 %s -fsyntax-only -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -// XFAIL: * // A destructor may be marked noreturn and should still influence the CFG. -namespace PR6884 { - struct abort_struct { - abort_struct() {} // Make this non-POD so the destructor is invoked. - ~abort_struct() __attribute__((noreturn)); - }; - - int f() { - abort_struct(); +void pr6884_abort() __attribute__((noreturn)); + +struct pr6884_abort_struct { + pr6884_abort_struct() {} + ~pr6884_abort_struct() __attribute__((noreturn)) { pr6884_abort(); } +}; + +int pr6884_f(int x) { + switch (x) { default: pr6884_abort(); } +} + +int pr6884_g(int x) { + switch (x) { default: pr6884_abort_struct(); } +} + +int pr6884_g_positive(int x) { + switch (x) { default: ; } +} // expected-warning {{control reaches end of non-void function}} + +int pr6884_h(int x) { + switch (x) { + default: { + pr6884_abort_struct a; + } } +} - int f2() { - abort_struct s; +// PR9380 +struct PR9380 { + ~PR9380(); +}; +struct PR9380_B : public PR9380 { + PR9380_B( const PR9380& str ); +}; +void test_PR9380(const PR9380& aKey) { + const PR9380& flatKey = PR9380_B(aKey); +} + +// Array of objects with destructors. This is purely a coverage test case. +void test_array() { + PR9380 a[2]; +} + +// Test classes wrapped in typedefs. This is purely a coverage test case +// for CFGImplictDtor::getDestructorDecl(). +void test_typedefs() { + typedef PR9380 PR9380_Ty; + PR9380_Ty test; + PR9380_Ty test2[20]; +} + +// PR9412 - Handle CFG traversal with null successors. +enum PR9412_MatchType { PR9412_Exact }; + +template <PR9412_MatchType type> int PR9412_t() { + switch (type) { + case PR9412_Exact: + default: + break; } +} // expected-warning {{control reaches end of non-void function}} + +void PR9412_f() { + PR9412_t<PR9412_Exact>(); // expected-note {{in instantiation of function template specialization 'PR9412_t<0>' requested here}} } + diff --git a/test/SemaCXX/return.cpp b/test/SemaCXX/return.cpp index 46524fc..af7f50c 100644 --- a/test/SemaCXX/return.cpp +++ b/test/SemaCXX/return.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fexceptions -fsyntax-only -Wignored-qualifiers -verify +// RUN: %clang_cc1 %s -fcxx-exceptions -fexceptions -fsyntax-only -Wignored-qualifiers -verify int test1() { throw; @@ -41,3 +41,15 @@ char* volatile i(); // expected-warning{{'volatile' type qualifier on return typ const volatile int scalar_cv(); // expected-warning{{'const volatile' type qualifiers on return type have no effect}} } + +namespace PR9328 { + typedef char *PCHAR; + class Test + { + const PCHAR GetName() { return 0; } // expected-warning{{'const' type qualifier on return type has no effect}} + }; +} + +class foo { + operator int * const (); +}; diff --git a/test/SemaCXX/rval-references.cpp b/test/SemaCXX/rval-references.cpp index 11187cb..74afdbe 100644 --- a/test/SemaCXX/rval-references.cpp +++ b/test/SemaCXX/rval-references.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify -std=c++0x %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++0x %s typedef int&& irr; typedef irr& ilr_c1; // Collapses to int& diff --git a/test/SemaCXX/scope-check.cpp b/test/SemaCXX/scope-check.cpp index d462af0..3a90cc0 100644 --- a/test/SemaCXX/scope-check.cpp +++ b/test/SemaCXX/scope-check.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-unreachable-code +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=gnu++0x %s -Wno-unreachable-code namespace test0 { struct D { ~D(); }; @@ -151,3 +152,22 @@ namespace test8 { l2: x++; } } + +namespace test9 { + struct S { int i; }; + void test1() { + goto foo; + S s; + foo: + return; + } + unsigned test2(unsigned x, unsigned y) { + switch (x) { + case 2: + S s; + if (y > 42) return x + y; + default: + return x - 2; + } + } +} diff --git a/test/SemaCXX/short-enums.cpp b/test/SemaCXX/short-enums.cpp new file mode 100644 index 0000000..ca713b7 --- /dev/null +++ b/test/SemaCXX/short-enums.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fshort-enums -fsyntax-only %s + +// This shouldn't crash: PR9474 + +enum E { VALUE_1 }; + +template <typename T> +struct A {}; + +template <E Enum> +struct B : A<B<Enum> > {}; + +void bar(int x) { + switch (x) { + case sizeof(B<VALUE_1>): ; + } +}
\ No newline at end of file diff --git a/test/SemaCXX/short-wchar-sign.cpp b/test/SemaCXX/short-wchar-sign.cpp new file mode 100644 index 0000000..9a177c0 --- /dev/null +++ b/test/SemaCXX/short-wchar-sign.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -triple i386-mingw32 -fsyntax-only -pedantic -verify %s +// RUN: %clang_cc1 -fshort-wchar -fsyntax-only -pedantic -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -pedantic -verify %s + +// Check that short wchar_t is unsigned, and that regular wchar_t is not. +int test[(wchar_t(-1)<wchar_t(0)) == (sizeof(wchar_t) == 4) ?1:-1]; diff --git a/test/SemaCXX/sourceranges.cpp b/test/SemaCXX/sourceranges.cpp index 602d76b..0537aa2 100644 --- a/test/SemaCXX/sourceranges.cpp +++ b/test/SemaCXX/sourceranges.cpp @@ -13,15 +13,15 @@ typedef int C; } int main() { - // CHECK: CXXNewExpr {{0x[0-9a-fA-F]+}} <col:19, col:28> 'foo::class A *' + // CHECK: CXXNewExpr {{0x[0-9a-fA-F]+}} <col:19, col:28> 'foo::A *' P<foo::A> p14 = new foo::A; - // CHECK: CXXNewExpr {{0x[0-9a-fA-F]+}} <col:19, col:28> 'foo::enum B *' + // CHECK: CXXNewExpr {{0x[0-9a-fA-F]+}} <col:19, col:28> 'foo::B *' P<foo::B> p24 = new foo::B; // CHECK: CXXNewExpr {{0x[0-9a-fA-F]+}} <col:19, col:28> 'foo::C *' P<foo::C> pr4 = new foo::C; } foo::A getName() { - // CHECK: CXXConstructExpr {{0x[0-9a-fA-F]+}} <col:10, col:17> 'foo::class A' + // CHECK: CXXConstructExpr {{0x[0-9a-fA-F]+}} <col:10, col:17> 'foo::A' return foo::A(); } diff --git a/test/SemaCXX/static-cast.cpp b/test/SemaCXX/static-cast.cpp index 46c6eee..7fb016e 100644 --- a/test/SemaCXX/static-cast.cpp +++ b/test/SemaCXX/static-cast.cpp @@ -84,8 +84,8 @@ void t_529_5_8() (void)static_cast<C1&>(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1 &' via virtual base 'B'}} (void)static_cast<D*>((A*)0); // expected-error {{cannot cast 'A *' to 'D *' via virtual base 'B'}} (void)static_cast<D&>(*((A*)0)); // expected-error {{cannot cast 'A' to 'D &' via virtual base 'B'}} - (void)static_cast<B*>((const A*)0); // expected-error {{static_cast from 'const A *' to 'B *' casts away constness}} - (void)static_cast<B&>(*((const A*)0)); // expected-error {{static_cast from 'const A' to 'B &' casts away constness}} + (void)static_cast<B*>((const A*)0); // expected-error {{static_cast from 'const A *' to 'B *' casts away qualifiers}} + (void)static_cast<B&>(*((const A*)0)); // expected-error {{static_cast from 'const A' to 'B &' casts away qualifiers}} (void)static_cast<E*>((A*)0); // expected-error {{cannot cast private base class 'A' to 'E'}} (void)static_cast<E&>(*((A*)0)); // expected-error {{cannot cast private base class 'A' to 'E'}} (void)static_cast<H*>((A*)0); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}} @@ -119,7 +119,7 @@ void t_529_10() // Bad code below - (void)static_cast<int*>((const void*)0); // expected-error {{static_cast from 'const void *' to 'int *' casts away constness}} + (void)static_cast<int*>((const void*)0); // expected-error {{static_cast from 'const void *' to 'int *' casts away qualifiers}} (void)static_cast<void (*)()>((void*)0); // expected-error {{static_cast from 'void *' to 'void (*)()' is not allowed}} } diff --git a/test/SemaCXX/storage-class.cpp b/test/SemaCXX/storage-class.cpp index a2e2063..01cfbfc 100644 --- a/test/SemaCXX/storage-class.cpp +++ b/test/SemaCXX/storage-class.cpp @@ -2,3 +2,6 @@ extern const int PR6495a = 42; extern int PR6495b = 42; // expected-warning{{'extern' variable has an initializer}} extern const int PR6495c[] = {42,43,44}; + +extern struct Test1 {}; // expected-warning {{'extern' ignored on this declaration}} +extern "C" struct Test0 {}; // no warning diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp index ff9a6bf..96e9696 100644 --- a/test/SemaCXX/type-traits.cpp +++ b/test/SemaCXX/type-traits.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s #define T(b) (b) ? 1 : -1 #define F(b) (b) ? -1 : 1 @@ -27,22 +27,37 @@ struct HasAnonymousUnion { }; }; +typedef int Vector __attribute__((vector_size(16))); +typedef int VectorExt __attribute__((ext_vector_type(4))); + // Not PODs typedef const void cvoid; struct Derives : POD {}; +typedef Derives DerivesAr[10]; +typedef Derives DerivesArNB[]; struct DerivesEmpty : Empty {}; struct HasCons { HasCons(int); }; struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); }; +struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); }; // \ + // expected-warning {{rvalue references}} struct HasDest { ~HasDest(); }; class HasPriv { int priv; }; class HasProt { protected: int prot; }; struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} }; struct HasNonPOD { NonPOD np; }; struct HasVirt { virtual void Virt() {}; }; -typedef Derives NonPODAr[10]; +typedef NonPOD NonPODAr[10]; typedef HasVirt VirtAr[10]; -typedef HasCons NonPODArNB[]; +typedef NonPOD NonPODArNB[]; union NonPODUnion { int i; Derives n; }; +struct DerivesHasCons : HasCons {}; +struct DerivesHasCopyAssign : HasCopyAssign {}; +struct DerivesHasMoveAssign : HasMoveAssign {}; +struct DerivesHasDest : HasDest {}; +struct DerivesHasPriv : HasPriv {}; +struct DerivesHasProt : HasProt {}; +struct DerivesHasRef : HasRef {}; +struct DerivesHasVirt : HasVirt {}; struct HasNoThrowCopyAssign { void operator =(const HasNoThrowCopyAssign&) throw(); @@ -77,37 +92,51 @@ typedef HasVirtDest VirtDestAr[1]; void is_pod() { - int t01[T(__is_pod(int))]; - int t02[T(__is_pod(Enum))]; - int t03[T(__is_pod(POD))]; - int t04[T(__is_pod(Int))]; - int t05[T(__is_pod(IntAr))]; - int t06[T(__is_pod(Statics))]; - int t07[T(__is_pod(Empty))]; - int t08[T(__is_pod(EmptyUnion))]; - int t09[T(__is_pod(Union))]; - int t10[T(__is_pod(HasFunc))]; - int t11[T(__is_pod(HasOp))]; - int t12[T(__is_pod(HasConv))]; - int t13[T(__is_pod(HasAssign))]; - int t14[T(__is_pod(IntArNB))]; - int t15[T(__is_pod(HasAnonymousUnion))]; - - int t21[F(__is_pod(Derives))]; - int t22[F(__is_pod(HasCons))]; - int t23[F(__is_pod(HasCopyAssign))]; - int t24[F(__is_pod(HasDest))]; - int t25[F(__is_pod(HasPriv))]; - int t26[F(__is_pod(HasProt))]; - int t27[F(__is_pod(HasRef))]; - int t28[F(__is_pod(HasNonPOD))]; - int t29[F(__is_pod(HasVirt))]; - int t30[F(__is_pod(NonPODAr))]; - int t31[F(__is_pod(DerivesEmpty))]; - int t32[F(__is_pod(void))]; - int t33[F(__is_pod(cvoid))]; - int t34[F(__is_pod(NonPODArNB))]; - // int t32[F(__is_pod(NonPODUnion))]; + { int arr[T(__is_pod(int))]; } + { int arr[T(__is_pod(Enum))]; } + { int arr[T(__is_pod(POD))]; } + { int arr[T(__is_pod(Int))]; } + { int arr[T(__is_pod(IntAr))]; } + { int arr[T(__is_pod(Statics))]; } + { int arr[T(__is_pod(Empty))]; } + { int arr[T(__is_pod(EmptyUnion))]; } + { int arr[T(__is_pod(Union))]; } + { int arr[T(__is_pod(HasFunc))]; } + { int arr[T(__is_pod(HasOp))]; } + { int arr[T(__is_pod(HasConv))]; } + { int arr[T(__is_pod(HasAssign))]; } + { int arr[T(__is_pod(IntArNB))]; } + { int arr[T(__is_pod(HasAnonymousUnion))]; } + { int arr[T(__is_pod(Vector))]; } + { int arr[T(__is_pod(VectorExt))]; } + + { int arr[F(__is_pod(Derives))]; } + { int arr[F(__is_pod(DerivesAr))]; } + { int arr[F(__is_pod(DerivesArNB))]; } + { int arr[F(__is_pod(DerivesEmpty))]; } + { int arr[F(__is_pod(HasCons))]; } + { int arr[F(__is_pod(HasCopyAssign))]; } + { int arr[F(__is_pod(HasMoveAssign))]; } + { int arr[F(__is_pod(HasDest))]; } + { int arr[F(__is_pod(HasPriv))]; } + { int arr[F(__is_pod(HasProt))]; } + { int arr[F(__is_pod(HasRef))]; } + { int arr[F(__is_pod(HasVirt))]; } + { int arr[F(__is_pod(DerivesHasCons))]; } + { int arr[F(__is_pod(DerivesHasCopyAssign))]; } + { int arr[F(__is_pod(DerivesHasMoveAssign))]; } + { int arr[F(__is_pod(DerivesHasDest))]; } + { int arr[F(__is_pod(DerivesHasPriv))]; } + { int arr[F(__is_pod(DerivesHasProt))]; } + { int arr[F(__is_pod(DerivesHasRef))]; } + { int arr[F(__is_pod(DerivesHasVirt))]; } + { int arr[F(__is_pod(NonPOD))]; } + { int arr[F(__is_pod(HasNonPOD))]; } + { int arr[F(__is_pod(NonPODAr))]; } + { int arr[F(__is_pod(NonPODArNB))]; } + { int arr[F(__is_pod(void))]; } + { int arr[F(__is_pod(cvoid))]; } +// { int arr[F(__is_pod(NonPODUnion))]; } } typedef Empty EmptyAr[10]; @@ -118,48 +147,49 @@ struct BitOnly { int x : 3; }; void is_empty() { - int t01[T(__is_empty(Empty))]; - int t02[T(__is_empty(DerivesEmpty))]; - int t03[T(__is_empty(HasCons))]; - int t04[T(__is_empty(HasCopyAssign))]; - int t05[T(__is_empty(HasDest))]; - int t06[T(__is_empty(HasFunc))]; - int t07[T(__is_empty(HasOp))]; - int t08[T(__is_empty(HasConv))]; - int t09[T(__is_empty(HasAssign))]; - int t10[T(__is_empty(Bit0))]; - int t11[T(__is_empty(Bit0Cons))]; - - int t21[F(__is_empty(Int))]; - int t22[F(__is_empty(POD))]; - int t23[F(__is_empty(EmptyUnion))]; - int t24[F(__is_empty(EmptyAr))]; - int t25[F(__is_empty(HasRef))]; - int t26[F(__is_empty(HasVirt))]; - int t27[F(__is_empty(BitOnly))]; - int t28[F(__is_empty(void))]; - int t29[F(__is_empty(IntArNB))]; - int t30[F(__is_empty(HasAnonymousUnion))]; -// int t27[F(__is_empty(DerivesVirt))]; + { int arr[T(__is_empty(Empty))]; } + { int arr[T(__is_empty(DerivesEmpty))]; } + { int arr[T(__is_empty(HasCons))]; } + { int arr[T(__is_empty(HasCopyAssign))]; } + { int arr[T(__is_empty(HasMoveAssign))]; } + { int arr[T(__is_empty(HasDest))]; } + { int arr[T(__is_empty(HasFunc))]; } + { int arr[T(__is_empty(HasOp))]; } + { int arr[T(__is_empty(HasConv))]; } + { int arr[T(__is_empty(HasAssign))]; } + { int arr[T(__is_empty(Bit0))]; } + { int arr[T(__is_empty(Bit0Cons))]; } + + { int arr[F(__is_empty(Int))]; } + { int arr[F(__is_empty(POD))]; } + { int arr[F(__is_empty(EmptyUnion))]; } + { int arr[F(__is_empty(EmptyAr))]; } + { int arr[F(__is_empty(HasRef))]; } + { int arr[F(__is_empty(HasVirt))]; } + { int arr[F(__is_empty(BitOnly))]; } + { int arr[F(__is_empty(void))]; } + { int arr[F(__is_empty(IntArNB))]; } + { int arr[F(__is_empty(HasAnonymousUnion))]; } +// { int arr[F(__is_empty(DerivesVirt))]; } } typedef Derives ClassType; void is_class() { - int t01[T(__is_class(Derives))]; - int t02[T(__is_class(HasPriv))]; - int t03[T(__is_class(ClassType))]; - int t04[T(__is_class(HasAnonymousUnion))]; + { int arr[T(__is_class(Derives))]; } + { int arr[T(__is_class(HasPriv))]; } + { int arr[T(__is_class(ClassType))]; } + { int arr[T(__is_class(HasAnonymousUnion))]; } - int t11[F(__is_class(int))]; - int t12[F(__is_class(Enum))]; - int t13[F(__is_class(Int))]; - int t14[F(__is_class(IntAr))]; - int t15[F(__is_class(NonPODAr))]; - int t16[F(__is_class(Union))]; - int t17[F(__is_class(cvoid))]; - int t18[F(__is_class(IntArNB))]; + { int arr[F(__is_class(int))]; } + { int arr[F(__is_class(Enum))]; } + { int arr[F(__is_class(Int))]; } + { int arr[F(__is_class(IntAr))]; } + { int arr[F(__is_class(DerivesAr))]; } + { int arr[F(__is_class(Union))]; } + { int arr[F(__is_class(cvoid))]; } + { int arr[F(__is_class(IntArNB))]; } } typedef Union UnionAr[10]; @@ -167,36 +197,36 @@ typedef Union UnionType; void is_union() { - int t01[T(__is_union(Union))]; - int t02[T(__is_union(UnionType))]; + { int arr[T(__is_union(Union))]; } + { int arr[T(__is_union(UnionType))]; } - int t11[F(__is_union(int))]; - int t12[F(__is_union(Enum))]; - int t13[F(__is_union(Int))]; - int t14[F(__is_union(IntAr))]; - int t15[F(__is_union(UnionAr))]; - int t16[F(__is_union(cvoid))]; - int t17[F(__is_union(IntArNB))]; - int t18[F(__is_union(HasAnonymousUnion))]; + { int arr[F(__is_union(int))]; } + { int arr[F(__is_union(Enum))]; } + { int arr[F(__is_union(Int))]; } + { int arr[F(__is_union(IntAr))]; } + { int arr[F(__is_union(UnionAr))]; } + { int arr[F(__is_union(cvoid))]; } + { int arr[F(__is_union(IntArNB))]; } + { int arr[F(__is_union(HasAnonymousUnion))]; } } typedef Enum EnumType; void is_enum() { - int t01[T(__is_enum(Enum))]; - int t02[T(__is_enum(EnumType))]; + { int arr[T(__is_enum(Enum))]; } + { int arr[T(__is_enum(EnumType))]; } - int t11[F(__is_enum(int))]; - int t12[F(__is_enum(Union))]; - int t13[F(__is_enum(Int))]; - int t14[F(__is_enum(IntAr))]; - int t15[F(__is_enum(UnionAr))]; - int t16[F(__is_enum(Derives))]; - int t17[F(__is_enum(ClassType))]; - int t18[F(__is_enum(cvoid))]; - int t19[F(__is_enum(IntArNB))]; - int t20[F(__is_enum(HasAnonymousUnion))]; + { int arr[F(__is_enum(int))]; } + { int arr[F(__is_enum(Union))]; } + { int arr[F(__is_enum(Int))]; } + { int arr[F(__is_enum(IntAr))]; } + { int arr[F(__is_enum(UnionAr))]; } + { int arr[F(__is_enum(Derives))]; } + { int arr[F(__is_enum(ClassType))]; } + { int arr[F(__is_enum(cvoid))]; } + { int arr[F(__is_enum(IntArNB))]; } + { int arr[F(__is_enum(HasAnonymousUnion))]; } } typedef HasVirt Polymorph; @@ -204,19 +234,788 @@ struct InheritPolymorph : Polymorph {}; void is_polymorphic() { - int t01[T(__is_polymorphic(Polymorph))]; - int t02[T(__is_polymorphic(InheritPolymorph))]; + { int arr[T(__is_polymorphic(Polymorph))]; } + { int arr[T(__is_polymorphic(InheritPolymorph))]; } + + { int arr[F(__is_polymorphic(int))]; } + { int arr[F(__is_polymorphic(Union))]; } + { int arr[F(__is_polymorphic(Int))]; } + { int arr[F(__is_polymorphic(IntAr))]; } + { int arr[F(__is_polymorphic(UnionAr))]; } + { int arr[F(__is_polymorphic(Derives))]; } + { int arr[F(__is_polymorphic(ClassType))]; } + { int arr[F(__is_polymorphic(Enum))]; } + { int arr[F(__is_polymorphic(cvoid))]; } + { int arr[F(__is_polymorphic(IntArNB))]; } +} + +void is_integral() +{ + int t01[T(__is_integral(bool))]; + int t02[T(__is_integral(char))]; + int t03[T(__is_integral(signed char))]; + int t04[T(__is_integral(unsigned char))]; + //int t05[T(__is_integral(char16_t))]; + //int t06[T(__is_integral(char32_t))]; + int t07[T(__is_integral(wchar_t))]; + int t08[T(__is_integral(short))]; + int t09[T(__is_integral(unsigned short))]; + int t10[T(__is_integral(int))]; + int t11[T(__is_integral(unsigned int))]; + int t12[T(__is_integral(long))]; + int t13[T(__is_integral(unsigned long))]; + + int t21[F(__is_integral(float))]; + int t22[F(__is_integral(double))]; + int t23[F(__is_integral(long double))]; + int t24[F(__is_integral(Union))]; + int t25[F(__is_integral(UnionAr))]; + int t26[F(__is_integral(Derives))]; + int t27[F(__is_integral(ClassType))]; + int t28[F(__is_integral(Enum))]; + int t29[F(__is_integral(void))]; + int t30[F(__is_integral(cvoid))]; + int t31[F(__is_integral(IntArNB))]; +} + +void is_floating_point() +{ + int t01[T(__is_floating_point(float))]; + int t02[T(__is_floating_point(double))]; + int t03[T(__is_floating_point(long double))]; + + int t11[F(__is_floating_point(bool))]; + int t12[F(__is_floating_point(char))]; + int t13[F(__is_floating_point(signed char))]; + int t14[F(__is_floating_point(unsigned char))]; + //int t15[F(__is_floating_point(char16_t))]; + //int t16[F(__is_floating_point(char32_t))]; + int t17[F(__is_floating_point(wchar_t))]; + int t18[F(__is_floating_point(short))]; + int t19[F(__is_floating_point(unsigned short))]; + int t20[F(__is_floating_point(int))]; + int t21[F(__is_floating_point(unsigned int))]; + int t22[F(__is_floating_point(long))]; + int t23[F(__is_floating_point(unsigned long))]; + int t24[F(__is_floating_point(Union))]; + int t25[F(__is_floating_point(UnionAr))]; + int t26[F(__is_floating_point(Derives))]; + int t27[F(__is_floating_point(ClassType))]; + int t28[F(__is_floating_point(Enum))]; + int t29[F(__is_floating_point(void))]; + int t30[F(__is_floating_point(cvoid))]; + int t31[F(__is_floating_point(IntArNB))]; +} + +void is_arithmetic() +{ + int t01[T(__is_arithmetic(float))]; + int t02[T(__is_arithmetic(double))]; + int t03[T(__is_arithmetic(long double))]; + int t11[T(__is_arithmetic(bool))]; + int t12[T(__is_arithmetic(char))]; + int t13[T(__is_arithmetic(signed char))]; + int t14[T(__is_arithmetic(unsigned char))]; + //int t15[T(__is_arithmetic(char16_t))]; + //int t16[T(__is_arithmetic(char32_t))]; + int t17[T(__is_arithmetic(wchar_t))]; + int t18[T(__is_arithmetic(short))]; + int t19[T(__is_arithmetic(unsigned short))]; + int t20[T(__is_arithmetic(int))]; + int t21[T(__is_arithmetic(unsigned int))]; + int t22[T(__is_arithmetic(long))]; + int t23[T(__is_arithmetic(unsigned long))]; + + int t24[F(__is_arithmetic(Union))]; + int t25[F(__is_arithmetic(UnionAr))]; + int t26[F(__is_arithmetic(Derives))]; + int t27[F(__is_arithmetic(ClassType))]; + int t28[F(__is_arithmetic(Enum))]; + int t29[F(__is_arithmetic(void))]; + int t30[F(__is_arithmetic(cvoid))]; + int t31[F(__is_arithmetic(IntArNB))]; +} + +struct ACompleteType {}; +struct AnIncompleteType; + +void is_complete_type() +{ + int t01[T(__is_complete_type(float))]; + int t02[T(__is_complete_type(double))]; + int t03[T(__is_complete_type(long double))]; + int t11[T(__is_complete_type(bool))]; + int t12[T(__is_complete_type(char))]; + int t13[T(__is_complete_type(signed char))]; + int t14[T(__is_complete_type(unsigned char))]; + //int t15[T(__is_complete_type(char16_t))]; + //int t16[T(__is_complete_type(char32_t))]; + int t17[T(__is_complete_type(wchar_t))]; + int t18[T(__is_complete_type(short))]; + int t19[T(__is_complete_type(unsigned short))]; + int t20[T(__is_complete_type(int))]; + int t21[T(__is_complete_type(unsigned int))]; + int t22[T(__is_complete_type(long))]; + int t23[T(__is_complete_type(unsigned long))]; + int t24[T(__is_complete_type(ACompleteType))]; + + int t30[F(__is_complete_type(AnIncompleteType))]; +} + +void is_void() +{ + int t01[T(__is_void(void))]; + int t02[T(__is_void(cvoid))]; + + int t10[F(__is_void(float))]; + int t11[F(__is_void(double))]; + int t12[F(__is_void(long double))]; + int t13[F(__is_void(bool))]; + int t14[F(__is_void(char))]; + int t15[F(__is_void(signed char))]; + int t16[F(__is_void(unsigned char))]; + int t17[F(__is_void(wchar_t))]; + int t18[F(__is_void(short))]; + int t19[F(__is_void(unsigned short))]; + int t20[F(__is_void(int))]; + int t21[F(__is_void(unsigned int))]; + int t22[F(__is_void(long))]; + int t23[F(__is_void(unsigned long))]; + int t24[F(__is_void(Union))]; + int t25[F(__is_void(UnionAr))]; + int t26[F(__is_void(Derives))]; + int t27[F(__is_void(ClassType))]; + int t28[F(__is_void(Enum))]; + int t29[F(__is_void(IntArNB))]; + int t30[F(__is_void(void*))]; + int t31[F(__is_void(cvoid*))]; +} + +void is_array() +{ + int t01[T(__is_array(IntAr))]; + int t02[T(__is_array(IntArNB))]; + int t03[T(__is_array(UnionAr))]; + + int t10[F(__is_array(void))]; + int t11[F(__is_array(cvoid))]; + int t12[F(__is_array(float))]; + int t13[F(__is_array(double))]; + int t14[F(__is_array(long double))]; + int t15[F(__is_array(bool))]; + int t16[F(__is_array(char))]; + int t17[F(__is_array(signed char))]; + int t18[F(__is_array(unsigned char))]; + int t19[F(__is_array(wchar_t))]; + int t20[F(__is_array(short))]; + int t21[F(__is_array(unsigned short))]; + int t22[F(__is_array(int))]; + int t23[F(__is_array(unsigned int))]; + int t24[F(__is_array(long))]; + int t25[F(__is_array(unsigned long))]; + int t26[F(__is_array(Union))]; + int t27[F(__is_array(Derives))]; + int t28[F(__is_array(ClassType))]; + int t29[F(__is_array(Enum))]; + int t30[F(__is_array(void*))]; + int t31[F(__is_array(cvoid*))]; +} + +template <typename T> void tmpl_func(T&) {} + +template <typename T> struct type_wrapper { + typedef T type; + typedef T* ptrtype; + typedef T& reftype; +}; + +void is_function() +{ + int t01[T(__is_function(type_wrapper<void(void)>::type))]; + int t02[T(__is_function(typeof(tmpl_func<int>)))]; + + typedef void (*ptr_to_func_type)(void); + + int t10[F(__is_function(void))]; + int t11[F(__is_function(cvoid))]; + int t12[F(__is_function(float))]; + int t13[F(__is_function(double))]; + int t14[F(__is_function(long double))]; + int t15[F(__is_function(bool))]; + int t16[F(__is_function(char))]; + int t17[F(__is_function(signed char))]; + int t18[F(__is_function(unsigned char))]; + int t19[F(__is_function(wchar_t))]; + int t20[F(__is_function(short))]; + int t21[F(__is_function(unsigned short))]; + int t22[F(__is_function(int))]; + int t23[F(__is_function(unsigned int))]; + int t24[F(__is_function(long))]; + int t25[F(__is_function(unsigned long))]; + int t26[F(__is_function(Union))]; + int t27[F(__is_function(Derives))]; + int t28[F(__is_function(ClassType))]; + int t29[F(__is_function(Enum))]; + int t30[F(__is_function(void*))]; + int t31[F(__is_function(cvoid*))]; + int t32[F(__is_function(void(*)()))]; + int t33[F(__is_function(ptr_to_func_type))]; + int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))]; + int t35[F(__is_function(type_wrapper<void(void)>::reftype))]; +} + +void is_reference() +{ + int t01[T(__is_reference(int&))]; + int t02[T(__is_reference(const int&))]; + int t03[T(__is_reference(void *&))]; + + int t10[F(__is_reference(int))]; + int t11[F(__is_reference(const int))]; + int t12[F(__is_reference(void *))]; +} + +void is_lvalue_reference() +{ + int t01[T(__is_lvalue_reference(int&))]; + int t02[T(__is_lvalue_reference(void *&))]; + int t03[T(__is_lvalue_reference(const int&))]; + int t04[T(__is_lvalue_reference(void * const &))]; + + int t10[F(__is_lvalue_reference(int))]; + int t11[F(__is_lvalue_reference(const int))]; + int t12[F(__is_lvalue_reference(void *))]; +} + +#if __has_feature(cxx_rvalue_references) + +void is_rvalue_reference() +{ + int t01[T(__is_rvalue_reference(const int&&))]; + int t02[T(__is_rvalue_reference(void * const &&))]; + + int t10[F(__is_rvalue_reference(int&))]; + int t11[F(__is_rvalue_reference(void *&))]; + int t12[F(__is_rvalue_reference(const int&))]; + int t13[F(__is_rvalue_reference(void * const &))]; + int t14[F(__is_rvalue_reference(int))]; + int t15[F(__is_rvalue_reference(const int))]; + int t16[F(__is_rvalue_reference(void *))]; +} + +#endif + +void is_fundamental() +{ + int t01[T(__is_fundamental(float))]; + int t02[T(__is_fundamental(double))]; + int t03[T(__is_fundamental(long double))]; + int t11[T(__is_fundamental(bool))]; + int t12[T(__is_fundamental(char))]; + int t13[T(__is_fundamental(signed char))]; + int t14[T(__is_fundamental(unsigned char))]; + //int t15[T(__is_fundamental(char16_t))]; + //int t16[T(__is_fundamental(char32_t))]; + int t17[T(__is_fundamental(wchar_t))]; + int t18[T(__is_fundamental(short))]; + int t19[T(__is_fundamental(unsigned short))]; + int t20[T(__is_fundamental(int))]; + int t21[T(__is_fundamental(unsigned int))]; + int t22[T(__is_fundamental(long))]; + int t23[T(__is_fundamental(unsigned long))]; + int t24[T(__is_fundamental(void))]; + int t25[T(__is_fundamental(cvoid))]; + + int t30[F(__is_fundamental(Union))]; + int t31[F(__is_fundamental(UnionAr))]; + int t32[F(__is_fundamental(Derives))]; + int t33[F(__is_fundamental(ClassType))]; + int t34[F(__is_fundamental(Enum))]; + int t35[F(__is_fundamental(IntArNB))]; +} + +void is_object() +{ + int t01[T(__is_object(int))]; + int t02[T(__is_object(int *))]; + int t03[T(__is_object(void *))]; + int t04[T(__is_object(Union))]; + int t05[T(__is_object(UnionAr))]; + int t06[T(__is_object(ClassType))]; + int t07[T(__is_object(Enum))]; + + int t10[F(__is_object(type_wrapper<void(void)>::type))]; + int t11[F(__is_object(int&))]; + int t12[F(__is_object(void))]; +} + +void is_scalar() +{ + int t01[T(__is_scalar(float))]; + int t02[T(__is_scalar(double))]; + int t03[T(__is_scalar(long double))]; + int t04[T(__is_scalar(bool))]; + int t05[T(__is_scalar(char))]; + int t06[T(__is_scalar(signed char))]; + int t07[T(__is_scalar(unsigned char))]; + int t08[T(__is_scalar(wchar_t))]; + int t09[T(__is_scalar(short))]; + int t10[T(__is_scalar(unsigned short))]; + int t11[T(__is_scalar(int))]; + int t12[T(__is_scalar(unsigned int))]; + int t13[T(__is_scalar(long))]; + int t14[T(__is_scalar(unsigned long))]; + int t15[T(__is_scalar(Enum))]; + int t16[T(__is_scalar(void*))]; + int t17[T(__is_scalar(cvoid*))]; + + int t20[F(__is_scalar(void))]; + int t21[F(__is_scalar(cvoid))]; + int t22[F(__is_scalar(Union))]; + int t23[F(__is_scalar(UnionAr))]; + int t24[F(__is_scalar(Derives))]; + int t25[F(__is_scalar(ClassType))]; + int t26[F(__is_scalar(IntArNB))]; +} + +struct StructWithMembers { + int member; + void method() {} +}; + +void is_compound() +{ + int t01[T(__is_compound(void*))]; + int t02[T(__is_compound(cvoid*))]; + int t03[T(__is_compound(void (*)()))]; + int t04[T(__is_compound(int StructWithMembers::*))]; + int t05[T(__is_compound(void (StructWithMembers::*)()))]; + int t06[T(__is_compound(int&))]; + int t07[T(__is_compound(Union))]; + int t08[T(__is_compound(UnionAr))]; + int t09[T(__is_compound(Derives))]; + int t10[T(__is_compound(ClassType))]; + int t11[T(__is_compound(IntArNB))]; + int t12[T(__is_compound(Enum))]; + + int t20[F(__is_compound(float))]; + int t21[F(__is_compound(double))]; + int t22[F(__is_compound(long double))]; + int t23[F(__is_compound(bool))]; + int t24[F(__is_compound(char))]; + int t25[F(__is_compound(signed char))]; + int t26[F(__is_compound(unsigned char))]; + int t27[F(__is_compound(wchar_t))]; + int t28[F(__is_compound(short))]; + int t29[F(__is_compound(unsigned short))]; + int t30[F(__is_compound(int))]; + int t31[F(__is_compound(unsigned int))]; + int t32[F(__is_compound(long))]; + int t33[F(__is_compound(unsigned long))]; + int t34[F(__is_compound(void))]; + int t35[F(__is_compound(cvoid))]; +} + +void is_pointer() +{ + StructWithMembers x; + + int t01[T(__is_pointer(void*))]; + int t02[T(__is_pointer(cvoid*))]; + int t03[T(__is_pointer(cvoid*))]; + int t04[T(__is_pointer(char*))]; + int t05[T(__is_pointer(int*))]; + int t06[T(__is_pointer(int**))]; + int t07[T(__is_pointer(ClassType*))]; + int t08[T(__is_pointer(Derives*))]; + int t09[T(__is_pointer(Enum*))]; + int t10[T(__is_pointer(IntArNB*))]; + int t11[T(__is_pointer(Union*))]; + int t12[T(__is_pointer(UnionAr*))]; + int t13[T(__is_pointer(StructWithMembers*))]; + int t14[T(__is_pointer(void (*)()))]; + + int t20[F(__is_pointer(void))]; + int t21[F(__is_pointer(cvoid))]; + int t22[F(__is_pointer(cvoid))]; + int t23[F(__is_pointer(char))]; + int t24[F(__is_pointer(int))]; + int t25[F(__is_pointer(int))]; + int t26[F(__is_pointer(ClassType))]; + int t27[F(__is_pointer(Derives))]; + int t28[F(__is_pointer(Enum))]; + int t29[F(__is_pointer(IntArNB))]; + int t30[F(__is_pointer(Union))]; + int t31[F(__is_pointer(UnionAr))]; + int t32[F(__is_pointer(StructWithMembers))]; + int t33[F(__is_pointer(int StructWithMembers::*))]; + int t34[F(__is_pointer(void (StructWithMembers::*) ()))]; +} + +void is_member_object_pointer() +{ + StructWithMembers x; + + int t01[T(__is_member_object_pointer(int StructWithMembers::*))]; + + int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))]; + int t11[F(__is_member_object_pointer(void*))]; + int t12[F(__is_member_object_pointer(cvoid*))]; + int t13[F(__is_member_object_pointer(cvoid*))]; + int t14[F(__is_member_object_pointer(char*))]; + int t15[F(__is_member_object_pointer(int*))]; + int t16[F(__is_member_object_pointer(int**))]; + int t17[F(__is_member_object_pointer(ClassType*))]; + int t18[F(__is_member_object_pointer(Derives*))]; + int t19[F(__is_member_object_pointer(Enum*))]; + int t20[F(__is_member_object_pointer(IntArNB*))]; + int t21[F(__is_member_object_pointer(Union*))]; + int t22[F(__is_member_object_pointer(UnionAr*))]; + int t23[F(__is_member_object_pointer(StructWithMembers*))]; + int t24[F(__is_member_object_pointer(void))]; + int t25[F(__is_member_object_pointer(cvoid))]; + int t26[F(__is_member_object_pointer(cvoid))]; + int t27[F(__is_member_object_pointer(char))]; + int t28[F(__is_member_object_pointer(int))]; + int t29[F(__is_member_object_pointer(int))]; + int t30[F(__is_member_object_pointer(ClassType))]; + int t31[F(__is_member_object_pointer(Derives))]; + int t32[F(__is_member_object_pointer(Enum))]; + int t33[F(__is_member_object_pointer(IntArNB))]; + int t34[F(__is_member_object_pointer(Union))]; + int t35[F(__is_member_object_pointer(UnionAr))]; + int t36[F(__is_member_object_pointer(StructWithMembers))]; + int t37[F(__is_member_object_pointer(void (*)()))]; +} + +void is_member_function_pointer() +{ + StructWithMembers x; - int t11[F(__is_polymorphic(int))]; - int t12[F(__is_polymorphic(Union))]; - int t13[F(__is_polymorphic(Int))]; - int t14[F(__is_polymorphic(IntAr))]; - int t15[F(__is_polymorphic(UnionAr))]; - int t16[F(__is_polymorphic(Derives))]; - int t17[F(__is_polymorphic(ClassType))]; - int t18[F(__is_polymorphic(Enum))]; - int t19[F(__is_polymorphic(cvoid))]; - int t20[F(__is_polymorphic(IntArNB))]; + int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))]; + + int t10[F(__is_member_function_pointer(int StructWithMembers::*))]; + int t11[F(__is_member_function_pointer(void*))]; + int t12[F(__is_member_function_pointer(cvoid*))]; + int t13[F(__is_member_function_pointer(cvoid*))]; + int t14[F(__is_member_function_pointer(char*))]; + int t15[F(__is_member_function_pointer(int*))]; + int t16[F(__is_member_function_pointer(int**))]; + int t17[F(__is_member_function_pointer(ClassType*))]; + int t18[F(__is_member_function_pointer(Derives*))]; + int t19[F(__is_member_function_pointer(Enum*))]; + int t20[F(__is_member_function_pointer(IntArNB*))]; + int t21[F(__is_member_function_pointer(Union*))]; + int t22[F(__is_member_function_pointer(UnionAr*))]; + int t23[F(__is_member_function_pointer(StructWithMembers*))]; + int t24[F(__is_member_function_pointer(void))]; + int t25[F(__is_member_function_pointer(cvoid))]; + int t26[F(__is_member_function_pointer(cvoid))]; + int t27[F(__is_member_function_pointer(char))]; + int t28[F(__is_member_function_pointer(int))]; + int t29[F(__is_member_function_pointer(int))]; + int t30[F(__is_member_function_pointer(ClassType))]; + int t31[F(__is_member_function_pointer(Derives))]; + int t32[F(__is_member_function_pointer(Enum))]; + int t33[F(__is_member_function_pointer(IntArNB))]; + int t34[F(__is_member_function_pointer(Union))]; + int t35[F(__is_member_function_pointer(UnionAr))]; + int t36[F(__is_member_function_pointer(StructWithMembers))]; + int t37[F(__is_member_function_pointer(void (*)()))]; +} + +void is_member_pointer() +{ + StructWithMembers x; + + int t01[T(__is_member_pointer(int StructWithMembers::*))]; + int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))]; + + int t10[F(__is_member_pointer(void*))]; + int t11[F(__is_member_pointer(cvoid*))]; + int t12[F(__is_member_pointer(cvoid*))]; + int t13[F(__is_member_pointer(char*))]; + int t14[F(__is_member_pointer(int*))]; + int t15[F(__is_member_pointer(int**))]; + int t16[F(__is_member_pointer(ClassType*))]; + int t17[F(__is_member_pointer(Derives*))]; + int t18[F(__is_member_pointer(Enum*))]; + int t19[F(__is_member_pointer(IntArNB*))]; + int t20[F(__is_member_pointer(Union*))]; + int t21[F(__is_member_pointer(UnionAr*))]; + int t22[F(__is_member_pointer(StructWithMembers*))]; + int t23[F(__is_member_pointer(void))]; + int t24[F(__is_member_pointer(cvoid))]; + int t25[F(__is_member_pointer(cvoid))]; + int t26[F(__is_member_pointer(char))]; + int t27[F(__is_member_pointer(int))]; + int t28[F(__is_member_pointer(int))]; + int t29[F(__is_member_pointer(ClassType))]; + int t30[F(__is_member_pointer(Derives))]; + int t31[F(__is_member_pointer(Enum))]; + int t32[F(__is_member_pointer(IntArNB))]; + int t33[F(__is_member_pointer(Union))]; + int t34[F(__is_member_pointer(UnionAr))]; + int t35[F(__is_member_pointer(StructWithMembers))]; + int t36[F(__is_member_pointer(void (*)()))]; +} + +void is_const() +{ + int t01[T(__is_const(cvoid))]; + int t02[T(__is_const(const char))]; + int t03[T(__is_const(const int))]; + int t04[T(__is_const(const long))]; + int t05[T(__is_const(const short))]; + int t06[T(__is_const(const signed char))]; + int t07[T(__is_const(const wchar_t))]; + int t08[T(__is_const(const bool))]; + int t09[T(__is_const(const float))]; + int t10[T(__is_const(const double))]; + int t11[T(__is_const(const long double))]; + int t12[T(__is_const(const unsigned char))]; + int t13[T(__is_const(const unsigned int))]; + int t14[T(__is_const(const unsigned long long))]; + int t15[T(__is_const(const unsigned long))]; + int t16[T(__is_const(const unsigned short))]; + int t17[T(__is_const(const void))]; + int t18[T(__is_const(const ClassType))]; + int t19[T(__is_const(const Derives))]; + int t20[T(__is_const(const Enum))]; + int t21[T(__is_const(const IntArNB))]; + int t22[T(__is_const(const Union))]; + int t23[T(__is_const(const UnionAr))]; + + int t30[F(__is_const(char))]; + int t31[F(__is_const(int))]; + int t32[F(__is_const(long))]; + int t33[F(__is_const(short))]; + int t34[F(__is_const(signed char))]; + int t35[F(__is_const(wchar_t))]; + int t36[F(__is_const(bool))]; + int t37[F(__is_const(float))]; + int t38[F(__is_const(double))]; + int t39[F(__is_const(long double))]; + int t40[F(__is_const(unsigned char))]; + int t41[F(__is_const(unsigned int))]; + int t42[F(__is_const(unsigned long long))]; + int t43[F(__is_const(unsigned long))]; + int t44[F(__is_const(unsigned short))]; + int t45[F(__is_const(void))]; + int t46[F(__is_const(ClassType))]; + int t47[F(__is_const(Derives))]; + int t48[F(__is_const(Enum))]; + int t49[F(__is_const(IntArNB))]; + int t50[F(__is_const(Union))]; + int t51[F(__is_const(UnionAr))]; +} + +void is_volatile() +{ + int t02[T(__is_volatile(volatile char))]; + int t03[T(__is_volatile(volatile int))]; + int t04[T(__is_volatile(volatile long))]; + int t05[T(__is_volatile(volatile short))]; + int t06[T(__is_volatile(volatile signed char))]; + int t07[T(__is_volatile(volatile wchar_t))]; + int t08[T(__is_volatile(volatile bool))]; + int t09[T(__is_volatile(volatile float))]; + int t10[T(__is_volatile(volatile double))]; + int t11[T(__is_volatile(volatile long double))]; + int t12[T(__is_volatile(volatile unsigned char))]; + int t13[T(__is_volatile(volatile unsigned int))]; + int t14[T(__is_volatile(volatile unsigned long long))]; + int t15[T(__is_volatile(volatile unsigned long))]; + int t16[T(__is_volatile(volatile unsigned short))]; + int t17[T(__is_volatile(volatile void))]; + int t18[T(__is_volatile(volatile ClassType))]; + int t19[T(__is_volatile(volatile Derives))]; + int t20[T(__is_volatile(volatile Enum))]; + int t21[T(__is_volatile(volatile IntArNB))]; + int t22[T(__is_volatile(volatile Union))]; + int t23[T(__is_volatile(volatile UnionAr))]; + + int t30[F(__is_volatile(char))]; + int t31[F(__is_volatile(int))]; + int t32[F(__is_volatile(long))]; + int t33[F(__is_volatile(short))]; + int t34[F(__is_volatile(signed char))]; + int t35[F(__is_volatile(wchar_t))]; + int t36[F(__is_volatile(bool))]; + int t37[F(__is_volatile(float))]; + int t38[F(__is_volatile(double))]; + int t39[F(__is_volatile(long double))]; + int t40[F(__is_volatile(unsigned char))]; + int t41[F(__is_volatile(unsigned int))]; + int t42[F(__is_volatile(unsigned long long))]; + int t43[F(__is_volatile(unsigned long))]; + int t44[F(__is_volatile(unsigned short))]; + int t45[F(__is_volatile(void))]; + int t46[F(__is_volatile(ClassType))]; + int t47[F(__is_volatile(Derives))]; + int t48[F(__is_volatile(Enum))]; + int t49[F(__is_volatile(IntArNB))]; + int t50[F(__is_volatile(Union))]; + int t51[F(__is_volatile(UnionAr))]; +} + +struct TrivialStruct { + int member; +}; + +struct NonTrivialStruct { + int member; + NonTrivialStruct() { + member = 0; + } +}; + +void is_trivial2() +{ + int t01[T(__is_trivial(char))]; + int t02[T(__is_trivial(int))]; + int t03[T(__is_trivial(long))]; + int t04[T(__is_trivial(short))]; + int t05[T(__is_trivial(signed char))]; + int t06[T(__is_trivial(wchar_t))]; + int t07[T(__is_trivial(bool))]; + int t08[T(__is_trivial(float))]; + int t09[T(__is_trivial(double))]; + int t10[T(__is_trivial(long double))]; + int t11[T(__is_trivial(unsigned char))]; + int t12[T(__is_trivial(unsigned int))]; + int t13[T(__is_trivial(unsigned long long))]; + int t14[T(__is_trivial(unsigned long))]; + int t15[T(__is_trivial(unsigned short))]; + int t16[T(__is_trivial(ClassType))]; + int t17[T(__is_trivial(Derives))]; + int t18[T(__is_trivial(Enum))]; + int t19[T(__is_trivial(IntAr))]; + int t20[T(__is_trivial(Union))]; + int t21[T(__is_trivial(UnionAr))]; + int t22[T(__is_trivial(TrivialStruct))]; + + int t30[F(__is_trivial(void))]; + int t31[F(__is_trivial(NonTrivialStruct))]; +} + +struct CStruct { + int one; + int two; +}; + +struct CEmptyStruct {}; + +struct CppEmptyStruct : CStruct {}; +struct CppStructStandard : CEmptyStruct { + int three; + int four; +}; +struct CppStructNonStandardByBase : CStruct { + int three; + int four; +}; +struct CppStructNonStandardByVirt : CStruct { + virtual void method() {} +}; +struct CppStructNonStandardByMemb : CStruct { + CppStructNonStandardByVirt member; +}; +struct CppStructNonStandardByProt : CStruct { + int five; +protected: + int six; +}; +struct CppStructNonStandardByVirtBase : virtual CStruct { +}; +struct CppStructNonStandardBySameBase : CEmptyStruct { + CEmptyStruct member; +}; +struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct { + CEmptyStruct member; +}; + +void is_standard_layout() +{ + typedef const int ConstInt; + typedef ConstInt ConstIntAr[4]; + typedef CppStructStandard CppStructStandardAr[4]; + + int t01[T(__is_standard_layout(int))]; + int t02[T(__is_standard_layout(ConstInt))]; + int t03[T(__is_standard_layout(ConstIntAr))]; + int t04[T(__is_standard_layout(CStruct))]; + int t05[T(__is_standard_layout(CppStructStandard))]; + int t06[T(__is_standard_layout(CppStructStandardAr))]; + int t07[T(__is_standard_layout(Vector))]; + int t08[T(__is_standard_layout(VectorExt))]; + + typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4]; + + int t10[F(__is_standard_layout(CppStructNonStandardByVirt))]; + int t11[F(__is_standard_layout(CppStructNonStandardByMemb))]; + int t12[F(__is_standard_layout(CppStructNonStandardByProt))]; + int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))]; + int t14[F(__is_standard_layout(CppStructNonStandardByBase))]; + int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))]; + int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))]; + int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))]; +} + +void is_signed() +{ + //int t01[T(__is_signed(char))]; + int t02[T(__is_signed(int))]; + int t03[T(__is_signed(long))]; + int t04[T(__is_signed(short))]; + int t05[T(__is_signed(signed char))]; + int t06[T(__is_signed(wchar_t))]; + + int t10[F(__is_signed(bool))]; + int t11[F(__is_signed(cvoid))]; + int t12[F(__is_signed(float))]; + int t13[F(__is_signed(double))]; + int t14[F(__is_signed(long double))]; + int t15[F(__is_signed(unsigned char))]; + int t16[F(__is_signed(unsigned int))]; + int t17[F(__is_signed(unsigned long long))]; + int t18[F(__is_signed(unsigned long))]; + int t19[F(__is_signed(unsigned short))]; + int t20[F(__is_signed(void))]; + int t21[F(__is_signed(ClassType))]; + int t22[F(__is_signed(Derives))]; + int t23[F(__is_signed(Enum))]; + int t24[F(__is_signed(IntArNB))]; + int t25[F(__is_signed(Union))]; + int t26[F(__is_signed(UnionAr))]; +} + +void is_unsigned() +{ + int t01[T(__is_unsigned(bool))]; + int t02[T(__is_unsigned(unsigned char))]; + int t03[T(__is_unsigned(unsigned short))]; + int t04[T(__is_unsigned(unsigned int))]; + int t05[T(__is_unsigned(unsigned long))]; + int t06[T(__is_unsigned(unsigned long long))]; + int t07[T(__is_unsigned(Enum))]; + + int t10[F(__is_unsigned(void))]; + int t11[F(__is_unsigned(cvoid))]; + int t12[F(__is_unsigned(float))]; + int t13[F(__is_unsigned(double))]; + int t14[F(__is_unsigned(long double))]; + int t16[F(__is_unsigned(char))]; + int t17[F(__is_unsigned(signed char))]; + int t18[F(__is_unsigned(wchar_t))]; + int t19[F(__is_unsigned(short))]; + int t20[F(__is_unsigned(int))]; + int t21[F(__is_unsigned(long))]; + int t22[F(__is_unsigned(Union))]; + int t23[F(__is_unsigned(UnionAr))]; + int t24[F(__is_unsigned(Derives))]; + int t25[F(__is_unsigned(ClassType))]; + int t26[F(__is_unsigned(IntArNB))]; } typedef Int& IntRef; @@ -227,6 +1026,10 @@ struct HasCopy { HasCopy(HasCopy& cp); }; +struct HasMove { + HasMove(HasMove&& cp); // expected-warning {{rvalue references}} +}; + struct HasTemplateCons { HasVirt Annoying; @@ -235,216 +1038,235 @@ struct HasTemplateCons { }; void has_trivial_default_constructor() { - int t01[T(__has_trivial_constructor(Int))]; - int t02[T(__has_trivial_constructor(IntAr))]; - int t03[T(__has_trivial_constructor(Union))]; - int t04[T(__has_trivial_constructor(UnionAr))]; - int t05[T(__has_trivial_constructor(POD))]; - int t06[T(__has_trivial_constructor(Derives))]; - int t07[T(__has_trivial_constructor(ConstIntAr))]; - int t08[T(__has_trivial_constructor(ConstIntArAr))]; - int t09[T(__has_trivial_constructor(HasDest))]; - int t10[T(__has_trivial_constructor(HasPriv))]; - int t11[F(__has_trivial_constructor(HasCons))]; - int t12[F(__has_trivial_constructor(HasRef))]; - int t13[F(__has_trivial_constructor(HasCopy))]; - int t14[F(__has_trivial_constructor(IntRef))]; - int t15[T(__has_trivial_constructor(HasCopyAssign))]; - int t16[T(__has_trivial_constructor(const Int))]; - int t17[T(__has_trivial_constructor(NonPODAr))]; - int t18[F(__has_trivial_constructor(VirtAr))]; - int t19[F(__has_trivial_constructor(void))]; - int t20[F(__has_trivial_constructor(cvoid))]; - int t21[F(__has_trivial_constructor(HasTemplateCons))]; + { int arr[T(__has_trivial_constructor(Int))]; } + { int arr[T(__has_trivial_constructor(IntAr))]; } + { int arr[T(__has_trivial_constructor(Union))]; } + { int arr[T(__has_trivial_constructor(UnionAr))]; } + { int arr[T(__has_trivial_constructor(POD))]; } + { int arr[T(__has_trivial_constructor(Derives))]; } + { int arr[T(__has_trivial_constructor(DerivesAr))]; } + { int arr[T(__has_trivial_constructor(ConstIntAr))]; } + { int arr[T(__has_trivial_constructor(ConstIntArAr))]; } + { int arr[T(__has_trivial_constructor(HasDest))]; } + { int arr[T(__has_trivial_constructor(HasPriv))]; } + { int arr[T(__has_trivial_constructor(HasCopyAssign))]; } + { int arr[T(__has_trivial_constructor(HasMoveAssign))]; } + { int arr[T(__has_trivial_constructor(const Int))]; } + + { int arr[F(__has_trivial_constructor(HasCons))]; } + { int arr[F(__has_trivial_constructor(HasRef))]; } + { int arr[F(__has_trivial_constructor(HasCopy))]; } + { int arr[F(__has_trivial_constructor(IntRef))]; } + { int arr[F(__has_trivial_constructor(VirtAr))]; } + { int arr[F(__has_trivial_constructor(void))]; } + { int arr[F(__has_trivial_constructor(cvoid))]; } + { int arr[F(__has_trivial_constructor(HasTemplateCons))]; } } void has_trivial_copy_constructor() { - int t01[T(__has_trivial_copy(Int))]; - int t02[T(__has_trivial_copy(IntAr))]; - int t03[T(__has_trivial_copy(Union))]; - int t04[T(__has_trivial_copy(UnionAr))]; - int t05[T(__has_trivial_copy(POD))]; - int t06[T(__has_trivial_copy(Derives))]; - int t07[T(__has_trivial_copy(ConstIntAr))]; - int t08[T(__has_trivial_copy(ConstIntArAr))]; - int t09[T(__has_trivial_copy(HasDest))]; - int t10[T(__has_trivial_copy(HasPriv))]; - int t11[T(__has_trivial_copy(HasCons))]; - int t12[T(__has_trivial_copy(HasRef))]; - int t13[F(__has_trivial_copy(HasCopy))]; - int t14[T(__has_trivial_copy(IntRef))]; - int t15[T(__has_trivial_copy(HasCopyAssign))]; - int t16[T(__has_trivial_copy(const Int))]; - int t17[F(__has_trivial_copy(NonPODAr))]; - int t18[F(__has_trivial_copy(VirtAr))]; - int t19[F(__has_trivial_copy(void))]; - int t20[F(__has_trivial_copy(cvoid))]; - int t21[F(__has_trivial_copy(HasTemplateCons))]; + { int arr[T(__has_trivial_copy(Int))]; } + { int arr[T(__has_trivial_copy(IntAr))]; } + { int arr[T(__has_trivial_copy(Union))]; } + { int arr[T(__has_trivial_copy(UnionAr))]; } + { int arr[T(__has_trivial_copy(POD))]; } + { int arr[T(__has_trivial_copy(Derives))]; } + { int arr[T(__has_trivial_copy(ConstIntAr))]; } + { int arr[T(__has_trivial_copy(ConstIntArAr))]; } + { int arr[T(__has_trivial_copy(HasDest))]; } + { int arr[T(__has_trivial_copy(HasPriv))]; } + { int arr[T(__has_trivial_copy(HasCons))]; } + { int arr[T(__has_trivial_copy(HasRef))]; } + { int arr[T(__has_trivial_copy(HasMove))]; } + { int arr[T(__has_trivial_copy(IntRef))]; } + { int arr[T(__has_trivial_copy(HasCopyAssign))]; } + { int arr[T(__has_trivial_copy(HasMoveAssign))]; } + { int arr[T(__has_trivial_copy(const Int))]; } + + { int arr[F(__has_trivial_copy(HasCopy))]; } + { int arr[F(__has_trivial_copy(HasTemplateCons))]; } + { int arr[F(__has_trivial_copy(DerivesAr))]; } + { int arr[F(__has_trivial_copy(VirtAr))]; } + { int arr[F(__has_trivial_copy(void))]; } + { int arr[F(__has_trivial_copy(cvoid))]; } } void has_trivial_copy_assignment() { - int t01[T(__has_trivial_assign(Int))]; - int t02[T(__has_trivial_assign(IntAr))]; - int t03[T(__has_trivial_assign(Union))]; - int t04[T(__has_trivial_assign(UnionAr))]; - int t05[T(__has_trivial_assign(POD))]; - int t06[T(__has_trivial_assign(Derives))]; - int t07[F(__has_trivial_assign(ConstIntAr))]; - int t08[F(__has_trivial_assign(ConstIntArAr))]; - int t09[T(__has_trivial_assign(HasDest))]; - int t10[T(__has_trivial_assign(HasPriv))]; - int t11[T(__has_trivial_assign(HasCons))]; - int t12[T(__has_trivial_assign(HasRef))]; - int t13[T(__has_trivial_assign(HasCopy))]; - int t14[F(__has_trivial_assign(IntRef))]; - int t15[F(__has_trivial_assign(HasCopyAssign))]; - int t16[F(__has_trivial_assign(const Int))]; - int t17[F(__has_trivial_assign(NonPODAr))]; - int t18[F(__has_trivial_assign(VirtAr))]; - int t19[F(__has_trivial_assign(void))]; - int t20[F(__has_trivial_assign(cvoid))]; + { int arr[T(__has_trivial_assign(Int))]; } + { int arr[T(__has_trivial_assign(IntAr))]; } + { int arr[T(__has_trivial_assign(Union))]; } + { int arr[T(__has_trivial_assign(UnionAr))]; } + { int arr[T(__has_trivial_assign(POD))]; } + { int arr[T(__has_trivial_assign(Derives))]; } + { int arr[T(__has_trivial_assign(HasDest))]; } + { int arr[T(__has_trivial_assign(HasPriv))]; } + { int arr[T(__has_trivial_assign(HasCons))]; } + { int arr[T(__has_trivial_assign(HasRef))]; } + { int arr[T(__has_trivial_assign(HasCopy))]; } + { int arr[T(__has_trivial_assign(HasMove))]; } + { int arr[T(__has_trivial_assign(HasMoveAssign))]; } + + { int arr[F(__has_trivial_assign(IntRef))]; } + { int arr[F(__has_trivial_assign(HasCopyAssign))]; } + { int arr[F(__has_trivial_assign(const Int))]; } + { int arr[F(__has_trivial_assign(ConstIntAr))]; } + { int arr[F(__has_trivial_assign(ConstIntArAr))]; } + { int arr[F(__has_trivial_assign(DerivesAr))]; } + { int arr[F(__has_trivial_assign(VirtAr))]; } + { int arr[F(__has_trivial_assign(void))]; } + { int arr[F(__has_trivial_assign(cvoid))]; } } void has_trivial_destructor() { - int t01[T(__has_trivial_destructor(Int))]; - int t02[T(__has_trivial_destructor(IntAr))]; - int t03[T(__has_trivial_destructor(Union))]; - int t04[T(__has_trivial_destructor(UnionAr))]; - int t05[T(__has_trivial_destructor(POD))]; - int t06[T(__has_trivial_destructor(Derives))]; - int t07[T(__has_trivial_destructor(ConstIntAr))]; - int t08[T(__has_trivial_destructor(ConstIntArAr))]; - int t09[F(__has_trivial_destructor(HasDest))]; - int t10[T(__has_trivial_destructor(HasPriv))]; - int t11[T(__has_trivial_destructor(HasCons))]; - int t12[T(__has_trivial_destructor(HasRef))]; - int t13[T(__has_trivial_destructor(HasCopy))]; - int t14[T(__has_trivial_destructor(IntRef))]; - int t15[T(__has_trivial_destructor(HasCopyAssign))]; - int t16[T(__has_trivial_destructor(const Int))]; - int t17[T(__has_trivial_destructor(NonPODAr))]; - int t18[T(__has_trivial_destructor(VirtAr))]; - int t19[F(__has_trivial_destructor(void))]; - int t20[F(__has_trivial_destructor(cvoid))]; + { int arr[T(__has_trivial_destructor(Int))]; } + { int arr[T(__has_trivial_destructor(IntAr))]; } + { int arr[T(__has_trivial_destructor(Union))]; } + { int arr[T(__has_trivial_destructor(UnionAr))]; } + { int arr[T(__has_trivial_destructor(POD))]; } + { int arr[T(__has_trivial_destructor(Derives))]; } + { int arr[T(__has_trivial_destructor(ConstIntAr))]; } + { int arr[T(__has_trivial_destructor(ConstIntArAr))]; } + { int arr[T(__has_trivial_destructor(HasPriv))]; } + { int arr[T(__has_trivial_destructor(HasCons))]; } + { int arr[T(__has_trivial_destructor(HasRef))]; } + { int arr[T(__has_trivial_destructor(HasCopy))]; } + { int arr[T(__has_trivial_destructor(HasMove))]; } + { int arr[T(__has_trivial_destructor(IntRef))]; } + { int arr[T(__has_trivial_destructor(HasCopyAssign))]; } + { int arr[T(__has_trivial_destructor(HasMoveAssign))]; } + { int arr[T(__has_trivial_destructor(const Int))]; } + { int arr[T(__has_trivial_destructor(DerivesAr))]; } + { int arr[T(__has_trivial_destructor(VirtAr))]; } + + { int arr[F(__has_trivial_destructor(HasDest))]; } + { int arr[F(__has_trivial_destructor(void))]; } + { int arr[F(__has_trivial_destructor(cvoid))]; } } struct A { ~A() {} }; template<typename> struct B : A { }; void f() { - int t01[F(__has_trivial_destructor(A))]; - int t02[F(__has_trivial_destructor(B<int>))]; + { int arr[F(__has_trivial_destructor(A))]; } + { int arr[F(__has_trivial_destructor(B<int>))]; } } void has_nothrow_assign() { - int t01[T(__has_nothrow_assign(Int))]; - int t02[T(__has_nothrow_assign(IntAr))]; - int t03[T(__has_nothrow_assign(Union))]; - int t04[T(__has_nothrow_assign(UnionAr))]; - int t05[T(__has_nothrow_assign(POD))]; - int t06[T(__has_nothrow_assign(Derives))]; - int t07[F(__has_nothrow_assign(ConstIntAr))]; - int t08[F(__has_nothrow_assign(ConstIntArAr))]; - int t09[T(__has_nothrow_assign(HasDest))]; - int t10[T(__has_nothrow_assign(HasPriv))]; - int t11[T(__has_nothrow_assign(HasCons))]; - int t12[T(__has_nothrow_assign(HasRef))]; - int t13[T(__has_nothrow_assign(HasCopy))]; - int t14[F(__has_nothrow_assign(IntRef))]; - int t15[F(__has_nothrow_assign(HasCopyAssign))]; - int t16[F(__has_nothrow_assign(const Int))]; - int t17[F(__has_nothrow_assign(NonPODAr))]; - int t18[F(__has_nothrow_assign(VirtAr))]; - int t19[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; - int t20[F(__has_nothrow_assign(HasMultipleCopyAssign))]; - int t21[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; - int t22[F(__has_nothrow_assign(void))]; - int t23[F(__has_nothrow_assign(cvoid))]; - int t24[T(__has_nothrow_assign(HasVirtDest))]; + { int arr[T(__has_nothrow_assign(Int))]; } + { int arr[T(__has_nothrow_assign(IntAr))]; } + { int arr[T(__has_nothrow_assign(Union))]; } + { int arr[T(__has_nothrow_assign(UnionAr))]; } + { int arr[T(__has_nothrow_assign(POD))]; } + { int arr[T(__has_nothrow_assign(Derives))]; } + { int arr[T(__has_nothrow_assign(HasDest))]; } + { int arr[T(__has_nothrow_assign(HasPriv))]; } + { int arr[T(__has_nothrow_assign(HasCons))]; } + { int arr[T(__has_nothrow_assign(HasRef))]; } + { int arr[T(__has_nothrow_assign(HasCopy))]; } + { int arr[T(__has_nothrow_assign(HasMove))]; } + { int arr[T(__has_nothrow_assign(HasMoveAssign))]; } + { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; } + { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; } + { int arr[T(__has_nothrow_assign(HasVirtDest))]; } + + { int arr[F(__has_nothrow_assign(IntRef))]; } + { int arr[F(__has_nothrow_assign(HasCopyAssign))]; } + { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; } + { int arr[F(__has_nothrow_assign(const Int))]; } + { int arr[F(__has_nothrow_assign(ConstIntAr))]; } + { int arr[F(__has_nothrow_assign(ConstIntArAr))]; } + { int arr[F(__has_nothrow_assign(DerivesAr))]; } + { int arr[F(__has_nothrow_assign(VirtAr))]; } + { int arr[F(__has_nothrow_assign(void))]; } + { int arr[F(__has_nothrow_assign(cvoid))]; } } void has_nothrow_copy() { - int t01[T(__has_nothrow_copy(Int))]; - int t02[T(__has_nothrow_copy(IntAr))]; - int t03[T(__has_nothrow_copy(Union))]; - int t04[T(__has_nothrow_copy(UnionAr))]; - int t05[T(__has_nothrow_copy(POD))]; - int t06[T(__has_nothrow_copy(Derives))]; - int t07[T(__has_nothrow_copy(ConstIntAr))]; - int t08[T(__has_nothrow_copy(ConstIntArAr))]; - int t09[T(__has_nothrow_copy(HasDest))]; - int t10[T(__has_nothrow_copy(HasPriv))]; - int t11[T(__has_nothrow_copy(HasCons))]; - int t12[T(__has_nothrow_copy(HasRef))]; - int t13[F(__has_nothrow_copy(HasCopy))]; - int t14[T(__has_nothrow_copy(IntRef))]; - int t15[T(__has_nothrow_copy(HasCopyAssign))]; - int t16[T(__has_nothrow_copy(const Int))]; - int t17[F(__has_nothrow_copy(NonPODAr))]; - int t18[F(__has_nothrow_copy(VirtAr))]; - - int t19[T(__has_nothrow_copy(HasNoThrowCopy))]; - int t20[F(__has_nothrow_copy(HasMultipleCopy))]; - int t21[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; - int t22[F(__has_nothrow_copy(void))]; - int t23[F(__has_nothrow_copy(cvoid))]; - int t24[T(__has_nothrow_copy(HasVirtDest))]; - int t25[T(__has_nothrow_copy(HasTemplateCons))]; + { int arr[T(__has_nothrow_copy(Int))]; } + { int arr[T(__has_nothrow_copy(IntAr))]; } + { int arr[T(__has_nothrow_copy(Union))]; } + { int arr[T(__has_nothrow_copy(UnionAr))]; } + { int arr[T(__has_nothrow_copy(POD))]; } + { int arr[T(__has_nothrow_copy(const Int))]; } + { int arr[T(__has_nothrow_copy(ConstIntAr))]; } + { int arr[T(__has_nothrow_copy(ConstIntArAr))]; } + { int arr[T(__has_nothrow_copy(Derives))]; } + { int arr[T(__has_nothrow_copy(IntRef))]; } + { int arr[T(__has_nothrow_copy(HasDest))]; } + { int arr[T(__has_nothrow_copy(HasPriv))]; } + { int arr[T(__has_nothrow_copy(HasCons))]; } + { int arr[T(__has_nothrow_copy(HasRef))]; } + { int arr[T(__has_nothrow_copy(HasMove))]; } + { int arr[T(__has_nothrow_copy(HasCopyAssign))]; } + { int arr[T(__has_nothrow_copy(HasMoveAssign))]; } + { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; } + { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; } + { int arr[T(__has_nothrow_copy(HasVirtDest))]; } + { int arr[T(__has_nothrow_copy(HasTemplateCons))]; } + + { int arr[F(__has_nothrow_copy(HasCopy))]; } + { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; } + { int arr[F(__has_nothrow_copy(DerivesAr))]; } + { int arr[F(__has_nothrow_copy(VirtAr))]; } + { int arr[F(__has_nothrow_copy(void))]; } + { int arr[F(__has_nothrow_copy(cvoid))]; } } void has_nothrow_constructor() { - int t01[T(__has_nothrow_constructor(Int))]; - int t02[T(__has_nothrow_constructor(IntAr))]; - int t03[T(__has_nothrow_constructor(Union))]; - int t04[T(__has_nothrow_constructor(UnionAr))]; - int t05[T(__has_nothrow_constructor(POD))]; - int t06[T(__has_nothrow_constructor(Derives))]; - int t07[T(__has_nothrow_constructor(ConstIntAr))]; - int t08[T(__has_nothrow_constructor(ConstIntArAr))]; - int t09[T(__has_nothrow_constructor(HasDest))]; - int t10[T(__has_nothrow_constructor(HasPriv))]; - int t11[F(__has_nothrow_constructor(HasCons))]; - int t12[F(__has_nothrow_constructor(HasRef))]; - int t13[F(__has_nothrow_constructor(HasCopy))]; - int t14[F(__has_nothrow_constructor(IntRef))]; - int t15[T(__has_nothrow_constructor(HasCopyAssign))]; - int t16[T(__has_nothrow_constructor(const Int))]; - int t17[T(__has_nothrow_constructor(NonPODAr))]; - // int t18[T(__has_nothrow_constructor(VirtAr))]; // not implemented - - int t19[T(__has_nothrow_constructor(HasNoThrowConstructor))]; - int t20[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; - int t21[F(__has_nothrow_constructor(void))]; - int t22[F(__has_nothrow_constructor(cvoid))]; - int t23[T(__has_nothrow_constructor(HasVirtDest))]; - int t24[F(__has_nothrow_constructor(HasTemplateCons))]; + { int arr[T(__has_nothrow_constructor(Int))]; } + { int arr[T(__has_nothrow_constructor(IntAr))]; } + { int arr[T(__has_nothrow_constructor(Union))]; } + { int arr[T(__has_nothrow_constructor(UnionAr))]; } + { int arr[T(__has_nothrow_constructor(POD))]; } + { int arr[T(__has_nothrow_constructor(Derives))]; } + { int arr[T(__has_nothrow_constructor(DerivesAr))]; } + { int arr[T(__has_nothrow_constructor(ConstIntAr))]; } + { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; } + { int arr[T(__has_nothrow_constructor(HasDest))]; } + { int arr[T(__has_nothrow_constructor(HasPriv))]; } + { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; } + { int arr[T(__has_nothrow_constructor(const Int))]; } + { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; } + { int arr[T(__has_nothrow_constructor(HasVirtDest))]; } + // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented + + { int arr[F(__has_nothrow_constructor(HasCons))]; } + { int arr[F(__has_nothrow_constructor(HasRef))]; } + { int arr[F(__has_nothrow_constructor(HasCopy))]; } + { int arr[F(__has_nothrow_constructor(HasMove))]; } + { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; } + { int arr[F(__has_nothrow_constructor(IntRef))]; } + { int arr[F(__has_nothrow_constructor(void))]; } + { int arr[F(__has_nothrow_constructor(cvoid))]; } + { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; } } void has_virtual_destructor() { - int t01[F(__has_virtual_destructor(Int))]; - int t02[F(__has_virtual_destructor(IntAr))]; - int t03[F(__has_virtual_destructor(Union))]; - int t04[F(__has_virtual_destructor(UnionAr))]; - int t05[F(__has_virtual_destructor(POD))]; - int t06[F(__has_virtual_destructor(Derives))]; - int t07[F(__has_virtual_destructor(ConstIntAr))]; - int t08[F(__has_virtual_destructor(ConstIntArAr))]; - int t09[F(__has_virtual_destructor(HasDest))]; - int t10[F(__has_virtual_destructor(HasPriv))]; - int t11[F(__has_virtual_destructor(HasCons))]; - int t12[F(__has_virtual_destructor(HasRef))]; - int t13[F(__has_virtual_destructor(HasCopy))]; - int t14[F(__has_virtual_destructor(IntRef))]; - int t15[F(__has_virtual_destructor(HasCopyAssign))]; - int t16[F(__has_virtual_destructor(const Int))]; - int t17[F(__has_virtual_destructor(NonPODAr))]; - int t18[F(__has_virtual_destructor(VirtAr))]; - - int t19[T(__has_virtual_destructor(HasVirtDest))]; - int t20[T(__has_virtual_destructor(DerivedVirtDest))]; - int t21[F(__has_virtual_destructor(VirtDestAr))]; - int t22[F(__has_virtual_destructor(void))]; - int t23[F(__has_virtual_destructor(cvoid))]; + { int arr[F(__has_virtual_destructor(Int))]; } + { int arr[F(__has_virtual_destructor(IntAr))]; } + { int arr[F(__has_virtual_destructor(Union))]; } + { int arr[F(__has_virtual_destructor(UnionAr))]; } + { int arr[F(__has_virtual_destructor(POD))]; } + { int arr[F(__has_virtual_destructor(Derives))]; } + { int arr[F(__has_virtual_destructor(DerivesAr))]; } + { int arr[F(__has_virtual_destructor(const Int))]; } + { int arr[F(__has_virtual_destructor(ConstIntAr))]; } + { int arr[F(__has_virtual_destructor(ConstIntArAr))]; } + { int arr[F(__has_virtual_destructor(HasDest))]; } + { int arr[F(__has_virtual_destructor(HasPriv))]; } + { int arr[F(__has_virtual_destructor(HasCons))]; } + { int arr[F(__has_virtual_destructor(HasRef))]; } + { int arr[F(__has_virtual_destructor(HasCopy))]; } + { int arr[F(__has_virtual_destructor(HasMove))]; } + { int arr[F(__has_virtual_destructor(HasCopyAssign))]; } + { int arr[F(__has_virtual_destructor(HasMoveAssign))]; } + { int arr[F(__has_virtual_destructor(IntRef))]; } + { int arr[F(__has_virtual_destructor(VirtAr))]; } + + { int arr[T(__has_virtual_destructor(HasVirtDest))]; } + { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; } + { int arr[F(__has_virtual_destructor(VirtDestAr))]; } + { int arr[F(__has_virtual_destructor(void))]; } + { int arr[F(__has_virtual_destructor(cvoid))]; } } @@ -474,29 +1296,29 @@ template <class T> class NonderivedTemp {}; template <class T> class UndefinedTemp; // expected-note {{declared here}} void is_base_of() { - int t01[T(__is_base_of(Base, Derived))]; - int t02[T(__is_base_of(const Base, Derived))]; - int t03[F(__is_base_of(Derived, Base))]; - int t04[F(__is_base_of(Derived, int))]; - int t05[T(__is_base_of(Base, Base))]; - int t06[T(__is_base_of(Base, Derived3))]; - int t07[T(__is_base_of(Derived, Derived3))]; - int t08[T(__is_base_of(Derived2b, Derived3))]; - int t09[T(__is_base_of(Derived2a, Derived3))]; - int t10[T(__is_base_of(BaseA<int>, DerivedB<int>))]; - int t11[F(__is_base_of(DerivedB<int>, BaseA<int>))]; - int t12[T(__is_base_of(Base, CrazyDerived<Base>))]; - int t13[F(__is_base_of(Union, Union))]; - int t14[T(__is_base_of(Empty, Empty))]; - int t15[T(__is_base_of(class_forward, class_forward))]; - int t16[F(__is_base_of(Empty, class_forward))]; // expected-error {{incomplete type 'class_forward' used in type trait expression}} - int t17[F(__is_base_of(Base&, Derived&))]; + { int arr[T(__is_base_of(Base, Derived))]; } + { int arr[T(__is_base_of(const Base, Derived))]; } + { int arr[F(__is_base_of(Derived, Base))]; } + { int arr[F(__is_base_of(Derived, int))]; } + { int arr[T(__is_base_of(Base, Base))]; } + { int arr[T(__is_base_of(Base, Derived3))]; } + { int arr[T(__is_base_of(Derived, Derived3))]; } + { int arr[T(__is_base_of(Derived2b, Derived3))]; } + { int arr[T(__is_base_of(Derived2a, Derived3))]; } + { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; } + { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; } + { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; } + { int arr[F(__is_base_of(Union, Union))]; } + { int arr[T(__is_base_of(Empty, Empty))]; } + { int arr[T(__is_base_of(class_forward, class_forward))]; } + { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}} + { int arr[F(__is_base_of(Base&, Derived&))]; } int t18[F(__is_base_of(Base[10], Derived[10]))]; - int t19[F(__is_base_of(int, int))]; - int t20[F(__is_base_of(long, int))]; - int t21[T(__is_base_of(Base, DerivedTemp<int>))]; - int t22[F(__is_base_of(Base, NonderivedTemp<int>))]; - int t23[F(__is_base_of(Base, UndefinedTemp<int>))]; // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} + { int arr[F(__is_base_of(int, int))]; } + { int arr[F(__is_base_of(long, int))]; } + { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; } + { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; } + { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} isBaseOfT<Base, Derived>(); isBaseOfF<Derived, Base>(); @@ -508,6 +1330,64 @@ void is_base_of() { isBaseOfF<DerivedB<int>, BaseA<int> >(); } +#if 0 +template<class T, class U> +class TemplateClass {}; + +template<class T> +using TemplateAlias = TemplateClass<T, int>; +#endif + +typedef class Base BaseTypedef; + +void is_same() +{ + int t01[T(__is_same(Base, Base))]; + int t02[T(__is_same(Base, BaseTypedef))]; +#if 0 + int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))]; +#endif + + int t10[F(__is_same(Base, const Base))]; + int t11[F(__is_same(Base, Base&))]; + int t12[F(__is_same(Base, Derived))]; +} + +struct IntWrapper +{ + int value; + IntWrapper(int _value) : value(_value) {} + operator int() const { + return value; + } +}; + +struct FloatWrapper +{ + float value; + FloatWrapper(float _value) : value(_value) {} + FloatWrapper(const IntWrapper& obj) + : value(static_cast<float>(obj.value)) {} + operator float() const { + return value; + } + operator IntWrapper() const { + return IntWrapper(static_cast<int>(value)); + } +}; + +void is_convertible() +{ + int t01[T(__is_convertible(IntWrapper, IntWrapper))]; + int t02[T(__is_convertible(IntWrapper, const IntWrapper))]; + int t03[T(__is_convertible(IntWrapper, int))]; + int t04[T(__is_convertible(int, IntWrapper))]; + int t05[T(__is_convertible(IntWrapper, FloatWrapper))]; + int t06[T(__is_convertible(FloatWrapper, IntWrapper))]; + int t07[T(__is_convertible(FloatWrapper, float))]; + int t08[T(__is_convertible(float, FloatWrapper))]; +} + struct FromInt { FromInt(int); }; struct ToInt { operator int(); }; typedef void Function(); @@ -524,27 +1404,83 @@ struct X0 { }; void is_convertible_to() { - int t01[T(__is_convertible_to(Int, Int))]; - int t02[F(__is_convertible_to(Int, IntAr))]; - int t03[F(__is_convertible_to(IntAr, IntAr))]; - int t04[T(__is_convertible_to(void, void))]; - int t05[T(__is_convertible_to(cvoid, void))]; - int t06[T(__is_convertible_to(void, cvoid))]; - int t07[T(__is_convertible_to(cvoid, cvoid))]; - int t08[T(__is_convertible_to(int, FromInt))]; - int t09[T(__is_convertible_to(long, FromInt))]; - int t10[T(__is_convertible_to(double, FromInt))]; - int t11[T(__is_convertible_to(const int, FromInt))]; - int t12[T(__is_convertible_to(const int&, FromInt))]; - int t13[T(__is_convertible_to(ToInt, int))]; - int t14[T(__is_convertible_to(ToInt, const int&))]; - int t15[T(__is_convertible_to(ToInt, long))]; - int t16[F(__is_convertible_to(ToInt, int&))]; - int t17[F(__is_convertible_to(ToInt, FromInt))]; - int t18[T(__is_convertible_to(IntAr&, IntAr&))]; - int t19[T(__is_convertible_to(IntAr&, const IntAr&))]; - int t20[F(__is_convertible_to(const IntAr&, IntAr&))]; - int t21[F(__is_convertible_to(Function, Function))]; - int t22[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; - int t23[T(__is_convertible_to(X0<int>, X0<float>))]; + { int arr[T(__is_convertible_to(Int, Int))]; } + { int arr[F(__is_convertible_to(Int, IntAr))]; } + { int arr[F(__is_convertible_to(IntAr, IntAr))]; } + { int arr[T(__is_convertible_to(void, void))]; } + { int arr[T(__is_convertible_to(cvoid, void))]; } + { int arr[T(__is_convertible_to(void, cvoid))]; } + { int arr[T(__is_convertible_to(cvoid, cvoid))]; } + { int arr[T(__is_convertible_to(int, FromInt))]; } + { int arr[T(__is_convertible_to(long, FromInt))]; } + { int arr[T(__is_convertible_to(double, FromInt))]; } + { int arr[T(__is_convertible_to(const int, FromInt))]; } + { int arr[T(__is_convertible_to(const int&, FromInt))]; } + { int arr[T(__is_convertible_to(ToInt, int))]; } + { int arr[T(__is_convertible_to(ToInt, const int&))]; } + { int arr[T(__is_convertible_to(ToInt, long))]; } + { int arr[F(__is_convertible_to(ToInt, int&))]; } + { int arr[F(__is_convertible_to(ToInt, FromInt))]; } + { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; } + { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; } + { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; } + { int arr[F(__is_convertible_to(Function, Function))]; } + { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; } + { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; } +} + +void is_trivial() +{ + { int arr[T(__is_trivial(int))]; } + { int arr[T(__is_trivial(Enum))]; } + { int arr[T(__is_trivial(POD))]; } + { int arr[T(__is_trivial(Int))]; } + { int arr[T(__is_trivial(IntAr))]; } + { int arr[T(__is_trivial(IntArNB))]; } + { int arr[T(__is_trivial(Statics))]; } + { int arr[T(__is_trivial(Empty))]; } + { int arr[T(__is_trivial(EmptyUnion))]; } + { int arr[T(__is_trivial(Union))]; } + { int arr[T(__is_trivial(Derives))]; } + { int arr[T(__is_trivial(DerivesAr))]; } + { int arr[T(__is_trivial(DerivesArNB))]; } + { int arr[T(__is_trivial(DerivesEmpty))]; } + { int arr[T(__is_trivial(HasFunc))]; } + { int arr[T(__is_trivial(HasOp))]; } + { int arr[T(__is_trivial(HasConv))]; } + { int arr[T(__is_trivial(HasAssign))]; } + { int arr[T(__is_trivial(HasAnonymousUnion))]; } + { int arr[T(__is_trivial(HasPriv))]; } + { int arr[T(__is_trivial(HasProt))]; } + { int arr[T(__is_trivial(DerivesHasPriv))]; } + { int arr[T(__is_trivial(DerivesHasProt))]; } + { int arr[T(__is_trivial(Vector))]; } + { int arr[T(__is_trivial(VectorExt))]; } + + { int arr[F(__is_trivial(HasCons))]; } + { int arr[F(__is_trivial(HasCopyAssign))]; } + { int arr[F(__is_trivial(HasMoveAssign))]; } + { int arr[F(__is_trivial(HasDest))]; } + { int arr[F(__is_trivial(HasRef))]; } + { int arr[F(__is_trivial(HasNonPOD))]; } + { int arr[F(__is_trivial(HasVirt))]; } + { int arr[F(__is_trivial(DerivesHasCons))]; } + { int arr[F(__is_trivial(DerivesHasCopyAssign))]; } + { int arr[F(__is_trivial(DerivesHasMoveAssign))]; } + { int arr[F(__is_trivial(DerivesHasDest))]; } + { int arr[F(__is_trivial(DerivesHasRef))]; } + { int arr[F(__is_trivial(DerivesHasVirt))]; } + { int arr[F(__is_trivial(void))]; } + { int arr[F(__is_trivial(cvoid))]; } +} + +void array_rank() { + int t01[T(__array_rank(IntAr) == 1)]; + int t02[T(__array_rank(ConstIntArAr) == 2)]; +} + +void array_extent() { + int t01[T(__array_extent(IntAr, 0) == 10)]; + int t02[T(__array_extent(ConstIntArAr, 0) == 4)]; + int t03[T(__array_extent(ConstIntArAr, 1) == 10)]; } diff --git a/test/SemaCXX/uninit-variables-conditional.cpp b/test/SemaCXX/uninit-variables-conditional.cpp new file mode 100644 index 0000000..3324215 --- /dev/null +++ b/test/SemaCXX/uninit-variables-conditional.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -Wconditional-uninitialized -fsyntax-only %s -verify + +class Foo { +public: + Foo(); + ~Foo(); + operator bool(); +}; + +int bar(); +int baz(); +int init(double *); + +// This case flags a false positive under -Wconditional-uninitialized because +// the destructor in Foo fouls about the minor bit of path-sensitivity in +// -Wuninitialized. +double test() { + double x; // expected-note {{variable 'x' is declared here}} expected-note{{add initialization to silence this warning}} + if (bar() || baz() || Foo() || init(&x)) + return 1.0; + + return x; // expected-warning {{variable 'x' may be uninitialized when used here}} +} diff --git a/test/SemaCXX/uninit-variables.cpp b/test/SemaCXX/uninit-variables.cpp index 2bc7fb3..a0180e3 100644 --- a/test/SemaCXX/uninit-variables.cpp +++ b/test/SemaCXX/uninit-variables.cpp @@ -1,4 +1,7 @@ -// RUN: %clang_cc1 -fsyntax-only -Wuninitialized-experimental -fsyntax-only %s -verify +// RUN: %clang_cc1 -fsyntax-only -Wuninitialized -fsyntax-only -fcxx-exceptions %s -verify + +// Stub out types for 'typeid' to work. +namespace std { class type_info {}; } int test1_aux(int &x); int test1() { @@ -13,6 +16,20 @@ int test2_aux() { return x; // no-warning } +// Don't warn on unevaluated contexts. +void unevaluated_tests() { + int x; + (void)sizeof(x); + (void)typeid(x); +} + +// Warn for glvalue arguments to typeid whose type is polymorphic. +struct A { virtual ~A() {} }; +void polymorphic_test() { + A *a; // expected-note{{declared here}} expected-note{{add initialization}} + (void)typeid(*a); // expected-warning{{variable 'a' is uninitialized when used here }} +} + // Handle cases where the CFG may constant fold some branches, thus // mitigating the need for some path-sensitivity in the analysis. unsigned test3_aux(); @@ -38,7 +55,7 @@ unsigned test3_c() { if (flag && (x = test3_aux()) == 0) { x = 1; } - return x; // expected-warning{{variable 'x' is possibly uninitialized when used here}} + return x; // expected-warning{{variable 'x' is uninitialized when used here}} } enum test4_A { @@ -46,6 +63,49 @@ enum test4_A { }; test4_A test4() { test4_A a; // expected-note{{variable 'a' is declared here}} - return a; // expected-warning{{variable 'a' is possibly uninitialized when used here}} + return a; // expected-warning{{variable 'a' is uninitialized when used here}} } +// This test previously crashed Sema. +class Rdar9188004A { +public: + virtual ~Rdar9188004A(); +}; + +template< typename T > class Rdar9188004B : public Rdar9188004A { +virtual double *foo(Rdar9188004B *next) const { + double *values = next->foo(0); + try { + } + catch(double e) { + values[0] = e; + } + return 0; + } +}; +class Rdar9188004C : public Rdar9188004B<Rdar9188004A> { + virtual void bar(void) const; +}; +void Rdar9188004C::bar(void) const {} + +// Don't warn about uninitialized variables in unreachable code. +void PR9625() { + if (false) { + int x; + (void)static_cast<float>(x); // no-warning + } +} + +// Don't warn about variables declared in "catch" +void RDar9251392_bar(const char *msg); + +void RDar9251392() { + try { + throw "hi"; + } + catch (const char* msg) { + RDar9251392_bar(msg); // no-warning + } +} + + diff --git a/test/SemaCXX/uninitialized.cpp b/test/SemaCXX/uninitialized.cpp index 26202fb..0a3b5d9 100644 --- a/test/SemaCXX/uninitialized.cpp +++ b/test/SemaCXX/uninitialized.cpp @@ -1,14 +1,45 @@ // RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -verify %s -// Previously this triggered a warning on the sizeof(fieldB), indicating -// a use of an uninitialized value. -class Rdar8610363_A { - int fieldA; -public: - Rdar8610363_A(int a); -}; -class Rdar8610363_B { - Rdar8610363_A fieldB; -public: - Rdar8610363_B(int b) : fieldB(sizeof(fieldB)) {} // no-warning +int foo(int x); +int bar(int* x); +int boo(int& x); +int far(const int& x); + +// Test self-references within initializers which are guaranteed to be +// uninitialized. +int a = a; // no-warning: used to signal intended lack of initialization. +int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} +int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}} +void test() { + int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} +} +int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} +int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} + +// Thes don't warn as they don't require the value. +int g = sizeof(g); +void* ptr = &ptr; +int h = bar(&h); +int i = boo(i); +int j = far(j); +int k = __alignof__(k); + +// Also test similar constructs in a field's initializer. +struct S { + int x; + void *ptr; + + S(bool (*)[1]) : x(x) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[3]) : x(x + x) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[5]) : x(foo(x)) {} // FIXME: This should warn! + + // These don't actually require the value of x and so shouldn't warn. + S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363 + S(char (*)[2]) : ptr(&ptr) {} + S(char (*)[3]) : x(__alignof__(x)) {} + S(char (*)[4]) : x(bar(&x)) {} + S(char (*)[5]) : x(boo(x)) {} + S(char (*)[6]) : x(far(x)) {} }; diff --git a/test/SemaCXX/unknown-anytype.cpp b/test/SemaCXX/unknown-anytype.cpp new file mode 100644 index 0000000..b0a2981 --- /dev/null +++ b/test/SemaCXX/unknown-anytype.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -funknown-anytype -fsyntax-only -verify %s + +namespace test0 { + extern __unknown_anytype test0; + extern __unknown_anytype test1(); + extern __unknown_anytype test2(int); +} + +namespace test1 { + extern __unknown_anytype foo; + int test() { + // TODO: it would be great if the 'cannot initialize' errors + // turned into something more interesting. It's just a matter of + // making sure that these locations check for placeholder types + // properly. + + int x = foo; // expected-error {{cannot initialize}} + int y = 0 + foo; // expected-error {{'foo' has unknown type}} + return foo; // expected-error {{cannot initialize}} + } +} + +namespace test2 { + extern __unknown_anytype foo(); + void test() { + foo(); // expected-error {{'foo' has unknown return type}} + } +} + +namespace test3 { + extern __unknown_anytype foo; + void test() { + foo(); // expected-error {{call to unsupported expression with unknown type}} + ((void(void)) foo)(); // expected-error {{variable 'foo' with unknown type cannot be given a function type}} + } +} diff --git a/test/SemaCXX/unreachable-catch-clauses.cpp b/test/SemaCXX/unreachable-catch-clauses.cpp index e8158d4..c75067f 100644 --- a/test/SemaCXX/unreachable-catch-clauses.cpp +++ b/test/SemaCXX/unreachable-catch-clauses.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s class BaseEx {}; class Ex1: public BaseEx {}; diff --git a/test/SemaCXX/unreachable-code.cpp b/test/SemaCXX/unreachable-code.cpp index 03d44ab..743290e 100644 --- a/test/SemaCXX/unreachable-code.cpp +++ b/test/SemaCXX/unreachable-code.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fexceptions -fsyntax-only -Wunreachable-code -fblocks -verify %s +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -Wunreachable-code -fblocks -verify %s int j; void bar() { } diff --git a/test/SemaCXX/unused-functions.cpp b/test/SemaCXX/unused-functions.cpp index cefa9e1..f164bf2 100644 --- a/test/SemaCXX/unused-functions.cpp +++ b/test/SemaCXX/unused-functions.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -Wunused -verify %s +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -Wunused -verify %s static int foo(int x) { return x; } @@ -6,3 +6,5 @@ template<typename T> T get_from_foo(T y) { return foo(y); } int g(int z) { return get_from_foo(z); } + +namespace { void f() = delete; } diff --git a/test/SemaCXX/vtable-instantiation.cc b/test/SemaCXX/vtable-instantiation.cc index 5a13d95..49949a7 100644 --- a/test/SemaCXX/vtable-instantiation.cc +++ b/test/SemaCXX/vtable-instantiation.cc @@ -18,3 +18,29 @@ void f() { c2.c2(); // expected-note {{in instantiation of member function}} } +namespace PR9325 { + template<typename T> + class Target + { + public: + virtual T Value() const + { + return 1; // expected-error{{cannot initialize return object of type 'int *' with an rvalue of type 'int'}} + } + }; + + template<typename T> + struct Provider + { + static Target<T> Instance; + }; + + template<typename T> + Target<T> Provider<T>::Instance; // expected-note{{in instantiation of}} + + void f() + { + Target<int*>* traits = &Provider<int*>::Instance; + } + +} diff --git a/test/SemaCXX/warn-assignment-condition.cpp b/test/SemaCXX/warn-assignment-condition.cpp index 27eedb9..c0ef35b 100644 --- a/test/SemaCXX/warn-assignment-condition.cpp +++ b/test/SemaCXX/warn-assignment-condition.cpp @@ -125,3 +125,16 @@ void test2() { if ((test2 == fn)) {} } +namespace rdar9027658 { +template <typename T> +void f() { + if ((T::g == 3)) { } // expected-warning {{equality comparison with extraneous parentheses}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} \ + // expected-note {{remove extraneous parentheses around the comparison to silence this warning}} +} + +struct S { int g; }; +void test() { + f<S>(); // expected-note {{in instantiation}} +} +} diff --git a/test/SemaCXX/warn-bool-conversion.cpp b/test/SemaCXX/warn-bool-conversion.cpp new file mode 100644 index 0000000..f6fa9f2 --- /dev/null +++ b/test/SemaCXX/warn-bool-conversion.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int* j = false; // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} + +void foo(int* i, int *j=(false)) // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} +{ + foo(false); // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} + foo((int*)false); // no-warning: explicit cast + foo(0); // no-warning: not a bool, even though its convertible to bool + + foo(false == true); // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} + foo((42 + 24) < 32); // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} + + const bool kFlag = false; + foo(kFlag); // expected-warning{{ initialization of pointer of type 'int *' to NULL from a constant boolean expression}} +} + +char f(struct Undefined*); +double f(...); + +// Ensure that when using false in metaprogramming machinery its conversion +// isn't flagged. +template <int N> struct S {}; +S<sizeof(f(false))> s; diff --git a/test/SemaCXX/warn-deprecated-header.cpp b/test/SemaCXX/warn-deprecated-header.cpp new file mode 100644 index 0000000..f6ac2cb --- /dev/null +++ b/test/SemaCXX/warn-deprecated-header.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -fdeprecated-macro -verify %s +// RUN: %clang_cc1 -fsyntax-only -Werror %s + +#ifdef __DEPRECATED +#warning This file is deprecated. // expected-warning {{This file is deprecated.}} +#endif diff --git a/test/SemaCXX/warn-exit-time-destructors.cpp b/test/SemaCXX/warn-exit-time-destructors.cpp new file mode 100644 index 0000000..f49134b --- /dev/null +++ b/test/SemaCXX/warn-exit-time-destructors.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -fsyntax-only -Wexit-time-destructors %s -verify + +namespace test1 { + struct A { ~A(); }; + A a; // expected-warning {{declaration requires an exit-time destructor}} + A b[10]; // expected-warning {{declaration requires an exit-time destructor}} + A c[10][10]; // expected-warning {{declaration requires an exit-time destructor}} + + A &d = a; + A &e = b[5]; + A &f = c[5][7]; +} + +namespace test2 { +void f() { + struct A { ~A() { } }; + + static A a; // expected-warning {{declaration requires an exit-time destructor}} + static A b[10]; // expected-warning {{declaration requires an exit-time destructor}} + static A c[10][10]; // expected-warning {{declaration requires an exit-time destructor}} + + static A &d = a; + static A &e = b[5]; + static A &f = c[5][7]; +} + +} diff --git a/test/SemaCXX/warn-global-constructors.cpp b/test/SemaCXX/warn-global-constructors.cpp index ad60954..6330958 100644 --- a/test/SemaCXX/warn-global-constructors.cpp +++ b/test/SemaCXX/warn-global-constructors.cpp @@ -53,8 +53,8 @@ namespace test3 { namespace test4 { char a[] = "hello"; - char b[5] = "hello"; - char c[][5] = { "hello" }; + char b[6] = "hello"; + char c[][6] = { "hello" }; } namespace test5 { diff --git a/test/SemaCXX/warn-literal-conversion.cpp b/test/SemaCXX/warn-literal-conversion.cpp index dab5c01..b9c9528 100644 --- a/test/SemaCXX/warn-literal-conversion.cpp +++ b/test/SemaCXX/warn-literal-conversion.cpp @@ -8,13 +8,18 @@ void test0() { int y0 = 1.2222F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} int y1 = (1.2222F); // expected-warning {{implicit conversion turns literal floating-point number into integer}} int y2 = (((1.2222F))); // expected-warning {{implicit conversion turns literal floating-point number into integer}} - int y3 = 12E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} - int y4 = 1.2E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y3 = 12E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} \ + // expected-note {{this can be rewritten as an integer literal with the exact same value}} + int y4 = 1.2E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} \ + // expected-note {{this can be rewritten as an integer literal with the exact same value}} // Double int y5 = 1.2222; // expected-warning {{implicit conversion turns literal floating-point number into integer}} - int y6 = 12E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} - int y7 = 1.2E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} - int y8 = (1.2E1); // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y6 = 12E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} \ + // expected-note {{this can be rewritten as an integer literal with the exact same value}} + int y7 = 1.2E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} \ + // expected-note {{this can be rewritten as an integer literal with the exact same value}} + int y8 = (1.2E1); // expected-warning {{implicit conversion turns literal floating-point number into integer}} \ + // expected-note {{this can be rewritten as an integer literal with the exact same value}} // Test assignment to an existing variable. y8 = 2.22F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} diff --git a/test/SemaCXX/warn-missing-prototypes.cpp b/test/SemaCXX/warn-missing-prototypes.cpp index b6ebe82..f7e8db3 100644 --- a/test/SemaCXX/warn-missing-prototypes.cpp +++ b/test/SemaCXX/warn-missing-prototypes.cpp @@ -24,3 +24,9 @@ template<typename> void h() { } // Don't warn when instantiating function templates. template void h<int>(); + +// PR9519: don't warn about friend functions. +class I { + friend void I_friend() {} +}; + diff --git a/test/SemaCXX/warn-non-pod-memset.cpp b/test/SemaCXX/warn-non-pod-memset.cpp new file mode 100644 index 0000000..fbdcead --- /dev/null +++ b/test/SemaCXX/warn-non-pod-memset.cpp @@ -0,0 +1,63 @@ +// RUN: %clang_cc1 -fsyntax-only -Wnon-pod-memset -verify %s + +extern void *memset(void *, int, unsigned); + +// Several POD types that should not warn. +struct S1 {} s1; +struct S2 { int x; } s2; +struct S3 { float x, y; S1 s[4]; void (*f)(S1**); } s3; + +// We use the C++11 concept of POD for this warning, so ensure a non-aggregate +// still warns. +class C1 { + int x, y, z; +public: + void foo() {} +} c1; + +// Non-POD types that should warn. +struct X1 { X1(); } x1; +struct X2 { ~X2(); } x2; +struct X3 { virtual void f(); } x3; +struct X4 : X2 {} x4; +struct X5 : virtual S1 {} x5; + +void test_warn() { + memset(&x1, 0, sizeof x1); // \ + // expected-warning {{destination for this memset call is a pointer to a non-POD type}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memset(&x2, 0, sizeof x2); // \ + // expected-warning {{destination for this memset call is a pointer to a non-POD type}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memset(&x3, 0, sizeof x3); // \ + // expected-warning {{destination for this memset call is a pointer to a non-POD type}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memset(&x4, 0, sizeof x4); // \ + // expected-warning {{destination for this memset call is a pointer to a non-POD type}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memset(&x5, 0, sizeof x5); // \ + // expected-warning {{destination for this memset call is a pointer to a non-POD type}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} +} + +void test_nowarn(void *void_ptr) { + int i, *iptr; + float y; + char c; + + memset(&i, 0, sizeof i); + memset(&iptr, 0, sizeof iptr); + memset(&y, 0, sizeof y); + memset(&c, 0, sizeof c); + memset(void_ptr, 0, 42); + memset(&s1, 0, sizeof s1); + memset(&s2, 0, sizeof s2); + memset(&s3, 0, sizeof s3); + memset(&c1, 0, sizeof c1); + + // Unevaluated code shouldn't warn. + (void)sizeof memset(&x1, 0, sizeof x1); + + // Dead code shouldn't warn. + if (false) memset(&x1, 0, sizeof x1); +} diff --git a/test/SemaCXX/warn-overloaded-virtual.cpp b/test/SemaCXX/warn-overloaded-virtual.cpp index 86b1d23..8e2b671 100644 --- a/test/SemaCXX/warn-overloaded-virtual.cpp +++ b/test/SemaCXX/warn-overloaded-virtual.cpp @@ -52,3 +52,15 @@ struct Derived : public Base { void foo(int, int); }; } + +namespace PR9396 { +class A { +public: + virtual void f(int) {} +}; + +class B : public A { +public: + static void f() {} +}; +} diff --git a/test/SemaCXX/warn-shadow.cpp b/test/SemaCXX/warn-shadow.cpp index 3bf9af4..68e9467 100644 --- a/test/SemaCXX/warn-shadow.cpp +++ b/test/SemaCXX/warn-shadow.cpp @@ -70,3 +70,14 @@ struct S { } }; } + +extern int bob; // expected-note {{previous declaration is here}} + +// rdar://8883302 +void rdar8883302() { + extern int bob; // don't warn for shadowing. +} + +void test8() { + int bob; // expected-warning {{declaration shadows a variable in the global namespace}} +} diff --git a/test/SemaCXX/warn-unreachable.cpp b/test/SemaCXX/warn-unreachable.cpp index 3c8a429..ea6755f 100644 --- a/test/SemaCXX/warn-unreachable.cpp +++ b/test/SemaCXX/warn-unreachable.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fexceptions -fsyntax-only -verify -fblocks -Wunreachable-code -Wno-unused-value +// RUN: %clang_cc1 %s -fcxx-exceptions -fexceptions -fsyntax-only -verify -fblocks -Wunreachable-code -Wno-unused-value int &halt() __attribute__((noreturn)); int &live(); diff --git a/test/SemaCXX/warn-unused-filescoped.cpp b/test/SemaCXX/warn-unused-filescoped.cpp index c32acb0..dbff4b0 100644 --- a/test/SemaCXX/warn-unused-filescoped.cpp +++ b/test/SemaCXX/warn-unused-filescoped.cpp @@ -78,3 +78,12 @@ namespace test4 { void test(A a); // expected-warning {{unused function}} extern "C" void test4(A a); } + +namespace rdar8733476 { + static void foo() { } // expected-warning {{not needed and will not be emitted}} + + template <int> + void bar() { + foo(); + } +} diff --git a/test/SemaCXX/warn-using-namespace-in-header.cpp b/test/SemaCXX/warn-using-namespace-in-header.cpp new file mode 100644 index 0000000..72c2552 --- /dev/null +++ b/test/SemaCXX/warn-using-namespace-in-header.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -fsyntax-only -Wheader-hygiene -verify %s + +#include "warn-using-namespace-in-header.h" + +namespace dont_warn {} +using namespace dont_warn; + +// Warning is actually in the header but only the cpp file gets scanned. +// expected-warning {{using namespace directive in global context in header}} + + + + + + + + + +// Warn inside linkage specs too. +// expected-warning {{using namespace directive in global context in header}} + + + + + + +// expected-warning {{using namespace directive in global context in header}} + + + + + + + + + + + + + + + + + + + + + + +// expected-warning {{using namespace directive in global context in header}} + +// |using namespace| through a macro shouldn't warn if the instantiation is in a +// cc file. +USING_MACRO diff --git a/test/SemaCXX/warn-using-namespace-in-header.h b/test/SemaCXX/warn-using-namespace-in-header.h new file mode 100644 index 0000000..b544c54 --- /dev/null +++ b/test/SemaCXX/warn-using-namespace-in-header.h @@ -0,0 +1,50 @@ + + + + + +// Lots of vertical space to make the error line match up with the line of the +// expected line in the source file. +namespace warn_in_header_in_global_context {} +using namespace warn_in_header_in_global_context; + +// While we want to error on the previous using directive, we don't when we are +// inside a namespace +namespace dont_warn_here { +using namespace warn_in_header_in_global_context; +} + +// We should warn in toplevel extern contexts. +namespace warn_inside_linkage {} +extern "C++" { +using namespace warn_inside_linkage; +} + +// This is really silly, but we should warn on it: +extern "C++" { +extern "C" { +extern "C++" { +using namespace warn_inside_linkage; +} +} +} + +// But we shouldn't warn in extern contexts inside namespaces. +namespace dont_warn_here { +extern "C++" { +using namespace warn_in_header_in_global_context; +} +} + +// We also shouldn't warn in case of functions. +inline void foo() { + using namespace warn_in_header_in_global_context; +} + + +namespace macronamespace {} +#define USING_MACRO using namespace macronamespace; + +// |using namespace| through a macro should warn if the instantiation is in a +// header. +USING_MACRO diff --git a/test/SemaCXX/warn_false_to_pointer.cpp b/test/SemaCXX/warn_false_to_pointer.cpp deleted file mode 100644 index fb6f955..0000000 --- a/test/SemaCXX/warn_false_to_pointer.cpp +++ /dev/null @@ -1,10 +0,0 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s - -int* j = false; // expected-warning{{ initialization of pointer of type 'int *' from literal 'false'}} - -void foo(int* i, int *j=(false)) // expected-warning{{ initialization of pointer of type 'int *' from literal 'false'}} -{ - foo(false); // expected-warning{{ initialization of pointer of type 'int *' from literal 'false'}} - foo((int*)false); -} - diff --git a/test/SemaCXX/writable-strings-deprecated.cpp b/test/SemaCXX/writable-strings-deprecated.cpp index c89c882..8295401 100644 --- a/test/SemaCXX/writable-strings-deprecated.cpp +++ b/test/SemaCXX/writable-strings-deprecated.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -Wno-deprecated-writable-strings -verify %s +// RUN: %clang_cc1 -fsyntax-only -fwritable-strings -verify %s +// RUN: %clang_cc1 -fsyntax-only -Wno-write-strings -verify %s // rdar://8827606 char *fun(void) |