[clang] [clang][NFC] Refactor expected directives in C++ DRs 500-599 (PR #74373)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Dec 4 13:44:47 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 47.59 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/74373.diff
1 Files Affected:
- (modified) clang/test/CXX/drs/dr5xx.cpp (+361-234)
``````````diff
diff --git a/clang/test/CXX/drs/dr5xx.cpp b/clang/test/CXX/drs/dr5xx.cpp
index 204d07f04f4e5..21a6646d4abcf 100644
--- a/clang/test/CXX/drs/dr5xx.cpp
+++ b/clang/test/CXX/drs/dr5xx.cpp
@@ -1,20 +1,21 @@
-// 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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98-11,cxx98-14,cxx98-17,cxx98 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx98-11,cxx98-14,cxx98-17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,cxx98-14,cxx98-17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx17,cxx98-17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx23,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
// FIXME: This is included to avoid a diagnostic with no source location
// pointing at the implicit operator new. We can't match such a diagnostic
// with -verify.
__extension__ typedef __SIZE_TYPE__ size_t;
-void *operator new(size_t); // expected-error 0-1{{missing exception spec}} expected-note{{candidate}}
+void *operator new(size_t); // #dr5xx-global-operator-new
+// cxx98-error at -1 {{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
#if __cplusplus > 201402L
namespace std {
enum class align_val_t : size_t {};
}
-void *operator new(size_t, std::align_val_t); // expected-note{{candidate}}
+void *operator new(size_t, std::align_val_t); // #dr5xx-global-operator-new-aligned
#endif
namespace dr500 { // dr500: dup 372
@@ -33,7 +34,8 @@ namespace dr501 { // dr501: yes
struct A {
friend void f() {}
void g() {
- void (*p)() = &f; // expected-error {{undeclared identifier}}
+ void (*p)() = &f;
+ // expected-error at -1 {{use of undeclared identifier 'f'}}
}
};
}
@@ -45,7 +47,8 @@ namespace dr502 { // dr502: yes
void q1() { f(e); }
void q2() { Q arr[sizeof(E)]; f(arr); }
void q3() { Q arr[e]; f(arr); }
- void sanity() { Q arr[1]; f(arr); } // expected-error {{undeclared identifier 'f'}}
+ void sanity() { Q arr[1]; f(arr); }
+ // expected-error at -1 {{use of undeclared identifier 'f'}}
};
int f(A<int>::E);
template<int N> int f(Q (&)[N]);
@@ -53,14 +56,22 @@ namespace dr502 { // dr502: yes
}
namespace dr505 { // dr505: yes
- const char *exts = "\e\(\{\[\%"; // expected-error 5{{use of non-standard escape}}
- const char *unknown = "\Q"; // expected-error {{unknown escape sequence}}
+ const char *exts = "\e\(\{\[\%";
+ // expected-error at -1 {{use of non-standard escape character '\e'}}
+ // expected-error at -2 {{use of non-standard escape character '\('}}
+ // expected-error at -3 {{use of non-standard escape character '\{'}}
+ // expected-error at -4 {{use of non-standard escape character '\['}}
+ // expected-error at -5 {{use of non-standard escape character '\%'}}
+ const char *unknown = "\Q";
+ // expected-error at -1 {{unknown escape sequence '\Q'}}
}
namespace dr506 { // dr506: yes
struct NonPod { ~NonPod(); };
void f(...);
- void g(NonPod np) { f(np); } // expected-error {{cannot pass}}
+ void g(NonPod np) { f(np); }
+ // cxx98-error at -1 {{cannot pass object of non-POD type 'NonPod' through variadic function; call will abort at runtime}}
+ // since-cxx11-error at -2 {{cannot pass object of non-trivial type 'NonPod' through variadic function; call will abort at runtime}}
}
// FIXME: Add tests here once DR260 is resolved.
@@ -71,15 +82,13 @@ namespace dr506 { // dr506: yes
// dr510: na
namespace dr512 { // dr512: yes
- struct A {
- A(int);
+ struct A { // #dr512-A
+ A(int); // #dr512-A-ctor
};
union U { A a; };
-#if __cplusplus < 201103L
- // expected-error at -2 {{has a non-trivial default constructor}}
- // expected-note at -6 {{no default constructor}}
- // expected-note at -6 {{suppressed by user-declared constructor}}
-#endif
+ // cxx98-error at -1 {{union member 'a' has a non-trivial default constructor}}
+ // cxx98-note@#dr512-A {{because type 'dr512::A' has no default constructor}}
+ // cxx98-note@#dr512-A-ctor {{implicit default constructor suppressed by user-declared constructor}}
}
// dr513: na
@@ -101,9 +110,7 @@ namespace dr515 { // dr515: sup 1017
struct A { int a; };
struct B { void f() { int k = sizeof(A::a); } };
-#if __cplusplus < 201103L
- // expected-error at -2 {{invalid use of non-static data member}}
-#endif
+ // cxx98-error at -1 {{invalid use of non-static data member 'a'}}
}
// dr516: na
@@ -111,7 +118,8 @@ namespace dr515 { // dr515: sup 1017
namespace dr517 { // dr517: no
// This is NDR, but we should diagnose it anyway.
template<typename T> struct S {};
- template<typename T> int v = 0; // expected-error 0-1{{extension}}
+ template<typename T> int v = 0;
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
template struct S<int*>;
template int v<int*>;
@@ -121,18 +129,16 @@ namespace dr517 { // dr517: no
// FIXME: These are both ill-formed.
template<typename T> struct S<T*> {};
- template<typename T> int v<T*> = 0; // expected-error 0-1{{extension}}
+ template<typename T> int v<T*> = 0;
// FIXME: These are both ill-formed.
template<typename T> struct S<T&> {};
- template<typename T> int v<T&> = 0; // expected-error 0-1{{extension}}
+ template<typename T> int v<T&> = 0;
}
namespace dr518 { // dr518: yes c++11
enum E { e, };
-#if __cplusplus < 201103L
- // expected-error at -2 {{C++11 extension}}
-#endif
+ // cxx98-error at -1 {{commas at the end of enumerator lists are a C++11 extension}}
}
namespace dr519 { // dr519: yes
@@ -156,7 +162,7 @@ namespace dr522 { // dr522: yes
template<typename T> void b2(volatile T * const *);
template<typename T> void b2(volatile T * const S::*);
template<typename T> void b2(volatile T * const S::* const *);
- template<typename T> void b2a(volatile T *S::* const *); // expected-note {{candidate template ignored: deduced type 'volatile int *dr522::S::*const *' of 1st parameter does not match adjusted type 'int *dr522::S::**' of argument}}
+ template<typename T> void b2a(volatile T *S::* const *); // #dr522-b2a
template<typename T> struct Base {};
struct Derived : Base<int> {};
@@ -174,22 +180,27 @@ namespace dr522 { // dr522: yes
b2(pm);
b2(a);
b2(am);
- b2a(am); // expected-error {{no matching function}}
+ b2a(am);
+ // expected-error at -1 {{no matching function for call to 'b2a'}}
+ // expected-note@#dr522-b2a {{candidate template ignored: deduced type 'volatile int *dr522::S::*const *' of 1st parameter does not match adjusted type 'int *dr522::S::**' of argument}}
b3(d);
b3(cd);
}
}
namespace dr524 { // dr524: yes
- template<typename T> void f(T a, T b) { operator+(a, b); } // expected-error {{call}}
+ template<typename T> void f(T a, T b) { operator+(a, b); }
+ // expected-error at -1 {{call to function 'operator+' that is neither visible in the template definition nor found by argument-dependent lookup}}
+ // expected-note@#dr524-f-N-S {{in instantiation of function template specialization 'dr524::f<dr524::N::S>' requested here}}
+ // expected-note@#dr524-operator-plus {{'operator+' should be declared prior to the call site or in namespace 'dr524::N'}}
struct S {};
void operator+(S, S);
template void f(S, S);
namespace N { struct S {}; }
- void operator+(N::S, N::S); // expected-note {{should be declared}}
- template void f(N::S, N::S); // expected-note {{instantiation}}
+ void operator+(N::S, N::S); // #dr524-operator-plus
+ template void f(N::S, N::S); // #dr524-f-N-S
}
namespace dr525 { // dr525: yes
@@ -202,9 +213,11 @@ namespace dr525 { // dr525: yes
}
}
namespace after {
- template <class T> struct D { typename T::error e; }; // expected-error {{prior to '::'}}
+ template <class T> struct D { typename T::error e; };
+ // expected-error at -1 {{type 'double' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr525-ppp {{in instantiation of template class 'dr525::after::D<double>' requested here}}
void g(D<double> *ppp) {
- delete ppp; // expected-note {{instantiation of}}
+ delete ppp; // #dr525-ppp
}
}
}
@@ -212,30 +225,36 @@ namespace dr525 { // dr525: yes
namespace dr526 { // dr526: yes
template<int> struct S {};
template<int N> void f1(S<N> s);
- template<int N> void f2(S<(N)> s); // expected-note {{couldn't infer}}
- template<int N> void f3(S<+N> s); // expected-note {{couldn't infer}}
+ template<int N> void f2(S<(N)> s); // #dr526-f2
+ template<int N> void f3(S<+N> s); // #dr526-f3
template<int N> void g1(int (&)[N]);
- template<int N> void g2(int (&)[(N)]); // expected-note {{couldn't infer}}
- template<int N> void g3(int (&)[+N]); // expected-note {{couldn't infer}}
+ template<int N> void g2(int (&)[(N)]); // #dr526-g2
+ template<int N> void g3(int (&)[+N]); // #dr526-g3
void test(int (&a)[3], S<3> s) {
f1(s);
- f2(s); // expected-error {{no matching}}
- f3(s); // expected-error {{no matching}}
+ f2(s);
+ // expected-error at -1 {{no matching function for call to 'f2'}}
+ // expected-note@#dr526-f2 {{candidate template ignored: couldn't infer template argument 'N'}}
+ f3(s);
+ // expected-error at -1 {{no matching function for call to 'f3'}}
+ // expected-note@#dr526-f3 {{candidate template ignored: couldn't infer template argument 'N'}}
g1(a);
- g2(a); // expected-error {{no matching}}
- g3(a); // expected-error {{no matching}}
+ g2(a);
+ // expected-error at -1 {{no matching function for call to 'g2'}}
+ // expected-note@#dr526-g2 {{candidate template ignored: couldn't infer template argument 'N'}}
+ g3(a);
+ // expected-error at -1 {{no matching function for call to 'g3'}}
+ // expected-note@#dr526-g3 {{candidate template ignored: couldn't infer template argument 'N'}}
}
template<int N> struct X {
typedef int type;
X<N>::type v1;
X<(N)>::type v2;
+ // cxx98-17-error at -1 {{missing 'typename' prior to dependent type name X<(N)>::type; implicit 'typename' is a C++20 extension}}
X<+N>::type v3;
-#if __cplusplus <= 201703L
- // expected-error at -3 {{implicit 'typename' is a C++20 extension}}
- // expected-error at -3 {{implicit 'typename' is a C++20 extension}}
-#endif
+ // cxx98-17-error at -1 {{missing 'typename' prior to dependent type name X<+N>::type; implicit 'typename' is a C++20 extension}}
};
}
@@ -307,32 +326,48 @@ namespace dr531 { // dr531: partial
void f(T) { T::error; }
template<typename U> void g(T, U) { T::error; }
struct B { typename T::error error; };
- template<typename U> struct C { typename T::error error; }; // expected-note {{here}}
+ template<typename U> struct C { typename T::error error; }; // #dr531-C
static T n;
};
template<typename T> T A<T>::n = T::error;
- void A<int>::f(int) {} // expected-error {{requires 'template<>'}}
- template<typename U> void A<int>::g(int, U) {} // expected-error {{should be empty}}
- struct A<int>::B {}; // expected-error {{requires 'template<>'}}
- template<typename U> struct A<int>::C {}; // expected-error {{should be empty}} expected-error {{different kind of symbol}}
- int A<int>::n = 0; // expected-error {{requires 'template<>'}}
-
- template<> struct A<char> { // expected-note 2{{here}}
+ void A<int>::f(int) {}
+ // expected-error at -1 {{template specialization requires 'template<>'}}
+ template<typename U> void A<int>::g(int, U) {}
+ // expected-error at -1 {{template parameter list matching the non-templated nested type 'dr531::bad::A<int>' should be empty}}
+ struct A<int>::B {};
+ // expected-error at -1 {{template specialization requires 'template<>'}}
+ template<typename U> struct A<int>::C {};
+ // expected-error at -1 {{template parameter list matching the non-templated nested type 'dr531::bad::A<int>' should be empty}}
+ // expected-error at -2 {{redefinition of 'C' as different kind of symbol}}
+ // expected-note@#dr531-C {{previous definition is here}}
+ int A<int>::n = 0;
+ // expected-error at -1 {{template specialization requires 'template<>'}}
+
+ template<> struct A<char> { // #dr531-A-char
void f(char);
template<typename U> void g(char, U);
- struct B; // expected-note {{here}}
+ struct B; // #dr531-B
template<typename U> struct C;
static char n;
};
- template<> void A<char>::f(char) {} // expected-error {{no function template matches}}
+ template<> void A<char>::f(char) {}
+ // expected-error at -1 {{no function template matches function template specialization 'f'}}
// FIXME: This is ill-formed; -pedantic-errors should reject.
- template<> template<typename U> void A<char>::g(char, U) {} // expected-warning {{extraneous template parameter list}}
- template<> struct A<char>::B {}; // expected-error {{extraneous 'template<>'}} expected-error {{does not specialize}}
+ template<> template<typename U> void A<char>::g(char, U) {}
+ // expected-warning at -1 {{extraneous template parameter list in template specialization}}
+ // expected-note@#dr531-A-char {{'template<>' header not required for explicitly-specialized class 'dr531::bad::A<char>' declared here}}
+ template<> struct A<char>::B {};
+ // expected-error at -1 {{extraneous 'template<>' in declaration of struct 'B'}}
+ // expected-error at -2 {{specialization of member 'dr531::bad::A<char>::B' does not specialize an instantiated member}}
+ // expected-note@#dr531-B {{attempt to specialize declaration here}}
// FIXME: This is ill-formed; -pedantic-errors should reject.
- template<> template<typename U> struct A<char>::C {}; // expected-warning {{extraneous template parameter list}}
- template<> char A<char>::n = 0; // expected-error {{extraneous 'template<>'}}
+ template<> template<typename U> struct A<char>::C {};
+ // expected-warning at -1 {{extraneous template parameter list in template specialization}}
+ // expected-note@#dr531-A-char {{'template<>' header not required for explicitly-specialized class 'dr531::bad::A<char>' declared here}}
+ template<> char A<char>::n = 0;
+ // expected-error at -1 {{extraneous 'template<>' in declaration of variable 'n'}}
}
namespace nested {
@@ -346,10 +381,12 @@ namespace dr531 { // dr531: partial
template<typename V> void i();
};
template<> template<typename U> void A<int>::B<U>::f() {}
- template<typename U> void A<int>::B<U>::g() {} // expected-error {{should be empty}}
+ template<typename U> void A<int>::B<U>::g() {}
+ // expected-error at -1 {{template parameter list matching the non-templated nested type 'dr531::nested::A<int>' should be empty ('template<>')}}
template<> template<typename U> template<typename V> void A<int>::B<U>::h() {}
- template<typename U> template<typename V> void A<int>::B<U>::i() {} // expected-error {{should be empty}}
+ template<typename U> template<typename V> void A<int>::B<U>::i() {}
+ // expected-error at -1 {{template parameter list matching the non-templated nested type 'dr531::nested::A<int>' should be empty ('template<>')}}
#if __cplusplus <= 201703L
// FIXME: All of those declarations shouldn't crash in C++20 mode.
@@ -357,8 +394,10 @@ namespace dr531 { // dr531: partial
template<> template<> template<typename V> void A<int>::B<int>::h() {}
template<> template<> template<> void A<int>::B<int>::h<int>() {}
- template<> void A<int>::B<char>::f() {} // expected-error {{requires 'template<>'}}
- template<> template<typename V> void A<int>::B<char>::h() {} // expected-error {{should be empty}}
+ template<> void A<int>::B<char>::f() {}
+ // cxx98-17-error at -1 {{template specialization requires 'template<>'}}
+ template<> template<typename V> void A<int>::B<char>::h() {}
+ // cxx98-17-error at -1 {{template parameter list matching the non-templated nested type 'dr531::nested::A<int>::B<char>' should be empty ('template<>')}}
#endif
}
}
@@ -384,7 +423,8 @@ namespace dr532 { // dr532: 3.5
namespace dr534 { // dr534: 2.9
struct S {};
template<typename T> void operator+(S, T);
- template<typename T> void operator+<T*>(S, T*) {} // expected-error {{function template partial spec}}
+ template<typename T> void operator+<T*>(S, T*) {}
+ // expected-error at -1 {{function template partial specialization is not allowed}}
}
namespace dr535 { // dr535: yes
@@ -423,43 +463,70 @@ namespace dr535 { // dr535: yes
// dr538: na
// dr539: yes
-const dr539( // expected-error {{a type specifier is required}}
- const a) { // expected-error {{unknown type name 'a'}}
- const b; // expected-error {{a type specifier is required}}
- new const; // expected-error {{expected a type}}
- try {} catch (const n) {} // expected-error {{unknown type name 'n'}}
- try {} catch (const) {} // expected-error {{expected a type}}
- if (const n = 0) {} // expected-error {{a type specifier is required}}
- switch (const n = 0) {} // expected-error {{a type specifier is required}}
- while (const n = 0) {} // expected-error {{a type specifier is required}}
- for (const n = 0; // expected-error {{a type specifier is required}}
- const m = 0; ) {} // expected-error {{a type specifier is required}}
- sizeof(const); // expected-error {{a type specifier is required}}
+const dr539(
+// expected-error at -1 {{a type specifier is required for all declarations}}
+ const a) {
+ // expected-error at -1 {{unknown type name 'a'}}
+ const b;
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ new const;
+ // expected-error at -1 {{expected a type}}
+ try {} catch (const n) {}
+ // expected-error at -1 {{unknown type name 'n'}}
+ try {} catch (const) {}
+ // expected-error at -1 {{expected a type}}
+ if (const n = 0) {}
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ switch (const n = 0) {}
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ while (const n = 0) {}
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ for (const n = 0;
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ const m = 0; ) {}
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ sizeof(const);
+ // expected-error at -1 {{a type specifier is required for all declarations}}
struct S {
- const n; // expected-error {{a type specifier is required}}
- operator const(); // expected-error {{expected a type}}
+ const n;
+ // expected-error at -1 {{a type specifier is required for all declarations}}
+ operator const();
+ // expected-error at -1 {{expected a type}}
};
#if __cplusplus >= 201103L
int arr[3];
// FIXME: The extra braces here are to avoid the parser getting too
// badly confused when recovering here. We should fix this recovery.
- { for (const n // expected-error {{unknown type name 'n'}} expected-note {{}}
- : arr) ; {} } // expected-error +{{}}
- (void) [](const) {}; // expected-error {{a type specifier is required}}
- (void) [](const n) {}; // expected-error {{unknown type name 'n'}}
- enum E : const {}; // expected-error {{expected a type}}
- using T = const; // expected-error {{expected a type}}
- auto f() -> const; // expected-error {{expected a type}}
+ { for (const n
+ // since-cxx11-error at -1 {{unknown type name 'n'}}
+ // since-cxx11-note at -2 {{}}
+ : arr) ; {} }
+ // since-cxx11-error at -1 +{{}}
+ (void) [](const) {};
+ // since-cxx11-error at -1 {{a type ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/74373
More information about the cfe-commits
mailing list