[clang] [clang][NFC] Refactor expected directives in C++ DRs 300-399 (PR #74243)
via cfe-commits
cfe-commits at lists.llvm.org
Sun Dec 3 05:52:32 PST 2023
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Vlad Serebrennikov (Endilll)
<details>
<summary>Changes</summary>
This patch continues the work started with ea5b1ef016d020c37f903d6c7d4f623be975dab8. See that commit and its corresponding PR for details.
---
Patch is 76.50 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/74243.diff
1 Files Affected:
- (modified) clang/test/CXX/drs/dr3xx.cpp (+594-345)
``````````diff
diff --git a/clang/test/CXX/drs/dr3xx.cpp b/clang/test/CXX/drs/dr3xx.cpp
index d12e0aea5f5a..b1fcf709c227 100644
--- a/clang/test/CXX/drs/dr3xx.cpp
+++ b/clang/test/CXX/drs/dr3xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++23 -verify=expected,cxx20_23,cxx23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98_20,cxx20_23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -verify=expected,cxx20-23,cxx23,since-cxx11,since-cxx17,since-cxx23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98-20,cxx20-23,since-cxx11,since-cxx17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98-17,cxx98-20,since-cxx11,since-cxx17 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98-14,cxx98-17,cxx98-20,cxx11-14,since-cxx11 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98-14,cxx98-17,cxx98-20,cxx11-14,since-cxx11 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98-14,cxx98-17,cxx98-20,cxx98 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr300 { // dr300: yes
template<typename R, typename A> void f(R (&)(A)) {}
@@ -18,50 +18,81 @@ namespace dr301 { // dr301: 3.5
void operator-(S, S);
void f() {
- bool a = (void(*)(S, S))operator+<S> < // expected-warning {{ordered comparison of function pointers}}
- (void(*)(S, S))operator+<S>;
- bool b = (void(*)(S, S))operator- < // cxx20_23-note {{to match this '<'}} cxx98_17-warning {{ordered comparison of function pointers}}
- (void(*)(S, S))operator-; // cxx20_23-error {{expected '>'}}
- bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}}
- (void(*)(S, S))operator-; // expected-error {{expected '>'}}
+ bool a = (void(*)(S, S))operator+<S> < (void(*)(S, S))operator+<S>;
+ // expected-warning at -1 {{ordered comparison of function pointers ('void (*)(S, S)' and 'void (*)(S, S)')}}
+ bool b = (void(*)(S, S))operator- < (void(*)(S, S))operator-;
+ // cxx98-17-warning at -1 {{ordered comparison of function pointers ('void (*)(S, S)' and 'void (*)(S, S)')}}
+ // cxx20-23-error at -2 {{expected '>'}}
+ // cxx20-23-note at -3 {{to match this '<'}}
+ bool c = (void(*)(S, S))operator+ < (void(*)(S, S))operator-;
+ // expected-error at -1 {{expected '>'}}
+ // expected-note at -2 {{to match this '<'}}
}
template<typename T> void f() {
- typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
+ // FIXME: We are emitting a lot of bogus diagnostics here.
+ typename T::template operator+<int> a;
+ // expected-error at -1 {{typename specifier refers to a non-type template}}
+ // expected-error at -2 {{'template' keyword not permitted here}}
+ // expected-error at -3 {{a type specifier is required for all declarations}}
+ // expected-error at -4 {{'operator+' cannot be the name of a variable or data member}}
+ // expected-error at -5 {{expected ';' at end of declaration}}
// FIXME: This shouldn't say (null).
- class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
- enum T::template operator+<int> c; // expected-error {{expected identifier}}
- enum T::template operator+<int>::E d; // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}} expected-error {{forward reference}}
+ class T::template operator+<int> b;
+ // expected-error at -1 {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
+ enum T::template operator+<int> c;
+ // expected-error at -1 {{expected identifier}}
+ enum T::template operator+<int>::E d;
+ // expected-error at -1 {{qualified name refers into a specialization of function template 'T::template operator +'}}
+ // expected-error at -2 {{ISO C++ forbids forward references to 'enum' types}}
enum T::template X<int>::E e;
- T::template operator+<int>::foobar(); // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}}
+ T::template operator+<int>::foobar();
+ // expected-error at -1 {{qualified name refers into a specialization of function template 'T::template operator +'}}
T::template operator+<int>(0); // ok
}
- template<typename T> class operator&<T*> {}; // expected-error +{{}}
- template<typename T> class T::operator& {}; // expected-error +{{}}
- template<typename T> class S::operator&<T*> {}; // expected-error +{{}}
+ // FIXME: We are emitting a bunch of bogus diagnostics for the next 3 lines.
+ // All of them do a bad job at explaining that 'class' is not allowed here.
+ template<typename T> class operator&<T*> {};
+ // expected-error at -1 {{declaration of anonymous class must be a definition}}
+ // expected-error at -2 {{declaration does not declare anything}}
+ template<typename T> class T::operator& {};
+ // expected-error at -1 {{expected identifier}}
+ // expected-error at -2 {{declaration of anonymous class must be a definition}}
+ // expected-error at -3 {{declaration does not declare anything}}
+ template<typename T> class S::operator&<T*> {};
+ // expected-error at -1 {{expected identifier}}
+ // expected-error at -2 {{declaration of anonymous class must be a definition}}
+ // expected-error at -3 {{declaration does not declare anything}}
}
namespace dr302 { // dr302: 3.0
struct A { A(); ~A(); };
#if __cplusplus < 201103L
- struct B { // expected-error {{implicit default constructor for 'dr302::B' must explicitly initialize the const member 'n'}}
- const int n; // expected-note {{declared here}}
+ struct B {
+ // expected-error at -1 {{implicit default constructor for 'dr302::B' must explicitly initialize the const member 'n'}}
+ // expected-note@#dr302-b {{in implicit default constructor for 'dr302::B' first required here}}
+ // expected-note@#dr302-B-n {{declared here}}
+ const int n; // #dr302-B-n
A a;
- } b = B(); // expected-note {{first required here}}
+ } b = B(); // #dr302-b
// Trivial default constructor C::C() is not called here.
struct C {
const int n;
} c = C();
#else
struct B {
- const int n; // expected-note {{deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
+ const int n; // #dr302-B-n
A a;
- } b = B(); // expected-error {{call to implicitly-deleted default constructor}}
+ } b = B();
+ // expected-error at -1 {{call to implicitly-deleted default constructor of 'B'}}
+ // expected-note@#dr302-B-n {{default constructor of 'B' is implicitly deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
// C::C() is called here, because even though it's trivial, it's deleted.
struct C {
- const int n; // expected-note {{deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
- } c = C(); // expected-error {{call to implicitly-deleted default constructor}}
+ const int n; // #dr302-C-n
+ } c = C();
+ // expected-error at -1 {{call to implicitly-deleted default constructor of 'C'}}
+ // expected-note@#dr302-C-n {{default constructor of 'C' is implicitly deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
struct D {
const int n = 0;
} d = D();
@@ -72,17 +103,15 @@ namespace dr302 { // dr302: 3.0
namespace dr304 { // dr304: 2.9
typedef int &a;
- int n = a(); // expected-error {{requires an initializer}}
-
- struct S { int &b; };
- int m = S().b;
-#if __cplusplus < 201103L
- // expected-error at -3 {{requires an initializer}}
- // expected-note at -3 {{in value-initialization}}
-#else
- // expected-error at -5 {{deleted}}
- // expected-note at -7 {{reference}}
-#endif
+ int n = a();
+ // expected-error at -1 {{reference to type 'int' requires an initializer}}
+
+ struct S { int &b; }; // #dr304-S
+ // cxx98-error at -1 {{reference to type 'int' requires an initializer}}
+ // cxx98-note@#dr304-m {{in value-initialization of type 'S' here}}
+ int m = S().b; // #dr304-m
+ // since-cxx11-error at -1 {{call to implicitly-deleted default constructor of 'S'}}
+ // since-cxx11-note@#dr304-S {{default constructor of 'S' is implicitly deleted because field 'b' of reference type 'int &' would not be initialized}}
}
namespace dr305 { // dr305: no
@@ -100,8 +129,10 @@ namespace dr305 { // dr305: no
b->~C();
}
void h(B *b) {
- struct B {}; // expected-note {{type 'B' found by destructor name lookup}}
- b->~B(); // expected-error {{does not match}}
+ struct B {}; // #dr305-h-B
+ b->~B();
+ // expected-error at -1 {{destructor type 'B' in object destruction expression does not match the type 'B' (aka 'dr305::A') of the object being destroyed}}
+ // expected-note@#dr305-h-B {{type 'B' found by destructor name lookup}}
}
template<typename T> struct X {};
@@ -109,7 +140,8 @@ namespace dr305 { // dr305: no
struct X {};
x->~X<int>();
x->~X();
- x->~X<char>(); // expected-error {{no member named}}
+ x->~X<char>();
+ // expected-error at -1 {{no member named '~X' in 'dr305::X<int>'}}
}
#if __cplusplus >= 201103L
@@ -125,8 +157,10 @@ namespace dr305 { // dr305: no
template<typename T> using T2 = T;
};
void k(Z *z) {
- z->~T1<int>(); // expected-error {{no member named 'T1' in 'dr305::Z'}}
- z->~T2<int>(); // expected-error {{no member named '~int'}}
+ z->~T1<int>();
+ // expected-error at -1 {{no member named 'T1' in 'dr305::Z'}}
+ z->~T2<int>();
+ // expected-error at -1 {{no member named '~int' in 'dr305::Z'}}
z->~T2<Z>();
}
@@ -135,7 +169,8 @@ namespace dr305 { // dr305: no
template<typename A> struct R {};
}
template<typename A> using R = Q::R<int>;
- void qr(Q::R<int> x) { x.~R<char>(); } // expected-error {{no member named}}
+ void qr(Q::R<int> x) { x.~R<char>(); }
+ // expected-error at -1 {{no member named '~R' in 'dr305::Q::R<int>'}}
#endif
}
@@ -145,11 +180,14 @@ namespace dr306 { // dr306: dup 39
struct D : A, A::B, C {};
D::B b;
- struct X {}; // expected-note {{member type 'dr306::X' found}}
- template<typename T> struct Y { typedef T X; }; // expected-note {{member type 'const dr306::X' found}}
+ struct X {}; // #dr306-X
+ template<typename T> struct Y { typedef T X; }; // #dr306-typedef-X
template<typename T> struct Z : X, Y<T> {};
Z<X>::X zx;
- Z<const X>::X zcx; // expected-error {{member 'X' found in multiple base classes of different types}}
+ Z<const X>::X zcx;
+ // expected-error at -1 {{member 'X' found in multiple base classes of different types}}
+ // expected-note@#dr306-X {{member type 'dr306::X' found}}
+ // expected-note@#dr306-typedef-X {{member type 'const dr306::X' found}}
}
// dr307: na
@@ -172,9 +210,11 @@ namespace dr308 { // dr308: 3.7
// positive rate should be acceptably low.
try {
throw D();
- } catch (const A&) { // expected-note {{for type 'const A &'}}
+ } catch (const A&) { // #dr308-catch-A
// unreachable
- } catch (const B&) { // expected-warning {{exception of type 'const B &' will be caught by earlier handler}}
+ } catch (const B&) {
+ // expected-warning at -1 {{exception of type 'const B &' will be caught by earlier handler}}
+ // expected-note@#dr308-catch-A {{for type 'const A &'}}
// get here instead
}
}
@@ -185,27 +225,26 @@ namespace dr308 { // dr308: 3.7
namespace dr311 { // dr311: 3.0
namespace X { namespace Y {} }
namespace X::Y {}
-#if __cplusplus <= 201402L
- // expected-error at -2 {{define each namespace separately}}
-#endif
+ // cxx98-14-error at -1 {{nested namespace definition is a C++17 extension; define each namespace separately}}
namespace X {
namespace X::Y {}
-#if __cplusplus <= 201402L
- // expected-error at -2 {{define each namespace separately}}
-#endif
+ // cxx98-14-error at -1 {{nested namespace definition is a C++17 extension; define each namespace separately}}
}
// FIXME: The diagnostics here are not very good.
- namespace ::dr311::X {} // expected-error 2+{{}} // expected-warning {{extra qual}}
+ namespace ::dr311::X {}
+ // expected-error at -1 {{expected identifier or '{'}}
+ // expected-warning at -2 {{extra qualification on member 'X'}}
+ // expected-error at -3 {{a type specifier is required for all declarations}}
+ // expected-error at -4 {{expected ';' after top level declarator}}
}
// dr312: dup 616
namespace dr313 { // dr313: dup 299 c++11
struct A { operator int() const; };
+ // FIXME: should this be available in c++98 mode?
int *p = new int[A()];
-#if __cplusplus < 201103L
- // FIXME: should this be available in c++98 mode? expected-error at -2 {{extension}}
-#endif
+ // cxx98-error at -1 {{implicit conversion from array size expression of type 'A' to integral type 'int' is a C++11 extension}}
}
namespace dr314 { // dr314: no
@@ -227,8 +266,10 @@ template <typename T> struct C2 : public A<T>::B<T> {
// dr316: sup 1004
namespace dr317 { // dr317: 3.5
- void f() {} // expected-note {{previous}}
- inline void f(); // expected-error {{inline declaration of 'f' follows non-inline definition}}
+ void f() {} // #dr317-f
+ inline void f();
+ // expected-error at -1 {{inline declaration of 'f' follows non-inline definition}}
+ // expected-note@#dr317-f {{previous definition is here}}
int g();
int n = g();
@@ -236,8 +277,10 @@ namespace dr317 { // dr317: 3.5
int h();
int m = h();
- int h() { return 0; } // expected-note {{previous}}
- inline int h(); // expected-error {{inline declaration of 'h' follows non-inline definition}}
+ int h() { return 0; } // #dr317-h
+ inline int h();
+ // expected-error at -1 {{inline declaration of 'h' follows non-inline definition}}
+ // expected-note@#dr317-h {{previous definition is here}}
}
namespace dr318 { // dr318: sup 1310
@@ -268,20 +311,18 @@ namespace dr319 { // dr319: no
struct A { int n; };
extern A a; // FIXME: ill-formed
X<A> xa;
+ // cxx98-error at -1 {{template argument uses local type 'A'}}
typedef A B;
extern B b; // FIXME: ill-formed
X<B> xb;
+ // cxx98-error at -1 {{template argument uses local type 'A'}}
const int n = 1;
typedef int (*C)[n];
extern C c; // ok
X<C> xc;
}
-#if __cplusplus < 201103L
- // expected-error at -12 {{uses local type 'A'}}
- // expected-error at -9 {{uses local type 'A'}}
-#endif
}
namespace dr320 { // dr320: yes
@@ -328,16 +369,29 @@ namespace dr322 { // dr322: 2.8
// dr323: no
namespace dr324 { // dr324: 3.6
- struct S { int n : 1; } s; // expected-note 3{{bit-field is declared here}}
- int &a = s.n; // expected-error {{non-const reference cannot bind to bit-field}}
- int *b = &s.n; // expected-error {{address of bit-field}}
- int &c = (s.n = 0); // expected-error {{non-const reference cannot bind to bit-field}}
- int *d = &(s.n = 0); // expected-error {{address of bit-field}}
- int &e = true ? s.n : s.n; // expected-error {{non-const reference cannot bind to bit-field}}
- int *f = &(true ? s.n : s.n); // expected-error {{address of bit-field}}
- int &g = (void(), s.n); // expected-error {{non-const reference cannot bind to bit-field}}
- int *h = &(void(), s.n); // expected-error {{address of bit-field}}
- int *i = &++s.n; // expected-error {{address of bit-field}}
+ struct S { int n : 1; } s; // #dr324-n
+ int &a = s.n;
+ // expected-error at -1 {{non-const reference cannot bind to bit-field 'n'}}
+ // expected-note@#dr324-n {{bit-field is declared here}}
+ int *b = &s.n;
+ // expected-error at -1 {{address of bit-field requested}}
+ int &c = (s.n = 0);
+ // expected-error at -1 {{non-const reference cannot bind to bit-field 'n'}}
+ // expected-note@#dr324-n {{bit-field is declared here}}
+ int *d = &(s.n = 0);
+ // expected-error at -1 {{address of bit-field requested}}
+ // FIXME: why don't we emit a note here, as for the rest of this type of diagnostic in this test?
+ int &e = true ? s.n : s.n;
+ // expected-error at -1 {{non-const reference cannot bind to bit-field}}
+ int *f = &(true ? s.n : s.n);
+ // expected-error at -1 {{address of bit-field requested}}
+ int &g = (void(), s.n);
+ // expected-error at -1 {{non-const reference cannot bind to bit-field 'n'}}
+ // expected-note@#dr324-n {{bit-field is declared here}}
+ int *h = &(void(), s.n);
+ // expected-error at -1 {{address of bit-field requested}}
+ int *i = &++s.n;
+ // expected-error at -1 {{address of bit-field requested}}
}
namespace dr326 { // dr326: 3.1
@@ -354,24 +408,35 @@ namespace dr327 { // dr327: dup 538
}
namespace dr328 { // dr328: yes
- struct A; // expected-note 3{{forward declaration}}
- struct B { A a; }; // expected-error {{incomplete}}
- template<typename> struct C { A a; }; // expected-error {{incomplete}}
- A *p = new A[0]; // expected-error {{incomplete}}
+ struct A; // #dr328-A
+ struct B { A a; };
+ // expected-error at -1 {{field has incomplete type 'A'}}
+ // expected-note@#dr328-A {{forward declaration of 'dr328::A'}}
+ template<typename> struct C { A a; };
+ // expected-error at -1 {{field has incomplete type 'A'}}
+ // expected-note@#dr328-A {{forward declaration of 'dr328::A'}}
+ A *p = new A[0];
+ // expected-error at -1 {{allocation of incomplete type 'A'}}
+ // expected-note@#dr328-A {{forward declaration of 'dr328::A'}}
}
namespace dr329 { // dr329: 3.5
struct B {};
template<typename T> struct A : B {
friend void f(A a) { g(a); }
- friend void h(A a) { g(a); } // expected-error {{undeclared}}
- friend void i(B b) {} // expected-error {{redefinition}} expected-note {{previous}}
+ friend void h(A a) { g(a); }
+ // expected-error at -1 {{use of undeclared identifier 'g'}}
+ // expected-note@#dr329-h-call {{in instantiation of member function 'dr329::h' requested here}}
+ friend void i(B b) {} // #dr329-i
+ // expected-error at -1 {{redefinition of 'i'}}
+ // expected-note@#dr329-b {{in instantiation of template class 'dr329::A<char>' requested here}}
+ // expected-note@#dr329-i {{previous definition is here}}
};
- A<int> a;
- A<char> b; // expected-note {{instantiation}}
+ A<int> a;
+ A<char> b; // #dr329-b
void test() {
- h(a); // expected-note {{instantiation}}
+ h(a); // #dr329-h-call
}
}
@@ -387,50 +452,60 @@ namespace dr330 { // dr330: 7
void f(P p, Q q, Q2 q2, R r, S s, T t) {
q = p; // ok
q2 = p; // ok
- r = p; // expected-error {{incompatible}}
+ r = p;
+ // expected-error at -1 {{incompatible pointer types assigning to 'R' (aka 'const int *const (*)[4]') from 'P' (aka 'int *(*)[3]')}}
s = p;
-#if __cplusplus < 202002
- // expected-error at -2 {{incompatible}} (fixed by p0388)
-#endif
- t = p; // expected-error {{incompatible}}
+ // cxx98-17-error at -1 {{incompatible pointer types assigning to 'S' (aka 'const int *const (*)[]') from 'P' (aka 'int *(*)[3]')}} (fixed by p0388)
+ t = p;
+ // expected-error at -1 {{incompatible pointer types assigning to 'T' (aka 'const int *(*)[]') from 'P' (aka 'int *(*)[3]')}}
s = q;
-#if __cplusplus < 202002
- // expected-error at -2 {{incompatible}} (fixed by p0388)
-#endif
+ // cxx98-17-error at -1 {{incompatible pointer types assigning to 'S' (aka 'const int *const (*)[]') from 'Q' (aka 'const int *cons...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/74243
More information about the cfe-commits
mailing list