diff options
Diffstat (limited to 'clang/test/SemaCXX')
423 files changed, 34722 insertions, 0 deletions
diff --git a/clang/test/SemaCXX/2008-01-11-BadWarning.cpp b/clang/test/SemaCXX/2008-01-11-BadWarning.cpp new file mode 100644 index 0000000..b84e7c1 --- /dev/null +++ b/clang/test/SemaCXX/2008-01-11-BadWarning.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wall %s +// rdar://5683899 +void** f(void **Buckets, unsigned NumBuckets) { + return Buckets + NumBuckets; +} diff --git a/clang/test/SemaCXX/Inputs/array-bounds-system-header.h b/clang/test/SemaCXX/Inputs/array-bounds-system-header.h new file mode 100644 index 0000000..07cde80 --- /dev/null +++ b/clang/test/SemaCXX/Inputs/array-bounds-system-header.h @@ -0,0 +1,11 @@ +// "System header" for testing that -Warray-bounds is properly suppressed in +// certain cases. + +#define BAD_MACRO_1 \ + int i[3]; \ + i[3] = 5 +#define BAD_MACRO_2(_b, _i) \ + (_b)[(_i)] = 5 +#define QUESTIONABLE_MACRO(_a) \ + sizeof(_a) > 3 ? (_a)[3] = 5 : 5 +#define NOP(x) (x) diff --git a/clang/test/SemaCXX/Inputs/lit.local.cfg b/clang/test/SemaCXX/Inputs/lit.local.cfg new file mode 100644 index 0000000..e6f55ee --- /dev/null +++ b/clang/test/SemaCXX/Inputs/lit.local.cfg @@ -0,0 +1 @@ +config.suffixes = [] diff --git a/clang/test/SemaCXX/Inputs/malloc.h b/clang/test/SemaCXX/Inputs/malloc.h new file mode 100644 index 0000000..c54d621 --- /dev/null +++ b/clang/test/SemaCXX/Inputs/malloc.h @@ -0,0 +1,3 @@ +extern "C" { +extern void *malloc (__SIZE_TYPE__ __size) throw () __attribute__ ((__malloc__)) ; +} diff --git a/clang/test/SemaCXX/Inputs/warn-new-overaligned-3.h b/clang/test/SemaCXX/Inputs/warn-new-overaligned-3.h new file mode 100644 index 0000000..d2bd4d5 --- /dev/null +++ b/clang/test/SemaCXX/Inputs/warn-new-overaligned-3.h @@ -0,0 +1,19 @@ +#pragma GCC system_header + +// This header file pretends to be <new> from the system library, for the +// purpose of the over-aligned warnings test. + +void* operator new(unsigned long) { + return 0; +} +void* operator new[](unsigned long) { + return 0; +} + +void* operator new(unsigned long, void *) { + return 0; +} + +void* operator new[](unsigned long, void *) { + return 0; +} diff --git a/clang/test/SemaCXX/MicrosoftCompatibility-cxx98.cpp b/clang/test/SemaCXX/MicrosoftCompatibility-cxx98.cpp new file mode 100644 index 0000000..0c7d354 --- /dev/null +++ b/clang/test/SemaCXX/MicrosoftCompatibility-cxx98.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++98 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions + + +//MSVC allows forward enum declaration +enum ENUM; // expected-warning {{forward references to 'enum' types are a Microsoft extension}} +ENUM *var = 0; +ENUM var2 = (ENUM)3; +enum ENUM1* var3 = 0;// expected-warning {{forward references to 'enum' types are a Microsoft extension}} diff --git a/clang/test/SemaCXX/MicrosoftCompatibility.cpp b/clang/test/SemaCXX/MicrosoftCompatibility.cpp new file mode 100644 index 0000000..3634fa3 --- /dev/null +++ b/clang/test/SemaCXX/MicrosoftCompatibility.cpp @@ -0,0 +1,176 @@ +// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions + + + +namespace ms_conversion_rules { + +void f(float a); +void f(int a); + +void test() +{ + long a = 0; + f((long)0); + f(a); +} + +} + + + +namespace ms_protected_scope { + struct C { C(); }; + + int jump_over_variable_init(bool b) { + if (b) + goto foo; // expected-warning {{goto into protected scope}} + C c; // expected-note {{jump bypasses variable initialization}} + foo: + return 1; + } + +struct Y { + ~Y(); +}; + +void jump_over_var_with_dtor() { + goto end; // expected-warning{{goto into protected scope}} + Y y; // expected-note {{jump bypasses variable with a non-trivial destructor}} + end: + ; +} + + void jump_over_variable_case(int c) { + switch (c) { + case 0: + int x = 56; // expected-note {{jump bypasses variable initialization}} + case 1: // expected-error {{switch case is in protected scope}} + x = 10; + } + } + + +void exception_jump() { + goto l2; // expected-error {{goto into protected scope}} + try { // expected-note {{jump bypasses initialization of try block}} + l2: ; + } catch(int) { + } +} + +int jump_over_indirect_goto() { + static void *ps[] = { &&a0 }; + goto *&&a0; // expected-warning {{goto into protected scope}} + int a = 3; // expected-note {{jump bypasses variable initialization}} + a0: + return 0; +} + +} + +namespace PR11826 { + struct pair { + pair(int v) { } + void operator=(pair&& rhs) { } + }; + void f() { + pair p0(3); + pair p = p0; + } +} + +namespace PR11826_for_symmetry { + struct pair { + pair(int v) { } + pair(pair&& rhs) { } + }; + void f() { + pair p0(3); + pair p(4); + p = p0; + } +} + +namespace ms_using_declaration_bug { + +class A { +public: + int f(); +}; + +class B : public A { +private: + using A::f; +}; + +class C : public B { +private: + using B::f; // expected-warning {{using declaration referring to inaccessible member 'ms_using_declaration_bug::B::f' (which refers to accessible member 'ms_using_declaration_bug::A::f') is a Microsoft compatibility extension}} +}; + +} + + +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}} + }; + +class D { +public: + typedef int Type; +}; + +template <class T> +void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}} +{ + const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}} +} + +template void function_missing_typename<D>(const D::Type param); + +} + +enum ENUM2 { + ENUM2_a = (enum ENUM2) 4, + ENUM2_b = 0x9FFFFFFF, // expected-warning {{enumerator value is not representable in the underlying type 'int'}} + ENUM2_c = 0x100000000 // expected-warning {{enumerator value is not representable in the underlying type 'int'}} +}; + + +namespace PR11791 { + template<class _Ty> + void del(_Ty *_Ptr) { + _Ptr->~_Ty(); // expected-warning {{pseudo-destructors on type void are a Microsoft extension}} + } + + void f() { + int* a = 0; + del((void*)a); // expected-note {{in instantiation of function template specialization}} + } +} diff --git a/clang/test/SemaCXX/MicrosoftExtensions.cpp b/clang/test/SemaCXX/MicrosoftExtensions.cpp new file mode 100644 index 0000000..0b72cd3 --- /dev/null +++ b/clang/test/SemaCXX/MicrosoftExtensions.cpp @@ -0,0 +1,205 @@ +// 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); + + +// Microsoft doesn't validate exception specification. +namespace microsoft_exception_spec { + +void foo(); // expected-note {{previous declaration}} +void foo() throw(); // expected-warning {{exception specification in declaration does not match previous declaration}} + +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(); + virtual void f3() throw(...); +}; + +struct Derived : Base { + virtual void f2() throw(...); + virtual void f3(); +}; + +class A { + virtual ~A() throw(); // expected-note {{overridden virtual function is here}} +}; + +class B : public A { + virtual ~B(); // expected-warning {{exception specification of overriding function is more lax than base version}} +}; + +} + +// MSVC allows type definition in anonymous union and struct +struct A +{ + union + { + int a; + struct B // expected-warning {{types declared in an anonymous union are a Microsoft extension}} + { + int c; + } d; + + union C // expected-warning {{types declared in an anonymous union are a Microsoft extension}} + { + int e; + int ee; + } f; + + typedef int D; // expected-warning {{types declared in an anonymous union are a Microsoft extension}} + struct F; // expected-warning {{types declared in an anonymous union are a Microsoft extension}} + }; + + struct + { + int a2; + + struct B2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} + { + int c2; + } d2; + + union C2 // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} + { + int e2; + int ee2; + } f2; + + typedef int D2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} + struct F2; // expected-warning {{types declared in an anonymous struct are a Microsoft extension}} + }; +}; + +// __stdcall handling +struct M { + int __stdcall addP(); + float __stdcall subtractP(); +}; + +// __unaligned handling +typedef char __unaligned *aligned_type; + + +template<typename T> void h1(T (__stdcall M::* const )()) { } + +void m1() { + h1<int>(&M::addP); + h1(&M::subtractP); +} + + + + + +void f(long long); +void f(int); + +int main() +{ + // This is an ambiguous call in standard C++. + // This calls f(long long) in Microsoft mode because LL is always signed. + f(0xffffffffffffffffLL); + f(0xffffffffffffffffi64); +} + +// Enumeration types with a fixed underlying type. +const int seventeen = 17; +typedef int Int; + +struct X0 { + enum E1 : Int { SomeOtherValue } field; // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}} + enum E1 : seventeen; +}; + +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}} + + + +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}} +{ + +} + +long function_prototype(int a); +long (*function_ptr)(int a); + +void function_to_voidptr_conv() { + void *a1 = function_prototype; + void *a2 = &function_prototype; + void *a3 = function_ptr; +} + + +void pointer_to_integral_type_conv(char* ptr) { + char ch = (char)ptr; + short sh = (short)ptr; + ch = (char)ptr; + sh = (short)ptr; +} + + +namespace friend_as_a_forward_decl { + +class A { + class Nested { + friend class B; + B* b; + }; + B* b; +}; +B* global_b; + + +void f() +{ + class Local { + friend class Z; + Z* b; + }; + Z* b; +} + +} + +struct PR11150 { + class X { + virtual void f() = 0; + }; + + int array[__is_abstract(X)? 1 : -1]; +}; + +void f() { int __except = 0; } + diff --git a/clang/test/SemaCXX/PR10177.cpp b/clang/test/SemaCXX/PR10177.cpp new file mode 100644 index 0000000..8d745de --- /dev/null +++ b/clang/test/SemaCXX/PR10177.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +template<typename T, typename U, U> using alias_ref = T; +template<typename T, typename U, U> void func_ref() {} +template<typename T, typename U, U> struct class_ref {}; + +template<int N> +struct U { + static int a; +}; + +template<int N> struct S; // expected-note 2{{here}} + +template<int N> +int U<N>::a = S<N>::kError; // expected-error 2{{undefined}} + +template<typename T> +void f() { + // FIXME: The standard suggests that U<0>::a is odr-used by this expression, + // but it's not entirely clear that's the right behaviour. + (void)alias_ref<int, int&, U<0>::a>(); + (void)func_ref<int, int&, U<1>::a>(); // expected-note {{here}} + (void)class_ref<int, int&, U<2>::a>(); // expected-note {{here}} +}; + +int main() { + f<int>(); // expected-note 2{{here}} +} + +namespace N { + template<typename T> struct S { static int n; }; + template<typename T> int S<T>::n = 5; + void g(int*); + template<typename T> int f() { + int k[S<T>::n]; + g(k); + return k[3]; + } + int j = f<int>(); +} diff --git a/clang/test/SemaCXX/PR10243.cpp b/clang/test/SemaCXX/PR10243.cpp new file mode 100644 index 0000000..129ff80 --- /dev/null +++ b/clang/test/SemaCXX/PR10243.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +struct S; // expected-note 4{{forward declaration of 'S'}} + +struct T0 { + S s; // expected-error{{field has incomplete type 'S'}} + T0() = default; +}; + +struct T1 { + S s; // expected-error{{field has incomplete type 'S'}} + T1(T1&) = default; +}; + +struct T2 { + S s; // expected-error{{field has incomplete type 'S'}} + T2& operator=(T2&) = default; +}; + +struct T3 { + S s; // expected-error{{field has incomplete type 'S'}} + ~T3() = default; +}; diff --git a/clang/test/SemaCXX/PR10447.cpp b/clang/test/SemaCXX/PR10447.cpp new file mode 100644 index 0000000..08644ad --- /dev/null +++ b/clang/test/SemaCXX/PR10447.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -verify %s + +// PR12223 +namespace test1 { + namespace N { + extern "C" void f(struct S*); + void g(S*); + } + namespace N { + void f(struct S *s) { + g(s); + } + } +} + +// PR10447 +namespace test2 { + extern "C" { + void f(struct Bar*) { } + test2::Bar *ptr; + } +} diff --git a/clang/test/SemaCXX/PR10458.cpp b/clang/test/SemaCXX/PR10458.cpp new file mode 100644 index 0000000..57588eb --- /dev/null +++ b/clang/test/SemaCXX/PR10458.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98 + +void f() { + int arr[] = { 1, 2, 3 }; + for (auto &i : arr) { // expected-warning {{'auto' type specifier is a C++11 extension}} expected-warning {{range-based for loop is a C++11 extension}} + } +} diff --git a/clang/test/SemaCXX/PR11358.cpp b/clang/test/SemaCXX/PR11358.cpp new file mode 100644 index 0000000..9c49227 --- /dev/null +++ b/clang/test/SemaCXX/PR11358.cpp @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 %s -verify +// PR11358 + +namespace test1 { + template<typename T> + struct container { + class iterator {}; + iterator begin() { return iterator(); } + }; + + template<typename T> + struct Test { + typedef container<T> Container; + void test() { + Container::iterator i = c.begin(); // expected-error{{missing 'typename'}} + } + Container c; + }; +} + +namespace test2 { + template <typename Key, typename Value> + class hash_map { + class const_iterator { void operator++(); }; + const_iterator begin() const; + const_iterator end() const; + }; + + template <typename KeyType, typename ValueType> + void MapTest(hash_map<KeyType, ValueType> map) { + for (hash_map<KeyType, ValueType>::const_iterator it = map.begin(); // expected-error{{missing 'typename'}} + it != map.end(); it++) { + } + } +} + +namespace test3 { + template<typename T> + struct container { + class iterator {}; + }; + + template<typename T> + struct Test { + typedef container<T> Container; + void test() { + Container::iterator const i; // expected-error{{missing 'typename'}} + } + Container c; + }; +} diff --git a/clang/test/SemaCXX/PR12481.cpp b/clang/test/SemaCXX/PR12481.cpp new file mode 100644 index 0000000..9487e4d --- /dev/null +++ b/clang/test/SemaCXX/PR12481.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -x c++ -fsyntax-only %s + +class C1 { }; +class C2 { }; +template<class TrieData> struct BinaryTrie { + ~BinaryTrie() { + (void)(({ + static int x = 5; + } + )); + } +}; +class FooTable { + BinaryTrie<C1> c1_trie_; + BinaryTrie<C2> c2_trie_; +}; +FooTable* foo = new FooTable; diff --git a/clang/test/SemaCXX/PR5086-ambig-resolution-enum.cpp b/clang/test/SemaCXX/PR5086-ambig-resolution-enum.cpp new file mode 100644 index 0000000..b5aac5f --- /dev/null +++ b/clang/test/SemaCXX/PR5086-ambig-resolution-enum.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +class C { +public: + enum E { e1=0 }; + const char * fun1(int , enum E) const; + int fun1(unsigned, const char *) const; +}; + +void foo(const C& rc) { + enum {BUFLEN = 128 }; + const char *p = rc.fun1(BUFLEN - 2, C::e1); +} diff --git a/clang/test/SemaCXX/PR6562.cpp b/clang/test/SemaCXX/PR6562.cpp new file mode 100644 index 0000000..854d9b0 --- /dev/null +++ b/clang/test/SemaCXX/PR6562.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct X { ~X(); }; +template <typename T> +struct A { + struct B { X x; }; + struct C : public B { + C() : B() { } + }; +}; diff --git a/clang/test/SemaCXX/PR6618.cpp b/clang/test/SemaCXX/PR6618.cpp new file mode 100644 index 0000000..10d4dc8 --- /dev/null +++ b/clang/test/SemaCXX/PR6618.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class bar; // expected-note {{forward declaration of 'bar'}} +struct zed { + bar g; // expected-error {{field has incomplete type}} +}; +class baz { + zed h; +}; +void f() { + enum { + e = sizeof(baz) + }; +} diff --git a/clang/test/SemaCXX/PR7410.cpp b/clang/test/SemaCXX/PR7410.cpp new file mode 100644 index 0000000..6d2cda9 --- /dev/null +++ b/clang/test/SemaCXX/PR7410.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct BaseReturn {}; + +struct Base { + virtual BaseReturn Foo() = 0; // expected-note{{overridden virtual function is here}} +}; +struct X {}; +struct Derived : Base { + X Foo(); // expected-error{{virtual function 'Foo' has a different return type ('X') than the function it overrides (which has return type 'BaseReturn')}} +}; + +Derived d; diff --git a/clang/test/SemaCXX/PR7944.cpp b/clang/test/SemaCXX/PR7944.cpp new file mode 100644 index 0000000..51b3f6b --- /dev/null +++ b/clang/test/SemaCXX/PR7944.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR7944 + +#define MACRO(x) x + +struct B { int f() { return 0; } }; +struct A { B* b() { return new B; } }; + +void g() { + A a; + MACRO(a.b->f()); // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} +} diff --git a/clang/test/SemaCXX/PR8012.cpp b/clang/test/SemaCXX/PR8012.cpp new file mode 100644 index 0000000..9cfc2b0 --- /dev/null +++ b/clang/test/SemaCXX/PR8012.cpp @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +void foo (int operator+); // expected-error{{cannot be the name of a parameter}} diff --git a/clang/test/SemaCXX/PR8385.cpp b/clang/test/SemaCXX/PR8385.cpp new file mode 100644 index 0000000..77a117a --- /dev/null +++ b/clang/test/SemaCXX/PR8385.cpp @@ -0,0 +1,7 @@ +// RUN: not %clang_cc1 -fsyntax-only %s + +// don't crash on this, but don't constrain our diagnostics here as they're +// currently rather poor (we even accept things like "template struct {}"). +// Other, explicit tests, should verify the relevant behavior of template +// instantiation. +struct{template struct{ diff --git a/clang/test/SemaCXX/PR8755.cpp b/clang/test/SemaCXX/PR8755.cpp new file mode 100644 index 0000000..07778dd --- /dev/null +++ b/clang/test/SemaCXX/PR8755.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template <typename T> +struct A { + typedef int iterator; // expected-note{{declared here}} +}; + +template <typename T> +void f() { + class A <T> ::iterator foo; // expected-error{{elaborated type refers to a typedef}} +} + +void g() { + f<int>(); // expected-note{{in instantiation of function template}} +} + diff --git a/clang/test/SemaCXX/PR8884.cpp b/clang/test/SemaCXX/PR8884.cpp new file mode 100644 index 0000000..4026465 --- /dev/null +++ b/clang/test/SemaCXX/PR8884.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only %s +extern "C" { + class bar { + friend struct foo; + static struct foo& baz (); + }; + struct foo { + void zed () { + bar::baz(); + } + }; +} diff --git a/clang/test/SemaCXX/PR9459.cpp b/clang/test/SemaCXX/PR9459.cpp new file mode 100644 index 0000000..2b96f34 --- /dev/null +++ b/clang/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() // expected-error {{expected ';' after struct}} expected-error {{requires a type specifier}} +{ts<a>::ap<ae_same<int>::&ae_same<>>::p(a); }; // expected-error {{use of undeclared identifier 'a'}} diff --git a/clang/test/SemaCXX/PR9460.cpp b/clang/test/SemaCXX/PR9460.cpp new file mode 100644 index 0000000..0dd8446 --- /dev/null +++ b/clang/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{ + runtime_error( +basic_string<char> struct{ // expected-error {{cannot combine with previous 'type-name' declaration specifier}} +a(){ // expected-error {{requires a type specifier}} + runtime_error(0); +} +} +); +}; diff --git a/clang/test/SemaCXX/PR9461.cpp b/clang/test/SemaCXX/PR9461.cpp new file mode 100644 index 0000000..beed348 --- /dev/null +++ b/clang/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);}; + +struct system_error:runtime_error{ // expected-note {{to match}} +system_error():time_error("" // expected-error 3 {{expected}} expected-note {{to match}} diff --git a/clang/test/SemaCXX/PR9572.cpp b/clang/test/SemaCXX/PR9572.cpp new file mode 100644 index 0000000..b475b57 --- /dev/null +++ b/clang/test/SemaCXX/PR9572.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class Base { + virtual ~Base(); // expected-note {{implicitly declared private here}} +}; +struct Foo : public Base { // expected-error {{base class 'Base' has private destructor}} + const int kBlah = 3; // expected-warning {{is a C++11 extension}} + Foo(); +}; +struct Bar : public Foo { + Bar() { } // expected-note {{implicit default destructor for 'Foo' first required here}} +}; +struct Baz { + Foo f; + Baz() { } +}; diff --git a/clang/test/SemaCXX/PR9884.cpp b/clang/test/SemaCXX/PR9884.cpp new file mode 100644 index 0000000..ab883c4 --- /dev/null +++ b/clang/test/SemaCXX/PR9884.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class Base { +protected: + Base(int val); +}; + + +class Derived : public Base { +public: + Derived(int val); +}; + + +Derived::Derived(int val) + : Base( val ) +{ +} diff --git a/clang/test/SemaCXX/PR9902.cpp b/clang/test/SemaCXX/PR9902.cpp new file mode 100644 index 0000000..80086e4 --- /dev/null +++ b/clang/test/SemaCXX/PR9902.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +template <class _Tp, class _Up, bool = false> +struct __allocator_traits_rebind +{ +}; + +template <template <class, class...> class _Alloc, class _Tp, class ..._Args, +class _Up> +struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> +{ + typedef _Alloc<_Up, _Args...> type; +}; + +template <class Alloc> +struct allocator_traits +{ + template <class T> using rebind_alloc = typename __allocator_traits_rebind<Alloc, T>::type; + template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; +}; + +template <class T> +struct allocator {}; + +int main() +{ + allocator_traits<allocator<char>>::rebind_alloc<int> a; +} diff --git a/clang/test/SemaCXX/PR9908.cpp b/clang/test/SemaCXX/PR9908.cpp new file mode 100644 index 0000000..fc090cc --- /dev/null +++ b/clang/test/SemaCXX/PR9908.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +template <class _Tp, class _Up> +struct __allocator_traits_rebind +{ + typedef typename _Tp::template rebind<_Up>::other type; +}; + +template <class Alloc> +struct allocator_traits +{ + typedef Alloc allocator_type; + template <class T> using rebind_alloc = typename +__allocator_traits_rebind<allocator_type, T>::type; + template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; +}; + +template <class T> +struct ReboundA {}; + +template <class T> +struct A +{ + typedef T value_type; + + template <class U> struct rebind {typedef ReboundA<U> other;}; +}; + +int main() +{ + allocator_traits<A<char> >::rebind_traits<double> a; +} diff --git a/clang/test/SemaCXX/__null.cpp b/clang/test/SemaCXX/__null.cpp new file mode 100644 index 0000000..56e59c0 --- /dev/null +++ b/clang/test/SemaCXX/__null.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -Wno-null-conversion -fsyntax-only -verify +// RUN: %clang_cc1 -triple i686-unknown-unknown %s -Wno-null-conversion -fsyntax-only -verify + +void f() { + int* i = __null; + i = __null; + int i2 = __null; + + // Verify statically that __null is the right size + int a[sizeof(typeof(__null)) == sizeof(void*)? 1 : -1]; + + // Verify that null is evaluated as 0. + int b[__null ? -1 : 1]; +} + +struct A {}; + +void g() { + (void)(0 ? __null : A()); // expected-error {{non-pointer operand type 'A' incompatible with NULL}} + (void)(0 ? A(): __null); // expected-error {{non-pointer operand type 'A' incompatible with NULL}} +} diff --git a/clang/test/SemaCXX/__try.cpp b/clang/test/SemaCXX/__try.cpp new file mode 100644 index 0000000..cb5d38a --- /dev/null +++ b/clang/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/clang/test/SemaCXX/abstract.cpp b/clang/test/SemaCXX/abstract.cpp new file mode 100644 index 0000000..b164d9e --- /dev/null +++ b/clang/test/SemaCXX/abstract.cpp @@ -0,0 +1,261 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +#define __CONCAT(__X, __Y) __CONCAT1(__X, __Y) +#define __CONCAT1(__X, __Y) __X ## __Y + +#define static_assert(__b, __m) \ + typedef int __CONCAT(__sa, __LINE__)[__b ? 1 : -1] +#endif + +class C { + virtual void f() = 0; // expected-note {{unimplemented pure virtual method 'f'}} +}; + +static_assert(__is_abstract(C), "C has a pure virtual function"); + +class D : C { +}; + +static_assert(__is_abstract(D), "D inherits from an abstract class"); + +class E : D { + virtual void f(); +}; + +static_assert(!__is_abstract(E), "E inherits from an abstract class but implements f"); + +C *d = new C; // expected-error {{allocating an object of abstract class type 'C'}} + +C c; // expected-error {{variable type 'C' is an abstract class}} +void t1(C c); // expected-error {{parameter type 'C' is an abstract class}} +void t2(C); // expected-error {{parameter type 'C' is an abstract class}} + +struct S { + C c; // expected-error {{field type 'C' is an abstract class}} +}; + +void t3(const C&); + +void f() { + C(); // expected-error {{allocating an object of abstract class type 'C'}} + t3(C()); // expected-error {{allocating an object of abstract class type 'C'}} +} + +C e1[2]; // expected-error {{array of abstract class type 'C'}} +C (*e2)[2]; // expected-error {{array of abstract class type 'C'}} +C (**e3)[2]; // expected-error {{array of abstract class type 'C'}} + +void t4(C c[2]); // expected-error {{array of abstract class type 'C'}} + +void t5(void (*)(C)); // expected-error {{parameter type 'C' is an abstract class}} + +typedef void (*Func)(C); // expected-error {{parameter type 'C' is an abstract class}} +void t6(Func); + +class F { + F a() { while (1) {} } // expected-error {{return type 'F' is an abstract class}} + + class D { + void f(F c); // expected-error {{parameter type 'F' is an abstract class}} + }; + + union U { + void u(F c); // expected-error {{parameter type 'F' is an abstract class}} + }; + + virtual void f() = 0; // expected-note {{unimplemented pure virtual method 'f'}} +}; + +// Diagnosing in these cases is prohibitively expensive. We still +// diagnose at the function definition, of course. + +class Abstract; + +void t7(Abstract a); + +void t8() { + void h(Abstract a); +} + +namespace N { +void h(Abstract a); +} + +class Abstract { + virtual void f() = 0; +}; + +// <rdar://problem/6854087> +class foo { +public: + virtual foo *getFoo() = 0; +}; + +class bar : public foo { +public: + virtual bar *getFoo(); +}; + +bar x; + +// <rdar://problem/6902298> +class A { +public: + virtual void release() = 0; + virtual void release(int count) = 0; + virtual void retain() = 0; +}; + +class B : public A { +public: + virtual void release(); + virtual void release(int count); + virtual void retain(); +}; + +void foo(void) { + B b; +} + +struct K { + int f; + virtual ~K(); +}; + +struct L : public K { + void f(); +}; + +// PR5222 +namespace PR5222 { + struct A { + virtual A *clone() = 0; + }; + struct B : public A { + virtual B *clone() = 0; + }; + struct C : public B { + virtual C *clone(); + }; + + C c; +} + +// PR5550 - instantiating template didn't track overridden methods +namespace PR5550 { + struct A { + virtual void a() = 0; + virtual void b() = 0; + }; + template<typename T> struct B : public A { + virtual void b(); + virtual void c() = 0; + }; + struct C : public B<int> { + virtual void a(); + virtual void c(); + }; + C x; +} + +namespace PureImplicit { + // A pure virtual destructor should be implicitly overridden. + struct A { virtual ~A() = 0; }; + struct B : A {}; + B x; + + // A pure virtual assignment operator should be implicitly overridden. + struct D; + struct C { virtual D& operator=(const D&) = 0; }; + struct D : C {}; + D y; +} + +namespace test1 { + struct A { + virtual void foo() = 0; + }; + + struct B : A { + using A::foo; + }; + + struct C : B { + void foo(); + }; + + void test() { + C c; + } +} + +// rdar://problem/8302168 +namespace test2 { + struct X1 { + virtual void xfunc(void) = 0; // expected-note {{unimplemented pure virtual method}} + void g(X1 parm7); // expected-error {{parameter type 'test2::X1' is an abstract class}} + void g(X1 parm8[2]); // expected-error {{array of abstract class type 'test2::X1'}} + }; + + template <int N> + struct X2 { + virtual void xfunc(void) = 0; // expected-note {{unimplemented pure virtual method}} + void g(X2 parm10); // expected-error {{parameter type 'X2<N>' is an abstract class}} + void g(X2 parm11[2]); // expected-error {{array of abstract class type 'X2<N>'}} + }; +} + +namespace test3 { + struct A { // expected-note {{not complete until}} + A x; // expected-error {{field has incomplete type}} + virtual void abstract() = 0; + }; + + struct B { // expected-note {{not complete until}} + virtual void abstract() = 0; + B x; // expected-error {{field has incomplete type}} + }; + + struct C { + static C x; // expected-error {{abstract class}} + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + }; + + struct D { + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + static D x; // expected-error {{abstract class}} + }; +} + +namespace test4 { + template <class T> struct A { + A x; // expected-error {{abstract class}} + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + }; + + template <class T> struct B { + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + B x; // expected-error {{abstract class}} + }; + + template <class T> struct C { + static C x; // expected-error {{abstract class}} + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + }; + + template <class T> struct D { + virtual void abstract() = 0; // expected-note {{unimplemented pure virtual method}} + static D x; // expected-error {{abstract class}} + }; +} + +// PR9247: Crash on invalid in clang::Sema::ActOnFinishCXXMemberSpecification +namespace pr9247 { + struct A { + virtual void g(const A& input) = 0; + struct B { + C* f(int foo); + }; + }; +} diff --git a/clang/test/SemaCXX/access-base-class.cpp b/clang/test/SemaCXX/access-base-class.cpp new file mode 100644 index 0000000..f676e19 --- /dev/null +++ b/clang/test/SemaCXX/access-base-class.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace T1 { + +class A { }; +class B : private A { }; // expected-note {{declared private here}} + +void f(B* b) { + A *a = b; // expected-error{{cannot cast 'T1::B' to its private base class 'T1::A'}} +} + +} + +namespace T2 { + +class A { }; +class B : A { }; // expected-note {{implicitly declared private here}} + +void f(B* b) { + A *a = b; // expected-error {{cannot cast 'T2::B' to its private base class 'T2::A'}} +} + +} + +namespace T3 { + +class A { }; +class B : public A { }; + +void f(B* b) { + A *a = b; +} + +} + +namespace T4 { + +class A {}; + +class B : private virtual A {}; +class C : public virtual A {}; + +class D : public B, public C {}; + +void f(D *d) { + // This takes the D->C->B->A path. + A *a = d; +} + +} + +namespace T5 { + class A {}; + + class B : private A { + void f(B *b) { + A *a = b; + } + }; +} + +namespace T6 { + class C; + + class A {}; // expected-note{{member is declared here}} + + class B : private A { // expected-note {{declared private here}} expected-note {{constrained by private inheritance here}} + void f(C* c); + }; + + class C : public B { + void f(C *c) { + A* a = c; // expected-error {{cannot cast 'T6::C' to its private base class 'T6::A'}} \ + // expected-error {{'A' is a private member of 'T6::A'}} + } + }; + + void B::f(C *c) { + A *a = c; + } +} + +namespace T7 { + class A {}; + class B : public A {}; + class C : private B { + void f(C *c) { + A* a = c; // okay + } + }; +} + diff --git a/clang/test/SemaCXX/access-control-check.cpp b/clang/test/SemaCXX/access-control-check.cpp new file mode 100644 index 0000000..4540e99 --- /dev/null +++ b/clang/test/SemaCXX/access-control-check.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class M { + int iM; +}; + +class P { + int iP; // expected-note {{declared private here}} + int PPR(); // expected-note {{declared private here}} +}; + +class N : M,P { + N() {} + int PR() { return iP + PPR(); } // expected-error 2 {{private member of 'P'}} +}; diff --git a/clang/test/SemaCXX/access-member-pointer.cpp b/clang/test/SemaCXX/access-member-pointer.cpp new file mode 100644 index 0000000..676eb10 --- /dev/null +++ b/clang/test/SemaCXX/access-member-pointer.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR7694 + +class A { }; +class B : private A { public: void foo(); }; // expected-note {{declared private here}} +void B::foo() { + (void)static_cast<void(A::*)()>(&B::foo); +} +void bar() { + (void)static_cast<void(A::*)()>(&B::foo); // expected-error {{cannot cast 'B' to its private base class 'A'}} +} diff --git a/clang/test/SemaCXX/access.cpp b/clang/test/SemaCXX/access.cpp new file mode 100644 index 0000000..18ad301 --- /dev/null +++ b/clang/test/SemaCXX/access.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class C { + struct S; // expected-note {{previously declared 'private' here}} +public: + + struct S {}; // expected-error {{'S' redeclared with 'public' access}} +}; + +struct S { + class C; // expected-note {{previously declared 'public' here}} + +private: + class C { }; // expected-error {{'C' redeclared with 'private' access}} +}; + +class T { +protected: + template<typename T> struct A; // expected-note {{previously declared 'protected' here}} + +private: + template<typename T> struct A {}; // expected-error {{'A' redeclared with 'private' access}} +}; + +// PR5573 +namespace test1 { + class A { + private: + class X; // expected-note {{previously declared 'private' here}} + public: + class X; // expected-error {{'X' redeclared with 'public' access}} + class X {}; + }; +} diff --git a/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp b/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp new file mode 100644 index 0000000..cfd55ee --- /dev/null +++ b/clang/test/SemaCXX/addr-of-overloaded-function-casting.cpp @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void g(); + +void f(); // expected-note 9{{candidate function}} +void f(int); // expected-note 9{{candidate function}} + +template<class T> void t(T); // expected-note 6{{candidate function}} +template<class T> void t(T*); // expected-note 6{{candidate function}} + +template<class T> void u(T); + +int main() +{ + { bool b = (void (&)(char))f; } // expected-error{{does not match required type}} + { bool b = (void (*)(char))f; } // expected-error{{does not match required type}} + + { bool b = (void (&)(int))f; } //ok + { bool b = (void (*)(int))f; } //ok + + { bool b = static_cast<void (&)(char)>(f); } // expected-error{{does not match}} + { bool b = static_cast<void (*)(char)>(f); } // expected-error{{address of overloaded function}} + + { bool b = static_cast<void (&)(int)>(f); } //ok + { bool b = static_cast<void (*)(int)>(f); } //ok + + + { bool b = reinterpret_cast<void (&)(char)>(f); } // expected-error{{cannot resolve}} + { bool b = reinterpret_cast<void (*)(char)>(f); } // expected-error{{cannot resolve}} + + { bool b = reinterpret_cast<void (*)(char)>(g); } //ok + { bool b = static_cast<void (*)(char)>(g); } // expected-error{{not allowed}} + + { bool b = reinterpret_cast<void (&)(int)>(f); } // expected-error{{cannot resolve}} + { bool b = reinterpret_cast<void (*)(int)>(f); } // expected-error{{cannot resolve}} + + { bool b = (int (&)(char))t; } // expected-error{{does not match}} + { bool b = (int (*)(char))t; } // expected-error{{does not match}} + + { bool b = (void (&)(int))t; } //ok + { bool b = (void (*)(int))t; } //ok + + { bool b = static_cast<void (&)(char)>(t); } //ok + { bool b = static_cast<void (*)(char)>(t); } //ok + + { bool b = static_cast<void (&)(int)>(t); } //ok + { bool b = static_cast<void (*)(int)>(t); } //ok + + + { bool b = reinterpret_cast<void (&)(char)>(t); } // expected-error{{cannot resolve}} + { bool b = reinterpret_cast<void (*)(char)>(t); } // expected-error{{cannot resolve}} + + { bool b = reinterpret_cast<int (*)(char)>(g); } //ok + { bool b = static_cast<int (*)(char)>(t); } // expected-error{{cannot be static_cast}} + { bool b = static_cast<int (&)(char)>(t); } // expected-error{{does not match required}} + + { bool b = static_cast<void (&)(char)>(f); } // expected-error{{does not match}} +} diff --git a/clang/test/SemaCXX/addr-of-overloaded-function.cpp b/clang/test/SemaCXX/addr-of-overloaded-function.cpp new file mode 100644 index 0000000..096f748 --- /dev/null +++ b/clang/test/SemaCXX/addr-of-overloaded-function.cpp @@ -0,0 +1,210 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int f(double); // expected-note{{candidate function}} +int f(int); // expected-note{{candidate function}} + +int (*pfd)(double) = f; // selects f(double) +int (*pfd2)(double) = &f; // selects f(double) +int (*pfd3)(double) = ((&((f)))); // selects f(double) +int (*pfi)(int) = &f; // selects f(int) +// FIXME: This error message is not very good. We need to keep better +// track of what went wrong when the implicit conversion failed to +// give a better error message here. +int (*pfe)(...) = &f; // expected-error{{address of overloaded function 'f' does not match required type 'int (...)'}} +int (&rfi)(int) = f; // selects f(int) +int (&rfd)(double) = f; // selects f(double) + +void g(int (*fp)(int)); // expected-note{{candidate function}} +void g(int (*fp)(float)); +void g(int (*fp)(double)); // expected-note{{candidate function}} + +int g1(int); +int g1(char); + +int g2(int); +int g2(double); + +template<typename T> T g3(T); +int g3(int); +int g3(char); + +void g_test() { + g(g1); + g(g2); // expected-error{{call to 'g' is ambiguous}} + g(g3); +} + +template<typename T> T h1(T); +template<typename R, typename A1> R h1(A1); +int h1(char); + +void ha(int (*fp)(int)); +void hb(int (*fp)(double)); + +void h_test() { + ha(h1); + hb(h1); +} + +struct A { }; +void f(void (*)(A *)); + +struct B +{ + void g() { f(d); } + void d(void *); + static void d(A *); +}; + +struct C { + C &getC() { + return makeAC; // expected-error{{reference to non-static member function must be called}} + } + + C &makeAC(); + const C &makeAC() const; + + static void f(); // expected-note{{candidate function}} + static void f(int); // expected-note{{candidate function}} + + void g() { + int (&fp)() = f; // expected-error{{address of overloaded function 'f' does not match required type 'int ()'}} + } +}; + +// PR6886 +namespace test0 { + void myFunction(void (*)(void *)); + + class Foo { + void foo(); + + static void bar(void*); + static void bar(); + }; + + void Foo::foo() { + myFunction(bar); + } +} + +namespace PR7971 { + struct S { + void g() { + f(&g); + } + void f(bool (*)(int, char)); + static bool g(int, char); + }; +} + +namespace PR8033 { + template <typename T1, typename T2> int f(T1 *, const T2 *); // expected-note {{candidate function [with T1 = const int, T2 = int]}} \ + // expected-note{{candidate function}} + template <typename T1, typename T2> int f(const T1 *, T2 *); // expected-note {{candidate function [with T1 = int, T2 = const int]}} \ + // expected-note{{candidate function}} + int (*p)(const int *, const int *) = f; // expected-error{{address of overloaded function 'f' is ambiguous}} \ + // expected-error{{address of overloaded function 'f' is ambiguous}} + +} + +namespace PR8196 { + template <typename T> struct mcdata { + typedef int result_type; + }; + template <class T> + typename mcdata<T>::result_type wrap_mean(mcdata<T> const&); + void add_property(double(*)(mcdata<double> const &)); // expected-note{{candidate function not viable: no overload of 'wrap_mean' matching}} + void f() { + add_property(&wrap_mean); // expected-error{{no matching function for call to 'add_property'}} + } +} + +namespace PR7425 { + template<typename T> + void foo() + { + } + + struct B + { + template<typename T> + B(const T&) + { + } + }; + + void bar(const B& b) + { + } + + void bar2(const B& b = foo<int>) + { + } + + void test(int argc, char** argv) + { + bar(foo<int>); + bar2(); + } +} + +namespace test1 { + void fun(int x) {} + + void parameter_number() { + void (*ptr1)(int, int) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(int, int)' with an rvalue of type 'void (*)(int)': different number of parameters (2 vs 1)}} + void (*ptr2)(int, int); + ptr2 = &fun; // expected-error {{assigning to 'void (*)(int, int)' from incompatible type 'void (*)(int)': different number of parameters (2 vs 1)}} + } + + void parameter_mismatch() { + void (*ptr1)(double) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(double)' with an rvalue of type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}} + void (*ptr2)(double); + ptr2 = &fun; // expected-error {{assigning to 'void (*)(double)' from incompatible type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}} + } + + void return_type_test() { + int (*ptr1)(int) = &fun; // expected-error {{cannot initialize a variable of type 'int (*)(int)' with an rvalue of type 'void (*)(int)': different return type ('int' vs 'void')}} + int (*ptr2)(int); + ptr2 = &fun; // expected-error {{assigning to 'int (*)(int)' from incompatible type 'void (*)(int)': different return type ('int' vs 'void')}} + } + + int foo(double x, double y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}} + int foo(int x, int y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}} + int foo(double x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'double')}} + double foo(float x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}} + double foo(int x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}} + double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}} + double foo(int x) {return 0;} // expected-note {{candidate function has different return type ('int' expected but has 'double')}} + + int (*ptr)(int) = &foo; // expected-error {{address of overloaded function 'foo' does not match required type 'int (int)'}} + + struct Qualifiers { + void N() {}; + void C() const {}; + void V() volatile {}; + void R() __restrict {}; + void CV() const volatile {}; + void CR() const __restrict {}; + void VR() volatile __restrict {}; + void CVR() const volatile __restrict {}; + }; + + + void QualifierTest() { + void (Qualifiers::*X)(); + X = &Qualifiers::C; // expected-error {{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const': different qualifiers (none vs const)}} + X = &Qualifiers::V; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile': different qualifiers (none vs volatile)}} + X = &Qualifiers::R; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() restrict': different qualifiers (none vs restrict)}} + X = &Qualifiers::CV; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const volatile': different qualifiers (none vs const and volatile)}} + X = &Qualifiers::CR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const restrict': different qualifiers (none vs const and restrict)}} + X = &Qualifiers::VR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() volatile restrict': different qualifiers (none vs volatile and restrict)}} + X = &Qualifiers::CVR; // expected-error{{assigning to 'void (test1::Qualifiers::*)()' from incompatible type 'void (test1::Qualifiers::*)() const volatile restrict': different qualifiers (none vs const, volatile, and restrict)}} + } + + struct Dummy { + void N() {}; + }; + + void (Qualifiers::*X)() = &Dummy::N; // expected-error{{cannot initialize a variable of type 'void (test1::Qualifiers::*)()' with an rvalue of type 'void (test1::Dummy::*)()': different classes ('test1::Qualifiers' vs 'test1::Dummy')}} +} diff --git a/clang/test/SemaCXX/address-of-temporary.cpp b/clang/test/SemaCXX/address-of-temporary.cpp new file mode 100644 index 0000000..eb5dee5 --- /dev/null +++ b/clang/test/SemaCXX/address-of-temporary.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -Wno-error=address-of-temporary -verify %s +struct X { + X(); + X(int); + X(int, int); +}; + +void f0() { (void)&X(); } // expected-warning{{taking the address of a temporary object}} +void f1() { (void)&X(1); } // expected-warning{{taking the address of a temporary object}} +void f2() { (void)&X(1, 2); } // expected-warning{{taking the address of a temporary object}} +void f3() { (void)&(X)1; } // expected-warning{{taking the address of a temporary object}} + diff --git a/clang/test/SemaCXX/address-of.cpp b/clang/test/SemaCXX/address-of.cpp new file mode 100644 index 0000000..69fcaff --- /dev/null +++ b/clang/test/SemaCXX/address-of.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR clang/3175 + +void bar(int*); + +class c { + int var; + static int svar; + void foo() { + bar(&var); + bar(&svar); + } + + static void wibble() { + bar(&var); // expected-error{{invalid use of member 'var' in static member function}} + bar(&svar); + } +}; + +enum E { + Enumerator +}; + +void test() { + (void)&Enumerator; // expected-error{{address expression must be an lvalue or a function designator}} +} + +template<int N> +void test2() { + (void)&N; // expected-error{{address expression must be an lvalue or a function designator}} +} + +// PR clang/3222 +void xpto(); +void (*xyz)(void) = &xpto; + +struct PR11066 { + static int foo(short); + static int foo(float); + void test(); +}; + +void PR11066::test() { + int (PR11066::*ptr)(int) = & &PR11066::foo; // expected-error{{address expression must be an lvalue or a function designator}} +} + diff --git a/clang/test/SemaCXX/address-space-conversion.cpp b/clang/test/SemaCXX/address-space-conversion.cpp new file mode 100644 index 0000000..d21d419 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/address-space-newdelete.cpp b/clang/test/SemaCXX/address-space-newdelete.cpp new file mode 100644 index 0000000..b809cd3 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/address-space-references.cpp b/clang/test/SemaCXX/address-space-references.cpp new file mode 100644 index 0000000..f5a63d2 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/aggregate-initialization.cpp b/clang/test/SemaCXX/aggregate-initialization.cpp new file mode 100644 index 0000000..885bf70 --- /dev/null +++ b/clang/test/SemaCXX/aggregate-initialization.cpp @@ -0,0 +1,84 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// Verify that using an initializer list for a non-aggregate looks for +// constructors.. +// Note that due to a (likely) standard bug, this is technically an aggregate, +// but we do not treat it as one. +struct NonAggr1 { // expected-note 2 {{candidate constructor}} + NonAggr1(int, int) { } // expected-note {{candidate constructor}} + + int m; +}; + +struct Base { }; +struct NonAggr2 : public Base { // expected-note 3 {{candidate constructor}} + int m; +}; + +class NonAggr3 { // expected-note 3 {{candidate constructor}} + int m; +}; + +struct NonAggr4 { // expected-note 3 {{candidate constructor}} + int m; + virtual void f(); +}; + +NonAggr1 na1 = { 17 }; // expected-error{{no matching constructor for initialization of 'NonAggr1'}} +NonAggr2 na2 = { 17 }; // expected-error{{no matching constructor for initialization of 'NonAggr2'}} +NonAggr3 na3 = { 17 }; // expected-error{{no matching constructor for initialization of 'NonAggr3'}} +NonAggr4 na4 = { 17 }; // expected-error{{no matching constructor for initialization of 'NonAggr4'}} + +// PR5817 +typedef int type[][2]; +const type foo = {0}; + +// Vector initialization. +typedef short __v4hi __attribute__ ((__vector_size__ (8))); +__v4hi v1 = { (void *)1, 2, 3 }; // expected-error {{cannot initialize a vector element of type 'short' with an rvalue of type 'void *'}} + +// Array initialization. +int a[] = { (void *)1 }; // expected-error {{cannot initialize an array element of type 'int' with an rvalue of type 'void *'}} + +// Struct initialization. +struct S { int a; } s = { (void *)1 }; // expected-error {{cannot initialize a member subobject of type 'int' with an rvalue of type 'void *'}} + +// Check that we're copy-initializing the structs. +struct A { + A(); + A(int); + ~A(); + + A(const A&) = delete; // expected-note 2 {{function has been explicitly marked deleted here}} +}; + +struct B { + A a; +}; + +struct C { + const A& a; +}; + +void f() { + A as1[1] = { }; + A as2[1] = { 1 }; // expected-error {{copying array element of type 'A' invokes deleted constructor}} + + B b1 = { }; + B b2 = { 1 }; // expected-error {{copying member subobject of type 'A' invokes deleted constructor}} + + C c1 = { 1 }; +} + +class Agg { +public: + int i, j; +}; + +class AggAgg { +public: + Agg agg1; + Agg agg2; +}; + +AggAgg aggagg = { 1, 2, 3, 4 }; diff --git a/clang/test/SemaCXX/alias-template.cpp b/clang/test/SemaCXX/alias-template.cpp new file mode 100644 index 0000000..484dd33 --- /dev/null +++ b/clang/test/SemaCXX/alias-template.cpp @@ -0,0 +1,147 @@ +// RUN: %clang_cc1 -verify -std=c++11 %s + +namespace RedeclAliasTypedef { + template<typename U> using T = int; + template<typename U> using T = int; + template<typename U> using T = T<U>; +} + +namespace IllegalTypeIds { + template<typename U> using A = void(int n = 0); // expected-error {{default arguments can only be specified for parameters in a function declaration}} + template<typename U> using B = inline void(int n); // expected-error {{type name does not allow function specifier}} + template<typename U> using C = virtual void(int n); // expected-error {{type name does not allow function specifier}} + template<typename U> using D = explicit void(int n); // expected-error {{type name does not allow function specifier}} + template<typename U> using E = void(int n) throw(); // expected-error {{exception specifications are not allowed in type aliases}} + template<typename U> using F = void(*)(int n) &&; // expected-error {{pointer to function type cannot have '&&' qualifier}} + template<typename U> using G = __thread void(int n); // expected-error {{type name does not allow storage class to be specified}} + template<typename U> using H = constexpr int; // expected-error {{type name does not allow constexpr specifier}} + + template<typename U> using Y = void(int n); // ok + template<typename U> using Z = void(int n) &&; // ok +} + +namespace IllegalSyntax { + template<typename Z> using ::T = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} + template<typename Z> using operator int = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} + template<typename Z> using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}} + template<typename Z> using typename ::V = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} + template<typename Z> using typename ::operator bool = void(int n); // expected-error {{name defined in alias declaration must be an identifier}} +} + +namespace VariableLengthArrays { + template<typename Z> using T = int[42]; // ok + + int n = 32; + template<typename Z> using T = int[n]; // expected-error {{variable length array declaration not allowed at file scope}} + + const int m = 42; + template<typename Z> using U = int[m]; // expected-note {{previous definition}} + template<typename Z> using U = int[42]; // ok + template<typename Z> using U = int; // expected-error {{type alias template redefinition with different types ('int' vs 'int [42]')}} +} + +namespace RedeclFunc { + int f(int, char**); + template<typename Z> using T = int; + T<char> f(int, char **); // ok +} + +namespace LookupFilter { + namespace N { template<typename U> using S = int; } + using namespace N; + template<typename U> using S = S<U>*; // ok +} + +namespace InFunctions { + template<typename...T> struct S0 { + template<typename Z> using U = T*; // expected-error {{declaration type contains unexpanded parameter pack 'T'}} + U<char> u; + }; + + template<typename Z> using T1 = int; + template<typename Z> using T2 = int[-1]; // expected-error {{array size is negative}} + template<typename...T> struct S3 { // expected-note {{template parameter is declared here}} + template<typename Z> using T = int; // expected-error {{declaration of 'T' shadows template parameter}} + }; + template<typename Z> using Z = Z; +} + +namespace ClassNameRedecl { + class C0 { + // FIXME: this diagnostic is pretty poor + template<typename U> using C0 = int; // expected-error {{name defined in alias declaration must be an identifier}} + }; + class C1 { + // FIXME: this diagnostic is pretty poor + template<typename U> using C1 = C1; // expected-error {{name defined in alias declaration must be an identifier}} + }; + class C2 { + template<typename U> using C0 = C1; // ok + }; + template<typename...T> class C3 { + template<typename U> using f = T; // expected-error {{declaration type contains unexpanded parameter pack 'T'}} + }; + template<typename T> class C4 { // expected-note {{template parameter is declared here}} + template<typename U> using T = int; // expected-error {{declaration of 'T' shadows template parameter}} + }; + class C5 { + class c; // expected-note {{previous definition}} + template<typename U> using c = int; // expected-error {{redefinition of 'c' as different kind of symbol}} + class d; // expected-note {{previous definition}} + template<typename U> using d = d; // expected-error {{redefinition of 'd' as different kind of symbol}} + }; + class C6 { + class c { template<typename U> using C6 = int; }; // ok + }; +} + +class CtorDtorName { + template<typename T> using X = CtorDtorName; + X<int>(); // expected-error {{expected member name}} + ~X<int>(); // expected-error {{destructor cannot be declared using a type alias}} +}; + +namespace TagName { + template<typename Z> using S = struct { int n; }; // expected-error {{can not be defined}} + template<typename Z> using T = class { int n; }; // expected-error {{can not be defined}} + template<typename Z> using U = enum { a, b, c }; // expected-error {{can not be defined}} + template<typename Z> using V = struct V { int n; }; // expected-error {{redefinition of 'V' as different kind of symbol}} \ + expected-error {{'TagName::V' can not be defined in a type alias template}} \ + expected-note {{previous definition is here}} +} + +namespace StdExample { + template<typename T, typename U> struct pair; + + template<typename T> using handler_t = void (*)(T); + extern handler_t<int> ignore; + extern void (*ignore)(int); + // FIXME: we recover as if cell is an undeclared variable. the diagnostics are terrible! + template<typename T> using cell = pair<T*, cell<T>*>; // expected-error {{use of undeclared identifier 'cell'}} \ + expected-error {{'T' does not refer to a value}} \ + expected-note {{declared here}} \ + expected-error {{expected ';' after alias declaration}} +} + +namespace Access { + class C0 { + template<typename Z> using U = int; // expected-note {{declared private here}} + }; + C0::U<int> v; // expected-error {{'U' is a private member}} + class C1 { + public: + template<typename Z> using U = int; + }; + C1::U<int> w; // ok +} + +namespace VoidArg { + template<typename Z> using V = void; + V<int> f(int); // ok + V<char> g(V<double>); // expected-error {{empty parameter list defined with a type alias of 'void' not allowed}} +} + +namespace Curried { + template<typename T, typename U> struct S; + template<typename T> template<typename U> using SS = S<T, U>; // expected-error {{extraneous template parameter list in alias template declaration}} +} diff --git a/clang/test/SemaCXX/alignof-sizeof-reference.cpp b/clang/test/SemaCXX/alignof-sizeof-reference.cpp new file mode 100644 index 0000000..ccdf45e --- /dev/null +++ b/clang/test/SemaCXX/alignof-sizeof-reference.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct s0; // expected-note {{forward declaration}} +char ar[sizeof(s0&)]; // expected-error {{invalid application of 'sizeof' to an incomplete type}} +void test() { + char &r = ar[0]; + static_assert(alignof(r) == 1, "bad alignment"); + static_assert(sizeof(r) == 1, "bad size"); +} + +void f(); // expected-note{{possible target for call}} +void f(int); // expected-note{{possible target for call}} +void g() { + sizeof(&f); // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} \ + // expected-warning{{expression result unused}} +} + +template<typename T> void f_template(); // expected-note{{possible target for call}} +template<typename T> void f_template(T*); // expected-note{{possible target for call}} +void rdar9659191() { + (void)alignof(f_template<int>); // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} +} diff --git a/clang/test/SemaCXX/altivec.cpp b/clang/test/SemaCXX/altivec.cpp new file mode 100644 index 0000000..39421b7 --- /dev/null +++ b/clang/test/SemaCXX/altivec.cpp @@ -0,0 +1,78 @@ +// RUN: %clang_cc1 -faltivec -fno-lax-vector-conversions -triple powerpc-unknown-unknown -verify %s + +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) +{ +} + +void test1() +{ + V4i vGCC; + vector int vAltiVec; + + f(vAltiVec); + vGCC = vAltiVec; + bool res = vGCC > vAltiVec; + vAltiVec = 0 ? vGCC : vGCC; +} + +template<typename T> +void template_f(T param) { + param++; +} + +void test2() +{ + vector int vi; + ++vi; + vi++; + --vi; + vi--; + vector float vf; + vf++; + + ++vi=vi; + (++vi)[1]=1; + template_f(vi); +} + +namespace LValueToRValueConversions { + struct Struct { + float f(); + int n(); + }; + + vector float initFloat = (vector float)(Struct().f); // expected-error {{did you mean to call it}} + vector int initInt = (vector int)(Struct().n); // expected-error {{did you mean to call it}} +} diff --git a/clang/test/SemaCXX/ambig-user-defined-conversions.cpp b/clang/test/SemaCXX/ambig-user-defined-conversions.cpp new file mode 100644 index 0000000..1a3c102 --- /dev/null +++ b/clang/test/SemaCXX/ambig-user-defined-conversions.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace test0 { + struct BASE { + operator int &(); // expected-note {{candidate function}} + }; + struct BASE1 { + operator int &(); // expected-note {{candidate function}} + }; + + struct B : public BASE, BASE1 {}; + + extern B f(); + B b1; + + void func(const int ci, const char cc); // expected-note {{candidate function}} + void func(const char ci, const B b); // expected-note {{candidate function}} + void func(const B b, const int ci); // expected-note {{candidate function}} + + const int Test1() { + + func(b1, f()); // expected-error {{call to 'func' is ambiguous}} + return f(); // expected-error {{conversion from 'test0::B' to 'const int' is ambiguous}} + } + + // This used to crash when comparing the two operands. + void func2(const char cc); // expected-note {{candidate function}} + void func2(const int ci); // expected-note {{candidate function}} + void Test2() { + func2(b1); // expected-error {{call to 'func2' is ambiguous}} + } +} + +namespace test1 { + struct E; + struct A { + A (E&); + }; + + struct E { + operator A (); + }; + + struct C { + C (E&); + }; + + void f1(A); // expected-note {{candidate function}} + void f1(C); // expected-note {{candidate function}} + + void Test2() + { + E b; + f1(b); // expected-error {{call to 'f1' is ambiguous}} + // ambiguous because b -> C via constructor and + // b -> A via constructor or conversion function. + } +} + +namespace rdar8876150 { + struct A { operator bool(); }; + struct B : A { }; + struct C : A { }; + struct D : B, C { }; + + bool f(D d) { return !d; } // expected-error{{ambiguous conversion from derived class 'rdar8876150::D' to base class 'rdar8876150::A':}} +} diff --git a/clang/test/SemaCXX/ambiguous-builtin-unary-operator.cpp b/clang/test/SemaCXX/ambiguous-builtin-unary-operator.cpp new file mode 100644 index 0000000..6e96e03 --- /dev/null +++ b/clang/test/SemaCXX/ambiguous-builtin-unary-operator.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct A { + operator int&(); + operator long*& (); +}; + +struct B { + operator long&(); + operator int*& (); +}; + +struct C : B, A { }; + +void test(C c) { + ++c; // expected-error {{use of overloaded operator '++' is ambiguous}}\ + // expected-note {{built-in candidate operator++(int &)}} \ + // expected-note {{built-in candidate operator++(long &)}} \ + // expected-note {{built-in candidate operator++(long *&)}} \ + // expected-note {{built-in candidate operator++(int *&)}} +} + +struct A1 { operator volatile int&(); }; + +struct B1 { operator volatile long&(); }; + +struct C1 : B1, A1 { }; + +void test(C1 c) { + ++c; // expected-error {{use of overloaded operator '++' is ambiguous}} \ + // expected-note {{built-in candidate operator++(volatile int &)}} \ + // expected-note {{built-in candidate operator++(volatile long &)}} +} + diff --git a/clang/test/SemaCXX/anonymous-struct.cpp b/clang/test/SemaCXX/anonymous-struct.cpp new file mode 100644 index 0000000..19a88d7 --- /dev/null +++ b/clang/test/SemaCXX/anonymous-struct.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct S { + S(); // expected-note {{because type 'S' has a user-declared constructor}} +}; + +struct { // expected-error {{anonymous structs and classes must be class members}} +}; + +struct E { + struct { + S x; // expected-error {{anonymous struct member 'x' has a non-trivial constructor}} + }; + static struct { + }; +}; diff --git a/clang/test/SemaCXX/anonymous-union.cpp b/clang/test/SemaCXX/anonymous-union.cpp new file mode 100644 index 0000000..2dd7ab8 --- /dev/null +++ b/clang/test/SemaCXX/anonymous-union.cpp @@ -0,0 +1,199 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s +struct X { + union { + float f3; + double d2; + } named; + + union { + int i; + float f; + + union { + float f2; + mutable double d; + }; + }; + + void test_unqual_references(); + + struct { // expected-warning{{anonymous structs are a GNU extension}} + int a; + float b; + }; + + void test_unqual_references_const() const; + + mutable union { // expected-error{{anonymous union at class scope must not have a storage specifier}} + float c1; + double c2; + }; +}; + +void X::test_unqual_references() { + i = 0; + f = 0.0; + f2 = f; + d = f; + f3 = 0; // expected-error{{use of undeclared identifier 'f3'}} + a = 0; +} + +void X::test_unqual_references_const() const { + d = 0.0; + f2 = 0; // expected-error{{read-only variable is not assignable}} + a = 0; // expected-error{{read-only variable is not assignable}} +} + +void test_unqual_references(X x, const X xc) { + x.i = 0; + x.f = 0.0; + x.f2 = x.f; + x.d = x.f; + x.f3 = 0; // expected-error{{no member named 'f3'}} + x.a = 0; + + xc.d = 0.0; + xc.f = 0; // expected-error{{read-only variable is not assignable}} + xc.a = 0; // expected-error{{read-only variable is not assignable}} +} + + +struct Redecl { + int x; // expected-note{{previous declaration is here}} + class y { }; + + union { + int x; // expected-error{{member of anonymous union redeclares 'x'}} + float y; + double z; // expected-note{{previous declaration is here}} + double zz; // expected-note{{previous definition is here}} + }; + + int z; // expected-error{{duplicate member 'z'}} + void zz(); // expected-error{{redefinition of 'zz' as different kind of symbol}} +}; + +union { // expected-error{{anonymous unions at namespace or global scope must be declared 'static'}} + int int_val; + float float_val; +}; + +static union { + int int_val2; + float float_val2; +}; + +void f() { + int_val2 = 0; + float_val2 = 0.0; +} + +void g() { + union { + int i; + float f2; + }; + i = 0; + f2 = 0.0; +} + +struct BadMembers { + union { + struct X { }; // expected-error {{types cannot be declared in an anonymous union}} + struct { int x; int y; } y; + + void f(); // expected-error{{functions cannot be declared in an anonymous union}} + private: int x1; // expected-error{{anonymous union cannot contain a private data member}} + protected: float x2; // expected-error{{anonymous union cannot contain a protected data member}} + }; +}; + +// <rdar://problem/6481130> +typedef union { }; // expected-warning{{declaration does not declare anything}} + +// <rdar://problem/7562438> +typedef struct objc_module *Foo ; + +typedef struct _s { + union { + int a; + int Foo; + }; +} s, *ps; + +// <rdar://problem/7987650> +namespace test4 { + class A { + struct { // expected-warning{{anonymous structs are a GNU extension}} + int s0; // expected-note {{declared private here}} + double s1; // expected-note {{declared private here}} + union { + int su0; // expected-note {{declared private here}} + double su1; // expected-note {{declared private here}} + }; + }; + union { + int u0; // expected-note {{declared private here}} + double u1; // expected-note {{declared private here}} + struct { // expected-warning{{anonymous structs are a GNU extension}} + int us0; // expected-note {{declared private here}} + double us1; // expected-note {{declared private here}} + }; + }; + }; + + void test() { + A a; + (void) a.s0; // expected-error {{private member}} + (void) a.s1; // expected-error {{private member}} + (void) a.su0; // expected-error {{private member}} + (void) a.su1; // expected-error {{private member}} + (void) a.u0; // expected-error {{private member}} + (void) a.u1; // expected-error {{private member}} + (void) a.us0; // expected-error {{private member}} + (void) a.us1; // expected-error {{private member}} + } +} + +typedef void *voidPtr; + +void f2() { + union { int **ctxPtr; void **voidPtr; }; +} + +void foo_PR6741() { + union { + char *m_a; + int *m_b; + }; + + if(1) { + union { + char *m_a; + int *m_b; + }; + } +} + +namespace PR8326 { + template <class T> + class Foo { + public: + Foo() + : x(0) + , y(1){ + } + + private: + const union { // expected-warning{{anonymous union cannot be 'const'}} + struct { // expected-warning{{anonymous structs are a GNU extension}} + T x; + T y; + }; + T v[2]; + }; + }; + + Foo<int> baz; +} diff --git a/clang/test/SemaCXX/array-bound-merge.cpp b/clang/test/SemaCXX/array-bound-merge.cpp new file mode 100644 index 0000000..74f58fa --- /dev/null +++ b/clang/test/SemaCXX/array-bound-merge.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR5515 + +extern int a[]; +int a[10]; +extern int b[10]; +int b[]; +extern int c[1]; +int c[] = {1,2}; // expected-error {{excess elements in array initializer}} diff --git a/clang/test/SemaCXX/array-bounds-ptr-arith.cpp b/clang/test/SemaCXX/array-bounds-ptr-arith.cpp new file mode 100644 index 0000000..16e2567 --- /dev/null +++ b/clang/test/SemaCXX/array-bounds-ptr-arith.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -verify -Wno-string-plus-int -Warray-bounds-pointer-arithmetic %s + +void swallow (const char *x) { (void)x; } +void test_pointer_arithmetic(int n) { + const char hello[] = "Hello world!"; // expected-note 2 {{declared here}} + const char *helloptr = hello; + + swallow("Hello world!" + 6); // no-warning + swallow("Hello world!" - 6); // expected-warning {{refers before the beginning of the array}} + swallow("Hello world!" + 14); // expected-warning {{refers past the end of the array}} + swallow("Hello world!" + 13); // no-warning + + swallow(hello + 6); // no-warning + swallow(hello - 6); // expected-warning {{refers before the beginning of the array}} + swallow(hello + 14); // expected-warning {{refers past the end of the array}} + swallow(hello + 13); // no-warning + + swallow(helloptr + 6); // no-warning + swallow(helloptr - 6); // no-warning + swallow(helloptr + 14); // no-warning + swallow(helloptr + 13); // no-warning + + double numbers[2]; // expected-note {{declared here}} + swallow((char*)numbers + sizeof(double)); // no-warning + swallow((char*)numbers + 60); // expected-warning {{refers past the end of the array}} + + char buffer[5]; // expected-note 2 {{declared here}} + // TODO: Add FixIt notes for adding parens around non-ptr part of arith expr + swallow(buffer + sizeof("Hello")-1); // expected-warning {{refers past the end of the array}} + swallow(buffer + (sizeof("Hello")-1)); // no-warning + if (n > 0 && n <= 6) swallow(buffer + 6 - n); // expected-warning {{refers past the end of the array}} + if (n > 0 && n <= 6) swallow(buffer + (6 - n)); // no-warning +} diff --git a/clang/test/SemaCXX/array-bounds-system-header.cpp b/clang/test/SemaCXX/array-bounds-system-header.cpp new file mode 100644 index 0000000..34de5b5 --- /dev/null +++ b/clang/test/SemaCXX/array-bounds-system-header.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -isystem %S/Inputs -verify %s +#include <array-bounds-system-header.h> +void test_system_header_macro() { + BAD_MACRO_1; // no-warning + char a[3]; // expected-note 2 {{declared here}} + BAD_MACRO_2(a, 3); // expected-warning {{array index 3}} + QUESTIONABLE_MACRO(a); + NOP(a[3] = 5); // expected-warning {{array index 3}} +} diff --git a/clang/test/SemaCXX/array-bounds.cpp b/clang/test/SemaCXX/array-bounds.cpp new file mode 100644 index 0000000..57a9e3d --- /dev/null +++ b/clang/test/SemaCXX/array-bounds.cpp @@ -0,0 +1,255 @@ +// RUN: %clang_cc1 -verify %s + +int foo() { + int x[2]; // expected-note 4 {{array 'x' declared here}} + int y[2]; // expected-note 2 {{array 'y' declared here}} + int z[1]; // expected-note {{array 'z' declared here}} + int w[1][1]; // expected-note {{array 'w' declared here}} + int v[1][1][1]; // expected-note {{array 'v' declared here}} + int *p = &y[2]; // no-warning + (void) sizeof(x[2]); // no-warning + y[2] = 2; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}} + z[1] = 'x'; // expected-warning {{array index 1 is past the end of the array (which contains 1 element)}} + w[0][2] = 0; // expected-warning {{array index 2 is past the end of the array (which contains 1 element)}} + v[0][0][2] = 0; // expected-warning {{array index 2 is past the end of the array (which contains 1 element)}} + return x[2] + // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}} + y[-1] + // expected-warning {{array index -1 is before the beginning of the array}} + x[sizeof(x)] + // expected-warning {{array index 8 is past the end of the array (which contains 2 elements)}} + x[sizeof(x) / sizeof(x[0])] + // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}} + x[sizeof(x) / sizeof(x[0]) - 1] + // no-warning + x[sizeof(x[2])]; // expected-warning {{array index 4 is past the end of the array (which contains 2 elements)}} +} + +// This code example tests that -Warray-bounds works with arrays that +// are template parameters. +template <char *sz> class Qux { + bool test() { return sz[0] == 'a'; } +}; + +void f1(int a[1]) { + int val = a[3]; // no warning for function argumnet +} + +void f2(const int (&a)[2]) { // expected-note {{declared here}} + int val = a[3]; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} +} + +void test() { + struct { + int a[0]; + } s2; + s2.a[3] = 0; // no warning for 0-sized array + + union { + short a[2]; // expected-note 4 {{declared here}} + char c[4]; + } u; + u.a[3] = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} + u.c[3] = 1; // no warning + short *p = &u.a[2]; // no warning + p = &u.a[3]; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} + *(&u.a[2]) = 1; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}} + *(&u.a[3]) = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} + *(&u.c[3]) = 1; // no warning + + const int const_subscript = 3; + int array[2]; // expected-note {{declared here}} + array[const_subscript] = 0; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} + + int *ptr; + ptr[3] = 0; // no warning for pointer references + int array2[] = { 0, 1, 2 }; // expected-note 2 {{declared here}} + + array2[3] = 0; // expected-warning {{array index 3 is past the end of the array (which contains 3 elements)}} + array2[2+2] = 0; // expected-warning {{array index 4 is past the end of the array (which contains 3 elements)}} + + const char *str1 = "foo"; + char c1 = str1[5]; // no warning for pointers + + const char str2[] = "foo"; // expected-note {{declared here}} + char c2 = str2[5]; // expected-warning {{array index 5 is past the end of the array (which contains 4 elements)}} + + int (*array_ptr)[2]; + (*array_ptr)[3] = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}} +} + +template <int I> struct S { + char arr[I]; // expected-note 2 {{declared here}} +}; +template <int I> void f() { + S<3> s; + s.arr[4] = 0; // expected-warning {{array index 4 is past the end of the array (which contains 3 elements)}} + s.arr[I] = 0; // expected-warning {{array index 5 is past the end of the array (which contains 3 elements)}} +} + +void test_templates() { + f<5>(); // expected-note {{in instantiation}} +} + +#define SIZE 10 +#define ARR_IN_MACRO(flag, arr, idx) flag ? arr[idx] : 1 + +int test_no_warn_macro_unreachable() { + int arr[SIZE]; // expected-note {{array 'arr' declared here}} + return ARR_IN_MACRO(0, arr, SIZE) + // no-warning + ARR_IN_MACRO(1, arr, SIZE); // expected-warning{{array index 10 is past the end of the array (which contains 10 elements)}} +} + +// This exhibited an assertion failure for a 32-bit build of Clang. +int test_pr9240() { + short array[100]; // expected-note {{array 'array' declared here}} + return array[(unsigned long long) 100]; // expected-warning {{array index 100 is past the end of the array (which contains 100 elements)}} +} + +// PR 9284 - a template parameter can cause an array bounds access to be +// infeasible. +template <bool extendArray> +void pr9284() { + int arr[3 + (extendArray ? 1 : 0)]; + + if (extendArray) + arr[3] = 42; // no-warning +} + +template <bool extendArray> +void pr9284b() { + int arr[3 + (extendArray ? 1 : 0)]; // expected-note {{array 'arr' declared here}} + + if (!extendArray) + arr[3] = 42; // expected-warning{{array index 3 is past the end of the array (which contains 3 elements)}} +} + +void test_pr9284() { + pr9284<true>(); + pr9284<false>(); + pr9284b<true>(); + pr9284b<false>(); // expected-note{{in instantiation of function template specialization 'pr9284b<false>' requested here}} +} + +int test_pr9296() { + int array[2]; + 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 2 is past the end of the array (which 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 2 is past the end of the array (which 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 +} + +namespace tailpad { + struct foo { + char c1[1]; // expected-note {{declared here}} + int x; + char c2[1]; + }; + + class baz { + public: + char c1[1]; // expected-note {{declared here}} + int x; + char c2[1]; + }; + + char bar(struct foo *F, baz *B) { + return F->c1[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}} + F->c2[3] + // no warning, foo could have tail padding allocated. + B->c1[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}} + B->c2[3]; // no warning, baz could have tail padding allocated. + } +} + +namespace metaprogramming { +#define ONE 1 + struct foo { char c[ONE]; }; // expected-note {{declared here}} + template <int N> struct bar { char c[N]; }; // expected-note {{declared here}} + + char test(foo *F, bar<1> *B) { + return F->c[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}} + B->c[3]; // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}} + } +} + +void bar(int x) {} +int test_more() { + int foo[5]; // expected-note 5 {{array 'foo' declared here}} + bar(foo[5]); // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}} + ++foo[5]; // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}} + if (foo[6]) // expected-warning {{array index 6 is past the end of the array (which contains 5 elements)}} + return --foo[6]; // expected-warning {{array index 6 is past the end of the array (which contains 5 elements)}} + else + return foo[5]; // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}} +} + +void test_pr10771() { + double foo[4096]; // expected-note {{array 'foo' declared here}} + + ((char*)foo)[sizeof(foo) - 1] = '\0'; // no-warning + *(((char*)foo) + sizeof(foo) - 1) = '\0'; // no-warning + + ((char*)foo)[sizeof(foo)] = '\0'; // expected-warning {{array index 32768 is past the end of the array (which contains 32768 elements)}} + + // TODO: This should probably warn, too. + *(((char*)foo) + sizeof(foo)) = '\0'; // no-warning +} + +int test_pr11007_aux(const char * restrict, ...); + +// Test checking with varargs. +void test_pr11007() { + double a[5]; // expected-note {{array 'a' declared here}} + test_pr11007_aux("foo", a[1000]); // expected-warning {{array index 1000 is past the end of the array}} +} + +void test_rdar10916006(void) +{ + int a[128]; // expected-note {{array 'a' declared here}} + a[(unsigned char)'\xA1'] = 1; // expected-warning {{array index 161 is past the end of the array}} +} diff --git a/clang/test/SemaCXX/arrow-operator.cpp b/clang/test/SemaCXX/arrow-operator.cpp new file mode 100644 index 0000000..6535a0a --- /dev/null +++ b/clang/test/SemaCXX/arrow-operator.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct T { + void f(); +}; + +struct A { + T* operator->(); // expected-note{{candidate function}} +}; + +struct B { + T* operator->(); // expected-note{{candidate function}} +}; + +struct C : A, B { +}; + +struct D : A { }; + +struct E; // expected-note {{forward declaration of 'E'}} + +void f(C &c, D& d, E& e) { + c->f(); // expected-error{{use of overloaded operator '->' is ambiguous}} + d->f(); + e->f(); // expected-error{{incomplete definition of type}} +} + +// rdar://8875304 +namespace rdar8875304 { +class Point {}; +class Line_Segment{ public: Line_Segment(const Point&){} }; +class Node { public: Point Location(){ Point p; return p; } }; + +void f() +{ + Node** node1; + Line_Segment(node1->Location()); // expected-error {{not a structure or union}} +} +} diff --git a/clang/test/SemaCXX/atomic-type.cxx b/clang/test/SemaCXX/atomic-type.cxx new file mode 100644 index 0000000..18707eb --- /dev/null +++ b/clang/test/SemaCXX/atomic-type.cxx @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -verify %s + +template<typename T> struct atomic { + _Atomic(T) value; +}; + +template<typename T> struct user { + struct inner { char n[sizeof(T)]; }; + atomic<inner> i; +}; + +user<int> u; + +// Test overloading behavior of atomics. +struct A { }; + +int &ovl1(_Atomic(int)); +long &ovl1(_Atomic(long)); +float &ovl1(_Atomic(float)); +double &ovl1(_Atomic(A const *const *)); +short &ovl1(_Atomic(A **)); + +void test_overloading(int i, float f, _Atomic(int) ai, _Atomic(float) af, + long l, _Atomic(long) al, A const *const *acc, + A const ** ac, A **a) { + int& ir1 = ovl1(i); + int& ir2 = ovl1(ai); + long& lr1 = ovl1(l); + long& lr2 = ovl1(al); + float &fr1 = ovl1(f); + float &fr2 = ovl1(af); + double &dr1 = ovl1(acc); + double &dr2 = ovl1(ac); + short &sr1 = ovl1(a); +} diff --git a/clang/test/SemaCXX/attr-after-definition.cpp b/clang/test/SemaCXX/attr-after-definition.cpp new file mode 100644 index 0000000..148a63e --- /dev/null +++ b/clang/test/SemaCXX/attr-after-definition.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct X { }; +struct Y { }; + +bool f0(X) { return true; } // expected-note{{definition}} +bool f1(X) { return true; } + +__attribute__ ((__visibility__("hidden"))) bool f0(X); // expected-warning{{attribute}} +__attribute__ ((__visibility__("hidden"))) bool f1(Y); diff --git a/clang/test/SemaCXX/attr-cxx0x.cpp b/clang/test/SemaCXX/attr-cxx0x.cpp new file mode 100644 index 0000000..4281895 --- /dev/null +++ b/clang/test/SemaCXX/attr-cxx0x.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +int align_illegal alignas(3); //expected-error {{requested alignment is not a power of 2}} +char align_big alignas(int); +int align_small alignas(1); // FIXME: this should be rejected +int align_multiple alignas(1) alignas(8) alignas(1); + +struct align_member { + int member alignas(8); +}; + +template <unsigned A> struct alignas(A) align_class_template {}; + +// FIXME: these should not error +template <typename... T> alignas(T...) struct align_class_temp_pack_type {}; // expected-error{{pack expansions in alignment specifiers are not supported yet}} +template <unsigned... A> alignas(A...) struct align_class_temp_pack_expr {}; // expected-error{{pack expansions in alignment specifiers are not supported yet}} + +typedef char align_typedef alignas(8); +template<typename T> using align_alias_template = align_typedef; + +static_assert(alignof(align_big) == alignof(int), "k's alignment is wrong"); +static_assert(alignof(align_small) == 1, "j's alignment is wrong"); +static_assert(alignof(align_multiple) == 8, "l's alignment is wrong"); +static_assert(alignof(align_member) == 8, "quuux's alignment is wrong"); +static_assert(sizeof(align_member) == 8, "quuux's size is wrong"); +static_assert(alignof(align_typedef) == 8, "typedef's alignment is wrong"); +static_assert(alignof(align_class_template<8>) == 8, "template's alignment is wrong"); +static_assert(alignof(align_class_template<16>) == 16, "template's alignment is wrong"); +// FIXME: enable these tests +// static_assert(alignof(align_class_temp_pack_type<short, int, long>) == alignof(long), "template's alignment is wrong"); +// static_assert(alignof(align_class_temp_pack_expr<8, 16, 32>) == 32, "template's alignment is wrong"); +static_assert(alignof(align_alias_template<int>) == 8, "alias template's alignment is wrong"); diff --git a/clang/test/SemaCXX/attr-declspec-ignored.cpp b/clang/test/SemaCXX/attr-declspec-ignored.cpp new file mode 100644 index 0000000..0503750 --- /dev/null +++ b/clang/test/SemaCXX/attr-declspec-ignored.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only + +namespace test1 { + __attribute__((visibility("hidden"))) __attribute__((aligned)) class A; // expected-warning{{attribute 'visibility' is ignored, place it after "class" to apply attribute to type declaration}} \ + // expected-warning{{attribute 'aligned' is ignored, place it after "class" to apply attribute to type declaration}} + __attribute__((visibility("hidden"))) __attribute__((aligned)) struct B; // expected-warning{{attribute 'visibility' is ignored, place it after "struct" to apply attribute to type declaration}} \ + // expected-warning{{attribute 'aligned' is ignored, place it after "struct" to apply attribute to type declaration}} + __attribute__((visibility("hidden"))) __attribute__((aligned)) union C; // expected-warning{{attribute 'visibility' is ignored, place it after "union" to apply attribute to type declaration}} \ + // expected-warning{{attribute 'aligned' is ignored, place it after "union" to apply attribute to type declaration}} + __attribute__((visibility("hidden"))) __attribute__((aligned)) enum D {D}; // expected-warning{{attribute 'visibility' is ignored, place it after "enum" to apply attribute to type declaration}} \ + // expected-warning{{attribute 'aligned' is ignored, place it after "enum" to apply attribute to type declaration}} +} + +namespace test2 { + __attribute__((visibility("hidden"))) __attribute__((aligned)) class A {} a; + __attribute__((visibility("hidden"))) __attribute__((aligned)) struct B {} b; + __attribute__((visibility("hidden"))) __attribute__((aligned)) union C {} c; + __attribute__((visibility("hidden"))) __attribute__((aligned)) enum D {D} d; +} diff --git a/clang/test/SemaCXX/attr-deprecated.cpp b/clang/test/SemaCXX/attr-deprecated.cpp new file mode 100644 index 0000000..46568aa --- /dev/null +++ b/clang/test/SemaCXX/attr-deprecated.cpp @@ -0,0 +1,235 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +class A { + void f() __attribute__((deprecated)); + void g(A* a); + void h(A* a) __attribute__((deprecated)); + + int b __attribute__((deprecated)); +}; + +void A::g(A* a) +{ + f(); // expected-warning{{'f' is deprecated}} + a->f(); // expected-warning{{'f' is deprecated}} + + (void)b; // expected-warning{{'b' is deprecated}} + (void)a->b; // expected-warning{{'b' is deprecated}} +} + +void A::h(A* a) +{ + f(); + a->f(); + + (void)b; + (void)a->b; +} + +struct B { + virtual void f() __attribute__((deprecated)); + void g(); +}; + +void B::g() { + f(); + B::f(); // expected-warning{{'f' is deprecated}} +} + +struct C : B { + virtual void f(); + void g(); +}; + +void C::g() { + f(); + C::f(); + B::f(); // expected-warning{{'f' is deprecated}} +} + +void f(B* b, C *c) { + b->f(); + b->B::f(); // expected-warning{{'f' is deprecated}} + + c->f(); + c->C::f(); + c->B::f(); // expected-warning{{'f' is deprecated}} +} + +struct D { + virtual void f() __attribute__((deprecated)); +}; + +void D::f() { } + +void f(D* d) { + d->f(); +} + + +// Overloaded namespace members. +namespace test1 { + void foo(int) __attribute__((deprecated)); + void test1() { foo(10); } // expected-warning {{deprecated}} + void foo(short) __attribute__((deprecated)); + void test2(short s) { foo(s); } // expected-warning {{deprecated}} + void foo(long); + void test3(long l) { foo(l); } + struct A { + friend void foo(A*) __attribute__((deprecated)); + }; + void test4(A *a) { foo(a); } // expected-warning {{deprecated}} + + namespace ns { + struct Foo {}; + void foo(const Foo &f) __attribute__((deprecated)); + } + void test5() { + foo(ns::Foo()); // expected-warning {{deprecated}} + } +} + +// Overloaded class members. +namespace test2 { + struct A { + void foo(int) __attribute__((deprecated)); + void foo(long); + static void bar(int) __attribute__((deprecated)); + static void bar(long); + + void test2(int i, long l); + }; + void test1(int i, long l) { + A a; + a.foo(i); // expected-warning {{deprecated}} + a.foo(l); + a.bar(i); // expected-warning {{deprecated}} + a.bar(l); + A::bar(i); // expected-warning {{deprecated}} + A::bar(l); + } + + void A::test2(int i, long l) { + foo(i); // expected-warning {{deprecated}} + foo(l); + bar(i); // expected-warning {{deprecated}} + bar(l); + } +} + +// Overloaded operators. +namespace test3 { + struct A { + void operator*(const A &); + void operator*(int) __attribute__((deprecated)); + void operator-(const A &) const; + }; + void operator+(const A &, const A &); + void operator+(const A &, int) __attribute__((deprecated)); + void operator-(const A &, int) __attribute__((deprecated)); + + void test() { + A a, b; + a + b; + a + 1; // expected-warning {{deprecated}} + a - b; + a - 1; // expected-warning {{deprecated}} + a * b; + a * 1; // expected-warning {{deprecated}} + } +} + +// Overloaded operator call. +namespace test4 { + struct A { + typedef void (*intfn)(int); + typedef void (*unintfn)(unsigned); + operator intfn() __attribute__((deprecated)); + operator unintfn(); + void operator ()(A &) __attribute__((deprecated)); + void operator ()(const A &); + }; + + void test() { + A a; + a(1); // expected-warning {{deprecated}} + a(1U); + + A &b = a; + const A &c = a; + a(b); // expected-warning {{deprecated}} + a(c); + } +} + +namespace test5 { + struct A { + operator int() __attribute__((deprecated)); + operator long(); + }; + void test1(A a) { + int i = a; // expected-warning {{deprecated}} + long l = a; + } + + void foo(int); + void foo(void*); + void bar(long); + void bar(void*); + void test2(A a) { + foo(a); // expected-warning {{deprecated}} + bar(a); + } + + struct B { + int myInt; + long myLong; + + B(A &a) : + myInt(a), // expected-warning {{deprecated}} + myLong(a) + {} + }; +} + +// rdar://problem/8518751 +namespace test6 { + enum __attribute__((deprecated)) A { + a0 + }; + void testA() { + A x; // expected-warning {{'A' is deprecated}} + x = a0; // expected-warning {{'a0' is deprecated}} + } + + enum B { + b0 __attribute__((deprecated)), + b1 + }; + void testB() { + B x; + x = b0; // expected-warning {{'b0' is deprecated}} + x = b1; + } + + template <class T> struct C { + enum __attribute__((deprecated)) Enum { + c0 + }; + }; + void testC() { + C<int>::Enum x; // expected-warning {{'Enum' is deprecated}} + x = C<int>::c0; // expected-warning {{'c0' is deprecated}} + } + + template <class T> struct D { + enum Enum { + d0, + d1 __attribute__((deprecated)), + }; + }; + void testD() { + D<int>::Enum x; + x = D<int>::d0; + x = D<int>::d1; // expected-warning {{'d1' is deprecated}} + } +} diff --git a/clang/test/SemaCXX/attr-format.cpp b/clang/test/SemaCXX/attr-format.cpp new file mode 100644 index 0000000..da134a1 --- /dev/null +++ b/clang/test/SemaCXX/attr-format.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fsyntax-only -Wformat-nonliteral -verify %s +struct S { + static void f(const char*, ...) __attribute__((format(printf, 1, 2))); + static const char* f2(const char*) __attribute__((format_arg(1))); + + // GCC has a hidden 'this' argument in member functions which is why + // the format argument is argument 2 here. + void g(const char*, ...) __attribute__((format(printf, 2, 3))); + const char* g2(const char*) __attribute__((format_arg(2))); + + void h(const char*, ...) __attribute__((format(printf, 1, 4))); // \ + expected-error{{implicit this argument as the format string}} + void h2(const char*, ...) __attribute__((format(printf, 2, 1))); // \ + expected-error{{out of bounds}} + const char* h3(const char*) __attribute__((format_arg(1))); // \ + expected-error{{invalid for the implicit this argument}} +}; + +// PR5521 +struct A { void a(const char*,...) __attribute((format(printf,2,3))); }; +void b(A x) { + x.a("%d", 3); +} + +// PR8625: correctly interpret static member calls as not having an implicit +// 'this' argument. +namespace PR8625 { + struct S { + static void f(const char*, const char*, ...) + __attribute__((format(printf, 2, 3))); + }; + void test(S s, const char* str) { + s.f(str, "%s", str); + } +} diff --git a/clang/test/SemaCXX/attr-nonnull.cpp b/clang/test/SemaCXX/attr-nonnull.cpp new file mode 100644 index 0000000..09c054c --- /dev/null +++ b/clang/test/SemaCXX/attr-nonnull.cpp @@ -0,0 +1,33 @@ +// 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 + // argument is the one that must not be null. + void g(const char*, const char*, const char*) __attribute__((nonnull(3))); + + void h(const char*) __attribute__((nonnull(1))); // \ + expected-error{{invalid for the implicit this argument}} +}; + +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}} + s.g(0, "", 0); +} + +namespace rdar8769025 { + __attribute__((nonnull)) void f0(int *&p); + __attribute__((nonnull)) void f1(int * const &p); + __attribute__((nonnull(2))) void f2(int i, int * const &p); + + void test_f1() { + f1(0); // expected-warning{{null passed to a callee which requires a non-null argument}} + f2(0, 0); // expected-warning{{null passed to a callee which requires a non-null argument}} + } +} diff --git a/clang/test/SemaCXX/attr-noreturn.cpp b/clang/test/SemaCXX/attr-noreturn.cpp new file mode 100644 index 0000000..eaf0d0c --- /dev/null +++ b/clang/test/SemaCXX/attr-noreturn.cpp @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Reachability tests have to come first because they get suppressed +// if any errors have occurred. +namespace test5 { + struct A { + __attribute__((noreturn)) void fail(); + void nofail(); + } a; + + int &test1() { + a.nofail(); + } // expected-warning {{control reaches end of non-void function}} + + int &test2() { + a.fail(); + } +} + +// PR5620 +void f0() __attribute__((__noreturn__)); +void f1(void (*)()); +void f2() { f1(f0); } + +// Taking the address of a noreturn function +void test_f0a() { + void (*fp)() = f0; + void (*fp1)() __attribute__((noreturn)) = f0; +} + +// Taking the address of an overloaded noreturn function +void f0(int) __attribute__((__noreturn__)); + +void test_f0b() { + void (*fp)() = f0; + void (*fp1)() __attribute__((noreturn)) = f0; +} + +// No-returned function pointers +typedef void (* noreturn_fp)() __attribute__((noreturn)); + +void f3(noreturn_fp); // expected-note{{candidate function}} + +void test_f3() { + f3(f0); // okay + f3(f2); // expected-error{{no matching function for call}} +} + + +class xpto { + int blah() __attribute__((noreturn)); +}; + +int xpto::blah() { + return 3; // expected-warning {{function 'blah' declared 'noreturn' should not return}} +} diff --git a/clang/test/SemaCXX/attr-regparm.cpp b/clang/test/SemaCXX/attr-regparm.cpp new file mode 100644 index 0000000..91ee613 --- /dev/null +++ b/clang/test/SemaCXX/attr-regparm.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-pc-linux-gnu %s +// RUN: %clang_cc1 -fsyntax-only -verify -triple i686-apple-darwin10 %s + +// PR7025 +struct X0 { + void __attribute__((regparm(3))) f0(); + void __attribute__((regparm(3))) f1(); + void __attribute__((regparm(3))) f2(); // expected-note{{previous declaration is here}} + void f3(); // expected-note{{previous declaration is here}} +}; + +void X0::f0() { } +void __attribute__((regparm(3))) X0::f1() { } +void __attribute__((regparm(2))) X0::f2() { } // expected-error{{function declared with with regparm(2) attribute was previously declared with the regparm(3) attribute}} +void __attribute__((regparm(2))) X0::f3() { } // expected-error{{function declared with with regparm(2) attribute was previously declared without the regparm attribute}} diff --git a/clang/test/SemaCXX/attr-sentinel.cpp b/clang/test/SemaCXX/attr-sentinel.cpp new file mode 100644 index 0000000..92c6e21 --- /dev/null +++ b/clang/test/SemaCXX/attr-sentinel.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f(int, ...) __attribute__((sentinel)); + +void g() { + f(1, 2, __null); +} + +typedef __typeof__(sizeof(int)) size_t; + +struct S { + S(int,...) __attribute__((sentinel)); // expected-note {{marked sentinel}} + void a(int,...) __attribute__((sentinel)); // expected-note {{marked sentinel}} + void* operator new(size_t,...) __attribute__((sentinel)); // expected-note {{marked sentinel}} + void operator()(int,...) __attribute__((sentinel)); // expected-note {{marked sentinel}} +}; + +void class_test() { + S s(1,2,3); // expected-warning {{missing sentinel in function call}} + S* s2 = new (1,2,3) S(1, __null); // expected-warning {{missing sentinel in function call}} + s2->a(1,2,3); // expected-warning {{missing sentinel in function call}} + s(1,2,3); // expected-warning {{missing sentinel in function call}} +} diff --git a/clang/test/SemaCXX/attr-unavailable.cpp b/clang/test/SemaCXX/attr-unavailable.cpp new file mode 100644 index 0000000..2d82668 --- /dev/null +++ b/clang/test/SemaCXX/attr-unavailable.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int &foo(int); // expected-note {{candidate}} +double &foo(double); // expected-note {{candidate}} +void foo(...) __attribute__((__unavailable__)); // expected-note {{candidate function}} \ +// expected-note{{function has been explicitly marked unavailable here}} + +void bar(...) __attribute__((__unavailable__)); // expected-note 2{{explicitly marked unavailable}} + +void test_foo(short* sp) { + int &ir = foo(1); + double &dr = foo(1.0); + foo(sp); // expected-error{{call to unavailable function 'foo'}} + + void (*fp)(...) = &bar; // expected-error{{'bar' is unavailable}} + void (*fp2)(...) = bar; // expected-error{{'bar' is unavailable}} + + int &(*fp3)(int) = foo; + void (*fp4)(...) = foo; // expected-error{{'foo' is unavailable}} +} + +namespace radar9046492 { +// rdar://9046492 +#define FOO __attribute__((unavailable("not available - replaced"))) + +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}} +} +} + +void unavail(short* sp) __attribute__((__unavailable__)); +void unavail(short* sp) { + // No complains inside an unavailable function. + int &ir = foo(1); + double &dr = foo(1.0); + foo(sp); + foo(); +} diff --git a/clang/test/SemaCXX/attr-weak.cpp b/clang/test/SemaCXX/attr-weak.cpp new file mode 100644 index 0000000..b6a9e0a --- /dev/null +++ b/clang/test/SemaCXX/attr-weak.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only -verify %s + +static int test0 __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} +static void test1() __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} + +namespace test2 __attribute__((weak)) { // expected-warning {{'weak' attribute only applies to variables and functions}} +} + +namespace { + int test3 __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} + void test4() __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} +} + +struct Test5 { + static void test5() __attribute__((weak)); // no error +}; + +namespace { + struct Test6 { + static void test6() __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}} + }; +} + +template <class T> struct Test7 { + void test7() __attribute__((weak)) {} +}; +namespace { class Internal; } +template struct Test7<Internal>; +template struct Test7<int>; diff --git a/clang/test/SemaCXX/attr-weakref.cpp b/clang/test/SemaCXX/attr-weakref.cpp new file mode 100644 index 0000000..a345791 --- /dev/null +++ b/clang/test/SemaCXX/attr-weakref.cpp @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only -verify %s + +// GCC will accept anything as the argument of weakref. Should we +// check for an existing decl? +static int a1() __attribute__((weakref ("foo"))); +static int a2() __attribute__((weakref, alias ("foo"))); + +static int a3 __attribute__((weakref ("foo"))); +static int a4 __attribute__((weakref, alias ("foo"))); + +// gcc rejects, clang accepts +static int a5 __attribute__((alias ("foo"), weakref)); + +// this is pointless, but accepted by gcc. We reject it. +static int a6 __attribute__((weakref)); //expected-error {{weakref declaration of 'a6' must also have an alias attribute}} + +// gcc warns, clang rejects +void f(void) { + static int a __attribute__((weakref ("v2"))); // expected-error {{declaration of 'a' must be in a global context}} +} + +// both gcc and clang reject +class c { + static int a __attribute__((weakref ("v2"))); // expected-error {{declaration of 'a' must be in a global context}} + static int b() __attribute__((weakref ("f3"))); // expected-error {{declaration of 'b' must be in a global context}} +}; +int a7() __attribute__((weakref ("f1"))); // expected-error {{weakref declaration must have internal linkage}} +int a8 __attribute__((weakref ("v1"))); // expected-error {{weakref declaration must have internal linkage}} + +// gcc accepts this +int a9 __attribute__((weakref)); // expected-error {{weakref declaration must have internal linkage}} diff --git a/clang/test/SemaCXX/auto-cxx0x.cpp b/clang/test/SemaCXX/auto-cxx0x.cpp new file mode 100644 index 0000000..a8f9e84 --- /dev/null +++ b/clang/test/SemaCXX/auto-cxx0x.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 +void f() { + auto int a; // expected-warning {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} + int auto b; // expected-error{{cannot combine with previous 'int' declaration specifier}} +} diff --git a/clang/test/SemaCXX/auto-cxx98.cpp b/clang/test/SemaCXX/auto-cxx98.cpp new file mode 100644 index 0000000..1e28d06 --- /dev/null +++ b/clang/test/SemaCXX/auto-cxx98.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98 -Wc++11-compat +void f() { + auto int a; // expected-warning {{'auto' storage class specifier is redundant and incompatible with C++11}} + int auto b; // expected-warning {{'auto' storage class specifier is redundant and incompatible with C++11}} + auto c; // expected-warning {{C++11 extension}} expected-error {{requires an initializer}} + static auto d = 0; // expected-warning {{C++11 extension}} + auto static e = 0; // expected-warning {{C++11 extension}} +} diff --git a/clang/test/SemaCXX/auto-subst-failure.cpp b/clang/test/SemaCXX/auto-subst-failure.cpp new file mode 100644 index 0000000..b323dfc --- /dev/null +++ b/clang/test/SemaCXX/auto-subst-failure.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +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/clang/test/SemaCXX/bitfield-layout.cpp b/clang/test/SemaCXX/bitfield-layout.cpp new file mode 100644 index 0000000..adecf55 --- /dev/null +++ b/clang/test/SemaCXX/bitfield-layout.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=x86_64-apple-darwin10 + +#define CHECK_SIZE(name, size) extern int name##1[sizeof(name) == size ? 1 : -1]; +#define CHECK_ALIGN(name, size) extern int name##2[__alignof(name) == size ? 1 : -1]; + +// Simple tests. +struct Test1 { + char c : 9; // expected-warning {{size of bit-field 'c' (9 bits) exceeds the size of its type; value will be truncated to 8 bits}} +}; +CHECK_SIZE(Test1, 2); +CHECK_ALIGN(Test1, 1); + +struct Test2 { + char c : 16; // expected-warning {{size of bit-field 'c' (16 bits) exceeds the size of its type; value will be truncated to 8 bits}} +}; +CHECK_SIZE(Test2, 2); +CHECK_ALIGN(Test2, 2); + +struct Test3 { + char c : 32; // expected-warning {{size of bit-field 'c' (32 bits) exceeds the size of its type; value will be truncated to 8 bits}} +}; +CHECK_SIZE(Test3, 4); +CHECK_ALIGN(Test3, 4); + +struct Test4 { + char c : 64; // expected-warning {{size of bit-field 'c' (64 bits) exceeds the size of its type; value will be truncated to 8 bits}} +}; +CHECK_SIZE(Test4, 8); +CHECK_ALIGN(Test4, 8); + diff --git a/clang/test/SemaCXX/block-call.cpp b/clang/test/SemaCXX/block-call.cpp new file mode 100644 index 0000000..d519911 --- /dev/null +++ b/clang/test/SemaCXX/block-call.cpp @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -x c++ -fsyntax-only -verify %s -fblocks + +int (*FP)(); +int (^IFP) (); +int (^II) (int); +int main() { + int (*FPL) (int) = FP; // expected-error {{cannot initialize a variable of type 'int (*)(int)' with an lvalue of type 'int (*)()'}} + + // For Blocks, the ASTContext::typesAreBlockCompatible() makes sure this is an error. + int (^PFR) (int) = IFP; // expected-error {{cannot initialize a variable of type 'int (^)(int)' with an lvalue of type 'int (^)()'}} + PFR = II; // OK + + int (^IFP) () = PFR; // OK + + + const int (^CIC) () = IFP; // OK - initializing 'const int (^)()' with an expression of type 'int (^)()'}} + + const int (^CICC) () = CIC; + + + int * const (^IPCC) () = 0; + + int * const (^IPCC1) () = IPCC; + + int * (^IPCC2) () = IPCC; // expected-error {{cannot initialize a variable of type 'int *(^)()' with an lvalue of type 'int *const (^)()'}} + + int (^IPCC3) (const int) = PFR; + + int (^IPCC4) (int, char (^CArg) (double)); + + int (^IPCC5) (int, char (^CArg) (double)) = IPCC4; + + int (^IPCC6) (int, char (^CArg) (float)) = IPCC4; // expected-error {{cannot initialize a variable of type 'int (^)(int, char (^)(float))' with an lvalue of type}} + + IPCC2 = 0; + IPCC2 = 1; + int (^x)() = 0; + int (^y)() = 3; // expected-error {{cannot initialize a variable of type 'int (^)()' with an rvalue of type 'int'}} + int a = 1; + int (^z)() = a+4; // expected-error {{cannot initialize a variable of type 'int (^)()' with an rvalue of type 'int'}} +} + +int blah() { + int (^IFP) (float); + char (^PCP)(double, double, char); + + IFP(1.0); + IFP (1.0, 2.0); // expected-error {{too many arguments to block call}} + + char ch = PCP(1.0, 2.0, 'a'); + return PCP(1.0, 2.0); // expected-error {{too few arguments to block}} +} diff --git a/clang/test/SemaCXX/blocks-1.cpp b/clang/test/SemaCXX/blocks-1.cpp new file mode 100644 index 0000000..1b15094 --- /dev/null +++ b/clang/test/SemaCXX/blocks-1.cpp @@ -0,0 +1,58 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks -std=c++11 + +extern "C" int exit(int); + +typedef struct { + unsigned long ps[30]; + int qs[30]; +} BobTheStruct; + +int main (int argc, const char * argv[]) { + BobTheStruct inny; + BobTheStruct outty; + BobTheStruct (^copyStruct)(BobTheStruct); + int i; + + for(i=0; i<30; i++) { + inny.ps[i] = i * i * i; + inny.qs[i] = -i * i * i; + } + + copyStruct = ^(BobTheStruct aBigStruct){ return aBigStruct; }; // pass-by-value intrinsically copies the argument + + outty = copyStruct(inny); + + if ( &inny == &outty ) { + exit(1); + } + for(i=0; i<30; i++) { + if ( (inny.ps[i] != outty.ps[i]) || (inny.qs[i] != outty.qs[i]) ) { + exit(1); + } + } + + return 0; +} + +namespace rdar8134521 { + void foo() { + int (^P)(int) = reinterpret_cast<int(^)(int)>(1); + P = (int(^)(int))(1); + + P = reinterpret_cast<int(^)(int)>((void*)1); + P = (int(^)(int))((void*)1); + } +} + +namespace rdar11055105 { + struct A { + void foo(); + }; + + template <class T> void foo(T &x) noexcept(noexcept(x.foo())); + + void (^block)() = ^{ + A a; + foo(a); + }; +} diff --git a/clang/test/SemaCXX/blocks.cpp b/clang/test/SemaCXX/blocks.cpp new file mode 100644 index 0000000..adbff55 --- /dev/null +++ b/clang/test/SemaCXX/blocks.cpp @@ -0,0 +1,70 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks + +void tovoid(void*); + +void tovoid_test(int (^f)(int, int)) { + tovoid(f); +} + +void reference_lvalue_test(int& (^f)()) { + f() = 10; +} + +// PR 7165 +namespace test1 { + void g(void (^)()); + struct Foo { + void foo(); + void test() { + (void) ^{ foo(); }; + } + }; +} + +namespace test2 { + int repeat(int value, int (^block)(int), unsigned n) { + while (n--) value = block(value); + return value; + } + + class Power { + int base; + + public: + Power(int base) : base(base) {} + int calculate(unsigned n) { + return repeat(1, ^(int v) { return v * base; }, n); + } + }; + + int test() { + return Power(2).calculate(10); + } +} + +// rdar: // 8382559 +namespace radar8382559 { + void func(bool& outHasProperty); + + int test3() { + __attribute__((__blocks__(byref))) bool hasProperty = false; + bool has = true; + + bool (^b)() = ^ { + func(hasProperty); + if (hasProperty) + hasProperty = 0; + if (has) + hasProperty = 1; + return hasProperty; + }; + func(hasProperty); + func(has); + b(); + if (hasProperty) + hasProperty = 1; + if (has) + has = 2; + return hasProperty = 1; + } +} diff --git a/clang/test/SemaCXX/bool.cpp b/clang/test/SemaCXX/bool.cpp new file mode 100644 index 0000000..2b3ab68 --- /dev/null +++ b/clang/test/SemaCXX/bool.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Bool literals can be enum values. +enum { + ReadWrite = false, + ReadOnly = true +}; + +// bool cannot be decremented, and gives a warning on increment +void test(bool b) +{ + ++b; // expected-warning {{incrementing expression of type bool is deprecated}} + b++; // expected-warning {{incrementing expression of type bool is deprecated}} + --b; // expected-error {{cannot decrement expression of type bool}} + b--; // expected-error {{cannot decrement expression of type bool}} + + bool *b1 = (int *)0; // expected-error{{cannot initialize}} +} + +// static_assert_arg_is_bool(x) compiles only if x is a bool. +template <typename T> +void static_assert_arg_is_bool(T x) { + bool* p = &x; +} + +void test2() { + int n = 2; + static_assert_arg_is_bool(n && 4); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + static_assert_arg_is_bool(n || 5); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} +} diff --git a/clang/test/SemaCXX/borland-extensions.cpp b/clang/test/SemaCXX/borland-extensions.cpp new file mode 100644 index 0000000..4831530 --- /dev/null +++ b/clang/test/SemaCXX/borland-extensions.cpp @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fborland-extensions + +// Borland extensions + +// 1. test -fborland-extensions +int dummy_function() { return 0; } + +// 2. test __pascal +int _pascal f2(); + +float __pascal gi2(int, int); +template<typename T> T g2(T (__pascal * const )(int, int)) { return 0; } + +struct M { + int __pascal addP(); + float __pascal subtractP(); +}; +template<typename T> int h2(T (__pascal M::* const )()) { return 0; } +void m2() { + int i; float f; + i = f2(); + f = gi2(2, i); + f = g2(gi2); + i = h2<int>(&M::addP); + f = h2(&M::subtractP); +} + +// 3. test other calling conventions +int _cdecl fa3(); +int _fastcall fc3(); +int _stdcall fd3(); + +// 4. test __uuidof() +typedef struct _GUID { + unsigned long Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[ 8 ]; +} GUID; + +struct __declspec(uuid("{12345678-1234-1234-1234-123456789abc}")) Foo; +struct Data { + GUID const* Guid; +}; + +void t4() { + unsigned long data; + + const GUID guid_inl = __uuidof(Foo); + Data ata1 = { &guid_inl}; + data = ata1.Guid->Data1; +} + diff --git a/clang/test/SemaCXX/builtin-exception-spec.cpp b/clang/test/SemaCXX/builtin-exception-spec.cpp new file mode 100644 index 0000000..324d20e --- /dev/null +++ b/clang/test/SemaCXX/builtin-exception-spec.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -isystem %S/Inputs -fsyntax-only -verify %s +#include <malloc.h> + +extern "C" { +void *malloc(__SIZE_TYPE__); +} diff --git a/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp new file mode 100644 index 0000000..61e3478 --- /dev/null +++ b/clang/test/SemaCXX/builtin-ptrtomember-ambig.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct A {}; + +struct R { + operator const A*(); +}; + + +struct B : R { + operator A*(); +}; + +struct C : B { + +}; + + +void foo(C c, int A::* pmf) { + // FIXME. Why so many built-in candidates? + int i = c->*pmf; // expected-error {{use of overloaded operator '->*' is ambiguous}} \ + // expected-note {{built-in candidate operator->*(const struct A *, const int struct A::*)}} \ + // expected-note {{built-in candidate operator->*(const struct A *, int struct A::*)}} \ + // expected-note {{built-in candidate operator->*(struct A *, const int struct A::*)}} \ + // expected-note {{built-in candidate operator->*(struct A *, int struct A::*)}} +} + diff --git a/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp b/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp new file mode 100644 index 0000000..2d93c6b --- /dev/null +++ b/clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct A {}; +struct E {}; + +struct R { + operator A*(); + operator E*(); // expected-note{{candidate function}} +}; + + +struct S { + operator A*(); + operator E*(); // expected-note{{candidate function}} +}; + +struct B : R { + operator A*(); +}; + +struct C : B { + +}; + +void foo(C c, int A::* pmf) { + int i = c->*pmf; +} + +struct B1 : R, S { + operator A*(); +}; + +struct C1 : B1 { + +}; + +void foo1(C1 c1, int A::* pmf) { + int i = c1->*pmf; + c1->*pmf = 10; +} + +void foo1(C1 c1, int E::* pmf) { + int i = c1->*pmf; // expected-error {{use of overloaded operator '->*' is ambiguous}} \ + // expected-note {{because of ambiguity in conversion of 'C1' to 'E *'}} \ + // expected-note 4 {{built-in candidate operator}} +} diff --git a/clang/test/SemaCXX/builtin-ptrtomember-overload.cpp b/clang/test/SemaCXX/builtin-ptrtomember-overload.cpp new file mode 100644 index 0000000..c7b5173 --- /dev/null +++ b/clang/test/SemaCXX/builtin-ptrtomember-overload.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct A {}; + +struct B { + operator A*(); +}; + +struct C : B { + +}; + + +void foo(C c, B b, int A::* pmf) { + int j = c->*pmf; + int i = b->*pmf; +} + +struct D { + operator const D *(); +}; + +struct DPtr { + operator volatile int D::*(); +}; + +int test(D d, DPtr dptr) { + return d->*dptr; +} + diff --git a/clang/test/SemaCXX/builtin_objc_msgSend.cpp b/clang/test/SemaCXX/builtin_objc_msgSend.cpp new file mode 100644 index 0000000..0e90d54 --- /dev/null +++ b/clang/test/SemaCXX/builtin_objc_msgSend.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// rdar://8686888 + +typedef struct objc_selector *SEL; +typedef struct objc_object *id; + +extern "C" __attribute__((visibility("default"))) id objc_msgSend(id self, SEL op, ...) + __attribute__((visibility("default"))); + +inline void TCFReleaseGC(void * object) +{ + static SEL SEL_release; + objc_msgSend((id)object, SEL_release); +} diff --git a/clang/test/SemaCXX/builtins.cpp b/clang/test/SemaCXX/builtins.cpp new file mode 100644 index 0000000..568ba5d --- /dev/null +++ b/clang/test/SemaCXX/builtins.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +typedef const struct __CFString * CFStringRef; +#define CFSTR __builtin___CFStringMakeConstantString + +void f() { + (void)CFStringRef(CFSTR("Hello")); +} + +void a() { __builtin_va_list x, y; ::__builtin_va_copy(x, y); } diff --git a/clang/test/SemaCXX/c99-variable-length-array.cpp b/clang/test/SemaCXX/c99-variable-length-array.cpp new file mode 100644 index 0000000..7773c08 --- /dev/null +++ b/clang/test/SemaCXX/c99-variable-length-array.cpp @@ -0,0 +1,141 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wvla %s +struct NonPOD { + NonPOD(); +}; + +struct NonPOD2 { + NonPOD np; +}; + +struct POD { + int x; + int y; +}; + +// We allow VLAs of POD types, only. +void vla(int N) { + int array1[N]; // expected-warning{{variable length arrays are a C99 feature}} + POD array2[N]; // expected-warning{{variable length arrays are a C99 feature}} + NonPOD array3[N]; // expected-error{{variable length array of non-POD element type 'NonPOD'}} + NonPOD2 array4[N][3]; // expected-error{{variable length array of non-POD element type 'NonPOD2'}} +} + +/// Warn about VLAs in templates. +template<typename T> +void vla_in_template(int N, T t) { + int array1[N]; // expected-warning{{variable length arrays are a C99 feature}} +} + +struct HasConstantValue { + static const unsigned int value = 2; +}; + +struct HasNonConstantValue { + static unsigned int value; +}; + +template<typename T> +void vla_in_template(T t) { + int array2[T::value]; // expected-warning{{variable length arrays are a C99 feature}} +} + +template void vla_in_template<HasConstantValue>(HasConstantValue); +template void vla_in_template<HasNonConstantValue>(HasNonConstantValue); // expected-note{{instantiation of}} + +template<typename T> struct X0 { }; + +// Cannot use any variably-modified type with a template parameter or +// argument. +void inst_with_vla(int N) { + int array[N]; // expected-warning{{variable length arrays are a C99 feature}} + X0<__typeof__(array)> x0a; // expected-error{{variably modified type 'typeof (array)' (aka 'int [N]') cannot be used as a template argument}} +} + +template<typename T> +struct X1 { + template<int (&Array)[T::value]> // expected-error{{non-type template parameter of variably modified type 'int (&)[HasNonConstantValue::value]'}} \ + // expected-warning{{variable length arrays are a C99 feature}} + struct Inner { + + }; +}; + +X1<HasConstantValue> x1a; +X1<HasNonConstantValue> x1b; // expected-note{{in instantiation of}} + +// Template argument deduction does not allow deducing a size from a VLA. +template<typename T, unsigned N> +void accept_array(T (&array)[N]); // expected-note{{candidate template ignored: failed template argument deduction}} + +void test_accept_array(int N) { + int array[N]; // expected-warning{{variable length arrays are a C99 feature}} + accept_array(array); // expected-error{{no matching function for call to 'accept_array'}} +} + +// Variably-modified types cannot be used in local classes. +void local_classes(int N) { // expected-note {{declared here}} + struct X { + int size; + int array[N]; // expected-error{{fields must have a constant size: 'variable length array in structure' extension will never be supported}} \ + // expected-error{{reference to local variable 'N' declared in enclosing function 'local_classes'}} \ + // expected-warning{{variable length arrays are a C99 feature}} + }; +} + +namespace PR7206 { + void f(int x) { + struct edge_info { + float left; + float right; + }; + struct edge_info edgeInfo[x]; // expected-warning{{variable length arrays are a C99 feature}} + } +} + +namespace rdar8020206 { + template<typename T> + void f(int i) { + const unsigned value = i; + int array[value * i]; // expected-warning 2{{variable length arrays are a C99 feature}} + } + + template void f<int>(int); // expected-note{{instantiation of}} +} + +namespace rdar8021385 { + typedef int my_int; + struct A { typedef int my_int; }; + template<typename T> + struct B { + typedef typename T::my_int my_int; + void f0() { + int M = 4; + my_int a[M]; // expected-warning{{variable length arrays are a C99 feature}} + } + }; + B<A> a; +} + +namespace PR8209 { + void f(int n) { + typedef int vla_type[n]; // expected-warning{{variable length arrays are a C99 feature}} + (void)new vla_type; // expected-error{{variably}} + } +} + +namespace rdar8733881 { // rdar://8733881 + +static const int k_cVal3 = (int)(1000*0.2f); + int f() { + // Ok, fold to a constant size array as an extension. + char rgch[k_cVal3] = {0}; + } +} + +namespace PR11744 { + template<typename T> int f(int n) { + T arr[3][n]; // expected-warning 3 {{variable length arrays are a C99 feature}} + return 3; + } + int test = f<int>(0); // expected-note {{instantiation of}} +} diff --git a/clang/test/SemaCXX/c99.cpp b/clang/test/SemaCXX/c99.cpp new file mode 100644 index 0000000..13918dc --- /dev/null +++ b/clang/test/SemaCXX/c99.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +void f1(int i[static 5]) { // expected-error{{C99}} +} + +struct Point { int x; int y; }; + +Point p1 = { .x = 17, // expected-warning{{designated initializers are a C99 feature}} + y: 25 }; // expected-warning{{designated initializers are a C99 feature}} \ + // expected-warning{{use of GNU old-style field designator extension}} diff --git a/clang/test/SemaCXX/cast-conversion.cpp b/clang/test/SemaCXX/cast-conversion.cpp new file mode 100644 index 0000000..dd2bc98 --- /dev/null +++ b/clang/test/SemaCXX/cast-conversion.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct R { + R(int); +}; + +struct A { + A(R); +}; + +struct B { // expected-note 3 {{candidate constructor (the implicit copy constructor) not viable}} \ + expected-note 3 {{candidate constructor (the implicit move constructor) not viable}} + B(A); // expected-note 3 {{candidate constructor not viable}} +}; + +int main () { + B(10); // expected-error {{no matching conversion for functional-style cast from 'int' to 'B'}} + (B)10; // expected-error {{no matching conversion for C-style cast from 'int' to 'B'}} + static_cast<B>(10); // expected-error {{no matching conversion for static_cast from 'int' to 'B'}} \\ + // expected-warning {{expression result unused}} +} + +template<class T> +struct X0 { + X0(const T &); +}; + +template<class T> +X0<T> make_X0(const T &Val) { + return X0<T>(Val); +} + +void test_X0() { + const char array[2] = { 'a', 'b' }; + make_X0(array); +} + +// PR5210 recovery +class C { +protected: + template <int> float* &f0(); // expected-note{{candidate}} + template <unsigned> float* &f0(); // expected-note{{candidate}} + + void f1() { + static_cast<float*>(f0<0>()); // expected-error{{ambiguous}} + } +}; diff --git a/clang/test/SemaCXX/cast-explicit-ctor.cpp b/clang/test/SemaCXX/cast-explicit-ctor.cpp new file mode 100644 index 0000000..0052856 --- /dev/null +++ b/clang/test/SemaCXX/cast-explicit-ctor.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct B { explicit B(bool); }; +void f() { + (void)(B)true; + (void)B(true); +} diff --git a/clang/test/SemaCXX/class-base-member-init.cpp b/clang/test/SemaCXX/class-base-member-init.cpp new file mode 100644 index 0000000..e84e57b --- /dev/null +++ b/clang/test/SemaCXX/class-base-member-init.cpp @@ -0,0 +1,92 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +class S { +public: + S (); +}; + +struct D : S { + D() : + b1(0), // expected-note {{previous initialization is here}} + b2(1), + b1(0), // expected-error {{multiple initializations given for non-static member 'b1'}} + S(), // expected-note {{previous initialization is here}} + S() // expected-error {{multiple initializations given for base 'S'}} + {} + int b1; + int b2; +}; + +struct A { + struct { + int a; + int b; + }; + A(); +}; + +A::A() : a(10), b(20) { } + +namespace Test1 { + template<typename T> struct A {}; + template<typename T> struct B : A<T> { + + B() : A<T>(), // expected-note {{previous initialization is here}} + A<T>() { } // expected-error {{multiple initializations given for base 'A<T>'}} + }; +} + +namespace Test2 { + template<typename T> struct A : T { + A() : T(), // expected-note {{previous initialization is here}} + T() { } // expected-error {{multiple initializations given for base 'T'}} + }; +} + +namespace Test3 { + template<typename T> struct A { + T t; + + A() : t(1), // expected-note {{previous initialization is here}} + t(2) { } // expected-error {{multiple initializations given for non-static member 't'}} + }; +} + +namespace test4 { + class A { + union { + struct { + int a; + int b; + }; + + int c; + + union { + int d; + int e; + }; + }; + + A(char _) : a(0), b(0) {} + A(short _) : a(0), c(0) {} // expected-error {{initializing multiple members of union}} expected-note {{previous initialization is here}} + A(int _) : d(0), e(0) {} // expected-error {{initializing multiple members of union}} expected-note {{previous initialization is here}} + A(long _) : a(0), d(0) {} // expected-error {{initializing multiple members of union}} expected-note {{previous initialization is here}} + }; +} + +namespace test5 { + struct Base { + Base(int); + }; + struct A : Base { + A() : decltype(Base(1))(3) { + } + A(int) : Base(3), // expected-note {{previous initialization is here}} + decltype(Base(1))(2), // expected-error {{multiple initializations given for base 'decltype(test5::Base(1))' (aka 'test5::Base')}} + decltype(int())() { // expected-error {{constructor initializer 'decltype(int())' (aka 'int') does not name a class}} + } + A(float) : decltype(A())(3) { + } + }; +} diff --git a/clang/test/SemaCXX/class-layout.cpp b/clang/test/SemaCXX/class-layout.cpp new file mode 100644 index 0000000..d81944a --- /dev/null +++ b/clang/test/SemaCXX/class-layout.cpp @@ -0,0 +1,104 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify + +#define SA(n, p) int a##n[(p) ? 1 : -1] + +struct A { + int a; + char b; +}; + +SA(0, sizeof(A) == 8); + +struct B : A { + char c; +}; + +SA(1, sizeof(B) == 12); + +struct C { +// Make fields private so C won't be a POD type. +private: + int a; + char b; +}; + +SA(2, sizeof(C) == 8); + +struct D : C { + char c; +}; + +SA(3, sizeof(D) == 8); + +struct __attribute__((packed)) E { + char b; + int a; +}; + +SA(4, sizeof(E) == 5); + +struct __attribute__((packed)) F : E { + char d; +}; + +SA(5, sizeof(F) == 6); + +struct G { G(); }; +struct H : G { }; + +SA(6, sizeof(H) == 1); + +struct I { + char b; + int a; +} __attribute__((packed)); + +SA(6_1, sizeof(I) == 5); + +// PR5580 +namespace PR5580 { + +class A { bool iv0 : 1; }; +SA(7, sizeof(A) == 1); + +class B : A { bool iv0 : 1; }; +SA(8, sizeof(B) == 2); + +struct C { bool iv0 : 1; }; +SA(9, sizeof(C) == 1); + +struct D : C { bool iv0 : 1; }; +SA(10, sizeof(D) == 2); + +} + +namespace Test1 { + +// Test that we don't assert on this hierarchy. +struct A { }; +struct B : A { virtual void b(); }; +class C : virtual A { int c; }; +struct D : virtual B { }; +struct E : C, virtual D { }; +class F : virtual E { }; +struct G : virtual E, F { }; + +SA(0, sizeof(G) == 24); + +} + +namespace Test2 { + +// Test that this somewhat complex class structure is laid out correctly. +struct A { }; +struct B : A { virtual void b(); }; +struct C : virtual B { }; +struct D : virtual A { }; +struct E : virtual B, D { }; +struct F : E, virtual C { }; +struct G : virtual F, A { }; +struct H { G g; }; + +SA(0, sizeof(H) == 24); + +} diff --git a/clang/test/SemaCXX/class-names.cpp b/clang/test/SemaCXX/class-names.cpp new file mode 100644 index 0000000..2962988 --- /dev/null +++ b/clang/test/SemaCXX/class-names.cpp @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class C { }; + +C c; + +void D(int); + +class D {}; + +void foo() +{ + D(5); + class D d; +} + +class D; // expected-note {{previous use is here}} + +enum D; // expected-error {{use of 'D' with tag type that does not match previous declaration}} + +class A * A; + +class A * a2; + +void bar() +{ + A = 0; +} + +void C(int); + +void bar2() +{ + C(17); +} + +extern int B; +class B; +class B {}; +int B; + +enum E { e1_val }; +E e1; + +void E(int); + +void bar3() { + E(17); +} + +enum E e2; + +enum E2 { E2 }; diff --git a/clang/test/SemaCXX/class.cpp b/clang/test/SemaCXX/class.cpp new file mode 100644 index 0000000..4dffc8d --- /dev/null +++ b/clang/test/SemaCXX/class.cpp @@ -0,0 +1,197 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s +class C { +public: + auto int errx; // expected-error {{storage class specified for a member declaration}} expected-warning {{'auto' storage class specifier is redundant}} + register int erry; // expected-error {{storage class specified for a member declaration}} + extern int errz; // expected-error {{storage class specified for a member declaration}} + + static void sm() { + sx = 0; + this->x = 0; // expected-error {{invalid use of 'this' outside of a non-static member function}} + x = 0; // expected-error {{invalid use of member 'x' in static member function}} + } + + class NestedC { + public: + NestedC(int); + void f() { + sx = 0; + x = 0; // expected-error {{use of non-static data member 'x' of 'C' from nested type 'NestedC'}} + sm(); + m(); // expected-error {{call to non-static member function 'm' of 'C' from nested type 'NestedC'}} + } + }; + + int b : 1, w : 2; + int : 1, : 2; + typedef int E : 1; // expected-error {{typedef member 'E' cannot be a bit-field}} + static int sb : 1; // expected-error {{static member 'sb' cannot be a bit-field}} + static int vs; + + typedef int func(); + func tm; + func *ptm; + func btm : 1; // expected-error {{bit-field 'btm' has non-integral type}} + NestedC bc : 1; // expected-error {{bit-field 'bc' has non-integral type}} + + enum E1 { en1, en2 }; + + int i = 0; // expected-warning {{in-class initialization of non-static data member is a C++11 extension}} + static int si = 0; // expected-error {{non-const static data member must be initialized out of line}} + static const NestedC ci = 0; // expected-error {{static data member of type 'const C::NestedC' must be initialized out of line}} + static const int nci = vs; // expected-error {{in-class initializer for static data member is not a constant expression}} + static const int vi = 0; + static const volatile int cvi = 0; // ok, illegal in C++11 + static const E evi = 0; + + void m() { + sx = 0; + this->x = 0; + y = 0; + this = 0; // expected-error {{expression is not assignable}} + } + + int f1(int p) { + A z = 6; + return p + x + this->y + z; + } + + typedef int A; + + virtual int viv; // expected-error {{'virtual' can only appear on non-static member functions}} + virtual static int vsif(); // expected-error {{'virtual' can only appear on non-static member functions}} + virtual int vif(); + +private: + int x,y; + static int sx; + + mutable int mi; + mutable int &mir; // expected-error {{'mutable' cannot be applied to references}} + mutable void mfn(); // expected-error {{'mutable' cannot be applied to functions}} + mutable const int mci; // expected-error {{'mutable' and 'const' cannot be mixed}} + + static const int number = 50; + static int arr[number]; +}; + +class C2 { + void f() { + static int lx; + class LC1 { + int m() { return lx; } + }; + class LC2 { + int m() { return lx; } + }; + } +}; + +struct C3 { + int i; + mutable int j; +}; +void f() +{ + const C3 c3 = { 1, 2 }; + (void)static_cast<int*>(&c3.i); // expected-error {{static_cast from 'const int *' to 'int *' is not allowed}} + // but no error here + (void)static_cast<int*>(&c3.j); +} + +// Play with mutable a bit more, to make sure it doesn't crash anything. +mutable int gi; // expected-error {{'mutable' can only be applied to member variables}} +mutable void gfn(); // expected-error {{illegal storage class on function}} +void ogfn() +{ + mutable int ml; // expected-error {{'mutable' can only be applied to member variables}} + + // PR3020: This used to crash due to double ownership of C4. + struct C4; + C4; // expected-warning {{declaration does not declare anything}} +} + +struct C4 { + void f(); // expected-note{{previous declaration is here}} + int f; // expected-error{{duplicate member 'f'}} +}; + +// PR5415 - don't hang! +struct S +{ + void f(); // expected-note 1 {{previous declaration}} + void S::f() {} // expected-warning {{extra qualification on member}} expected-error {{class member cannot be redeclared}} expected-note {{previous declaration}} expected-note {{previous definition}} + void f() {} // expected-error {{class member cannot be redeclared}} expected-error {{redefinition}} +}; + +// Don't crash on this bogus code. +namespace pr6629 { + // TODO: most of these errors are spurious + template<class T1, class T2> struct foo : + bogus<foo<T1,T2> > // expected-error {{unknown template name 'bogus'}} \ + // BOGUS expected-error {{expected '{' after base class list}} \ + // BOGUS expected-error {{expected ';' after struct}} \ + // BOGUS expected-error {{expected unqualified-id}} + { }; + + template<> struct foo<unknown,unknown> { // expected-error {{undeclared identifier 'unknown'}} + template <typename U1, typename U2> struct bar { + typedef bar type; + static const int value = 0; + }; + }; +} + +namespace PR7153 { + class EnclosingClass { + public: + struct A { } mutable *member; + }; + + void f(const EnclosingClass &ec) { + ec.member = 0; + } +} + +namespace PR7196 { + struct A { + int a; + + void f() { + char i[sizeof(a)]; + enum { x = sizeof(i) }; + enum { y = sizeof(a) }; + } + }; +} + +namespace rdar8066414 { + class C { + C() {} + } // expected-error{{expected ';' after class}} +} + +namespace rdar8367341 { + float foo(); + + struct A { + static const float x = 5.0f; // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} + static const float y = foo(); // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} expected-error {{in-class initializer for static data member is not a constant expression}} + }; +} + +namespace with_anon { +struct S { + union { + char c; + }; +}; + +void f() { + S::c; // expected-error {{invalid use of non-static data member}} +} +} + +struct PR9989 { + static int const PR9989_Member = sizeof PR9989_Member; +}; diff --git a/clang/test/SemaCXX/comma.cpp b/clang/test/SemaCXX/comma.cpp new file mode 100644 index 0000000..79ff7d1 --- /dev/null +++ b/clang/test/SemaCXX/comma.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR6076 +void f(); +void (&g)() = (void(), f); + +int a[1]; +int (&b)[1] = (void(), a); diff --git a/clang/test/SemaCXX/compare.cpp b/clang/test/SemaCXX/compare.cpp new file mode 100644 index 0000000..28e2dd0 --- /dev/null +++ b/clang/test/SemaCXX/compare.cpp @@ -0,0 +1,225 @@ +// Force x86-64 because some of our heuristics are actually based +// on integer sizes. + +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -pedantic -verify -Wsign-compare %s + +int test0(long a, unsigned long b) { + enum EnumA {A}; + enum EnumB {B}; + enum EnumC {C = 0x10000}; + return + // (a,b) + (a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + (a == (unsigned int) b) + + (a == (unsigned short) b) + + (a == (unsigned char) b) + + ((long) a == b) + // expected-warning {{comparison of integers of different signs}} + ((int) a == b) + // expected-warning {{comparison of integers of different signs}} + ((short) a == b) + // expected-warning {{comparison of integers of different signs}} + ((signed char) a == b) + // expected-warning {{comparison of integers of different signs}} + ((long) a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + ((int) a == (unsigned int) b) + // expected-warning {{comparison of integers of different signs}} + ((short) a == (unsigned short) b) + + ((signed char) a == (unsigned char) b) + + (a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) b) + + (a < (unsigned short) b) + + (a < (unsigned char) b) + + ((long) a < b) + // expected-warning {{comparison of integers of different signs}} + ((int) a < b) + // expected-warning {{comparison of integers of different signs}} + ((short) a < b) + // expected-warning {{comparison of integers of different signs}} + ((signed char) a < b) + // expected-warning {{comparison of integers of different signs}} + ((long) a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) b) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) b) + + ((signed char) a < (unsigned char) b) + + + // (A,b) + (A == (unsigned long) b) + + (A == (unsigned int) b) + + (A == (unsigned short) b) + + (A == (unsigned char) b) + + ((long) A == b) + + ((int) A == b) + + ((short) A == b) + + ((signed char) A == b) + + ((long) A == (unsigned long) b) + + ((int) A == (unsigned int) b) + + ((short) A == (unsigned short) b) + + ((signed char) A == (unsigned char) b) + + (A < (unsigned long) b) + + (A < (unsigned int) b) + + (A < (unsigned short) b) + + (A < (unsigned char) b) + + ((long) A < b) + + ((int) A < b) + + ((short) A < b) + + ((signed char) A < b) + + ((long) A < (unsigned long) b) + + ((int) A < (unsigned int) b) + + ((short) A < (unsigned short) b) + + ((signed char) A < (unsigned char) b) + + + // (a,B) + (a == (unsigned long) B) + + (a == (unsigned int) B) + + (a == (unsigned short) B) + + (a == (unsigned char) B) + + ((long) a == B) + + ((int) a == B) + + ((short) a == B) + + ((signed char) a == B) + + ((long) a == (unsigned long) B) + + ((int) a == (unsigned int) B) + + ((short) a == (unsigned short) B) + + ((signed char) a == (unsigned char) B) + + (a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) B) + + (a < (unsigned short) B) + + (a < (unsigned char) B) + + ((long) a < B) + + ((int) a < B) + + ((short) a < B) + + ((signed char) a < B) + + ((long) a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) B) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) B) + + ((signed char) a < (unsigned char) B) + + + // (C,b) + (C == (unsigned long) b) + + (C == (unsigned int) b) + + (C == (unsigned short) b) + + (C == (unsigned char) b) + + ((long) C == b) + + ((int) C == b) + + ((short) C == b) + + ((signed char) C == b) + + ((long) C == (unsigned long) b) + + ((int) C == (unsigned int) b) + + ((short) C == (unsigned short) b) + + ((signed char) C == (unsigned char) b) + + (C < (unsigned long) b) + + (C < (unsigned int) b) + + (C < (unsigned short) b) + + (C < (unsigned char) b) + + ((long) C < b) + + ((int) C < b) + + ((short) C < b) + + ((signed char) C < b) + + ((long) C < (unsigned long) b) + + ((int) C < (unsigned int) b) + + ((short) C < (unsigned short) b) + + ((signed char) C < (unsigned char) b) + + + // (a,C) + (a == (unsigned long) C) + + (a == (unsigned int) C) + + (a == (unsigned short) C) + + (a == (unsigned char) C) + + ((long) a == C) + + ((int) a == C) + + ((short) a == C) + + ((signed char) a == C) + + ((long) a == (unsigned long) C) + + ((int) a == (unsigned int) C) + + ((short) a == (unsigned short) C) + + ((signed char) a == (unsigned char) C) + + (a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) C) + + (a < (unsigned short) C) + + (a < (unsigned char) C) + + ((long) a < C) + + ((int) a < C) + + ((short) a < C) + + ((signed char) a < C) + + ((long) a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) C) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) C) + + ((signed char) a < (unsigned char) C) + + + // (0x80000,b) + (0x80000 == (unsigned long) b) + + (0x80000 == (unsigned int) b) + + (0x80000 == (unsigned short) b) + + (0x80000 == (unsigned char) b) + + ((long) 0x80000 == b) + + ((int) 0x80000 == b) + + ((short) 0x80000 == b) + + ((signed char) 0x80000 == b) + + ((long) 0x80000 == (unsigned long) b) + + ((int) 0x80000 == (unsigned int) b) + + ((short) 0x80000 == (unsigned short) b) + + ((signed char) 0x80000 == (unsigned char) b) + + (0x80000 < (unsigned long) b) + + (0x80000 < (unsigned int) b) + + (0x80000 < (unsigned short) b) + + (0x80000 < (unsigned char) b) + + ((long) 0x80000 < b) + + ((int) 0x80000 < b) + + ((short) 0x80000 < b) + + ((signed char) 0x80000 < b) + + ((long) 0x80000 < (unsigned long) b) + + ((int) 0x80000 < (unsigned int) b) + + ((short) 0x80000 < (unsigned short) b) + + ((signed char) 0x80000 < (unsigned char) b) + + + // (a,0x80000) + (a == (unsigned long) 0x80000) + + (a == (unsigned int) 0x80000) + + (a == (unsigned short) 0x80000) + + (a == (unsigned char) 0x80000) + + ((long) a == 0x80000) + + ((int) a == 0x80000) + + ((short) a == 0x80000) + + ((signed char) a == 0x80000) + + ((long) a == (unsigned long) 0x80000) + + ((int) a == (unsigned int) 0x80000) + + ((short) a == (unsigned short) 0x80000) + + ((signed char) a == (unsigned char) 0x80000) + + (a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}} + (a < (unsigned int) 0x80000) + + (a < (unsigned short) 0x80000) + + (a < (unsigned char) 0x80000) + + ((long) a < 0x80000) + + ((int) a < 0x80000) + + ((short) a < 0x80000) + + ((signed char) a < 0x80000) + + ((long) a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}} + ((int) a < (unsigned int) 0x80000) + // expected-warning {{comparison of integers of different signs}} + ((short) a < (unsigned short) 0x80000) + + ((signed char) a < (unsigned char) 0x80000) + + + 10 + ; +} + +int test1(int i) { + enum en { zero }; + return i > zero; +} + +enum E { e }; +void test2(int i, void *vp) { + if (test1 == vp) { } // expected-warning{{equality comparison between function pointer and void pointer}} + if (test1 == e) { } // expected-error{{comparison between pointer and integer}} + if (vp < 0) { } + if (test1 < e) { } // expected-error{{comparison between pointer and integer}} +} + +// PR7536 +static const unsigned int kMax = 0; +int pr7536() { + return (kMax > 0); +} + +// -Wsign-compare should not warn when ?: operands have different signedness. +// This will be caught by -Wsign-conversion +void test3() { + unsigned long a; + signed long b; + (void) (true ? a : b); + (void) (true ? (unsigned int)a : (signed int)b); + (void) (true ? b : a); + (void) (true ? (unsigned char)b : (signed char)a); +} diff --git a/clang/test/SemaCXX/complex-init-list.cpp b/clang/test/SemaCXX/complex-init-list.cpp new file mode 100644 index 0000000..e75833a --- /dev/null +++ b/clang/test/SemaCXX/complex-init-list.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic + +// This file tests the clang extension which allows initializing the components +// of a complex number individually using an initialization list. Basically, +// if you have an explicit init list for a complex number that contains two +// initializers, this extension kicks in to turn it into component-wise +// initialization. +// +// See also the testcase for the C version of this extension in +// test/Sema/complex-init-list.c. + +// Basic testcase +// (No pedantic warning is necessary because _Complex is not part of C++.) +_Complex float valid1 = { 1.0f, 2.0f }; diff --git a/clang/test/SemaCXX/complex-overload.cpp b/clang/test/SemaCXX/complex-overload.cpp new file mode 100644 index 0000000..719a850 --- /dev/null +++ b/clang/test/SemaCXX/complex-overload.cpp @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +char *foo(float); + +void test_foo_1(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + // Note: GCC and EDG reject these two, but they are valid C99 conversions + char *cp3 = foo(fc); + char *cp4 = foo(dc); +} + +int *foo(float _Complex); + +void test_foo_2(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + int *ip = foo(fc); + int *lp = foo(dc); +} + +long *foo(double _Complex); + +void test_foo_3(float fv, double dv, float _Complex fc, double _Complex dc) { + char *cp1 = foo(fv); + char *cp2 = foo(dv); + int *ip = foo(fc); + long *lp = foo(dc); +} + +char *promote_or_convert(double _Complex); // expected-note{{candidate function}} +int *promote_or_convert(long double _Complex); // expected-note{{candidate function}} + +void test_promote_or_convert(float f, float _Complex fc) { + char *cp = promote_or_convert(fc); + int *ip2 = promote_or_convert(f); // expected-error{{call to 'promote_or_convert' is ambiguous}} +} + +char *promote_or_convert2(float); +int *promote_or_convert2(double _Complex); + +void test_promote_or_convert2(float _Complex fc) { + int *cp = promote_or_convert2(fc); +} + +char *promote_or_convert3(int _Complex); +int *promote_or_convert3(long _Complex); + +void test_promote_or_convert3(short _Complex sc) { + char *cp = promote_or_convert3(sc); +} diff --git a/clang/test/SemaCXX/composite-pointer-type.cpp b/clang/test/SemaCXX/composite-pointer-type.cpp new file mode 100644 index 0000000..06fc8f4 --- /dev/null +++ b/clang/test/SemaCXX/composite-pointer-type.cpp @@ -0,0 +1,60 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class Base { }; +class Derived1 : public Base { }; +class Derived2 : public Base { }; + +void f0(volatile Base *b, Derived1 *d1, const Derived2 *d2) { + if (b > d1) + return; + if (d1 <= b) + return; + if (b > d2) + return; + if (d1 >= d2) // expected-error{{comparison of distinct}} + return; +} + +void f1(volatile Base *b, Derived1 *d1, const Derived2 *d2) { + if (b == d1) + return; + if (d1 == b) + return; + if (b != d2) + return; + if (d1 == d2) // expected-error{{comparison of distinct}} + return; +} + +// PR4691 +int ptrcmp1(void *a, int *b) { + return a < b; +} +int ptrcmp2(long *a, int *b) { + return a < b; // expected-error{{distinct}} +} + +// PR5509 - Multi-level pointers +int f2() { + typedef int *IntPtr; + typedef IntPtr *IntPtrPtr; + typedef IntPtr const *IntPtrConstPtr; + IntPtrConstPtr i = 0; + IntPtrPtr j = 0; + return i != j; +} + +// PR5763 +typedef double Matrix4[4][4]; + +bool f(Matrix4 m1, const Matrix4 m2) { + return m1 != m2; +} + +// PR6346 +bool f1(bool b, void **p, const void **q) { + if (p == q) // expected-warning{{comparison of distinct pointer types ('void **' and 'const void **') uses non-standard composite pointer type 'const void *const *'}} + return false; + + return b? p : q; // expected-warning{{incompatible operand types ('void **' and 'const void **') use non-standard composite pointer type 'const void *const *'}} +} diff --git a/clang/test/SemaCXX/compound-literal.cpp b/clang/test/SemaCXX/compound-literal.cpp new file mode 100644 index 0000000..fe0e45d --- /dev/null +++ b/clang/test/SemaCXX/compound-literal.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// http://llvm.org/PR7905 +namespace PR7905 { +struct S; // expected-note {{forward declaration}} +void foo1() { + (void)(S[]) {{3}}; // expected-error {{array has incomplete element type}} +} + +template <typename T> struct M { T m; }; +void foo2() { + (void)(M<short> []) {{3}}; +} +} diff --git a/clang/test/SemaCXX/condition.cpp b/clang/test/SemaCXX/condition.cpp new file mode 100644 index 0000000..993f8e1 --- /dev/null +++ b/clang/test/SemaCXX/condition.cpp @@ -0,0 +1,60 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void test() { + int x; + if (x) ++x; + if (int x=0) ++x; + + typedef int arr[10]; + while (arr x=0) ; // expected-error {{an array type is not allowed here}} expected-error {{array initializer must be an initializer list}} + while (int f()=0) ; // expected-warning {{interpreted as a function declaration}} expected-note {{initializer}} expected-error {{a function type is not allowed here}} + + struct S {} s; + if (s) ++x; // expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} + while (struct S x=s) ; // expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} + do ; while (s); // expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} + for (;s;) ; // expected-error {{value of type 'struct S' is not contextually convertible to 'bool'}} + switch (s) {} // expected-error {{statement requires expression of integer type ('struct S' invalid)}} + + while (struct NewS *x=0) ; + while (struct S {} *x=0) ; // expected-error {{types may not be defined in conditions}} + while (struct {} *x=0) ; // expected-error {{types may not be defined in conditions}} + switch (enum {E} x=0) ; // expected-error {{types may not be defined in conditions}} expected-error {{cannot initialize}} \ + // expected-warning{{enumeration value 'E' not handled in switch}} expected-warning {{switch statement has empty body}} \ + // expected-note{{put the semicolon on a separate line}} + + if (int x=0) { // expected-note 2 {{previous definition is here}} + int x; // expected-error {{redefinition of 'x'}} + } + else + int x; // expected-error {{redefinition of 'x'}} + while (int x=0) int x; // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + while (int x=0) { int x; } // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + for (int x; int x=0; ) ; // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + for (int x; ; ) int x; // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + for (; int x=0; ) int x; // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + for (; int x=0; ) { int x; } // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} + switch (int x=0) { default: int x; } // expected-error {{redefinition of 'x'}} expected-note {{previous definition is here}} +} + +int* get_int_ptr(); + +void test2() { + float *ip; + if (int *ip = ip) { + } +} + +// Make sure we do function/array decay. +void test3() { + if ("help") + (void) 0; + + if (test3) // expected-warning {{address of function 'test3' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + (void) 0; +} + +void test4(bool (&x)(void)) { + while (x); +} diff --git a/clang/test/SemaCXX/conditional-expr.cpp b/clang/test/SemaCXX/conditional-expr.cpp new file mode 100644 index 0000000..4aee913 --- /dev/null +++ b/clang/test/SemaCXX/conditional-expr.cpp @@ -0,0 +1,330 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -Wsign-conversion %s + +// C++ rules for ?: are a lot stricter than C rules, and have to take into +// account more conversion options. +// This test runs in C++0x mode for the contextual conversion of the condition. + +struct ToBool { explicit operator bool(); }; + +struct B; +struct A { + A(); + A(const B&); // expected-note 2 {{candidate constructor}} +}; +struct B { operator A() const; }; // expected-note 2 {{candidate function}} +struct I { operator int(); }; +struct J { operator I(); }; +struct K { operator double(); }; +typedef void (*vfn)(); +struct F { operator vfn(); }; +struct G { operator vfn(); }; + +struct Base { + int trick(); + A trick() const; + void fn1(); +}; +struct Derived : Base { + void fn2(); +}; +struct Convertible { operator Base&(); }; +struct Priv : private Base {}; // expected-note 4 {{declared private here}} +struct Mid : Base {}; +struct Fin : Mid, Derived {}; +typedef void (Derived::*DFnPtr)(); +struct ToMemPtr { operator DFnPtr(); }; + +struct BadDerived; +struct BadBase { operator BadDerived&(); }; +struct BadDerived : BadBase {}; + +struct Fields { + int i1, i2, b1 : 3, b2 : 3; +}; +struct MixedFields { + int i; + volatile int vi; + const int ci; + const volatile int cvi; +}; +struct MixedFieldsDerived : MixedFields { +}; + +enum Enum { EVal }; + +struct Ambig { + operator short(); // expected-note 2 {{candidate function}} + operator signed char(); // expected-note 2 {{candidate function}} +}; + +void test() +{ + // This function tests C++0x 5.16 + + // p1 (contextually convert to bool) + int i1 = ToBool() ? 0 : 1; + + // p2 (one or both void, and throwing) + i1 ? throw 0 : throw 1; + i1 ? test() : throw 1; + i1 ? throw 0 : test(); + i1 ? test() : test(); + i1 = i1 ? throw 0 : 0; + i1 = i1 ? 0 : throw 0; + i1 ? 0 : test(); // expected-error {{right operand to ? is void, but left operand is of type 'int'}} + i1 ? test() : 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}} + (i1 ? throw 0 : i1) = 0; // expected-error {{expression is not assignable}} + (i1 ? i1 : throw 0) = 0; // expected-error {{expression is not assignable}} + + // p3 (one or both class type, convert to each other) + // b1 (lvalues) + Base base; + Derived derived; + Convertible conv; + Base &bar1 = i1 ? base : derived; + Base &bar2 = i1 ? derived : base; + Base &bar3 = i1 ? base : conv; + Base &bar4 = i1 ? conv : base; + // these are ambiguous + BadBase bb; + BadDerived bd; + (void)(i1 ? bb : bd); // expected-error {{conditional expression is ambiguous; 'BadBase' can be converted to 'BadDerived' and vice versa}} + (void)(i1 ? bd : bb); // expected-error {{conditional expression is ambiguous}} + // curiously enough (and a defect?), these are not + // for rvalues, hierarchy takes precedence over other conversions + (void)(i1 ? BadBase() : BadDerived()); + (void)(i1 ? BadDerived() : BadBase()); + + // b2.1 (hierarchy stuff) + extern const Base constret(); + extern const Derived constder(); + // should use const overload + A a1((i1 ? constret() : Base()).trick()); + A a2((i1 ? Base() : constret()).trick()); + A a3((i1 ? constret() : Derived()).trick()); + A a4((i1 ? Derived() : constret()).trick()); + // should use non-const overload + i1 = (i1 ? Base() : Base()).trick(); + i1 = (i1 ? Base() : Base()).trick(); + i1 = (i1 ? Base() : Derived()).trick(); + i1 = (i1 ? Derived() : Base()).trick(); + // should fail: const lost + (void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('Base' and 'const Derived')}} + (void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('const Derived' and 'Base')}} + + Priv priv; + Fin fin; + (void)(i1 ? Base() : Priv()); // expected-error{{private base class}} + (void)(i1 ? Priv() : Base()); // expected-error{{private base class}} + (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}} + (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}} + (void)(i1 ? base : priv); // expected-error {{private base class}} + (void)(i1 ? priv : base); // expected-error {{private base class}} + (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} + (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} + + // b2.2 (non-hierarchy) + i1 = i1 ? I() : i1; + i1 = i1 ? i1 : I(); + I i2(i1 ? I() : J()); + I i3(i1 ? J() : I()); + // "the type [it] woud have if E2 were converted to an rvalue" + vfn pfn = i1 ? F() : test; + pfn = i1 ? test : F(); + (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} + (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} + (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} + (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} + // By the way, this isn't an lvalue: + &(i1 ? i1 : i2); // expected-error {{address expression must be an lvalue or a function designator}} + + // p4 (lvalue, same type) + Fields flds; + int &ir1 = i1 ? flds.i1 : flds.i2; + (i1 ? flds.b1 : flds.i2) = 0; + (i1 ? flds.i1 : flds.b2) = 0; + (i1 ? flds.b1 : flds.b2) = 0; + + // p5 (conversion to built-in types) + // GCC 4.3 fails these + double d1 = i1 ? I() : K(); + pfn = i1 ? F() : G(); + DFnPtr pfm; + pfm = i1 ? DFnPtr() : &Base::fn1; + pfm = i1 ? &Base::fn1 : DFnPtr(); + + // p6 (final conversions) + i1 = i1 ? i1 : ir1; + int *pi1 = i1 ? &i1 : 0; + pi1 = i1 ? 0 : &i1; + i1 = i1 ? i1 : EVal; + i1 = i1 ? EVal : i1; + d1 = i1 ? 'c' : 4.0; + d1 = i1 ? 4.0 : 'c'; + Base *pb = i1 ? (Base*)0 : (Derived*)0; + pb = i1 ? (Derived*)0 : (Base*)0; + pfm = i1 ? &Base::fn1 : &Derived::fn2; + pfm = i1 ? &Derived::fn2 : &Base::fn1; + pfm = i1 ? &Derived::fn2 : 0; + pfm = i1 ? 0 : &Derived::fn2; + const int (MixedFieldsDerived::*mp1) = + i1 ? &MixedFields::ci : &MixedFieldsDerived::i; + const volatile int (MixedFields::*mp2) = + i1 ? &MixedFields::ci : &MixedFields::cvi; + (void)(i1 ? &MixedFields::ci : &MixedFields::vi); + // Conversion of primitives does not result in an lvalue. + &(i1 ? i1 : d1); // expected-error {{address expression must be an lvalue or a function designator}} + + (void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}} + (void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}} + + + unsigned long test0 = 5; + test0 = test0 ? (long) test0 : test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} + test0 = test0 ? (int) test0 : test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? (short) test0 : test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} + test0 = test0 ? test0 : (long) test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} + test0 = test0 ? test0 : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? test0 : (short) test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} + test0 = test0 ? test0 : (long) 10; + test0 = test0 ? test0 : (int) 10; + test0 = test0 ? test0 : (short) 10; + test0 = test0 ? (long) 10 : test0; + test0 = test0 ? (int) 10 : test0; + test0 = test0 ? (short) 10 : test0; + + int test1; + test0 = test0 ? EVal : test0; + test1 = test0 ? EVal : (int) test0; + + test0 = test0 ? EVal : test1; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + test0 = test0 ? test1 : EVal; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} + + test1 = test0 ? EVal : (int) test0; + test1 = test0 ? (int) test0 : EVal; + + // Note the thing that this does not test: since DR446, various situations + // *must* create a separate temporary copy of class objects. This can only + // be properly tested at runtime, though. +} + +namespace PR6595 { + struct OtherString { + OtherString(); + OtherString(const char*); + }; + + struct String { + String(const char *); + String(const OtherString&); + operator const char*() const; + }; + + void f(bool Cond, String S, OtherString OS) { + (void)(Cond? S : ""); + (void)(Cond? "" : S); + const char a[1] = {'a'}; + (void)(Cond? S : a); + (void)(Cond? a : S); + (void)(Cond? OS : S); + } +} + +namespace PR6757 { + struct Foo1 { + Foo1(); + Foo1(const Foo1&); + }; + + struct Foo2 { }; + + struct Foo3 { + Foo3(); + Foo3(Foo3&); // expected-note{{would lose const qualifier}} + }; + + struct Bar { + operator const Foo1&() const; + operator const Foo2&() const; + operator const Foo3&() const; + }; + + void f() { + (void)(true ? Bar() : Foo1()); // okay + (void)(true ? Bar() : Foo2()); // okay + (void)(true ? Bar() : Foo3()); // expected-error{{no viable constructor copying temporary}} + } +} + +// Reduced from selfhost. +namespace test1 { + struct A { + enum Foo { + fa, fb, fc, fd, fe, ff + }; + + Foo x(); + }; + + void foo(int); + + void test(A *a) { + foo(a ? a->x() : 0); + } +} + +namespace rdar7998817 { + class X { + X(X&); // expected-note{{declared private here}} + + struct ref { }; + + public: + X(); + X(ref); + + operator ref(); + }; + + void f(bool B) { + X x; + (void)(B? x // expected-error{{calling a private constructor of class 'rdar7998817::X'}} + : X()); + } +} + +namespace PR7598 { + enum Enum { + v = 1, + }; + + const Enum g() { + return v; + } + + const volatile Enum g2() { + return v; + } + + void f() { + const Enum v2 = v; + Enum e = false ? g() : v; + Enum e2 = false ? v2 : v; + Enum e3 = false ? g2() : v; + } + +} + +namespace PR9236 { +#define NULL 0L + void f() { + int i; + (void)(true ? A() : NULL); // expected-error{{non-pointer operand type 'A' incompatible with NULL}} + (void)(true ? NULL : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}} + (void)(true ? 0 : A()); // expected-error{{incompatible operand types}} + (void)(true ? nullptr : A()); // expected-error{{non-pointer operand type 'A' incompatible with nullptr}} + (void)(true ? nullptr : i); // expected-error{{non-pointer operand type 'int' incompatible with nullptr}} + (void)(true ? __null : A()); // expected-error{{non-pointer operand type 'A' incompatible with NULL}} + (void)(true ? (void*)0 : A()); // expected-error{{incompatible operand types}} + } +} diff --git a/clang/test/SemaCXX/const-cast.cpp b/clang/test/SemaCXX/const-cast.cpp new file mode 100644 index 0000000..62851f8 --- /dev/null +++ b/clang/test/SemaCXX/const-cast.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A {}; + +// See if aliasing can confuse this baby. +typedef char c; +typedef c *cp; +typedef cp *cpp; +typedef cpp *cppp; +typedef cppp &cpppr; +typedef const cppp &cpppcr; +typedef const char cc; +typedef cc *ccp; +typedef volatile ccp ccvp; +typedef ccvp *ccvpp; +typedef const volatile ccvpp ccvpcvp; +typedef ccvpcvp *ccvpcvpp; +typedef int iar[100]; +typedef iar &iarr; +typedef int (*f)(int); + +char ***good_const_cast_test(ccvpcvpp var) +{ + // Cast away deep consts and volatiles. + char ***var2 = const_cast<cppp>(var); + char ***const &var3 = var2; + // Const reference to reference. + char ***&var4 = const_cast<cpppr>(var3); + // Drop reference. Intentionally without qualifier change. + char *** var5 = const_cast<cppp>(var4); + // Const array to array reference. + const int ar[100] = {0}; + int (&rar)[100] = const_cast<iarr>(ar); + // Array decay. Intentionally without qualifier change. + int *pi = const_cast<int*>(ar); + f fp = 0; + // Don't misidentify fn** as a function pointer. + f *fpp = const_cast<f*>(&fp); + int const A::* const A::*icapcap = 0; + int A::* A::* iapap = const_cast<int A::* A::*>(icapcap); + + return var4; +} + +short *bad_const_cast_test(char const *volatile *const volatile *var) +{ + // Different pointer levels. + char **var2 = const_cast<char**>(var); // expected-error {{const_cast from 'const char *volatile *const volatile *' to 'char **' is not allowed}} + // Different final type. + short ***var3 = const_cast<short***>(var); // expected-error {{const_cast from 'const char *volatile *const volatile *' to 'short ***' is not allowed}} + // Rvalue to reference. + char ***&var4 = const_cast<cpppr>(&var2); // expected-error {{const_cast from rvalue to reference type 'cpppr'}} + // Non-pointer. + char v = const_cast<char>(**var2); // expected-error {{const_cast to 'char', which is not a reference, pointer-to-object, or pointer-to-data-member}} + const int *ar[100] = {0}; + // Not even lenient g++ accepts this. + int *(*rar)[100] = const_cast<int *(*)[100]>(&ar); // expected-error {{const_cast from 'const int *(*)[100]' to 'int *(*)[100]' is not allowed}} + f fp1 = 0; + // Function pointers. + f fp2 = const_cast<f>(fp1); // expected-error {{const_cast to 'f' (aka 'int (*)(int)'), which is not a reference, pointer-to-object, or pointer-to-data-member}} + void (A::*mfn)() = 0; + (void)const_cast<void (A::*)()>(mfn); // expected-error {{const_cast to 'void (A::*)()', which is not a reference, pointer-to-object, or pointer-to-data-member}} + return **var3; +} diff --git a/clang/test/SemaCXX/constant-expression-cxx11.cpp b/clang/test/SemaCXX/constant-expression-cxx11.cpp new file mode 100644 index 0000000..9f80e71 --- /dev/null +++ b/clang/test/SemaCXX/constant-expression-cxx11.cpp @@ -0,0 +1,1250 @@ +// RUN: %clang_cc1 -triple i686-linux -Wno-string-plus-int -fsyntax-only -verify -std=c++11 -pedantic %s -Wno-comment + +namespace StaticAssertFoldTest { + +int x; +static_assert(++x, "test"); // expected-error {{not an integral constant expression}} +static_assert(false, "test"); // expected-error {{test}} + +} + +typedef decltype(sizeof(char)) size_t; + +template<typename T> constexpr T id(const T &t) { return t; } +template<typename T> constexpr T min(const T &a, const T &b) { + return a < b ? a : b; +} +template<typename T> constexpr T max(const T &a, const T &b) { + return a < b ? b : a; +} +template<typename T, size_t N> constexpr T *begin(T (&xs)[N]) { return xs; } +template<typename T, size_t N> constexpr T *end(T (&xs)[N]) { return xs + N; } + +struct MemberZero { + constexpr int zero() { return 0; } +}; + +namespace DerivedToVBaseCast { + + struct U { int n; }; + struct V : U { int n; }; + struct A : virtual V { int n; }; + struct Aa { int n; }; + struct B : virtual A, Aa {}; + struct C : virtual A, Aa {}; + struct D : B, C {}; + + D d; + constexpr B *p = &d; + constexpr C *q = &d; + + static_assert((void*)p != (void*)q, ""); + static_assert((A*)p == (A*)q, ""); + static_assert((Aa*)p != (Aa*)q, ""); + + constexpr B &pp = d; + constexpr C &qq = d; + static_assert((void*)&pp != (void*)&qq, ""); + static_assert(&(A&)pp == &(A&)qq, ""); + static_assert(&(Aa&)pp != &(Aa&)qq, ""); + + constexpr V *v = p; + constexpr V *w = q; + constexpr V *x = (A*)p; + static_assert(v == w, ""); + static_assert(v == x, ""); + + static_assert((U*)&d == p, ""); + static_assert((U*)&d == q, ""); + static_assert((U*)&d == v, ""); + static_assert((U*)&d == w, ""); + static_assert((U*)&d == x, ""); + + struct X {}; + struct Y1 : virtual X {}; + struct Y2 : X {}; + struct Z : Y1, Y2 {}; + Z z; + static_assert((X*)(Y1*)&z != (X*)(Y2*)&z, ""); +} + +namespace ConstCast { + +constexpr int n1 = 0; +constexpr int n2 = const_cast<int&>(n1); +constexpr int *n3 = const_cast<int*>(&n1); +constexpr int n4 = *const_cast<int*>(&n1); +constexpr const int * const *n5 = const_cast<const int* const*>(&n3); +constexpr int **n6 = const_cast<int**>(&n3); +constexpr int n7 = **n5; +constexpr int n8 = **n6; + +} + +namespace TemplateArgumentConversion { + template<int n> struct IntParam {}; + + using IntParam0 = IntParam<0>; + using IntParam0 = IntParam<id(0)>; + using IntParam0 = IntParam<MemberZero().zero>; // expected-error {{did you mean to call it with no arguments?}} +} + +namespace CaseStatements { + void f(int n) { + switch (n) { + case MemberZero().zero: // expected-error {{did you mean to call it with no arguments?}} expected-note {{previous}} + case id(0): // expected-error {{duplicate case value '0'}} + return; + } + } +} + +extern int &Recurse1; +int &Recurse2 = Recurse1; // expected-note {{declared here}} +int &Recurse1 = Recurse2; +constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}} + +extern const int RecurseA; +const int RecurseB = RecurseA; // expected-note {{declared here}} +const int RecurseA = 10; +constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}} + +namespace MemberEnum { + struct WithMemberEnum { + enum E { A = 42 }; + } wme; + + static_assert(wme.A == 42, ""); +} + +namespace DefaultArguments { + +const int z = int(); +constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) { + return a + b + *c + d; +} +const int four = 4; +constexpr int eight = 8; +constexpr const int twentyseven = 27; +static_assert(Sum() == 0, ""); +static_assert(Sum(1) == 1, ""); +static_assert(Sum(1, four) == 5, ""); +static_assert(Sum(1, eight, &twentyseven) == 36, ""); +static_assert(Sum(1, 2, &four, eight) == 15, ""); + +} + +namespace Ellipsis { + +// Note, values passed through an ellipsis can't actually be used. +constexpr int F(int a, ...) { return a; } +static_assert(F(0) == 0, ""); +static_assert(F(1, 0) == 1, ""); +static_assert(F(2, "test") == 2, ""); +static_assert(F(3, &F) == 3, ""); +int k = 0; // expected-note {{here}} +static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}} + +} + +namespace Recursion { + constexpr int fib(int n) { return n > 1 ? fib(n-1) + fib(n-2) : n; } + static_assert(fib(11) == 89, ""); + + constexpr int gcd_inner(int a, int b) { + return b == 0 ? a : gcd_inner(b, a % b); + } + constexpr int gcd(int a, int b) { + return gcd_inner(max(a, b), min(a, b)); + } + + static_assert(gcd(1749237, 5628959) == 7, ""); +} + +namespace FunctionCast { + // When folding, we allow functions to be cast to different types. Such + // cast functions cannot be called, even if they're constexpr. + constexpr int f() { return 1; } + typedef double (*DoubleFn)(); + typedef int (*IntFn)(); + int a[(int)DoubleFn(f)()]; // expected-error {{variable length array}} expected-warning{{C99 feature}} + int b[(int)IntFn(f)()]; // ok +} + +namespace StaticMemberFunction { + struct S { + static constexpr int k = 42; + static constexpr int f(int n) { return n * k + 2; } + } s; + + constexpr int n = s.f(19); + static_assert(S::f(19) == 800, ""); + static_assert(s.f(19) == 800, ""); + static_assert(n == 800, ""); + + constexpr int (*sf1)(int) = &S::f; + constexpr int (*sf2)(int) = &s.f; + constexpr const int *sk = &s.k; +} + +namespace ParameterScopes { + + const int k = 42; + constexpr const int &ObscureTheTruth(const int &a) { return a; } + constexpr const int &MaybeReturnJunk(bool b, const int a) { // expected-note 2{{declared here}} + return ObscureTheTruth(b ? a : k); + } + static_assert(MaybeReturnJunk(false, 0) == 42, ""); // ok + constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}} + + constexpr const int MaybeReturnNonstaticRef(bool b, const int a) { + return ObscureTheTruth(b ? a : k); + } + static_assert(MaybeReturnNonstaticRef(false, 0) == 42, ""); // ok + constexpr int b = MaybeReturnNonstaticRef(true, 0); // ok + + constexpr int InternalReturnJunk(int n) { + return MaybeReturnJunk(true, n); // expected-note {{read of variable whose lifetime has ended}} + } + constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}} + + constexpr int LToR(int &n) { return n; } + constexpr int GrabCallersArgument(bool which, int a, int b) { + return LToR(which ? b : a); + } + static_assert(GrabCallersArgument(false, 1, 2) == 1, ""); + static_assert(GrabCallersArgument(true, 4, 8) == 8, ""); + +} + +namespace Pointers { + + constexpr int f(int n, const int *a, const int *b, const int *c) { + return n == 0 ? 0 : *a + f(n-1, b, c, a); + } + + const int x = 1, y = 10, z = 100; + static_assert(f(23, &x, &y, &z) == 788, ""); + + constexpr int g(int n, int a, int b, int c) { + return f(n, &a, &b, &c); + } + static_assert(g(23, x, y, z) == 788, ""); + +} + +namespace FunctionPointers { + + constexpr int Double(int n) { return 2 * n; } + constexpr int Triple(int n) { return 3 * n; } + constexpr int Twice(int (*F)(int), int n) { return F(F(n)); } + constexpr int Quadruple(int n) { return Twice(Double, n); } + constexpr auto Select(int n) -> int (*)(int) { + return n == 2 ? &Double : n == 3 ? &Triple : n == 4 ? &Quadruple : 0; + } + constexpr int Apply(int (*F)(int), int n) { return F(n); } // expected-note {{subexpression}} + + static_assert(1 + Apply(Select(4), 5) + Apply(Select(3), 7) == 42, ""); + + constexpr int Invalid = Apply(Select(0), 0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Apply(0, 0)'}} + +} + +namespace PointerComparison { + +int x, y; +static_assert(&x == &y, "false"); // expected-error {{false}} +static_assert(&x != &y, ""); +constexpr bool g1 = &x == &y; +constexpr bool g2 = &x != &y; +constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool g4 = &x >= &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool g5 = &x < &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool g6 = &x > &y; // expected-error {{must be initialized by a constant expression}} + +struct S { int x, y; } s; +static_assert(&s.x == &s.y, "false"); // expected-error {{false}} +static_assert(&s.x != &s.y, ""); +static_assert(&s.x <= &s.y, ""); +static_assert(&s.x >= &s.y, "false"); // expected-error {{false}} +static_assert(&s.x < &s.y, ""); +static_assert(&s.x > &s.y, "false"); // expected-error {{false}} + +static_assert(0 == &y, "false"); // expected-error {{false}} +static_assert(0 != &y, ""); +constexpr bool n3 = 0 <= &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool n4 = 0 >= &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool n5 = 0 < &y; // expected-error {{must be initialized by a constant expression}} +constexpr bool n6 = 0 > &y; // expected-error {{must be initialized by a constant expression}} + +static_assert(&x == 0, "false"); // expected-error {{false}} +static_assert(&x != 0, ""); +constexpr bool n9 = &x <= 0; // expected-error {{must be initialized by a constant expression}} +constexpr bool n10 = &x >= 0; // expected-error {{must be initialized by a constant expression}} +constexpr bool n11 = &x < 0; // expected-error {{must be initialized by a constant expression}} +constexpr bool n12 = &x > 0; // expected-error {{must be initialized by a constant expression}} + +static_assert(&x == &x, ""); +static_assert(&x != &x, "false"); // expected-error {{false}} +static_assert(&x <= &x, ""); +static_assert(&x >= &x, ""); +static_assert(&x < &x, "false"); // expected-error {{false}} +static_assert(&x > &x, "false"); // expected-error {{false}} + +constexpr S* sptr = &s; +constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}} + +struct U {}; +struct Str { + int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{dynamic_cast is not allowed in a constant expression}} + int b : reinterpret_cast<S*>(sptr) == reinterpret_cast<S*>(sptr); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{reinterpret_cast is not allowed in a constant expression}} + int c : (S*)(long)(sptr) == (S*)(long)(sptr); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + int d : (S*)(42) == (S*)(42); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + int e : (Str*)(sptr) == (Str*)(sptr); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + int f : &(U&)(*sptr) == &(U&)(*sptr); // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + int g : (S*)(void*)(sptr) == sptr; // \ + expected-warning {{not an integral constant expression}} \ + expected-note {{cast from 'void *' is not allowed in a constant expression}} +}; + +extern char externalvar[]; +constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} +constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} expected-warning {{unspecified}} +static_assert(0 != "foo", ""); + +} + +namespace MaterializeTemporary { + +constexpr int f(const int &r) { return r; } +constexpr int n = f(1); + +constexpr bool same(const int &a, const int &b) { return &a == &b; } +constexpr bool sameTemporary(const int &n) { return same(n, n); } + +static_assert(n, ""); +static_assert(!same(4, 4), ""); +static_assert(same(n, n), ""); +static_assert(sameTemporary(9), ""); + +} + +constexpr int strcmp_ce(const char *p, const char *q) { + return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1); +} + +namespace StringLiteral { + +template<typename Char> +constexpr int MangleChars(const Char *p) { + return *p + 3 * (*p ? MangleChars(p+1) : 0); +} + +static_assert(MangleChars("constexpr!") == 1768383, ""); +static_assert(MangleChars(u8"constexpr!") == 1768383, ""); +static_assert(MangleChars(L"constexpr!") == 1768383, ""); +static_assert(MangleChars(u"constexpr!") == 1768383, ""); +static_assert(MangleChars(U"constexpr!") == 1768383, ""); + +constexpr char c0 = "nought index"[0]; +constexpr char c1 = "nice index"[10]; +constexpr char c2 = "nasty index"[12]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is past the end}} expected-note {{read of dereferenced one-past-the-end pointer}} +constexpr char c3 = "negative index"[-1]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is before the beginning}} expected-note {{cannot refer to element -1 of array of 15 elements}} +constexpr char c4 = ((char*)(int*)"no reinterpret_casts allowed")[14]; // expected-error {{must be initialized by a constant expression}} expected-note {{cast which performs the conversions of a reinterpret_cast}} + +constexpr const char *p = "test" + 2; +static_assert(*p == 's', ""); + +constexpr const char *max_iter(const char *a, const char *b) { + return *a < *b ? b : a; +} +constexpr const char *max_element(const char *a, const char *b) { + return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b)); +} + +constexpr char str[] = "the quick brown fox jumped over the lazy dog"; +constexpr const char *max = max_element(begin(str), end(str)); +static_assert(*max == 'z', ""); +static_assert(max == str + 38, ""); + +static_assert(strcmp_ce("hello world", "hello world") == 0, ""); +static_assert(strcmp_ce("hello world", "hello clang") > 0, ""); +static_assert(strcmp_ce("constexpr", "test") < 0, ""); +static_assert(strcmp_ce("", " ") < 0, ""); + +struct S { + int n : "foo"[4]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} +}; + +struct T { + char c[6]; + constexpr T() : c{"foo"} {} +}; +constexpr T t; + +static_assert(t.c[0] == 'f', ""); +static_assert(t.c[1] == 'o', ""); +static_assert(t.c[2] == 'o', ""); +static_assert(t.c[3] == 0, ""); +static_assert(t.c[4] == 0, ""); +static_assert(t.c[5] == 0, ""); +static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}} + +struct U { + wchar_t chars[6]; + int n; +} constexpr u = { { L"test" }, 0 }; +static_assert(u.chars[2] == L's', ""); + +struct V { + char c[4]; + constexpr V() : c("hi!") {} +}; +static_assert(V().c[1] == "i"[0], ""); + +} + +namespace Array { + +template<typename Iter> +constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) { + return begin == end ? 0 : *begin + Sum(begin+1, end); +} + +constexpr int xs[] = { 1, 2, 3, 4, 5 }; +constexpr int ys[] = { 5, 4, 3, 2, 1 }; +constexpr int sum_xs = Sum(begin(xs), end(xs)); +static_assert(sum_xs == 15, ""); + +constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n, + const int *xs, const int *ys, int c) { + return n ? F( + *xs, // expected-note {{read of dereferenced one-past-the-end pointer}} + *ys, + ZipFoldR(F, n-1, xs+1, ys+1, c)) // \ + expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \ + expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}} + : c; +} +constexpr int MulAdd(int x, int y, int c) { return x * y + c; } +constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0); +static_assert(InnerProduct == 35, ""); + +constexpr int SubMul(int x, int y, int c) { return (x - y) * c; } +constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1); +static_assert(DiffProd == 8, ""); +static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \ + expected-error {{constant expression}} \ + expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}} + +constexpr const int *p = xs + 3; +constexpr int xs4 = p[1]; // ok +constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} +constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}} +constexpr int xs0 = p[-3]; // ok +constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} + +constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; +static_assert(zs[0][0][0][0] == 1, ""); +static_assert(zs[1][1][1][1] == 16, ""); +static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} +static_assert((&zs[0][0][0][2])[-1] == 2, ""); +static_assert(**(**(zs + 1) + 1) == 11, ""); +static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][-1] + 1) == 11, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of array of 2 elements in a constant expression}} +static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, ""); +constexpr int err_zs_1_2_0_0 = zs[1][2][0][0]; // expected-error {{constant expression}} expected-note {{cannot access array element of pointer past the end}} + +constexpr int fail(const int &p) { + return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}} +} +static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \ +expected-error {{static_assert expression is not an integral constant expression}} \ +expected-note {{in call to 'fail(zs[1][0][1][0])'}} + +constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}} +constexpr int SumNonzero(const int *p) { + return *p + (*p ? SumNonzero(p+1) : 0); +} +constexpr int CountZero(const int *p, const int *q) { + return p == q ? 0 : (*p == 0) + CountZero(p+1, q); +} +static_assert(SumNonzero(arr) == 6, ""); +static_assert(CountZero(arr, arr + 40) == 36, ""); + +struct ArrayElem { + constexpr ArrayElem() : n(0) {} + int n; + constexpr int f() { return n; } +}; +struct ArrayRVal { + constexpr ArrayRVal() {} + ArrayElem elems[10]; +}; +static_assert(ArrayRVal().elems[3].f() == 0, ""); + +} + +namespace DependentValues { + +struct I { int n; typedef I V[10]; }; +I::V x, y; +template<bool B> struct S { + int k; + void f() { + I::V &cells = B ? x : y; + I &i = cells[k]; + switch (i.n) {} + } +}; + +} + +namespace Class { + +struct A { constexpr A(int a, int b) : k(a + b) {} int k; }; +constexpr int fn(const A &a) { return a.k; } +static_assert(fn(A(4,5)) == 9, ""); + +struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}} +struct C { + constexpr C(C *this_) : m(42), n(this_->m) {} // ok + int m, n; +}; +struct D { + C c; + constexpr D() : c(&c) {} +}; +static_assert(D().c.n == 42, ""); + +struct E { + constexpr E() : p(&p) {} + void *p; +}; +constexpr const E &e1 = E(); // expected-error {{constant expression}} expected-note {{reference to temporary is not a constant expression}} expected-note {{temporary created here}} +// This is a constant expression if we elide the copy constructor call, and +// is not a constant expression if we don't! But we do, so it is. +constexpr E e2 = E(); +static_assert(e2.p == &e2.p, ""); +constexpr E e3; +static_assert(e3.p == &e3.p, ""); + +extern const class F f; +struct F { + constexpr F() : p(&f.p) {} + const void *p; +}; +constexpr F f; + +struct G { + struct T { + constexpr T(T *p) : u1(), u2(p) {} + union U1 { + constexpr U1() {} + int a, b = 42; + } u1; + union U2 { + constexpr U2(T *p) : c(p->u1.b) {} + int c, d; + } u2; + } t; + constexpr G() : t(&t) {} +} constexpr g; + +static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}} +static_assert(g.t.u1.b == 42, ""); +static_assert(g.t.u2.c == 42, ""); +static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}} + +struct S { + int a, b; + const S *p; + double d; + const char *q; + + constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {} +}; + +S global(43, &global); + +static_assert(S(15, &global).b == 15, ""); + +constexpr bool CheckS(const S &s) { + return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l'; +} +static_assert(CheckS(S(27, &global)), ""); + +struct Arr { + char arr[3]; + constexpr Arr() : arr{'x', 'y', 'z'} {} +}; +constexpr int hash(Arr &&a) { + return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000; +} +constexpr int k = hash(Arr()); +static_assert(k == 0x007a7978, ""); + + +struct AggregateInit { + const char &c; + int n; + double d; + int arr[5]; + void *p; +}; + +constexpr AggregateInit agg1 = { "hello"[0] }; + +static_assert(strcmp_ce(&agg1.c, "hello") == 0, ""); +static_assert(agg1.n == 0, ""); +static_assert(agg1.d == 0.0, ""); +static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} +static_assert(agg1.arr[0] == 0, ""); +static_assert(agg1.arr[4] == 0, ""); +static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}} +static_assert(agg1.p == nullptr, ""); + +static constexpr const unsigned char uc[] = { "foo" }; +static_assert(uc[0] == 'f', ""); +static_assert(uc[3] == 0, ""); + +namespace SimpleDerivedClass { + +struct B { + constexpr B(int n) : a(n) {} + int a; +}; +struct D : B { + constexpr D(int n) : B(n) {} +}; +constexpr D d(3); +static_assert(d.a == 3, ""); + +} + +struct Bottom { constexpr Bottom() {} }; +struct Base : Bottom { + constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {} + int a; + const char *b; +}; +struct Base2 : Bottom { + constexpr Base2(const int &r) : r(r) {} + int q = 123; + const int &r; +}; +struct Derived : Base, Base2 { + constexpr Derived() : Base(76), Base2(a) {} + int c = r + b[1]; +}; + +constexpr bool operator==(const Base &a, const Base &b) { + return a.a == b.a && strcmp_ce(a.b, b.b) == 0; +} + +constexpr Base base; +constexpr Base base2(76); +constexpr Derived derived; +static_assert(derived.a == 76, ""); +static_assert(derived.b[2] == 's', ""); +static_assert(derived.c == 76 + 'e', ""); +static_assert(derived.q == 123, ""); +static_assert(derived.r == 76, ""); +static_assert(&derived.r == &derived.a, ""); + +static_assert(!(derived == base), ""); +static_assert(derived == base2, ""); + +constexpr Bottom &bot1 = (Base&)derived; +constexpr Bottom &bot2 = (Base2&)derived; +static_assert(&bot1 != &bot2, ""); + +constexpr Bottom *pb1 = (Base*)&derived; +constexpr Bottom *pb2 = (Base2*)&derived; +static_assert(&pb1 != &pb2, ""); +static_assert(pb1 == &bot1, ""); +static_assert(pb2 == &bot2, ""); + +constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}} +constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}} +constexpr Base2 &ok2 = (Base2&)bot2; +static_assert(&ok2 == &derived, ""); + +constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}} +constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}} +constexpr Base2 *pok2 = (Base2*)pb2; +static_assert(pok2 == &derived, ""); +static_assert(&ok2 == pok2, ""); +static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, ""); +static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, ""); + +constexpr Base *nullB = 42 - 6 * 7; +static_assert((Bottom*)nullB == 0, ""); +static_assert((Derived*)nullB == 0, ""); +static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, ""); + +namespace ConversionOperators { + +struct T { + constexpr T(int n) : k(5*n - 3) {} + constexpr operator int() { return k; } + int k; +}; + +struct S { + constexpr S(int n) : k(2*n + 1) {} + constexpr operator int() { return k; } + constexpr operator T() { return T(k); } + int k; +}; + +constexpr bool check(T a, T b) { return a == b.k; } + +static_assert(S(5) == 11, ""); +static_assert(check(S(5), 11), ""); + +} + +} + +namespace Temporaries { + +struct S { + constexpr S() {} + constexpr int f(); +}; +struct T : S { + constexpr T(int n) : S(), n(n) {} + int n; +}; +constexpr int S::f() { + // 'this' must be the postfix-expression in a class member access expression, + // so we can't just use + // return static_cast<T*>(this)->n; + return this->*(int(S::*))&T::n; +} +// The T temporary is implicitly cast to an S subobject, but we can recover the +// T full-object via a base-to-derived cast, or a derived-to-base-casted member +// pointer. +static_assert(T(3).f() == 3, ""); + +constexpr int f(const S &s) { + return static_cast<const T&>(s).n; +} +constexpr int n = f(T(5)); +static_assert(f(T(5)) == 5, ""); + +constexpr bool b(int n) { return &n; } +static_assert(b(0), ""); + +} + +namespace Union { + +union U { + int a; + int b; +}; + +constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}} +static_assert(u[0].a == 0, ""); +static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}} +static_assert(u[1].b == 1, ""); +static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} +static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}} +static_assert((&(u[1]) + 1 + 1)->b == 3, ""); + +constexpr U v = {}; +static_assert(v.a == 0, ""); + +union Empty {}; +constexpr Empty e = {}; + +// Make sure we handle trivial copy constructors for unions. +constexpr U x = {42}; +constexpr U y = x; +static_assert(y.a == 42, ""); +static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}} + +} + +namespace MemberPointer { + struct A { + constexpr A(int n) : n(n) {} + int n; + constexpr int f() { return n + 3; } + }; + constexpr A a(7); + static_assert(A(5).*&A::n == 5, ""); + static_assert((&a)->*&A::n == 7, ""); + static_assert((A(8).*&A::f)() == 11, ""); + static_assert(((&a)->*&A::f)() == 10, ""); + + struct B : A { + constexpr B(int n, int m) : A(n), m(m) {} + int m; + constexpr int g() { return n + m + 1; } + }; + constexpr B b(9, 13); + static_assert(B(4, 11).*&A::n == 4, ""); + static_assert(B(4, 11).*&B::m == 11, ""); + static_assert(B(4, 11).*(int(A::*))&B::m == 11, ""); + static_assert((&b)->*&A::n == 9, ""); + static_assert((&b)->*&B::m == 13, ""); + static_assert((&b)->*(int(A::*))&B::m == 13, ""); + static_assert((B(4, 11).*&A::f)() == 7, ""); + static_assert((B(4, 11).*&B::g)() == 16, ""); + static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, ""); + static_assert(((&b)->*&A::f)() == 12, ""); + static_assert(((&b)->*&B::g)() == 23, ""); + static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, ""); + + struct S { + constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) : + m(m), n(n), pf(pf), pn(pn) {} + constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {} + + constexpr int f() { return this->*pn; } + virtual int g() const; + + int m, n; + int (S::*pf)() const; + int S::*pn; + }; + + constexpr int S::*pm = &S::m; + constexpr int S::*pn = &S::n; + constexpr int (S::*pf)() const = &S::f; + constexpr int (S::*pg)() const = &S::g; + + constexpr S s(2, 5, &S::f, &S::m); + + static_assert((s.*&S::f)() == 2, ""); + static_assert((s.*s.pf)() == 2, ""); + + static_assert(pf == &S::f, ""); + static_assert(pf == s.*&S::pf, ""); + static_assert(pm == &S::m, ""); + static_assert(pm != pn, ""); + static_assert(s.pn != pn, ""); + static_assert(s.pn == pm, ""); + static_assert(pg != nullptr, ""); + static_assert(pf != nullptr, ""); + static_assert((int S::*)nullptr == nullptr, ""); + static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}} + static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}} + + template<int n> struct T : T<n-1> {}; + template<> struct T<0> { int n; }; + template<> struct T<30> : T<29> { int m; }; + + T<17> t17; + T<30> t30; + + constexpr int (T<10>::*deepn) = &T<0>::n; + static_assert(&(t17.*deepn) == &t17.n, ""); + static_assert(deepn == &T<2>::n, ""); + + constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m; + constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}} + static_assert(&(t30.*deepm) == &t30.m, ""); + static_assert(deepm == &T<50>::m, ""); + static_assert(deepm != deepn, ""); + + constexpr T<5> *p17_5 = &t17; + constexpr T<13> *p17_13 = (T<13>*)p17_5; + constexpr T<23> *p17_23 = (T<23>*)p17_13; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'T<17>' to type 'T<23>'}} + static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, ""); + static_assert(&(p17_13->*deepn) == &t17.n, ""); + constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}} + + constexpr T<5> *p30_5 = &t30; + constexpr T<23> *p30_23 = (T<23>*)p30_5; + constexpr T<13> *p30_13 = p30_23; + static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, ""); + static_assert(&(p30_13->*deepn) == &t30.n, ""); + static_assert(&(p30_23->*deepn) == &t30.n, ""); + static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, ""); + static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, ""); + static_assert(&(p30_23->*deepm) == &t30.m, ""); + + struct Base { int n; }; + template<int N> struct Mid : Base {}; + struct Derived : Mid<0>, Mid<1> {}; + static_assert(&Mid<0>::n == &Mid<1>::n, ""); + static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n != + (int Derived::*)(int Mid<1>::*)&Mid<1>::n, ""); + static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, ""); +} + +namespace ArrayBaseDerived { + + struct Base { + constexpr Base() {} + int n = 0; + }; + struct Derived : Base { + constexpr Derived() {} + constexpr const int *f() { return &n; } + }; + + constexpr Derived a[10]; + constexpr Derived *pd3 = const_cast<Derived*>(&a[3]); + constexpr Base *pb3 = const_cast<Derived*>(&a[3]); + static_assert(pb3 == pd3, ""); + + // pb3 does not point to an array element. + constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer. + constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}} + constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}} + constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}} + constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}} + constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}} + constexpr Base *pb3a = pb4 - 1; + + // pb4 does not point to a Derived. + constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}} + constexpr Derived *pd3a = (Derived*)pb3a; + constexpr int pd3n = pd3a->n; + + // pd3a still points to the Derived array. + constexpr Derived *pd6 = pd3a + 3; + static_assert(pd6 == &a[6], ""); + constexpr Derived *pd9 = pd6 + 3; + constexpr Derived *pd10 = pd6 + 4; + constexpr int pd9n = pd9->n; // ok + constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}} + constexpr int pd0n = pd10[-10].n; + constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}} + + constexpr Base *pb9 = pd9; + constexpr const int *(Base::*pfb)() const = + static_cast<const int *(Base::*)() const>(&Derived::f); + static_assert((pb9->*pfb)() == &a[9].n, ""); +} + +namespace Complex { + +class complex { + int re, im; +public: + constexpr complex(int re = 0, int im = 0) : re(re), im(im) {} + constexpr complex(const complex &o) : re(o.re), im(o.im) {} + constexpr complex operator-() const { return complex(-re, -im); } + friend constexpr complex operator+(const complex &l, const complex &r) { + return complex(l.re + r.re, l.im + r.im); + } + friend constexpr complex operator-(const complex &l, const complex &r) { + return l + -r; + } + friend constexpr complex operator*(const complex &l, const complex &r) { + return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re); + } + friend constexpr bool operator==(const complex &l, const complex &r) { + return l.re == r.re && l.im == r.im; + } + constexpr bool operator!=(const complex &r) const { + return re != r.re || im != r.im; + } + constexpr int real() const { return re; } + constexpr int imag() const { return im; } +}; + +constexpr complex i = complex(0, 1); +constexpr complex k = (3 + 4*i) * (6 - 4*i); +static_assert(complex(1,0).real() == 1, ""); +static_assert(complex(1,0).imag() == 0, ""); +static_assert(((complex)1).imag() == 0, ""); +static_assert(k.real() == 34, ""); +static_assert(k.imag() == 12, ""); +static_assert(k - 34 == 12*i, ""); +static_assert((complex)1 == complex(1), ""); +static_assert((complex)1 != complex(0, 1), ""); +static_assert(complex(1) == complex(1), ""); +static_assert(complex(1) != complex(0, 1), ""); +constexpr complex makeComplex(int re, int im) { return complex(re, im); } +static_assert(makeComplex(1,0) == complex(1), ""); +static_assert(makeComplex(1,0) != complex(0, 1), ""); + +class complex_wrap : public complex { +public: + constexpr complex_wrap(int re, int im = 0) : complex(re, im) {} + constexpr complex_wrap(const complex_wrap &o) : complex(o) {} +}; + +static_assert((complex_wrap)1 == complex(1), ""); +static_assert((complex)1 != complex_wrap(0, 1), ""); +static_assert(complex(1) == complex_wrap(1), ""); +static_assert(complex_wrap(1) != complex(0, 1), ""); +constexpr complex_wrap makeComplexWrap(int re, int im) { + return complex_wrap(re, im); +} +static_assert(makeComplexWrap(1,0) == complex(1), ""); +static_assert(makeComplexWrap(1,0) != complex(0, 1), ""); + +} + +namespace PR11595 { + struct A { constexpr bool operator==(int x) { return true; } }; + struct B { B(); A& x; }; + static_assert(B().x == 3, ""); // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}} + + constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}} + return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}} + } +} + +namespace ExprWithCleanups { + struct A { A(); ~A(); int get(); }; + constexpr int get(bool FromA) { return FromA ? A().get() : 1; } + constexpr int n = get(false); +} + +namespace Volatile { + +volatile constexpr int n1 = 0; // expected-note {{here}} +volatile const int n2 = 0; // expected-note {{here}} +int n3 = 37; // expected-note {{declared here}} + +constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}} +constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}} +constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}} +constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}} + +struct T { int n; }; +const T t = { 42 }; // expected-note {{declared here}} + +constexpr int f(volatile int &&r) { + return r; // expected-note {{read of volatile-qualified type 'volatile int'}} +} +constexpr int g(volatile int &&r) { + return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}} +} +struct S { + int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}} + int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}} + int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}} + int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}} +}; + +} + +namespace ExternConstexpr { + extern constexpr int n = 0; + extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}} + void f() { + extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}} + constexpr int j = 0; + constexpr int k; // expected-error {{default initialization of an object of const type}} + } +} + +namespace ComplexConstexpr { + constexpr _Complex float test1 = {}; + constexpr _Complex float test2 = {1}; + constexpr _Complex double test3 = {1,2}; + constexpr _Complex int test4 = {4}; + constexpr _Complex int test5 = 4; + constexpr _Complex int test6 = {5,6}; + typedef _Complex float fcomplex; + constexpr fcomplex test7 = fcomplex(); + + constexpr const double &t2r = __real test3; + constexpr const double &t2i = __imag test3; + static_assert(&t2r + 1 == &t2i, ""); + static_assert(t2r == 1.0, ""); + static_assert(t2i == 2.0, ""); + constexpr const double *t2p = &t2r; + static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}} + static_assert(t2p[0] == 1.0, ""); + static_assert(t2p[1] == 2.0, ""); + static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}} + static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}} + constexpr _Complex float *p = 0; + constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}} + constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}} + constexpr const _Complex double *q = &test3 + 1; + constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}} + constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}} + + static_assert(__real test6 == 5, ""); + static_assert(__imag test6 == 6, ""); + static_assert(&__imag test6 == &__real test6 + 1, ""); +} + +namespace InstantiateCaseStmt { + template<int x> constexpr int f() { return x; } + template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; } + int gg(int c) { return g<4>(c); } +} + +namespace ConvertedConstantExpr { + extern int &m; + extern int &n; + + constexpr int k = 4; + int &m = const_cast<int&>(k); + + // If we have nothing more interesting to say, ensure we don't produce a + // useless note and instead just point to the non-constant subexpression. + enum class E { + em = m, + en = n, // expected-error {{not a constant expression}} + eo = (m + + n // expected-error {{not a constant expression}} + ), + eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}} + }; +} + +namespace IndirectField { + struct S { + struct { // expected-warning {{GNU extension}} + union { + struct { // expected-warning {{GNU extension}} + int a; + int b; + }; + int c; + }; + int d; + }; + union { + int e; + int f; + }; + constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {} + constexpr S(int c, int d, int f) : c(c), d(d), f(f) {} + }; + + constexpr S s1(1, 2, 3, 4); + constexpr S s2(5, 6, 7); + + // FIXME: The diagnostics here do a very poor job of explaining which unnamed + // member is active and which is requested. + static_assert(s1.a == 1, ""); + static_assert(s1.b == 2, ""); + static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} + static_assert(s1.d == 3, ""); + static_assert(s1.e == 4, ""); + static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} + + static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} + static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} + static_assert(s2.c == 5, ""); + static_assert(s2.d == 6, ""); + static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} + static_assert(s2.f == 7, ""); +} + +// DR1405: don't allow reading mutable members in constant expressions. +namespace MutableMembers { + struct MM { + mutable int n; // expected-note 3{{declared here}} + } constexpr mm = { 4 }; + constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}} + int x = (mm.n = 1, 3); + constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}} + + // Here's one reason why allowing this would be a disaster... + template<int n> struct Id { int k = n; }; + int f() { + constexpr MM m = { 0 }; + ++m.n; + return Id<m.n>().k; // expected-error {{not a constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}} + } + + struct A { int n; }; + struct B { mutable A a; }; // expected-note {{here}} + struct C { B b; }; + constexpr C c[3] = {}; + constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}} +} + +namespace Fold { + + // This macro forces its argument to be constant-folded, even if it's not + // otherwise a constant expression. + #define fold(x) (__builtin_constant_p(x) ? (x) : (x)) + + constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}} + constexpr int m = fold((int)(char*)123); // ok + static_assert(m == 123, ""); + + #undef fold + +} + +namespace DR1454 { + +constexpr const int &f(const int &n) { return n; } +constexpr int k1 = f(0); // ok + +struct Wrap { + const int &value; +}; +constexpr const Wrap &g(const Wrap &w) { return w; } +constexpr int k2 = g({0}).value; // ok + +constexpr const int &i = 0; // expected-error {{constant expression}} expected-note {{temporary}} expected-note 2{{here}} +constexpr const int j = i; // expected-error {{constant expression}} expected-note {{initializer of 'i' is not a constant expression}} + +} + +namespace RecursiveOpaqueExpr { + template<typename Iter> + constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) { + return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}} + } + + constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 }; + static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, ""); + + constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 }; + static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, ""); +} + +namespace VLASizeof { + + void f(int k) { + int arr[k]; // expected-warning {{C99}} + constexpr int n = 1 + + sizeof(arr) // expected-error {{constant expression}} + * 3; + } +} + +namespace CompoundLiteral { + // FIXME: + // We don't model the semantics of this correctly: the compound literal is + // represented as a prvalue in the AST, but actually behaves like an lvalue. + // We treat the compound literal as a temporary and refuse to produce a + // pointer to it. This is OK: we're not required to treat this as a constant + // in C++, and in C we model compound literals as lvalues. + constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}} +} + +namespace Vector { + typedef int __attribute__((vector_size(16))) VI4; + constexpr VI4 f(int n) { + return VI4 { n * 3, n + 4, n - 5, n / 6 }; + } + constexpr auto v1 = f(10); + + typedef double __attribute__((vector_size(32))) VD4; + constexpr VD4 g(int n) { + return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}} + } + constexpr auto v2 = g(4); +} diff --git a/clang/test/SemaCXX/constant-expression.cpp b/clang/test/SemaCXX/constant-expression.cpp new file mode 100644 index 0000000..23a4dda --- /dev/null +++ b/clang/test/SemaCXX/constant-expression.cpp @@ -0,0 +1,119 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 -pedantic %s +// C++ [expr.const]p1: +// In several places, C++ requires expressions that evaluate to an integral +// or enumeration constant: as array bounds, as case expressions, as +// bit-field lengths, as enumerator initializers, as static member +// initializers, and as integral or enumeration non-type template arguments. +// An integral constant-expression can involve only literals, enumerators, +// const variables or static data members of integral or enumeration types +// initialized with constant expressions, and sizeof expressions. Floating +// literals can appear only if they are cast to integral or enumeration types. + +enum Enum { eval = 1 }; +const int cval = 2; +const Enum ceval = eval; +struct Struct { + static const int sval = 3; + static const Enum seval = eval; +}; + +template <int itval, Enum etval> struct C { + enum E { + v1 = 1, + v2 = eval, + v3 = cval, + v4 = ceval, + v5 = Struct::sval, + v6 = Struct::seval, + v7 = itval, + v8 = etval, + v9 = (int)1.5, + v10 = sizeof(Struct), + v11 = true? 1 + cval * Struct::sval ^ itval / (int)1.5 - sizeof(Struct) : 0 + }; + unsigned + b1 : 1, + b2 : eval, + b3 : cval, + b4 : ceval, + b5 : Struct::sval, + b6 : Struct::seval, + b7 : itval, + b8 : etval, + b9 : (int)1.5, + b10 : sizeof(Struct), + b11 : true? 1 + cval * Struct::sval ^ itval / (int)1.5 - sizeof(Struct) : 0 + ; + static const int + i1 = 1, + i2 = eval, + i3 = cval, + i4 = ceval, + i5 = Struct::sval, + i6 = Struct::seval, + i7 = itval, + i8 = etval, + i9 = (int)1.5, + i10 = sizeof(Struct), + i11 = true? 1 + cval * Struct::sval ^ itval / (int)1.5 - sizeof(Struct) : 0 + ; + void f(int cond) { + switch(cond) { + case 0 + 1: + case 100 + eval: + case 200 + cval: + case 300 + ceval: + case 400 + Struct::sval: + case 500 + Struct::seval: + case 600 + itval: + case 700 + etval: + case 800 + (int)1.5: + case 900 + sizeof(Struct): + case 1000 + (true? 1 + cval * Struct::sval ^ + itval / (int)1.5 - sizeof(Struct) : 0): + ; + } + } + typedef C<itval, etval> T0; +}; + +template struct C<1, eval>; +template struct C<cval, ceval>; +template struct C<Struct::sval, Struct::seval>; + +enum { + a = sizeof(int) == 8, + b = a? 8 : 4 +}; + +void diags(int n) { + switch (n) { + case (1/0, 1): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} + case (int)(1/0, 2.0): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} + case __imag(1/0): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} + case (int)__imag((double)(1/0)): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} + ; + } +} + +namespace IntOrEnum { + const int k = 0; + const int &p = k; + template<int n> struct S {}; + S<p> s; // expected-error {{not an integral constant expression}} +} + +extern const int recurse1; +// recurse2 cannot be used in a constant expression because it is not +// initialized by a constant expression. The same expression appearing later in +// the TU would be a constant expression, but here it is not. +const int recurse2 = recurse1; +const int recurse1 = 1; +int array1[recurse1]; // ok +int array2[recurse2]; // expected-warning {{variable length array}} expected-warning {{integer constant expression}} + +namespace FloatConvert { + typedef int a[(int)42.3]; + typedef int a[(int)42.997]; + typedef int b[(int)4e10]; // expected-warning {{variable length}} expected-error {{variable length}} +} diff --git a/clang/test/SemaCXX/constexpr-ackermann.cpp b/clang/test/SemaCXX/constexpr-ackermann.cpp new file mode 100644 index 0000000..c4ea313 --- /dev/null +++ b/clang/test/SemaCXX/constexpr-ackermann.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s + +constexpr unsigned long long A(unsigned long long m, unsigned long long n) { + return m == 0 ? n + 1 : n == 0 ? A(m-1, 1) : A(m - 1, A(m, n - 1)); +} + +using X = int[A(3,4)]; +using X = int[125]; diff --git a/clang/test/SemaCXX/constexpr-backtrace-limit.cpp b/clang/test/SemaCXX/constexpr-backtrace-limit.cpp new file mode 100644 index 0000000..9c40eed --- /dev/null +++ b/clang/test/SemaCXX/constexpr-backtrace-limit.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -fconstexpr-backtrace-limit 0 -fconstexpr-depth 4 -fno-caret-diagnostics 2>&1 | FileCheck %s -check-prefix=TEST1 +// TEST1: constant expression +// TEST1-NEXT: exceeded maximum depth of 4 +// TEST1-NEXT: in call to 'recurse(2)' +// TEST1-NEXT: in call to 'recurse(3)' +// TEST1-NEXT: in call to 'recurse(4)' +// TEST1-NEXT: in call to 'recurse(5)' + +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -fconstexpr-backtrace-limit 2 -fconstexpr-depth 4 -fno-caret-diagnostics 2>&1 | FileCheck %s -check-prefix=TEST2 +// TEST2: constant expression +// TEST2-NEXT: exceeded maximum depth of 4 +// TEST2-NEXT: in call to 'recurse(2)' +// TEST2-NEXT: skipping 2 calls +// TEST2-NEXT: in call to 'recurse(5)' + +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -fconstexpr-backtrace-limit 2 -fconstexpr-depth 8 -fno-caret-diagnostics 2>&1 | FileCheck %s -check-prefix=TEST3 +// TEST3: constant expression +// TEST3-NEXT: reinterpret_cast +// TEST3-NEXT: in call to 'recurse(0)' +// TEST3-NEXT: skipping 4 calls +// TEST3-NEXT: in call to 'recurse(5)' + +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -fconstexpr-backtrace-limit 8 -fconstexpr-depth 8 -fno-caret-diagnostics 2>&1 | FileCheck %s -check-prefix=TEST4 +// TEST4: constant expression +// TEST4-NEXT: reinterpret_cast +// TEST4-NEXT: in call to 'recurse(0)' +// TEST4-NEXT: in call to 'recurse(1)' +// TEST4-NEXT: in call to 'recurse(2)' +// TEST4-NEXT: in call to 'recurse(3)' +// TEST4-NEXT: in call to 'recurse(4)' +// TEST4-NEXT: in call to 'recurse(5)' + +constexpr int recurse(int n) { return n ? recurse(n-1) : *(int*)n; } +static_assert(recurse(5), ""); diff --git a/clang/test/SemaCXX/constexpr-depth.cpp b/clang/test/SemaCXX/constexpr-depth.cpp new file mode 100644 index 0000000..feba6fd --- /dev/null +++ b/clang/test/SemaCXX/constexpr-depth.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -DMAX=128 -fconstexpr-depth 128 +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -DMAX=2 -fconstexpr-depth 2 +// RUN: %clang -std=c++11 -fsyntax-only -Xclang -verify %s -DMAX=10 -fconstexpr-depth=10 + +constexpr int depth(int n) { return n > 1 ? depth(n-1) : 0; } // expected-note {{exceeded maximum depth}} expected-note +{{}} + +constexpr int kBad = depth(MAX + 1); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'depth(}} +constexpr int kGood = depth(MAX); diff --git a/clang/test/SemaCXX/constexpr-factorial.cpp b/clang/test/SemaCXX/constexpr-factorial.cpp new file mode 100644 index 0000000..b6cdde5 --- /dev/null +++ b/clang/test/SemaCXX/constexpr-factorial.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s + +constexpr unsigned oddfac(unsigned n) { + return n == 1 ? 1 : n * oddfac(n-2); +} +constexpr unsigned k = oddfac(123); + +using A = int[k % 256]; +using A = int[43]; diff --git a/clang/test/SemaCXX/constexpr-nqueens.cpp b/clang/test/SemaCXX/constexpr-nqueens.cpp new file mode 100644 index 0000000..b158d6e --- /dev/null +++ b/clang/test/SemaCXX/constexpr-nqueens.cpp @@ -0,0 +1,73 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s + +typedef unsigned long uint64_t; + +struct Board { + uint64_t State; + bool Failed; + + constexpr Board() : State(0), Failed(false) {} + constexpr Board(const Board &O) : State(O.State), Failed(O.Failed) {} + constexpr Board(uint64_t State, bool Failed = false) : + State(State), Failed(Failed) {} + constexpr Board addQueen(int Row, int Col) { + return Board(State | ((uint64_t)Row << (Col * 4))); + } + constexpr int getQueenRow(int Col) { + return (State >> (Col * 4)) & 0xf; + } + constexpr bool ok(int Row, int Col) { + return okRecurse(Row, Col, 0); + } + constexpr bool okRecurse(int Row, int Col, int CheckCol) { + return Col == CheckCol ? true : + getQueenRow(CheckCol) == Row ? false : + getQueenRow(CheckCol) == Row + (Col - CheckCol) ? false : + getQueenRow(CheckCol) == Row + (CheckCol - Col) ? false : + okRecurse(Row, Col, CheckCol + 1); + } + constexpr bool at(int Row, int Col) { + return getQueenRow(Col) == Row; + } + constexpr bool check(const char *, int=0, int=0); +}; + +constexpr Board buildBoardRecurse(int N, int Col, const Board &B); +constexpr Board buildBoardScan(int N, int Col, int Row, const Board &B); +constexpr Board tryBoard(const Board &Try, + int N, int Col, int Row, const Board &B) { + return Try.Failed ? buildBoardScan(N, Col, Row, B) : Try; +} +constexpr Board buildBoardScan(int N, int Col, int Row, const Board &B) { + return Row == N ? Board(0, true) : + B.ok(Row, Col) ? + tryBoard(buildBoardRecurse(N, Col + 1, B.addQueen(Row, Col)), + N, Col, Row+1, B) : + buildBoardScan(N, Col, Row + 1, B); +} +constexpr Board buildBoardRecurse(int N, int Col, const Board &B) { + return Col == N ? B : buildBoardScan(N, Col, 0, B); +} +constexpr Board buildBoard(int N) { + return buildBoardRecurse(N, 0, Board()); +} + +constexpr Board q8 = buildBoard(8); + +constexpr bool Board::check(const char *p, int Row, int Col) { + return + *p == '\n' ? check(p+1, Row+1, 0) : + *p == 'o' ? at(Row, Col) && check(p+1, Row, Col+1) : + *p == '-' ? !at(Row, Col) && check(p+1, Row, Col+1) : + *p == 0 ? true : + false; +} +static_assert(q8.check( + "o-------\n" + "------o-\n" + "----o---\n" + "-------o\n" + "-o------\n" + "---o----\n" + "-----o--\n" + "--o-----\n"), ""); diff --git a/clang/test/SemaCXX/constexpr-printing.cpp b/clang/test/SemaCXX/constexpr-printing.cpp new file mode 100644 index 0000000..9170fa1 --- /dev/null +++ b/clang/test/SemaCXX/constexpr-printing.cpp @@ -0,0 +1,102 @@ +// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -triple x86_64-linux-gnu + +struct S; +constexpr int extract(const S &s); + +struct S { + constexpr S() : n(extract(*this)), m(0) {} // expected-note {{in call to 'extract(s1)'}} + constexpr S(int k) : n(k), m(extract(*this)) {} + int n, m; +}; + +constexpr int extract(const S &s) { return s.n; } // expected-note {{read of uninitialized object is not allowed in a constant expression}} + +constexpr S s1; // ok +void f() { + constexpr S s1; // expected-error {{constant expression}} expected-note {{in call to 'S()'}} + constexpr S s2(10); +} + +typedef __attribute__((vector_size(16))) int vector_int; + +struct T { + constexpr T() : arr() {} + int arr[4]; +}; +struct U : T { + constexpr U(const int *p) : T(), another(), p(p) {} + constexpr U(const U &u) : T(), another(), p(u.p) {} + T another; + const int *p; +}; +constexpr U u1(&u1.arr[2]); + +constexpr int test_printing(int a, float b, _Complex int c, _Complex float d, + int *e, int &f, vector_int g, U h) { + return *e; // expected-note {{read of non-constexpr variable 'u2'}} +} +U u2(0); // expected-note {{here}} +static_assert(test_printing(12, 39.762, 3 + 4i, 12.9 + 3.6i, &u2.arr[4], u2.another.arr[2], (vector_int){5, 1, 2, 3}, u1) == 0, ""); // \ +expected-error {{constant expression}} \ +expected-note {{in call to 'test_printing(12, 3.976200e+01, 3+4i, 1.290000e+01+3.600000e+00i, &u2.T::arr[4], u2.another.arr[2], {5, 1, 2, 3}, {{{}}, {{}}, &u1.T::arr[2]})'}} + +struct V { + // FIXME: when we can generate these as constexpr constructors, remove the + // explicit definitions. + constexpr V() : arr{[255] = 42} {} + constexpr V(const V &v) : arr{[255] = 42} {} + int arr[256]; +}; +constexpr V v; +constexpr int get(const int *p) { return *p; } // expected-note {{read of dereferenced one-past-the-end pointer}} +constexpr int passLargeArray(V v) { return get(v.arr+256); } // expected-note {{in call to 'get(&v.arr[256])'}} +static_assert(passLargeArray(v) == 0, ""); // expected-error {{constant expression}} expected-note {{in call to 'passLargeArray({{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...}})'}} + +union Union { + constexpr Union(int n) : b(n) {} + constexpr Union(const Union &u) : b(u.b) {} + int a, b; +}; +constexpr Union myUnion = 76; + +constexpr int badness(Union u) { return u.a + u.b; } // expected-note {{read of member 'a' of union with active member 'b'}} +static_assert(badness(myUnion), ""); // expected-error {{constant expression}} \ + expected-note {{in call to 'badness({.b = 76})'}} + +struct MemPtrTest { + int n; + void f(); +}; +MemPtrTest mpt; // expected-note {{here}} +constexpr int MemPtr(int (MemPtrTest::*a), void (MemPtrTest::*b)(), int &c) { + return c; // expected-note {{read of non-constexpr variable 'mpt'}} +} +static_assert(MemPtr(&MemPtrTest::n, &MemPtrTest::f, mpt.*&MemPtrTest::n), ""); // expected-error {{constant expression}} \ +expected-note {{in call to 'MemPtr(&MemPtrTest::n, &MemPtrTest::f, mpt.n)'}} + +template<typename CharT> +constexpr CharT get(const CharT *p) { return p[-1]; } // expected-note 5{{}} + +constexpr char c = get("test\0\\\"\t\a\b\234"); // \ + expected-error {{}} expected-note {{"test\000\\\"\t\a\b\234"}} +constexpr char c8 = get(u8"test\0\\\"\t\a\b\234"); // \ + expected-error {{}} expected-note {{u8"test\000\\\"\t\a\b\234"}} +constexpr char16_t c16 = get(u"test\0\\\"\t\a\b\234\u1234"); // \ + expected-error {{}} expected-note {{u"test\000\\\"\t\a\b\234\u1234"}} +constexpr char32_t c32 = get(U"test\0\\\"\t\a\b\234\u1234\U0010ffff"); // \ + expected-error {{}} expected-note {{U"test\000\\\"\t\a\b\234\u1234\U0010FFFF"}} +constexpr wchar_t wc = get(L"test\0\\\"\t\a\b\234\u1234\xffffffff"); // \ + expected-error {{}} expected-note {{L"test\000\\\"\t\a\b\234\x1234\xFFFFFFFF"}} + +constexpr char32_t c32_err = get(U"\U00110000"); // expected-error {{invalid universal character}} + +typedef decltype(sizeof(int)) LabelDiffTy; +constexpr LabelDiffTy mulBy3(LabelDiffTy x) { return x * 3; } // expected-note {{subexpression}} +void LabelDiffTest() { + static_assert(mulBy3((LabelDiffTy)&&a-(LabelDiffTy)&&b) == 3, ""); // expected-error {{constant expression}} expected-note {{call to 'mulBy3(&&a - &&b)'}} + a:b:return; +} + +constexpr bool test_bool_printing(bool b) { return 1 / !(2*b | !(2*b)); } // expected-note 2{{division by zero}} +constexpr bool test_bool_0 = test_bool_printing(false); // expected-error {{constant expr}} expected-note {{in call to 'test_bool_printing(false)'}} +constexpr bool test_bool_1 = test_bool_printing(true); // expected-error {{constant expr}} expected-note {{in call to 'test_bool_printing(true)'}} diff --git a/clang/test/SemaCXX/constexpr-strlen.cpp b/clang/test/SemaCXX/constexpr-strlen.cpp new file mode 100644 index 0000000..5e28e7f --- /dev/null +++ b/clang/test/SemaCXX/constexpr-strlen.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -pedantic + +# 1 "/usr/include/string.h" 1 3 4 +extern "C" { + typedef decltype(sizeof(int)) size_t; + extern size_t strlen(const char *p); +} + +# 10 "SemaCXX/constexpr-strlen.cpp" 2 +constexpr int n = __builtin_strlen("hello"); // ok +constexpr int m = strlen("hello"); // expected-error {{constant expression}} expected-note {{non-constexpr function 'strlen' cannot be used in a constant expression}} + +// Make sure we can evaluate a call to strlen. +int arr[3]; // expected-note {{here}} +int k = arr[strlen("hello")]; // expected-warning {{array index 5}} diff --git a/clang/test/SemaCXX/constexpr-turing.cpp b/clang/test/SemaCXX/constexpr-turing.cpp new file mode 100644 index 0000000..c515378 --- /dev/null +++ b/clang/test/SemaCXX/constexpr-turing.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -verify -std=c++11 %s + +// A direct proof that constexpr is Turing-complete, once DR1454 is implemented. + +const unsigned halt = (unsigned)-1; + +enum Dir { L, R }; +struct Action { + bool tape; + Dir dir; + unsigned next; +}; +using State = Action[2]; + +// An infinite tape! +struct Tape { + constexpr Tape() : l(0), val(false), r(0) {} + constexpr Tape(const Tape &old, bool write) : + l(old.l), val(write), r(old.r) {} + constexpr Tape(const Tape &old, Dir dir) : + l(dir == L ? old.l ? old.l->l : 0 : &old), + val(dir == L ? old.l ? old.l->val : false + : old.r ? old.r->val : false), + r(dir == R ? old.r ? old.r->r : 0 : &old) {} + const Tape *l; + bool val; + const Tape *r; +}; +constexpr Tape update(const Tape &old, bool write) { return Tape(old, write); } +constexpr Tape move(const Tape &old, Dir dir) { return Tape(old, dir); } + +// Run turing machine 'tm' on tape 'tape' from state 'state'. Return number of +// steps taken until halt. +constexpr unsigned run(const State *tm, const Tape &tape, unsigned state) { + return state == halt ? 1 : + run(tm, move(update(tape, tm[state][tape.val].tape), + tm[state][tape.val].dir), + tm[state][tape.val].next) + 1; +} + +// 3-state busy beaver. 14 steps. +constexpr State bb3[] = { + { { true, R, 1 }, { true, L, 2 } }, + { { true, L, 0 }, { true, R, 1 } }, + { { true, L, 1 }, { true, R, halt } } +}; +static_assert(run(bb3, Tape(), 0) == 14, ""); + +// 4-state busy beaver. 108 steps. +constexpr State bb4[] = { + { { true, R, 1 }, { true, L, 1 } }, + { { true, L, 0 }, { false, L, 2 } }, + { { true, R, halt }, { true, L, 3 } }, + { { true, R, 3 }, { false, R, 0 } } }; +static_assert(run(bb4, Tape(), 0) == 108, ""); diff --git a/clang/test/SemaCXX/constexpr-value-init.cpp b/clang/test/SemaCXX/constexpr-value-init.cpp new file mode 100644 index 0000000..e459f09 --- /dev/null +++ b/clang/test/SemaCXX/constexpr-value-init.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify + +struct A { + constexpr A() : a(b + 1), b(a + 1) {} // expected-note {{uninitialized}} + int a; + int b; +}; +struct B { + A a; +}; + +constexpr A a; // ok, zero initialization preceeds static initialization +void f() { + constexpr A a; // expected-error {{constant expression}} expected-note {{in call to 'A()'}} +} + +constexpr B b1; // expected-error {{requires a user-provided default constructor}} +constexpr B b2 = B(); // ok +static_assert(b2.a.a == 1, ""); +static_assert(b2.a.b == 2, ""); + +struct C { + int c; +}; +struct D : C { int d; }; +constexpr C c1; // expected-error {{requires a user-provided default constructor}} +constexpr C c2 = C(); // ok +constexpr D d1; // expected-error {{requires a user-provided default constructor}} +constexpr D d2 = D(); // ok with DR1452 +static_assert(D().c == 0, ""); +static_assert(D().d == 0, ""); + +struct V : virtual C {}; +template<typename T> struct Z : T { + constexpr Z() : V() {} +}; +constexpr int n = Z<V>().c; // expected-error {{constant expression}} expected-note {{virtual base class}} diff --git a/clang/test/SemaCXX/constructor-initializer.cpp b/clang/test/SemaCXX/constructor-initializer.cpp new file mode 100644 index 0000000..e8b7f0b --- /dev/null +++ b/clang/test/SemaCXX/constructor-initializer.cpp @@ -0,0 +1,282 @@ +// RUN: %clang_cc1 -Wreorder -fsyntax-only -verify %s +class A { + int m; +public: + A() : A::m(17) { } // expected-error {{member initializer 'm' does not name a non-static data member or base class}} + A(int); +}; + +class B : public A { +public: + B() : A(), m(1), n(3.14) { } + +private: + int m; + float n; +}; + + +class C : public virtual B { +public: + C() : B() { } +}; + +class D : public C { +public: + D() : B(), C() { } +}; + +class E : public D, public B { +public: + E() : B(), D() { } // expected-error{{base class initializer 'B' names both a direct base class and an inherited virtual base class}} +}; + + +typedef int INT; + +class F : public B { +public: + int B; + + F() : B(17), + m(17), // expected-error{{member initializer 'm' does not name a non-static data member or base class}} + INT(17) // expected-error{{constructor initializer 'INT' (aka 'int') does not name a class}} + { + } +}; + +class G : A { + G() : A(10); // expected-error{{expected '{'}} +}; + +void f() : a(242) { } // expected-error{{only constructors take base initializers}} + +class H : A { + H(); +}; + +H::H() : A(10) { } + + +class X {}; +class Y {}; + +struct S : Y, virtual X { + S (); +}; + +struct Z : S { + Z() : X(), S(), E() {} // expected-error {{type 'E' is not a direct or virtual base of 'Z'}} +}; + +class U { + union { int a; char* p; }; + union { int b; double d; }; + + U() : a(1), // expected-note {{previous initialization is here}} + p(0), // expected-error {{initializing multiple members of union}} + d(1.0) {} +}; + +struct V {}; +struct Base {}; +struct Base1 {}; + +struct Derived : Base, Base1, virtual V { + Derived (); +}; + +struct Current : Derived { + int Derived; + Current() : Derived(1), ::Derived(), // expected-warning {{field 'Derived' will be initialized after base '::Derived'}} \ + // expected-warning {{base class '::Derived' will be initialized after base 'Derived::V'}} + ::Derived::Base(), // expected-error {{type '::Derived::Base' is not a direct or virtual base of 'Current'}} + Derived::Base1(), // expected-error {{type 'Derived::Base1' is not a direct or virtual base of 'Current'}} + Derived::V(), + ::NonExisting(), // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}} + INT::NonExisting() {} // expected-error {{expected a class or namespace}} \ + // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}} +}; + +struct M { // expected-note 2 {{candidate constructor (the implicit copy constructor)}} \ + // expected-note {{declared here}} \ + // expected-note {{declared here}} + M(int i, int j); // expected-note 2 {{candidate constructor}} +}; + +struct N : M { + N() : M(1), // expected-error {{no matching constructor for initialization of 'M'}} + m1(100) { } // expected-error {{no matching constructor for initialization of 'M'}} + M m1; +}; + +struct P : M { + P() { } // expected-error {{constructor for 'P' must explicitly initialize the base class 'M' which does not have a default constructor}} \ + // expected-error {{member 'm'}} + M m; // expected-note {{member is declared here}} +}; + +struct Q { + Q() : f1(1,2), // expected-error {{excess elements in scalar initializer}} + pf(0.0) { } // expected-error {{cannot initialize a member subobject of type 'float *' with an rvalue of type 'double'}} + float f1; + + float *pf; +}; + +// A silly class used to demonstrate field-is-uninitialized in constructors with +// multiple params. +class TwoInOne { public: TwoInOne(TwoInOne a, TwoInOne b) {} }; +class InitializeUsingSelfTest { + bool A; + char* B; + int C; + TwoInOne D; + InitializeUsingSelfTest(int E) + : A(A), // expected-warning {{field is uninitialized when used here}} + B((((B)))), // expected-warning {{field is uninitialized when used here}} + C(A && InitializeUsingSelfTest::C), // expected-warning {{field is uninitialized when used here}} + D(D, // expected-warning {{field is uninitialized when used here}} + D) {} // expected-warning {{field is uninitialized when used here}} +}; + +int IntWrapper(int i) { return 0; }; +class InitializeUsingSelfExceptions { + int A; + int B; + int C; + void *P; + InitializeUsingSelfExceptions(int B) + : A(IntWrapper(A)), // Due to a conservative implementation, we do not report warnings inside function/ctor calls even though it is possible to do so. + B(B), // Not a warning; B is a local variable. + C(sizeof(C)), // sizeof doesn't reference contents, do not warn + P(&P) {} // address-of doesn't reference contents (the pointer may be dereferenced in the same expression but it would be rare; and weird) +}; + +class CopyConstructorTest { + bool A, B, C; + CopyConstructorTest(const CopyConstructorTest& rhs) + : A(rhs.A), + B(B), // expected-warning {{field is uninitialized when used here}} + C(rhs.C || C) { } // expected-warning {{field is uninitialized when used here}} +}; + +// Make sure we aren't marking default constructors when we shouldn't be. +template<typename T> +struct NDC { + T &ref; + + NDC() { } + NDC(T &ref) : ref(ref) { } +}; + +struct X0 : NDC<int> { + X0(int &ref) : NDC<int>(ref), ndc(ref) { } + + NDC<int> ndc; +}; + +namespace Test0 { + +struct A { A(); }; + +struct B { + B() { } + const A a; +}; + +} + +namespace Test1 { + struct A { + enum Kind { Foo } Kind; + A() : Kind(Foo) {} + }; +} + +namespace Test2 { + +struct A { + A(const A&); +}; + +struct B : virtual A { }; +struct C : A, B { }; + +C f(C c) { + return c; +} + +} + +// Don't build implicit initializers for anonymous union fields when we already +// have an explicit initializer for another field in the union. +namespace PR7402 { + struct S { + union { + void* ptr_; + struct { int i_; }; + }; + + template <typename T> S(T) : ptr_(0) { } + }; + + void f() { + S s(3); + } +} + +// <rdar://problem/8308215>: don't crash. +// Lots of questionable recovery here; errors can change. +namespace test3 { + class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note 3 {{candidate}} expected-note {{passing argument}} + class B : public A { + public: + B(const String& s, int e=0) // expected-error {{unknown type name}} + : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}} + B(const B& e) + : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error {{no viable conversion}} expected-error {{does not name}} + } + }; +} + +// PR8075 +namespace PR8075 { + +struct S1 { + enum { FOO = 42 }; + static const int bar = 42; + static int baz(); + S1(int); +}; + +const int S1::bar; + +struct S2 { + S1 s1; + S2() : s1(s1.FOO) {} +}; + +struct S3 { + S1 s1; + S3() : s1(s1.bar) {} +}; + +struct S4 { + S1 s1; + S4() : s1(s1.baz()) {} +}; + +} + +namespace PR12049 { + int function(); + + class Class + { + public: + Class() : member(function() {} // expected-note {{to match this '('}} + + int member; // expected-error {{expected ')'}} + }; +} diff --git a/clang/test/SemaCXX/constructor-recovery.cpp b/clang/test/SemaCXX/constructor-recovery.cpp new file mode 100644 index 0000000..c1bb436 --- /dev/null +++ b/clang/test/SemaCXX/constructor-recovery.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct C { + virtual C() = 0; // expected-error{{constructor cannot be declared 'virtual'}} +}; + +void f() { + C c; +} diff --git a/clang/test/SemaCXX/constructor.cpp b/clang/test/SemaCXX/constructor.cpp new file mode 100644 index 0000000..f3b910d --- /dev/null +++ b/clang/test/SemaCXX/constructor.cpp @@ -0,0 +1,87 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef int INT; + +class Foo { + Foo(); + (Foo)(float) { } + explicit Foo(int); // expected-note {{previous declaration is here}} + Foo(const Foo&); + + ((Foo))(INT); // expected-error{{cannot be redeclared}} + + Foo(Foo foo, int i = 17, int j = 42); // expected-error{{copy constructor must pass its first argument by reference}} + + static Foo(short, short); // expected-error{{constructor cannot be declared 'static'}} + virtual Foo(double); // expected-error{{constructor cannot be declared 'virtual'}} + Foo(long) const; // expected-error{{'const' qualifier is not allowed on a constructor}} + + int Foo(int, int); // expected-error{{constructor cannot have a return type}} \ + // expected-error{{member 'Foo' has the same name as its class}} +}; + +Foo::Foo(const Foo&) { } + +typedef struct { + int version; +} Anon; +extern const Anon anon; +extern "C" const Anon anon2; + +// PR3188: The extern declaration complained about not having an appropriate +// constructor. +struct x; +extern x a; + +// A similar case. +struct y { + y(int); +}; +extern y b; + +struct Length { + Length l() const { return *this; } +}; + +// <rdar://problem/6815988> +struct mmst_reg{ + char mmst_reg[10]; +}; + +// PR3948 +namespace PR3948 { +// PR3948 +class a { + public: + int b(int a()); +}; +int x(); +void y() { + a z; z.b(x); +} +} + +namespace A { + struct S { + S(); + S(int); + void f1(); + void f2(); + operator int (); + ~S(); + }; +} + +A::S::S() {} + +void A::S::f1() {} + +struct S {}; + +A::S::S(int) {} + +void A::S::f2() {} + +A::S::operator int() { return 1; } + +A::S::~S() {} + diff --git a/clang/test/SemaCXX/conversion-delete-expr.cpp b/clang/test/SemaCXX/conversion-delete-expr.cpp new file mode 100644 index 0000000..0f298a8 --- /dev/null +++ b/clang/test/SemaCXX/conversion-delete-expr.cpp @@ -0,0 +1,109 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// Test1 +struct B { + operator char *(); // expected-note {{candidate function}} +}; + +struct D : B { + operator int *(); // expected-note {{candidate function}} +}; + +void f (D d) +{ + delete d; // expected-error {{ambiguous conversion of delete expression of type 'D' to a pointer}} +} + +// Test2 +struct B1 { + operator int *(); +}; + +struct D1 : B1 { + operator int *(); +}; + +void f1 (D1 d) +{ + delete d; +} + +// Test3 +struct B2 { + operator const int *(); // expected-note {{candidate function}} +}; + +struct D2 : B2 { + operator int *(); // expected-note {{candidate function}} +}; + +void f2 (D2 d) +{ + delete d; // expected-error {{ambiguous conversion of delete expression of type 'D2' to a pointer}} +} + +// Test4 +struct B3 { + operator const int *(); // expected-note {{candidate function}} +}; + +struct A3 { + operator const int *(); // expected-note {{candidate function}} +}; + +struct D3 : A3, B3 { +}; + +void f3 (D3 d) +{ + delete d; // expected-error {{ambiguous conversion of delete expression of type 'D3' to a pointer}} +} + +// Test5 +struct X { + operator int(); + operator int*(); +}; + +void f4(X x) { delete x; delete x; } + +// Test6 +struct X1 { + operator int(); + operator int*(); + template<typename T> operator T*() const; // converts to any pointer! +}; + +void f5(X1 x) { delete x; } // OK. In selecting a conversion to pointer function, template convesions are skipped. + +// Test7 +struct Base { + operator int*(); +}; + +struct Derived : Base { + // not the same function as Base's non-const operator int() + operator int*() const; +}; + +void foo6(const Derived cd, Derived d) { + // overload resolution selects Derived::operator int*() const; + delete cd; + delete d; +} + +// Test8 +struct BB { + template<typename T> operator T*() const; +}; + +struct DD : BB { + template<typename T> operator T*() const; // hides base conversion + operator int *() const; +}; + +void foo7 (DD d) +{ + // OK. In selecting a conversion to pointer function, template convesions are skipped. + delete d; +} diff --git a/clang/test/SemaCXX/conversion-function.cpp b/clang/test/SemaCXX/conversion-function.cpp new file mode 100644 index 0000000..a7a1782 --- /dev/null +++ b/clang/test/SemaCXX/conversion-function.cpp @@ -0,0 +1,394 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class X { +public: + operator bool(); + operator int() const; + + bool f() { + return operator bool(); + } + + float g() { + return operator float(); // expected-error{{use of undeclared 'operator float'}} + } +}; + +operator int(); // expected-error{{conversion function must be a non-static member function}} + +operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}} + +typedef int func_type(int); +typedef int array_type[10]; + +class Y { +public: + void operator bool(int, ...) const; // expected-error{{conversion function cannot have a return type}} \ + // expected-error{{conversion function cannot have any parameters}} + + operator float(...) const; // expected-error{{conversion function cannot be variadic}} + + + operator func_type(); // expected-error{{conversion function cannot convert to a function type}} + operator array_type(); // expected-error{{conversion function cannot convert to an array type}} +}; + + +typedef int INT; +typedef INT* INT_PTR; + +class Z { + operator int(); // expected-note {{previous declaration is here}} + operator int**(); // expected-note {{previous declaration is here}} + + operator INT(); // expected-error{{conversion function cannot be redeclared}} + operator INT_PTR*(); // expected-error{{conversion function cannot be redeclared}} +}; + + +class A { }; + +class B : public A { +public: + operator A&() const; // expected-warning{{conversion function converting 'B' to its base class 'A' will never be used}} + operator const void() const; // expected-warning{{conversion function converting 'B' to 'const void' will never be used}} + operator const B(); // expected-warning{{conversion function converting 'B' to itself will never be used}} +}; + +// This used to crash Clang. +struct Flip; +struct Flop { + Flop(); + Flop(const Flip&); // expected-note{{candidate constructor}} +}; +struct Flip { + operator Flop() const; // expected-note{{candidate function}} +}; +Flop flop = Flip(); // expected-error {{conversion from 'Flip' to 'Flop' is ambiguous}} + +// This tests that we don't add the second conversion declaration to the list of user conversions +struct C { + operator const char *() const; +}; + +C::operator const char*() const { return 0; } + +void f(const C& c) { + const char* v = c; +} + +// Test. Conversion in base class is visible in derived class. +class XB { +public: + operator int(); // expected-note {{candidate function}} +}; + +class Yb : public XB { +public: + operator char(); // expected-note {{candidate function}} +}; + +void f(Yb& a) { + if (a) { } // expected-error {{conversion from 'Yb' to 'bool' is ambiguous}} + int i = a; // OK. calls XB::operator int(); + char ch = a; // OK. calls Yb::operator char(); +} + +// Test conversion + copy construction. +class AutoPtrRef { }; + +class AutoPtr { + AutoPtr(AutoPtr &); // expected-note{{declared private here}} + +public: + AutoPtr(); + AutoPtr(AutoPtrRef); + + operator AutoPtrRef(); +}; + +AutoPtr make_auto_ptr(); + +AutoPtr test_auto_ptr(bool Cond) { + AutoPtr p1( make_auto_ptr() ); + + AutoPtr p; + if (Cond) + return p; // expected-error{{calling a private constructor}} + + return AutoPtr(); +} + +struct A1 { + A1(const char *); + ~A1(); + +private: + A1(const A1&); // expected-note 2 {{declared private here}} +}; + +A1 f() { + // FIXME: redundant diagnostics! + return "Hello"; // expected-error {{calling a private constructor}} expected-warning {{an accessible copy constructor}} +} + +namespace source_locations { + template<typename T> + struct sneaky_int { + typedef int type; + }; + + template<typename T, typename U> + struct A { }; + + template<typename T> + struct A<T, T> : A<T, int> { }; + + struct E { + template<typename T> + operator A<T, typename sneaky_int<T>::type>&() const; // expected-note{{candidate function}} + }; + + void f() { + A<float, float> &af = E(); // expected-error{{no viable conversion}} + A<float, int> &af2 = E(); + const A<float, int> &caf2 = E(); + } + + // Check + template<typename T> + struct E2 { + operator T + * // expected-error{{pointer to a reference}} + () const; + }; + + E2<int&> e2i; // expected-note{{in instantiation}} +} + +namespace crazy_declarators { + struct A { + (&operator bool())(); // expected-error {{must use a typedef to declare a conversion to 'bool (&)()'}} + + // FIXME: This diagnostic is misleading (the correct spelling + // would be 'operator int*'), but it's a corner case of a + // rarely-used syntax extension. + *operator int(); // expected-error {{must use a typedef to declare a conversion to 'int *'}} + }; +} + +namespace smart_ptr { + class Y { + class YRef { }; + + Y(Y&); + + public: + Y(); + Y(YRef); + + operator YRef(); // expected-note{{candidate function}} + }; + + struct X { // expected-note{{candidate constructor (the implicit copy constructor) not}} + explicit X(Y); + }; + + Y make_Y(); + + X f() { + X x = make_Y(); // expected-error{{no viable conversion from 'smart_ptr::Y' to 'smart_ptr::X'}} + X x2(make_Y()); + return X(Y()); + } +} + +struct Any { + Any(...); +}; + +struct Other { + Other(const Other &); + Other(); +}; + +void test_any() { + Any any = Other(); // expected-error{{cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtime}} +} + +namespace PR7055 { + // Make sure that we don't allow too many conversions in an + // auto_ptr-like template. In particular, we can't create multiple + // temporary objects when binding to a reference. + struct auto_ptr { + struct auto_ptr_ref { }; + + auto_ptr(auto_ptr&); + auto_ptr(auto_ptr_ref); + explicit auto_ptr(int *); + + operator auto_ptr_ref(); + }; + + struct X { + X(auto_ptr); + }; + + X f() { + X x(auto_ptr(new int)); + return X(auto_ptr(new int)); + } + + auto_ptr foo(); + + X e(foo()); + + struct Y { + Y(X); + }; + + Y f2(foo()); +} + +namespace PR7934 { + typedef unsigned char uint8; + + struct MutablePtr { + MutablePtr() : ptr(0) {} + void *ptr; + + operator void*() { return ptr; } + + private: + operator uint8*() { return reinterpret_cast<uint8*>(ptr); } + operator const char*() const { return reinterpret_cast<const char*>(ptr); } + }; + + void fake_memcpy(const void *); + + void use() { + MutablePtr ptr; + fake_memcpy(ptr); + } +} + +namespace rdar8018274 { + struct X { }; + struct Y { + operator const struct X *() const; + }; + + struct Z : Y { + operator struct X * (); + }; + + void test() { + Z x; + (void) (x != __null); + } + + + struct Base { + operator int(); + }; + + struct Derived1 : Base { }; + + struct Derived2 : Base { }; + + struct SuperDerived : Derived1, Derived2 { + using Derived1::operator int; + }; + + struct UeberDerived : SuperDerived { + operator long(); + }; + + void test2(UeberDerived ud) { + int i = ud; // expected-error{{ambiguous conversion from derived class 'rdar8018274::SuperDerived' to base class 'rdar8018274::Base'}} + } + + struct Base2 { + operator int(); + }; + + struct Base3 { + operator int(); + }; + + struct Derived23 : Base2, Base3 { + using Base2::operator int; + }; + + struct ExtraDerived23 : Derived23 { }; + + void test3(ExtraDerived23 ed) { + int i = ed; + } +} + +namespace PR8065 { + template <typename T> struct Iterator; + template <typename T> struct Container; + + template<> + struct Iterator<int> { + typedef Container<int> container_type; + }; + + template <typename T> + struct Container { + typedef typename Iterator<T>::container_type X; + operator X(void) { return X(); } + }; + + Container<int> test; +} + +namespace PR8034 { + struct C { + operator int(); + + private: + template <typename T> operator T(); + }; + 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; +} + +namespace PR8800 { + struct A; + struct C { + operator A&(); + }; + void f() { + C c; + A& a1(c); + A& a2 = c; + A& a3 = static_cast<A&>(c); + A& a4 = (A&)c; + } +} diff --git a/clang/test/SemaCXX/conversion.cpp b/clang/test/SemaCXX/conversion.cpp new file mode 100644 index 0000000..a64b187 --- /dev/null +++ b/clang/test/SemaCXX/conversion.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -Wconversion -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -Wconversion %s 2>&1 | FileCheck %s + +#include <stddef.h> + +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed int int32_t; +typedef signed long int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long uint64_t; + +// <rdar://problem/7909130> +namespace test0 { + int32_t test1_positive(char *I, char *E) { + return (E - I); // expected-warning {{implicit conversion loses integer precision}} + } + + int32_t test1_negative(char *I, char *E) { + return static_cast<int32_t>(E - I); + } + + uint32_t test2_positive(uint64_t x) { + return x; // expected-warning {{implicit conversion loses integer precision}} + } + + uint32_t test2_negative(uint64_t x) { + return (uint32_t) x; + } +} + +namespace test1 { + uint64_t test1(int x, unsigned y) { + return sizeof(x == y); + } + + uint64_t test2(int x, unsigned y) { + return __alignof(x == y); + } + + void * const foo(); + bool test2(void *p) { + return p == foo(); + } +} + +namespace test2 { + struct A { + unsigned int x : 2; + A() : x(10) {} // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}} + }; +} + +// This file tests -Wnull-conversion, a subcategory of -Wconversion +// which is on by default. + +void test3() { + int a = NULL; // expected-warning {{implicit conversion of NULL constant to 'int'}} + int b; + b = NULL; // expected-warning {{implicit conversion of NULL constant to 'int'}} + long l = NULL; // FIXME: this should also warn, but currently does not if sizeof(NULL)==sizeof(inttype) + int c = ((((NULL)))); // expected-warning {{implicit conversion of NULL constant to 'int'}} + int d; + d = ((((NULL)))); // expected-warning {{implicit conversion of NULL constant to 'int'}} + bool bl = NULL; // FIXME: this should warn but we currently suppress a bunch of conversion-to-bool warnings including this one + char ch = NULL; // expected-warning {{implicit conversion of NULL constant to 'char'}} + unsigned char uch = NULL; // expected-warning {{implicit conversion of NULL constant to 'unsigned char'}} + short sh = NULL; // expected-warning {{implicit conversion of NULL constant to 'short'}} + + // Use FileCheck to ensure we don't get any unnecessary macro-expansion notes + // (that don't appear as 'real' notes & can't be seen/tested by -verify) + // CHECK-NOT: note: + // CHECK: note: expanded from macro 'FNULL' +#define FNULL NULL + int a2 = FNULL; // expected-warning {{implicit conversion of NULL constant to 'int'}} + // CHECK-NOT: note: + // CHECK: note: expanded from macro 'FINIT' +#define FINIT int a3 = NULL; + FINIT // expected-warning {{implicit conversion of NULL constant to 'int'}} +} diff --git a/clang/test/SemaCXX/convert-to-bool.cpp b/clang/test/SemaCXX/convert-to-bool.cpp new file mode 100644 index 0000000..c9a3555 --- /dev/null +++ b/clang/test/SemaCXX/convert-to-bool.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct ConvToBool { + operator bool() const; +}; + +struct ConvToInt { + operator int(); +}; + +struct ExplicitConvToBool { + explicit operator bool(); // expected-warning{{explicit conversion functions are a C++11 extension}} +}; + +void test_conv_to_bool(ConvToBool ctb, ConvToInt cti, ExplicitConvToBool ecb) { + if (ctb) { } + if (cti) { } + if (ecb) { } + for (; ctb; ) { } + for (; cti; ) { } + for (; ecb; ) { } + while (ctb) { }; + while (cti) { } + while (ecb) { } + do { } while (ctb); + do { } while (cti); + do { } while (ecb); + + if (!ctb) { } + if (!cti) { } + if (!ecb) { } + + bool b1 = !ecb; + if (ctb && ecb) { } + bool b2 = ctb && ecb; + if (ctb || ecb) { } + bool b3 = ctb || ecb; +} + +void accepts_bool(bool) { } // expected-note{{candidate function}} + +struct ExplicitConvToRef { + explicit operator int&(); // expected-warning{{explicit conversion functions are a C++11 extension}} +}; + +void test_explicit_bool(ExplicitConvToBool ecb) { + bool b1(ecb); // okay + bool b2 = ecb; // expected-error{{no viable conversion from 'ExplicitConvToBool' to 'bool'}} + accepts_bool(ecb); // expected-error{{no matching function for call to}} +} + +void test_explicit_conv_to_ref(ExplicitConvToRef ecr) { + int& i1 = ecr; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'ExplicitConvToRef'}} + int& i2(ecr); // okay +} + +struct A { }; +struct B { }; +struct C { + explicit operator A&(); // expected-warning{{explicit conversion functions are a C++11 extension}} + operator B&(); // expected-note{{candidate}} +}; + +void test_copy_init_conversions(C c) { + A &a = c; // expected-error{{no viable conversion from 'C' to 'A'}} + B &b = b; // okay +} + diff --git a/clang/test/SemaCXX/converting-constructor.cpp b/clang/test/SemaCXX/converting-constructor.cpp new file mode 100644 index 0000000..1688e51 --- /dev/null +++ b/clang/test/SemaCXX/converting-constructor.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class Z { }; + +class Y { +public: + Y(const Z&); +}; + +class X { +public: + X(int); + X(const Y&); +}; + +void f(X); // expected-note{{candidate function}} + +void g(short s, Y y, Z z) { + f(s); + f(1.0f); + f(y); + f(z); // expected-error{{no matching function}} +} + + +class FromShort { +public: + FromShort(short s); +}; + +class FromShortExplicitly { // expected-note{{candidate constructor (the implicit copy constructor)}} +public: + explicit FromShortExplicitly(short s); +}; + +void explicit_constructor(short s) { + FromShort fs1(s); + FromShort fs2 = s; + FromShortExplicitly fse1(s); + FromShortExplicitly fse2 = s; // expected-error{{no viable conversion}} +} + +// PR5519 +struct X1 { X1(const char&); }; +void x1(X1); +void y1() { + x1(1); +} diff --git a/clang/test/SemaCXX/copy-assignment.cpp b/clang/test/SemaCXX/copy-assignment.cpp new file mode 100644 index 0000000..798582c --- /dev/null +++ b/clang/test/SemaCXX/copy-assignment.cpp @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A { +}; + +struct ConvertibleToA { + operator A(); +}; + +struct ConvertibleToConstA { + operator const A(); +}; + +struct B { + B& operator=(B&); // expected-note 4 {{candidate function}} +}; + +struct ConvertibleToB { + operator B(); +}; + +struct ConvertibleToBref { + operator B&(); +}; + +struct ConvertibleToConstB { + operator const B(); +}; + +struct ConvertibleToConstBref { + operator const B&(); +}; + +struct C { + int operator=(int); // expected-note{{candidate function}} + long operator=(long); // expected-note{{candidate function}} + int operator+=(int); // expected-note{{candidate function}} + int operator+=(long); // expected-note{{candidate function}} +}; + +struct D { + D& operator+=(const D &); +}; + +struct ConvertibleToInt { + operator int(); +}; + +void test() { + A a, na; + const A constA = A(); + ConvertibleToA convertibleToA; + ConvertibleToConstA convertibleToConstA; + + B b, nb; + const B constB = B(); + ConvertibleToB convertibleToB; + ConvertibleToBref convertibleToBref; + ConvertibleToConstB convertibleToConstB; + ConvertibleToConstBref convertibleToConstBref; + + C c, nc; + const C constC = C(); + + D d, nd; + const D constD = D(); + + ConvertibleToInt convertibleToInt; + + na = a; + na = constA; + na = convertibleToA; + na = convertibleToConstA; + na += a; // expected-error{{no viable overloaded '+='}} + + nb = b; + nb = constB; // expected-error{{no viable overloaded '='}} + nb = convertibleToB; // expected-error{{no viable overloaded '='}} + nb = convertibleToBref; + nb = convertibleToConstB; // expected-error{{no viable overloaded '='}} + nb = convertibleToConstBref; // expected-error{{no viable overloaded '='}} + + nc = c; + nc = constC; + nc = 1; + nc = 1L; + nc = 1.0; // expected-error{{use of overloaded operator '=' is ambiguous}} + nc += 1; + nc += 1L; + nc += 1.0; // expected-error{{use of overloaded operator '+=' is ambiguous}} + + nd = d; + nd += d; + nd += constD; + + int i; + i = convertibleToInt; + i = a; // expected-error{{assigning to 'int' from incompatible type 'A'}} +} + +// <rdar://problem/8315440>: Don't crash +namespace test1 { + template<typename T> class A : public unknown::X { // expected-error {{undeclared identifier 'unknown'}} expected-error {{expected class name}} + A(UndeclaredType n) : X(n) {} // expected-error {{unknown type name 'UndeclaredType'}} + }; + template<typename T> class B : public A<T> { + virtual void foo() {} + }; + extern template class A<char>; + extern template class B<char>; +} diff --git a/clang/test/SemaCXX/copy-constructor-error.cpp b/clang/test/SemaCXX/copy-constructor-error.cpp new file mode 100644 index 0000000..64a7d58 --- /dev/null +++ b/clang/test/SemaCXX/copy-constructor-error.cpp @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct S { + S (S); // expected-error {{copy constructor must pass its first argument by reference}} +}; + +S f(); + +void g() { + S a( f() ); +} + +namespace PR6064 { + struct A { + A() { } + inline A(A&, int); // expected-note {{was not a special member function}} + }; + + A::A(A&, int = 0) { } // expected-warning {{makes this constructor a copy constructor}} + + void f() { + A const a; + A b(a); + } +} diff --git a/clang/test/SemaCXX/copy-initialization.cpp b/clang/test/SemaCXX/copy-initialization.cpp new file mode 100644 index 0000000..ea2db0c --- /dev/null +++ b/clang/test/SemaCXX/copy-initialization.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class X { +public: + explicit X(const X&); // expected-note {{candidate constructor}} + X(int*); // expected-note 3{{candidate constructor}} + explicit X(float*); // expected-note {{candidate constructor}} +}; + +class Y : public X { }; + +void f(Y y, int *ip, float *fp) { + X x1 = y; // expected-error{{no matching constructor for initialization of 'X'}} + X x2 = 0; + X x3 = ip; + X x4 = fp; // expected-error{{no viable conversion}} + X x2a(0); // expected-error{{call to constructor of 'X' is ambiguous}} + X x3a(ip); + X x4a(fp); +} + +struct foo { + void bar(); // expected-note{{declared here}} +}; + +// PR3600 +void test(const foo *P) { P->bar(); } // expected-error{{'bar' not viable: 'this' argument has type 'const foo', but function is not marked const}} + +namespace PR6757 { + struct Foo { + Foo(); + Foo(Foo&); // expected-note{{candidate constructor not viable}} + }; + + struct Bar { + operator const Foo&() const; + }; + + void f(Foo); + + void g(Foo foo) { + f(Bar()); // expected-error{{no viable constructor copying parameter of type 'const PR6757::Foo'}} + f(foo); + } +} + +namespace DR5 { + // Core issue 5: if a temporary is created in copy-initialization, it is of + // the cv-unqualified version of the destination type. + namespace Ex1 { + struct C { }; + C c; + struct A { + A(const A&); + A(const C&); + }; + const volatile A a = c; // ok + } + + namespace Ex2 { + struct S { + S(S&&); // expected-warning {{C++11}} + S(int); + }; + const S a(0); + const S b = 0; + } +} diff --git a/clang/test/SemaCXX/crashes.cpp b/clang/test/SemaCXX/crashes.cpp new file mode 100644 index 0000000..b77248e --- /dev/null +++ b/clang/test/SemaCXX/crashes.cpp @@ -0,0 +1,106 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// <rdar://problem/8124080> +template<typename _Alloc> class allocator; +template<class _CharT> struct char_traits; +template<typename _CharT, typename _Traits = char_traits<_CharT>, + typename _Alloc = allocator<_CharT> > +class basic_string; +template<typename _CharT, typename _Traits, typename _Alloc> +const typename basic_string<_CharT, _Traits, _Alloc>::size_type +basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_max_size // expected-error{{no member named '_Rep' in 'basic_string<_CharT, _Traits, _Alloc>'}} + = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; + +// PR7118 +template<typename T> +class Foo { + class Bar; + void f() { + Bar i; + } +}; + +// PR7625 +template<typename T> struct a : T { + struct x : T { + int aa() { return p; } // expected-error{{use of undeclared identifier 'p'}} + }; +}; + +// rdar://8605381 +namespace rdar8605381 { +struct X {}; + +struct Y { // expected-note{{candidate}} + Y(); +}; + +struct { + Y obj; +} objs[] = { + new Y // expected-error{{no viable conversion}} +}; +} + +// http://llvm.org/PR8234 +namespace PR8234 { +template<typename Signature> +class callback +{ +}; + +template<typename R , typename ARG_TYPE0> +class callback<R( ARG_TYPE0)> +{ + public: + callback() {} +}; + +template< typename ARG_TYPE0> +class callback<void( ARG_TYPE0)> +{ + public: + callback() {} +}; + +void f() +{ + callback<void(const int&)> op; +} +} + +namespace PR9007 { + struct bar { + enum xxx { + yyy = sizeof(struct foo*) + }; + foo *xxx(); + }; +} + +namespace PR9026 { + class InfallibleTArray { + }; + class Variant; + class CompVariant { + operator const InfallibleTArray&() const; + }; + class Variant { + operator const CompVariant&() const; + }; + void Write(const Variant& __v); + void Write(const InfallibleTArray& __v); + Variant x; + void Write2() { + Write(x); + } +} + +namespace PR10270 { + template<typename T> class C; + template<typename T> void f() { + if (C<T> == 1) // expected-error{{expected unqualified-id}} \ + // expected-error{{invalid '==' at end of declaration}} + return; + } +} diff --git a/clang/test/SemaCXX/cstyle-cast.cpp b/clang/test/SemaCXX/cstyle-cast.cpp new file mode 100644 index 0000000..12495ec --- /dev/null +++ b/clang/test/SemaCXX/cstyle-cast.cpp @@ -0,0 +1,231 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A {}; + +// ----------- const_cast -------------- + +typedef char c; +typedef c *cp; +typedef cp *cpp; +typedef cpp *cppp; +typedef cppp &cpppr; +typedef const cppp &cpppcr; +typedef const char cc; +typedef cc *ccp; +typedef volatile ccp ccvp; +typedef ccvp *ccvpp; +typedef const volatile ccvpp ccvpcvp; +typedef ccvpcvp *ccvpcvpp; +typedef int iar[100]; +typedef iar &iarr; +typedef int (*f)(int); + +void t_cc() +{ + ccvpcvpp var = 0; + // Cast away deep consts and volatiles. + char ***var2 = (cppp)(var); + char ***const &var3 = var2; + // Const reference to reference. + char ***&var4 = (cpppr)(var3); + // Drop reference. Intentionally without qualifier change. + char *** var5 = (cppp)(var4); + const int ar[100] = {0}; + // Array decay. Intentionally without qualifier change. + int *pi = (int*)(ar); + f fp = 0; + // Don't misidentify fn** as a function pointer. + f *fpp = (f*)(&fp); + int const A::* const A::*icapcap = 0; + int A::* A::* iapap = (int A::* A::*)(icapcap); +} + +// ----------- static_cast ------------- + +struct B : public A {}; // Single public base. +struct C1 : public virtual B {}; // Single virtual base. +struct C2 : public virtual B {}; +struct D : public C1, public C2 {}; // Diamond +struct E : private A {}; // Single private base. +struct F : public C1 {}; // Single path to B with virtual. +struct G1 : public B {}; +struct G2 : public B {}; +struct H : public G1, public G2 {}; // Ambiguous path to B. + +enum Enum { En1, En2 }; +enum Onom { On1, On2 }; + +struct Co1 { operator int(); }; +struct Co2 { Co2(int); }; +struct Co3 { }; +struct Co4 { Co4(Co3); operator Co3(); }; + +// Explicit implicits +void t_529_2() +{ + int i = 1; + (void)(float)(i); + double d = 1.0; + (void)(float)(d); + (void)(int)(d); + (void)(char)(i); + (void)(unsigned long)(i); + (void)(int)(En1); + (void)(double)(En1); + (void)(int&)(i); + (void)(const int&)(i); + + int ar[1]; + (void)(const int*)(ar); + (void)(void (*)())(t_529_2); + + (void)(void*)(0); + (void)(void*)((int*)0); + (void)(volatile const void*)((const int*)0); + (void)(A*)((B*)0); + (void)(A&)(*((B*)0)); + (void)(const B*)((C1*)0); + (void)(B&)(*((C1*)0)); + (void)(A*)((D*)0); + (void)(const A&)(*((D*)0)); + (void)(int B::*)((int A::*)0); + (void)(void (B::*)())((void (A::*)())0); + (void)(A*)((E*)0); // C-style cast ignores access control + (void)(void*)((const int*)0); // const_cast appended + + (void)(int)(Co1()); + (void)(Co2)(1); + (void)(Co3)((Co4)(Co3())); + + // Bad code below + //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}} +} + +// Anything to void +void t_529_4() +{ + (void)(1); + (void)(t_529_4); +} + +// Static downcasts +void t_529_5_8() +{ + (void)(B*)((A*)0); + (void)(B&)(*((A*)0)); + (void)(const G1*)((A*)0); + (void)(const G1&)(*((A*)0)); + (void)(B*)((const A*)0); // const_cast appended + (void)(B&)(*((const A*)0)); // const_cast appended + (void)(E*)((A*)0); // access control ignored + (void)(E&)(*((A*)0)); // access control ignored + + // Bad code below + + (void)(C1*)((A*)0); // expected-error {{cannot cast 'A *' to 'C1 *' via virtual base 'B'}} + (void)(C1&)(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1 &' via virtual base 'B'}} + (void)(D*)((A*)0); // expected-error {{cannot cast 'A *' to 'D *' via virtual base 'B'}} + (void)(D&)(*((A*)0)); // expected-error {{cannot cast 'A' to 'D &' via virtual base 'B'}} + (void)(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}} + (void)(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}} + + // TODO: Test DR427. This requires user-defined conversions, though. +} + +// Enum conversions +void t_529_7() +{ + (void)(Enum)(1); + (void)(Enum)(1.0); + (void)(Onom)(En1); + + // Bad code below + + (void)(Enum)((int*)0); // expected-error {{C-style cast from 'int *' to 'Enum' is not allowed}} +} + +// Void pointer to object pointer +void t_529_10() +{ + (void)(int*)((void*)0); + (void)(const A*)((void*)0); + (void)(int*)((const void*)0); // const_cast appended +} + +// Member pointer upcast. +void t_529_9() +{ + (void)(int A::*)((int B::*)0); + + // Bad code below + (void)(int A::*)((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}} + (void)(int A::*)((int F::*)0); // expected-error {{conversion from pointer to member of class 'F' to pointer to member of class 'A' via virtual base 'B' is not allowed}} +} + +// -------- reinterpret_cast ----------- + +enum test { testval = 1 }; +struct structure { int m; }; +typedef void (*fnptr)(); + +// Test conversion between pointer and integral types, as in p3 and p4. +void integral_conversion() +{ + void *vp = (void*)(testval); + long l = (long)(vp); + (void)(float*)(l); + fnptr fnp = (fnptr)(l); + (void)(char)(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}} + (void)(long)(fnp); +} + +void pointer_conversion() +{ + int *p1 = 0; + float *p2 = (float*)(p1); + structure *p3 = (structure*)(p2); + typedef int **ppint; + ppint *deep = (ppint*)(p3); + (void)(fnptr*)(deep); +} + +void constness() +{ + int ***const ipppc = 0; + int const *icp = (int const*)(ipppc); + (void)(int*)(icp); // const_cast appended + int const *const **icpcpp = (int const* const**)(ipppc); // const_cast appended + int *ip = (int*)(icpcpp); + (void)(int const*)(ip); + (void)(int const* const* const*)(ipppc); +} + +void fnptrs() +{ + typedef int (*fnptr2)(int); + fnptr fp = 0; + (void)(fnptr2)(fp); + void *vp = (void*)(fp); + (void)(fnptr)(vp); +} + +void refs() +{ + long l = 0; + char &c = (char&)(l); + // Bad: from rvalue + (void)(int&)(&c); // expected-error {{C-style cast from rvalue to reference type 'int &'}} +} + +void memptrs() +{ + const int structure::*psi = 0; + (void)(const float structure::*)(psi); + (void)(int structure::*)(psi); // const_cast appended + + void (structure::*psf)() = 0; + (void)(int (structure::*)())(psf); + + (void)(void (structure::*)())(psi); // expected-error {{C-style cast from 'const int structure::*' to 'void (structure::*)()' is not allowed}} + (void)(int structure::*)(psf); // expected-error {{C-style cast from 'void (structure::*)()' to 'int structure::*' is not allowed}} +} diff --git a/clang/test/SemaCXX/cv-unqual-rvalues.cpp b/clang/test/SemaCXX/cv-unqual-rvalues.cpp new file mode 100644 index 0000000..ed76ced --- /dev/null +++ b/clang/test/SemaCXX/cv-unqual-rvalues.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR7463: Make sure that when we have an rvalue, it does not have +// cv-qualified non-class type. +template <typename T_> void g (T_&); // expected-note 7{{not viable}} + +template<const int X> void h() { + g(X); // expected-error{{no matching function for call to 'g'}} +} + +template<typename T, T X> void h2() { + g(X); // expected-error{{no matching function for call to 'g'}} +} + +void a(__builtin_va_list x) { + g(__builtin_va_arg(x, const int)); // expected-error{{no matching function for call to 'g'}} + g((const int)0); // expected-error{{no matching function for call to 'g'}} + typedef const int cint; + g(cint(0)); // expected-error{{no matching function for call to 'g'}} + g(static_cast<const int>(1)); // expected-error{{no matching function for call to 'g'}} + g(reinterpret_cast<int *const>(0)); // expected-error{{no matching function for call to 'g'}} + h<0>(); + h2<const int, 0>(); // expected-note{{instantiation of}} +} diff --git a/clang/test/SemaCXX/cxx-member-pointer-op.cpp b/clang/test/SemaCXX/cxx-member-pointer-op.cpp new file mode 100644 index 0000000..f43d438 --- /dev/null +++ b/clang/test/SemaCXX/cxx-member-pointer-op.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +struct C { + static int (C::* a); +}; + +typedef void (C::*pmfc)(); + +void g(pmfc) { + C *c; + c->*pmfc(); // expected-error {{invalid use of pointer to member type after ->*}} + C c1; + c1.*pmfc(); // expected-error {{invalid use of pointer to member type after .*}} + c->*(pmfc()); // expected-error {{invalid use of pointer to member type after ->*}} + c1.*((pmfc())); // expected-error {{invalid use of pointer to member type after .*}} +} + +int a(C* x) { + return x->*C::a; +} + diff --git a/clang/test/SemaCXX/cxx0x-class.cpp b/clang/test/SemaCXX/cxx0x-class.cpp new file mode 100644 index 0000000..41b0a5c --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-class.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +int vs = 0; + +class C { +public: + struct NestedC { + NestedC(int); + }; + + int i = 0; + static int si = 0; // expected-error {{non-const static data member must be initialized out of line}} + static const NestedC ci = 0; // expected-error {{static data member of type 'const C::NestedC' must be initialized out of line}} + static const int nci = vs; // expected-error {{in-class initializer for static data member is not a constant expression}} + static const int vi = 0; + static const volatile int cvi = 0; // expected-error {{static const volatile data member must be initialized out of line}} +}; + +namespace rdar8367341 { + float foo(); // expected-note {{here}} + + struct A { + static const float x = 5.0f; // expected-warning {{GNU extension}} expected-note {{use 'constexpr' specifier to silence this warning}} + static const float y = foo(); // expected-warning {{GNU extension}} expected-note {{use 'constexpr' specifier to silence this warning}} expected-error {{in-class initializer for static data member is not a constant expression}} + static constexpr float x2 = 5.0f; + static constexpr float y2 = foo(); // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr function 'foo'}} + }; +} + + +namespace Foo { + // Regression test -- forward declaration of Foo should not cause error about + // nonstatic data member. + class Foo; + class Foo { + int x; + int y = x; + }; +} diff --git a/clang/test/SemaCXX/cxx0x-compat.cpp b/clang/test/SemaCXX/cxx0x-compat.cpp new file mode 100644 index 0000000..123008a --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-compat.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wc++11-compat -verify %s + +namespace N { + template<typename T> void f(T) {} // expected-note 2{{here}} + namespace M { + template void ::N::f<int>(int); // expected-warning {{explicit instantiation of 'f' not in a namespace enclosing 'N'}} + } +} +using namespace N; +template void f<char>(char); // expected-warning {{explicit instantiation of 'N::f' must occur in namespace 'N'}} + +template<typename T> void g(T) {} // expected-note 2{{here}} +namespace M { + template void g<int>(int); // expected-warning {{explicit instantiation of 'g' must occur at global scope}} + template void ::g<char>(char); // expected-warning {{explicit instantiation of 'g' must occur at global scope}} +} + +template inline void g<double>(double); // expected-warning {{explicit instantiation cannot be 'inline'}} + +void g() { + auto int n = 0; // expected-warning {{'auto' storage class specifier is redundant and incompatible with C++11}} +} + +int n; +struct S { + char c; +} +s = { n }, // expected-warning {{non-constant-expression cannot be narrowed from type 'int' to 'char' in initializer list in C++11}} expected-note {{explicit cast}} +t = { 1234 }; // expected-warning {{constant expression evaluates to 1234 which cannot be narrowed to type 'char' in C++11}} expected-warning {{changes value}} expected-note {{explicit cast}} + +#define PRIuS "uS" +int printf(const char *, ...); +typedef __typeof(sizeof(int)) size_t; +void h(size_t foo, size_t bar) { + printf("foo is %"PRIuS", bar is %"PRIuS, foo, bar); // expected-warning 2{{identifier after literal will be treated as a reserved user-defined literal suffix in C++11}} +} + +#define _x + 1 +char c = 'x'_x; // expected-warning {{will be treated as a user-defined literal suffix}} diff --git a/clang/test/SemaCXX/cxx0x-constexpr-const.cpp b/clang/test/SemaCXX/cxx0x-constexpr-const.cpp new file mode 100644 index 0000000..197edeb --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-constexpr-const.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -std=c++11 -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/clang/test/SemaCXX/cxx0x-cursory-default-delete.cpp b/clang/test/SemaCXX/cxx0x-cursory-default-delete.cpp new file mode 100644 index 0000000..3290595 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-cursory-default-delete.cpp @@ -0,0 +1,75 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct non_copiable { + non_copiable(const non_copiable&) = delete; // expected-note {{marked deleted here}} + non_copiable& operator = (const non_copiable&) = delete; // expected-note {{explicitly deleted}} + non_copiable() = default; +}; + +struct non_const_copy { + non_const_copy(non_const_copy&) = default; // expected-note {{not viable}} + non_const_copy& operator = (non_const_copy&) & = default; // expected-note {{not viable}} + non_const_copy& operator = (non_const_copy&) && = default; // expected-note {{not viable}} + non_const_copy() = default; // expected-note {{not viable}} +}; + +void fn1 () { + non_copiable nc; + non_copiable nc2 = nc; // expected-error {{deleted constructor}} + nc = nc; // expected-error {{deleted operator}} + + non_const_copy ncc; + non_const_copy ncc2 = ncc; + ncc = ncc2; + const non_const_copy cncc; + non_const_copy ncc3 = cncc; // expected-error {{no matching}} + ncc = cncc; // expected-error {{no viable overloaded}} +}; + +struct non_const_derived : non_const_copy { + non_const_derived(const non_const_derived&) = default; // expected-error {{requires it to be non-const}} + non_const_derived& operator =(non_const_derived&) = default; +}; + +struct bad_decls { + bad_decls(volatile bad_decls&) = default; // expected-error {{may not be volatile}} + bad_decls&& operator = (bad_decls) = default; // expected-error 2{{lvalue reference}} + bad_decls& operator = (volatile bad_decls&) = default; // expected-error {{may not be volatile}} + bad_decls& operator = (const bad_decls&) const = default; // expected-error {{may not have 'const', 'constexpr' or 'volatile' qualifiers}} +}; + +struct A {}; struct B {}; + +struct except_spec_a { + virtual ~except_spec_a() throw(A); + except_spec_a() throw(A); +}; +struct except_spec_b { + virtual ~except_spec_b() throw(B); + except_spec_b() throw(B); +}; + +struct except_spec_d_good : except_spec_a, except_spec_b { + ~except_spec_d_good(); +}; +except_spec_d_good::~except_spec_d_good() = default; +// FIXME: This should error in the virtual override check. +// It doesn't because we generate the implicit specification later than +// appropriate. +struct except_spec_d_bad : except_spec_a, except_spec_b { + ~except_spec_d_bad() = default; +}; + +// FIXME: This should error because the exceptions spec doesn't match. +struct except_spec_d_mismatch : except_spec_a, except_spec_b { + except_spec_d_mismatch() throw(A) = default; +}; +struct except_spec_d_match : except_spec_a, except_spec_b { + except_spec_d_match() throw(A, B) = default; +}; + +// gcc-compatibility: allow attributes on default definitions +// (but not normal definitions) +struct S { S(); }; +S::S() __attribute((pure)) = default; + diff --git a/clang/test/SemaCXX/cxx0x-defaulted-functions.cpp b/clang/test/SemaCXX/cxx0x-defaulted-functions.cpp new file mode 100644 index 0000000..2e4107c --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-defaulted-functions.cpp @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +void fn() = default; // expected-error {{only special member}} +struct foo { + void fn() = default; // expected-error {{only special member}} + + foo() = default; + foo(const foo&) = default; + foo(foo&) = default; + foo& operator = (const foo&) = default; + foo& operator = (foo&) = default; + ~foo() = default; +}; + +struct bar { + bar(); + bar(const bar&); + bar(bar&); + bar& operator = (const bar&); + bar& operator = (bar&); + ~bar(); +}; + +bar::bar() = default; +bar::bar(const bar&) = default; +bar::bar(bar&) = default; +bar& bar::operator = (const bar&) = default; +bar& bar::operator = (bar&) = default; +bar::~bar() = default; + +static_assert(__is_trivial(foo), "foo should be trivial"); + +static_assert(!__has_trivial_destructor(bar), "bar's destructor isn't trivial"); +static_assert(!__has_trivial_constructor(bar), + "bar's default constructor isn't trivial"); +static_assert(!__has_trivial_copy(bar), "bar has no trivial copy"); +static_assert(!__has_trivial_assign(bar), "bar has no trivial assign"); + +void tester() { + foo f, g(f); + bar b, c(b); + f = g; + b = c; +} + +template<typename T> struct S : T { + constexpr S() = default; + constexpr S(const S&) = default; + constexpr S(S&&) = default; +}; +struct lit { constexpr lit() {} }; +S<lit> s_lit; // ok +S<bar> s_bar; // ok diff --git a/clang/test/SemaCXX/cxx0x-delegating-ctors.cpp b/clang/test/SemaCXX/cxx0x-delegating-ctors.cpp new file mode 100644 index 0000000..2d49f0f --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-delegating-ctors.cpp @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +struct foo { + int i; + foo(); + foo(int); + foo(int, int); + foo(bool); + foo(char); + foo(const float*); + foo(const float&); + foo(void*); +}; + +// 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{{creates a delegation cycle}} +} + +// Good +foo::foo (const float* f) : foo(*f) { // expected-note{{it delegates to}} +} + +foo::foo (const float &f) : foo(&f) { //expected-error{{creates a delegation cycle}} \ + //expected-note{{which delegates to}} +} + +foo::foo (char) : i(3), foo(3) { // expected-error{{must appear alone}} +} + +// This should not cause an infinite loop +foo::foo (void*) : foo(4.0f) { +} + +struct deleted_dtor { + ~deleted_dtor() = delete; // expected-note{{function has been explicitly marked deleted here}} + deleted_dtor(); + deleted_dtor(int) : deleted_dtor() // expected-error{{attempt to use a deleted function}} + {} +}; diff --git a/clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp b/clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp new file mode 100644 index 0000000..0cebc10 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp @@ -0,0 +1,131 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct non_trivial { + non_trivial(); + non_trivial(const non_trivial&); + non_trivial& operator = (const non_trivial&); + ~non_trivial(); +}; + +union bad_union { + non_trivial nt; // expected-note {{non-trivial default constructor}} +}; +bad_union u; // expected-error {{call to implicitly-deleted default constructor}} +union bad_union2 { // expected-note {{all data members are const-qualified}} + const int i; +}; +bad_union2 u2; // expected-error {{call to implicitly-deleted default constructor}} + +struct bad_anon { + union { + non_trivial nt; // expected-note {{non-trivial default constructor}} + }; +}; +bad_anon a; // expected-error {{call to implicitly-deleted default constructor}} +struct bad_anon2 { + union { // expected-note {{all data members of an anonymous union member are const-qualified}} + const int i; + }; +}; +bad_anon2 a2; // expected-error {{call to implicitly-deleted default constructor}} + +// This would be great except that we implement +union good_union { + const int i; + float f; +}; +good_union gu; +struct good_anon { + union { + const int i; + float f; + }; +}; +good_anon ga; + +struct good : non_trivial { + non_trivial nt; +}; +good g; + +struct bad_const { + const good g; // expected-note {{field 'g' of const-qualified type 'const good' would not be initialized}} +}; +bad_const bc; // expected-error {{call to implicitly-deleted default constructor}} + +struct good_const { + const non_trivial nt; +}; +good_const gc; + +struct no_default { + no_default() = delete; // expected-note 3{{deleted here}} +}; +struct no_dtor { + ~no_dtor() = delete; // expected-note 2{{deleted here}} +}; + +struct bad_field_default { + no_default nd; // expected-note {{field 'nd' has a deleted default constructor}} +}; +bad_field_default bfd; // expected-error {{call to implicitly-deleted default constructor}} +struct bad_base_default : no_default { // expected-note {{base class 'no_default' has a deleted default constructor}} +}; +bad_base_default bbd; // expected-error {{call to implicitly-deleted default constructor}} + +struct bad_field_dtor { + no_dtor nd; // expected-note {{field 'nd' has a deleted destructor}} +}; +bad_field_dtor bfx; // expected-error {{call to implicitly-deleted default constructor}} +struct bad_base_dtor : no_dtor { // expected-note {{base class 'no_dtor' has a deleted destructor}} +}; +bad_base_dtor bbx; // expected-error {{call to implicitly-deleted default constructor}} + +struct ambiguous_default { + ambiguous_default(); + ambiguous_default(int = 2); +}; +struct has_amb_field { + ambiguous_default ad; // expected-note {{field 'ad' has multiple default constructors}} +}; +has_amb_field haf; // expected-error {{call to implicitly-deleted default constructor}} + +class inaccessible_default { + inaccessible_default(); +}; +struct has_inacc_field { + inaccessible_default id; // expected-note {{field 'id' has an inaccessible default constructor}} +}; +has_inacc_field hif; // expected-error {{call to implicitly-deleted default constructor}} + +class friend_default { + friend struct has_friend; + friend_default(); +}; +struct has_friend { + friend_default fd; +}; +has_friend hf; + +struct defaulted_delete { + no_default nd; // expected-note {{because field 'nd' has a deleted default constructor}} + defaulted_delete() = default; // expected-note{{implicitly deleted here}} +}; +defaulted_delete dd; // expected-error {{call to implicitly-deleted default constructor}} + +struct late_delete { + no_default nd; + late_delete(); +}; +late_delete::late_delete() = default; // expected-error {{would delete it}} + +// See also rdar://problem/8125400. +namespace empty { + static union {}; + static union { union {}; }; + static union { struct {}; }; + static union { union { union {}; }; }; + static union { union { struct {}; }; }; + static union { struct { union {}; }; }; + static union { struct { struct {}; }; }; +} diff --git a/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp b/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp new file mode 100644 index 0000000..801a82f --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-aggregates.cpp @@ -0,0 +1,89 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +struct one { char c[1]; }; +struct two { char c[2]; }; + +namespace aggregate { + // Direct list initialization does NOT allow braces to be elided! + struct S { + int ar[2]; + struct T { + int i1; + int i2; + } t; + struct U { + int i1; + } u[2]; + struct V { + int var[2]; + } v; + }; + + void bracing() { + S s1 = { 1, 2, 3 ,4, 5, 6, 7, 8 }; // no-error + S s2{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } }; // completely braced + S s3{ 1, 2, 3, 4, 5, 6 }; // expected-error 5 {{cannot omit braces}} + S s4{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } }; // expected-error 2 {{cannot omit braces}} + S s5{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} }; // expected-error {{cannot omit braces}} + } + + void bracing_new() { + new S{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } }; // completely braced + new S{ 1, 2, 3, 4, 5, 6 }; // expected-error 5 {{cannot omit braces}} + new S{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } }; // expected-error 2 {{cannot omit braces}} + new S{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} }; // expected-error {{cannot omit braces}} + } + + void bracing_construct() { + (void) S{ {1, 2}, {3, 4}, { {5}, {6} }, { {7, 8} } }; // completely braced + (void) S{ 1, 2, 3, 4, 5, 6 }; // expected-error 5 {{cannot omit braces}} + (void) S{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } }; // expected-error 2 {{cannot omit braces}} + (void) S{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} }; // expected-error {{cannot omit braces}} + } + + struct String { + String(const char*); + }; + + struct A { + int m1; + int m2; + }; + + void function_call() { + void takes_A(A); + takes_A({1, 2}); + } + + struct B { + int m1; + String m2; + }; + + void overloaded_call() { + one overloaded(A); + two overloaded(B); + + static_assert(sizeof(overloaded({1, 2})) == sizeof(one), "bad overload"); + static_assert(sizeof(overloaded({1, "two"})) == sizeof(two), + "bad overload"); + // String is not default-constructible + static_assert(sizeof(overloaded({1})) == sizeof(one), "bad overload"); + } + + struct C { int a[2]; C():a({1, 2}) { } }; // expected-error {{parenthesized initialization of a member array is a GNU extension}} +} + +namespace array_explicit_conversion { + typedef int test1[2]; + typedef int test2[]; + template<int x> struct A { int a[x]; }; // expected-error {{'a' declared as an array with a negative size}} + typedef A<1> test3[]; + typedef A<-1> test4[]; + void f() { + (void)test1{1}; + (void)test2{1}; + (void)test3{{{1}}}; + (void)test4{{{1}}}; // expected-note {{in instantiation of template class 'array_explicit_conversion::A<-1>' requested here}} + } +} diff --git a/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp new file mode 100644 index 0000000..09aca24 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp @@ -0,0 +1,283 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +struct one { char c[1]; }; +struct two { char c[2]; }; + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + +namespace objects { + + struct X1 { X1(int); }; + struct X2 { explicit X2(int); }; // expected-note {{constructor declared here}} + + template <int N> + struct A { + A() { static_assert(N == 0, ""); } + A(int, double) { static_assert(N == 1, ""); } + }; + + template <int N> + struct F { + F() { static_assert(N == 0, ""); } + F(int, double) { static_assert(N == 1, ""); } + F(std::initializer_list<int>) { static_assert(N == 3, ""); } + }; + + template <int N> + struct D { + D(std::initializer_list<int>) { static_assert(N == 0, ""); } // expected-note 1 {{candidate}} + D(std::initializer_list<double>) { static_assert(N == 1, ""); } // expected-note 1 {{candidate}} + }; + + template <int N> + struct E { + E(int, int) { static_assert(N == 0, ""); } + E(X1, int) { static_assert(N == 1, ""); } + }; + + void overload_resolution() { + { A<0> a{}; } + { A<0> a = {}; } + { A<1> a{1, 1.0}; } + { A<1> a = {1, 1.0}; } + + { F<0> f{}; } + { F<0> f = {}; } + // Narrowing conversions don't affect viability. The next two choose + // the initializer_list constructor. + // FIXME: Emit narrowing conversion errors. + { F<3> f{1, 1.0}; } // xpected-error {{narrowing conversion}} + { F<3> f = {1, 1.0}; } // xpected-error {{narrowing conversion}} + { F<3> f{1, 2, 3, 4, 5, 6, 7, 8}; } + { F<3> f = {1, 2, 3, 4, 5, 6, 7, 8}; } + { F<3> f{1, 2, 3, 4, 5, 6, 7, 8}; } + { F<3> f{1, 2}; } + + { D<0> d{1, 2, 3}; } + { D<1> d{1.0, 2.0, 3.0}; } + { D<-1> d{1, 2.0}; } // expected-error {{ambiguous}} + + { E<0> e{1, 2}; } + } + + void explicit_implicit() { + { X1 x{0}; } + { X1 x = {0}; } + { X2 x{0}; } + { X2 x = {0}; } // expected-error {{constructor is explicit}} + } + + struct C { + C(); + C(int, double); + C(int, int); + + int operator[](C); + }; + + C function_call() { + void takes_C(C); + takes_C({1, 1.0}); + + C c; + c[{1, 1.0}]; + + return {1, 1.0}; + } + + void inline_init() { + (void) C{1, 1.0}; + (void) new C{1, 1.0}; + (void) A<1>{1, 1.0}; + (void) new A<1>{1, 1.0}; + } + + struct B { // expected-note 2 {{candidate constructor}} + B(C, int, C); // expected-note {{candidate constructor not viable: cannot convert initializer list argument to 'objects::C'}} + }; + + void nested_init() { + B b1{{1, 1.0}, 2, {3, 4}}; + B b2{{1, 1.0, 4}, 2, {3, 4}}; // expected-error {{no matching constructor for initialization of 'objects::B'}} + } + + void overloaded_call() { + one ov1(B); // expected-note {{not viable: cannot convert initializer list}} + two ov1(C); // expected-note {{not viable: cannot convert initializer list}} + + static_assert(sizeof(ov1({})) == sizeof(two), "bad overload"); + static_assert(sizeof(ov1({1, 2})) == sizeof(two), "bad overload"); + static_assert(sizeof(ov1({{1, 1.0}, 2, {3, 4}})) == sizeof(one), "bad overload"); + + ov1({1}); // expected-error {{no matching function}} + + one ov2(int); + two ov2(F<3>); + static_assert(sizeof(ov2({1})) == sizeof(one), "bad overload"); // list -> int ranks as identity + static_assert(sizeof(ov2({1, 2, 3})) == sizeof(two), "bad overload"); // list -> F only viable + } + + struct G { // expected-note 6 {{not viable}} + // This is not an initializer-list constructor. + template<typename ...T> + G(std::initializer_list<int>, T ...); // expected-note 3 {{not viable}} + }; + + struct H { // expected-note 6 {{not viable}} + explicit H(int, int); // expected-note 3 {{not viable}} expected-note {{declared here}} + H(int, void*); // expected-note 3 {{not viable}} + }; + + void edge_cases() { + // invalid (the first phase only considers init-list ctors) + // (for the second phase, no constructor is viable) + G g1{1, 2, 3}; // expected-error {{no matching constructor}} + (void) new G{1, 2, 3}; // expected-error {{no matching constructor}} + (void) G{1, 2, 3} // expected-error {{no matching constructor}} + + // valid (T deduced to <>). + G g2({1, 2, 3}); + (void) new G({1, 2, 3}); + (void) G({1, 2, 3}); + + // invalid + H h1({1, 2}); // expected-error {{no matching constructor}} + (void) new H({1, 2}); // expected-error {{no matching constructor}} + // FIXME: Bad diagnostic, mentions void type instead of init list. + (void) H({1, 2}); // expected-error {{no matching conversion}} + + // valid (by copy constructor). + H h2({1, nullptr}); + (void) new H({1, nullptr}); + (void) H({1, nullptr}); + + // valid + H h3{1, 2}; + (void) new H{1, 2}; + (void) H{1, 2}; + } + + struct memberinit { + H h1{1, nullptr}; + H h2 = {1, nullptr}; + H h3{1, 1}; + H h4 = {1, 1}; // expected-error {{constructor is explicit}} + }; +} + +namespace PR12092 { + + struct S { + S(const char*); + }; + struct V { + template<typename T> V(T, T); + void f(std::initializer_list<S>); + void f(const V &); + }; + + void g() { + extern V s; + s.f({"foo", "bar"}); + } + +} + +namespace PR12117 { + struct A { A(int); }; + struct B { B(A); } b{{0}}; + struct C { C(int); } c{0}; +} + +namespace PR12167 { + template<int N> struct string {}; + + struct X { + X(const char v); + template<typename T> bool operator()(T) const; + }; + + template<int N, class Comparator> bool g(const string<N>& s, Comparator cmp) { + return cmp(s); + } + template<int N> bool f(const string<N> &s) { + return g(s, X{'x'}); + } + + bool s = f(string<1>()); +} + +namespace PR12257_PR12241 { + struct command_pair + { + command_pair(int, int); + }; + + struct command_map + { + command_map(std::initializer_list<command_pair>); + }; + + struct generator_pair + { + generator_pair(const command_map); + }; + + // 5 levels: init list, gen_pair, command_map, init list, command_pair + const std::initializer_list<generator_pair> x = {{{{{3, 4}}}}}; + + // 4 levels: init list, gen_pair, command_map via init list, command_pair + const std::initializer_list<generator_pair> y = {{{{1, 2}}}}; +} + +namespace PR12120 { + struct A { explicit A(int); A(float); }; // expected-note {{declared here}} + A a = { 0 }; // expected-error {{constructor is explicit}} + + struct B { explicit B(short); B(long); }; // expected-note 2 {{candidate}} + B b = { 0 }; // expected-error {{ambiguous}} +} + +namespace PR12498 { + class ArrayRef; // expected-note{{forward declaration}} + + struct C { + void foo(const ArrayRef&); // expected-note{{passing argument to parameter here}} + }; + + static void bar(C* c) + { + c->foo({ nullptr, 1 }); // expected-error{{initialization of incomplete type 'const PR12498::ArrayRef'}} + } + +} diff --git a/clang/test/SemaCXX/cxx0x-initializer-references.cpp b/clang/test/SemaCXX/cxx0x-initializer-references.cpp new file mode 100644 index 0000000..c4e9c90 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-references.cpp @@ -0,0 +1,92 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct one { char c; }; +struct two { char c[2]; }; + +namespace reference { + struct A { + int i1, i2; + }; + + void single_init() { + const int &cri1a = {1}; + const int &cri1b{1}; + + int i = 1; + int &ri1a = {i}; + int &ri1b{i}; + + int &ri2 = {1}; // expected-error {{cannot bind to an initializer list temporary}} + + A a{1, 2}; + A &ra1a = {a}; + A &ra1b{a}; + } + + void reference_to_aggregate() { + const A &ra1{1, 2}; + A &ra2{1, 2}; // expected-error {{cannot bind to an initializer list temporary}} + + const int (&arrayRef)[] = {1, 2, 3}; + static_assert(sizeof(arrayRef) == 3 * sizeof(int), "bad array size"); + } + + struct B { + int i1; + }; + + void call() { + void f(const int&); + f({1}); + + void g(int&); // expected-note {{passing argument}} + g({1}); // expected-error {{cannot bind to an initializer list temporary}} + int i = 0; + g({i}); + + void h(const B&); + h({1}); + + void a(B&); // expected-note {{passing argument}} + a({1}); // expected-error {{cannot bind to an initializer list temporary}} + B b{1}; + a({b}); + } + + void overloading() { + one f(const int&); + two f(const B&); + + // First is identity conversion, second is user-defined conversion. + static_assert(sizeof(f({1})) == sizeof(one), "bad overload resolution"); + + one g(int&); + two g(const B&); + + static_assert(sizeof(g({1})) == sizeof(two), "bad overload resolution"); + + one h(const int&); + two h(const A&); + + static_assert(sizeof(h({1, 2})) == sizeof(two), "bad overload resolution"); + } + + void edge_cases() { + // FIXME: very poor error message + int const &b({0}); // expected-error {{could not bind}} + } + +} + +namespace PR12182 { + void f(int const(&)[3]); + + void g() { + f({1, 2}); + } +} + +namespace PR12660 { + const int &i { 1 }; + struct S { S(int); } const &s { 2 }; +} diff --git a/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp b/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp new file mode 100644 index 0000000..627855e --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp @@ -0,0 +1,116 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct one { char c[1]; }; +struct two { char c[2]; }; + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + +namespace integral { + + void initialization() { + { const int a{}; static_assert(a == 0, ""); } + { const int a = {}; static_assert(a == 0, ""); } + { const int a{1}; static_assert(a == 1, ""); } + { const int a = {1}; static_assert(a == 1, ""); } + { const int a{1, 2}; } // expected-error {{excess elements}} + { const int a = {1, 2}; } // expected-error {{excess elements}} + // FIXME: Redundant warnings. + { const short a{100000}; } // expected-error {{cannot be narrowed}} expected-note {{inserting an explicit cast}} expected-warning {{changes value}} + { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{inserting an explicit cast}} expected-warning {{changes value}} + { if (const int a{1}) static_assert(a == 1, ""); } + { if (const int a = {1}) static_assert(a == 1, ""); } + } + + int direct_usage() { + int ar[10]; + (void) ar[{1}]; // expected-error {{array subscript is not an integer}} + + return {1}; + } + + void inline_init() { + auto v = int{1}; + (void) new int{1}; + } + + struct A { + int i; + A() : i{1} {} + }; + + void function_call() { + void takes_int(int); + takes_int({1}); + } + + void overloaded_call() { + one overloaded(int); + two overloaded(double); + + static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload"); + static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload"); + + void ambiguous(int, double); // expected-note {{candidate}} + void ambiguous(double, int); // expected-note {{candidate}} + ambiguous({0}, {0}); // expected-error {{ambiguous}} + + void emptylist(int); + void emptylist(int, int, int); + emptylist({}); + emptylist({}, {}, {}); + } + + void edge_cases() { + // FIXME: very poor error message + int a({0}); // expected-error {{cannot initialize}} + (void) int({0}); // expected-error {{functional-style cast}} + new int({0}); // expected-error {{cannot initialize}} + } + + void default_argument(int i = {}) { + } + struct DefaultArgument { + void default_argument(int i = {}) { + } + }; +} + +namespace PR12118 { + void test() { + one f(std::initializer_list<int>); + two f(int); + + // to initializer_list is preferred + static_assert(sizeof(f({0})) == sizeof(one), "bad overload"); + } +} diff --git a/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp b/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp new file mode 100644 index 0000000..7384309 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp @@ -0,0 +1,177 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// This must obviously come before the definition of std::initializer_list. +void missing_initializerlist() { + auto l = {1, 2, 3, 4}; // expected-error {{std::initializer_list was not found}} +} + +namespace std { + typedef decltype(sizeof(int)) size_t; + + // libc++'s implementation + template <class _E> + class initializer_list + { + const _E* __begin_; + size_t __size_; + + initializer_list(const _E* __b, size_t __s) + : __begin_(__b), + __size_(__s) + {} + + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + + typedef const _E* iterator; + typedef const _E* const_iterator; + + initializer_list() : __begin_(nullptr), __size_(0) {} + + size_t size() const {return __size_;} + const _E* begin() const {return __begin_;} + const _E* end() const {return __begin_ + __size_;} + }; +} + +template <typename T, typename U> +struct same_type { static const bool value = false; }; +template <typename T> +struct same_type<T, T> { static const bool value = true; }; + +struct one { char c[1]; }; +struct two { char c[2]; }; + +struct A { + int a, b; +}; + +struct B { + B(); + B(int, int); +}; + +void simple_list() { + std::initializer_list<int> il = { 1, 2, 3 }; + std::initializer_list<double> dl = { 1.0, 2.0, 3 }; + std::initializer_list<A> al = { {1, 2}, {2, 3}, {3, 4} }; + std::initializer_list<B> bl = { {1, 2}, {2, 3}, {} }; +} + +void function_call() { + void f(std::initializer_list<int>); + f({1, 2, 3}); + + void g(std::initializer_list<B>); + g({ {1, 2}, {2, 3}, {} }); +} + +struct C { + C(int); +}; + +struct D { + D(); + operator int(); + operator C(); +}; + +void overloaded_call() { + one overloaded(std::initializer_list<int>); + two overloaded(std::initializer_list<B>); + + static_assert(sizeof(overloaded({1, 2, 3})) == sizeof(one), "bad overload"); + static_assert(sizeof(overloaded({ {1, 2}, {2, 3}, {} })) == sizeof(two), "bad overload"); + + void ambiguous(std::initializer_list<A>); // expected-note {{candidate}} + void ambiguous(std::initializer_list<B>); // expected-note {{candidate}} + ambiguous({ {1, 2}, {2, 3}, {3, 4} }); // expected-error {{ambiguous}} + + one ov2(std::initializer_list<int>); // expected-note {{candidate}} + two ov2(std::initializer_list<C>); // expected-note {{candidate}} + // Worst sequence to int is identity, whereas to C it's user-defined. + static_assert(sizeof(ov2({1, 2, 3})) == sizeof(one), "bad overload"); + // But here, user-defined is worst in both cases. + ov2({1, 2, D()}); // expected-error {{ambiguous}} +} + +template <typename T> +T deduce(std::initializer_list<T>); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} +template <typename T> +T deduce_ref(const std::initializer_list<T>&); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} + +void argument_deduction() { + static_assert(same_type<decltype(deduce({1, 2, 3})), int>::value, "bad deduction"); + static_assert(same_type<decltype(deduce({1.0, 2.0, 3.0})), double>::value, "bad deduction"); + + deduce({1, 2.0}); // expected-error {{no matching function}} + + static_assert(same_type<decltype(deduce_ref({1, 2, 3})), int>::value, "bad deduction"); + static_assert(same_type<decltype(deduce_ref({1.0, 2.0, 3.0})), double>::value, "bad deduction"); + + deduce_ref({1, 2.0}); // expected-error {{no matching function}} +} + +void auto_deduction() { + auto l = {1, 2, 3, 4}; + static_assert(same_type<decltype(l), std::initializer_list<int>>::value, ""); + auto bl = {1, 2.0}; // expected-error {{cannot deduce}} + + for (int i : {1, 2, 3, 4}) {} +} + +void dangle() { + new auto{1, 2, 3}; // expected-error {{cannot use list-initialization}} + new std::initializer_list<int>{1, 2, 3}; // expected-warning {{at the end of the full-expression}} +} + +struct haslist1 { + std::initializer_list<int> il = {1, 2, 3}; // expected-warning{{at the end of the constructor}} + std::initializer_list<int> jl{1, 2, 3}; // expected-warning{{at the end of the constructor}} + haslist1(); +}; + +haslist1::haslist1() +: il{1, 2, 3} // expected-warning{{at the end of the constructor}} +{} + +namespace PR12119 { + // Deduction with nested initializer lists. + template<typename T> void f(std::initializer_list<T>); + template<typename T> void g(std::initializer_list<std::initializer_list<T>>); + + void foo() { + f({0, {1}}); + g({{0, 1}, {2, 3}}); + std::initializer_list<int> il = {1, 2}; + g({il, {2, 3}}); + } +} + +namespace Decay { + template<typename T> + void f(std::initializer_list<T>) { + T x = 1; // expected-error{{cannot initialize a variable of type 'const char *' with an rvalue of type 'int'}} + } + + void g() { + f({"A", "BB", "CCC"}); // expected-note{{in instantiation of function template specialization 'Decay::f<const char *>' requested here}} + + auto x = { "A", "BB", "CCC" }; + std::initializer_list<const char *> *il = &x; + + for( auto s : {"A", "BB", "CCC", "DDD"}) { } + } +} + +namespace PR12436 { + struct X { + template<typename T> + X(std::initializer_list<int>, T); + }; + + X x({}, 17); +} diff --git a/clang/test/SemaCXX/cxx0x-nontrivial-union.cpp b/clang/test/SemaCXX/cxx0x-nontrivial-union.cpp new file mode 100644 index 0000000..0e4add8 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-nontrivial-union.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct non_trivial { + non_trivial(); + non_trivial(const non_trivial&); + non_trivial& operator = (const non_trivial&); + ~non_trivial(); +}; + +union u { + non_trivial nt; +}; +union u2 { + non_trivial nt; + int k; + u2(int k) : k(k) {} + u2() : nt() {} +}; + +union static_data_member { + static int i; +}; +int static_data_member::i; + +union bad { + int &i; // expected-error {{union member 'i' has reference type 'int &'}} +}; + +struct s { + union { + non_trivial nt; + }; +}; + +// Don't crash on this. +struct TemplateCtor { template<typename T> TemplateCtor(T); }; +union TemplateCtorMember { TemplateCtor s; }; + +template<typename T> struct remove_ref { typedef T type; }; +template<typename T> struct remove_ref<T&> { typedef T type; }; +template<typename T> struct remove_ref<T&&> { typedef T type; }; +template<typename T> T &&forward(typename remove_ref<T>::type &&t); +template<typename T> T &&forward(typename remove_ref<T>::type &t); +template<typename T> typename remove_ref<T>::type &&move(T &&t); + +using size_t = decltype(sizeof(int)); +void *operator new(size_t, void *p) noexcept { return p; } + +namespace disabled_dtor { + template<typename T> + union disable_dtor { + T val; + template<typename...U> + disable_dtor(U &&...u) : val(forward<U>(u)...) {} + ~disable_dtor() {} + }; + + struct deleted_dtor { + deleted_dtor(int n, char c) : n(n), c(c) {} + int n; + char c; + ~deleted_dtor() = delete; + }; + + disable_dtor<deleted_dtor> dd(4, 'x'); +} + +namespace optional { + template<typename T> struct optional { + bool has; + union { T value; }; + + optional() : has(false) {} + template<typename...U> + optional(U &&...u) : has(true), value(forward<U>(u)...) {} + + optional(const optional &o) : has(o.has) { + if (has) new (&value) T(o.value); + } + optional(optional &&o) : has(o.has) { + if (has) new (&value) T(move(o.value)); + } + + optional &operator=(const optional &o) { + if (has) { + if (o.has) + value = o.value; + else + value.~T(); + } else if (o.has) { + new (&value) T(o.value); + } + has = o.has; + } + optional &operator=(optional &&o) { + if (has) { + if (o.has) + value = move(o.value); + else + value.~T(); + } else if (o.has) { + new (&value) T(move(o.value)); + } + has = o.has; + } + + ~optional() { + if (has) + value.~T(); + } + + explicit operator bool() const { return has; } + T &operator*() const { return value; } + }; + + optional<non_trivial> o1; + optional<non_trivial> o2{non_trivial()}; + optional<non_trivial> o3{*o2}; + void f() { + if (o2) + o1 = o2; + o2 = optional<non_trivial>(); + } +} diff --git a/clang/test/SemaCXX/cxx0x-return-init-list.cpp b/clang/test/SemaCXX/cxx0x-return-init-list.cpp new file mode 100644 index 0000000..da83271 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-return-init-list.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Test that a very basic variation of generalized initializer returns (that +// required for libstdc++ 4.5) is supported in C++98. + +int test0(int i) { + return { i }; // expected-warning{{generalized initializer lists are a C++11 extension}} +} + +template<typename T, typename U> +T test1(U u) { + return { u }; // expected-warning{{generalized initializer lists are a C++11 extension}} +} + +template int test1(char); +template long test1(int); diff --git a/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp b/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp new file mode 100644 index 0000000..6a7fe45 --- /dev/null +++ b/clang/test/SemaCXX/cxx0x-type-convert-construct.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -std=gnu++11 -fsyntax-only -verify %s + +void f() { + char *u8str; + u8str = u8"a UTF-8 string"; // expected-error {{assigning to 'char *' from incompatible type 'const char [15]'}} + char16_t *ustr; + ustr = u"a UTF-16 string"; // expected-error {{assigning to 'char16_t *' from incompatible type 'const char16_t [16]'}} + char32_t *Ustr; + Ustr = U"a UTF-32 string"; // expected-error {{assigning to 'char32_t *' from incompatible type 'const char32_t [16]'}} + + char *Rstr; + Rstr = R"foo(a raw string)foo"; // expected-warning{{conversion from string literal to 'char *' is deprecated}} + wchar_t *LRstr; + LRstr = LR"foo(a wide raw string)foo"; // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}} + char *u8Rstr; + u8Rstr = u8R"foo(a UTF-8 raw string)foo"; // expected-error {{assigning to 'char *' from incompatible type 'const char [19]'}} + char16_t *uRstr; + uRstr = uR"foo(a UTF-16 raw string)foo"; // expected-error {{assigning to 'char16_t *' from incompatible type 'const char16_t [20]'}} + char32_t *URstr; + URstr = UR"foo(a UTF-32 raw string)foo"; // expected-error {{assigning to 'char32_t *' from incompatible type 'const char32_t [20]'}} +} diff --git a/clang/test/SemaCXX/cxx11-ast-print.cpp b/clang/test/SemaCXX/cxx11-ast-print.cpp new file mode 100644 index 0000000..afabf88 --- /dev/null +++ b/clang/test/SemaCXX/cxx11-ast-print.cpp @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -std=c++11 -ast-print %s | FileCheck %s + +// FIXME: Print the trailing-return-type properly. +// CHECK: decltype(nullptr) operator "" _foo(const char *p, decltype(sizeof(int))); +auto operator"" _foo(const char *p, decltype(sizeof(int))) -> decltype(nullptr); + +// CHECK: decltype(""_foo) operator "" _bar(unsigned long long); +decltype(""_foo) operator"" _bar(unsigned long long); + +// CHECK: decltype(42_bar) operator "" _baz(long double); +decltype(42_bar) operator"" _baz(long double); + +// CHECK: decltype(4.5_baz) operator "" _baz(char); +decltype(4.5_baz) operator"" _baz(char); + +// CHECK: const char *operator "" _quux(const char *); +const char *operator"" _quux(const char *); + +// CHECK: template <char...> const char *operator "" _fritz(); +template<char...> const char *operator"" _fritz(); + +// CHECK: const char *p1 = "bar1"_foo; +const char *p1 = "bar1"_foo; +// CHECK: const char *p2 = "bar2"_foo; +const char *p2 = R"x(bar2)x"_foo; +// CHECK: const char *p3 = u8"bar3"_foo; +const char *p3 = u8"bar3"_foo; +// CHECK: const char *p4 = 297_bar; +const char *p4 = 0x129_bar; +// CHECK: const char *p5 = 1.0E+12_baz; +const char *p5 = 1e12_baz; +// CHECK: const char *p6 = 'x'_baz; +const char *p6 = 'x'_baz; +// CHECK: const char *p7 = 123_quux; +const char *p7 = 123_quux; +// CHECK: const char *p8 = 4.9_quux; +const char *p8 = 4.9_quux; +// CHECK: const char *p9 = 0x42e3F_fritz; +const char *p9 = 0x42e3F_fritz; +// CHECK: const char *p10 = 3.300e+15_fritz; +const char *p10 = 3.300e+15_fritz; diff --git a/clang/test/SemaCXX/cxx11-user-defined-literals.cpp b/clang/test/SemaCXX/cxx11-user-defined-literals.cpp new file mode 100644 index 0000000..4bbecdb --- /dev/null +++ b/clang/test/SemaCXX/cxx11-user-defined-literals.cpp @@ -0,0 +1,137 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s -fms-extensions -triple x86_64-apple-darwin9.0.0 + +using size_t = decltype(sizeof(int)); +enum class LitKind { + Char, WideChar, Char16, Char32, + CharStr, WideStr, Char16Str, Char32Str, + Integer, Floating, Raw, Template +}; +constexpr LitKind operator"" _kind(char p) { return LitKind::Char; } +constexpr LitKind operator"" _kind(wchar_t p) { return LitKind::WideChar; } +constexpr LitKind operator"" _kind(char16_t p) { return LitKind::Char16; } +constexpr LitKind operator"" _kind(char32_t p) { return LitKind::Char32; } +constexpr LitKind operator"" _kind(const char *p, size_t n) { return LitKind::CharStr; } +constexpr LitKind operator"" _kind(const wchar_t *p, size_t n) { return LitKind::WideStr; } +constexpr LitKind operator"" _kind(const char16_t *p, size_t n) { return LitKind::Char16Str; } +constexpr LitKind operator"" _kind(const char32_t *p, size_t n) { return LitKind::Char32Str; } +constexpr LitKind operator"" _kind(unsigned long long n) { return LitKind::Integer; } +constexpr LitKind operator"" _kind(long double n) { return LitKind::Floating; } +constexpr LitKind operator"" _kind2(const char *p) { return LitKind::Raw; } +template<char ...Cs> constexpr LitKind operator"" _kind3() { return LitKind::Template; } + +static_assert('x'_kind == LitKind::Char, ""); +static_assert(L'x'_kind == LitKind::WideChar, ""); +static_assert(u'x'_kind == LitKind::Char16, ""); +static_assert(U'x'_kind == LitKind::Char32, ""); +static_assert("foo"_kind == LitKind::CharStr, ""); +static_assert(u8"foo"_kind == LitKind::CharStr, ""); +static_assert(L"foo"_kind == LitKind::WideStr, ""); +static_assert(u"foo"_kind == LitKind::Char16Str, ""); +static_assert(U"foo"_kind == LitKind::Char32Str, ""); +static_assert(194_kind == LitKind::Integer, ""); +static_assert(0377_kind == LitKind::Integer, ""); +static_assert(0x5ffc_kind == LitKind::Integer, ""); +static_assert(.5954_kind == LitKind::Floating, ""); +static_assert(1._kind == LitKind::Floating, ""); +static_assert(1.e-2_kind == LitKind::Floating, ""); +static_assert(4e6_kind == LitKind::Floating, ""); +static_assert(4e6_kind2 == LitKind::Raw, ""); +static_assert(4e6_kind3 == LitKind::Template, ""); + +constexpr const char *fractional_digits_impl(const char *p) { + return *p == '.' ? p + 1 : *p ? fractional_digits_impl(p + 1) : 0; +} +constexpr const char *operator"" _fractional_digits(const char *p) { + return fractional_digits_impl(p) ?: p; +} +constexpr bool streq(const char *p, const char *q) { + return *p == *q && (!*p || streq(p+1, q+1)); +} + +static_assert(streq(143.97_fractional_digits, "97"), ""); +static_assert(streq(0x786_fractional_digits, "0x786"), ""); +static_assert(streq(.4_fractional_digits, "4"), ""); +static_assert(streq(4._fractional_digits, ""), ""); +static_assert(streq(1e+97_fractional_digits, "1e+97"), ""); +static_assert(streq(0377_fractional_digits, "0377"), ""); +static_assert(streq(0377.5_fractional_digits, "5"), ""); + +int operator"" _ambiguous(char); // expected-note {{candidate}} +namespace N { + void *operator"" _ambiguous(char); // expected-note {{candidate}} +} +using namespace N; +int k = 'x'_ambiguous; // expected-error {{ambiguous}} + +int operator"" _deleted(unsigned long long) = delete; // expected-note {{here}} +int m = 42_deleted; // expected-error {{attempt to use a deleted}} + +namespace Using { + namespace M { + int operator"" _using(char); + } + int k1 = 'x'_using; // expected-error {{no matching literal operator for call to 'operator "" _using'}} + + using M::operator "" _using; + int k2 = 'x'_using; +} + +namespace AmbiguousRawTemplate { + int operator"" _ambig1(const char *); // expected-note {{candidate}} + template<char...> int operator"" _ambig1(); // expected-note {{candidate}} + + int k1 = 123_ambig1; // expected-error {{call to 'operator "" _ambig1' is ambiguous}} + + namespace Inner { + template<char...> int operator"" _ambig2(); // expected-note 3{{candidate}} + } + int operator"" _ambig2(const char *); // expected-note 3{{candidate}} + using Inner::operator"" _ambig2; + + int k2 = 123_ambig2; // expected-error {{call to 'operator "" _ambig2' is ambiguous}} + + namespace N { + using Inner::operator"" _ambig2; + + int k3 = 123_ambig2; // ok + + using AmbiguousRawTemplate::operator"" _ambig2; + + int k4 = 123_ambig2; // expected-error {{ambiguous}} + + namespace M { + + template<char...> int operator"" _ambig2(); + + int k5 = 123_ambig2; // ok + } + + int operator"" _ambig2(unsigned long long); + + int k6 = 123_ambig2; // ok + int k7 = 123._ambig2; // expected-error {{ambiguous}} + } +} + +constexpr unsigned mash(unsigned a) { + return 0x93ae27b5 * ((a >> 13) | a << 19); +} +template<typename=void> constexpr unsigned hash(unsigned a) { return a; } +template<char C, char...Cs> constexpr unsigned hash(unsigned a) { + return hash<Cs...>(mash(a ^ mash(C))); +} +template<typename T, T v> struct constant { constexpr static T value = v; }; +template<char...Cs> constexpr unsigned operator"" _hash() { + return constant<unsigned, hash<Cs...>(0)>::value; +} +static_assert(0x1234_hash == 0x103eff5e, ""); +static_assert(hash<'0', 'x', '1', '2', '3', '4'>(0) == 0x103eff5e, ""); + +// Functions and literal suffixes go in separate namespaces. +namespace Namespace { + template<char...> int operator"" _x(); + int k = _x(); // expected-error {{undeclared identifier '_x'}} + + int _y(unsigned long long); + int k2 = 123_y; // expected-error {{no matching literal operator for call to 'operator "" _y'}} +} diff --git a/clang/test/SemaCXX/cxx98-compat-flags.cpp b/clang/test/SemaCXX/cxx98-compat-flags.cpp new file mode 100644 index 0000000..6dc24be --- /dev/null +++ b/clang/test/SemaCXX/cxx98-compat-flags.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -Wno-bind-to-temporary-copy -Wno-unnamed-type-template-args -Wno-local-type-template-args -Werror %s + +template<typename T> int TemplateFn(T) { return 0; } +void LocalTemplateArg() { + struct S {}; + TemplateFn(S()); // expected-warning {{local type 'S' as template argument is incompatible with C++98}} +} +struct {} obj_of_unnamed_type; // expected-note {{here}} +int UnnamedTemplateArg = TemplateFn(obj_of_unnamed_type); // expected-warning {{unnamed type as template argument is incompatible with C++98}} + +namespace CopyCtorIssues { + struct Private { + Private(); + private: + Private(const Private&); // expected-note {{declared private here}} + }; + struct NoViable { + NoViable(); + NoViable(NoViable&); // expected-note {{not viable}} + }; + struct Ambiguous { + Ambiguous(); + Ambiguous(const Ambiguous &, int = 0); // expected-note {{candidate}} + Ambiguous(const Ambiguous &, double = 0); // expected-note {{candidate}} + }; + struct Deleted { + Private p; // expected-note {{copy constructor of 'Deleted' is implicitly deleted because field 'p' has an inaccessible copy constructor}} + }; + + const Private &a = Private(); // expected-warning {{copying variable of type 'CopyCtorIssues::Private' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}} + const NoViable &b = NoViable(); // expected-warning {{copying variable of type 'CopyCtorIssues::NoViable' when binding a reference to a temporary would find no viable constructor in C++98}} + const Ambiguous &c = Ambiguous(); // expected-warning {{copying variable of type 'CopyCtorIssues::Ambiguous' when binding a reference to a temporary would find ambiguous constructors in C++98}} + const Deleted &d = Deleted(); // expected-warning {{copying variable of type 'CopyCtorIssues::Deleted' when binding a reference to a temporary would invoke a deleted constructor in C++98}} +} diff --git a/clang/test/SemaCXX/cxx98-compat-pedantic.cpp b/clang/test/SemaCXX/cxx98-compat-pedantic.cpp new file mode 100644 index 0000000..00532d5 --- /dev/null +++ b/clang/test/SemaCXX/cxx98-compat-pedantic.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat-pedantic -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -Werror %s +// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Werror %s + +// -Wc++98-compat-pedantic warns on C++11 features which we accept without a +// warning in C++98 mode. + +#line 32767 // ok +#line 32768 // expected-warning {{#line number greater than 32767 is incompatible with C++98}} + +#define VA_MACRO(x, ...) x // expected-warning {{variadic macros are incompatible with C++98}} +VA_MACRO(,x) // expected-warning {{empty macro argument list is incompatible with C++98}} + +; // expected-warning {{extra ';' outside of a function is incompatible with C++98}} + +enum Enum { + Enum_value, // expected-warning {{commas at the end of enumerator lists are incompatible with C++98}} +}; + +template<typename T> struct InstantiationAfterSpecialization {}; +template<> struct InstantiationAfterSpecialization<int> {}; // expected-note {{here}} +template struct InstantiationAfterSpecialization<int>; // expected-warning {{explicit instantiation of 'InstantiationAfterSpecialization<int>' that occurs after an explicit specialization is incompatible with C++98}} + +void *dlsym(); +void (*FnPtr)() = (void(*)())dlsym(); // expected-warning {{cast between pointer-to-function and pointer-to-object is incompatible with C++98}} +void *FnVoidPtr = (void*)&dlsym; // expected-warning {{cast between pointer-to-function and pointer-to-object is incompatible with C++98}} + +struct ConvertToInt { + operator int(); +}; +int *ArraySizeConversion = new int[ConvertToInt()]; // expected-warning {{implicit conversion from array size expression of type 'ConvertToInt' to integral type 'int' is incompatible with C++98}} + +template<typename T> class ExternTemplate {}; +extern template class ExternTemplate<int>; // expected-warning {{extern templates are incompatible with C++98}} diff --git a/clang/test/SemaCXX/cxx98-compat.cpp b/clang/test/SemaCXX/cxx98-compat.cpp new file mode 100644 index 0000000..82a9dc8 --- /dev/null +++ b/clang/test/SemaCXX/cxx98-compat.cpp @@ -0,0 +1,305 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wc++98-compat -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++11 %s + +namespace std { struct type_info; } + +template<typename ...T> // expected-warning {{variadic templates are incompatible with C++98}} +class Variadic1 {}; + +template<template<typename> class ...T> // expected-warning {{variadic templates are incompatible with C++98}} +class Variadic2 {}; + +template<int ...I> // expected-warning {{variadic templates are incompatible with C++98}} +class Variadic3 {}; + +int alignas(8) with_alignas; // expected-warning {{'alignas' is incompatible with C++98}} +int with_attribute [[ ]]; // expected-warning {{attributes are incompatible with C++98}} + +void Literals() { + (void)u8"str"; // expected-warning {{unicode literals are incompatible with C++98}} + (void)u"str"; // expected-warning {{unicode literals are incompatible with C++98}} + (void)U"str"; // expected-warning {{unicode literals are incompatible with C++98}} + (void)u'x'; // expected-warning {{unicode literals are incompatible with C++98}} + (void)U'x'; // expected-warning {{unicode literals are incompatible with C++98}} + + (void)u8R"X(str)X"; // expected-warning {{raw string literals are incompatible with C++98}} + (void)uR"X(str)X"; // expected-warning {{raw string literals are incompatible with C++98}} + (void)UR"X(str)X"; // expected-warning {{raw string literals are incompatible with C++98}} + (void)R"X(str)X"; // expected-warning {{raw string literals are incompatible with C++98}} + (void)LR"X(str)X"; // expected-warning {{raw string literals are incompatible with C++98}} +} + +template<typename T> struct S {}; +namespace TemplateParsing { + S<::S<void> > s; // expected-warning {{'<::' is treated as digraph '<:' (aka '[') followed by ':' in C++98}} + S< ::S<void>> t; // expected-warning {{consecutive right angle brackets are incompatible with C++98 (use '> >')}} +} + +void Lambda() { + []{}(); // expected-warning {{lambda expressions are incompatible with C++98}} +} + +int InitList(int i = {}) { // expected-warning {{generalized initializer lists are incompatible with C++98}} \ + // expected-warning {{scalar initialized from empty initializer list is incompatible with C++98}} + (void)new int {}; // expected-warning {{generalized initializer lists are incompatible with C++98}} \ + // expected-warning {{scalar initialized from empty initializer list is incompatible with C++98}} + (void)int{}; // expected-warning {{generalized initializer lists are incompatible with C++98}} \ + // expected-warning {{scalar initialized from empty initializer list is incompatible with C++98}} + int x { 0 }; // expected-warning {{generalized initializer lists are incompatible with C++98}} + S<int> s = {}; // ok, aggregate + s = {}; // expected-warning {{generalized initializer lists are incompatible with C++98}} + return { 0 }; // expected-warning {{generalized initializer lists are incompatible with C++98}} +} +struct DelayedDefaultArgumentParseInitList { + void f(int i = {1}) { // expected-warning {{generalized initializer lists are incompatible with C++98}} + } +}; + +int operator"" _hello(const char *); // expected-warning {{literal operators are incompatible with C++98}} + +enum EnumFixed : int { // expected-warning {{enumeration types with a fixed underlying type are incompatible with C++98}} +}; + +enum class EnumScoped { // expected-warning {{scoped enumerations are incompatible with C++98}} +}; + +void Deleted() = delete; // expected-warning {{deleted function definitions are incompatible with C++98}} +struct Defaulted { + Defaulted() = default; // expected-warning {{defaulted function definitions are incompatible with C++98}} +}; + +int &&RvalueReference = 0; // expected-warning {{rvalue references are incompatible with C++98}} +struct RefQualifier { + void f() &; // expected-warning {{reference qualifiers on functions are incompatible with C++98}} +}; + +auto f() -> int; // expected-warning {{trailing return types are incompatible with C++98}} + +void RangeFor() { + int xs[] = {1, 2, 3}; + for (int &a : xs) { // expected-warning {{range-based for loop is incompatible with C++98}} + } +} + +struct InClassInit { + int n = 0; // expected-warning {{in-class initialization of non-static data members is incompatible with C++98}} +}; + +struct OverrideControlBase { + virtual void f(); + virtual void g(); +}; +struct OverrideControl final : OverrideControlBase { // expected-warning {{'final' keyword is incompatible with C++98}} + virtual void f() override; // expected-warning {{'override' keyword is incompatible with C++98}} + virtual void g() final; // expected-warning {{'final' keyword is incompatible with C++98}} +}; + +using AliasDecl = int; // expected-warning {{alias declarations are incompatible with C++98}} +template<typename T> using AliasTemplate = T; // expected-warning {{alias declarations are incompatible with C++98}} + +inline namespace InlineNS { // expected-warning {{inline namespaces are incompatible with C++98}} +} + +auto auto_deduction = 0; // expected-warning {{'auto' type specifier is incompatible with C++98}} +int *p = new auto(0); // expected-warning {{'auto' type specifier is incompatible with C++98}} + +const int align_of = alignof(int); // expected-warning {{alignof expressions are incompatible with C++98}} +char16_t c16 = 0; // expected-warning {{'char16_t' type specifier is incompatible with C++98}} +char32_t c32 = 0; // expected-warning {{'char32_t' type specifier is incompatible with C++98}} +constexpr int const_expr = 0; // expected-warning {{'constexpr' specifier is incompatible with C++98}} +decltype(const_expr) decl_type = 0; // expected-warning {{'decltype' type specifier is incompatible with C++98}} +__decltype(const_expr) decl_type2 = 0; // ok +void no_except() noexcept; // expected-warning {{noexcept specifications are incompatible with C++98}} +bool no_except_expr = noexcept(1 + 1); // expected-warning {{noexcept expressions are incompatible with C++98}} +void *null = nullptr; // expected-warning {{'nullptr' is incompatible with C++98}} +static_assert(true, "!"); // expected-warning {{static_assert declarations are incompatible with C++98}} + +// FIXME: Reintroduce this test if support for inheriting constructors is +// implemented. +#if 0 +struct InhCtorBase { + InhCtorBase(int); +}; +struct InhCtorDerived : InhCtorBase { + using InhCtorBase::InhCtorBase; // xpected-warning {{inheriting constructors are incompatible with C++98}} +}; +#endif + +struct FriendMember { + static void MemberFn(); + friend void FriendMember::MemberFn(); // expected-warning {{friend declaration naming a member of the declaring class is incompatible with C++98}} +}; + +struct DelegCtor { + DelegCtor(int) : DelegCtor() {} // expected-warning {{delegating constructors are incompatible with C++98}} + DelegCtor(); +}; + +template<int n = 0> void DefaultFuncTemplateArg(); // expected-warning {{default template arguments for a function template are incompatible with C++98}} + +template<typename T> int TemplateFn(T) { return 0; } +void LocalTemplateArg() { + struct S {}; + TemplateFn(S()); // expected-warning {{local type 'S' as template argument is incompatible with C++98}} +} +struct {} obj_of_unnamed_type; // expected-note {{here}} +int UnnamedTemplateArg = TemplateFn(obj_of_unnamed_type); // expected-warning {{unnamed type as template argument is incompatible with C++98}} + +namespace RedundantParensInAddressTemplateParam { + int n; + template<int*p> struct S {}; + S<(&n)> s; // expected-warning {{redundant parentheses surrounding address non-type template argument are incompatible with C++98}} + S<(((&n)))> t; // expected-warning {{redundant parentheses surrounding address non-type template argument are incompatible with C++98}} +} + +namespace TemplateSpecOutOfScopeNs { + template<typename T> struct S {}; // expected-note {{here}} +} +template<> struct TemplateSpecOutOfScopeNs::S<char> {}; // expected-warning {{class template specialization of 'S' outside namespace 'TemplateSpecOutOfScopeNs' is incompatible with C++98}} + +struct Typename { + template<typename T> struct Inner {}; +}; +typename ::Typename TypenameOutsideTemplate(); // expected-warning {{use of 'typename' outside of a template is incompatible with C++98}} +Typename::template Inner<int> TemplateOutsideTemplate(); // expected-warning {{use of 'template' keyword outside of a template is incompatible with C++98}} + +struct TrivialButNonPOD { + int f(int); +private: + int k; +}; +void Ellipsis(int n, ...); +void TrivialButNonPODThroughEllipsis() { + Ellipsis(1, TrivialButNonPOD()); // expected-warning {{passing object of trivial but non-POD type 'TrivialButNonPOD' through variadic function is incompatible with C++98}} +} + +struct HasExplicitConversion { + explicit operator bool(); // expected-warning {{explicit conversion functions are incompatible with C++98}} +}; + +struct Struct {}; +enum Enum { enum_val = 0 }; +struct BadFriends { + friend enum ::Enum; // expected-warning {{befriending enumeration type 'enum ::Enum' is incompatible with C++98}} + friend int; // expected-warning {{non-class friend type 'int' is incompatible with C++98}} + friend Struct; // expected-warning {{befriending 'Struct' without 'struct' keyword is incompatible with C++98}} +}; + +int n = {}; // expected-warning {{scalar initialized from empty initializer list is incompatible with C++98}} + +class PrivateMember { + struct ImPrivate {}; +}; +template<typename T> typename T::ImPrivate SFINAEAccessControl(T t) { // expected-warning {{substitution failure due to access control is incompatible with C++98}} expected-note {{while substituting deduced template arguments into function template 'SFINAEAccessControl' [with T = PrivateMember]}} + return typename T::ImPrivate(); +} +int SFINAEAccessControl(...) { return 0; } +int CheckSFINAEAccessControl = SFINAEAccessControl(PrivateMember()); + +template<typename T> +struct FriendRedefinition { + friend void Friend() {} // expected-warning {{friend function 'Friend' would be implicitly redefined in C++98}} expected-note {{previous}} +}; +FriendRedefinition<int> FriendRedef1; +FriendRedefinition<char> FriendRedef2; // expected-note {{requested here}} + +namespace CopyCtorIssues { + struct Private { + Private(); + private: + Private(const Private&); // expected-note {{declared private here}} + }; + struct NoViable { + NoViable(); + NoViable(NoViable&); // expected-note {{not viable}} + }; + struct Ambiguous { + Ambiguous(); + Ambiguous(const Ambiguous &, int = 0); // expected-note {{candidate}} + Ambiguous(const Ambiguous &, double = 0); // expected-note {{candidate}} + }; + struct Deleted { + Private p; // expected-note {{implicitly deleted}} + }; + + const Private &a = Private(); // expected-warning {{copying variable of type 'CopyCtorIssues::Private' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}} + const NoViable &b = NoViable(); // expected-warning {{copying variable of type 'CopyCtorIssues::NoViable' when binding a reference to a temporary would find no viable constructor in C++98}} + const Ambiguous &c = Ambiguous(); // expected-warning {{copying variable of type 'CopyCtorIssues::Ambiguous' when binding a reference to a temporary would find ambiguous constructors in C++98}} + const Deleted &d = Deleted(); // expected-warning {{copying variable of type 'CopyCtorIssues::Deleted' when binding a reference to a temporary would invoke a deleted constructor in C++98}} +} + +namespace UnionOrAnonStructMembers { + struct NonTrivCtor { + NonTrivCtor(); // expected-note 2{{user-declared constructor}} + }; + struct NonTrivCopy { + NonTrivCopy(const NonTrivCopy&); // expected-note 2{{user-declared copy constructor}} + }; + struct NonTrivDtor { + ~NonTrivDtor(); // expected-note 2{{user-declared destructor}} + }; + union BadUnion { + NonTrivCtor ntc; // expected-warning {{union member 'ntc' with a non-trivial constructor is incompatible with C++98}} + NonTrivCopy ntcp; // expected-warning {{union member 'ntcp' with a non-trivial copy constructor is incompatible with C++98}} + NonTrivDtor ntd; // expected-warning {{union member 'ntd' with a non-trivial destructor is incompatible with C++98}} + }; + struct Wrap { + struct { + NonTrivCtor ntc; // expected-warning {{anonymous struct member 'ntc' with a non-trivial constructor is incompatible with C++98}} + NonTrivCopy ntcp; // expected-warning {{anonymous struct member 'ntcp' with a non-trivial copy constructor is incompatible with C++98}} + NonTrivDtor ntd; // expected-warning {{anonymous struct member 'ntd' with a non-trivial destructor is incompatible with C++98}} + }; + }; + union WithStaticDataMember { + static constexpr double d = 0.0; // expected-warning {{static data member 'd' in union is incompatible with C++98}} expected-warning {{'constexpr' specifier is incompatible with C++98}} + static const int n = 0; // expected-warning {{static data member 'n' in union is incompatible with C++98}} + static int k; // expected-warning {{static data member 'k' in union is incompatible with C++98}} + }; +} + +int EnumNNS = Enum::enum_val; // expected-warning {{enumeration type in nested name specifier is incompatible with C++98}} +template<typename T> void EnumNNSFn() { + int k = T::enum_val; // expected-warning {{enumeration type in nested name specifier is incompatible with C++98}} +}; +template void EnumNNSFn<Enum>(); // expected-note {{in instantiation}} + +void JumpDiagnostics(int n) { + goto DirectJump; // expected-warning {{goto would jump into protected scope in C++98}} + TrivialButNonPOD tnp1; // expected-note {{jump bypasses initialization of non-POD variable}} + +DirectJump: + void *Table[] = {&&DirectJump, &&Later}; + goto *Table[n]; // expected-warning {{indirect goto might cross protected scopes in C++98}} + + TrivialButNonPOD tnp2; // expected-note {{jump bypasses initialization of non-POD variable}} +Later: // expected-note {{possible target of indirect goto}} + switch (n) { + TrivialButNonPOD tnp3; // expected-note {{jump bypasses initialization of non-POD variable}} + default: // expected-warning {{switch case would be in a protected scope in C++98}} + return; + } +} + +namespace UnevaluatedMemberAccess { + struct S { + int n; + int f() { return sizeof(S::n); } // ok + }; + int k = sizeof(S::n); // expected-warning {{use of non-static data member 'n' in an unevaluated context is incompatible with C++98}} + const std::type_info &ti = typeid(S::n); // expected-warning {{use of non-static data member 'n' in an unevaluated context is incompatible with C++98}} +} + +namespace LiteralUCNs { + char c1 = '\u001e'; // expected-warning {{universal character name referring to a control character is incompatible with C++98}} + wchar_t c2 = L'\u0041'; // expected-warning {{specifying character 'A' with a universal character name is incompatible with C++98}} + const char *s1 = "foo\u0031"; // expected-warning {{specifying character '1' with a universal character name is incompatible with C++98}} + const wchar_t *s2 = L"bar\u0085"; // expected-warning {{universal character name referring to a control character is incompatible with C++98}} +} + +namespace NonTypeTemplateArgs { + template<typename T, T v> struct S {}; + const int k = 5; // expected-note {{here}} + static void f() {} // expected-note {{here}} + S<const int&, k> s1; // expected-warning {{non-type template argument referring to object 'k' with internal linkage is incompatible with C++98}} + S<void(&)(), f> s2; // expected-warning {{non-type template argument referring to function 'f' with internal linkage is incompatible with C++98}} +} diff --git a/clang/test/SemaCXX/dcl_ambig_res.cpp b/clang/test/SemaCXX/dcl_ambig_res.cpp new file mode 100644 index 0000000..fa71b11 --- /dev/null +++ b/clang/test/SemaCXX/dcl_ambig_res.cpp @@ -0,0 +1,76 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +// [dcl.ambig.res]p1: +struct S { + S(int); + void bar(); +}; + +int returns_an_int(); + +void foo(double a) +{ + S w(int(a)); // expected-warning{{disambiguated}} + w(17); + S x1(int()); // expected-warning{{disambiguated}} + x1(&returns_an_int); + S y((int)a); + y.bar(); + S z = int(a); + z.bar(); +} + +// [dcl.ambig.res]p3: +char *p; +void *operator new(__SIZE_TYPE__, int); +void foo3() { + const int x = 63; + new (int(*p)) int; //new-placement expression + new (int(*[x])); //new type-id +} + +// [dcl.ambig.res]p4: +template <class T> // expected-note{{here}} +struct S4 { + T *p; +}; +S4<int()> x; //type-id +S4<int(1)> y; // expected-error{{must be a type}} + +// [dcl.ambig.res]p5: +void foo5() +{ + (void)sizeof(int(1)); //expression + // FIXME: should we make this an error rather than a warning? + // (It affects SFINAE) + (void)sizeof(int()); // expected-warning{{function type}} +} + +// [dcl.ambig.res]p6: +void foo6() +{ + (void)(int(1)); //expression + (void)(int())1; // expected-error{{to 'int ()'}} +} + +// [dcl.ambig.res]p7: +class C7 { }; +void f7(int(C7)) { } // expected-note{{candidate}} +int g7(C7); +void foo7() { + f7(1); // expected-error{{no matching function}} + f7(g7); //OK +} + +void h7(int *(C7[10])) { } // expected-note{{previous}} +void h7(int *(*_fp)(C7 _parm[10])) { } // expected-error{{redefinition}} + +struct S5 { + static bool const value = false; +}; +int foo8() { + int v(int(S5::value)); // expected-warning{{disambiguated}} expected-error{{parameter declarator cannot be qualified}} +} + +template<typename T> +void rdar8739801( void (T::*)( void ) __attribute__((unused)) ); diff --git a/clang/test/SemaCXX/dcl_init_aggr.cpp b/clang/test/SemaCXX/dcl_init_aggr.cpp new file mode 100644 index 0000000..bd3de9e --- /dev/null +++ b/clang/test/SemaCXX/dcl_init_aggr.cpp @@ -0,0 +1,123 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +// C++ [dcl.init.aggr]p2 +struct A { + int x; + struct B { + int i; + int j; + } b; +} a1 = { 1, { 2, 3 } }; + +struct NonAggregate { + NonAggregate(); + + int a, b; +}; +NonAggregate non_aggregate_test = { 1, 2 }; // expected-error{{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}} + +NonAggregate non_aggregate_test2[2] = { { 1, 2 }, { 3, 4 } }; // expected-error 2 {{initialization of non-aggregate type 'NonAggregate' with an initializer list}} + + +// C++ [dcl.init.aggr]p3 +A a_init = A(); + +// C++ [dcl.init.aggr]p4 +int x[] = { 1, 3, 5 }; +int x_sizecheck[(sizeof(x) / sizeof(int)) == 3? 1 : -1]; +int x2[] = { }; // expected-warning{{zero size arrays are an extension}} + +// C++ [dcl.init.aggr]p5 +struct StaticMemberTest { + int i; + static int s; + int *j; +} smt = { 1, &smt.i }; + +// C++ [dcl.init.aggr]p6 +char cv[4] = { 'a', 's', 'd', 'f', 0 }; // expected-error{{excess elements in array initializer}} + +// C++ [dcl.init.aggr]p7 +struct TooFew { int a; char* b; int c; }; +TooFew too_few = { 1, "asdf" }; // expected-warning{{conversion from string literal to 'char *' is deprecated}} + +struct NoDefaultConstructor { // expected-note 3 {{candidate constructor (the implicit copy constructor)}} \ + // expected-note{{declared here}} + NoDefaultConstructor(int); // expected-note 3 {{candidate constructor}} +}; +struct TooFewError { // expected-error{{implicit default constructor for}} + int a; + NoDefaultConstructor nodef; // expected-note{{member is declared here}} +}; +TooFewError too_few_okay = { 1, 1 }; +TooFewError too_few_error = { 1 }; // expected-error{{no matching constructor}} + +TooFewError too_few_okay2[2] = { 1, 1 }; // expected-note{{implicit default constructor for 'TooFewError' first required here}} +TooFewError too_few_error2[2] = { 1 }; // expected-error{{no matching constructor}} + +NoDefaultConstructor too_few_error3[3] = { }; // expected-error {{no matching constructor}} + +// C++ [dcl.init.aggr]p8 +struct Empty { }; +struct EmptyTest { + Empty s; + int i; +} empty_test = { { }, 3 }; + +EmptyTest empty_test2 = { 3 }; // expected-error{{initializer for aggregate with no elements requires explicit braces}} + +struct NonEmpty { + int a; + Empty empty; +}; +struct NonEmptyTest { + NonEmpty a, b; +} non_empty_test = { { }, { } }; + +// C++ [dcl.init.aggr]p9 +struct HasReference { + int i; + int &j; // expected-note{{uninitialized reference member is here}} +}; +int global_int; +HasReference r1 = { 1, global_int }; +HasReference r2 = { 1 } ; // expected-error{{reference member of type 'int &' uninitialized}} + +// C++ [dcl.init.aggr]p10 +// Note: the behavior here is identical to C +int xs[2][2] = { 3, 1, 4, 2 }; +float y[4][3] = { { 1 }, { 2 }, { 3 }, { 4 } }; + +// C++ [dcl.init.aggr]p11 +// Note: the behavior here is identical to C +float y2[4][3] = { { 1, 3, 5 }, { 2, 4, 6 }, { 3, 5, 7 } }; +float same_as_y2[4][3] = { 1, 3, 5, 2, 4, 6, 3, 5, 7 }; + +// C++ [dcl.init.aggr]p12 +struct A2 { + int i; + operator int *(); +}; +struct B2 { + A2 a1, a2; + int *z; +}; +struct C2 { + operator A2(); +}; +struct D2 { + operator int(); +}; +A2 a2; +C2 c2; +D2 d2; +B2 b2 = { 4, a2, a2 }; +B2 b2_2 = { 4, d2, 0 }; +B2 b2_3 = { c2, a2, a2 }; + +// C++ [dcl.init.aggr]p15: +union u { int a; char* b; }; // expected-note{{candidate constructor (the implicit copy constructor)}} +u u1 = { 1 }; +u u2 = u1; +u u3 = 1; // expected-error{{no viable conversion}} +u u4 = { 0, "asdf" }; // expected-error{{excess elements in union initializer}} +u u5 = { "asdf" }; // expected-error{{cannot initialize a member subobject of type 'int' with an lvalue of type 'const char [5]'}} diff --git a/clang/test/SemaCXX/decl-expr-ambiguity.cpp b/clang/test/SemaCXX/decl-expr-ambiguity.cpp new file mode 100644 index 0000000..6f4d08c --- /dev/null +++ b/clang/test/SemaCXX/decl-expr-ambiguity.cpp @@ -0,0 +1,72 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic-errors %s + +void f() { + int a; + struct S { int m; }; + typedef S *T; + + // Expressions. + T(a)->m = 7; + int(a)++; // expected-error {{assignment to cast is illegal}} + __extension__ int(a)++; // expected-error {{assignment to cast is illegal}} + __typeof(int)(a,5)<<a; // expected-error {{excess elements in scalar initializer}} + void(a), ++a; + if (int(a)+1) {} + for (int(a)+1;;) {} // expected-warning {{expression result unused}} + a = sizeof(int()+1); + a = sizeof(int(1)); + typeof(int()+1) a2; // expected-error {{extension used}} + (int(1)); // expected-warning {{expression result unused}} + + // type-id + (int())1; // expected-error {{C-style cast from 'int' to 'int ()' is not allowed}} + + // Declarations. + int fd(T(a)); // expected-warning {{parentheses were disambiguated as a function declarator}} + T(*d)(int(p)); // expected-warning {{parentheses were disambiguated as a function declarator}} expected-note {{previous definition is here}} + typedef T(*td)(int(p)); + extern T(*tp)(int(p)); + T d3(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}} + T d3v(void); + typedef T d3t(); + extern T f3(); + __typeof(*T()) f4(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}} + typedef void *V; + __typeof(*V()) f5(); + T multi1, + multi2(); // expected-warning {{empty parentheses interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}} + T(d)[5]; // expected-error {{redefinition of 'd'}} + typeof(int[])(f) = { 1, 2 }; // expected-error {{extension used}} + void(b)(int); + int(d2) __attribute__(()); + if (int(a)=1) {} + int(d3(int())); +} + +struct RAII { + RAII(); + ~RAII(); +}; + +void func(); +namespace N { + struct S; + + void emptyParens() { + RAII raii(); // expected-warning {{function declaration}} expected-note {{remove parentheses to declare a variable}} + int a, b, c, d, e, // expected-note {{change this ',' to a ';' to call 'func'}} + func(); // expected-warning {{function declaration}} expected-note {{replace parentheses with an initializer}} + + S s(); // expected-warning {{function declaration}} + } +} + +class C { }; +void fn(int(C)) { } // void fn(int(*fp)(C c)) { } expected-note{{candidate function}} + // not: void fn(int C); +int g(C); + +void foo() { + fn(1); // expected-error {{no matching function}} + fn(g); // OK +} diff --git a/clang/test/SemaCXX/decl-init-ref.cpp b/clang/test/SemaCXX/decl-init-ref.cpp new file mode 100644 index 0000000..4c635c1 --- /dev/null +++ b/clang/test/SemaCXX/decl-init-ref.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +struct A {}; + +struct BASE { + operator A(); // expected-note {{candidate function}} +}; + +struct BASE1 { + operator A(); // expected-note {{candidate function}} +}; + +class B : public BASE , public BASE1 +{ + public: + B(); +} b; + +extern B f(); + +const int& ri = (void)0; // expected-error {{reference to type 'const int' could not bind to an rvalue of type 'void'}} + +int main() { + const A& rca = f(); // expected-error {{reference initialization of type 'const A &' with initializer of type 'B' is ambiguous}} + A& ra = f(); // expected-error {{non-const lvalue reference to type 'A' cannot bind to a temporary of type 'B'}} +} + +struct PR6139 { A (&x)[1]; }; +PR6139 x = {{A()}}; // expected-error{{non-const lvalue reference to type 'A [1]' cannot bind to a temporary of type 'A'}} diff --git a/clang/test/SemaCXX/decltype-98.cpp b/clang/test/SemaCXX/decltype-98.cpp new file mode 100644 index 0000000..db52565 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/decltype-crash.cpp b/clang/test/SemaCXX/decltype-crash.cpp new file mode 100644 index 0000000..002bd4c --- /dev/null +++ b/clang/test/SemaCXX/decltype-crash.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s + +int& a(); + +void f() { + decltype(a()) c; // expected-warning {{'decltype' is a keyword in C++11}} expected-error {{use of undeclared identifier 'decltype'}} +} diff --git a/clang/test/SemaCXX/decltype-overloaded-functions.cpp b/clang/test/SemaCXX/decltype-overloaded-functions.cpp new file mode 100644 index 0000000..b0a43a9 --- /dev/null +++ b/clang/test/SemaCXX/decltype-overloaded-functions.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +void f(); // expected-note{{possible target for call}} +void f(int); // expected-note{{possible target for call}} +decltype(f) a; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{variable has incomplete type 'decltype(f())' (aka 'void')}} + +template<typename T> struct S { + decltype(T::f) * f; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} expected-error {{call to non-static member function without an object argument}} +}; + +struct K { + void f(); // expected-note{{possible target for call}} + void f(int); // expected-note{{possible target for call}} +}; +S<K> b; // expected-note{{in instantiation of template class 'S<K>' requested here}} diff --git a/clang/test/SemaCXX/decltype-pr4444.cpp b/clang/test/SemaCXX/decltype-pr4444.cpp new file mode 100644 index 0000000..2f95075 --- /dev/null +++ b/clang/test/SemaCXX/decltype-pr4444.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +template<typename T, T t> +struct TestStruct { + typedef decltype(t+2) sum_type; +}; diff --git a/clang/test/SemaCXX/decltype-pr4448.cpp b/clang/test/SemaCXX/decltype-pr4448.cpp new file mode 100644 index 0000000..9d33ce7 --- /dev/null +++ b/clang/test/SemaCXX/decltype-pr4448.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +template< typename T, T t, decltype(t+2) v > +struct Convoluted {}; + +int test_array[5]; + +Convoluted< int *, test_array, nullptr > tarray; diff --git a/clang/test/SemaCXX/decltype-this.cpp b/clang/test/SemaCXX/decltype-this.cpp new file mode 100644 index 0000000..a13416f --- /dev/null +++ b/clang/test/SemaCXX/decltype-this.cpp @@ -0,0 +1,16 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +template<typename T, typename U> struct is_same { + static const bool value = false; +}; + +template<typename T> struct is_same<T, T> { + static const bool value = true; +}; + +struct S { + void f() { static_assert(is_same<decltype(this), S*>::value, ""); } + void g() const { static_assert(is_same<decltype(this), const S*>::value, ""); } + void h() volatile { static_assert(is_same<decltype(this), volatile S*>::value, ""); } + void i() const volatile { static_assert(is_same<decltype(this), const volatile S*>::value, ""); } +}; diff --git a/clang/test/SemaCXX/decltype.cpp b/clang/test/SemaCXX/decltype.cpp new file mode 100644 index 0000000..a1200e0 --- /dev/null +++ b/clang/test/SemaCXX/decltype.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +// PR5290 +int const f0(); +void f0_test() { + decltype(0, f0()) i = 0; + i = 0; +} + +struct A { int a[1]; A() { } }; +typedef A const AC; +int &f1(int*); +float &f2(int const*); + +void test_f2() { + float &fr = f2(AC().a); +} + +namespace pr10154 { + class A{ + A(decltype(nullptr) param); + }; +} + +template<typename T> struct S {}; +template<typename T> auto f(T t) -> decltype(S<int>(t)) { + using U = decltype(S<int>(t)); + using U = S<int>; + return S<int>(t); +} diff --git a/clang/test/SemaCXX/default-arg-special-member.cpp b/clang/test/SemaCXX/default-arg-special-member.cpp new file mode 100644 index 0000000..8402d38 --- /dev/null +++ b/clang/test/SemaCXX/default-arg-special-member.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -Wno-default-arg-special-member -Werror -fsyntax-only %s + +class foo { + foo(foo&, int); // expected-note {{was not a special member function}} + foo(int); // expected-note {{was not a special member function}} + foo(const foo&); // expected-note {{was a copy constructor}} +}; + +foo::foo(foo&, int = 0) { } // expected-warning {{makes this constructor a copy constructor}} +foo::foo(int = 0) { } // expected-warning {{makes this constructor a default constructor}} +foo::foo(const foo& = 0) { } //expected-warning {{makes this constructor a default constructor}} diff --git a/clang/test/SemaCXX/default-argument-temporaries.cpp b/clang/test/SemaCXX/default-argument-temporaries.cpp new file mode 100644 index 0000000..3ab7bf4 --- /dev/null +++ b/clang/test/SemaCXX/default-argument-temporaries.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct B { B(void* = 0); }; + +struct A { + A(B b = B()) { } +}; + +void f() { + (void)B(); + (void)A(); +} diff --git a/clang/test/SemaCXX/default-assignment-operator.cpp b/clang/test/SemaCXX/default-assignment-operator.cpp new file mode 100644 index 0000000..668c600 --- /dev/null +++ b/clang/test/SemaCXX/default-assignment-operator.cpp @@ -0,0 +1,118 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class Base { // expected-error {{cannot define the implicit default assignment operator for 'Base', because non-static reference member 'ref' can't use default assignment operator}} \ + // expected-warning{{class 'Base' does not declare any constructor to initialize its non-modifiable members}} + int &ref; // expected-note {{declared here}} \ + // expected-note{{reference member 'ref' will never be initialized}} +}; + +class X : Base { // // expected-error {{cannot define the implicit default assignment operator for 'X', because non-static const member 'cint' can't use default assignment operator}} \ +// expected-note{{assignment operator for 'Base' first required here}} +public: + X(); + const int cint; // expected-note {{declared here}} +}; + +struct Y : X { + Y(); + Y& operator=(const Y&); + Y& operator=(volatile Y&); + Y& operator=(const volatile Y&); + Y& operator=(Y&); +}; + +class Z : Y {}; + +Z z1; +Z z2; + +// Test1 +void f(X x, const X cx) { + x = cx; // expected-note{{assignment operator for 'X' first required here}} + x = cx; + z1 = z2; +} + +// Test2 +class T {}; +T t1; +T t2; + +void g() { + t1 = t2; +} + +// Test3 +class V { +public: + V(); + V &operator = (V &b); +}; + +class W : V {}; +W w1, w2; + +void h() { + w1 = w2; +} + +// Test4 + +class B1 { +public: + B1(); + B1 &operator = (B1 b); +}; + +class D1 : B1 {}; +D1 d1, d2; + +void i() { + d1 = d2; +} + +// Test5 + +class E1 { // expected-error{{cannot define the implicit default assignment operator for 'E1', because non-static const member 'a' can't use default assignment operator}} + +public: + const int a; // expected-note{{declared here}} + E1() : a(0) {} + +}; + +E1 e1, e2; + +void j() { + e1 = e2; // expected-note{{assignment operator for 'E1' first required here}} +} + +namespace ProtectedCheck { + struct X { + protected: + X &operator=(const X&); // expected-note{{declared protected here}} + }; + + struct Y : public X { }; + + void f(Y y) { y = y; } + + struct Z { // expected-error{{'operator=' is a protected member of 'ProtectedCheck::X'}} + X x; + }; + + void f(Z z) { z = z; } // expected-note{{implicit default copy assignment operator}} + +} + +namespace MultiplePaths { + struct X0 { + X0 &operator=(const X0&); + }; + + struct X1 : public virtual X0 { }; + + struct X2 : X0, X1 { }; + + void f(X2 x2) { x2 = x2; } +} diff --git a/clang/test/SemaCXX/default-constructor-initializers.cpp b/clang/test/SemaCXX/default-constructor-initializers.cpp new file mode 100644 index 0000000..e783f49 --- /dev/null +++ b/clang/test/SemaCXX/default-constructor-initializers.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct X1 { // has no implicit default constructor + X1(int); +}; + +struct X2 : X1 { // expected-note 2 {{'X2' declared here}} + X2(int); +}; + +struct X3 : public X2 { // expected-error {{implicit default constructor for 'X3' must explicitly initialize the base class 'X2' which does not have a default constructor}} +}; +X3 x3; // expected-note {{first required here}} + + +struct X4 { // expected-error {{must explicitly initialize the member 'x2'}} \ + // expected-error {{must explicitly initialize the reference member 'rx2'}} + X2 x2; // expected-note {{member is declared here}} + X2 & rx2; // expected-note {{declared here}} +}; + +X4 x4; // expected-note {{first required here}} + + +struct Y1 { // has no implicit default constructor + Y1(int); +}; + +struct Y2 : Y1 { + Y2(int); + Y2(); +}; + +struct Y3 : public Y2 { +}; +Y3 y3; + +struct Y4 { + Y2 y2; +}; + +Y4 y4; + +// More tests + +struct Z1 { // expected-error {{must explicitly initialize the reference member 'z'}} \ + // expected-error {{must explicitly initialize the const member 'c1'}} + int& z; // expected-note {{declared here}} + const int c1; // expected-note {{declared here}} + volatile int v1; +}; + +// Test default initialization which *requires* a constructor call for non-POD. +Z1 z1; // expected-note {{first required here}} + +// Ensure that value initialization doesn't use trivial implicit constructors. +namespace PR7948 { + // Note that this is also non-POD to ensure we don't just special case PODs. + struct S { const int x; ~S(); }; + const S arr[2] = { { 42 } }; +} + +// This is valid +union U { + const int i; + float f; +}; +U u; diff --git a/clang/test/SemaCXX/default1.cpp b/clang/test/SemaCXX/default1.cpp new file mode 100644 index 0000000..ae6ef97 --- /dev/null +++ b/clang/test/SemaCXX/default1.cpp @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void f(int i); +void f(int i = 0); // expected-note {{previous definition is here}} +void f(int i = 17); // expected-error {{redefinition of default argument}} + + +void g(int i, int j, int k = 3); +void g(int i, int j = 2, int k); +void g(int i = 1, int j, int k); + +void h(int i, int j = 2, int k = 3, + int l, // expected-error {{missing default argument on parameter 'l'}} + int, // expected-error {{missing default argument on parameter}} + int n);// expected-error {{missing default argument on parameter 'n'}} + +struct S { } s; +void i(int = s) { } // expected-error {{no viable conversion}} \ +// expected-note{{passing argument to parameter here}} + +struct X { + X(int); +}; + +void j(X x = 17); + +struct Y { // expected-note 2{{candidate}} + explicit Y(int); +}; + +void k(Y y = 17); // expected-error{{no viable conversion}} \ +// expected-note{{passing argument to parameter 'y' here}} + +void kk(Y = 17); // expected-error{{no viable conversion}} \ +// expected-note{{passing argument to parameter here}} + +int l () { + int m(int i, int j, int k = 3); + if (1) + { + int m(int i, int j = 2, int k = 4); + m(8); + } + return 0; +} + +int i () { + void j (int f = 4); + { + void j (int f); // expected-note{{'j' declared here}} + j(); // expected-error{{too few arguments to function call, expected 1, have 0}} + } +} diff --git a/clang/test/SemaCXX/default2.cpp b/clang/test/SemaCXX/default2.cpp new file mode 100644 index 0000000..1626044 --- /dev/null +++ b/clang/test/SemaCXX/default2.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f(int i, int j, int k = 3); +void f(int i, int j, int k); +void f(int i, int j = 2, int k); +void f(int i, int j, int k); +void f(int i = 1, int j, int k); +void f(int i, int j, int k); + +void i() +{ + f(); + f(0); + f(0, 1); + f(0, 1, 2); +} + + +int f1(int i, // expected-note {{previous declaration is here}} + int i, int j) { // expected-error {{redefinition of parameter 'i'}} + i = 17; + return j; +} + +int x; +void g(int x, int y = x); // expected-error {{default argument references parameter 'x'}} + +void g2(int x, int y, int z = x + y); // expected-error {{default argument references parameter 'x'}} expected-error {{default argument references parameter 'y'}} + +class X { + void f(X* x = this); // expected-error{{invalid use of 'this' outside of a non-static member function}} + + void g() { + int f(X* x = this); // expected-error{{default argument references 'this'}} + } +}; + +// C++ [dcl.fct.default]p6 +class C { + static int x; + void f(int i = 3); // expected-note{{previous definition is here}} + void g(int i, int j = x); + + void h(); +}; +void C::f(int i = 3) // expected-error{{redefinition of default argument}} +{ } + +void C::g(int i = 88, int j) {} + +void C::h() { + g(); // okay +} + +// C++ [dcl.fct.default]p9 +struct Y { + int a; + int mem1(int i = a); // expected-error{{invalid use of non-static data member 'a'}} + int mem2(int i = b); // OK; use Y::b + int mem3(int i); + int mem4(int i); + + struct Nested { + int mem5(int i = b, // OK; use Y::b + int j = c, // OK; use Y::Nested::c + int k = j, // expected-error{{default argument references parameter 'j'}} + int l = a, // expected-error{{invalid use of non-static data member 'a'}} + Nested* self = this, // expected-error{{invalid use of 'this' outside of a non-static member function}} + int m); // expected-error{{missing default argument on parameter 'm'}} + static int c; + Nested(int i = 42); + }; + + int mem7(Nested n = Nested()); + + static int b; +}; + +int Y::mem3(int i = b) { return i; } // OK; use X::b + +int Y::mem4(int i = a) // expected-error{{invalid use of non-static data member 'a'}} +{ return i; } + + +// Try to verify that default arguments interact properly with copy +// constructors. +class Z { +public: + Z(Z&, int i = 17); // expected-note 3 {{candidate constructor}} + + void f(Z& z) { + Z z2; // expected-error{{no matching constructor for initialization}} + Z z3(z); + } + + void test_Z(const Z& z) { + Z z2(z); // expected-error{{no matching constructor for initialization of 'Z'}} + } +}; + +void test_Z(const Z& z) { + Z z2(z); // expected-error{{no matching constructor for initialization of 'Z'}} +} + +struct ZZ { + static ZZ g(int = 17); + + void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}} \ + // expected-note{{passing argument to parameter 'z' here}} + + ZZ(ZZ&, int = 17); // expected-note{{candidate constructor}} +}; + +// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325 +class C2 { + static void g(int = f()); // expected-error{{use of default argument to function 'f' that is declared later in class 'C2'}} + static int f(int = 10); // expected-note{{default argument declared here}} +}; + +// Make sure we actually parse the default argument for an inline definition +class XX { + void A(int length = -1 ) { } + void B() { A(); } +}; diff --git a/clang/test/SemaCXX/defaulted-ctor-loop.cpp b/clang/test/SemaCXX/defaulted-ctor-loop.cpp new file mode 100644 index 0000000..6416336 --- /dev/null +++ b/clang/test/SemaCXX/defaulted-ctor-loop.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// WARNING: This test may recurse infinitely if failing. + +struct foo; +struct bar { + bar(foo&); +}; +struct foo { + bar b; + foo() + : b(b) // expected-warning{{field is uninitialized}} + {} +}; diff --git a/clang/test/SemaCXX/defaulted-private-dtor.cpp b/clang/test/SemaCXX/defaulted-private-dtor.cpp new file mode 100644 index 0000000..e6f9555 --- /dev/null +++ b/clang/test/SemaCXX/defaulted-private-dtor.cpp @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -verify -std=c++11 %s -fcxx-exceptions + +class BadDtor { + // A private, but nonetheless trivial, destructor. + ~BadDtor() = default; // expected-note 9{{here}} + friend class K; +}; +void f() { + BadDtor *p = new BadDtor[3]; // expected-error {{private destructor}} + delete [] p; // expected-error {{private destructor}} + const BadDtor &dd2 = BadDtor(); // expected-error {{private destructor}} + BadDtor dd; // expected-error {{private destructor}} + throw dd; // expected-error {{private destructor}} +} +struct V { + V(); + BadDtor bd; // expected-note {{inaccessible destructor}} +}; +V v; // expected-error {{deleted function}} +struct W : BadDtor { // expected-note {{inaccessible destructor}} + W(); +}; +W w; // expected-error {{deleted function}} +struct X : BadDtor { // expected-error {{private destructor}} + ~X() {} +}; +struct Y { + BadDtor dd; // expected-error {{private destructor}} + ~Y() {} +}; +struct Z : virtual BadDtor { // expected-error {{private destructor}} + ~Z() {} +}; +BadDtor dd; // expected-error {{private destructor}} + +class K : BadDtor { + void f() { + BadDtor *p = new BadDtor[3]; + delete [] p; + const BadDtor &dd2 = BadDtor(); + BadDtor dd; + throw dd; + + { + BadDtor x; + goto dont_call_dtor; + } +dont_call_dtor: + ; + } + struct Z : virtual BadDtor { + ~Z() {} + }; + BadDtor dd; + ~K(); +}; diff --git a/clang/test/SemaCXX/delete.cpp b/clang/test/SemaCXX/delete.cpp new file mode 100644 index 0000000..5824fac --- /dev/null +++ b/clang/test/SemaCXX/delete.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: cp %s %t +// RUN: %clang_cc1 -fixit -x c++ %t +// RUN: %clang_cc1 -E -o - %t | FileCheck %s + +void f(int a[10][20]) { + // CHECK: delete[] a; + delete a; // expected-warning {{'delete' applied to a pointer-to-array type}} +} diff --git a/clang/test/SemaCXX/deleted-function.cpp b/clang/test/SemaCXX/deleted-function.cpp new file mode 100644 index 0000000..d13fd0e --- /dev/null +++ b/clang/test/SemaCXX/deleted-function.cpp @@ -0,0 +1,57 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -fcxx-exceptions %s + +int i = delete; // expected-error {{only functions can have deleted definitions}} + +void fn() = delete; // expected-note {{candidate function has been explicitly deleted}} + +void fn2(); // expected-note {{previous declaration is here}} +void fn2() = delete; // expected-error {{deleted definition must be first declaration}} + +void fn3() = delete; // expected-note {{previous definition is here}} +void fn3() { // expected-error {{redefinition}} +} + +void ov(int) {} // expected-note {{candidate function}} +void ov(double) = delete; // expected-note {{candidate function has been explicitly deleted}} + +struct WithDel { + WithDel() = delete; // expected-note {{function has been explicitly marked deleted here}} + void fn() = delete; // expected-note {{function has been explicitly marked deleted here}} + operator int() = delete; // expected-note {{function has been explicitly marked deleted here}} + void operator +(int) = delete; + + int i = delete; // expected-error {{only functions can have deleted definitions}} +}; + +void test() { + fn(); // expected-error {{call to deleted function 'fn'}} + ov(1); + ov(1.0); // expected-error {{call to deleted function 'ov'}} + + WithDel dd; // expected-error {{call to deleted constructor of 'WithDel'}} + WithDel *d = 0; + d->fn(); // expected-error {{attempt to use a deleted function}} + int i = *d; // expected-error {{invokes a deleted function}} +} + +struct DelDtor { + ~DelDtor() = delete; // expected-note 9{{here}} +}; +void f() { + DelDtor *p = new DelDtor[3]; // expected-error {{attempt to use a deleted function}} + delete [] p; // expected-error {{attempt to use a deleted function}} + const DelDtor &dd2 = DelDtor(); // expected-error {{attempt to use a deleted function}} + DelDtor dd; // expected-error {{attempt to use a deleted function}} + throw dd; // expected-error {{attempt to use a deleted function}} +} +struct X : DelDtor { + ~X() {} // expected-error {{attempt to use a deleted function}} +}; +struct Y { + DelDtor dd; + ~Y() {} // expected-error {{attempt to use a deleted function}} +}; +struct Z : virtual DelDtor { + ~Z() {} // expected-error {{attempt to use a deleted function}} +}; +DelDtor dd; // expected-error {{attempt to use a deleted function}} diff --git a/clang/test/SemaCXX/deleted-operator.cpp b/clang/test/SemaCXX/deleted-operator.cpp new file mode 100644 index 0000000..0e0282a --- /dev/null +++ b/clang/test/SemaCXX/deleted-operator.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +struct PR10757 { + bool operator~() = delete; // expected-note {{explicitly deleted}} + bool operator==(const PR10757&) = delete; // expected-note {{explicitly deleted}} + operator float(); +}; +int PR10757f() { + PR10757 a1; + // FIXME: We get a ridiculous number of "built-in candidate" notes here... + if(~a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 6 {{built-in candidate}} + if(a1==a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 81 {{built-in candidate}} +} + +struct DelOpDel { + virtual ~DelOpDel() {} // expected-error {{deleted function}} + void operator delete(void*) = delete; // expected-note {{deleted here}} +}; diff --git a/clang/test/SemaCXX/dependent-auto.cpp b/clang/test/SemaCXX/dependent-auto.cpp new file mode 100644 index 0000000..6d37f7a --- /dev/null +++ b/clang/test/SemaCXX/dependent-auto.cpp @@ -0,0 +1,59 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +template<typename T> +struct only { + only(T); + template<typename U> only(U) = delete; // expected-note {{here}} +}; + +template<typename ...T> +void f(T ...t) { + auto x(t...); // expected-error {{is empty}} expected-error {{contains multiple expressions}} + only<int> check = x; +} + +void g() { + f(); // expected-note {{here}} + f(0); + f(0, 1); // expected-note {{here}} +} + + +template<typename T> +bool h(T t) { + auto a = t; + decltype(a) b; + a = a + b; + + auto p = new auto(t); + + only<double*> test = p; // expected-error {{conversion function from 'char *' to 'only<double *>'}} + return p; +} + +bool b = h('x'); // expected-note {{here}} + +// PR 9276 - Make sure we check auto types deduce the same +// in the case of a dependent initializer +namespace PR9276 { + template<typename T> + void f() { + auto i = T(), j = 0; // expected-error {{deduced as 'long' in declaration of 'i' and deduced as 'int' in declaration of 'j'}} + } + + void g() { + f<long>(); // expected-note {{here}} + f<int>(); + } +} + +namespace NoRepeatedDiagnostic { + template<typename T> + void f() { + auto a = 0, b = 0.0, c = T(); // expected-error {{deduced as 'int' in declaration of 'a' and deduced as 'double' in declaration of 'b'}} + } + // We've already diagnosed an issue. No extra diagnostics is needed for these. + template void f<int>(); + template void f<double>(); + template void f<char>(); +} diff --git a/clang/test/SemaCXX/dependent-noexcept-unevaluated.cpp b/clang/test/SemaCXX/dependent-noexcept-unevaluated.cpp new file mode 100644 index 0000000..0a3a8bb --- /dev/null +++ b/clang/test/SemaCXX/dependent-noexcept-unevaluated.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 %s + +template <class T> +T&& +declval() noexcept; + +template <class T> +struct some_trait +{ + static const bool value = false; +}; + +template <class T> +void swap(T& x, T& y) noexcept(some_trait<T>::value) +{ + T tmp(static_cast<T&&>(x)); + x = static_cast<T&&>(y); + y = static_cast<T&&>(tmp); +} + +template <class T, unsigned N> +struct array +{ + T data[N]; + + void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>()))); +}; + +struct DefaultOnly +{ + DefaultOnly() = default; + DefaultOnly(const DefaultOnly&) = delete; + DefaultOnly& operator=(const DefaultOnly&) = delete; + ~DefaultOnly() = default; +}; + +int main() +{ + array<DefaultOnly, 1> a, b; +} diff --git a/clang/test/SemaCXX/dependent-types.cpp b/clang/test/SemaCXX/dependent-types.cpp new file mode 100644 index 0000000..13ed72f --- /dev/null +++ b/clang/test/SemaCXX/dependent-types.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++11 %s + +template<typename T> using U = int &; + +template<typename T, int Size> void f() { + T x1; + T* x2; + T& x3; // expected-error{{declaration of reference variable 'x3' requires an initializer}} + T x4[]; // expected-error{{needs an explicit size or an initializer}} + T x5[Size]; + int x6[Size]; + U<T> x7; // expected-error{{declaration of reference variable 'x7' requires an initializer}} +} diff --git a/clang/test/SemaCXX/derived-to-base-ambig.cpp b/clang/test/SemaCXX/derived-to-base-ambig.cpp new file mode 100644 index 0000000..129ec79 --- /dev/null +++ b/clang/test/SemaCXX/derived-to-base-ambig.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class A { }; +class B : public A { }; +class C : public A { }; +class D : public B, public C { }; + +void f(D* d) { + A* a; + a = d; // expected-error{{ambiguous conversion from derived class 'D' to base class 'A':}} expected-error{{assigning to 'A *' from incompatible type 'D *'}} +} + +class Object2 { }; +class A2 : public Object2 { }; +class B2 : public virtual A2 { }; +class C2 : virtual public A2 { }; +class D2 : public B2, public C2 { }; +class E2 : public D2, public C2, public virtual A2 { }; +class F2 : public E2, public A2 { }; + +void g(E2* e2, F2* f2) { + Object2* o2; + o2 = e2; + o2 = f2; // expected-error{{ambiguous conversion from derived class 'F2' to base class 'Object2':}} expected-error{{assigning to 'Object2 *' from incompatible type 'F2 *'}} +} + +// Test that ambiguous/inaccessibility checking does not trigger too +// early, because it should not apply during overload resolution. +void overload_okay(Object2*); +void overload_okay(E2*); + +void overload_call(F2* f2) { + overload_okay(f2); +} diff --git a/clang/test/SemaCXX/destructor.cpp b/clang/test/SemaCXX/destructor.cpp new file mode 100644 index 0000000..f3c6ab0 --- /dev/null +++ b/clang/test/SemaCXX/destructor.cpp @@ -0,0 +1,365 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -verify %s +class A { +public: + ~A(); +}; + +class B { +public: + ~B() { } +}; + +class C { +public: + (~C)() { } +}; + +struct D { + static void ~D(int, ...) const { } // \ + // expected-error{{static member function cannot have 'const' qualifier}} \ + // expected-error{{destructor cannot be declared 'static'}} \ + // expected-error{{destructor cannot have any parameters}} \ + // expected-error{{destructor cannot be variadic}} \ + // expected-error{{destructor cannot have a return type}} \ + // expected-error{{'const' qualifier is not allowed on a destructor}} +}; + +struct D2 { + void ~D2() { } // \ + // expected-error{{destructor cannot have a return type}} +}; + + +struct E; + +typedef E E_typedef; +struct E { + ~E_typedef(); // expected-error{{destructor cannot be declared using a typedef 'E_typedef' (aka 'E') of the class name}} +}; + +struct F { + (~F)(); // expected-note {{previous declaration is here}} + ~F(); // expected-error {{destructor cannot be redeclared}} +}; + +~; // expected-error {{expected a class name after '~' to name a destructor}} +~undef(); // expected-error {{expected the class name after '~' to name a destructor}} +~operator+(int, int); // expected-error {{expected a class name after '~' to name a destructor}} +~F(){} // expected-error {{destructor must be a non-static member function}} + +struct G { + ~G(); +}; + +G::~G() { } + +// <rdar://problem/6841210> +struct H { + ~H(void) { } +}; + +struct X {}; + +struct Y { + ~X(); // expected-error {{expected the class name after '~' to name the enclosing class}} +}; + +namespace PR6421 { + class T; // expected-note{{forward declaration}} + + class QGenericArgument // expected-note{{declared here}} + { + template<typename U> + void foo(T t) // expected-error{{variable has incomplete type}} + { } + + void disconnect() + { + T* t; + bob<QGenericArgument>(t); // expected-error{{undeclared identifier 'bob'}} \ + // expected-error{{does not refer to a value}} + } + }; +} + +namespace PR6709 { + template<class T> class X { T v; ~X() { ++*v; } }; + void a(X<int> x) {} +} + +struct X0 { virtual ~X0() throw(); }; +struct X1 : public X0 { }; + +// Make sure we instantiate operator deletes when building a virtual +// destructor. +namespace test6 { + template <class T> class A { + public: + void *operator new(__SIZE_TYPE__); + void operator delete(void *p) { + T::deleteIt(p); // expected-error {{type 'int' cannot be used prior to '::'}} + } + + virtual ~A() {} + }; + + class B : A<int> { B(); }; // expected-note {{in instantiation of member function 'test6::A<int>::operator delete' requested here}} + B::B() {} +} + +// Make sure classes are marked invalid when they have invalid +// members. This avoids a crash-on-invalid. +namespace test7 { + struct A { + ~A() const; // expected-error {{'const' qualifier is not allowed on a destructor}} + }; + struct B : A {}; + + void test() { + B *b; + b->~B(); + } +} + +namespace nonvirtualdtor { +struct S1 { // expected-warning {{has virtual functions but non-virtual destructor}} + virtual void m(); +}; + +struct S2 { + ~S2(); // expected-warning {{has virtual functions but non-virtual destructor}} + virtual void m(); +}; + +struct S3 : public S1 { // expected-warning {{has virtual functions but non-virtual destructor}} + virtual void m(); +}; + +struct S4 : public S2 { // expected-warning {{has virtual functions but non-virtual destructor}} + virtual void m(); +}; + +struct B { + virtual ~B(); + virtual void m(); +}; + +struct S5 : public B { + virtual void m(); +}; + +struct S6 { + virtual void m(); +private: + ~S6(); +}; + +struct S7 { + virtual void m(); +protected: + ~S7(); +}; + +template<class T> class TS : public B { + virtual void m(); +}; + +TS<int> baz; + +template<class T> class TS2 { // expected-warning {{'nonvirtualdtor::TS2<int>' has virtual functions but non-virtual destructor}} + virtual void m(); +}; + +TS2<int> foo; // expected-note {{instantiation}} +} + +namespace dnvd { // delete-non-virtual-dtor warning +struct NP {}; + +struct B { // expected-warning {{has virtual functions but non-virtual destructor}} + virtual void foo(); +}; + +struct D: B {}; // expected-warning {{has virtual functions but non-virtual destructor}} + +struct F final: B {}; // expected-warning {{has virtual functions but non-virtual destructor}} + +struct VB { + virtual void foo(); + virtual ~VB(); +}; + +struct VD: VB {}; + +struct VF final: VB {}; + +template <typename T> +class simple_ptr { +public: + simple_ptr(T* t): _ptr(t) {} + ~simple_ptr() { delete _ptr; } // \ + // expected-warning {{delete called on 'dnvd::B' that has virtual functions but non-virtual destructor}} \ + // expected-warning {{delete called on 'dnvd::D' that has virtual functions but non-virtual destructor}} + T& operator*() const { return *_ptr; } +private: + T* _ptr; +}; + +template <typename T> +class simple_ptr2 { +public: + simple_ptr2(T* t): _ptr(t) {} + ~simple_ptr2() { delete _ptr; } // expected-warning {{delete called on 'dnvd::B' that has virtual functions but non-virtual destructor}} + T& operator*() const { return *_ptr; } +private: + T* _ptr; +}; + +void use(B&); +void use(VB&); + +void nowarnstack() { + B b; use(b); + D d; use(d); + F f; use(f); + VB vb; use(vb); + VD vd; use(vd); + VF vf; use(vf); +} + +void nowarnnonpoly() { + { + NP* np = new NP(); + delete np; + } + { + NP* np = new NP[4]; + delete[] np; + } +} + +void nowarnarray() { + { + B* b = new B[4]; + delete[] b; + } + { + D* d = new D[4]; + delete[] d; + } + { + VB* vb = new VB[4]; + delete[] vb; + } + { + VD* vd = new VD[4]; + delete[] vd; + } +} + +template <typename T> +void nowarntemplate() { + { + T* t = new T(); + delete t; + } + { + T* t = new T[4]; + delete[] t; + } +} + +void nowarn0() { + { + F* f = new F(); + delete f; + } + { + VB* vb = new VB(); + delete vb; + } + { + VB* vb = new VD(); + delete vb; + } + { + VD* vd = new VD(); + delete vd; + } + { + VF* vf = new VF(); + delete vf; + } +} + +void warn0() { + { + B* b = new B(); + delete b; // expected-warning {{delete called on 'dnvd::B' that has virtual functions but non-virtual destructor}} + } + { + B* b = new D(); + delete b; // expected-warning {{delete called on 'dnvd::B' that has virtual functions but non-virtual destructor}} + } + { + D* d = new D(); + delete d; // expected-warning {{delete called on 'dnvd::D' that has virtual functions but non-virtual destructor}} + } +} + +void nowarn1() { + { + simple_ptr<F> f(new F()); + use(*f); + } + { + simple_ptr<VB> vb(new VB()); + use(*vb); + } + { + simple_ptr<VB> vb(new VD()); + use(*vb); + } + { + simple_ptr<VD> vd(new VD()); + use(*vd); + } + { + simple_ptr<VF> vf(new VF()); + use(*vf); + } +} + +void warn1() { + { + simple_ptr<B> b(new B()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr<dnvd::B>::~simple_ptr' requested here}} + use(*b); + } + { + simple_ptr2<B> b(new D()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr2<dnvd::B>::~simple_ptr2' requested here}} + use(*b); + } + { + simple_ptr<D> d(new D()); // expected-note {{in instantiation of member function 'dnvd::simple_ptr<dnvd::D>::~simple_ptr' requested here}} + use(*d); + } +} +} + +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/clang/test/SemaCXX/direct-initializer.cpp b/clang/test/SemaCXX/direct-initializer.cpp new file mode 100644 index 0000000..a7899c7 --- /dev/null +++ b/clang/test/SemaCXX/direct-initializer.cpp @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int x(1); +int (x2)(1); + +void f() { + int x(1); + int (x2)(1); + for (int x(1);;) {} +} + +class Y { +public: explicit Y(float); +}; + +class X { // expected-note{{candidate constructor (the implicit copy constructor)}} +public: + explicit X(int); // expected-note{{candidate constructor}} + X(float, float, float); // expected-note{{candidate constructor}} + X(float, Y); // expected-note{{candidate constructor}} +}; + +class Z { // expected-note{{candidate constructor (the implicit copy constructor)}} +public: + Z(int); // expected-note{{candidate constructor}} +}; + +void g() { + X x1(5); + X x2(1.0, 3, 4.2); + X x3(1.0, 1.0); // expected-error{{no matching constructor for initialization of 'X'}} + Y y(1.0); + X x4(3.14, y); + + Z z; // expected-error{{no matching constructor for initialization of 'Z'}} +} + +struct Base { + operator int*() const; +}; + +struct Derived : Base { + operator int*(); // expected-note {{candidate function}} +}; + +void foo(const Derived cd, Derived d) { + int *pi = cd; // expected-error {{no viable conversion from 'const Derived' to 'int *'}} + int *ppi = d; + +} diff --git a/clang/test/SemaCXX/discrim-union.cpp b/clang/test/SemaCXX/discrim-union.cpp new file mode 100644 index 0000000..15c9a22 --- /dev/null +++ b/clang/test/SemaCXX/discrim-union.cpp @@ -0,0 +1,118 @@ +// RUN: %clang_cc1 -std=c++11 %s -fsyntax-only -fcxx-exceptions + +template<typename T> struct remove_reference { typedef T type; }; +template<typename T> struct remove_reference<T&> { typedef T type; }; +template<typename T> struct remove_reference<T&&> { typedef T type; }; + +template<typename T> constexpr T &&forward(typename remove_reference<T>::type &t) noexcept { return static_cast<T&&>(t); } +template<typename T> constexpr T &&forward(typename remove_reference<T>::type &&t) noexcept { return static_cast<T&&>(t); } +template<typename T> constexpr typename remove_reference<T>::type &&move(T &&t) noexcept { return static_cast<typename remove_reference<T>::type&&>(t); } + +template<typename T> T declval() noexcept; + +namespace detail { + template<unsigned N> struct select {}; // : integral_constant<unsigned, N> {}; + template<typename T> struct type {}; + + template<typename...T> union either_impl; + + template<> union either_impl<> { + void get(...); + void destroy(...) { throw "logic_error"; } + }; + + template<typename T, typename...Ts> union either_impl<T, Ts...> { + private: + T val; + either_impl<Ts...> rest; + typedef either_impl<Ts...> rest_t; + + public: + constexpr either_impl(select<0>, T &&t) : val(move(t)) {} + + template<unsigned N, typename U> + constexpr either_impl(select<N>, U &&u) : rest(select<N-1>(), move(u)) {} + + constexpr static unsigned index(type<T>) { return 0; } + template<typename U> + constexpr static unsigned index(type<U> t) { + return decltype(rest)::index(t) + 1; + } + + void destroy(unsigned elem) { + if (elem) + rest.destroy(elem - 1); + else + val.~T(); + } + + constexpr const T &get(select<0>) { return val; } + template<unsigned N> constexpr const decltype(static_cast<const rest_t&>(rest).get(select<N-1>{})) get(select<N>) { + return rest.get(select<N-1>{}); + } + }; +} + +template<typename T> +struct a { + T value; + template<typename...U> + constexpr a(U &&...u) : value{forward<U>(u)...} {} +}; +template<typename T> using an = a<T>; + +template<typename T, typename U> T throw_(const U &u) { throw u; } + +template<typename...T> +class either { + unsigned elem; + detail::either_impl<T...> impl; + typedef decltype(impl) impl_t; + +public: + template<typename U> + constexpr either(a<U> &&t) : + elem(impl_t::index(detail::type<U>())), + impl(detail::select<impl_t::index(detail::type<U>())>(), move(t.value)) {} + + // Destruction disabled to allow use in a constant expression. + // FIXME: declare a destructor iff any element has a nontrivial destructor + //~either() { impl.destroy(elem); } + + constexpr unsigned index() noexcept { return elem; } + + template<unsigned N> using const_get_result = + decltype(static_cast<const impl_t&>(impl).get(detail::select<N>{})); + + template<unsigned N> + constexpr const_get_result<N> get() { + // Can't just use throw here, since that makes the conditional a prvalue, + // which means we return a reference to a temporary. + return (elem != N ? throw_<const_get_result<N>>("bad_either_get") + : impl.get(detail::select<N>{})); + } + + template<typename U> + constexpr const U &get() { + return get<impl_t::index(detail::type<U>())>(); + } +}; + +typedef either<int, char, double> icd; +constexpr icd icd1 = an<int>(4); +constexpr icd icd2 = a<char>('x'); +constexpr icd icd3 = a<double>(6.5); + +static_assert(icd1.get<int>() == 4, ""); +static_assert(icd2.get<char>() == 'x', ""); +static_assert(icd3.get<double>() == 6.5, ""); + +struct non_triv { + constexpr non_triv() : n(5) {} + int n; +}; +constexpr either<const icd*, non_triv> icd4 = a<const icd*>(&icd2); +constexpr either<const icd*, non_triv> icd5 = a<non_triv>(); + +static_assert(icd4.get<const icd*>()->get<char>() == 'x', ""); +static_assert(icd5.get<non_triv>().n == 5, ""); diff --git a/clang/test/SemaCXX/do-while-scope.cpp b/clang/test/SemaCXX/do-while-scope.cpp new file mode 100644 index 0000000..2602ae1 --- /dev/null +++ b/clang/test/SemaCXX/do-while-scope.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void test() { + int x; + do + int x; + while (1); +} diff --git a/clang/test/SemaCXX/dr1301.cpp b/clang/test/SemaCXX/dr1301.cpp new file mode 100644 index 0000000..ec0db74 --- /dev/null +++ b/clang/test/SemaCXX/dr1301.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s +struct A { // expected-note 2{{candidate}} + A(int); // expected-note {{candidate}} + int n; +}; +int a = A().n; // expected-error {{no matching constructor}} + +struct B { + B() = delete; // expected-note 3{{here}} + int n; +}; +int b = B().n; // expected-error {{call to deleted}} + +struct C { + B b; // expected-note {{deleted default constructor}} +}; +int c = C().b.n; // expected-error {{call to implicitly-deleted default}} + +struct D { + D() = default; // expected-note {{here}} + B b; // expected-note {{'b' has a deleted default constructor}} +}; +int d = D().b.n; // expected-error {{call to implicitly-deleted default}} + +struct E { + E() = default; + int n; +}; +int e = E().n; // ok + +struct F { + F(); + int n; +}; +int f = F().n; // ok + +union G { + F f; // expected-note {{non-trivial default constructor}} +}; +int g = G().f.n; // expected-error {{call to implicitly-deleted default}} + +struct H { + int n; +private: + H(); // expected-note {{here}} +}; +int h = H().n; // expected-error {{private constructor}} + +struct I { + H h; // expected-note {{inaccessible default constructor}} +}; +int i = I().h.n; // expected-error {{call to implicitly-deleted default}} + +struct J { + J(); + virtual int f(); + int n; +}; +int j1 = J().n; // ok +int j2 = J().f(); // ok + +union K { + J j; // expected-note 2{{non-trivial default constructor}} + int m; +}; +int k1 = K().j.n; // expected-error {{call to implicitly-deleted default}} +int k2 = K().j.f(); // expected-error {{call to implicitly-deleted default}} diff --git a/clang/test/SemaCXX/dynamic-cast.cpp b/clang/test/SemaCXX/dynamic-cast.cpp new file mode 100644 index 0000000..b73e8c5 --- /dev/null +++ b/clang/test/SemaCXX/dynamic-cast.cpp @@ -0,0 +1,74 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A {}; +struct B : A {}; +struct C : B {}; + +struct D : private A {}; +struct E : A {}; +struct F : B, E {}; + +struct Incomplete; // expected-note 2 {{forward declaration of 'Incomplete'}} + +struct Poly +{ + virtual void f(); +}; + +struct PolyDerived : Poly +{ +}; + +void basic_bad() +{ + // ptr -> nonptr + (void)dynamic_cast<A>((A*)0); // expected-error {{'A' is not a reference or pointer}} + // nonptr -> ptr + (void)dynamic_cast<A*>(0); // expected-error {{'int' is not a pointer}} + // ptr -> noncls + (void)dynamic_cast<int*>((A*)0); // expected-error {{'int' is not a class}} + // noncls -> ptr + (void)dynamic_cast<A*>((int*)0); // expected-error {{'int' is not a class}} + // ref -> noncls + (void)dynamic_cast<int&>(*((A*)0)); // expected-error {{'int' is not a class}} + // noncls -> ref + (void)dynamic_cast<A&>(*((int*)0)); // expected-error {{'int' is not a class}} + // ptr -> incomplete + (void)dynamic_cast<Incomplete*>((A*)0); // expected-error {{'Incomplete' is an incomplete type}} + // incomplete -> ptr + (void)dynamic_cast<A*>((Incomplete*)0); // expected-error {{'Incomplete' is an incomplete type}} +} + +void same() +{ + (void)dynamic_cast<A*>((A*)0); + (void)dynamic_cast<A&>(*((A*)0)); +} + +void up() +{ + (void)dynamic_cast<A*>((B*)0); + (void)dynamic_cast<A&>(*((B*)0)); + (void)dynamic_cast<A*>((C*)0); + (void)dynamic_cast<A&>(*((C*)0)); + + // Inaccessible + //(void)dynamic_cast<A*>((D*)0); + //(void)dynamic_cast<A&>(*((D*)0)); + + // Ambiguous + (void)dynamic_cast<A*>((F*)0); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A':\n struct F -> struct B -> struct A\n struct F -> struct E -> struct A}} + (void)dynamic_cast<A&>(*((F*)0)); // expected-error {{ambiguous conversion from derived class 'F' to base class 'A':\n struct F -> struct B -> struct A\n struct F -> struct E -> struct A}} +} + +void poly() +{ + (void)dynamic_cast<A*>((Poly*)0); + (void)dynamic_cast<A&>(*((Poly*)0)); + (void)dynamic_cast<A*>((PolyDerived*)0); + (void)dynamic_cast<A&>(*((PolyDerived*)0)); + + // Not polymorphic source + (void)dynamic_cast<Poly*>((A*)0); // expected-error {{'A' is not polymorphic}} + (void)dynamic_cast<PolyDerived&>(*((A*)0)); // expected-error {{'A' is not polymorphic}} +} diff --git a/clang/test/SemaCXX/elaborated-type-specifier.cpp b/clang/test/SemaCXX/elaborated-type-specifier.cpp new file mode 100644 index 0000000..760079f --- /dev/null +++ b/clang/test/SemaCXX/elaborated-type-specifier.cpp @@ -0,0 +1,48 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Test the use of elaborated-type-specifiers to inject the names of +// structs (or classes or unions) into an outer scope as described in +// C++ [basic.scope.pdecl]p5. +typedef struct S1 { + union { + struct S2 *x; + struct S3 *y; + }; +} S1; + +bool test_elab(S1 *s1, struct S2 *s2, struct S3 *s3) { + if (s1->x == s2) return true; + if (s1->y == s3) return true; + return false; +} + +namespace NS { + class X { + public: + void test_elab2(struct S4 *s4); + }; + + void X::test_elab2(S4 *s4) { } // expected-note{{passing argument to parameter 's4' here}} +} + +void test_X_elab(NS::X x) { + struct S4 *s4 = 0; + x.test_elab2(s4); // expected-error{{cannot initialize a parameter of type 'NS::S4 *' with an lvalue of type 'struct S4 *'}} +} + +namespace NS { + S4 *get_S4(); +} + +void test_S5_scope() { + S4 *s4; // expected-error{{use of undeclared identifier 'S4'}} \ + // expected-error{{use of undeclared identifier 's4'}} +} + +int test_funcparam_scope(struct S5 * s5) { + struct S5 { int y; } *s5_2 = 0; + if (s5 == s5_2) return 1; // expected-error {{comparison of distinct pointer types ('struct S5 *' and 'struct S5 *')}} + return 0; +} + + diff --git a/clang/test/SemaCXX/empty-class-layout.cpp b/clang/test/SemaCXX/empty-class-layout.cpp new file mode 100644 index 0000000..c68f2bb --- /dev/null +++ b/clang/test/SemaCXX/empty-class-layout.cpp @@ -0,0 +1,157 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify + +#define SA(n, p) int a##n[(p) ? 1 : -1] + +namespace Test0 { + +struct A { int a; }; +SA(0, sizeof(A) == 4); + +struct B { }; +SA(1, sizeof(B) == 1); + +struct C : A, B { }; +SA(2, sizeof(C) == 4); + +struct D { }; +struct E : D { }; +struct F : E { }; + +struct G : E, F { }; +SA(3, sizeof(G) == 2); + +struct Empty { Empty(); }; + +struct I : Empty { + Empty e; +}; +SA(4, sizeof(I) == 2); + +struct J : Empty { + Empty e[2]; +}; +SA(5, sizeof(J) == 3); + +template<int N> struct Derived : Empty, Derived<N - 1> { +}; +template<> struct Derived<0> : Empty { }; + +struct S1 : virtual Derived<10> { + Empty e; +}; +SA(6, sizeof(S1) == 24); + +struct S2 : virtual Derived<10> { + Empty e[2]; +}; +SA(7, sizeof(S2) == 24); + +struct S3 { + Empty e; +}; + +struct S4 : Empty, S3 { +}; +SA(8, sizeof(S4) == 2); + +struct S5 : S3, Empty {}; +SA(9, sizeof(S5) == 2); + +struct S6 : S5 { }; +SA(10, sizeof(S6) == 2); + +struct S7 : Empty { + void *v; +}; +SA(11, sizeof(S7) == 8); + +struct S8 : Empty, A { +}; +SA(12, sizeof(S8) == 4); + +} + +namespace Test1 { + +// Test that we don't try to place both A subobjects at offset 0. +struct A { }; +class B { virtual void f(); }; +class C : A, virtual B { }; +struct D : virtual C { }; +struct E : virtual A { }; +class F : D, E { }; + +SA(0, sizeof(F) == 24); + +} + +namespace Test2 { + +// Test that B::a isn't laid out at offset 0. +struct Empty { }; +struct A : Empty { }; +struct B : Empty { + A a; +}; + +SA(0, sizeof(B) == 2); + +} + +namespace Test3 { + +// Test that B::a isn't laid out at offset 0. +struct Empty { }; +struct A { Empty e; }; +struct B : Empty { A a; }; +SA(0, sizeof(B) == 2); + +} + +namespace Test4 { + +// Test that C::Empty isn't laid out at offset 0. +struct Empty { }; +struct A : Empty { }; +struct B { A a; }; +struct C : B, Empty { }; +SA(0, sizeof(C) == 2); + +} + +namespace Test5 { + +// Test that B::Empty isn't laid out at offset 0. +struct Empty { }; +struct Field : virtual Empty { }; +struct A { + Field f; +}; +struct B : A, Empty { }; +SA(0, sizeof(B) == 16); + +} + +namespace Test6 { + +// Test that B::A isn't laid out at offset 0. +struct Empty { }; +struct Field : virtual Empty { }; +struct A { + Field f; +}; +struct B : Empty, A { }; +SA(0, sizeof(B) == 16); + +} + +namespace Test7 { + // Make sure we reserve enough space for both bases; PR11745. + struct Empty { }; + struct Base1 : Empty { }; + struct Base2 : Empty { }; + struct Test : Base1, Base2 { + char c; + }; + SA(0, sizeof(Test) == 2); +} diff --git a/clang/test/SemaCXX/enum-bitfield.cpp b/clang/test/SemaCXX/enum-bitfield.cpp new file mode 100644 index 0000000..63445ca --- /dev/null +++ b/clang/test/SemaCXX/enum-bitfield.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++11 -verify -triple x86_64-apple-darwin %s + +enum E {}; + +struct Z {}; +typedef int Integer; + +struct X { + enum E : 1; + enum E : Z; // expected-error{{invalid underlying type}} + enum E2 : int; + enum E3 : Integer; +}; + +struct Y { + enum E : int(2); + enum E : Z(); // expected-error{{integral constant expression must have integral or unscoped enumeration type, not 'Z'}} +}; diff --git a/clang/test/SemaCXX/enum-scoped.cpp b/clang/test/SemaCXX/enum-scoped.cpp new file mode 100644 index 0000000..ebe9245 --- /dev/null +++ b/clang/test/SemaCXX/enum-scoped.cpp @@ -0,0 +1,247 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++11 -verify -triple x86_64-apple-darwin %s + +enum class E1 { + Val1 = 1L +}; + +enum struct E2 { + Val1 = '\0' +}; + +E1 v1 = Val1; // expected-error{{undeclared identifier}} +E1 v2 = E1::Val1; + +static_assert(sizeof(E1) == sizeof(int), "bad size"); +static_assert(sizeof(E1::Val1) == sizeof(int), "bad size"); +static_assert(sizeof(E2) == sizeof(int), "bad size"); +static_assert(sizeof(E2::Val1) == sizeof(int), "bad size"); + +E1 v3 = E2::Val1; // expected-error{{cannot initialize a variable}} +int x1 = E1::Val1; // expected-error{{cannot initialize a variable}} + +enum E3 : char { + Val2 = 1 +}; + +E3 v4 = Val2; +E1 v5 = Val2; // expected-error{{cannot initialize a variable}} + +static_assert(sizeof(E3) == 1, "bad size"); + +int x2 = Val2; + +int a1[Val2]; +int a2[E1::Val1]; // expected-error{{size of array has non-integer type}} + +int* p1 = new int[Val2]; +int* p2 = new int[E1::Val1]; // expected-error{{array size expression must have integral or unscoped enumeration type, not 'E1'}} + +enum class E4 { + e1 = -2147483648, // ok + e2 = 2147483647, // ok + e3 = 2147483648 // expected-error{{enumerator value evaluates to 2147483648, which cannot be narrowed to type 'int'}} +}; + +enum class E5 { + e1 = 2147483647, // ok + e2 // expected-error{{2147483648 is not representable in the underlying}} +}; + +enum class E6 : bool { + e1 = false, e2 = true, + e3 // expected-error{{2 is not representable in the underlying}} +}; + +enum E7 : bool { + e1 = false, e2 = true, + e3 // expected-error{{2 is not representable in the underlying}} +}; + +template <class T> +struct X { + enum E : T { + e1, e2, + e3 // expected-error{{2 is not representable in the underlying}} + }; +}; + +X<bool> X2; // expected-note{{in instantiation of template}} + +enum Incomplete1; // expected-error{{C++ forbids forward references}} + +enum Complete1 : int; +Complete1 complete1; + +enum class Complete2; +Complete2 complete2; + +// All the redeclarations below are done twice on purpose. Tests that the type +// of the declaration isn't changed. + +enum class Redeclare2; // expected-note{{previous use is here}} expected-note{{previous use is here}} +enum Redeclare2; // expected-error{{previously declared as scoped}} +enum Redeclare2; // expected-error{{previously declared as scoped}} + +enum Redeclare3 : int; // expected-note{{previous use is here}} expected-note{{previous use is here}} +enum Redeclare3; // expected-error{{previously declared with fixed underlying type}} +enum Redeclare3; // expected-error{{previously declared with fixed underlying type}} + +enum class Redeclare5; +enum class Redeclare5 : int; // ok + +enum Redeclare6 : int; // expected-note{{previous use is here}} expected-note{{previous use is here}} +enum Redeclare6 : short; // expected-error{{redeclared with different underlying type}} +enum Redeclare6 : short; // expected-error{{redeclared with different underlying type}} + +enum class Redeclare7; // expected-note{{previous use is here}} expected-note{{previous use is here}} +enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}} +enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}} + +enum : long { + long_enum_val = 10000 +}; + +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) { } +} + +// <rdar://problem/9366066> +namespace rdar9366066 { + enum class X : unsigned { value }; + + void f(X x) { + x % X::value; // expected-error{{invalid operands to binary expression ('rdar9366066::X' and 'rdar9366066::X')}} + x % 8; // expected-error{{invalid operands to binary expression ('rdar9366066::X' and 'int')}} + } +} + +// Part 1 of PR10264 +namespace test5 { + namespace ns { + typedef unsigned Atype; + enum A : Atype; + } + enum ns::A : ns::Atype { + x, y, z + }; +} + +// Part 2 of PR10264 +namespace test6 { + enum A : unsigned; + struct A::a; // expected-error {{incomplete type 'test6::A' named in nested name specifier}} + enum A::b; // expected-error {{incomplete type 'test6::A' named in nested name specifier}} + int A::c; // expected-error {{incomplete type 'test6::A' named in nested name specifier}} + void A::d(); // expected-error {{incomplete type 'test6::A' named in nested name specifier}} + void test() { + (void) A::e; // expected-error {{incomplete type 'test6::A' named in nested name specifier}} + } +} + +namespace PR11484 { + const int val = 104; + enum class test1 { owner_dead = val, }; +} + +namespace N2764 { + enum class E { a, b }; + enum E x1 = E::a; // ok + enum class E x2 = E::a; // expected-error {{reference to scoped enumeration must use 'enum' not 'enum class'}} + + enum F { a, b }; + enum F y1 = a; // ok + enum class F y2 = a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}} + + struct S { + friend enum class E; // expected-error {{reference to scoped enumeration must use 'enum' not 'enum class'}} + friend enum class F; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}} + + friend enum G {}; // expected-error {{forward reference}} expected-error {{cannot define a type in a friend declaration}} + friend enum class H {}; // expected-error {{cannot define a type in a friend declaration}} + + enum A : int; + A a; + } s; + + enum S::A : int {}; + + enum class B; +} + +enum class N2764::B {}; + +namespace PR12106 { + template<typename E> struct Enum { + Enum() : m_e(E::Last) {} + E m_e; + }; + + enum eCOLORS { Last }; + Enum<eCOLORS> e; +} + +namespace test7 { + enum class E { e = (struct S*)0 == (struct S*)0 }; + S *p; +} + +namespace test8 { + template<typename T> struct S { + enum A : int; // expected-note {{here}} + enum class B; // expected-note {{here}} + enum class C : int; // expected-note {{here}} + enum class D : int; // expected-note {{here}} + }; + template<typename T> enum S<T>::A { a }; // expected-error {{previously declared with fixed underlying type}} + template<typename T> enum class S<T>::B : char { b }; // expected-error {{redeclared with different underlying}} + template<typename T> enum S<T>::C : int { c }; // expected-error {{previously declared as scoped}} + template<typename T> enum class S<T>::D : char { d }; // expected-error {{redeclared with different underlying}} +} + +namespace test9 { + template<typename T> struct S { + enum class ET : T; // expected-note 2{{here}} + enum class Eint : int; // expected-note 2{{here}} + }; + template<> enum class S<int>::ET : int {}; + template<> enum class S<char>::ET : short {}; // expected-error {{different underlying type}} + template<> enum class S<int>::Eint : short {}; // expected-error {{different underlying type}} + template<> enum class S<char>::Eint : int {}; + + template<typename T> enum class S<T>::ET : int {}; // expected-error {{different underlying type 'int' (was 'short')}} + template<typename T> enum class S<T>::Eint : T {}; // expected-error {{different underlying type 'short' (was 'int')}} + + // The implicit instantiation of S<short> causes the implicit instantiation of + // all declarations of member enumerations, so is ill-formed, even though we + // never instantiate the definitions of S<short>::ET nor S<short>::Eint. + S<short> s; // expected-note {{in instantiation of}} +} + +namespace test10 { + template<typename T> int f() { + enum E : int; + enum E : T; // expected-note {{here}} + E x; + enum E : int { e }; // expected-error {{different underlying}} + x = e; + return x; + } + int k = f<int>(); + int l = f<short>(); // expected-note {{here}} + + template<typename T> int g() { + enum class E : int; + enum class E : T; // expected-note {{here}} + E x; + enum class E : int { e }; // expected-error {{different underlying}} + x = E::e; + return (int)x; + } + int m = g<int>(); + int n = g<short>(); // expected-note {{here}} +} diff --git a/clang/test/SemaCXX/enum-unscoped-nonexistent.cpp b/clang/test/SemaCXX/enum-unscoped-nonexistent.cpp new file mode 100644 index 0000000..d49800c --- /dev/null +++ b/clang/test/SemaCXX/enum-unscoped-nonexistent.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -std=c++11 -verify %s + +struct Base { + static const int a = 1; +}; +template<typename T> struct S : Base { + enum E : int; + constexpr int f(); + constexpr int g(); // expected-note {{declared here}} + void h(); +}; +template<> enum S<char>::E : int {}; // expected-note {{enum 'S<char>::E' was explicitly specialized here}} +template<> enum S<short>::E : int { b = 2 }; +template<> enum S<int>::E : int { a = 4 }; +template<typename T> enum S<T>::E : int { b = 8 }; + +// The unqualified-id here names a member of the non-dependent base class Base +// and not the injected enumerator name 'a' from the specialization. +template<typename T> constexpr int S<T>::f() { return a; } +static_assert(S<char>().f() == 1, ""); +static_assert(S<int>().f() == 1, ""); + +// The unqualified-id here names a member of the current instantiation, which +// bizarrely might not exist in some instantiations. +template<typename T> constexpr int S<T>::g() { return b; } // expected-error {{enumerator 'b' does not exist in instantiation of 'S<char>'}} +static_assert(S<char>().g() == 1, ""); // expected-note {{here}} expected-error {{not an integral constant expression}} expected-note {{undefined}} +static_assert(S<short>().g() == 2, ""); +static_assert(S<long>().g() == 8, ""); + +// 'b' is type-dependent, so these assertions should not fire before 'h' is +// instantiated. +template<typename T> void S<T>::h() { + char c[S<T>::b]; + static_assert(b != 8, ""); + static_assert(sizeof(c) != 8, ""); +} +void f() { + S<short>().h(); // ok, b == 2 +} diff --git a/clang/test/SemaCXX/enum.cpp b/clang/test/SemaCXX/enum.cpp new file mode 100644 index 0000000..370e1c3 --- /dev/null +++ b/clang/test/SemaCXX/enum.cpp @@ -0,0 +1,97 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++98 -verify -triple x86_64-apple-darwin %s +enum E { // expected-note{{previous definition is here}} + Val1, + Val2 +}; + +enum E; // expected-warning{{redeclaration of already-defined enum 'E' is a GNU extension}} + +int& enumerator_type(int); +float& enumerator_type(E); + +void f() { + E e = Val1; + float& fr = enumerator_type(Val2); +} + +// <rdar://problem/6502934> +typedef enum Foo { + A = 0, + B = 1 +} Foo; + +void bar() { + Foo myvar = A; + myvar = B; +} + +/// PR3688 +struct s1 { + enum e1 (*bar)(void); // expected-error{{ISO C++ forbids forward references to 'enum' types}} +}; + +enum e1 { YES, NO }; + +static enum e1 badfunc(struct s1 *q) { + return q->bar(); +} + +enum e2; // expected-error{{ISO C++ forbids forward references to 'enum' types}} + +namespace test1 { + template <class A, class B> struct is_same { static const int value = -1; }; + template <class A> struct is_same<A,A> { static const int value = 1; }; + + enum enum0 { v0 }; + int test0[is_same<__typeof(+v0), int>::value]; + + enum enum1 { v1 = __INT_MAX__ }; + int test1[is_same<__typeof(+v1), int>::value]; + + enum enum2 { v2 = __INT_MAX__ * 2U }; + int test2[is_same<__typeof(+v2), unsigned int>::value]; + + enum enum3 { v3 = __LONG_MAX__ }; + int test3[is_same<__typeof(+v3), long>::value]; + + enum enum4 { v4 = __LONG_MAX__ * 2UL }; + int test4[is_same<__typeof(+v4), unsigned long>::value]; +} + +// PR6061 +namespace PR6061 { + struct A { enum { id }; }; + struct B { enum { id }; }; + + struct C : public A, public B + { + enum { id }; + }; +} + +namespace Conditional { + enum a { A }; a x(const enum a x) { return 1?x:A; } +} + +namespace PR7051 { + enum E { e0 }; + void f() { + E e; + e = 1; // expected-error{{assigning to 'PR7051::E' from incompatible type 'int'}} + e |= 1; // expected-error{{assigning to 'PR7051::E' from incompatible type 'int'}} + } +} + +// PR7466 +enum { }; // expected-warning{{declaration does not declare anything}} +typedef enum { }; // expected-warning{{typedef requires a name}} + +// PR7921 +enum PR7921E { + PR7921V = (PR7921E)(123) // expected-error {{expression is not an integral constant expression}} +}; + +void PR8089() { + enum E; // expected-error{{ISO C++ forbids forward references to 'enum' types}} + int a = (E)3; // expected-error{{cannot initialize a variable of type 'int' with an rvalue of type 'E'}} +} diff --git a/clang/test/SemaCXX/exception-spec-no-exceptions.cpp b/clang/test/SemaCXX/exception-spec-no-exceptions.cpp new file mode 100644 index 0000000..2e18070 --- /dev/null +++ b/clang/test/SemaCXX/exception-spec-no-exceptions.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fobjc-exceptions %s + +// 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 { + void foo() throw(int); + void foo() throw(); +} + +// Overrides. +namespace test1 { + struct A { + virtual void foo() throw(); + }; + + struct B : A { + virtual void foo() throw(int); + }; +} + +// Calls from less permissive contexts. We don't actually do this +// check, but if we did it should also be disabled under +// -fno-exceptions. +namespace test2 { + void foo() throw(int); + void bar() throw() { + foo(); + } +} + diff --git a/clang/test/SemaCXX/exceptions.cpp b/clang/test/SemaCXX/exceptions.cpp new file mode 100644 index 0000000..486d88e --- /dev/null +++ b/clang/test/SemaCXX/exceptions.cpp @@ -0,0 +1,122 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s + +struct A; // expected-note 4 {{forward declaration of 'A'}} + +struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}} + +void trys() { + try { + } catch(int i) { // expected-note {{previous definition}} + int j = i; + int i; // expected-error {{redefinition of 'i'}} + } catch(float i) { + } catch(void v) { // expected-error {{cannot catch incomplete type 'void'}} + } catch(A a) { // expected-error {{cannot catch incomplete type 'A'}} + } catch(A *a) { // expected-error {{cannot catch pointer to incomplete type 'A'}} + } catch(A &a) { // expected-error {{cannot catch reference to incomplete type 'A'}} + } catch(Abstract) { // expected-error {{variable type 'Abstract' is an abstract class}} + } catch(...) { + int j = i; // expected-error {{use of undeclared identifier 'i'}} + } + + try { + } catch(...) { // expected-error {{catch-all handler must come last}} + } catch(int) { + } +} + +void throws() { + throw; + throw 0; + throw throw; // expected-error {{cannot throw object of incomplete type 'void'}} + throw (A*)0; // expected-error {{cannot throw pointer to object of incomplete type 'A'}} +} + +void jumps() { +l1: + goto l5; + goto l4; // expected-error {{goto into protected scope}} + goto l3; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{goto into protected scope}} + goto l1; + try { // expected-note 4 {{jump bypasses initialization of try block}} + l2: + goto l5; + goto l4; // expected-error {{goto into protected scope}} + goto l3; // expected-error {{goto into protected scope}} + goto l2; + goto l1; + } catch(int) { // expected-note 4 {{jump bypasses initialization of catch block}} + l3: + goto l5; + goto l4; // expected-error {{goto into protected scope}} + goto l3; + goto l2; // expected-error {{goto into protected scope}} + goto l1; + } catch(...) { // expected-note 4 {{jump bypasses initialization of catch block}} + l4: + goto l5; + goto l4; + goto l3; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{goto into protected scope}} + goto l1; + } +l5: + goto l5; + goto l4; // expected-error {{goto into protected scope}} + goto l3; // expected-error {{goto into protected scope}} + goto l2; // expected-error {{goto into protected scope}} + goto l1; +} + +struct BadReturn { + BadReturn() try { + } catch(...) { + // Try to hide + try { + } catch(...) { + { + if (0) + return; // expected-error {{return in the catch of a function try block of a constructor is illegal}} + } + } + } + BadReturn(int); +}; + +BadReturn::BadReturn(int) try { +} catch(...) { + // Try to hide + try { + } catch(int) { + return; // expected-error {{return in the catch of a function try block of a constructor is illegal}} + } catch(...) { + { + if (0) + return; // expected-error {{return in the catch of a function try block of a constructor is illegal}} + } + } +} + +// Cannot throw an abstract type. +class foo { +public: + foo() {} + void bar () { + throw *this; // expected-error{{cannot throw an object of abstract type 'foo'}} + } + virtual void test () = 0; // expected-note{{unimplemented pure virtual method 'test'}} +}; + +namespace PR6831 { + namespace NA { struct S; } + namespace NB { struct S; } + + void f() { + using namespace NA; + using namespace NB; + try { + } catch (int S) { + } + } +} diff --git a/clang/test/SemaCXX/explicit.cpp b/clang/test/SemaCXX/explicit.cpp new file mode 100644 index 0000000..4774637 --- /dev/null +++ b/clang/test/SemaCXX/explicit.cpp @@ -0,0 +1,175 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +namespace Constructor { +struct A { + A(int); +}; + +struct B { + explicit B(int); +}; + +B::B(int) { } + +struct C { + void f(const A&); + void f(const B&); +}; + +void f(C c) { + c.f(10); +} +} + +namespace Conversion { + struct A { + operator int(); + explicit operator bool(); + }; + + A::operator bool() { return false; } + + struct B { + void f(int); + void f(bool); + }; + + void f(A a, B b) { + b.f(a); + } + + void testExplicit() + { + // Taken from 12.3.2p2 + class Y { }; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'Conversion::Z' to 'const Conversion::Y &' for 1st argument}} \ + expected-note {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'Conversion::Z' to 'Conversion::Y &&' for 1st argument}} \ + expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'Conversion::Z' to 'const Conversion::Y &' for 1st argument}} \ + expected-note {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'Conversion::Z' to 'Conversion::Y &&' for 1st argument}} + + struct Z { + explicit operator Y() const; + explicit operator int() const; + }; + + Z z; + // 13.3.1.4p1 & 8.5p16: + Y y2 = z; // expected-error {{no viable conversion from 'Conversion::Z' to 'Conversion::Y'}} + Y y3 = (Y)z; + Y y4 = Y(z); + Y y5 = static_cast<Y>(z); + // 13.3.1.5p1 & 8.5p16: + int i1 = (int)z; + int i2 = int(z); + int i3 = static_cast<int>(z); + int i4(z); + // 13.3.1.6p1 & 8.5.3p5: + const Y& y6 = z; // expected-error {{no viable conversion from 'Conversion::Z' to 'const Conversion::Y'}} + const int& y7(z); + } + + void testBool() { + struct Bool { + operator bool(); + }; + + struct NotBool { + explicit operator bool(); // expected-note {{conversion to integral type 'bool'}} + }; + Bool b; + NotBool n; + + (void) (1 + b); + (void) (1 + n); // expected-error {{invalid operands to binary expression ('int' and 'Conversion::NotBool')}} + + // 5.3.1p9: + (void) (!b); + (void) (!n); + + // 5.14p1: + (void) (b && true); + (void) (n && true); + + // 5.15p1: + (void) (b || true); + (void) (n || true); + + // 5.16p1: + (void) (b ? 0 : 1); + (void) (n ? 0: 1); + + // 5.19p5: + // TODO: After constexpr has been implemented + + // 6.4p4: + if (b) {} + if (n) {} + + // 6.4.2p2: + switch (b) {} // expected-warning {{switch condition has boolean value}} + switch (n) {} // expected-error {{switch condition type 'Conversion::NotBool' requires explicit conversion to 'bool'}} \ + expected-warning {{switch condition has boolean value}} + + // 6.5.1: + while (b) {} + while (n) {} + + // 6.5.2p1: + do {} while (b); + do {} while (n); + + // 6.5.3: + for (;b;) {} + for (;n;) {} + } + + void testNew() + { + // 5.3.4p6: + struct Int { + operator int(); + }; + struct NotInt { + explicit operator int(); // expected-note {{conversion to integral type 'int' declared here}} + }; + + Int i; + NotInt ni; + + new int[i]; + new int[ni]; // expected-error {{array size expression of type 'Conversion::NotInt' requires explicit conversion to type 'int'}} + } + + void testDelete() + { + // 5.3.5pp2: + struct Ptr { + operator int*(); + }; + struct NotPtr { + explicit operator int*(); + }; + + Ptr p; + NotPtr np; + + delete p; + delete np; // expected-error {{cannot delete expression of type 'Conversion::NotPtr'}} + } + + void testFunctionPointer() + { + // 13.3.1.1.2p2: + using Func = void(*)(int); + + struct FP { + operator Func(); + }; + struct NotFP { + explicit operator Func(); + }; + + FP fp; + NotFP nfp; + fp(1); + nfp(1); // expected-error {{type 'Conversion::NotFP' does not provide a call operator}} + } +} diff --git a/clang/test/SemaCXX/expression-traits.cpp b/clang/test/SemaCXX/expression-traits.cpp new file mode 100644 index 0000000..2767d4a --- /dev/null +++ b/clang/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{{possible target for call}} + + 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{{reference to overloaded function could not be resolved; did you mean to call it?}} + + __is_lvalue_expr(::Class::NestedMemfunTemplate); // qualified-id: template \ + // expected-error{{reference to non-static member function must be called}} + + __is_lvalue_expr(::Class::operator+); // operator-function-id: template \ + // expected-error{{reference to non-static member function must 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/clang/test/SemaCXX/expressions.cpp b/clang/test/SemaCXX/expressions.cpp new file mode 100644 index 0000000..355833e --- /dev/null +++ b/clang/test/SemaCXX/expressions.cpp @@ -0,0 +1,120 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void choice(int); +int choice(bool); + +void test() { + // Result of ! must be type bool. + int i = choice(!1); +} + +// rdar://8018252 +void f0() { + extern void f0_1(int*); + register int x; + f0_1(&x); +} + +namespace test1 { + template <class T> void bar(T &x) { T::fail(); } + template <class T> void bar(volatile T &x) {} + + void test_ints() { + volatile int x; + bar(x = 5); + bar(x += 5); + } + + enum E { E_zero }; + void test_enums() { + volatile E x; + bar(x = E_zero); + bar(x += E_zero); // expected-error {{incompatible type}} + } +} + +int test2(int x) { + return x && 4; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + + return x && sizeof(int) == 4; // no warning, RHS is logical op. + return x && true; + return x && false; + return x || true; + return x || false; + + return x && (unsigned)0; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + + return x || (unsigned)1; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + + return x || 0; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || 1; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || -1; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || 5; // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x && 0; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && 1; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && -1; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && 5; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x || (0); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || (1); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || (-1); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x || (5); // expected-warning {{use of logical '||' with constant operand}} \ + // expected-note {{use '|' for a bitwise operation}} + return x && (0); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && (1); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && (-1); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + return x && (5); // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} +} + +template<unsigned int A, unsigned int B> struct S +{ + enum { + e1 = A && B, + e2 = A && 7 // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + }; + + int foo() { + int x = A && B; + int y = B && 3; // expected-warning {{use of logical '&&' with constant operand}} \ + // expected-note {{use '&' for a bitwise operation}} \ + // expected-note {{remove constant to silence this warning}} + + return x + y; + } +}; + +void test3() { + S<5, 8> s1; + S<2, 7> s2; + (void)s1.foo(); + (void)s2.foo(); +} diff --git a/clang/test/SemaCXX/flexible-array-test.cpp b/clang/test/SemaCXX/flexible-array-test.cpp new file mode 100644 index 0000000..e6c3132 --- /dev/null +++ b/clang/test/SemaCXX/flexible-array-test.cpp @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// pr7029 + +template <class Key, class T> struct QMap +{ + void insert(const Key &, const T &); + T v; +}; + + +template <class Key, class T> +void QMap<Key, T>::insert(const Key &, const T &avalue) +{ + v = avalue; +} + + +struct inotify_event +{ + int wd; + + // clang doesn't like '[]': + // cannot initialize a parameter of type 'void *' with an rvalue of type 'char (*)[]' + char name []; +}; + + +void foo() +{ + inotify_event event; + inotify_event* ptr = &event; + inotify_event event1 = *ptr; + *ptr = event; + QMap<int, inotify_event> eventForId; + eventForId.insert(ptr->wd, *ptr); +} + +struct S { + virtual void foo(); +}; + +struct X { + int blah; + S strings[]; // expected-error {{flexible array member 'strings' of non-POD element type 'S []'}} +}; + +class A { + int s; + char c[]; +}; + +union B { + int s; + char c[]; +}; + +namespace rdar9065507 { + +struct StorageBase { + long ref_count; + unsigned size; + unsigned capacity; +}; + +struct Storage : StorageBase { + int data[]; +}; + +} diff --git a/clang/test/SemaCXX/fntype-decl.cpp b/clang/test/SemaCXX/fntype-decl.cpp new file mode 100644 index 0000000..b8ae625 --- /dev/null +++ b/clang/test/SemaCXX/fntype-decl.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR2942 +typedef void fn(int); +fn f; // expected-note {{previous declaration is here}} + +int g(int x, int y); +int g(int x, int y = 2); + +typedef int g_type(int, int); +g_type g; + +int h(int x) { // expected-note {{previous definition is here}} + return g(x); +} + +float f(int) { } // expected-error{{functions that differ only in their return type cannot be overloaded}} + +int h(int) { } // expected-error{{redefinition of 'h'}} + diff --git a/clang/test/SemaCXX/for-range-examples.cpp b/clang/test/SemaCXX/for-range-examples.cpp new file mode 100644 index 0000000..8bda510 --- /dev/null +++ b/clang/test/SemaCXX/for-range-examples.cpp @@ -0,0 +1,182 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +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); +} + +// PR11793 +namespace test2 { + class A { + int xs[10]; // expected-note {{implicitly declared private here}} + }; + void test(A &a) { + for (int x : a.xs) { } // expected-error {{'xs' is a private member of 'test2::A'}} + } +} + +namespace test3 { + // Make sure this doesn't crash + struct A {}; + struct B { ~B(); operator bool(); }; + struct C { B operator!=(const C&); C& operator++(); int operator*(); }; + C begin(const A&); + C end(const A&); + template<typename T> void f() { for (auto a : A()) {} } + void g() { f<int>(); } +} + +namespace test4 { + void f() { + int y; + + // Make sure these don't crash. Better diagnostics would be nice. + for (: {1, 2, 3}) {} // expected-error {{expected expression}} expected-error {{expected ';'}} + for (x : {1, 2, 3}) {} // expected-error {{undeclared identifier}} expected-error {{expected ';'}} + for (y : {1, 2, 3}) {} // expected-error {{must declare a variable}} expected-warning {{result unused}} + } +} diff --git a/clang/test/SemaCXX/for-range-no-std.cpp b/clang/test/SemaCXX/for-range-no-std.cpp new file mode 100644 index 0000000..fa42ca4 --- /dev/null +++ b/clang/test/SemaCXX/for-range-no-std.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98 -Wno-c++11-extensions + +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}} +} + +void PR11601() { + void (*vv[])() = {PR11601, PR11601, PR11601}; + for (void (*i)() : vv) i(); +} diff --git a/clang/test/SemaCXX/for-range-unused.cpp b/clang/test/SemaCXX/for-range-unused.cpp new file mode 100644 index 0000000..ce6b379 --- /dev/null +++ b/clang/test/SemaCXX/for-range-unused.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -Wunused + +// PR9968: We used to warn that __range is unused in a dependent for-range. + +template <typename T> + struct Vector { + void doIt() { + int a; // expected-warning {{unused variable 'a'}} + + for (auto& e : elements) + ; + } + + T elements[10]; + }; + + +int main(int, char**) { + Vector<int> vector; + vector.doIt(); +} diff --git a/clang/test/SemaCXX/format-strings-0x.cpp b/clang/test/SemaCXX/format-strings-0x.cpp new file mode 100644 index 0000000..e7c5904 --- /dev/null +++ b/clang/test/SemaCXX/format-strings-0x.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s + +extern "C" { +extern int scanf(const char *restrict, ...); +extern int printf(const char *restrict, ...); +} + +void f(char **sp, float *fp) { + scanf("%as", sp); // expected-warning{{format specifies type 'float *' but the argument has type 'char **'}} + + printf("%a", 1.0); + scanf("%afoobar", fp); + printf(nullptr); + printf(*sp); // expected-warning {{not a string literal}} +} diff --git a/clang/test/SemaCXX/format-strings.cpp b/clang/test/SemaCXX/format-strings.cpp new file mode 100644 index 0000000..6b0df29 --- /dev/null +++ b/clang/test/SemaCXX/format-strings.cpp @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -pedantic %s + +#include <stdarg.h> + +extern "C" { +extern int scanf(const char *restrict, ...); +extern int printf(const char *restrict, ...); +extern int vprintf(const char *restrict, va_list); +} + +void f(char **sp, float *fp) { + scanf("%as", sp); // expected-warning{{'a' length modifier is not supported by ISO C}} + + // TODO: Warn that the 'a' conversion specifier is a C++11 feature. + printf("%a", 1.0); + scanf("%afoobar", fp); +} + +void g() { + printf("%ls", "foo"); // expected-warning{{format specifies type 'wchar_t *' but the argument has type 'const char *'}} +} + +// Test that we properly handle format_idx on C++ members. +class Foo { +public: + const char *gettext(const char *fmt) __attribute__((format_arg(2))); + + int scanf(const char *, ...) __attribute__((format(scanf, 2, 3))); + int printf(const char *, ...) __attribute__((format(printf, 2, 3))); + int printf2(const char *, ...); + + static const char *gettext_static(const char *fmt) __attribute__((format_arg(1))); + static int printf_static(const char *fmt, ...) __attribute__((format(printf, 1, 2))); +}; + +void h(int *i) { + Foo foo; + foo.scanf("%d"); // expected-warning{{more '%' conversions than data arguments}} + foo.printf("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}} + Foo::printf_static("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}} + + printf(foo.gettext("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}} + printf(Foo::gettext_static("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}} +} + +// Test handling __null for format string literal checking. +extern "C" { + int test_null_format(const char *format, ...) __attribute__((__format__ (__printf__, 1, 2))); +} + +void rdar8269537(const char *f) +{ + test_null_format(false); // expected-warning {{null from a constant boolean}} + test_null_format(0); // no-warning + test_null_format(__null); // no-warning + test_null_format(f); // expected-warning {{not a string literal}} +} + +int Foo::printf(const char *fmt, ...) { + va_list ap; + va_start(ap,fmt); + const char * const format = fmt; + vprintf(format, ap); // no-warning + + const char *format2 = fmt; + vprintf(format2, ap); // expected-warning{{format string is not a string literal}} + + return 0; +} + +int Foo::printf2(const char *fmt, ...) { + va_list ap; + va_start(ap,fmt); + vprintf(fmt, ap); // expected-warning{{format string is not a string literal}} + + return 0; +} diff --git a/clang/test/SemaCXX/friend-class-nodecl.cpp b/clang/test/SemaCXX/friend-class-nodecl.cpp new file mode 100644 index 0000000..41e2da6 --- /dev/null +++ b/clang/test/SemaCXX/friend-class-nodecl.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -ast-print %s -o %t +// RUN: not grep '^ *class B' %t + +// Tests that the tag decls in friend declarations aren't added to the +// declaring class's decl chain. + +class A { + friend class B; +}; + diff --git a/clang/test/SemaCXX/friend-out-of-line.cpp b/clang/test/SemaCXX/friend-out-of-line.cpp new file mode 100644 index 0000000..56b2daa --- /dev/null +++ b/clang/test/SemaCXX/friend-out-of-line.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// <rdar://problem/10204947> +namespace N { + class X; +}; + +class N::X { + template<typename T> friend const T& f(const X&); + friend const int& g(const X&); + friend class Y; +}; diff --git a/clang/test/SemaCXX/friend.cpp b/clang/test/SemaCXX/friend.cpp new file mode 100644 index 0000000..c5b11eb --- /dev/null +++ b/clang/test/SemaCXX/friend.cpp @@ -0,0 +1,140 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +friend class A; // expected-error {{'friend' used outside of class}} +void f() { friend class A; } // expected-error {{'friend' used outside of class}} +class C { friend class A; }; +class D { void f() { friend class A; } }; // expected-error {{'friend' used outside of class}} + +// PR5760 +namespace test0 { + namespace ns { + void f(int); + } + + struct A { + friend void ns::f(int a); + }; +} + +// Test derived from LLVM's Registry.h +namespace test1 { + template <class T> struct Outer { + void foo(T); + struct Inner { + friend void Outer::foo(T); + }; + }; + + void test() { + (void) Outer<int>::Inner(); + } +} + +// PR5476 +namespace test2 { + namespace foo { + void Func(int x); + } + + class Bar { + friend void ::test2::foo::Func(int x); + }; +} + +// PR5134 +namespace test3 { + class Foo { + friend const int getInt(int inInt = 0); + + }; +} + +namespace test4 { + class T4A { + friend class T4B; + + public: + T4A(class T4B *); + + protected: + T4B *mB; // error here + }; + + class T4B {}; +} + +namespace rdar8529993 { +struct A { ~A(); }; + +struct B : A +{ + template<int> friend A::~A(); // expected-error {{destructor cannot be declared as a template}} +}; +} + +// PR7915 +namespace test5 { + struct A; + struct A1 { friend void A(); }; + + struct B { friend void B(); }; +} + +// PR8479 +namespace test6_1 { + class A { + public: + private: + friend class vectorA; + A() {} + }; + class vectorA { + public: + vectorA(int i, const A& t = A()) {} + }; + void f() { + vectorA v(1); + } +} +namespace test6_2 { + template<class T> + class vector { + public: + vector(int i, const T& t = T()) {} + }; + class A { + public: + private: + friend class vector<A>; + A() {} + }; + void f() { + vector<A> v(1); + } +} +namespace test6_3 { + template<class T> + class vector { + public: + vector(int i) {} + void f(const T& t = T()) {} + }; + class A { + public: + private: + friend void vector<A>::f(const A&); + A() {} + }; + void f() { + vector<A> v(1); + v.f(); + } +} + +namespace test7 { + extern "C" { + class X { + friend int f() { return 42; } + }; + } +} diff --git a/clang/test/SemaCXX/function-extern-c.cpp b/clang/test/SemaCXX/function-extern-c.cpp new file mode 100644 index 0000000..f20cd38 --- /dev/null +++ b/clang/test/SemaCXX/function-extern-c.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -Wreturn-type -fsyntax-only -std=c++11 -verify %s + +class A { +public: + A(const A&); +}; + +struct S { + int i; + double d; + + virtual void B() {} +}; + +union U { + struct { + int i; + virtual void B() {} // Can only do this in C++11 + } t; +}; + +struct S2 { + int i; + double d; +}; + +extern "C" U f3( void ); // expected-warning {{'f3' has C-linkage specified, but returns user-defined type 'U' which is incompatible with C}} +extern "C" S f0(void); // expected-warning {{'f0' has C-linkage specified, but returns user-defined type 'S' which is incompatible with C}} +extern "C" A f4( void ); // expected-warning {{'f4' has C-linkage specified, but returns user-defined type 'A' which is incompatible with C}} + +// These should all be fine +extern "C" S2 f5( void ); +extern "C" void f2( A x ); +extern "C" void f6( S s ); +extern "C" void f7( U u ); +extern "C" double f8(void); +extern "C" long long f11( void ); +extern "C" A *f10( void ); diff --git a/clang/test/SemaCXX/function-overload-typo-crash.cpp b/clang/test/SemaCXX/function-overload-typo-crash.cpp new file mode 100644 index 0000000..8c5cec8 --- /dev/null +++ b/clang/test/SemaCXX/function-overload-typo-crash.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR10283 +void min(); //expected-note {{'min' declared here}} +void min(int); + +template <typename T> void max(T); //expected-note {{'max' declared here}} + +void f() { + fin(); //expected-error {{use of undeclared identifier 'fin'; did you mean 'min'}} + fax(0); //expected-error {{use of undeclared identifier 'fax'; did you mean 'max'}} +} + +template <typename T> void somefunc(T*, T*); //expected-note {{'somefunc' declared here}} +template <typename T> void somefunc(const T[]); //expected-note {{'somefunc' declared here}} +template <typename T1, typename T2> void somefunc(T1*, T2*); //expected-note {{'somefunc' declared here}} +template <typename T1, typename T2> void somefunc(T1*, const T2[]); //expected-note 2 {{'somefunc' declared here}} + +void c() { + int *i = 0, *j = 0; + const int x[] = {1, 2, 3}; + long *l = 0; + somefun(i, j); //expected-error {{use of undeclared identifier 'somefun'; did you mean 'somefunc'?}} + somefun(x); //expected-error {{use of undeclared identifier 'somefun'; did you mean 'somefunc'?}} + somefun(i, l); //expected-error {{use of undeclared identifier 'somefun'; did you mean 'somefunc'?}} + somefun(l, x); //expected-error {{use of undeclared identifier 'somefun'; did you mean 'somefunc'?}} + somefun(i, x); //expected-error {{use of undeclared identifier 'somefun'; did you mean 'somefunc'?}} +} diff --git a/clang/test/SemaCXX/function-overloaded-redecl.cpp b/clang/test/SemaCXX/function-overloaded-redecl.cpp new file mode 100644 index 0000000..0077881 --- /dev/null +++ b/clang/test/SemaCXX/function-overloaded-redecl.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +typedef const int cInt; + +void f (int); +void f (const int); // redecl + +void f (int) { } // expected-note {{previous definition is here}} +void f (cInt) { } // expected-error {{redefinition of 'f'}} + diff --git a/clang/test/SemaCXX/function-redecl.cpp b/clang/test/SemaCXX/function-redecl.cpp new file mode 100644 index 0000000..0eb109d --- /dev/null +++ b/clang/test/SemaCXX/function-redecl.cpp @@ -0,0 +1,100 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int foo(int); + +namespace N { + void f1() { + void foo(int); // okay + } + + // FIXME: we shouldn't even need this declaration to detect errors + // below. + void foo(int); // expected-note{{previous declaration is here}} + + void f2() { + int foo(int); // expected-error{{functions that differ only in their return type cannot be overloaded}} + + { + int foo; + { + // FIXME: should diagnose this because it's incompatible with + // N::foo. However, name lookup isn't properly "skipping" the + // "int foo" above. + float foo(int); + } + } + } +} + +class A { + void typocorrection(); // expected-note {{'typocorrection' declared here}} +}; + +void A::Notypocorrection() { // expected-error {{out-of-line definition of 'Notypocorrection' does not match any declaration in 'A'; did you mean 'typocorrection'}} +} + + +namespace test0 { + void dummy() { + void Bar(); // expected-note {{'Bar' declared here}} + class A { + friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean 'Bar'}} + }; + } +} + + +class B { + void typocorrection(const int); // expected-note {{'typocorrection' declared here}} + void typocorrection(double); +}; + +void B::Notypocorrection(int) { // expected-error {{out-of-line definition of 'Notypocorrection' does not match any declaration in 'B'; did you mean 'typocorrection'}} +} + +struct X { int f(); }; +struct Y : public X {}; +int Y::f() { return 3; } // expected-error {{out-of-line definition of 'f' does not match any declaration in 'Y'}} + +namespace test1 { +struct Foo { + class Inner { }; +}; +} + +class Bar { + void f(test1::Foo::Inner foo) const; // expected-note {{member declaration does not match because it is const qualified}} +}; + +using test1::Foo; + +void Bar::f(Foo::Inner foo) { // expected-error {{out-of-line definition of 'f' does not match any declaration in 'Bar'}} + (void)foo; +} + +class Crash { + public: + void GetCart(int count) const; +}; +// This out-of-line definition was fine... +void Crash::cart(int count) const {} // expected-error {{out-of-line definition of 'cart' does not match any declaration in 'Crash'}} \ + // expected-note {{'cart' declared here}} \ + // expected-note {{previous definition is here}} +// ...while this one crashed clang +void Crash::chart(int count) const {} // expected-error {{out-of-line definition of 'chart' does not match any declaration in 'Crash'; did you mean 'cart'?}} \ + // expected-error {{redefinition of 'cart'}} + +class TestConst { + public: + int getit() const; // expected-note {{member declaration does not match because it is const qualified}} + void setit(int); // expected-note {{member declaration does not match because it is not const qualified}} +}; + +int TestConst::getit() { // expected-error {{out-of-line definition of 'getit' does not match any declaration in 'TestConst'}} + return 1; +} + +void TestConst::setit(int) const { // expected-error {{out-of-line definition of 'setit' does not match any declaration in 'TestConst'}} +} + +struct J { int typo() const; }; +int J::typo_() { return 3; } // expected-error {{out-of-line definition of 'typo_' does not match any declaration in 'J'}} diff --git a/clang/test/SemaCXX/function-type-qual.cpp b/clang/test/SemaCXX/function-type-qual.cpp new file mode 100644 index 0000000..73613ae --- /dev/null +++ b/clang/test/SemaCXX/function-type-qual.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f() const; // expected-error {{non-member function cannot have 'const' qualifier}} +void (*pf)() const; // expected-error {{pointer to function type cannot have 'const' qualifier}} +extern void (&rf)() const; // expected-error {{reference to function type cannot have 'const' qualifier}} + +typedef void cfn() const; +cfn f2; // expected-error {{non-member function of type 'cfn' (aka 'void () const') cannot have 'const' qualifier}} + +class C { + void f() const; + cfn f2; + static void f3() const; // expected-error {{static member function cannot have 'const' qualifier}} + static cfn f4; // expected-error {{static member function of type 'cfn' (aka 'void () const') cannot have 'const' qualifier}} + + void m1() { + x = 0; + } + + void m2() const { + x = 0; // expected-error {{read-only variable is not assignable}} + } + + int x; +}; + +void (C::*mpf)() const; +cfn C::*mpg; diff --git a/clang/test/SemaCXX/functional-cast.cpp b/clang/test/SemaCXX/functional-cast.cpp new file mode 100644 index 0000000..61e4da3 --- /dev/null +++ b/clang/test/SemaCXX/functional-cast.cpp @@ -0,0 +1,320 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// ------------ not interpreted as C-style cast ------------ + +struct SimpleValueInit { + int i; +}; + +struct InitViaConstructor { + InitViaConstructor(int i = 7); +}; + +struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}} + NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}} +}; + +void test_cxx_functional_value_init() { + (void)SimpleValueInit(); + (void)InitViaConstructor(); + (void)NoValueInit(); // expected-error{{no matching constructor for initialization}} +} + +void test_cxx_function_cast_multi() { + (void)NoValueInit(0, 0); + (void)NoValueInit(0, 0, 0); // expected-error{{no matching constructor for initialization}} + (void)int(1, 2); // expected-error{{excess elements in scalar initializer}} +} + + +// ------------------ everything else -------------------- + +struct A {}; + +// ----------- const_cast -------------- + +typedef char c; +typedef c *cp; +typedef cp *cpp; +typedef cpp *cppp; +typedef cppp &cpppr; +typedef const cppp &cpppcr; +typedef const char cc; +typedef cc *ccp; +typedef volatile ccp ccvp; +typedef ccvp *ccvpp; +typedef const volatile ccvpp ccvpcvp; +typedef ccvpcvp *ccvpcvpp; +typedef int iar[100]; +typedef iar &iarr; +typedef int (*f)(int); + +void t_cc() +{ + ccvpcvpp var = 0; + // Cast away deep consts and volatiles. + char ***var2 = cppp(var); + char ***const &var3 = var2; + // Const reference to reference. + char ***&var4 = cpppr(var3); + // Drop reference. Intentionally without qualifier change. + char *** var5 = cppp(var4); + const int ar[100] = {0}; + // Array decay. Intentionally without qualifier change. + typedef int *intp; + int *pi = intp(ar); + f fp = 0; + // Don't misidentify fn** as a function pointer. + typedef f *fp_t; + f *fpp = fp_t(&fp); + int const A::* const A::*icapcap = 0; + typedef int A::* A::*iapap_t; + iapap_t iapap = iapap_t(icapcap); +} + +// ----------- static_cast ------------- + +struct B : public A {}; // Single public base. +struct C1 : public virtual B {}; // Single virtual base. +struct C2 : public virtual B {}; +struct D : public C1, public C2 {}; // Diamond +struct E : private A {}; // Single private base. +struct F : public C1 {}; // Single path to B with virtual. +struct G1 : public B {}; +struct G2 : public B {}; +struct H : public G1, public G2 {}; // Ambiguous path to B. + +enum Enum { En1, En2 }; +enum Onom { On1, On2 }; + +struct Co1 { operator int(); }; +struct Co2 { Co2(int); }; +struct Co3 { }; +struct Co4 { Co4(Co3); operator Co3(); }; + +// Explicit implicits +void t_529_2() +{ + int i = 1; + (void)float(i); + double d = 1.0; + (void)float(d); + (void)int(d); + (void)char(i); + typedef unsigned long ulong; + (void)ulong(i); + (void)int(En1); + (void)double(En1); + typedef int &intr; + (void)intr(i); + typedef const int &cintr; + (void)cintr(i); + + int ar[1]; + typedef const int *cintp; + (void)cintp(ar); + typedef void (*pfvv)(); + (void)pfvv(t_529_2); + + typedef void *voidp; + (void)voidp(0); + (void)voidp((int*)0); + typedef volatile const void *vcvoidp; + (void)vcvoidp((const int*)0); + typedef A *Ap; + (void)Ap((B*)0); + typedef A &Ar; + (void)Ar(*((B*)0)); + typedef const B *cBp; + (void)cBp((C1*)0); + typedef B &Br; + (void)Br(*((C1*)0)); + (void)Ap((D*)0); + typedef const A &cAr; + (void)cAr(*((D*)0)); + typedef int B::*Bmp; + (void)Bmp((int A::*)0); + typedef void (B::*Bmfp)(); + (void)Bmfp((void (A::*)())0); + (void)Ap((E*)0); // functional-style cast ignores access control + (void)voidp((const int*)0); // const_cast appended + + (void)int(Co1()); + (void)Co2(1); + (void)Co3((Co4)(Co3())); + + // Bad code below + //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}} +} + +// Anything to void +void t_529_4() +{ + void(1); + (void(t_529_4)); +} + +// Static downcasts +void t_529_5_8() +{ + typedef B *Bp; + (void)Bp((A*)0); + typedef B &Br; + (void)Br(*((A*)0)); + typedef const G1 *cG1p; + (void)cG1p((A*)0); + typedef const G1 &cG1r; + (void)cG1r(*((A*)0)); + (void)Bp((const A*)0); // const_cast appended + (void)Br(*((const A*)0)); // const_cast appended + typedef E *Ep; + (void)Ep((A*)0); // access control ignored + typedef E &Er; + (void)Er(*((A*)0)); // access control ignored + + // Bad code below + + typedef C1 *C1p; + (void)C1p((A*)0); // expected-error {{cannot cast 'A *' to 'C1p' (aka 'C1 *') via virtual base 'B'}} + typedef C1 &C1r; + (void)C1r(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1r' (aka 'C1 &') via virtual base 'B'}} + typedef D *Dp; + (void)Dp((A*)0); // expected-error {{cannot cast 'A *' to 'Dp' (aka 'D *') via virtual base 'B'}} + typedef D &Dr; + (void)Dr(*((A*)0)); // expected-error {{cannot cast 'A' to 'Dr' (aka 'D &') via virtual base 'B'}} + typedef H *Hp; + (void)Hp((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}} + typedef H &Hr; + (void)Hr(*((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}} + + // TODO: Test DR427. This requires user-defined conversions, though. +} + +// Enum conversions +void t_529_7() +{ + (void)Enum(1); + (void)Enum(1.0); + (void)Onom(En1); + + // Bad code below + + (void)Enum((int*)0); // expected-error {{functional-style cast from 'int *' to 'Enum' is not allowed}} +} + +// Void pointer to object pointer +void t_529_10() +{ + typedef int *intp; + (void)intp((void*)0); + typedef const A *cAp; + (void)cAp((void*)0); + (void)intp((const void*)0); // const_cast appended +} + +// Member pointer upcast. +void t_529_9() +{ + typedef int A::*Amp; + (void)Amp((int B::*)0); + + // Bad code below + (void)Amp((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}} + (void)Amp((int F::*)0); // expected-error {{conversion from pointer to member of class 'F' to pointer to member of class 'A' via virtual base 'B' is not allowed}} +} + +// -------- reinterpret_cast ----------- + +enum test { testval = 1 }; +struct structure { int m; }; +typedef void (*fnptr)(); + +// Test conversion between pointer and integral types, as in p3 and p4. +void integral_conversion() +{ + typedef void *voidp; + void *vp = voidp(testval); + long l = long(vp); + typedef float *floatp; + (void)floatp(l); + fnptr fnp = fnptr(l); + (void)char(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}} + (void)long(fnp); +} + +void pointer_conversion() +{ + int *p1 = 0; + typedef float *floatp; + float *p2 = floatp(p1); + typedef structure *structurep; + structure *p3 = structurep(p2); + typedef int **ppint; + typedef ppint *pppint; + ppint *deep = pppint(p3); + typedef fnptr fnptrp; + (void)fnptrp(deep); +} + +void constness() +{ + int ***const ipppc = 0; + typedef int const *icp_t; + int const *icp = icp_t(ipppc); + typedef int *intp; + (void)intp(icp); // const_cast appended + typedef int const *const ** intcpcpp; + intcpcpp icpcpp = intcpcpp(ipppc); // const_cast appended + int *ip = intp(icpcpp); + (void)icp_t(ip); + typedef int const *const *const *intcpcpcp; + (void)intcpcpcp(ipppc); +} + +void fnptrs() +{ + typedef int (*fnptr2)(int); + fnptr fp = 0; + (void)fnptr2(fp); + typedef void *voidp; + void *vp = voidp(fp); + (void)fnptr(vp); +} + +void refs() +{ + long l = 0; + typedef char &charr; + char &c = charr(l); + // Bad: from rvalue + typedef int &intr; + (void)intr(&c); // expected-error {{functional-style cast from rvalue to reference type 'intr' (aka 'int &')}} +} + +void memptrs() +{ + const int structure::*psi = 0; + typedef const float structure::*structurecfmp; + (void)structurecfmp(psi); + typedef int structure::*structureimp; + (void)structureimp(psi); // const_cast appended + + void (structure::*psf)() = 0; + typedef int (structure::*structureimfp)(); + (void)structureimfp(psf); + + typedef void (structure::*structurevmfp)(); + (void)structurevmfp(psi); // expected-error {{functional-style cast from 'const int structure::*' to 'structurevmfp' (aka 'void (structure::*)()') is not allowed}} + (void)structureimp(psf); // expected-error {{functional-style cast from 'void (structure::*)()' to 'structureimp' (aka 'int structure::*') is not allowed}} +} + +// ---------------- misc ------------------ + +void crash_on_invalid_1() +{ + typedef itn Typo; // expected-error {{unknown type name 'itn'}} + (void)Typo(1); // used to crash + + typedef int &int_ref; + (void)int_ref(); // expected-error {{reference to type 'int' requires an initializer}} +} diff --git a/clang/test/SemaCXX/generic-selection.cpp b/clang/test/SemaCXX/generic-selection.cpp new file mode 100644 index 0000000..c0a5d89 --- /dev/null +++ b/clang/test/SemaCXX/generic-selection.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -std=c++11 -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/clang/test/SemaCXX/gnu-case-ranges.cpp b/clang/test/SemaCXX/gnu-case-ranges.cpp new file mode 100644 index 0000000..b082e3a --- /dev/null +++ b/clang/test/SemaCXX/gnu-case-ranges.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -verify -Wno-covered-switch-default %s + +enum E { + one, + two, + three, + four +}; + + +int test(enum E e) +{ + switch (e) + { + case one: + return 7; + case two ... two + 1: + return 42; + case four: + return 25; + default: + return 0; + } +} diff --git a/clang/test/SemaCXX/goto.cpp b/clang/test/SemaCXX/goto.cpp new file mode 100644 index 0000000..24bcb7c --- /dev/null +++ b/clang/test/SemaCXX/goto.cpp @@ -0,0 +1,127 @@ +// 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; +} + +namespace PR10620 { + struct S { + ~S() {} + }; + void g(const S& s) { + goto done; // expected-error {{goto into protected scope}} + const S s2(s); // expected-note {{jump bypasses variable initialization}} + done: + ; + } +} + +namespace test12 { + struct A { A(); A(const A&); ~A(); }; + void test(A a) { // expected-note {{jump enters lifetime of block}} FIXME: wierd location + goto lbl; // expected-error {{goto into protected scope}} + (void) ^{ (void) a; }; + lbl: + return; + } +} diff --git a/clang/test/SemaCXX/goto2.cpp b/clang/test/SemaCXX/goto2.cpp new file mode 100644 index 0000000..01ea031 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/i-c-e-cxx.cpp b/clang/test/SemaCXX/i-c-e-cxx.cpp new file mode 100644 index 0000000..5631577 --- /dev/null +++ b/clang/test/SemaCXX/i-c-e-cxx.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s + +// C++-specific tests for integral constant expressions. + +const int c = 10; +int ar[c]; + +struct X0 { + static const int value = static_cast<int>(4.0); +}; + +void f() { + if (const int value = 17) { + int array[value]; + } +} + +int a() { + const int t=t; // expected-note {{declared here}} + switch(1) { // expected-warning {{no case matching constant switch condition '1'}} + case t:; // expected-error {{not an integral constant expression}} expected-note {{initializer of 't' is not a constant expression}} + } +} + +// PR6206: out-of-line definitions are legit +namespace pr6206 { + class Foo { + public: + static const int kBar; + }; + + const int Foo::kBar = 20; + + char Test() { + char str[Foo::kBar]; + str[0] = '0'; + return str[0]; + } +} + +// PR6373: default arguments don't count. +void pr6373(const unsigned x = 0) { + unsigned max = 80 / x; +} + + +// rdar://9204520 +namespace rdar9204520 { + +struct A { + static const int B = int(0.75 * 1000 * 1000); // expected-warning {{not a constant expression; folding it to a constant is a GNU extension}} +}; + +int foo() { return A::B; } +} + +// PR11040 +const int x = 10; +int* y = reinterpret_cast<const char&>(x); // expected-error {{cannot initialize}} + +// This isn't an integral constant expression, but make sure it folds anyway. +struct PR8836 { char _; long long a; }; // expected-warning {{long long}} +int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const volatile char&>((((PR8836*)0)->a))]; // expected-warning {{folded to constant array as an extension}} expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + +const int nonconst = 1.0; // expected-note {{declared here}} +int arr[nonconst]; // expected-warning {{folded to constant array as an extension}} expected-note {{initializer of 'nonconst' is not a constant expression}} +const int castfloat = static_cast<int>(1.0); +int arr2[castfloat]; // ok diff --git a/clang/test/SemaCXX/illegal-member-initialization.cpp b/clang/test/SemaCXX/illegal-member-initialization.cpp new file mode 100644 index 0000000..87069ef --- /dev/null +++ b/clang/test/SemaCXX/illegal-member-initialization.cpp @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A { + A() : value(), cvalue() { } // expected-error {{reference to type 'int' requires an initializer}} + int &value; + const int cvalue; +}; + +struct B { +}; + +struct X { + X() { } // expected-error {{constructor for 'X' must explicitly initialize the reference member 'value'}} \ + // expected-error {{constructor for 'X' must explicitly initialize the const member 'cvalue'}} \ + // expected-error {{constructor for 'X' must explicitly initialize the reference member 'b'}} \ + // expected-error {{constructor for 'X' must explicitly initialize the const member 'cb'}} + int &value; // expected-note{{declared here}} + const int cvalue; // expected-note{{declared here}} + B& b; // expected-note{{declared here}} + const B cb; // expected-note{{declared here}} +}; + + +// PR5924 +struct bar {}; +bar xxx(); + +struct foo { + foo_t a; // expected-error {{unknown type name 'foo_t'}} + foo() : a(xxx()) {} // no error here. +}; diff --git a/clang/test/SemaCXX/implicit-exception-spec.cpp b/clang/test/SemaCXX/implicit-exception-spec.cpp new file mode 100644 index 0000000..25316f8 --- /dev/null +++ b/clang/test/SemaCXX/implicit-exception-spec.cpp @@ -0,0 +1,89 @@ +// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s + +template<bool b> struct ExceptionIf { static int f(); }; +template<> struct ExceptionIf<false> { typedef int f; }; + +// The exception specification of a defaulted default constructor depends on +// the contents of in-class member initializers. However, the in-class member +// initializers can depend on the exception specification of the constructor, +// since the class is considered complete within them. We reject any such cases. +namespace InClassInitializers { + // Noexcept::Noexcept() is implicitly declared as noexcept(false), because it + // directly invokes ThrowSomething(). However... + // + // If noexcept(Noexcept()) is false, then Noexcept() is a constant expression, + // so noexcept(Noexcept()) is true. But if noexcept(Noexcept()) is true, then + // Noexcept::Noexcept is not declared constexpr, therefore noexcept(Noexcept()) + // is false. + bool ThrowSomething() noexcept(false); + struct ConstExpr { + bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{exception specification is not available until end of class definition}} + }; + // We can use it now. + bool w = noexcept(ConstExpr()); + + // Much more obviously broken: we can't parse the initializer without already + // knowing whether it produces a noexcept expression. + struct TemplateArg { + int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{exception specification is not available until end of class definition}} + }; + bool x = noexcept(TemplateArg()); + + // And within a nested class. + struct Nested { + struct Inner { + int n = ExceptionIf<noexcept(Nested())>::f(); // expected-error {{exception specification is not available until end of class definition}} + } inner; + }; + bool y = noexcept(Nested()); + bool z = noexcept(Nested::Inner()); +} + +namespace ExceptionSpecification { + // A type is permitted to be used in a dynamic exception specification when it + // is still being defined, but isn't complete within such an exception + // specification. + struct Nested { // expected-note {{not complete}} + struct T { + T() noexcept(!noexcept(Nested())); // expected-error{{incomplete type}} + } t; + }; +} + +namespace DefaultArgument { + struct Default { + struct T { + T(int = ExceptionIf<noexcept(Default())::f()); // expected-error {{call to implicitly-deleted default constructor}} + } t; // expected-note {{has no default constructor}} + }; +} + +namespace ImplicitDtorExceptionSpec { + struct A { + virtual ~A(); + + struct Inner { + ~Inner() throw(); + }; + Inner inner; + }; + + struct B { + virtual ~B() {} // expected-note {{here}} + }; + + struct C : B { + virtual ~C() {} + A a; + }; + + struct D : B { + ~D(); // expected-error {{more lax than base}} + struct E { + ~E(); + struct F { + ~F() throw(A); + } f; + } e; + }; +} diff --git a/clang/test/SemaCXX/implicit-int.cpp b/clang/test/SemaCXX/implicit-int.cpp new file mode 100644 index 0000000..9711adf --- /dev/null +++ b/clang/test/SemaCXX/implicit-int.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +x; // expected-error{{C++ requires a type specifier for all declarations}} + +f(int y) { return y; } // expected-error{{C++ requires a type specifier for all declarations}} diff --git a/clang/test/SemaCXX/implicit-member-functions.cpp b/clang/test/SemaCXX/implicit-member-functions.cpp new file mode 100644 index 0000000..8451739 --- /dev/null +++ b/clang/test/SemaCXX/implicit-member-functions.cpp @@ -0,0 +1,52 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A { }; +A::A() { } // expected-error {{definition of implicitly declared default constructor}} + +struct B { }; +B::B(const B&) { } // expected-error {{definition of implicitly declared copy constructor}} + +struct C { }; +C& C::operator=(const C&) { return *this; } // expected-error {{definition of implicitly declared copy assignment operator}} + +struct D { }; +D::~D() { } // expected-error {{definition of implicitly declared destructor}} + +// Make sure that the special member functions are introduced for +// name-lookup purposes and overload with user-declared +// constructors and assignment operators. +namespace PR6570 { + class A { }; + + class B { + public: + B() {} + + B(const A& a) { + operator = (CONST); + operator = (a); + } + + B& operator = (const A& a) { + return *this; + } + + void f(const A &a) { + B b(a); + }; + + static const B CONST; + }; + +} + +namespace PR7594 { + // If the lazy declaration of special member functions is triggered + // in an out-of-line initializer, make sure the functions aren't in + // the initializer scope. This used to crash Clang: + struct C { + C(); + static C *c; + }; + C *C::c = new C(); +} diff --git a/clang/test/SemaCXX/implicit-virtual-member-functions.cpp b/clang/test/SemaCXX/implicit-virtual-member-functions.cpp new file mode 100644 index 0000000..f6082e5 --- /dev/null +++ b/clang/test/SemaCXX/implicit-virtual-member-functions.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A { + virtual ~A(); +}; + +struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}} + virtual void f(); + + void operator delete (void *, int); // expected-note {{'operator delete' declared here}} +}; + +void B::f() { // expected-note {{implicit default destructor for 'B' first required here}} +} + +struct C : A { // expected-error {{no suitable member 'operator delete' in 'C'}} + C(); + void operator delete(void *, int); // expected-note {{'operator delete' declared here}} +}; + +C::C() { } // expected-note {{implicit default destructor for 'C' first required here}} + +struct D : A { // expected-error {{no suitable member 'operator delete' in 'D'}} + void operator delete(void *, int); // expected-note {{'operator delete' declared here}} +}; + +void f() { + new D; // expected-note {{implicit default destructor for 'D' first required here}} +} + diff --git a/clang/test/SemaCXX/incomplete-call.cpp b/clang/test/SemaCXX/incomplete-call.cpp new file mode 100644 index 0000000..69eb03a --- /dev/null +++ b/clang/test/SemaCXX/incomplete-call.cpp @@ -0,0 +1,49 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A; // expected-note 14 {{forward declaration of 'A'}} + +A f(); // expected-note {{'f' declared here}} + +struct B { + A f(); // expected-note {{'f' declared here}} + A operator()(); // expected-note 2 {{'operator()' declared here}} + operator A(); // expected-note {{'operator A' declared here}} + A operator!(); // expected-note 2 {{'operator!' declared here}} + A operator++(int); // expected-note {{'operator++' declared here}} + A operator[](int); // expected-note {{'operator[]' declared here}} + A operator+(int); // expected-note {{'operator+' declared here}} + A operator->(); // expected-note {{'operator->' declared here}} +}; + +void g() { + f(); // expected-error {{calling 'f' with incomplete return type 'A'}} + + typedef A (*Func)(); + Func fp; + fp(); // expected-error {{calling function with incomplete return type 'A'}} + ((Func)0)(); // expected-error {{calling function with incomplete return type 'A'}} + + B b; + b.f(); // expected-error {{calling 'f' with incomplete return type 'A'}} + + b.operator()(); // expected-error {{calling 'operator()' with incomplete return type 'A'}} + b.operator A(); // expected-error {{calling 'operator A' with incomplete return type 'A'}} + b.operator!(); // expected-error {{calling 'operator!' with incomplete return type 'A'}} + + !b; // expected-error {{calling 'operator!' with incomplete return type 'A'}} + b(); // expected-error {{calling 'operator()' with incomplete return type 'A'}} + b++; // expected-error {{calling 'operator++' with incomplete return type 'A'}} + b[0]; // expected-error {{calling 'operator[]' with incomplete return type 'A'}} + b + 1; // expected-error {{calling 'operator+' with incomplete return type 'A'}} + b->f(); // expected-error {{calling 'operator->' with incomplete return type 'A'}} + + A (B::*mfp)() = 0; + (b.*mfp)(); // expected-error {{calling function with incomplete return type 'A'}} + +} + + +struct C; // expected-note{{forward declaration}} + +void test_incomplete_object_call(C& c) { + c(); // expected-error{{incomplete type in call to object of type}} +} diff --git a/clang/test/SemaCXX/increment-decrement.cpp b/clang/test/SemaCXX/increment-decrement.cpp new file mode 100644 index 0000000..11b7d1e --- /dev/null +++ b/clang/test/SemaCXX/increment-decrement.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +volatile int i; + +const int &inc = i++; +const int &dec = i--; + +const int &incfail = ++i; // expected-error {{drops qualifiers}} +const int &decfail = --i; // expected-error {{drops qualifiers}} + +// PR7794 +void f0(int e) { + ++(int&)e; +} diff --git a/clang/test/SemaCXX/indirect-goto.cpp b/clang/test/SemaCXX/indirect-goto.cpp new file mode 100644 index 0000000..5b3fac4 --- /dev/null +++ b/clang/test/SemaCXX/indirect-goto.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace test1 { + // Make sure this doesn't crash. + struct A { ~A(); }; + void a() { goto *(A(), &&L); L: return; } +} diff --git a/clang/test/SemaCXX/inherit.cpp b/clang/test/SemaCXX/inherit.cpp new file mode 100644 index 0000000..a926c81 --- /dev/null +++ b/clang/test/SemaCXX/inherit.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class A { }; + +class B1 : A { }; + +class B2 : virtual A { }; + +class B3 : virtual virtual A { }; // expected-error{{duplicate 'virtual' in base specifier}} + +class C : public B1, private B2 { }; + + +class D; // expected-note {{forward declaration of 'D'}} + +class E : public D { }; // expected-error{{base class has incomplete type}} + +typedef int I; + +class F : public I { }; // expected-error{{base specifier must name a class}} + +union U1 : public A { }; // expected-error{{unions cannot have base classes}} + +union U2 {}; + +class G : public U2 { }; // expected-error{{unions cannot be base classes}} + +typedef G G_copy; +typedef G G_copy_2; +typedef G_copy G_copy_3; + +class H : G_copy, A, G_copy_2, // expected-error{{base class 'G_copy' (aka 'G') specified more than once as a direct base class}} + public G_copy_3 { }; // expected-error{{base class 'G_copy' (aka 'G') specified more than once as a direct base class}} diff --git a/clang/test/SemaCXX/init-priority-attr.cpp b/clang/test/SemaCXX/init-priority-attr.cpp new file mode 100644 index 0000000..6facebf --- /dev/null +++ b/clang/test/SemaCXX/init-priority-attr.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class Two { +private: + int i, j, k; +public: + static int count; + Two( int ii, int jj ) { i = ii; j = jj; k = count++; }; + Two( void ) { i = 0; j = 0; k = count++; }; + int eye( void ) { return i; }; + int jay( void ) { return j; }; + int kay( void ) { return k; }; +}; + +extern Two foo; +extern Two goo; +extern Two coo[]; +extern Two koo[]; + +Two foo __attribute__((init_priority(101))) ( 5, 6 ); + +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}} + +Two koo[4] __attribute__((init_priority(1.13))); // expected-error {{'init_priority' attribute requires integer constant}} + + +Two func() __attribute__((init_priority(1001))); // expected-error {{can only use 'init_priority' attribute on file-scope definitions of objects of class type}} + +int i __attribute__((init_priority(1001))); // expected-error {{can only use 'init_priority' attribute on file-scope definitions of objects of class type}} + +int main() { + Two foo __attribute__((init_priority(1001))); // expected-error {{can only use 'init_priority' attribute on file-scope definitions of objects of class type}} +} + diff --git a/clang/test/SemaCXX/inline.cpp b/clang/test/SemaCXX/inline.cpp new file mode 100644 index 0000000..e569300 --- /dev/null +++ b/clang/test/SemaCXX/inline.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Check that we don't allow illegal uses of inline +// (checking C++-only constructs here) +struct c {inline int a;}; // expected-error{{'inline' can only appear on functions}} diff --git a/clang/test/SemaCXX/instantiate-blocks.cpp b/clang/test/SemaCXX/instantiate-blocks.cpp new file mode 100644 index 0000000..bb0f8d8 --- /dev/null +++ b/clang/test/SemaCXX/instantiate-blocks.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fblocks -fsyntax-only -verify %s +// rdar: // 6182276 + +template <typename T, typename T1> void foo(T t, T1 r) +{ + T block_arg; + __block T1 byref_block_arg; + + T1 (^block)(T) = ^ T1 (T arg) { + byref_block_arg = arg; + block_arg = arg; // expected-error {{variable is not assignable (missing __block type specifier)}} + return block_arg+arg; }; +} + +// rdar://10466373 +template <typename T, typename T1> void noret(T t, T1 r) +{ + (void) ^{ + if (1) + return t; + else if (2) + return r; // expected-error {{return type 'double' must match previous return type 'float' when block literal has unspecified explicit return type}} + }; +} + +int main(void) +{ + foo(100, 'a'); // expected-note {{in instantiation of function template specialization 'foo<int, char>' requested here}} + + noret((float)0.0, double(0.0)); // expected-note {{in instantiation of function template specialization 'noret<float, double>' requested here}} +} + diff --git a/clang/test/SemaCXX/invalid-instantiated-field-decl.cpp b/clang/test/SemaCXX/invalid-instantiated-field-decl.cpp new file mode 100644 index 0000000..8b26489 --- /dev/null +++ b/clang/test/SemaCXX/invalid-instantiated-field-decl.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template <typename T> +class SmallVectorImpl { +public: + explicit SmallVectorImpl(unsigned N) { + } + + ~SmallVectorImpl() { } + +}; + +template <typename T, unsigned N> +class SmallVector : public SmallVectorImpl<T> { + typedef typename SmallVectorImpl<T>::U U; // expected-error {{no type named 'U' in 'SmallVectorImpl<CallSite>'}} + enum { + + MinUs = (static_cast<unsigned int>(sizeof(T))*N + // expected-error {{invalid application of 'sizeof' to an incomplete type 'CallSite'}} + static_cast<unsigned int>(sizeof(U)) - 1) / + static_cast<unsigned int>(sizeof(U)), + NumInlineEltsElts = MinUs + }; + U InlineElts[NumInlineEltsElts]; +public: + SmallVector() : SmallVectorImpl<T>(NumInlineEltsElts) { + } + +}; + +class CallSite; // expected-note {{forward declaration of 'CallSite'}} +class InlineFunctionInfo { +public: + explicit InlineFunctionInfo() {} + SmallVector<CallSite, 2> DevirtualizedCalls; // expected-note {{in instantiation of template class 'SmallVector<CallSite, 2>' requested}} +}; diff --git a/clang/test/SemaCXX/invalid-member-expr.cpp b/clang/test/SemaCXX/invalid-member-expr.cpp new file mode 100644 index 0000000..287d9af --- /dev/null +++ b/clang/test/SemaCXX/invalid-member-expr.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class X {}; + +void test() { + X x; + + x.int; // expected-error{{expected unqualified-id}} + x.~int(); // expected-error{{expected a class name}} + x.operator; // expected-error{{expected a type}} + x.operator typedef; // expected-error{{expected a type}} expected-error{{type name does not allow storage class}} +} + +void test2() { + X *x; + + x->int; // expected-error{{expected unqualified-id}} + x->~int(); // expected-error{{expected a class name}} + x->operator; // expected-error{{expected a type}} + x->operator typedef; // expected-error{{expected a type}} expected-error{{type name does not allow storage class}} +} + +// PR6327 +namespace test3 { + template <class A, class B> struct pair {}; + + void test0() { + pair<int, int> z = minmax({}); // expected-error {{expected expression}} + } + + struct string { + class iterator {}; + }; + + void test1() { + string s; + string::iterator i = s.foo(); // expected-error {{no member named 'foo'}} + } +} diff --git a/clang/test/SemaCXX/invalid-template-specifier.cpp b/clang/test/SemaCXX/invalid-template-specifier.cpp new file mode 100644 index 0000000..bcd6da7 --- /dev/null +++ b/clang/test/SemaCXX/invalid-template-specifier.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +// PR4809 +// This test is primarily checking that this doesn't crash, not the particular +// diagnostics. + +const template basic_istream<char>; // expected-error {{expected unqualified-id}} + +namespace S {} +template <class X> class Y { + void x() { S::template y<char>(1); } // expected-error {{does not refer to a template}} \ + // expected-error {{unqualified-id}} +}; diff --git a/clang/test/SemaCXX/issue547.cpp b/clang/test/SemaCXX/issue547.cpp new file mode 100644 index 0000000..ab03a15 --- /dev/null +++ b/clang/test/SemaCXX/issue547.cpp @@ -0,0 +1,66 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +template<typename T> +struct classify_function { + static const unsigned value = 0; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args...)> { + static const unsigned value = 1; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args...) const> { + static const unsigned value = 2; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args...) volatile> { + static const unsigned value = 3; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args...) const volatile> { + static const unsigned value = 4; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......)> { + static const unsigned value = 5; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......) const> { + static const unsigned value = 6; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......) volatile> { + static const unsigned value = 7; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......) const volatile> { + static const unsigned value = 8; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......) &&> { + static const unsigned value = 9; +}; + +template<typename R, typename ...Args> +struct classify_function<R(Args......) const &> { + static const unsigned value = 10; +}; + +typedef void f0(int) const; +typedef void f1(int, float...) const volatile; +typedef void f2(int, double, ...) &&; +typedef void f3(int, double, ...) const &; + +int check0[classify_function<f0>::value == 2? 1 : -1]; +int check1[classify_function<f1>::value == 8? 1 : -1]; +int check2[classify_function<f2>::value == 9? 1 : -1]; +int check3[classify_function<f3>::value == 10? 1 : -1]; diff --git a/clang/test/SemaCXX/lambda-expressions.cpp b/clang/test/SemaCXX/lambda-expressions.cpp new file mode 100644 index 0000000..e91dee9 --- /dev/null +++ b/clang/test/SemaCXX/lambda-expressions.cpp @@ -0,0 +1,150 @@ +// RUN: %clang_cc1 -std=c++0x -Wno-unused-value -fsyntax-only -verify -fblocks %s + +namespace std { class type_info; }; + +namespace ExplicitCapture { + class C { + int Member; + + static void Overload(int); + void Overload(); + virtual C& Overload(float); + + void ImplicitThisCapture() { + [](){(void)Member;}; // expected-error {{'this' cannot be implicitly captured in this context}} + [&](){(void)Member;}; + + [this](){(void)Member;}; + [this]{[this]{};}; + []{[this]{};};// expected-error {{'this' cannot be implicitly captured in this context}} + []{Overload(3);}; + []{Overload();}; // expected-error {{'this' cannot be implicitly captured in this context}} + []{(void)typeid(Overload());}; + []{(void)typeid(Overload(.5f));};// expected-error {{'this' cannot be implicitly captured in this context}} + } + }; + + void f() { + [this] () {}; // expected-error {{'this' cannot be captured in this context}} + } +} + +namespace ReturnDeduction { + void test() { + [](){ return 1; }; + [](){ return 1; }; + [](){ return ({return 1; 1;}); }; + [](){ return ({return 'c'; 1;}); }; // expected-error {{must match previous return type}} \ + // expected-warning{{omitted result type}} + []()->int{ return 'c'; return 1; }; + [](){ return 'c'; return 1; }; // expected-error {{must match previous return type}} + []() { return; return (void)0; }; + [](){ return 1; return 1; }; // expected-warning{{omitted result type}} + } +} + +namespace ImplicitCapture { + void test() { + int a = 0; // expected-note 5 {{declared}} + []() { return a; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{begins here}} + [&]() { return a; }; + [=]() { return a; }; + [=]() { int* b = &a; }; // expected-error {{cannot initialize a variable of type 'int *' with an rvalue of type 'const int *'}} + [=]() { return [&]() { return a; }; }; + []() { return [&]() { return a; }; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} + []() { return ^{ return a; }; };// expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} + []() { return [&a] { return a; }; }; // expected-error 2 {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note 2 {{lambda expression begins here}} + [=]() { return [&a] { return a; }; }; // + + const int b = 2; + []() { return b; }; + + union { // expected-note {{declared}} + int c; + float d; + }; + d = 3; + [=]() { return c; }; // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}} + + __block int e; // expected-note 3 {{declared}} + [&]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}} + [&e]() { return e; }; // expected-error 2 {{__block variable 'e' cannot be captured in a lambda expression}} + + int f[10]; // expected-note {{declared}} + [&]() { return f[2]; }; + (void) ^{ return []() { return f[2]; }; }; // expected-error {{variable 'f' cannot be implicitly captured in a lambda with no capture-default specified}} \ + // expected-note{{lambda expression begins here}} + + struct G { G(); G(G&); int a; }; // expected-note 6 {{not viable}} + G g; + [=]() { const G* gg = &g; return gg->a; }; // expected-warning{{omitted result type}} + [=]() { return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error {{no matching constructor for initialization of 'ImplicitCapture::G'}} \ + // expected-warning{{omitted result type}} + (void)^{ return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error 2 {{no matching constructor for initialization of 'const ImplicitCapture::G'}} \ + // expected-warning{{omitted result type}} + + const int h = a; // expected-note {{declared}} + []() { return h; }; // expected-error {{variable 'h' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} + + // The exemption for variables which can appear in constant expressions + // applies only to objects (and not to references). + // FIXME: This might be a bug in the standard. + static int i; + constexpr int &ref_i = i; // expected-note {{declared}} + [] { return ref_i; }; // expected-error {{variable 'ref_i' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} + } +} + +namespace PR12031 { + struct X { + template<typename T> + X(const T&); + ~X(); + }; + + void f(int i, X x); + void g() { + const int v = 10; + f(v, [](){}); + } +} + +namespace NullPtr { + int &f(int *p); + char &f(...); + void g() { + int n = 0; + [=] { + char &k = f(n); // not a null pointer constant + } (); + + const int m = 0; + [=] { + int &k = f(m); // a null pointer constant + } (); + + [=] () -> bool { + int &k = f(m); // a null pointer constant + return &m == 0; + } (); + + [m] { + int &k = f(m); // a null pointer constant + } (); + } +} + +void PR12248() +{ + unsigned int result = 0; + auto l = [&]() { ++result; }; +} + +namespace ModifyingCapture { + void test() { + int n = 0; + [=] { + n = 1; // expected-error {{cannot assign to a variable captured by copy in a non-mutable lambda}} + }; + } +} diff --git a/clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp b/clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp new file mode 100644 index 0000000..3ac2336 --- /dev/null +++ b/clang/test/SemaCXX/libstdcxx_is_pod_hack.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +// This is a test for an egregious hack in Clang that works around +// issues with GCC's evolution. libstdc++ 4.2.x uses __is_pod as an +// identifier (to declare a struct template like the one below), while +// GCC 4.3 and newer make __is_pod a keyword. Clang treats __is_pod as +// a keyword *unless* it is introduced following the struct keyword. + +template<typename T> +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; + +#if __has_feature(is_pod) +# error __is_pod won't work now anyway +#endif diff --git a/clang/test/SemaCXX/libstdcxx_map_base_hack.cpp b/clang/test/SemaCXX/libstdcxx_map_base_hack.cpp new file mode 100644 index 0000000..a556281 --- /dev/null +++ b/clang/test/SemaCXX/libstdcxx_map_base_hack.cpp @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +// libstdc++ 4.2.x contains a bug where a friend struct template +// declaration for std::tr1::__detail::_Map base has different +// template arguments than the real declaration. Clang has an +// egregious hack to work around this problem, since we can't modify +// all of the world's libstdc++'s. + +namespace std { namespace tr1 { namespace __detail { + template<typename _Key, typename _Value, typename _Ex, bool __unique, + typename _Hashtable> + struct _Map_base { }; + +} } } + +namespace std { namespace tr1 { + template<typename T> + struct X1 { + template<typename _Key2, typename _Pair, typename _Hashtable> + friend struct __detail::_Map_base; + }; + +} } + +std::tr1::X1<int> x1i; diff --git a/clang/test/SemaCXX/linkage-spec.cpp b/clang/test/SemaCXX/linkage-spec.cpp new file mode 100644 index 0000000..cb7e32c --- /dev/null +++ b/clang/test/SemaCXX/linkage-spec.cpp @@ -0,0 +1,104 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +extern "C" { + extern "C" void f(int); +} + +extern "C++" { + extern "C++" int& g(int); + float& g(); +} +double& g(double); + +void test(int x, double d) { + f(x); + float &f1 = g(); + int& i1 = g(x); + double& d1 = g(d); +} + +extern "C" int foo; +extern "C" int foo; + +extern "C" const int bar; +extern "C" int const bar; + +// <rdar://problem/6895431> +extern "C" struct bar d; +extern struct bar e; + +extern "C++" { + namespace N0 { + struct X0 { + int foo(int x) { return x; } + }; + } +} + +// PR5430 +namespace pr5430 { + extern "C" void func(void); +} +using namespace pr5430; +extern "C" void pr5430::func(void) { } + +// PR5404 +int f2(char *) +{ + return 0; +} + +extern "C" +{ + int f2(int) + { + return f2((char *)0); + } +} + +// PR6991 +extern "C" typedef int (*PutcFunc_t)(int); + + +// PR7859 +extern "C" void pr7859_a(int) {} // expected-note {{previous definition}} +extern "C" void pr7859_a(int) {} // expected-error {{redefinition}} + +extern "C" void pr7859_b() {} // expected-note {{previous definition}} +extern "C" void pr7859_b(int) {} // expected-error {{conflicting}} + +extern "C" void pr7859_c(short) {} // expected-note {{previous definition}} +extern "C" void pr7859_c(int) {} // expected-error {{conflicting}} + +// <rdar://problem/8318976> +extern "C" { + struct s0 { + private: + s0(); + s0(const s0 &); + }; +} + +//PR7754 +extern "C++" template <class T> int pr7754(T param); + +namespace N { + int value; +} + +extern "C++" using N::value; + +// PR7076 +extern "C" const char *Version_string = "2.9"; + +namespace PR9162 { + extern "C" { + typedef struct _ArtsSink ArtsSink; + struct _ArtsSink { + int sink; + }; + } + int arts_sink_get_type() + { + return sizeof(ArtsSink); + } +} diff --git a/clang/test/SemaCXX/linkage.cpp b/clang/test/SemaCXX/linkage.cpp new file mode 100644 index 0000000..6b73d59 --- /dev/null +++ b/clang/test/SemaCXX/linkage.cpp @@ -0,0 +1,96 @@ +// This is an IR generation test because the calculation of visibility +// during IR gen will cause linkage to be implicitly recomputed and +// compared against the earlier cached value. If we had a way of +// testing linkage directly in Sema, that would be better. + +// RUN: %clang_cc1 -Werror -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck %s + +// PR8926 +namespace test0 { + typedef struct { + void *foo() { return 0; } + } A; + + // CHECK: define linkonce_odr i8* @_ZN5test01A3fooEv( + + void test(A *a) { + a->foo(); + } +} + +namespace test1 { + typedef struct { + template <unsigned n> void *foo() { return 0; } + + void foo() { + foo<0>(); + } + } A; + + // CHECK: define linkonce_odr void @_ZN5test11A3fooEv( + // another at the end + + void test(A *a) { + a->foo(); + } +} + +namespace test2 { + typedef struct { + template <unsigned n> struct B { + void *foo() { return 0; } + }; + + void foo(B<0> *b) { + b->foo(); + } + } A; + + // CHECK: define linkonce_odr void @_ZN5test21A3fooEPNS0_1BILj0EEE( + + void test(A *a) { + a->foo(0); + } +} + +namespace test3 { + namespace { struct A {}; } + + // CHECK: define internal void @_ZN5test34testENS_12_GLOBAL__N_11AE( + void test(A a) {} + void force() { test(A()); } + + // CHECK: define void @test3( + extern "C" void test3(A a) {} +} + +namespace { + // CHECK: define void @test4( + extern "C" void test4(void) {} +} + +// PR9316: Ensure that even non-namespace-scope function declarations in +// a C declaration context respect that over the anonymous namespace. +extern "C" { + namespace { + struct X { + int f() { + extern int g(); + extern int a; + + // Test both for mangling in the code generation and warnings from use + // of internal, undefined names via -Werror. + // CHECK: call i32 @g( + // CHECK: load i32* @a, + return g() + a; + } + }; + } + // Force the above function to be emitted by codegen. + int test(X& x) { + return x.f(); + } +} + +// CHECK: define linkonce_odr i8* @_ZN5test21A1BILj0EE3fooEv( +// CHECK: define linkonce_odr i8* @_ZN5test11A3fooILj0EEEPvv( diff --git a/clang/test/SemaCXX/literal-operators.cpp b/clang/test/SemaCXX/literal-operators.cpp new file mode 100644 index 0000000..7f68cd3 --- /dev/null +++ b/clang/test/SemaCXX/literal-operators.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +#include <stddef.h> + +struct tag { + void operator "" _tag_bad (const char *); // expected-error {{literal operator 'operator "" _tag_bad' must be in a namespace or global scope}} + friend void operator "" _tag_good (const char *); +}; + +namespace ns { void operator "" _ns_good (const char *); } + +// Check extern "C++" declarations +extern "C++" void operator "" _extern_good (const char *); +extern "C++" { void operator "" _extern_good (const char *); } + +void fn () { void operator "" _fn_good (const char *); } + +// One-param declarations (const char * was already checked) +void operator "" _good (char); +void operator "" _good (wchar_t); +void operator "" _good (char16_t); +void operator "" _good (char32_t); +void operator "" _good (unsigned long long); +void operator "" _good (long double); + +// Two-param declarations +void operator "" _good (const char *, size_t); +void operator "" _good (const wchar_t *, size_t); +void operator "" _good (const char16_t *, size_t); +void operator "" _good (const char32_t *, size_t); + +// Check typedef and array equivalences +void operator "" _good (const char[]); +typedef const char c; +void operator "" _good (c*); + +// Check extra cv-qualifiers +void operator "" _cv_good (volatile const char *, const size_t); // expected-error {{parameter declaration for literal operator 'operator "" _cv_good' is not valid}} + +// Template declaration +template <char...> void operator "" _good (); + +// FIXME: Test some invalid decls that might crop up. diff --git a/clang/test/SemaCXX/literal-type.cpp b/clang/test/SemaCXX/literal-type.cpp new file mode 100644 index 0000000..14a4094 --- /dev/null +++ b/clang/test/SemaCXX/literal-type.cpp @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %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"); +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 +// [DR1452 adds class types with trivial default constructors to +// this list] +// -- 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 NonLiteral { NonLiteral(); }; +struct HasNonLiteralBase : NonLiteral {}; +struct HasNonLiteralMember { HasDtor x; }; + +static_assert(__is_literal(Empty), "fail"); +static_assert(__is_literal(LiteralType), "fail"); +static_assert(__is_literal(NonAggregate), "fail"); +static_assert(!__is_literal(NonLiteral), "fail"); +static_assert(!__is_literal(HasDtor), "fail"); +static_assert(!__is_literal(HasNonLiteralBase), "fail"); +static_assert(!__is_literal(HasNonLiteralMember), "fail"); + +// DR1361 removes the brace-or-equal-initializer bullet so that we can allow: +extern int f(); // expected-note {{here}} +struct HasNonConstExprMemInit { + int x = f(); // expected-note {{non-constexpr function}} + constexpr HasNonConstExprMemInit() {} // expected-error {{never produces a constant expression}} + constexpr HasNonConstExprMemInit(int y) : x(y) {} // ok +}; +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) {} +}; +template <typename T> class HasConstExprCtorT { + constexpr HasConstExprCtorT(T) {} +}; +static_assert(__is_literal(HasConstExprCtor), "fail"); +static_assert(__is_literal(HasConstExprCtorTemplate<int>), "fail"); +static_assert(__is_literal(HasConstExprCtorT<NonLiteral>), "fail"); diff --git a/clang/test/SemaCXX/local-classes.cpp b/clang/test/SemaCXX/local-classes.cpp new file mode 100644 index 0000000..500b219 --- /dev/null +++ b/clang/test/SemaCXX/local-classes.cpp @@ -0,0 +1,41 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace PR6382 { + int foo() + { + goto error; + { + struct BitPacker { + BitPacker() {} + }; + BitPacker packer; + } + + error: + return -1; + } +} + +namespace PR6383 { + void test (bool gross) + { + struct compare_and_set + { + void operator() (const bool inner, const bool gross = false) + { + // the code + } + } compare_and_set2; + + compare_and_set2 (false, gross); + } +} + +namespace Templates { + template<int Value> + void f() { + struct Inner { + static int getValue() { return Value; } + }; + } +} diff --git a/clang/test/SemaCXX/lookup-member.cpp b/clang/test/SemaCXX/lookup-member.cpp new file mode 100644 index 0000000..c75b185 --- /dev/null +++ b/clang/test/SemaCXX/lookup-member.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace A { + class String; +}; + +using A::String; +class String; + +// rdar://8603569 +union value { +char *String; +}; diff --git a/clang/test/SemaCXX/member-class-11.cpp b/clang/test/SemaCXX/member-class-11.cpp new file mode 100644 index 0000000..c230c53 --- /dev/null +++ b/clang/test/SemaCXX/member-class-11.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +struct rdar9677163 { + struct Y { ~Y(); }; + struct Z { ~Z(); }; + Y::~Y() { } // expected-error{{non-friend class member '~Y' cannot have a qualified name}} + ~Z(); // expected-error{{expected the class name after '~' to name the enclosing class}} +}; diff --git a/clang/test/SemaCXX/member-expr-anonymous-union.cpp b/clang/test/SemaCXX/member-expr-anonymous-union.cpp new file mode 100644 index 0000000..6e35eb2 --- /dev/null +++ b/clang/test/SemaCXX/member-expr-anonymous-union.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +// PR5543 + +struct A { int x; union { int* y; float* z; }; }; struct B : A {int a;}; +int* a(B* x) { return x->y; } + +struct x { union { int y; }; }; x y; template <int X> int f() { return X+y.y; } +int g() { return f<2>(); } + diff --git a/clang/test/SemaCXX/member-expr-static.cpp b/clang/test/SemaCXX/member-expr-static.cpp new file mode 100644 index 0000000..7ed60f7 --- /dev/null +++ b/clang/test/SemaCXX/member-expr-static.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef void (*thread_continue_t)(); + +extern "C" { + extern void kernel_thread_start(thread_continue_t continuation); + extern void pure_c(void); +} + +class _IOConfigThread { +public: + static void main( void ); +}; + + +void foo( void ) { + kernel_thread_start(&_IOConfigThread::main); + kernel_thread_start((thread_continue_t)&_IOConfigThread::main); + kernel_thread_start(&pure_c); +} diff --git a/clang/test/SemaCXX/member-expr.cpp b/clang/test/SemaCXX/member-expr.cpp new file mode 100644 index 0000000..dbddd1c --- /dev/null +++ b/clang/test/SemaCXX/member-expr.cpp @@ -0,0 +1,159 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class X{ +public: + enum E {Enumerator}; // expected-note 2{{declared here}} + int f(); + static int mem; + static float g(); +}; + +void test(X* xp, X x) { + int i1 = x.f(); + int i2 = xp->f(); + x.E; // expected-error{{cannot refer to type member 'E' in 'X' with '.'}} + xp->E; // expected-error{{cannot refer to type member 'E' in 'X' with '->'}} + int i3 = x.Enumerator; + int i4 = xp->Enumerator; + x.mem = 1; + xp->mem = 2; + float f1 = x.g(); + float f2 = xp->g(); +} + +struct A { + int f0; +}; +struct B { + A *f0(); +}; +int f0(B *b) { + return b->f0->f0; // expected-error{{did you mean to call it with no arguments}} +} + +int i; + +namespace C { + int i; +} + +void test2(X *xp) { + xp->::i = 7; // expected-error{{qualified member access refers to a member in the global namespace}} + xp->C::i = 7; // expected-error{{qualified member access refers to a member in namespace 'C'}} +} + + +namespace test3 { + struct NamespaceDecl; + + struct NamedDecl { + void *getIdentifier() const; + }; + + struct NamespaceDecl : NamedDecl { + bool isAnonymousNamespace() const { + return !getIdentifier(); + } + }; +} + +namespace test4 { + class X { + protected: + template<typename T> void f(T); + }; + + class Y : public X { + public: + using X::f; + }; + + void test_f(Y y) { + y.f(17); + } +} + +namespace test5 { + struct A { + template <class T> void foo(); + }; + + void test0(int x) { + x.A::foo<int>(); // expected-error {{'int' is not a structure or union}} + } + + void test1(A *x) { + x.A::foo<int>(); // expected-error {{'test5::A *' is a pointer}} + } + + void test2(A &x) { + x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer}} + } +} + +namespace PR7508 { + struct A { + struct CleanupScope {}; + void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}} + }; + + void foo(A &a) { + a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}} + } +} + +namespace rdar8231724 { + namespace N { + template<typename T> struct X1; + int i; + } + + struct X { }; + struct Y : X { }; + + void f(Y *y) { + y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}} + } +} + +namespace PR9025 { + struct S { int x; }; + S fun(); // expected-note{{possible target for call}} + int fun(int i); // expected-note{{possible target for call}} + int g() { + return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} + } + + S fun2(); // expected-note{{possible target for call}} + S fun2(int i); // expected-note{{possible target for call}} + int g2() { + return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} + } + + S fun3(int i=0); // expected-note{{possible target for call}} + int fun3(int i, int j); // expected-note{{possible target for call}} + int g3() { + return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} + } + + template <typename T> S fun4(); // expected-note{{possible target for call}} + int g4() { + return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} + } + + S fun5(int i); // expected-note{{possible target for call}} + S fun5(float f); // expected-note{{possible target for call}} + int g5() { + return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} + } +} + +namespace FuncInMemberExpr { + struct Vec { int size(); }; + Vec fun1(); + int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} + Vec *fun2(); + int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} + Vec fun3(int x = 0); + int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} +} diff --git a/clang/test/SemaCXX/member-init.cpp b/clang/test/SemaCXX/member-init.cpp new file mode 100644 index 0000000..c93c85b --- /dev/null +++ b/clang/test/SemaCXX/member-init.cpp @@ -0,0 +1,75 @@ +// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s + +struct Bitfield { + int n : 3 = 7; // expected-error {{bitfield member cannot have an in-class initializer}} +}; + +int a; +class NoWarning { + int &n = a; +public: + int &GetN() { return n; } +}; + +bool b(); +int k; +struct Recurse { + int &n = b() ? Recurse().n : k; // ok +}; + +struct UnknownBound { + int as[] = { 1, 2, 3 }; // expected-error {{array bound cannot be deduced from an in-class initializer}} + int bs[4] = { 4, 5, 6, 7 }; + int cs[] = { 8, 9, 10 }; // expected-error {{array bound cannot be deduced from an in-class initializer}} +}; + +template<int n> struct T { static const int B; }; +template<> struct T<2> { template<int C, int D> using B = int; }; +const int C = 0, D = 0; +struct S { + int as[] = { decltype(x)::B<C, D>(0) }; // expected-error {{array bound cannot be deduced from an in-class initializer}} + T<sizeof(as) / sizeof(int)> x; // expected-error {{requires a type specifier}} + // test that we handle invalid array bound deductions without crashing when the declarator name is itself invalid + operator int[](){}; // expected-error {{'operator int' cannot be the name of a variable or data member}} \ + // expected-error {{array bound cannot be deduced from an in-class initializer}} +}; + +struct ThrowCtor { ThrowCtor(int) noexcept(false); }; +struct NoThrowCtor { NoThrowCtor(int) noexcept(true); }; + +struct Throw { ThrowCtor tc = 42; }; +struct NoThrow { NoThrowCtor tc = 42; }; + +static_assert(!noexcept(Throw()), "incorrect exception specification"); +static_assert(noexcept(NoThrow()), "incorrect exception specification"); + +struct CheckExcSpec { + CheckExcSpec() noexcept(true) = default; + int n = 0; +}; +struct CheckExcSpecFail { + CheckExcSpecFail() noexcept(true) = default; // expected-error {{exception specification of explicitly defaulted default constructor does not match the calculated one}} + ThrowCtor tc = 123; +}; + +struct TypedefInit { + typedef int A = 0; // expected-error {{illegal initializer}} +}; + +// PR10578 / <rdar://problem/9877267> +namespace PR10578 { + template<typename T> + struct X { + X() { + T* x = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}} + } + }; + + struct Y : X<int> { + Y(); + }; + + Y::Y() try { // expected-note{{in instantiation of member function 'PR10578::X<int>::X' requested here}} + } catch(...) { + } +} diff --git a/clang/test/SemaCXX/member-location.cpp b/clang/test/SemaCXX/member-location.cpp new file mode 100644 index 0000000..6f7e1f5 --- /dev/null +++ b/clang/test/SemaCXX/member-location.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR4103: Make sure we have a location for the error +class A { + float a(int *); // expected-note{{passing argument to parameter here}} + int b(); +}; +int A::b() { return a(a((int*)0)); } // expected-error {{cannot initialize a parameter of type 'int *' with an rvalue of type 'float'}} + diff --git a/clang/test/SemaCXX/member-name-lookup.cpp b/clang/test/SemaCXX/member-name-lookup.cpp new file mode 100644 index 0000000..0149169 --- /dev/null +++ b/clang/test/SemaCXX/member-name-lookup.cpp @@ -0,0 +1,158 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A { + int a; // expected-note 4{{member found by ambiguous name lookup}} + static int b; + static int c; // expected-note 2{{member found by ambiguous name lookup}} + + enum E { enumerator }; + + typedef int type; + + static void f(int); + void f(float); // expected-note 2{{member found by ambiguous name lookup}} + + static void static_f(int); + static void static_f(double); +}; + +struct B : A { + int d; // expected-note 2{{member found by ambiguous name lookup}} + + enum E2 { enumerator2 }; + + enum E3 { enumerator3 }; // expected-note 2{{member found by ambiguous name lookup}} +}; + +struct C : A { + int c; // expected-note 2{{member found by ambiguous name lookup}} + int d; // expected-note 2{{member found by ambiguous name lookup}} + + enum E3 { enumerator3_2 }; // expected-note 2{{member found by ambiguous name lookup}} +}; + +struct D : B, C { + void test_lookup(); +}; + +void test_lookup(D d) { + d.a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}} + (void)d.b; // okay + d.c; // expected-error{{member 'c' found in multiple base classes of different types}} + d.d; // expected-error{{member 'd' found in multiple base classes of different types}} + d.f(0); // expected-error{{non-static member 'f' found in multiple base-class subobjects of type 'A':}} + d.static_f(0); // okay + + D::E e = D::enumerator; // okay + D::type t = 0; // okay + + D::E2 e2 = D::enumerator2; // okay + + D::E3 e3; // expected-error{{multiple base classes}} +} + +void D::test_lookup() { + a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}} + (void)b; // okay + c; // expected-error{{member 'c' found in multiple base classes of different types}} + d; // expected-error{{member 'd' found in multiple base classes of different types}} + f(0); // expected-error{{non-static member 'f' found in multiple base-class subobjects of type 'A':}} + static_f(0); // okay + + E e = enumerator; // okay + type t = 0; // okay + + E2 e2 = enumerator2; // okay + + E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}} +} + +struct B2 : virtual A { + int d; // expected-note 2{{member found by ambiguous name lookup}} + + enum E2 { enumerator2 }; + + enum E3 { enumerator3 }; // expected-note 2 {{member found by ambiguous name lookup}} +}; + +struct C2 : virtual A { + int c; + int d; // expected-note 2{{member found by ambiguous name lookup}} + + enum E3 { enumerator3_2 }; // expected-note 2{{member found by ambiguous name lookup}} +}; + +struct D2 : B2, C2 { + void test_virtual_lookup(); +}; + +struct F : A { }; +struct G : F, D2 { + void test_virtual_lookup(); +}; + +void test_virtual_lookup(D2 d2, G g) { + (void)d2.a; + (void)d2.b; + (void)d2.c; // okay + d2.d; // expected-error{{member 'd' found in multiple base classes of different types}} + d2.f(0); // okay + d2.static_f(0); // okay + + D2::E e = D2::enumerator; // okay + D2::type t = 0; // okay + + D2::E2 e2 = D2::enumerator2; // okay + + D2::E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}} + + g.a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}} + g.static_f(0); // okay +} + +void D2::test_virtual_lookup() { + (void)a; + (void)b; + (void)c; // okay + d; // expected-error{{member 'd' found in multiple base classes of different types}} + f(0); // okay + static_f(0); // okay + + E e = enumerator; // okay + type t = 0; // okay + + E2 e2 = enumerator2; // okay + + E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}} +} + +void G::test_virtual_lookup() { + a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}} + static_f(0); // okay +} + + +struct HasMemberType1 { + struct type { }; // expected-note{{member found by ambiguous name lookup}} +}; + +struct HasMemberType2 { + struct type { }; // expected-note{{member found by ambiguous name lookup}} +}; + +struct HasAnotherMemberType : HasMemberType1, HasMemberType2 { + struct type { }; +}; + +struct UsesAmbigMemberType : HasMemberType1, HasMemberType2 { + type t; // expected-error{{member 'type' found in multiple base classes of different types}} +}; + +struct X0 { + struct Inner { + static const int m; + }; + + static const int n = 17; +}; + +const int X0::Inner::m = n; diff --git a/clang/test/SemaCXX/member-operator-expr.cpp b/clang/test/SemaCXX/member-operator-expr.cpp new file mode 100644 index 0000000..ae5f8bb --- /dev/null +++ b/clang/test/SemaCXX/member-operator-expr.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class X { +public: + int operator++(); + operator int(); +}; + +void test() { + X x; + int i; + + i = x.operator++(); + i = x.operator int(); + x.operator--(); // expected-error{{no member named 'operator--'}} + x.operator float(); // expected-error{{no member named 'operator float'}} + x.operator; // expected-error{{expected a type}} +} + +void test2() { + X *x; + int i; + + i = x->operator++(); + i = x->operator int(); + x->operator--(); // expected-error{{no member named 'operator--'}} + x->operator float(); // expected-error{{no member named 'operator float'}} + x->operator; // expected-error{{expected a type}} +} diff --git a/clang/test/SemaCXX/member-pointer-ms.cpp b/clang/test/SemaCXX/member-pointer-ms.cpp new file mode 100644 index 0000000..3b2d0fc --- /dev/null +++ b/clang/test/SemaCXX/member-pointer-ms.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -cxx-abi microsoft -fsyntax-only -verify %s + +// Test that we reject pointers to members of incomplete classes (for now) +struct A; //expected-note{{forward declaration of 'A'}} +int A::*pai1; //expected-error{{incomplete type 'A'}} + +// Test that we don't allow reinterpret_casts from pointers of one size to +// pointers of a different size. +struct A {}; +struct B {}; +struct C: A, B {}; + +void (A::*paf)(); +void (C::*pcf)() = reinterpret_cast<void (C::*)()>(paf); //expected-error{{cannot reinterpret_cast from member pointer type}} diff --git a/clang/test/SemaCXX/member-pointer-size.cpp b/clang/test/SemaCXX/member-pointer-size.cpp new file mode 100644 index 0000000..3aa1eaf --- /dev/null +++ b/clang/test/SemaCXX/member-pointer-size.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify +// RUN: %clang_cc1 -triple i686-unknown-unknown %s -fsyntax-only -verify +#include <stddef.h> + +struct A; + +void f() { + int A::*dataMember; + + int (A::*memberFunction)(); + + typedef int assert1[sizeof(dataMember) == sizeof(ptrdiff_t) ? 1 : -1]; + typedef int assert2[sizeof(memberFunction) == sizeof(ptrdiff_t) * 2 ? 1 : -1]; +} + diff --git a/clang/test/SemaCXX/member-pointer.cpp b/clang/test/SemaCXX/member-pointer.cpp new file mode 100644 index 0000000..4e8b4a8 --- /dev/null +++ b/clang/test/SemaCXX/member-pointer.cpp @@ -0,0 +1,314 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A {}; +enum B { Dummy }; +namespace C {} +struct D : A {}; +struct E : A {}; +struct F : D, E {}; +struct G : virtual D {}; + +int A::*pdi1; +int (::A::*pdi2); +int (A::*pfi)(int); + +int B::*pbi; // expected-error {{expected a class or namespace}} +int C::*pci; // expected-error {{'pci' does not point into a class}} +void A::*pdv; // expected-error {{'pdv' declared as a member pointer to void}} +int& A::*pdr; // expected-error {{'pdr' declared as a member pointer to a reference}} + +void f() { + // This requires tentative parsing. + int (A::*pf)(int, int); + + // Implicit conversion to bool. + bool b = pdi1; + b = pfi; + + // Conversion from null pointer constant. + pf = 0; + pf = __null; + + // Conversion to member of derived. + int D::*pdid = pdi1; + pdid = pdi2; + + // Fail conversion due to ambiguity and virtuality. + int F::*pdif = pdi1; // expected-error {{ambiguous conversion from pointer to member of base class 'A' to pointer to member of derived class 'F':}} + int G::*pdig = pdi1; // expected-error {{conversion from pointer to member of class 'A' to pointer to member of class 'G' via virtual base 'D' is not allowed}} + + // Conversion to member of base. + pdi1 = pdid; // expected-error {{assigning to 'int A::*' from incompatible type 'int D::*'}} + + // Comparisons + int (A::*pf2)(int, int); + int (D::*pf3)(int, int) = 0; + bool b1 = (pf == pf2); (void)b1; + bool b2 = (pf != pf2); (void)b2; + bool b3 = (pf == pf3); (void)b3; + bool b4 = (pf != 0); (void)b4; +} + +struct TheBase +{ + void d(); +}; + +struct HasMembers : TheBase +{ + int i; + void f(); + + void g(); + void g(int); + static void g(double); +}; + +namespace Fake +{ + int i; + void f(); +} + +void g() { + HasMembers hm; + + int HasMembers::*pmi = &HasMembers::i; + int *pni = &Fake::i; + int *pmii = &hm.i; + + void (HasMembers::*pmf)() = &HasMembers::f; + void (*pnf)() = &Fake::f; + &hm.f; // expected-error {{cannot create a non-constant pointer to member function}} + + void (HasMembers::*pmgv)() = &HasMembers::g; + void (HasMembers::*pmgi)(int) = &HasMembers::g; + void (*pmgd)(double) = &HasMembers::g; + + void (HasMembers::*pmd)() = &HasMembers::d; +} + +struct Incomplete; + +void h() { + HasMembers hm, *phm = &hm; + + int HasMembers::*pi = &HasMembers::i; + hm.*pi = 0; + int i = phm->*pi; + (void)&(hm.*pi); + (void)&(phm->*pi); + (void)&((&hm)->*pi); + + void (HasMembers::*pf)() = &HasMembers::f; + (hm.*pf)(); + (phm->*pf)(); + + (void)(hm->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'HasMembers'}} + (void)(phm.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'HasMembers *'}} + (void)(i.*pi); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'int'}} + int *ptr; + (void)(ptr->*pi); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'int *'}} + + int A::*pai = 0; + D d, *pd = &d; + (void)(d.*pai); + (void)(pd->*pai); + F f, *ptrf = &f; + (void)(f.*pai); // expected-error {{left hand operand to .* must be a class compatible with the right hand operand, but is 'F'}} + (void)(ptrf->*pai); // expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'F *'}} + + (void)(hm.*i); // expected-error {{pointer-to-member}} + (void)(phm->*i); // expected-error {{pointer-to-member}} + + // Okay + Incomplete *inc; + int Incomplete::*pii = 0; + (void)(inc->*pii); +} + +struct OverloadsPtrMem +{ + int operator ->*(const char *); +}; + +void i() { + OverloadsPtrMem m; + int foo = m->*"Awesome!"; +} + +namespace pr5985 { + struct c { + void h(); + void f() { + void (c::*p)(); + p = &h; // expected-error {{must explicitly qualify}} + p = &this->h; // expected-error {{cannot create a non-constant pointer to member function}} + p = &(*this).h; // expected-error {{cannot create a non-constant pointer to member function}} + } + }; +} + +namespace pr6783 { + struct Base {}; + struct X; // expected-note {{forward declaration}} + + int test1(int Base::* p2m, X* object) + { + return object->*p2m; // expected-error {{left hand operand to ->*}} + } +} + +namespace PR7176 { + namespace base + { + struct Process + { }; + struct Continuous : Process + { + bool cond(); + }; + } + + typedef bool( base::Process::*Condition )(); + + void m() + { (void)(Condition) &base::Continuous::cond; } +} + +namespace rdar8358512 { + // We can't call this with an overload set because we're not allowed + // to look into overload sets unless the parameter has some kind of + // function type. + template <class F> void bind(F f); // expected-note 12 {{candidate template ignored}} + template <class F, class T> void bindmem(F (T::*f)()); // expected-note 4 {{candidate template ignored}} + template <class F> void bindfn(F (*f)()); // expected-note 4 {{candidate template ignored}} + + struct A { + void nonstat(); + void nonstat(int); + + void mixed(); + static void mixed(int); + + static void stat(); + static void stat(int); + + template <typename T> struct Test0 { + void test() { + bind(&nonstat); // expected-error {{no matching function for call}} + bind(&A::nonstat); // expected-error {{no matching function for call}} + + bind(&mixed); // expected-error {{no matching function for call}} + bind(&A::mixed); // expected-error {{no matching function for call}} + + bind(&stat); // expected-error {{no matching function for call}} + bind(&A::stat); // expected-error {{no matching function for call}} + } + }; + + template <typename T> struct Test1 { + void test() { + bindmem(&nonstat); // expected-error {{no matching function for call}} + bindmem(&A::nonstat); + + bindmem(&mixed); // expected-error {{no matching function for call}} + bindmem(&A::mixed); + + bindmem(&stat); // expected-error {{no matching function for call}} + bindmem(&A::stat); // expected-error {{no matching function for call}} + } + }; + + template <typename T> struct Test2 { + void test() { + bindfn(&nonstat); // expected-error {{no matching function for call}} + bindfn(&A::nonstat); // expected-error {{no matching function for call}} + + bindfn(&mixed); // expected-error {{no matching function for call}} + bindfn(&A::mixed); // expected-error {{no matching function for call}} + + bindfn(&stat); + bindfn(&A::stat); + } + }; + }; + + template <class T> class B { + void nonstat(); + void nonstat(int); + + void mixed(); + static void mixed(int); + + static void stat(); + static void stat(int); + + // None of these can be diagnosed yet, because the arguments are + // still dependent. + void test0a() { + bind(&nonstat); + bind(&B::nonstat); + + bind(&mixed); + bind(&B::mixed); + + bind(&stat); + bind(&B::stat); + } + + void test0b() { + bind(&nonstat); // expected-error {{no matching function for call}} + bind(&B::nonstat); // expected-error {{no matching function for call}} + + bind(&mixed); // expected-error {{no matching function for call}} + bind(&B::mixed); // expected-error {{no matching function for call}} + + bind(&stat); // expected-error {{no matching function for call}} + bind(&B::stat); // expected-error {{no matching function for call}} + } + }; + + template void B<int>::test0b(); // expected-note {{in instantiation}} +} + +namespace PR9973 { + template<class R, class T> struct dm + { + typedef R T::*F; + F f_; + template<class U> int & call(U u) + { return u->*f_; } // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} + + template<class U> int operator()(U u) + { call(u); } // expected-note{{in instantiation of}} + }; + + template<class R, class T> + dm<R, T> mem_fn(R T::*) ; + + struct test + { int nullary_v(); }; + + void f() + { + test* t; + mem_fn(&test::nullary_v)(t); // expected-note{{in instantiation of}} + } +} + +namespace test8 { + struct A { int foo; }; + int test1() { + // Verify that we perform (and check) an lvalue conversion on the operands here. + return (*((A**) 0)) // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}} + ->**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}} + } + + int test2() { + // Verify that we perform (and check) an lvalue conversion on the operands here. + // TODO: the .* should itself warn about being a dereference of null. + return (*((A*) 0)) + .**(int A::**) 0; // expected-warning {{indirection of non-volatile null pointer will be deleted}} expected-note {{consider}} + } +} diff --git a/clang/test/SemaCXX/member-pointers-2.cpp b/clang/test/SemaCXX/member-pointers-2.cpp new file mode 100644 index 0000000..6c39282 --- /dev/null +++ b/clang/test/SemaCXX/member-pointers-2.cpp @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 -emit-llvm-only %s + +// Tests that Sema properly creates member-access expressions for +// these instead of bare FieldDecls. + +struct Foo { + int myvalue; + + // We have to override these to get something with an lvalue result. + int &operator++(int); + int &operator--(int); +}; + +struct Test0 { + Foo memfoo; + int memint; + int memarr[10]; + Test0 *memptr; + struct MemClass { int a; } memstruct; + int &memfun(); + + void test() { + int *p; + p = &Test0::memfoo++; + p = &Test0::memfoo--; + p = &Test0::memarr[1]; + p = &Test0::memptr->memint; + p = &Test0::memstruct.a; + p = &Test0::memfun(); + } +}; + +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/clang/test/SemaCXX/microsoft-cxx0x.cpp b/clang/test/SemaCXX/microsoft-cxx0x.cpp new file mode 100644 index 0000000..3b9bbef --- /dev/null +++ b/clang/test/SemaCXX/microsoft-cxx0x.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wc++11-narrowing -Wmicrosoft -verify -fms-extensions -std=c++11 + + +struct A { + unsigned int a; +}; +int b = 3; +A var = { b }; // expected-warning {{ cannot be narrowed }} expected-note {{override}} diff --git a/clang/test/SemaCXX/missing-header.cpp b/clang/test/SemaCXX/missing-header.cpp new file mode 100644 index 0000000..5b3915b --- /dev/null +++ b/clang/test/SemaCXX/missing-header.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include "not exist" // expected-error{{'not exist' file not found}} + +class AnalysisDeclContext {}; +static ControlFlowKind CheckFallThrough(AnalysisDeclContext &AC) { + if (const AsmStmt *AS = dyn_cast<AsmStmt>(S)) {} + bool NoReturnEdge = false; +} diff --git a/clang/test/SemaCXX/missing-members.cpp b/clang/test/SemaCXX/missing-members.cpp new file mode 100644 index 0000000..529ba10 --- /dev/null +++ b/clang/test/SemaCXX/missing-members.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace A { + namespace B { + class C { }; + struct S { }; + union U { }; + } +} + +void f() { + A::B::i; // expected-error {{no member named 'i' in namespace 'A::B'}} + A::B::C::i; // expected-error {{no member named 'i' in 'A::B::C'}} + ::i; // expected-error {{no member named 'i' in the global namespace}} +} + +namespace B { + class B { }; +} + +void g() { + A::B::D::E; // expected-error {{no member named 'D' in namespace 'A::B'}} + B::B::C::D; // expected-error {{no member named 'C' in 'B::B'}} + ::C::D; // expected-error {{no member named 'C' in the global namespace}} +} + +int A::B::i = 10; // expected-error {{no member named 'i' in namespace 'A::B'}} +int A::B::C::i = 10; // expected-error {{no member named 'i' in 'A::B::C'}} +int A::B::S::i = 10; // expected-error {{no member named 'i' in 'A::B::S'}} +int A::B::U::i = 10; // expected-error {{no member named 'i' in 'A::B::U'}} + +using A::B::D; // expected-error {{no member named 'D' in namespace 'A::B'}} + +struct S : A::B::C { + using A::B::C::f; // expected-error {{no member named 'f' in 'A::B::C'}} + +}; diff --git a/clang/test/SemaCXX/missing-namespace-qualifier-typo-corrections.cpp b/clang/test/SemaCXX/missing-namespace-qualifier-typo-corrections.cpp new file mode 100644 index 0000000..83f8395 --- /dev/null +++ b/clang/test/SemaCXX/missing-namespace-qualifier-typo-corrections.cpp @@ -0,0 +1,121 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s + +namespace fizbin { class Foobar {}; } // expected-note 2 {{'fizbin::Foobar' declared here}} \ + // expected-note {{'Foobar' declared here}} +Foobar *my_bar // expected-error{{unknown type name 'Foobar'; did you mean 'fizbin::Foobar'?}} + = new Foobar; // expected-error{{unknown type name 'Foobar'; did you mean 'fizbin::Foobar'?}} +fizbin::Foobar *my_foo = new fizbin::FooBar; // expected-error{{no type named 'FooBar' in namespace 'fizbin'; did you mean 'Foobar'?}} + +namespace barstool { int toFoobar() { return 1; } } // expected-note 3 {{'barstool::toFoobar' declared here}} +int Double(int x) { return x + x; } +void empty() { + Double(toFoobar()); // expected-error{{use of undeclared identifier 'toFoobar'; did you mean 'barstool::toFoobar'?}} +} + +namespace fizbin { + namespace baztool { bool toFoobar() { return true; } } // expected-note{{'fizbin::baztool' declared here}} + namespace nested { bool moreFoobar() { return true; } } // expected-note{{'fizbin::nested::moreFoobar' declared here}} + namespace nested { bool lessFoobar() { return true; } } // expected-note{{'fizbin::nested' declared here}} \ + // expected-note{{'fizbin::nested::lessFoobar' declared here}} + class dummy { // expected-note 2 {{'fizbin::dummy' declared here}} + public: + static bool moreFoobar() { return false; } // expected-note{{'moreFoobar' declared here}} + }; +} +void Check() { // expected-note{{'Check' declared here}} + if (toFoobar()) Double(7); // expected-error{{use of undeclared identifier 'toFoobar'; did you mean 'barstool::toFoobar'?}} + if (noFoobar()) Double(7); // expected-error{{use of undeclared identifier 'noFoobar'; did you mean 'barstool::toFoobar'?}} + if (moreFoobar()) Double(7); // expected-error{{use of undeclared identifier 'moreFoobar'; did you mean 'fizbin::nested::moreFoobar'}} + if (lessFoobar()) Double(7); // expected-error{{use of undeclared identifier 'lessFoobar'; did you mean 'fizbin::nested::lessFoobar'?}} + if (baztool::toFoobar()) Double(7); // expected-error{{use of undeclared identifier 'baztool'; did you mean 'fizbin::baztool'?}} + if (nested::moreFoobar()) Double(7); // expected-error{{use of undeclared identifier 'nested'; did you mean 'fizbin::nested'?}} + if (dummy::moreFoobar()) Double(7); // expected-error{{use of undeclared identifier 'dummy'; did you mean 'fizbin::dummy'?}} + if (dummy::mreFoobar()) Double(7); // expected-error{{use of undeclared identifier 'dummy'; did you mean 'fizbin::dummy'?}} \ + // expected-error{{no member named 'mreFoobar' in 'fizbin::dummy'; did you mean 'moreFoobar'?}} + if (moFoobin()) Double(7); // expected-error{{use of undeclared identifier 'moFoobin'}} +} + +void Alt() { + Cleck(); // expected-error{{use of undeclared identifier 'Cleck'; did you mean 'Check'?}} +} + +namespace N { + namespace inner { + class myvector { /* ... */ }; // expected-note{{'inner::myvector' declared here}} + } + + void f() { + myvector v; // expected-error{{unknown type name 'myvector'; did you mean 'inner::myvector'?}} + } +} + +namespace realstd { + inline namespace __1 { + class mylinkedlist { /* ... */ }; // expected-note 2 {{'realstd::mylinkedlist' declared here}} + } + + class linkedlist { /* ... */ }; +} + +void f() { + mylinkedlist v; // expected-error{{unknown type name 'mylinkedlist'; did you mean 'realstd::mylinkedlist'?}} + nylinkedlist w; // expected-error{{unknown type name 'nylinkedlist'; did you mean 'realstd::mylinkedlist'?}} +} + +// Test case from http://llvm.org/bugs/show_bug.cgi?id=10318 +namespace llvm { + template <typename T> class GraphWriter {}; // expected-note 3{{declared here}} +} + +struct S {}; +void bar() { + GraphWriter<S> x; //expected-error{{no template named 'GraphWriter'; did you mean 'llvm::GraphWriter'?}} + (void)new llvm::GraphWriter; // expected-error {{use of class template llvm::GraphWriter requires template arguments}} + (void)new llvm::Graphwriter<S>; // expected-error {{no template named 'Graphwriter' in namespace 'llvm'; did you mean 'GraphWriter'?}} +} + +// If namespace prefixes and character edits have the same weight, correcting +// "fimish" to "N::famish" would have the same edit distance as correcting +// "fimish" to "Finish". The result would be no correction being suggested +// unless one of the corrections is given precedence (e.g. by filtering out +// suggestions with added namespace qualifiers). +namespace N { void famish(int); } +void Finish(int); // expected-note {{'Finish' declared here}} +void Start() { + fimish(7); // expected-error {{use of undeclared identifier 'fimish'; did you mean 'Finish'?}} +} + +// But just eliminating the corrections containing added namespace qualifiers +// won't work if both of the tied corrections have namespace qualifiers added. +namespace N { +void someCheck(int); // expected-note {{'N::someCheck' declared here}} +namespace O { void somechock(int); } +} +void confusing() { + somechick(7); // expected-error {{use of undeclared identifier 'somechick'; did you mean 'N::someCheck'?}} +} + + +class Message {}; +namespace extra { + namespace util { + namespace MessageUtils { + bool Equivalent(const Message&, const Message&); // expected-note {{'extra::util::MessageUtils::Equivalent' declared here}} \ + // expected-note {{'::extra::util::MessageUtils::Equivalent' declared here}} + } + } +} +namespace util { namespace MessageUtils {} } +bool nstest () { + Message a, b; + return util::MessageUtils::Equivalent(a, b); // expected-error {{no member named 'Equivalent' in namespace 'util::MessageUtils'; did you mean 'extra::util::MessageUtils::Equivalent'?}} +} + +namespace util { + namespace extra { + bool nstest () { + Message a, b; + return MessageUtils::Equivalent(a, b); // expected-error {{no member named 'Equivalent' in namespace 'util::MessageUtils'; did you mean '::extra::util::MessageUtils::Equivalent'?}} + } + } +} diff --git a/clang/test/SemaCXX/ms-exception-spec.cpp b/clang/test/SemaCXX/ms-exception-spec.cpp new file mode 100644 index 0000000..bda56f5 --- /dev/null +++ b/clang/test/SemaCXX/ms-exception-spec.cpp @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -fms-extensions + +void f() throw(...) { } diff --git a/clang/test/SemaCXX/namespace-alias.cpp b/clang/test/SemaCXX/namespace-alias.cpp new file mode 100644 index 0000000..e18b58b --- /dev/null +++ b/clang/test/SemaCXX/namespace-alias.cpp @@ -0,0 +1,127 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace N { struct X { }; }; + +namespace A = N; + +int B; // expected-note {{previous definition is here}} +namespace B = N; // expected-error {{redefinition of 'B' as different kind of symbol}} + +namespace C { } // expected-note {{previous definition is here}} +namespace C = N; // expected-error {{redefinition of 'C'}} + +int i; +namespace D = +i; // expected-error {{expected namespace name}} + +namespace E1 = N:: +Foo; // expected-error {{expected namespace name}} +namespace E2 = N:: +X; // expected-error {{expected namespace name}} + +namespace F { + namespace A { namespace B { } } // expected-note {{candidate found by name lookup is 'F::A::B'}} + namespace B { } // expected-note {{candidate found by name lookup is 'F::B'}} + using namespace A; + namespace D = B; // expected-error {{reference to 'B' is ambiguous}} +} + +namespace G { + namespace B = N; +} + +namespace H { + namespace A1 { } + namespace A2 { } + + // These all point to A1. + namespace B = A1; // expected-note {{previous definition is here}} + namespace B = A1; + namespace C = B; + namespace B = C; + + namespace B = A2; // expected-error {{redefinition of 'B' as different kind of symbol}} +} + +namespace I { + namespace A1 { int i; } + + namespace A2 = A1; +} + +int f() { + return I::A2::i; +} + +namespace J { + namespace A { + namespace B { void func (); } + } + + namespace C = A; + + using namespace C::B; + + void g() { + func(); + } +} + +namespace K { + namespace KA { void func(); } + + void f() { + namespace KB = KA; + KB::func(); + } + + template <class T> void g() { + namespace KC = KA; + KC::func(); + } + template void g<int>(); + template void g<long>(); + + void h() { + KB::func(); // expected-error {{undeclared identifier 'KB'}} + KC::func(); // expected-error {{undeclared identifier 'KC'}} + } +} + +namespace { + class C1; +} +namespace { + class C1; +} +C1 *pc1 = 0; + +namespace N { + namespace { + class C2; + } +} +namespace N { + namespace { + class C2; + } +} +N::C2 *pc2 = 0; + +// PR6341 +namespace A = N; +namespace N { } +namespace A = N; + +A::X nx; + +namespace PR7014 { + namespace X + { + namespace Y {} + } + + using namespace X; + + namespace Y = X::Y; +} diff --git a/clang/test/SemaCXX/namespace.cpp b/clang/test/SemaCXX/namespace.cpp new file mode 100644 index 0000000..d47b707 --- /dev/null +++ b/clang/test/SemaCXX/namespace.cpp @@ -0,0 +1,92 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace A { // expected-note 2 {{previous definition is here}} + int A; + void f() { A = 0; } +} + +void f() { A = 0; } // expected-error {{unexpected namespace name 'A': expected expression}} +int A; // expected-error {{redefinition of 'A' as different kind of symbol}} +class A; // expected-error {{redefinition of 'A' as different kind of symbol}} + +class B {}; // expected-note {{previous definition is here}} \ + // expected-note{{candidate function (the implicit copy assignment operator)}} + +void C(); // expected-note {{previous definition is here}} +namespace C {} // expected-error {{redefinition of 'C' as different kind of symbol}} + +namespace D { + class D {}; +} + +namespace S1 { + int x; + + namespace S2 { + + namespace S3 { + B x; + } + } +} + +namespace S1 { + void f() { + x = 0; + } + + namespace S2 { + + namespace S3 { + void f() { + x = 0; // expected-error {{no viable overloaded '='}} + } + } + + int y; + } +} + +namespace S1 { + namespace S2 { + namespace S3 { + void f3() { + y = 0; + } + } + } +} + +namespace B {} // expected-error {{redefinition of 'B' as different kind of symbol}} + + +namespace foo { + enum x { + Y + }; +} + +static foo::x test1; // ok + +static foo::X test2; // typo: expected-error {{no type named 'X' in}} + +namespace PR6620 { + namespace numeric { + namespace op { + struct greater {}; + } + namespace { + extern op::greater const greater; + } + } + + namespace numeric { + namespace { + op::greater const greater = op::greater(); + } + + template<typename T, typename U> + int f(T& l, U& r) + { numeric::greater(l, r); } + + } +} diff --git a/clang/test/SemaCXX/neon-vector-types.cpp b/clang/test/SemaCXX/neon-vector-types.cpp new file mode 100644 index 0000000..aa82b11 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/nested-name-spec-locations.cpp b/clang/test/SemaCXX/nested-name-spec-locations.cpp new file mode 100644 index 0000000..048d4ba --- /dev/null +++ b/clang/test/SemaCXX/nested-name-spec-locations.cpp @@ -0,0 +1,162 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Note: the formatting in this test case is intentionally funny, with +// nested-name-specifiers stretched out vertically so that we can +// match up diagnostics per-line and still verify that we're getting +// good source-location information. + +namespace outer { + namespace inner { + template<typename T> + struct X0 { + }; + } +} + +template<typename T> +struct add_reference { + typedef T& type; +}; + +namespace outer_alias = outer; + +template<typename T> +struct UnresolvedUsingValueDeclTester { + using outer::inner::X0< + typename add_reference<T>::type + * // expected-error{{declared as a pointer to a reference of type}} + >::value; +}; + +UnresolvedUsingValueDeclTester<int> UnresolvedUsingValueDeclCheck; // expected-note{{in instantiation of template class}} + +template<typename T> +struct UnresolvedUsingTypenameDeclTester { + using outer::inner::X0< + typename add_reference<T>::type + * // expected-error{{declared as a pointer to a reference of type}} + >::value; +}; + +UnresolvedUsingTypenameDeclTester<int> UnresolvedUsingTypenameDeclCheck; // expected-note{{in instantiation of template class}} + + +template<typename T, typename U> +struct PseudoDestructorExprTester { + void f(T *t) { + t->T::template Inner<typename add_reference<U>::type + * // expected-error{{as a pointer to a reference of type}} + >::Blarg::~Blarg(); + } +}; + +struct HasInnerTemplate { + template<typename T> + struct Inner; + + typedef HasInnerTemplate T; +}; + +void PseudoDestructorExprCheck( + PseudoDestructorExprTester<HasInnerTemplate, float> tester) { + tester.f(0); // expected-note{{in instantiation of member function}} +} + +template<typename T> +struct DependentScopedDeclRefExpr { + void f() { + 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/clang/test/SemaCXX/nested-name-spec.cpp b/clang/test/SemaCXX/nested-name-spec.cpp new file mode 100644 index 0000000..b317634 --- /dev/null +++ b/clang/test/SemaCXX/nested-name-spec.cpp @@ -0,0 +1,288 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s +namespace A { + struct C { + static int cx; + + static int cx2; + + static int Ag1(); + static int Ag2(); + }; + int ax; + void Af(); +} + +A:: ; // expected-error {{expected unqualified-id}} +// FIXME: there is a member 'ax'; it's just not a class. +::A::ax::undef ex3; // expected-error {{no member named 'ax'}} +A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}} + +int A::C::Ag1() { return 0; } + +static int A::C::Ag2() { return 0; } // expected-error{{'static' can}} + +int A::C::cx = 17; + + +static int A::C::cx2 = 17; // expected-error{{'static' can}} + +class C2 { + void m(); // expected-note{{member declaration does not match because it is not const qualified}} + + void f(const int& parm); // expected-note{{type of 1st parameter of member declaration does not match definition ('const int &' vs 'int')}} + void f(int) const; // expected-note{{member declaration does not match because it is const qualified}} + void f(float); + + int x; +}; + +void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}} + +void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}} + +void C2::m() { + x = 0; +} + +namespace B { + void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}} +} + +void f1() { + void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}} +} + +void f2() { + A:: ; // expected-error {{expected unqualified-id}} + A::C::undef = 0; // expected-error {{no member named 'undef'}} + ::A::C::cx = 0; + int x = ::A::ax = A::C::cx; + x = sizeof(A::C); + x = sizeof(::A::C::cx); +} + +A::C c1; +struct A::C c2; +struct S : public A::C {}; +struct A::undef; // expected-error {{no struct named 'undef' in namespace 'A'}} + +namespace A2 { + typedef int INT; + struct RC; + struct CC { + struct NC; + }; +} + +struct A2::RC { + INT x; +}; + +struct A2::CC::NC { + void m() {} +}; + +void f3() { + N::x = 0; // expected-error {{use of undeclared identifier 'N'}} + int N; + N::x = 0; // expected-error {{expected a class or namespace}} + { int A; A::ax = 0; } + { typedef int A; A::ax = 0; } // expected-error{{expected a class or namespace}} + { typedef A::C A; A::ax = 0; } // expected-error {{no member named 'ax'}} + { typedef A::C A; A::cx = 0; } +} + +// make sure the following doesn't hit any asserts +void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}} \ + expected-error {{variable has incomplete type 'void'}} + +typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}} + +void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}} + +int A2::RC::x; // expected-error{{non-static data member defined out-of-line}} + +void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}} + + +namespace E { + int X = 5; + + namespace Nested { + enum E { + X = 0 + }; + + void f() { + return E::X; // expected-error{{expected a class or namespace}} + } + } +} + + +class Operators { + Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}} + operator bool(); +}; + +Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}} + Operators ops; + return ops; +} + +Operators Operators::operator+(const Operators&) const { + Operators ops; + return ops; +} + +Operators::operator bool() { + return true; +} + +namespace A { + void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}} +} + +void A::f() {} // expected-error{{out-of-line definition of 'f' does not match any declaration in namespace 'A'}} + +void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}} + +struct Struct { }; + +void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}} + +void global_func(int); +void global_func2(int); + +namespace N { + void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}} + + void f(); + // FIXME: if we move this to a separate definition of N, things break! +} +void ::global_func2(int) { } // expected-warning{{extra qualification on member 'global_func2'}} + +void N::f() { } // okay + +struct Y; // expected-note{{forward declaration of 'Y'}} +Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}} + +X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}} \ + // expected-error{{C++ requires a type specifier for all declarations}} \ + // expected-error{{only constructors take base initializers}} + +struct foo_S { + static bool value; +}; +bool (foo_S::value); + + +namespace somens { + struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}} +} + +template <typename T> +class foo { +}; + + +// PR4452 / PR4451 +foo<somens:a> a2; // expected-error {{unexpected ':' in nested name specifier}} + +somens::a a3 = a2; // expected-error {{no viable conversion}} + +// typedefs and using declarations. +namespace test1 { + namespace ns { + class Counter { public: static int count; }; + typedef Counter counter; + } + using ns::counter; + + class Test { + void test1() { + counter c; + c.count++; + counter::count++; + } + }; +} + +// We still need to do lookup in the lexical scope, even if we push a +// non-lexical scope. +namespace test2 { + namespace ns { + extern int *count_ptr; + } + namespace { + int count = 0; + } + + int *ns::count_ptr = &count; +} + +// PR6259, invalid case +namespace test3 { + class A; // expected-note {{forward declaration}} + void foo(const char *path) { + A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}} + } +} + +namespace PR7133 { + namespace A { + class Foo; + } + + namespace A { + namespace B { + bool foo(Foo &); + } + } + + bool A::B::foo(Foo &) { + return false; + } +} + +class CLASS { + void CLASS::foo2(); // expected-warning {{extra qualification on member 'foo2'}} +}; + +namespace PR8159 { + class B { }; + + class A { + int A::a; // expected-warning{{extra qualification on member 'a'}} + static int A::b; // expected-warning{{extra qualification on member 'b'}} + int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}} + }; +} + +namespace rdar7980179 { + class A { void f0(); }; // expected-note {{previous}} + int A::f0() {} // expected-error {{out-of-line definition of 'rdar7980179::A::f0' differs from the declaration in the return type}} +} + +namespace alias = A; +double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}} + +// http://llvm.org/PR10109 +namespace PR10109 { +template<typename T> +struct A { +protected: + struct B; + struct B::C; // expected-error {{requires a template parameter list}} \ + // expected-error {{no struct named 'C'}} \ + // expected-error{{non-friend class member 'C' cannot have a qualified name}} +}; + +template<typename T> +struct A2 { +protected: + struct B; +}; +template <typename T> +struct A2<T>::B::C; // expected-error {{no struct named 'C'}} +} diff --git a/clang/test/SemaCXX/new-array-size-conv.cpp b/clang/test/SemaCXX/new-array-size-conv.cpp new file mode 100644 index 0000000..e8bb679 --- /dev/null +++ b/clang/test/SemaCXX/new-array-size-conv.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s + +struct ValueInt +{ + ValueInt(int v = 0) : ValueLength(v) {} + operator int () const { return ValueLength; } // expected-note 3{{conversion to integral type 'int' declared here}} +private: + int ValueLength; +}; + +enum E { e }; +struct ValueEnum { + operator E() const; // expected-note{{conversion to enumeration type 'E' declared here}} +}; + +struct ValueBoth : ValueInt, ValueEnum { }; + +struct IndirectValueInt : ValueInt { }; +struct TwoValueInts : ValueInt, IndirectValueInt { }; + +void test() { + (void)new int[ValueInt(10)]; // expected-warning{{implicit conversion from array size expression of type 'ValueInt' to integral type 'int' is a C++11 extension}} + (void)new int[ValueEnum()]; // expected-warning{{implicit conversion from array size expression of type 'ValueEnum' to enumeration type 'E' is a C++11 extension}} + (void)new int[ValueBoth()]; // expected-error{{ambiguous conversion of array size expression of type 'ValueBoth' to an integral or enumeration type}} + + (void)new int[TwoValueInts()]; // expected-error{{ambiguous conversion of array size expression of type 'TwoValueInts' to an integral or enumeration type}} +} diff --git a/clang/test/SemaCXX/new-delete-0x.cpp b/clang/test/SemaCXX/new-delete-0x.cpp new file mode 100644 index 0000000..dcc2e9b --- /dev/null +++ b/clang/test/SemaCXX/new-delete-0x.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -std=c++11 + +using size_t = decltype(sizeof(0)); +struct noreturn_t {} constexpr noreturn = {}; + +void *operator new [[noreturn]] (size_t, noreturn_t); +void operator delete [[noreturn]] (void*, noreturn_t); + +void good_news() +{ + auto p = new int[2][[]]; + auto q = new int[[]][2]; + auto r = new int*[[]][2][[]]; + auto s = new (int(*[[]])[2][[]]); +} + +void bad_news(int *ip) +{ + // attribute-specifiers can go almost anywhere in a new-type-id... + auto r = new int[[]{return 1;}()][2]; // expected-error {{expected ']'}} + auto s = new int*[[]{return 1;}()][2]; // expected-error {{expected ']'}} + // ... but not here: + auto t = new (int(*)[[]]); // expected-error {{an attribute list cannot appear here}} + auto u = new (int(*)[[]{return 1;}()][2]); // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}} expected-error {{variably modified type}} +} + +void good_deletes() +{ + delete [&]{ return (int*)0; }(); + // FIXME: This appears to be legal. + delete []{ return (int*)0; }(); // unexpected-error {{expected expression}} +} diff --git a/clang/test/SemaCXX/new-delete-cxx0x.cpp b/clang/test/SemaCXX/new-delete-cxx0x.cpp new file mode 100644 index 0000000..c404fab --- /dev/null +++ b/clang/test/SemaCXX/new-delete-cxx0x.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -triple=i686-pc-linux-gnu + +void ugly_news(int *ip) { + // These are ill-formed according to one reading of C++98, and at the least + // have undefined behavior. But they're well-formed, and defined to throw + // std::bad_array_new_length, in C++11. + (void)new int[-1]; // expected-warning {{array size is negative}} + (void)new int[2000000000]; // expected-warning {{array is too large}} +} + + +struct S { + S(int); + S(); + ~S(); +}; + +struct T { // expected-note 2 {{not viable}} + T(int); // expected-note {{not viable}} +}; + +void fn() { + (void) new int[2] {1, 2}; + (void) new S[2] {1, 2}; + (void) new T[2] {1, 2}; // expected-error {{no matching constructor}} +} diff --git a/clang/test/SemaCXX/new-delete-predefined-decl-2.cpp b/clang/test/SemaCXX/new-delete-predefined-decl-2.cpp new file mode 100644 index 0000000..981476d --- /dev/null +++ b/clang/test/SemaCXX/new-delete-predefined-decl-2.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -DQUALIFIED -fsyntax-only -verify %s + +// PR5904 +void f0(int *ptr) { +#ifndef QUALIFIED + operator delete(ptr); +#endif +} + +void f1(int *ptr) { + ::operator delete[](ptr); +} diff --git a/clang/test/SemaCXX/new-delete-predefined-decl.cpp b/clang/test/SemaCXX/new-delete-predefined-decl.cpp new file mode 100644 index 0000000..20b15b7 --- /dev/null +++ b/clang/test/SemaCXX/new-delete-predefined-decl.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -DTEMPLATE_OVERLOAD -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s + +#include <stddef.h> + +// Note that each test must be run separately so it can be the first operator +// new declaration in the file. + +#if defined(TEMPLATE_OVERLOAD) +// Don't crash on global template operator new overloads. +template<typename T> void* operator new(size_t, T); +void test_template_overload() { + (void)new(0) double; +} +#endif + +void test_predefined() { + (void)new double; +} diff --git a/clang/test/SemaCXX/new-delete.cpp b/clang/test/SemaCXX/new-delete.cpp new file mode 100644 index 0000000..e77e3d6 --- /dev/null +++ b/clang/test/SemaCXX/new-delete.cpp @@ -0,0 +1,501 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu + +#include <stddef.h> + +struct S // expected-note {{candidate}} +{ + S(int, int, double); // expected-note {{candidate}} + S(double, int); // expected-note 2 {{candidate}} + S(float, int); // expected-note 2 {{candidate}} +}; +struct T; // expected-note{{forward declaration of 'T'}} +struct U +{ + // A special new, to verify that the global version isn't used. + void* operator new(size_t, S*); // expected-note {{candidate}} +}; +struct V : U +{ +}; + +// PR5823 +void* operator new(const size_t); // expected-note 2 {{candidate}} +void* operator new(size_t, int*); // expected-note 3 {{candidate}} +void* operator new(size_t, float*); // expected-note 3 {{candidate}} +void* operator new(size_t, S); // expected-note 2 {{candidate}} + +struct foo { }; + +void good_news() +{ + int *pi = new int; + float *pf = new (pi) float(); + pi = new int(1); + pi = new int('c'); + const int *pci = new const int(); + S *ps = new S(1, 2, 3.4); + ps = new (pf) (S)(1, 2, 3.4); + S *(*paps)[2] = new S*[*pi][2]; + typedef int ia4[4]; + ia4 *pai = new (int[3][4]); + pi = ::new int; + U *pu = new (ps) U; + V *pv = new (ps) V; + + pi = new (S(1.0f, 2)) int; + + (void)new int[true]; + + // PR7147 + typedef int a[2]; + foo* f1 = new foo; + foo* f2 = new foo[2]; + typedef foo x[2]; + typedef foo y[2][2]; + x* f3 = new y; +} + +struct abstract { + virtual ~abstract() = 0; +}; + +void bad_news(int *ip) +{ + int i = 1; // expected-note 2{{here}} + (void)new; // expected-error {{expected a type}} + (void)new 4; // expected-error {{expected a type}} + (void)new () int; // expected-error {{expected expression}} + (void)new int[1.1]; // expected-error {{array size expression must have integral or enumeration type, not 'double'}} + (void)new int[1][i]; // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}} + (void)new (int[1][i]); // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}} + (void)new (int[i]); // expected-warning {{when type is in parentheses}} + (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}} + (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}} + (void)new S(1); // expected-error {{no matching constructor}} + (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}} + (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}} + (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}} + // Undefined, but clang should reject it directly. + (void)new int[-1]; // expected-error {{array size is negative}} + (void)new int[2000000000]; // expected-error {{array is too large}} + (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumeration type, not 'S'}} + (void)::S::new int; // expected-error {{expected unqualified-id}} + (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}} + (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}} + // This must fail, because the member version shouldn't be found. + (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}} + // This must fail, because any member version hides all global versions. + (void)new U; // expected-error {{no matching function for call to 'operator new'}} + (void)new (int[]); // expected-error {{array size must be specified in new expressions}} + (void)new int&; // expected-error {{cannot allocate reference type 'int &' with new}} + // Some lacking cases due to lack of sema support. +} + +void good_deletes() +{ + delete (int*)0; + delete [](int*)0; + delete (S*)0; + ::delete (int*)0; +} + +void bad_deletes() +{ + delete 0; // expected-error {{cannot delete expression of type 'int'}} + delete [0] (int*)0; // expected-error {{expected expression}} + delete (void*)0; // expected-warning {{cannot delete expression with pointer-to-'void' type 'void *'}} + delete (T*)0; // expected-warning {{deleting pointer to incomplete type}} + ::S::delete (int*)0; // expected-error {{expected unqualified-id}} +} + +struct X0 { }; + +struct X1 { + operator int*(); + operator float(); +}; + +struct X2 { + operator int*(); // expected-note {{candidate function}} + operator float*(); // expected-note {{candidate function}} +}; + +void test_delete_conv(X0 x0, X1 x1, X2 x2) { + delete x0; // expected-error{{cannot delete}} + delete x1; + delete x2; // expected-error{{ambiguous conversion of delete expression of type 'X2' to a pointer}} +} + +// PR4782 +class X3 { +public: + static void operator delete(void * mem, size_t size); +}; + +class X4 { +public: + static void release(X3 *x); + static void operator delete(void * mem, size_t size); +}; + + +void X4::release(X3 *x) { + delete x; +} + +class X5 { +public: + void Destroy() const { delete this; } +}; + +class Base { +public: + static void *operator new(signed char) throw(); // expected-error {{'operator new' takes type size_t}} + static int operator new[] (size_t) throw(); // expected-error {{operator new[]' must return type 'void *'}} +}; + +class Tier {}; +class Comp : public Tier {}; + +class Thai : public Base { +public: + Thai(const Tier *adoptDictionary); +}; + +void loadEngineFor() { + const Comp *dict; + new Thai(dict); +} + +template <class T> struct TBase { + void* operator new(T size, int); // expected-error {{'operator new' cannot take a dependent type as first parameter; use size_t}} +}; + +TBase<int> t1; + +class X6 { +public: + static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}} +}; + +class X7 { +public: + static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}} +}; + +class X8 : public X6, public X7 { +}; + +void f(X8 *x8) { + delete x8; // expected-error {{member 'operator delete' found in multiple base classes of different types}} +} + +class X9 { +public: + static void operator delete(void*, int); // expected-note {{'operator delete' declared here}} + static void operator delete(void*, float); // expected-note {{'operator delete' declared here}} +}; + +void f(X9 *x9) { + delete x9; // expected-error {{no suitable member 'operator delete' in 'X9'}} +} + +struct X10 { + virtual ~X10(); +}; + +struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}} + void operator delete(void*, int); // expected-note {{'operator delete' declared here}} +}; + +void f() { + X11 x11; // expected-note {{implicit default destructor for 'X11' first required here}} +} + +struct X12 { + void* operator new(size_t, void*); +}; + +struct X13 : X12 { + using X12::operator new; +}; + +static void* f(void* g) +{ + return new (g) X13(); +} + +class X14 { +public: + static void operator delete(void*, const size_t); +}; + +void f(X14 *x14a, X14 *x14b) { + delete x14a; +} + +class X15 { +private: + X15(); // expected-note {{declared private here}} + ~X15(); // expected-note {{declared private here}} +}; + +void f(X15* x) { + new X15(); // expected-error {{calling a private constructor}} + delete x; // expected-error {{calling a private destructor}} +} + +namespace PR5918 { // Look for template operator new overloads. + struct S { template<typename T> static void* operator new(size_t, T); }; + void test() { + (void)new(0) S; + } +} + +namespace Test1 { + +void f() { + (void)new int[10](1, 2); // expected-error {{array 'new' cannot have initialization arguments}} + + typedef int T[10]; + (void)new T(1, 2); // expected-error {{array 'new' cannot have initialization arguments}} +} + +template<typename T> +void g(unsigned i) { + (void)new T[1](i); // expected-error {{array 'new' cannot have initialization arguments}} +} + +template<typename T> +void h(unsigned i) { + (void)new T(i); // expected-error {{array 'new' cannot have initialization arguments}} +} +template void h<unsigned>(unsigned); +template void h<unsigned[10]>(unsigned); // expected-note {{in instantiation of function template specialization 'Test1::h<unsigned int [10]>' requested here}} + +} + +// Don't diagnose access for overload candidates that aren't selected. +namespace PR7436 { +struct S1 { + void* operator new(size_t); + void operator delete(void* p); + +private: + void* operator new(size_t, void*); // expected-note {{declared private here}} + void operator delete(void*, void*); +}; +class S2 { + void* operator new(size_t); // expected-note {{declared private here}} + void operator delete(void* p); // expected-note {{declared private here}} +}; + +void test(S1* s1, S2* s2) { + delete s1; + delete s2; // expected-error {{is a private member}} + (void)new S1(); + (void)new (0L) S1(); // expected-error {{is a private member}} + (void)new S2(); // expected-error {{is a private member}} +} +} + +namespace rdar8018245 { + struct X0 { + static const int value = 17; + }; + + const int X0::value; + + struct X1 { + static int value; + }; + + int X1::value; + + template<typename T> + int *f() { + return new (int[T::value]); // expected-warning{{when type is in parentheses, array cannot have dynamic size}} + } + + template int *f<X0>(); + template int *f<X1>(); // expected-note{{in instantiation of}} + +} + +// <rdar://problem/8248780> +namespace Instantiate { + template<typename T> struct X { + operator T*(); + }; + + void f(X<int> &xi) { + delete xi; + } +} + +namespace PR7810 { + struct X { + // cv is ignored in arguments + static void operator delete(void *const); + }; + struct Y { + // cv is ignored in arguments + static void operator delete(void *volatile); + }; +} + +// Don't crash on template delete operators +namespace TemplateDestructors { + struct S { + virtual ~S() {} + + void* operator new(const size_t size); + template<class T> void* operator new(const size_t, const int, T*); + void operator delete(void*, const size_t); + template<class T> void operator delete(void*, const size_t, const int, T*); + }; +} + +namespace DeleteParam { + struct X { + void operator delete(X*); // expected-error{{first parameter of 'operator delete' must have type 'void *'}} + }; + + struct Y { + void operator delete(void* const); + }; +} + +// <rdar://problem/8427878> +// Test that the correct 'operator delete' is selected to pair with +// the unexpected placement 'operator new'. +namespace PairedDelete { + template <class T> struct A { + A(); + void *operator new(size_t s, double d = 0); + void operator delete(void *p, double d); + void operator delete(void *p) { + T::dealloc(p); + } + }; + + A<int> *test() { + return new A<int>(); + } +} + +namespace PR7702 { + void test1() { + new DoesNotExist; // expected-error {{unknown type name 'DoesNotExist'}} + } +} + +namespace ArrayNewNeedsDtor { + struct A { A(); private: ~A(); }; // expected-note {{declared private here}} + struct B { B(); A a; }; // expected-error {{field of type 'ArrayNewNeedsDtor::A' has private destructor}} + B *test9() { + return new B[5]; // expected-note {{implicit default destructor for 'ArrayNewNeedsDtor::B' first required here}} + } +} + +namespace DeleteIncompleteClass { + struct A; // expected-note {{forward declaration}} + extern A x; + void f() { delete x; } // expected-error {{deleting incomplete class type}} +} + +namespace DeleteIncompleteClassPointerError { + struct A; // expected-note {{forward declaration}} + void f(A *x) { 1+delete x; } // expected-warning {{deleting pointer to incomplete type}} \ + // expected-error {{invalid operands to binary expression}} +} + +namespace PR10504 { + struct A { + virtual void foo() = 0; + }; + void f(A *x) { delete x; } // expected-warning {{delete called on 'PR10504::A' that is abstract but has non-virtual destructor}} +} + +struct PlacementArg {}; +inline void *operator new[](size_t, const PlacementArg &) throw () { + return 0; +} +inline void operator delete[](void *, const PlacementArg &) throw () { +} + +namespace r150682 { + + template <typename X> + struct S { + struct Inner {}; + S() { new Inner[1]; } + }; + + struct T { + }; + + template<typename X> + void tfn() { + new (*(PlacementArg*)0) T[1]; + } + + void fn() { + tfn<int>(); + } + +} + +namespace P12023 { + struct CopyCounter + { + CopyCounter(); + CopyCounter(const CopyCounter&); + }; + + int main() + { + CopyCounter* f = new CopyCounter[10](CopyCounter()); // expected-error {{cannot have initialization arguments}} + return 0; + } +} + +namespace PR12061 { + template <class C> struct scoped_array { + scoped_array(C* p = __null); + }; + template <class Payload> struct Foo { + Foo() : a_(new scoped_array<int>[5]) { } + scoped_array< scoped_array<int> > a_; + }; + class Bar {}; + Foo<Bar> x; + + template <class C> struct scoped_array2 { + scoped_array2(C* p = __null, C* q = __null); + }; + template <class Payload> struct Foo2 { + Foo2() : a_(new scoped_array2<int>[5]) { } + scoped_array2< scoped_array2<int> > a_; + }; + class Bar2 {}; + Foo2<Bar2> x2; + + class MessageLoop { + public: + explicit MessageLoop(int type = 0); + }; + template <class CookieStoreTestTraits> + class CookieStoreTest { + protected: + CookieStoreTest() { + new MessageLoop; + } + }; + struct CookieMonsterTestTraits { + }; + class DeferredCookieTaskTest : public CookieStoreTest<CookieMonsterTestTraits> + { + DeferredCookieTaskTest() {} + }; +} diff --git a/clang/test/SemaCXX/no-exceptions.cpp b/clang/test/SemaCXX/no-exceptions.cpp new file mode 100644 index 0000000..f739568 --- /dev/null +++ b/clang/test/SemaCXX/no-exceptions.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Various tests for -fno-exceptions + +typedef __SIZE_TYPE__ size_t; + +namespace test0 { + // rdar://problem/7878149 + class Foo { + public: + void* operator new(size_t x); + private: + void operator delete(void *x); + }; + + void test() { + // Under -fexceptions, this does access control for the associated + // 'operator delete'. + (void) new Foo(); + } +} + +namespace test1 { +void f() { + throw; // expected-error {{cannot use 'throw' with exceptions disabled}} +} + +void g() { + try { // expected-error {{cannot use 'try' with exceptions disabled}} + f(); + } catch (...) { + } +} + +} diff --git a/clang/test/SemaCXX/no-implicit-builtin-decls.cpp b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp new file mode 100644 index 0000000..d82f7f1 --- /dev/null +++ b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f() { + void *p = malloc(sizeof(int) * 10); // expected-error{{use of undeclared identifier 'malloc'}} +} + +int malloc(double); diff --git a/clang/test/SemaCXX/non-empty-class-size-zero.cpp b/clang/test/SemaCXX/non-empty-class-size-zero.cpp new file mode 100644 index 0000000..6b714db --- /dev/null +++ b/clang/test/SemaCXX/non-empty-class-size-zero.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s +// rdar://8945175 + +struct X { + int array[0]; + int array1[0]; + int array2[0]; + X(); + ~X(); +}; + +struct Y { + int first; + X padding; + int second; +}; + +int zero_size_array[(sizeof(Y) == 8) -1]; // no error here! diff --git a/clang/test/SemaCXX/null_in_arithmetic_ops.cpp b/clang/test/SemaCXX/null_in_arithmetic_ops.cpp new file mode 100644 index 0000000..a6c0dbf --- /dev/null +++ b/clang/test/SemaCXX/null_in_arithmetic_ops.cpp @@ -0,0 +1,93 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -fblocks -Wnull-arithmetic -verify -Wno-string-plus-int %s +#include <stddef.h> + +void f() { + int a; + bool b; + void (^c)(); + class X; + void (X::*d) (); + extern void e(); + int f[2]; + const void *v; + + a = 0 ? NULL + a : a + NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL - a : a - NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL / a : a / NULL; // expected-warning 2{{use of NULL in arithmetic operation}} \ + // expected-warning {{division by zero is undefined}} + a = 0 ? NULL * a : a * NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL >> a : a >> NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL << a : a << NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL % a : a % NULL; // expected-warning 2{{use of NULL in arithmetic operation}} \ + expected-warning {{remainder by zero is undefined}} + a = 0 ? NULL & a : a & NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL | a : a | NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + a = 0 ? NULL ^ a : a ^ NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + + // Check for warnings or errors when doing arithmetic on pointers and other + // types. + v = 0 ? NULL + &a : &a + NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + v = 0 ? NULL + c : c + NULL; // \ + expected-error {{invalid operands to binary expression ('long' and 'void (^)()')}} \ + expected-error {{invalid operands to binary expression ('void (^)()' and 'long')}} + v = 0 ? NULL + d : d + NULL; // \ + expected-error {{invalid operands to binary expression ('long' and 'void (X::*)()')}} \ + expected-error {{invalid operands to binary expression ('void (X::*)()' and 'long')}} + v = 0 ? NULL + e : e + NULL; // expected-error 2{{arithmetic on a pointer to the function type 'void ()'}} + v = 0 ? NULL + f : f + NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + v = 0 ? NULL + "f" : "f" + NULL; // expected-warning 2{{use of NULL in arithmetic operation}} + + // Using two NULLs should only give one error instead of two. + a = NULL + NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL - NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL / NULL; // expected-warning{{use of NULL in arithmetic operation}} \ + // expected-warning{{division by zero is undefined}} + a = NULL * NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL >> NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL << NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL % NULL; // expected-warning{{use of NULL in arithmetic operation}} \ + // expected-warning{{remainder by zero is undefined}} + a = NULL & NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL | NULL; // expected-warning{{use of NULL in arithmetic operation}} + a = NULL ^ NULL; // expected-warning{{use of NULL in arithmetic operation}} + + a += NULL; // expected-warning{{use of NULL in arithmetic operation}} + a -= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a /= NULL; // expected-warning{{use of NULL in arithmetic operation}} \ + // expected-warning{{division by zero is undefined}} + a *= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a >>= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a <<= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a %= NULL; // expected-warning{{use of NULL in arithmetic operation}} \ + // expected-warning{{remainder by zero is undefined}} + a &= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a |= NULL; // expected-warning{{use of NULL in arithmetic operation}} + a ^= NULL; // expected-warning{{use of NULL in arithmetic operation}} + + b = a < NULL || a > NULL; // expected-warning 2{{comparison between NULL and non-pointer ('int' and NULL)}} + b = NULL < a || NULL > a; // expected-warning 2{{comparison between NULL and non-pointer (NULL and 'int')}} + b = a <= NULL || a >= NULL; // expected-warning 2{{comparison between NULL and non-pointer ('int' and NULL)}} + b = NULL <= a || NULL >= a; // expected-warning 2{{comparison between NULL and non-pointer (NULL and 'int')}} + b = a == NULL || a != NULL; // expected-warning 2{{comparison between NULL and non-pointer ('int' and NULL)}} + b = NULL == a || NULL != a; // expected-warning 2{{comparison between NULL and non-pointer (NULL and 'int')}} + + b = &a < NULL || NULL < &a || &a > NULL || NULL > &a; + b = &a <= NULL || NULL <= &a || &a >= NULL || NULL >= &a; + b = &a == NULL || NULL == &a || &a != NULL || NULL != &a; + + b = 0 == a; + b = 0 == &a; + + b = NULL < NULL || NULL > NULL; + b = NULL <= NULL || NULL >= NULL; + b = NULL == NULL || NULL != NULL; + + b = ((NULL)) != a; // expected-warning{{comparison between NULL and non-pointer (NULL and 'int')}} + + // Check that even non-standard pointers don't warn. + b = c == NULL || NULL == c || c != NULL || NULL != c; + b = d == NULL || NULL == d || d != NULL || NULL != d; + b = e == NULL || NULL == e || e != NULL || NULL != e; + b = f == NULL || NULL == f || f != NULL || NULL != f; + b = "f" == NULL || NULL == "f" || "f" != NULL || NULL != "f"; +} diff --git a/clang/test/SemaCXX/nullptr-98.cpp b/clang/test/SemaCXX/nullptr-98.cpp new file mode 100644 index 0000000..0d624c2 --- /dev/null +++ b/clang/test/SemaCXX/nullptr-98.cpp @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify %s +void f(void *); +void g() { f(__nullptr); } diff --git a/clang/test/SemaCXX/nullptr.cpp b/clang/test/SemaCXX/nullptr.cpp new file mode 100644 index 0000000..e313603 --- /dev/null +++ b/clang/test/SemaCXX/nullptr.cpp @@ -0,0 +1,185 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -ffreestanding %s +#include <stdint.h> + +typedef decltype(nullptr) nullptr_t; + +struct A {}; + +int o1(char*); +void o1(uintptr_t); +void o2(char*); // expected-note {{candidate}} +void o2(int A::*); // expected-note {{candidate}} + +nullptr_t f(nullptr_t null) +{ + // Implicit conversions. + null = nullptr; + void *p = nullptr; + p = null; + int *pi = nullptr; + pi = null; + null = 0; + int A::*pm = nullptr; + pm = null; + void (*pf)() = nullptr; + pf = null; + void (A::*pmf)() = nullptr; + pmf = null; + bool b = nullptr; + + // Can't convert nullptr to integral implicitly. + uintptr_t i = nullptr; // expected-error {{cannot initialize}} + + // Operators + (void)(null == nullptr); + (void)(null <= nullptr); + (void)(null == (void*)0); + (void)((void*)0 == nullptr); + (void)(null <= (void*)0); + (void)((void*)0 <= nullptr); + (void)(0 == nullptr); + (void)(nullptr == 0); + (void)(nullptr <= 0); + (void)(0 <= nullptr); + (void)(1 > nullptr); // expected-error {{invalid operands to binary expression}} + (void)(1 != nullptr); // expected-error {{invalid operands to binary expression}} + (void)(1 + nullptr); // expected-error {{invalid operands to binary expression}} + (void)(0 ? nullptr : 0); // expected-error {{non-pointer operand type 'int' incompatible with nullptr}} + (void)(0 ? nullptr : (void*)0); + (void)(0 ? nullptr : A()); // expected-error {{non-pointer operand type 'A' incompatible with nullptr}} + (void)(0 ? A() : nullptr); // expected-error {{non-pointer operand type 'A' incompatible with nullptr}} + + // Overloading + int t = o1(nullptr); + t = o1(null); + o2(nullptr); // expected-error {{ambiguous}} + + // nullptr is an rvalue, null is an lvalue + (void)&nullptr; // expected-error {{address expression must be an lvalue}} + nullptr_t *pn = &null; + + // You can reinterpret_cast nullptr to an integer. + (void)reinterpret_cast<uintptr_t>(nullptr); + (void)reinterpret_cast<uintptr_t>(*pn); + + int *ip = *pn; + if (*pn) { } + + // You can throw nullptr. + throw nullptr; +} + +// Template arguments can be nullptr. +template <int *PI, void (*PF)(), int A::*PM, void (A::*PMF)()> +struct T {}; + +typedef T<nullptr, nullptr, nullptr, nullptr> NT; + +namespace test1 { +template<typename T, typename U> struct is_same { + static const bool value = false; +}; + +template<typename T> struct is_same<T, T> { + static const bool value = true; +}; + +void *g(void*); +bool g(bool); + +// Test that we prefer g(void*) over g(bool). +static_assert(is_same<decltype(g(nullptr)), void*>::value, ""); +} + +namespace test2 { + void f(int, ...) __attribute__((sentinel)); + + void g() { + // nullptr can be used as the sentinel value. + f(10, nullptr); + } +} + +namespace test3 { + void f(const char*, ...) __attribute__((format(printf, 1, 2))); + + void g() { + // Don't warn when using nullptr with %p. + f("%p", nullptr); + } +} + +static_assert(__is_scalar(nullptr_t), ""); +static_assert(__is_pod(nullptr_t), ""); +static_assert(sizeof(nullptr_t) == sizeof(void*), ""); + +static_assert(!(nullptr < nullptr), ""); +static_assert(!(nullptr > nullptr), ""); +static_assert( nullptr <= nullptr, ""); +static_assert( nullptr >= nullptr, ""); +static_assert( nullptr == nullptr, ""); +static_assert(!(nullptr != nullptr), ""); + +static_assert(!(0 < nullptr), ""); +static_assert(!(0 > nullptr), ""); +static_assert( 0 <= nullptr, ""); +static_assert( 0 >= nullptr, ""); +static_assert( 0 == nullptr, ""); +static_assert(!(0 != nullptr), ""); + +static_assert(!(nullptr < 0), ""); +static_assert(!(nullptr > 0), ""); +static_assert( nullptr <= 0, ""); +static_assert( nullptr >= 0, ""); +static_assert( nullptr == 0, ""); +static_assert(!(nullptr != 0), ""); + +namespace overloading { + int &f1(int*); + float &f1(bool); + + void test_f1() { + int &ir = (f1)(nullptr); + } + + struct ConvertsToNullPtr { + operator nullptr_t() const; + }; + + void test_conversion(ConvertsToNullPtr ctn) { + (void)(ctn == ctn); + (void)(ctn != ctn); + (void)(ctn <= ctn); + (void)(ctn >= ctn); + (void)(ctn < ctn); + (void)(ctn > ctn); + } +} + +namespace templates { + template<typename T, nullptr_t Value> + struct X { + X() { ptr = Value; } + + T *ptr; + }; + + X<int, nullptr> x; + + + template<int (*fp)(int), int* p, int A::* pmd, int (A::*pmf)(int)> + struct X2 {}; + + X2<nullptr, nullptr, nullptr, nullptr> x2; +} + +namespace null_pointer_constant { + +// Pending implementation of core issue 903, ensure we don't allow any of the +// C++11 constant evaluation semantics in null pointer constants. +struct S { int n; }; +constexpr int null() { return 0; } +void *p = S().n; // expected-error {{cannot initialize}} +void *q = null(); // expected-error {{cannot initialize}} + +} diff --git a/clang/test/SemaCXX/nullptr_in_arithmetic_ops.cpp b/clang/test/SemaCXX/nullptr_in_arithmetic_ops.cpp new file mode 100644 index 0000000..9671353 --- /dev/null +++ b/clang/test/SemaCXX/nullptr_in_arithmetic_ops.cpp @@ -0,0 +1,73 @@ +// RUN: %clang_cc1 -fsyntax-only -fblocks -std=c++11 -verify %s + +void foo() { + int a; + bool b; + + a = 0 ? nullptr + a : a + nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr - a : a - nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr / a : a / nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr * a : a * nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr >> a : a >> nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr << a : a << nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr % a : a % nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr & a : a & nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr | a : a | nullptr; // expected-error 2{{invalid operands to binary expression}} + a = 0 ? nullptr ^ a : a ^ nullptr; // expected-error 2{{invalid operands to binary expression}} + + // Using two nullptrs should only give one error instead of two. + a = nullptr + nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr - nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr / nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr * nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr >> nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr << nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr % nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr & nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr | nullptr; // expected-error{{invalid operands to binary expression}} + a = nullptr ^ nullptr; // expected-error{{invalid operands to binary expression}} + + a += nullptr; // expected-error{{invalid operands to binary expression}} + a -= nullptr; // expected-error{{invalid operands to binary expression}} + a /= nullptr; // expected-error{{invalid operands to binary expression}} + a *= nullptr; // expected-error{{invalid operands to binary expression}} + a >>= nullptr; // expected-error{{invalid operands to binary expression}} + a <<= nullptr; // expected-error{{invalid operands to binary expression}} + a %= nullptr; // expected-error{{invalid operands to binary expression}} + a &= nullptr; // expected-error{{invalid operands to binary expression}} + a |= nullptr; // expected-error{{invalid operands to binary expression}} + a ^= nullptr; // expected-error{{invalid operands to binary expression}} + + b = a < nullptr || nullptr < a; // expected-error 2{{invalid operands to binary expression}} + b = a > nullptr || nullptr > a; // expected-error 2{{invalid operands to binary expression}} + b = a <= nullptr || nullptr <= a; // expected-error 2{{invalid operands to binary expression}} + b = a >= nullptr || nullptr >= a; // expected-error 2{{invalid operands to binary expression}} + b = a == nullptr || nullptr == a; // expected-error 2{{invalid operands to binary expression}} + b = a != nullptr || nullptr != a; // expected-error 2{{invalid operands to binary expression}} + + b = &a < nullptr || nullptr < &a || &a > nullptr || nullptr > &a; + b = &a <= nullptr || nullptr <= &a || &a >= nullptr || nullptr >= &a; + b = &a == nullptr || nullptr == &a || &a != nullptr || nullptr != &a; + + b = nullptr < nullptr || nullptr > nullptr; + b = nullptr <= nullptr || nullptr >= nullptr; + b = nullptr == nullptr || nullptr != nullptr; + + b = ((nullptr)) != a; // expected-error{{invalid operands to binary expression}} + + void (^c)(); + c = nullptr; + b = c == nullptr || nullptr == c || c != nullptr || nullptr != c; + + class X; + void (X::*d) (); + d = nullptr; + b = d == nullptr || nullptr == d || d != nullptr || nullptr != d; + + extern void e(); + b = e == nullptr || nullptr == e || e != nullptr || nullptr != e; + + int f[2]; + b = f == nullptr || nullptr == f || f != nullptr || nullptr != f; + b = "f" == nullptr || nullptr == "f" || "f" != nullptr || nullptr != "f"; +} diff --git a/clang/test/SemaCXX/offsetof.cpp b/clang/test/SemaCXX/offsetof.cpp new file mode 100644 index 0000000..a5f5d34 --- /dev/null +++ b/clang/test/SemaCXX/offsetof.cpp @@ -0,0 +1,75 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -fsyntax-only -verify %s -Winvalid-offsetof + +struct NonPOD { + virtual void f(); + int m; +}; + +struct P { + NonPOD fieldThatPointsToANonPODType; +}; + +void f() { + int i = __builtin_offsetof(P, fieldThatPointsToANonPODType.m); // expected-warning{{offset of on non-POD type 'P'}} +} + +struct Base { int x; }; +struct Derived : Base { int y; }; +int o = __builtin_offsetof(Derived, x); // expected-warning{{offset of on non-POD type}} + +const int o2 = sizeof(__builtin_offsetof(Derived, x)); + +struct HasArray { + int array[17]; +}; + +// Constant and non-constant offsetof expressions +void test_ice(int i) { + int array0[__builtin_offsetof(HasArray, array[5])]; + int array1[__builtin_offsetof(HasArray, array[i])]; +} + +// Bitfields +struct has_bitfields { + int i : 7; + int j : 12; // expected-note{{bit-field is declared here}} +}; + +int test3 = __builtin_offsetof(struct has_bitfields, j); // expected-error{{cannot compute offset of bit-field 'j'}} + +// offsetof referring to members of a base class. +struct Base1 { + int x; +}; + +struct Base2 { + int y; +}; + +struct Derived2 : public Base1, public Base2 { + int z; +}; + +int derived1[__builtin_offsetof(Derived2, x) == 0? 1 : -1]; +int derived2[__builtin_offsetof(Derived2, y) == 4? 1 : -1]; +int derived3[__builtin_offsetof(Derived2, z) == 8? 1 : -1]; + +// offsetof referring to anonymous struct in base. +// PR7769 +struct foo { + struct { + int x; + }; +}; + +struct bar : public foo { +}; + +int anonstruct[__builtin_offsetof(bar, x) == 0 ? 1 : -1]; + +struct LtoRCheck { + int a[10]; + int f(); +}; +int ltor = __builtin_offsetof(struct LtoRCheck, a[LtoRCheck().f]); // \ + expected-error {{reference to non-static member function must be called}} diff --git a/clang/test/SemaCXX/operator-arrow-temporary.cpp b/clang/test/SemaCXX/operator-arrow-temporary.cpp new file mode 100644 index 0000000..8e79609 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/out-of-line-def-mismatch.cpp b/clang/test/SemaCXX/out-of-line-def-mismatch.cpp new file mode 100644 index 0000000..6ade5b8 --- /dev/null +++ b/clang/test/SemaCXX/out-of-line-def-mismatch.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s + +namespace N2 { + struct S1; + + namespace N1 { + class C1 {}; + + struct S2 { + void func(S1*); // expected-note {{type of 1st parameter of member declaration does not match definition ('N2::S1 *' vs 'N2::N1::S1 *')}} + void func(C1&, unsigned, const S1*); // expected-note {{type of 3rd parameter of member declaration does not match definition ('const N2::S1 *' vs 'const N2::N1::S1 *')}} + void func(const S1*, unsigned); //expected-note {{type of 1st parameter of member declaration does not match definition ('const N2::S1 *' vs 'N2::N1::S1')}} + void func(unsigned, const S1*); // expected-note {{type of 1st parameter of member declaration does not match definition ('unsigned int' vs 'unsigned int *')}} + }; + + struct S1 {}; + } +} + +void N2::N1::S2::func(S1*) {} // expected-error {{out-of-line definition of 'func' does not match any declaration in 'N2::N1::S2'}} +void N2::N1::S2::func(C1&, unsigned, const S1*) {} // expected-error {{out-of-line definition of 'func' does not match any declaration in 'N2::N1::S2'}} +void N2::N1::S2::func(S1*, double) {} // expected-error {{out-of-line definition of 'func' does not match any declaration in 'N2::N1::S2'}} +void N2::N1::S2::func(S1, unsigned) {} // expected-error {{out-of-line definition of 'func' does not match any declaration in 'N2::N1::S2'}} +void N2::N1::S2::func(unsigned*, S1*) {} // expected-error {{out-of-line definition of 'func' does not match any declaration in 'N2::N1::S2'}} diff --git a/clang/test/SemaCXX/overload-0x.cpp b/clang/test/SemaCXX/overload-0x.cpp new file mode 100644 index 0000000..677d16a --- /dev/null +++ b/clang/test/SemaCXX/overload-0x.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s + +namespace test0 { + struct A { // expected-note {{candidate function (the implicit copy assignment operator) not viable: 'this' argument has type 'const test0::A', but method is not marked const}} expected-note {{candidate function (the implicit move assignment operator) not viable: 'this' argument has type 'const test0::A', but method is not marked const}} + A &operator=(void*); // expected-note {{candidate function not viable: 'this' argument has type 'const test0::A', but method is not marked const}} + }; + + void test(const A &a) { + a = "help"; // expected-error {{no viable overloaded '='}} + } +} diff --git a/clang/test/SemaCXX/overload-call-copycon.cpp b/clang/test/SemaCXX/overload-call-copycon.cpp new file mode 100644 index 0000000..6720cb6 --- /dev/null +++ b/clang/test/SemaCXX/overload-call-copycon.cpp @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -Wnon-pod-varargs +class X { }; // expected-note {{the implicit copy constructor}} \ + // expected-note{{the implicit default constructor}} + +int& copycon(X x); // expected-note{{passing argument to parameter}} +float& copycon(...); + +void test_copycon(X x, X const xc, X volatile xv) { + int& i1 = copycon(x); + int& i2 = copycon(xc); + copycon(xv); // expected-error{{no matching constructor}} +} + +class A { +public: + A(A&); // expected-note{{would lose const qualifier}} \ + // expected-note{{no known conversion}} +}; + +class B : public A { }; // expected-note{{would lose const qualifier}} \ +// expected-note{{would lose volatile qualifier}} \ +// expected-note 2{{requires 0 arguments}} + +short& copycon2(A a); // expected-note{{passing argument to parameter}} +int& copycon2(B b); // expected-note 2{{passing argument to parameter}} +float& copycon2(...); + +void test_copycon2(A a, const A ac, B b, B const bc, B volatile bv) { + int& i1 = copycon2(b); + copycon2(bc); // expected-error{{no matching constructor}} + copycon2(bv); // expected-error{{no matching constructor}} + short& s1 = copycon2(a); + copycon2(ac); // expected-error{{no matching constructor}} +} + +int& copycon3(A a); // expected-note{{passing argument to parameter 'a' here}} +float& copycon3(...); + +void test_copycon3(B b, const B bc) { + int& i1 = copycon3(b); + copycon3(bc); // expected-error{{no matching constructor}} +} + +class C : public B { }; + +float& copycon4(A a); +int& copycon4(B b); + +void test_copycon4(C c) { + int& i = copycon4(c); +}; diff --git a/clang/test/SemaCXX/overload-call.cpp b/clang/test/SemaCXX/overload-call.cpp new file mode 100644 index 0000000..b5e1214 --- /dev/null +++ b/clang/test/SemaCXX/overload-call.cpp @@ -0,0 +1,570 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +int* f(int) { return 0; } +float* f(float) { return 0; } +void f(); + +void test_f(int iv, float fv) { + float* fp = f(fv); + int* ip = f(iv); +} + +int* g(int, float, int); // expected-note {{candidate function}} +float* g(int, int, int); // expected-note {{candidate function}} +double* g(int, float, float); // expected-note {{candidate function}} +char* g(int, float, ...); // expected-note {{candidate function}} +void g(); + +void test_g(int iv, float fv) { + int* ip1 = g(iv, fv, 0); + float* fp1 = g(iv, iv, 0); + double* dp1 = g(iv, fv, fv); + char* cp1 = g(0, 0); + char* cp2 = g(0, 0, 0, iv, fv); + + double* dp2 = g(0, fv, 1.5); // expected-error {{call to 'g' is ambiguous}} +} + +double* h(double f); +int* h(int); + +void test_h(float fv, unsigned char cv) { + double* dp = h(fv); + int* ip = h(cv); +} + +int* i(int); +double* i(long); + +void test_i(short sv, int iv, long lv, unsigned char ucv) { + int* ip1 = i(sv); + int* ip2 = i(iv); + int* ip3 = i(ucv); + double* dp1 = i(lv); +} + +int* j(void*); +double* j(bool); + +void test_j(int* ip) { + int* ip1 = j(ip); +} + +int* k(char*); +double* k(bool); + +void test_k() { + int* ip1 = k("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}} + int* ip2 = k(("foo")); // expected-warning{{conversion from string literal to 'char *' is deprecated}} + double* dp1 = k(L"foo"); +} + +int* l(wchar_t*); +double* l(bool); + +void test_l() { + int* ip1 = l(L"foo"); // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}} + double* dp1 = l("foo"); +} + +int* m(const char*); +double* m(char*); + +void test_m() { + int* ip = m("foo"); +} + +int* n(char*); +double* n(void*); +class E; + +void test_n(E* e) { + char ca[7]; + int* ip1 = n(ca); + int* ip2 = n("foo"); // expected-warning{{conversion from string literal to 'char *' is deprecated}} + + float fa[7]; + double* dp1 = n(fa); + + double* dp2 = n(e); +} + +enum PromotesToInt { + PromotesToIntValue = -1 +}; + +enum PromotesToUnsignedInt { + PromotesToUnsignedIntValue = __INT_MAX__ * 2U +}; + +int* o(int); +double* o(unsigned int); +float* o(long); + +void test_o() { + int* ip1 = o(PromotesToIntValue); + double* dp1 = o(PromotesToUnsignedIntValue); +} + +int* p(int); +double* p(double); + +void test_p() { + int* ip = p((short)1); + double* dp = p(1.0f); +} + +struct Bits { + signed short int_bitfield : 5; + unsigned int uint_bitfield : 8; +}; + +int* bitfields(int, int); +float* bitfields(unsigned int, int); + +void test_bitfield(Bits bits, int x) { + int* ip = bitfields(bits.int_bitfield, 0); + float* fp = bitfields(bits.uint_bitfield, 0u); +} + +int* multiparm(long, int, long); // expected-note {{candidate function}} +float* multiparm(int, int, int); // expected-note {{candidate function}} +double* multiparm(int, int, short); // expected-note {{candidate function}} + +void test_multiparm(long lv, short sv, int iv) { + int* ip1 = multiparm(lv, iv, lv); + int* ip2 = multiparm(lv, sv, lv); + float* fp1 = multiparm(iv, iv, iv); + float* fp2 = multiparm(sv, iv, iv); + double* dp1 = multiparm(sv, sv, sv); + double* dp2 = multiparm(iv, sv, sv); + multiparm(sv, sv, lv); // expected-error {{call to 'multiparm' is ambiguous}} +} + +// Test overloading based on qualification vs. no qualification +// conversion. +int* quals1(int const * p); +char* quals1(int * p); + +int* quals2(int const * const * pp); +char* quals2(int * * pp); + +int* quals3(int const * * const * ppp); +char* quals3(int *** ppp); + +void test_quals(int * p, int * * pp, int * * * ppp) { + char* q1 = quals1(p); + char* q2 = quals2(pp); + char* q3 = quals3(ppp); +} + +// Test overloading based on qualification ranking (C++ 13.3.2)p3. +int* quals_rank1(int const * p); +float* quals_rank1(int const volatile *p); +char* quals_rank1(char*); +double* quals_rank1(const char*); + +int* quals_rank2(int const * const * pp); +float* quals_rank2(int * const * pp); + +void quals_rank3(int const * const * const volatile * p); // expected-note{{candidate function}} +void quals_rank3(int const * const volatile * const * p); // expected-note{{candidate function}} + +void quals_rank3(int const *); // expected-note{{candidate function}} +void quals_rank3(int volatile *); // expected-note{{candidate function}} + +void test_quals_ranking(int * p, int volatile *pq, int * * pp, int * * * ppp) { + int* q1 = quals_rank1(p); + float* q2 = quals_rank1(pq); + double* q3 = quals_rank1("string literal"); + char a[17]; + const char* ap = a; + char* q4 = quals_rank1(a); + double* q5 = quals_rank1(ap); + + float* q6 = quals_rank2(pp); + + quals_rank3(ppp); // expected-error {{call to 'quals_rank3' is ambiguous}} + + quals_rank3(p); // expected-error {{call to 'quals_rank3' is ambiguous}} + quals_rank3(pq); +} + +// Test overloading based on derived-to-base conversions +class A { }; +class B : public A { }; +class C : public B { }; +class D : public C { }; + +int* derived1(A*); +char* derived1(const A*); +float* derived1(void*); + +int* derived2(A*); +float* derived2(B*); + +int* derived3(A*); +float* derived3(const B*); +char* derived3(C*); + +void test_derived(B* b, B const* bc, C* c, const C* cc, void* v, D* d) { + int* d1 = derived1(b); + char* d2 = derived1(bc); + int* d3 = derived1(c); + char* d4 = derived1(cc); + float* d5 = derived1(v); + + float* d6 = derived2(b); + float* d7 = derived2(c); + + char* d8 = derived3(d); +} + +void derived4(C*); // expected-note{{candidate function not viable: cannot convert from base class pointer 'A *' to derived class pointer 'C *' for 1st argument}} + +void test_base(A* a) { + derived4(a); // expected-error{{no matching function for call to 'derived4}} +} + +// Test overloading of references. +// (FIXME: tests binding to determine candidate sets, not overload +// resolution per se). +int* intref(int&); +float* intref(const int&); + +void intref_test() { + float* ir1 = intref(5); + float* ir2 = intref(5.5); // expected-warning{{implicit conversion turns literal floating-point number into integer}} +} + +void derived5(C&); // expected-note{{candidate function not viable: cannot bind base class object of type 'A' to derived class reference 'C &' for 1st argument}} + +void test_base(A& a) { + derived5(a); // expected-error{{no matching function for call to 'derived5}} +} + +// Test reference binding vs. standard conversions. +int& bind_vs_conv(const double&); +float& bind_vs_conv(int); + +void bind_vs_conv_test() +{ + int& i1 = bind_vs_conv(1.0f); + float& f1 = bind_vs_conv((short)1); +} + +// Test that cv-qualifiers get subsumed in the reference binding. +struct X { }; +struct Y { }; +struct Z : X, Y { }; + +int& cvqual_subsume(X&); // expected-note{{candidate function}} +float& cvqual_subsume(const Y&); // expected-note{{candidate function}} + +int& cvqual_subsume2(const X&); // expected-note{{candidate function}} +float& cvqual_subsume2(const volatile Y&); // expected-note{{candidate function}} + +Z get_Z(); + +void cvqual_subsume_test(Z z) { + cvqual_subsume(z); // expected-error{{call to 'cvqual_subsume' is ambiguous}} + int& x = cvqual_subsume2(get_Z()); // expected-error{{call to 'cvqual_subsume2' is ambiguous}} +} + +// Test overloading with cv-qualification differences in reference +// binding. +int& cvqual_diff(X&); +float& cvqual_diff(const X&); + +void cvqual_diff_test(X x, Z z) { + int& i1 = cvqual_diff(x); + int& i2 = cvqual_diff(z); +} + +// Test overloading with derived-to-base differences in reference +// binding. +struct Z2 : Z { }; + +int& db_rebind(X&); +long& db_rebind(Y&); +float& db_rebind(Z&); + +void db_rebind_test(Z2 z2) { + float& f1 = db_rebind(z2); +} + +class string { }; +class opt : public string { }; + +struct SR { + SR(const string&); +}; + +void f(SR) { } + +void g(opt o) { + f(o); +} + + +namespace PR5756 { + int &a(void*, int); + float &a(void*, float); + void b() { + int &ir = a(0,0); + (void)ir; + } +} + +// Tests the exact text used to note the candidates +namespace test1 { + template <class T> void foo(T t, unsigned N); // expected-note {{candidate function [with T = int] not viable: no known conversion from 'const char [6]' to 'unsigned int' for 2nd argument}} + void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'const char [6]' to 'char' for 2nd argument}} + void foo(int n); // expected-note {{candidate function not viable: requires 1 argument, but 2 were provided}} + void foo(unsigned n = 10); // expected-note {{candidate function not viable: requires at most 1 argument, but 2 were provided}} + void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}} + void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} + void foo(int n, const char *s, int t, int u = 0); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} + + void test() { + foo(4, "hello"); //expected-error {{no matching function for call to 'foo'}} + } +} + +// PR 6014 +namespace test2 { + struct QFixed { + QFixed(int i); + QFixed(long i); + }; + + bool operator==(const QFixed &f, int i); + + class qrgb666 { + inline operator unsigned int () const; + + inline bool operator==(const qrgb666 &v) const; + inline bool operator!=(const qrgb666 &v) const { return !(*this == v); } + }; +} + +// PR 6117 +namespace test3 { + struct Base {}; + struct Incomplete; + + void foo(Base *); // expected-note 2 {{cannot convert argument of incomplete type}} + void foo(Base &); // expected-note 2 {{cannot convert argument of incomplete type}} + + void test(Incomplete *P) { + foo(P); // expected-error {{no matching function for call to 'foo'}} + foo(*P); // expected-error {{no matching function for call to 'foo'}} + } +} + +namespace DerivedToBaseVsVoid { + struct A { }; + struct B : A { }; + + float &f(void *); + int &f(const A*); + + void g(B *b) { + int &ir = f(b); + } +} + +// PR 6398 + PR 6421 +namespace test4 { + class A; + class B { + static void foo(); // expected-note {{not viable}} + static void foo(int*); // expected-note {{not viable}} + static void foo(long*); // expected-note {{not viable}} + + void bar(A *a) { + foo(a); // expected-error {{no matching function for call}} + } + }; +} + +namespace DerivedToBase { + struct A { }; + struct B : A { }; + struct C : B { }; + + int &f0(const A&); + float &f0(B); + + void g() { + float &fr = f0(C()); + } +} + +namespace PR6483 { + struct X0 { + operator const unsigned int & () const; + }; + + struct X1 { + operator unsigned int & () const; + }; + + void f0(const bool &); + void f1(bool &); // expected-note 2{{not viable}} + + void g(X0 x0, X1 x1) { + f0(x0); + f1(x0); // expected-error{{no matching function for call}} + f0(x1); + f1(x1); // expected-error{{no matching function for call}} + } +} + +namespace PR6078 { + struct A { + A(short); // expected-note{{candidate constructor}} + A(long); // expected-note{{candidate constructor}} + }; + struct S { + typedef void ft(A); + operator ft*(); + }; + + void f() { + S()(0); // expected-error{{conversion from 'int' to 'PR6078::A' is ambiguous}} + } +} + +namespace PR6177 { + struct String { String(char const*); }; + + void f(bool const volatile&); // expected-note{{passing argument to parameter here}} + void f(String); + + void g() { f(""); } // expected-error{{volatile lvalue reference to type 'const volatile bool' cannot bind to a value of unrelated type 'const char [1]'}} +} + +namespace PR7095 { + struct X { }; + + struct Y { + operator const X*(); + + private: + operator X*(); + }; + + void f(const X *); + void g(Y y) { f(y); } +} + +namespace PR7224 { + class A {}; + class B : public A {}; + + int &foo(A *const d); + float &foo(const A *const d); + + void bar() + { + B *const d = 0; + B const *const d2 = 0; + int &ir = foo(d); + float &fr = foo(d2); + } +} + +namespace NontrivialSubsequence { + struct X0; + + class A { + operator X0 *(); + public: + operator const X0 *(); + }; + + A a; + void foo( void const * ); + + void g() { + foo(a); + } +} + +// rdar://rdar8499524 +namespace rdar8499524 { + struct W {}; + struct S { + S(...); + }; + + void g(const S&); + void f() { + g(W()); + } +} + +namespace rdar9173984 { + template <typename T, unsigned long N> int &f(const T (&)[N]); + template <typename T> float &f(const T *); + + void test() { + int arr[2] = {0, 0}; + int *arrp = arr; + int &ir = f(arr); + float &fr = f(arrp); + } +} + +namespace PR9507 { + void f(int * const&); // expected-note{{candidate function}} + void f(int const(&)[1]); // expected-note{{candidate function}} + + int main() { + int n[1]; + f(n); // expected-error{{call to 'f' is ambiguous}} + } +} + +namespace rdar9803316 { + void foo(float); + int &foo(int); + + void bar() { + int &ir = (&foo)(0); + } +} + +namespace IncompleteArg { + // Ensure that overload resolution attempts to complete argument types when + // performing ADL. + template<typename T> struct S { + friend int f(const S&); + }; + extern S<int> s; + int k = f(s); + + template<typename T> struct Op { + friend bool operator==(const Op &, const Op &); + }; + extern Op<char> op; + bool b = op == op; + + // ... and not in other cases! Nothing here requires U<int()> to be complete. + // (Note that instantiating U<int()> will fail.) + template<typename T> struct U { + T t; + }; + struct Consumer { + template<typename T> + int operator()(const U<T> &); + }; + template<typename T> U<T> &make(); + Consumer c; + int n = sizeof(c(make<int()>())); +} + +namespace PR12142 { + void fun(int (*x)[10]); // expected-note{{candidate function not viable: 1st argument ('const int (*)[10]') would lose const qualifier}} + void g() { fun((const int(*)[10])0); } // expected-error{{no matching function for call to 'fun'}} +} diff --git a/clang/test/SemaCXX/overload-decl.cpp b/clang/test/SemaCXX/overload-decl.cpp new file mode 100644 index 0000000..c610ff7 --- /dev/null +++ b/clang/test/SemaCXX/overload-decl.cpp @@ -0,0 +1,31 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +void f(); +void f(int); +void f(int, float); +void f(int, int); +void f(int, ...); + +typedef float Float; +void f(int, Float); // expected-note {{previous declaration is here}} + +int f(int, Float); // expected-error {{functions that differ only in their return type cannot be overloaded}} + +void g(void); // expected-note {{previous declaration is here}} +int g(); // expected-error {{functions that differ only in their return type cannot be overloaded}} + +typedef int INT; + +class X { + void f(); + void f(int); // expected-note {{previous declaration is here}} + void f() const; + + void f(INT); // expected-error{{cannot be redeclared}} + + void g(int); // expected-note {{previous declaration is here}} + void g(int, float); // expected-note {{previous declaration is here}} + int g(int, Float); // expected-error {{functions that differ only in their return type cannot be overloaded}} + + static void g(float); + static void g(int); // expected-error {{static and non-static member functions with the same parameter types cannot be overloaded}} +}; diff --git a/clang/test/SemaCXX/overload-member-call.cpp b/clang/test/SemaCXX/overload-member-call.cpp new file mode 100644 index 0000000..37c9552 --- /dev/null +++ b/clang/test/SemaCXX/overload-member-call.cpp @@ -0,0 +1,98 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct X { + int& f(int) const; // expected-note 2 {{candidate function}} + float& f(int); // expected-note 2 {{candidate function}} + + void test_f(int x) const { + int& i = f(x); + } + + void test_f2(int x) { + float& f2 = f(x); + } + + int& g(int) const; // expected-note 2 {{candidate function}} + float& g(int); // expected-note 2 {{candidate function}} + static double& g(double); // expected-note 2 {{candidate function}} + + void h(int); + + void test_member() { + float& f1 = f(0); + float& f2 = g(0); + double& d1 = g(0.0); + } + + void test_member_const() const { + int &i1 = f(0); + int &i2 = g(0); + double& d1 = g(0.0); + } + + static void test_member_static() { + double& d1 = g(0.0); + g(0); // expected-error{{call to 'g' is ambiguous}} + } +}; + +void test(X x, const X xc, X* xp, const X* xcp, volatile X xv, volatile X* xvp) { + int& i1 = xc.f(0); + int& i2 = xcp->f(0); + float& f1 = x.f(0); + float& f2 = xp->f(0); + xv.f(0); // expected-error{{no matching member function for call to 'f'}} + xvp->f(0); // expected-error{{no matching member function for call to 'f'}} + + int& i3 = xc.g(0); + int& i4 = xcp->g(0); + float& f3 = x.g(0); + float& f4 = xp->g(0); + double& d1 = xp->g(0.0); + double& d2 = X::g(0.0); + X::g(0); // expected-error{{call to 'g' is ambiguous}} + + X::h(0); // expected-error{{call to non-static member function without an object argument}} +} + +struct X1 { + int& member(); + float& member() const; +}; + +struct X2 : X1 { }; + +void test_X2(X2 *x2p, const X2 *cx2p) { + int &ir = x2p->member(); + float &fr = cx2p->member(); +} + +// Tests the exact text used to note the candidates +namespace test1 { + class A { + template <class T> void foo(T t, unsigned N); // expected-note {{candidate function [with T = int] not viable: no known conversion from 'const char [6]' to 'unsigned int' for 2nd argument}} + void foo(int n, char N); // expected-note {{candidate function not viable: no known conversion from 'const char [6]' to 'char' for 2nd argument}} + void foo(int n); // expected-note {{candidate function not viable: requires 1 argument, but 2 were provided}} + void foo(unsigned n = 10); // expected-note {{candidate function not viable: requires at most 1 argument, but 2 were provided}} + void foo(int n, const char *s, int t); // expected-note {{candidate function not viable: requires 3 arguments, but 2 were provided}} + void foo(int n, const char *s, int t, ...); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} + void foo(int n, const char *s, int t, int u = 0); // expected-note {{candidate function not viable: requires at least 3 arguments, but 2 were provided}} + + void bar(double d); //expected-note {{candidate function not viable: 'this' argument has type 'const test1::A', but method is not marked const}} + void bar(int i); //expected-note {{candidate function not viable: 'this' argument has type 'const test1::A', but method is not marked const}} + + void baz(A &d); // expected-note {{candidate function not viable: 1st argument ('const test1::A') would lose const qualifier}} + void baz(int i); // expected-note {{candidate function not viable: no known conversion from 'const test1::A' to 'int' for 1st argument}} + }; + + void test() { + A a; + a.foo(4, "hello"); //expected-error {{no matching member function for call to 'foo'}} + + const A b = A(); + b.bar(0); //expected-error {{no matching member function for call to 'bar'}} + + a.baz(b); //expected-error {{no matching member function for call to 'baz'}} + } +} + diff --git a/clang/test/SemaCXX/overload-value-dep-arg.cpp b/clang/test/SemaCXX/overload-value-dep-arg.cpp new file mode 100644 index 0000000..c1834a7 --- /dev/null +++ b/clang/test/SemaCXX/overload-value-dep-arg.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +class C { + C(void*); +}; + +int f(const C&); +int f(unsigned long); + +template<typename T> int f(const T* t) { + return f(reinterpret_cast<unsigned long>(t)); +} + diff --git a/clang/test/SemaCXX/overloaded-builtin-operators-0x.cpp b/clang/test/SemaCXX/overloaded-builtin-operators-0x.cpp new file mode 100644 index 0000000..6a5a162 --- /dev/null +++ b/clang/test/SemaCXX/overloaded-builtin-operators-0x.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -fshow-overloads=best -std=c++11 -verify %s + +template <class T> +struct X +{ + operator T() const {return T();} +}; + +void test_char16t(X<char16_t> x) { + bool b = x == char16_t(); +} diff --git a/clang/test/SemaCXX/overloaded-builtin-operators.cpp b/clang/test/SemaCXX/overloaded-builtin-operators.cpp new file mode 100644 index 0000000..b3c0808 --- /dev/null +++ b/clang/test/SemaCXX/overloaded-builtin-operators.cpp @@ -0,0 +1,239 @@ +// RUN: %clang_cc1 -fsyntax-only -fshow-overloads=best -verify %s +struct yes; +struct no; + +struct Short { + operator short(); +}; + +struct Long { + operator long(); +}; + +enum E1 { }; +struct Enum1 { + operator E1(); +}; + +enum E2 { }; +struct Enum2 { + operator E2(); +}; + + +struct X { + void f(); +}; + +typedef void (X::*pmf)(); +struct Xpmf { + operator pmf(); +}; + +yes& islong(long); +yes& islong(unsigned long); // FIXME: shouldn't be needed +no& islong(int); + +void f(Short s, Long l, Enum1 e1, Enum2 e2, Xpmf pmf) { + // C++ [over.built]p8 + int i1 = +e1; + int i2 = -e2; + + // C++ [over.built]p10: + int i3 = ~s; + bool b1 = !s; + + // C++ [over.built]p12 + (void)static_cast<yes&>(islong(s + l)); + (void)static_cast<no&>(islong(s + s)); + + // C++ [over.built]p16 + (void)(pmf == &X::f); + (void)(pmf == 0); + + // C++ [over.built]p17 + (void)static_cast<yes&>(islong(s % l)); + (void)static_cast<yes&>(islong(l << s)); + (void)static_cast<no&>(islong(s << l)); + (void)static_cast<yes&>(islong(e1 % l)); + // FIXME: should pass (void)static_cast<no&>(islong(e1 % e2)); +} + +struct ShortRef { // expected-note{{candidate function (the implicit copy assignment operator)}} + operator short&(); +}; + +struct LongRef { + operator volatile long&(); +}; + +struct XpmfRef { // expected-note{{candidate function (the implicit copy assignment operator)}} + operator pmf&(); +}; + +struct E2Ref { + operator E2&(); +}; + +void g(ShortRef sr, LongRef lr, E2Ref e2_ref, XpmfRef pmf_ref) { + // C++ [over.built]p3 + short s1 = sr++; + + // C++ [over.built]p3 + long l1 = lr--; + + // C++ [over.built]p18 + short& sr1 = (sr *= lr); + volatile long& lr1 = (lr *= sr); + + // C++ [over.built]p20: + E2 e2r2; + e2r2 = e2_ref; + + pmf &pmr = (pmf_ref = &X::f); // expected-error{{no viable overloaded '='}} + pmf pmr2; + pmr2 = pmf_ref; + + // C++ [over.built]p22 + short& sr2 = (sr %= lr); + volatile long& lr2 = (lr <<= sr); + + bool b1 = (sr && lr) || (sr || lr); +} + +struct VolatileIntPtr { + operator int volatile *(); +}; + +struct ConstIntPtr { + operator int const *(); +}; + +struct VolatileIntPtrRef { + operator int volatile *&(); +}; + +struct ConstIntPtrRef { + operator int const *&(); +}; + +void test_with_ptrs(VolatileIntPtr vip, ConstIntPtr cip, ShortRef sr, + VolatileIntPtrRef vipr, ConstIntPtrRef cipr) { + const int& cir1 = cip[sr]; + const int& cir2 = sr[cip]; + volatile int& vir1 = vip[sr]; + volatile int& vir2 = sr[vip]; + bool b1 = (vip == cip); + long p1 = vip - cip; + + // C++ [over.built]p5: + int volatile *vip1 = vipr++; + int const *cip1 = cipr++; + int volatile *&vipr1 = ++vipr; + int const *&cipr1 = --cipr; + + // C++ [over.built]p6: + int volatile &ivr = *vip; + + // C++ [over.built]p8: + int volatile *vip2 = +vip; + int i1 = +sr; + int i2 = -sr; + + // C++ [over.built]p13: + int volatile &ivr2 = vip[17]; + int const &icr2 = 17[cip]; +} + +// C++ [over.match.open]p4 + +void test_assign_restrictions(ShortRef& sr) { + sr = (short)0; // expected-error{{no viable overloaded '='}} +} + +struct Base { }; +struct Derived1 : Base { }; +struct Derived2 : Base { }; + +template<typename T> +struct ConvertibleToPtrOf { + operator T*(); +}; + +bool test_with_base_ptrs(ConvertibleToPtrOf<Derived1> d1, + ConvertibleToPtrOf<Derived2> d2) { + return d1 == d2; // expected-error{{invalid operands}} +} + +// DR425 +struct A { + template< typename T > operator T() const; +}; + +void test_dr425(A a) { + // FIXME: lots of candidates here! + (void)(1.0f * a); // expected-error{{ambiguous}} \ + // expected-note 4{{candidate}} \ + // expected-note {{remaining 77 candidates omitted; pass -fshow-overloads=all to show them}} +} + +// pr5432 +enum e {X}; + +const int a[][2] = {{1}}; + +int test_pr5432() { + return a[X][X]; +} + +void f() { + (void)__extension__(A()); +} + +namespace PR7319 { + typedef enum { Enum1, Enum2, Enum3 } MyEnum; + + template<typename X> bool operator>(const X &inX1, const X &inX2); + + void f() { + MyEnum e1, e2; + if (e1 > e2) {} + } +} + +namespace PR8477 { + struct Foo { + operator bool(); + operator const char *(); + }; + + bool doit() { + Foo foo; + long long zero = 0; + (void)(foo + zero); + (void)(foo - zero); + (void)(zero + foo); + (void)(zero[foo]); + (void)(foo - foo); // expected-error{{use of overloaded operator '-' is ambiguous}} \ + // expected-note 4{{built-in candidate operator-}} \ + // expected-note{{candidates omitted}} + return foo[zero] == zero; + } +} + +namespace PR7851 { + struct X { + operator const void *() const; + operator void *(); + + operator const unsigned *() const; + operator unsigned *(); + }; + + void f() { + X x; + x[0] = 1; + *x = 0; + (void)(x - x); + } +} diff --git a/clang/test/SemaCXX/overloaded-name.cpp b/clang/test/SemaCXX/overloaded-name.cpp new file mode 100644 index 0000000..6da0354 --- /dev/null +++ b/clang/test/SemaCXX/overloaded-name.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int ovl(int); // expected-note 3{{possible target for call}} +float ovl(float); // expected-note 3{{possible target for call}} + +template<typename T> T ovl(T); // expected-note 3{{possible target for call}} + +void test(bool b) { + (void)((void)0, ovl); // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} + // PR7863 + (void)(b? ovl : &ovl); // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} + (void)(b? ovl<float> : &ovl); // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} + (void)(b? ovl<float> : ovl<float>); +} + +namespace rdar9623945 { + void f(...) { + } + + class X { + public: + const char* text(void); + void g(void) { + f(text()); + f(text); // expected-error {{reference to non-static member function must be called; did you mean to call it with no arguments?}} + f(text()); + f(text); // expected-error {{reference to non-static member function must be called; did you mean to call it with no arguments?}} + } + }; +} diff --git a/clang/test/SemaCXX/overloaded-operator-decl.cpp b/clang/test/SemaCXX/overloaded-operator-decl.cpp new file mode 100644 index 0000000..4519a2d --- /dev/null +++ b/clang/test/SemaCXX/overloaded-operator-decl.cpp @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct X { + X(); + X(int); +}; + +X operator+(X, X); +X operator-(X, X) { X x; return x; } + +struct Y { + Y operator-() const; + void operator()(int x = 17) const; + int operator[](int); + + static int operator+(Y, Y); // expected-error{{overloaded 'operator+' cannot be a static member function}} +}; + + +void f(X x) { + x = operator+(x, x); +} + +X operator+(int, float); // expected-error{{overloaded 'operator+' must have at least one parameter of class or enumeration type}} + +X operator*(X, X = 5); // expected-error{{parameter of overloaded 'operator*' cannot have a default argument}} + +X operator/(X, X, ...); // expected-error{{overloaded 'operator/' cannot be variadic}} + +X operator%(Y); // expected-error{{overloaded 'operator%' must be a binary operator (has 1 parameter)}} + +void operator()(Y&, int, int); // expected-error{{overloaded 'operator()' must be a non-static member function}} + +typedef int INT; +typedef float FLOAT; +Y& operator++(Y&); +Y operator++(Y&, INT); +X operator++(X&, FLOAT); // expected-error{{parameter of overloaded post-increment operator must have type 'int' (not 'FLOAT' (aka 'float'))}} + +int operator+; // expected-error{{'operator+' cannot be the name of a variable or data member}} + +namespace PR6238 { + static struct { + void operator()(); + } plus; +} + +struct PR10839 { + operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}} + int operator+; // expected-error{{'operator+' cannot be the name of a variable or data member}} +}; diff --git a/clang/test/SemaCXX/overloaded-operator.cpp b/clang/test/SemaCXX/overloaded-operator.cpp new file mode 100644 index 0000000..8ecb54d --- /dev/null +++ b/clang/test/SemaCXX/overloaded-operator.cpp @@ -0,0 +1,417 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class X { }; + +X operator+(X, X); + +void f(X x) { + x = x + x; +} + +struct Y; +struct Z; + +struct Y { + Y(const Z&); +}; + +struct Z { + Z(const Y&); +}; + +Y operator+(Y, Y); +bool operator-(Y, Y); // expected-note{{candidate function}} +bool operator-(Z, Z); // expected-note{{candidate function}} + +void g(Y y, Z z) { + y = y + z; + bool b = y - z; // expected-error{{use of overloaded operator '-' is ambiguous}} +} + +struct A { + bool operator==(Z&); // expected-note 2{{candidate function}} +}; + +A make_A(); + +bool operator==(A&, Z&); // expected-note 3{{candidate function}} + +void h(A a, const A ac, Z z) { + make_A() == z; // expected-warning{{equality comparison result unused}} + a == z; // expected-error{{use of overloaded operator '==' is ambiguous}} + ac == z; // expected-error{{invalid operands to binary expression ('const A' and 'Z')}} +} + +struct B { + bool operator==(const B&) const; + + void test(Z z) { + make_A() == z; // expected-warning{{equality comparison result unused}} + } +}; + +// we shouldn't see warnings about self-comparison, +// this is a member function, we dunno what it'll do +bool i(B b) +{ + return b == b; +} + +enum Enum1 { }; +enum Enum2 { }; + +struct E1 { + E1(Enum1) { } +}; + +struct E2 { + E2(Enum2); +}; + +// C++ [over.match.oper]p3 - enum restriction. +float& operator==(E1, E2); // expected-note{{candidate function}} + +void enum_test(Enum1 enum1, Enum2 enum2, E1 e1, E2 e2, Enum1 next_enum1) { + float &f1 = (e1 == e2); + float &f2 = (enum1 == e2); + float &f3 = (e1 == enum2); + float &f4 = (enum1 == next_enum1); // expected-error{{non-const lvalue reference to type 'float' cannot bind to a temporary of type 'bool'}} +} + +// PR5244 - Argument-dependent lookup would include the two operators below, +// which would break later assumptions and lead to a crash. +class pr5244_foo +{ + pr5244_foo(int); + pr5244_foo(char); +}; + +bool operator==(const pr5244_foo& s1, const pr5244_foo& s2); // expected-note{{candidate function}} +bool operator==(char c, const pr5244_foo& s); // expected-note{{candidate function}} + +enum pr5244_bar +{ + pr5244_BAR +}; + +class pr5244_baz +{ +public: + pr5244_bar quux; +}; + +void pr5244_barbaz() +{ + pr5244_baz quuux; + (void)(pr5244_BAR == quuux.quux); +} + + + +struct PostInc { + PostInc operator++(int); + PostInc& operator++(); +}; + +struct PostDec { + PostDec operator--(int); + PostDec& operator--(); +}; + +void incdec_test(PostInc pi, PostDec pd) { + const PostInc& pi1 = pi++; + const PostDec& pd1 = pd--; + PostInc &pi2 = ++pi; + PostDec &pd2 = --pd; +} + +struct SmartPtr { + int& operator*(); + long& operator*() const volatile; +}; + +void test_smartptr(SmartPtr ptr, const SmartPtr cptr, + const volatile SmartPtr cvptr) { + int &ir = *ptr; + long &lr = *cptr; + long &lr2 = *cvptr; +} + + +struct ArrayLike { + int& operator[](int); +}; + +void test_arraylike(ArrayLike a) { + int& ir = a[17]; +} + +struct SmartRef { + int* operator&(); +}; + +void test_smartref(SmartRef r) { + int* ip = &r; +} + +bool& operator,(X, Y); + +void test_comma(X x, Y y) { + bool& b1 = (x, y); + X& xr = (x, x); // expected-warning {{expression result unused}} +} + +struct Callable { + int& operator()(int, double = 2.71828); // expected-note{{candidate function}} + float& operator()(int, double, long, ...); // expected-note{{candidate function}} + + double& operator()(float); // expected-note{{candidate function}} +}; + +struct Callable2 { + int& operator()(int i = 0); + double& operator()(...) const; +}; + +struct DerivesCallable : public Callable { +}; + +void test_callable(Callable c, Callable2 c2, const Callable2& c2c, + DerivesCallable dc) { + int &ir = c(1); + float &fr = c(1, 3.14159, 17, 42); + + c(); // expected-error{{no matching function for call to object of type 'Callable'}} + + double &dr = c(1.0f); + + int &ir2 = c2(); + int &ir3 = c2(1); + double &fr2 = c2c(); + + int &ir4 = dc(17); + double &fr3 = dc(3.14159f); +} + +typedef float FLOAT; +typedef int& INTREF; +typedef INTREF Func1(FLOAT, double); +typedef float& Func2(int, double); + +struct ConvertToFunc { + operator Func1*(); // expected-note 2{{conversion candidate of type 'INTREF (*)(FLOAT, double)'}} + operator Func2&(); // expected-note 2{{conversion candidate of type 'float &(&)(int, double)'}} + void operator()(); +}; + +struct ConvertToFuncDerived : ConvertToFunc { }; + +void test_funcptr_call(ConvertToFunc ctf, ConvertToFuncDerived ctfd) { + int &i1 = ctf(1.0f, 2.0); + float &f1 = ctf((short int)1, 1.0f); + ctf((long int)17, 2.0); // expected-error{{call to object of type 'ConvertToFunc' is ambiguous}} + ctf(); + + int &i2 = ctfd(1.0f, 2.0); + float &f2 = ctfd((short int)1, 1.0f); + ctfd((long int)17, 2.0); // expected-error{{call to object of type 'ConvertToFuncDerived' is ambiguous}} + ctfd(); +} + +struct HasMember { + int m; +}; + +struct Arrow1 { + HasMember* operator->(); +}; + +struct Arrow2 { + Arrow1 operator->(); // expected-note{{candidate function}} +}; + +void test_arrow(Arrow1 a1, Arrow2 a2, const Arrow2 a3) { + int &i1 = a1->m; + int &i2 = a2->m; + a3->m; // expected-error{{no viable overloaded 'operator->'}} +} + +struct CopyConBase { +}; + +struct CopyCon : public CopyConBase { + CopyCon(const CopyConBase &Base); + + CopyCon(const CopyConBase *Base) { + *this = *Base; + } +}; + +namespace N { + struct X { }; +} + +namespace M { + N::X operator+(N::X, N::X); +} + +namespace M { + void test_X(N::X x) { + (void)(x + x); + } +} + +struct AA { bool operator!=(AA&); }; +struct BB : AA {}; +bool x(BB y, BB z) { return y != z; } + + +struct AX { + AX& operator ->(); // expected-note {{declared here}} + int b; +}; + +void m() { + AX a; + a->b = 0; // expected-error {{circular pointer delegation detected}} +} + +struct CircA { + struct CircB& operator->(); // expected-note {{declared here}} + int val; +}; +struct CircB { + struct CircC& operator->(); // expected-note {{declared here}} +}; +struct CircC { + struct CircA& operator->(); // expected-note {{declared here}} +}; + +void circ() { + CircA a; + a->val = 0; // expected-error {{circular pointer delegation detected}} +} + +// PR5360: Arrays should lead to built-in candidates for subscript. +typedef enum { + LastReg = 23, +} Register; +class RegAlloc { + int getPriority(Register r) { + return usepri[r]; + } + int usepri[LastReg + 1]; +}; + +// PR5546: Don't generate incorrect and ambiguous overloads for multi-level +// arrays. +namespace pr5546 +{ + enum { X }; + extern const char *const sMoveCommands[][2][2]; + const char* a() { return sMoveCommands[X][0][0]; } + const char* b() { return (*(sMoveCommands+X))[0][0]; } +} + +// PR5512 and its discussion +namespace pr5512 { + struct Y { + operator short(); + operator float(); + }; + void g_test(Y y) { + short s = 0; + // DR507, this should be ambiguous, but we special-case assignment + s = y; + // Note: DR507, this is ambiguous as specified + //s += y; + } + + struct S {}; + void operator +=(int&, S); + void f(S s) { + int i = 0; + i += s; + } + + struct A {operator int();}; + int a; + void b(A x) { + a += x; + } +} + +// PR5900 +namespace pr5900 { + struct NotAnArray {}; + void test0() { + NotAnArray x; + x[0] = 0; // expected-error {{does not provide a subscript operator}} + } + + struct NonConstArray { + int operator[](unsigned); // expected-note {{candidate}} + }; + int test1() { + const NonConstArray x = NonConstArray(); + return x[0]; // expected-error {{no viable overloaded operator[] for type}} + } + + // Not really part of this PR, but implemented at the same time. + struct NotAFunction {}; + void test2() { + NotAFunction x; + x(); // expected-error {{does not provide a call operator}} + } +} + +// Operator lookup through using declarations. +namespace N { + struct X2 { }; +} + +namespace N2 { + namespace M { + namespace Inner { + template<typename T> + N::X2 &operator<<(N::X2&, const T&); + } + using Inner::operator<<; + } +} + +void test_lookup_through_using() { + using namespace N2::M; + N::X2 x; + x << 17; +} + +namespace rdar9136502 { + struct X { + int i(); + int i(int); + }; + + struct Y { + Y &operator<<(int); + }; + + void f(X x, Y y) { + y << x.i; // expected-error{{reference to non-static member function must be called}} + } +} + +namespace rdar9222009 { +class StringRef { + inline bool operator==(StringRef LHS, StringRef RHS) { // expected-error{{overloaded 'operator==' must be a binary operator (has 3 parameters)}} + return !(LHS == RHS); // expected-error{{invalid operands to binary expression ('rdar9222009::StringRef' and 'rdar9222009::StringRef')}} + } +}; + +} + +namespace PR11784 { + struct A { A& operator=(void (*x)()); }; + void f(); + void f(int); + void g() { A x; x = f; } +} diff --git a/clang/test/SemaCXX/pascal-strings.cpp b/clang/test/SemaCXX/pascal-strings.cpp new file mode 100644 index 0000000..89194b5 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/pragma-pack.cpp b/clang/test/SemaCXX/pragma-pack.cpp new file mode 100644 index 0000000..1bc738b --- /dev/null +++ b/clang/test/SemaCXX/pragma-pack.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -triple i686-apple-darwin9 -fsyntax-only -verify %s + +namespace rdar8745206 { + +struct Base { + int i; +}; + +#pragma pack(push, 1) +struct Sub : public Base { + char c; +}; +#pragma pack(pop) + +int check[sizeof(Sub) == 5 ? 1 : -1]; + +} + +namespace check2 { + +struct Base { + virtual ~Base(); + int x; +}; + +#pragma pack(push, 1) +struct Sub : virtual Base { + char c; +}; +#pragma pack(pop) + +int check[sizeof(Sub) == 13 ? 1 : -1]; + +} diff --git a/clang/test/SemaCXX/pragma-unused.cpp b/clang/test/SemaCXX/pragma-unused.cpp new file mode 100644 index 0000000..c9ddffa --- /dev/null +++ b/clang/test/SemaCXX/pragma-unused.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-parameter -Wunused -verify %s + +struct S { + void m(int x, int y) { + int z; + #pragma unused(x,y,z) + } +}; diff --git a/clang/test/SemaCXX/pragma-visibility.cpp b/clang/test/SemaCXX/pragma-visibility.cpp new file mode 100644 index 0000000..e3ef97a --- /dev/null +++ b/clang/test/SemaCXX/pragma-visibility.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace test1 __attribute__((visibility("hidden"))) { // expected-note{{surrounding namespace with visibility attribute starts here}} +#pragma GCC visibility pop // expected-error{{#pragma visibility pop with no matching #pragma visibility push}} +} + +// GCC 4.6 accepts this, but the "hidden" leaks past the namespace end. +namespace test2 __attribute__((visibility("hidden"))) { +#pragma GCC visibility push(protected) // expected-error{{#pragma visibility push with no matching #pragma visibility pop}} +} // expected-note{{surrounding namespace with visibility attribute ends here}} + +#pragma GCC visibility pop // expected-error{{#pragma visibility pop with no matching #pragma visibility push}} + +// <rdar://problem/10871094> +struct A { + #pragma GCC visibility push(protected) + #pragma GCC visibility pop +}; + +void f() { + #pragma GCC visibility push(protected) + #pragma GCC visibility pop +} diff --git a/clang/test/SemaCXX/prefetch-enum.cpp b/clang/test/SemaCXX/prefetch-enum.cpp new file mode 100644 index 0000000..3c77dae --- /dev/null +++ b/clang/test/SemaCXX/prefetch-enum.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only %s -verify +// PR5679 + +enum X { A = 3 }; + +void Test() { + char ch; + __builtin_prefetch(&ch, 0, A); +} diff --git a/clang/test/SemaCXX/primary-base.cpp b/clang/test/SemaCXX/primary-base.cpp new file mode 100644 index 0000000..a6cbbad --- /dev/null +++ b/clang/test/SemaCXX/primary-base.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class A { virtual void f(); }; +class B : virtual A { }; + +class C : B { }; + +// Since A is already a primary base class, C should be the primary base class +// of F. +class F : virtual A, virtual C { }; + +int sa[sizeof(F) == sizeof(A) ? 1 : -1]; diff --git a/clang/test/SemaCXX/pseudo-destructors.cpp b/clang/test/SemaCXX/pseudo-destructors.cpp new file mode 100644 index 0000000..a8f6683 --- /dev/null +++ b/clang/test/SemaCXX/pseudo-destructors.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A {}; + +enum Foo { F }; +typedef Foo Bar; // expected-note{{type 'Bar' (aka 'Foo') is declared here}} + +typedef int Integer; +typedef double Double; + +void g(); + +namespace N { + typedef Foo Wibble; + typedef int OtherInteger; +} + +template <typename T> +void cv_test(const volatile T* cvt) { + cvt->T::~T(); // no-warning +} + +void f(A* a, Foo *f, int *i, double *d, int ii) { + a->~A(); + a->A::~A(); + + a->~foo(); // expected-error{{identifier 'foo' in object destruction expression 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(); + i->~Bar(); // expected-error{{does not match}} + + g().~Bar(); // expected-error{{non-scalar}} + + f->::~Bar(); + f->N::~Wibble(); // FIXME: technically, Wibble isn't a class-name + + f->::~Bar(17, 42); // expected-error{{cannot have any arguments}} + + i->~Integer(); + i->Integer::~Integer(); + i->N::~OtherInteger(); + i->N::OtherInteger::~OtherInteger(); + i->N::OtherInteger::~Integer(); // expected-error{{'Integer' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}} + i->N::~Integer(); // expected-error{{'Integer' does not refer to a type name in pseudo-destructor expression; expected the name of type 'int'}} + i->Integer::~Double(); // expected-error{{the type of object expression ('int') does not match the type being destroyed ('Double' (aka 'double')) in pseudo-destructor expression}} + + ii->~Integer(); // expected-error{{member reference type 'int' is not a pointer; maybe you meant to use '.'?}} + ii.~Integer(); + + cv_test(a); + cv_test(f); + cv_test(i); + cv_test(d); +} + + +typedef int Integer; + +void destroy_without_call(int *ip) { + ip->~Integer; // expected-error{{called immediately}} +} + +// PR5530 +namespace N1 { + class X0 { }; +} + +void test_X0(N1::X0 &x0) { + x0.~X0(); +} + +namespace PR11339 { + template<class T> + void destroy(T* p) { + p->~T(); // ok + p->~oops(); // expected-error{{expected the class name after '~' to name a destructor}} + } + + template void destroy(int*); // expected-note{{in instantiation of function template specialization}} +} diff --git a/clang/test/SemaCXX/ptrtomember-overload-resolution.cpp b/clang/test/SemaCXX/ptrtomember-overload-resolution.cpp new file mode 100644 index 0000000..787e330 --- /dev/null +++ b/clang/test/SemaCXX/ptrtomember-overload-resolution.cpp @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +// 13.3.3.2 Ranking implicit conversion sequences +// conversion of A::* to B::* is better than conversion of A::* to C::*, +struct A { +int Ai; +}; + +struct B : public A {}; +struct C : public B {}; + +const char * f(int C::*){ return ""; } +int f(int B::*) { return 1; } + +struct D : public C {}; + +const char * g(int B::*){ return ""; } +int g(int D::*) { return 1; } + +void test() +{ + int i = f(&A::Ai); + + const char * str = g(&A::Ai); +} + +// conversion of B::* to C::* is better than conversion of A::* to C::* +typedef void (A::*pmfa)(); +typedef void (B::*pmfb)(); +typedef void (C::*pmfc)(); + +struct X { + operator pmfa(); + operator pmfb(); +}; + + +void g(pmfc); + +void test2(X x) +{ + g(x); +} + diff --git a/clang/test/SemaCXX/ptrtomember.cpp b/clang/test/SemaCXX/ptrtomember.cpp new file mode 100644 index 0000000..aee535e --- /dev/null +++ b/clang/test/SemaCXX/ptrtomember.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct S { + int i; + + int mem(int); +}; + +int foo(int S::* ps, S *s) +{ + return (s->*ps)(1); // expected-error {{called object type 'int' is not a function or function pointer}} +} + +struct S2 { + int bitfield : 1; +}; + +int S2::*pf = &S2::bitfield; // expected-error {{address of bit-field requested}} + +struct S3 { + void m(); +}; + +void f3(S3* p, void (S3::*m)()) { + p->*m; // expected-error {{reference to non-static member function must be called}} + (void)(p->*m); // expected-error {{reference to non-static member function must be called}} + (void)(void*)(p->*m); // expected-error {{reference to non-static member function must be called}} expected-error {{cannot cast from type 'void' to pointer type 'void *'}} + (void)reinterpret_cast<void*>(p->*m); // expected-error {{reference to non-static member function must be called}} expected-error {{reinterpret_cast from 'void' to 'void *' is not allowed}} + if (p->*m) {} // expected-error {{reference to non-static member function must be called}} expected-error {{value of type 'void' is not contextually convertible to 'bool'}} + if (!(p->*m)) {} // expected-error {{reference to non-static member function must be called}} expected-error {{invalid argument type 'void' to unary expression}} + if (p->m) {}; // expected-error {{reference to non-static member function must be called}} expected-error {{value of type 'void' is not contextually convertible to 'bool'}} + if (!p->m) {}; // expected-error {{reference to non-static member function must be called}} expected-error {{invalid argument type 'void' to unary expression}} +} diff --git a/clang/test/SemaCXX/qual-id-test.cpp b/clang/test/SemaCXX/qual-id-test.cpp new file mode 100644 index 0000000..9994d75 --- /dev/null +++ b/clang/test/SemaCXX/qual-id-test.cpp @@ -0,0 +1,149 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace A +{ + namespace B + { + struct base // expected-note{{object type}} + { + void x() {} + void y() {} + }; + } + + struct member + { + void foo(); + }; + + struct middleman + { + member * operator->() { return 0; } + }; + + struct sub : B::base + { + void x() {} + middleman operator->() { return middleman(); } + }; +} + +struct bad +{ + int x(); +}; + +namespace C +{ + void fun() + { + A::sub a; + + a.x(); + + a.sub::x(); + a.base::x(); + + a.B::base::x(); // expected-error{{use of undeclared identifier 'B'}} + + a.A::sub::x(); + a.A::B::base::x(); + + a.bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}} + + a->foo(); + a->member::foo(); + a->A::member::foo(); + } + + void fun2() + { + A::sub *a; + + a->x(); + + a->sub::x(); + a->base::x(); + + a->B::base::x(); // expected-error{{use of undeclared identifier 'B'}} + + a->A::sub::x(); + a->A::B::base::x(); + + a->bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}} + + (*a)->foo(); + (*a)->member::foo(); + (*a)->A::member::foo(); + } + + void fun3() + { + int i; + i.foo(); // expected-error{{member reference base type 'int' is not a structure or union}} + } + + void fun4a() { + A::sub *a; + + typedef A::member base; // expected-note{{current scope}} + a->base::x(); // expected-error{{ambiguous}} + } + + void fun4b() { + A::sub *a; + + typedef A::B::base base; + a->base::x(); + } + + template<typename T> + void fun5() + { + T a; + a.x(); + a->foo(); + + a.A::sub::x(); + a.A::B::base::x(); + a->A::member::foo(); + + a.bad::x(); // expected-error{{'bad::x' is not a member of class 'A::sub'}} + } + + void test_fun5() { + fun5<A::sub>(); // expected-note{{instantiation}} + } + + template<typename T> + void fun6() { + T a; + a.sub::x(); + a.base::x(); + a->member::foo(); + a.B::base::x(); // expected-error{{use of undeclared identifier 'B'}} + } + + void test_fun6() { + fun6<A::sub>(); // expected-note{{instantiation}} + } + +} + +// PR4703 +struct a { + int a; + static int sa; +}; + +a a; + +int a::sa = a.a; // expected-error {{invalid use of non-static data member 'a'}} + + +namespace PR6645 { + typedef int foo; + namespace Inner { + typedef int PR6645::foo; // expected-error{{typedef declarator cannot be qualified}} \ + // expected-error{{cannot define or redeclare 'foo' here because namespace 'Inner' does not enclose namespace 'PR6645'}} + } +} diff --git a/clang/test/SemaCXX/qualification-conversion.cpp b/clang/test/SemaCXX/qualification-conversion.cpp new file mode 100644 index 0000000..f1af5bf --- /dev/null +++ b/clang/test/SemaCXX/qualification-conversion.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +int* quals1(int const * p); +int* quals2(int const * const * pp); +int* quals3(int const * * const * ppp); // expected-note{{candidate function}} + +void test_quals(int * p, int * * pp, int * * * ppp) { + int const * const * pp2 = pp; + quals1(p); + quals2(pp); + quals3(ppp); // expected-error {{no matching}} +} + +struct A {}; +void mquals1(int const A::*p); +void mquals2(int const A::* const A::*pp); +void mquals3(int const A::* A::* const A::*ppp); // expected-note{{candidate function}} + +void test_mquals(int A::*p, int A::* A::*pp, int A::* A::* A::*ppp) { + int const A::* const A::* pp2 = pp; + mquals1(p); + mquals2(pp); + mquals3(ppp); // expected-error {{no matching}} +} + +void aquals1(int const (*p)[1]); +void aquals2(int * const (*pp)[1]); +void aquals2a(int const * (*pp2)[1]); // expected-note{{candidate function}} + +void test_aquals(int (*p)[1], int * (*pp)[1], int * (*pp2)[1]) { + int const (*p2)[1] = p; + aquals1(p); + aquals2(pp); + aquals2a(pp2); // expected-error {{no matching}} +} diff --git a/clang/test/SemaCXX/qualified-id-lookup.cpp b/clang/test/SemaCXX/qualified-id-lookup.cpp new file mode 100644 index 0000000..d65a468 --- /dev/null +++ b/clang/test/SemaCXX/qualified-id-lookup.cpp @@ -0,0 +1,153 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace Ns { + int f(); // expected-note{{previous declaration is here}} + + enum E { + Enumerator + }; +} +namespace Ns { + double f(); // expected-error{{functions that differ only in their return type cannot be overloaded}} + + int x = Enumerator; +} + +namespace Ns2 { + float f(); +} + +int y = Ns::Enumerator; + +namespace Ns2 { + float f(int); // expected-note{{previous declaration is here}} +} + +namespace Ns2 { + double f(int); // expected-error{{functions that differ only in their return type cannot be overloaded}} +} + +namespace N { + int& f1(); +} + +namespace N { + struct f1 { + static int member; + + typedef int type; + + void foo(type); + }; + + void test_f1() { + int &i1 = f1(); + } +} + +void N::f1::foo(int i) { + f1::member = i; + f1::type &ir = i; +} + +namespace N { + float& f1(int x) { + N::f1::type& i1 = x; + f1::type& i2 = x; + } + + struct f2 { + static int member; + }; + void f2(); +} + +int i1 = N::f1::member; +typedef struct N::f1 type1; +int i2 = N::f2::member; +typedef struct N::f2 type2; + +void test_f1(int i) { + int &v1 = N::f1(); + float &v2 = N::f1(i); + int v3 = ::i1; + int v4 = N::f1::member; +} + +typedef int f2_type; +namespace a { + typedef int f2_type(int, int); + + void test_f2() { + ::f2_type(1, 2); // expected-error {{excess elements in scalar initializer}} + } +} + +// PR clang/3291 +namespace a { + namespace a { // A1 + namespace a { // A2 + int i; + } + } +} + +void test_a() { + a::a::i = 3; // expected-error{{no member named 'i'}} + a::a::a::i = 4; +} + +struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}} + typedef int type; + + Undef::type member; + + static int size = sizeof(Undef); // expected-error{{invalid application of 'sizeof' to an incomplete type 'Undef'}} + + int f(); +}; + +int Undef::f() { + return sizeof(Undef); +} + +// PR clang/5667 +namespace test1 { + template <typename T> struct is_class { + enum { value = 0 }; + }; + + template <typename T> class ClassChecker { + bool isClass() { + return is_class<T>::value; + } + }; + + template class ClassChecker<int>; +} + +namespace PR6830 { + namespace foo { + + class X { + public: + X() {} + }; + + } // namespace foo + + class Z { + public: + explicit Z(const foo::X& x) {} + + void Work() {} + }; + + void Test() { + Z(foo::X()).Work(); + } +} + +namespace pr12339 { + extern "C" void i; + pr12339::FOO // expected-error{{no type named 'FOO' in namespace 'pr12339'}} +} // expected-error{{expected unqualified-id}} diff --git a/clang/test/SemaCXX/qualified-member-enum.cpp b/clang/test/SemaCXX/qualified-member-enum.cpp new file mode 100644 index 0000000..83b0a59 --- /dev/null +++ b/clang/test/SemaCXX/qualified-member-enum.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Check that this doesn't crash. +struct A { + enum {LABEL}; +}; +int f() { + return A().A::LABEL; +} + diff --git a/clang/test/SemaCXX/qualified-names-diag.cpp b/clang/test/SemaCXX/qualified-names-diag.cpp new file mode 100644 index 0000000..c8b5746 --- /dev/null +++ b/clang/test/SemaCXX/qualified-names-diag.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +namespace foo { + namespace wibble { + struct x { int y; }; + + namespace bar { + namespace wonka { + struct x { + struct y { }; + }; + } + } + } +} + +namespace bar { + typedef int y; + + struct incomplete; // expected-note{{forward declaration of 'bar::incomplete'}} +} +void test() { + foo::wibble::x a; + ::bar::y b; + a + b; // expected-error{{invalid operands to binary expression ('foo::wibble::x' and '::bar::y' (aka 'int'))}} + + ::foo::wibble::bar::wonka::x::y c; + c + b; // expected-error{{invalid operands to binary expression ('::foo::wibble::bar::wonka::x::y' and '::bar::y' (aka 'int'))}} + + (void)sizeof(bar::incomplete); // expected-error{{invalid application of 'sizeof' to an incomplete type 'bar::incomplete'}} +} + +int ::foo::wibble::bar::wonka::x::y::* ptrmem; + diff --git a/clang/test/SemaCXX/qualified-names-print.cpp b/clang/test/SemaCXX/qualified-names-print.cpp new file mode 100644 index 0000000..2099268 --- /dev/null +++ b/clang/test/SemaCXX/qualified-names-print.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -ast-print %s 2>&1 | grep "N::M::X<INT>::value" +namespace N { + namespace M { + template<typename T> + struct X { + enum { value }; + }; + } +} + +typedef int INT; + +int test() { + return N::M::X<INT>::value; +} diff --git a/clang/test/SemaCXX/redeclared-alias-template.cpp b/clang/test/SemaCXX/redeclared-alias-template.cpp new file mode 100644 index 0000000..09e9d0d --- /dev/null +++ b/clang/test/SemaCXX/redeclared-alias-template.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +template<typename T> using A = int; // expected-note 2{{previous}} +template<typename T> using A = char; // expected-error {{type alias template redefinition with different types ('char' vs 'int')}} +template<typename T1, typename T2> using A = T1; // expected-error {{too many template parameters in template redeclaration}} + +template<typename T1, typename T2> using B = T1; // expected-note {{previous}} +template<typename T2, typename T1> using B = T1; // expected-error {{type alias template redefinition with different types}} + + +template<typename> struct S; +template<template<typename> class F> using FInt = F<int>; +template<typename X> using SXRInt = FInt<S<X>::template R>; +template<typename X> using SXRInt = typename S<X>::template R<int>; // ok, redeclaration. + +template<template<typename> class> struct TT; + +namespace FilterLookup { + TT<A> f(); // expected-note {{previous declaration is here}} + + template<typename> using A = int; + TT<A> f(); // expected-error {{functions that differ only in their return type cannot be overloaded}} +} diff --git a/clang/test/SemaCXX/redeclared-auto.cpp b/clang/test/SemaCXX/redeclared-auto.cpp new file mode 100644 index 0000000..87ad6bd --- /dev/null +++ b/clang/test/SemaCXX/redeclared-auto.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +extern int a; +auto a = 0; // expected-note 2{{here}} +auto a = 0; // expected-error {{redefinition}} +int a = 0; // expected-error {{redefinition}} +extern auto a; // expected-error {{requires an initializer}} + +extern int b; // expected-note {{here}} +auto b = 0.0; // expected-error {{different type}} + +struct S { + static int a; + static int b; // expected-note {{here}} +}; + +auto S::a = 0; // expected-note 2{{here}} +auto S::a; // expected-error {{redefinition}} expected-error {{requires an initializer}} +int S::a = 0; // expected-error {{redefinition}} + +auto S::b = 0.0; // expected-error {{different type}} + +void f() { + extern int a; + extern auto a; // expected-error {{requires an initializer}} +} diff --git a/clang/test/SemaCXX/ref-init-ambiguous.cpp b/clang/test/SemaCXX/ref-init-ambiguous.cpp new file mode 100644 index 0000000..ce47e10 --- /dev/null +++ b/clang/test/SemaCXX/ref-init-ambiguous.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +enum E2 { }; + +struct A { + operator E2&(); // expected-note 3 {{candidate function}} +}; + +struct B { + operator E2&(); // expected-note 3 {{candidate function}} +}; + +struct C : B, A { +}; + +void test(C c) { + const E2 &e2 = c; // expected-error {{reference initialization of type 'const E2 &' with initializer of type 'C' is ambiguous}} +} + +void foo(const E2 &);// expected-note{{passing argument to parameter here}} + +const E2 & re(C c) { + foo(c); // expected-error {{reference initialization of type 'const E2 &' with initializer of type 'C' is ambiguous}} + + return c; // expected-error {{reference initialization of type 'const E2 &' with initializer of type 'C' is ambiguous}} +} + + diff --git a/clang/test/SemaCXX/references.cpp b/clang/test/SemaCXX/references.cpp new file mode 100644 index 0000000..70d3799 --- /dev/null +++ b/clang/test/SemaCXX/references.cpp @@ -0,0 +1,139 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int g(int); + +void f() { + int i; + int &r = i; + r = 1; + int *p = &r; + int &rr = r; + int (&rg)(int) = g; + rg(i); + int a[3]; + int (&ra)[3] = a; + ra[1] = i; + int *Q; + int *& P = Q; + P[1] = 1; +} + +typedef int t[1]; +void test2() { + t a; + t& b = a; + + + int c[3]; + int (&rc)[3] = c; +} + +// C++ [dcl.init.ref]p5b1 +struct A { }; +struct B : A { } b; + +void test3() { + double d = 2.0; + double& rd = d; // rd refers to d + const double& rcd = d; // rcd refers to d + + A& ra = b; // ra refers to A subobject in b + const A& rca = b; // rca refers to A subobject in b +} + +B fB(); + +// C++ [dcl.init.ref]p5b2 +void test4() { + double& rd2 = 2.0; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}} + int i = 2; + double& rd3 = i; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a value of unrelated type 'int'}} + + const A& rca = fB(); +} + +void test5() { + // const double& rcd2 = 2; // rcd2 refers to temporary with value 2.0 + const volatile int cvi = 1; + const int& r = cvi; // expected-error{{binding of reference to type 'const int' to a value of type 'const volatile int' drops qualifiers}} +} + +// C++ [dcl.init.ref]p3 +int& test6(int& x) { + int& yo; // expected-error{{declaration of reference variable 'yo' requires an initializer}} + + return x; +} +int& not_initialized_error; // expected-error{{declaration of reference variable 'not_initialized_error' requires an initializer}} +extern int& not_initialized_okay; + +class Test6 { // expected-warning{{class 'Test6' does not declare any constructor to initialize its non-modifiable members}} + int& okay; // expected-note{{reference member 'okay' will never be initialized}} +}; + +struct C : B, A { }; + +void test7(C& c) { + A& a1 = c; // expected-error {{ambiguous conversion from derived class 'C' to base class 'A':}} +} + +// C++ [dcl.ref]p1, C++ [dcl.ref]p4 +void test8(int& const,// expected-error{{'const' qualifier may not be applied to a reference}} + + void&, // expected-error{{cannot form a reference to 'void'}} + int& &) // expected-error{{type name declared as a reference to a reference}} +{ + typedef int& intref; + typedef intref& intrefref; // C++ DR 106: reference collapsing + + typedef intref const intref_c; // okay. FIXME: how do we verify that this is the same type as intref? +} + + +class string { + char *Data; + unsigned Length; +public: + string(); + ~string(); +}; + +string getInput(); + +void test9() { + string &s = getInput(); // expected-error{{lvalue reference}} +} + +void test10() { + __attribute((vector_size(16))) typedef int vec4; + typedef __attribute__(( ext_vector_type(4) )) int ext_vec4; + + vec4 v; + int &a = v[0]; // expected-error{{non-const reference cannot bind to vector element}} + const int &b = v[0]; + + ext_vec4 ev; + int &c = ev.x; // expected-error{{non-const reference cannot bind to vector element}} + const int &d = ev.x; +} + +namespace PR7149 { + template<typename T> struct X0 + { + T& first; + X0(T& p1) : first(p1) { } + }; + + + void f() + { + int p1[1]; + X0< const int[1]> c(p1); + } +} + +namespace PR8608 { + bool& f(unsigned char& c) { return (bool&)c; } +} + +// The following crashed trying to recursively evaluate the LValue. +const int &do_not_crash = do_not_crash; diff --git a/clang/test/SemaCXX/reinterpret-cast.cpp b/clang/test/SemaCXX/reinterpret-cast.cpp new file mode 100644 index 0000000..7f41b93 --- /dev/null +++ b/clang/test/SemaCXX/reinterpret-cast.cpp @@ -0,0 +1,292 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -ffreestanding -Wundefined-reinterpret-cast %s + +#include <stdint.h> + +enum test { testval = 1 }; +struct structure { int m; }; +typedef void (*fnptr)(); + +// Test the conversion to self. +void self_conversion() +{ + // T->T is allowed per [expr.reinterpret.cast]p2 so long as it doesn't + // cast away constness, and is integral, enumeration, pointer or + // pointer-to-member. + int i = 0; + (void)reinterpret_cast<int>(i); + + test e = testval; + (void)reinterpret_cast<test>(e); + + // T*->T* is allowed + int *pi = 0; + (void)reinterpret_cast<int*>(pi); + + const int structure::*psi = 0; + (void)reinterpret_cast<const int structure::*>(psi); + + structure s; + (void)reinterpret_cast<structure>(s); // expected-error {{reinterpret_cast from 'structure' to 'structure' is not allowed}} + + float f = 0.0f; + (void)reinterpret_cast<float>(f); // expected-error {{reinterpret_cast from 'float' to 'float' is not allowed}} +} + +// Test conversion between pointer and integral types, as in /3 and /4. +void integral_conversion() +{ + void *vp = reinterpret_cast<void*>(testval); + intptr_t i = reinterpret_cast<intptr_t>(vp); + (void)reinterpret_cast<float*>(i); + fnptr fnp = reinterpret_cast<fnptr>(i); + (void)reinterpret_cast<char>(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}} + (void)reinterpret_cast<intptr_t>(fnp); +} + +void pointer_conversion() +{ + int *p1 = 0; + float *p2 = reinterpret_cast<float*>(p1); + structure *p3 = reinterpret_cast<structure*>(p2); + typedef int **ppint; + ppint *deep = reinterpret_cast<ppint*>(p3); + (void)reinterpret_cast<fnptr*>(deep); +} + +void constness() +{ + int ***const ipppc = 0; + // 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 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 qualifiers}} + // Valid: T1* -> T2* + int *ip = reinterpret_cast<int*>(icpcpp); + // Valid: T* -> T const* + (void)reinterpret_cast<int const*>(ip); + // Valid: T*** -> T2 const* const* const* + (void)reinterpret_cast<int const* const* const*>(ipppc); +} + +void fnptrs() +{ + typedef int (*fnptr2)(int); + fnptr fp = 0; + (void)reinterpret_cast<fnptr2>(fp); + void *vp = reinterpret_cast<void*>(fp); + (void)reinterpret_cast<fnptr>(vp); +} + +void refs() +{ + long l = 0; + char &c = reinterpret_cast<char&>(l); + // Bad: from rvalue + (void)reinterpret_cast<int&>(&c); // expected-error {{reinterpret_cast from rvalue to reference type 'int &'}} +} + +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 qualifiers}} + + void (structure::*psf)() = 0; + (void)reinterpret_cast<int (structure::*)()>(psf); + + (void)reinterpret_cast<void (structure::*)()>(psi); // expected-error {{reinterpret_cast from 'const int structure::*' to 'void (structure::*)()' is not allowed}} + (void)reinterpret_cast<int structure::*>(psf); // expected-error {{reinterpret_cast from 'void (structure::*)()' to 'int structure::*' is not allowed}} + + // Cannot cast from integers to member pointers, not even the null pointer + // literal. + (void)reinterpret_cast<void (structure::*)()>(0); // expected-error {{reinterpret_cast from 'int' to 'void (structure::*)()' is not allowed}} + (void)reinterpret_cast<int structure::*>(0); // expected-error {{reinterpret_cast from 'int' to 'int structure::*' is not allowed}} +} + +namespace PR5545 { +// PR5545 +class A; +class B; +void (A::*a)(); +void (B::*b)() = reinterpret_cast<void (B::*)()>(a); +} + +// <rdar://problem/8018292> +void const_arrays() { + typedef char STRING[10]; + 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 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}} +} + +void dereference_reinterpret_cast() { + struct A {}; + typedef A A2; + class B {}; + typedef B B2; + A a; + B b; + A2 a2; + B2 b2; + long l; + double d; + float f; + char c; + unsigned char uc; + void* v_ptr; + (void)reinterpret_cast<double&>(l); // expected-warning {{reinterpret_cast from 'long' to 'double &' has undefined behavior}} + (void)*reinterpret_cast<double*>(&l); // expected-warning {{dereference of type 'double *' that was reinterpret_cast from type 'long *' has undefined behavior}} + (void)reinterpret_cast<double&>(f); // expected-warning {{reinterpret_cast from 'float' to 'double &' has undefined behavior}} + (void)*reinterpret_cast<double*>(&f); // expected-warning {{dereference of type 'double *' that was reinterpret_cast from type 'float *' has undefined behavior}} + (void)reinterpret_cast<float&>(l); // expected-warning {{reinterpret_cast from 'long' to 'float &' has undefined behavior}} + (void)*reinterpret_cast<float*>(&l); // expected-warning {{dereference of type 'float *' that was reinterpret_cast from type 'long *' has undefined behavior}} + (void)reinterpret_cast<float&>(d); // expected-warning {{reinterpret_cast from 'double' to 'float &' has undefined behavior}} + (void)*reinterpret_cast<float*>(&d); // expected-warning {{dereference of type 'float *' that was reinterpret_cast from type 'double *' has undefined behavior}} + + // TODO: add warning for tag types + (void)reinterpret_cast<A&>(b); + (void)*reinterpret_cast<A*>(&b); + (void)reinterpret_cast<B&>(a); + (void)*reinterpret_cast<B*>(&a); + (void)reinterpret_cast<A2&>(b2); + (void)*reinterpret_cast<A2*>(&b2); + (void)reinterpret_cast<B2&>(a2); + (void)*reinterpret_cast<B2*>(&a2); + + // Casting to itself is allowed + (void)reinterpret_cast<A&>(a); + (void)*reinterpret_cast<A*>(&a); + (void)reinterpret_cast<B&>(b); + (void)*reinterpret_cast<B*>(&b); + (void)reinterpret_cast<long&>(l); + (void)*reinterpret_cast<long*>(&l); + (void)reinterpret_cast<double&>(d); + (void)*reinterpret_cast<double*>(&d); + (void)reinterpret_cast<char&>(c); + (void)*reinterpret_cast<char*>(&c); + + // Casting to and from chars are allowable + (void)reinterpret_cast<A&>(c); + (void)*reinterpret_cast<A*>(&c); + (void)reinterpret_cast<B&>(c); + (void)*reinterpret_cast<B*>(&c); + (void)reinterpret_cast<long&>(c); + (void)*reinterpret_cast<long*>(&c); + (void)reinterpret_cast<double&>(c); + (void)*reinterpret_cast<double*>(&c); + (void)reinterpret_cast<char&>(l); + (void)*reinterpret_cast<char*>(&l); + (void)reinterpret_cast<char&>(d); + (void)*reinterpret_cast<char*>(&d); + (void)reinterpret_cast<char&>(f); + (void)*reinterpret_cast<char*>(&f); + + // Casting from void pointer. + (void)*reinterpret_cast<A*>(v_ptr); + (void)*reinterpret_cast<B*>(v_ptr); + (void)*reinterpret_cast<long*>(v_ptr); + (void)*reinterpret_cast<double*>(v_ptr); + (void)*reinterpret_cast<float*>(v_ptr); + + // Casting to void pointer + (void)*reinterpret_cast<void*>(&a); + (void)*reinterpret_cast<void*>(&b); + (void)*reinterpret_cast<void*>(&l); + (void)*reinterpret_cast<void*>(&d); + (void)*reinterpret_cast<void*>(&f); +} + +void reinterpret_cast_whitelist () { + // the dynamic type of the object + int a; + float b; + (void)reinterpret_cast<int&>(a); + (void)*reinterpret_cast<int*>(&a); + (void)reinterpret_cast<float&>(b); + (void)*reinterpret_cast<float*>(&b); + + // a cv-qualified version of the dynamic object + (void)reinterpret_cast<const int&>(a); + (void)*reinterpret_cast<const int*>(&a); + (void)reinterpret_cast<volatile int&>(a); + (void)*reinterpret_cast<volatile int*>(&a); + (void)reinterpret_cast<const volatile int&>(a); + (void)*reinterpret_cast<const volatile int*>(&a); + (void)reinterpret_cast<const float&>(b); + (void)*reinterpret_cast<const float*>(&b); + (void)reinterpret_cast<volatile float&>(b); + (void)*reinterpret_cast<volatile float*>(&b); + (void)reinterpret_cast<const volatile float&>(b); + (void)*reinterpret_cast<const volatile float*>(&b); + + // a type that is the signed or unsigned type corresponding to the dynamic + // type of the object + signed d; + unsigned e; + (void)reinterpret_cast<signed&>(d); + (void)*reinterpret_cast<signed*>(&d); + (void)reinterpret_cast<signed&>(e); + (void)*reinterpret_cast<signed*>(&e); + (void)reinterpret_cast<unsigned&>(d); + (void)*reinterpret_cast<unsigned*>(&d); + (void)reinterpret_cast<unsigned&>(e); + (void)*reinterpret_cast<unsigned*>(&e); + + // a type that is the signed or unsigned type corresponding a cv-qualified + // version of the dynamic type the object + (void)reinterpret_cast<const signed&>(d); + (void)*reinterpret_cast<const signed*>(&d); + (void)reinterpret_cast<const signed&>(e); + (void)*reinterpret_cast<const signed*>(&e); + (void)reinterpret_cast<const unsigned&>(d); + (void)*reinterpret_cast<const unsigned*>(&d); + (void)reinterpret_cast<const unsigned&>(e); + (void)*reinterpret_cast<const unsigned*>(&e); + (void)reinterpret_cast<volatile signed&>(d); + (void)*reinterpret_cast<volatile signed*>(&d); + (void)reinterpret_cast<volatile signed&>(e); + (void)*reinterpret_cast<volatile signed*>(&e); + (void)reinterpret_cast<volatile unsigned&>(d); + (void)*reinterpret_cast<volatile unsigned*>(&d); + (void)reinterpret_cast<volatile unsigned&>(e); + (void)*reinterpret_cast<volatile unsigned*>(&e); + (void)reinterpret_cast<const volatile signed&>(d); + (void)*reinterpret_cast<const volatile signed*>(&d); + (void)reinterpret_cast<const volatile signed&>(e); + (void)*reinterpret_cast<const volatile signed*>(&e); + (void)reinterpret_cast<const volatile unsigned&>(d); + (void)*reinterpret_cast<const volatile unsigned*>(&d); + (void)reinterpret_cast<const volatile unsigned&>(e); + (void)*reinterpret_cast<const volatile unsigned*>(&e); + + // an aggregate or union type that includes one of the aforementioned types + // among its members (including, recursively, a member of a subaggregate or + // contained union) + // TODO: checking is not implemented for tag types + + // a type that is a (possible cv-qualified) base class type of the dynamic + // type of the object + // TODO: checking is not implemented for tag types + + // a char or unsigned char type + (void)reinterpret_cast<char&>(a); + (void)*reinterpret_cast<char*>(&a); + (void)reinterpret_cast<unsigned char&>(a); + (void)*reinterpret_cast<unsigned char*>(&a); + (void)reinterpret_cast<char&>(b); + (void)*reinterpret_cast<char*>(&b); + (void)reinterpret_cast<unsigned char&>(b); + (void)*reinterpret_cast<unsigned char*>(&b); +} diff --git a/clang/test/SemaCXX/reinterpret-fn-obj-pedantic.cpp b/clang/test/SemaCXX/reinterpret-fn-obj-pedantic.cpp new file mode 100644 index 0000000..9cdf5a1 --- /dev/null +++ b/clang/test/SemaCXX/reinterpret-fn-obj-pedantic.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 -pedantic %s + +void fnptrs() +{ + typedef void (*fnptr)(); + fnptr fp = 0; + void *vp = reinterpret_cast<void*>(fp); // expected-warning {{cast between pointer-to-function and pointer-to-object is an extension}} + (void)reinterpret_cast<fnptr>(vp); // expected-warning {{cast between pointer-to-function and pointer-to-object is an extension}} +} diff --git a/clang/test/SemaCXX/return-noreturn.cpp b/clang/test/SemaCXX/return-noreturn.cpp new file mode 100644 index 0000000..617de00 --- /dev/null +++ b/clang/test/SemaCXX/return-noreturn.cpp @@ -0,0 +1,140 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default +// RUN: %clang_cc1 %s -fsyntax-only -std=c++11 -verify -Wreturn-type -Wmissing-noreturn -Wno-unreachable-code -Wno-covered-switch-default + +// A destructor may be marked noreturn and should still influence the CFG. +void pr6884_abort() __attribute__((noreturn)); + +struct pr6884_abort_struct { + pr6884_abort_struct() {} + ~pr6884_abort_struct() __attribute__((noreturn)) { pr6884_abort(); } +}; + +struct other { ~other() {} }; + +// Ensure that destructors from objects are properly modeled in the CFG despite +// the presence of switches, case statements, labels, and blocks. These tests +// try to cover bugs reported in both PR6884 and PR10063. +namespace abort_struct_complex_cfgs { + int basic(int x) { + switch (x) { default: pr6884_abort(); } + } + int f1(int x) { + switch (x) default: pr6884_abort_struct(); + } + int f2(int x) { + switch (x) { default: pr6884_abort_struct(); } + } + int f2_positive(int x) { + switch (x) { default: ; } + } // expected-warning {{control reaches end of non-void function}} + int f3(int x) { + switch (x) { default: { pr6884_abort_struct(); } } + } + int f4(int x) { + switch (x) default: L1: L2: case 4: pr6884_abort_struct(); + } + int f5(int x) { + switch (x) default: L1: { L2: case 4: pr6884_abort_struct(); } + } + int f6(int x) { + switch (x) default: L1: L2: case 4: { pr6884_abort_struct(); } + } + + // Test that these constructs work even when extraneous blocks are created + // before and after the switch due to implicit destructors. + int g1(int x) { + other o; + switch (x) default: pr6884_abort_struct(); + } + int g2(int x) { + other o; + switch (x) { default: pr6884_abort_struct(); } + } + int g2_positive(int x) { + other o; + switch (x) { default: ; } + } // expected-warning {{control reaches end of non-void function}} + int g3(int x) { + other o; + switch (x) { default: { pr6884_abort_struct(); } } + } + int g4(int x) { + other o; + switch (x) default: L1: L2: case 4: pr6884_abort_struct(); + } + int g5(int x) { + other o; + switch (x) default: L1: { L2: case 4: pr6884_abort_struct(); } + } + int g6(int x) { + other o; + switch (x) default: L1: L2: case 4: { pr6884_abort_struct(); } + } + + // Test that these constructs work even with variables carrying the no-return + // destructor instead of temporaries. + int h1(int x) { + other o; + switch (x) default: pr6884_abort_struct a; + } + int h2(int x) { + other o; + switch (x) { default: pr6884_abort_struct a; } + } + int h3(int x) { + other o; + switch (x) { default: { pr6884_abort_struct a; } } + } + int h4(int x) { + other o; + switch (x) default: L1: L2: case 4: pr6884_abort_struct a; + } + int h5(int x) { + other o; + switch (x) default: L1: { L2: case 4: pr6884_abort_struct a; } + } + int h6(int x) { + other o; + switch (x) default: L1: L2: case 4: { pr6884_abort_struct a; } + } +} + +// 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/clang/test/SemaCXX/return-stack-addr.cpp b/clang/test/SemaCXX/return-stack-addr.cpp new file mode 100644 index 0000000..fbbaf83 --- /dev/null +++ b/clang/test/SemaCXX/return-stack-addr.cpp @@ -0,0 +1,141 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int* ret_local() { + int x = 1; + return &x; // expected-warning {{address of stack memory}} +} + +int* ret_local_array() { + int x[10]; + return x; // expected-warning {{address of stack memory}} +} + +int* ret_local_array_element(int i) { + int x[10]; + return &x[i]; // expected-warning {{address of stack memory}} +} + +int *ret_local_array_element_reversed(int i) { + int x[10]; + return &i[x]; // expected-warning {{address of stack memory}} +} + +int* ret_local_array_element_const_index() { + int x[10]; + return &x[2]; // expected-warning {{address of stack memory}} +} + +int& ret_local_ref() { + int x = 1; + return x; // expected-warning {{reference to stack memory}} +} + +int* ret_local_addrOf() { + int x = 1; + return &*&x; // expected-warning {{address of stack memory}} +} + +int* ret_local_addrOf_paren() { + int x = 1; + return (&(*(&x))); // expected-warning {{address of stack memory}} +} + +int* ret_local_addrOf_ptr_arith() { + int x = 1; + return &*(&x+1); // expected-warning {{address of stack memory}} +} + +int* ret_local_addrOf_ptr_arith2() { + int x = 1; + return &*(&x+1); // expected-warning {{address of stack memory}} +} + +int* ret_local_field() { + struct { int x; } a; + return &a.x; // expected-warning {{address of stack memory}} +} + +int& ret_local_field_ref() { + struct { int x; } a; + return a.x; // expected-warning {{reference to stack memory}} +} + +int* ret_conditional(bool cond) { + int x = 1; + int y = 2; + return cond ? &x : &y; // expected-warning {{address of stack memory}} +} + +int* ret_conditional_rhs(int *x, bool cond) { + int y = 1; + return cond ? x : &y; // expected-warning {{address of stack memory}} +} + +void* ret_c_cast() { + int x = 1; + return (void*) &x; // expected-warning {{address of stack memory}} +} + +int* ret_static_var() { + static int x = 1; + return &x; // no warning. +} + +int z = 1; + +int* ret_global() { + return &z; // no warning. +} + +int* ret_parameter(int x) { + return &x; // expected-warning {{address of stack memory}} +} + + +void* ret_cpp_static_cast(short x) { + return static_cast<void*>(&x); // expected-warning {{address of stack memory}} +} + +int* ret_cpp_reinterpret_cast(double x) { + return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}} +} + +int* ret_cpp_reinterpret_cast_no_warning(long x) { + return reinterpret_cast<int*>(x); // no-warning +} + +int* ret_cpp_const_cast(const int x) { + return const_cast<int*>(&x); // expected-warning {{address of stack memory}} +} + +// PR 7999 - handle the case where a field is itself a reference. +template <typename T> struct PR7999 { + PR7999(T& t) : value(t) {} + T& value; +}; + +struct PR7999_X {}; + +PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning +void test_PR7999(PR7999_X& x) { (void)PR7999_f(x); } // no-warning + +// PR 8774: Don't try to evaluate parameters with default arguments like +// variables with an initializer, especially in templates where the default +// argument may not be an expression (yet). +namespace PR8774 { + template <typename U> struct B { }; + template <typename V> V f(typename B<V>::type const &v = B<V>::value()) { + return v; + } + template <> struct B<const char *> { + typedef const char *type; + static const char *value(); + }; + void g() { + const char *t; + f<const char*>(t); + } +} + +// TODO: test case for dynamic_cast. clang does not yet have +// support for C++ classes to write such a test case. diff --git a/clang/test/SemaCXX/return.cpp b/clang/test/SemaCXX/return.cpp new file mode 100644 index 0000000..2f98a27 --- /dev/null +++ b/clang/test/SemaCXX/return.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 %s -fcxx-exceptions -fexceptions -fsyntax-only -Wignored-qualifiers -verify + +int test1() { + throw; +} + +// PR5071 +template<typename T> T f() { } + +template<typename T> +void g(T t) { + return t * 2; // okay +} + +template<typename T> +T h() { + return 17; +} + +// Don't warn on cv-qualified class return types, only scalar return types. +namespace ignored_quals { +struct S {}; +const S class_c(); +const volatile S class_cv(); + +const int scalar_c(); // expected-warning{{'const' type qualifier on return type has no effect}} +int const scalar_c2(); // expected-warning{{'const' type qualifier on return type has no effect}} + +const +char* +const // expected-warning{{'const' type qualifier on return type has no effect}} +f(); + +char +const* +const // expected-warning{{'const' type qualifier on return type has no effect}} +g(); + +char* const h(); // expected-warning{{'const' type qualifier on return type has no effect}} +char* volatile i(); // expected-warning{{'volatile' type qualifier on return type has no effect}} + +char* +volatile // expected-warning{{'const volatile' type qualifiers on return type have no effect}} +const +j(); + +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 (); +}; + +namespace PR10057 { + struct S { + ~S(); + }; + + template <class VarType> + void Test(const VarType& value) { + return S() = value; + } +} + +namespace return_has_expr { + struct S { + S() { + return 42; // expected-error {{constructor 'S' should not return a value}} + } + ~S() { + return 42; // expected-error {{destructor '~S' should not return a value}} + } + }; +} diff --git a/clang/test/SemaCXX/runtimediag-ppe.cpp b/clang/test/SemaCXX/runtimediag-ppe.cpp new file mode 100644 index 0000000..0e8451b --- /dev/null +++ b/clang/test/SemaCXX/runtimediag-ppe.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Make sure diagnostics that we don't print based on runtime control +// flow are delayed correctly in cases where we can't immediately tell whether +// the context is unevaluated. + +namespace std { + class type_info; +} + +int& NP(int); +void test1() { (void)typeid(NP(1 << 32)); } + +class Poly { virtual ~Poly(); }; +Poly& P(int); +void test2() { (void)typeid(P(1 << 32)); } // expected-warning {{shift count >= width of type}} + +void test3() { 1 ? (void)0 : (void)typeid(P(1 << 32)); } diff --git a/clang/test/SemaCXX/rval-references-examples.cpp b/clang/test/SemaCXX/rval-references-examples.cpp new file mode 100644 index 0000000..110ae26 --- /dev/null +++ b/clang/test/SemaCXX/rval-references-examples.cpp @@ -0,0 +1,112 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +template<typename T> +class unique_ptr { + T *ptr; + + unique_ptr(const unique_ptr&) = delete; // expected-note 3{{function has been explicitly marked deleted here}} + unique_ptr &operator=(const unique_ptr&) = delete; // expected-note{{candidate function has been explicitly deleted}} +public: + unique_ptr() : ptr(0) { } + unique_ptr(unique_ptr &&other) : ptr(other.ptr) { other.ptr = 0; } + explicit unique_ptr(T *ptr) : ptr(ptr) { } + + ~unique_ptr() { delete ptr; } + + unique_ptr &operator=(unique_ptr &&other) { // expected-note{{candidate function not viable: no known conversion from 'unique_ptr<int>' to 'unique_ptr<int> &&' for 1st argument}} + if (this == &other) + return *this; + + delete ptr; + ptr = other.ptr; + other.ptr = 0; + return *this; + } +}; + +template<typename T> +struct remove_reference { + typedef T type; +}; + +template<typename T> +struct remove_reference<T&> { + typedef T type; +}; + +template<typename T> +struct remove_reference<T&&> { + typedef T type; +}; + + +template <class T> typename remove_reference<T>::type&& move(T&& t) { + return static_cast<typename remove_reference<T>::type&&>(t); +} + +template <class T> T&& forward(typename remove_reference<T>::type& t) { + return static_cast<T&&>(t); +} + +template <class T> T&& forward(typename remove_reference<T>::type&& t) { + return static_cast<T&&>(t); +} + +template<typename T, typename ...Args> +unique_ptr<T> make_unique_ptr(Args &&...args) { + return unique_ptr<T>(new T(forward<Args>(args)...)); +} + +template<typename T> void accept_unique_ptr(unique_ptr<T>); // expected-note{{passing argument to parameter here}} + +unique_ptr<int> test_unique_ptr() { + // Simple construction + unique_ptr<int> p; + unique_ptr<int> p1(new int); + + // Move construction + unique_ptr<int> p2(make_unique_ptr<int>(17)); + unique_ptr<int> p3 = make_unique_ptr<int>(17); + + // Copy construction (failures) + unique_ptr<int> p4(p); // expected-error{{call to deleted constructor of 'unique_ptr<int>'}} + unique_ptr<int> p5 = p; // expected-error{{call to deleted constructor of 'unique_ptr<int>'}} + + // Move assignment + p2 = move(p); + p2 = make_unique_ptr<int>(0); + + // Copy assignment (failures); + p2 = p3; // expected-error{{overload resolution selected deleted operator '='}} + + // Implicit copies + accept_unique_ptr(make_unique_ptr<double>(0.0)); + accept_unique_ptr(move(p2)); + + // Implicit copies (failures); + accept_unique_ptr(p); // expected-error{{call to deleted constructor of 'unique_ptr<int>'}} + + return p; +} + +namespace perfect_forwarding { + struct A { }; + + struct F0 { + void operator()(A&, const A&, A&&, const A&&, A&&, const A&&); // expected-note{{candidate function not viable: 5th argument ('const perfect_forwarding::A') would lose const qualifier}} + }; + + template<typename F, typename ...Args> + void forward(F f, Args &&...args) { + f(static_cast<Args&&>(args)...); // expected-error{{no matching function for call to object of type 'perfect_forwarding::F0'}} + } + + template<typename T> T get(); + + void test_forward() { + forward(F0(), get<A&>(), get<A const&>(), get<A>(), get<const A>(), + get<A&&>(), get<const A&&>()); + forward(F0(), get<A&>(), get<A const&>(), get<A>(), get<const A>(), // expected-note{{in instantiation of function template specialization 'perfect_forwarding::forward<perfect_forwarding::F0, perfect_forwarding::A &, const perfect_forwarding::A &, perfect_forwarding::A, const perfect_forwarding::A, const perfect_forwarding::A, const perfect_forwarding::A>' requested here}} + get<const A&&>(), get<const A&&>()); + } +}; diff --git a/clang/test/SemaCXX/rval-references.cpp b/clang/test/SemaCXX/rval-references.cpp new file mode 100644 index 0000000..fc341e8 --- /dev/null +++ b/clang/test/SemaCXX/rval-references.cpp @@ -0,0 +1,94 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s + +typedef int&& irr; +typedef irr& ilr_c1; // Collapses to int& +typedef int& ilr; +typedef ilr&& ilr_c2; // Collapses to int& + +irr ret_irr() { + return 0; // expected-warning {{returning reference to local temporary}} +} + +struct not_int {}; + +int over(int&); +not_int over(int&&); + +int over2(const int&); +not_int over2(int&&); + +struct conv_to_not_int_rvalue { + operator not_int &&(); +}; + +typedef void (fun_type)(); +void fun(); +fun_type &&make_fun(); + +void f() { + int &&virr1; // expected-error {{declaration of reference variable 'virr1' requires an initializer}} + int &&virr2 = 0; + int &&virr3 = virr2; // expected-error {{rvalue reference to type 'int' cannot bind to lvalue of type 'int'}} + int i1 = 0; + int &&virr4 = i1; // expected-error {{rvalue reference to type 'int' cannot bind to lvalue of type 'int'}} + int &&virr5 = ret_irr(); + int &&virr6 = static_cast<int&&>(i1); + (void)static_cast<not_int&&>(i1); // expected-error {{types are not compatible}} + + int i2 = over(i1); + not_int ni1 = over(0); + int i3 = over(virr2); + not_int ni2 = over(ret_irr()); + + int i4 = over2(i1); + not_int ni3 = over2(0); + + ilr_c1 vilr1 = i1; + ilr_c2 vilr2 = i1; + + conv_to_not_int_rvalue cnir; + not_int &&ni4 = cnir; + not_int &ni5 = cnir; // expected-error{{non-const lvalue reference to type 'not_int' cannot bind to a value of unrelated type 'conv_to_not_int_rvalue'}} + not_int &&ni6 = conv_to_not_int_rvalue(); + + fun_type &&fun_ref = fun; // works because functions are special + fun_type &&fun_ref2 = make_fun(); // same + fun_type &fun_lref = make_fun(); // also special + + try { + } catch(int&&) { // expected-error {{cannot catch exceptions by rvalue reference}} + } +} + +int&& should_warn(int i) { + // FIXME: The stack address return test doesn't reason about casts. + return static_cast<int&&>(i); // xpected-warning {{returning reference to temporary}} +} +int&& should_not_warn(int&& i) { // But GCC 4.4 does + return static_cast<int&&>(i); +} + + +// Test the return dance. This also tests IsReturnCopyElidable. +struct MoveOnly { + MoveOnly(); + MoveOnly(const MoveOnly&) = delete; // expected-note {{candidate constructor}} \ + // expected-note 3{{explicitly marked deleted here}} + MoveOnly(MoveOnly&&); // expected-note {{candidate constructor}} + MoveOnly(int&&); // expected-note {{candidate constructor}} +}; + +MoveOnly gmo; +MoveOnly returningNonEligible() { + int i; + static MoveOnly mo; + MoveOnly &r = mo; + if (0) // Copy from global can't be elided + return gmo; // expected-error {{call to deleted constructor}} + else if (0) // Copy from local static can't be elided + return mo; // expected-error {{call to deleted constructor}} + else if (0) // Copy from reference can't be elided + return r; // expected-error {{call to deleted constructor}} + else // Construction from different type can't be elided + return i; // expected-error {{no viable conversion from 'int' to 'MoveOnly'}} +} diff --git a/clang/test/SemaCXX/scope-check.cpp b/clang/test/SemaCXX/scope-check.cpp new file mode 100644 index 0000000..b659de0 --- /dev/null +++ b/clang/test/SemaCXX/scope-check.cpp @@ -0,0 +1,209 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-unreachable-code +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=gnu++11 %s -Wno-unreachable-code + +namespace test0 { + struct D { ~D(); }; + + int f(bool b) { + if (b) { + D d; + goto end; + } + + end: + return 1; + } +} + +namespace test1 { + struct C { C(); }; + + int f(bool b) { + if (b) + goto foo; // expected-error {{goto into protected scope}} + C c; // expected-note {{jump bypasses variable initialization}} + foo: + return 1; + } +} + +namespace test2 { + struct C { C(); }; + + int f(void **ip) { + static void *ips[] = { &&lbl1, &&lbl2 }; + + C c; + goto *ip; + lbl1: + return 0; + lbl2: + return 1; + } +} + +namespace test3 { + struct C { C(); }; + + int f(void **ip) { + static void *ips[] = { &&lbl1, &&lbl2 }; + + goto *ip; + lbl1: { + C c; + return 0; + } + lbl2: + return 1; + } +} + +namespace test4 { + struct C { C(); }; + struct D { ~D(); }; + + int f(void **ip) { + static void *ips[] = { &&lbl1, &&lbl2 }; + + C c0; + + goto *ip; // expected-error {{indirect goto might cross protected scopes}} + C c1; // expected-note {{jump bypasses variable initialization}} + lbl1: // expected-note {{possible target of indirect goto}} + return 0; + lbl2: + return 1; + } +} + +namespace test5 { + struct C { C(); }; + struct D { ~D(); }; + + int f(void **ip) { + static void *ips[] = { &&lbl1, &&lbl2 }; + C c0; + + goto *ip; + lbl1: // expected-note {{possible target of indirect goto}} + return 0; + lbl2: + if (ip[1]) { + D d; // expected-note {{jump exits scope of variable with non-trivial destructor}} + ip += 2; + goto *ip; // expected-error {{indirect goto might cross protected scopes}} + } + return 1; + } +} + +namespace test6 { + struct C { C(); }; + + unsigned f(unsigned s0, unsigned s1, void **ip) { + static void *ips[] = { &&lbl1, &&lbl2, &&lbl3, &&lbl4 }; + C c0; + + goto *ip; + lbl1: + s0++; + goto *++ip; + lbl2: + s0 -= s1; + goto *++ip; + lbl3: { + unsigned tmp = s0; + s0 = s1; + s1 = tmp; + goto *++ip; + } + lbl4: + return s0; + } +} + +// C++0x says it's okay to skip non-trivial initializers on static +// locals, and we implement that in '03 as well. +namespace test7 { + struct C { C(); }; + + void test() { + goto foo; + static C c; + foo: + return; + } +} + +// PR7789 +namespace test8 { + void test1(int c) { + switch (c) { + case 0: + int x = 56; // expected-note {{jump bypasses variable initialization}} + case 1: // expected-error {{switch case is in protected scope}} + x = 10; + } + } + + void test2() { + goto l2; // expected-error {{goto into protected scope}} + l1: int x = 5; // expected-note {{jump bypasses variable initialization}} + 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; + } + } +} + +// http://llvm.org/PR10462 +namespace PR10462 { +enum MyEnum { + something_valid, + something_invalid +}; + +bool recurse() { + MyEnum K; + switch (K) { // expected-warning {{enumeration value 'something_invalid' not handled in switch}} + case something_valid: + case what_am_i_thinking: // expected-error {{use of undeclared identifier}} + int *X = 0; + if (recurse()) { + } + + break; + } +} + + +namespace test10 { +
+int test() {
+ static void *ps[] = { &&a0 };
+ goto *&&a0; // expected-error {{goto into protected scope}}
+ int a = 3; // expected-note {{jump bypasses variable initialization}}
+ a0:
+ return 0;
+} + +} + +} + diff --git a/clang/test/SemaCXX/shift.cpp b/clang/test/SemaCXX/shift.cpp new file mode 100644 index 0000000..d5a5bed --- /dev/null +++ b/clang/test/SemaCXX/shift.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -Wall -Wshift-sign-overflow -ffreestanding -fsyntax-only -verify %s + +#include <limits.h> + +#define WORD_BIT (sizeof(int) * CHAR_BIT) + +template <int N> void f() { + (void)(N << 30); // expected-warning {{bits to represent, but 'int' only has}} + (void)(30 << N); // expected-warning {{bits to represent, but 'int' only has}} +} + +void test() { + f<30>(); // expected-note {{instantiation}} +} diff --git a/clang/test/SemaCXX/short-enums.cpp b/clang/test/SemaCXX/short-enums.cpp new file mode 100644 index 0000000..ca713b7 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/short-wchar-sign.cpp b/clang/test/SemaCXX/short-wchar-sign.cpp new file mode 100644 index 0000000..9a177c0 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/sourceranges.cpp b/clang/test/SemaCXX/sourceranges.cpp new file mode 100644 index 0000000..0537aa2 --- /dev/null +++ b/clang/test/SemaCXX/sourceranges.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -ast-dump %s | FileCheck %s + +template<class T> +class P { + public: + P(T* t) {} +}; + +namespace foo { +class A {}; +enum B {}; +typedef int C; +} + +int main() { + // 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::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::A' + return foo::A(); +} diff --git a/clang/test/SemaCXX/statements.cpp b/clang/test/SemaCXX/statements.cpp new file mode 100644 index 0000000..6d04c84 --- /dev/null +++ b/clang/test/SemaCXX/statements.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 %s -fsyntax-only -pedantic -verify + +void foo() { + return foo(); +} + +// PR6451 - C++ Jump checking +struct X { + X(); +}; + +void test2() { + goto later; // expected-error {{goto into protected scope}} + X x; // expected-note {{jump bypasses variable initialization}} +later: + ; +} + +namespace PR6536 { + struct A {}; + void a() { goto out; A x; out: return; } +} diff --git a/clang/test/SemaCXX/static-array-member.cpp b/clang/test/SemaCXX/static-array-member.cpp new file mode 100644 index 0000000..8f57549 --- /dev/null +++ b/clang/test/SemaCXX/static-array-member.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only %s + +struct X0 { + static int array[]; + + int x; + int y; +}; + +int X0::array[sizeof(X0) * 2]; + +template<typename T, int N> +struct X1 { + static T array[]; +}; + +template<typename T, int N> +T X1<T, N>::array[N]; diff --git a/clang/test/SemaCXX/static-assert.cpp b/clang/test/SemaCXX/static-assert.cpp new file mode 100644 index 0000000..364e4e4 --- /dev/null +++ b/clang/test/SemaCXX/static-assert.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -triple=x86_64-linux-gnu + +int f(); // expected-note {{declared here}} + +static_assert(f(), "f"); // expected-error {{static_assert expression is not an integral constant expression}} expected-note {{non-constexpr function 'f' cannot be used in a constant expression}} +static_assert(true, "true is not false"); +static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}} + +void g() { + static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}} +} + +class C { + static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}} +}; + +template<int N> struct T { + static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed "N is not 2!"}} +}; + +T<1> t1; // expected-note {{in instantiation of template class 'T<1>' requested here}} +T<2> t2; + +template<typename T> struct S { + static_assert(sizeof(T) > sizeof(char), "Type not big enough!"); // expected-error {{static_assert failed "Type not big enough!"}} +}; + +S<char> s1; // expected-note {{in instantiation of template class 'S<char>' requested here}} +S<int> s2; + +static_assert(false, L"\xFFFFFFFF"); // expected-error {{static_assert failed L"\xFFFFFFFF"}} +static_assert(false, u"\U000317FF"); // expected-error {{static_assert failed u"\U000317FF"}} +// FIXME: render this as u8"\u03A9" +static_assert(false, u8"Ω"); // expected-error {{static_assert failed u8"\316\251"}} +static_assert(false, L"\u1234"); // expected-error {{static_assert failed L"\x1234"}} +static_assert(false, L"\x1ff" "0\x123" "fx\xfffff" "goop"); // expected-error {{static_assert failed L"\x1FF""0\x123""fx\xFFFFFgoop"}} diff --git a/clang/test/SemaCXX/static-cast-complete-type.cpp b/clang/test/SemaCXX/static-cast-complete-type.cpp new file mode 100644 index 0000000..6d76f81 --- /dev/null +++ b/clang/test/SemaCXX/static-cast-complete-type.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +template<typename T> struct S { + S(int); +}; + +struct T; // expected-note{{forward declaration of 'T'}} + +void f() { + S<int> s0 = static_cast<S<int> >(0); + S<void*> s1 = static_cast<S<void*> >(00); + + (void)static_cast<T>(10); // expected-error{{'T' is an incomplete type}} +} diff --git a/clang/test/SemaCXX/static-cast.cpp b/clang/test/SemaCXX/static-cast.cpp new file mode 100644 index 0000000..7fb016e --- /dev/null +++ b/clang/test/SemaCXX/static-cast.cpp @@ -0,0 +1,197 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A {}; +struct B : public A {}; // Single public base. +struct C1 : public virtual B {}; // Single virtual base. +struct C2 : public virtual B {}; +struct D : public C1, public C2 {}; // Diamond +struct E : private A {}; // Single private base. expected-note 3 {{declared private here}} +struct F : public C1 {}; // Single path to B with virtual. +struct G1 : public B {}; +struct G2 : public B {}; +struct H : public G1, public G2 {}; // Ambiguous path to B. + +enum Enum { En1, En2 }; +enum Onom { On1, On2 }; + +struct Co1 { operator int(); }; +struct Co2 { Co2(int); }; +struct Co3 { }; +struct Co4 { Co4(Co3); operator Co3(); }; + +// Explicit implicits +void t_529_2() +{ + int i = 1; + (void)static_cast<float>(i); + double d = 1.0; + (void)static_cast<float>(d); + (void)static_cast<int>(d); + (void)static_cast<char>(i); + (void)static_cast<unsigned long>(i); + (void)static_cast<int>(En1); + (void)static_cast<double>(En1); + (void)static_cast<int&>(i); + (void)static_cast<const int&>(i); + + int ar[1]; + (void)static_cast<const int*>(ar); + (void)static_cast<void (*)()>(t_529_2); + + (void)static_cast<void*>(0); + (void)static_cast<void*>((int*)0); + (void)static_cast<volatile const void*>((const int*)0); + (void)static_cast<A*>((B*)0); + (void)static_cast<A&>(*((B*)0)); + (void)static_cast<const B*>((C1*)0); + (void)static_cast<B&>(*((C1*)0)); + (void)static_cast<A*>((D*)0); + (void)static_cast<const A&>(*((D*)0)); + (void)static_cast<int B::*>((int A::*)0); + (void)static_cast<void (B::*)()>((void (A::*)())0); + + (void)static_cast<int>(Co1()); + (void)static_cast<Co2>(1); + (void)static_cast<Co3>(static_cast<Co4>(Co3())); + + // Bad code below + + (void)static_cast<void*>((const int*)0); // expected-error {{static_cast from 'const int *' to 'void *' is not allowed}} + (void)static_cast<A*>((E*)0); // expected-error {{cannot cast 'E' to its private base class 'A'}} + (void)static_cast<A*>((H*)0); // expected-error {{ambiguous conversion}} + (void)static_cast<int>((int*)0); // expected-error {{static_cast from 'int *' to 'int' is not allowed}} + (void)static_cast<A**>((B**)0); // expected-error {{static_cast from 'B **' to 'A **' is not allowed}} + (void)static_cast<char&>(i); // expected-error {{non-const lvalue reference to type 'char' cannot bind to a value of unrelated type 'int'}} +} + +// Anything to void +void t_529_4() +{ + static_cast<void>(1); + static_cast<void>(t_529_4); +} + +// Static downcasts +void t_529_5_8() +{ + (void)static_cast<B*>((A*)0); + (void)static_cast<B&>(*((A*)0)); + (void)static_cast<const G1*>((A*)0); + (void)static_cast<const G1&>(*((A*)0)); + + // Bad code below + + (void)static_cast<C1*>((A*)0); // expected-error {{cannot cast 'A *' to 'C1 *' via virtual base 'B'}} + (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 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}} + (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}} + (void)static_cast<E*>((B*)0); // expected-error {{static_cast from 'B *' to 'E *' is not allowed}} + (void)static_cast<E&>(*((B*)0)); // expected-error {{non-const lvalue reference to type 'E' cannot bind to a value of unrelated type 'B'}} + + // TODO: Test inaccessible base in context where it's accessible, i.e. + // member function and friend. + + // TODO: Test DR427. This requires user-defined conversions, though. +} + +// Enum conversions +void t_529_7() +{ + (void)static_cast<Enum>(1); + (void)static_cast<Enum>(1.0); + (void)static_cast<Onom>(En1); + + // Bad code below + + (void)static_cast<Enum>((int*)0); // expected-error {{static_cast from 'int *' to 'Enum' is not allowed}} +} + +// Void pointer to object pointer +void t_529_10() +{ + (void)static_cast<int*>((void*)0); + (void)static_cast<const A*>((void*)0); + + // Bad code below + + (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}} +} + +// Member pointer upcast. +void t_529_9() +{ + (void)static_cast<int A::*>((int B::*)0); + + // Bad code below + (void)static_cast<int A::*>((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}} + (void)static_cast<int A::*>((int F::*)0); // expected-error {{conversion from pointer to member of class 'F' to pointer to member of class 'A' via virtual base 'B' is not allowed}} +} + +// PR 5261 - static_cast should instantiate template if possible +namespace pr5261 { + struct base {}; + template<typename E> struct derived : public base {}; + template<typename E> struct outer { + base *pb; + ~outer() { (void)static_cast<derived<E>*>(pb); } + }; + outer<int> EntryList; +} + + +// Initialization by constructor +struct X0; + +struct X1 { + X1(); + X1(X1&); + X1(const X0&); + + operator X0() const; +}; + +struct X0 { }; + +void test_ctor_init() { + (void)static_cast<X1>(X1()); +} + +// Casting away constness +struct X2 { +}; + +struct X3 : X2 { +}; + +struct X4 { + typedef const X3 X3_typedef; + + void f() const { + (void)static_cast<X3_typedef*>(x2); + } + + const X2 *x2; +}; + +// PR5897 - accept static_cast from const void* to const int (*)[1]. +void PR5897() { (void)static_cast<const int(*)[1]>((const void*)0); } + +namespace PR6072 { + struct A { }; + struct B : A { void f(int); void f(); }; // expected-note 2{{candidate function}} + struct C : B { }; + struct D { }; + + void f() { + (void)static_cast<void (A::*)()>(&B::f); + (void)static_cast<void (B::*)()>(&B::f); + (void)static_cast<void (C::*)()>(&B::f); + (void)static_cast<void (D::*)()>(&B::f); // expected-error{{address of overloaded function 'f' cannot be static_cast to type 'void (PR6072::D::*)()'}} + } +} diff --git a/clang/test/SemaCXX/static-initializers.cpp b/clang/test/SemaCXX/static-initializers.cpp new file mode 100644 index 0000000..ca49fce --- /dev/null +++ b/clang/test/SemaCXX/static-initializers.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int f() { + return 10; +} + +void g() { + static int a = f(); +} + +static int b = f(); diff --git a/clang/test/SemaCXX/storage-class.cpp b/clang/test/SemaCXX/storage-class.cpp new file mode 100644 index 0000000..01cfbfc --- /dev/null +++ b/clang/test/SemaCXX/storage-class.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +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/clang/test/SemaCXX/string-plus-int.cpp b/clang/test/SemaCXX/string-plus-int.cpp new file mode 100644 index 0000000..5752f8f --- /dev/null +++ b/clang/test/SemaCXX/string-plus-int.cpp @@ -0,0 +1,66 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-array-bounds %s -fpascal-strings +// RUN: %clang_cc1 -fdiagnostics-parseable-fixits -x c++ %s 2>&1 -Wno-array-bounds -fpascal-strings | FileCheck %s + +void consume(const char* c) {} +void consume(const unsigned char* c) {} +void consume(const wchar_t* c) {} +void consumeChar(char c) {} + +enum MyEnum { + kMySmallEnum = 1, + kMyEnum = 5 +}; + +enum OperatorOverloadEnum { + kMyOperatorOverloadedEnum = 5 +}; + +const char* operator+(const char* c, OperatorOverloadEnum e) { + return "yo"; +} + +const char* operator+(OperatorOverloadEnum e, const char* c) { + return "yo"; +} + +void f(int index) { + // Should warn. + // CHECK: fix-it:"{{.*}}":{31:11-31:11}:"&" + // CHECK: fix-it:"{{.*}}":{31:17-31:18}:"[" + // CHECK: fix-it:"{{.*}}":{31:20-31:20}:"]" + consume("foo" + 5); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + consume("foo" + index); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + consume("foo" + kMyEnum); // expected-warning {{adding 'MyEnum' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + + consume(5 + "foo"); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + consume(index + "foo"); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + consume(kMyEnum + "foo"); // expected-warning {{adding 'MyEnum' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + + // FIXME: suggest replacing with "foo"[5] + consumeChar(*("foo" + 5)); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + consumeChar(*(5 + "foo")); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + + consume(L"foo" + 5); // expected-warning {{adding 'int' to a string does not append to the string}} expected-note {{use array indexing to silence this warning}} + + // Should not warn. + consume(&("foo"[3])); + consume(&("foo"[index])); + consume(&("foo"[kMyEnum])); + consume("foo" + kMySmallEnum); + consume(kMySmallEnum + "foo"); + + consume(L"foo" + 2); + + consume("foo" + 3); // Points at the \0 + consume("foo" + 4); // Points 1 past the \0, which is legal too. + consume("\pfoo" + 4); // Pascal strings don't have a trailing \0, but they + // have a leading length byte, so this is fine too. + + consume("foo" + kMyOperatorOverloadedEnum); + consume(kMyOperatorOverloadedEnum + "foo"); + + #define A "foo" + #define B "bar" + consume(A B + sizeof(A) - 1); +} + diff --git a/clang/test/SemaCXX/struct-class-redecl.cpp b/clang/test/SemaCXX/struct-class-redecl.cpp new file mode 100644 index 0000000..5c59578 --- /dev/null +++ b/clang/test/SemaCXX/struct-class-redecl.cpp @@ -0,0 +1,164 @@ +// RUN: %clang_cc1 -fsyntax-only -Wmismatched-tags -verify %s +// RUN: %clang_cc1 -fsyntax-only -Wmismatched-tags %s 2>&1 | FileCheck %s +class X; // expected-note 2{{here}} +typedef struct X * X_t; // expected-warning{{previously declared}} +union X { int x; float y; }; // expected-error{{use of 'X' with tag type that does not match previous declaration}} + +template<typename T> struct Y; // expected-note{{did you mean class here?}} +template<class U> class Y { }; // expected-warning{{previously declared}} + +class A; +class A; // expected-note{{previous use is here}} +struct A; // expected-warning{{struct 'A' was previously declared as a class}} + +class B; // expected-note{{did you mean struct here?}} +class B; // expected-note{{previous use is here}}\ + // expected-note{{did you mean struct here?}} +struct B; // expected-warning{{struct 'B' was previously declared as a class}} +struct B {}; // expected-warning{{'B' defined as a struct here but previously declared as a class}} + +class C; // expected-note{{previous use is here}} +struct C; // expected-warning{{struct 'C' was previously declared as a class}}\ + // expected-note{{previous use is here}}\ + // expected-note{{did you mean class here?}} +class C; // expected-warning{{class 'C' was previously declared as a struct}}\ + // expected-note{{previous use is here}} +struct C; // expected-warning{{struct 'C' was previously declared as a class}}\ + // expected-note{{did you mean class here?}} +class C {}; // expected-warning{{'C' defined as a class here but previously declared as a struct}} + +struct D {}; // expected-note{{previous definition is here}}\ + // expected-note{{previous use is here}} +class D {}; // expected-error{{redefinition of 'D'}} +struct D; +class D; // expected-warning{{class 'D' was previously declared as a struct}}\ + // expected-note{{did you mean struct here?}} + +class E; +class E; +class E {}; +class E; + +struct F; +struct F; +struct F {}; +struct F; + +template<class U> class G; // expected-note{{previous use is here}}\ + // expected-note{{did you mean struct here?}} +template<class U> struct G; // expected-warning{{struct template 'G' was previously declared as a class template}} +template<class U> struct G {}; // expected-warning{{'G' defined as a struct template here but previously declared as a class template}} + +/* +*** 'X' messages *** +CHECK: warning: struct 'X' was previously declared as a class +CHECK: {{^}}typedef struct X * X_t; +CHECK: {{^}} ^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class X; +CHECK: {{^}} ^{{$}} +CHECK: error: use of 'X' with tag type that does not match previous declaration +CHECK: {{^}}union X { int x; float y; }; +CHECK: {{^}}^~~~~{{$}} +CHECK: {{^}}class{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class X; +CHECK: {{^}} ^{{$}} +*** 'Y' messages *** +CHECK: warning: 'Y' defined as a class template here but + previously declared as a struct template +CHECK: {{^}}template<class U> class Y { }; +CHECK: {{^}} ^{{$}} +CHECK: note: did you mean class here? +CHECK: {{^}}template<typename T> struct Y; +CHECK: {{^}} ^~~~~~{{$}} +CHECK: {{^}} class{{$}} +*** 'A' messages *** +CHECK: warning: struct 'A' was previously declared as a class +CHECK: {{^}}struct A; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class A; +CHECK: {{^}} ^{{$}} +*** 'B' messages *** +CHECK: warning: struct 'B' was previously declared as a class +CHECK: {{^}}struct B; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class B; +CHECK: {{^}} ^{{$}} +CHECK: 'B' defined as a struct here but previously declared as a class +CHECK: {{^}}struct B {}; +CHECK: {{^}}^{{$}} +CHECK: note: did you mean struct here? +CHECK: {{^}}class B; +CHECK: {{^}}^~~~~{{$}} +CHECK: {{^}}struct{{$}} +CHECK: note: did you mean struct here? +CHECK: {{^}}class B; +CHECK: {{^}}^~~~~{{$}} +CHECK: {{^}}struct{{$}} +*** 'C' messages *** +CHECK: warning: struct 'C' was previously declared as a class +CHECK: {{^}}struct C; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class C; +CHECK: {{^}} ^{{$}} +CHECK: warning: class 'C' was previously declared as a struct +CHECK: {{^}}class C; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}struct C; +CHECK: {{^}} ^{{$}} +CHECK: warning: struct 'C' was previously declared as a class +CHECK: {{^}}struct C; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}class C; +CHECK: {{^}} ^{{$}} +CHECK: warning: 'C' defined as a class here but previously declared as a struct +CHECK: {{^}}class C {}; +CHECK: {{^}}^{{$}} +CHECK: note: did you mean class here? +CHECK: {{^}}struct C; +CHECK: {{^}}^~~~~~{{$}} +CHECK: {{^}}class{{$}} +CHECK: note: did you mean class here? +CHECK: {{^}}struct C; +CHECK: {{^}}^~~~~~{{$}} +CHECK: {{^}}class{{$}} +*** 'D' messages *** +CHECK: error: redefinition of 'D' +CHECK: {{^}}class D {}; +CHECK: {{^}} ^{{$}} +CHECK: note: previous definition is here +CHECK: {{^}}struct D {}; +CHECK: {{^}} ^{{$}} +CHECK: warning: class 'D' was previously declared as a struct +CHECK: {{^}}class D; +CHECK: {{^}}^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}struct D {}; +CHECK: {{^}} ^{{$}} +CHECK: note: did you mean struct here? +CHECK: {{^}}class D; +CHECK: {{^}}^~~~~{{$}} +CHECK: {{^}}struct{{$}} +*** 'E' messages *** +*** 'F' messages *** +*** 'G' messages *** +CHECK: warning: struct template 'G' was previously declared as a class template +CHECK: {{^}}template<class U> struct G; +CHECK: {{^}} ^{{$}} +CHECK: note: previous use is here +CHECK: {{^}}template<class U> class G; +CHECK: {{^}} ^{{$}} +CHECK: warning: 'G' defined as a struct template here but previously declared as a class template +CHECK: {{^}}template<class U> struct G {}; +CHECK: {{^}} ^{{$}} +CHECK: note: did you mean struct here? +CHECK: {{^}}template<class U> class G; +CHECK: {{^}} ^~~~~ +CHECK: {{^}} struct +*/ diff --git a/clang/test/SemaCXX/switch-0x.cpp b/clang/test/SemaCXX/switch-0x.cpp new file mode 100644 index 0000000..2e74da0 --- /dev/null +++ b/clang/test/SemaCXX/switch-0x.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// PR5518 +struct A { + explicit operator int(); // expected-note{{conversion to integral type}} +}; + +void x() { + switch(A()) { // expected-error{{explicit conversion to}} + } +} diff --git a/clang/test/SemaCXX/switch.cpp b/clang/test/SemaCXX/switch.cpp new file mode 100644 index 0000000..517faa9 --- /dev/null +++ b/clang/test/SemaCXX/switch.cpp @@ -0,0 +1,87 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +void test() { + bool x = true; + switch (x) { // expected-warning {{bool}} + case 0: + break; + } + + int n = 3; + switch (n && true) { // expected-warning {{bool}} + case 1: + break; + } +} + +// PR5518 +struct A { + operator int(); // expected-note{{conversion to integral type}} +}; + +void x() { + switch(A()) { + } +} + +enum E { e1, e2 }; +struct B : A { + operator E() const; // expected-note{{conversion to enumeration type}} +}; + +void x2() { + switch (B()) { // expected-error{{multiple conversions}} + } +} + +struct C; // expected-note{{forward declaration}} + +void x3(C &c) { + switch (c) { // expected-error{{incomplete class type}} + } +} + +namespace test3 { + enum En { A, B, C }; + template <En how> void foo() { + int x = 0, y = 5; + + switch (how) { //expected-warning {{no case matching constant switch condition '2'}} + case A: x *= y; break; + case B: x += y; break; + // No case for C, but it's okay because we have a constant condition. + } + } + + template void foo<A>(); + template void foo<B>(); + template void foo<C>(); //expected-note {{in instantiation}} +} + +// PR9304 and rdar://9045501 +void click_check_header_sizes() { + switch (0 == 8) { // expected-warning {{switch condition has boolean value}} + case 0: ; + } +} + +void local_class(int n) { + for (;;) switch (n) { + case 0: + struct S { + void f() { + case 1: // expected-error {{'case' statement not in switch statement}} + break; // expected-error {{'break' statement not in loop or switch statement}} + default: // expected-error {{'default' statement not in switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + } + }; + S().f(); + []{ + case 2: // expected-error {{'case' statement not in switch statement}} + break; // expected-error {{'break' statement not in loop or switch statement}} + default: // expected-error {{'default' statement not in switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + }(); + } +} diff --git a/clang/test/SemaCXX/tag-ambig.cpp b/clang/test/SemaCXX/tag-ambig.cpp new file mode 100644 index 0000000..6403cf3 --- /dev/null +++ b/clang/test/SemaCXX/tag-ambig.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// <rdar://problem/9168556> +typedef struct Point Point; + +namespace NameSpace { + class Point; +} + +using namespace NameSpace; + +class Test +{ +public: + struct Point { }; + virtual bool testMethod (Test::Point& p) = 0; +}; + +// PR8151 +namespace A { struct Face {}; } +namespace B { struct Face {}; } +using namespace A; +using namespace B; + +class C { + struct Face; + Face *mFaces; +}; diff --git a/clang/test/SemaCXX/templated-friend-decl.cpp b/clang/test/SemaCXX/templated-friend-decl.cpp new file mode 100644 index 0000000..c0034cd --- /dev/null +++ b/clang/test/SemaCXX/templated-friend-decl.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 %s + +template <typename T> +struct Foo { + template <typename U> + struct Bar {}; + + // The templated declaration for class Bar should not be instantiated when + // Foo<int> is. This is to protect against PR5848; for now, this "parses" but + // requires a rewrite of the templated friend code to be properly fixed. + template <typename U> + friend struct Bar; +}; + +Foo<int> x; diff --git a/clang/test/SemaCXX/this.cpp b/clang/test/SemaCXX/this.cpp new file mode 100644 index 0000000..27ee1e8 --- /dev/null +++ b/clang/test/SemaCXX/this.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +int x = this; // expected-error {{invalid use of 'this' outside of a non-static member function}} + +void f() { + int x = this; // expected-error {{invalid use of 'this' outside of a non-static member function}} +} diff --git a/clang/test/SemaCXX/trailing-return-0x.cpp b/clang/test/SemaCXX/trailing-return-0x.cpp new file mode 100644 index 0000000..c219b77 --- /dev/null +++ b/clang/test/SemaCXX/trailing-return-0x.cpp @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +template <class T> +struct only +{ + only(T) {} + + template <class U> + only(U) + { + static_assert(sizeof(U) == 0, "expected type failure"); + } +}; + +auto f() -> int +{ + return 0; +} + +auto g(); // expected-error{{return without trailing return type}} + +int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}} + +int i(); +auto i() -> int; +int i() {} + +using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}} +using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}} + +using U = auto (int) -> auto (*)(char) -> void; +using U = void (*(int))(char); // ok + +int x; + +template <class T> +auto i(T x) -> decltype(x) +{ + return x; +} + +only<double> p1 = i(1.0); + +template <class T> +struct X +{ + auto f(T x) -> T { return x; } + + template <class U> + auto g(T x, U y) -> decltype(x + y) + { + return x + y; + } + + template<typename U> + struct nested { + template <class V> + auto h(T x, U y, V z) -> decltype(x + y + z) + { + return x + y + z; + } + }; + + template<typename U> + nested<U> get_nested(); +}; + +X<int> xx; +only<int> p2 = xx.f(0L); +only<double> p3 = xx.g(0L, 1.0); +only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f); diff --git a/clang/test/SemaCXX/trivial-constructor.cpp b/clang/test/SemaCXX/trivial-constructor.cpp new file mode 100644 index 0000000..bda206b --- /dev/null +++ b/clang/test/SemaCXX/trivial-constructor.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 +struct T1 { +}; +static_assert(__has_trivial_constructor(T1), "T1 has trivial constructor!"); + +struct T2 { + T2(); +}; +static_assert(!__has_trivial_constructor(T2), "T2 has a user-declared constructor!"); + +struct T3 { + virtual void f(); +}; +static_assert(!__has_trivial_constructor(T3), "T3 has a virtual function!"); + +struct T4 : virtual T3 { +}; +static_assert(!__has_trivial_constructor(T4), "T4 has a virtual base class!"); + +struct T5 : T1 { +}; +static_assert(__has_trivial_constructor(T5), "All the direct base classes of T5 have trivial constructors!"); + +struct T6 { + T5 t5; + T1 t1[2][2]; + static T2 t2; +}; +static_assert(__has_trivial_constructor(T6), "All nonstatic data members of T6 have trivial constructors!"); + +struct T7 { + T4 t4; +}; +static_assert(!__has_trivial_constructor(T7), "t4 does not have a trivial constructor!"); + +struct T8 : T2 { +}; +static_assert(!__has_trivial_constructor(T8), "The base class T2 does not have a trivial constructor!"); diff --git a/clang/test/SemaCXX/trivial-destructor.cpp b/clang/test/SemaCXX/trivial-destructor.cpp new file mode 100644 index 0000000..db415cf --- /dev/null +++ b/clang/test/SemaCXX/trivial-destructor.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 +struct T1 { +}; +static_assert(__has_trivial_destructor(T1), "T1 has trivial destructor!"); + +struct T2 { + ~T2(); +}; +static_assert(!__has_trivial_destructor(T2), "T2 has a user-declared destructor!"); + +struct T3 { + virtual void f(); +}; +static_assert(__has_trivial_destructor(T3), "T3 has a virtual function (but still a trivial destructor)!"); + +struct T4 : virtual T3 { +}; +static_assert(__has_trivial_destructor(T4), "T4 has a virtual base class! (but still a trivial destructor)!"); + +struct T5 : T1 { +}; +static_assert(__has_trivial_destructor(T5), "All the direct base classes of T5 have trivial destructors!"); + +struct T6 { + T5 t5; + T1 t1[2][2]; + static T2 t2; +}; +static_assert(__has_trivial_destructor(T6), "All nonstatic data members of T6 have trivial destructors!"); + +struct T7 { + T2 t2; +}; +static_assert(!__has_trivial_destructor(T7), "t2 does not have a trivial destructor!"); + +struct T8 : T2 { +}; +static_assert(!__has_trivial_destructor(T8), "The base class T2 does not have a trivial destructor!"); diff --git a/clang/test/SemaCXX/type-convert-construct.cpp b/clang/test/SemaCXX/type-convert-construct.cpp new file mode 100644 index 0000000..479af21 --- /dev/null +++ b/clang/test/SemaCXX/type-convert-construct.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f() { + float v1 = float(1); + int v2 = typeof(int)(1,2); // expected-error {{excess elements in scalar initializer}} + typedef int arr[]; + int v3 = arr(); // expected-error {{array types cannot be value-initialized}} + int v4 = int(); + int v5 = int; // expected-error {{expected '(' for function-style cast or type construction}} + typedef int T; + int *p; + bool v6 = T(0) == p; + char *str; + str = "a string"; // expected-warning{{conversion from string literal to 'char *' is deprecated}} + wchar_t *wstr; + wstr = L"a wide string"; // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}} +} diff --git a/clang/test/SemaCXX/type-definition-in-specifier.cpp b/clang/test/SemaCXX/type-definition-in-specifier.cpp new file mode 100644 index 0000000..a614e6c --- /dev/null +++ b/clang/test/SemaCXX/type-definition-in-specifier.cpp @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct S0; +struct S1; +struct S2; +struct S3; +struct S4; +struct S5; +struct S6; + +struct S0 { int x; }; + +void f0() { + typedef struct S1 { int x; } S1_typedef; + + (void)((struct S2 { int x; }*)0); // expected-error{{can not be defined}} + + struct S3 { int x; } s3; + + (void)static_cast<struct S4 { int x; } *>(0); // expected-error{{can not be defined}} +} + +struct S5 { int x; } f1() { return S5(); } // expected-error{{result type}} + +void f2(struct S6 { int x; } p); // expected-error{{parameter type}} diff --git a/clang/test/SemaCXX/type-dependent-exprs.cpp b/clang/test/SemaCXX/type-dependent-exprs.cpp new file mode 100644 index 0000000..398c3cb --- /dev/null +++ b/clang/test/SemaCXX/type-dependent-exprs.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +class X { +public: + virtual int f(); +}; + +void g(int); // expected-note{{candidate function}} + +template<typename T> +T f(T x) { + (void)(x + 0); + (void)T(0); + (void)(x += 0); + (void)(x? x : x); + (void)static_cast<int>(x); + (void)reinterpret_cast<int>(x); + (void)dynamic_cast<X*>(&x); + (void)const_cast<int>(x); + return g(x); + h(x); // h is a dependent name + g(1, 1); // expected-error{{no matching function for call}} + h(1); // expected-error{{use of undeclared identifier 'h'}} + return 0; +} + +// This one entered into an infinite loop. +template <unsigned long N> +void rdar8520617() { + if (N > 1) { } +} + +int f2() { + rdar8520617<0>(); +} + diff --git a/clang/test/SemaCXX/type-formatting.cpp b/clang/test/SemaCXX/type-formatting.cpp new file mode 100644 index 0000000..3fe9278 --- /dev/null +++ b/clang/test/SemaCXX/type-formatting.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct X0 { }; +struct X1 { }; + +template<typename T> +void f0() { + const T *t = (const X0*)0; // expected-error{{cannot initialize a variable of type 'const X1 *' with an rvalue of type 'const X0 *'}} +} +template void f0<X1>(); // expected-note{{instantiation of}} diff --git a/clang/test/SemaCXX/type-traits-incomplete.cpp b/clang/test/SemaCXX/type-traits-incomplete.cpp new file mode 100644 index 0000000..c0a520e --- /dev/null +++ b/clang/test/SemaCXX/type-traits-incomplete.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct S; // expected-note 2 {{forward declaration of 'S'}} + +void f() { + __is_pod(S); // expected-error{{incomplete type 'S' used in type trait expression}} + __is_pod(S[]); // expected-error{{incomplete type 'S' used in type trait expression}} +} diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp new file mode 100644 index 0000000..f53939a --- /dev/null +++ b/clang/test/SemaCXX/type-traits.cpp @@ -0,0 +1,1818 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 %s +#define T(b) (b) ? 1 : -1 +#define F(b) (b) ? -1 : 1 + +struct NonPOD { NonPOD(int); }; + +// PODs +enum Enum { EV }; +struct POD { Enum e; int i; float f; NonPOD* p; }; +struct Empty {}; +typedef Empty EmptyAr[10]; +typedef int Int; +typedef Int IntAr[10]; +typedef Int IntArNB[]; +class Statics { static int priv; static NonPOD np; }; +union EmptyUnion {}; +union Union { int i; float f; }; +struct HasFunc { void f (); }; +struct HasOp { void operator *(); }; +struct HasConv { operator int(); }; +struct HasAssign { void operator =(int); }; + +struct HasAnonymousUnion { + union { + int i; + float f; + }; +}; + +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&&); }; +struct HasDefaultTrivialCopyAssign { + HasDefaultTrivialCopyAssign &operator =(const HasDefaultTrivialCopyAssign&) + = default; +}; +struct TrivialMoveButNotCopy { + TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default; + TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&); +}; +struct NonTrivialDefault { + NonTrivialDefault(); +}; + +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 NonPOD NonPODAr[10]; +typedef HasVirt VirtAr[10]; +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(); +}; +struct HasMultipleCopyAssign { + void operator =(const HasMultipleCopyAssign&) throw(); + void operator =(volatile HasMultipleCopyAssign&); +}; +struct HasMultipleNoThrowCopyAssign { + void operator =(const HasMultipleNoThrowCopyAssign&) throw(); + void operator =(volatile HasMultipleNoThrowCopyAssign&) throw(); +}; + +struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); }; +struct HasNoThrowConstructorWithArgs { + HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw(); +}; + +struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); }; +struct HasMultipleCopy { + HasMultipleCopy(const HasMultipleCopy&) throw(); + HasMultipleCopy(volatile HasMultipleCopy&); +}; +struct HasMultipleNoThrowCopy { + HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw(); + HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw(); +}; + +struct HasVirtDest { virtual ~HasVirtDest(); }; +struct DerivedVirtDest : HasVirtDest {}; +typedef HasVirtDest VirtDestAr[1]; + +class AllPrivate { + AllPrivate() throw(); + AllPrivate(const AllPrivate&) throw(); + AllPrivate &operator=(const AllPrivate &) throw(); + ~AllPrivate() throw(); +}; + +struct ThreeArgCtor { + ThreeArgCtor(int*, char*, int); +}; + +void is_pod() +{ + { 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]; +struct Bit0 { int : 0; }; +struct Bit0Cons { int : 0; Bit0Cons(); }; +struct BitOnly { int x : 3; }; +//struct DerivesVirt : virtual POD {}; + +void is_empty() +{ + { 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 arr[T(__is_class(Derives))]; } + { int arr[T(__is_class(HasPriv))]; } + { int arr[T(__is_class(ClassType))]; } + { int arr[T(__is_class(HasAnonymousUnion))]; } + + { 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]; +typedef Union UnionType; + +void is_union() +{ + { int arr[T(__is_union(Union))]; } + { int arr[T(__is_union(UnionType))]; } + + { 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 arr[T(__is_enum(Enum))]; } + { int arr[T(__is_enum(EnumType))]; } + + { 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))]; } +} + +struct FinalClass final { +}; + +template<typename T> +struct PotentiallyFinal { }; + +template<typename T> +struct PotentiallyFinal<T*> final { }; + +template<> +struct PotentiallyFinal<int> final { }; + +void is_final() +{ + { int arr[T(__is_final(FinalClass))]; } + { int arr[T(__is_final(PotentiallyFinal<float*>))]; } + { int arr[T(__is_final(PotentiallyFinal<int>))]; } + + { int arr[F(__is_final(int))]; } + { int arr[F(__is_final(Union))]; } + { int arr[F(__is_final(Int))]; } + { int arr[F(__is_final(IntAr))]; } + { int arr[F(__is_final(UnionAr))]; } + { int arr[F(__is_final(Derives))]; } + { int arr[F(__is_final(ClassType))]; } + { int arr[F(__is_final(cvoid))]; } + { int arr[F(__is_final(IntArNB))]; } + { int arr[F(__is_final(HasAnonymousUnion))]; } + { int arr[F(__is_final(PotentiallyFinal<float>))]; } +} + +typedef HasVirt Polymorph; +struct InheritPolymorph : Polymorph {}; + +void is_polymorphic() +{ + { 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 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; + } +}; + +struct SuperNonTrivialStruct { + SuperNonTrivialStruct() { } + ~SuperNonTrivialStruct() { } +}; + +struct NonTCStruct { + NonTCStruct(const NonTCStruct&) {} +}; + +struct AllDefaulted { + AllDefaulted() = default; + AllDefaulted(const AllDefaulted &) = default; + AllDefaulted(AllDefaulted &&) = default; + AllDefaulted &operator=(const AllDefaulted &) = default; + AllDefaulted &operator=(AllDefaulted &&) = default; + ~AllDefaulted() = default; +}; + +struct AllDeleted { + AllDeleted() = delete; + AllDeleted(const AllDeleted &) = delete; + AllDeleted(AllDeleted &&) = delete; + AllDeleted &operator=(const AllDeleted &) = delete; + AllDeleted &operator=(AllDeleted &&) = delete; + ~AllDeleted() = delete; +}; + +struct ExtDefaulted { + ExtDefaulted(); + ExtDefaulted(const ExtDefaulted &); + ExtDefaulted(ExtDefaulted &&); + ExtDefaulted &operator=(const ExtDefaulted &); + ExtDefaulted &operator=(ExtDefaulted &&); + ~ExtDefaulted(); +}; + +// Despite being defaulted, these functions are not trivial. +ExtDefaulted::ExtDefaulted() = default; +ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default; +ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default; +ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default; +ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default; +ExtDefaulted::~ExtDefaulted() = default; + +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 t23[T(__is_trivial(AllDefaulted))]; + int t24[T(__is_trivial(AllDeleted))]; + + int t30[F(__is_trivial(void))]; + int t31[F(__is_trivial(NonTrivialStruct))]; + int t32[F(__is_trivial(SuperNonTrivialStruct))]; + int t33[F(__is_trivial(NonTCStruct))]; + int t34[F(__is_trivial(ExtDefaulted))]; +} + +void is_trivially_copyable2() +{ + int t01[T(__is_trivially_copyable(char))]; + int t02[T(__is_trivially_copyable(int))]; + int t03[T(__is_trivially_copyable(long))]; + int t04[T(__is_trivially_copyable(short))]; + int t05[T(__is_trivially_copyable(signed char))]; + int t06[T(__is_trivially_copyable(wchar_t))]; + int t07[T(__is_trivially_copyable(bool))]; + int t08[T(__is_trivially_copyable(float))]; + int t09[T(__is_trivially_copyable(double))]; + int t10[T(__is_trivially_copyable(long double))]; + int t11[T(__is_trivially_copyable(unsigned char))]; + int t12[T(__is_trivially_copyable(unsigned int))]; + int t13[T(__is_trivially_copyable(unsigned long long))]; + int t14[T(__is_trivially_copyable(unsigned long))]; + int t15[T(__is_trivially_copyable(unsigned short))]; + int t16[T(__is_trivially_copyable(ClassType))]; + int t17[T(__is_trivially_copyable(Derives))]; + int t18[T(__is_trivially_copyable(Enum))]; + int t19[T(__is_trivially_copyable(IntAr))]; + int t20[T(__is_trivially_copyable(Union))]; + int t21[T(__is_trivially_copyable(UnionAr))]; + int t22[T(__is_trivially_copyable(TrivialStruct))]; + int t23[T(__is_trivially_copyable(NonTrivialStruct))]; + int t24[T(__is_trivially_copyable(AllDefaulted))]; + int t25[T(__is_trivially_copyable(AllDeleted))]; + + int t30[F(__is_trivially_copyable(void))]; + int t31[F(__is_trivially_copyable(SuperNonTrivialStruct))]; + int t32[F(__is_trivially_copyable(NonTCStruct))]; + int t33[F(__is_trivially_copyable(ExtDefaulted))]; +} + +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; +typedef const IntAr ConstIntAr; +typedef ConstIntAr ConstIntArAr[4]; + +struct HasCopy { + HasCopy(HasCopy& cp); +}; + +struct HasMove { + HasMove(HasMove&& cp); +}; + +struct HasTemplateCons { + HasVirt Annoying; + + template <typename T> + HasTemplateCons(const T&); +}; + +void has_trivial_default_constructor() { + { 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[T(__has_trivial_constructor(AllDefaulted))]; } + { int arr[T(__has_trivial_constructor(AllDeleted))]; } + + { 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))]; } + { int arr[F(__has_trivial_constructor(AllPrivate))]; } + { int arr[F(__has_trivial_constructor(ExtDefaulted))]; } +} + +void has_trivial_copy_constructor() { + { 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[T(__has_trivial_copy(AllDefaulted))]; } + { int arr[T(__has_trivial_copy(AllDeleted))]; } + + { 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))]; } + { int arr[F(__has_trivial_copy(AllPrivate))]; } + { int arr[F(__has_trivial_copy(ExtDefaulted))]; } +} + +void has_trivial_copy_assignment() { + { 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[T(__has_trivial_assign(AllDefaulted))]; } + { int arr[T(__has_trivial_assign(AllDeleted))]; } + + { 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))]; } + { int arr[F(__has_trivial_assign(AllPrivate))]; } + { int arr[F(__has_trivial_assign(ExtDefaulted))]; } +} + +void has_trivial_destructor() { + { 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[T(__has_trivial_destructor(AllDefaulted))]; } + { int arr[T(__has_trivial_destructor(AllDeleted))]; } + + { int arr[F(__has_trivial_destructor(HasDest))]; } + { int arr[F(__has_trivial_destructor(void))]; } + { int arr[F(__has_trivial_destructor(cvoid))]; } + { int arr[F(__has_trivial_destructor(AllPrivate))]; } + { int arr[F(__has_trivial_destructor(ExtDefaulted))]; } +} + +struct A { ~A() {} }; +template<typename> struct B : A { }; + +void f() { + { int arr[F(__has_trivial_destructor(A))]; } + { int arr[F(__has_trivial_destructor(B<int>))]; } +} + +class PR11110 { + template <int> int operator=( int ); + int operator=(PR11110); +}; + +class UsingAssign; + +class UsingAssignBase { +protected: + UsingAssign &operator=(const UsingAssign&) throw(); +}; + +class UsingAssign : public UsingAssignBase { +public: + using UsingAssignBase::operator=; +}; + +void has_nothrow_assign() { + { 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[T(__has_nothrow_assign(AllPrivate))]; } + { int arr[T(__has_nothrow_assign(UsingAssign))]; } + + { 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))]; } + { int arr[F(__has_nothrow_assign(PR11110))]; } +} + +void has_nothrow_copy() { + { 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[T(__has_nothrow_copy(AllPrivate))]; } + + { 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))]; } +} + +template<bool b> struct assert_expr; +template<> struct assert_expr<true> {}; + +void has_nothrow_constructor() { + { 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[T(__has_nothrow_constructor(AllPrivate))]; } + + { 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))]; } + + // While parsing an in-class initializer, the constructor is not known to be + // non-throwing yet. + struct HasInClassInit { int n = (assert_expr<!__has_nothrow_constructor(HasInClassInit)>(), 0); }; + { int arr[T(__has_nothrow_constructor(HasInClassInit))]; } +} + +void has_virtual_destructor() { + { 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))]; } + { int arr[F(__has_virtual_destructor(AllPrivate))]; } +} + + +class Base {}; +class Derived : Base {}; +class Derived2a : Derived {}; +class Derived2b : Derived {}; +class Derived3 : virtual Derived2a, virtual Derived2b {}; +template<typename T> struct BaseA { T a; }; +template<typename T> struct DerivedB : BaseA<T> { }; +template<typename T> struct CrazyDerived : T { }; + + +class class_forward; // expected-note {{forward declaration of 'class_forward'}} + +template <typename Base, typename Derived> +void isBaseOfT() { + int t[T(__is_base_of(Base, Derived))]; +}; +template <typename Base, typename Derived> +void isBaseOfF() { + int t[F(__is_base_of(Base, Derived))]; +}; + +template <class T> class DerivedTemp : Base {}; +template <class T> class NonderivedTemp {}; +template <class T> class UndefinedTemp; // expected-note {{declared here}} + +void is_base_of() { + { 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 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>(); + + isBaseOfT<Base, CrazyDerived<Base> >(); + isBaseOfF<CrazyDerived<Base>, Base>(); + + isBaseOfT<BaseA<int>, DerivedB<int> >(); + isBaseOfF<DerivedB<int>, BaseA<int> >(); +} + +template<class T, class U> +class TemplateClass {}; + +template<class T> +using TemplateAlias = TemplateClass<T, int>; + +typedef class Base BaseTypedef; + +void is_same() +{ + int t01[T(__is_same(Base, Base))]; + int t02[T(__is_same(Base, BaseTypedef))]; + int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))]; + + 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(); + +void is_convertible_to(); +class PrivateCopy { + PrivateCopy(const PrivateCopy&); + friend void is_convertible_to(); +}; + +template<typename T> +struct X0 { + template<typename U> X0(const X0<U>&); +}; + +void is_convertible_to() { + { 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>))]; } +} + +namespace is_convertible_to_instantiate { + // Make sure we don't try to instantiate the constructor. + template<int x> class A { A(int) { int a[x]; } }; + int x = __is_convertible_to(int, A<-1>); +} + +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 trivial_checks() +{ + { int arr[T(__is_trivially_copyable(int))]; } + { int arr[T(__is_trivially_copyable(Enum))]; } + { int arr[T(__is_trivially_copyable(POD))]; } + { int arr[T(__is_trivially_copyable(Int))]; } + { int arr[T(__is_trivially_copyable(IntAr))]; } + { int arr[T(__is_trivially_copyable(IntArNB))]; } + { int arr[T(__is_trivially_copyable(Statics))]; } + { int arr[T(__is_trivially_copyable(Empty))]; } + { int arr[T(__is_trivially_copyable(EmptyUnion))]; } + { int arr[T(__is_trivially_copyable(Union))]; } + { int arr[T(__is_trivially_copyable(Derives))]; } + { int arr[T(__is_trivially_copyable(DerivesAr))]; } + { int arr[T(__is_trivially_copyable(DerivesArNB))]; } + { int arr[T(__is_trivially_copyable(DerivesEmpty))]; } + { int arr[T(__is_trivially_copyable(HasFunc))]; } + { int arr[T(__is_trivially_copyable(HasOp))]; } + { int arr[T(__is_trivially_copyable(HasConv))]; } + { int arr[T(__is_trivially_copyable(HasAssign))]; } + { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; } + { int arr[T(__is_trivially_copyable(HasPriv))]; } + { int arr[T(__is_trivially_copyable(HasProt))]; } + { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; } + { int arr[T(__is_trivially_copyable(DerivesHasProt))]; } + { int arr[T(__is_trivially_copyable(Vector))]; } + { int arr[T(__is_trivially_copyable(VectorExt))]; } + { int arr[T(__is_trivially_copyable(HasCons))]; } + { int arr[T(__is_trivially_copyable(HasRef))]; } + { int arr[T(__is_trivially_copyable(HasNonPOD))]; } + { int arr[T(__is_trivially_copyable(DerivesHasCons))]; } + { int arr[T(__is_trivially_copyable(DerivesHasRef))]; } + + { int arr[F(__is_trivially_copyable(HasCopyAssign))]; } + { int arr[F(__is_trivially_copyable(HasMoveAssign))]; } + { int arr[F(__is_trivially_copyable(HasDest))]; } + { int arr[F(__is_trivially_copyable(HasVirt))]; } + { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; } + { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; } + { int arr[F(__is_trivially_copyable(DerivesHasDest))]; } + { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; } + { int arr[F(__is_trivially_copyable(void))]; } + { int arr[F(__is_trivially_copyable(cvoid))]; } + + { int arr[T((__is_trivially_constructible(int)))]; } + { int arr[T((__is_trivially_constructible(int, int)))]; } + { int arr[T((__is_trivially_constructible(int, float)))]; } + { int arr[T((__is_trivially_constructible(int, int&)))]; } + { int arr[T((__is_trivially_constructible(int, const int&)))]; } + { int arr[T((__is_trivially_constructible(int, int)))]; } + { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; } + { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; } + { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; } + { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; } + { int arr[T((__is_trivially_constructible(NonTrivialDefault, + const NonTrivialDefault&)))]; } + { int arr[T((__is_trivially_constructible(NonTrivialDefault, + NonTrivialDefault&&)))]; } + { int arr[T((__is_trivially_constructible(AllDefaulted)))]; } + { int arr[T((__is_trivially_constructible(AllDefaulted, + const AllDefaulted &)))]; } + { int arr[T((__is_trivially_constructible(AllDefaulted, + AllDefaulted &&)))]; } + + { int arr[F((__is_trivially_constructible(int, int*)))]; } + { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; } + { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; } + { int arr[F((__is_trivially_constructible(AllDeleted)))]; } + { int arr[F((__is_trivially_constructible(AllDeleted, + const AllDeleted &)))]; } + { int arr[F((__is_trivially_constructible(AllDeleted, + AllDeleted &&)))]; } + { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; } + { int arr[F((__is_trivially_constructible(ExtDefaulted, + const ExtDefaulted &)))]; } + { int arr[F((__is_trivially_constructible(ExtDefaulted, + ExtDefaulted &&)))]; } + + { int arr[T((__is_trivially_assignable(int&, int)))]; } + { int arr[T((__is_trivially_assignable(int&, int&)))]; } + { int arr[T((__is_trivially_assignable(int&, int&&)))]; } + { int arr[T((__is_trivially_assignable(int&, const int&)))]; } + { int arr[T((__is_trivially_assignable(POD&, POD)))]; } + { int arr[T((__is_trivially_assignable(POD&, POD&)))]; } + { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; } + { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; } + { int arr[T((__is_trivially_assignable(int*&, int*)))]; } + { int arr[T((__is_trivially_assignable(AllDefaulted, + const AllDefaulted &)))]; } + { int arr[T((__is_trivially_assignable(AllDefaulted, + AllDefaulted &&)))]; } + + { int arr[F((__is_trivially_assignable(int*&, float*)))]; } + { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; } + { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; } + { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; } + { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; } + { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&, + TrivialMoveButNotCopy&)))]; } + { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&, + const TrivialMoveButNotCopy&)))]; } + { int arr[F((__is_trivially_assignable(AllDeleted, + const AllDeleted &)))]; } + { int arr[F((__is_trivially_assignable(AllDeleted, + AllDeleted &&)))]; } + { int arr[F((__is_trivially_assignable(ExtDefaulted, + const ExtDefaulted &)))]; } + { int arr[F((__is_trivially_assignable(ExtDefaulted, + ExtDefaulted &&)))]; } + + { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, + HasDefaultTrivialCopyAssign&)))]; } + { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, + const HasDefaultTrivialCopyAssign&)))]; } + { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&, + TrivialMoveButNotCopy)))]; } + { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&, + TrivialMoveButNotCopy&&)))]; } +} + +// Instantiation of __is_trivially_constructible +template<typename T, typename ...Args> +struct is_trivially_constructible { + static const bool value = __is_trivially_constructible(T, Args...); +}; + +void is_trivially_constructible_test() { + { int arr[T((is_trivially_constructible<int>::value))]; } + { int arr[T((is_trivially_constructible<int, int>::value))]; } + { int arr[T((is_trivially_constructible<int, float>::value))]; } + { int arr[T((is_trivially_constructible<int, int&>::value))]; } + { int arr[T((is_trivially_constructible<int, const int&>::value))]; } + { int arr[T((is_trivially_constructible<int, int>::value))]; } + { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; } + { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; } + { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; } + { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; } + { int arr[T((is_trivially_constructible<NonTrivialDefault, + const NonTrivialDefault&>::value))]; } + { int arr[T((is_trivially_constructible<NonTrivialDefault, + NonTrivialDefault&&>::value))]; } + + { int arr[F((is_trivially_constructible<int, int*>::value))]; } + { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; } + { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; } +} + +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/clang/test/SemaCXX/typedef-redecl.cpp b/clang/test/SemaCXX/typedef-redecl.cpp new file mode 100644 index 0000000..b53bcd2 --- /dev/null +++ b/clang/test/SemaCXX/typedef-redecl.cpp @@ -0,0 +1,95 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef int INT; +typedef INT REALLY_INT; // expected-note {{previous definition is here}} +typedef REALLY_INT REALLY_REALLY_INT; +typedef REALLY_INT BOB; +typedef float REALLY_INT; // expected-error{{typedef redefinition with different types ('float' vs 'INT' (aka 'int'))}} + +struct X { + typedef int result_type; // expected-note {{previous definition is here}} + typedef INT result_type; // expected-error {{redefinition of 'result_type'}} +}; + +struct Y; // expected-note{{previous definition is here}} +typedef int Y; // expected-error{{typedef redefinition with different types ('int' vs 'Y')}} + +typedef int Y2; // expected-note{{declared here}} +struct Y2; // expected-error{{definition of type 'Y2' conflicts with typedef of the same name}} + +void f(); // expected-note{{previous definition is here}} +typedef int f; // expected-error{{redefinition of 'f' as different kind of symbol}} + +typedef int f2; // expected-note{{previous definition is here}} +void f2(); // expected-error{{redefinition of 'f2' as different kind of symbol}} + +typedef struct s s; +typedef int I; +typedef int I; +typedef I I; + +struct s { }; + +// PR5874 +namespace test1 { + typedef int foo; + namespace a { using test1::foo; }; + typedef int foo; + using namespace a; + foo x; +} + +namespace PR6923 { + struct A; + + extern "C" { + struct A; + typedef struct A A; + } + + struct A; +} + +namespace PR7462 { + struct A {}; + typedef int operator! (A); // expected-error{{typedef name must be an identifier}} + int i = !A(); // expected-error{{invalid argument type}} +} + +template<typename T> +typedef T f(T t) { return t; } // expected-error {{function definition declared 'typedef'}} +int k = f(0); +int k2 = k; + +namespace PR11630 { + template <class T> + struct S + { + static const unsigned C = 1; + static void f() + { + typedef int q[C == 1 ? 1 : -1]; // expected-note{{previous definition is here}} + typedef int q[C >= 1 ? 2 : -2]; // expected-error{{typedef redefinition with different types ('int [2]' vs 'int [1]')}} + typedef int n[C == 1 ? 1 : -1]; + typedef int n[C >= 1 ? 1 : -1]; + } + }; + + template <int T> + struct S2 + { + static void f() + { + typedef int q[1]; // expected-note{{previous definition is here}} + typedef int q[T]; // expected-error{{typedef redefinition with different types ('int [2]' vs 'int [1]')}} + } + }; + + void f() { + S<int> a; + a.f(); // expected-note{{in instantiation of member function 'PR11630::S<int>::f' requested here}} + S2<1> b; + b.f(); + S2<2> b2; + b2.f(); // expected-note{{in instantiation of member function 'PR11630::S2<2>::f' requested here}} + } +} diff --git a/clang/test/SemaCXX/typeid-ref.cpp b/clang/test/SemaCXX/typeid-ref.cpp new file mode 100644 index 0000000..d01fd31 --- /dev/null +++ b/clang/test/SemaCXX/typeid-ref.cpp @@ -0,0 +1,12 @@ +// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s +namespace std { + class type_info; +} + +struct X { }; + +void f() { + // CHECK: @_ZTS1X = linkonce_odr constant + // CHECK: @_ZTI1X = linkonce_odr unnamed_addr constant + (void)typeid(X&); +} diff --git a/clang/test/SemaCXX/typeid.cpp b/clang/test/SemaCXX/typeid.cpp new file mode 100644 index 0000000..d3a2a28 --- /dev/null +++ b/clang/test/SemaCXX/typeid.cpp @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f() +{ + (void)typeid(int); // expected-error {{you need to include <typeinfo> before using the 'typeid' operator}} +} + +namespace std { + class type_info; +} + +void g() +{ + (void)typeid(int); +} + +struct X; // expected-note 3{{forward declaration}} + +void g1(X &x) { + (void)typeid(X); // expected-error{{'typeid' of incomplete type 'X'}} + (void)typeid(X&); // expected-error{{'typeid' of incomplete type 'X'}} + (void)typeid(x); // expected-error{{'typeid' of incomplete type 'X'}} +} diff --git a/clang/test/SemaCXX/types_compatible_p.cpp b/clang/test/SemaCXX/types_compatible_p.cpp new file mode 100644 index 0000000..4aa9a1c --- /dev/null +++ b/clang/test/SemaCXX/types_compatible_p.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +bool f() { + return __builtin_types_compatible_p(int, const int); // expected-error{{C++}} +} diff --git a/clang/test/SemaCXX/typo-correction.cpp b/clang/test/SemaCXX/typo-correction.cpp new file mode 100644 index 0000000..b1e8d91 --- /dev/null +++ b/clang/test/SemaCXX/typo-correction.cpp @@ -0,0 +1,192 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s + +struct errc { + int v_; + operator int() const {return v_;} +}; + +class error_condition +{ + int _val_; +public: + error_condition() : _val_(0) {} + + error_condition(int _val) + : _val_(_val) {} + + template <class E> + error_condition(E _e) { + // make_error_condition must not be typo corrected to error_condition + // even though the first declaration of make_error_condition has not + // yet been encountered. This was a bug in the first version of the type + // name typo correction patch that wasn't noticed until building LLVM with + // Clang failed. + *this = make_error_condition(_e); + } + +}; + +inline error_condition make_error_condition(errc _e) { + return error_condition(static_cast<int>(_e)); +} + + +// Prior to the introduction of a callback object to further filter possible +// typo corrections, this example would not trigger a suggestion as "base_type" +// is a closer match to "basetype" than is "BaseType" but "base_type" does not +// refer to a base class or non-static data member. +struct BaseType { }; +struct Derived : public BaseType { // expected-note {{base class 'BaseType' specified here}} + static int base_type; // expected-note {{'base_type' declared here}} + Derived() : basetype() {} // expected-error{{initializer 'basetype' does not name a non-static data member or base class; did you mean the base class 'BaseType'?}} +}; + +// Test the improvement from passing a callback object to CorrectTypo in +// the helper function LookupMemberExprInRecord. +int get_type(struct Derived *st) { + return st->Base_Type; // expected-error{{no member named 'Base_Type' in 'Derived'; did you mean 'base_type'?}} +} + +// In this example, somename should not be corrected to the cached correction +// "some_name" since "some_name" is a class and a namespace name is needed. +class some_name {}; // expected-note {{'some_name' declared here}} +somename Foo; // expected-error {{unknown type name 'somename'; did you mean 'some_name'?}} +namespace SomeName {} // expected-note {{namespace 'SomeName' defined here}} +using namespace somename; // expected-error {{no namespace named 'somename'; did you mean 'SomeName'?}} + + +// Without the callback object, CorrectTypo would choose "field1" as the +// correction for "fielda" as it is closer than "FieldA", but that correction +// would be later discarded by the caller and no suggestion would be given. +struct st { + struct { + int field1; + }; + double FieldA; // expected-note{{'FieldA' declared here}} +}; +st var = { .fielda = 0.0 }; // expected-error{{field designator 'fielda' does not refer to any field in type 'st'; did you mean 'FieldA'?}} + +// Test the improvement from passing a callback object to CorrectTypo in +// Sema::BuildCXXNestedNameSpecifier. And also for the improvement by doing +// so in Sema::getTypeName. +typedef char* another_str; // expected-note{{'another_str' declared here}} +namespace AnotherStd { // expected-note{{'AnotherStd' declared here}} + class string {}; +} +another_std::string str; // expected-error{{use of undeclared identifier 'another_std'; did you mean 'AnotherStd'?}} +another_str *cstr = new AnotherStr; // expected-error{{unknown type name 'AnotherStr'; did you mean 'another_str'?}} + +// Test the improvement from passing a callback object to CorrectTypo in +// Sema::ActOnSizeofParameterPackExpr. +char* TireNames; +template<typename ...TypeNames> struct count { // expected-note{{parameter pack 'TypeNames' declared here}} + static const unsigned value = sizeof...(TyreNames); // expected-error{{'TyreNames' does not refer to the name of a parameter pack; did you mean 'TypeNames'?}} +}; + +// Test the typo-correction callback in Sema::DiagnoseUnknownTypeName. +namespace unknown_type_test { + class StreamOut {}; // expected-note 2 {{'StreamOut' declared here}} + long stream_count; // expected-note 2 {{'stream_count' declared here}} +}; +unknown_type_test::stream_out out; // expected-error{{no type named 'stream_out' in namespace 'unknown_type_test'; did you mean 'StreamOut'?}} + +// Demonstrate a case where using only the cached value returns the wrong thing +// when the cached value was the result of a previous callback object that only +// accepts a subset of the current callback object. +namespace { +using namespace unknown_type_test; +void bar(long i); +void before_caching_classname() { + bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}} +} +stream_out out; // expected-error{{unknown type name 'stream_out'; did you mean 'StreamOut'?}} +void after_caching_classname() { + bar((stream_out)); // expected-error{{use of undeclared identifier 'stream_out'; did you mean 'stream_count'?}} +} +} + +// Test the typo-correction callback in Sema::DiagnoseInvalidRedeclaration. +struct BaseDecl { + void add_in(int i); +}; +struct TestRedecl : public BaseDecl { + void add_it(int i); // expected-note{{'add_it' declared here}} +}; +void TestRedecl::add_in(int i) {} // expected-error{{out-of-line definition of 'add_in' does not match any declaration in 'TestRedecl'; did you mean 'add_it'?}} + +// Test the improved typo correction for the Parser::ParseCastExpr => +// Sema::ActOnIdExpression => Sema::DiagnoseEmptyLookup call path. +class SomeNetMessage; +class Message {}; +void foo(Message&); +void foo(SomeNetMessage&); +void doit(void *data) { + Message somenetmsg; // expected-note{{'somenetmsg' declared here}} + foo(somenetmessage); // expected-error{{use of undeclared identifier 'somenetmessage'; did you mean 'somenetmsg'?}} + foo((somenetmessage)data); // expected-error{{use of undeclared identifier 'somenetmessage'; did you mean 'SomeNetMessage'?}} +} + +// Test the typo-correction callback in BuildRecoveryCallExpr. +// Solves the main issue in PR 9320 of suggesting corrections that take the +// wrong number of arguments. +void revoke(const char*); // expected-note 2{{'revoke' declared here}} +void Test() { + Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}} + Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}} + Invoke("foo", "bar"); // expected-error{{use of undeclared identifier 'Invoke'}} +} +void Test2(void (*invoke)(const char *, int)) { // expected-note{{'invoke' declared here}} + Invoke(); // expected-error{{use of undeclared identifier 'Invoke'}} + Invoke("foo"); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'revoke'?}} + Invoke("foo", 7); // expected-error{{use of undeclared identifier 'Invoke'; did you mean 'invoke'?}} + Invoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Invoke'}} +} + +void provoke(const char *x, bool y=false) {} // expected-note 2{{'provoke' declared here}} +void Test3() { + Provoke(); // expected-error{{use of undeclared identifier 'Provoke'}} + Provoke("foo"); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}} + Provoke("foo", true); // expected-error{{use of undeclared identifier 'Provoke'; did you mean 'provoke'?}} + Provoke("foo", 7, 22); // expected-error{{use of undeclared identifier 'Provoke'}} +} + +// PR 11737 - Don't try to typo-correct the implicit 'begin' and 'end' in a +// C++11 for-range statement. +struct R {}; +bool begun(R); +void RangeTest() { + for (auto b : R()) {} // expected-error {{use of undeclared identifier 'begin'}} expected-note {{range has type}} +} + +// PR 12019 - Avoid infinite mutual recursion in DiagnoseInvalidRedeclaration +// by not trying to typo-correct a method redeclaration to declarations not +// in the current record. +class Parent { + void set_types(int index, int value); + void add_types(int value); +}; +class Child: public Parent {}; +void Child::add_types(int value) {} // expected-error{{out-of-line definition of 'add_types' does not match any declaration in 'Child'}} + +// Fix the callback based filtering of typo corrections within +// Sema::ActOnIdExpression by Parser::ParseCastExpression to allow type names as +// potential corrections for template arguments. +namespace clash { +class ConstructExpr {}; // expected-note{{'clash::ConstructExpr' declared here}} +} +class ClashTool { + bool HaveConstructExpr(); + template <class T> T* getExprAs(); + + void test() { + ConstructExpr *expr = // expected-error{{unknown type name 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}} + getExprAs<ConstructExpr>(); // expected-error{{use of undeclared identifier 'ConstructExpr'; did you mean 'clash::ConstructExpr'?}} + } +}; + +namespace test1 { + struct S { + struct Foobar *f; // expected-note{{'Foobar' declared here}} + }; + test1::FooBar *b; // expected-error{{no type named 'FooBar' in namespace 'test1'; did you mean 'Foobar'?}} +} diff --git a/clang/test/SemaCXX/unary-real-imag.cpp b/clang/test/SemaCXX/unary-real-imag.cpp new file mode 100644 index 0000000..91b63e3 --- /dev/null +++ b/clang/test/SemaCXX/unary-real-imag.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +struct A {}; +int i = __real__ A(); // expected-error {{invalid type 'A' to __real operator}} +int j = __imag__ A(); // expected-error {{invalid type 'A' to __imag operator}} + diff --git a/clang/test/SemaCXX/undefined-internal.cpp b/clang/test/SemaCXX/undefined-internal.cpp new file mode 100644 index 0000000..1541720 --- /dev/null +++ b/clang/test/SemaCXX/undefined-internal.cpp @@ -0,0 +1,183 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// Make sure we don't produce invalid IR. +// RUN: %clang_cc1 -emit-llvm-only %s + +namespace test1 { + static void foo(); // expected-warning {{function 'test1::foo' has internal linkage but is not defined}} + template <class T> static void bar(); // expected-warning {{function 'test1::bar<int>' has internal linkage but is not defined}} + + void test() { + foo(); // expected-note {{used here}} + bar<int>(); // expected-note {{used here}} + } +} + +namespace test2 { + namespace { + void foo(); // expected-warning {{function 'test2::<anonymous namespace>::foo' has internal linkage but is not defined}} + extern int var; // expected-warning {{variable 'test2::<anonymous namespace>::var' has internal linkage but is not defined}} + template <class T> void bar(); // expected-warning {{function 'test2::<anonymous namespace>::bar<int>' has internal linkage but is not defined}} + } + void test() { + foo(); // expected-note {{used here}} + var = 0; // expected-note {{used here}} + bar<int>(); // expected-note {{used here}} + } +} + +namespace test3 { + namespace { + void foo(); + extern int var; + template <class T> void bar(); + } + + void test() { + foo(); + var = 0; + bar<int>(); + } + + namespace { + void foo() {} + int var = 0; + template <class T> void bar() {} + } +} + +namespace test4 { + namespace { + struct A { + A(); // expected-warning {{function 'test4::<anonymous namespace>::A::A' has internal linkage but is not defined}} + ~A();// expected-warning {{function 'test4::<anonymous namespace>::A::~A' has internal linkage but is not defined}} + virtual void foo(); // expected-warning {{function 'test4::<anonymous namespace>::A::foo' has internal linkage but is not defined}} + virtual void bar() = 0; + virtual void baz(); // expected-warning {{function 'test4::<anonymous namespace>::A::baz' has internal linkage but is not defined}} + }; + } + + void test(A &a) { + a.foo(); // expected-note {{used here}} + a.bar(); + a.baz(); // expected-note {{used here}} + } + + struct Test : A { + Test() {} // expected-note 2 {{used here}} + }; +} + +// rdar://problem/9014651 +namespace test5 { + namespace { + struct A {}; + } + + template <class N> struct B { + static int var; // expected-warning {{variable 'test5::B<test5::<anonymous>::A>::var' has internal linkage but is not defined}} + static void foo(); // expected-warning {{function 'test5::B<test5::<anonymous>::A>::foo' has internal linkage but is not defined}} + }; + + void test() { + B<A>::var = 0; // expected-note {{used here}} + B<A>::foo(); // expected-note {{used here}} + } +} + +namespace test6 { + template <class T> struct A { + static const int zero = 0; + static const int one = 1; + static const int two = 2; + + int value; + + A() : value(zero) { + value = one; + } + }; + + namespace { struct Internal; } + + void test() { + A<Internal> a; + a.value = A<Internal>::two; + } +} + +// We support (as an extension) private, undefined copy constructors when +// a temporary is bound to a reference even in C++98. Similarly, we shouldn't +// warn about this copy constructor being used without a definition. +namespace PR9323 { + namespace { + struct Uncopyable { + Uncopyable() {} + private: + Uncopyable(const Uncopyable&); // expected-note {{declared private here}} + }; + } + void f(const Uncopyable&) {} + void test() { + f(Uncopyable()); // expected-warning {{C++98 requires an accessible copy constructor}} + }; +} + + +namespace std { class type_info; }; +namespace cxx11_odr_rules { + // Note: the way this test is written isn't really ideal, but there really + // isn't any other way to check that the odr-used logic for constants + // is working without working implicit capture in lambda-expressions. + // (The more accurate used-but-not-defined warning is the only other visible + // effect of accurate odr-used computation.) + // + // Note that the warning in question can trigger in cases some people would + // consider false positives; hopefully that happens rarely in practice. + // + // FIXME: Suppressing this test while I figure out how to fix a bug in the + // odr-use marking code. + + namespace { + struct A { + static const int unused = 10; + static const int used1 = 20; // xpected-warning {{internal linkage}} + static const int used2 = 20; // xpected-warning {{internal linkage}} + virtual ~A() {} + }; + } + + void a(int,int); + A& p(const int&) { static A a; return a; } + + // Check handling of default arguments + void b(int = A::unused); + + void tests() { + // Basic test + a(A::unused, A::unused); + + // Check that nesting an unevaluated or constant-evaluated context does + // the right thing. + a(A::unused, sizeof(int[10])); + + // Check that the checks work with unevaluated contexts + (void)sizeof(p(A::used1)); + (void)typeid(p(A::used1)); // xpected-note {{used here}} + + // Misc other testing + a(A::unused, 1 ? A::used2 : A::used2); // xpected-note {{used here}} + b(); + } +} + + +namespace OverloadUse { + namespace { + void f(); + void f(int); // expected-warning {{function 'OverloadUse::<anonymous namespace>::f' has internal linkage but is not defined}} + } + template<void x()> void t(int*) { x(); } + template<void x(int)> void t(long*) { x(10); } // expected-note {{used here}} + void g() { long a; t<f>(&a); } +} diff --git a/clang/test/SemaCXX/underlying_type.cpp b/clang/test/SemaCXX/underlying_type.cpp new file mode 100644 index 0000000..7bca06b --- /dev/null +++ b/clang/test/SemaCXX/underlying_type.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -std=c++11 %s + +#include "limits.h" + +template<typename T, typename U> +struct is_same_type { + static const bool value = false; +}; +template <typename T> +struct is_same_type<T, T> { + static const bool value = true; +}; + +__underlying_type(int) a; // expected-error {{only enumeration types}} +__underlying_type(struct b) c; // expected-error {{only enumeration types}} + +enum class f : char; +static_assert(is_same_type<char, __underlying_type(f)>::value, + "f has the wrong underlying type"); + +enum g {d = INT_MIN }; +static_assert(is_same_type<int, __underlying_type(g)>::value, + "g has the wrong underlying type"); + +__underlying_type(f) h; +static_assert(is_same_type<char, decltype(h)>::value, + "h has the wrong type"); + +template <typename T> +struct underlying_type { + typedef __underlying_type(T) type; // expected-error {{only enumeration types}} +}; + +static_assert(is_same_type<underlying_type<f>::type, char>::value, + "f has the wrong underlying type in the template"); + +underlying_type<int>::type e; // expected-note {{requested here}} + +using uint = unsigned; +enum class foo : uint { bar }; + +static_assert(is_same_type<underlying_type<foo>::type, unsigned>::value, + "foo has the wrong underlying type"); diff --git a/clang/test/SemaCXX/uninit-variables-conditional.cpp b/clang/test/SemaCXX/uninit-variables-conditional.cpp new file mode 100644 index 0000000..3c44c72 --- /dev/null +++ b/clang/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{{initialize the variable 'x' 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/clang/test/SemaCXX/uninit-variables.cpp b/clang/test/SemaCXX/uninit-variables.cpp new file mode 100644 index 0000000..eb6428d --- /dev/null +++ b/clang/test/SemaCXX/uninit-variables.cpp @@ -0,0 +1,143 @@ +// 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() { + int x; + test1_aux(x); + return x; // no-warning +} + +int test2_aux() { + int x; + int &y = x; + 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{{initialize the variable 'a' to silence this warning}} + (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(); +unsigned test3() { + unsigned x = 0; + const bool flag = true; + if (flag && (x = test3_aux()) == 0) { + return x; + } + return x; +} +unsigned test3_b() { + unsigned x ; + const bool flag = true; + if (flag && (x = test3_aux()) == 0) { + x = 1; + } + return x; // no-warning +} +unsigned test3_c() { + unsigned x; // expected-note{{initialize the variable 'x' to silence this warning}} + const bool flag = false; + if (flag && (x = test3_aux()) == 0) { + x = 1; + } + return x; // expected-warning{{variable 'x' is uninitialized when used here}} +} + +enum test4_A { + test4_A_a, test_4_A_b +}; +test4_A test4() { + test4_A a; // expected-note{{variable 'a' is declared here}} + return a; // expected-warning{{variable 'a' is uninitialized when used here}} +} + +// Test variables getting invalidated by function calls with reference arguments +// *AND* there are multiple invalidated arguments. +void test5_aux(int &, int &); + +int test5() { + int x, y; + test5_aux(x, y); + return x + y; // no-warning +} + +// 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 + } +} + +// Test handling of "no-op" casts. +void test_noop_cast() +{ + int x = 1; + int y = (int&)x; // no-warning +} + +void test_noop_cast2() { + int x; // expected-note {{initialize the variable 'x' to silence this warning}} + int y = (int&)x; // expected-warning {{uninitialized when used here}} +} + +// Test handling of bit casts. +void test_bitcasts() { + int x = 1; + int y = (float &)x; // no-warning +} + +void test_bitcasts_2() { + int x; // expected-note {{initialize the variable 'x' to silence this warning}} + int y = (float &)x; // expected-warning {{uninitialized when used here}} +} + diff --git a/clang/test/SemaCXX/uninitialized.cpp b/clang/test/SemaCXX/uninitialized.cpp new file mode 100644 index 0000000..7879e7c --- /dev/null +++ b/clang/test/SemaCXX/uninitialized.cpp @@ -0,0 +1,169 @@ +// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -std=c++11 -verify %s + +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); + + +// Test self-references with record types. +class A { + // Non-POD class. + public: + enum count { ONE, TWO, THREE }; + int num; + static int count; + int get() const { return num; } + int get2() { return num; } + void set(int x) { num = x; } + static int zero() { return 0; } + + A() {} + A(A const &a) {} + A(int x) {} + A(int *x) {} + A(A *a) {} + ~A(); +}; + +A getA() { return A(); } +A getA(int x) { return A(); } +A getA(A* a) { return A(); } + +void setupA() { + A a1; + a1.set(a1.get()); + A a2(a1.get()); + A a3(a1); + A a4(&a4); + A a5(a5.zero()); + A a6(a6.ONE); + A a7 = getA(); + A a8 = getA(a8.TWO); + A a9 = getA(&a9); + A a10(a10.count); + + A a11(a11); // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}} + A a12(a12.get()); // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}} + A a13(a13.num); // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}} + A a14 = A(a14); // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}} + A a15 = getA(a15.num); // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}} + A a16(&a16.num); // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}} + A a17(a17.get2()); // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}} +} + +struct B { + // POD struct. + int x; + int *y; +}; + +B getB() { return B(); }; +B getB(int x) { return B(); }; +B getB(int *x) { return B(); }; +B getB(B *b) { return B(); }; + +void setupB() { + B b1; + B b2(b1); + B b3 = { 5, &b3.x }; + B b4 = getB(); + B b5 = getB(&b5); + B b6 = getB(&b6.x); + + // Silence unused warning + (void) b2; + (void) b4; + + B b7(b7); // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}} + B b8 = getB(b8.x); // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}} + B b9 = getB(b9.y); // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}} +} + +// 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)) {} +}; + +struct C { char a[100], *e; } car = { .e = car.a }; + +// <rdar://problem/10398199> +namespace rdar10398199 { + class FooBase { protected: ~FooBase() {} }; + class Foo : public FooBase { + public: + operator int&() const; + }; + void stuff(); + template <typename T> class FooImpl : public Foo { + T val; + public: + FooImpl(const T &x) : val(x) {} + ~FooImpl() { stuff(); } + }; + + template <typename T> FooImpl<T> makeFoo(const T& x) { + return FooImpl<T>(x); + } + + void test() { + const Foo &x = makeFoo(42); + const int&y = makeFoo(42u); + (void)x; + (void)y; + }; +} + +// PR 12325 - this was a false uninitialized value warning due to +// a broken CFG. +int pr12325(int params) { + int x = ({ + while (false) + ; + int _v = params; + if (false) + ; + _v; // no-warning + }); + return x; +} + +// Test lambda expressions with -Wuninitialized +int test_lambda() { + auto f1 = [] (int x, int y) { int z; return x + y + z; }; // expected-warning {{C++11 requires lambda with omitted result type to consist of a single return statement}} expected-warning{{variable 'z' is uninitialized when used here}} expected-note {{initialize the variable 'z' to silence this warning}} + return f1(1, 2); +} diff --git a/clang/test/SemaCXX/unknown-anytype-blocks.cpp b/clang/test/SemaCXX/unknown-anytype-blocks.cpp new file mode 100644 index 0000000..86ce7e1 --- /dev/null +++ b/clang/test/SemaCXX/unknown-anytype-blocks.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -funknown-anytype -fblocks -fsyntax-only -verify -std=c++11 %s + +namespace test1 { + __unknown_anytype (^foo)(); + __unknown_anytype (^bar)(); + int test() { + auto ret1 = (int)foo(); + auto ret2 = bar(); // expected-error {{'bar' has unknown return type; cast the call to its declared return type}} + return ret1; + } +} diff --git a/clang/test/SemaCXX/unknown-anytype.cpp b/clang/test/SemaCXX/unknown-anytype.cpp new file mode 100644 index 0000000..a07ec83 --- /dev/null +++ b/clang/test/SemaCXX/unknown-anytype.cpp @@ -0,0 +1,47 @@ +// 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 {{'foo' has unknown type}} + int y = 0 + foo; // expected-error {{'foo' has unknown type}} + return foo; // expected-error {{'foo' has unknown type}} + } +} + +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}} + } +} + +// rdar://problem/9899447 +namespace test4 { + extern __unknown_anytype test0(...); + extern __unknown_anytype test1(...); + + void test() { + void (*fn)(int) = (void(*)(int)) test0; + int x = (int) test1; // expected-error {{function 'test1' with unknown type must be given a function type}} + } +} diff --git a/clang/test/SemaCXX/unknown-type-name.cpp b/clang/test/SemaCXX/unknown-type-name.cpp new file mode 100644 index 0000000..5f8d8ca --- /dev/null +++ b/clang/test/SemaCXX/unknown-type-name.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// PR3990 +namespace N { + struct Wibble { + }; + + typedef Wibble foo; +} +using namespace N; + +foo::bar x; // expected-error{{no type named 'bar' in 'N::Wibble'}} + +void f() { + foo::bar = 4; // expected-error{{no member named 'bar' in 'N::Wibble'}} +} + +template<typename T> +struct A { + typedef T type; + + type f(); +}; + +template<typename T> +A<T>::type g(T t) { return t; } // expected-error{{missing 'typename'}} + +template<typename T> +A<T>::type A<T>::f() { return type(); } // expected-error{{missing 'typename'}} diff --git a/clang/test/SemaCXX/unreachable-catch-clauses.cpp b/clang/test/SemaCXX/unreachable-catch-clauses.cpp new file mode 100644 index 0000000..c75067f --- /dev/null +++ b/clang/test/SemaCXX/unreachable-catch-clauses.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s + +class BaseEx {}; +class Ex1: public BaseEx {}; +typedef Ex1 Ex2; + +void f(); + +void test() +try {} +catch (BaseEx &e) { f(); } +catch (Ex1 &e) { f(); } // expected-note {{for type class Ex1 &}} +catch (Ex2 &e) { f(); } // expected-warning {{exception of type Ex2 & will be caught by earlier handler}} + diff --git a/clang/test/SemaCXX/unreachable-code.cpp b/clang/test/SemaCXX/unreachable-code.cpp new file mode 100644 index 0000000..743290e --- /dev/null +++ b/clang/test/SemaCXX/unreachable-code.cpp @@ -0,0 +1,58 @@ +// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -Wunreachable-code -fblocks -verify %s + +int j; +void bar() { } +int test1() { + for (int i = 0; + i != 10; + ++i) { // expected-warning {{will never be executed}} + if (j == 23) // missing {}'s + bar(); + return 1; + } + return 0; + return 1; // expected-warning {{will never be executed}} +} + +void test2(int i) { + switch (i) { + case 0: + break; + bar(); // expected-warning {{will never be executed}} + case 2: + switch (i) { + default: + a: goto a; + } + bar(); // expected-warning {{will never be executed}} + } + b: goto b; + bar(); // expected-warning {{will never be executed}} +} + +void test3() { + ^{ return; + bar(); // expected-warning {{will never be executed}} + }(); + while (++j) { + continue; + bar(); // expected-warning {{will never be executed}} + } +} + +// PR 6130 - Don't warn about bogus unreachable code with throw's and +// temporary objects. +class PR6130 { +public: + PR6130(); + ~PR6130(); +}; + +int pr6130(unsigned i) { + switch(i) { + case 0: return 1; + case 1: return 2; + default: + throw PR6130(); // no-warning + } +} diff --git a/clang/test/SemaCXX/unused-functions.cpp b/clang/test/SemaCXX/unused-functions.cpp new file mode 100644 index 0000000..3598082 --- /dev/null +++ b/clang/test/SemaCXX/unused-functions.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused -verify %s + +static int foo(int x) { return x; } + +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/clang/test/SemaCXX/unused-with-error.cpp b/clang/test/SemaCXX/unused-with-error.cpp new file mode 100644 index 0000000..5660007 --- /dev/null +++ b/clang/test/SemaCXX/unused-with-error.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused -verify %s + +// Make sure 'unused' warnings are disabled when errors occurred. +static void foo(int *X) { // expected-note {{candidate}} +} +void bar(const int *Y) { + foo(Y); // expected-error {{no matching function for call}} +} diff --git a/clang/test/SemaCXX/unused.cpp b/clang/test/SemaCXX/unused.cpp new file mode 100644 index 0000000..88783ce --- /dev/null +++ b/clang/test/SemaCXX/unused.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR4103 : Make sure we don't get a bogus unused expression warning +class APInt { + char foo; +}; +class APSInt : public APInt { + char bar; +public: + APSInt &operator=(const APSInt &RHS); +}; + +APSInt& APSInt::operator=(const APSInt &RHS) { + APInt::operator=(RHS); + return *this; +} + +template<typename T> +struct X { + X(); +}; + +void test() { + X<int>(); +} diff --git a/clang/test/SemaCXX/user-defined-conversions.cpp b/clang/test/SemaCXX/user-defined-conversions.cpp new file mode 100644 index 0000000..43ec5a3 --- /dev/null +++ b/clang/test/SemaCXX/user-defined-conversions.cpp @@ -0,0 +1,99 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct X { + operator bool(); +}; + +int& f(bool); +float& f(int); + +void f_test(X x) { + int& i1 = f(x); +} + +struct Y { + operator short(); + operator float(); +}; + +void g(int); + +void g_test(Y y) { + g(y); + short s; + s = y; +} + +struct A { }; +struct B : A { }; + +struct C { + operator B&(); +}; + +// Test reference binding via an lvalue conversion function. +void h(volatile A&); +void h_test(C c) { + h(c); +} + +// Test conversion followed by copy-construction +struct FunkyDerived; + +struct Base { + Base(const FunkyDerived&); +}; + +struct Derived : Base { }; + +struct FunkyDerived : Base { }; + +struct ConvertibleToBase { + operator Base(); +}; + +struct ConvertibleToDerived { + operator Derived(); +}; + +struct ConvertibleToFunkyDerived { + operator FunkyDerived(); +}; + +void test_conversion(ConvertibleToBase ctb, ConvertibleToDerived ctd, + ConvertibleToFunkyDerived ctfd) { + Base b1 = ctb; + Base b2(ctb); + Base b3 = ctd; + Base b4(ctd); + Base b5 = ctfd; +} + +struct X1 { + X1(X1&); // expected-note{{candidate constructor not viable: no known conversion from 'X1' to 'X1 &' for 1st argument}} +}; + +struct X2 { + operator X1(); +}; + +int &f(X1); +float &f(...); + +void g(X2 b) { + int &ir = f(b); // expected-error{{no viable constructor copying parameter of type 'X1'}} +} + +namespace rdar10202900 { + class A { + public: + A(); + + private: + A(int i); // expected-note{{declared private here}} + }; + + void testA(A a) { + int b = 10; + a = b; // expected-error{{calling a private constructor of class 'rdar10202900::A'}} + } +} diff --git a/clang/test/SemaCXX/using-decl-1.cpp b/clang/test/SemaCXX/using-decl-1.cpp new file mode 100644 index 0000000..ebe97f6 --- /dev/null +++ b/clang/test/SemaCXX/using-decl-1.cpp @@ -0,0 +1,120 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +extern "C" { void f(bool); } + +namespace std { + using ::f; + inline void f() { return f(true); } +} + +namespace M { + void f(float); +} + +namespace N { + using M::f; + void f(int) { } // expected-note{{previous}} + + void f(int) { } // expected-error{{redefinition}} +} + +namespace N { + void f(double); + void f(long); +} + +struct X0 { + void operator()(int); + void operator()(long); +}; + +struct X1 : X0 { + // FIXME: give this operator() a 'float' parameter to test overloading + // behavior. It currently fails. + void operator()(); + using X0::operator(); + + void test() { + (*this)(1); + } +}; + +struct A { void f(); }; +struct B : A { }; +class C : B { using B::f; }; + +// PR5751: Resolve overloaded functions through using decls. +namespace O { + void f(int i); + void f(double d); +} +namespace P { + void f(); + void g(void (*ptr)(int)); + using O::f; + void test() { + f(); + f(1); + void (*f_ptr1)(double) = f; + void (*f_ptr2)() = f; + g(f); + } +} + +// Make sure that ADL can find names brought in by using decls. +namespace test0 { + namespace ns { + class Foo {}; + + namespace inner { + void foo(char *); // expected-note {{no known conversion}} + } + + using inner::foo; + } + + void test(ns::Foo *p) { + foo(*p); // expected-error {{no matching function for call to 'foo'}} + } +} + +// Redeclarations! +namespace test1 { + namespace ns0 { struct Foo {}; } + namespace A { void foo(ns0::Foo *p, int y, int z); } + namespace ns2 { using A::foo; } + namespace ns1 { struct Bar : ns0::Foo {}; } + namespace A { void foo(ns0::Foo *p, int y, int z = 0); } // expected-note {{candidate}} + namespace ns1 { using A::foo; } + namespace ns2 { struct Baz : ns1::Bar {}; } + namespace A { void foo(ns0::Foo *p, int y = 0, int z); } + + void test(ns2::Baz *p) { + foo(p, 0, 0); // okay! + foo(p, 0); // should be fine! + foo(p); // expected-error {{no matching function}} + } +} + +namespace test2 { + namespace ns { int foo; } + template <class T> using ns::foo; // expected-error {{cannot template a using declaration}} + + // PR8022 + struct A { + template <typename T> void f(T); + }; + class B : A { + template <typename T> using A::f<T>; // expected-error {{cannot template a using declaration}} + }; +} + +// PR8756 +namespace foo +{ + class Class1; // expected-note{{forward declaration}} + class Class2 + { + using ::foo::Class1::Function; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}} + }; +} diff --git a/clang/test/SemaCXX/using-decl-pr4441.cpp b/clang/test/SemaCXX/using-decl-pr4441.cpp new file mode 100644 index 0000000..39a446f --- /dev/null +++ b/clang/test/SemaCXX/using-decl-pr4441.cpp @@ -0,0 +1,8 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace A { + struct B { }; + void operator+(B,B); +} + +using A::operator+; diff --git a/clang/test/SemaCXX/using-decl-pr4450.cpp b/clang/test/SemaCXX/using-decl-pr4450.cpp new file mode 100644 index 0000000..4f929ad --- /dev/null +++ b/clang/test/SemaCXX/using-decl-pr4450.cpp @@ -0,0 +1,15 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace A { + void g(); +} + +namespace X { + using A::g; +} + +void h() +{ + A::g(); + X::g(); +} diff --git a/clang/test/SemaCXX/using-decl-templates.cpp b/clang/test/SemaCXX/using-decl-templates.cpp new file mode 100644 index 0000000..2f8abca --- /dev/null +++ b/clang/test/SemaCXX/using-decl-templates.cpp @@ -0,0 +1,82 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +template<typename T> struct A { + void f() { } + struct N { }; // expected-note{{target of using declaration}} +}; + +template<typename T> struct B : A<T> { + using A<T>::f; + using A<T>::N; // expected-error{{dependent using declaration resolved to type without 'typename'}} + + using A<T>::foo; // expected-error{{no member named 'foo'}} + using A<double>::f; // expected-error{{using declaration refers into 'A<double>::', which is not a base class of 'B<int>'}} +}; + +B<int> a; // expected-note{{in instantiation of template class 'B<int>' requested here}} + +template<typename T> struct C : A<T> { + using A<T>::f; + + void f() { }; +}; + +template <typename T> struct D : A<T> { + using A<T>::f; + + void f(); +}; + +template<typename T> void D<T>::f() { } + +template<typename T> struct E : A<T> { + using A<T>::f; + + void g() { f(); } +}; + +namespace test0 { + struct Base { + int foo; + }; + template<typename T> struct E : Base { + using Base::foo; + }; + + template struct E<int>; +} + +// PR7896 +namespace PR7896 { +template <class T> struct Foo { + int k (float); +}; +struct Baz { + int k (int); +}; +template <class T> struct Bar : public Foo<T>, Baz { + using Foo<T>::k; + using Baz::k; + int foo() { + return k (1.0f); + } +}; +template int Bar<int>::foo(); +} + +// PR10883 +namespace PR10883 { + template <typename T> + class Base { + public: + typedef long Container; + }; + + template <typename T> + class Derived : public Base<T> { + public: + using Base<T>::Container; + + void foo(const Container& current); // expected-error {{unknown type name 'Container'}} + }; +} diff --git a/clang/test/SemaCXX/using-directive.cpp b/clang/test/SemaCXX/using-directive.cpp new file mode 100644 index 0000000..22c6e14 --- /dev/null +++ b/clang/test/SemaCXX/using-directive.cpp @@ -0,0 +1,135 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace A { + short i; // expected-note 2{{candidate found by name lookup is 'A::i'}} + namespace B { + long i; // expected-note{{candidate found by name lookup is 'A::B::i'}} + void f() {} // expected-note{{candidate function}} + int k; + namespace E {} // \ + expected-note{{candidate found by name lookup is 'A::B::E'}} + } + + namespace E {} // expected-note{{candidate found by name lookup is 'A::E'}} + + namespace C { + using namespace B; + namespace E {} // \ + expected-note{{candidate found by name lookup is 'A::C::E'}} + } + + void f() {} // expected-note{{candidate function}} + + class K1 { + void foo(); + }; + + void local_i() { + char i; + using namespace A; + using namespace B; + int a[sizeof(i) == sizeof(char)? 1 : -1]; // okay + } + namespace B { + int j; + } + + void ambig_i() { + using namespace A; + using namespace A::B; + (void) i; // expected-error{{reference to 'i' is ambiguous}} + f(); // expected-error{{call to 'f' is ambiguous}} + (void) j; // okay + using namespace C; + (void) k; // okay + using namespace E; // expected-error{{reference to 'E' is ambiguous}} + } + + struct K2 {}; // expected-note 2{{candidate found by name lookup is 'A::K2'}} +} + +struct K2 {}; // expected-note 2{{candidate found by name lookup is 'K2'}} + +using namespace A; + +void K1::foo() {} // okay + +struct K2 *k2; // expected-error{{reference to 'K2' is ambiguous}} + +K2 *k3; // expected-error{{reference to 'K2' is ambiguous}} + +class X { // expected-note{{candidate found by name lookup is 'X'}} + // FIXME: produce a suitable error message for this + using namespace A; // expected-error{{not allowed}} +}; + +namespace N { + struct K2; + struct K2 { }; +} + +namespace Ni { + int i(); // expected-note{{candidate found by name lookup is 'Ni::i'}} +} + +namespace NiTest { + using namespace A; + using namespace Ni; + + int test() { + return i; // expected-error{{reference to 'i' is ambiguous}} + } +} + +namespace OneTag { + struct X; // expected-note{{candidate found by name lookup is 'OneTag::X'}} +} + +namespace OneFunction { + void X(); // expected-note{{candidate found by name lookup is 'OneFunction::X'}} +} + +namespace TwoTag { + struct X; // expected-note{{candidate found by name lookup is 'TwoTag::X'}} +} + +namespace FuncHidesTagAmbiguity { + using namespace OneTag; + using namespace OneFunction; + using namespace TwoTag; + + void test() { + (void)X(); // expected-error{{reference to 'X' is ambiguous}} + } +} + +// PR5479 +namespace Aliased { + void inAliased(); +} +namespace Alias = Aliased; +using namespace Alias; +void testAlias() { + inAliased(); +} + +namespace N { void f2(int); } + +extern "C++" { + using namespace N; + void f3() { f2(1); } +} + +void f4() { f2(1); } + +// PR7517 +using namespace std; // expected-warning{{using directive refers to implicitly-defined namespace 'std'}} +using namespace ::std; // expected-warning{{using directive refers to implicitly-defined namespace 'std'}} + +namespace test1 { + namespace ns { typedef int test1; } + template <class T> using namespace ns; // expected-error {{cannot template a using directive}} + + // Test that we recovered okay. + test1 x; +} diff --git a/clang/test/SemaCXX/value-dependent-exprs.cpp b/clang/test/SemaCXX/value-dependent-exprs.cpp new file mode 100644 index 0000000..2017ffa --- /dev/null +++ b/clang/test/SemaCXX/value-dependent-exprs.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -verify %s + +template <unsigned I> +class C0 { + static const int iv0 = 1 << I; + + enum { + A = I, + B = I + 1 + }; + + struct s0 { + int a : I; + int b[I]; + }; + + // FIXME: I'm unclear where the right place to handle this is. +#if 0 + void f0(int *p) { + if (p == I) { + } + } +#endif + +#if 0 + // FIXME: Not sure whether we care about these. + void f1(int *a) + __attribute__((nonnull(1 + I))) + __attribute__((constructor(1 + I))) + __attribute__((destructor(1 + I))) + __attribute__((sentinel(1 + I, 2 + I))), + __attribute__((reqd_work_group_size(1 + I, 2 + I, 3 + I))), + __attribute__((format_arg(1 + I))), + __attribute__((aligned(1 + I))), + __attribute__((regparm(1 + I))); + + typedef int int_a0 __attribute__((address_space(1 + B))); +#endif + +#if 0 + // FIXME: This doesn't work. PR4996. + int f2() { + return __builtin_choose_expr(I, 1, 2); + } +#endif + +}; diff --git a/clang/test/SemaCXX/value-initialization.cpp b/clang/test/SemaCXX/value-initialization.cpp new file mode 100644 index 0000000..4e3acbb --- /dev/null +++ b/clang/test/SemaCXX/value-initialization.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 + +struct A { // expected-warning {{does not declare any constructor to initialize}} + const int i; // expected-note{{const member 'i' will never be initialized}} expected-note {{implicitly deleted}} + virtual void f() { } +}; + +int main () { + (void)A(); // expected-error {{call to implicitly-deleted default constructor}} +} diff --git a/clang/test/SemaCXX/vararg-default-arg.cpp b/clang/test/SemaCXX/vararg-default-arg.cpp new file mode 100644 index 0000000..3c8e41c --- /dev/null +++ b/clang/test/SemaCXX/vararg-default-arg.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 %s -verify -fsyntax-only +// PR5462 + +void f1(void); +void f2(const char * = __null, ...); + +void f1(void) +{ + f2(); +} diff --git a/clang/test/SemaCXX/vararg-non-pod.cpp b/clang/test/SemaCXX/vararg-non-pod.cpp new file mode 100644 index 0000000..86b560e --- /dev/null +++ b/clang/test/SemaCXX/vararg-non-pod.cpp @@ -0,0 +1,125 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-error=non-pod-varargs + +extern char version[]; + +class C { +public: + C(int); + void g(int a, ...); + static void h(int a, ...); +}; + +void g(int a, ...); + +void t1() +{ + C c(10); + + g(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}} + g(10, version); +} + +void t2() +{ + C c(10); + + c.g(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}} + c.g(10, version); + + C::h(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}} + C::h(10, version); +} + +int (^block)(int, ...); + +void t3() +{ + C c(10); + + block(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}} + block(10, version); +} + +class D { +public: + void operator() (int a, ...); +}; + +void t4() +{ + C c(10); + + D d; + + d(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}} + d(10, version); +} + +class E { + E(int, ...); // expected-note 2{{implicitly declared private here}} +}; + +void t5() +{ + C c(10); + + E e(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \ + // expected-error{{calling a private constructor of class 'E'}} + (void)E(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \ + // expected-error{{calling a private constructor of class 'E'}} + +} + +// PR5761: unevaluated operands and the non-POD warning +class Foo { + public: + Foo() {} +}; + +int Helper(...); +const int size = sizeof(Helper(Foo())); + +namespace std { + class type_info { }; +} + +struct Base { virtual ~Base(); }; +Base &get_base(...); +int eat_base(...); + +void test_typeid(Base &base) { + (void)typeid(get_base(base)); // expected-warning{{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}} + (void)typeid(eat_base(base)); // okay +} + + +// rdar://7985267 - Shouldn't warn, doesn't actually use __builtin_va_start is +// magic. + +void t6(Foo somearg, ... ) { + __builtin_va_list list; + __builtin_va_start(list, somearg); +} + +void t7(int n, ...) { + __builtin_va_list list; + __builtin_va_start(list, n); + (void)__builtin_va_arg(list, C); // expected-warning{{second argument to 'va_arg' is of non-POD type 'C'}} + __builtin_va_end(list); +} + +struct Abstract { + virtual void doit() = 0; // expected-note{{unimplemented pure virtual method}} +}; + +void t8(int n, ...) { + __builtin_va_list list; + __builtin_va_start(list, n); + (void)__builtin_va_arg(list, Abstract); // expected-error{{second argument to 'va_arg' is of abstract type 'Abstract'}} + __builtin_va_end(list); +} + +int t9(int n) { + // Make sure the error works in potentially-evaluated sizeof + return (int)sizeof(*(Helper(Foo()), (int (*)[n])0)); // expected-warning{{cannot pass object of non-POD type}} +} diff --git a/clang/test/SemaCXX/vector-casts.cpp b/clang/test/SemaCXX/vector-casts.cpp new file mode 100644 index 0000000..681a07e --- /dev/null +++ b/clang/test/SemaCXX/vector-casts.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +typedef int __v2si __attribute__((__vector_size__(8))); +typedef short __v4hi __attribute__((__vector_size__(8))); +typedef short __v8hi __attribute__((__vector_size__(16))); + +struct S { }; // expected-note 2 {{candidate constructor}} + +void f() { + __v2si v2si; + __v4hi v4hi; + __v8hi v8hi; + unsigned long long ll; + unsigned char c; + S s; + + (void)reinterpret_cast<__v2si>(v4hi); + (void)(__v2si)v4hi; + (void)reinterpret_cast<__v4hi>(v2si); + (void)(__v4hi)v2si; + (void)reinterpret_cast<unsigned long long>(v2si); + (void)(unsigned long long)v2si; + (void)reinterpret_cast<__v2si>(ll); + (void)(__v2si)(ll); + + (void)reinterpret_cast<S>(v2si); // expected-error {{reinterpret_cast from '__v2si' to 'S' is not allowed}} + (void)(S)v2si; // expected-error {{no matching conversion for C-style cast from '__v2si' to 'S'}} + (void)reinterpret_cast<__v2si>(s); // expected-error {{reinterpret_cast from 'S' to '__v2si' is not allowed}} + (void)(__v2si)s; // expected-error {{cannot convert 'S' to '__v2si' without a conversion operator}} + + (void)reinterpret_cast<unsigned char>(v2si); // expected-error {{reinterpret_cast from vector '__v2si' to scalar 'unsigned char' of different size}} + (void)(unsigned char)v2si; // expected-error {{C-style cast from vector '__v2si' to scalar 'unsigned char' of different size}} + (void)reinterpret_cast<__v2si>(c); // expected-error {{reinterpret_cast from scalar 'unsigned char' to vector '__v2si' of different size}} + + (void)reinterpret_cast<__v8hi>(v4hi); // expected-error {{reinterpret_cast from vector '__v4hi' to vector '__v8hi' of different size}} + (void)(__v8hi)v4hi; // expected-error {{C-style cast from vector '__v4hi' to vector '__v8hi' of different size}} + (void)reinterpret_cast<__v4hi>(v8hi); // expected-error {{reinterpret_cast from vector '__v8hi' to vector '__v4hi' of different size}} + (void)(__v4hi)v8hi; // expected-error {{C-style cast from vector '__v8hi' to vector '__v4hi' of different size}} +} + + diff --git a/clang/test/SemaCXX/vector-no-lax.cpp b/clang/test/SemaCXX/vector-no-lax.cpp new file mode 100644 index 0000000..32dcacf --- /dev/null +++ b/clang/test/SemaCXX/vector-no-lax.cpp @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -fno-lax-vector-conversions -verify %s +typedef unsigned int __attribute__((vector_size (16))) vUInt32; +typedef int __attribute__((vector_size (16))) vSInt32; + +vSInt32 foo (vUInt32 a) { + vSInt32 b = { 0, 0, 0, 0 }; + b += a; // expected-error{{can't convert between vector values}} + return b; +} diff --git a/clang/test/SemaCXX/vector.cpp b/clang/test/SemaCXX/vector.cpp new file mode 100644 index 0000000..82245ac --- /dev/null +++ b/clang/test/SemaCXX/vector.cpp @@ -0,0 +1,269 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify %s +typedef char char16 __attribute__ ((__vector_size__ (16))); +typedef long long longlong16 __attribute__ ((__vector_size__ (16))); +typedef char char16_e __attribute__ ((__ext_vector_type__ (16))); +typedef long long longlong16_e __attribute__ ((__ext_vector_type__ (2))); + +// Test overloading and function calls with vector types. +void f0(char16); + +void f0_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { + f0(c16); + f0(ll16); + f0(c16e); + f0(ll16e); +} + +int &f1(char16); // expected-note 2{{candidate function}} +float &f1(longlong16); // expected-note 2{{candidate function}} + +void f1_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { + int &ir1 = f1(c16); + float &fr1 = f1(ll16); + f1(c16e); // expected-error{{call to 'f1' is ambiguous}} + f1(ll16e); // expected-error{{call to 'f1' is ambiguous}} +} + +void f2(char16_e); // expected-note{{no known conversion from 'longlong16_e' to 'char16_e' for 1st argument}} \ + // expected-note{{candidate function not viable: no known conversion from 'convertible_to<longlong16_e>' to 'char16_e' for 1st argument}} + +void f2_test(char16 c16, longlong16 ll16, char16_e c16e, longlong16_e ll16e) { + f2(c16); + f2(ll16); + f2(c16e); + f2(ll16e); // expected-error{{no matching function}} + f2('a'); + f2(17); +} + +// Test the conditional operator with vector types. +void conditional(bool Cond, char16 c16, longlong16 ll16, char16_e c16e, + longlong16_e ll16e) { + // Conditional operators with the same type. + __typeof__(Cond? c16 : c16) *c16p1 = &c16; + __typeof__(Cond? ll16 : ll16) *ll16p1 = &ll16; + __typeof__(Cond? c16e : c16e) *c16ep1 = &c16e; + __typeof__(Cond? ll16e : ll16e) *ll16ep1 = &ll16e; + + // Conditional operators with similar types. + __typeof__(Cond? c16 : c16e) *c16ep2 = &c16e; + __typeof__(Cond? c16e : c16) *c16ep3 = &c16e; + __typeof__(Cond? ll16 : ll16e) *ll16ep2 = &ll16e; + __typeof__(Cond? ll16e : ll16) *ll16ep3 = &ll16e; + + // Conditional operators with compatible types under -flax-vector-conversions (default) + (void)(Cond? c16 : ll16); + (void)(Cond? ll16e : c16e); + (void)(Cond? ll16e : c16); +} + +// Test C++ cast'ing of vector types. +void casts(longlong16 ll16, longlong16_e ll16e) { + // C-style casts. + (void)(char16)ll16; + (void)(char16_e)ll16; + (void)(longlong16)ll16; + (void)(longlong16_e)ll16; + (void)(char16)ll16e; + (void)(char16_e)ll16e; + (void)(longlong16)ll16e; + (void)(longlong16_e)ll16e; + + // Function-style casts. + (void)char16(ll16); + (void)char16_e(ll16); + (void)longlong16(ll16); + (void)longlong16_e(ll16); + (void)char16(ll16e); + (void)char16_e(ll16e); + (void)longlong16(ll16e); + (void)longlong16_e(ll16e); + + // static_cast + (void)static_cast<char16>(ll16); + (void)static_cast<char16_e>(ll16); + (void)static_cast<longlong16>(ll16); + (void)static_cast<longlong16_e>(ll16); + (void)static_cast<char16>(ll16e); + (void)static_cast<char16_e>(ll16e); // expected-error{{static_cast from 'longlong16_e' to 'char16_e' is not allowed}} + (void)static_cast<longlong16>(ll16e); + (void)static_cast<longlong16_e>(ll16e); + + // reinterpret_cast + (void)reinterpret_cast<char16>(ll16); + (void)reinterpret_cast<char16_e>(ll16); + (void)reinterpret_cast<longlong16>(ll16); + (void)reinterpret_cast<longlong16_e>(ll16); + (void)reinterpret_cast<char16>(ll16e); + (void)reinterpret_cast<char16_e>(ll16e); + (void)reinterpret_cast<longlong16>(ll16e); + (void)reinterpret_cast<longlong16_e>(ll16e); +} + +template<typename T> +struct convertible_to { // expected-note 3 {{candidate function (the implicit copy assignment operator)}} + operator T() const; +}; + +void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16, + char16_e c16e, longlong16_e ll16e, + convertible_to<char16> to_c16, + convertible_to<longlong16> to_ll16, + convertible_to<char16_e> to_c16e, + convertible_to<longlong16_e> to_ll16e, + convertible_to<char16&> rto_c16, + convertible_to<char16_e&> rto_c16e) { + f0(to_c16); + f0(to_ll16); + f0(to_c16e); + f0(to_ll16e); + f2(to_c16); + f2(to_ll16); + f2(to_c16e); + f2(to_ll16e); // expected-error{{no matching function}} + + (void)(c16 == c16e); + (void)(c16 == to_c16); + (void)+to_c16; + (void)-to_c16; + (void)~to_c16; + (void)(to_c16 == to_c16e); + (void)(to_c16 != to_c16e); + (void)(to_c16 < to_c16e); + (void)(to_c16 <= to_c16e); + (void)(to_c16 > to_c16e); + (void)(to_c16 >= to_c16e); + (void)(to_c16 + to_c16); + (void)(to_c16 - to_c16); + (void)(to_c16 * to_c16); + (void)(to_c16 / to_c16); + (void)(rto_c16 = to_c16); // expected-error{{no viable overloaded '='}} + (void)(rto_c16 += to_c16); + (void)(rto_c16 -= to_c16); + (void)(rto_c16 *= to_c16); + (void)(rto_c16 /= to_c16); + + (void)+to_c16e; + (void)-to_c16e; + (void)~to_c16e; + (void)(to_c16e == to_c16e); + (void)(to_c16e != to_c16e); + (void)(to_c16e < to_c16e); + (void)(to_c16e <= to_c16e); + (void)(to_c16e > to_c16e); + (void)(to_c16e >= to_c16e); + (void)(to_c16e + to_c16); + (void)(to_c16e - to_c16); + (void)(to_c16e * to_c16); + (void)(to_c16e / to_c16); + (void)(rto_c16e = to_c16); // expected-error{{no viable overloaded '='}} + (void)(rto_c16e += to_c16); + (void)(rto_c16e -= to_c16); + (void)(rto_c16e *= to_c16); + (void)(rto_c16e /= to_c16); + + (void)+to_c16; + (void)-to_c16; + (void)~to_c16; + (void)(to_c16 == to_c16e); + (void)(to_c16 != to_c16e); + (void)(to_c16 < to_c16e); + (void)(to_c16 <= to_c16e); + (void)(to_c16 > to_c16e); + (void)(to_c16 >= to_c16e); + (void)(to_c16 + to_c16e); + (void)(to_c16 - to_c16e); + (void)(to_c16 * to_c16e); + (void)(to_c16 / to_c16e); + (void)(rto_c16 = c16e); // expected-error{{no viable overloaded '='}} + (void)(rto_c16 += to_c16e); + (void)(rto_c16 -= to_c16e); + (void)(rto_c16 *= to_c16e); + (void)(rto_c16 /= to_c16e); + + (void)(Cond? to_c16 : to_c16e); + (void)(Cond? to_ll16e : to_ll16); + + // These 2 are convertable with -flax-vector-conversions (default) + (void)(Cond? to_c16 : to_ll16); + (void)(Cond? to_c16e : to_ll16e); +} + +typedef float fltx2 __attribute__((__vector_size__(8))); +typedef float fltx4 __attribute__((__vector_size__(16))); +typedef double dblx2 __attribute__((__vector_size__(16))); +typedef double dblx4 __attribute__((__vector_size__(32))); + +void accept_fltx2(fltx2); // expected-note{{candidate function not viable: no known conversion from 'double' to 'fltx2' for 1st argument}} +void accept_fltx4(fltx4); +void accept_dblx2(dblx2); +void accept_dblx4(dblx4); +void accept_bool(bool); // expected-note{{candidate function not viable: no known conversion from 'fltx2' to 'bool' for 1st argument}} + +void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) { + // Exact matches + accept_fltx2(fltx2_val); + accept_fltx4(fltx4_val); + accept_dblx2(dblx2_val); + accept_dblx4(dblx4_val); + + // Same-size conversions + // FIXME: G++ rejects these conversions, we accept them. Revisit this! + accept_fltx4(dblx2_val); + accept_dblx2(fltx4_val); + + // Conversion to bool. + accept_bool(fltx2_val); // expected-error{{no matching function for call to 'accept_bool'}} + + // Scalar-to-vector conversions. + accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}} +} + +typedef int intx4 __attribute__((__vector_size__(16))); +typedef int inte4 __attribute__((__ext_vector_type__(4))); +typedef int flte4 __attribute__((__ext_vector_type__(4))); + +void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, flte4 m) { + (void)(f == g); + (void)(g != f); + (void)(f <= g); + (void)(g >= f); + (void)(f < g); + (void)(g > f); + + (void)(+g); + (void)(-g); + + (void)(f + g); + (void)(f - g); + (void)(f * g); + (void)(f / g); + (void)(f = g); + (void)(f += g); + (void)(f -= g); + (void)(f *= g); + (void)(f /= g); + + + (void)(n == m); + (void)(m != n); + (void)(n <= m); + (void)(m >= n); + (void)(n < m); + (void)(m > n); + + (void)(+m); + (void)(-m); + (void)(~m); + + (void)(n + m); + (void)(n - m); + (void)(n * m); + (void)(n / m); + (void)(n % m); + (void)(n = m); + (void)(n += m); + (void)(n -= m); + (void)(n *= m); + (void)(n /= m); +} diff --git a/clang/test/SemaCXX/virtual-base-used.cpp b/clang/test/SemaCXX/virtual-base-used.cpp new file mode 100644 index 0000000..d147b13 --- /dev/null +++ b/clang/test/SemaCXX/virtual-base-used.cpp @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +// PR7800 + +class NoDestroy { ~NoDestroy(); }; // expected-note 3 {{declared private here}} +struct A { + virtual ~A(); +}; + +struct B : public virtual A { + NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}} +}; +struct D : public virtual B { + virtual void foo(); + ~D(); +}; +void D::foo() { // expected-note {{implicit default destructor for 'B' first required here}} +} + +struct E : public virtual A { + NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}} +}; +struct F : public E { // expected-note {{implicit default destructor for 'E' first required here}} +}; +struct G : public virtual F { + virtual void foo(); + ~G(); +}; +void G::foo() { // expected-note {{implicit default destructor for 'F' first required here}} +} + +struct H : public virtual A { + NoDestroy x; // expected-error {{field of type 'NoDestroy' has private destructor}} +}; +struct I : public virtual H { + ~I(); +}; +struct J : public I { + virtual void foo(); + ~J(); +}; +void J::foo() { // expected-note {{implicit default destructor for 'H' first required here}} +} diff --git a/clang/test/SemaCXX/virtual-member-functions-key-function.cpp b/clang/test/SemaCXX/virtual-member-functions-key-function.cpp new file mode 100644 index 0000000..09a30b9 --- /dev/null +++ b/clang/test/SemaCXX/virtual-member-functions-key-function.cpp @@ -0,0 +1,29 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s +struct A { + virtual ~A(); +}; + +struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}} + B() { } // expected-note {{implicit default destructor for 'B' first required here}} + void operator delete(void *, int); // expected-note {{'operator delete' declared here}} +}; + +struct C : A { // expected-error {{no suitable member 'operator delete' in 'C'}} + void operator delete(void *, int); // expected-note {{'operator delete' declared here}} +}; + +void f() { + (void)new B; + (void)new C; // expected-note {{implicit default destructor for 'C' first required here}} +} + +// Make sure that the key-function computation is consistent when the +// first virtual member function of a nested class has an inline body. +struct Outer { + struct Inner { + virtual void f() { } + void g(); + }; +}; + +void Outer::Inner::g() { } diff --git a/clang/test/SemaCXX/virtual-override.cpp b/clang/test/SemaCXX/virtual-override.cpp new file mode 100644 index 0000000..b477438 --- /dev/null +++ b/clang/test/SemaCXX/virtual-override.cpp @@ -0,0 +1,290 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 +namespace T1 { + +class A { + virtual int f(); // expected-note{{overridden virtual function is here}} +}; + +class B : A { + virtual void f(); // expected-error{{virtual function 'f' has a different return type ('void') than the function it overrides (which has return type 'int')}} +}; + +} + +namespace T2 { + +struct a { }; +struct b { }; + +class A { + virtual a* f(); // expected-note{{overridden virtual function is here}} +}; + +class B : A { + virtual b* f(); // expected-error{{return type of virtual function 'f' is not covariant with the return type of the function it overrides ('T2::b *' is not derived from 'T2::a *')}} +}; + +} + +namespace T3 { + +struct a { }; +struct b : private a { }; // expected-note{{declared private here}} + +class A { + virtual a* f(); // FIXME: desired-note{{overridden virtual function is here}} +}; + +class B : A { + virtual b* f(); // expected-error{{invalid covariant return for virtual function: 'T3::a' is a private base class of 'T3::b'}} +}; + +} + +namespace T4 { + +struct a { }; +struct a1 : a { }; +struct b : a, a1 { }; + +class A { + virtual a* f(); // expected-note{{overridden virtual function is here}} +}; + +class B : A { + virtual b* f(); // expected-error{{return type of virtual function 'f' is not covariant with the return type of the function it overrides (ambiguous conversion from derived class 'T4::b' to base class 'T4::a':\n\ + struct T4::b -> struct T4::a\n\ + struct T4::b -> struct T4::a1 -> struct T4::a)}} +}; + +} + +namespace T5 { + +struct a { }; + +class A { + virtual a* const f(); + virtual a* const g(); // expected-note{{overridden virtual function is here}} +}; + +class B : A { + virtual a* const f(); + virtual a* g(); // expected-error{{return type of virtual function 'g' is not covariant with the return type of the function it overrides ('T5::a *' has different qualifiers than 'T5::a *const')}} +}; + +} + +namespace T6 { + +struct a { }; + +class A { + virtual const a* f(); + virtual a* g(); // expected-note{{overridden virtual function is here}} +}; + +class B : A { + virtual a* f(); + virtual const a* g(); // expected-error{{return type of virtual function 'g' is not covariant with the return type of the function it overrides (class type 'const T6::a *' is more qualified than class type 'T6::a *'}} +}; + +} + +namespace T7 { + struct a { }; + struct b { }; + + class A { + a* f(); + }; + + class B : A { + virtual b* f(); + }; +} + +namespace T8 { + struct a { }; + struct b; // expected-note {{forward declaration of 'T8::b'}} + + class A { + virtual a *f(); + }; + + class B : A { + b* f(); // expected-error {{return type of virtual function 'f' is not covariant with the return type of the function it overrides ('T8::b' is incomplete)}} + }; +} + +namespace T9 { + struct a { }; + + template<typename T> struct b : a { + int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}} + }; + + class A { + virtual a *f(); + }; + + class B : A { + virtual b<int> *f(); // expected-note {{in instantiation of template class 'T9::b<int>' requested here}} + }; +} + +// PR5656 +class X0 { + virtual void f0(); +}; +class X1 : public X0 { + void f0() = 0; +}; + +template <typename Base> +struct Foo : Base { + void f(int) = 0; // expected-error{{not virtual and cannot be declared pure}} +}; + +struct Base1 { virtual void f(int); }; +struct Base2 { }; + +void test() { + (void)sizeof(Foo<Base1>); + (void)sizeof(Foo<Base2>); // expected-note{{instantiation}} +} + +template<typename Base> +struct Foo2 : Base { + template<typename T> int f(T); +}; + +void test2() { + Foo2<Base1> f1; + Foo2<Base2> f2; + f1.f(17); + f2.f(17); +}; + +struct Foo3 { + virtual void f(int) = 0; // expected-note{{unimplemented pure virtual method}} +}; + +template<typename T> +struct Bar3 : Foo3 { + void f(T); +}; + +void test3() { + Bar3<int> b3i; // okay + Bar3<float> b3f; // expected-error{{is an abstract class}} +} + +// 5920 +namespace PR5920 { + class Base {}; + + template <typename T> + class Derived : public Base {}; + + class Foo { + public: + virtual Base* Method(); + }; + + class Bar : public Foo { + public: + virtual Derived<int>* Method(); + }; +} + +// Look through template types and typedefs to see whether return types are +// pointers or references. +namespace PR6110 { + class Base {}; + class Derived : public Base {}; + + typedef Base* BaseP; + typedef Derived* DerivedP; + + class X { virtual BaseP f(); }; + class X1 : public X { virtual DerivedP f(); }; + + template <typename T> class Y { virtual T f(); }; + template <typename T1, typename T> class Y1 : public Y<T> { virtual T1 f(); }; + Y1<Derived*, Base*> y; +} + +// Defer checking for covariance if either return type is dependent. +namespace type_dependent_covariance { + struct B {}; + template <int N> struct TD : public B {}; + template <> struct TD<1> {}; + + template <int N> struct TB {}; + struct D : public TB<0> {}; + + template <int N> struct X { + virtual B* f1(); // expected-note{{overridden virtual function is here}} + virtual TB<N>* f2(); // expected-note{{overridden virtual function is here}} + }; + template <int N, int M> struct X1 : X<N> { + virtual TD<M>* f1(); // expected-error{{return type of virtual function 'f1' is not covariant with the return type of the function it overrides ('TD<1> *'}} + virtual D* f2(); // expected-error{{return type of virtual function 'f2' is not covariant with the return type of the function it overrides ('type_dependent_covariance::D *' is not derived from 'TB<1> *')}} + }; + + X1<0, 0> good; + X1<0, 1> bad_derived; // expected-note{{instantiation}} + X1<1, 0> bad_base; // expected-note{{instantiation}} +} + +namespace T10 { + struct A { }; + struct B : A { }; + + struct C { + virtual A&& f(); + }; + + struct D : C { + virtual B&& f(); + }; +}; + +namespace T11 { + struct A { }; + struct B : A { }; + + struct C { + virtual A& f(); // expected-note {{overridden virtual function is here}} + }; + + struct D : C { + virtual B&& f(); // expected-error {{virtual function 'f' has a different return type ('T11::B &&') than the function it overrides (which has return type 'T11::A &')}} + }; +}; + +namespace T12 { + struct A { }; + struct B : A { }; + + struct C { + virtual A&& f(); // expected-note {{overridden virtual function is here}} + }; + + struct D : C { + virtual B& f(); // expected-error {{virtual function 'f' has a different return type ('T12::B &') than the function it overrides (which has return type 'T12::A &&')}} + }; +}; + +namespace PR8168 { + class A { + public: + virtual void foo() {} // expected-note{{overridden virtual function is here}} + }; + + class B : public A { + public: + static void foo() {} // expected-error{{'static' member function 'foo' overrides a virtual function}} + }; +} diff --git a/clang/test/SemaCXX/virtuals.cpp b/clang/test/SemaCXX/virtuals.cpp new file mode 100644 index 0000000..ea7d203 --- /dev/null +++ b/clang/test/SemaCXX/virtuals.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 %s + +class A { + virtual void f(); + virtual void g() = 0; // expected-note{{unimplemented pure virtual method 'g' in 'A'}} + + void h() = 0; // expected-error {{'h' is not virtual and cannot be declared pure}} + void i() = 1; // expected-error {{initializer on function does not look like a pure-specifier}} + void j() = 0u; // expected-error {{initializer on function does not look like a pure-specifier}} + + + void k(); + +public: + A(int); +}; + +virtual void A::k() { } // expected-error{{'virtual' can only be specified inside the class definition}} + +class B : public A { + // Needs to recognize that overridden function is virtual. + void g() = 0; + + // Needs to recognize that function does not override. + void g(int) = 0; // expected-error{{'g' is not virtual and cannot be declared pure}} +}; + +// Needs to recognize invalid uses of abstract classes. +A fn(A) // expected-error{{parameter type 'A' is an abstract class}} \ + // expected-error{{return type 'A' is an abstract class}} +{ + A a; // expected-error{{variable type 'A' is an abstract class}} + (void)static_cast<A>(0); + try { + } catch(A) { // expected-error{{variable type 'A' is an abstract class}} + } +} + +namespace rdar9670557 { + typedef int func(int); + func *a(); + struct X { + virtual func f = 0; + virtual func (g) = 0; + func *h = 0; + }; +} diff --git a/clang/test/SemaCXX/vla.cpp b/clang/test/SemaCXX/vla.cpp new file mode 100644 index 0000000..d63b633 --- /dev/null +++ b/clang/test/SemaCXX/vla.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -verify %s + +// PR11925 +int n; +int (&f())[n]; // expected-error {{function declaration cannot have variably modified type}} diff --git a/clang/test/SemaCXX/vtable-instantiation.cc b/clang/test/SemaCXX/vtable-instantiation.cc new file mode 100644 index 0000000..2a1b989 --- /dev/null +++ b/clang/test/SemaCXX/vtable-instantiation.cc @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +namespace PR8640 { + template<class T1> struct C1 { + virtual void c1() { + T1 t1 = 3; // expected-error {{cannot initialize a variable}} + } + }; + + template<class T2> struct C2 { + void c2() { + new C1<T2>(); // expected-note {{in instantiation of member function}} + } + }; + + void f() { + C2<int*> c2; + 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; + } +} + +namespace PR10020 { + struct MG { + virtual void Accept(int) = 0; + }; + + template <typename Type> + struct GMG : MG { + void Accept(int i) { + static_cast<Type *>(0)->Accept(i); // expected-error{{member reference base}} + } + static GMG* Method() { return &singleton; } // expected-note{{in instantiation of}} + static GMG singleton; + }; + + template <typename Type> + GMG<Type> GMG<Type>::singleton; + + void test(void) { + GMG<int>::Method(); // expected-note{{in instantiation of}} + } +} diff --git a/clang/test/SemaCXX/warn-assignment-condition.cpp b/clang/test/SemaCXX/warn-assignment-condition.cpp new file mode 100644 index 0000000..04f2e79 --- /dev/null +++ b/clang/test/SemaCXX/warn-assignment-condition.cpp @@ -0,0 +1,146 @@ +// RUN: %clang_cc1 -fsyntax-only -Wparentheses -verify %s + +struct A { + int foo(); + friend A operator+(const A&, const A&); + A operator|=(const A&); + operator bool(); +}; + +void test() { + int x, *p; + A a, b; + + // With scalars. + if (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + if ((x = 7)) {} + do { + } while (x = 7); // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + do { + } while ((x = 7)); + while (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + + while ((x = 7)) {} + for (; x = 7; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + for (; (x = 7); ) {} + + if (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + if ((p = p)) {} + do { + } while (p = p); // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + do { + } while ((p = p)); + while (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + while ((p = p)) {} + for (; p = p; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + for (; (p = p); ) {} + + // Initializing variables (shouldn't warn). + if (int y = x) {} + while (int y = x) {} + if (A y = a) {} + while (A y = a) {} + + // With temporaries. + if (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + if ((x = (b+b).foo())) {} + do { + } while (x = (b+b).foo()); // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + do { + } while ((x = (b+b).foo())); + while (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + while ((x = (b+b).foo())) {} + for (; x = (b+b).foo(); ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + for (; (x = (b+b).foo()); ) {} + + // With a user-defined operator. + if (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + if ((a = b + b)) {} + do { + } while (a = b + b); // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + do { + } while ((a = b + b)); + while (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + while ((a = b + b)) {} + for (; a = b + b; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '==' to turn this assignment into an equality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + for (; (a = b + b); ) {} + + // Compound assignments. + if (x |= 2) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '!=' to turn this compound assignment into an inequality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + + if (a |= b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \ + // expected-note{{use '!=' to turn this compound assignment into an inequality comparison}} \ + // expected-note{{place parentheses around the assignment to silence this warning}} + + if ((x == 5)) {} // 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}} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wparentheses-equality" + if ((x == 5)) {} // no-warning +#pragma clang diagnostic pop + + if ((5 == x)) {} + +#define EQ(x,y) ((x) == (y)) + if (EQ(x, 5)) {} +#undef EQ +} + +void (*fn)(); + +void test2() { + if ((fn == test2)) {} // 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}} + 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/clang/test/SemaCXX/warn-bad-memaccess.cpp b/clang/test/SemaCXX/warn-bad-memaccess.cpp new file mode 100644 index 0000000..3a02c84 --- /dev/null +++ b/clang/test/SemaCXX/warn-bad-memaccess.cpp @@ -0,0 +1,117 @@ +// RUN: %clang_cc1 -fsyntax-only -Wdynamic-class-memaccess -verify %s + +extern "C" void *memset(void *, int, unsigned); +extern "C" void *memmove(void *s1, const void *s2, unsigned n); +extern "C" void *memcpy(void *s1, const void *s2, unsigned n); +extern "C" void *memcmp(void *s1, const void *s2, unsigned n); + +// Several 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; + +class C1 { + int x, y, z; +public: + void foo() {} +} c1; + +struct X1 { virtual void f(); } x1; +struct X2 : virtual S1 {} x2; + +void test_warn() { + memset(&x1, 0, sizeof x1); // \ + // expected-warning {{destination for this 'memset' call is a pointer to dynamic class}} \ + // 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 dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + + memmove(&x1, 0, sizeof x1); // \ + // expected-warning{{destination for this 'memmove' call is a pointer to dynamic class 'struct X1'; vtable pointer will be overwritten}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memmove(0, &x1, sizeof x1); // \ + // expected-warning{{source of this 'memmove' call is a pointer to dynamic class 'struct X1'; vtable pointer will be moved}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memcpy(&x1, 0, sizeof x1); // \ + // expected-warning{{destination for this 'memcpy' call is a pointer to dynamic class 'struct X1'; vtable pointer will be overwritten}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memcpy(0, &x1, sizeof x1); // \ + // expected-warning{{source of this 'memcpy' call is a pointer to dynamic class 'struct X1'; vtable pointer will be copied}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memcmp(&x1, 0, sizeof x1); // \ + // expected-warning{{first operand of this 'memcmp' call is a pointer to dynamic class 'struct X1'; vtable pointer will be compared}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + memcmp(0, &x1, sizeof x1); // \ + // expected-warning{{second operand of this 'memcmp' call is a pointer to dynamic class 'struct X1'; vtable pointer will be compared}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + + __builtin_memset(&x1, 0, sizeof x1); // \ + // expected-warning {{destination for this '__builtin_memset' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin_memset(&x2, 0, sizeof x2); // \ + // expected-warning {{destination for this '__builtin_memset' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + + __builtin_memmove(&x1, 0, sizeof x1); // \ + // expected-warning{{destination for this '__builtin_memmove' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin_memmove(0, &x1, sizeof x1); // \ + // expected-warning{{source of this '__builtin_memmove' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin_memcpy(&x1, 0, sizeof x1); // \ + // expected-warning{{destination for this '__builtin_memcpy' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin_memcpy(0, &x1, sizeof x1); // \ + // expected-warning{{source of this '__builtin_memcpy' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + + __builtin___memset_chk(&x1, 0, sizeof x1, sizeof x1); // \ + // expected-warning {{destination for this '__builtin___memset_chk' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin___memset_chk(&x2, 0, sizeof x2, sizeof x2); // \ + // expected-warning {{destination for this '__builtin___memset_chk' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + + __builtin___memmove_chk(&x1, 0, sizeof x1, sizeof x1); // \ + // expected-warning{{destination for this '__builtin___memmove_chk' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin___memmove_chk(0, &x1, sizeof x1, sizeof x1); // \ + // expected-warning{{source of this '__builtin___memmove_chk' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin___memcpy_chk(&x1, 0, sizeof x1, sizeof x1); // \ + // expected-warning{{destination for this '__builtin___memcpy_chk' call is a pointer to dynamic class}} \ + // expected-note {{explicitly cast the pointer to silence this warning}} + __builtin___memcpy_chk(0, &x1, sizeof x1, sizeof x1); // \ + // expected-warning{{source of this '__builtin___memcpy_chk' call is a pointer to dynamic class}} \ + // 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); +} + +namespace N { + void *memset(void *, int, unsigned); + void test_nowarn() { + N::memset(&x1, 0, sizeof x1); + } +} diff --git a/clang/test/SemaCXX/warn-bool-conversion.cpp b/clang/test/SemaCXX/warn-bool-conversion.cpp new file mode 100644 index 0000000..b3d136e --- /dev/null +++ b/clang/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/clang/test/SemaCXX/warn-cast-align.cpp b/clang/test/SemaCXX/warn-cast-align.cpp new file mode 100644 index 0000000..68acbdd --- /dev/null +++ b/clang/test/SemaCXX/warn-cast-align.cpp @@ -0,0 +1,45 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -Wcast-align -verify %s + +// Simple casts. +void test0(char *P) { + char *a; short *b; int *c; + + a = (char*) P; + a = static_cast<char*>(P); + a = reinterpret_cast<char*>(P); + typedef char *CharPtr; + a = CharPtr(P); + + b = (short*) P; // expected-warning {{cast from 'char *' to 'short *' increases required alignment from 1 to 2}} + b = reinterpret_cast<short*>(P); + typedef short *ShortPtr; + b = ShortPtr(P); // expected-warning {{cast from 'char *' to 'ShortPtr' (aka 'short *') increases required alignment from 1 to 2}} + + c = (int*) P; // expected-warning {{cast from 'char *' to 'int *' increases required alignment from 1 to 4}} + c = reinterpret_cast<int*>(P); + typedef int *IntPtr; + c = IntPtr(P); // expected-warning {{cast from 'char *' to 'IntPtr' (aka 'int *') increases required alignment from 1 to 4}} +} + +// Casts from void* are a special case. +void test1(void *P) { + char *a; short *b; int *c; + + a = (char*) P; + a = static_cast<char*>(P); + a = reinterpret_cast<char*>(P); + typedef char *CharPtr; + a = CharPtr(P); + + b = (short*) P; + b = static_cast<short*>(P); + b = reinterpret_cast<short*>(P); + typedef short *ShortPtr; + b = ShortPtr(P); + + c = (int*) P; + c = static_cast<int*>(P); + c = reinterpret_cast<int*>(P); + typedef int *IntPtr; + c = IntPtr(P); +} diff --git a/clang/test/SemaCXX/warn-char-subscripts.cpp b/clang/test/SemaCXX/warn-char-subscripts.cpp new file mode 100644 index 0000000..84ea536 --- /dev/null +++ b/clang/test/SemaCXX/warn-char-subscripts.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -Wchar-subscripts -fsyntax-only -verify %s + +template<typename T> +void t1() { + int array[1] = { 0 }; + T subscript = 0; + int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}} +} + +template<typename T> +void t2() { + int array[1] = { 0 }; + T subscript = 0; + int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}} +} + +void test() { + t1<char>(); // expected-note {{in instantiation of function template specialization 't1<char>' requested here}} + t2<char>(); // expected-note {{in instantiation of function template specialization 't2<char>' requested here}} +} + diff --git a/clang/test/SemaCXX/warn-dangling-field.cpp b/clang/test/SemaCXX/warn-dangling-field.cpp new file mode 100644 index 0000000..95f8c61 --- /dev/null +++ b/clang/test/SemaCXX/warn-dangling-field.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -fsyntax-only -Wdangling-field -verify %s + +struct X { + X(int); +}; +struct Y { + operator X*(); + operator X&(); +}; + +struct S { + int &x, *y; // expected-note {{reference member declared here}} \ + // expected-note {{pointer member declared here}} + S(int i) + : x(i), // expected-warning {{binding reference member 'x' to stack allocated parameter 'i'}} + y(&i) {} // expected-warning {{initializing pointer member 'y' with the stack address of parameter 'i'}} + S(int &i) : x(i), y(&i) {} // no-warning: reference parameter + S(int *i) : x(*i), y(i) {} // no-warning: pointer parameter +}; + +struct S2 { + const X &x; // expected-note {{reference member declared here}} + S2(int i) : x(i) {} // expected-warning {{binding reference member 'x' to a temporary}} +}; + +struct S3 { + X &x1, *x2; + S3(Y y) : x1(y), x2(y) {} // no-warning: conversion operator +}; + +template <typename T> struct S4 { + T x; // expected-note {{reference member declared here}} + S4(int i) : x(i) {} // expected-warning {{binding reference member 'x' to stack allocated parameter 'i'}} +}; + +template struct S4<int>; // no warning from this instantiation +template struct S4<int&>; // expected-note {{in instantiation}} diff --git a/clang/test/SemaCXX/warn-deprecated-header.cpp b/clang/test/SemaCXX/warn-deprecated-header.cpp new file mode 100644 index 0000000..f6ac2cb --- /dev/null +++ b/clang/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/clang/test/SemaCXX/warn-empty-body.cpp b/clang/test/SemaCXX/warn-empty-body.cpp new file mode 100644 index 0000000..d643ced --- /dev/null +++ b/clang/test/SemaCXX/warn-empty-body.cpp @@ -0,0 +1,271 @@ +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s + +void a(int i); +int b(); +int c(); + +void test1(int x, int y) { + while(true) { + if (x); // expected-warning {{if statement has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + + int i; + // PR11329 + for (i = 0; i < x; i++); { // expected-warning{{for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + b(); + } + + for (i = 0; i < x; i++); // expected-warning{{for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + { + a(i); + } + + for (i = 0; + i < x; + i++); // expected-warning{{for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + { + a(i); + } + + int arr[3] = { 1, 2, 3 }; + for (int j : arr); // expected-warning{{range-based for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + for (int j : + arr); // expected-warning{{range-based for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + while (b() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + while (b() == 0); { // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + } + + while (b() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + { + a(i); + } + + while (b() == 0 || + c() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + { + a(i); + } + + do; // expected-note{{to match this 'do'}} + b(); // expected-error{{expected 'while' in do/while loop}} + while (b()); // no-warning + c(); + + do; // expected-note{{to match this 'do'}} + b(); // expected-error{{expected 'while' in do/while loop}} + while (b()); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + c(); + + switch(x) // no-warning + { + switch(y); // expected-warning{{switch statement has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + { + case 0: + a(10); + break; + default: + a(20); + break; + } + } + } +} + +/// There should be no warning when null statement is placed on its own line. +void test2(int x, int y) { + if (x) // no-warning + ; // no-warning + + int i; + for (i = 0; i < x; i++) // no-warning + ; // no-warning + + for (i = 0; + i < x; + i++) // no-warning + ; // no-warning + + int arr[3] = { 1, 2, 3 }; + for (int j : arr) // no-warning + ; // no-warning + + while (b() == 0) // no-warning + ; // no-warning + + while (b() == 0 || + c() == 0) // no-warning + ; // no-warning + + switch(x) + { + switch(y) // no-warning + ; // no-warning + } + + // Last `for' or `while' statement in compound statement shouldn't warn. + while(b() == 0); // no-warning +} + +/// There should be no warning for a null statement resulting from an empty macro. +#define EMPTY(a) +void test3(int x, int y) { + if (x) EMPTY(x); // no-warning + + int i; + for (i = 0; i < x; i++) EMPTY(i); // no-warning + + for (i = 0; + i < x; + i++) EMPTY(i); // no-warning + + int arr[3] = { 1, 2, 3 }; + for (int j : arr) EMPTY(j); // no-warning + + for (int j : + arr) EMPTY(j); // no-warning + + while (b() == 0) EMPTY(i); // no-warning + + while (b() == 0 || + c() == 0) EMPTY(i); // no-warning + + switch (x) { + switch (y) + EMPTY(i); // no-warning + } +} + +void test4(int x) +{ + // Idiom used in some metaprogramming constructs. + switch (x) default:; // no-warning + + // Frequent idiom used in macros. + do {} while (false); // no-warning +} + +/// There should be no warning for a common for/while idiom when it is obvious +/// from indentation that next statement wasn't meant to be a body. +void test5(int x, int y) { + int i; + for (i = 0; i < x; i++); // expected-warning{{for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + for (i = 0; i < x; i++); // no-warning + a(i); + + for (i = 0; + i < x; + i++); // expected-warning{{for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + for (i = 0; + i < x; + i++); // no-warning + a(i); + + while (b() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + while (b() == 0); // no-warning + a(i); + + while (b() == 0 || + c() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(i); + + while (b() == 0 || + c() == 0); // no-warning + a(i); +} + +/// There should be no warning for a statement with a non-null body. +void test6(int x, int y) { + if (x) {} // no-warning + + if (x) + a(x); // no-warning + + int i; + for (i = 0; i < x; i++) // no-warning + a(i); // no-warning + + for (i = 0; i < x; i++) { // no-warning + a(i); // no-warning + } + + for (i = 0; + i < x; + i++) // no-warning + a(i); // no-warning + + int arr[3] = { 1, 2, 3 }; + for (int j : arr) // no-warning + a(j); + + for (int j : arr) {} // no-warning + + while (b() == 0) // no-warning + a(i); // no-warning + + while (b() == 0) {} // no-warning + + switch(x) // no-warning + { + switch(y) // no-warning + { + case 0: + a(10); + break; + default: + a(20); + break; + } + } +} + +void test_errors(int x) { + if (1) + aa; // expected-error{{use of undeclared identifier}} + // no empty body warning. + + int i; + for (i = 0; i < x; i++) + bb; // expected-error{{use of undeclared identifier}} + + int arr[3] = { 1, 2, 3 }; + for (int j : arr) + cc; // expected-error{{use of undeclared identifier}} + + while (b() == 0) + dd; // expected-error{{use of undeclared identifier}} +} + +// Warnings for statements in templates shouldn't be duplicated for all +// instantiations. +template <typename T> +void test_template(int x) { + if (x); // expected-warning{{if statement has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + + if (x) + EMPTY(x); // no-warning + + int arr[3] = { 1, 2, 3 }; + for (int j : arr); // expected-warning{{range-based for loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + + while (b() == 0); // expected-warning{{while loop has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}} + a(x); +} + +void test_template_inst(int x) { + test_template<int>(x); + test_template<double>(x); +} + diff --git a/clang/test/SemaCXX/warn-enum-compare.cpp b/clang/test/SemaCXX/warn-enum-compare.cpp new file mode 100644 index 0000000..52639e7 --- /dev/null +++ b/clang/test/SemaCXX/warn-enum-compare.cpp @@ -0,0 +1,212 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +enum Foo { FooA, FooB, FooC }; +enum Bar { BarD, BarE, BarF }; +enum { AnonAA = 42, AnonAB = 43 }; +enum { AnonBA = 44, AnonBB = 45 }; + +namespace name1 { + enum Foo {F1, F2, F3}; + enum Baz {B1, B2, B3}; +} + +namespace name2 { + enum Baz {B1, B2, B3}; +} + +using name1::Baz; +using name1::B1; +using name2::B2; +typedef name1::Foo oneFoo; +typedef name1::Foo twoFoo; +Foo getFoo(); +Bar getBar(); + +void test () { + Foo x = FooA; + Bar y = BarD; + Baz z = name1::B3; + name1::Foo a; + oneFoo b; + twoFoo c; + + while (x == FooA); + while (y == BarD); + while (a == name1::F1); + while (z == name1::B2); + while (a == b); + while (a == c); + while (b == c); + while (B1 == name1::B2); + while (B2 == name2::B1); + while (x == AnonAA); + while (AnonBB == y); + while (AnonAA == AnonAB); + while (AnonAB == AnonBA); + while (AnonBB == AnonAA); + + while ((x) == FooA); + while ((y) == BarD); + while ((a) == name1::F1); + while (z == (name1::B2)); + while (a == (b)); + while (a == (c)); + while ((b) == (c)); + while ((B1) == (name1::B2)); + while ((B2) == (name2::B1)); + + while (((x)) == FooA); + while ((y) == (BarD)); + while ((a) == (name1::F1)); + while (z == (name1::B2)); + while ((a) == ((((b))))); + while (((a)) == (c)); + while ((b) == (((c)))); + while ((((((B1))))) == (((name1::B2)))); + while (B2 == ((((((name2::B1))))))); + + while (B1 == B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (name1::B2 == name2::B3); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (z == name2::B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while (((((B1)))) == B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (name1::B2 == (name2::B3)); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (z == ((((name2::B2))))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while ((((B1))) == (((B2)))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while ((name1::B2) == (((name2::B3)))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while ((((z))) == (name2::B2)); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while (x == a); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'name1::Foo')}} + while (x == b); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'oneFoo' (aka 'name1::Foo'))}} + while (x == c); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'twoFoo' (aka 'name1::Foo'))}} + + while (x == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (x == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (x == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + + + while (y == x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (y == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (BarD == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (BarD == x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD != x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD >= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD < x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (y == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (BarD == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (getBar() == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (getBar() == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() < FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (getBar() == x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() != x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() >= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() <= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() > x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() < x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + +} diff --git a/clang/test/SemaCXX/warn-everthing.cpp b/clang/test/SemaCXX/warn-everthing.cpp new file mode 100644 index 0000000..ad3dd8a --- /dev/null +++ b/clang/test/SemaCXX/warn-everthing.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -Weverything -fsyntax-only %s -verify + +// This previously crashed due to a bug in the CFG. Exercising all +// warnings helps check CFG construction. +class PR12271 { +public: + PR12271(); + ~PR12271(); +}; + +void testPR12271() { // expected-warning {{no previous prototype for function 'testPR12271'}} + PR12271 a[1][1]; // expected-warning {{unused variable 'a'}} +} diff --git a/clang/test/SemaCXX/warn-exit-time-destructors.cpp b/clang/test/SemaCXX/warn-exit-time-destructors.cpp new file mode 100644 index 0000000..f49134b --- /dev/null +++ b/clang/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/clang/test/SemaCXX/warn-func-as-bool.cpp b/clang/test/SemaCXX/warn-func-as-bool.cpp new file mode 100644 index 0000000..b5df744 --- /dev/null +++ b/clang/test/SemaCXX/warn-func-as-bool.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -x c++ -verify -fsyntax-only %s + +void f1(); + +struct S { + static void f2(); +}; + +extern void f3() __attribute__((weak_import)); + +struct S2 { + static void f4() __attribute__((weak_import)); +}; + +bool f5(); +bool f6(int); + +void bar() { + bool b; + + b = f1; // expected-warning {{address of function 'f1' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + if (f1) {} // expected-warning {{address of function 'f1' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + b = S::f2; // expected-warning {{address of function 'S::f2' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + if (S::f2) {} // expected-warning {{address of function 'S::f2' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + b = f5; // expected-warning {{address of function 'f5' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} \ + expected-note {{suffix with parentheses to turn this into a function call}} + b = f6; // expected-warning {{address of function 'f6' will always evaluate to 'true'}} \ + expected-note {{prefix with the address-of operator to silence this warning}} + + // implicit casts of weakly imported symbols are ok: + b = f3; + if (f3) {} + b = S2::f4; + if (S2::f4) {} +} diff --git a/clang/test/SemaCXX/warn-global-constructors.cpp b/clang/test/SemaCXX/warn-global-constructors.cpp new file mode 100644 index 0000000..6330958 --- /dev/null +++ b/clang/test/SemaCXX/warn-global-constructors.cpp @@ -0,0 +1,97 @@ +// RUN: %clang_cc1 -fsyntax-only -Wglobal-constructors %s -verify + +int opaque_int(); + +namespace test0 { + // These should never require global constructors. + int a; + int b = 20; + float c = 5.0f; + + // This global constructor is avoidable based on initialization order. + int d = b; // expected-warning {{global constructor}} + + // These global constructors are unavoidable. + int e = opaque_int(); // expected-warning {{global constructor}} + int f = b; // expected-warning {{global constructor}} +} + +namespace test1 { + struct A { int x; }; + A a; + A b = A(); + A c = { 10 }; + A d = { opaque_int() }; // expected-warning {{global constructor}} + A e = A(A()); + A f = A(a); // expected-warning {{global constructor}} + A g(a); // expected-warning {{global constructor}} + A h((A())); // elided + A i((A(A()))); // elided +} + +namespace test2 { + struct A { A(); }; + A a; // expected-warning {{global constructor}} + A b[10]; // expected-warning {{global constructor}} + A c[10][10]; // expected-warning {{global constructor}} + + A &d = a; + A &e = b[5]; + A &f = c[5][7]; +} + +namespace test3 { + struct A { ~A(); }; + A a; // expected-warning {{global destructor}} + A b[10]; // expected-warning {{global destructor}} + A c[10][10]; // expected-warning {{global destructor}} + + A &d = a; + A &e = b[5]; + A &f = c[5][7]; +} + +namespace test4 { + char a[] = "hello"; + char b[6] = "hello"; + char c[][6] = { "hello" }; +} + +namespace test5 { + struct A { A(); }; + + void f1() { + static A a; + } + void f2() { + static A& a = *new A; + } +} + +namespace test6 { + struct A { ~A(); }; + + void f1() { + static A a; + } + void f2() { + static A& a = *new A; + } +} + +namespace pr8095 { + struct Foo { + int x; + Foo(int x1) : x(x1) {} + }; + void foo() { + static Foo a(0); + } + + struct Bar { + ~Bar(); + }; + void bar() { + static Bar b; + } +} diff --git a/clang/test/SemaCXX/warn-large-by-value-copy.cpp b/clang/test/SemaCXX/warn-large-by-value-copy.cpp new file mode 100644 index 0000000..3e419ec --- /dev/null +++ b/clang/test/SemaCXX/warn-large-by-value-copy.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -Wlarge-by-value-copy=100 %s + +// rdar://8548050 +namespace rdar8548050 { + +struct S100 { + char x[100]; +}; + +struct S101 { + char x[101]; +}; + +S100 f100(S100 s) { return s; } + +S101 f101(S101 s) { return s; } // expected-warning {{return value of 'f101' is a large (101 bytes) pass-by-value object}} \ + // expected-warning {{'s' is a large (101 bytes) pass-by-value argument}} + +typedef int Arr[200]; +void farr(Arr a) { } + +struct NonPOD { + char x[200]; + virtual void m(); +}; + +NonPOD fNonPOD(NonPOD s) { return s; } + +template <unsigned size> +struct TS { + char x[size]; +}; + +template <unsigned size> +void tf(TS<size> ts) {} // expected-warning {{ts' is a large (300 bytes) pass-by-value argument}} + +void g() { + TS<300> ts; + tf<300>(ts); // expected-note {{instantiation}} +} + +} + +template<typename T> class DependentPOD { + enum b { x }; + b foo() { return x; } +}; diff --git a/clang/test/SemaCXX/warn-literal-conversion.cpp b/clang/test/SemaCXX/warn-literal-conversion.cpp new file mode 100644 index 0000000..5fcae5d --- /dev/null +++ b/clang/test/SemaCXX/warn-literal-conversion.cpp @@ -0,0 +1,40 @@ +// RUN: %clang_cc1 -fsyntax-only -Wliteral-conversion -verify %s + +void foo(int y); + +// Warn when a literal float or double is assigned or bound to an integer. +void test0() { + // Float + 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 = 12E-1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y4 = 1.23E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + // Double + int y5 = 1.2222; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y6 = 12E-1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y7 = 1.23E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + int y8 = (1.23E1); // expected-warning {{implicit conversion turns literal floating-point number into integer}} + + // Test assignment to an existing variable. + y8 = 2.22F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + + // Test direct initialization. + int y9(1.23F); // expected-warning {{implicit conversion turns literal floating-point number into integer}} + + // Test passing a literal floating-point value to a function that takes an integer. + foo(1.2F); // expected-warning {{implicit conversion turns literal floating-point number into integer}} + + int y10 = -1.2F; // expected-warning {{implicit conversion turns literal floating-point number into integer}} + + // -Wconversion-literal does NOT catch const values. + // (-Wconversion DOES catch them.) + static const float sales_tax_rate = .095F; + int z = sales_tax_rate; + foo(sales_tax_rate); + + // Expressions, such as those that indicate rounding-down, should NOT produce warnings. + int x = 24 * 0.5; + int y = (24*60*60) * 0.25; + int pennies = 123.45 * 100; +} diff --git a/clang/test/SemaCXX/warn-memset-bad-sizeof.cpp b/clang/test/SemaCXX/warn-memset-bad-sizeof.cpp new file mode 100644 index 0000000..e0d28da --- /dev/null +++ b/clang/test/SemaCXX/warn-memset-bad-sizeof.cpp @@ -0,0 +1,145 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-sizeof-array-argument %s +// +extern "C" void *memset(void *, int, unsigned); +extern "C" void *memmove(void *s1, const void *s2, unsigned n); +extern "C" void *memcpy(void *s1, const void *s2, unsigned n); +extern "C" void *memcmp(void *s1, const void *s2, unsigned n); + +struct S {int a, b, c, d;}; +typedef S* PS; + +struct Foo {}; +typedef const Foo& CFooRef; +typedef const Foo CFoo; +typedef volatile Foo VFoo; +typedef const volatile Foo CVFoo; + +typedef double Mat[4][4]; + +template <class Dest, class Source> +inline Dest bit_cast(const Source& source) { + Dest dest; + memcpy(&dest, &source, sizeof(dest)); + return dest; +} + +// http://www.lysator.liu.se/c/c-faq/c-2.html#2-6 +void f(Mat m, const Foo& const_foo, char *buffer) { + S s; + S* ps = &s; + PS ps2 = &s; + char arr[5]; + char* parr[5]; + Foo foo; + char* heap_buffer = new char[42]; + + /* Should warn */ + memset(&s, 0, sizeof(&s)); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same expression as the destination}} + memset(ps, 0, sizeof(ps)); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same expression as the destination}} + memset(ps2, 0, sizeof(ps2)); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same expression as the destination}} + memset(ps2, 0, sizeof(typeof(ps2))); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}} + memset(ps2, 0, sizeof(PS)); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}} + memset(heap_buffer, 0, sizeof(heap_buffer)); // \ + // expected-warning {{argument to 'sizeof' in 'memset' call is the same expression as the destination}} + + memcpy(&s, 0, sizeof(&s)); // \ + // expected-warning {{argument to 'sizeof' in 'memcpy' call is the same expression as the destination}} + memcpy(0, &s, sizeof(&s)); // \ + // expected-warning {{argument to 'sizeof' in 'memcpy' call is the same expression as the source}} + + memmove(ps, 0, sizeof(ps)); // \ + // expected-warning {{argument to 'sizeof' in 'memmove' call is the same expression as the destination}} + memcmp(ps, 0, sizeof(ps)); // \ + // expected-warning {{argument to 'sizeof' in 'memcmp' call is the same expression as the destination}} + + /* Shouldn't warn */ + memset((void*)&s, 0, sizeof(&s)); + memset(&s, 0, sizeof(s)); + memset(&s, 0, sizeof(S)); + memset(&s, 0, sizeof(const S)); + memset(&s, 0, sizeof(volatile S)); + memset(&s, 0, sizeof(volatile const S)); + memset(&foo, 0, sizeof(CFoo)); + memset(&foo, 0, sizeof(VFoo)); + memset(&foo, 0, sizeof(CVFoo)); + memset(ps, 0, sizeof(*ps)); + memset(ps2, 0, sizeof(*ps2)); + memset(ps2, 0, sizeof(typeof(*ps2))); + memset(arr, 0, sizeof(arr)); + memset(parr, 0, sizeof(parr)); + + memcpy(&foo, &const_foo, sizeof(Foo)); + memcpy((void*)&s, 0, sizeof(&s)); + memcpy(0, (void*)&s, sizeof(&s)); + char *cptr; + memcpy(&cptr, buffer, sizeof(cptr)); + memcpy((char*)&cptr, buffer, sizeof(cptr)); + + CFooRef cfoo = foo; + memcpy(&foo, &cfoo, sizeof(Foo)); + + memcpy(0, &arr, sizeof(arr)); + typedef char Buff[8]; + memcpy(0, &arr, sizeof(Buff)); + + unsigned char* puc; + bit_cast<char*>(puc); + + float* pf; + bit_cast<int*>(pf); + + int iarr[14]; + memset(&iarr[0], 0, sizeof iarr); + + int* iparr[14]; + memset(&iparr[0], 0, sizeof iparr); + + memset(m, 0, sizeof(Mat)); + + // Copy to raw buffer shouldn't warn either + memcpy(&foo, &arr, sizeof(Foo)); + memcpy(&arr, &foo, sizeof(Foo)); + + // Shouldn't warn, and shouldn't crash either. + memset(({ + if (0) {} + while (0) {} + for (;;) {} + &s; + }), 0, sizeof(s)); +} + +namespace ns { +void memset(void* s, char c, int n); +void f(int* i) { + memset(i, 0, sizeof(i)); +} +} + +extern "C" int strncmp(const char *s1, const char *s2, unsigned n); +extern "C" int strncasecmp(const char *s1, const char *s2, unsigned n); +extern "C" char *strncpy(char *det, const char *src, unsigned n); +extern "C" char *strncat(char *dst, const char *src, unsigned n); +extern "C" char *strndup(const char *src, unsigned n); + +void strcpy_and_friends() { + const char* FOO = "<- should be an array instead"; + const char* BAR = "<- this, too"; + + strncmp(FOO, BAR, sizeof(FOO)); // \ + // expected-warning {{argument to 'sizeof' in 'strncmp' call is the same expression as the destination}} + strncasecmp(FOO, BAR, sizeof(FOO)); // \ + // expected-warning {{argument to 'sizeof' in 'strncasecmp' call is the same expression as the destination}} + + char buff[80]; + + strncpy(buff, BAR, sizeof(BAR)); // \ + // expected-warning {{argument to 'sizeof' in 'strncpy' call is the same expression as the source}} + strndup(FOO, sizeof(FOO)); // \ + // expected-warning {{argument to 'sizeof' in 'strndup' call is the same expression as the source}} +} diff --git a/clang/test/SemaCXX/warn-missing-noreturn.cpp b/clang/test/SemaCXX/warn-missing-noreturn.cpp new file mode 100644 index 0000000..8072ac6 --- /dev/null +++ b/clang/test/SemaCXX/warn-missing-noreturn.cpp @@ -0,0 +1,125 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -Wmissing-noreturn -Wreturn-type +void f() __attribute__((noreturn)); + +template<typename T> void g(T) { + f(); +} + +template void g<int>(int); + +template<typename T> struct A { + void g() { + f(); + } +}; + +template struct A<int>; + +struct B { + template<typename T> void g(T) { + f(); + } +}; + +template void B::g<int>(int); + +// We don't want a warning here. +struct X { + virtual void g() { f(); } +}; + +namespace test1 { + bool condition(); + + // We don't want a warning here. + void foo() { + while (condition()) {} + } +} + + +// <rdar://problem/7880658> - This test case previously had a false "missing return" +// warning. +struct R7880658 { + R7880658 &operator++(); + bool operator==(const R7880658 &) const; + bool operator!=(const R7880658 &) const; +}; + +void f_R7880658(R7880658 f, R7880658 l) { // no-warning + for (; f != l; ++f) { + } +} + +namespace test2 { + + bool g(); + void *h() __attribute__((noreturn)); + void *j(); + + struct A { + void *f; + + A() : f(0) { } + A(int) : f(h()) { } // expected-warning {{function 'A' could be declared with attribute 'noreturn'}} + A(char) : f(j()) { } + A(bool b) : f(b ? h() : j()) { } + }; +} + +namespace test3 { + struct A { + ~A(); + }; + + struct B { + ~B() { } + + A a; + }; + + struct C : A { + ~C() { } + }; +} + +// <rdar://problem/8875247> - Properly handle CFGs with destructors. +struct rdar8875247 { + ~rdar8875247 (); +}; +void rdar8875247_aux(); + +int rdar8875247_test() { + rdar8875247 f; +} // expected-warning{{control reaches end of non-void function}} + +struct rdar8875247_B { + rdar8875247_B(); + ~rdar8875247_B(); +}; + +rdar8875247_B test_rdar8875247_B() { + rdar8875247_B f; + return f; +} // no-warning + +namespace PR10801 { + struct Foo { + void wibble() __attribute((__noreturn__)); + }; + + struct Bar { + void wibble(); + }; + + template <typename T> void thingy(T thing) { + thing.wibble(); + } + + void test() { + Foo f; + Bar b; + thingy(f); + thingy(b); + } +} diff --git a/clang/test/SemaCXX/warn-missing-prototypes.cpp b/clang/test/SemaCXX/warn-missing-prototypes.cpp new file mode 100644 index 0000000..f7e8db3 --- /dev/null +++ b/clang/test/SemaCXX/warn-missing-prototypes.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wmissing-prototypes %s + +void f() { } // expected-warning {{no previous prototype for function 'f'}} + +namespace NS { + void f() { } // expected-warning {{no previous prototype for function 'f'}} +} + +namespace { + // Don't warn about functions in anonymous namespaces. + void f() { } +} + +struct A { + // Don't warn about member functions. + void f() { } +}; + +// Don't warn about inline functions. +inline void g() { } + +// Don't warn about function templates. +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/clang/test/SemaCXX/warn-new-overaligned-2.cpp b/clang/test/SemaCXX/warn-new-overaligned-2.cpp new file mode 100644 index 0000000..5505009 --- /dev/null +++ b/clang/test/SemaCXX/warn-new-overaligned-2.cpp @@ -0,0 +1,22 @@ +// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify %s + +// This test verifies that we don't warn when the global operator new is +// overridden. That's why we can't merge this with the other test file. + +void* operator new(unsigned long); +void* operator new[](unsigned long); + +struct Test { + template <typename T> + struct SeparateCacheLines { + T data; + } __attribute__((aligned(256))); + + SeparateCacheLines<int> high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; + new Test[10]; +} diff --git a/clang/test/SemaCXX/warn-new-overaligned-3.cpp b/clang/test/SemaCXX/warn-new-overaligned-3.cpp new file mode 100644 index 0000000..c9a57fb --- /dev/null +++ b/clang/test/SemaCXX/warn-new-overaligned-3.cpp @@ -0,0 +1,33 @@ +// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned %s -isystem %S/Inputs -verify + +// This test ensures that we still get the warning even if we #include <new> +// where the header here simulates <new>. +#include <warn-new-overaligned-3.h> + +namespace test1 { +struct Test { + template <typename T> + struct SeparateCacheLines { + T data; + } __attribute__((aligned(256))); + + SeparateCacheLines<int> high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; // expected-warning {{type 'test1::Test' requires 256 bytes of alignment and the default allocator only guarantees}} + new Test[10]; // expected-warning {{type 'test1::Test' requires 256 bytes of alignment and the default allocator only guarantees}} +} +} + +namespace test2 { +struct helper { int i __attribute__((aligned(256))); }; + +struct Placement { + Placement() { + new (d) helper(); + } + helper *d; +}; +} diff --git a/clang/test/SemaCXX/warn-new-overaligned.cpp b/clang/test/SemaCXX/warn-new-overaligned.cpp new file mode 100644 index 0000000..42a4e35 --- /dev/null +++ b/clang/test/SemaCXX/warn-new-overaligned.cpp @@ -0,0 +1,73 @@ +// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -Wover-aligned -verify %s + +namespace test1 { +struct Test { + template <typename T> + struct SeparateCacheLines { + T data; + } __attribute__((aligned(256))); + + SeparateCacheLines<int> high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; // expected-warning {{type 'test1::Test' requires 256 bytes of alignment and the default allocator only guarantees}} + new Test[10]; // expected-warning {{type 'test1::Test' requires 256 bytes of alignment and the default allocator only guarantees}} +} +} + +namespace test2 { +class Test { + typedef int __attribute__((aligned(256))) aligned_int; + aligned_int high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; // expected-warning {{type 'test2::Test' requires 256 bytes of alignment and the default allocator only guarantees}} + new Test[10]; // expected-warning {{type 'test2::Test' requires 256 bytes of alignment and the default allocator only guarantees}} +} +} + +namespace test3 { +struct Test { + template <typename T> + struct SeparateCacheLines { + T data; + } __attribute__((aligned(256))); + + void* operator new(unsigned long) { + return 0; + } + + SeparateCacheLines<int> high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; + new Test[10]; // expected-warning {{type 'test3::Test' requires 256 bytes of alignment and the default allocator only guarantees}} +} +} + +namespace test4 { +struct Test { + template <typename T> + struct SeparateCacheLines { + T data; + } __attribute__((aligned(256))); + + void* operator new[](unsigned long) { + return 0; + } + + SeparateCacheLines<int> high_contention_data[10]; +}; + +void helper() { + Test t; + new Test; // expected-warning {{type 'test4::Test' requires 256 bytes of alignment and the default allocator only guarantees}} + new Test[10]; +} +} diff --git a/clang/test/SemaCXX/warn-overloaded-virtual.cpp b/clang/test/SemaCXX/warn-overloaded-virtual.cpp new file mode 100644 index 0000000..8e2b671 --- /dev/null +++ b/clang/test/SemaCXX/warn-overloaded-virtual.cpp @@ -0,0 +1,66 @@ +// RUN: %clang_cc1 -fsyntax-only -Woverloaded-virtual -verify %s + +struct B1 { + virtual void foo(int); // expected-note {{declared here}} + virtual void foo(); // expected-note {{declared here}} +}; + +struct S1 : public B1 { + void foo(float); // expected-warning {{hides overloaded virtual functions}} +}; + +struct S2 : public B1 { + void foo(); // expected-note {{declared here}} +}; + +struct B2 { + virtual void foo(void*); // expected-note {{declared here}} +}; + +struct MS1 : public S2, public B2 { + virtual void foo(int); // expected-warning {{hides overloaded virtual functions}} +}; + +struct B3 { + virtual void foo(int); + virtual void foo(); +}; + +struct S3 : public B3 { + using B3::foo; + void foo(float); +}; + +struct B4 { + virtual void foo(); +}; + +struct S4 : public B4 { + void foo(float); + void foo(); +}; + +namespace PR9182 { +struct Base { + virtual void foo(int); +}; + +void Base::foo(int) { } + +struct Derived : public Base { + virtual void foo(int); + void foo(int, int); +}; +} + +namespace PR9396 { +class A { +public: + virtual void f(int) {} +}; + +class B : public A { +public: + static void f() {} +}; +} diff --git a/clang/test/SemaCXX/warn-pure-virtual-call-from-ctor-dtor.cpp b/clang/test/SemaCXX/warn-pure-virtual-call-from-ctor-dtor.cpp new file mode 100644 index 0000000..ade6198 --- /dev/null +++ b/clang/test/SemaCXX/warn-pure-virtual-call-from-ctor-dtor.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify +struct A { + A() { f(); } // expected-warning {{call to pure virtual member function 'f'; overrides of 'f' in subclasses are not available in the constructor of 'A'}} + ~A() { f(); } // expected-warning {{call to pure virtual member function 'f'; overrides of 'f' in subclasses are not available in the destructor of 'A'}} + + virtual void f() = 0; // expected-note 2 {{'f' declared here}} +}; + +// Don't warn (or note) when calling the function on a pointer. (PR10195) +struct B { + A *a; + B() { a->f(); }; + ~B() { a->f(); }; +}; diff --git a/clang/test/SemaCXX/warn-reorder-ctor-initialization.cpp b/clang/test/SemaCXX/warn-reorder-ctor-initialization.cpp new file mode 100644 index 0000000..8c254e5 --- /dev/null +++ b/clang/test/SemaCXX/warn-reorder-ctor-initialization.cpp @@ -0,0 +1,132 @@ +// RUN: %clang_cc1 -fsyntax-only -Wreorder -verify %s + +struct BB {}; + +struct BB1 {}; + +class complex : public BB, BB1 { +public: + complex() + : s2(1), // expected-warning {{field 's2' will be initialized after field 's1'}} + s1(1), + s3(3), // expected-warning {{field 's3' will be initialized after base 'BB1'}} + BB1(), // expected-warning {{base class 'BB1' will be initialized after base 'BB'}} + BB() + {} + int s1; + int s2; + int s3; +}; + + +// testing virtual bases. + + +struct V { + V(); +}; + +struct A : public virtual V { + A(); +}; + +struct B : public virtual V { + B(); +}; + +struct Diamond : public A, public B { + Diamond() : A(), B() {} +}; + + +struct C : public A, public B, private virtual V { + C() { } +}; + + +struct D : public A, public B { + D() : A(), V() { } // expected-warning {{base class 'A' will be initialized after base 'V'}} +}; + + +struct E : public A, public B, private virtual V { + E() : A(), V() { } // expected-warning {{base class 'A' will be initialized after base 'V'}} +}; + + +struct A1 { + A1(); +}; + +struct B1 { + B1(); +}; + +struct F : public A1, public B1, private virtual V { + F() : A1(), V() { } // expected-warning {{base class 'A1' will be initialized after base 'V'}} +}; + +struct X : public virtual A, virtual V, public virtual B { + X(): A(), V(), B() {} // expected-warning {{base class 'A' will be initialized after base 'V'}} +}; + +class Anon { + int c; union {int a,b;}; int d; + Anon() : c(10), b(1), d(2) {} +}; +class Anon2 { + int c; union {int a,b;}; int d; + Anon2() : c(2), + d(10), // expected-warning {{field 'd' will be initialized after field 'b'}} + b(1) {} +}; +class Anon3 { + union {int a,b;}; + Anon3() : b(1) {} +}; + +namespace T1 { + +struct S1 { }; +struct S2: virtual S1 { }; +struct S3 { }; + +struct S4: virtual S3, S2 { + S4() : S2(), // expected-warning {{base class 'T1::S2' will be initialized after base 'T1::S3'}} + S3() { }; +}; +} + +namespace test2 { + struct Foo { Foo(); }; + class A { + template <class T> A(T *t) : + y(), // expected-warning {{field 'y' will be initialized after field 'x'}} + x() + {} + Foo x; + Foo y; + }; +} + +// PR6575: this should not crash +namespace test3 { + struct MyClass { + MyClass() : m_int(0) {} + union { + struct { + int m_int; + }; + }; + }; +} + +namespace PR7179 { + struct X + { + struct Y + { + template <class T> Y(T x) : X(x) { } + }; + }; +} diff --git a/clang/test/SemaCXX/warn-self-assign.cpp b/clang/test/SemaCXX/warn-self-assign.cpp new file mode 100644 index 0000000..fcdb2ab --- /dev/null +++ b/clang/test/SemaCXX/warn-self-assign.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -fsyntax-only -Wself-assign -verify %s + +void f() { + int a = 42, b = 42; + a = a; // expected-warning{{explicitly assigning}} + b = b; // expected-warning{{explicitly assigning}} + a = b; + b = a = b; + a = a = a; // expected-warning{{explicitly assigning}} + a = b = b = a; +} + +// Dummy type. +struct S {}; + +void false_positives() { +#define OP = +#define LHS a +#define RHS a + int a = 42; + // These shouldn't warn due to the use of the preprocessor. + a OP a; + LHS = a; + a = RHS; + LHS OP RHS; +#undef OP +#undef LHS +#undef RHS + + S s; + s = s; // Not a builtin assignment operator, no warning. + + // Volatile stores aren't side-effect free. + volatile int vol_a; + vol_a = vol_a; + volatile int &vol_a_ref = vol_a; + vol_a_ref = vol_a_ref; +} + +template <typename T> void g() { + T a; + a = a; // May or may not be a builtin assignment operator, no warning. +} +void instantiate() { + g<int>(); + g<S>(); +} diff --git a/clang/test/SemaCXX/warn-self-comparisons.cpp b/clang/test/SemaCXX/warn-self-comparisons.cpp new file mode 100644 index 0000000..620be19 --- /dev/null +++ b/clang/test/SemaCXX/warn-self-comparisons.cpp @@ -0,0 +1,5 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +void f(int (&array1)[2], int (&array2)[2]) { + if (array1 == array2) { } // no warning +} diff --git a/clang/test/SemaCXX/warn-shadow.cpp b/clang/test/SemaCXX/warn-shadow.cpp new file mode 100644 index 0000000..68e9467 --- /dev/null +++ b/clang/test/SemaCXX/warn-shadow.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -Wshadow %s + +namespace { + int i; // expected-note {{previous declaration is here}} +} + +namespace one { +namespace two { + int j; // expected-note {{previous declaration is here}} +} +} + +namespace xx { + int m; +} +namespace yy { + int m; +} + +using namespace one::two; +using namespace xx; +using namespace yy; + +void foo() { + int i; // expected-warning {{declaration shadows a variable in namespace '<anonymous>'}} + int j; // expected-warning {{declaration shadows a variable in namespace 'one::two'}} + int m; +} + +class A { + static int data; // expected-note {{previous declaration}} + int field; // expected-note {{previous declaration}} + + void test() { + char *field; // expected-warning {{declaration shadows a field of 'A'}} + char *data; // expected-warning {{declaration shadows a static data member of 'A'}} + } +}; + +// TODO: this should warn, <rdar://problem/5018057> +class B : A { + int data; + static int field; +}; + +// rdar://8900456 +namespace rdar8900456 { +struct Foo { + static void Baz(); +private: + int Bar; +}; + +void Foo::Baz() { + double Bar = 12; // Don't warn. +} +} + +// http://llvm.org/PR9160 +namespace PR9160 { +struct V { + V(int); +}; +struct S { + V v; + static void m() { + if (1) { + V v(0); + } + } +}; +} + +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/clang/test/SemaCXX/warn-sign-conversion.cpp b/clang/test/SemaCXX/warn-sign-conversion.cpp new file mode 100644 index 0000000..ba2bc9b --- /dev/null +++ b/clang/test/SemaCXX/warn-sign-conversion.cpp @@ -0,0 +1,80 @@ +// RUN: %clang_cc1 -verify -fsyntax-only -Wsign-conversion %s + +// NOTE: When a 'enumeral mismatch' warning is implemented then expect several +// of the following cases to be impacted. + +// namespace for anonymous enums tests +namespace test1 { + enum { A }; + enum { B = -1 }; + + template <typename T> struct Foo { + enum { C }; + enum { D = ~0U }; + }; + + enum { E = ~0U }; + + void doit_anonymous( int i ) { + int a1 = 1 ? i : A; + int a2 = 1 ? A : i; + + int b1 = 1 ? i : B; + int b2 = 1 ? B : i; + + int c1 = 1 ? i : Foo<bool>::C; + int c2 = 1 ? Foo<bool>::C : i; + + int d1a = 1 ? i : Foo<bool>::D; // expected-warning {{test1::Foo<bool>::<anonymous enum at }} + int d1b = 1 ? i : Foo<bool>::D; // expected-warning {{warn-sign-conversion.cpp:13:5>' to 'int'}} + int d2a = 1 ? Foo<bool>::D : i; // expected-warning {{operand of ? changes signedness: 'test1::Foo<bool>::<anonymous enum at }} + int d2b = 1 ? Foo<bool>::D : i; // expected-warning {{warn-sign-conversion.cpp:13:5>' to 'int'}} + int d3a = 1 ? B : Foo<bool>::D; // expected-warning {{operand of ? changes signedness: 'test1::Foo<bool>::<anonymous enum at }} + int d3b = 1 ? B : Foo<bool>::D; // expected-warning {{warn-sign-conversion.cpp:13:5>' to 'int'}} + int d4a = 1 ? Foo<bool>::D : B; // expected-warning {{operand of ? changes signedness: 'test1::Foo<bool>::<anonymous enum at }} + int d4b = 1 ? Foo<bool>::D : B; // expected-warning {{warn-sign-conversion.cpp:13:5>' to 'int'}} + + int e1a = 1 ? i : E; // expected-warning {{operand of ? changes signedness: 'test1::<anonymous enum at }} + int e1b = 1 ? i : E; // expected-warning {{warn-sign-conversion.cpp:16:3>' to 'int'}} + int e2a = 1 ? E : i; // expected-warning {{operand of ? changes signedness: 'test1::<anonymous enum at }} + int e2b = 1 ? E : i; // expected-warning {{warn-sign-conversion.cpp:16:3>' to 'int'}} + int e3a = 1 ? E : B; // expected-warning {{operand of ? changes signedness: 'test1::<anonymous enum at }} + int e3b = 1 ? E : B; // expected-warning {{warn-sign-conversion.cpp:16:3>' to 'int'}} + int e4a = 1 ? B : E; // expected-warning {{operand of ? changes signedness: 'test1::<anonymous enum at }} + int e4b = 1 ? B : E; // expected-warning {{warn-sign-conversion.cpp:16:3>' to 'int'}} + } +} + +// namespace for named enums tests +namespace test2 { + enum Named1 { A }; + enum Named2 { B = -1 }; + + template <typename T> struct Foo { + enum Named3 { C }; + enum Named4 { D = ~0U }; + }; + + enum Named5 { E = ~0U }; + + void doit_anonymous( int i ) { + int a1 = 1 ? i : A; + int a2 = 1 ? A : i; + + int b1 = 1 ? i : B; + int b2 = 1 ? B : i; + + int c1 = 1 ? i : Foo<bool>::C; + int c2 = 1 ? Foo<bool>::C : i; + + int d1 = 1 ? i : Foo<bool>::D; // expected-warning {{operand of ? changes signedness: 'test2::Foo<bool>::Named4' to 'int'}} + int d2 = 1 ? Foo<bool>::D : i; // expected-warning {{operand of ? changes signedness: 'test2::Foo<bool>::Named4' to 'int'}} + int d3 = 1 ? B : Foo<bool>::D; // expected-warning {{operand of ? changes signedness: 'test2::Foo<bool>::Named4' to 'int'}} + int d4 = 1 ? Foo<bool>::D : B; // expected-warning {{operand of ? changes signedness: 'test2::Foo<bool>::Named4' to 'int'}} + + int e1 = 1 ? i : E; // expected-warning {{operand of ? changes signedness: 'test2::Named5' to 'int'}} + int e2 = 1 ? E : i; // expected-warning {{operand of ? changes signedness: 'test2::Named5' to 'int'}} + int e3 = 1 ? E : B; // expected-warning {{operand of ? changes signedness: 'test2::Named5' to 'int'}} + int e4 = 1 ? B : E; // expected-warning {{operand of ? changes signedness: 'test2::Named5' to 'int'}} + } +} diff --git a/clang/test/SemaCXX/warn-string-conversion.cpp b/clang/test/SemaCXX/warn-string-conversion.cpp new file mode 100644 index 0000000..23960e4 --- /dev/null +++ b/clang/test/SemaCXX/warn-string-conversion.cpp @@ -0,0 +1,18 @@ +// RUN: %clang_cc1 -fsyntax-only -Wstring-conversion -verify %s + +// Warn on cases where a string literal is converted into a bool. +// An exception is made for this in logical operators. +void assert(bool condition); +void test0() { + bool b0 = "hi"; // expected-warning{{implicit conversion turns string literal into bool: 'const char [3]' to 'bool'}} + b0 = ""; // expected-warning{{implicit conversion turns string literal into bool: 'const char [1]' to 'bool'}} + b0 = 0 && ""; + assert("error"); // expected-warning{{implicit conversion turns string literal into bool: 'const char [6]' to 'bool'}} + assert(0 && "error"); + + while("hi") {} // expected-warning{{implicit conversion turns string literal into bool: 'const char [3]' to 'bool'}} + do {} while("hi"); // expected-warning{{implicit conversion turns string literal into bool: 'const char [3]' to 'bool'}} + for (;"hi";); // expected-warning{{implicit conversion turns string literal into bool: 'const char [3]' to 'bool'}} + if("hi") {} // expected-warning{{implicit conversion turns string literal into bool: 'const char [3]' to 'bool'}} +} + diff --git a/clang/test/SemaCXX/warn-thread-safety-analysis.cpp b/clang/test/SemaCXX/warn-thread-safety-analysis.cpp new file mode 100644 index 0000000..566e5c1 --- /dev/null +++ b/clang/test/SemaCXX/warn-thread-safety-analysis.cpp @@ -0,0 +1,2243 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wthread-safety %s + +#define LOCKABLE __attribute__ ((lockable)) +#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) +#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) +#define GUARDED_VAR __attribute__ ((guarded_var)) +#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x))) +#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var)) +#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) +#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) +#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__))) +#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__))) +#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__))) +#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__))) +#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__))) +#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) +#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) +#define EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__ ((exclusive_locks_required(__VA_ARGS__))) +#define SHARED_LOCKS_REQUIRED(...) \ + __attribute__ ((shared_locks_required(__VA_ARGS__))) +#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) + +//-----------------------------------------// +// Helper fields +//-----------------------------------------// + + +class __attribute__((lockable)) Mutex { + public: + void Lock() __attribute__((exclusive_lock_function)); + void ReaderLock() __attribute__((shared_lock_function)); + void Unlock() __attribute__((unlock_function)); + bool TryLock() __attribute__((exclusive_trylock_function(true))); + bool ReaderTryLock() __attribute__((shared_trylock_function(true))); + void LockWhen(const int &cond) __attribute__((exclusive_lock_function)); +}; + +class __attribute__((scoped_lockable)) MutexLock { + public: + MutexLock(Mutex *mu) __attribute__((exclusive_lock_function(mu))); + ~MutexLock() __attribute__((unlock_function)); +}; + +class __attribute__((scoped_lockable)) ReaderMutexLock { + public: + ReaderMutexLock(Mutex *mu) __attribute__((exclusive_lock_function(mu))); + ~ReaderMutexLock() __attribute__((unlock_function)); +}; + + +Mutex sls_mu; + +Mutex sls_mu2 __attribute__((acquired_after(sls_mu))); +int sls_guard_var __attribute__((guarded_var)) = 0; +int sls_guardby_var __attribute__((guarded_by(sls_mu))) = 0; + +bool getBool(); + +class MutexWrapper { +public: + Mutex mu; + int x __attribute__((guarded_by(mu))); + void MyLock() __attribute__((exclusive_lock_function(mu))); +}; + +MutexWrapper sls_mw; + +void sls_fun_0() { + sls_mw.mu.Lock(); + sls_mw.x = 5; + sls_mw.mu.Unlock(); +} + +void sls_fun_2() { + sls_mu.Lock(); + int x = sls_guard_var; + sls_mu.Unlock(); +} + +void sls_fun_3() { + sls_mu.Lock(); + sls_guard_var = 2; + sls_mu.Unlock(); +} + +void sls_fun_4() { + sls_mu2.Lock(); + sls_guard_var = 2; + sls_mu2.Unlock(); +} + +void sls_fun_5() { + sls_mu.Lock(); + int x = sls_guardby_var; + sls_mu.Unlock(); +} + +void sls_fun_6() { + sls_mu.Lock(); + sls_guardby_var = 2; + sls_mu.Unlock(); +} + +void sls_fun_7() { + sls_mu.Lock(); + sls_mu2.Lock(); + sls_mu2.Unlock(); + sls_mu.Unlock(); +} + +void sls_fun_8() { + sls_mu.Lock(); + if (getBool()) + sls_mu.Unlock(); + else + sls_mu.Unlock(); +} + +void sls_fun_9() { + if (getBool()) + sls_mu.Lock(); + else + sls_mu.Lock(); + sls_mu.Unlock(); +} + +void sls_fun_good_6() { + if (getBool()) { + sls_mu.Lock(); + } else { + if (getBool()) { + getBool(); // EMPTY + } else { + getBool(); // EMPTY + } + sls_mu.Lock(); + } + sls_mu.Unlock(); +} + +void sls_fun_good_7() { + sls_mu.Lock(); + while (getBool()) { + sls_mu.Unlock(); + if (getBool()) { + if (getBool()) { + sls_mu.Lock(); + continue; + } + } + sls_mu.Lock(); + } + sls_mu.Unlock(); +} + +void sls_fun_good_8() { + sls_mw.MyLock(); + sls_mw.mu.Unlock(); +} + +void sls_fun_bad_1() { + sls_mu.Unlock(); // \ + // expected-warning{{unlocking 'sls_mu' that was not locked}} +} + +void sls_fun_bad_2() { + sls_mu.Lock(); + sls_mu.Lock(); // \ + // expected-warning{{locking 'sls_mu' that is already locked}} + sls_mu.Unlock(); +} + +void sls_fun_bad_3() { + sls_mu.Lock(); // expected-note {{mutex acquired here}} +} // expected-warning{{mutex 'sls_mu' is still locked at the end of function}} + +void sls_fun_bad_4() { + if (getBool()) + sls_mu.Lock(); // \ + expected-warning{{mutex 'sls_mu2' is not locked on every path through here}} \ + expected-note{{mutex acquired here}} + + else + sls_mu2.Lock(); // \ + expected-note{{mutex acquired here}} +} // expected-warning{{mutex 'sls_mu' is not locked on every path through here}} + +void sls_fun_bad_5() { + sls_mu.Lock(); // expected-note {{mutex acquired here}} + if (getBool()) + sls_mu.Unlock(); +} // expected-warning{{mutex 'sls_mu' is not locked on every path through here}} + +void sls_fun_bad_6() { + if (getBool()) { + sls_mu.Lock(); // expected-note {{mutex acquired here}} + } else { + if (getBool()) { + getBool(); // EMPTY + } else { + getBool(); // EMPTY + } + } + sls_mu.Unlock(); // \ + expected-warning{{mutex 'sls_mu' is not locked on every path through here}}\ + expected-warning{{unlocking 'sls_mu' that was not locked}} +} + +void sls_fun_bad_7() { + sls_mu.Lock(); + while (getBool()) { + sls_mu.Unlock(); + if (getBool()) { + if (getBool()) { + continue; // \ + expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} + } + } + sls_mu.Lock(); // expected-note {{mutex acquired here}} + } + sls_mu.Unlock(); +} + +void sls_fun_bad_8() { + sls_mu.Lock(); // expected-note{{mutex acquired here}} + + // FIXME: TERRIBLE SOURCE LOCATION! + do { // expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} + sls_mu.Unlock(); + } while (getBool()); +} + +void sls_fun_bad_9() { + do { + sls_mu.Lock(); // \ + // expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} \ + // expected-note{{mutex acquired here}} + } while (getBool()); + sls_mu.Unlock(); +} + +void sls_fun_bad_10() { + sls_mu.Lock(); // expected-note 2{{mutex acquired here}} + while(getBool()) { + sls_mu.Unlock(); // expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} + } +} // expected-warning{{mutex 'sls_mu' is still locked at the end of function}} + +void sls_fun_bad_11() { + while (getBool()) { // \ + expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} + sls_mu.Lock(); // expected-note {{mutex acquired here}} + } + sls_mu.Unlock(); // \ + // expected-warning{{unlocking 'sls_mu' that was not locked}} +} + +void sls_fun_bad_12() { + sls_mu.Lock(); // expected-note {{mutex acquired here}} + while (getBool()) { + sls_mu.Unlock(); + if (getBool()) { + if (getBool()) { + break; // expected-warning{{mutex 'sls_mu' is not locked on every path through here}} + } + } + sls_mu.Lock(); + } + sls_mu.Unlock(); +} + +//-----------------------------------------// +// Handling lock expressions in attribute args +// -------------------------------------------// + +Mutex aa_mu; + +class GlobalLocker { +public: + void globalLock() __attribute__((exclusive_lock_function(aa_mu))); + void globalUnlock() __attribute__((unlock_function(aa_mu))); +}; + +GlobalLocker glock; + +void aa_fun_1() { + glock.globalLock(); + glock.globalUnlock(); +} + +void aa_fun_bad_1() { + glock.globalUnlock(); // \ + // expected-warning{{unlocking 'aa_mu' that was not locked}} +} + +void aa_fun_bad_2() { + glock.globalLock(); + glock.globalLock(); // \ + // expected-warning{{locking 'aa_mu' that is already locked}} + glock.globalUnlock(); +} + +void aa_fun_bad_3() { + glock.globalLock(); // expected-note{{mutex acquired here}} +} // expected-warning{{mutex 'aa_mu' is still locked at the end of function}} + +//--------------------------------------------------// +// Regression tests for unusual method names +//--------------------------------------------------// + +Mutex wmu; + +// Test diagnostics for other method names. +class WeirdMethods { + // FIXME: can't currently check inside constructors and destructors. + WeirdMethods() { + wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}} + } // EXPECTED-WARNING {{mutex 'wmu' is still locked at the end of function}} + ~WeirdMethods() { + wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}} + } // EXPECTED-WARNING {{mutex 'wmu' is still locked at the end of function}} + void operator++() { + wmu.Lock(); // expected-note {{mutex acquired here}} + } // expected-warning {{mutex 'wmu' is still locked at the end of function}} + operator int*() { + wmu.Lock(); // expected-note {{mutex acquired here}} + return 0; + } // expected-warning {{mutex 'wmu' is still locked at the end of function}} +}; + +//-----------------------------------------------// +// Errors for guarded by or guarded var variables +// ----------------------------------------------// + +int *pgb_gvar __attribute__((pt_guarded_var)); +int *pgb_var __attribute__((pt_guarded_by(sls_mu))); + +class PGBFoo { + public: + int x; + int *pgb_field __attribute__((guarded_by(sls_mu2))) + __attribute__((pt_guarded_by(sls_mu))); + void testFoo() { + pgb_field = &x; // \ + // expected-warning {{writing variable 'pgb_field' requires locking 'sls_mu2' exclusively}} + *pgb_field = x; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \ + // expected-warning {{writing the value pointed to by 'pgb_field' requires locking 'sls_mu' exclusively}} + x = *pgb_field; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \ + // expected-warning {{reading the value pointed to by 'pgb_field' requires locking 'sls_mu'}} + (*pgb_field)++; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \ + // expected-warning {{writing the value pointed to by 'pgb_field' requires locking 'sls_mu' exclusively}} + } +}; + +class GBFoo { + public: + int gb_field __attribute__((guarded_by(sls_mu))); + + void testFoo() { + gb_field = 0; // \ + // expected-warning {{writing variable 'gb_field' requires locking 'sls_mu' exclusively}} + } + + void testNoAnal() __attribute__((no_thread_safety_analysis)) { + gb_field = 0; + } +}; + +GBFoo GlobalGBFoo __attribute__((guarded_by(sls_mu))); + +void gb_fun_0() { + sls_mu.Lock(); + int x = *pgb_var; + sls_mu.Unlock(); +} + +void gb_fun_1() { + sls_mu.Lock(); + *pgb_var = 2; + sls_mu.Unlock(); +} + +void gb_fun_2() { + int x; + pgb_var = &x; +} + +void gb_fun_3() { + int *x = pgb_var; +} + +void gb_bad_0() { + sls_guard_var = 1; // \ + // expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}} +} + +void gb_bad_1() { + int x = sls_guard_var; // \ + // expected-warning{{reading variable 'sls_guard_var' requires locking any mutex}} +} + +void gb_bad_2() { + sls_guardby_var = 1; // \ + // expected-warning {{writing variable 'sls_guardby_var' requires locking 'sls_mu' exclusively}} +} + +void gb_bad_3() { + int x = sls_guardby_var; // \ + // expected-warning {{reading variable 'sls_guardby_var' requires locking 'sls_mu'}} +} + +void gb_bad_4() { + *pgb_gvar = 1; // \ + // expected-warning {{writing the value pointed to by 'pgb_gvar' requires locking any mutex exclusively}} +} + +void gb_bad_5() { + int x = *pgb_gvar; // \ + // expected-warning {{reading the value pointed to by 'pgb_gvar' requires locking any mutex}} +} + +void gb_bad_6() { + *pgb_var = 1; // \ + // expected-warning {{writing the value pointed to by 'pgb_var' requires locking 'sls_mu' exclusively}} +} + +void gb_bad_7() { + int x = *pgb_var; // \ + // expected-warning {{reading the value pointed to by 'pgb_var' requires locking 'sls_mu'}} +} + +void gb_bad_8() { + GBFoo G; + G.gb_field = 0; // \ + // expected-warning {{writing variable 'gb_field' requires locking 'sls_mu'}} +} + +void gb_bad_9() { + sls_guard_var++; // \ + // expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}} + sls_guard_var--; // \ + // expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}} + ++sls_guard_var; // \ + // expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}} + --sls_guard_var;// \ + // expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}} +} + +//-----------------------------------------------// +// Warnings on variables with late parsed attributes +// ----------------------------------------------// + +class LateFoo { +public: + int a __attribute__((guarded_by(mu))); + int b; + + void foo() __attribute__((exclusive_locks_required(mu))) { } + + void test() { + a = 0; // \ + // expected-warning{{writing variable 'a' requires locking 'mu' exclusively}} + b = a; // \ + // expected-warning {{reading variable 'a' requires locking 'mu'}} + c = 0; // \ + // expected-warning {{writing variable 'c' requires locking 'mu' exclusively}} + } + + int c __attribute__((guarded_by(mu))); + + Mutex mu; +}; + +class LateBar { + public: + int a_ __attribute__((guarded_by(mu1_))); + int b_; + int *q __attribute__((pt_guarded_by(mu))); + Mutex mu1_; + Mutex mu; + LateFoo Foo; + LateFoo Foo2; + LateFoo *FooPointer; +}; + +LateBar b1, *b3; + +void late_0() { + LateFoo FooA; + LateFoo FooB; + FooA.mu.Lock(); + FooA.a = 5; + FooA.mu.Unlock(); +} + +void late_1() { + LateBar BarA; + BarA.FooPointer->mu.Lock(); + BarA.FooPointer->a = 2; + BarA.FooPointer->mu.Unlock(); +} + +void late_bad_0() { + LateFoo fooA; + LateFoo fooB; + fooA.mu.Lock(); + fooB.a = 5; // \ + // expected-warning{{writing variable 'a' requires locking 'mu' exclusively}} + fooA.mu.Unlock(); +} + +void late_bad_1() { + Mutex mu; + mu.Lock(); + b1.mu1_.Lock(); + int res = b1.a_ + b3->b_; + b3->b_ = *b1.q; // \ + // expected-warning{{reading the value pointed to by 'q' requires locking 'mu'}} + b1.mu1_.Unlock(); + b1.b_ = res; + mu.Unlock(); +} + +void late_bad_2() { + LateBar BarA; + BarA.FooPointer->mu.Lock(); + BarA.Foo.a = 2; // \ + // expected-warning{{writing variable 'a' requires locking 'mu' exclusively}} + BarA.FooPointer->mu.Unlock(); +} + +void late_bad_3() { + LateBar BarA; + BarA.Foo.mu.Lock(); + BarA.FooPointer->a = 2; // \ + // expected-warning{{writing variable 'a' requires locking 'mu' exclusively}} + BarA.Foo.mu.Unlock(); +} + +void late_bad_4() { + LateBar BarA; + BarA.Foo.mu.Lock(); + BarA.Foo2.a = 2; // \ + // expected-warning{{writing variable 'a' requires locking 'mu' exclusively}} + BarA.Foo.mu.Unlock(); +} + +//-----------------------------------------------// +// Extra warnings for shared vs. exclusive locks +// ----------------------------------------------// + +void shared_fun_0() { + sls_mu.Lock(); + do { + sls_mu.Unlock(); + sls_mu.Lock(); + } while (getBool()); + sls_mu.Unlock(); +} + +void shared_fun_1() { + sls_mu.ReaderLock(); // \ + // expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}} + do { + sls_mu.Unlock(); + sls_mu.Lock(); // \ + // expected-note {{the other lock of mutex 'sls_mu' is here}} + } while (getBool()); + sls_mu.Unlock(); +} + +void shared_fun_3() { + if (getBool()) + sls_mu.Lock(); + else + sls_mu.Lock(); + *pgb_var = 1; + sls_mu.Unlock(); +} + +void shared_fun_4() { + if (getBool()) + sls_mu.ReaderLock(); + else + sls_mu.ReaderLock(); + int x = sls_guardby_var; + sls_mu.Unlock(); +} + +void shared_fun_8() { + if (getBool()) + sls_mu.Lock(); // \ + // expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}} + else + sls_mu.ReaderLock(); // \ + // expected-note {{the other lock of mutex 'sls_mu' is here}} + sls_mu.Unlock(); +} + +void shared_bad_0() { + sls_mu.Lock(); // \ + // expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}} + do { + sls_mu.Unlock(); + sls_mu.ReaderLock(); // \ + // expected-note {{the other lock of mutex 'sls_mu' is here}} + } while (getBool()); + sls_mu.Unlock(); +} + +void shared_bad_1() { + if (getBool()) + sls_mu.Lock(); // \ + // expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}} + else + sls_mu.ReaderLock(); // \ + // expected-note {{the other lock of mutex 'sls_mu' is here}} + *pgb_var = 1; + sls_mu.Unlock(); +} + +void shared_bad_2() { + if (getBool()) + sls_mu.ReaderLock(); // \ + // expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}} + else + sls_mu.Lock(); // \ + // expected-note {{the other lock of mutex 'sls_mu' is here}} + *pgb_var = 1; + sls_mu.Unlock(); +} + +// FIXME: Add support for functions (not only methods) +class LRBar { + public: + void aa_elr_fun() __attribute__((exclusive_locks_required(aa_mu))); + void aa_elr_fun_s() __attribute__((shared_locks_required(aa_mu))); + void le_fun() __attribute__((locks_excluded(sls_mu))); +}; + +class LRFoo { + public: + void test() __attribute__((exclusive_locks_required(sls_mu))); + void testShared() __attribute__((shared_locks_required(sls_mu2))); +}; + +void elr_fun() __attribute__((exclusive_locks_required(sls_mu))); +void elr_fun() {} + +LRFoo MyLRFoo; +LRBar Bar; + +void es_fun_0() { + aa_mu.Lock(); + Bar.aa_elr_fun(); + aa_mu.Unlock(); +} + +void es_fun_1() { + aa_mu.Lock(); + Bar.aa_elr_fun_s(); + aa_mu.Unlock(); +} + +void es_fun_2() { + aa_mu.ReaderLock(); + Bar.aa_elr_fun_s(); + aa_mu.Unlock(); +} + +void es_fun_3() { + sls_mu.Lock(); + MyLRFoo.test(); + sls_mu.Unlock(); +} + +void es_fun_4() { + sls_mu2.Lock(); + MyLRFoo.testShared(); + sls_mu2.Unlock(); +} + +void es_fun_5() { + sls_mu2.ReaderLock(); + MyLRFoo.testShared(); + sls_mu2.Unlock(); +} + +void es_fun_6() { + Bar.le_fun(); +} + +void es_fun_7() { + sls_mu.Lock(); + elr_fun(); + sls_mu.Unlock(); +} + +void es_fun_8() __attribute__((no_thread_safety_analysis)); + +void es_fun_8() { + Bar.aa_elr_fun_s(); +} + +void es_fun_9() __attribute__((shared_locks_required(aa_mu))); +void es_fun_9() { + Bar.aa_elr_fun_s(); +} + +void es_fun_10() __attribute__((exclusive_locks_required(aa_mu))); +void es_fun_10() { + Bar.aa_elr_fun_s(); +} + +void es_bad_0() { + Bar.aa_elr_fun(); // \ + // expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}} +} + +void es_bad_1() { + aa_mu.ReaderLock(); + Bar.aa_elr_fun(); // \ + // expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}} + aa_mu.Unlock(); +} + +void es_bad_2() { + Bar.aa_elr_fun_s(); // \ + // expected-warning {{calling function 'aa_elr_fun_s' requires shared lock on 'aa_mu'}} +} + +void es_bad_3() { + MyLRFoo.test(); // \ + // expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}} +} + +void es_bad_4() { + MyLRFoo.testShared(); // \ + // expected-warning {{calling function 'testShared' requires shared lock on 'sls_mu2'}} +} + +void es_bad_5() { + sls_mu.ReaderLock(); + MyLRFoo.test(); // \ + // expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}} + sls_mu.Unlock(); +} + +void es_bad_6() { + sls_mu.Lock(); + Bar.le_fun(); // \ + // expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is locked}} + sls_mu.Unlock(); +} + +void es_bad_7() { + sls_mu.ReaderLock(); + Bar.le_fun(); // \ + // expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is locked}} + sls_mu.Unlock(); +} + + +//-----------------------------------------------// +// Unparseable lock expressions +// ----------------------------------------------// + +// FIXME -- derive new tests for unhandled expressions + + +//----------------------------------------------------------------------------// +// The following test cases are ported from the gcc thread safety implementation +// They are each wrapped inside a namespace with the test number of the gcc test +// +// FIXME: add all the gcc tests, once this analysis passes them. +//----------------------------------------------------------------------------// + +//-----------------------------------------// +// Good testcases (no errors) +//-----------------------------------------// + +namespace thread_annot_lock_20 { +class Bar { + public: + static int func1() EXCLUSIVE_LOCKS_REQUIRED(mu1_); + static int b_ GUARDED_BY(mu1_); + static Mutex mu1_; + static int a_ GUARDED_BY(mu1_); +}; + +Bar b1; + +int Bar::func1() +{ + int res = 5; + + if (a_ == 4) + res = b_; + return res; +} +} // end namespace thread_annot_lock_20 + +namespace thread_annot_lock_22 { +// Test various usage of GUARDED_BY and PT_GUARDED_BY annotations, especially +// uses in class definitions. +Mutex mu; + +class Bar { + public: + int a_ GUARDED_BY(mu1_); + int b_; + int *q PT_GUARDED_BY(mu); + Mutex mu1_ ACQUIRED_AFTER(mu); +}; + +Bar b1, *b3; +int *p GUARDED_BY(mu) PT_GUARDED_BY(mu); +int res GUARDED_BY(mu) = 5; + +int func(int i) +{ + int x; + mu.Lock(); + b1.mu1_.Lock(); + res = b1.a_ + b3->b_; + *p = i; + b1.a_ = res + b3->b_; + b3->b_ = *b1.q; + b1.mu1_.Unlock(); + b1.b_ = res; + x = res; + mu.Unlock(); + return x; +} +} // end namespace thread_annot_lock_22 + +namespace thread_annot_lock_27_modified { +// test lock annotations applied to function definitions +// Modified: applied annotations only to function declarations +Mutex mu1; +Mutex mu2 ACQUIRED_AFTER(mu1); + +class Foo { + public: + int method1(int i) SHARED_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1); +}; + +int Foo::method1(int i) { + return i; +} + + +int foo(int i) EXCLUSIVE_LOCKS_REQUIRED(mu2) SHARED_LOCKS_REQUIRED(mu1); +int foo(int i) { + return i; +} + +static int bar(int i) EXCLUSIVE_LOCKS_REQUIRED(mu1); +static int bar(int i) { + return i; +} + +void main() { + Foo a; + + mu1.Lock(); + mu2.Lock(); + a.method1(1); + foo(2); + mu2.Unlock(); + bar(3); + mu1.Unlock(); +} +} // end namespace thread_annot_lock_27_modified + + +namespace thread_annot_lock_38 { +// Test the case where a template member function is annotated with lock +// attributes in a non-template class. +class Foo { + public: + void func1(int y) LOCKS_EXCLUDED(mu_); + template <typename T> void func2(T x) LOCKS_EXCLUDED(mu_); + private: + Mutex mu_; +}; + +Foo *foo; + +void main() +{ + foo->func1(5); + foo->func2(5); +} +} // end namespace thread_annot_lock_38 + +namespace thread_annot_lock_43 { +// Tests lock canonicalization +class Foo { + public: + Mutex *mu_; +}; + +class FooBar { + public: + Foo *foo_; + int GetA() EXCLUSIVE_LOCKS_REQUIRED(foo_->mu_) { return a_; } + int a_ GUARDED_BY(foo_->mu_); +}; + +FooBar *fb; + +void main() +{ + int x; + fb->foo_->mu_->Lock(); + x = fb->GetA(); + fb->foo_->mu_->Unlock(); +} +} // end namespace thread_annot_lock_43 + +namespace thread_annot_lock_49 { +// Test the support for use of lock expression in the annotations +class Foo { + public: + Mutex foo_mu_; +}; + +class Bar { + private: + Foo *foo; + Mutex bar_mu_ ACQUIRED_AFTER(foo->foo_mu_); + + public: + void Test1() { + foo->foo_mu_.Lock(); + bar_mu_.Lock(); + bar_mu_.Unlock(); + foo->foo_mu_.Unlock(); + } +}; + +void main() { + Bar bar; + bar.Test1(); +} +} // end namespace thread_annot_lock_49 + +namespace thread_annot_lock_61_modified { + // Modified to fix the compiler errors + // Test the fix for a bug introduced by the support of pass-by-reference + // paramters. + struct Foo { Foo &operator<< (bool) {return *this;} }; + Foo &getFoo(); + struct Bar { Foo &func () {return getFoo();} }; + struct Bas { void operator& (Foo &) {} }; + void mumble() + { + Bas() & Bar().func() << "" << ""; + Bas() & Bar().func() << ""; + } +} // end namespace thread_annot_lock_61_modified + + +namespace thread_annot_lock_65 { +// Test the fix for a bug in the support of allowing reader locks for +// non-const, non-modifying overload functions. (We didn't handle the builtin +// properly.) +enum MyFlags { + Zero, + One, + Two, + Three, + Four, + Five, + Six, + Seven, + Eight, + Nine +}; + +inline MyFlags +operator|(MyFlags a, MyFlags b) +{ + return MyFlags(static_cast<int>(a) | static_cast<int>(b)); +} + +inline MyFlags& +operator|=(MyFlags& a, MyFlags b) +{ + return a = a | b; +} +} // end namespace thread_annot_lock_65 + +namespace thread_annot_lock_66_modified { +// Modified: Moved annotation to function defn +// Test annotations on out-of-line definitions of member functions where the +// annotations refer to locks that are also data members in the class. +Mutex mu; + +class Foo { + public: + int method1(int i) SHARED_LOCKS_REQUIRED(mu1, mu, mu2); + int data GUARDED_BY(mu1); + Mutex *mu1; + Mutex *mu2; +}; + +int Foo::method1(int i) +{ + return data + i; +} + +void main() +{ + Foo a; + + a.mu2->Lock(); + a.mu1->Lock(); + mu.Lock(); + a.method1(1); + mu.Unlock(); + a.mu1->Unlock(); + a.mu2->Unlock(); +} +} // end namespace thread_annot_lock_66_modified + +namespace thread_annot_lock_68_modified { +// Test a fix to a bug in the delayed name binding with nested template +// instantiation. We use a stack to make sure a name is not resolved to an +// inner context. +template <typename T> +class Bar { + Mutex mu_; +}; + +template <typename T> +class Foo { + public: + void func(T x) { + mu_.Lock(); + count_ = x; + mu_.Unlock(); + } + + private: + T count_ GUARDED_BY(mu_); + Bar<T> bar_; + Mutex mu_; +}; + +void main() +{ + Foo<int> *foo; + foo->func(5); +} +} // end namespace thread_annot_lock_68_modified + +namespace thread_annot_lock_30_modified { +// Test delay parsing of lock attribute arguments with nested classes. +// Modified: trylocks replaced with exclusive_lock_fun +int a = 0; + +class Bar { + struct Foo; + + public: + void MyLock() EXCLUSIVE_LOCK_FUNCTION(mu); + + int func() { + MyLock(); +// if (foo == 0) { +// return 0; +// } + a = 5; + mu.Unlock(); + return 1; + } + + class FooBar { + int x; + int y; + }; + + private: + Mutex mu; +}; + +Bar *bar; + +void main() +{ + bar->func(); +} +} // end namespace thread_annot_lock_30_modified + +namespace thread_annot_lock_47 { +// Test the support for annotations on virtual functions. +// This is a good test case. (i.e. There should be no warning emitted by the +// compiler.) +class Base { + public: + virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_); + virtual void func2() LOCKS_EXCLUDED(mu_); + Mutex mu_; +}; + +class Child : public Base { + public: + virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_); + virtual void func2() LOCKS_EXCLUDED(mu_); +}; + +void main() { + Child *c; + Base *b = c; + + b->mu_.Lock(); + b->func1(); + b->mu_.Unlock(); + b->func2(); + + c->mu_.Lock(); + c->func1(); + c->mu_.Unlock(); + c->func2(); +} +} // end namespace thread_annot_lock_47 + +//-----------------------------------------// +// Tests which produce errors +//-----------------------------------------// + +namespace thread_annot_lock_13 { +Mutex mu1; +Mutex mu2; + +int g GUARDED_BY(mu1); +int w GUARDED_BY(mu2); + +class Foo { + public: + void bar() LOCKS_EXCLUDED(mu_, mu1); + int foo() SHARED_LOCKS_REQUIRED(mu_) EXCLUSIVE_LOCKS_REQUIRED(mu2); + + private: + int a_ GUARDED_BY(mu_); + public: + Mutex mu_ ACQUIRED_AFTER(mu1); +}; + +int Foo::foo() +{ + int res; + w = 5; + res = a_ + 5; + return res; +} + +void Foo::bar() +{ + int x; + mu_.Lock(); + x = foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'mu2'}} + a_ = x + 1; + mu_.Unlock(); + if (x > 5) { + mu1.Lock(); + g = 2; + mu1.Unlock(); + } +} + +void main() +{ + Foo f1, *f2; + f1.mu_.Lock(); + f1.bar(); // expected-warning {{cannot call function 'bar' while mutex 'mu_' is locked}} + mu2.Lock(); + f1.foo(); + mu2.Unlock(); + f1.mu_.Unlock(); + f2->mu_.Lock(); + f2->bar(); // expected-warning {{cannot call function 'bar' while mutex 'mu_' is locked}} + f2->mu_.Unlock(); + mu2.Lock(); + w = 2; + mu2.Unlock(); +} +} // end namespace thread_annot_lock_13 + +namespace thread_annot_lock_18_modified { +// Modified: Trylocks removed +// Test the ability to distnguish between the same lock field of +// different objects of a class. + class Bar { + public: + bool MyLock() EXCLUSIVE_LOCK_FUNCTION(mu1_); + void MyUnlock() UNLOCK_FUNCTION(mu1_); + int a_ GUARDED_BY(mu1_); + + private: + Mutex mu1_; +}; + +Bar *b1, *b2; + +void func() +{ + b1->MyLock(); + b1->a_ = 5; + b2->a_ = 3; // expected-warning {{writing variable 'a_' requires locking 'mu1_' exclusively}} + b2->MyLock(); + b2->MyUnlock(); + b1->MyUnlock(); +} +} // end namespace thread_annot_lock_18_modified + +namespace thread_annot_lock_21 { +// Test various usage of GUARDED_BY and PT_GUARDED_BY annotations, especially +// uses in class definitions. +Mutex mu; + +class Bar { + public: + int a_ GUARDED_BY(mu1_); + int b_; + int *q PT_GUARDED_BY(mu); + Mutex mu1_ ACQUIRED_AFTER(mu); +}; + +Bar b1, *b3; +int *p GUARDED_BY(mu) PT_GUARDED_BY(mu); + +int res GUARDED_BY(mu) = 5; + +int func(int i) +{ + int x; + b3->mu1_.Lock(); + res = b1.a_ + b3->b_; // expected-warning {{reading variable 'a_' requires locking 'mu1_'}} \ + // expected-warning {{writing variable 'res' requires locking 'mu' exclusively}} + *p = i; // expected-warning {{reading variable 'p' requires locking 'mu'}} \ + // expected-warning {{writing the value pointed to by 'p' requires locking 'mu' exclusively}} + b1.a_ = res + b3->b_; // expected-warning {{reading variable 'res' requires locking 'mu'}} \ + // expected-warning {{writing variable 'a_' requires locking 'mu1_' exclusively}} + b3->b_ = *b1.q; // expected-warning {{reading the value pointed to by 'q' requires locking 'mu'}} + b3->mu1_.Unlock(); + b1.b_ = res; // expected-warning {{reading variable 'res' requires locking 'mu'}} + x = res; // expected-warning {{reading variable 'res' requires locking 'mu'}} + return x; +} +} // end namespace thread_annot_lock_21 + +namespace thread_annot_lock_35_modified { +// Test the analyzer's ability to distinguish the lock field of different +// objects. +class Foo { + private: + Mutex lock_; + int a_ GUARDED_BY(lock_); + + public: + void Func(Foo* child) LOCKS_EXCLUDED(lock_) { + Foo *new_foo = new Foo; + + lock_.Lock(); + + child->Func(new_foo); // There shouldn't be any warning here as the + // acquired lock is not in child. + child->bar(7); // expected-warning {{calling function 'bar' requires exclusive lock on 'lock_'}} + child->a_ = 5; // expected-warning {{writing variable 'a_' requires locking 'lock_' exclusively}} + lock_.Unlock(); + } + + void bar(int y) EXCLUSIVE_LOCKS_REQUIRED(lock_) { + a_ = y; + } +}; + +Foo *x; + +void main() { + Foo *child = new Foo; + x->Func(child); +} +} // end namespace thread_annot_lock_35_modified + +namespace thread_annot_lock_36_modified { +// Modified to move the annotations to function defns. +// Test the analyzer's ability to distinguish the lock field of different +// objects +class Foo { + private: + Mutex lock_; + int a_ GUARDED_BY(lock_); + + public: + void Func(Foo* child) LOCKS_EXCLUDED(lock_); + void bar(int y) EXCLUSIVE_LOCKS_REQUIRED(lock_); +}; + +void Foo::Func(Foo* child) { + Foo *new_foo = new Foo; + + lock_.Lock(); + + child->lock_.Lock(); + child->Func(new_foo); // expected-warning {{cannot call function 'Func' while mutex 'lock_' is locked}} + child->bar(7); + child->a_ = 5; + child->lock_.Unlock(); + + lock_.Unlock(); +} + +void Foo::bar(int y) { + a_ = y; +} + + +Foo *x; + +void main() { + Foo *child = new Foo; + x->Func(child); +} +} // end namespace thread_annot_lock_36_modified + + +namespace thread_annot_lock_42 { +// Test support of multiple lock attributes of the same kind on a decl. +class Foo { + private: + Mutex mu1, mu2, mu3; + int x GUARDED_BY(mu1) GUARDED_BY(mu2); + int y GUARDED_BY(mu2); + + void f2() LOCKS_EXCLUDED(mu1) LOCKS_EXCLUDED(mu2) LOCKS_EXCLUDED(mu3) { + mu2.Lock(); + y = 2; + mu2.Unlock(); + } + + public: + void f1() EXCLUSIVE_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1) { + x = 5; + f2(); // expected-warning {{cannot call function 'f2' while mutex 'mu1' is locked}} \ + // expected-warning {{cannot call function 'f2' while mutex 'mu2' is locked}} + } +}; + +Foo *foo; + +void func() +{ + foo->f1(); // expected-warning {{calling function 'f1' requires exclusive lock on 'mu2'}} \ + // expected-warning {{calling function 'f1' requires exclusive lock on 'mu1'}} +} +} // end namespace thread_annot_lock_42 + +namespace thread_annot_lock_46 { +// Test the support for annotations on virtual functions. +class Base { + public: + virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_); + virtual void func2() LOCKS_EXCLUDED(mu_); + Mutex mu_; +}; + +class Child : public Base { + public: + virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_); + virtual void func2() LOCKS_EXCLUDED(mu_); +}; + +void main() { + Child *c; + Base *b = c; + + b->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'mu_'}} + b->mu_.Lock(); + b->func2(); // expected-warning {{cannot call function 'func2' while mutex 'mu_' is locked}} + b->mu_.Unlock(); + + c->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'mu_'}} + c->mu_.Lock(); + c->func2(); // expected-warning {{cannot call function 'func2' while mutex 'mu_' is locked}} + c->mu_.Unlock(); +} +} // end namespace thread_annot_lock_46 + +namespace thread_annot_lock_67_modified { +// Modified: attributes on definitions moved to declarations +// Test annotations on out-of-line definitions of member functions where the +// annotations refer to locks that are also data members in the class. +Mutex mu; +Mutex mu3; + +class Foo { + public: + int method1(int i) SHARED_LOCKS_REQUIRED(mu1, mu, mu2, mu3); + int data GUARDED_BY(mu1); + Mutex *mu1; + Mutex *mu2; +}; + +int Foo::method1(int i) { + return data + i; +} + +void main() +{ + Foo a; + a.method1(1); // expected-warning {{calling function 'method1' requires shared lock on 'mu1'}} \ + // expected-warning {{calling function 'method1' requires shared lock on 'mu'}} \ + // expected-warning {{calling function 'method1' requires shared lock on 'mu2'}} \ + // expected-warning {{calling function 'method1' requires shared lock on 'mu3'}} +} +} // end namespace thread_annot_lock_67_modified + + +namespace substitution_test { + class MyData { + public: + Mutex mu; + + void lockData() __attribute__((exclusive_lock_function(mu))) { } + void unlockData() __attribute__((unlock_function(mu))) { } + + void doSomething() __attribute__((exclusive_locks_required(mu))) { } + }; + + + class DataLocker { + public: + void lockData (MyData *d) __attribute__((exclusive_lock_function(d->mu))) { } + void unlockData(MyData *d) __attribute__((unlock_function(d->mu))) { } + }; + + + class Foo { + public: + void foo(MyData* d) __attribute__((exclusive_locks_required(d->mu))) { } + + void bar1(MyData* d) { + d->lockData(); + foo(d); + d->unlockData(); + } + + void bar2(MyData* d) { + DataLocker dlr; + dlr.lockData(d); + foo(d); + dlr.unlockData(d); + } + + void bar3(MyData* d1, MyData* d2) { + DataLocker dlr; + dlr.lockData(d1); // expected-note {{mutex acquired here}} + dlr.unlockData(d2); // \ + // expected-warning {{unlocking 'mu' that was not locked}} + } // expected-warning {{mutex 'mu' is still locked at the end of function}} + + void bar4(MyData* d1, MyData* d2) { + DataLocker dlr; + dlr.lockData(d1); + foo(d2); // \ + // expected-warning {{calling function 'foo' requires exclusive lock on 'mu'}} + dlr.unlockData(d1); + } + }; +} // end namespace substituation_test + + + +namespace constructor_destructor_tests { + Mutex fooMu; + int myVar GUARDED_BY(fooMu); + + class Foo { + public: + Foo() __attribute__((exclusive_lock_function(fooMu))) { } + ~Foo() __attribute__((unlock_function(fooMu))) { } + }; + + void fooTest() { + Foo foo; + myVar = 0; + } +} + + +namespace invalid_lock_expression_test { + +class LOCKABLE MyLockable { +public: + MyLockable() __attribute__((exclusive_lock_function)) { } + ~MyLockable() { } +}; + +// create an empty lock expression +void foo() { + MyLockable lock; // \ + // expected-warning {{cannot resolve lock expression}} +} + +} // end namespace invalid_lock_expression_test + +namespace template_member_test { + + struct S { int n; }; + struct T { + Mutex m; + S *s GUARDED_BY(this->m); + }; + Mutex m; + struct U { + union { + int n; + }; + } *u GUARDED_BY(m); + + template<typename U> + struct IndirectLock { + int DoNaughtyThings(T *t) { + u->n = 0; // expected-warning {{reading variable 'u' requires locking 'm'}} + return t->s->n; // expected-warning {{reading variable 's' requires locking 'm'}} + } + }; + + template struct IndirectLock<int>; // expected-note {{here}} + + struct V { + void f(int); + void f(double); + + Mutex m; + V *p GUARDED_BY(this->m); + }; + template<typename U> struct W { + V v; + void f(U u) { + v.p->f(u); // expected-warning {{reading variable 'p' requires locking 'm'}} + } + }; + template struct W<int>; // expected-note {{here}} + +} + +namespace test_scoped_lockable { + +struct TestScopedLockable { + Mutex mu1; + Mutex mu2; + int a __attribute__((guarded_by(mu1))); + int b __attribute__((guarded_by(mu2))); + + bool getBool(); + + void foo1() { + MutexLock mulock(&mu1); + a = 5; + } + + void foo2() { + ReaderMutexLock mulock1(&mu1); + if (getBool()) { + MutexLock mulock2a(&mu2); + b = a + 1; + } + else { + MutexLock mulock2b(&mu2); + b = a + 2; + } + } + + void foo3() { + MutexLock mulock_a(&mu1); + MutexLock mulock_b(&mu1); // \ + // expected-warning {{locking 'mu1' that is already locked}} + } // expected-warning {{unlocking 'mu1' that was not locked}} + + void foo4() { + MutexLock mulock1(&mu1), mulock2(&mu2); + a = b+1; + b = a+1; + } +}; + +} // end namespace test_scoped_lockable + + +namespace FunctionAttrTest { + +class Foo { +public: + Mutex mu_; + int a GUARDED_BY(mu_); +}; + +Foo fooObj; + +void foo() EXCLUSIVE_LOCKS_REQUIRED(fooObj.mu_); + +void bar() { + foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'mu_'}} + fooObj.mu_.Lock(); + foo(); + fooObj.mu_.Unlock(); +} + +}; // end namespace FunctionAttrTest + + +struct TestTryLock { + Mutex mu; + int a GUARDED_BY(mu); + bool cond; + + void foo1() { + if (mu.TryLock()) { + a = 1; + mu.Unlock(); + } + } + + void foo2() { + if (!mu.TryLock()) return; + a = 2; + mu.Unlock(); + } + + void foo3() { + bool b = mu.TryLock(); + if (b) { + a = 3; + mu.Unlock(); + } + } + + void foo4() { + bool b = mu.TryLock(); + if (!b) return; + a = 4; + mu.Unlock(); + } + + void foo5() { + while (mu.TryLock()) { + a = a + 1; + mu.Unlock(); + } + } + + void foo6() { + bool b = mu.TryLock(); + b = !b; + if (b) return; + a = 6; + mu.Unlock(); + } + + void foo7() { + bool b1 = mu.TryLock(); + bool b2 = !b1; + bool b3 = !b2; + if (b3) { + a = 7; + mu.Unlock(); + } + } + + // Test use-def chains: join points + void foo8() { + bool b = mu.TryLock(); + bool b2 = b; + if (cond) + b = true; + if (b) { // b should be unknown at this point, becuase of the join point + a = 8; // expected-warning {{writing variable 'a' requires locking 'mu' exclusively}} + } + if (b2) { // b2 should be known at this point. + a = 8; + mu.Unlock(); + } + } + + // Test use-def-chains: back edges + void foo9() { + bool b = mu.TryLock(); + + for (int i = 0; i < 10; ++i); + + if (b) { // b is still known, because the loop doesn't alter it + a = 9; + mu.Unlock(); + } + } + + // Test use-def chains: back edges + void foo10() { + bool b = mu.TryLock(); + + while (cond) { + if (b) { // b should be uknown at this point b/c of the loop + a = 10; // expected-warning {{writing variable 'a' requires locking 'mu' exclusively}} + } + b = !b; + } + } +}; // end TestTrylock + + +namespace TestTemplateAttributeInstantiation { + +class Foo1 { +public: + Mutex mu_; + int a GUARDED_BY(mu_); +}; + +class Foo2 { +public: + int a GUARDED_BY(mu_); + Mutex mu_; +}; + + +class Bar { +public: + // Test non-dependent expressions in attributes on template functions + template <class T> + void barND(Foo1 *foo, T *fooT) EXCLUSIVE_LOCKS_REQUIRED(foo->mu_) { + foo->a = 0; + } + + // Test dependent expressions in attributes on template functions + template <class T> + void barD(Foo1 *foo, T *fooT) EXCLUSIVE_LOCKS_REQUIRED(fooT->mu_) { + fooT->a = 0; + } +}; + + +template <class T> +class BarT { +public: + Foo1 fooBase; + T fooBaseT; + + // Test non-dependent expression in ordinary method on template class + void barND() EXCLUSIVE_LOCKS_REQUIRED(fooBase.mu_) { + fooBase.a = 0; + } + + // Test dependent expressions in ordinary methods on template class + void barD() EXCLUSIVE_LOCKS_REQUIRED(fooBaseT.mu_) { + fooBaseT.a = 0; + } + + // Test dependent expressions in template method in template class + template <class T2> + void barTD(T2 *fooT) EXCLUSIVE_LOCKS_REQUIRED(fooBaseT.mu_, fooT->mu_) { + fooBaseT.a = 0; + fooT->a = 0; + } +}; + +template <class T> +class Cell { +public: + Mutex mu_; + // Test dependent guarded_by + T data GUARDED_BY(mu_); + + void fooEx() EXCLUSIVE_LOCKS_REQUIRED(mu_) { + data = 0; + } + + void foo() { + mu_.Lock(); + data = 0; + mu_.Unlock(); + } +}; + +void test() { + Bar b; + BarT<Foo2> bt; + Foo1 f1; + Foo2 f2; + + f1.mu_.Lock(); + f2.mu_.Lock(); + bt.fooBase.mu_.Lock(); + bt.fooBaseT.mu_.Lock(); + + b.barND(&f1, &f2); + b.barD(&f1, &f2); + bt.barND(); + bt.barD(); + bt.barTD(&f2); + + f1.mu_.Unlock(); + bt.barTD(&f1); // \ + // expected-warning {{calling function 'barTD' requires exclusive lock on 'mu_'}} + + bt.fooBase.mu_.Unlock(); + bt.fooBaseT.mu_.Unlock(); + f2.mu_.Unlock(); + + Cell<int> cell; + cell.data = 0; // \ + // expected-warning {{writing variable 'data' requires locking 'mu_' exclusively}} + cell.foo(); + cell.mu_.Lock(); + cell.fooEx(); + cell.mu_.Unlock(); +} + + +template <class T> +class CellDelayed { +public: + // Test dependent guarded_by + T data GUARDED_BY(mu_); + static T static_data GUARDED_BY(static_mu_); + + void fooEx(CellDelayed<T> *other) EXCLUSIVE_LOCKS_REQUIRED(mu_, other->mu_) { + this->data = other->data; + } + + template <class T2> + void fooExT(CellDelayed<T2> *otherT) EXCLUSIVE_LOCKS_REQUIRED(mu_, otherT->mu_) { + this->data = otherT->data; + } + + void foo() { + mu_.Lock(); + data = 0; + mu_.Unlock(); + } + + Mutex mu_; + static Mutex static_mu_; +}; + +void testDelayed() { + CellDelayed<int> celld; + CellDelayed<int> celld2; + celld.foo(); + celld.mu_.Lock(); + celld2.mu_.Lock(); + + celld.fooEx(&celld2); + celld.fooExT(&celld2); + + celld2.mu_.Unlock(); + celld.mu_.Unlock(); +} + +}; // end namespace TestTemplateAttributeInstantiation + + +namespace FunctionDeclDefTest { + +class Foo { +public: + Mutex mu_; + int a GUARDED_BY(mu_); + + virtual void foo1(Foo *f_declared) EXCLUSIVE_LOCKS_REQUIRED(f_declared->mu_); +}; + +// EXCLUSIVE_LOCKS_REQUIRED should be applied, and rewritten to f_defined->mu_ +void Foo::foo1(Foo *f_defined) { + f_defined->a = 0; +}; + +void test() { + Foo myfoo; + myfoo.foo1(&myfoo); // \ + // expected-warning {{calling function 'foo1' requires exclusive lock on 'mu_'}} + myfoo.mu_.Lock(); + myfoo.foo1(&myfoo); + myfoo.mu_.Unlock(); +} + +}; + +namespace GoingNative { + + struct __attribute__((lockable)) mutex { + void lock() __attribute__((exclusive_lock_function)); + void unlock() __attribute__((unlock_function)); + // ... + }; + bool foo(); + bool bar(); + mutex m; + void test() { + m.lock(); + while (foo()) { + m.unlock(); + // ... + if (bar()) { + // ... + if (foo()) + continue; // expected-warning {{expecting mutex 'm' to be locked at start of each loop}} + //... + } + // ... + m.lock(); // expected-note {{mutex acquired here}} + } + m.unlock(); + } + +} + + + +namespace FunctionDefinitionTest { + +class Foo { +public: + void foo1(); + void foo2(); + void foo3(Foo *other); + + template<class T> + void fooT1(const T& dummy1); + + template<class T> + void fooT2(const T& dummy2) EXCLUSIVE_LOCKS_REQUIRED(mu_); + + Mutex mu_; + int a GUARDED_BY(mu_); +}; + +template<class T> +class FooT { +public: + void foo(); + + Mutex mu_; + T a GUARDED_BY(mu_); +}; + + +void Foo::foo1() NO_THREAD_SAFETY_ANALYSIS { + a = 1; +} + +void Foo::foo2() EXCLUSIVE_LOCKS_REQUIRED(mu_) { + a = 2; +} + +void Foo::foo3(Foo *other) EXCLUSIVE_LOCKS_REQUIRED(other->mu_) { + other->a = 3; +} + +template<class T> +void Foo::fooT1(const T& dummy1) EXCLUSIVE_LOCKS_REQUIRED(mu_) { + a = dummy1; +} + +/* TODO -- uncomment with template instantiation of attributes. +template<class T> +void Foo::fooT2(const T& dummy2) { + a = dummy2; +} +*/ + +void fooF1(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_) { + f->a = 1; +} + +void fooF2(Foo *f); +void fooF2(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_) { + f->a = 2; +} + +void fooF3(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_); +void fooF3(Foo *f) { + f->a = 3; +} + +template<class T> +void FooT<T>::foo() EXCLUSIVE_LOCKS_REQUIRED(mu_) { + a = 0; +} + +void test() { + int dummy = 0; + Foo myFoo; + + myFoo.foo2(); // \ + // expected-warning {{calling function 'foo2' requires exclusive lock on 'mu_'}} + myFoo.foo3(&myFoo); // \ + // expected-warning {{calling function 'foo3' requires exclusive lock on 'mu_'}} + myFoo.fooT1(dummy); // \ + // expected-warning {{calling function 'fooT1' requires exclusive lock on 'mu_'}} + + // FIXME: uncomment with template instantiation of attributes patch + // myFoo.fooT2(dummy); // expected warning + + fooF1(&myFoo); // \ + // expected-warning {{calling function 'fooF1' requires exclusive lock on 'mu_'}} + fooF2(&myFoo); // \ + // expected-warning {{calling function 'fooF2' requires exclusive lock on 'mu_'}} + fooF3(&myFoo); // \ + // expected-warning {{calling function 'fooF3' requires exclusive lock on 'mu_'}} + + myFoo.mu_.Lock(); + myFoo.foo2(); + myFoo.foo3(&myFoo); + myFoo.fooT1(dummy); + + // FIXME: uncomment with template instantiation of attributes patch + // myFoo.fooT2(dummy); + + fooF1(&myFoo); + fooF2(&myFoo); + fooF3(&myFoo); + myFoo.mu_.Unlock(); + + FooT<int> myFooT; + myFooT.foo(); // \ + // expected-warning {{calling function 'foo' requires exclusive lock on 'mu_'}} +} + +} // end namespace FunctionDefinitionTest + + +namespace SelfLockingTest { + +class LOCKABLE MyLock { +public: + int foo GUARDED_BY(this); + + void lock() EXCLUSIVE_LOCK_FUNCTION(); + void unlock() UNLOCK_FUNCTION(); + + void doSomething() { + this->lock(); // allow 'this' as a lock expression + foo = 0; + doSomethingElse(); + this->unlock(); + } + + void doSomethingElse() EXCLUSIVE_LOCKS_REQUIRED(this) { + foo = 1; + }; + + void test() { + foo = 2; // \ + // expected-warning {{writing variable 'foo' requires locking 'this' exclusively}} + } +}; + + +class LOCKABLE MyLock2 { +public: + Mutex mu_; + int foo GUARDED_BY(this); + + // don't check inside lock and unlock functions + void lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.Lock(); } + void unlock() UNLOCK_FUNCTION() { mu_.Unlock(); } + + // don't check inside constructors and destructors + MyLock2() { foo = 1; } + ~MyLock2() { foo = 0; } +}; + + +} // end namespace SelfLockingTest + + +namespace InvalidNonstatic { + +// Forward decl here causes bogus "invalid use of non-static data member" +// on reference to mutex_ in guarded_by attribute. +class Foo; + +class Foo { + Mutex* mutex_; + + int foo __attribute__((guarded_by(mutex_))); +}; + +} // end namespace InvalidNonStatic + + +namespace NoReturnTest { + +bool condition(); +void fatal() __attribute__((noreturn)); + +Mutex mu_; + +void test1() { + MutexLock lock(&mu_); + if (condition()) { + fatal(); + return; + } +} + +} // end namespace NoReturnTest + + +namespace TestMultiDecl { + +class Foo { +public: + int GUARDED_BY(mu_) a; + int GUARDED_BY(mu_) b, c; + + void foo() { + a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + b = 0; // \ + // expected-warning {{writing variable 'b' requires locking 'mu_' exclusively}} + c = 0; // \ + // expected-warning {{writing variable 'c' requires locking 'mu_' exclusively}} + } + +private: + Mutex mu_; +}; + +} // end namespace TestMultiDecl + + +namespace WarnNoDecl { + +class Foo { + void foo(int a); __attribute__(( // \ + // expected-warning {{declaration does not declare anything}} + exclusive_locks_required(a))); // \ + // expected-warning {{attribute exclusive_locks_required ignored}} +}; + +} // end namespace WarnNoDecl + + + +namespace MoreLockExpressions { + +class Foo { +public: + Mutex mu_; + int a GUARDED_BY(mu_); +}; + +class Bar { +public: + int b; + Foo* f; + + Foo& getFoo() { return *f; } + Foo& getFoo2(int c) { return *f; } + Foo& getFoo3(int c, int d) { return *f; } + + Foo& getFooey() { return *f; } +}; + +Foo& getBarFoo(Bar &bar, int c) { return bar.getFoo2(c); } + +void test() { + Foo foo; + Foo *fooArray; + Bar bar; + int a; + int b; + int c; + + bar.getFoo().mu_.Lock(); + bar.getFoo().a = 0; + bar.getFoo().mu_.Unlock(); + + (bar.getFoo().mu_).Lock(); // test parenthesis + bar.getFoo().a = 0; + (bar.getFoo().mu_).Unlock(); + + bar.getFoo2(a).mu_.Lock(); + bar.getFoo2(a).a = 0; + bar.getFoo2(a).mu_.Unlock(); + + bar.getFoo3(a, b).mu_.Lock(); + bar.getFoo3(a, b).a = 0; + bar.getFoo3(a, b).mu_.Unlock(); + + getBarFoo(bar, a).mu_.Lock(); + getBarFoo(bar, a).a = 0; + getBarFoo(bar, a).mu_.Unlock(); + + bar.getFoo2(10).mu_.Lock(); + bar.getFoo2(10).a = 0; + bar.getFoo2(10).mu_.Unlock(); + + bar.getFoo2(a + 1).mu_.Lock(); + bar.getFoo2(a + 1).a = 0; + bar.getFoo2(a + 1).mu_.Unlock(); + + (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock(); + (a > 0 ? fooArray[1] : fooArray[b]).a = 0; + (a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock(); + + bar.getFoo().mu_.Lock(); + bar.getFooey().a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + bar.getFoo().mu_.Unlock(); + + bar.getFoo2(a).mu_.Lock(); + bar.getFoo2(b).a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + bar.getFoo2(a).mu_.Unlock(); + + bar.getFoo3(a, b).mu_.Lock(); + bar.getFoo3(a, c).a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + bar.getFoo3(a, b).mu_.Unlock(); + + getBarFoo(bar, a).mu_.Lock(); + getBarFoo(bar, b).a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + getBarFoo(bar, a).mu_.Unlock(); + + (a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock(); + (a > 0 ? fooArray[b] : fooArray[c]).a = 0; // \ + // expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}} + (a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock(); +} + + +} // end namespace + + diff --git a/clang/test/SemaCXX/warn-thread-safety-parsing.cpp b/clang/test/SemaCXX/warn-thread-safety-parsing.cpp new file mode 100644 index 0000000..c2fa1d7 --- /dev/null +++ b/clang/test/SemaCXX/warn-thread-safety-parsing.cpp @@ -0,0 +1,1345 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wthread-safety %s + +#define LOCKABLE __attribute__ ((lockable)) +#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) +#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) +#define GUARDED_VAR __attribute__ ((guarded_var)) +#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x))) +#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var)) +#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) +#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) +#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__))) +#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__))) +#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__))) +#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__))) +#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__))) +#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) +#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) +#define EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__ ((exclusive_locks_required(__VA_ARGS__))) +#define SHARED_LOCKS_REQUIRED(...) \ + __attribute__ ((shared_locks_required(__VA_ARGS__))) +#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) + + +class __attribute__((lockable)) Mu { + public: + void Lock(); +}; + +class UnlockableMu{ +}; + +class MuWrapper { + public: + Mu mu; + Mu getMu() { + return mu; + } + Mu * getMuPointer() { + return μ + } +}; + + +class MuDoubleWrapper { + public: + MuWrapper* muWrapper; + MuWrapper* getWrapper() { + return muWrapper; + } +}; + +Mu mu1; +UnlockableMu umu; +Mu mu2; +MuWrapper muWrapper; +MuDoubleWrapper muDoubleWrapper; +Mu* muPointer; +Mu ** muDoublePointer = & muPointer; +Mu& muRef = mu1; + +//---------------------------------------// +// Scoping tests +//--------------------------------------// + +class Foo { + Mu foomu; + void needLock() __attribute__((exclusive_lock_function(foomu))); +}; + +class Foo2 { + void needLock() __attribute__((exclusive_lock_function(foomu))); + Mu foomu; +}; + +class Bar { + Mu barmu; + Mu barmu2 __attribute__((acquired_after(barmu))); +}; + + +//-----------------------------------------// +// No Thread Safety Analysis (noanal) // +//-----------------------------------------// + +// FIXME: Right now we cannot parse attributes put on function definitions +// We would like to patch this at some point. + +#if !__has_attribute(no_thread_safety_analysis) +#error "Should support no_thread_safety_analysis attribute" +#endif + +void noanal_fun() __attribute__((no_thread_safety_analysis)); + +void noanal_fun_args() __attribute__((no_thread_safety_analysis(1))); // \ + // expected-error {{attribute takes no arguments}} + +int noanal_testfn(int y) __attribute__((no_thread_safety_analysis)); + +int noanal_testfn(int y) { + int x __attribute__((no_thread_safety_analysis)) = y; // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} + return x; +}; + +int noanal_test_var __attribute__((no_thread_safety_analysis)); // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} + +class NoanalFoo { + private: + int test_field __attribute__((no_thread_safety_analysis)); // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} + void test_method() __attribute__((no_thread_safety_analysis)); +}; + +class __attribute__((no_thread_safety_analysis)) NoanalTestClass { // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} +}; + +void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} + + +//-----------------------------------------// +// Guarded Var Attribute (gv) +//-----------------------------------------// + +#if !__has_attribute(guarded_var) +#error "Should support guarded_var attribute" +#endif + +int gv_var_noargs __attribute__((guarded_var)); + +int gv_var_args __attribute__((guarded_var(1))); // \ + // expected-error {{attribute takes no arguments}} + +class GVFoo { + private: + int gv_field_noargs __attribute__((guarded_var)); + int gv_field_args __attribute__((guarded_var(1))); // \ + // expected-error {{attribute takes no arguments}} +}; + +class __attribute__((guarded_var)) GV { // \ + // expected-warning {{'guarded_var' attribute only applies to fields and global variables}} +}; + +void gv_function() __attribute__((guarded_var)); // \ + // expected-warning {{'guarded_var' attribute only applies to fields and global variables}} + +void gv_function_params(int gv_lvar __attribute__((guarded_var))); // \ + // expected-warning {{'guarded_var' attribute only applies to fields and global variables}} + +int gv_testfn(int y){ + int x __attribute__((guarded_var)) = y; // \ + // expected-warning {{'guarded_var' attribute only applies to fields and global variables}} + return x; +} + +//-----------------------------------------// +// Pt Guarded Var Attribute (pgv) +//-----------------------------------------// + +//FIXME: add support for boost::scoped_ptr<int> fancyptr and references + +#if !__has_attribute(pt_guarded_var) +#error "Should support pt_guarded_var attribute" +#endif + +int *pgv_pt_var_noargs __attribute__((pt_guarded_var)); + +int pgv_var_noargs __attribute__((pt_guarded_var)); // \ + // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}} + +class PGVFoo { + private: + int *pt_field_noargs __attribute__((pt_guarded_var)); + int field_noargs __attribute__((pt_guarded_var)); // \ + // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}} + int *gv_field_args __attribute__((pt_guarded_var(1))); // \ + // expected-error {{attribute takes no arguments}} +}; + +class __attribute__((pt_guarded_var)) PGV { // \ + // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} +}; + +int *pgv_var_args __attribute__((pt_guarded_var(1))); // \ + // expected-error {{attribute takes no arguments}} + + +void pgv_function() __attribute__((pt_guarded_var)); // \ + // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} + +void pgv_function_params(int *gv_lvar __attribute__((pt_guarded_var))); // \ + // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} + +void pgv_testfn(int y){ + int *x __attribute__((pt_guarded_var)) = new int(0); // \ + // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} + delete x; +} + +//-----------------------------------------// +// Lockable Attribute (l) +//-----------------------------------------// + +//FIXME: In future we may want to add support for structs, ObjC classes, etc. + +#if !__has_attribute(lockable) +#error "Should support lockable attribute" +#endif + +class __attribute__((lockable)) LTestClass { +}; + +class __attribute__((lockable (1))) LTestClass_args { // \ + // expected-error {{attribute takes no arguments}} +}; + +void l_test_function() __attribute__((lockable)); // \ + // expected-warning {{'lockable' attribute only applies to classes}} + +int l_testfn(int y) { + int x __attribute__((lockable)) = y; // \ + // expected-warning {{'lockable' attribute only applies to classes}} + return x; +} + +int l_test_var __attribute__((lockable)); // \ + // expected-warning {{'lockable' attribute only applies to classes}} + +class LFoo { + private: + int test_field __attribute__((lockable)); // \ + // expected-warning {{'lockable' attribute only applies to classes}} + void test_method() __attribute__((lockable)); // \ + // expected-warning {{'lockable' attribute only applies to classes}} +}; + + +void l_function_params(int lvar __attribute__((lockable))); // \ + // expected-warning {{'lockable' attribute only applies to classes}} + + +//-----------------------------------------// +// Scoped Lockable Attribute (sl) +//-----------------------------------------// + +#if !__has_attribute(scoped_lockable) +#error "Should support scoped_lockable attribute" +#endif + +class __attribute__((scoped_lockable)) SLTestClass { +}; + +class __attribute__((scoped_lockable (1))) SLTestClass_args { // \ + // expected-error {{attribute takes no arguments}} +}; + +void sl_test_function() __attribute__((scoped_lockable)); // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} + +int sl_testfn(int y) { + int x __attribute__((scoped_lockable)) = y; // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} + return x; +} + +int sl_test_var __attribute__((scoped_lockable)); // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} + +class SLFoo { + private: + int test_field __attribute__((scoped_lockable)); // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} + void test_method() __attribute__((scoped_lockable)); // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} +}; + + +void sl_function_params(int lvar __attribute__((scoped_lockable))); // \ + // expected-warning {{'scoped_lockable' attribute only applies to classes}} + + +//-----------------------------------------// +// Guarded By Attribute (gb) +//-----------------------------------------// + +// FIXME: Eventually, would we like this attribute to take more than 1 arg? + +#if !__has_attribute(guarded_by) +#error "Should support guarded_by attribute" +#endif + +//1. Check applied to the right types & argument number + +int gb_var_arg __attribute__((guarded_by(mu1))); + +int gb_var_args __attribute__((guarded_by(mu1, mu2))); // \ + // expected-error {{attribute takes one argument}} + +int gb_var_noargs __attribute__((guarded_by)); // \ + // expected-error {{attribute takes one argument}} + +class GBFoo { + private: + int gb_field_noargs __attribute__((guarded_by)); // \ + // expected-error {{attribute takes one argument}} + int gb_field_args __attribute__((guarded_by(mu1))); +}; + +class __attribute__((guarded_by(mu1))) GB { // \ + // expected-warning {{'guarded_by' attribute only applies to fields and global variables}} +}; + +void gb_function() __attribute__((guarded_by(mu1))); // \ + // expected-warning {{'guarded_by' attribute only applies to fields and global variables}} + +void gb_function_params(int gv_lvar __attribute__((guarded_by(mu1)))); // \ + // expected-warning {{'guarded_by' attribute only applies to fields and global variables}} + +int gb_testfn(int y){ + int x __attribute__((guarded_by(mu1))) = y; // \ + // expected-warning {{'guarded_by' attribute only applies to fields and global variables}} + return x; +} + +//2. Check argument parsing. + +// legal attribute arguments +int gb_var_arg_1 __attribute__((guarded_by(muWrapper.mu))); +int gb_var_arg_2 __attribute__((guarded_by(muDoubleWrapper.muWrapper->mu))); +int gb_var_arg_3 __attribute__((guarded_by(muWrapper.getMu()))); +int gb_var_arg_4 __attribute__((guarded_by(*muWrapper.getMuPointer()))); +int gb_var_arg_5 __attribute__((guarded_by(&mu1))); +int gb_var_arg_6 __attribute__((guarded_by(muRef))); +int gb_var_arg_7 __attribute__((guarded_by(muDoubleWrapper.getWrapper()->getMu()))); +int gb_var_arg_8 __attribute__((guarded_by(muPointer))); + + +// illegal attribute arguments +int gb_var_arg_bad_1 __attribute__((guarded_by(1))); // \ + // expected-warning {{'guarded_by' attribute requires arguments that are class type or point to class type; type here is 'int'}} +int gb_var_arg_bad_2 __attribute__((guarded_by("mu"))); // \ + // expected-warning {{'guarded_by' attribute requires arguments that are class type or point to class type; type here is 'const char [3]'}} +int gb_var_arg_bad_3 __attribute__((guarded_by(muDoublePointer))); // \ + // expected-warning {{'guarded_by' attribute requires arguments that are class type or point to class type; type here is 'class Mu **'}} +int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \ + // expected-warning {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute; type here is 'class UnlockableMu'}} + +//3. +// Thread Safety analysis tests + + +//-----------------------------------------// +// Pt Guarded By Attribute (pgb) +//-----------------------------------------// + +#if !__has_attribute(pt_guarded_by) +#error "Should support pt_guarded_by attribute" +#endif + +//1. Check applied to the right types & argument number + +int *pgb_var_noargs __attribute__((pt_guarded_by)); // \ + // expected-error {{attribute takes one argument}} + +int *pgb_ptr_var_arg __attribute__((pt_guarded_by(mu1))); + +int *pgb_ptr_var_args __attribute__((guarded_by(mu1, mu2))); // \ + // expected-error {{attribute takes one argument}} + +int pgb_var_args __attribute__((pt_guarded_by(mu1))); // \ + // expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}} + +class PGBFoo { + private: + int *pgb_field_noargs __attribute__((pt_guarded_by)); // \ + // expected-error {{attribute takes one argument}} + int *pgb_field_args __attribute__((pt_guarded_by(mu1))); +}; + +class __attribute__((pt_guarded_by(mu1))) PGB { // \ + // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} +}; + +void pgb_function() __attribute__((pt_guarded_by(mu1))); // \ + // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} + +void pgb_function_params(int gv_lvar __attribute__((pt_guarded_by(mu1)))); // \ + // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} + +void pgb_testfn(int y){ + int *x __attribute__((pt_guarded_by(mu1))) = new int(0); // \ + // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} + delete x; +} + +//2. Check argument parsing. + +// legal attribute arguments +int * pgb_var_arg_1 __attribute__((pt_guarded_by(muWrapper.mu))); +int * pgb_var_arg_2 __attribute__((pt_guarded_by(muDoubleWrapper.muWrapper->mu))); +int * pgb_var_arg_3 __attribute__((pt_guarded_by(muWrapper.getMu()))); +int * pgb_var_arg_4 __attribute__((pt_guarded_by(*muWrapper.getMuPointer()))); +int * pgb_var_arg_5 __attribute__((pt_guarded_by(&mu1))); +int * pgb_var_arg_6 __attribute__((pt_guarded_by(muRef))); +int * pgb_var_arg_7 __attribute__((pt_guarded_by(muDoubleWrapper.getWrapper()->getMu()))); +int * pgb_var_arg_8 __attribute__((pt_guarded_by(muPointer))); + + +// illegal attribute arguments +int * pgb_var_arg_bad_1 __attribute__((pt_guarded_by(1))); // \ + // expected-warning {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} +int * pgb_var_arg_bad_2 __attribute__((pt_guarded_by("mu"))); // \ + // expected-warning {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} +int * pgb_var_arg_bad_3 __attribute__((pt_guarded_by(muDoublePointer))); // \ + // expected-warning {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} +int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \ + // expected-warning {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + +//-----------------------------------------// +// Acquired After (aa) +//-----------------------------------------// + +// FIXME: Would we like this attribute to take more than 1 arg? + +#if !__has_attribute(acquired_after) +#error "Should support acquired_after attribute" +#endif + +Mu mu_aa __attribute__((acquired_after(mu1))); + +Mu aa_var_noargs __attribute__((acquired_after)); // \ + // expected-error {{attribute takes at least 1 argument}} + +class AAFoo { + private: + Mu aa_field_noargs __attribute__((acquired_after)); // \ + // expected-error {{attribute takes at least 1 argument}} + Mu aa_field_args __attribute__((acquired_after(mu1))); +}; + +class __attribute__((acquired_after(mu1))) AA { // \ + // expected-warning {{'acquired_after' attribute only applies to fields and global variables}} +}; + +void aa_function() __attribute__((acquired_after(mu1))); // \ + // expected-warning {{'acquired_after' attribute only applies to fields and global variables}} + +void aa_function_params(int gv_lvar __attribute__((acquired_after(mu1)))); // \ + // expected-warning {{'acquired_after' attribute only applies to fields and global variables}} + +void aa_testfn(int y){ + Mu x __attribute__((acquired_after(mu1))) = Mu(); // \ + // expected-warning {{'acquired_after' attribute only applies to fields and global variables}} +} + +//Check argument parsing. + +// legal attribute arguments +Mu aa_var_arg_1 __attribute__((acquired_after(muWrapper.mu))); +Mu aa_var_arg_2 __attribute__((acquired_after(muDoubleWrapper.muWrapper->mu))); +Mu aa_var_arg_3 __attribute__((acquired_after(muWrapper.getMu()))); +Mu aa_var_arg_4 __attribute__((acquired_after(*muWrapper.getMuPointer()))); +Mu aa_var_arg_5 __attribute__((acquired_after(&mu1))); +Mu aa_var_arg_6 __attribute__((acquired_after(muRef))); +Mu aa_var_arg_7 __attribute__((acquired_after(muDoubleWrapper.getWrapper()->getMu()))); +Mu aa_var_arg_8 __attribute__((acquired_after(muPointer))); + + +// illegal attribute arguments +Mu aa_var_arg_bad_1 __attribute__((acquired_after(1))); // \ + // expected-warning {{'acquired_after' attribute requires arguments that are class type or point to class type}} +Mu aa_var_arg_bad_2 __attribute__((acquired_after("mu"))); // \ + // expected-warning {{'acquired_after' attribute requires arguments that are class type or point to class type}} +Mu aa_var_arg_bad_3 __attribute__((acquired_after(muDoublePointer))); // \ + // expected-warning {{'acquired_after' attribute requires arguments that are class type or point to class type}} +Mu aa_var_arg_bad_4 __attribute__((acquired_after(umu))); // \ + // expected-warning {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}} +UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \ + // expected-warning {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}} + +//-----------------------------------------// +// Acquired Before (ab) +//-----------------------------------------// + +#if !__has_attribute(acquired_before) +#error "Should support acquired_before attribute" +#endif + +Mu mu_ab __attribute__((acquired_before(mu1))); + +Mu ab_var_noargs __attribute__((acquired_before)); // \ + // expected-error {{attribute takes at least 1 argument}} + +class ABFoo { + private: + Mu ab_field_noargs __attribute__((acquired_before)); // \ + // expected-error {{attribute takes at least 1 argument}} + Mu ab_field_args __attribute__((acquired_before(mu1))); +}; + +class __attribute__((acquired_before(mu1))) AB { // \ + // expected-warning {{'acquired_before' attribute only applies to fields and global variables}} +}; + +void ab_function() __attribute__((acquired_before(mu1))); // \ + // expected-warning {{'acquired_before' attribute only applies to fields and global variables}} + +void ab_function_params(int gv_lvar __attribute__((acquired_before(mu1)))); // \ + // expected-warning {{'acquired_before' attribute only applies to fields and global variables}} + +void ab_testfn(int y){ + Mu x __attribute__((acquired_before(mu1))) = Mu(); // \ + // expected-warning {{'acquired_before' attribute only applies to fields and global variables}} +} + +// Note: illegal int ab_int __attribute__((acquired_before(mu1))) will +// be taken care of by warnings that ab__int is not lockable. + +//Check argument parsing. + +// legal attribute arguments +Mu ab_var_arg_1 __attribute__((acquired_before(muWrapper.mu))); +Mu ab_var_arg_2 __attribute__((acquired_before(muDoubleWrapper.muWrapper->mu))); +Mu ab_var_arg_3 __attribute__((acquired_before(muWrapper.getMu()))); +Mu ab_var_arg_4 __attribute__((acquired_before(*muWrapper.getMuPointer()))); +Mu ab_var_arg_5 __attribute__((acquired_before(&mu1))); +Mu ab_var_arg_6 __attribute__((acquired_before(muRef))); +Mu ab_var_arg_7 __attribute__((acquired_before(muDoubleWrapper.getWrapper()->getMu()))); +Mu ab_var_arg_8 __attribute__((acquired_before(muPointer))); + + +// illegal attribute arguments +Mu ab_var_arg_bad_1 __attribute__((acquired_before(1))); // \ + // expected-warning {{'acquired_before' attribute requires arguments that are class type or point to class type}} +Mu ab_var_arg_bad_2 __attribute__((acquired_before("mu"))); // \ + // expected-warning {{'acquired_before' attribute requires arguments that are class type or point to class type}} +Mu ab_var_arg_bad_3 __attribute__((acquired_before(muDoublePointer))); // \ + // expected-warning {{'acquired_before' attribute requires arguments that are class type or point to class type}} +Mu ab_var_arg_bad_4 __attribute__((acquired_before(umu))); // \ + // expected-warning {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}} +UnlockableMu ab_var_arg_bad_5 __attribute__((acquired_before(mu_ab))); // \ + // expected-warning {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}} + + +//-----------------------------------------// +// Exclusive Lock Function (elf) +//-----------------------------------------// + +#if !__has_attribute(exclusive_lock_function) +#error "Should support exclusive_lock_function attribute" +#endif + +// takes zero or more arguments, all locks (vars/fields) + +void elf_function() __attribute__((exclusive_lock_function)); + +void elf_function_args() __attribute__((exclusive_lock_function(mu1, mu2))); + +int elf_testfn(int y) __attribute__((exclusive_lock_function)); + +int elf_testfn(int y) { + int x __attribute__((exclusive_lock_function)) = y; // \ + // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} + return x; +}; + +int elf_test_var __attribute__((exclusive_lock_function)); // \ + // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} + +class ElfFoo { + private: + int test_field __attribute__((exclusive_lock_function)); // \ + // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} + void test_method() __attribute__((exclusive_lock_function)); +}; + +class __attribute__((exclusive_lock_function)) ElfTestClass { // \ + // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} +}; + +void elf_fun_params(int lvar __attribute__((exclusive_lock_function))); // \ + // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} + +// Check argument parsing. + +// legal attribute arguments +int elf_function_1() __attribute__((exclusive_lock_function(muWrapper.mu))); +int elf_function_2() __attribute__((exclusive_lock_function(muDoubleWrapper.muWrapper->mu))); +int elf_function_3() __attribute__((exclusive_lock_function(muWrapper.getMu()))); +int elf_function_4() __attribute__((exclusive_lock_function(*muWrapper.getMuPointer()))); +int elf_function_5() __attribute__((exclusive_lock_function(&mu1))); +int elf_function_6() __attribute__((exclusive_lock_function(muRef))); +int elf_function_7() __attribute__((exclusive_lock_function(muDoubleWrapper.getWrapper()->getMu()))); +int elf_function_8() __attribute__((exclusive_lock_function(muPointer))); +int elf_function_9(Mu x) __attribute__((exclusive_lock_function(1))); +int elf_function_9(Mu x, Mu y) __attribute__((exclusive_lock_function(1,2))); + + +// illegal attribute arguments +int elf_function_bad_2() __attribute__((exclusive_lock_function("mu"))); // \ + // expected-warning {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}} +int elf_function_bad_3() __attribute__((exclusive_lock_function(muDoublePointer))); // \ + // expected-warning {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}} +int elf_function_bad_4() __attribute__((exclusive_lock_function(umu))); // \ + // expected-warning {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} + +int elf_function_bad_1() __attribute__((exclusive_lock_function(1))); // \ + // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} +int elf_function_bad_5(Mu x) __attribute__((exclusive_lock_function(0))); // \ + // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} +int elf_function_bad_6(Mu x, Mu y) __attribute__((exclusive_lock_function(0))); // \ + // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} +int elf_function_bad_7() __attribute__((exclusive_lock_function(0))); // \ + // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} + + +//-----------------------------------------// +// Shared Lock Function (slf) +//-----------------------------------------// + +#if !__has_attribute(shared_lock_function) +#error "Should support shared_lock_function attribute" +#endif + +// takes zero or more arguments, all locks (vars/fields) + +void slf_function() __attribute__((shared_lock_function)); + +void slf_function_args() __attribute__((shared_lock_function(mu1, mu2))); + +int slf_testfn(int y) __attribute__((shared_lock_function)); + +int slf_testfn(int y) { + int x __attribute__((shared_lock_function)) = y; // \ + // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} + return x; +}; + +int slf_test_var __attribute__((shared_lock_function)); // \ + // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} + +void slf_fun_params(int lvar __attribute__((shared_lock_function))); // \ + // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} + +class SlfFoo { + private: + int test_field __attribute__((shared_lock_function)); // \ + // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} + void test_method() __attribute__((shared_lock_function)); +}; + +class __attribute__((shared_lock_function)) SlfTestClass { // \ + // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int slf_function_1() __attribute__((shared_lock_function(muWrapper.mu))); +int slf_function_2() __attribute__((shared_lock_function(muDoubleWrapper.muWrapper->mu))); +int slf_function_3() __attribute__((shared_lock_function(muWrapper.getMu()))); +int slf_function_4() __attribute__((shared_lock_function(*muWrapper.getMuPointer()))); +int slf_function_5() __attribute__((shared_lock_function(&mu1))); +int slf_function_6() __attribute__((shared_lock_function(muRef))); +int slf_function_7() __attribute__((shared_lock_function(muDoubleWrapper.getWrapper()->getMu()))); +int slf_function_8() __attribute__((shared_lock_function(muPointer))); +int slf_function_9(Mu x) __attribute__((shared_lock_function(1))); +int slf_function_9(Mu x, Mu y) __attribute__((shared_lock_function(1,2))); + + +// illegal attribute arguments +int slf_function_bad_2() __attribute__((shared_lock_function("mu"))); // \ + // expected-warning {{'shared_lock_function' attribute requires arguments that are class type or point to class type}} +int slf_function_bad_3() __attribute__((shared_lock_function(muDoublePointer))); // \ + // expected-warning {{'shared_lock_function' attribute requires arguments that are class type or point to class type}} +int slf_function_bad_4() __attribute__((shared_lock_function(umu))); // \ + // expected-warning {{'shared_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} + +int slf_function_bad_1() __attribute__((shared_lock_function(1))); // \ + // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} +int slf_function_bad_5(Mu x) __attribute__((shared_lock_function(0))); // \ + // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} +int slf_function_bad_6(Mu x, Mu y) __attribute__((shared_lock_function(0))); // \ + // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} +int slf_function_bad_7() __attribute__((shared_lock_function(0))); // \ + // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} + + +//-----------------------------------------// +// Exclusive TryLock Function (etf) +//-----------------------------------------// + +#if !__has_attribute(exclusive_trylock_function) +#error "Should support exclusive_trylock_function attribute" +#endif + +// takes a mandatory boolean or integer argument specifying the retval +// plus an optional list of locks (vars/fields) + +void etf_function() __attribute__((exclusive_trylock_function)); // \ + // expected-error {{attribute takes at least 1 argument}} + +void etf_function_args() __attribute__((exclusive_trylock_function(1, mu2))); + +void etf_function_arg() __attribute__((exclusive_trylock_function(1))); + +int etf_testfn(int y) __attribute__((exclusive_trylock_function(1))); + +int etf_testfn(int y) { + int x __attribute__((exclusive_trylock_function(1))) = y; // \ + // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} + return x; +}; + +int etf_test_var __attribute__((exclusive_trylock_function(1))); // \ + // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} + +class EtfFoo { + private: + int test_field __attribute__((exclusive_trylock_function(1))); // \ + // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} + void test_method() __attribute__((exclusive_trylock_function(1))); +}; + +class __attribute__((exclusive_trylock_function(1))) EtfTestClass { // \ + // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} +}; + +void etf_fun_params(int lvar __attribute__((exclusive_trylock_function(1)))); // \ + // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} + +// Check argument parsing. + +// legal attribute arguments +int etf_function_1() __attribute__((exclusive_trylock_function(1, muWrapper.mu))); +int etf_function_2() __attribute__((exclusive_trylock_function(1, muDoubleWrapper.muWrapper->mu))); +int etf_function_3() __attribute__((exclusive_trylock_function(1, muWrapper.getMu()))); +int etf_function_4() __attribute__((exclusive_trylock_function(1, *muWrapper.getMuPointer()))); +int etf_function_5() __attribute__((exclusive_trylock_function(1, &mu1))); +int etf_function_6() __attribute__((exclusive_trylock_function(1, muRef))); +int etf_function_7() __attribute__((exclusive_trylock_function(1, muDoubleWrapper.getWrapper()->getMu()))); +int etf_functetfn_8() __attribute__((exclusive_trylock_function(1, muPointer))); +int etf_function_9() __attribute__((exclusive_trylock_function(true))); + + +// illegal attribute arguments +int etf_function_bad_1() __attribute__((exclusive_trylock_function(mu1))); // \ + // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} +int etf_function_bad_2() __attribute__((exclusive_trylock_function("mu"))); // \ + // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} +int etf_function_bad_3() __attribute__((exclusive_trylock_function(muDoublePointer))); // \ + // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} + +int etf_function_bad_4() __attribute__((exclusive_trylock_function(1, "mu"))); // \ + // expected-warning {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}} +int etf_function_bad_5() __attribute__((exclusive_trylock_function(1, muDoublePointer))); // \ + // expected-warning {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}} +int etf_function_bad_6() __attribute__((exclusive_trylock_function(1, umu))); // \ + // expected-warning {{'exclusive_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + +//-----------------------------------------// +// Shared TryLock Function (stf) +//-----------------------------------------// + +#if !__has_attribute(shared_trylock_function) +#error "Should support shared_trylock_function attribute" +#endif + +// takes a mandatory boolean or integer argument specifying the retval +// plus an optional list of locks (vars/fields) + +void stf_function() __attribute__((shared_trylock_function)); // \ + // expected-error {{attribute takes at least 1 argument}} + +void stf_function_args() __attribute__((shared_trylock_function(1, mu2))); + +void stf_function_arg() __attribute__((shared_trylock_function(1))); + +int stf_testfn(int y) __attribute__((shared_trylock_function(1))); + +int stf_testfn(int y) { + int x __attribute__((shared_trylock_function(1))) = y; // \ + // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} + return x; +}; + +int stf_test_var __attribute__((shared_trylock_function(1))); // \ + // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} + +void stf_fun_params(int lvar __attribute__((shared_trylock_function(1)))); // \ + // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} + + +class StfFoo { + private: + int test_field __attribute__((shared_trylock_function(1))); // \ + // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} + void test_method() __attribute__((shared_trylock_function(1))); +}; + +class __attribute__((shared_trylock_function(1))) StfTestClass { // \ + // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int stf_function_1() __attribute__((shared_trylock_function(1, muWrapper.mu))); +int stf_function_2() __attribute__((shared_trylock_function(1, muDoubleWrapper.muWrapper->mu))); +int stf_function_3() __attribute__((shared_trylock_function(1, muWrapper.getMu()))); +int stf_function_4() __attribute__((shared_trylock_function(1, *muWrapper.getMuPointer()))); +int stf_function_5() __attribute__((shared_trylock_function(1, &mu1))); +int stf_function_6() __attribute__((shared_trylock_function(1, muRef))); +int stf_function_7() __attribute__((shared_trylock_function(1, muDoubleWrapper.getWrapper()->getMu()))); +int stf_function_8() __attribute__((shared_trylock_function(1, muPointer))); +int stf_function_9() __attribute__((shared_trylock_function(true))); + + +// illegal attribute arguments +int stf_function_bad_1() __attribute__((shared_trylock_function(mu1))); // \ + // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} +int stf_function_bad_2() __attribute__((shared_trylock_function("mu"))); // \ + // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} +int stf_function_bad_3() __attribute__((shared_trylock_function(muDoublePointer))); // \ + // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} + +int stf_function_bad_4() __attribute__((shared_trylock_function(1, "mu"))); // \ + // expected-warning {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}} +int stf_function_bad_5() __attribute__((shared_trylock_function(1, muDoublePointer))); // \ + // expected-warning {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}} +int stf_function_bad_6() __attribute__((shared_trylock_function(1, umu))); // \ + // expected-warning {{'shared_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + +//-----------------------------------------// +// Unlock Function (uf) +//-----------------------------------------// + +#if !__has_attribute(unlock_function) +#error "Should support unlock_function attribute" +#endif + +// takes zero or more arguments, all locks (vars/fields) + +void uf_function() __attribute__((unlock_function)); + +void uf_function_args() __attribute__((unlock_function(mu1, mu2))); + +int uf_testfn(int y) __attribute__((unlock_function)); + +int uf_testfn(int y) { + int x __attribute__((unlock_function)) = y; // \ + // expected-warning {{'unlock_function' attribute only applies to functions and methods}} + return x; +}; + +int uf_test_var __attribute__((unlock_function)); // \ + // expected-warning {{'unlock_function' attribute only applies to functions and methods}} + +class UfFoo { + private: + int test_field __attribute__((unlock_function)); // \ + // expected-warning {{'unlock_function' attribute only applies to functions and methods}} + void test_method() __attribute__((unlock_function)); +}; + +class __attribute__((no_thread_safety_analysis)) UfTestClass { // \ + // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} +}; + +void uf_fun_params(int lvar __attribute__((unlock_function))); // \ + // expected-warning {{'unlock_function' attribute only applies to functions and methods}} + +// Check argument parsing. + +// legal attribute arguments +int uf_function_1() __attribute__((unlock_function(muWrapper.mu))); +int uf_function_2() __attribute__((unlock_function(muDoubleWrapper.muWrapper->mu))); +int uf_function_3() __attribute__((unlock_function(muWrapper.getMu()))); +int uf_function_4() __attribute__((unlock_function(*muWrapper.getMuPointer()))); +int uf_function_5() __attribute__((unlock_function(&mu1))); +int uf_function_6() __attribute__((unlock_function(muRef))); +int uf_function_7() __attribute__((unlock_function(muDoubleWrapper.getWrapper()->getMu()))); +int uf_function_8() __attribute__((unlock_function(muPointer))); +int uf_function_9(Mu x) __attribute__((unlock_function(1))); +int uf_function_9(Mu x, Mu y) __attribute__((unlock_function(1,2))); + + +// illegal attribute arguments +int uf_function_bad_2() __attribute__((unlock_function("mu"))); // \ + // expected-warning {{'unlock_function' attribute requires arguments that are class type or point to class type}} +int uf_function_bad_3() __attribute__((unlock_function(muDoublePointer))); // \ + // expected-warning {{'unlock_function' attribute requires arguments that are class type or point to class type}} +int uf_function_bad_4() __attribute__((unlock_function(umu))); // \ + // expected-warning {{'unlock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} + +int uf_function_bad_1() __attribute__((unlock_function(1))); // \ + // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}} +int uf_function_bad_5(Mu x) __attribute__((unlock_function(0))); // \ + // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} +int uf_function_bad_6(Mu x, Mu y) __attribute__((unlock_function(0))); // \ + // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} +int uf_function_bad_7() __attribute__((unlock_function(0))); // \ + // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}} + + +//-----------------------------------------// +// Lock Returned (lr) +//-----------------------------------------// + +#if !__has_attribute(lock_returned) +#error "Should support lock_returned attribute" +#endif + +// Takes exactly one argument, a var/field + +void lr_function() __attribute__((lock_returned)); // \ + // expected-error {{attribute takes one argument}} + +void lr_function_arg() __attribute__((lock_returned(mu1))); + +void lr_function_args() __attribute__((lock_returned(mu1, mu2))); // \ + // expected-error {{attribute takes one argument}} + +int lr_testfn(int y) __attribute__((lock_returned(mu1))); + +int lr_testfn(int y) { + int x __attribute__((lock_returned(mu1))) = y; // \ + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} + return x; +}; + +int lr_test_var __attribute__((lock_returned(mu1))); // \ + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} + +void lr_fun_params(int lvar __attribute__((lock_returned(mu1)))); // \ + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} + +class LrFoo { + private: + int test_field __attribute__((lock_returned(mu1))); // \ + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} + void test_method() __attribute__((lock_returned(mu1))); +}; + +class __attribute__((lock_returned(mu1))) LrTestClass { // \ + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int lr_function_1() __attribute__((lock_returned(muWrapper.mu))); +int lr_function_2() __attribute__((lock_returned(muDoubleWrapper.muWrapper->mu))); +int lr_function_3() __attribute__((lock_returned(muWrapper.getMu()))); +int lr_function_4() __attribute__((lock_returned(*muWrapper.getMuPointer()))); +int lr_function_5() __attribute__((lock_returned(&mu1))); +int lr_function_6() __attribute__((lock_returned(muRef))); +int lr_function_7() __attribute__((lock_returned(muDoubleWrapper.getWrapper()->getMu()))); +int lr_function_8() __attribute__((lock_returned(muPointer))); + + +// illegal attribute arguments +int lr_function_bad_1() __attribute__((lock_returned(1))); // \ + // expected-warning {{'lock_returned' attribute requires arguments that are class type or point to class type}} +int lr_function_bad_2() __attribute__((lock_returned("mu"))); // \ + // expected-warning {{'lock_returned' attribute requires arguments that are class type or point to class type}} +int lr_function_bad_3() __attribute__((lock_returned(muDoublePointer))); // \ + // expected-warning {{'lock_returned' attribute requires arguments that are class type or point to class type}} +int lr_function_bad_4() __attribute__((lock_returned(umu))); // \ + // expected-warning {{'lock_returned' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + + +//-----------------------------------------// +// Locks Excluded (le) +//-----------------------------------------// + +#if !__has_attribute(locks_excluded) +#error "Should support locks_excluded attribute" +#endif + +// takes one or more arguments, all locks (vars/fields) + +void le_function() __attribute__((locks_excluded)); // \ + // expected-error {{attribute takes at least 1 argument}} + +void le_function_arg() __attribute__((locks_excluded(mu1))); + +void le_function_args() __attribute__((locks_excluded(mu1, mu2))); + +int le_testfn(int y) __attribute__((locks_excluded(mu1))); + +int le_testfn(int y) { + int x __attribute__((locks_excluded(mu1))) = y; // \ + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} + return x; +}; + +int le_test_var __attribute__((locks_excluded(mu1))); // \ + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} + +void le_fun_params(int lvar __attribute__((locks_excluded(mu1)))); // \ + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} + +class LeFoo { + private: + int test_field __attribute__((locks_excluded(mu1))); // \ + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} + void test_method() __attribute__((locks_excluded(mu1))); +}; + +class __attribute__((locks_excluded(mu1))) LeTestClass { // \ + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int le_function_1() __attribute__((locks_excluded(muWrapper.mu))); +int le_function_2() __attribute__((locks_excluded(muDoubleWrapper.muWrapper->mu))); +int le_function_3() __attribute__((locks_excluded(muWrapper.getMu()))); +int le_function_4() __attribute__((locks_excluded(*muWrapper.getMuPointer()))); +int le_function_5() __attribute__((locks_excluded(&mu1))); +int le_function_6() __attribute__((locks_excluded(muRef))); +int le_function_7() __attribute__((locks_excluded(muDoubleWrapper.getWrapper()->getMu()))); +int le_function_8() __attribute__((locks_excluded(muPointer))); + + +// illegal attribute arguments +int le_function_bad_1() __attribute__((locks_excluded(1))); // \ + // expected-warning {{'locks_excluded' attribute requires arguments that are class type or point to class type}} +int le_function_bad_2() __attribute__((locks_excluded("mu"))); // \ + // expected-warning {{'locks_excluded' attribute requires arguments that are class type or point to class type}} +int le_function_bad_3() __attribute__((locks_excluded(muDoublePointer))); // \ + // expected-warning {{'locks_excluded' attribute requires arguments that are class type or point to class type}} +int le_function_bad_4() __attribute__((locks_excluded(umu))); // \ + // expected-warning {{'locks_excluded' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + + +//-----------------------------------------// +// Exclusive Locks Required (elr) +//-----------------------------------------// + +#if !__has_attribute(exclusive_locks_required) +#error "Should support exclusive_locks_required attribute" +#endif + +// takes one or more arguments, all locks (vars/fields) + +void elr_function() __attribute__((exclusive_locks_required)); // \ + // expected-error {{attribute takes at least 1 argument}} + +void elr_function_arg() __attribute__((exclusive_locks_required(mu1))); + +void elr_function_args() __attribute__((exclusive_locks_required(mu1, mu2))); + +int elr_testfn(int y) __attribute__((exclusive_locks_required(mu1))); + +int elr_testfn(int y) { + int x __attribute__((exclusive_locks_required(mu1))) = y; // \ + // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} + return x; +}; + +int elr_test_var __attribute__((exclusive_locks_required(mu1))); // \ + // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} + +void elr_fun_params(int lvar __attribute__((exclusive_locks_required(mu1)))); // \ + // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} + +class ElrFoo { + private: + int test_field __attribute__((exclusive_locks_required(mu1))); // \ + // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} + void test_method() __attribute__((exclusive_locks_required(mu1))); +}; + +class __attribute__((exclusive_locks_required(mu1))) ElrTestClass { // \ + // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int elr_function_1() __attribute__((exclusive_locks_required(muWrapper.mu))); +int elr_function_2() __attribute__((exclusive_locks_required(muDoubleWrapper.muWrapper->mu))); +int elr_function_3() __attribute__((exclusive_locks_required(muWrapper.getMu()))); +int elr_function_4() __attribute__((exclusive_locks_required(*muWrapper.getMuPointer()))); +int elr_function_5() __attribute__((exclusive_locks_required(&mu1))); +int elr_function_6() __attribute__((exclusive_locks_required(muRef))); +int elr_function_7() __attribute__((exclusive_locks_required(muDoubleWrapper.getWrapper()->getMu()))); +int elr_function_8() __attribute__((exclusive_locks_required(muPointer))); + + +// illegal attribute arguments +int elr_function_bad_1() __attribute__((exclusive_locks_required(1))); // \ + // expected-warning {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} +int elr_function_bad_2() __attribute__((exclusive_locks_required("mu"))); // \ + // expected-warning {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} +int elr_function_bad_3() __attribute__((exclusive_locks_required(muDoublePointer))); // \ + // expected-warning {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} +int elr_function_bad_4() __attribute__((exclusive_locks_required(umu))); // \ + // expected-warning {{'exclusive_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + + + +//-----------------------------------------// +// Shared Locks Required (slr) +//-----------------------------------------// + +#if !__has_attribute(shared_locks_required) +#error "Should support shared_locks_required attribute" +#endif + +// takes one or more arguments, all locks (vars/fields) + +void slr_function() __attribute__((shared_locks_required)); // \ + // expected-error {{attribute takes at least 1 argument}} + +void slr_function_arg() __attribute__((shared_locks_required(mu1))); + +void slr_function_args() __attribute__((shared_locks_required(mu1, mu2))); + +int slr_testfn(int y) __attribute__((shared_locks_required(mu1))); + +int slr_testfn(int y) { + int x __attribute__((shared_locks_required(mu1))) = y; // \ + // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} + return x; +}; + +int slr_test_var __attribute__((shared_locks_required(mu1))); // \ + // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} + +void slr_fun_params(int lvar __attribute__((shared_locks_required(mu1)))); // \ + // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} + +class SlrFoo { + private: + int test_field __attribute__((shared_locks_required(mu1))); // \ + // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} + void test_method() __attribute__((shared_locks_required(mu1))); +}; + +class __attribute__((shared_locks_required(mu1))) SlrTestClass { // \ + // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} +}; + +// Check argument parsing. + +// legal attribute arguments +int slr_function_1() __attribute__((shared_locks_required(muWrapper.mu))); +int slr_function_2() __attribute__((shared_locks_required(muDoubleWrapper.muWrapper->mu))); +int slr_function_3() __attribute__((shared_locks_required(muWrapper.getMu()))); +int slr_function_4() __attribute__((shared_locks_required(*muWrapper.getMuPointer()))); +int slr_function_5() __attribute__((shared_locks_required(&mu1))); +int slr_function_6() __attribute__((shared_locks_required(muRef))); +int slr_function_7() __attribute__((shared_locks_required(muDoubleWrapper.getWrapper()->getMu()))); +int slr_function_8() __attribute__((shared_locks_required(muPointer))); + + +// illegal attribute arguments +int slr_function_bad_1() __attribute__((shared_locks_required(1))); // \ + // expected-warning {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} +int slr_function_bad_2() __attribute__((shared_locks_required("mu"))); // \ + // expected-warning {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} +int slr_function_bad_3() __attribute__((shared_locks_required(muDoublePointer))); // \ + // expected-warning {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} +int slr_function_bad_4() __attribute__((shared_locks_required(umu))); // \ + // expected-warning {{'shared_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}} + + +//-----------------------------------------// +// Regression tests for unusual cases. +//-----------------------------------------// + +int trivially_false_edges(bool b) { + // Create NULL (never taken) edges in CFG + if (false) return 1; + else return 2; +} + +// Possible Clang bug -- method pointer in template parameter +class UnFoo { +public: + void foo(); +}; + +template<void (UnFoo::*methptr)()> +class MCaller { +public: + static void call_method_ptr(UnFoo *f) { + // FIXME: Possible Clang bug: + // getCalleeDecl() returns NULL in the following case: + (f->*methptr)(); + } +}; + +void call_method_ptr_inst(UnFoo* f) { + MCaller<&UnFoo::foo>::call_method_ptr(f); +} + +int temp; +void empty_back_edge() { + // Create a back edge to a block with with no statements + for (;;) { + ++temp; + if (temp > 10) break; + } +} + +struct Foomger { + void operator++(); +}; + +struct Foomgoper { + Foomger f; + + bool done(); + void invalid_back_edge() { + do { + // FIXME: Possible Clang bug: + // The first statement in this basic block has no source location + ++f; + } while (!done()); + } +}; + + +//----------------------------------------------------- +// Parsing of member variables and function parameters +//------------------------------------------------------ + +Mu gmu; + +class StaticMu { + static Mu statmu; +}; + +class FooLate { +public: + void foo1() __attribute__((exclusive_locks_required(gmu))) { } + void foo2() __attribute__((exclusive_locks_required(mu))) { } + void foo3(Mu *m) __attribute__((exclusive_locks_required(m))) { } + void foo3(FooLate *f) __attribute__((exclusive_locks_required(f->mu))) { } + void foo4(FooLate *f) __attribute__((exclusive_locks_required(f->mu))); + + static void foo5() __attribute__((exclusive_locks_required(mu))); // \ + // expected-error {{'this' cannot be implicitly used in a static member function declaration}} + + template <class T> + void foo6() __attribute__((exclusive_locks_required(T::statmu))) { } + + template <class T> + void foo7(T* f) __attribute__((exclusive_locks_required(f->mu))) { } + + int a __attribute__((guarded_by(gmu))); + int b __attribute__((guarded_by(mu))); + int c __attribute__((guarded_by(this->mu))); + + Mu mu; +}; + +//------------------------- +// Empty argument lists +//------------------------- + +class __attribute__((lockable)) EmptyArgListsTest { + void lock() __attribute__((exclusive_lock_function())) { } + void unlock() __attribute__((unlock_function())) { } +}; + + +namespace FunctionDefinitionParseTest { +// Test parsing of attributes on function definitions. + +class Foo { +public: + Mu mu_; + void foo1(); + void foo2(Foo *f); +}; + +template <class T> +class Bar { +public: + Mu mu_; + void bar(); +}; + +void Foo::foo1() __attribute__((exclusive_locks_required(mu_))) { } +void Foo::foo2(Foo *f) __attribute__((exclusive_locks_required(f->mu_))) { } + +template <class T> +void Bar<T>::bar() __attribute__((exclusive_locks_required(mu_))) { } + +void baz(Foo *f) __attribute__((exclusive_locks_required(f->mu_))) { } + +} // end namespace + + +namespace TestMultiDecl { + +class Foo { +public: + int __attribute__((guarded_by(mu_))) a; + int __attribute__((guarded_by(mu_))) b, c; + +private: + Mu mu_; +}; + + +namespace NestedClassLateDecl { + +class Foo { + class Bar { + int a GUARDED_BY(mu); + int b GUARDED_BY(fooMuStatic); + + void bar() EXCLUSIVE_LOCKS_REQUIRED(mu) { a = 0; } + void bar2(Bar* b) EXCLUSIVE_LOCKS_REQUIRED(b->mu) { b->a = 0; } + void bar3(Foo* f) EXCLUSIVE_LOCKS_REQUIRED(f->fooMu) { f->a = 0; } + + Mu mu; + }; + + int a GUARDED_BY(fooMu); + Mu fooMu; + static Mu fooMuStatic; +}; + +} + +} // end namespace TestMultiDecl + diff --git a/clang/test/SemaCXX/warn-unreachable.cpp b/clang/test/SemaCXX/warn-unreachable.cpp new file mode 100644 index 0000000..f36300a --- /dev/null +++ b/clang/test/SemaCXX/warn-unreachable.cpp @@ -0,0 +1,109 @@ +// RUN: %clang_cc1 %s -fcxx-exceptions -fexceptions -fsyntax-only -verify -fblocks -Wunreachable-code -Wno-unused-value + +int &halt() __attribute__((noreturn)); +int &live(); +int dead(); +int liveti() throw(int); +int (*livetip)() throw(int); + +int test1() { + try { + live(); + } catch (int i) { + live(); + } + return 1; +} + +void test2() { + try { + live(); + } catch (int i) { + live(); + } + try { + liveti(); + } catch (int i) { + live(); + } + try { + livetip(); + } catch (int i) { + live(); + } + throw 1; + dead(); // expected-warning {{will never be executed}} +} + + +void test3() { + halt() + --; // expected-warning {{will never be executed}} + // FIXME: The unreachable part is just the '?', but really all of this + // code is unreachable and shouldn't be separately reported. + halt() // expected-warning {{will never be executed}} + ? + dead() : dead(); + live(), + float + (halt()); // expected-warning {{will never be executed}} +} + +void test4() { + struct S { + int mem; + } s; + S &foor(); + halt(), foor()// expected-warning {{will never be executed}} + .mem; +} + +void test5() { + struct S { + int mem; + } s; + S &foor() __attribute__((noreturn)); + foor() + .mem; // expected-warning {{will never be executed}} +} + +void test6() { + struct S { + ~S() { } + S(int i) { } + }; + live(), + S + (halt()); // expected-warning {{will never be executed}} +} + +// Don't warn about unreachable code in template instantiations, as +// they may only be unreachable in that specific instantiation. +void isUnreachable(); + +template <typename T> void test_unreachable_templates() { + T::foo(); + isUnreachable(); // no-warning +} + +struct TestUnreachableA { + static void foo() __attribute__((noreturn)); +}; +struct TestUnreachableB { + static void foo(); +}; + +void test_unreachable_templates_harness() { + test_unreachable_templates<TestUnreachableA>(); + test_unreachable_templates<TestUnreachableB>(); +} + +// Do warn about explict template specializations, as they represent +// actual concrete functions that somebody wrote. + +template <typename T> void funcToSpecialize() {} +template <> void funcToSpecialize<int>() { + halt(); + dead(); // expected-warning {{will never be executed}} +} + diff --git a/clang/test/SemaCXX/warn-unused-comparison.cpp b/clang/test/SemaCXX/warn-unused-comparison.cpp new file mode 100644 index 0000000..0153f21 --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-comparison.cpp @@ -0,0 +1,94 @@ +// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -Wno-unused -Wunused-comparison %s + +struct A { + bool operator==(const A&); + bool operator!=(const A&); + A operator|=(const A&); + operator bool(); +}; + +void test() { + int x, *p; + A a, b; + + x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + x != 7; // expected-warning {{inequality comparison result unused}} \ + // expected-note {{use '|=' to turn this inequality comparison into an or-assignment}} + 7 == x; // expected-warning {{equality comparison result unused}} + p == p; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} \ + // expected-warning {{self-comparison always evaluates to true}} + a == a; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + a == b; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + a != b; // expected-warning {{inequality comparison result unused}} \ + // expected-note {{use '|=' to turn this inequality comparison into an or-assignment}} + A() == b; // expected-warning {{equality comparison result unused}} + if (42) x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + else if (42) x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + else x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + do x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + while (false); + while (false) x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + for (x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + x == 7; // No warning -- result is used + x == 7) // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + switch (42) default: x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + switch (42) case 42: x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + switch (42) { + case 1: + case 2: + default: + case 3: + case 4: + x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + } + + (void)(x == 7); + (void)(p == p); // expected-warning {{self-comparison always evaluates to true}} + { bool b = x == 7; } + + { bool b = ({ x == 7; // expected-warning {{equality comparison result unused}} \ + // expected-note {{use '=' to turn this equality comparison into an assignment}} + x == 7; }); } // no warning on the second, its result is used! + +#define EQ(x,y) (x) == (y) + EQ(x, 5); +#undef EQ +} + +namespace PR10291 { + template<typename T> + class X + { + public: + + X() : i(0) { } + + void foo() + { + throw + i == 0u ? + 5 : 6; + } + + private: + int i; + }; + + X<int> x; +} diff --git a/clang/test/SemaCXX/warn-unused-filescoped.cpp b/clang/test/SemaCXX/warn-unused-filescoped.cpp new file mode 100644 index 0000000..dbff4b0 --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-filescoped.cpp @@ -0,0 +1,89 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-member-function %s + +static void f1(); // expected-warning{{unused}} + +namespace { + void f2(); // expected-warning{{unused}} + + void f3() { } // expected-warning{{unused}} + + struct S { + void m1() { } // expected-warning{{unused}} + void m2(); // expected-warning{{unused}} + void m3(); + S(const S&); + void operator=(const S&); + }; + + template <typename T> + struct TS { + void m(); + }; + template <> void TS<int>::m() { } // expected-warning{{unused}} + + template <typename T> + void tf() { } + template <> void tf<int>() { } // expected-warning{{unused}} + + struct VS { + virtual void vm() { } + }; + + struct SVS : public VS { + void vm() { } + }; +} + +void S::m3() { } // expected-warning{{unused}} + +static inline void f4() { } +const unsigned int cx = 0; + +static int x1; // expected-warning{{unused}} + +namespace { + int x2; // expected-warning{{unused}} + + struct S2 { + static int x; // expected-warning{{unused}} + }; + + template <typename T> + struct TS2 { + static int x; + }; + template <> int TS2<int>::x; // expected-warning{{unused}} +} + +namespace PR8841 { + // Ensure that friends of class templates are considered to have a dependent + // context and not marked unused. + namespace { + template <typename T> struct X { + friend bool operator==(const X&, const X&) { return false; } + }; + } + template <typename T> void template_test(X<T> x) { + (void)(x == x); + } + void test() { + X<int> x; + template_test(x); + } +} + +namespace test4 { + namespace { struct A {}; } + + 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/clang/test/SemaCXX/warn-unused-parameters.cpp b/clang/test/SemaCXX/warn-unused-parameters.cpp new file mode 100644 index 0000000..00ce1a9 --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-parameters.cpp @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-parameter -verify -std=c++11 %s +template<typename T> +struct X { + T f0(T x); + T f1(T x); + T f2(T); + template<typename U> U f3(U x); + template<typename U> U f4(U x); + template<typename U> U f5(U); +}; + +template<typename T> T X<T>::f0(T x) { return x; } +template<typename T> T X<T>::f1(T) { return T(); } +template<typename T> T X<T>::f2(T x) { return T(); } // expected-warning{{unused parameter 'x'}} +template<typename T> template<typename U> U X<T>::f3(U x) { return x; } +template<typename T> template<typename U> U X<T>::f4(U) { return U(); } +template<typename T> template<typename U> U X<T>::f5(U x) { return U(); } // expected-warning{{unused parameter 'x'}} + +void test_X(X<int> &x, int i) { + x.f0(i); + x.f1(i); + x.f2(i); + x.f3(i); + x.f4(i); + x.f5(i); +} + +// Make sure both parameters aren't considered unused. +template <typename... T> +static int test_pack(T... t, T... s) +{ + auto l = [&t...]() { return sizeof...(s); }; + return l(); +} diff --git a/clang/test/SemaCXX/warn-unused-result.cpp b/clang/test/SemaCXX/warn-unused-result.cpp new file mode 100644 index 0000000..d14fdf9 --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-result.cpp @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int f() __attribute__((warn_unused_result)); + +struct S { + void t() const; +}; +S g1() __attribute__((warn_unused_result)); +S *g2() __attribute__((warn_unused_result)); +S &g3() __attribute__((warn_unused_result)); + +void test() { + f(); // expected-warning {{ignoring return value}} + g1(); // expected-warning {{ignoring return value}} + g2(); // expected-warning {{ignoring return value}} + g3(); // expected-warning {{ignoring return value}} + + (void)f(); + (void)g1(); + (void)g2(); + (void)g3(); + + if (f() == 0) return; + + g1().t(); + g2()->t(); + g3().t(); + + int i = f(); + S s1 = g1(); + S *s2 = g2(); + S &s3 = g3(); + const S &s4 = g1(); +} + +struct X { + int foo() __attribute__((warn_unused_result)); +}; + +void bah() { + X x, *x2; + x.foo(); // expected-warning {{ignoring return value}} + x2->foo(); // expected-warning {{ignoring return value}} +} diff --git a/clang/test/SemaCXX/warn-unused-value.cpp b/clang/test/SemaCXX/warn-unused-value.cpp new file mode 100644 index 0000000..1c0263c --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-value.cpp @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value %s + +// PR4806 +namespace test0 { + class Box { + public: + int i; + volatile int j; + }; + + void doit() { + // pointer to volatile has side effect (thus no warning) + Box* box = new Box; + box->i; // expected-warning {{expression result unused}} + box->j; + } +} + +namespace test1 { +struct Foo { + int i; + bool operator==(const Foo& rhs) { + return i == rhs.i; + } +}; + +#define NOP(x) (x) +void b(Foo f1, Foo f2) { + NOP(f1 == f2); // expected-warning {{expression result unused}} +} +#undef NOP +} + +namespace test2 { + extern "C" { + namespace std { + template<typename T> struct basic_string { + struct X {}; + void method() const { + X* x; + &x[0]; // expected-warning {{expression result unused}} + } + }; + typedef basic_string<char> string; + void func(const std::string& str) { + str.method(); // expected-note {{in instantiation of member function}} + } + } + } +} + diff --git a/clang/test/SemaCXX/warn-unused-variables.cpp b/clang/test/SemaCXX/warn-unused-variables.cpp new file mode 100644 index 0000000..5827019 --- /dev/null +++ b/clang/test/SemaCXX/warn-unused-variables.cpp @@ -0,0 +1,124 @@ +// RUN: %clang_cc1 -fsyntax-only -Wunused-variable -verify %s +template<typename T> void f() { + T t; + t = 17; +} + +// PR5407 +struct A { A(); }; +struct B { ~B(); }; +void f() { + A a; + B b; +} + +// PR5531 +namespace PR5531 { + struct A { + }; + + struct B { + B(int); + }; + + struct C { + ~C(); + }; + + void test() { + A(); + B(17); + C(); + } +} + +template<typename T> +struct X0 { }; + +template<typename T> +void test_dependent_init(T *p) { + X0<int> i(p); + (void)i; +} + +namespace PR6948 { + template<typename T> class X; + + void f() { + X<char> str (read_from_file()); // expected-error{{use of undeclared identifier 'read_from_file'}} + } +} + +void unused_local_static() { + static int x = 0; + static int y = 0; // expected-warning{{unused variable 'y'}} +#pragma unused(x) +} + +// PR10168 +namespace PR10168 { + // We expect a warning in the definition only for non-dependent variables, and + // a warning in the instantiation only for dependent variables. + template<typename T> + struct S { + void f() { + int a; // expected-warning {{unused variable 'a'}} + T b; // expected-warning 2{{unused variable 'b'}} + } + }; + + template<typename T> + void f() { + int a; // expected-warning {{unused variable 'a'}} + T b; // expected-warning 2{{unused variable 'b'}} + } + + void g() { + S<int>().f(); // expected-note {{here}} + S<char>().f(); // expected-note {{here}} + f<int>(); // expected-note {{here}} + f<char>(); // expected-note {{here}} + } +} + +namespace PR11550 { + struct S1 { + S1(); + }; + S1 makeS1(); + void testS1(S1 a) { + // This constructor call can be elided. + S1 x = makeS1(); // expected-warning {{unused variable 'x'}} + + // This one cannot, so no warning. + S1 y; + + // This call cannot, but the constructor is trivial. + S1 z = a; // expected-warning {{unused variable 'z'}} + } + + // The same is true even when we know thet constructor has side effects. + void foo(); + struct S2 { + S2() { + foo(); + } + }; + S2 makeS2(); + void testS2(S2 a) { + S2 x = makeS2(); // expected-warning {{unused variable 'x'}} + S2 y; + S2 z = a; // expected-warning {{unused variable 'z'}} + } + + // Or when the constructor is not declared by the user. + struct S3 { + S1 m; + }; + S3 makeS3(); + void testS3(S3 a) { + S3 x = makeS3(); // expected-warning {{unused variable 'x'}} + S3 y; + S3 z = a; // expected-warning {{unused variable 'z'}} + } +} diff --git a/clang/test/SemaCXX/warn-using-namespace-in-header.cpp b/clang/test/SemaCXX/warn-using-namespace-in-header.cpp new file mode 100644 index 0000000..72c2552 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/warn-using-namespace-in-header.h b/clang/test/SemaCXX/warn-using-namespace-in-header.h new file mode 100644 index 0000000..b544c54 --- /dev/null +++ b/clang/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/clang/test/SemaCXX/warn-weak-vtables.cpp b/clang/test/SemaCXX/warn-weak-vtables.cpp new file mode 100644 index 0000000..135e034 --- /dev/null +++ b/clang/test/SemaCXX/warn-weak-vtables.cpp @@ -0,0 +1,78 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify -Wweak-vtables -Wweak-template-vtables + +struct A { // expected-warning {{'A' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}} + virtual void f() { } +}; + +template<typename T> struct B { + virtual void f() { } +}; + +namespace { + struct C { + virtual void f() { } + }; +} + +void f() { + struct A { + virtual void f() { } + }; + + A *a; + a->f(); +} + +// Use the vtables +void uses(A &a, B<int> &b, C &c) { + a.f(); + b.f(); + c.f(); +} + +// <rdar://problem/9979458> +class Parent { +public: + Parent() {} + virtual ~Parent(); + virtual void * getFoo() const = 0; +}; + +class Derived : public Parent { +public: + Derived(); + void * getFoo() const; +}; + +class VeryDerived : public Derived { // expected-warning{{'VeryDerived' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}} +public: + void * getFoo() const { return 0; } +}; + +Parent::~Parent() {} + +void uses(Parent &p, Derived &d, VeryDerived &vd) { + p.getFoo(); + d.getFoo(); + vd.getFoo(); +} + +template<typename T> struct TemplVirt { + virtual void f(); +}; + +template class TemplVirt<float>; // expected-warning{{explicit template instantiation 'TemplVirt<float>' will emit a vtable in every translation unit}} + +template<> struct TemplVirt<bool> { + virtual void f(); +}; + +template<> struct TemplVirt<long> { // expected-warning{{'TemplVirt<long>' has no out-of-line virtual method definitions; its vtable will be emitted in every translation unit}} + virtual void f() {} +}; + +void uses(TemplVirt<float>& f, TemplVirt<bool>& b, TemplVirt<long>& l) { + f.f(); + b.f(); + l.f(); +} diff --git a/clang/test/SemaCXX/wchar_t.cpp b/clang/test/SemaCXX/wchar_t.cpp new file mode 100644 index 0000000..f9d7b61 --- /dev/null +++ b/clang/test/SemaCXX/wchar_t.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s +wchar_t x; + +void f(wchar_t p) { + wchar_t x; + unsigned wchar_t y; // expected-warning {{'wchar_t' cannot be signed or unsigned}} + signed wchar_t z; // expected-warning {{'wchar_t' cannot be signed or unsigned}} + ++x; +} + +// PR4502 +wchar_t const c = L'c'; +int a[c == L'c' ? 1 : -1]; + + +// PR5917 +template<typename _CharT> +struct basic_string { +}; + +template<typename _CharT> +basic_string<_CharT> operator+ (const basic_string<_CharT>&, _CharT); + +int t(void) { + basic_string<wchar_t>() + L'-'; + return (0); +} + + +// rdar://8040728 +wchar_t in[] = L"\x434" "\x434"; // No warning + diff --git a/clang/test/SemaCXX/writable-strings-deprecated.cpp b/clang/test/SemaCXX/writable-strings-deprecated.cpp new file mode 100644 index 0000000..8295401 --- /dev/null +++ b/clang/test/SemaCXX/writable-strings-deprecated.cpp @@ -0,0 +1,14 @@ +// 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) +{ + return "foo"; +} + +void test(bool b) +{ + ++b; // expected-warning {{incrementing expression of type bool is deprecated}} +} diff --git a/clang/test/SemaCXX/zero-length-arrays.cpp b/clang/test/SemaCXX/zero-length-arrays.cpp new file mode 100644 index 0000000..05ded4a --- /dev/null +++ b/clang/test/SemaCXX/zero-length-arrays.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// <rdar://problem/10228639> +class Foo { + ~Foo(); + Foo(const Foo&); +public: + Foo(int); +}; + +class Bar { + int foo_count; + Foo foos[0]; + Foo foos2[0][2]; + Foo foos3[2][0]; + +public: + Bar(): foo_count(0) { } + ~Bar() { } +}; + +void testBar() { + Bar b; + Bar b2(b); + b = b2; +} |