r182720 - Tests and status for DR51-99.
Richard Smith
richard-llvm at metafoo.co.uk
Sun May 26 15:03:53 PDT 2013
Author: rsmith
Date: Sun May 26 17:03:53 2013
New Revision: 182720
URL: http://llvm.org/viewvc/llvm-project?rev=182720&view=rev
Log:
Tests and status for DR51-99.
Modified:
cfe/trunk/test/CXX/drs/dr0xx.cpp
cfe/trunk/www/cxx_dr_status.html
cfe/trunk/www/make_cxx_dr_status
Modified: cfe/trunk/test/CXX/drs/dr0xx.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CXX/drs/dr0xx.cpp?rev=182720&r1=182719&r2=182720&view=diff
==============================================================================
--- cfe/trunk/test/CXX/drs/dr0xx.cpp (original)
+++ cfe/trunk/test/CXX/drs/dr0xx.cpp Sun May 26 17:03:53 2013
@@ -1,6 +1,6 @@
-// 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
+// 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++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1 { // dr1: no
namespace X { extern "C" void dr1_f(int a = 1); } // expected-note 2{{candidate}} expected-note {{conflicting}}
@@ -234,21 +234,22 @@ namespace dr23 { // dr23: yes
// dr24: na
-namespace dr25 { // dr25: no
+namespace dr25 { // dr25: yes
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::*g)() throw () = f; // expected-error {{is not superset of source}}
+ void (A::*g2)() throw () = 0;
void (A::*h)() throw (int, char) = f;
- void (A::*i)() throw () = &A::f;
+ void (A::*i)() throw () = &A::f; // expected-error {{is not superset of source}}
+ void (A::*i2)() throw () = 0;
void (A::*j)() throw (int, char) = &A::f;
void x() {
- // FIXME: The assignments to g and i should be rejected.
- g = f;
+ // FIXME: Don't produce the second error here.
+ g2 = f; // expected-error {{is not superset}} expected-error {{incompatible}}
h = f;
- i = &A::f;
+ i2 = &A::f; // expected-error {{is not superset}} expected-error {{incompatible}}
j = &A::f;
}
}
@@ -502,3 +503,502 @@ namespace dr50 { // dr50: yes
X *t = reinterpret_cast<X*>(p);
X *u = dynamic_cast<X*>(p); // expected-error {{incomplete}}
}
+
+namespace dr51 { // dr51: yes
+ struct A {};
+ struct B : A {};
+ struct S {
+ operator A&();
+ operator B&();
+ } s;
+ A &a = s;
+}
+
+namespace dr52 { // dr52: yes
+ struct A { int n; }; // expected-note {{here}}
+ struct B : private A {} b; // expected-note 2{{private}}
+ // FIXME: This first diagnostic is very strangely worded, and seems to be bogus.
+ int k = b.A::n; // expected-error {{'A' is a private member of 'dr52::A'}}
+ // expected-error at -1 {{cannot cast 'struct B' to its private base}}
+}
+
+namespace dr53 { // dr53: yes
+ int n = 0;
+ enum E { e } x = static_cast<E>(n);
+}
+
+namespace dr54 { // dr54: yes
+ struct A { int a; } a;
+ struct V { int v; } v;
+ struct B : private A, virtual V { int b; } b; // expected-note 6{{private here}}
+
+ A &sab = static_cast<A&>(b); // expected-error {{private base}}
+ A *spab = static_cast<A*>(&b); // expected-error {{private base}}
+ int A::*smab = static_cast<int A::*>(&B::b); // expected-error {{private base}}
+ B &sba = static_cast<B&>(a); // expected-error {{private base}}
+ B *spba = static_cast<B*>(&a); // expected-error {{private base}}
+ int B::*smba = static_cast<int B::*>(&A::a); // expected-error {{private base}}
+
+ V &svb = static_cast<V&>(b);
+ V *spvb = static_cast<V*>(&b);
+ int V::*smvb = static_cast<int V::*>(&B::b); // expected-error {{virtual base}}
+ B &sbv = static_cast<B&>(v); // expected-error {{virtual base}}
+ B *spbv = static_cast<B*>(&v); // expected-error {{virtual base}}
+ int B::*smbv = static_cast<int B::*>(&V::v); // expected-error {{virtual base}}
+
+ A &cab = (A&)(b);
+ A *cpab = (A*)(&b);
+ int A::*cmab = (int A::*)(&B::b);
+ B &cba = (B&)(a);
+ B *cpba = (B*)(&a);
+ int B::*cmba = (int B::*)(&A::a);
+
+ V &cvb = (V&)(b);
+ V *cpvb = (V*)(&b);
+ int V::*cmvb = (int V::*)(&B::b); // expected-error {{virtual base}}
+ B &cbv = (B&)(v); // expected-error {{virtual base}}
+ B *cpbv = (B*)(&v); // expected-error {{virtual base}}
+ int B::*cmbv = (int B::*)(&V::v); // expected-error {{virtual base}}
+}
+
+namespace dr55 { // dr55: yes
+ enum E { e = 5 };
+ int test[(e + 1 == 6) ? 1 : -1];
+}
+
+namespace dr56 { // dr56: yes
+ struct A {
+ typedef int T; // expected-note {{previous}}
+ typedef int T; // expected-error {{redefinition}}
+ };
+ struct B {
+ struct X;
+ typedef X X; // expected-note {{previous}}
+ typedef X X; // expected-error {{redefinition}}
+ };
+}
+
+namespace dr58 { // dr58: yes
+ // FIXME: Ideally, we should have a CodeGen test for this.
+#if __cplusplus >= 201103L
+ enum E1 { E1_0 = 0, E1_1 = 1 };
+ enum E2 { E2_0 = 0, E2_m1 = -1 };
+ struct X { E1 e1 : 1; E2 e2 : 1; };
+ static_assert(X{E1_1, E2_m1}.e1 == 1, "");
+ static_assert(X{E1_1, E2_m1}.e2 == -1, "");
+#endif
+}
+
+namespace dr59 { // dr59: yes
+ template<typename T> struct convert_to { operator T() const; };
+ struct A {}; // expected-note 2{{volatile qualifier}}
+ struct B : A {}; // expected-note 2{{volatile qualifier}}
+#if __cplusplus >= 201103L // move constructors
+ // expected-note at -3 2{{volatile qualifier}}
+ // expected-note at -3 2{{volatile qualifier}}
+#endif
+
+ A a1 = convert_to<A>();
+ A a2 = convert_to<A&>();
+ A a3 = convert_to<const A>();
+ A a4 = convert_to<const volatile A>(); // expected-error {{no viable}}
+ A a5 = convert_to<const volatile A&>(); // expected-error {{no viable}}
+
+ B b1 = convert_to<B>();
+ B b2 = convert_to<B&>();
+ B b3 = convert_to<const B>();
+ B b4 = convert_to<const volatile B>(); // expected-error {{no viable}}
+ B b5 = convert_to<const volatile B&>(); // expected-error {{no viable}}
+
+ int n1 = convert_to<int>();
+ int n2 = convert_to<int&>();
+ int n3 = convert_to<const int>();
+ int n4 = convert_to<const volatile int>();
+ int n5 = convert_to<const volatile int&>();
+}
+
+namespace dr60 { // dr60: yes
+ void f(int &);
+ int &f(...);
+ const int k = 0;
+ int &n = f(k);
+}
+
+namespace dr61 { // dr61: no
+ struct X {
+ static void f();
+ } x;
+ struct Y {
+ static void f();
+ static void f(int);
+ } y;
+ // This is (presumably) valid, because x.f does not refer to an overloaded
+ // function name.
+ void (*p)() = &x.f;
+ // FIXME: This should be rejected.
+ void (*q)() = &y.f;
+}
+
+namespace dr62 { // dr62: yes
+ struct A {
+ struct { int n; } b;
+ };
+ template<typename T> struct X {};
+ template<typename T> T get() { return get<T>(); }
+ template<typename T> int take(T) { return 0; }
+
+ X<A> x1;
+ A a = get<A>();
+
+ typedef struct { } *NoNameForLinkagePtr;
+#if __cplusplus < 201103L
+ // expected-note at -2 5{{here}}
+#endif
+ NoNameForLinkagePtr noNameForLinkagePtr;
+
+ struct Danger {
+ NoNameForLinkagePtr p;
+ };
+
+ X<NoNameForLinkagePtr> x2;
+ X<const NoNameForLinkagePtr> x3;
+ NoNameForLinkagePtr p1 = get<NoNameForLinkagePtr>();
+ NoNameForLinkagePtr p2 = get<const NoNameForLinkagePtr>();
+ int n1 = take(noNameForLinkagePtr);
+#if __cplusplus < 201103L
+ // expected-error at -6 {{uses unnamed type}}
+ // expected-error at -6 {{uses unnamed type}}
+ // expected-error at -6 {{uses unnamed type}}
+ // expected-error at -6 {{uses unnamed type}}
+ // expected-error at -6 {{uses unnamed type}}
+#endif
+
+ X<Danger> x4;
+
+ void f() {
+ struct NoLinkage {};
+ X<NoLinkage> a;
+ X<const NoLinkage> b;
+ get<NoLinkage>();
+ get<const NoLinkage>();
+ X<void (*)(NoLinkage A::*)> c;
+ X<int NoLinkage::*> d;
+#if __cplusplus < 201103L
+ // expected-error at -7 {{uses local type}}
+ // expected-error at -7 {{uses local type}}
+ // expected-error at -7 {{uses local type}}
+ // expected-error at -7 {{uses local type}}
+ // expected-error at -7 {{uses local type}}
+ // expected-error at -7 {{uses local type}}
+#endif
+ }
+}
+
+namespace dr63 { // dr63: yes
+ template<typename T> struct S { typename T::error e; };
+ extern S<int> *p;
+ void *q = p;
+}
+
+namespace dr64 { // dr64: yes
+ template<class T> void f(T);
+ template<class T> void f(T*);
+ template<> void f(int*);
+ template<> void f<int>(int*);
+ template<> void f(int);
+}
+
+// dr65: na
+
+namespace dr66 { // dr66: no
+ namespace X {
+ int f(int n); // expected-note 2{{candidate}}
+ }
+ using X::f;
+ namespace X {
+ int f(int n = 0);
+ int f(int, int);
+ }
+ // FIXME: The first two calls here should be accepted.
+ int a = f(); // expected-error {{no matching function}}
+ int b = f(1);
+ int c = f(1, 2); // expected-error {{no matching function}}
+}
+
+// dr67: na
+
+namespace dr68 { // dr68: yes
+ template<typename T> struct X {};
+ struct ::dr68::X<int> x1;
+ struct ::dr68::template X<int> x2;
+#if __cplusplus < 201103L
+ // expected-error at -2 {{'template' keyword outside of a template}}
+#endif
+ struct Y {
+ friend struct X<int>;
+ friend struct ::dr68::X<char>;
+ friend struct ::dr68::template X<double>;
+#if __cplusplus < 201103L
+ // expected-error at -2 {{'template' keyword outside of a template}}
+#endif
+ };
+ template<typename>
+ struct Z {
+ friend struct ::dr68::template X<double>;
+ friend typename ::dr68::X<double>;
+#if __cplusplus < 201103L
+ // expected-error at -2 {{C++11 extension}}
+#endif
+ };
+}
+
+namespace dr69 { // dr69: yes
+ template<typename T> static void f() {}
+ // FIXME: Should we warn here?
+ inline void g() { f<int>(); }
+ // FIXME: This should be rejected, per [temp.explicit]p11.
+ extern template void f<char>();
+#if __cplusplus < 201103L
+ // expected-error at -2 {{C++11 extension}}
+#endif
+ template<void(*)()> struct Q {};
+ Q<&f<int> > q;
+#if __cplusplus < 201103L
+ // expected-error at -2 {{internal linkage}} expected-note at -11 {{here}}
+#endif
+}
+
+namespace dr70 { // dr70: yes
+ template<int> struct A {};
+ template<int I, int J> int f(int (&)[I + J], A<I>, A<J>);
+ int arr[7];
+ int k = f(arr, A<3>(), A<4>());
+}
+
+// dr71: na
+// dr72: dup 69
+
+#if __cplusplus >= 201103L
+namespace dr73 { // dr73: no
+ // The resolution to dr73 is unworkable. Consider:
+ int a, b;
+ static_assert(&a + 1 != &b, "");
+}
+#endif
+
+namespace dr74 { // dr74: yes
+ enum E { k = 5 };
+ int (*p)[k] = new int[k][k];
+}
+
+namespace dr75 { // dr75: yes
+ struct S {
+ static int n = 0; // expected-error {{non-const}}
+ };
+}
+
+namespace dr76 { // dr76: yes
+ const volatile int n = 1;
+ int arr[n]; // expected-error +{{variable length array}}
+}
+
+namespace dr77 { // dr77: yes
+ struct A {
+ struct B {};
+ friend struct B;
+ };
+}
+
+namespace dr78 { // dr78: sup ????
+ // Under DR78, this is valid, because 'k' has static storage duration, so is
+ // zero-initialized.
+ const int k; // expected-error {{default initialization of an object of const}}
+}
+
+// dr79: na
+
+namespace dr80 { // dr80: yes
+ struct A {
+ int A;
+ };
+ struct B {
+ static int B; // expected-error {{same name as its class}}
+ };
+ struct C {
+ int C; // expected-note {{hidden by}}
+ // FIXME: These diagnostics aren't very good.
+ C(); // expected-error {{must use 'struct' tag to refer to}} expected-error {{expected member name}}
+ };
+ struct D {
+ D();
+ int D; // expected-error {{same name as its class}}
+ };
+}
+
+// dr81: na
+// dr82: dup 48
+
+namespace dr83 { // dr83: yes
+ int &f(const char*);
+ char &f(char *);
+ int &k = f("foo");
+}
+
+namespace dr84 { // dr84: yes
+ struct B;
+ struct A { operator B() const; };
+ struct C {};
+ struct B {
+ B(B&); // expected-note {{candidate}}
+ B(C);
+ operator C() const;
+ };
+ A a;
+ // Cannot use B(C) / operator C() pair to construct the B from the B temporary
+ // here.
+ B b = a; // expected-error {{no viable}}
+}
+
+namespace dr85 { // dr85: no
+ struct A {
+ struct B;
+ struct B {};
+ // FIXME: This redeclaration is invalid. Per [class.mem]p1,
+ // "A member shall not be declared twice in the member-specification,
+ // except that a nested class [...] can be declared then later defined"
+ // This is not that case.
+ struct B;
+ };
+}
+
+// dr86: dup 446
+
+namespace dr87 { // dr87: no
+ template<typename T> struct X {};
+ // FIXME: This is invalid.
+ X<void() throw()> x;
+ // ... but this is valid.
+ X<void(void() throw())> y;
+}
+
+namespace dr88 { // dr88: yes
+ template<typename T> struct S {
+ static const int a = 1;
+ static const int b;
+ };
+ // FIXME: This diagnostic is pretty bad.
+ template<> const int S<int>::a = 4; // expected-error {{redefinition}} expected-note {{previous}}
+ template<> const int S<int>::b = 4;
+}
+
+// dr89: na
+
+namespace dr90 { // dr90: yes
+ struct A {
+ template<typename T> friend void dr90_f(T);
+ };
+ struct B : A {
+ template<typename T> friend void dr90_g(T);
+ struct C {};
+ union D {};
+ };
+ struct E : B {};
+ struct F : B::C {};
+
+ void test() {
+ dr90_f(A());
+ dr90_f(B());
+ dr90_f(B::C()); // expected-error {{undeclared identifier}}
+ dr90_f(B::D()); // expected-error {{undeclared identifier}}
+ dr90_f(E());
+ dr90_f(F()); // expected-error {{undeclared identifier}}
+
+ dr90_g(A()); // expected-error {{undeclared identifier}}
+ dr90_g(B());
+ dr90_g(B::C());
+ dr90_g(B::D());
+ dr90_g(E());
+ dr90_g(F()); // expected-error {{undeclared identifier}}
+ }
+}
+
+namespace dr91 { // dr91: yes
+ union U { friend int f(U); };
+ int k = f(U());
+}
+
+// dr93: na
+
+namespace dr94 { // dr94: yes
+ struct A { static const int n = 5; };
+ int arr[A::n];
+}
+
+namespace dr95 { // dr95: yes
+ struct A;
+ struct B;
+ namespace N {
+ class C {
+ friend struct A;
+ friend struct B;
+ static void f(); // expected-note {{here}}
+ };
+ struct A *p; // dr95::A, not dr95::N::A.
+ }
+ A *q = N::p; // ok, same type
+ struct B { void f() { N::C::f(); } }; // expected-error {{private}}
+}
+
+namespace dr96 { // dr96: no
+ struct A {
+ void f(int);
+ template<typename T> int f(T);
+ template<typename T> struct S {};
+ } a;
+ template<template<typename> class X> struct B {};
+
+ template<typename T>
+ void test() {
+ int k1 = a.template f<int>(0);
+ // FIXME: This is ill-formed, because 'f' is not a template-id and does not
+ // name a class template.
+ // FIXME: What about alias templates?
+ int k2 = a.template f(1);
+ A::template S<int> s;
+ B<A::template S> b;
+ }
+}
+
+namespace dr97 { // dr97: yes
+ struct A {
+ static const int a = false;
+ static const int b = !a;
+ };
+}
+
+namespace dr98 { // dr98: yes
+ void test(int n) {
+ switch (n) {
+ try { // expected-note 2{{bypasses}}
+ case 0: // expected-error {{protected}}
+ x:
+ throw n;
+ } catch (...) { // expected-note 2{{bypasses}}
+ case 1: // expected-error {{protected}}
+ y:
+ throw n;
+ }
+ case 2:
+ goto x; // expected-error {{protected}}
+ case 3:
+ goto y; // expected-error {{protected}}
+ }
+ }
+}
+
+namespace dr99 { // dr99: sup 214
+ template<typename T> void f(T&);
+ template<typename T> int &f(const T&);
+ const int n = 0;
+ int &r = f(n);
+}
Modified: cfe/trunk/www/cxx_dr_status.html
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/www/cxx_dr_status.html?rev=182720&r1=182719&r2=182720&view=diff
==============================================================================
--- cfe/trunk/www/cxx_dr_status.html (original)
+++ cfe/trunk/www/cxx_dr_status.html Sun May 26 17:03:53 2013
@@ -188,7 +188,7 @@
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#25">25</a></td>
<td>TC1</td>
<td>Exception specifications and pointers to members</td>
- <td class="none" align="center">No</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#26">26</a></td>
@@ -344,37 +344,37 @@
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#51">51</a></td>
<td>TC1</td>
<td>Overloading and user-defined conversions</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#52">52</a></td>
<td>TC1</td>
<td>Non-static members, member selection and access checking</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#53">53</a></td>
<td>TC1</td>
<td>Lvalue-to-rvalue conversion before certain static_casts</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#54">54</a></td>
<td>CD1</td>
<td>Static_cast from private base to derived class</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#55">55</a></td>
<td>NAD</td>
<td>Adding/subtracting pointer and enumeration value</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#56">56</a></td>
<td>TC1</td>
<td>Redeclaring typedefs within classes</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr class="open">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#57">57</a></td>
@@ -386,205 +386,205 @@
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#58">58</a></td>
<td>CD1</td>
<td>Signedness of bit fields of enum type</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#59">59</a></td>
<td>TC1</td>
<td>Clarification of overloading and UDC to reference type</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#60">60</a></td>
<td>CD1</td>
<td>Reference binding and valid conversion sequences</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#61">61</a></td>
<td>NAD</td>
<td>Address of static member function "<TT>&p->f</TT>"</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#62">62</a></td>
<td>CD1</td>
<td>Unnamed members of classes used as type parameters</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#63">63</a></td>
<td>CD1</td>
<td>Class instantiation from pointer conversion to void*, null and self</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#64">64</a></td>
<td>TC1</td>
<td>Partial ordering to disambiguate explicit specialization</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#65">65</a></td>
<td>TC1</td>
<td>Typo in default argument example</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#66">66</a></td>
<td>NAD</td>
<td>Visibility of default args vs overloads added after using-declaration</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#67">67</a></td>
<td>TC1</td>
<td>Evaluation of left side of object-expression</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#68">68</a></td>
<td>TC1</td>
<td>Grammar does not allow "friend class A<int>;"</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#69">69</a></td>
<td>TC1</td>
<td>Storage class specifiers on template declarations</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#70">70</a></td>
<td>CD1</td>
<td>Is an array bound a nondeduced context?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#71">71</a></td>
<td>NAD</td>
<td>Incorrect cross reference</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#72">72</a></td>
<td>dup</td>
<td>Linkage and storage class specifiers for templates</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Duplicate of 69</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#73">73</a></td>
<td>TC1</td>
<td>Pointer equality</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#74">74</a></td>
<td>TC1</td>
<td>Enumeration value in direct-new-declarator</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#75">75</a></td>
<td>TC1</td>
<td>In-class initialized members must be const</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#76">76</a></td>
<td>TC1</td>
<td>Are const volatile variables considered "constant expressions"?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#77">77</a></td>
<td>CD1</td>
<td>The definition of friend does not allow nested classes to be friends</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#78">78</a></td>
<td>CD1</td>
<td>Section 8.5 paragraph 9 should state it only applies to non-static objects</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">Superseded by ????</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#79">79</a></td>
<td>dup</td>
<td>Alignment and placement new</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#80">80</a></td>
<td>TC1</td>
<td>Class members with same name as class</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#81">81</a></td>
<td>NAD</td>
<td>Null pointers and C compatability</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#82">82</a></td>
<td>dup</td>
<td>Definition of "using" a constant expression</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Duplicate of 48</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#83">83</a></td>
<td>TC1</td>
<td>Overloading and deprecated conversion of string literal</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#84">84</a></td>
<td>TC1</td>
<td>Overloading and conversion loophole used by <TT>auto_ptr</TT></td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#85">85</a></td>
<td>TC1</td>
<td>Redeclaration of member class</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#86">86</a></td>
<td>CD1</td>
<td>Lifetime of temporaries in query expressions</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">Duplicate of 446</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#87">87</a></td>
<td>CD1</td>
<td>Exception specifications on function parameters</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#88">88</a></td>
<td>NAD</td>
<td>Specialization of member constant templates</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#89">89</a></td>
<td>TC1</td>
<td>Object lifetime does not account for reference rebinding</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#90">90</a></td>
<td>TC1</td>
<td>Should the enclosing class be an "associated class" too?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#91">91</a></td>
<td>NAD</td>
<td>A union's associated types should include the union itself</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr class="open">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#92">92</a></td>
@@ -596,43 +596,43 @@
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#93">93</a></td>
<td>TC1</td>
<td>Missing word in 3.8 <U>basic.life</U> paragraph 2</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#94">94</a></td>
<td>TC1</td>
<td>Inconsistencies in the descriptions of constant expressions</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#95">95</a></td>
<td>NAD</td>
<td>Elaborated type specifiers referencing names declared in friend decls</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#96">96</a></td>
<td>FDIS</td>
<td>Syntactic disambiguation using the <TT>template</TT> keyword</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#97">97</a></td>
<td>NAD</td>
<td>Use of bool constants in integral constant expressions</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#98">98</a></td>
<td>TC1</td>
<td>Branching into try block</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#99">99</a></td>
<td>NAD</td>
<td>Partial ordering, references and cv-qualifiers</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">Superseded by 214</td>
</tr>
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#100">100</a></td>
Modified: cfe/trunk/www/make_cxx_dr_status
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/www/make_cxx_dr_status?rev=182720&r1=182719&r2=182720&view=diff
==============================================================================
--- cfe/trunk/www/make_cxx_dr_status (original)
+++ cfe/trunk/www/make_cxx_dr_status Sun May 26 17:03:53 2013
@@ -34,6 +34,8 @@ def parse(dr):
status_re = re.compile(r'\bdr([0-9]+): (.*)')
status_map = {}
for test_cpp in os.listdir(dr_test_dir):
+ if not test_cpp.endswith('.cpp'):
+ continue
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()):
@@ -114,9 +116,13 @@ def availability(issue):
avail = 'N/A'
avail_style = ' class="na"'
elif status.startswith('sup '):
- dup = int(status.split(' ', 1)[1])
+ dup = status.split(' ', 1)[1]
avail = 'Superseded by %s' % dup
- _, avail_style = availability(dup)
+ try:
+ _, avail_style = availability(int(dup))
+ except:
+ print >>sys.stderr, "issue %s marked as sup %s" % (issue, dup)
+ avail_style = ' class="none"'
elif status.startswith('dup '):
dup = int(status.split(' ', 1)[1])
avail = 'Duplicate of %s' % dup
More information about the cfe-commits
mailing list