From: Richard Smith Date: Sun, 19 May 2013 07:22:38 +0000 (+0000) Subject: Tests and status for core issues 1-50. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=1c7315116ffb9b7527358ef2d145c5db68fccb36;p=clang Tests and status for core issues 1-50. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@182207 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/test/CXX/class.derived/class.member.lookup/p7.cpp b/test/CXX/class.derived/class.member.lookup/p7.cpp new file mode 100644 index 0000000000..a785e0f90e --- /dev/null +++ b/test/CXX/class.derived/class.member.lookup/p7.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -verify %s + +// expected-no-diagnostics + +struct A { int n; }; +struct B { float n; }; +struct C : A, B {}; +struct D : virtual C {}; +struct E : virtual C { char n; }; +struct F : D, E {} f; +char &k = f.n; diff --git a/test/CXX/drs/dr0xx.cpp b/test/CXX/drs/dr0xx.cpp new file mode 100644 index 0000000000..8c5022437e --- /dev/null +++ b/test/CXX/drs/dr0xx.cpp @@ -0,0 +1,504 @@ +// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -pedantic-errors -Wno-bind-to-temporary-copy +// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -pedantic-errors + +namespace dr1 { // dr1: no + namespace X { extern "C" void dr1_f(int a = 1); } // expected-note 2{{candidate}} expected-note {{conflicting}} + namespace Y { extern "C" void dr1_f(int a = 2); } // expected-note 2{{candidate}} expected-note {{target}} + using X::dr1_f; using Y::dr1_f; + void g() { + // FIXME: The first of these two should be accepted. + dr1_f(0); // expected-error {{ambiguous}} + dr1_f(); // expected-error {{ambiguous}} + } + namespace X { + using Y::dr1_f; // expected-error {{conflicts with declaration already in scope}} + void h() { + // FIXME: The second of these two should be rejected. + dr1_f(0); + dr1_f(); + } + } + + namespace X { + void z(int); + } + void X::z(int = 1) {} // expected-note {{previous}} + namespace X { + void z(int = 2); // expected-error {{redefinition of default argument}} + } +} + +namespace dr3 { // dr3: yes + template struct A {}; + template void f(T) { A a; } // expected-note {{implicit instantiation}} + template void f(int); + template<> struct A {}; // expected-error {{explicit specialization of 'dr3::A' after instantiation}} +} + +namespace dr4 { // dr4: yes + extern "C" { + static void dr4_f(int) {} + static void dr4_f(float) {} + void dr4_g(int) {} // expected-note {{previous}} + void dr4_g(float) {} // expected-error {{conflicting types}} + } +} + +namespace dr5 { // dr5: yes + struct A {} a; + struct B { + B(const A&); + B(const B&); + }; + const volatile B b = a; + + struct C { C(C&); }; + struct D : C {}; + struct E { operator D&(); } e; + const C c = e; +} + +namespace dr7 { // dr7: no + class A { public: ~A(); }; + class B : virtual private A {}; + class C : public B {} c; // FIXME: should be rejected, ~A is inaccessible + + class X { ~X(); }; // expected-note {{here}} + class Y : X { ~Y() {} }; // expected-error {{private destructor}} +} + +namespace dr8 { // dr8: dup 45 + class A { + struct U; + static const int k = 5; + void f(); + template struct T; + + T *g(); + }; + A::T *A::g() { return 0; } +} + +namespace dr9 { // dr9: yes + struct B { + protected: + int m; // expected-note {{here}} + friend int R1(); + }; + struct N : protected B { // expected-note 2{{protected}} + friend int R2(); + } n; + int R1() { return n.m; } // expected-error {{protected base class}} expected-error {{protected member}} + int R2() { return n.m; } +} + +namespace dr10 { // dr10: dup 45 + class A { + struct B { + A::B *p; + }; + }; +} + +namespace dr11 { // dr11: yes + template struct A : T { + using typename T::U; + U u; + }; + template struct B : T { + using T::V; + V v; // expected-error {{unknown type name}} + }; + struct X { typedef int U; }; + A ax; +} + +namespace dr12 { // dr12: sup 239 + enum E { e }; + E &f(E, E = e); + void g() { + int &f(int, E = e); + // Under DR12, these call two different functions. + // Under DR239, they call the same function. + int &b = f(e); + int &c = f(1); + } +} + +namespace dr14 { // dr14: no + namespace X { extern "C" int dr14_f(); } // expected-note {{candidate}} + namespace Y { extern "C" int dr14_f(); } // expected-note {{candidate}} + using namespace X; + using namespace Y; + // FIXME: This should be accepted, name lookup only finds one function (in two + // different namespaces). + int k = dr14_f(); // expected-error {{ambiguous}} + + class C { + int k; // expected-note {{here}} + friend int Y::dr14_f(); + } c; + namespace Z { + // FIXME: This should be accepted, this function is a friend. + extern "C" int dr14_f() { return c.k; } // expected-error {{private}} + } + + namespace X { typedef int T; typedef int U; } // expected-note {{candidate}} + namespace Y { typedef int T; typedef long U; } // expected-note {{candidate}} + T t; // ok, same type both times + U u; // expected-error {{ambiguous}} +} + +namespace dr15 { // dr15: yes + template void f(int); // expected-note {{previous}} + template void f(int = 0); // expected-error {{default arguments cannot be added}} +} + +namespace dr16 { // dr16: yes + class A { // expected-note {{here}} + void f(); // expected-note {{here}} + friend class C; + }; + class B : A {}; // expected-note 4{{here}} + class C : B { + void g() { + f(); // expected-error {{private member}} expected-error {{private base}} + A::f(); // expected-error {{private member}} expected-error {{private base}} + } + }; +} + +namespace dr17 { // dr17: yes + class A { + int n; + int f(); + struct C; + }; + struct B : A {} b; + int A::f() { return b.n; } + struct A::C : A { + int g() { return n; } + }; +} + +namespace dr18 { // dr18: yes + typedef void Void; + void f(Void); // expected-error {{empty parameter list defined with a typedef of 'void'}} +} + +namespace dr19 { // dr19: yes + struct A { + int n; // expected-note {{here}} + }; + struct B : protected A { // expected-note {{here}} + }; + struct C : B {} c; + struct D : B { + int get1() { return c.n; } // expected-error {{protected member}} + int get2() { return ((A&)c).n; } // ok, A is an accessible base of B from here + }; +} + +namespace dr20 { // dr20: yes + class X { + public: + X(); + private: + X(const X&); // expected-note {{here}} + }; + X f(); + X x = f(); // expected-error {{private}} +} + +namespace dr21 { // dr21: no + template struct A; + struct X { + // FIXME: We should reject these, per [temp.param]p9. + template friend struct A; + template friend struct B; + }; +} + +namespace dr22 { // dr22: sup 481 + template struct X; // expected-error {{unknown type name 'dr22_T'}} + typedef int T; + template struct Y; +} + +namespace dr23 { // dr23: yes + template void f(T, T); // expected-note {{candidate}} + template void f(T, int); // expected-note {{candidate}} + void g() { f(0, 0); } // expected-error {{ambiguous}} +} + +// dr24: na + +namespace dr25 { // dr25: no + struct A { + void f() throw(int); + }; + // FIXME: The initializations of g and i should be rejected. + void (A::*f)() throw (int); + void (A::*g)() throw () = f; + void (A::*h)() throw (int, char) = f; + void (A::*i)() throw () = &A::f; + void (A::*j)() throw (int, char) = &A::f; + void x() { + // FIXME: The assignments to g and i should be rejected. + g = f; + h = f; + i = &A::f; + j = &A::f; + } +} + +namespace dr26 { // dr26: yes + struct A { A(A, const A & = A()); }; // expected-error {{must pass its first argument by reference}} + struct B { + B(); // expected-note {{candidate}} + B(const B &, B = B()); // expected-error {{no matching constructor}} expected-note {{candidate}} expected-note {{here}} + }; +} + +namespace dr27 { // dr27: yes + enum E { e } n; + E &m = true ? n : n; +} + +// dr28: na + +namespace dr29 { // dr29: no + void dr29_f0(); // expected-note {{here}} + void g0() { void dr29_f0(); } + extern "C++" void g0_cxx() { void dr29_f0(); } + extern "C" void g0_c() { void dr29_f0(); } // expected-error {{different language linkage}} + + extern "C" void dr29_f1(); // expected-note {{here}} + void g1() { void dr29_f1(); } + extern "C" void g1_c() { void dr29_f1(); } + extern "C++" void g1_cxx() { void dr29_f1(); } // expected-error {{different language linkage}} + + // FIXME: We should reject this. + void g2() { void dr29_f2(); } + extern "C" void dr29_f2(); + + // FIXME: We should reject this. + extern "C" void g3() { void dr29_f3(); } + extern "C++" void dr29_f3(); + + // FIXME: We should reject this. + extern "C++" void g4() { void dr29_f4(); } + extern "C" void dr29_f4(); + + extern "C" void g5(); + extern "C++" void dr29_f5(); + void g5() { + void dr29_f5(); // ok, g5 is extern "C" but we're not inside the linkage-specification here. + } + + extern "C++" void g6(); + extern "C" void dr29_f6(); + void g6() { + void dr29_f6(); // ok, g6 is extern "C" but we're not inside the linkage-specification here. + } + + extern "C" void g7(); + extern "C++" void dr29_f7(); // expected-note {{here}} + extern "C" void g7() { + void dr29_f7(); // expected-error {{different language linkage}} + } + + extern "C++" void g8(); + extern "C" void dr29_f8(); // expected-note {{here}} + extern "C++" void g8() { + void dr29_f8(); // expected-error {{different language linkage}} + } +} + +namespace dr30 { // dr30: sup 468 + struct A { + template static int f(); + } a, *p = &a; + int x = A::template f<0>(); + int y = a.template f<0>(); + int z = p->template f<0>(); +#if __cplusplus < 201103L + // FIXME: It's not clear whether DR468 applies to C++98 too. + // expected-error@-5 {{'template' keyword outside of a template}} + // expected-error@-5 {{'template' keyword outside of a template}} + // expected-error@-5 {{'template' keyword outside of a template}} +#endif +} + +namespace dr31 { // dr31: yes + class X { + private: + void operator delete(void*); // expected-note {{here}} + }; + // We would call X::operator delete if X() threw (even though it can't, + // and even though we allocated the X using ::operator delete). + X *p = new X; // expected-error {{private}} +} + +// dr32: na + +namespace dr33 { // dr33: yes + namespace X { struct S; void f(void (*)(S)); } // expected-note {{candidate}} + namespace Y { struct T; void f(void (*)(T)); } // expected-note {{candidate}} + void g(X::S); + template Z g(Y::T); + void h() { f(&g); } // expected-error {{ambiguous}} +} + +// dr34: na +// dr35: dup 178 +// dr37: sup 475 + +namespace dr38 { // dr38: yes + template struct X {}; + template X operator+(X a, X b) { return a; } + template X operator+(X, X); +} + +namespace dr39 { // dr39: no + namespace example1 { + struct A { int &f(int); }; + struct B : A { + using A::f; + float &f(float); + } b; + int &r = b.f(0); + } + + namespace example2 { + struct A { + int &x(int); // expected-note {{found}} + static int &y(int); // expected-note {{found}} + }; + struct V { + int &z(int); + }; + struct B : A, virtual V { + using A::x; // expected-note {{found}} + float &x(float); + using A::y; // expected-note {{found}} + static float &y(float); + using V::z; + float &z(float); + }; + struct C : A, B, virtual V {} c; + int &x = c.x(0); // expected-error {{found in multiple base classes}} + // FIXME: This is valid, because we find the same static data member either way. + int &y = c.y(0); // expected-error {{found in multiple base classes}} + int &z = c.z(0); + } + + namespace example3 { + struct A { static int f(); }; + struct B : virtual A { using A::f; }; + struct C : virtual A { using A::f; }; + struct D : B, C {} d; + int k = d.f(); + } + + namespace example4 { + struct A { int n; }; // expected-note {{found}} + struct B : A {}; + struct C : A {}; + struct D : B, C { int f() { return n; } }; // expected-error {{found in multiple base-class}} + } +} + +// dr40: na + +namespace dr41 { // dr41: yes + struct S f(S); +} + +namespace dr42 { // dr42: yes + struct A { static const int k = 0; }; + struct B : A { static const int k = A::k; }; +} + +// dr43: na + +namespace dr44 { // dr44: yes + struct A { + template void f(); + template<> void f<0>(); // expected-error {{explicit specialization of 'f' in class scope}} + }; +} + +namespace dr45 { // dr45: yes + class A { + class B {}; + class C : B {}; + C c; + }; +} + +namespace dr46 { // dr46: yes + template struct A { template struct B {}; }; + template template struct A::B; // expected-error {{expected unqualified-id}} +} + +namespace dr47 { // dr47: no + template struct A { + friend void f() { T t; } + }; + A a; + A b; +#if __cplusplus < 201103L + // expected-error@-5 {{redefinition}} expected-note@-5 {{previous}} + // expected-note@-3 {{instantiation of}} +#else + void f(); + // FIXME: We should produce some kind of error here. C++11 [temp.friend]p4 + // says we instantiate 'f' when it's odr-used, but that doesn't imply that + // this is valid; we still have multiple definitions of 'f' even if we never + // instantiate any of them. + void g() { f(); } +#endif +} + +namespace dr48 { // dr48: yes + namespace { + struct S { + static const int m = 0; + static const int n = 0; + static const int o = 0; + }; + } + int a = S::m; + // FIXME: We should produce a 'has internal linkage but is not defined' + // diagnostic for 'S::n'. + const int &b = S::n; + const int S::o; + const int &c = S::o; +} + +namespace dr49 { // dr49: yes + template struct A {}; // expected-note {{here}} + int k; +#if __has_feature(cxx_constexpr) + constexpr +#endif + int *const p = &k; + A<&k> a; + A

b; // expected-error {{must have its address taken}} +#if __cplusplus < 201103L + // expected-error@-2 {{internal linkage}} + // expected-note@-5 {{here}} +#endif +} + +namespace dr50 { // dr50: yes + struct X; // expected-note {{forward}} + extern X *p; + X *q = (X*)p; + X *r = static_cast(p); + X *s = const_cast(p); + X *t = reinterpret_cast(p); + X *u = dynamic_cast(p); // expected-error {{incomplete}} +} diff --git a/www/cxx_dr_status.html b/www/cxx_dr_status.html index 2ca30c5709..6ee98e8a5f 100644 --- a/www/cxx_dr_status.html +++ b/www/cxx_dr_status.html @@ -44,7 +44,7 @@ 1 TC1 What if two using-declarations refer to the same function but the declarations introduce different default-arguments? - Unknown + No 2 @@ -56,19 +56,19 @@ 3 NAD The template compilation model rules render some explicit specialization declarations not visible during instantiation - Unknown + Yes 4 CD1 Does extern "C" affect the linkage of function names with internal linkage? - Unknown + Yes 5 CD1 CV-qualifiers and type conversions - Unknown + Yes 6 @@ -80,37 +80,37 @@ 7 NAD Can a class with a private virtual base class be derived from? - Unknown + No 8 CD1 Access to template arguments used in a function return type and in the nested name specifier - Unknown + Duplicate of 45 9 CD1 Clarification of access to base class members - Unknown + Yes 10 CD1 Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class? - Unknown + Duplicate of 45 11 CD1 How do the keywords typename/template interact with using-declarations? - Unknown + Yes 12 dup Default arguments on different declarations for the same function and the Koenig lookup - Unknown + Superseded by 239 13 @@ -122,133 +122,133 @@ 14 NAD extern "C" functions and declarations in different namespaces - Unknown + No 15 dup Default arguments for parameters of function templates - Unknown + Yes 16 CD1 Access to members of indirect private base classes - Unknown + Yes 17 NAD Footnote 99 should discuss the naming class when describing members that can be accessed from friends - Unknown + Yes 18 NAD f(TYPE) where TYPE is void should be allowed - Unknown + Yes 19 NAD Clarify protected member access - Unknown + Yes 20 TC1 Some clarifications needed for 12.8 para 15 - Unknown + Yes 21 TC1 Can a default argument for a template parameter appear in a friend declaration? - Unknown + No 22 TC1 Template parameter with a default argument that refers to itself - Unknown + Superseded by 481 23 NAD Some questions regarding partial ordering of function templates - Unknown + Yes 24 TC1 Errors in examples in 14.7.3 - Unknown + N/A 25 TC1 Exception specifications and pointers to members - Unknown + No 26 NAD Copy constructors and default arguments - Unknown + Yes 27 NAD Overload ambiguities for builtin ?: prototypes - Unknown + Yes 28 CD1 'exit', 'signal' and static object destruction - Unknown + N/A 29 CD1 Linkage of locally declared functions - Unknown + No 30 TC1 Valid uses of "::template" - Unknown + Superseded by 468 31 NAD Looking up new/delete - Unknown + Yes 32 TC1 Clarification of explicit instantiation of non-exported templates - Unknown + N/A 33 TC1 Argument dependent lookup and overloaded functions - Unknown + Yes 34 NAD Argument dependent lookup and points of instantiation - Unknown + N/A 35 TC1 Definition of default-initialization - Unknown + Duplicate of 178 36 @@ -260,85 +260,85 @@ 37 NAD When is uncaught_exception() true? - Unknown + Superseded by 475 38 TC1 Explicit template arguments and operator functions - Unknown + Yes 39 CD1 Conflicting ambiguity rules - Unknown + No 40 TC1 Syntax of declarator-id - Unknown + N/A 41 TC1 Clarification of lookup of names after declarator-id - Unknown + Yes 42 NAD Redefining names from base classes - Unknown + Yes 43 TC1 Copying base classes (PODs) using memcpy - Unknown + N/A 44 CD1 Member specializations - Unknown + Yes 45 CD1 Access to nested classes - Unknown + Yes 46 NAD Explicit instantiation of member templates - Unknown + Yes 47 NAD Template friend issues - Unknown + No 48 TC1 Definitions of unused static members - Unknown + Yes 49 TC1 Restriction on non-type, non-value template arguments - Unknown + Yes 50 NAD Converting pointer to incomplete type to same type - Unknown + Yes 51 diff --git a/www/make_cxx_dr_status b/www/make_cxx_dr_status index e53d7b914a..56c998bd42 100755 --- a/www/make_cxx_dr_status +++ b/www/make_cxx_dr_status @@ -1,7 +1,10 @@ #! /usr/bin/env python -import sys +import sys, os, re index = 'cwg_index.html' +output = 'cxx_dr_status.html' +dr_test_dir = '../test/CXX/drs' + if len(sys.argv) == 1: pass elif len(sys.argv) == 2: @@ -28,12 +31,23 @@ def parse(dr): title = title.replace('', '').replace('', '').strip() return DR(section, issue, url, status, title) -status_list = [line.split(' ', 1) for line in file('cxx_dr_status', 'r').readlines()] -status_map = dict((int(issue), status.strip()) for issue, status in status_list) +status_re = re.compile(r'\bdr([0-9]+): (.*)') +status_map = {} +for test_cpp in os.listdir(dr_test_dir): + test_cpp = os.path.join(dr_test_dir, test_cpp) + found_any = False; + for match in re.finditer(status_re, file(test_cpp, 'r').read()): + status_map[int(match.group(1))] = match.group(2) + found_any = True + if not found_any: + print >> sys.stderr, "warning:%s: no '// dr123: foo' comments in this file" % test_cpp + drs = sorted((parse(dr) for dr in file(index, 'r').read().split('')[2:]), key = lambda dr: dr.issue) +out_file = file(output, 'w') -print '''> out_file, '''\ + @@ -99,9 +113,13 @@ def availability(issue): elif status == 'na': avail = 'N/A' avail_style = ' class="na"' + elif status.startswith('sup '): + dup = int(status.split(' ', 1)[1]) + avail = 'Superseded by %s' % dup + _, avail_style = availability(dup) elif status.startswith('dup '): dup = int(status.split(' ', 1)[1]) - avail = 'Dup %s' % dup + avail = 'Duplicate of %s' % dup _, avail_style = availability(dup) else: assert False, 'unknown status %s for issue %s' % (status, dr.issue) @@ -121,7 +139,8 @@ for dr in drs: row_style = '' avail, avail_style = availability(dr.issue) - print ''' + print >> out_file, '''\ + %s %s %s @@ -129,7 +148,8 @@ for dr in drs: ''' % (row_style, dr.url, dr.issue, dr.status, dr.title, avail_style, avail) -print ''' +print >> out_file, '''\ +