r325475 - [cxx_dr_status] Tests for CWG issues 641-687.
Galina Kistanova via cfe-commits
cfe-commits at lists.llvm.org
Mon Feb 19 14:44:23 PST 2018
Hello Richard,
One of modified tests broke the next builder:
http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/8006
Failing Tests (1):
Clang :: CXX/drs/dr6xx.cpp
Please have a look?
Thanks
Galina
On Mon, Feb 19, 2018 at 1:05 AM, Richard Smith via cfe-commits <
cfe-commits at lists.llvm.org> wrote:
> Author: rsmith
> Date: Mon Feb 19 01:05:48 2018
> New Revision: 325475
>
> URL: http://llvm.org/viewvc/llvm-project?rev=325475&view=rev
> Log:
> [cxx_dr_status] Tests for CWG issues 641-687.
>
> Modified:
> cfe/trunk/test/CXX/drs/dr6xx.cpp
> cfe/trunk/www/cxx_dr_status.html
>
> Modified: cfe/trunk/test/CXX/drs/dr6xx.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CXX/
> drs/dr6xx.cpp?rev=325475&r1=325474&r2=325475&view=diff
> ============================================================
> ==================
> --- cfe/trunk/test/CXX/drs/dr6xx.cpp (original)
> +++ cfe/trunk/test/CXX/drs/dr6xx.cpp Mon Feb 19 01:05:48 2018
> @@ -1,7 +1,8 @@
> -// 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++14 %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors
> -// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors
> +// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors -fno-spell-checking
> +// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors -fno-spell-checking
> +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors -fno-spell-checking
> +// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors -fno-spell-checking
> +// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions
> -pedantic-errors -fno-spell-checking
>
> namespace std { struct type_info {}; }
>
> @@ -354,6 +355,672 @@ namespace dr639 { // dr639: yes
> }
> }
>
> +namespace dr641 { // dr641: yes
> + namespace std_example {
> + struct abc;
> +
> + struct xyz {
> + xyz(); // expected-note 0-1{{candidate}}
> + xyz(xyz &); // expected-note 0-1{{candidate}}
> +
> + operator xyz &() = delete; // expected-error 0-1{{extension}}
> expected-warning {{will never be used}}
> + operator abc &() = delete; // expected-error 0-1{{extension}}
> + };
> +
> + struct abc : xyz {};
> +
> + template<typename T>
> + void use(T &); // expected-note {{expects an l-value}}
> + void test() {
> + use<xyz>(xyz()); // expected-error {{no match}}
> + use<const xyz>(xyz());
> +#if __cplusplus < 201103L
> + // expected-error-re at -2 {{no viable constructor copying parameter
> of type '{{.*}}xyz'}}
> +#endif
> + }
> + }
> +
> + template<typename T> struct error { typedef typename T::error type; };
> +
> + struct A {
> + template<typename T, typename error<T>::type = 0> operator T() const;
> // expected-error 0-1{{extension}}
> + };
> + A a;
> + void f(A&); // expected-note 2{{candidate}}
> + void g(const A ca) {
> + f(A()); // expected-error {{no match}}
> + f(ca); // expected-error {{no match}}
> + (void)A();
> + (void)ca;
> + }
> +}
> +
> +namespace dr642 { // dr642: yes
> + void f() {
> + const int i = 2;
> + {
> + char i[i];
> + _Static_assert(sizeof(i) == 2, ""); // expected-error {{C11}}
> + }
> + }
> +
> + struct s { int a; };
> + void g(int s) {
> + struct s *p = new struct s;
> + p->a = s;
> + }
> +}
> +
> +#if __cplusplus >= 201103L
> +namespace dr643 { // dr643: yes
> + struct A {
> + int x;
> + auto f() -> decltype(this->x);
> + auto f(A &a) -> decltype(a.x);
> + auto g() -> decltype(x);
> + auto h() -> decltype(this->y); // expected-error {{no member named
> 'y'}}
> + auto h(A &a) -> decltype(a.y); // expected-error {{no member named
> 'y'}}
> + auto i() -> decltype(y); // expected-error {{undeclared identifier
> 'y'}}
> + int y;
> + };
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr644 { // dr644: partial
> + struct A {
> + A() = default;
> + int x, y;
> + };
> + static_assert(__is_literal_type(A), "");
> +
> + struct B : A {};
> + static_assert(__is_literal_type(B), "");
> +
> + struct C : virtual A {};
> + static_assert(!__is_literal_type(C), "");
> +
> + struct D { C c; };
> + static_assert(!__is_literal_type(D), "");
> +
> + // FIXME: According to DR644, E<C> is a literal type despite having
> virtual
> + // base classes. This appears to be a wording defect.
> + template<typename T>
> + struct E : T {
> + constexpr E() = default;
> + };
> + static_assert(!__is_literal_type(E<C>), "");
> +}
> +#endif
> +
> +// dr645 increases permission to optimize; it's not clear that it's
> possible to
> +// test for this.
> +// dr645: na
> +
> +#if __cplusplus >= 201103L
> +namespace dr646 { // dr646: sup 981
> + struct A {
> + constexpr A(const A&) = default; // ok
> + };
> +
> + struct B {
> + constexpr B() {}
> + B(B&);
> + };
> + constexpr B b = {}; // ok
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr647 { // dr647: yes
> + // This is partially superseded by dr1358.
> + struct A {
> + constexpr virtual void f() const;
> + constexpr virtual void g() const {} // expected-error {{virtual
> function cannot be constexpr}}
> + };
> +
> + struct X { virtual void f() const; }; // expected-note {{overridden}}
> + struct B : X {
> + constexpr void f() const {} // expected-error {{virtual function
> cannot be constexpr}}
> + };
> +
> + struct NonLiteral { NonLiteral() {} }; // expected-note {{not an
> aggregate and has no constexpr constructors}}
> +
> + struct C {
> + constexpr C(NonLiteral);
> + constexpr C(NonLiteral, int) {} // expected-error {{not a literal
> type}}
> + constexpr C() try {} catch (...) {} // expected-error {{function try
> block}}
> + };
> +
> + struct D {
> + operator int() const;
> + constexpr D(int) {}
> + D(float); // expected-note 2{{declared here}}
> + };
> + constexpr int get();
> + struct E {
> + int n;
> + D d;
> +
> + // FIXME: We should diagnose this, as the conversion function is not
> + // constexpr. However, that part of this issue is supreseded by
> dr1364 and
> + // others; no diagnostic is required for this any more.
> + constexpr E()
> + : n(D(0)),
> + d(0) {}
> +
> + constexpr E(int) // expected-error {{never produces a constant
> expression}}
> + : n(0),
> + d(0.0f) {} // expected-note {{non-constexpr constructor}}
> + constexpr E(float f) // expected-error {{never produces a constant
> expression}}
> + : n(get()),
> + d(D(0) + f) {} // expected-note {{non-constexpr constructor}}
> + };
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr648 { // dr648: yes
> + int f();
> + constexpr int a = (true ? 1 : f());
> + constexpr int b = false && f();
> + constexpr int c = true || f();
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr649 { // dr649: yes
> + alignas(0x20000000) int n; // expected-error {{requested alignment}}
> + struct alignas(0x20000000) X {}; // expected-error {{requested
> alignment}}
> + struct Y { int n alignas(0x20000000); }; // expected-error {{requested
> alignment}}
> + struct alignas(256) Z {};
> + // This part is superseded by dr2130 and eventually by aligned
> allocation support.
> + auto *p = new Z;
> +}
> +#endif
> +
> +// dr650 FIXME: add codegen test
> +
> +#if __cplusplus >= 201103L
> +namespace dr651 { // dr651: yes
> + struct X {
> + virtual X &f();
> + };
> + struct Y : X {
> + Y &f();
> + };
> + using T = decltype(((X&&)Y()).f());
> + using T = X &;
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr652 { // dr652: yes
> + constexpr int n = 1.2 * 3.4;
> + static_assert(n == 4, "");
> +}
> +#endif
> +
> +// dr653 FIXME: add codegen test
> +
> +#if __cplusplus >= 201103L
> +namespace dr654 { // dr654: yes
> + void f() {
> + if (nullptr) {} // expected-warning {{implicit conversion of nullptr
> constant to 'bool'}}
> + bool b = nullptr; // expected-warning {{implicit conversion of
> nullptr constant to 'bool'}}
> + if (nullptr == 0) {}
> + if (nullptr != 0) {}
> + if (nullptr <= 0) {} // expected-error {{invalid operands}}
> + if (nullptr == 1) {} // expected-error {{invalid operands}}
> + if (!nullptr) {} // expected-warning {{implicit conversion of nullptr
> constant to 'bool'}}
> + decltype(nullptr) n = 0;
> + static_cast<int>(nullptr); // expected-error {{not allowed}}
> + (void)static_cast<decltype(nullptr)>(0);
> + static_cast<decltype(nullptr)>(1); // expected-error {{not allowed}}
> + void(true ? nullptr : 0);
> + void(true ? 0 : nullptr);
> + }
> +}
> +#endif
> +
> +namespace dr655 { // dr655: yes
> + struct A { A(int); }; // expected-note 2-3{{not viable}}
> + struct B : A {
> + A a;
> + B();
> + B(int) : B() {} // expected-error 0-1 {{C++11}}
> + B(int*) : A() {} // expected-error {{no matching constructor}}
> + };
> +}
> +
> +namespace dr656 { // dr656: yes
> + struct A { A(const A&) = delete; }; // expected-error 0-1 {{C++11}}
> + struct B : A {};
> + struct X { operator B(); } x;
> + const A &r = x;
> + struct Y : private A { // expected-note 2{{here}} expected-note
> 2{{candidate}}
> + operator B() volatile;
> + };
> + extern Y y;
> + extern volatile Y vy;
> + // Conversion not considered due to reference-related types.
> + const A &s = y; // expected-error {{private base class}}
> + const A &t = vy; // expected-error {{drops 'volatile'}}
> +
> + struct C { operator struct D(); } c;
> + struct D : C {};
> + const D &d = c; // ok, D not reference-related to C
> +
> + template<typename T> void accept(T); // expected-note {{candidate}}
> + template<typename T> void accept(...) = delete; // expected-error 0-1
> {{C++11}} expected-note {{candidate}}
> + void f() {
> + accept<const A&>(x);
> + accept<const A&>(y); // expected-error {{private base class}}
> + accept<const A&>(vy); // expected-error {{call to deleted}}
> expected-error {{no matching constructor}}
> + accept<const D&>(c);
> + }
> +}
> +
> +namespace dr657 { // dr657: partial
> + struct Abs { virtual void x() = 0; };
> + struct Der : public Abs { virtual void x(); };
> +
> + struct Cnvt { template<typename F> Cnvt(F); };
> +
> + void foo(Cnvt a);
> + void foo(Abs &a);
> + void f(Abs *a) { foo(*a); }
> +
> + void bar(Abs &a);
> + template<typename T> void bar(T);
> + void g(Abs *a) { bar(*a); }
> +
> + // FIXME: The following examples demonstrate that we might be accepting
> the
> + // above cases for the wrong reason.
> +
> + // FIXME: We should reject this.
> + struct C { C(Abs) {} };
> + // FIXME: We should reject this.
> + struct Q { operator Abs() { __builtin_unreachable(); } } q;
> +#if __cplusplus >= 201703L
> + // FIXME: We should *definitely* reject this.
> + C c = Q().operator Abs();
> +#endif
> +
> + template<typename F> struct Cnvt2 { Cnvt2(F); typedef int type; };
> +
> + // FIXME: We should reject this.
> + void baz(Abs &a);
> + template<typename T> typename Cnvt2<T>::type baz(T);
> + void h(Abs *a) { baz(*a); }
> +
> + // FIXME: We should reject this too.
> + Cnvt2<Abs>::type err;
> +}
> +
> +// dr658 FIXME: add codegen test
> +
> +#if __cplusplus >= 201103L
> +namespace dr659 { // dr659: yes
> + static_assert(alignof(char) == alignof(char&), "");
> + static_assert(alignof(int) == alignof(int&), "");
> + int n = alignof(int(&)()); // expected-error {{application of 'alignof'
> to a function type}}
> + struct A; // expected-note {{forward}}
> + int m = alignof(A&); // expected-error {{application of 'alignof' to an
> incomplete type}}
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr660 { // dr660: yes
> + enum : int { a };
> + enum class { b }; // expected-error {{requires a name}}
> + auto x = a;
> +
> + struct X {
> + enum : int { a };
> + enum class { b }; // expected-error {{requires a name}}
> + };
> + auto y = X::a;
> +}
> +#endif
> +
> +// dr661 FIXME: add codegen test
> +
> +namespace dr662 { // dr662: yes
> + template <typename T> void f(T t) {
> + T &tr = t;
> + T *tp = &t; // expected-error {{pointer to a reference}}
> +#if __cplusplus >= 201103L
> + auto *ap = &t;
> +#endif
> + }
> + void g(int n) { f<int&>(n); } // expected-note {{instantiation of}}
> +}
> +
> +namespace dr663 { // dr663: yes c++11
> + int Ð ÐŽ = 123;
> +#if __cplusplus < 201103L
> + // expected-error at -2 {{non-ASCII}}
> +#endif
> +}
> +
> +#if __cplusplus >= 201103L
> +namespace dr664 { // dr664: yes
> + struct A { A(const A&) = delete; };
> + A &&f(A &&a, int n) {
> + if (n)
> + return f(static_cast<A&&>(a), n - 1);
> + return static_cast<A&&>(a);
> + }
> +}
> +#endif
> +
> +namespace dr665 { // dr665: yes
> + struct A { virtual ~A(); };
> + struct B : A {} *b;
> + struct C : private A {} *c; // expected-note {{here}}
> + struct D : B, C {} *d;
> +
> + struct VB : virtual A {} *vb;
> + struct VC : private virtual A {} *vc; // expected-note {{here}}
> + struct VD : VB, VC {} *vd;
> +
> + void f() {
> + (void)dynamic_cast<A*>(b);
> + (void)dynamic_cast<A*>(c); // expected-error {{private}}
> + (void)dynamic_cast<A*>(d); // expected-error {{ambiguous}}
> + (void)dynamic_cast<A*>(vb);
> + (void)dynamic_cast<A*>(vc); // expected-error {{private}}, even
> though it could be valid at runtime
> + (void)dynamic_cast<A*>(vd);
> + }
> +}
> +
> +namespace dr666 { // dr666: yes
> + struct P { friend P operator*(P, P); P(int); } p(0);
> +
> + template<int> int f();
> + template<typename T> int f() {
> + T::type *p = 0; // expected-error {{missing 'typename'}}
> + int a(T::type); // expected-error {{missing 'typename'}}
> + return f<T::type>(); // expected-error {{missing 'typename'}}
> + }
> + struct X { static const int type = 0; };
> + struct Y { typedef int type; };
> + int a = f<X>();
> + int b = f<Y>(); // expected-note {{instantiation of}}
> +}
> +
> +// Triviality is entirely different in C++98.
> +#if __cplusplus >= 201103L
> +namespace dr667 { // dr667: yes
> + struct A {
> + A() = default;
> + int &r;
> + };
> + static_assert(!__is_trivially_constructible(A), "");
> +
> + struct B { ~B() = delete; };
> + union C { B b; };
> + static_assert(!__is_trivially_destructible(C), "");
> +
> + struct D { D(const D&) = delete; };
> + struct E : D {};
> + static_assert(!__is_trivially_constructible(E, const E&), "");
> +
> + struct F { F &operator=(F&&) = delete; };
> + struct G : F {};
> + static_assert(!__is_trivially_assignable(G, G&&), "");
> +}
> +#endif
> +
> +// dr668 FIXME: add codegen test
> +
> +#if __cplusplus >= 201103L
> +namespace dr669 { // dr669: yes
> + void f() {
> + int n;
> + using T = decltype(n);
> + using T = int;
> + using U = decltype((n));
> + using U = int &;
> +
> + [=] {
> + using V = decltype(n);
> + using V = int;
> + using W = decltype((n));
> + using W = const int&;
> + } ();
> +
> + struct X {
> + int n;
> + void f() const {
> + using X = decltype(n);
> + using X = int;
> + using Y = decltype((n));
> + using Y = const int&;
> + }
> + };
> + }
> +}
> +#endif
> +
> +namespace dr671 { // dr671: yes
> + enum class E { e }; // expected-error 0-1 {{C++11}}
> + E e = static_cast<E>(0);
> + int n = static_cast<int>(E::e); // expected-error 0-1 {{C++11}}
> + int m = static_cast<int>(e); // expected-error 0-1 {{C++11}}
> +}
> +
> +// dr672 FIXME: add codegen test
> +
> +namespace dr673 { // dr673: yes
> + template<typename> struct X { static const int n = 0; };
> +
> + class A {
> + friend class B *f();
> + class C *f();
> + void f(class D *);
> + enum { e = X<struct E>::n };
> + void g() { extern struct F *p; }
> + };
> + B *b;
> + C *c;
> + D *d;
> + E *e;
> + F *f; // expected-error {{unknown type name}}
> +}
> +
> +namespace dr674 { // dr674: no
> + template<typename T> int f(T);
> +
> + int g(int);
> + template<typename T> int g(T);
> +
> + int h(int);
> + template<typename T> int h(T);
> +
> + class X {
> + // FIXME: This should deduce dr674::f<int>.
> + friend int dr674::f(int); // expected-error {{does not match any}}
> + friend int dr674::g(int);
> + friend int dr674::h<>(int);
> + int n;
> + };
> +
> + template<typename T> int f(T) { return X().n; }
> + int g(int) { return X().n; }
> + template<typename T> int g(T) { return X().n; }
> + int h(int) { return X().n; }
> + template<typename T> int h(T) { return X().n; }
> +
> + template int f(int);
> + template int g(int);
> + template int h(int);
> +}
> +
> +namespace dr675 { // dr675: dup 739
> + template<typename T> struct A { T n : 1; };
> +#if __cplusplus >= 201103L
> + static_assert(A<char>{1}.n < 0, "");
> + static_assert(A<int>{1}.n < 0, "");
> + static_assert(A<long long>{1}.n < 0, "");
> +#endif
> +}
> +
> +// dr676: na
> +
> +namespace dr677 { // dr677: no
> + struct A {
> + void *operator new(__SIZE_TYPE__);
> + void operator delete(void*) = delete; // expected-error 0-1{{C++11}}
> expected-note {{deleted}}
> + };
> + struct B {
> + void *operator new(__SIZE_TYPE__);
> + void operator delete(void*) = delete; // expected-error 0-1{{C++11}}
> expected-note 2{{deleted}}
> + virtual ~B();
> + };
> + void f(A *p) { delete p; } // expected-error {{deleted}}
> + // FIXME: This appears to be valid; we shouldn't even be looking up the
> 'operator delete' here.
> + void f(B *p) { delete p; } // expected-error {{deleted}}
> + B::~B() {} // expected-error {{deleted}}
> +}
> +
> +// dr678 FIXME: check that the modules ODR check catches this
> +
> +namespace dr679 { // dr679: yes
> + struct X {};
> + template<int> void operator+(X, X);
> + template<> void operator+<0>(X, X) {} // expected-note {{previous}}
> + template<> void operator+<0>(X, X) {} // expected-error {{redefinition}}
> +}
> +
> +// dr680: na
> +
> +#if __cplusplus >= 201103L
> +namespace dr681 { // dr681: partial
> + auto *a() -> int; // expected-error {{must specify return type 'auto',
> not 'auto *'}}
> + auto (*b)() -> int;
> + // FIXME: The errors here aren't great.
> + auto (*c()) -> int; // expected-error {{expected function body}}
> + auto ((*d)()) -> int; // expected-error {{expected ';'}} expected-error
> {{requires an initializer}}
> +
> + // FIXME: This is definitely wrong. This should be
> + // "function of () returning pointer to function of () returning int"
> + // not a function with a deduced return type.
> + auto (*e())() -> int; // expected-error 0-1{{C++14}}
> +
> + auto f() -> int (*)();
> + auto g() -> auto (*)() -> int;
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr683 { // dr683: yes
> + struct A {
> + A() = default;
> + A(const A&) = default;
> + A(A&);
> + };
> + static_assert(__is_trivially_constructible(A, const A&), "");
> + static_assert(!__is_trivially_constructible(A, A&), "");
> + static_assert(!__is_trivial(A), "");
> +
> + struct B : A {};
> + static_assert(__is_trivially_constructible(B, const B&), "");
> + static_assert(__is_trivially_constructible(B, B&), "");
> + static_assert(__is_trivial(B), "");
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr684 { // dr684: sup 1454
> + void f() {
> + int a; // expected-note {{here}}
> + constexpr int *p = &a; // expected-error {{constant expression}}
> expected-note {{pointer to 'a'}}
> + }
> +}
> +#endif
> +
> +#if __cplusplus >= 201103L
> +namespace dr685 { // dr685: yes
> + enum E : long { e };
> + void f(int);
> + int f(long);
> + int a = f(e);
> +
> + enum G : short { g };
> + int h(short);
> + void h(long);
> + int b = h(g);
> +
> + int i(int);
> + void i(long);
> + int c = i(g);
> +
> + int j(unsigned int); // expected-note {{candidate}}
> + void j(long); // expected-note {{candidate}}
> + int d = j(g); // expected-error {{ambiguous}}
> +
> + int k(short); // expected-note {{candidate}}
> + void k(int); // expected-note {{candidate}}
> + int x = k(g); // expected-error {{ambiguous}}
> +}
> +#endif
> +
> +namespace dr686 { // dr686: yes
> + void f() {
> + (void)dynamic_cast<struct A*>(0); // expected-error {{incomplete}}
> expected-note {{forward}}
> + (void)dynamic_cast<struct A{}*>(0); // expected-error {{cannot be
> defined in a type specifier}}
> + (void)typeid(struct B*);
> + (void)typeid(struct B{}*); // expected-error {{cannot be defined in a
> type specifier}}
> + (void)static_cast<struct C*>(0);
> + (void)static_cast<struct C{}*>(0); // expected-error {{cannot be
> defined in a type specifier}}
> + (void)reinterpret_cast<struct D*>(0);
> + (void)reinterpret_cast<struct D{}*>(0); // expected-error {{cannot be
> defined in a type specifier}}
> + (void)const_cast<struct E*>(0); // expected-error {{not allowed}}
> + (void)const_cast<struct E{}*>(0); // expected-error {{cannot be
> defined in a type specifier}}
> + (void)sizeof(struct F*);
> + (void)sizeof(struct F{}*); // expected-error {{cannot be defined in a
> type specifier}}
> + (void)new struct G*;
> + (void)new struct G{}*; // expected-error {{cannot be defined in a
> type specifier}}
> +#if __cplusplus >= 201103L
> + (void)alignof(struct H*);
> + (void)alignof(struct H{}*); // expected-error {{cannot be defined in
> a type specifier}}
> +#endif
> + (void)(struct I*)0;
> + (void)(struct I{}*)0; // expected-error {{cannot be defined in a type
> specifier}}
> + if (struct J *p = 0) {}
> + if (struct J {} *p = 0) {} // expected-error {{cannot be defined in a
> condition}}
> + for (struct K *p = 0; struct L *q = 0; ) {}
> + for (struct K {} *p = 0; struct L {} *q = 0; ) {} // expected-error
> {{'L' cannot be defined in a condition}}
> +#if __cplusplus >= 201103L
> + using M = struct {};
> +#endif
> + struct N {
> + operator struct O{}(){}; // expected-error {{cannot be defined in a
> type specifier}}
> + };
> + try {}
> + catch (struct P *) {} // expected-error {{incomplete}} expected-note
> {{forward}}
> + catch (struct P {} *) {} // expected-error {{cannot be defined in a
> type specifier}}
> +#if __cplusplus < 201703L
> + void g() throw(struct Q); // expected-error {{incomplete}}
> expected-note {{forward}}
> + void h() throw(struct Q {}); // expected-error {{cannot be defined in
> a type specifier}}
> +#endif
> + }
> + template<struct R *> struct X;
> + template<struct R {} *> struct Y; // expected-error {{cannot be defined
> in a type specifier}}
> +}
> +
> +namespace dr687 { // dr687 still open
> + template<typename T> void f(T a) {
> + // FIXME: This is valid in C++20.
> + g<int>(a); // expected-error {{undeclared}} expected-error {{'('}}
> +
> + // This is not.
> + template g<int>(a); // expected-error {{expected expression}}
> + }
> +}
> +
> namespace dr692 { // dr692: no
> namespace temp_func_order_example2 {
> template <typename T, typename U> struct A {};
>
> Modified: cfe/trunk/www/cxx_dr_status.html
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/www/cxx_dr_
> status.html?rev=325475&r1=325474&r2=325475&view=diff
> ============================================================
> ==================
> --- cfe/trunk/www/cxx_dr_status.html (original)
> +++ cfe/trunk/www/cxx_dr_status.html Mon Feb 19 01:05:48 2018
> @@ -3889,55 +3889,55 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#641">641</a></td>
> <td>CD2</td>
> <td>Overload resolution and conversion-to-same-type operators</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="642">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#642">642</a></td>
> <td>CD2</td>
> <td>Definition and use of “block scope” and “local
> scope”</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="643">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#643">643</a></td>
> <td>NAD</td>
> <td>Use of <TT>decltype</TT> in a class <I>member-specification</I></
> td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="644">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#644">644</a></td>
> <td>CD1</td>
> <td>Should a trivial class type be a literal type?</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="partial" align="center">Partial</td>
> </tr>
> <tr id="645">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#645">645</a></td>
> <td>CD2</td>
> <td>Are bit-field and non-bit-field members layout compatible?</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="na" align="center">N/A</td>
> </tr>
> <tr id="646">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#646">646</a></td>
> <td>NAD</td>
> <td>Can a class with a constexpr copy constructor be a literal
> type?</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="none" align="center">Superseded by <a
> href="#981">981</a></td>
> </tr>
> <tr id="647">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#647">647</a></td>
> <td>CD1</td>
> <td>Non-constexpr instances of constexpr constructor templates</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="648">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#648">648</a></td>
> <td>CD1</td>
> <td>Constant expressions in constexpr initializers</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="649">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#649">649</a></td>
> <td>CD1</td>
> <td>Optionally ill-formed extended alignment requests</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="650">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#650">650</a></td>
> @@ -3949,13 +3949,13 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#651">651</a></td>
> <td>CD1</td>
> <td>Problems in <TT>decltype</TT> specification and examples</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="652">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#652">652</a></td>
> <td>CD2</td>
> <td>Compile-time evaluation of floating-point expressions</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="653">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#653">653</a></td>
> @@ -3967,25 +3967,25 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#654">654</a></td>
> <td>CD1</td>
> <td>Conversions to and from <TT>nullptr_t</TT></td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="655">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#655">655</a></td>
> <td>C++11</td>
> <td>Initialization not specified for forwarding constructors</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="656">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#656">656</a></td>
> <td>CD2</td>
> <td>Direct binding to the result of a conversion operator</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="657">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#657">657</a></td>
> <td>CD2</td>
> <td>Abstract class parameter in synthesized declaration</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="partial" align="center">Partial</td>
> </tr>
> <tr id="658">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#658">658</a></td>
> @@ -3997,13 +3997,13 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#659">659</a></td>
> <td>CD1</td>
> <td>Alignment of function types</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="660">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#660">660</a></td>
> <td>CD1</td>
> <td>Unnamed scoped enumerations</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="661">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#661">661</a></td>
> @@ -4015,37 +4015,37 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#662">662</a></td>
> <td>NAD</td>
> <td>Forming a pointer to a reference type</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="663">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#663">663</a></td>
> <td>CD1</td>
> <td>Valid Cyrillic identifier characters</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes (C++11 onwards)</td>
> </tr>
> <tr id="664">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#664">664</a></td>
> <td>CD2</td>
> <td>Direct binding of references to non-class rvalue references</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="665">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#665">665</a></td>
> <td>CD2</td>
> <td>Problems in the specification of <TT>dynamic_cast</TT></td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="666">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#666">666</a></td>
> <td>CD1</td>
> <td>Dependent <I>qualified-id</I>s without the <TT>typename</TT>
> keyword</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="667">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#667">667</a></td>
> <td>CD2</td>
> <td>Trivial special member functions that cannot be implicitly
> defined</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="668">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#668">668</a></td>
> @@ -4057,7 +4057,7 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#669">669</a></td>
> <td>NAD</td>
> <td>Confusing specification of the meaning of <TT>decltype</TT></td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr class="open" id="670">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> active.html#670">670</a></td>
> @@ -4069,7 +4069,7 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#671">671</a></td>
> <td>CD1</td>
> <td>Explicit conversion from a scoped enumeration type to integral
> type</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="672">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#672">672</a></td>
> @@ -4081,31 +4081,31 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#673">673</a></td>
> <td>NAD</td>
> <td>Injection of names from <I>elaborated-type-specifier</I>s in
> <TT>friend</TT> declarations</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="674">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#674">674</a></td>
> <td>C++11</td>
> <td>“matching specialization” for a friend
> declaration</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="none" align="center">No</td>
> </tr>
> <tr id="675">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#675">675</a></td>
> <td>CD3</td>
> <td>Signedness of bit-field with typedef or template parameter
> type</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="none" align="center">Duplicate of <a
> href="#739">739</a></td>
> </tr>
> <tr id="676">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#676">676</a></td>
> <td>C++11</td>
> <td><I>static_assert-declaration</I>s and general requirements for
> declarations</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="na" align="center">N/A</td>
> </tr>
> <tr id="677">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#677">677</a></td>
> <td>CD1</td>
> <td>Deleted <TT>operator delete</TT> and virtual destructors</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="none" align="center">No</td>
> </tr>
> <tr id="678">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#678">678</a></td>
> @@ -4117,19 +4117,19 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#679">679</a></td>
> <td>CD1</td>
> <td>Equivalence of <I>template-id</I>s and operator function
> templates</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="680">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#680">680</a></td>
> <td>CD2</td>
> <td>What is a move constructor?</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="na" align="center">N/A</td>
> </tr>
> <tr id="681">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#681">681</a></td>
> <td>CD1</td>
> <td>Restrictions on declarators with late-specified return types</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="partial" align="center">Partial</td>
> </tr>
> <tr class="open" id="682">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> active.html#682">682</a></td>
> @@ -4141,25 +4141,25 @@ and <I>POD class</I></td>
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#683">683</a></td>
> <td>CD1</td>
> <td>Requirements for trivial subobject special functions</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="684">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#684">684</a></td>
> <td>CD1</td>
> <td>Constant expressions involving the address of an automatic
> variable</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="none" align="center">Superseded by <a
> href="#1454">1454</a></td>
> </tr>
> <tr id="685">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#685">685</a></td>
> <td>CD2</td>
> <td>Integral promotion of enumeration ignores fixed underlying
> type</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr id="686">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> defects.html#686">686</a></td>
> <td>CD1</td>
> <td>Type declarations/definitions in <I>type-specifier-seq</I>s and
> <I>type-id</I>s</td>
> - <td class="none" align="center">Unknown</td>
> + <td class="full" align="center">Yes</td>
> </tr>
> <tr class="open" id="687">
> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_
> closed.html#687">687</a></td>
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180219/149229e4/attachment-0001.html>
More information about the cfe-commits
mailing list