diff options
Diffstat (limited to 'test/CXX')
53 files changed, 514 insertions, 109 deletions
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp index 32dd75a..2292fc5 100644 --- a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp +++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s namespace A { class A { @@ -20,6 +22,9 @@ namespace D { namespace C { class C {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'B::B' to 'const C::C &' for 1st argument}} +#if __cplusplus >= 201103L // C++11 or later + // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'B::B' to 'C::C &&' for 1st argument}} +#endif void func(C); // expected-note {{'C::func' declared here}} \ // expected-note {{passing argument to parameter here}} C operator+(C,C); diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp index 7918e9f..ed6c6c0 100644 --- a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp +++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s namespace Ints { int zero = 0; // expected-note {{candidate found by name lookup is 'Ints::zero'}} @@ -31,7 +33,11 @@ void test() { } namespace Numbers { - struct Number { // expected-note 2 {{candidate}} + struct Number { // expected-note 2 {{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later + // expected-note@-2 2 {{candidate constructor (the implicit move constructor) not viable}} +#endif + explicit Number(double d) : d(d) {} double d; }; @@ -66,7 +72,11 @@ void test3() { namespace inline_ns { int x; // expected-note 2{{found}} - inline namespace A { // expected-warning {{C++11}} + inline namespace A { +#if __cplusplus <= 199711L // C++03 or earlier + // expected-warning@-2 {{inline namespaces are a C++11 feature}} +#endif + int x; // expected-note 2{{found}} int y; // expected-note 2{{found}} } diff --git a/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp b/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp index 1d2b525d..bf8df1a 100644 --- a/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp +++ b/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // rdar4641403 namespace N { @@ -34,7 +36,10 @@ namespace PR17731 { struct S c = b; } { - struct S { S() {} }; // expected-note {{candidate}} + struct S { S() {} }; // expected-note {{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later + // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif int a = S(); // expected-error {{no viable conversion from 'S'}} struct S c = b; // expected-error {{no viable conversion from 'struct S'}} } @@ -50,7 +55,10 @@ namespace PR17731 { struct S c = b; } { - struct S { S() {} }; // expected-note {{candidate}} + struct S { S() {} }; // expected-note {{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later + // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif int a = S(); // expected-error {{no viable conversion from 'S'}} struct S c = b; // expected-error {{no viable conversion from 'struct S'}} } diff --git a/test/CXX/basic/basic.start/basic.start.main/p3.cpp b/test/CXX/basic/basic.start/basic.start.main/p3.cpp new file mode 100644 index 0000000..f7085ca --- /dev/null +++ b/test/CXX/basic/basic.start/basic.start.main/p3.cpp @@ -0,0 +1,66 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST1 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST2 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST3 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST4 +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 -DTEST5 +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 -DTEST6 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST7 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST8 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST9 +// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST10 -ffreestanding + +#if TEST1 +int main; // expected-error{{main cannot be declared as global variable}} + +#elif TEST2 +// expected-no-diagnostics +int f () { + int main; + return main; +} + +#elif TEST3 +// expected-no-diagnostics +void x(int main) {}; +int y(int main); + +#elif TEST4 +// expected-no-diagnostics +class A { + static int main; +}; + +#elif TEST5 +// expected-no-diagnostics +template<class T> constexpr T main; + +#elif TEST6 +extern template<class T> constexpr T main; //expected-error{{expected unqualified-id}} + +#elif TEST7 +// expected-no-diagnostics +namespace foo { + int main; +} + +#elif TEST8 +void z(void) +{ + extern int main; // expected-error{{main cannot be declared as global variable}} +} + +#elif TEST9 +// expected-no-diagnostics +int q(void) +{ + static int main; + return main; +} + +#elif TEST10 +// expected-no-diagnostics +int main; + +#else +#error Unknown Test +#endif diff --git a/test/CXX/class.access/class.friend/p1.cpp b/test/CXX/class.access/class.friend/p1.cpp index 4a68162..54069b6 100644 --- a/test/CXX/class.access/class.friend/p1.cpp +++ b/test/CXX/class.access/class.friend/p1.cpp @@ -8,11 +8,12 @@ // friends members of the befriending class. struct S { static void f(); }; // expected-note 2 {{'S' declared here}} -S* g() { return 0; } // expected-note 2 {{'g' declared here}} +S* g() { return 0; } struct X { friend struct S; - friend S* g(); + friend S* g(); // expected-note 2 {{'g' declared here}} + // FIXME: The above two notes would be better attached to line 11. }; void test1() { diff --git a/test/CXX/class.access/class.friend/p11.cpp b/test/CXX/class.access/class.friend/p11.cpp index a5107fd..0d25c59 100644 --- a/test/CXX/class.access/class.friend/p11.cpp +++ b/test/CXX/class.access/class.friend/p11.cpp @@ -24,13 +24,12 @@ namespace test2 { void foo() { // expected-note {{'::test2::foo' declared here}} struct S1 { friend void foo(); // expected-error {{no matching function 'foo' found in local scope; did you mean '::test2::foo'?}} - // expected-note@-1{{'::test2::foo' declared here}} - // TODO: the above note should go on line 24 }; void foo(); // expected-note {{local declaration nearly matches}} struct S2 { - friend void foo(); + friend void foo(); // expected-note{{'::test2::foo' declared here}} + // TODO: the above note should go on line 24 }; { @@ -48,8 +47,8 @@ namespace test2 { struct S4 { friend void bar(); // expected-error {{no matching function 'bar' found in local scope; did you mean '::test2::bar'?}} - // expected-note@-1 2 {{'::test2::bar' declared here}} - // TODO: the above two notes should go on line 22 + // expected-note@-1 {{'::test2::bar' declared here}} + // TODO: the above note should go on line 22 }; { void bar(); } @@ -82,6 +81,8 @@ namespace test2 { struct S9 { struct Inner { friend void baz(); // expected-error {{no matching function 'baz' found in local scope; did you mean 'bar'?}} + // expected-note@-1 {{'::test2::bar' declared here}} + // TODO: the above note should go on line 22 }; }; diff --git a/test/CXX/class.access/class.friend/p2-cxx03.cpp b/test/CXX/class.access/class.friend/p2-cxx03.cpp index f8cabfd..88b2ea3 100644 --- a/test/CXX/class.access/class.friend/p2-cxx03.cpp +++ b/test/CXX/class.access/class.friend/p2-cxx03.cpp @@ -1,7 +1,14 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s template<typename T> class X0 { - friend T; // expected-warning{{non-class friend type 'T' is a C++11 extension}} + friend T; +#if __cplusplus <= 199711L // C++03 or earlier modes + // expected-warning@-2{{non-class friend type 'T' is a C++11 extension}} +#else + // expected-no-diagnostics +#endif }; class X1 { }; diff --git a/test/CXX/class/class.friend/p1.cpp b/test/CXX/class/class.friend/p1.cpp index 96701b3..b83dfa3 100644 --- a/test/CXX/class/class.friend/p1.cpp +++ b/test/CXX/class/class.friend/p1.cpp @@ -79,3 +79,9 @@ class PreDeclared; int myoperation(float f) { return (int) f; } + +template <typename T> +class B { + template <typename U> + friend B<U>() {} // expected-error {{must use a qualified name when declaring a constructor as a friend}} +}; diff --git a/test/CXX/class/class.nest/p1.cpp b/test/CXX/class/class.nest/p1.cpp index b0341da..59bf50f 100644 --- a/test/CXX/class/class.nest/p1.cpp +++ b/test/CXX/class/class.nest/p1.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s class Outer { int x; @@ -7,7 +9,10 @@ class Outer { // C++11 does relax this rule (see 5.1.1.10) in the first case, but we need to enforce it in C++03 mode. class Inner { - static char a[sizeof(x)]; // expected-error {{invalid use of non-static data member 'x'}} + static char a[sizeof(x)]; +#if __cplusplus <= 199711L + // expected-error@-2 {{invalid use of non-static data member 'x'}} +#endif static char b[sizeof(sx)]; // okay static char c[sizeof(f)]; // expected-error {{call to non-static member function without an object argument}} }; diff --git a/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p1.cpp b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p1.cpp new file mode 100644 index 0000000..ded6ed0 --- /dev/null +++ b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p1.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -fcxx-exceptions -x c++ -verify %s + +namespace A { + template<typename T> concept bool C1() { return true; } + + template<typename T> concept bool C2 = true; +} + +template<typename T> concept bool C3() { return (throw 0, true); } +static_assert(noexcept(C3<int>()), "function concept should be treated as if noexcept(true) specified"); + +template<typename T> concept bool D1(); // expected-error {{function concept declaration must be a definition}} + +struct B { + template<typename T> concept bool D2() { return true; } // expected-error {{concept declarations may only appear in namespace scope}} +}; + +struct C { + template<typename T> static concept bool D3 = true; // expected-error {{concept declarations may only appear in namespace scope}} +}; + +concept bool D4() { return true; } // expected-error {{'concept' can only appear on the definition of a function template or variable template}} + +concept bool D5 = true; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} + +template<typename T> +concept bool D6; // expected-error {{variable concept declaration must be initialized}} + +template<typename T> +concept bool D7() throw(int) { return true; } // expected-error {{function concept cannot have exception specification}} + +// Tag +concept class CC1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +concept struct CS1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +concept union CU1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +concept enum CE1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +template <typename T> concept class TCC1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +template <typename T> concept struct TCS1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +template <typename T> concept union TCU1 {}; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +typedef concept int CI; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} +void fpc(concept int i) {} // expected-error {{'concept' can only appear on the definition of a function template or variable template}} + +concept bool; // expected-error {{'concept' can only appear on the definition of a function template or variable template}} diff --git a/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p2.cpp b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p2.cpp new file mode 100644 index 0000000..4779109 --- /dev/null +++ b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p2.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s + +template<typename T> concept thread_local bool VCTL = true; // expected-error {{variable concept cannot be declared 'thread_local'}} + +template<typename T> concept constexpr bool VCC = true; // expected-error {{variable concept cannot be declared 'constexpr'}} + +template<typename T> concept inline bool FCI() { return true; } // expected-error {{function concept cannot be declared 'inline'}} + +struct X { + template<typename T> concept friend bool FCF() { return true; } // expected-error {{function concept cannot be declared 'friend'}} +}; + +template<typename T> concept constexpr bool FCC() { return true; } // expected-error {{function concept cannot be declared 'constexpr'}} diff --git a/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p5.cpp b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p5.cpp new file mode 100644 index 0000000..38593bc --- /dev/null +++ b/test/CXX/concepts-ts/dcl.dcl/dcl.spec/dcl.spec.concept/p5.cpp @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s + +template<typename T> +concept bool fcpv(void) { return true; } + +template<typename T> +concept bool fcpi(int i = 0) { return true; } // expected-error {{function concept cannot have any parameters}} + +template<typename... Ts> +concept bool fcpp(Ts... ts) { return true; } // expected-error {{function concept cannot have any parameters}} + +template<typename T> +concept bool fcpva(...) { return true; } // expected-error {{function concept cannot have any parameters}} diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp index bf30ee7..021c250 100644 --- a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp +++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp @@ -1,10 +1,15 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // We have to avoid ADL for this test. template <unsigned N> class test {}; -class foo {}; // expected-note {{candidate}} +class foo {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif test<0> foo(foo); // expected-note {{candidate}} namespace Test0 { diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp index 4897323..18b2c6b 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p5.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -triple x86_64-unknown-unknown -verify -std=c++11 -fcxx-exceptions %s +// RUN: %clang_cc1 -fsyntax-only -triple x86_64-unknown-unknown -verify -std=c++14 -fcxx-exceptions %s // RUN: %clang_cc1 -fsyntax-only -triple x86_64-unknown-unknown -std=c++11 -fcxx-exceptions -Wno-invalid-constexpr %s -DNO_INVALID_CONSTEXPR namespace StdExample { @@ -102,7 +103,10 @@ X x = cmin(X(), X()); // ok, not constexpr template<typename T> struct Y { constexpr Y() {} - constexpr int get() { return T(); } // expected-warning {{C++14}} + constexpr int get() { return T(); } +#if __cplusplus < 201402L + // expected-warning@-2 {{C++14}} +#endif }; struct Z { operator int(); }; @@ -118,7 +122,7 @@ namespace PR14550 { // marks some functions as constexpr which use builtins which we don't // support constant folding). Ensure that we don't mark those functions // as invalid after suppressing the diagnostic. -# 122 "p5.cpp" 1 3 +# 126 "p5.cpp" 1 3 int n; struct A { static constexpr int f() { return n; } @@ -126,7 +130,11 @@ namespace PR14550 { template<typename T> struct B { B() { g(T::f()); } // expected-error {{undeclared identifier 'g'}} }; -# 130 "p5.cpp" 2 +# 134 "p5.cpp" 2 template class B<A>; // expected-note {{here}} } #endif + +#if __cplusplus >= 201402L +constexpr void f() { throw; } // expected-error {{never produces}} expected-note {{subexpression}} +#endif diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp index 5d1e6fb..08b22c1 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p6.cpp @@ -1,10 +1,15 @@ // RUN: %clang_cc1 -verify %s +// RUN: %clang_cc1 -verify -std=c++98 %s +// RUN: %clang_cc1 -verify -std=c++11 %s class A { public: explicit A(); - explicit operator int(); // expected-warning {{explicit conversion functions are a C++11 extension}} + explicit operator int(); +#if __cplusplus <= 199711L // C++03 or earlier modes + // expected-warning@-2 {{explicit conversion functions are a C++11 extension}} +#endif explicit void f0(); // expected-error {{'explicit' can only be applied to a constructor or conversion function}} @@ -12,8 +17,11 @@ public: }; explicit A::A() { } // expected-error {{'explicit' can only be specified inside the class definition}} -explicit A::operator bool() { return false; } // expected-warning {{explicit conversion functions are a C++11 extension}}\ - // expected-error {{'explicit' can only be specified inside the class definition}} +explicit A::operator bool() { return false; } +#if __cplusplus <= 199711L // C++03 or earlier modes +// expected-warning@-2 {{explicit conversion functions are a C++11 extension}} +#endif +// expected-error@-4 {{'explicit' can only be specified inside the class definition}} class B { friend explicit A::A(); // expected-error {{'explicit' is invalid in friend declarations}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp index 44cc5a7..0b7a902 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp @@ -1,26 +1,58 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++0x-compat %s +// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // The auto or register specifiers can be applied only to names of objects // declared in a block (6.3) or to function parameters (8.4). auto int ao; // expected-error {{illegal storage class on file-scoped variable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif + auto void af(); // expected-error {{illegal storage class on function}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif register int ro; // expected-error {{illegal storage class on file-scoped variable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'register' storage class specifier is deprecated}} +#endif + register void rf(); // expected-error {{illegal storage class on function}} struct S { auto int ao; // expected-error {{storage class specified for a member declaration}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif auto void af(); // expected-error {{storage class specified for a member declaration}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif register int ro; // expected-error {{storage class specified for a member declaration}} register void rf(); // expected-error {{storage class specified for a member declaration}} }; void foo(auto int ap, register int rp) { +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif auto int abo; +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif auto void abf(); // expected-error {{illegal storage class on function}} +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +#endif register int rbo; +#if __cplusplus >= 201103L // C++11 or later +// expected-warning@-2 {{'register' storage class specifier is deprecated}} +#endif + register void rbf(); // expected-error {{illegal storage class on function}} } diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-1y.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-1y.cpp index 39c547b..eb75151 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-1y.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-1y.cpp @@ -3,9 +3,9 @@ // FIXME: This is in p11 (?) in C++1y. void f() { - decltype(auto) a = a; // expected-error{{variable 'a' declared with 'auto' type cannot appear in its own initializer}} - if (decltype(auto) b = b) {} // expected-error {{variable 'b' declared with 'auto' type cannot appear in its own initializer}} - decltype(auto) c = ({ decltype(auto) d = c; 0; }); // expected-error {{variable 'c' declared with 'auto' type cannot appear in its own initializer}} + decltype(auto) a = a; // expected-error{{variable 'a' declared with 'decltype(auto)' type cannot appear in its own initializer}} + if (decltype(auto) b = b) {} // expected-error {{variable 'b' declared with 'decltype(auto)' type cannot appear in its own initializer}} + decltype(auto) c = ({ decltype(auto) d = c; 0; }); // expected-error {{variable 'c' declared with 'decltype(auto)' type cannot appear in its own initializer}} } void g() { diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-generic-lambda-1y.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-generic-lambda-1y.cpp index 65b085b..07bc884 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-generic-lambda-1y.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3-generic-lambda-1y.cpp @@ -49,7 +49,7 @@ int main() static double dfi(int i) { return i + 3.14; } static Local localfi(int) { return Local{}; } }; - auto l4 = [](auto (*fp)(int)) -> int { return fp(3); }; //expected-error{{no viable conversion from 'Local' to 'int'}} + auto l4 = [](auto (*fp)(int)) -> int { return fp(3); }; //expected-error{{no viable conversion from returned value of type 'Local' to function return type 'int'}} l4(&Local::ifi); l4(&Local::cfi); l4(&Local::dfi); diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp index c3dc1de..06bd72e 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-1y.cpp @@ -49,7 +49,7 @@ decltype(auto) f1(); decltype(auto) (*f2)(); // expected-error {{'decltype(auto)' can only be used as a return type in a function declaration}} expected-error {{requires an initializer}} decltype(auto) *f3(); // expected-error {{cannot form pointer to 'decltype(auto)'}} const decltype(auto) f4(); // expected-error {{'decltype(auto)' cannot be combined with other type specifiers}} -typedef decltype(auto) f5(); // expected-error {{'decltype(auto)' can only be used as a return type in a function declaration}} +typedef decltype(auto) f5(); // expected-error {{'decltype(auto)' not allowed in typedef}} decltype(auto) ((((((f6))))())); // ok decltype(auto) f7()(); // expected-error {{'decltype(auto)' can only be used as a return type in a function declaration}} expected-error {{function cannot return function type}} decltype(auto) (S::*f8)(); // expected-error {{'decltype(auto)' can only be used as a return type in a function declaration}} expected-error {{requires an initializer}} diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p1.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p1.cpp new file mode 100644 index 0000000..e3982fd --- /dev/null +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p1.cpp @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -verify %s -std=c++11 + +namespace N { + struct A; + template<typename T> struct B {}; +} +template<typename T> struct C {}; +struct D { + template<typename T> struct A {}; +}; +struct N::A; // expected-error {{cannot have a nested name specifier}} + +template<typename T> struct N::B; // expected-error {{cannot have a nested name specifier}} +template<typename T> struct N::B<T*>; // FIXME: This is technically ill-formed, but that's not the intent. +template<> struct N::B<int>; +template struct N::B<float>; + +template<typename T> struct C; +template<typename T> struct C<T*>; // FIXME: This is technically ill-formed, but that's not the intent. +template<> struct C<int>; +template struct C<float>; + +template<typename T> struct D::A; // expected-error {{cannot have a nested name specifier}} +template<typename T> struct D::A<T*>; // FIXME: This is technically ill-formed, but that's not the intent. +template<> struct D::A<int>; +template struct D::A<float>; diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp index 40e7540..1940651 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s class A {}; // expected-note 4 {{previous use is here}} enum E {}; @@ -14,7 +16,10 @@ class A1 { friend union A; // expected-error {{use of 'A' with tag type that does not match previous declaration}} friend enum A; // expected-error {{use of 'A' with tag type that does not match previous declaration}} - friend enum E; // expected-warning {{befriending enumeration type 'enum E' is a C++11 extension}} + friend enum E; +#if __cplusplus <= 199711L // C++03 or earlier modes + // expected-warning@-2 {{befriending enumeration type 'enum E' is a C++11 extension}} +#endif }; template <class T> struct B { // expected-note {{previous use is here}} diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp index cb62874..3822122 100644 --- a/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp +++ b/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp @@ -1,7 +1,12 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s struct Base { }; struct Derived : Base { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif struct Unrelated { }; struct Derived2 : Base { }; struct Diamond : Derived, Derived2 { }; diff --git a/test/CXX/drs/dr0xx.cpp b/test/CXX/drs/dr0xx.cpp index dd0d4d1..3bb6701 100644 --- a/test/CXX/drs/dr0xx.cpp +++ b/test/CXX/drs/dr0xx.cpp @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy -// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple +// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple namespace dr1 { // dr1: no namespace X { extern "C" void dr1_f(int a = 1); } diff --git a/test/CXX/drs/dr13xx.cpp b/test/CXX/drs/dr13xx.cpp index 29b39cb..37c144e 100644 --- a/test/CXX/drs/dr13xx.cpp +++ b/test/CXX/drs/dr13xx.cpp @@ -7,9 +7,9 @@ namespace dr1346 { // dr1346: 3.5 auto a(1); // expected-error 0-1{{extension}} auto b(1, 2); // expected-error {{multiple expressions}} expected-error 0-1{{extension}} #if __cplusplus >= 201103L - auto c({}); // expected-error {{parenthesized initializer list}} expected-error {{cannot deduce}} - auto d({1}); // expected-error {{parenthesized initializer list}} expected-error {{<initializer_list>}} - auto e({1, 2}); // expected-error {{parenthesized initializer list}} expected-error {{<initializer_list>}} + auto c({}); // expected-error {{parenthesized initializer list}} + auto d({1}); // expected-error {{parenthesized initializer list}} + auto e({1, 2}); // expected-error {{parenthesized initializer list}} #endif template<typename...Ts> void f(Ts ...ts) { // expected-error 0-1{{extension}} auto x(ts...); // expected-error {{empty}} expected-error 0-1{{extension}} @@ -21,9 +21,9 @@ namespace dr1346 { // dr1346: 3.5 [a(1)] {} (); // expected-error 0-1{{extension}} [b(1, 2)] {} (); // expected-error {{multiple expressions}} expected-error 0-1{{extension}} #if __cplusplus >= 201103L - [c({})] {} (); // expected-error {{parenthesized initializer list}} expected-error {{cannot deduce}} expected-error 0-1{{extension}} - [d({1})] {} (); // expected-error {{parenthesized initializer list}} expected-error {{<initializer_list>}} expected-error 0-1{{extension}} - [e({1, 2})] {} (); // expected-error {{parenthesized initializer list}} expected-error {{<initializer_list>}} expected-error 0-1{{extension}} + [c({})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}} + [d({1})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}} + [e({1, 2})] {} (); // expected-error {{parenthesized initializer list}} expected-error 0-1{{extension}} #endif } #endif diff --git a/test/CXX/drs/dr15xx.cpp b/test/CXX/drs/dr15xx.cpp index d35583f..7472be7 100644 --- a/test/CXX/drs/dr15xx.cpp +++ b/test/CXX/drs/dr15xx.cpp @@ -101,4 +101,75 @@ namespace dr1589 { // dr1589: 3.7 c++11 } } // dr1589 + +namespace dr1591 { //dr1591. Deducing array bound and element type from initializer list + template<class T, int N> int h(T const(&)[N]); + int X = h({1,2,3}); // T deduced to int, N deduced to 3 + + template<class T> int j(T const(&)[3]); + int Y = j({42}); // T deduced to int, array bound not considered + + struct Aggr { int i; int j; }; + template<int N> int k(Aggr const(&)[N]); //expected-note{{not viable}} + int Y0 = k({1,2,3}); //expected-error{{no matching function}} + int Z = k({{1},{2},{3}}); // OK, N deduced to 3 + + template<int M, int N> int m(int const(&)[M][N]); + int X0 = m({{1,2},{3,4}}); // M and N both deduced to 2 + + template<class T, int N> int n(T const(&)[N], T); + int X1 = n({{1},{2},{3}},Aggr()); // OK, T is Aggr, N is 3 + + + namespace check_multi_dim_arrays { + template<class T, int N, int M, int O> int ***f(const T (&a)[N][M][O]); //expected-note{{deduced conflicting values}} + template<class T, int N, int M> int **f(const T (&a)[N][M]); //expected-note{{couldn't infer}} + + template<class T, int N> int *f(const T (&a)[N]); //expected-note{{couldn't infer}} + int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } }); + int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}} + int **p2 = f({ {1,2,3}, {3, 4, 5} }); + int **p22 = f({ {1,2}, {3, 4} }); + int *p1 = f({1, 2, 3}); + } + namespace check_multi_dim_arrays_rref { + template<class T, int N, int M, int O> int ***f(T (&&a)[N][M][O]); //expected-note{{deduced conflicting values}} + template<class T, int N, int M> int **f(T (&&a)[N][M]); //expected-note{{couldn't infer}} + + template<class T, int N> int *f(T (&&a)[N]); //expected-note{{couldn't infer}} + int ***p3 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12} } }); + int ***p33 = f({ { {1,2}, {3, 4} }, { {5,6}, {7, 8} }, { {9,10}, {11, 12, 13} } }); //expected-error{{no matching}} + int **p2 = f({ {1,2,3}, {3, 4, 5} }); + int **p22 = f({ {1,2}, {3, 4} }); + int *p1 = f({1, 2, 3}); + } + + namespace check_arrays_of_init_list { + template<class T, int N> float *f(const std::initializer_list<T> (&)[N]); + template<class T, int N> double *f(const T(&)[N]); + double *p = f({1, 2, 3}); + float *fp = f({{1}, {1, 2}, {1, 2, 3}}); + } + namespace core_reflector_28543 { + + template<class T, int N> int *f(T (&&)[N]); // #1 + template<class T> char *f(std::initializer_list<T> &&); //#2 + template<class T, int N, int M> int **f(T (&&)[N][M]); //#3 expected-note{{candidate}} + template<class T, int N> char **f(std::initializer_list<T> (&&)[N]); //#4 expected-note{{candidate}} + + template<class T> short *f(T (&&)[2]); //#5 + + template<class T> using Arr = T[]; + + char *pc = f({1, 2, 3}); // OK prefer #2 via 13.3.3.2 [over.ics.rank] + char *pc2 = f({1, 2}); // #2 also + int *pi = f(Arr<int>{1, 2, 3}); // OK prefer #1 + + void *pv1 = f({ {1, 2, 3}, {4, 5, 6} }); // expected-error{{ambiguous}} btw 3 & 4 + char **pcc = f({ {1}, {2, 3} }); // OK #4 + + short *ps = f(Arr<int>{1, 2}); // OK #5 + } +} // dr1591 + #endif diff --git a/test/CXX/drs/dr1xx.cpp b/test/CXX/drs/dr1xx.cpp index d8d9307..47d1494 100644 --- a/test/CXX/drs/dr1xx.cpp +++ b/test/CXX/drs/dr1xx.cpp @@ -234,7 +234,7 @@ namespace dr125 { friend dr125_A::dr125_B (::dr125_C)(); // ok friend dr125_A (::dr125_B::dr125_C)(); // ok friend dr125_A::dr125_B::dr125_C(); // expected-error {{did you mean the constructor name 'dr125_B'?}} - // expected-warning@-1 {{missing exception specification}} + // expected-error@-1 {{missing exception specification}} #if __cplusplus >= 201103L // expected-error@-3 {{follows constexpr declaration}} expected-note@-10 {{here}} #endif @@ -524,8 +524,13 @@ namespace dr143 { // dr143: yes namespace dr145 { // dr145: yes void f(bool b) { +#if __cplusplus <= 201402L ++b; // expected-warning {{deprecated}} b++; // expected-warning {{deprecated}} +#else + ++b; // expected-error {{increment}} + b++; // expected-error {{increment}} +#endif } } diff --git a/test/CXX/drs/dr3xx.cpp b/test/CXX/drs/dr3xx.cpp index c438fcc..a1c1c4c 100644 --- a/test/CXX/drs/dr3xx.cpp +++ b/test/CXX/drs/dr3xx.cpp @@ -1,7 +1,7 @@ -// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors namespace dr300 { // dr300: yes template<typename R, typename A> void f(R (&)(A)) {} diff --git a/test/CXX/drs/dr4xx.cpp b/test/CXX/drs/dr4xx.cpp index bbe5ee6..bceea79 100644 --- a/test/CXX/drs/dr4xx.cpp +++ b/test/CXX/drs/dr4xx.cpp @@ -83,7 +83,7 @@ namespace dr406 { // dr406: yes } A; } -namespace dr407 { // dr407: no +namespace dr407 { // dr407: 3.8 struct S; typedef struct S S; void f() { @@ -108,22 +108,22 @@ namespace dr407 { // dr407: no struct S s; // expected-error {{ambiguous}} } namespace D { - // FIXME: This is valid. using A::S; - typedef struct S S; // expected-note {{here}} - struct S s; // expected-error {{refers to a typedef}} + typedef struct S S; + struct S s; } namespace E { - // FIXME: The standard doesn't say whether this is valid. + // The standard doesn't say whether this is valid. We interpret + // DR407 as meaning "if lookup finds both a tag and a typedef with the + // same type, then it's OK in an elaborated-type-specifier". typedef A::S S; using A::S; struct S s; } namespace F { - typedef A::S S; // expected-note {{here}} + typedef A::S S; } - // FIXME: The standard doesn't say what to do in these cases, but - // our behavior should not depend on the order of the using-directives. + // The standard doesn't say what to do in these cases either. namespace G { using namespace A; using namespace F; @@ -132,7 +132,7 @@ namespace dr407 { // dr407: no namespace H { using namespace F; using namespace A; - struct S s; // expected-error {{refers to a typedef}} + struct S s; } } } @@ -659,7 +659,7 @@ namespace dr457 { // dr457: yes enum E { ea = a, - eb = b // expected-error {{not an integral constant}} expected-note {{read of volatile-qualified}} + eb = b // expected-error {{constant}} expected-note {{read of volatile-qualified}} }; } diff --git a/test/CXX/drs/dr5xx.cpp b/test/CXX/drs/dr5xx.cpp index 5bf085f..17b525d 100644 --- a/test/CXX/drs/dr5xx.cpp +++ b/test/CXX/drs/dr5xx.cpp @@ -7,7 +7,7 @@ // pointing at the implicit operator new. We can't match such a diagnostic // with -verify. __extension__ typedef __SIZE_TYPE__ size_t; -void *operator new(size_t); // expected-warning 0-1{{missing exception spec}} expected-note{{candidate}} +void *operator new(size_t); // expected-error 0-1{{missing exception spec}} expected-note{{candidate}} namespace dr500 { // dr500: dup 372 class D; @@ -519,23 +519,12 @@ namespace dr546 { // dr546: yes } namespace dr547 { // dr547: yes - // When targeting the MS x86 ABI, the type of a member function includes a - // __thiscall qualifier. This is non-conforming, but we still implement - // the intent of dr547 -#if defined(_M_IX86) || (defined(__MINGW32__) && !defined(__MINGW64__)) -#define THISCALL __thiscall -#else -#define THISCALL -#endif - template<typename T> struct X; - template<typename T> struct X<THISCALL T() const> {}; + template<typename T> struct X<T() const> {}; template<typename T, typename C> X<T> f(T C::*) { return X<T>(); } struct S { void f() const; }; - X<THISCALL void() const> x = f(&S::f); - -#undef THISCALL + X<void() const> x = f(&S::f); } namespace dr548 { // dr548: dup 482 diff --git a/test/CXX/except/except.spec/p3.cpp b/test/CXX/except/except.spec/p3.cpp index d77aea4..03f1d76 100644 --- a/test/CXX/except/except.spec/p3.cpp +++ b/test/CXX/except/except.spec/p3.cpp @@ -24,9 +24,9 @@ extern void (*r4)() throw(...); extern void (*r5)() throw(int); // expected-note {{previous declaration}} extern void (*r5)(); // expected-error {{exception specification in declaration does not match}} -// For functions, we accept this with a warning. +// throw(int) and no spec are not compatible extern void f5() throw(int); // expected-note {{previous declaration}} -extern void f5(); // expected-warning {{missing exception specification}} +extern void f5(); // expected-error {{missing exception specification}} // Different types are not compatible. extern void (*r7)() throw(int); // expected-note {{previous declaration}} diff --git a/test/CXX/except/except.spec/p4.cpp b/test/CXX/except/except.spec/p4.cpp index 8d1b75f..04b2bd9 100644 --- a/test/CXX/except/except.spec/p4.cpp +++ b/test/CXX/except/except.spec/p4.cpp @@ -19,7 +19,7 @@ struct T { void operator delete(void*) noexcept; // expected-note {{here}} }; -void T::a() {} // expected-warning {{missing exception specification 'noexcept'}} +void T::a() {} // expected-error {{missing exception specification 'noexcept'}} T::~T() {} // expected-warning {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}} void T::operator delete(void*) {} // expected-warning {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}} diff --git a/test/CXX/except/except.spec/p5-pointers.cpp b/test/CXX/except/except.spec/p5-pointers.cpp index f855520..fe4a264 100644 --- a/test/CXX/except/except.spec/p5-pointers.cpp +++ b/test/CXX/except/except.spec/p5-pointers.cpp @@ -73,7 +73,7 @@ void fnptrs() // Member function stuff struct Str1 { void f() throw(int); }; // expected-note {{previous declaration}} -void Str1::f() // expected-warning {{missing exception specification}} +void Str1::f() // expected-error {{missing exception specification}} { } diff --git a/test/CXX/expr/expr.const/p2-0x.cpp b/test/CXX/expr/expr.const/p2-0x.cpp index 2adefd9..c519ecb 100644 --- a/test/CXX/expr/expr.const/p2-0x.cpp +++ b/test/CXX/expr/expr.const/p2-0x.cpp @@ -601,11 +601,11 @@ namespace rdar13090123 { typedef __INTPTR_TYPE__ intptr_t; constexpr intptr_t f(intptr_t x) { - return (((x) >> 21) * 8); // expected-note{{subexpression not valid in a constant expression}} + return (((x) >> 21) * 8); } extern "C" int foo; constexpr intptr_t i = f((intptr_t)&foo - 10); // expected-error{{constexpr variable 'i' must be initialized by a constant expression}} \ - // expected-note{{in call to 'f((char*)&foo + -10)'}} + // expected-note{{reinterpret_cast}} } diff --git a/test/CXX/expr/expr.const/p5-0x.cpp b/test/CXX/expr/expr.const/p5-0x.cpp index 0a4ac22..0798709 100644 --- a/test/CXX/expr/expr.const/p5-0x.cpp +++ b/test/CXX/expr/expr.const/p5-0x.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s +// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -std=c++11 -verify %s // If an expression of literal class type is used in a context where an integral // constant expression is required, then that class type shall have a single diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/default-arguments.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/default-arguments.cpp index 38d5d0a..9b0a9ad 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/default-arguments.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/default-arguments.cpp @@ -26,23 +26,26 @@ struct NonPOD { }; struct NoDefaultCtor { - NoDefaultCtor(const NoDefaultCtor&); // expected-note{{candidate constructor}} + NoDefaultCtor(const NoDefaultCtor&); // expected-note{{candidate constructor}} \ + // expected-note{{candidate constructor not viable: requires 1 argument, but 0 were provided}} ~NoDefaultCtor(); }; template<typename T> void defargs_in_template_unused(T t) { - auto l1 = [](const T& value = T()) { }; + auto l1 = [](const T& value = T()) { }; // expected-error{{no matching constructor for initialization of 'NoDefaultCtor'}} l1(t); } template void defargs_in_template_unused(NonPOD); -template void defargs_in_template_unused(NoDefaultCtor); +template void defargs_in_template_unused(NoDefaultCtor); // expected-note{{in instantiation of function template specialization 'defargs_in_template_unused<NoDefaultCtor>' requested here}} template<typename T> void defargs_in_template_used() { - auto l1 = [](const T& value = T()) { }; // expected-error{{no matching constructor for initialization of 'NoDefaultCtor'}} - l1(); // expected-note{{in instantiation of default function argument expression for 'operator()<NoDefaultCtor>' required here}} + auto l1 = [](const T& value = T()) { }; // expected-error{{no matching constructor for initialization of 'NoDefaultCtor'}} \ + // expected-note{{candidate function not viable: requires single argument 'value', but no arguments were provided}} \ + // expected-note{{conversion candidate of type 'void (*)(const NoDefaultCtor &)'}} + l1(); // expected-error{{no matching function for call to object of type '(lambda at }} } template void defargs_in_template_used<NonPOD>(); diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp index 1228c74..63e51a7 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp @@ -48,7 +48,8 @@ auto bad_init_2 = [a(1, 2)] {}; // expected-error {{initializer for lambda captu auto bad_init_3 = [&a(void_fn())] {}; // expected-error {{cannot form a reference to 'void'}} auto bad_init_4 = [a(void_fn())] {}; // expected-error {{has incomplete type 'void'}} auto bad_init_5 = [a(overload_fn)] {}; // expected-error {{cannot deduce type for lambda capture 'a' from initializer of type '<overloaded function}} -auto bad_init_6 = [a{overload_fn}] {}; // expected-error {{cannot deduce type for lambda capture 'a' from initializer list}} expected-warning {{will change meaning in a future version of Clang}} +auto bad_init_6 = [a{overload_fn}] {}; // expected-error {{cannot deduce type for lambda capture 'a' from initializer list}} +auto bad_init_7 = [a{{1}}] {}; // expected-error {{cannot deduce type for lambda capture 'a' from nested initializer list}} template<typename...T> void pack_1(T...t) { (void)[a(t...)] {}; } // expected-error {{initializer missing for lambda capture 'a'}} template void pack_1<>(); // expected-note {{instantiation of}} @@ -61,7 +62,7 @@ auto a = [a(4), b = 5, &c = static_cast<const int&&>(0)] { using T = decltype(c); using T = const int &; }; -auto b = [a{0}] {}; // expected-error {{include <initializer_list>}} expected-warning {{will change meaning in a future version of Clang}} +auto b = [a{0}] {}; // OK, per N3922 struct S { S(); S(S&&); }; template<typename T> struct remove_reference { typedef T type; }; diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp index c18bb7d..e407617 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/templates.cpp @@ -38,7 +38,7 @@ template X captures(X, X); template<typename T> int infer_result(T x, T y) { auto lambda = [=](bool b) { return x + y; }; - return lambda(true); // expected-error{{no viable conversion from 'X' to 'int'}} + return lambda(true); // expected-error{{no viable conversion from returned value of type 'X' to function return type 'int'}} } template int infer_result(int, int); diff --git a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp index 9babf87..48c47f7 100644 --- a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp +++ b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp @@ -7,7 +7,7 @@ namespace test0 { template<typename T> void g(T); void test() { - foo(&g<int>); // expected-error-re {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}} + foo(&g<int>); // expected-error-re {{cannot form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}} } }; } diff --git a/test/CXX/lex/lex.literal/lex.ext/p12.cpp b/test/CXX/lex/lex.literal/lex.ext/p12.cpp index dad4680..34a2f5c 100644 --- a/test/CXX/lex/lex.literal/lex.ext/p12.cpp +++ b/test/CXX/lex/lex.literal/lex.ext/p12.cpp @@ -15,7 +15,7 @@ void *operator""_x(const char*); // #2 void *a = 123_x; // ok, calls #2 int b = u8"\"ัะตัั ๐"_x; // ok, calls #1 int c = u8R"("ัะตัั ๐)"_x; // ok, calls #1 -int d = "test"_x; // expected-note {{in instantiation of function template specialization 'operator "" _x<char, 't', 'e', 's', 't'>' requested here}} +int d = "test"_x; // expected-note {{in instantiation of function template specialization 'operator""_x<char, 't', 'e', 's', 't'>' requested here}} int e = uR"("ัะตัั ๐)"_x; int f = UR"("ัะตัั ๐)"_x; -int g = UR"("ัะตัั_๐)"_x; // expected-note {{in instantiation of function template specialization 'operator "" _x<char32_t, 34, 1090, 1077, 1089, 1090, 95, 65536>' requested here}} +int g = UR"("ัะตัั_๐)"_x; // expected-note {{in instantiation of function template specialization 'operator""_x<char32_t, 34, 1090, 1077, 1089, 1090, 95, 65536>' requested here}} diff --git a/test/CXX/lex/lex.literal/lex.ext/p2.cpp b/test/CXX/lex/lex.literal/lex.ext/p2.cpp index 3f3f796..6942b68 100644 --- a/test/CXX/lex/lex.literal/lex.ext/p2.cpp +++ b/test/CXX/lex/lex.literal/lex.ext/p2.cpp @@ -3,14 +3,14 @@ typedef decltype(sizeof(int)) size_t; // FIXME: These diagnostics should say 'size_t' instead of 'unsigned long' -int a = 123_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'unsigned long long' or 'const char *', and no matching literal operator template}} -int b = 4.2_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'long double' or 'const char *', and no matching literal operator template}} -int c = "foo"_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with arguments of types 'const char *' and 'unsigned}} -int d = L"foo"_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with arguments of types 'const wchar_t *' and 'unsigned}} -int e = u8"foo"_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with arguments of types 'const char *' and 'unsigned}} -int f = u"foo"_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with arguments of types 'const char16_t *' and 'unsigned}} -int g = U"foo"_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with arguments of types 'const char32_t *' and 'unsigned}} -int h = 'y'_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'char'}} -int i = L'y'_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'wchar_t'}} -int j = u'y'_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'char16_t'}} -int k = U'y'_x; // expected-error {{no matching literal operator for call to 'operator "" _x' with argument of type 'char32_t'}} +int a = 123_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'unsigned long long' or 'const char *', and no matching literal operator template}} +int b = 4.2_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'long double' or 'const char *', and no matching literal operator template}} +int c = "foo"_x; // expected-error {{no matching literal operator for call to 'operator""_x' with arguments of types 'const char *' and 'unsigned}} +int d = L"foo"_x; // expected-error {{no matching literal operator for call to 'operator""_x' with arguments of types 'const wchar_t *' and 'unsigned}} +int e = u8"foo"_x; // expected-error {{no matching literal operator for call to 'operator""_x' with arguments of types 'const char *' and 'unsigned}} +int f = u"foo"_x; // expected-error {{no matching literal operator for call to 'operator""_x' with arguments of types 'const char16_t *' and 'unsigned}} +int g = U"foo"_x; // expected-error {{no matching literal operator for call to 'operator""_x' with arguments of types 'const char32_t *' and 'unsigned}} +int h = 'y'_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'char'}} +int i = L'y'_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'wchar_t'}} +int j = u'y'_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'char16_t'}} +int k = U'y'_x; // expected-error {{no matching literal operator for call to 'operator""_x' with argument of type 'char32_t'}} diff --git a/test/CXX/lex/lex.literal/lex.ext/p5.cpp b/test/CXX/lex/lex.literal/lex.ext/p5.cpp index d364a37..a516168 100644 --- a/test/CXX/lex/lex.literal/lex.ext/p5.cpp +++ b/test/CXX/lex/lex.literal/lex.ext/p5.cpp @@ -6,7 +6,7 @@ int &operator "" _x1 (const char *); double &operator "" _x1 (const char *, size_t); double &i1 = "foo"_x1; double &i2 = u8"foo"_x1; -double &i3 = L"foo"_x1; // expected-error {{no matching literal operator for call to 'operator "" _x1' with arguments of types 'const wchar_t *' and 'unsigned long'}} +double &i3 = L"foo"_x1; // expected-error {{no matching literal operator for call to 'operator""_x1' with arguments of types 'const wchar_t *' and 'unsigned long'}} char &operator "" _x1(const wchar_t *, size_t); char &i4 = L"foo"_x1; // ok diff --git a/test/CXX/lex/lex.literal/lex.ext/p7.cpp b/test/CXX/lex/lex.literal/lex.ext/p7.cpp index be97f0c..0b40ecd 100644 --- a/test/CXX/lex/lex.literal/lex.ext/p7.cpp +++ b/test/CXX/lex/lex.literal/lex.ext/p7.cpp @@ -14,10 +14,10 @@ long double operator "" _w(long double); std::string operator "" _w(const char16_t*, size_t); unsigned operator "" _w(const char*); int main() { - auto v1 = 1.2_w; // calls operator "" _w(1.2L) - auto v2 = u"one"_w; // calls operator "" _w(u"one", 3) - auto v3 = 12_w; // calls operator "" _w("12") - "two"_w; // expected-error {{no matching literal operator for call to 'operator "" _w' with arguments of types 'const char *' and 'unsigned long'}} + auto v1 = 1.2_w; // calls operator""_w(1.2L) + auto v2 = u"one"_w; // calls operator""_w(u"one", 3) + auto v3 = 12_w; // calls operator""_w("12") + "two"_w; // expected-error {{no matching literal operator for call to 'operator""_w' with arguments of types 'const char *' and 'unsigned long'}} same_type<decltype(v1), long double> test1; same_type<decltype(v2), std::string> test2; diff --git a/test/CXX/lex/lex.literal/lex.string/p4.cpp b/test/CXX/lex/lex.literal/lex.string/p4.cpp new file mode 100644 index 0000000..b73c8ed --- /dev/null +++ b/test/CXX/lex/lex.literal/lex.string/p4.cpp @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s +// expected-no-diagnostics + +// NOTE: This file intentionally uses DOS-style line endings to test +// that we don't propagate them into string literals as per [lex.string]p4. + +constexpr const char* p = R"(a\ +b +c)"; + +static_assert(p[0] == 'a', ""); +static_assert(p[1] == '\\', ""); +static_assert(p[2] == '\n', ""); +static_assert(p[3] == 'b', ""); +static_assert(p[4] == '\n', ""); +static_assert(p[5] == 'c', ""); +static_assert(p[6] == '\0', ""); diff --git a/test/CXX/over/over.oper/over.literal/p2.cpp b/test/CXX/over/over.oper/over.literal/p2.cpp index 00466fb..f3ebadd 100644 --- a/test/CXX/over/over.oper/over.literal/p2.cpp +++ b/test/CXX/over/over.oper/over.literal/p2.cpp @@ -37,7 +37,7 @@ template void operator "" _h<'a', 'b', 'c', 'd'>(); namespace rdar13605348 { class C { - double operator"" _x(long double value) { return double(value); } // expected-error{{literal operator 'operator "" _x' must be in a namespace or global scope}} + double operator"" _x(long double value) { return double(value); } // expected-error{{literal operator 'operator""_x' must be in a namespace or global scope}} double value() { return 3.2_x; } // expected-error{{no matching literal operator for call to}} }; diff --git a/test/CXX/over/over.over/p2-resolve-single-template-id.cpp b/test/CXX/over/over.over/p2-resolve-single-template-id.cpp index b1c819a..e538b99 100644 --- a/test/CXX/over/over.over/p2-resolve-single-template-id.cpp +++ b/test/CXX/over/over.over/p2-resolve-single-template-id.cpp @@ -180,12 +180,12 @@ namespace member_pointers { { bool b = &s.g<int>; } { bool b = S::h<42>; } - { bool b = S::h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + { bool b = S::h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}} { bool b = &S::h<42>; } { bool b = &S::h<int>; } { bool b = s.h<42>; } - { bool b = s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + { bool b = s.h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}} { bool b = &s.h<42>; } - { bool b = &s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} + { bool b = &s.h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}} } } diff --git a/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp b/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp index 3f70ca7..22ea018 100644 --- a/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp +++ b/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s +// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -triple=x86_64-linux-gnu %s -DCPP11ONLY // C++11 [temp.arg.nontype]p1: // @@ -6,6 +7,8 @@ // be one of: // -- an integral constant expression; or // -- the name of a non-type template-parameter ; or +#ifndef CPP11ONLY + namespace non_type_tmpl_param { template <int N> struct X0 { X0(); }; template <int N> X0<N>::X0() { } @@ -95,3 +98,14 @@ namespace bad_args { int* iptr = &i; X0<iptr> x0b; // expected-error{{non-type template argument for template parameter of pointer type 'int *' must have its address taken}} } +#endif // CPP11ONLY + +namespace default_args { +#ifdef CPP11ONLY +namespace lambdas { +template<int I = ([] { return 5; }())> //expected-error 2{{constant expression}} expected-note{{constant expression}} +int f(); +} +#endif // CPP11ONLY + +}
\ No newline at end of file diff --git a/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp b/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp index 9fc4a58..86b2690 100644 --- a/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp +++ b/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // Test instantiation of static data members declared out-of-line. @@ -15,6 +17,9 @@ struct InitOkay { }; struct CannotInit { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif int &returnInt() { return X<int>::value; } float &returnFloat() { return X<float>::value; } diff --git a/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp index b0305dd..215f48d 100644 --- a/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp +++ b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s template<typename T> struct X0 { @@ -13,6 +15,9 @@ struct X1 { }; struct X2 { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif int& get_int() { return X0<int>::value; } X1& get_X1() { return X0<X1>::value; } diff --git a/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp b/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp index 5556f35..bfe08a6 100644 --- a/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp +++ b/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp @@ -1,11 +1,24 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s template<class X, class Y, class Z> X f(Y,Z); // expected-note {{candidate template ignored: couldn't infer template argument 'X'}} void g() { - f<int,char*,double>("aa",3.0); // expected-warning{{conversion from string literal to 'char *' is deprecated}} - f<int,char*>("aa",3.0); // Z is deduced to be double \ - // expected-warning{{conversion from string literal to 'char *' is deprecated}} + f<int,char*,double>("aa",3.0); +#if __cplusplus <= 199711L // C++03 or earlier modes + // expected-warning@-2{{conversion from string literal to 'char *' is deprecated}} +#else + // expected-warning@-4{{ISO C++11 does not allow conversion from string literal to 'char *'}} +#endif + + f<int,char*>("aa",3.0); // Z is deduced to be double +#if __cplusplus <= 199711L + // expected-warning@-2{{conversion from string literal to 'char *' is deprecated}} +#else + // expected-warning@-4{{ISO C++11 does not allow conversion from string literal to 'char *'}} +#endif + f<int>("aa",3.0); // Y is deduced to be char*, and // Z is deduced to be double f("aa",3.0); // expected-error{{no matching}} diff --git a/test/CXX/temp/temp.param/p3.cpp b/test/CXX/temp/temp.param/p3.cpp index dc40c4b..c3c9339 100644 --- a/test/CXX/temp/temp.param/p3.cpp +++ b/test/CXX/temp/temp.param/p3.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s // A type-parameter defines its identifier to be a type-name (if // declared with class or typename) or template-name (if declared with @@ -16,6 +18,10 @@ template<template<class T> class Y> struct X1 { // type-parameter (because its identifier is the name of an already // existing class) is taken as a type-parameter. For example, class T { /* ... */ }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif + int i; template<class T, T i> struct X2 { diff --git a/test/CXX/temp/temp.res/temp.local/p3.cpp b/test/CXX/temp/temp.res/temp.local/p3.cpp index d5e3786..63c40fb 100644 --- a/test/CXX/temp/temp.res/temp.local/p3.cpp +++ b/test/CXX/temp/temp.res/temp.local/p3.cpp @@ -14,8 +14,7 @@ template <class T> struct Derived: Base<int>, Base<char> { t->Derived::Base<T>::f(); t->Base<T>::f(); t->Base::f(); // expected-error{{member 'Base' found in multiple base classes of different types}} \ - // expected-error{{no member named 'f' in 'X0'}} \ - // expected-error{{'Base' is not a class, namespace, or enumeration}} + // expected-error{{no member named 'f' in 'X0'}} } }; diff --git a/test/CXX/temp/temp.res/temp.local/p6.cpp b/test/CXX/temp/temp.res/temp.local/p6.cpp index eccbb89..06eb1be 100644 --- a/test/CXX/temp/temp.res/temp.local/p6.cpp +++ b/test/CXX/temp/temp.res/temp.local/p6.cpp @@ -1,9 +1,11 @@ // RUN: %clang_cc1 -verify %s -fcxx-exceptions -std=c++1y +namespace N {} + template<typename T, // expected-note {{declared here}} typename T> struct X {}; // expected-error {{declaration of 'T' shadows template parameter}} -template<typename T> struct Y { // expected-note 15{{declared here}} +template<typename T> struct Y { // expected-note 16{{declared here}} template<typename T> struct A {}; // expected-error {{declaration of 'T' shadows template parameter}} struct B { @@ -50,6 +52,9 @@ template<typename T> struct Y { // expected-note 15{{declared here}} void d() { void T(); // expected-error {{declaration of 'T' shadows template parameter}} } + void e() { + namespace T = N; // expected-error {{declaration of 'T' shadows template parameter}} + } friend struct T; // expected-error {{declaration of 'T' shadows template parameter}} }; diff --git a/test/CXX/temp/temp.spec/temp.explicit/p1.cpp b/test/CXX/temp/temp.spec/temp.explicit/p1.cpp index b426339..5a77d27 100644 --- a/test/CXX/temp/temp.spec/temp.explicit/p1.cpp +++ b/test/CXX/temp/temp.spec/temp.explicit/p1.cpp @@ -1,4 +1,6 @@ // RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s struct C { }; @@ -49,6 +51,9 @@ template void X1<int>::f<>(int&, int*); // expected-note{{instantiation}} // Explicitly instantiate members of a class template struct Incomplete; // expected-note{{forward declaration}} struct NonDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor) not viable}} +#if __cplusplus >= 201103L // C++11 or later +// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}} +#endif NonDefaultConstructible(int); // expected-note{{candidate constructor}} }; |
