[clang][NFC] Refactor expected directives in C++ DRs 300-399

[Endilll]

This patch continues the work started with ea5b1ef. See that commit and its corresponding PR for details.

[Endilll]

This PR is created only for CI purposes.

[llvmbot]

@llvm/pr-subscribers-clang

Author: Vlad Serebrennikov (Endilll)

Changes

This patch continues the work started with ea5b1ef. 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 --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@-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@-1 {{ordered comparison of function pointers ('void (*)(S, S)' and 'void (*)(S, S)')}}
+    // cxx20-23-error@-2 {{expected '>'}}
+    //   cxx20-23-note@-3 {{to match this '<'}} 
+    bool c = (void(*)(S, S))operator+ < (void(*)(S, S))operator-;
+    // expected-error@-1 {{expected '>'}}
+    // expected-note@-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@-1 {{typename specifier refers to a non-type template}}
+    // expected-error@-2 {{'template' keyword not permitted here}}
+    // expected-error@-3 {{a type specifier is required for all declarations}}
+    // expected-error@-4 {{'operator+' cannot be the name of a variable or data member}}
+    // expected-error@-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@-1 {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
+    enum T::template operator+<int> c;
+    // expected-error@-1 {{expected identifier}}
+    enum T::template operator+<int>::E d;
+    // expected-error@-1 {{qualified name refers into a specialization of function template 'T::template operator +'}}
+    // expected-error@-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@-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@-1 {{declaration of anonymous class must be a definition}}
+  // expected-error@-2 {{declaration does not declare anything}}
+  template<typename T> class T::operator& {};
+  // expected-error@-1 {{expected identifier}}
+  // expected-error@-2 {{declaration of anonymous class must be a definition}}
+  // expected-error@-3 {{declaration does not declare anything}}
+  template<typename T> class S::operator&<T*> {};
+  // expected-error@-1 {{expected identifier}}
+  // expected-error@-2 {{declaration of anonymous class must be a definition}}
+  // expected-error@-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@-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@-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@-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@-3 {{requires an initializer}}
-  // expected-note@-3 {{in value-initialization}}
-#else
-  // expected-error@-5 {{deleted}}
-  // expected-note@-7 {{reference}}
-#endif
+  int n = a();
+  // expected-error@-1 {{reference to type 'int' requires an initializer}}
+
+  struct S { int &b; }; // #dr304-S
+  // cxx98-error@-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@-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@-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@-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@-1 {{no member named 'T1' in 'dr305::Z'}}
+    z->~T2<int>();
+    // expected-error@-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@-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@-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@-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@-2 {{define each namespace separately}}
-#endif
+  // cxx98-14-error@-1 {{nested namespace definition is a C++17 extension; define each namespace separately}}
   namespace X {
     namespace X::Y {}
-#if __cplusplus <= 201402L
-  // expected-error@-2 {{define each namespace separately}}
-#endif
+    // cxx98-14-error@-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@-1 {{expected identifier or '{'}}
+  // expected-warning@-2 {{extra qualification on member 'X'}}
+  // expected-error@-3 {{a type specifier is required for all declarations}}
+  // expected-error@-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@-2 {{extension}}
-#endif
+  // cxx98-error@-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@-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@-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@-1 {{template argument uses local type 'A'}}
 
     typedef A B;
     extern B b; // FIXME: ill-formed
     X<B> xb;
+    // cxx98-error@-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@-12 {{uses local type 'A'}}
-  // expected-error@-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@-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@-1 {{address of bit-field requested}}
+  int &c = (s.n = 0);
+  // expected-error@-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@-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@-1 {{non-const reference cannot bind to bit-field}}
+  int *f = &(true ? s.n : s.n);
+  // expected-error@-1 {{address of bit-field requested}}
+  int &g = (void(), s.n);
+  // expected-error@-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@-1 {{address of bit-field requested}}
+  int *i = &++s.n;
+  // expected-error@-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@-1 {{field has incomplete type 'A'}}
+  // expected-note@#dr328-A {{forward declaration of 'dr328::A'}}
+  template<typename> struct C { A a; };
+  // expected-error@-1 {{field has incomplete type 'A'}}
+  // expected-note@#dr328-A {{forward declaration of 'dr328::A'}}
+  A *p = new A[0];
+  // expected-error@-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@-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@-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@-1 {{incompatible pointer types assigning to 'R' (aka 'const int *const (*)[4]') from 'P' (aka 'int *(*)[3]')}}
     s = p;
-#if __cplusplus < 202002
-    // expected-error@-2 {{incompatible}} (fixed by p0388)
-#endif
-    t = p; // expected-error {{incompatible}}
+    // cxx98-17-error@-1 {{incompatible pointer types assigning to 'S' (aka 'const int *const (*)[]') from 'P' (aka 'int *(*)[3]')}} (fixed by p0388)
+    t = p;
+    // expected-error@-1 {{incompatible pointer types assigning to 'T' (aka 'const int *(*)[]') from 'P' (aka 'int *(*)[3]')}}
     s = q;
-#if __cplusplus < 202002
-    // expected-error@-2 {{incompatible}} (fixed by p0388)
-#endif
+    // cxx98-17-error@-1 {{incompatible pointer types assigning to 'S' (aka 'const int *const (*)[]') from 'Q' (aka 'const int *cons...
[truncated]