+// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions -fms-compatibility-version=19.00

+// RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -std=c++11 -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions -fms-compatibility-version=18.00

+#if defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT

+char16_t x;

+char32_t y;

+#else

+#endif

+

+#if _MSC_VER >= 1900

+_Atomic(int) z;

+#else

+#endif

+struct MSPropertyClass {

+ int get() { return 42; }

+ int __declspec(property(get = get)) n;

+};

+

+int *f(MSPropertyClass &x) {

+ return &x.n; // expected-error {{address of property expression requested}}

+}

+int MSPropertyClass::*g() {

+ return &MSPropertyClass::n; // expected-error {{address of property expression requested}}

+}

+

+

+namespace {

+struct B { int a; };

+template <class C>

+struct A : B {

+ // Don't crash on dependent_type_var '->' '__super'

+ void f() { int a = this->__super::a; }

+};

+}

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+int w = z.; // expected-error {{use of undeclared identifier 'z'}} \

+ // expected-error {{expected unqualified-id}}

+

+int x = { y[ // expected-error {{use of undeclared identifier 'y'}} \

+ // expected-note {{to match this '['}} \

+ // expected-note {{to match this '{'}} \

+ // expected-error {{expected ';' after top level declarator}}

+

+// The errors below all occur on the last line of the file, so splitting them

+// among multiple lines doesn't work.

+// expected-error {{expected expression}} expected-error {{expected ']'}} expected-error {{expected '}'}}

+// RUN: %clang_cc1 -std=c++11 -verify %s -Wno-unused

+

+// This must be at the start of the file (the failure depends on a SmallPtrSet

+// not having been reallocated yet).

+void fn1() {

+ // expected-no-diagnostics

+ constexpr int kIsolationClass = 0;

+ const int kBytesPerConnection = 0;

+ [=] { kIsolationClass, kBytesPerConnection, kBytesPerConnection; };

+}

+basic_string<_CharT,_Traits,_Alloc>::basic_string(const _CharT* c,const _Alloc&)

+{string a(c);}

+// RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fborland-extensions -fcxx-exceptions %s

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+struct A {

+ int a;

+};

+

+struct X1 : virtual A

+{};

+

+struct Y1 : X1, virtual A

+{};

+

+struct Y2 : X1, A // expected-warning{{direct base 'A' is inaccessible due to ambiguity:\n struct Y2 -> struct X1 -> struct A\n struct Y2 -> struct A}}

+{};

+

+struct X2 : A

+{};

+

+struct Z1 : X2, virtual A // expected-warning{{direct base 'A' is inaccessible due to ambiguity:\n struct Z1 -> struct X2 -> struct A\n struct Z1 -> struct A}}

+{};

+

+struct Z2 : X2, A // expected-warning{{direct base 'A' is inaccessible due to ambiguity:\n struct Z2 -> struct X2 -> struct A\n struct Z2 -> struct A}}

+{};

+ X = &Qualifiers::R; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} __restrict': different qualifiers (none vs restrict)}}

+ X = &Qualifiers::CR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const __restrict': different qualifiers (none vs const and restrict)}}

+ X = &Qualifiers::VR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile __restrict': different qualifiers (none vs volatile and restrict)}}

+ X = &Qualifiers::CVR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile __restrict': different qualifiers (none vs const, volatile, and restrict)}}

+

+template <typename T> void n(T) {

+ alignas(T) int T1;

+ char k[__alignof__(T1)];

+ static_assert(sizeof(k) == alignof(long long), "");

+}

+template void n(long long);

+

+namespace PR22042 {

+template <typename T>

+void Fun(T A) {

+ typedef int __attribute__((__aligned__(A))) T1; // expected-error {{requested alignment is dependent but declaration is not dependent}}

+ int k1[__alignof__(T1)];

+}

+

+template <int N>

+struct S {

+ typedef __attribute__((aligned(N))) int Field[sizeof(N)]; // expected-error {{requested alignment is dependent but declaration is not dependent}}

+};

+}

+void X::test_unqual_references_const() const { // expected-note 2{{member function 'X::test_unqual_references_const' is declared const here}}

+ f2 = 0; // expected-error{{cannot assign to non-static data member within const member function 'test_unqual_references_const'}}

+ a = 0; // expected-error{{cannot assign to non-static data member within const member function 'test_unqual_references_const'}}

+ // expected-note@-1 2{{variable 'xc' declared const here}}

+ xc.f = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const X'}}

+ xc.a = 0; // expected-error{{cannot assign to variable 'xc' with const-qualified type 'const X'}}

+// CHECK: S s(1, 2);

+

+// CHECK: struct CXXFunctionalCastExprPrint fce = CXXFunctionalCastExprPrint{};

+struct CXXFunctionalCastExprPrint {} fce = CXXFunctionalCastExprPrint{};

+

+// CHECK: struct CXXTemporaryObjectExprPrint toe = CXXTemporaryObjectExprPrint{};

+struct CXXTemporaryObjectExprPrint { CXXTemporaryObjectExprPrint(); } toe = CXXTemporaryObjectExprPrint{};

+ // FIXME: This does not seem like the right answer.

+ _Atomic(int) e3{0}; // expected-error {{illegal initializer}}

+

+ // allows extraneous braces around initializers. We should at least give the

+ // same answer in all these cases:

+ Y y3 = { X(0), { 4 } }; // expected-error {{illegal initializer type}}

+ Y y4 = { { X(0) }, 4 };

+ _Atomic(int) ai = { 4 }; // expected-error {{illegal initializer type}}

+ _Atomic(X) ax = { X(0) };

+// RUN: %clang_cc1 -verify -fsyntax-only -x c++ -Wassign-enum %s

+

+enum __attribute__((flag_enum)) flag { // expected-warning {{ignored}}

+};

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

+// RUN: not %clang_cc1 -std=c++11 -ast-dump %s | FileCheck --check-prefix=DUMP %s

+// RUN: not %clang_cc1 -std=c++11 -ast-print %s | FileCheck --check-prefix=PRINT %s

+

+int v1 __attribute__((no_sanitize("address"))); // expected-error{{'no_sanitize' attribute only applies to functions and methods}}

+

+int f1() __attribute__((no_sanitize)); // expected-error{{'no_sanitize' attribute takes at least 1 argument}}

+

+int f2() __attribute__((no_sanitize(1))); // expected-error{{'no_sanitize' attribute requires a string}}

+

+// DUMP-LABEL: FunctionDecl {{.*}} f3

+// DUMP: NoSanitizeAttr {{.*}} address

+// PRINT: int f3() __attribute__((no_sanitize("address")))

+int f3() __attribute__((no_sanitize("address")));

+

+// DUMP-LABEL: FunctionDecl {{.*}} f4

+// DUMP: NoSanitizeAttr {{.*}} thread

+// PRINT: int f4() {{\[\[}}clang::no_sanitize("thread")]]

+[[clang::no_sanitize("thread")]] int f4();

+

+// DUMP-LABEL: FunctionDecl {{.*}} f5

+// DUMP: NoSanitizeAttr {{.*}} address thread

+// PRINT: int f5() __attribute__((no_sanitize("address", "thread")))

+int f5() __attribute__((no_sanitize("address", "thread")));

+

+// DUMP-LABEL: FunctionDecl {{.*}} f6

+// DUMP: NoSanitizeAttr {{.*}} unknown

+// PRINT: int f6() __attribute__((no_sanitize("unknown")))

+int f6() __attribute__((no_sanitize("unknown"))); // expected-warning{{unknown sanitizer 'unknown' ignored}}

+// RUN: %clang_cc1 -fms-compatibility -fms-extensions -fsyntax-only -verify -std=c++11 %s

+

+

+// The D3D11 headers do something like this. MSVC doesn't error on this at

+// all, even without the __declspec(selectany), in violation of the standard.

+// We fall back to a warning for selectany to accept headers.

+struct SomeStruct {};

+extern const __declspec(selectany) SomeStruct some_struct; // expected-warning {{default initialization of an object of const type 'const SomeStruct' without a user-provided default constructor is a Microsoft extension}}

+

+// It should be possible to redeclare variables that were defined

+// __declspec(selectany) previously.

+extern const SomeStruct some_struct;

+

+// Without selectany, this should stay an error.

+const SomeStruct some_struct2; // expected-error {{default initialization of an object of const type 'const SomeStruct' without a user-provided default constructor}}

+ return __builtin_va_arg(ap, int); // expected-error {{binding value of type 'const __builtin_va_list' to reference to type '__builtin_va_list' drops 'const' qualifier}}

+S template_capture_var(S x, T y) { // expected-note{{variable 'y' declared const here}}

+ y++; // expected-error{{cannot assign to variable 'y' with const-qualified type 'const int'}}

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++98 -Wno-inaccessible-base

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -std=c++11 -Wno-inaccessible-base

+ void f(); // expected-note 1 {{previous declaration}} expected-note {{previous declaration}}

+ void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}}

+ void f() {} // expected-error {{class member cannot be redeclared}}

+ constexpr int k; // expected-error {{default initialization of an object of const type}}

+

+namespace PR17938 {

+ template <typename T> constexpr T const &f(T const &x) { return x; }

+

+ struct X {};

+ struct Y : X {};

+ struct Z : Y { constexpr Z() {} };

+

+ static constexpr auto z = f(Z());

+}

+constexpr B b1; // expected-error {{without a user-provided default constructor}}

+constexpr C c1; // expected-error {{without a user-provided default constructor}}

+constexpr D d1; // expected-error {{without a user-provided default constructor}}

+class E : public D, public B { // expected-warning{{direct base 'B' is inaccessible due to ambiguity:\n class E -> class D -> class C -> class B\n class E -> class B}}

+ INT::NonExisting() {} // expected-error {{'INT' (aka 'int') is not a class, namespace, or enumeration}} \

+

+ struct C : A, B { }; // expected-warning{{direct base 'Test2::A' is inaccessible due to ambiguity:\n struct Test2::C -> struct Test2::A\n struct Test2::C -> struct Test2::B -> struct Test2::A}}

+ static int* member(); // expected-note{{possible target}}

+ static int* member(int); // expected-note{{possible target}}

+ template<typename T> bs<T>::bs() { member; } // expected-error{{did you mean to call it}}

+ return bs<int>(); // expected-note{{in instantiation}}

+ struct _Alloc_hider : _Alloc { _Alloc_hider(_CharT*, const _Alloc&); };

+ : _M_dataplus(_S_construct(__beg, __end, __a, input_iterator_tag()), __a) {}

+constexpr int x = 1; // expected-note {{variable 'x' declared const here}}

+ x = 2; // expected-error {{cannot assign to variable 'x' with const-qualified type 'const int'}}

+ const non_const_copy cncc1; // expected-error {{default initialization of an object of const type 'const non_const_copy' without a user-provided default constructor}}

+struct DefaultDelete {

+ DefaultDelete() = default; // expected-note {{previous declaration is here}}

+ DefaultDelete() = delete; // expected-error {{constructor cannot be redeclared}}

+

+ ~DefaultDelete() = default; // expected-note {{previous declaration is here}}

+ ~DefaultDelete() = delete; // expected-error {{destructor cannot be redeclared}}

+

+ DefaultDelete &operator=(const DefaultDelete &) = default; // expected-note {{previous declaration is here}}

+ DefaultDelete &operator=(const DefaultDelete &) = delete; // expected-error {{class member cannot be redeclared}}

+};

+

+struct DeleteDefault {

+ DeleteDefault() = delete; // expected-note {{previous definition is here}}

+ DeleteDefault() = default; // expected-error {{constructor cannot be redeclared}}

+

+ ~DeleteDefault() = delete; // expected-note {{previous definition is here}}

+ ~DeleteDefault() = default; // expected-error {{destructor cannot be redeclared}}

+

+ DeleteDefault &operator=(const DeleteDefault &) = delete; // expected-note {{previous definition is here}}

+ DeleteDefault &operator=(const DeleteDefault &) = default; // expected-error {{class member cannot be redeclared}}

+};

+

+ void PR13573(const _Tp&) = delete;

+ // expected-warning@+1 {{braces around scalar initializer}}

+ struct B { B(A); } b{{0}}; //FIXME: non-conformant. Temporary fix until standard resolution.

+ // expected- error {{call to constructor of 'struct B' is ambiguous}} \

+ // expected- note 2{{candidate is the implicit}} \

+ // expected- note {{candidate constructor}}

+ struct C { C(int); }; // expected-note 2{{candidate constructor (the implicit}} \

+ // expected-note {{candidate constructor not viable: cannot convert initializer list argument to 'int'}}

+ D d3 { { { 0 } } }; // ok, { { 0 } } calls C({ 0 }), expected-warning {{braces around scalar init}}

+ D d4 { { { { 0 } } } }; // expected-error {{no matching constructor for initialization of 'inner_init::C &&'}}

+

+namespace PR21834 {

+const int &a = (const int &){0}; // expected-error {{cannot bind to an initializer list}}

+}

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -pedantic-errors

+ return {1}; // expected-warning {{braces around scalar init}}

+ takes_int({1}); // expected-warning {{braces around scalar init}}

+ static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload"); // expected-warning {{braces around scalar init}}

+ static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload"); // expected-warning {{braces around scalar init}}

+

+namespace TemporaryInitListSourceRange_PR22367 {

+ struct A {

+ constexpr A() {}

+ A(std::initializer_list<int>); // expected-note {{here}}

+ };

+ constexpr int f(A) { return 0; }

+ constexpr int k = f( // expected-error {{must be initialized by a constant expression}}

+ // The point of this test is to check that the caret points to

+ // 'std::initializer_list', not to '{0}'.

+ std::initializer_list // expected-note {{constructor}}

+ <int>

+ {0}

+ );

+}

+ return { i }; // expected-warning{{generalized initializer lists are a C++11 extension}} expected-warning {{scalar}}

+

+template <class C, C...> const char *operator"" _suffix();

+// CHECK: const char *PR23120 = operator "" _suffix<char32_t, 66615>();

+const char *PR23120 = U"𐐷"_suffix;

+

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

+// rdar://20281011

+

+namespace std {

+template<class _Ep> class initializer_list { };

+}

+

+namespace cva {

+

+template <class VT, unsigned int ROWS = 0, unsigned int COLS = 0>

+class Matrix {

+public:

+

+ typedef VT value_type;

+ inline __attribute__((always_inline)) value_type& at();

+};

+

+template <class VT, unsigned int SIZE> using Vector = Matrix<VT, SIZE, 1>;

+

+template <class VT>

+using RGBValue = Vector<VT, 3>;

+using RGBFValue = RGBValue<float>;

+

+template <class VT> class Matrix<VT, 0, 0> { // expected-note {{passing argument to parameter here}}

+public:

+ typedef VT value_type;

+ Matrix(const unsigned int nRows, const unsigned int nColumns, const value_type* data = nullptr);

+

+ Matrix(const std::initializer_list<value_type>& list) = delete; // expected-note {{'Matrix' has been explicitly marked deleted here}}

+

+};

+

+void getLaplacianClosedForm()

+{

+ Matrix<double> winI(0, 3);

+ RGBFValue* inputPreL;

+ winI = { inputPreL->at() }; // expected-error {{call to deleted constructor of 'cva::Matrix<double, 0, 0> &&'}}

+}

+

+}

+

+namespace incorrect_auto_type_deduction_for_typo {

+struct S {

+ template <typename T> S(T t) {

+ (void)sizeof(t);

+ (void)new auto(t);

+ }

+};

+

+void Foo(S);

+

+void test(int some_number) { // expected-note {{'some_number' declared here}}

+ auto x = sum_number; // expected-error {{use of undeclared identifier 'sum_number'; did you mean 'some_number'?}}

+ auto lambda = [x] {};

+ Foo(lambda);

+}

+}

+extern struct PR22493Ty {

+} PR22493 [[gnu::alias("_ZN7pcrecpp2RE6no_argE")]];

+

+ operator auto() { return 0; } // expected-note {{previous}}

+ operator auto() { return 0.; } // expected-error {{cannot be redeclared}} expected-error {{cannot initialize return object of type 'auto' with an rvalue of type 'double'}}

+ //expected-note{{non-literal type}}\

+ //expected-error{{inside of a constant expression}}

+ int arrG[([](auto i) { return i; })(3)]; //expected-error{{must have a constant size}} \

+ //expected-error{{inside of a constant expression}}

+}

+

+namespace classification_of_captures_of_init_captures {

+

+template <typename T>

+void f() {

+ [a = 24] () mutable {

+ [&a] { a = 3; }();

+ }();

+}

+

+template <typename T>

+void h() {

+ [a = 24] (auto param) mutable {

+ [&a] { a = 3; }();

+ }(42);

+}

+

+int run() {

+ f<int>();

+ h<int>();

+}

+

+}

+void operator delete(void *, size_t) noexcept; // expected-note {{'operator delete' declared here}}

+void operator delete[](void *, size_t) noexcept;

+ template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}}

+ template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}}

+ return { 0 }; // expected-warning {{generalized initializer lists are incompatible with C++98}} expected-warning {{scalar}}

+ void f(int i = {1}) { // expected-warning {{generalized initializer lists are incompatible with C++98}} expected-warning {{scalar}}

+// RUN: %clang_cc1 -std=c++14 -triple i686-pc-win32 -fms-extensions -verify %s

+// RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -verify %s

+// RUN: %clang_cc1 -std=c++14 -triple i686-pc-mingw32 -fms-extensions -verify %s

+

+namespace test9 {

+ // Used to fail when we forgot to make lambda call operators use __thiscall.

+ template <typename F>

+ decltype(auto) deduce(F f) {

+ return &decltype(f)::operator();

+ }

+ template <typename C, typename R, typename A>

+ decltype(auto) signaturehelper(R (C::*f)(A) const) {

+ return R();

+ }

+ void f() {

+ auto l = [](int x) { return x * 2; };

+ decltype(signaturehelper(deduce(l))) p;

+ }

+}

+// RUN: %clang_cc1 -triple i686-pc-win32 -std=c++11 -fms-extensions -fms-compatibility-version=18.00 -verify %s

+// RUN: %clang_cc1 -triple i686-pc-win32 -std=c++11 -fms-extensions -fms-compatibility-version=19.00 -verify %s

+#if _MSC_VER >= 1900

+__declspec(thread) int e = foo();

+#else

+#endif

+#if _MSC_VER >= 1900

+__declspec(thread) HasCtor f;

+#else

+#endif

+#if _MSC_VER >= 1900

+__declspec(thread) HasDtor g;

+#else

+__declspec(thread) HasCtor g; // expected-error {{must be a constant expression}} expected-note {{thread_local}}

+#endif

+ struct X2 : X0, X1 { }; // expected-warning{{direct base 'MultiplePaths::X0' is inaccessible due to ambiguity:\n struct MultiplePaths::X2 -> struct MultiplePaths::X0\n struct MultiplePaths::X2 -> struct MultiplePaths::X1 -> struct MultiplePaths::X0}}

+// Header for PCH test delete.cpp

+namespace pch_test {

+struct X {

+ int *a;

+ X();

+ X(int);

+ X(bool)

+ : a(new int[1]) { } // expected-note{{allocated with 'new[]' here}}

+ ~X()

+ {

+ delete a; // expected-warning{{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:9}:"[]"

+ }

+};

+}

+// Test without PCH

+// RUN: %clang_cc1 -fsyntax-only -include %S/delete-mismatch.h -fdiagnostics-parseable-fixits -std=c++11 %s 2>&1 | FileCheck %s

+

+// Test with PCH

+// RUN: %clang_cc1 -x c++-header -std=c++11 -emit-pch -o %t %S/delete-mismatch.h

+// RUN: %clang_cc1 -std=c++11 -include-pch %t -DWITH_PCH -fsyntax-only -verify %s -ast-dump

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:9}:"[]"

+}

+namespace MemberCheck {

+struct S {

+ int *a = new int[5]; // expected-note4 {{allocated with 'new[]' here}}

+ int *b;

+ int *c;

+ static int *d;

+ S();

+ S(int);

+ ~S() {

+ delete a; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete b; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete[] c; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}

+ }

+ void f();

+};

+

+void S::f()

+{

+ delete a; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete b; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+}

+

+S::S()

+: b(new int[1]), c(new int) {} // expected-note3 {{allocated with 'new[]' here}}

+// expected-note@-1 {{allocated with 'new' here}}

+

+S::S(int i)

+: b(new int[i]), c(new int) {} // expected-note3 {{allocated with 'new[]' here}}

+// expected-note@-1 {{allocated with 'new' here}}

+

+struct S2 : S {

+ ~S2() {

+ delete a; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ }

+};

+int *S::d = new int[42]; // expected-note {{allocated with 'new[]' here}}

+void f(S *s) {

+ int *a = new int[1]; // expected-note {{allocated with 'new[]' here}}

+ delete a; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete s->a; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete s->b; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete s->c;

+ delete s->d;

+ delete S::d; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+}

+

+// At least one constructor initializes field with matching form of 'new'.

+struct MatchingNewIsOK {

+ int *p;

+ bool is_array_;

+ MatchingNewIsOK() : p{new int}, is_array_(false) {}

+ explicit MatchingNewIsOK(unsigned c) : p{new int[c]}, is_array_(true) {}

+ ~MatchingNewIsOK() {

+ if (is_array_)

+ delete[] p;

+ else

+ delete p;

+ }

+};

+

+// At least one constructor's body is missing; no proof of mismatch.

+struct CantProve_MissingCtorDefinition {

+ int *p;

+ CantProve_MissingCtorDefinition();

+ CantProve_MissingCtorDefinition(int);

+ ~CantProve_MissingCtorDefinition();

+};

+

+CantProve_MissingCtorDefinition::CantProve_MissingCtorDefinition()

+ : p(new int)

+{ }

+

+CantProve_MissingCtorDefinition::~CantProve_MissingCtorDefinition()

+{

+ delete[] p;

+}

+

+struct base {};

+struct derived : base {};

+struct InitList {

+ base *p, *p2 = nullptr, *p3{nullptr}, *p4;

+ InitList(unsigned c) : p(new derived[c]), p4(nullptr) {} // expected-note {{allocated with 'new[]' here}}

+ InitList(unsigned c, unsigned) : p{new derived[c]}, p4{nullptr} {} // expected-note {{allocated with 'new[]' here}}

+ ~InitList() {

+ delete p; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ delete [] p;

+ delete p2;

+ delete [] p3;

+ delete p4;

+ }

+};

+}

+

+namespace NonMemberCheck {

+#define DELETE_ARRAY(x) delete[] (x)

+#define DELETE(x) delete (x)

+void f() {

+ int *a = new int(5); // expected-note2 {{allocated with 'new' here}}

+ delete[] a; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}

+ int *b = new int;

+ delete b;

+ int *c{new int}; // expected-note {{allocated with 'new' here}}

+ int *d{new int[1]}; // expected-note2 {{allocated with 'new[]' here}}

+ delete [ ] c; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:17}:""

+ delete d; // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:9}:"[]"

+ DELETE_ARRAY(a); // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}

+ DELETE(d); // expected-warning {{'delete' applied to a pointer that was allocated with 'new[]'; did you mean 'delete[]'?}}

+}

+#ifndef WITH_PCH

+pch_test::X::X()

+ : a(new int[1]) // expected-note{{allocated with 'new[]' here}}

+{ }

+pch_test::X::X(int i)

+ : a(new int[i]) // expected-note{{allocated with 'new[]' here}}

+{ }

+#endif

+

+struct DelCtor { // expected-note 4{{implicit}}

+ DelCtor(int) = delete; // expected-note 14{{deleted}}

+ // ensure the class is not an aggregate

+ DelCtor(int, int, int, int);

+};

+DelCtor dc1 = 0; // expected-error {{deleted}}

+DelCtor dc2(0); // expected-error {{deleted}}

+DelCtor dc3 = {0}; // expected-error {{deleted}}

+DelCtor dc4{0}; // expected-error {{deleted}}

+DelCtor dc5 = (DelCtor)0; // expected-error {{deleted}}

+DelCtor dc6 = DelCtor(0); // expected-error {{deleted}}

+DelCtor dc7 = DelCtor{0}; // expected-error {{deleted}}

+DelCtor *dc8 = new DelCtor(0); // expected-error {{deleted}}

+DelCtor *dc9 = new DelCtor{0}; // expected-error {{deleted}}

+DelCtor dc10[] = {0}; // expected-error {{deleted}}

+int use_dc(DelCtor); // expected-note 2{{here}}

+int dc11 = use_dc(0); // expected-error {{deleted}}

+int dc12 = use_dc({0}); // expected-error {{deleted}}

+int use_dcr(const DelCtor &); // expected-note {{here}}

+int dc13 = use_dcr(0); // expected-error {{deleted}}

+int dc14 = use_dcr({0}); // expected-error {{deleted}}

+

+struct DelCtorTemplate {

+ template<typename T> DelCtorTemplate(T) = delete; // expected-note {{deleted}}

+};

+int use_dct(const DelCtorTemplate &);

+int dc15 = use_dct(0); // expected-error {{deleted}}

+class E2 : public D2, public C2, public virtual A2 { }; // expected-warning{{direct base 'C2' is inaccessible due to ambiguity:\n class E2 -> class D2 -> class C2\n class E2 -> class C2}}

+class F2 : public E2, public A2 { }; // expected-warning{{direct base 'A2' is inaccessible due to ambiguity:\n class F2 -> class E2 -> class D2 -> class B2 -> class A2\n class F2 -> class A2}}

+struct S8 {} s8;

+

+UnknownType S8::~S8() { // expected-error {{unknown type name 'UnknownType'}}

+ s8.~S8();

+}

+

+

+namespace PR22668 {

+struct S {

+};

+void f(S s) {

+ (s.~S)();

+}

+void g(S s) {

+ (s.~S); // expected-error{{reference to destructor must be called}}

+}

+}

+// expected-no-diagnostics

+struct Incomplete;

+struct B : A {

+void f() {

+ // Since B's constructor is declared out of line, nothing in this file

+ // references a vtable, so the destructor doesn't get built.

+ A *b = new B();

+ b->m();

+ delete b;

+// RUN: %clang_cc1 -triple i686-windows-gnu -fms-extensions -verify -std=c++03 %s

+// RUN: %clang_cc1 -triple i686-windows-gnu -fms-extensions -verify -std=c++11 %s

+// RUN: %clang_cc1 -triple i686-windows-msvc -fms-extensions -verify -std=c++03 -DERROR %s

+// RUN: %clang_cc1 -triple i686-windows-msvc -fms-extensions -verify -std=c++11 %s

+

+#ifndef ERROR

+// expected-no-diagnostics

+#endif

+

+struct NonCopyable {

+private:

+#ifdef ERROR

+ // expected-note@+2{{declared private here}}

+#endif

+ NonCopyable();

+};

+

+#ifdef ERROR

+// expected-error@+4{{field of type 'NonCopyable' has private default constructor}}

+// expected-note@+3{{implicit default constructor for 'S' first required here}}

+// expected-note@+2{{due to 'S' being dllexported; try compiling in C++11 mode}}

+#endif

+struct __declspec(dllexport) S {

+ NonCopyable member;

+};

+// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s

+// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s

+// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template %s

+// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template %s

+template <typename T> struct __declspec(dllexport) ExportedTemplateWithExplicitInstantiationDecl { // expected-note{{attribute is here}}

+extern template struct ExportedTemplateWithExplicitInstantiationDecl<IncompleteType2>; // expected-warning{{explicit instantiation declaration should not be 'dllexport'}}

+// Warn about explicit instantiation declarations of dllexport classes.

+template <typename T> struct ExplicitInstantiationDeclTemplate {};

+extern template struct __declspec(dllexport) ExplicitInstantiationDeclTemplate<int>; // expected-warning{{explicit instantiation declaration should not be 'dllexport'}} expected-note{{attribute is here}}

+template <typename T> struct __declspec(dllexport) ExplicitInstantiationDeclExportedTemplate {}; // expected-note{{attribute is here}}

+extern template struct ExplicitInstantiationDeclExportedTemplate<int>; // expected-warning{{explicit instantiation declaration should not be 'dllexport'}}

+

+namespace { struct InternalLinkageType {}; }

+struct __declspec(dllexport) PR23308 {

+ void f(InternalLinkageType*);

+};

+void PR23308::f(InternalLinkageType*) {} // No error; we don't try to export f because it has internal linkage.

+// RUN: %clang_cc1 -triple i686-win32 -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DMS %s

+// RUN: %clang_cc1 -triple x86_64-win32 -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DMS %s

+// RUN: %clang_cc1 -triple i686-mingw32 -fsyntax-only -fms-extensions -verify -std=c++1y -Wunsupported-dll-base-class-template -DGNU %s

+// RUN: %clang_cc1 -triple x86_64-mingw32 -fsyntax-only -fms-extensions -verify -std=c++11 -Wunsupported-dll-base-class-template -DGNU %s

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -fsyntax-only -verify -Wno-inaccessible-base

+

+enum WithUnderlying : unsigned { wu_value };

+struct WithUnderlyingBitfield {

+ WithUnderlying wu : 3;

+} wu = { wu_value };

+int want_unsigned(unsigned);

+int want_unsigned(int) = delete;

+int check_enum_bitfield_promotes_correctly = want_unsigned(wu.wu);

+// RUN: %clang_cc1 -fsyntax-only -verify %s

+

+#define restrict __restrict__

+typedef int* ptr;

+void test1(ptr p, const ptr cp, restrict ptr rp, const restrict ptr crp,

+ volatile ptr vp, const volatile ptr cvp, restrict volatile ptr rvp,

+ const restrict volatile ptr crvp) {

+ ptr& p1 = p;

+ ptr& p2 = cp; // expected-error {{drops 'const' qualifier}}

+ ptr& p3 = rp; // expected-error {{drops 'restrict' qualifier}}

+ ptr& p4 = crp; // expected-error {{drops 'const' and 'restrict' qualifiers}}

+ ptr& p5 = vp; // expected-error {{drops 'volatile' qualifier}}

+ ptr& p6 = cvp; // expected-error {{drops 'const' and 'volatile' qualifiers}}

+ ptr& p7 = rvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}

+ ptr& p8 = crvp; // expected-error {{drops 'const', 'restrict', and 'volatile' qualifiers}}

+

+ const ptr& cp1 = p;

+ const ptr& cp2 = cp;

+ const ptr& cp3 = rp; // expected-error {{drops 'restrict' qualifier}}

+ const ptr& cp4 = crp; // expected-error {{drops 'restrict' qualifier}}

+ const ptr& cp5 = vp; // expected-error {{drops 'volatile' qualifier}}

+ const ptr& cp6 = cvp; // expected-error {{drops 'volatile' qualifier}}

+ const ptr& cp7 = rvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}

+ const ptr& cp8 = crvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}

+

+ const volatile ptr& cvp1 = p;

+ const volatile ptr& cvp2 = cp;

+ const volatile ptr& cvp3 = rp; // expected-error {{drops 'restrict' qualifier}}

+ const volatile ptr& cvp4 = crp; // expected-error {{drops 'restrict' qualifier}}

+ const volatile ptr& cvp5 = vp;

+ const volatile ptr& cvp6 = cvp;

+ const volatile ptr& cvp7 = rvp; // expected-error {{drops 'restrict' qualifier}}

+ const volatile ptr& cvp8 = crvp; // expected-error {{drops 'restrict' qualifier}}

+

+ const restrict volatile ptr& crvp1 = p;

+ const restrict volatile ptr& crvp2 = cp;

+ const restrict volatile ptr& crvp3 = rp;

+ const restrict volatile ptr& crvp4 = crp;

+ const restrict volatile ptr& crvp5 = vp;

+ const restrict volatile ptr& crvp6 = cvp;

+ const restrict volatile ptr& crvp7 = rvp;

+ const restrict volatile ptr& crvp8 = crvp;

+}

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s

+

+const int global = 5; // expected-note{{variable 'global' declared const here}}

+void test1() {

+ global = 2; // expected-error{{cannot assign to variable 'global' with const-qualified type 'const int'}}

+}

+

+void test2 () {

+ const int local = 5; // expected-note{{variable 'local' declared const here}}

+ local = 0; // expected-error{{cannot assign to variable 'local' with const-qualified type 'const int'}}

+}

+

+void test2 (const int parameter) { // expected-note{{variable 'parameter' declared const here}}

+ parameter = 2; // expected-error{{cannot assign to variable 'parameter' with const-qualified type 'const int'}}

+}

+

+class test3 {

+ int field;

+ const int const_field = 1; // expected-note 2{{non-static data member 'const_field' declared const here}}

+ static const int static_const_field = 1; // expected-note 2{{variable 'static_const_field' declared const here}}

+ void test() {

+ const_field = 4; // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}

+ static_const_field = 4; // expected-error{{cannot assign to variable 'static_const_field' with const-qualified type 'const int'}}

+ }

+ void test_const() const { // expected-note 2{{member function 'test3::test_const' is declared const here}}

+ field = 4; // expected-error{{cannot assign to non-static data member within const member function 'test_const'}}

+ const_field = 4 ; // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}

+ static_const_field = 4; // expected-error{{cannot assign to variable 'static_const_field' with const-qualified type 'const int'}}

+ }

+};

+

+const int &return_const_ref(); // expected-note{{function 'return_const_ref' which returns const-qualified type 'const int &' declared here}}

+

+void test4() {

+ return_const_ref() = 10; // expected-error{{cannot assign to return value because function 'return_const_ref' returns a const value}}

+}

+

+struct S5 {

+ int field;

+ const int const_field = 4; // expected-note {{non-static data member 'const_field' declared const here}}

+};

+

+void test5() {

+ S5 s5;

+ s5.field = 5;

+ s5.const_field = 5; // expected-error{{cannot assign to non-static data member 'const_field' with const-qualified type 'const int'}}

+}

+

+struct U1 {

+ int a = 5;

+};

+

+struct U2 {

+ U1 u1;

+};

+

+struct U3 {

+ const U2 u2 = U2(); // expected-note{{non-static data member 'u2' declared const here}}

+};

+

+struct U4 {

+ U3 u3;

+};

+

+void test6() {

+ U4 u4;

+ u4.u3.u2.u1.a = 5; // expected-error{{cannot assign to non-static data member 'u2' with const-qualified type 'const U2'}}

+}

+

+struct A {

+ int z;

+};

+struct B {

+ A a;

+};

+struct C {

+ B b;

+ C();

+};

+const C &getc(); // expected-note{{function 'getc' which returns const-qualified type 'const C &' declared here}}

+void test7() {

+ const C c; // expected-note{{variable 'c' declared const here}}

+ c.b.a.z = 5; // expected-error{{cannot assign to variable 'c' with const-qualified type 'const C'}}

+

+ getc().b.a.z = 5; // expected-error{{cannot assign to return value because function 'getc' returns a const value}}

+}

+

+struct D { const int n; }; // expected-note 2{{non-static data member 'n' declared const here}}

+struct E { D *const d = 0; };

+void test8() {

+ extern D *const d;

+ d->n = 0; // expected-error{{cannot assign to non-static data member 'n' with const-qualified type 'const int'}}

+

+ E e;

+ e.d->n = 0; // expected-error{{cannot assign to non-static data member 'n' with const-qualified type 'const int'}}

+}

+

+struct F { int n; };

+struct G { const F *f; }; // expected-note{{non-static data member 'f' declared const here}}

+void test10() {

+ const F *f; // expected-note{{variable 'f' declared const here}}

+ f->n = 0; // expected-error{{cannot assign to variable 'f' with const-qualified type 'const F *'}}

+

+ G g;

+ g.f->n = 0; // expected-error{{cannot assign to non-static data member 'f' with const-qualified type 'const F *'}}

+}

+

+void test11(

+ const int x, // expected-note{{variable 'x' declared const here}}

+ const int& y // expected-note{{variable 'y' declared const here}}

+ ) {

+ x = 5; // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}

+ y = 5; // expected-error{{cannot assign to variable 'y' with const-qualified type 'const int &'}}

+}

+

+struct H {

+ const int a = 0; // expected-note{{non-static data member 'a' declared const here}}

+ const int &b = a; // expected-note{{non-static data member 'b' declared const here}}

+};

+

+void test12(H h) {

+ h.a = 1; // expected-error {{cannot assign to non-static data member 'a' with const-qualified type 'const int'}}

+ h.b = 2; // expected-error {{cannot assign to non-static data member 'b' with const-qualified type 'const int &'}}

+}

+// RUN: not %clang_cc1 -fsyntax-only -std=c++11 %s 2>&1 | FileCheck %s

+

+struct E {

+ int num;

+ const int Cnum = 0;

+ mutable int Mnum;

+ static int Snum;

+ const static int CSnum;

+};

+

+struct D {

+ E e;

+ const E Ce;

+ mutable E Me;

+ static E Se;

+ const static E CSe;

+ E &getE() const;

+ const E &getCE() const;

+};

+

+struct C {

+ D d;

+ const D Cd;

+ mutable D Md;

+ static D Sd;

+ const static D CSd;

+ D &getD() const;

+ const D &getCD() const;

+};

+

+struct B {

+ C c;

+ const C Cc;

+ mutable C Mc;

+ static C Sc;

+ const static C CSc;

+ C &getC() const;

+ static C &getSC();

+ const C &getCC() const;

+ static const C &getSCC();

+};

+

+struct A {

+ B b;

+ const B Cb;

+ mutable B Mb;

+ static B Sb;

+ const static B CSb;

+ B &getB() const;

+ static B &getSB();

+ const B &getCB() const;

+ static const B &getSCB();

+};

+

+A& getA();

+

+// Valid assignment

+void test1(A a, const A Ca) {

+ a.b.c.d.e.num = 5;

+ a.b.c.d.e.Mnum = 5;

+ Ca.b.c.d.e.Mnum = 5;

+ a.b.c.d.e.Snum = 5;

+ Ca.b.c.d.e.Snum = 5;

+ Ca.b.c.Md.e.num = 5;

+ Ca.Mb.Cc.d.e.Mnum = 5;

+ Ca.Mb.getC().d.e.num = 5;

+ Ca.getSB().c.d.e.num = 5;

+ a.getSCB().c.d.Me.num = 5;

+ Ca.Cb.Cc.Cd.Ce.Snum = 5;

+ // CHECK-NOT: error:

+ // CHECK-NOT: note:

+}

+

+// One note

+void test2(A a, const A Ca) {

+ Ca.b.c.d.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ca'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ca'

+ // CHECK-NOT: note:

+

+ a.Cb.c.d.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cb'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cb'

+ // CHECK-NOT: note:

+

+ a.b.c.Cd.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+

+ a.b.c.d.e.CSnum = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'CSnum'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'CSnum'

+ // CHECK-NOT: note:

+

+ a.b.c.d.e.Cnum = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cnum'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cnum'

+ // CHECK-NOT: note:

+

+ a.getCB().c.d.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'getCB'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'getCB'

+ // CHECK-NOT: note:

+

+ a.getSCB().c.d.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'getSCB'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'getSCB'

+ // CHECK-NOT: note:

+}

+

+// Two notes

+void test3(A a, const A Ca) {

+

+ a.getSCB().Cc.d.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cc'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cc'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'getSCB'

+ // CHECK-NOT: note:

+

+ Ca.b.c.Cd.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ca'

+ // CHECK-NOT: note:

+

+ a.getCB().c.Cd.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'getCB'

+ // CHECK-NOT: note:

+

+ a.b.getCC().d.e.Cnum = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cnum'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cnum'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'getCC'

+ // CHECK-NOT: note:

+

+ a.b.c.Cd.Ce.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+

+ a.b.CSc.Cd.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'CSc'

+ // CHECK-NOT: note:

+

+ a.CSb.c.Cd.e.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Cd'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'CSb'

+ // CHECK-NOT: note:

+}

+

+// No errors

+void test4(const A Ca) {

+ // Mutable cases

+ Ca.Mb.c.d.e.num = 5;

+ Ca.CSb.Mc.d.e.num = 5;

+ Ca.getCB().Mc.d.e.num = 5;

+ Ca.getSCB().Mc.d.e.num = 5;

+

+ // Returning non-const reference

+ Ca.getB().c.d.e.num = 5;

+ Ca.CSb.getC().d.e.num = 5;

+ Ca.getCB().getC().d.e.num = 5;

+ Ca.getSCB().getC().d.e.num = 5;

+

+ // Returning non-const reference

+ Ca.getSB().c.d.e.num = 5;

+ Ca.CSb.getSC().d.e.num = 5;

+ Ca.getCB().getSC().d.e.num = 5;

+ Ca.getSCB().getSC().d.e.num = 5;

+

+ // Static member

+ Ca.Sb.c.d.e.num = 5;

+ Ca.CSb.Sc.d.e.num = 5;

+ Ca.getCB().Sc.d.e.num = 5;

+ Ca.getSCB().Sc.d.e.num = 5;

+

+ // CHECK-NOT: error:

+ // CHECK-NOT: note:

+}

+

+// Only display notes for relavent cases.

+void test5(const A Ca) {

+ Ca.Mb.c.d.Ce.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+

+ Ca.getB().c.d.Ce.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+

+ Ca.getSB().c.d.Ce.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+

+ Ca.Sb.c.d.Ce.num = 5;

+ // CHECK-NOT: error:

+ // CHECK: error:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+ // CHECK: note:{{.*}} 'Ce'

+ // CHECK-NOT: note:

+}

+// RUN: %clang_cc1 -std=c++03 -fblocks -triple x86_64-windows-msvc -fms-extensions -fsyntax-only -fexceptions -fcxx-exceptions -verify %s

+// RUN: %clang_cc1 -std=c++11 -fblocks -triple x86_64-windows-msvc -fms-extensions -fsyntax-only -fexceptions -fcxx-exceptions -verify %s

+

+// Basic usage should work.

+int safe_div(int n, int d) {

+ int r;

+ __try {

+ r = n / d;

+ } __except(_exception_code() == 0xC0000094) {

+ r = 0;

+ }

+ return r;

+}

+

+void might_crash();

+

+// Diagnose obvious builtin mis-usage.

+void bad_builtin_scope() {

+ __try {

+ might_crash();

+ } __except(1) {

+ }

+ _exception_code(); // expected-error {{'_exception_code' only allowed in __except block or filter expression}}

+ _exception_info(); // expected-error {{'_exception_info' only allowed in __except filter expression}}

+}

+

+// Diagnose obvious builtin misusage in a template.

+template <void FN()>

+void bad_builtin_scope_template() {

+ __try {

+ FN();

+ } __except(1) {

+ }

+ _exception_code(); // expected-error {{'_exception_code' only allowed in __except block or filter expression}}

+ _exception_info(); // expected-error {{'_exception_info' only allowed in __except filter expression}}

+}

+void instantiate_bad_scope_tmpl() {

+ bad_builtin_scope_template<might_crash>();

+}

+

+#if __cplusplus < 201103L

+// FIXME: Diagnose this case. For now we produce undef in codegen.

+template <typename T, T FN()>

+T func_template() {

+ return FN();

+}

+void inject_builtins() {

+ func_template<void *, __exception_info>();

+ func_template<unsigned long, __exception_code>();

+}

+#endif

+

+void use_seh_after_cxx() {

+ try { // expected-note {{conflicting 'try' here}}

+ might_crash();

+ } catch (int) {

+ }

+ __try { // expected-error {{cannot use C++ 'try' in the same function as SEH '__try'}}

+ might_crash();

+ } __except(1) {

+ }

+}

+

+void use_cxx_after_seh() {

+ __try { // expected-note {{conflicting '__try' here}}

+ might_crash();

+ } __except(1) {

+ }

+ try { // expected-error {{cannot use C++ 'try' in the same function as SEH '__try'}}

+ might_crash();

+ } catch (int) {

+ }

+}

+

+#if __cplusplus >= 201103L

+void use_seh_in_lambda() {

+ ([]() {

+ __try {

+ might_crash();

+ } __except(1) {

+ }

+ })();

+ try {

+ might_crash();

+ } catch (int) {

+ }

+}

+#endif

+

+void use_seh_in_block() {

+ void (^b)() = ^{

+ __try { // expected-error {{cannot use SEH '__try' in blocks, captured regions, or Obj-C method decls}}

+ might_crash();

+ } __except(1) {

+ }

+ };

+ try {

+ b();

+ } catch (int) {

+ }

+}

+

+void (^use_seh_in_global_block)() = ^{

+ __try { // expected-error {{cannot use SEH '__try' in blocks, captured regions, or Obj-C method decls}}

+ might_crash();

+ } __except(1) {

+ }

+};

+

+void (^use_cxx_in_global_block)() = ^{

+ try {

+ might_crash();

+ } catch(int) {

+ }

+};

+

+namespace HandlerInversion {

+struct B {};

+struct D : B {};

+struct D2 : D {};

+

+void f1() {

+ try {

+ } catch (B &b) { // expected-note {{for type 'HandlerInversion::B &'}}

+ } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}

+ }

+}

+

+void f2() {

+ try {

+ } catch (B *b) { // expected-note {{for type 'HandlerInversion::B *'}}

+ } catch (D *d) { // expected-warning {{exception of type 'HandlerInversion::D *' will be caught by earlier handler}}

+ }

+}

+

+void f3() {

+ try {

+ } catch (D &d) { // Ok

+ } catch (B &b) {

+ }

+}

+

+void f4() {

+ try {

+ } catch (B &b) { // Ok

+ }

+}

+

+void f5() {

+ try {

+ } catch (int) {

+ } catch (float) {

+ }

+}

+

+void f6() {

+ try {

+ } catch (B &b) { // expected-note {{for type 'HandlerInversion::B &'}}

+ } catch (D2 &d) { // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}

+ }

+}

+

+void f7() {

+ try {

+ } catch (B *b) { // Ok

+ } catch (D &d) { // Ok

+ }

+

+ try {

+ } catch (B b) { // Ok

+ } catch (D *d) { // Ok

+ }

+}

+

+void f8() {

+ try {

+ } catch (const B &b) { // expected-note {{for type 'const HandlerInversion::B &'}}

+ } catch (D2 &d) { // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}

+ }

+

+ try {

+ } catch (B &b) { // expected-note {{for type 'HandlerInversion::B &'}}

+ } catch (const D2 &d) { // expected-warning {{exception of type 'const HandlerInversion::D2 &' will be caught by earlier handler}}

+ }

+

+ try {

+ } catch (B b) { // expected-note {{for type 'HandlerInversion::B'}}

+ } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}

+ }

+}

+}

+

+namespace ConstVolatileThrow {

+struct S {

+ S() {} // expected-note{{candidate constructor not viable}}

+ S(const S &s); // expected-note{{candidate constructor not viable}}

+};

+

+typedef const volatile S CVS;

+

+void f() {

+ throw CVS(); // expected-error{{no matching constructor for initialization}}

+}

+}

+

+namespace ConstVolatileCatch {

+struct S {

+ S() {}

+ S(const volatile S &s);

+

+private:

+ S(const S &s); // expected-note {{declared private here}}

+};

+

+void f();

+

+void g() {

+ try {

+ f();

+ } catch (volatile S s) { // expected-error {{calling a private constructor}}

+ }

+}

+}

+ class X { X(); };

+ // X is not an aggregate, so constructors are considered,

+ // per 13.3.3.1/4 & DR1467.

+ const X x1{z};

+ const X& x2{z};

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11

+ for (e [[deprecated]] : arr) { e = 0; } // expected-warning{{use of the 'deprecated' attribute is a C++14 extension}} expected-warning {{deprecated}} expected-note {{here}} expected-error {{requires type for loop variable}}

+// RUN: %clang_cc1 -fsyntax-only -verify -Wformat -std=c++11 %s

+// expected-no-diagnostics

+extern "C" {

+extern int scanf(const char *restrict, ...);

+extern int printf(const char *restrict, ...);

+}

+

+void f(char *c) {

+ printf("%p", c);

+}

+ printf("%p", sp); // expected-warning{{format specifies type 'void *' but the argument has type 'char **'}}

+ scanf("%p", sp); // expected-warning{{format specifies type 'void **' but the argument has type 'char **'}}

+

+namespace implicit_this_tests {

+struct t {

+ void func1(const char *, ...) __attribute__((__format__(printf, 1, 2))); // expected-error {{format attribute cannot specify the implicit this argument as the format string}}

+ void (*func2)(const char *, ...) __attribute__((__format__(printf, 1, 2)));

+ static void (*func3)(const char *, ...) __attribute__((__format__(printf, 1, 2)));

+ static void func4(const char *, ...) __attribute__((__format__(printf, 1, 2)));

+};

+

+void f() {

+ t t1;

+ t1.func2("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}

+ t::func3("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}

+ t::func4("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}

+}

+}

+

+template<typename T>

+struct X_pr6954 {

+ operator int();

+ friend void f_pr6954(int x);

+};

+

+int array0_pr6954[sizeof(X_pr6954<int>)];

+int array1_pr6954[sizeof(X_pr6954<float>)];

+

+void g_pr6954() {

+ f_pr6954(5); // expected-error{{undeclared identifier 'f_pr6954'}}

+}

+

+ void m2() const { // expected-note {{member function 'C::m2' is declared const here}}

+ x = 0; // expected-error {{cannot assign to non-static data member within const member function 'm2'}}

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

+struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}} expected-note 2 {{candidate constructor (the implicit move constructor)}}

+ (void)int({}, 2); // expected-error{{excess elements in scalar initializer}}

+// RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -fms-extensions -Wno-deprecated %s

+

+// NOTE: use -Wno-deprecated to avoid cluttering the output with deprecated

+// warnings

+

+[[deprecated("1")]] int function_1();

+// expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}

+

+[[gnu::deprecated("3")]] int function_3();

+

+int __attribute__ (( deprecated("2") )) function_2();

+

+__declspec(deprecated("4")) int function_4();

+

+const int &incfail = ++i; // expected-error {{drops 'volatile' qualifier}}

+const int &decfail = --i; // expected-error {{drops 'volatile' qualifier}}

+// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++98

+typedef unsigned long long uint64_t;

+typedef unsigned long long uint32_t;

+

+uint64_t f0(uint64_t);

+uint64_t f1(uint64_t, uint32_t);

+uint64_t f2(uint64_t, ...);

+

+static const uint64_t overflow = 1 * 4608 * 1024 * 1024; // expected-warning {{overflow in expression; result is 536870912 with type 'int'}}

+

+uint64_t check_integer_overflows(int i) { //expected-note {{declared here}}

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ uint64_t overflow = 4608 * 1024 * 1024,

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow2 = (uint64_t)(4608 * 1024 * 1024),

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow3 = (uint64_t)(4608 * 1024 * 1024 * i),

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow4 = (1ULL * ((4608) * ((1024) * (1024))) + 2ULL),

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow5 = static_cast<uint64_t>(4608 * 1024 * 1024),

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ multi_overflow = (uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow += overflow2 = overflow3 = (uint64_t)(4608 * 1024 * 1024);

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow += overflow2 = overflow3 = 4608 * 1024 * 1024;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow += overflow2 = overflow3 = static_cast<uint64_t>(4608 * 1024 * 1024);

+

+ uint64_t not_overflow = 4608 * 1024 * 1024ULL;

+ uint64_t not_overflow2 = (1ULL * ((uint64_t)(4608) * (1024 * 1024)) + 2ULL);

+

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ overflow = 4608 * 1024 * 1024 ? 4608 * 1024 * 1024 : 0;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ overflow = 0 ? 0 : 4608 * 1024 * 1024;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if (4608 * 1024 * 1024)

+ return 0;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if ((uint64_t)(4608 * 1024 * 1024))

+ return 1;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if (static_cast<uint64_t>(4608 * 1024 * 1024))

+ return 1;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if ((uint64_t)(4608 * 1024 * 1024))

+ return 2;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if ((uint64_t)(4608 * 1024 * 1024 * i))

+ return 3;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ if ((1ULL * ((4608) * ((1024) * (1024))) + 2ULL))

+ return 4;

+

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ if ((uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024)))

+ return 5;

+

+ switch (i) {

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ case 4608 * 1024 * 1024:

+ return 6;

+// expected-warning@+1 {{overflow in expression; result is 537919488 with type 'int'}}

+ case (uint64_t)(4609 * 1024 * 1024):

+ return 7;

+// expected-warning@+1 {{overflow in expression; result is 537919488 with type 'int'}}

+ case 1 + static_cast<uint64_t>(4609 * 1024 * 1024):

+ return 7;

+// expected-error@+2 {{expression is not an integral constant expression}}

+// expected-note@+1 {{read of non-const variable 'i' is not allowed in a constant expression}}

+ case ((uint64_t)(4608 * 1024 * 1024 * i)):

+ return 8;

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ case ((1ULL * ((4608) * ((1024) * (1024))) + 2ULL)):

+ return 9;

+// expected-warning@+2 2{{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+1 {{overflow converting case value to switch condition type (288230376151711744 to 0)}}

+ case ((uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024))):

+ return 10;

+ }

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while (4608 * 1024 * 1024);

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while ((uint64_t)(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while (static_cast<uint64_t>(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while ((uint64_t)(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while ((uint64_t)(4608 * 1024 * 1024 * i));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ while ((1ULL * ((4608) * ((1024) * (1024))) + 2ULL));

+

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ while ((uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024)));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while (4608 * 1024 * 1024);

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while ((uint64_t)(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while (static_cast<uint64_t>(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while ((uint64_t)(4608 * 1024 * 1024));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while ((uint64_t)(4608 * 1024 * 1024 * i));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while ((1ULL * ((4608) * ((1024) * (1024))) + 2ULL));

+

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ do { } while ((uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024)));

+

+// expected-warning@+3 {{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+3 {{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+3 {{overflow in expression; result is 536870912 with type 'int'}}

+ for (uint64_t i = 4608 * 1024 * 1024;

+ (uint64_t)(4608 * 1024 * 1024);

+ i += (uint64_t)(4608 * 1024 * 1024 * i));

+

+// expected-warning@+3 {{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+3 2{{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+3 2{{overflow in expression; result is 536870912 with type 'int'}}

+ for (uint64_t i = (1ULL * ((4608) * ((1024) * (1024))) + 2ULL);

+ ((uint64_t)((uint64_t)(4608 * 1024 * 1024) * (uint64_t)(4608 * 1024 * 1024)));

+ i = ((4608 * 1024 * 1024) + ((uint64_t)(4608 * 1024 * 1024))));

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ _Complex long long x = 4608 * 1024 * 1024;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ (__real__ x) = 4608 * 1024 * 1024;

+

+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}

+ (__imag__ x) = 4608 * 1024 * 1024;

+

+// expected-warning@+4 {{overflow in expression; result is 536870912 with type 'int'}}

+// expected-warning@+3 {{array index 536870912 is past the end of the array (which contains 10 elements)}}

+// expected-note@+1 {{array 'a' declared here}}

+ uint64_t a[10];

+ a[4608 * 1024 * 1024] = 1i;

+

+// expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}

+ return ((4608 * 1024 * 1024) + ((uint64_t)(4608 * 1024 * 1024)));

+}

+ // CHECK: load i32, i32* @a,

+// CHECK: define linkonce_odr i8* @_ZN5test21A1BILj0EE3fooEv(

+ x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer; did you mean to use '.'?}}

+ return c->a; // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; did you mean to use '.'?}}

+ e->Func(); // expected-error {{member reference type 'PR15045::bar' is not a pointer; did you mean to use '.'?}} \

+ .i; // expected-error {{member reference type 'pr16676::S *' is a pointer; did you mean to use '->'}}

+static_assert(__alignof(int IncSingle::*) == __alignof(void *), "");

+static_assert(__alignof(int IncMultiple::*) == __alignof(void *), "");

+static_assert(__alignof(int IncVirtual::*) == __alignof(void *), "");

+static_assert(__alignof(void (IncSingle::*)()) == __alignof(void *), "");

+static_assert(__alignof(void (IncMultiple::*)()) == __alignof(void *), "");

+static_assert(__alignof(void (IncVirtual::*)()) == __alignof(void *), "");

+// more slot than virtual.

+void (*A::*ppfie)() throw(); // expected-error {{exception specifications are not allowed beyond a single level of indirection}}

+int B::*pbi; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \

+ // expected-error {{'pbi' does not point into a class}}

+void f() {

+ VC vc;

+void *u = new (ect, {0}) int[4]; // expected-warning {{braces around scalar init}}

+// RUN: %clang_cc1 %s -fsyntax-only -verify -fms-extensions -Wno-microsoft -std=c++11

+

+struct __declspec(novtable) S {};

+enum __declspec(novtable) E {}; // expected-warning{{'novtable' attribute only applies to classes}}

+int __declspec(novtable) I; // expected-warning{{'novtable' attribute only applies to classes}}

+typedef struct T __declspec(novtable) U; // expected-warning{{'novtable' attribute only applies to classes}}

+auto z = []() __declspec(novtable) { return nullptr; }; // expected-warning{{'novtable' attribute only applies to classes}}

+

+constexpr int f(char) { return 1; }

+constexpr int f(signed char) { return 2; }

+

+static_assert(f(0i8) == 1, "");

+// RUN: %clang_cc1 %s -fsyntax-only -verify -fms-compatibility

+

+struct S {

+ mutable int &a; // expected-warning {{'mutable' on a reference type is a Microsoft extension}}

+ S(int &b) : a(b) {}

+};

+

+int main() {

+ int a = 0;

+ const S s(a);

+ s.a = 10;

+ return s.a + a;

+}

+::A::ax::undef ex3; // expected-error {{'ax' is not a class, namespace, or enumeration}}

+ N::x = 0; // expected-error {{'N' is not a class, namespace, or enumeration}}

+ { typedef int A; A::ax = 0; } // expected-error{{'A' (aka 'int') is not a class, namespace, or enumeration}}

+ int f() {

+ return E::X; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}

+TypedefNamespace::F::NonexistentName BadNNSWithCXXScopeSpec; // expected-error {{'F' (aka 'int') is not a class, namespace, or enumeration}}

+

+namespace PR16951 {

+ namespace ns {

+ enum an_enumeration {

+ ENUMERATOR // expected-note{{'ENUMERATOR' declared here}}

+ };

+ }

+

+ int x1 = ns::an_enumeration::ENUMERATOR; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}

+

+ int x2 = ns::an_enumeration::ENUMERATOR::vvv; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \

+ // expected-error{{'ENUMERATOR' is not a class, namespace, or enumeration}} \

+

+ int x3 = ns::an_enumeration::X; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \

+ // expected-error{{no member named 'X'}}

+

+ enum enumerator_2 {

+ ENUMERATOR_2

+ };

+

+ int x4 = enumerator_2::ENUMERATOR_2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}

+ int x5 = enumerator_2::X2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \

+ // expected-error{{no member named 'X2' in 'PR16951::enumerator_2'}}

+

+}

+struct TwoValueInts : ValueInt, IndirectValueInt { }; // expected-warning{{direct base 'ValueInt' is inaccessible due to ambiguity:\n struct TwoValueInts -> struct ValueInt\n struct TwoValueInts -> struct IndirectValueInt -> struct ValueInt}}

+

+

+namespace {

+template <class C>

+struct A {

+ void f() { this->::new; } // expected-error {{expected unqualified-id}}

+ void g() { this->::delete; } // expected-error {{expected unqualified-id}}

+};

+}

+ void h(); // expected-note {{previous declaration is here}}

+ void h() __restrict; // expected-error {{class member cannot be redeclared}}

+ ii->~Integer(); // expected-error{{member reference type 'int' is not a pointer; did you mean to use '.'?}}

+ ip->~Integer; // expected-error{{reference to pseudo-destructor must be called}}

+}

+

+void paren_destroy_with_call(int *ip) {

+ (ip->~Integer)();

+ const int& r = cvi; // expected-error{{binding value of type 'const volatile int' to reference to type 'const int' drops 'volatile' qualifier}}

+struct C : B, A { }; // expected-warning {{direct base 'A' is inaccessible due to ambiguity:\n struct C -> struct B -> struct A\nstruct C -> struct A}}

+ (void)*reinterpret_cast<void*>(&a); // expected-warning {{ISO C++ does not allow}}

+ (void)*reinterpret_cast<void*>(&b); // expected-warning {{ISO C++ does not allow}}

+ (void)*reinterpret_cast<void*>(&l); // expected-warning {{ISO C++ does not allow}}

+ (void)*reinterpret_cast<void*>(&d); // expected-warning {{ISO C++ does not allow}}

+ (void)*reinterpret_cast<void*>(&f); // expected-warning {{ISO C++ does not allow}}

+// RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions %s -Wno-unreachable-code

+// RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions -std=gnu++11 %s -Wno-unreachable-code

+

+namespace seh {

+

+// Jumping into SEH try blocks is not permitted.

+

+void jump_into_except() {

+ goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}

+ __try { // expected-note {{jump bypasses initialization of __try block}}

+ into_try_except_try:

+ ;

+ } __except(0) {

+ }

+

+ goto into_try_except_except; // expected-error {{cannot jump from this goto statement to its label}}

+ __try {

+ } __except(0) { // expected-note {{jump bypasses initialization of __except block}}

+ into_try_except_except:

+ ;

+ }

+}

+

+void jump_into_finally() {

+ goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}

+ __try { // expected-note {{jump bypasses initialization of __try block}}

+ into_try_except_try:

+ ;

+ } __finally {

+ }

+

+ goto into_try_except_finally; // expected-error {{cannot jump from this goto statement to its label}}

+ __try {

+ } __finally { // expected-note {{jump bypasses initialization of __finally block}}

+ into_try_except_finally:

+ ;

+ }

+}

+

+// Jumping out of SEH try blocks ok in general. (Jumping out of a __finally

+// has undefined behavior.)

+

+void jump_out_of_except() {

+ __try {

+ goto out_of_except_try;

+ } __except(0) {

+ }

+out_of_except_try:

+ ;

+

+ __try {

+ } __except(0) {

+ goto out_of_except_except;

+ }

+out_of_except_except:

+ ;

+}

+

+void jump_out_of_finally() {

+ __try {

+ goto out_of_finally_try;

+ } __finally {

+ }

+out_of_finally_try:

+ ;

+

+ __try {

+ } __finally {

+ goto out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}

+ }

+

+ __try {

+ } __finally {

+ goto *&&out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}

+ }

+out_of_finally_finally:

+ ;

+}

+

+// Jumping between protected scope and handler is not permitted.

+

+void jump_try_except() {

+ __try {

+ goto from_try_to_except; // expected-error {{cannot jump from this goto statement to its label}}

+ } __except(0) { // expected-note {{jump bypasses initialization of __except block}}

+ from_try_to_except:

+ ;

+ }

+

+ __try { // expected-note {{jump bypasses initialization of __try block}}

+ from_except_to_try:

+ ;

+ } __except(0) {

+ goto from_except_to_try; // expected-error {{cannot jump from this goto statement to its label}}

+ }

+}

+

+void jump_try_finally() {

+ __try {

+ goto from_try_to_finally; // expected-error {{cannot jump from this goto statement to its label}}

+ } __finally { // expected-note {{jump bypasses initialization of __finally block}}

+ from_try_to_finally:

+ ;

+ }

+

+ __try { // expected-note {{jump bypasses initialization of __try block}}

+ from_finally_to_try:

+ ;

+ } __finally {

+ goto from_finally_to_try; // expected-error {{cannot jump from this goto statement to its label}} expected-warning {{jump out of __finally block has undefined behavior}}

+ }

+}

+

+void nested() {

+ // These are not permitted.

+ __try {

+ __try {

+ } __finally {

+ goto outer_except; // expected-error {{cannot jump from this goto statement to its label}}

+ }

+ } __except(0) { // expected-note {{jump bypasses initialization of __except bloc}}

+ outer_except:

+ ;

+ }

+

+ __try {

+ __try{

+ } __except(0) {

+ goto outer_finally; // expected-error {{cannot jump from this goto statement to its label}}

+ }

+ } __finally { // expected-note {{jump bypasses initialization of __finally bloc}}

+ outer_finally:

+ ;

+ }

+

+ // These are permitted.

+ __try {

+ __try {

+ } __finally {

+ goto after_outer_except; // expected-warning {{jump out of __finally block has undefined behavior}}

+ }

+ } __except(0) {

+ }

+after_outer_except:

+ ;

+

+ __try {

+ __try{

+ } __except(0) {

+ goto after_outer_finally;

+ }

+ } __finally {

+ }

+after_outer_finally:

+ ;

+}

+

+// This section is academic, as MSVC doesn't support indirect gotos.

+

+void indirect_jumps(void **ip) {

+ static void *ips[] = { &&l };

+

+ __try { // expected-note {{jump exits __try block}}

+ // FIXME: Should this be allowed? Jumping out of the guarded section of a

+ // __try/__except doesn't require unwinding.

+ goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}

+ } __except(0) {

+ }

+

+ __try {

+ } __except(0) { // expected-note {{jump exits __except block}}

+ // FIXME: What about here?

+ goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}

+ }

+

+ __try { // expected-note {{jump exits __try block}}

+ goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}

+ } __finally {

+ }

+

+ __try {

+ } __finally { // expected-note {{jump exits __finally block}}

+ goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}

+ }

+l: // expected-note 4 {{possible target of indirect goto statement}}

+ ;

+}

+

+} // namespace seh

+struct I; // Incomplete. expected-note {{'I' is incomplete}}

+struct J; // Incomplete. expected-note {{'J' is incomplete}}

+ (void)static_cast<E*>((B*)0); // expected-error {{static_cast from 'B *' to 'E *', which are not related by inheritance, is not allowed}}

+

+ (void)static_cast<E*>((J*)0); // expected-error {{static_cast from 'J *' to 'E *', which are not related by inheritance, is not allowed}}

+ (void)static_cast<I*>((B*)0); // expected-error {{static_cast from 'B *' to 'I *', which are not related by inheritance, is not allowed}}

+

+ { int arr[T(__is_trivially_copyable(NonTrivialDefault))]; }

+ { int arr[T(__is_trivially_copyable(NonTrivialDefault[]))]; }

+ { int arr[T(__is_trivially_copyable(NonTrivialDefault[3]))]; }

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

+

+namespace PR23186 {

+decltype(ned); // expected-error-re {{use of undeclared identifier 'ned'{{$}}}}

+// The code below was triggering an UNREACHABLE in ASTContext::getTypeInfoImpl

+// once the above code failed to recover properly after making the bogus

+// correction of 'ned' to 'new'.

+template <typename>

+struct S {

+ enum { V };

+ void f() {

+ switch (0)

+ case V:

+ ;

+ }

+};

+}

+

+namespace PR23140 {

+auto lneed = gned.*[] {}; // expected-error-re {{use of undeclared identifier 'gned'{{$}}}}

+

+void test(int aaa, int bbb, int thisvar) { // expected-note {{'thisvar' declared here}}

+ int thatval = aaa * (bbb + thatvar); // expected-error {{use of undeclared identifier 'thatvar'; did you mean 'thisvar'?}}

+}

+}

+

+namespace PR18854 {

+void f() {

+ for (auto&& x : e) { // expected-error-re {{use of undeclared identifier 'e'{{$}}}}

+ auto Functor = [x]() {};

+ long Alignment = __alignof__(Functor);

+ }

+}

+}

+extern long clock (void);

+struct Pointer {

+ void set_xpos(int);

+ void set_ypos(int);

+};

+void MovePointer(Pointer &Click, int x, int y) { // expected-note 2 {{'Click' declared here}}

+ click.set_xpos(x); // expected-error {{use of undeclared identifier 'click'; did you mean 'Click'?}}

+ click.set_ypos(x); // expected-error {{use of undeclared identifier 'click'; did you mean 'Click'?}}

+}

+

+

+namespace PR23005 {

+void f() { int a = Unknown::b(c); } // expected-error {{use of undeclared identifier 'Unknown'}}

+// expected-error@-1 {{use of undeclared identifier 'c'}}

+}

+

+namespace PR23350 {

+int z = 1 ? N : ; // expected-error {{expected expression}}

+// expected-error-re@-1 {{use of undeclared identifier 'N'{{$}}}}

+}

+

+// PR 23285. This test must be at the end of the file to avoid additional,

+// unwanted diagnostics.

+// expected-error-re@+2 {{use of undeclared identifier 'uintmax_t'{{$}}}}

+// expected-error@+1 {{expected ';' after top level declarator}}

+unsigned int a = 0(uintmax_t

+

+namespace crash_has_include {

+int has_include(int); // expected-note {{'has_include' declared here}}

+// expected-error@+1 {{__has_include must be used within a preprocessing directive}}

+int foo = __has_include(42); // expected-error {{use of undeclared identifier '__has_include'; did you mean 'has_include'?}}

+}

+void test_comma() {

+ int a; // expected-note {{initialize the variable 'a' to silence this warning}}

+ int b = (a, a ?: 2); // expected-warning {{variable 'a' is uninitialized when used here}}

+ int c = (a, a, b, c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}

+ int d; // expected-note {{initialize the variable 'd' to silence this warning}}

+ int e = (foo(d), e, b); // expected-warning {{variable 'd' is uninitialized when used here}}

+ int f; // expected-note {{initialize the variable 'f' to silence this warning}}

+ f = f + 1, 2; // expected-warning {{variable 'f' is uninitialized when used here}}

+ int h;

+ int g = (h, g, 2); // no-warning: h, g are evaluated but not used.

+}

+

+namespace member_ptr {

+struct A {

+ int x;

+ int y;

+ A(int x) : x{x} {}

+};

+

+void test_member_ptr() {

+ int A::* px = &A::x;

+ A a{a.*px}; // expected-warning {{variable 'a' is uninitialized when used within its own initialization}}

+ A b = b; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}

+}

+}

+

+namespace const_ptr {

+void foo(int *a);

+void bar(const int *a);

+void foobar(const int **a);

+

+void test_const_ptr() {

+ int a;

+ int b; // expected-note {{initialize the variable 'b' to silence this warning}}

+ foo(&a);

+ bar(&b);

+ b = a + b; // expected-warning {{variable 'b' is uninitialized when used here}}

+ int *ptr; //expected-note {{initialize the variable 'ptr' to silence this warning}}

+ const int *ptr2;

+ foo(ptr); // expected-warning {{variable 'ptr' is uninitialized when used here}}

+ foobar(&ptr2);

+}

+}

+

+

+void array_capture(bool b) {

+ const char fname[] = "array_capture";

+ if (b) {

+ int unused; // expected-warning {{unused variable}}

+ } else {

+ [fname]{};

+ }

+}

+catch (BaseEx &e) { f(); } // expected-note 2{{for type 'BaseEx &'}}

+catch (Ex1 &e) { f(); } // expected-warning {{exception of type 'Ex1 &' will be caught by earlier handler}}

+catch (Ex2 &e) { f(); } // expected-warning {{exception of type 'Ex2 &' (aka 'Ex1 &') will be caught by earlier handler}}

+struct b : a, a1 { }; // expected-warning{{direct base 'T4::a' is inaccessible due to ambiguity:\n struct T4::b -> struct T4::a\n struct T4::b -> struct T4::a1 -> struct T4::a}}

+

+void pr23151(int (&)[*]) { // expected-error {{variable length array must be bound in function definition}}

+}

+struct X1 { virtual void f(); } x1, x1arr[2];

+ memset(x1arr, 0, sizeof x1arr); // \

+ // expected-warning {{destination for this 'memset' call is a pointer to dynamic class}} \

+ // expected-note {{explicitly cast the pointer to silence this warning}}

+ memset((void*)x1arr, 0, sizeof x1arr);

+// Tests if state information is correctly discarded for certain shapes of CFGs.

+void testSwitchGOTO(void) {

+ int a;

+

+ LABEL0:

+ switch (a)

+ case 0:

+ goto LABEL0;

+

+ goto LABEL0;

+}

+

+#define MACRO_A 0

+

+ // Check that we handle conditions that start or end with a macro

+ // correctly.

+ if (x == MACRO_A); // expected-warning {{if statement has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}}

+ if (MACRO_A == x); // expected-warning {{if statement has empty body}} expected-note{{put the semicolon on a separate line to silence this warning}}

+

+ memset(iarr, 0, sizeof iarr);

+ memset(iparr, 0, sizeof iparr);

+// RUN: %clang_cc1 -fsyntax-only -verify -Wmissing-prototypes -std=c++11 %s

+// Don't warn on explicitly deleted functions.

+void j() = delete;

+// RUN: %clang_cc1 -fsyntax-only -Wpessimizing-move -std=c++11 -verify %s

+// RUN: %clang_cc1 -fsyntax-only -Wpessimizing-move -std=c++11 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s

+

+// definitions for std::move

+namespace std {

+inline namespace foo {

+template <class T> struct remove_reference { typedef T type; };

+template <class T> struct remove_reference<T&> { typedef T type; };

+template <class T> struct remove_reference<T&&> { typedef T type; };

+

+template <class T> typename remove_reference<T>::type &&move(T &&t);

+}

+}

+

+struct A {};

+struct B {

+ B() {}

+ B(A) {}

+};

+

+A test1(A a1) {

+ A a2;

+ return a1;

+ return a2;

+ return std::move(a1);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(a2);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+}

+

+B test2(A a1, B b1) {

+ // Object is different than return type so don't warn.

+ A a2;

+ return a1;

+ return a2;

+ return std::move(a1);

+ return std::move(a2);

+

+ B b2;

+ return b1;

+ return b2;

+ return std::move(b1);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(b2);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+}

+

+A global_a;

+A test3() {

+ // Don't warn when object is not local.

+ return global_a;

+ return std::move(global_a);

+ static A static_a;

+ return static_a;

+ return std::move(static_a);

+

+}

+

+A test4() {

+ return A();

+ return test3();

+

+ return std::move(A());

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:23-[[@LINE-4]]:24}:""

+ return std::move(test3());

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:27-[[@LINE-4]]:28}:""

+}

+

+void test5(A) {

+ test5(A());

+ test5(test4());

+

+ test5(std::move(A()));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:9-[[@LINE-3]]:19}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ test5(std::move(test4()));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:9-[[@LINE-3]]:19}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:26-[[@LINE-4]]:27}:""

+}

+

+void test6() {

+ A a1 = A();

+ A a2 = test3();

+

+ A a3 = std::move(A());

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:23-[[@LINE-4]]:24}:""

+ A a4 = std::move(test3());

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:27-[[@LINE-4]]:28}:""

+}

+

+A test7() {

+ A a1 = std::move(A());

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:23-[[@LINE-4]]:24}:""

+ A a2 = std::move((A()));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:25-[[@LINE-4]]:26}:""

+ A a3 = (std::move(A()));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:21}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:24-[[@LINE-4]]:25}:""

+ A a4 = (std::move((A())));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:21}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:26-[[@LINE-4]]:27}:""

+

+ return std::move(a1);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move((a1));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:24-[[@LINE-4]]:25}:""

+ return (std::move(a1));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:21}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:23-[[@LINE-4]]:24}:""

+ return (std::move((a1)));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:21}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:25-[[@LINE-4]]:26}:""

+}

+

+#define wrap1(x) x

+#define wrap2(x) x

+

+// Macro test. Since the std::move call is outside the macro, it is

+// safe to suggest a fix-it.

+A test8(A a) {

+ return std::move(a);

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:21-[[@LINE-4]]:22}:""

+ return std::move(wrap1(a));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:28-[[@LINE-4]]:29}:""

+ return std::move(wrap1(wrap2(a)));

+ // expected-warning@-1{{prevents copy elision}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:35-[[@LINE-4]]:36}:""

+}

+

+#define test9 \

+ A test9(A a) { \

+ return std::move(a); \

+ }

+

+// Macro test. The std::call is inside the macro, so no fix-it is suggested.

+test9

+// expected-warning@-1{{prevents copy elision}}

+// CHECK-NOT: fix-it

+

+#define return_a return std::move(a)

+

+// Macro test. The std::call is inside the macro, so no fix-it is suggested.

+A test10(A a) {

+ return_a;

+ // expected-warning@-1{{prevents copy elision}}

+ // CHECK-NOT: fix-it

+}

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wloop-analysis -verify %s

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -Wrange-loop-analysis -verify %s

+

+template <typename return_type>

+struct Iterator {

+ return_type operator*();

+ Iterator operator++();

+ bool operator!=(const Iterator);

+};

+

+template <typename T>

+struct Container {

+ typedef Iterator<T> I;

+

+ I begin();

+ I end();

+};

+

+struct Foo {};

+struct Bar {

+ Bar(Foo);

+ Bar(int);

+ operator int();

+};

+

+// Testing notes:

+// test0 checks that the full text of the warnings and notes is correct. The

+// rest of the tests checks a smaller portion of the text.

+// test1-6 are set in pairs, the odd numbers are the non-reference returning

+// versions of the even numbers.

+// test7-9 use an array instead of a range object

+// tests use all four versions of the loop varaible, const &T, const T, T&, and

+// T. Versions producing errors and are commented out.

+//

+// Conversion chart:

+// double <=> int

+// int <=> Bar

+// double => Bar

+// Foo => Bar

+//

+// Conversions during tests:

+// test1-2

+// int => int

+// int => double

+// int => Bar

+// test3-4

+// Bar => Bar

+// Bar => int

+// test5-6

+// Foo => Bar

+// test7

+// double => double

+// double => int

+// double => Bar

+// test8

+// Foo => Foo

+// Foo => Bar

+// test9

+// Bar => Bar

+// Bar => int

+

+void test0() {

+ Container<int> int_non_ref_container;

+ Container<int&> int_container;

+ Container<Bar&> bar_container;

+

+ for (const int &x : int_non_ref_container) {}

+ // expected-warning@-1 {{loop variable 'x' is always a copy because the range of type 'Container<int>' does not return a reference}}

+ // expected-note@-2 {{use non-reference type 'int'}}

+

+ for (const double &x : int_container) {}

+ // expected-warning@-1 {{loop variable 'x' has type 'const double &' but is initialized with type 'int' resulting in a copy}}

+ // expected-note@-2 {{use non-reference type 'double' to keep the copy or type 'const int &' to prevent copying}}

+

+ for (const Bar x : bar_container) {}

+ // expected-warning@-1 {{loop variable 'x' of type 'const Bar' creates a copy from type 'const Bar'}}

+ // expected-note@-2 {{use reference type 'const Bar &' to prevent copying}}

+}

+

+void test1() {

+ Container<int> A;

+

+ for (const int &x : A) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'int'}}

+ for (const int x : A) {}

+ // No warning, non-reference type indicates copy is made

+ //for (int &x : A) {}

+ // Binding error

+ for (int x : A) {}

+ // No warning, non-reference type indicates copy is made

+

+ for (const double &x : A) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'double'}}

+ for (const double x : A) {}

+ // No warning, non-reference type indicates copy is made

+ //for (double &x : A) {}

+ // Binding error

+ for (double x : A) {}

+ // No warning, non-reference type indicates copy is made

+

+ for (const Bar &x : A) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'Bar'}}

+ for (const Bar x : A) {}

+ // No warning, non-reference type indicates copy is made

+ //for (Bar &x : A) {}

+ // Binding error

+ for (Bar x : A) {}

+ // No warning, non-reference type indicates copy is made

+}

+

+void test2() {

+ Container<int&> B;

+

+ for (const int &x : B) {}

+ // No warning, this reference is not a temporary

+ for (const int x : B) {}

+ // No warning on POD copy

+ for (int &x : B) {}

+ // No warning

+ for (int x : B) {}

+ // No warning

+

+ for (const double &x : B) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'double'{{.*}}'const int &'}}

+ for (const double x : B) {}

+ //for (double &x : B) {}

+ // Binding error

+ for (double x : B) {}

+ // No warning

+

+ for (const Bar &x : B) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note@-2 {{'Bar'}}

+ for (const Bar x : B) {}

+ //for (Bar &x : B) {}

+ // Binding error

+ for (Bar x : B) {}

+ // No warning

+}

+

+void test3() {

+ Container<Bar> C;

+

+ for (const Bar &x : C) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'Bar'}}

+ for (const Bar x : C) {}

+ // No warning, non-reference type indicates copy is made

+ //for (Bar &x : C) {}

+ // Binding error

+ for (Bar x : C) {}

+ // No warning, non-reference type indicates copy is made

+

+ for (const int &x : C) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'int'}}

+ for (const int x : C) {}

+ // No warning, copy made

+ //for (int &x : C) {}

+ // Binding error

+ for (int x : C) {}

+ // No warning, copy made

+}

+

+void test4() {

+ Container<Bar&> D;

+

+ for (const Bar &x : D) {}

+ // No warning, this reference is not a temporary

+ for (const Bar x : D) {}

+ // expected-warning@-1 {{creates a copy}}

+ // expected-note@-2 {{'const Bar &'}}

+ for (Bar &x : D) {}

+ // No warning

+ for (Bar x : D) {}

+ // No warning

+

+ for (const int &x : D) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'int'{{.*}}'const Bar &'}}

+ for (const int x : D) {}

+ // No warning

+ //for (int &x : D) {}

+ // Binding error

+ for (int x : D) {}

+ // No warning

+}

+

+void test5() {

+ Container<Foo> E;

+

+ for (const Bar &x : E) {}

+ // expected-warning@-1 {{always a copy}}

+ // expected-note@-2 {{'Bar'}}

+ for (const Bar x : E) {}

+ // No warning, non-reference type indicates copy is made

+ //for (Bar &x : E) {}

+ // Binding error

+ for (Bar x : E) {}

+ // No warning, non-reference type indicates copy is made

+}

+

+void test6() {

+ Container<Foo&> F;

+

+ for (const Bar &x : F) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'Bar'{{.*}}'const Foo &'}}

+ for (const Bar x : F) {}

+ // No warning.

+ //for (Bar &x : F) {}

+ // Binding error

+ for (Bar x : F) {}

+ // No warning

+}

+

+void test7() {

+ double G[2];

+

+ for (const double &x : G) {}

+ // No warning

+ for (const double x : G) {}

+ // No warning on POD copy

+ for (double &x : G) {}

+ // No warning

+ for (double x : G) {}

+ // No warning

+

+ for (const int &x : G) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'int'{{.*}}'const double &'}}

+ for (const int x : G) {}

+ // No warning

+ //for (int &x : G) {}

+ // Binding error

+ for (int x : G) {}

+ // No warning

+

+ for (const Bar &x : G) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'Bar'{{.*}}'const double &'}}

+ for (const Bar x : G) {}

+ // No warning

+ //for (int &Bar : G) {}

+ // Binding error

+ for (int Bar : G) {}

+ // No warning

+}

+

+void test8() {

+ Foo H[2];

+

+ for (const Foo &x : H) {}

+ // No warning

+ for (const Foo x : H) {}

+ // No warning on POD copy

+ for (Foo &x : H) {}

+ // No warning

+ for (Foo x : H) {}

+ // No warning

+

+ for (const Bar &x : H) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'Bar'{{.*}}'const Foo &'}}

+ for (const Bar x : H) {}

+ // No warning

+ //for (Bar &x: H) {}

+ // Binding error

+ for (Bar x: H) {}

+ // No warning

+}

+

+void test9() {

+ Bar I[2] = {1,2};

+

+ for (const Bar &x : I) {}

+ // No warning

+ for (const Bar x : I) {}

+ // expected-warning@-1 {{creates a copy}}

+ // expected-note@-2 {{'const Bar &'}}

+ for (Bar &x : I) {}

+ // No warning

+ for (Bar x : I) {}

+ // No warning

+

+ for (const int &x : I) {}

+ // expected-warning@-1 {{resulting in a copy}}

+ // expected-note-re@-2 {{'int'{{.*}}'const Bar &'}}

+ for (const int x : I) {}

+ // No warning

+ //for (int &x : I) {}

+ // Binding error

+ for (int x : I) {}

+ // No warning

+}

+// RUN: %clang_cc1 -fsyntax-only -Wredundant-move -std=c++11 -verify %s

+// RUN: %clang_cc1 -fsyntax-only -Wredundant-move -std=c++11 -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s

+

+// definitions for std::move

+namespace std {

+inline namespace foo {

+template <class T> struct remove_reference { typedef T type; };

+template <class T> struct remove_reference<T&> { typedef T type; };

+template <class T> struct remove_reference<T&&> { typedef T type; };

+

+template <class T> typename remove_reference<T>::type &&move(T &&t);

+}

+}

+

+struct A {};

+struct B : public A {};

+

+A test1(B b1) {

+ B b2;

+ return b1;

+ return b2;

+ return std::move(b1);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(b2);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+}

+

+struct C {

+ C() {}

+ C(A) {}

+};

+

+C test2(A a1, B b1) {

+ A a2;

+ B b2;

+

+ return a1;

+ return a2;

+ return b1;

+ return b2;

+

+ return std::move(a1);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(a2);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(b1);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+ return std::move(b2);

+ // expected-warning@-1{{redundant move}}

+ // expected-note@-2{{remove std::move call}}

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:10-[[@LINE-3]]:20}:""

+ // CHECK: fix-it:"{{.*}}":{[[@LINE-4]]:22-[[@LINE-4]]:23}:""

+}

+

+// Copy of tests above with types changed to reference types.

+A test3(B& b1) {

+ B& b2 = b1;

+ return b1;

+ return b2;

+ return std::move(b1);

+ return std::move(b2);

+}

+

+C test4(A& a1, B& b1) {

+ A& a2 = a1;

+ B& b2 = b1;

+

+ return a1;

+ return a2;

+ return b1;

+ return b2;

+

+ return std::move(a1);

+ return std::move(a2);

+ return std::move(b1);

+ return std::move(b2);

+}

+class DMA : public virtual A, public virtual DA { //expected-warning{{direct base 'A' is inaccessible due to ambiguity:\n class DMA -> class A\n class DMA -> class DA -> class A}}

+#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 ASSERT_EXCLUSIVE_LOCK(...) __attribute__((assert_exclusive_lock(__VA_ARGS__)))

+#define ASSERT_SHARED_LOCK(...) __attribute__((assert_shared_lock(__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 EXCLUSIVE_UNLOCK_FUNCTION(...) __attribute__((release_capability(__VA_ARGS__)))

+#define SHARED_UNLOCK_FUNCTION(...) __attribute__((release_shared_capability(__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 LOCKABLE Mutex {

+class SCOPED_LOCKABLE MutexLock {

+ MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);

+ MutexLock(Mutex *mu, bool adopt) EXCLUSIVE_LOCKS_REQUIRED(mu);

+ ~MutexLock() UNLOCK_FUNCTION();

+class SCOPED_LOCKABLE ReaderMutexLock {

+ ReaderMutexLock(Mutex *mu) SHARED_LOCK_FUNCTION(mu);

+ ReaderMutexLock(Mutex *mu, bool adopt) SHARED_LOCKS_REQUIRED(mu);

+ ~ReaderMutexLock() UNLOCK_FUNCTION();

+ // TODO -- these require better smart pointer handling.

+

+namespace AcquiredBeforeAfterText {

+

+class Foo {

+ Mutex mu1 ACQUIRED_BEFORE(mu2, mu3);

+ Mutex mu2;

+ Mutex mu3;

+

+ void test1() {

+ mu1.Lock();

+ mu2.Lock();

+ mu3.Lock();

+

+ mu3.Unlock();

+ mu2.Unlock();

+ mu1.Unlock();

+ }

+

+ void test2() {

+ mu2.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu2'}}

+ mu1.Unlock();

+ mu2.Unlock();

+ }

+

+ void test3() {

+ mu3.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu3'}}

+ mu1.Unlock();

+ mu3.Unlock();

+ }

+

+ void test4() EXCLUSIVE_LOCKS_REQUIRED(mu1) {

+ mu2.Lock();

+ mu2.Unlock();

+ }

+

+ void test5() EXCLUSIVE_LOCKS_REQUIRED(mu2) {

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu2'}}

+ mu1.Unlock();

+ }

+

+ void test6() EXCLUSIVE_LOCKS_REQUIRED(mu2) {

+ mu1.AssertHeld();

+ }

+

+ void test7() EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2, mu3) { }

+

+ void test8() EXCLUSIVE_LOCKS_REQUIRED(mu3, mu2, mu1) { }

+};

+

+

+class Foo2 {

+ Mutex mu1;

+ Mutex mu2 ACQUIRED_AFTER(mu1);

+ Mutex mu3 ACQUIRED_AFTER(mu1);

+

+ void test1() {

+ mu1.Lock();

+ mu2.Lock();

+ mu3.Lock();

+

+ mu3.Unlock();

+ mu2.Unlock();

+ mu1.Unlock();

+ }

+

+ void test2() {

+ mu2.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu2'}}

+ mu1.Unlock();

+ mu2.Unlock();

+ }

+

+ void test3() {

+ mu3.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu3'}}

+ mu1.Unlock();

+ mu3.Unlock();

+ }

+};

+

+

+class Foo3 {

+ Mutex mu1 ACQUIRED_BEFORE(mu2);

+ Mutex mu2;

+ Mutex mu3 ACQUIRED_AFTER(mu2) ACQUIRED_BEFORE(mu4);

+ Mutex mu4;

+

+ void test1() {

+ mu1.Lock();

+ mu2.Lock();

+ mu3.Lock();

+ mu4.Lock();

+

+ mu4.Unlock();

+ mu3.Unlock();

+ mu2.Unlock();

+ mu1.Unlock();

+ }

+

+ void test2() {

+ mu4.Lock();

+ mu2.Lock(); // expected-warning {{mutex 'mu2' must be acquired before 'mu4'}}

+

+ mu2.Unlock();

+ mu4.Unlock();

+ }

+

+ void test3() {

+ mu4.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu4'}}

+

+ mu1.Unlock();

+ mu4.Unlock();

+ }

+

+ void test4() {

+ mu3.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu3'}}

+

+ mu1.Unlock();

+ mu3.Unlock();

+ }

+};

+

+

+// Test transitive DAG traversal with AFTER

+class Foo4 {

+ Mutex mu1;

+ Mutex mu2 ACQUIRED_AFTER(mu1);

+ Mutex mu3 ACQUIRED_AFTER(mu1);

+ Mutex mu4 ACQUIRED_AFTER(mu2, mu3);

+ Mutex mu5 ACQUIRED_AFTER(mu4);

+ Mutex mu6 ACQUIRED_AFTER(mu4);

+ Mutex mu7 ACQUIRED_AFTER(mu5, mu6);

+ Mutex mu8 ACQUIRED_AFTER(mu7);

+

+ void test() {

+ mu8.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu8'}}

+ mu1.Unlock();

+ mu8.Unlock();

+ }

+};

+

+

+// Test transitive DAG traversal with BEFORE

+class Foo5 {

+ Mutex mu1 ACQUIRED_BEFORE(mu2, mu3);

+ Mutex mu2 ACQUIRED_BEFORE(mu4);

+ Mutex mu3 ACQUIRED_BEFORE(mu4);

+ Mutex mu4 ACQUIRED_BEFORE(mu5, mu6);

+ Mutex mu5 ACQUIRED_BEFORE(mu7);

+ Mutex mu6 ACQUIRED_BEFORE(mu7);

+ Mutex mu7 ACQUIRED_BEFORE(mu8);

+ Mutex mu8;

+

+ void test() {

+ mu8.Lock();

+ mu1.Lock(); // expected-warning {{mutex 'mu1' must be acquired before 'mu8'}}

+ mu1.Unlock();

+ mu8.Unlock();

+ }

+};

+

+

+class Foo6 {

+ Mutex mu1 ACQUIRED_AFTER(mu3); // expected-warning {{Cycle in acquired_before/after dependencies, starting with 'mu1'}}

+ Mutex mu2 ACQUIRED_AFTER(mu1); // expected-warning {{Cycle in acquired_before/after dependencies, starting with 'mu2'}}

+ Mutex mu3 ACQUIRED_AFTER(mu2); // expected-warning {{Cycle in acquired_before/after dependencies, starting with 'mu3'}}

+

+ Mutex mu_b ACQUIRED_BEFORE(mu_b); // expected-warning {{Cycle in acquired_before/after dependencies, starting with 'mu_b'}}

+ Mutex mu_a ACQUIRED_AFTER(mu_a); // expected-warning {{Cycle in acquired_before/after dependencies, starting with 'mu_a'}}

+

+ void test0() {

+ mu_a.Lock();

+ mu_b.Lock();

+ mu_b.Unlock();

+ mu_a.Unlock();

+ }

+

+ void test1a() {

+ mu1.Lock();

+ mu1.Unlock();

+ }

+

+ void test1b() {

+ mu1.Lock();

+ mu_a.Lock();

+ mu_b.Lock();

+ mu_b.Unlock();

+ mu_a.Unlock();

+ mu1.Unlock();

+ }

+

+ void test() {

+ mu2.Lock();

+ mu2.Unlock();

+ }

+

+ void test3() {

+ mu3.Lock();

+ mu3.Unlock();

+ }

+};

+

+} // end namespace AcquiredBeforeAfterTest

+

+

+namespace ScopedAdoptTest {

+

+class Foo {

+ Mutex mu;

+ int a GUARDED_BY(mu);

+ int b;

+

+ void test1() EXCLUSIVE_UNLOCK_FUNCTION(mu) {

+ MutexLock slock(&mu, true);

+ a = 0;

+ }

+

+ void test2() SHARED_UNLOCK_FUNCTION(mu) {

+ ReaderMutexLock slock(&mu, true);

+ b = a;

+ }

+

+ void test3() EXCLUSIVE_LOCKS_REQUIRED(mu) { // expected-note {{mutex acquired here}}

+ MutexLock slock(&mu, true);

+ a = 0;

+ } // expected-warning {{expecting mutex 'mu' to be held at the end of function}}

+

+ void test4() SHARED_LOCKS_REQUIRED(mu) { // expected-note {{mutex acquired here}}

+ ReaderMutexLock slock(&mu, true);

+ b = a;

+ } // expected-warning {{expecting mutex 'mu' to be held at the end of function}}

+

+};

+

+} // end namespace ScopedAdoptTest

+

+// XFAIL: hexagon

+class Status;

+class Foo {

+ public:

+ Status doStuff();

+};

+

+ DoSomethingElse();

+ DoAnotherThing();

+

+template <typename T>

+class [[clang::warn_unused_result]] StatusOr {

+};

+StatusOr<int> doit();

+void test() {

+ Foo f;

+ f.doStuff(); // expected-warning {{ignoring return value}}

+ doit(); // expected-warning {{ignoring return value}}

+

+ auto func = []() { return Status(); };

+ func(); // expected-warning {{ignoring return value}}

+}

+ A a;

+void uses_abc() {

+ A a;

+ B<int> b;

+ C c;

+void uses_derived() {

+ Derived d;

+ VeryDerived vd;

+void uses_templ() {

+ TemplVirt<float> f;

+ TemplVirt<bool> b;

+ TemplVirt<long> l;