From: Richard Smith Date: Sun, 16 Jun 2013 08:00:51 +0000 (+0000) Subject: Add tests for C++ DR100-150. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=ed7dc87192784841839908a88b6d0623f6278408;p=clang Add tests for C++ DR100-150. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@184057 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/test/CXX/drs/dr1xx.cpp b/test/CXX/drs/dr1xx.cpp new file mode 100644 index 0000000000..1825bdbc25 --- /dev/null +++ b/test/CXX/drs/dr1xx.cpp @@ -0,0 +1,541 @@ +// 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++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +namespace dr100 { // dr100: yes + template struct A {}; // expected-note {{declared here}} + template struct B {}; // expected-note {{declared here}} + A<"foo"> a; // expected-error {{does not refer to any declaration}} + B<"bar"> b; // expected-error {{does not refer to any declaration}} +} + +namespace dr101 { // dr101: no + // FIXME: This is valid. + extern "C" void dr101_f(); // expected-note {{conflicting declaration}} + typedef unsigned size_t; + namespace X { + extern "C" void dr101_f(); // expected-note {{target of using declaration}} + typedef unsigned size_t; + } + using X::dr101_f; // expected-error {{conflicts with declaration already in scope}} + using X::size_t; +} + +namespace dr102 { // dr102: yes + namespace A { + template T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}} + } + namespace B { + struct S {}; + } + B::S operator+(B::S, B::S); // expected-note {{should be declared prior to the call site or in namespace 'dr102::B'}} + template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}} +} + +// dr103: na +// dr104 FIXME: add codegen test +// dr105: na + +namespace dr106 { // dr106: sup 540 + typedef int &r1; + typedef r1 &r1; + typedef const r1 r1; + typedef const r1 &r1; + + typedef const int &r2; + typedef r2 &r2; + typedef const r2 r2; + typedef const r2 &r2; +} + +namespace dr107 { // dr107: yes + struct S {}; + extern "C" S operator+(S, S) { return S(); } +} + +namespace dr108 { // dr108: yes + template struct A { + struct B { typedef int X; }; + B::X x; // expected-error {{missing 'typename'}} + struct C : B { X x; }; // expected-error {{unknown type name}} + }; + template<> struct A::B { int X; }; +} + +namespace dr109 { // dr109: yes + struct A { template void f(T); }; + template struct B : T { + using T::template f; // expected-error {{using declaration can not refer to a template}} + void g() { this->f(123); } // expected-error {{use 'template'}} + }; +} + +namespace dr111 { // dr111: dup 535 + struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); }; + struct B : A { B(); }; // expected-note {{would lose const qualifier}} expected-note {{requires 0 arguments}} + const B b1; + B b2(b1); // expected-error {{no matching constructor}} +} + +namespace dr112 { // dr112: yes + struct T { int n; }; + typedef T Arr[1]; + + const T a1[1] = {}; + volatile T a2[1] = {}; + const Arr a3 = {}; + volatile Arr a4 = {}; + template struct X {}; + X x1; + X x2; + X x3; + X x4; +#if __cplusplus < 201103L + // expected-error@-5 {{internal linkage}} expected-note@-10 {{here}} + // expected-error@-4 {{internal linkage}} expected-note@-9 {{here}} +#else + // FIXME: Test this somehow. +#endif +} + +namespace dr113 { // dr113: yes + extern void (*p)(); + void f() { + no_such_function(); // expected-error {{undeclared}} + p(); + } + void g(); + void (*p)() = &g; +} + +namespace dr114 { // dr114: yes + struct A { + virtual void f(int) = 0; // expected-note {{unimplemented}} + }; + struct B : A { + template void f(T); + void g() { f(0); } + } b; // expected-error {{abstract}} +} + +namespace dr115 { // dr115: yes + template int f(T); // expected-note +{{}} + template int g(T); // expected-note +{{}} + template int g(T, int); // expected-note +{{}} + + int k1 = f(&f); // expected-error {{no match}} + int k2 = f(&f); + int k3 = f(&g); // expected-error {{no match}} + + void h() { + (void)&f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}} + (void)&f; + (void)&g; // expected-error {{address of overloaded function 'g' cannot be cast to type 'void'}} + + &f; // expected-error {{reference to overloaded function could not be resolved}} + &f; // expected-warning {{unused}} + &g; // expected-error {{reference to overloaded function could not be resolved}} + } + + struct S { + template static int f(T); + template static int g(T); + template static int g(T, int); + } s; + + int k4 = f(&s.f); // expected-error {{non-constant pointer to member}} + int k5 = f(&s.f); + int k6 = f(&s.g); // expected-error {{non-constant pointer to member}} + + void i() { + (void)&s.f; // expected-error {{non-constant pointer to member}} + (void)&s.f; + (void)&s.g; // expected-error {{non-constant pointer to member}} + + &s.f; // expected-error {{non-constant pointer to member}} + &s.f; // expected-warning {{unused}} + &s.g; // expected-error {{non-constant pointer to member}} + } + + struct T { + template int f(T); + template int g(T); + template int g(T, int); + } t; + + int k7 = f(&s.f); // expected-error {{non-constant pointer to member}} + int k8 = f(&s.f); + int k9 = f(&s.g); // expected-error {{non-constant pointer to member}} + + void j() { + (void)&s.f; // expected-error {{non-constant pointer to member}} + (void)&s.f; + (void)&s.g; // expected-error {{non-constant pointer to member}} + + &s.f; // expected-error {{non-constant pointer to member}} + &s.f; // expected-warning {{unused}} + &s.g; // expected-error {{non-constant pointer to member}} + } + +#if __cplusplus >= 201103L + // Special case kicks in only if a template argument list is specified. + template void with_default(); // expected-note +{{}} + int k10 = f(&with_default); // expected-error {{no matching function}} + int k11 = f(&with_default<>); + void k() { + (void)&with_default; // expected-error {{overloaded function}} + (void)&with_default<>; + &with_default; // expected-error {{overloaded function}} + &with_default<>; // expected-warning {{unused}} + } +#endif +} + +namespace dr116 { // dr116: yes + template struct A {}; + template void f(A) {} // expected-note {{previous}} + template void f(A) {} // expected-error {{redefinition}} + template void f(A) {} // expected-note {{previous}} + template void f(A) {} // expected-error {{redefinition}} +} + +// dr117: na +// dr118 FIXME: add codegen test +// dr119: na +// dr120: na + +namespace dr121 { // dr121: yes + struct X { + template struct Y {}; + }; + template struct Z { + X::Y x; + T::Y y; // expected-error +{{}} + }; + Z z; +} + +namespace dr122 { // dr122: yes + template void f(); + void g() { f(); } +} + +// dr123: na +// dr124: dup 201 + +// dr125: yes +struct dr125_A { struct dr125_B {}; }; +dr125_A::dr125_B dr125_C(); +namespace dr125_B { dr125_A dr125_C(); } +namespace dr125 { + struct X { + 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 {{requires a type specifier}} + }; +} + +namespace dr126 { // dr126: no + struct C {}; + struct D : C {}; + struct E : private C { friend class A; friend class B; }; + struct F : protected C {}; + struct G : C {}; + struct H : D, G {}; + + struct A { + virtual void cp() throw(C*); + virtual void dp() throw(C*); + virtual void ep() throw(C*); // expected-note {{overridden}} + virtual void fp() throw(C*); // expected-note {{overridden}} + virtual void gp() throw(C*); + virtual void hp() throw(C*); // expected-note {{overridden}} + + virtual void cr() throw(C&); + virtual void dr() throw(C&); + virtual void er() throw(C&); // expected-note {{overridden}} + virtual void fr() throw(C&); // expected-note {{overridden}} + virtual void gr() throw(C&); + virtual void hr() throw(C&); // expected-note {{overridden}} + + virtual void pv() throw(void*); // expected-note {{overridden}} + +#if __cplusplus >= 201103L + virtual void np() throw(C*); // expected-note {{overridden}} + virtual void npm() throw(int C::*); // expected-note {{overridden}} + virtual void nr() throw(C&); // expected-note {{overridden}} +#endif + + virtual void ref1() throw(C *const&); + virtual void ref2() throw(C *); + + virtual void v() throw(int); + virtual void w() throw(const int); + virtual void x() throw(int*); + virtual void y() throw(const int*); + virtual void z() throw(int); // expected-note {{overridden}} + }; + struct B : A { + virtual void cp() throw(C*); + virtual void dp() throw(D*); + virtual void ep() throw(E*); // expected-error {{more lax}} + virtual void fp() throw(F*); // expected-error {{more lax}} + virtual void gp() throw(G*); + virtual void hp() throw(H*); // expected-error {{more lax}} + + virtual void cr() throw(C&); + virtual void dr() throw(D&); + virtual void er() throw(E&); // expected-error {{more lax}} + virtual void fr() throw(F&); // expected-error {{more lax}} + virtual void gr() throw(G&); + virtual void hr() throw(H&); // expected-error {{more lax}} + + virtual void pv() throw(C*); // expected-error {{more lax}} FIXME: This is valid. + +#if __cplusplus >= 201103L + using nullptr_t = decltype(nullptr); + virtual void np() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid. + virtual void npm() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid. + virtual void nr() throw(nullptr_t&); // expected-error {{more lax}} This is not. +#endif + + virtual void ref1() throw(D *const &); + virtual void ref2() throw(D *); + + virtual void v() throw(const int); + virtual void w() throw(int); + virtual void x() throw(const int*); // FIXME: 'const int*' is not allowed by A::h. + virtual void y() throw(int*); // ok + virtual void z() throw(long); // expected-error {{more lax}} + }; +} + +namespace dr127 { // dr127: yes + typedef __SIZE_TYPE__ size_t; + template struct A { + A() throw(int); + void *operator new(size_t, const char * = 0); + void operator delete(void *, const char *) { T::error; } // expected-error 2{{no members}} + void operator delete(void *) { T::error; } + }; + A *p = new A; // expected-note {{instantiat}} + A *q = new ("") A; // expected-note {{instantiat}} +} + +namespace dr128 { // dr128: yes + enum E1 { e1 } x = e1; + enum E2 { e2 } y = static_cast(x), z = static_cast(e1); +} + +// dr129: dup 616 +// dr130: na + +namespace dr131 { // dr131: yes + const char *a_with_\u0e8c = "\u0e8c"; + const char *b_with_\u0e8d = "\u0e8d"; + const char *c_with_\u0e8e = "\u0e8e"; +#if __cplusplus < 201103L + // expected-error@-4 {{expected ';'}} expected-error@-2 {{expected ';'}} +#endif +} + +namespace dr132 { // dr132: no + void f() { + extern struct {} x; // ok + extern struct S {} y; // FIXME: This is invalid. + } + static enum { E } e; +} + +// dr133: dup 87 +// dr134: na + +namespace dr135 { // dr135: yes + struct A { + A f(A a) { return a; } + friend A g(A a) { return a; } + static A h(A a) { return a; } + }; +} + +namespace dr136 { // dr136: no + void f(int, int, int = 0); + void g(int, int, int); + struct A { + // FIXME: These declarations of f, g, and h are invalid. + friend void f(int, int = 0, int); + friend void g(int, int, int = 0); + friend void h(int, int, int = 0); + friend void i(int, int, int = 0) {} + friend void j(int, int, int = 0) {} + operator int(); + }; + // FIXME: This declaration of i is invalid. + void i(int, int, int); + void q() { + j(A(), A()); // ok, has default argument + } + // FIXME: Also test extern "C" friends and default arguments from other + // namespaces? +} + +namespace dr137 { // dr137: yes + extern void *p; + extern const void *cp; + extern volatile void *vp; + extern const volatile void *cvp; + int *q = static_cast(p); + int *qc = static_cast(cp); // expected-error {{casts away qualifiers}} + int *qv = static_cast(vp); // expected-error {{casts away qualifiers}} + int *qcv = static_cast(cvp); // expected-error {{casts away qualifiers}} + const int *cq = static_cast(p); + const int *cqc = static_cast(cp); + const int *cqv = static_cast(vp); // expected-error {{casts away qualifiers}} + const int *cqcv = static_cast(cvp); // expected-error {{casts away qualifiers}} + const volatile int *cvq = static_cast(p); + const volatile int *cvqc = static_cast(cp); + const volatile int *cvqv = static_cast(vp); + const volatile int *cvqcv = static_cast(cvp); +} + +namespace dr139 { // dr139: yes + namespace example1 { + typedef int f; // expected-note {{previous}} + struct A { + friend void f(A &); // expected-error {{different kind of symbol}} + }; + } + + namespace example2 { + typedef int f; + namespace N { + struct A { + friend void f(A &); + operator int(); + void g(A a) { int i = f(a); } // ok, f is typedef not friend function + }; + } + } +} + +namespace dr140 { // dr140: yes + void f(int *const) {} // expected-note {{previous}} + void f(int[3]) {} // expected-error {{redefinition}} + void g(const int); + void g(int n) { n = 2; } +} + +namespace dr141 { // dr141: yes + template void f(); + template struct S { int n; }; + struct A : S { + template void f(); + template struct S {}; + } a; + struct B : S {} b; + void g() { + a.f(); + (void)a.S::n; // expected-error {{no member named 'n'}} +#if __cplusplus < 201103L + // expected-error@-2 {{ambiguous}} + // expected-note@-11 {{lookup from the current scope}} + // expected-note@-9 {{lookup in the object type}} +#endif + b.f(); // expected-error {{no member}} expected-error +{{}} + (void)b.S::n; + } + template struct C { + T t; + void g() { + t.f(); // expected-error {{use 'template'}} + } + void h() { + (void)t.S::n; // ok + } + void i() { + (void)t.S(); // ok! + } + }; + void h() { C().h(); } // ok + struct X { + template void S(); + }; + void i() { C().i(); } // ok!! +} + +namespace dr142 { // dr142: yes + class B { // expected-note +{{here}} + public: + int mi; // expected-note +{{here}} + static int si; // expected-note +{{here}} + }; + class D : private B { // expected-note +{{here}} + }; + class DD : public D { + void f(); + }; + void DD::f() { + mi = 3; // expected-error {{private base class}} expected-error {{private member}} + si = 3; // expected-error {{private member}} + B b_old; // expected-error {{private member}} + dr142::B b; + b.mi = 3; + b.si = 3; + B::si = 3; // expected-error {{private member}} + dr142::B::si = 3; + B *bp1_old = this; // expected-error {{private member}} expected-error {{private base class}} + dr142::B *bp1 = this; // expected-error {{private base class}} + B *bp2_old = (B*)this; // expected-error 2{{private member}} + dr142::B *bp2 = (dr142::B*)this; + bp2->mi = 3; + } +} + +namespace dr143 { // dr143: yes + namespace A { struct X; } + namespace B { void f(A::X); } + namespace A { + struct X { friend void B::f(X); }; + } + void g(A::X x) { + f(x); // expected-error {{undeclared identifier 'f'}} + } +} + +namespace dr145 { // dr145: yes + void f(bool b) { + ++b; // expected-warning {{deprecated}} + b++; // expected-warning {{deprecated}} + } +} + +namespace dr147 { // dr147: no + namespace example1 { + template struct A { + template A(T); + }; + // FIXME: This appears to be valid, and EDG and G++ accept. + template<> template<> A::A(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}} + } + namespace example2 { + struct A { A(); }; + struct B : A { B(); }; + A::A a1; // expected-error {{is a constructor}} + B::A a2; + } + namespace example3 { + template struct A { + template A(T); + static A a; + }; + template<> A::A(A::a); // expected-error {{is a constructor}} + } +} + +namespace dr148 { // dr148: yes + struct A { int A::*p; }; + int check1[__is_pod(int(A::*)) ? 1 : -1]; + int check2[__is_pod(A) ? 1 : -1]; +} + +// dr149: na diff --git a/www/cxx_dr_status.html b/www/cxx_dr_status.html index 4c43d45208..19fe637d65 100644 --- a/www/cxx_dr_status.html +++ b/www/cxx_dr_status.html @@ -638,25 +638,25 @@ 100 TC1 Clarify why string literals are not allowed as template arguments - Unknown + Yes 101 TC1 Redeclaration of extern "C" names via using-declarations - Unknown + No 102 NAD Operator lookup rules do not work well with parts of the library - Unknown + Yes 103 TC1 Is it extended-namespace-definition or extension-namespace-definition ? - Unknown + N/A 104 @@ -668,31 +668,31 @@ 105 TC1 Meaning of "template function" - Unknown + N/A 106 CD1 Creating references to references during template deduction/instantiation - Unknown + Superseded by 540 107 NAD Linkage of operator functions - Unknown + Yes 108 TC1 Are classes nested in templates dependent? - Unknown + Yes 109 NAD Allowing ::template in using-declarations - Unknown + Yes 110 @@ -704,43 +704,43 @@ 111 NAD Copy constructors and cv-qualifiers - Unknown + Duplicate of 535 112 CD1 Array types and cv-qualifiers - Unknown + Yes 113 CD1 Visibility of called function - Unknown + Yes 114 NAD Virtual overriding by template member function specializations - Unknown + Yes 115 CD1 Address of template-id - Unknown + Yes 116 TC1 Equivalent and functionally-equivalent function templates - Unknown + Yes 117 NAD Timing of destruction of temporaries - Unknown + N/A 118 @@ -752,115 +752,115 @@ 119 CD1 Object lifetime and aggregate initialization - Unknown + N/A 120 TC1 Nonexistent non-terminal qualified-name - Unknown + N/A 121 TC1 Dependent type names with non-dependent nested-name-specifiers - Unknown + Yes 122 CD1 template-ids as unqualified-ids - Unknown + Yes 123 TC1 Bad cross-reference - Unknown + N/A 124 CD1 Lifetime of temporaries in default initialization of class arrays - Unknown + Duplicate of 201 125 CD1 Ambiguity in friend declaration syntax - Unknown + Yes 126 TC1 Exception specifications and const - Unknown + No 127 TC1 Ambiguity in description of matching deallocation function - Unknown + Yes 128 TC1 Casting between enum types - Unknown + Yes 129 DR Stability of uninitialized auto variables - Unknown + Duplicate of 616 130 NAD Sequence points and new-expressions - Unknown + N/A 131 TC1 Typo in Lao characters - Unknown + Yes 132 NAD Local types and linkage - Unknown + No 133 dup Exception specifications and checking - Unknown + Duplicate of 87 134 TC1 Template classes and declarator-ids - Unknown + N/A 135 TC1 Class type in in-class member function definitions - Unknown + Yes 136 CD1 Default arguments and friend declarations - Unknown + No 137 TC1 static_cast of cv void* - Unknown + Yes 138 @@ -872,31 +872,31 @@ 139 CD1 Error in friend lookup example - Unknown + Yes 140 CD1 Agreement of parameter declarations - Unknown + Yes 141 CD1 Non-member function templates in member access expressions - Unknown + Yes 142 TC1 Injection-related errors in access example - Unknown + Yes 143 CD1 Friends and Koenig lookup - Unknown + Yes 144 @@ -908,7 +908,7 @@ 145 TC1 Deprecation of prefix ++ - Unknown + Yes 146 @@ -920,19 +920,19 @@ 147 TC1 Naming the constructor - Unknown + No 148 TC1 POD classes and pointers to members - Unknown + Yes 149 TC1 Accessibility and ambiguity - Unknown + N/A 150