diff --git a/clang/test/CXX/drs/dr2xx.cpp b/clang/test/CXX/drs/dr2xx.cpp index 19cb122aa6fc..692ed1d1afde 100644 --- a/clang/test/CXX/drs/dr2xx.cpp +++ b/clang/test/CXX/drs/dr2xx.cpp @@ -686,6 +686,8 @@ namespace dr259 { // dr259: yes c++11 #endif } +// FIXME: When dr260 is resolved, also add tests for DR507. + namespace dr261 { // dr261: no #pragma clang diagnostic push #pragma clang diagnostic warning "-Wused-but-marked-unused" diff --git a/clang/test/CXX/drs/dr5xx.cpp b/clang/test/CXX/drs/dr5xx.cpp index fa8d5682372f..09b28690fd4b 100644 --- a/clang/test/CXX/drs/dr5xx.cpp +++ b/clang/test/CXX/drs/dr5xx.cpp @@ -14,4 +14,183 @@ namespace dr500 { // dr500: dup 372 class D : public A::B {}; } -// expected-no-diagnostics +namespace dr501 { // dr501: yes + struct A { + friend void f() {} + void g() { + void (*p)() = &f; // expected-error {{undeclared identifier}} + } + }; +} + +namespace dr502 { // dr502: yes + struct Q {}; + template struct A { + enum E { e = 1 }; + void q1() { f(e); } + void q2() { Q arr[sizeof(E)]; f(arr); } + void q3() { Q arr[e]; f(arr); } + void sanity() { Q arr[1]; f(arr); } // expected-error {{undeclared identifier 'f'}} + }; + int f(A::E); + template int f(Q (&)[N]); + template struct A; +} + +namespace dr505 { // dr505: yes + const char *exts = "\e\(\{\[\%"; // expected-error 5{{use of non-standard escape}} + const char *unknown = "\Q"; // expected-error {{unknown escape sequence}} +} + +namespace dr506 { // dr506: yes + struct NonPod { ~NonPod(); }; + void f(...); + void g(NonPod np) { f(np); } // expected-error {{cannot pass}} +} + +// FIXME: Add tests here once DR260 is resolved. +// dr507: dup 260 + +// dr508: na +// dr509: na +// dr510: na + +namespace dr512 { // dr512: yes + struct A { + A(int); + }; + union U { A a; }; +#if __cplusplus < 201103L + // expected-error@-2 {{has a non-trivial constructor}} + // expected-note@-6 {{no default constructor}} + // expected-note@-6 {{suppressed by user-declared constructor}} +#endif +} + +// dr513: na + +namespace dr514 { // dr514: yes + namespace A { extern int x, y; } + int A::x = y; +} + +namespace dr515 { // dr515: sup 1017 + // FIXME: dr1017 reverses the wording of dr515, but the current draft has + // dr515's wording, with a different fix for dr1017. + + struct X { int n; }; + template struct Y : T { + int f() { return X::n; } + }; + int k = Y().f(); + + struct A { int a; }; + struct B { void f() { int k = sizeof(A::a); } }; +#if __cplusplus < 201103L + // expected-error@-2 {{invalid use of non-static data member}} +#endif +} + +// dr516: na + +namespace dr517 { // dr517: no + // This is NDR, but we should diagnose it anyway. + template struct S {}; + template int v = 0; // expected-error 0-1{{extension}} + + template struct S; + template int v; + + S s; + int k = v; + + // FIXME: These are both ill-formed. + template struct S {}; + template int v = 0; // expected-error 0-1{{extension}} + + // FIXME: These are both ill-formed. + template struct S {}; + template int v = 0; // expected-error 0-1{{extension}} +} + +namespace dr518 { // dr518: yes c++11 + enum E { e, }; +#if __cplusplus < 201103L + // expected-error@-2 {{C++11 extension}} +#endif +} + +namespace dr519 { // dr519: yes +// FIXME: Add a codegen test. +#if __cplusplus >= 201103L +#define fold(x) (__builtin_constant_p(x) ? (x) : (x)) + int test[fold((int*)(void*)0) ? -1 : 1]; +#undef fold +#endif +} + +// dr520: na + +// dr521: no +// FIXME: The wording here is broken. It's not reasonable to expect a +// diagnostic here. Once the relevant DR gets a number, mark this as a dup. + +namespace dr522 { // dr522: yes + struct S {}; + template void b1(volatile T &); + template void b2(volatile T * const *); + template void b2(volatile T * const S::*); + template void b2(volatile T * const S::* const *); + // FIXME: This diagnostic isn't very good. The problem is not substitution failure. + template void b2a(volatile T *S::* const *); // expected-note {{substitution failure}} + + template struct Base {}; + struct Derived : Base {}; + template void b3(Base); + template void b3(Base *); + + void test(int n, const int cn, int **p, int *S::*pm) { + int *a[3], *S::*am[3]; + const Derived cd = Derived(); + Derived d[3]; + + b1(n); + b1(cn); + b2(p); + b2(pm); + b2(a); + b2(am); + b2a(am); // expected-error {{no matching function}} + b3(d); + b3(cd); + } +} + +namespace dr524 { // dr524: yes + template void f(T a, T b) { operator+(a, b); } // expected-error {{call}} + + struct S {}; + void operator+(S, S); + template void f(S, S); + + namespace N { struct S {}; } + void operator+(N::S, N::S); // expected-note {{should be declared}} + template void f(N::S, N::S); // expected-note {{instantiation}} +} + +namespace dr525 { // dr525: yes + namespace before { + // Note, the example was correct prior to the change; instantiation is + // required for cases like this: + template struct D { operator T*(); }; + void g(D ppp) { + delete ppp; + } + } + namespace after { + template struct D { typename T::error e; }; // expected-error {{prior to '::'}} + void g(D *ppp) { + delete ppp; // expected-note {{instantiation of}} + } + } +} diff --git a/clang/www/cxx_dr_status.html b/clang/www/cxx_dr_status.html index 73bb160e49ea..1ada70c70225 100644 --- a/clang/www/cxx_dr_status.html +++ b/clang/www/cxx_dr_status.html @@ -3047,13 +3047,13 @@ of class templates 501 NAD Visibility of friend declarations within the befriending class - Unknown + Yes 502 C++11 Dependency of nested enumerations and enumerators - Unknown + Yes 503 @@ -3071,37 +3071,37 @@ of class templates 505 CD1 Conditionally-supported behavior for unknown character escapes - Unknown + Yes 506 CD1 Conditionally-supported behavior for non-POD objects passed to ellipsis - Unknown + Yes 507 dup Ambiguity assigning class object to built-in type - Unknown + Duplicate of 260 508 C++11 Non-constructed value-initialized objects - Unknown + N/A 509 CD1 Dead code in the specification of default initialization - Unknown + N/A 510 CD1 Default initialization of POD classes? - Unknown + N/A 511 @@ -3113,67 +3113,67 @@ of class templates 512 NAD Union members with user-declared non-default constructors - Unknown + Yes 513 CD1 Non-class “most-derived” objects - Unknown + N/A 514 CD1 Is the initializer for a namespace member in the scope of the namespace? - Unknown + Yes 515 CD1 Non-dependent references to base class members - Unknown + Superseded by 1017 516 CD1 Use of signed in bit-field declarations - Unknown + N/A 517 CD1 Partial specialization following explicit instantiation - Unknown + No 518 CD1 Trailing comma following enumerator-list - Unknown + Yes (C++11 onwards) 519 CD1 Null pointer preservation in void* conversions - Unknown + Yes 520 CD1 Old-style casts between incomplete class types - Unknown + N/A 521 CD1 Requirements for exceptions thrown by allocation functions - Unknown + No 522 CD1 Array-to-pointer decay in template argument deduction - Unknown + Yes 523 @@ -3185,13 +3185,13 @@ of class templates 524 CD1 Can function-notation calls to operator functions be dependent? - Unknown + Yes 525 CD1 Missing * in example - Unknown + Yes 526