r204033 - Tests for DR400-450.
Richard Smith
richard-llvm at metafoo.co.uk
Mon Mar 17 01:20:11 PDT 2014
Author: rsmith
Date: Mon Mar 17 03:20:10 2014
New Revision: 204033
URL: http://llvm.org/viewvc/llvm-project?rev=204033&view=rev
Log:
Tests for DR400-450.
Added:
cfe/trunk/test/CXX/drs/dr412.cpp
Modified:
cfe/trunk/test/CXX/drs/dr4xx.cpp
cfe/trunk/www/cxx_dr_status.html
Added: cfe/trunk/test/CXX/drs/dr412.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CXX/drs/dr412.cpp?rev=204033&view=auto
==============================================================================
--- cfe/trunk/test/CXX/drs/dr412.cpp (added)
+++ cfe/trunk/test/CXX/drs/dr412.cpp Mon Mar 17 03:20:10 2014
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT="throw()" -DBAD_ALLOC="throw(std::bad_alloc)"
+// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DNOEXCEPT=noexcept -DBAD_ALLOC=
+
+// dr412: yes
+// lwg404: yes
+// lwg2340: yes
+
+typedef __SIZE_TYPE__ size_t;
+namespace std { struct bad_alloc {}; }
+int x;
+inline void* operator new(size_t) BAD_ALLOC; // expected-error {{cannot be declared 'inline'}}
+inline void* operator new[](size_t) BAD_ALLOC; // expected-error {{cannot be declared 'inline'}}
+inline void operator delete(void*) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+inline void operator delete[](void*) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+#if __cplusplus >= 201402L
+inline void operator delete(void*, size_t) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+inline void operator delete[](void*, size_t) NOEXCEPT; // expected-error {{cannot be declared 'inline'}}
+#endif
Modified: cfe/trunk/test/CXX/drs/dr4xx.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CXX/drs/dr4xx.cpp?rev=204033&r1=204032&r2=204033&view=diff
==============================================================================
--- cfe/trunk/test/CXX/drs/dr4xx.cpp (original)
+++ cfe/trunk/test/CXX/drs/dr4xx.cpp Mon Mar 17 03:20:10 2014
@@ -2,6 +2,135 @@
// 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 dr400 { // dr400: yes
+ struct A { int a; struct a {}; }; // expected-note 2{{conflicting}} expected-note {{ambiguous}}
+ struct B { int a; struct a {}; }; // expected-note 2{{target}} expected-note {{ambiguous}}
+ struct C : A, B { using A::a; struct a b; };
+ struct D : A, B { using A::a; using B::a; struct a b; }; // expected-error 2{{conflicts}}
+ struct E : A, B { struct a b; }; // expected-error {{found in multiple base classes}}
+}
+
+namespace dr401 { // dr401: yes
+ template<class T, class U = typename T::type> class A : public T {}; // expected-error {{protected}} expected-error 2{{private}}
+
+ class B {
+ protected:
+ typedef int type; // expected-note {{protected}}
+ };
+
+ class C {
+ typedef int type; // expected-note {{private}}
+ friend class A<C>; // expected-note {{default argument}}
+ };
+
+ class D {
+ typedef int type; // expected-note {{private}}
+ friend class A<D, int>;
+ };
+
+ A<B> *b; // expected-note {{default argument}}
+ // FIXME: We're missing the "in instantiation of" note for the default
+ // argument here.
+ A<D> *d;
+
+ struct E {
+ template<class T, class U = typename T::type> class A : public T {};
+ };
+ class F {
+ typedef int type;
+ friend class E;
+ };
+ E::A<F> eaf; // ok, default argument is in befriended context
+
+ // FIXME: Why do we get different diagnostics in C++11 onwards here? We seem
+ // to not treat the default template argument as a SFINAE context in C++98.
+ template<class T, class U = typename T::type> void f(T) {}
+ void g(B b) { f(b); }
+#if __cplusplus < 201103L
+ // expected-error at -3 0-1{{extension}} expected-error at -3 {{protected}} expected-note at -3 {{instantiation}}
+ // expected-note at -3 {{substituting}}
+#else
+ // expected-error at -5 {{no matching}} expected-note at -6 {{protected}}
+#endif
+}
+
+namespace dr403 { // dr403: yes
+ namespace A {
+ struct S {};
+ int f(void*);
+ }
+ template<typename T> struct X {};
+ typedef struct X<A::S>::X XS;
+ XS *p;
+ int k = f(p); // ok, finds A::f, even though type XS is a typedef-name
+ // referring to an elaborated-type-specifier naming a
+ // injected-class-name, which is about as far from a
+ // template-id as we can make it.
+}
+
+// dr404: na
+// (NB: also sup 594)
+
+namespace dr406 { // dr406: yes
+ typedef struct {
+ static int n; // expected-error {{static data member 'n' not allowed in anonymous struct}}
+ } A;
+}
+
+namespace dr407 { // dr407: no
+ struct S;
+ typedef struct S S;
+ void f() {
+ struct S *p;
+ {
+ typedef struct S S; // expected-note {{here}}
+ struct S *p; // expected-error {{refers to a typedef}}
+ }
+ }
+ struct S {};
+
+ namespace UsingDir {
+ namespace A {
+ struct S {}; // expected-note {{found}}
+ }
+ namespace B {
+ typedef int S; // expected-note {{found}}
+ }
+ namespace C {
+ using namespace A;
+ using namespace B;
+ 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}}
+ }
+ namespace E {
+ // FIXME: The standard doesn't say whether this is valid.
+ typedef A::S S;
+ using A::S;
+ struct S s;
+ }
+ namespace F {
+ typedef A::S S; // expected-note {{here}}
+ }
+ // 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.
+ namespace G {
+ using namespace A;
+ using namespace F;
+ struct S s;
+ }
+ namespace H {
+ using namespace F;
+ using namespace A;
+ struct S s; // expected-error {{refers to a typedef}}
+ }
+ }
+}
+
namespace dr408 { // dr408: 3.4
template<int N> void g() { int arr[N != 1 ? 1 : -1]; }
template<> void g<2>() { }
@@ -31,6 +160,447 @@ namespace dr408 { // dr408: 3.4
template void R<int>::f();
}
+namespace dr409 { // dr409: yes
+ template<typename T> struct A {
+ typedef int B;
+ B b1;
+ A::B b2;
+ A<T>::B b3;
+ A<T*>::B b4; // expected-error {{missing 'typename'}}
+ };
+}
+
+namespace dr410 { // dr410: no
+ template<class T> void f(T);
+ void g(int);
+ namespace M {
+ template<class T> void h(T);
+ template<class T> void i(T);
+ struct A {
+ friend void f<>(int);
+ friend void h<>(int);
+ friend void g(int);
+ template<class T> void i(T);
+ friend void i<>(int);
+ private:
+ static void z(); // expected-note {{private}}
+ };
+
+ template<> void h(int) { A::z(); }
+ // FIXME: This should be ill-formed. The member A::i<> is befriended,
+ // not this function.
+ template<> void i(int) { A::z(); }
+ }
+ template<> void f(int) { M::A::z(); }
+ void g(int) { M::A::z(); } // expected-error {{private}}
+}
+
+// dr412 is in its own file.
+
+namespace dr413 { // dr413: yes
+ struct S {
+ int a;
+ int : 17;
+ int b;
+ };
+ S s = { 1, 2, 3 }; // expected-error {{excess elements}}
+}
+
+namespace dr414 { // dr414: dup 305
+ struct X {};
+ void f() {
+ X x;
+ struct X {};
+ x.~X();
+ }
+}
+
+namespace dr415 { // dr415: yes
+ template<typename T> void f(T, ...) { T::error; }
+ void f(int, int);
+ void g() { f(0, 0); } // ok
+}
+
+namespace dr416 { // dr416: yes
+ extern struct A a;
+ int &operator+(const A&, const A&);
+ int &k = a + a;
+ struct A { float &operator+(A&); };
+ float &f = a + a;
+}
+
+namespace dr417 { // dr417: no
+ struct A;
+ struct dr417::A {}; // expected-warning {{extra qualification}}
+ struct B { struct X; };
+ struct C : B {};
+ struct C::X {}; // expected-error {{no struct named 'X' in 'dr417::C'}}
+ struct B::X { struct Y; };
+ struct C::X::Y {}; // ok!
+ namespace N {
+ struct D;
+ struct E;
+ struct F;
+ struct H;
+ }
+ // FIXME: This is ill-formed.
+ using N::D;
+ struct dr417::D {}; // expected-warning {{extra qualification}}
+ using namespace N;
+ struct dr417::E {}; // expected-warning {{extra qualification}} expected-error {{no struct named 'E'}}
+ struct N::F {};
+ struct G;
+ using N::H;
+ namespace M {
+ struct dr417::G {}; // expected-error {{namespace 'M' does not enclose}}
+ struct dr417::H {}; // expected-error {{namespace 'M' does not enclose}}
+ }
+}
+
+namespace dr420 { // dr420: yes
+ template<typename T> struct ptr {
+ T *operator->() const;
+ T &operator*() const;
+ };
+ template<typename T, typename P> void test(P p) {
+ p->~T();
+ p->T::~T();
+ (*p).~T();
+ (*p).T::~T();
+ }
+ struct X {};
+ template void test<int>(int*);
+ template void test<int>(ptr<int>);
+ template void test<X>(X*);
+ template void test<X>(ptr<X>);
+
+ template<typename T>
+ void test2(T p) {
+ p->template Y<int>::~Y<int>();
+ p->~Y<int>();
+ // FIXME: This is ill-formed, but this diagnostic is terrible. We should
+ // reject this in the parser.
+ p->template ~Y<int>(); // expected-error 2{{no member named '~typename Y<int>'}}
+ }
+ template<typename T> struct Y {};
+ template void test2(Y<int>*); // expected-note {{instantiation}}
+ template void test2(ptr<Y<int> >); // expected-note {{instantiation}}
+
+ void test3(int *p, ptr<int> q) {
+ typedef int Int;
+ p->~Int();
+ q->~Int();
+ p->Int::~Int();
+ q->Int::~Int();
+ }
+
+#if __cplusplus >= 201103L
+ template<typename T> using id = T;
+ struct A { template<typename T> using id = T; };
+ void test4(int *p, ptr<int> q) {
+ p->~id<int>();
+ q->~id<int>();
+ p->id<int>::~id<int>();
+ q->id<int>::~id<int>();
+ p->template id<int>::~id<int>(); // expected-error {{expected unqualified-id}}
+ q->template id<int>::~id<int>(); // expected-error {{expected unqualified-id}}
+ p->A::template id<int>::~id<int>();
+ q->A::template id<int>::~id<int>();
+ }
+#endif
+}
+
+namespace dr421 { // dr421: yes
+ struct X { X(); int n; int &r; };
+ int *p = &X().n; // expected-error {{taking the address of a temporary}}
+ int *q = &X().r;
+}
+
+namespace dr422 { // dr422: yes
+ template<typename T, typename U> void f() {
+ typedef T type; // expected-note {{prev}}
+ typedef U type; // expected-error {{redef}}
+ }
+ template void f<int, int>();
+ template void f<int, char>(); // expected-note {{instantiation}}
+}
+
+namespace dr423 { // dr423: yes
+ template<typename T> struct X { operator T&(); };
+ void f(X<int> x) { x += 1; }
+}
+
+namespace dr424 { // dr424: yes
+ struct A {
+ typedef int N; // expected-note {{previous}}
+ typedef int N; // expected-error {{redefinition}}
+
+ struct X;
+ typedef X X; // expected-note {{previous}}
+ struct X {};
+
+ struct X *p;
+ struct A::X *q;
+ X *r;
+
+ typedef X X; // expected-error {{redefinition}}
+ };
+ struct B {
+ typedef int N;
+ };
+ struct C : B {
+ typedef int N; // expected-note {{previous}}
+ typedef int N; // expected-error {{redefinition}}
+ };
+}
+
+namespace dr425 { // dr425: yes
+ struct A { template<typename T> operator T() const; } a;
+ float f = 1.0f * a; // expected-error {{ambiguous}} expected-note 5+{{built-in candidate}}
+
+ template<typename T> struct is_float;
+ template<> struct is_float<float> { typedef void type; };
+
+ struct B {
+ template<typename T, typename U = typename is_float<T>::type> operator T() const; // expected-error 0-1{{extension}}
+ } b;
+ float g = 1.0f * b; // ok
+}
+
+namespace dr427 { // dr427: yes
+ struct B {};
+ struct D : public B {
+ D(B &) = delete; // expected-error 0-1{{extension}} expected-note {{deleted}}
+ };
+
+ extern D d1;
+ B &b = d1;
+ const D &d2 = static_cast<const D&>(b);
+ const D &d3 = (const D&)b;
+ const D &d4(b); // expected-error {{deleted}}
+}
+
+namespace dr428 { // dr428: yes
+ template<typename T> T make();
+ extern struct X x; // expected-note 5{{forward declaration}}
+ void f() {
+ throw void(); // expected-error {{cannot throw}}
+ throw make<void*>();
+ throw make<const volatile void*>();
+ throw x; // expected-error {{cannot throw}}
+ throw make<X&>(); // expected-error {{cannot throw}}
+ throw make<X*>(); // expected-error {{cannot throw}}
+ throw make<const volatile X&>(); // expected-error {{cannot throw}}
+ throw make<const volatile X*>(); // expected-error {{cannot throw}}
+ }
+}
+
+namespace dr429 { // dr429: yes c++11
+ // FIXME: This rule is obviously intended to apply to C++98 as well.
+ typedef __SIZE_TYPE__ size_t;
+ struct A {
+ static void *operator new(size_t, size_t);
+ static void operator delete(void*, size_t);
+ } *a = new (0) A;
+#if __cplusplus >= 201103L
+ // expected-error at -2 {{'new' expression with placement arguments refers to non-placement 'operator delete'}}
+ // expected-note at -4 {{here}}
+#endif
+ struct B {
+ static void *operator new(size_t, size_t);
+ static void operator delete(void*);
+ static void operator delete(void*, size_t);
+ } *b = new (0) B; // ok, second delete is not a non-placement deallocation function
+}
+
+namespace dr430 { // dr430: yes c++11
+ // resolved by n2239
+ // FIXME: This should apply in C++98 too.
+ void f(int n) {
+ int a[] = { n++, n++, n++ };
+#if __cplusplus < 201103L
+ // expected-warning at -2 {{multiple unsequenced modifications to 'n'}}
+#endif
+ }
+}
+
+namespace dr431 { // dr431: yes
+ struct A {
+ template<typename T> T *get();
+ template<typename T> struct B {
+ template<typename U> U *get();
+ };
+ };
+
+ template<typename T> void f(A a) {
+ a.get<A>()->get<T>();
+ a.get<T>()
+ ->get<T>(); // expected-error {{use 'template'}}
+ a.get<T>()->template get<T>();
+ a.A::get<T>();
+ A::B<int> *b = a.get<A::B<int> >();
+ b->get<int>();
+ b->A::B<int>::get<int>();
+ b->A::B<int>::get<T>();
+ b->A::B<T>::get<int>(); // expected-error {{use 'template'}}
+ b->A::B<T>::template get<int>();
+ b->A::B<T>::get<T>(); // expected-error {{use 'template'}}
+ b->A::B<T>::template get<T>();
+ A::B<T> *c = a.get<A::B<T> >();
+ c->get<int>(); // expected-error {{use 'template'}}
+ c->template get<int>();
+ }
+}
+
+namespace dr432 { // dr432: yes
+ template<typename T> struct A {};
+ template<typename T> struct B : A<B> {}; // expected-error {{requires template arguments}} expected-note {{declared}}
+ template<typename T> struct C : A<C<T> > {};
+#if __cplusplus >= 201103L
+ template<typename T> struct D : decltype(A<D>()) {}; // expected-error {{requires template arguments}} expected-note {{declared}}
+#endif
+}
+
+namespace dr433 { // dr433: yes
+ template<class T> struct S {
+ void f(union U*);
+ };
+ U *p;
+ template<class T> void S<T>::f(union U*) {}
+
+ S<int> s;
+}
+
+namespace dr434 { // dr434: yes
+ void f() {
+ const int ci = 0;
+ int *pi = 0;
+ const int *&rpci = pi; // expected-error {{cannot bind}}
+ rpci = &ci;
+ *pi = 1;
+ }
+}
+
+// dr435: na
+
+namespace dr436 { // dr436: yes
+ enum E { f }; // expected-note {{previous}}
+ void f(); // expected-error {{redefinition}}
+}
+
+namespace dr437 { // dr437: no
+ // This is superseded by 1308, which is in turn superseded by 1330,
+ // which restores this rule.
+ template<typename U> struct T : U {}; // expected-error {{incomplete}}
+ struct S { // expected-note {{not complete}}
+ void f() throw(S);
+ void g() throw(T<S>); // expected-note {{in instantiation of}}
+ struct U; // expected-note {{forward}}
+ void h() throw(U); // expected-error {{incomplete}}
+ struct U {};
+ };
+}
+
+// dr438 FIXME write a codegen test
+// dr439 FIXME write a codegen test
+// dr441 FIXME write a codegen test
+// dr442: sup 348
+// dr443: na
+
+namespace dr444 { // dr444: yes
+ struct D;
+ struct B { // expected-note {{candidate is the implicit copy}} expected-note 0-1 {{implicit move}}
+ D &operator=(D &) = delete; // expected-error 0-1{{extension}} expected-note {{deleted}}
+ };
+ struct D : B { // expected-note {{candidate is the implicit}} expected-note 0-1 {{implicit move}}
+ using B::operator=;
+ } extern d;
+ void f() {
+ d = d; // expected-error {{deleted}}
+ }
+}
+
+namespace dr445 { // dr445: yes
+ class A { void f(); }; // expected-note {{private}}
+ struct B {
+ friend void A::f(); // expected-error {{private}}
+ };
+}
+
+namespace dr446 { // dr446: yes
+ struct C;
+ struct A {
+ A();
+ A(const A&) = delete; // expected-error 0-1{{extension}} expected-note +{{deleted}}
+ A(const C&);
+ };
+ struct C : A {};
+ void f(A a, bool b, C c) {
+ void(b ? a : a);
+ b ? A() : a; // expected-error {{deleted}}
+ b ? a : A(); // expected-error {{deleted}}
+ b ? A() : A(); // expected-error {{deleted}}
+
+ void(b ? a : c);
+ b ? a : C(); // expected-error {{deleted}}
+ b ? c : A(); // expected-error {{deleted}}
+ b ? A() : C(); // expected-error {{deleted}}
+ }
+}
+
+namespace dr447 { // dr447: yes
+ struct A { int n; int a[4]; };
+ template<int> struct U {
+ typedef int type;
+ template<typename V> static void h();
+ };
+ template<typename T> U<sizeof(T)> g(T);
+ template<typename T, int N> void f(int n) {
+ // ok, not type dependent
+ g(__builtin_offsetof(A, n)).h<int>();
+ g(__builtin_offsetof(T, n)).h<int>();
+ // value dependent if first argument is a dependent type
+ U<__builtin_offsetof(A, n)>::type a;
+ U<__builtin_offsetof(T, n)>::type b; // expected-error +{{}} expected-warning 0+{{}}
+ // as an extension, we allow the member-designator to include array indices
+ g(__builtin_offsetof(A, a[0])).h<int>(); // expected-error {{extension}}
+ g(__builtin_offsetof(A, a[N])).h<int>(); // expected-error {{extension}}
+ U<__builtin_offsetof(A, a[0])>::type c; // expected-error {{extension}}
+ U<__builtin_offsetof(A, a[N])>::type d; // expected-error {{extension}} expected-error +{{}} expected-warning 0+{{}}
+ }
+}
+
+namespace dr448 { // dr448: yes
+ template<typename T = int> void f(int); // expected-error 0-1{{extension}} expected-note {{no known conversion}}
+ template<typename T> void g(T t) {
+ f<T>(t); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
+ dr448::f(t); // expected-error {{no matching function}}
+ }
+ template<typename T> void f(T); // expected-note {{should be declared prior to the call site}}
+ namespace HideFromADL { struct X {}; }
+ template void g(int); // ok
+ template void g(HideFromADL::X); // expected-note {{instantiation of}}
+}
+
+// dr449: na
+
+namespace dr450 { // dr450: yes
+ typedef int A[3];
+ void f1(const A &);
+ void f2(A &); // expected-note +{{not viable}}
+ struct S { A n; };
+ void g() {
+ f1(S().n);
+ f2(S().n); // expected-error {{no match}}}
+ }
+#if __cplusplus >= 201103L
+ void h() {
+ f1(A{});
+ f2(A{}); // expected-error {{no match}}
+ }
+#endif
+}
+
namespace dr482 { // dr482: 3.5
extern int a;
void f();
Modified: cfe/trunk/www/cxx_dr_status.html
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/www/cxx_dr_status.html?rev=204033&r1=204032&r2=204033&view=diff
==============================================================================
--- cfe/trunk/www/cxx_dr_status.html (original)
+++ cfe/trunk/www/cxx_dr_status.html Mon Mar 17 03:20:10 2014
@@ -555,7 +555,7 @@
<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">Duplicate of <a href="#446">446</a></td>
+ <td class="full" align="center">Duplicate of <a href="#446">446</a></td>
</tr>
<tr id="87">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#87">87</a></td>
@@ -2441,13 +2441,13 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#400">400</a></td>
<td>CD1</td>
<td>Using-declarations and the "struct hack"</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="401">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#401">401</a></td>
<td>CD1</td>
<td>When is access for template parameter default arguments checked?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr class="open" id="402">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#402">402</a></td>
@@ -2459,13 +2459,13 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#403">403</a></td>
<td>CD1</td>
<td>Reference to a type as a <I>template-id</I></td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="404">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#404">404</a></td>
<td>CD1</td>
<td>Unclear reference to construction with non-trivial constructor</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr class="open" id="405">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#405">405</a></td>
@@ -2477,13 +2477,13 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#406">406</a></td>
<td>CD1</td>
<td>Static data member in class with name for linkage purposes</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="407">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#407">407</a></td>
<td>C++11</td>
<td>Named class with associated typedef: two names or one?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr id="408">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#408">408</a></td>
@@ -2495,13 +2495,13 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#409">409</a></td>
<td>CD1</td>
<td>Obsolete paragraph missed by changes for issue 224</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="410">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#410">410</a></td>
<td>CD1</td>
<td>Paragraph missed in changes for issue 166</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr class="open" id="411">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#411">411</a></td>
@@ -2513,37 +2513,37 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#412">412</a></td>
<td>NAD</td>
<td>Can a replacement allocation function be inline?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="413">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#413">413</a></td>
<td>CD1</td>
<td>Definition of "empty class"</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="414">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#414">414</a></td>
<td>CD1</td>
<td>Multiple types found on destructor lookup</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Duplicate of <a href="#305">305</a></td>
</tr>
<tr id="415">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#415">415</a></td>
<td>CD1</td>
<td>Template deduction does not cause instantiation</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="416">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#416">416</a></td>
<td>CD1</td>
<td>Class must be complete to allow operator lookup?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="417">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#417">417</a></td>
<td>CD1</td>
<td>Using derived-class qualified name in out-of-class nested class definition</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr class="open" id="418">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#418">418</a></td>
@@ -2561,37 +2561,37 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#420">420</a></td>
<td>CD1</td>
<td>postfixexpression->scalar_type_dtor() inconsistent</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="421">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#421">421</a></td>
<td>CD1</td>
<td>Is rvalue.field an rvalue?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="422">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#422">422</a></td>
<td>NAD</td>
<td>Is a typedef redeclaration allowed with a template type that might be the same?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="423">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#423">423</a></td>
<td>NAD</td>
<td>Can a conversion be done on the left operand of a compound assignment?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="424">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#424">424</a></td>
<td>CD1</td>
<td>Wording problem with issue 56 resolution on redeclaring typedefs in class scope</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="425">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#425">425</a></td>
<td>CD1</td>
<td>Set of candidates for overloaded built-in operator with float operand</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr class="open" id="426">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#426">426</a></td>
@@ -2603,67 +2603,67 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#427">427</a></td>
<td>CD1</td>
<td><TT>static_cast</TT> ambiguity: conversion versus cast to derived</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="428">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#428">428</a></td>
<td>CD1</td>
<td>Mention of expression with reference type</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="429">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#429">429</a></td>
<td>CD1</td>
<td>Matching deallocation function chosen based on syntax or signature?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes (C++11 onwards)</td>
</tr>
<tr id="430">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#430">430</a></td>
<td>CD1</td>
<td>Ordering of expression evaluation in initializer list</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes (C++11 onwards)</td>
</tr>
<tr id="431">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#431">431</a></td>
<td>C++11</td>
<td>Defect in wording in 14.2</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="432">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#432">432</a></td>
<td>CD1</td>
<td>Is injected class name visible in base class specifier list?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="433">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#433">433</a></td>
<td>CD1</td>
<td>Do elaborated type specifiers in templates inject into enclosing namespace scope?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="434">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#434">434</a></td>
<td>NAD</td>
<td>Unclear suppression of standard conversions while binding reference to lvalue</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="435">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#435">435</a></td>
<td>NAD</td>
<td>Change "declararation or definition" to "declaration"</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr id="436">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#436">436</a></td>
<td>CD1</td>
<td>Problem in example in 9.6 paragraph 4</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="437">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#437">437</a></td>
<td>CD1</td>
<td>Is type of class allowed in member function exception specification?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="none" align="center">No</td>
</tr>
<tr id="438">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#438">438</a></td>
@@ -2693,55 +2693,55 @@ of class templates</td>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#442">442</a></td>
<td>CD1</td>
<td>Incorrect use of null pointer constant in description of delete operator</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">Superseded by <a href="#348">348</a></td>
</tr>
<tr id="443">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#443">443</a></td>
<td>CD1</td>
<td>Wording nit in description of lifetime of temporaries</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr id="444">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#444">444</a></td>
<td>NAD</td>
<td>Overriding and the generated copy assignment operator</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="445">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#445">445</a></td>
<td>NAD</td>
<td>Wording issue on friend declarations</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="446">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#446">446</a></td>
<td>CD1</td>
<td>Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="447">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#447">447</a></td>
<td>CD1</td>
<td>Is offsetof type-dependent?</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="448">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#448">448</a></td>
<td>C++11</td>
<td>Set of template functions in call with dependent explicit argument</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="449">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#449">449</a></td>
<td>NAD</td>
<td>Consistency in use of hyphen with names of "non" entities</td>
- <td class="none" align="center">Unknown</td>
+ <td class="na" align="center">N/A</td>
</tr>
<tr id="450">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#450">450</a></td>
<td>CD1</td>
<td>Binding a reference to const to a cv-qualified array rvalue</td>
- <td class="none" align="center">Unknown</td>
+ <td class="full" align="center">Yes</td>
</tr>
<tr id="451">
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#451">451</a></td>
More information about the cfe-commits
mailing list