[clang] ea5b1ef - [clang][NFC] Refactor expected directives in C++ DRs 1-99 (#73879)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 30 09:16:38 PST 2023
Author: Vlad Serebrennikov
Date: 2023-11-30T21:16:33+04:00
New Revision: ea5b1ef016d020c37f903d6c7d4f623be975dab8
URL: https://github.com/llvm/llvm-project/commit/ea5b1ef016d020c37f903d6c7d4f623be975dab8
DIFF: https://github.com/llvm/llvm-project/commit/ea5b1ef016d020c37f903d6c7d4f623be975dab8.diff
LOG: [clang][NFC] Refactor expected directives in C++ DRs 1-99 (#73879)
This patch converts (almost) every expected directive in `test/CXX/drs/dr0xx.cpp` into either `@-1` form (when directive immediately follow the line diagnostic is pointing out to), or `@#<marker>` form (when directive is placed away from the line diagnostic is pointing out to). It also converts directive to match exactly one diagnostic, as opposed to matching multiple. Error messages are expanded to exactly match compiler output. `#if __cplusplus` guarding directives are replaced with respective prefixes (e.g. `since-cxx17`).
All aforementioned changes serve a purpose of making it easier to reconstruct expected compiler output, which should also make it a bit easier to grasp the gist of those already non-trivial tests due to their nature of testing corner cases of the language.
Added:
Modified:
clang/test/CXX/drs/dr0xx.cpp
Removed:
################################################################################
diff --git a/clang/test/CXX/drs/dr0xx.cpp b/clang/test/CXX/drs/dr0xx.cpp
index 0d60d55326c8781..e79ce6daf2655c5 100644
--- a/clang/test/CXX/drs/dr0xx.cpp
+++ b/clang/test/CXX/drs/dr0xx.cpp
@@ -1,9 +1,9 @@
-// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
-// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
-// RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++98 %s -verify=expected,cxx98,cxx98-14 -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,since-cxx11,cxx98-14,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++14 %s -verify=expected,since-cxx11,cxx98-14,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
namespace dr1 { // dr1: no
namespace X { extern "C" void dr1_f(int a = 1); }
@@ -26,9 +26,11 @@ namespace dr1 { // dr1: no
namespace X {
void z(int);
}
- void X::z(int = 1) {} // expected-note {{previous}}
+ void X::z(int = 1) {} // #dr1-z
namespace X {
- void z(int = 1); // expected-error {{redefinition of default argument}}
+ void z(int = 1);
+ // expected-error at -1 {{redefinition of default argument}}
+ // expected-note@#dr1-z {{previous definition is here}}
}
void i(int = 1);
@@ -50,17 +52,21 @@ namespace dr1 { // dr1: no
namespace dr3 { // dr3: yes
template<typename T> struct A {};
- template<typename T> void f(T) { A<T> a; } // expected-note {{implicit instantiation}}
+ template<typename T> void f(T) { A<T> a; } // #dr3-f-T
template void f(int);
- template<> struct A<int> {}; // expected-error {{explicit specialization of 'dr3::A<int>' after instantiation}}
+ template<> struct A<int> {};
+ // expected-error at -1 {{explicit specialization of 'dr3::A<int>' after instantiation}}
+ // expected-note@#dr3-f-T {{implicit instantiation first required here}}
}
namespace dr4 { // dr4: yes
extern "C" {
static void dr4_f(int) {}
static void dr4_f(float) {}
- void dr4_g(int) {} // expected-note {{previous}}
- void dr4_g(float) {} // expected-error {{conflicting types}}
+ void dr4_g(int) {} // #dr4-g-int
+ void dr4_g(float) {}
+ // expected-error at -1 {{conflicting types for 'dr4_g'}}
+ // expected-note@#dr4-g-int {{previous definition is here}}
}
}
@@ -80,14 +86,21 @@ namespace dr5 { // dr5: 3.1
namespace dr7 { // dr7: 3.4
class A { public: ~A(); };
- class B : virtual private A {}; // expected-note 2 {{declared private here}}
- class C : public B {} c; // expected-error 2 {{inherited virtual base class 'A' has private destructor}} \
- // expected-note {{implicit default constructor for 'dr7::C' first required here}} \
- // expected-note {{implicit destructor for 'dr7::C' first required here}}
+ class B : virtual private A {}; // #dr7-B
+ class C : public B {} c; // #dr7-C
+ // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}}
+ // expected-note@#dr7-C {{in implicit default constructor for 'dr7::C' first required here}}
+ // expected-note@#dr7-B {{declared private here}}
+
+ // expected-error@#dr7-C {{inherited virtual base class 'A' has private destructor}}
+ // expected-note@#dr7-C {{in implicit destructor for 'dr7::C' first required here}}
+ // expected-note@#dr7-B {{declared private here}}
class VeryDerivedC : public B, virtual public A {} vdc;
- class X { ~X(); }; // expected-note {{here}}
- class Y : X { ~Y() {} }; // expected-error {{private destructor}}
+ class X { ~X(); }; // #dr7-X
+ class Y : X { ~Y() {} };
+ // expected-error at -1 {{base class 'X' has private destructor}}
+ // expected-note@#dr7-X {{implicitly declared private here}}
namespace PR16370 { // This regressed the first time DR7 was fixed.
struct S1 { virtual ~S1(); };
@@ -117,13 +130,16 @@ namespace dr8 { // dr8: dup 45
namespace dr9 { // dr9: 2.8
struct B {
protected:
- int m; // expected-note {{here}}
+ int m; // #dr9-m
friend int R1();
};
- struct N : protected B { // expected-note {{protected}}
+ struct N : protected B { // #dr9-N
friend int R2();
} n;
- int R1() { return n.m; } // expected-error {{protected member}}
+ int R1() { return n.m; }
+ // expected-error at -1 {{'m' is a protected member of 'dr9::B'}}
+ // expected-note@#dr9-N {{constrained by protected inheritance here}}
+ // expected-note@#dr9-m {{member is declared here}}
int R2() { return n.m; }
}
@@ -142,7 +158,8 @@ namespace dr11 { // dr11: yes
};
template<typename T> struct B : T {
using T::V;
- V v; // expected-error {{unknown type name}}
+ V v;
+ // expected-error at -1 {{unknown type name 'V'}}
};
struct X { typedef int U; };
A<X> ax;
@@ -190,27 +207,41 @@ namespace dr14 { // dr14: 3.4
extern "C" int dr14_f() { return c.k; }
}
- namespace X { typedef int T; typedef int U; } // expected-note {{candidate}}
- namespace Y { typedef int T; typedef long U; } // expected-note {{candidate}}
+ namespace X { typedef int T; typedef int U; } // #dr14-X-U
+ namespace Y { typedef int T; typedef long U; } // #dr14-Y-U
T t; // ok, same type both times
- U u; // expected-error {{ambiguous}}
+ U u;
+ // expected-error at -1 {{reference to 'U' is ambiguous}}
+ // expected-note@#dr14-X-U {{candidate found by name lookup is 'dr14::X::U'}}
+ // expected-note@#dr14-Y-U {{candidate found by name lookup is 'dr14::Y::U'}}
}
namespace dr15 { // dr15: yes
- template<typename T> void f(int); // expected-note {{previous}}
- template<typename T> void f(int = 0); // expected-error {{default arguments cannot be added}}
+ template<typename T> void f(int); // #dr15-f-decl-first
+ template<typename T> void f(int = 0);
+ // expected-error at -1 {{default arguments cannot be added to a function template that has already been declared}}
+ // expected-note@#dr15-f-decl-first {{previous template declaration is here}}
}
namespace dr16 { // dr16: 2.8
- class A { // expected-note {{here}}
- void f(); // expected-note {{here}}
+ class A { // #dr16-A
+ void f(); // #dr16-A-f-decl
friend class C;
};
- class B : A {}; // expected-note 3{{here}}
+ class B : A {}; // #dr16-B
class C : B {
void g() {
- f(); // expected-error {{private member}}
- A::f(); // expected-error {{private member}} expected-error {{private base}}
+ f();
+ // expected-error at -1 {{'f' is a private member of 'dr16::A'}}
+ // expected-note@#dr16-B {{constrained by implicitly private inheritance here}}
+ // expected-note@#dr16-A-f-decl {{member is declared here}}
+ A::f(); // #dr16-A-f-call
+ // expected-error@#dr16-A-f-call {{'A' is a private member of 'dr16::A'}}
+ // expected-note@#dr16-B {{constrained by implicitly private inheritance here}}
+ // expected-note@#dr16-A {{member is declared here}}
+
+ // expected-error@#dr16-A-f-call {{cannot cast 'dr16::C' to its private base class 'dr16::A'}}
+ // expected-note@#dr16-B {{implicitly declared private here}}
}
};
}
@@ -232,13 +263,16 @@ namespace dr17 { // dr17: yes
namespace dr19 { // dr19: 3.1
struct A {
- int n; // expected-note {{here}}
+ int n; // #dr19-n
};
- struct B : protected A { // expected-note {{here}}
+ struct B : protected A { // #dr19-B
};
struct C : B {} c;
struct D : B {
- int get1() { return c.n; } // expected-error {{protected member}}
+ int get1() { return c.n; }
+ // expected-error at -1 {{'n' is a protected member of 'dr19::A'}}
+ // expected-note@#dr19-B {{constrained by protected inheritance here}}
+ // expected-note@#dr19-n {{member is declared here}}
int get2() { return ((A&)c).n; } // ok, A is an accessible base of B from here
};
}
@@ -248,86 +282,94 @@ namespace dr20 { // dr20: 2.8
public:
X();
private:
- X(const X&); // expected-note {{here}}
+ X(const X&); // #dr20-X-ctor
};
X &f();
- X x = f(); // expected-error {{private}}
+ X x = f();
+ // expected-error at -1 {{calling a private constructor of class 'dr20::X'}}
+ // expected-note@#dr20-X-ctor {{declared private here}}
}
namespace dr21 { // dr21: 3.4
template<typename T> struct A;
struct X {
- template<typename T = int> friend struct A; // expected-error {{default template argument not permitted on a friend template}}
- template<typename T = int> friend struct B; // expected-error {{default template argument not permitted on a friend template}}
+ template<typename T = int> friend struct A;
+ // expected-error at -1 {{default template argument not permitted on a friend template}}
+ template<typename T = int> friend struct B;
+ // expected-error at -1 {{default template argument not permitted on a friend template}}
};
}
namespace dr22 { // dr22: sup 481
- template<typename dr22_T = dr22_T> struct X; // expected-error {{unknown type name 'dr22_T'}}
+ template<typename dr22_T = dr22_T> struct X;
+ // expected-error at -1 {{unknown type name 'dr22_T'}}
typedef int T;
template<typename T = T> struct Y;
}
namespace dr23 { // dr23: yes
- template<typename T> void f(T, T); // expected-note {{candidate}}
- template<typename T> void f(T, int); // expected-note {{candidate}}
- void g() { f(0, 0); } // expected-error {{ambiguous}}
+ template<typename T> void f(T, T); // #dr23-f-T-T
+ template<typename T> void f(T, int); // #dr23-f-T-int
+ void g() { f(0, 0); }
+ // expected-error at -1 {{call to 'f' is ambiguous}}
+ // expected-note@#dr23-f-T-T {{candidate function [with T = int]}}
+ // expected-note@#dr23-f-T-int {{candidate function [with T = int]}}
}
// dr24: na
namespace dr25 { // dr25: yes
struct A {
- void f() throw(int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void f() throw(int);
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
};
- void (A::*f)() throw (int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*f)() throw (int);
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
void (A::*g)() throw () = f;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{is not superset of source}}
-#else
- // expected-error at -4 {{
diff erent exception specifications}}
-#endif
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{
diff erent exception specifications}}
void (A::*g2)() throw () = 0;
- void (A::*h)() throw (int, char) = f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*h)() throw (int, char) = f;
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
void (A::*i)() throw () = &A::f;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{is not superset of source}}
-#else
- // expected-error at -4 {{
diff erent exception specifications}}
-#endif
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{
diff erent exception specifications}}
void (A::*i2)() throw () = 0;
- void (A::*j)() throw (int, char) = &A::f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void (A::*j)() throw (int, char) = &A::f;
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
void x() {
g2 = f;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{is not superset of source}}
-#else
- // expected-error at -4 {{
diff erent exception specifications}}
-#endif
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{
diff erent exception specifications}}
h = f;
i2 = &A::f;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{is not superset of source}}
-#else
- // expected-error at -4 {{
diff erent exception specifications}}
-#endif
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{
diff erent exception specifications}}
j = &A::f;
}
}
namespace dr26 { // dr26: yes
- struct A { A(A, const A & = A()); }; // expected-error {{must pass its first argument by reference}}
+ struct A { A(A, const A & = A()); };
+ // expected-error at -1 {{copy constructor must pass its first argument by reference}}
struct B {
B();
// FIXME: In C++98, we diagnose this twice.
B(const B &, B = B());
-#if __cplusplus <= 201402L
- // expected-error at -2 1+{{recursive evaluation of default argument}} expected-note at -2 1+{{used here}}
-#endif
+ // cxx98-14-error at -1 {{recursive evaluation of default argument}}
+ // cxx98-14-note at -2 {{default argument used here}}
+ // cxx98-error at -3 {{recursive evaluation of default argument}}
+ // cxx98-note at -4 {{default argument used here}}
};
struct C {
static C &f();
- C(const C &, C = f()); // expected-error {{recursive evaluation of default argument}} expected-note {{used here}}
+ C(const C &, C = f());
+ // expected-error at -1 {{recursive evaluation of default argument}}
+ // expected-note at -2 {{default argument used here}}
};
}
@@ -339,24 +381,34 @@ namespace dr27 { // dr27: yes
// dr28: na lib
namespace dr29 { // dr29: 3.4
- void dr29_f0(); // expected-note {{here}}
+ void dr29_f0(); // #dr29-f0
void g0() { void dr29_f0(); }
extern "C++" void g0_cxx() { void dr29_f0(); }
- extern "C" void g0_c() { void dr29_f0(); } // expected-error {{
diff erent language linkage}}
+ extern "C" void g0_c() { void dr29_f0(); }
+ // expected-error at -1 {{declaration of 'dr29_f0' has a
diff erent language linkage}}
+ // expected-note@#dr29-f0 {{previous declaration is here}}
- extern "C" void dr29_f1(); // expected-note {{here}}
+ extern "C" void dr29_f1(); // #dr29-f1
void g1() { void dr29_f1(); }
extern "C" void g1_c() { void dr29_f1(); }
- extern "C++" void g1_cxx() { void dr29_f1(); } // expected-error {{
diff erent language linkage}}
+ extern "C++" void g1_cxx() { void dr29_f1(); }
+ // expected-error at -1 {{declaration of 'dr29_f1' has a
diff erent language linkage}}
+ // expected-note@#dr29-f1 {{previous declaration is here}}
- void g2() { void dr29_f2(); } // expected-note {{here}}
- extern "C" void dr29_f2(); // expected-error {{
diff erent language linkage}}
+ void g2() { void dr29_f2(); } // #dr29-f2
+ extern "C" void dr29_f2();
+ // expected-error at -1 {{declaration of 'dr29_f2' has a
diff erent language linkage}}
+ // expected-note@#dr29-f2 {{previous declaration is here}}
- extern "C" void g3() { void dr29_f3(); } // expected-note {{here}}
- extern "C++" void dr29_f3(); // expected-error {{
diff erent language linkage}}
+ extern "C" void g3() { void dr29_f3(); } // #dr29-f3
+ extern "C++" void dr29_f3();
+ // expected-error at -1 {{declaration of 'dr29_f3' has a
diff erent language linkage}}
+ // expected-note@#dr29-f3 {{previous declaration is here}}
- extern "C++" void g4() { void dr29_f4(); } // expected-note {{here}}
- extern "C" void dr29_f4(); // expected-error {{
diff erent language linkage}}
+ extern "C++" void g4() { void dr29_f4(); } // #dr29-f4
+ extern "C" void dr29_f4();
+ // expected-error at -1 {{declaration of 'dr29_f4' has a
diff erent language linkage}}
+ // expected-note@#dr29-f4 {{previous declaration is here}}
extern "C" void g5();
extern "C++" void dr29_f5();
@@ -371,15 +423,19 @@ namespace dr29 { // dr29: 3.4
}
extern "C" void g7();
- extern "C++" void dr29_f7(); // expected-note {{here}}
+ extern "C++" void dr29_f7(); // #dr29-f7
extern "C" void g7() {
- void dr29_f7(); // expected-error {{
diff erent language linkage}}
+ void dr29_f7();
+ // expected-error at -1 {{declaration of 'dr29_f7' has a
diff erent language linkage}}
+ // expected-note@#dr29-f7 {{previous declaration is here}}
}
extern "C++" void g8();
- extern "C" void dr29_f8(); // expected-note {{here}}
+ extern "C" void dr29_f8(); // #dr29-f8
extern "C++" void g8() {
- void dr29_f8(); // expected-error {{
diff erent language linkage}}
+ void dr29_f8();
+ // expected-error at -1 {{declaration of 'dr29_f8' has a
diff erent language linkage}}
+ // expected-note@#dr29-f8 {{previous declaration is here}}
}
}
@@ -387,38 +443,42 @@ namespace dr30 { // dr30: sup 468 c++11
struct A {
template<int> static int f();
} a, *p = &a;
+ // FIXME: It's not clear whether DR468 applies to C++98 too.
int x = A::template f<0>();
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
int y = a.template f<0>();
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
int z = p->template f<0>();
-#if __cplusplus < 201103L
- // FIXME: It's not clear whether DR468 applies to C++98 too.
- // expected-error at -5 {{'template' keyword outside of a template}}
- // expected-error at -5 {{'template' keyword outside of a template}}
- // expected-error at -5 {{'template' keyword outside of a template}}
-#endif
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
}
namespace dr31 { // dr31: 2.8
class X {
private:
- void operator delete(void*); // expected-note {{here}}
+ void operator delete(void*); // #dr31-delete
};
// We would call X::operator delete if X() threw (even though it can't,
// and even though we allocated the X using ::operator delete).
- X *p = new X; // expected-error {{private}}
+ X *p = new X;
+ // expected-error at -1 {{'operator delete' is a private member of 'dr31::X'}}
+ // expected-note@#dr31-delete {{declared private here}}
}
// dr32: na
namespace dr33 { // dr33: 9
- namespace X { struct S; void f(void (*)(S)); } // expected-note {{candidate}}
- namespace Y { struct T; void f(void (*)(T)); } // expected-note {{candidate}}
+ namespace X { struct S; void f(void (*)(S)); } // #dr33-f-S
+ namespace Y { struct T; void f(void (*)(T)); } // #dr33-f-T
void g(X::S);
template<typename Z> Z g(Y::T);
- void h() { f(&g); } // expected-error {{ambiguous}}
+ void h() { f(&g); }
+ // expected-error at -1 {{call to 'f' is ambiguous}}
+ // expected-note@#dr33-f-S {{candidate function}}
+ // expected-note@#dr33-f-T {{candidate function}}
template<typename T> void t(X::S);
- template<typename T, typename U = void> void u(X::S); // expected-error 0-1{{default template argument}}
+ template<typename T, typename U = void> void u(X::S);
+ // expected-error at -1 0-1 {{default template arguments for a function template are a C++11 extension}}
void templ() { f(t<int>); f(u<int>); }
// Even though v<int> cannot select the first overload, ADL considers it
@@ -436,7 +496,8 @@ namespace dr33 { // dr33: 9
};
template<typename T> void f(Y<T>);
- int use = X() + f<int>; // expected-error {{invalid operands}}
+ int use = X() + f<int>;
+ // expected-error at -1 {{invalid operands to binary expression ('X' and 'void (Y<int>)')}}
}
namespace member {
@@ -481,17 +542,25 @@ namespace example2 {
struct D : virtual B, virtual C
{
- using B::i; // expected-note {{previous using declaration}}
- using B::i; // expected-error {{redeclaration of using declaration}}
-
- using C::i; // expected-note {{previous using declaration}}
- using C::i; // expected-error {{redeclaration of using declaration}}
-
- using B::j; // expected-note {{previous using declaration}}
- using B::j; // expected-error {{redeclaration of using declaration}}
-
- using C::j; // expected-note {{previous using declaration}}
- using C::j; // expected-error {{redeclaration of using declaration}}
+ using B::i; // #dr36-ex2-B-i-first
+ using B::i;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex2-B-i-first {{previous using declaration}}
+
+ using C::i; // #dr36-ex2-C-i-first
+ using C::i;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex2-C-i-first {{previous using declaration}}
+
+ using B::j; // #dr36-ex2-B-j-first
+ using B::j;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex2-B-j-first {{previous using declaration}}
+
+ using C::j; // #dr36-ex2-C-j-first
+ using C::j;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex2-C-j-first {{previous using declaration}}
};
}
@@ -511,17 +580,25 @@ namespace example3 {
template<typename T>
struct D : virtual B<T>, virtual C<T>
{
- using B<T>::i; // expected-note {{previous using declaration}}
- using B<T>::i; // expected-error {{redeclaration of using declaration}}
-
- using C<T>::i; // expected-note {{previous using declaration}}
- using C<T>::i; // expected-error {{redeclaration of using declaration}}
-
- using B<T>::j; // expected-note {{previous using declaration}}
- using B<T>::j; // expected-error {{redeclaration of using declaration}}
-
- using C<T>::j; // expected-note {{previous using declaration}}
- using C<T>::j; // expected-error {{redeclaration of using declaration}}
+ using B<T>::i; // #dr36-ex3-B-i-first
+ using B<T>::i;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex3-B-i-first {{previous using declaration}}
+
+ using C<T>::i; // #dr36-ex3-C-i-first
+ using C<T>::i;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex3-C-i-first {{previous using declaration}}
+
+ using B<T>::j; // #dr36-ex3-B-j-first
+ using B<T>::j;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex3-B-j-first {{previous using declaration}}
+
+ using C<T>::j; // #dr36-ex3-C-j-first
+ using C<T>::j;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-ex3-C-j-first {{previous using declaration}}
};
}
namespace example4 {
@@ -532,8 +609,10 @@ namespace example4 {
template<typename T>
struct G : E<T> {
- using E<T>::k; // expected-note {{previous using declaration}}
- using E<T>::k; // expected-error {{redeclaration of using declaration}}
+ using E<T>::k; // #dr36-E-k-first
+ using E<T>::k;
+ // expected-error at -1 {{redeclaration of using declaration}}
+ // expected-note@#dr36-E-k-first {{previous using declaration}}
};
}
}
@@ -558,24 +637,35 @@ namespace dr39 { // dr39: no
namespace example2 {
struct A {
- int &x(int); // expected-note {{found}}
- static int &y(int); // expected-note {{found}}
+ int &x(int); // #dr39-A-x-decl
+ static int &y(int); // #dr39-A-y-decl
};
struct V {
int &z(int);
};
struct B : A, virtual V {
- using A::x; // expected-note {{found}}
+ using A::x; // #dr39-using-A-x
float &x(float);
- using A::y; // expected-note {{found}}
+ using A::y; // #dr39-using-A-y
static float &y(float);
using V::z;
float &z(float);
};
- struct C : A, B, virtual V {} c; // expected-warning {{direct base 'A' is inaccessible due to ambiguity:\n struct dr39::example2::C -> A\n struct dr39::example2::C -> B -> A}}
- int &x = c.x(0); // expected-error {{found in multiple base classes}}
+ struct C : A, B, virtual V {} c;
+ /* expected-warning at -1
+ {{direct base 'A' is inaccessible due to ambiguity:
+ struct dr39::example2::C -> A
+ struct dr39::example2::C -> B -> A}} */
+ int &x = c.x(0);
+ // expected-error at -1 {{member 'x' found in multiple base classes of
diff erent types}}
+ // expected-note@#dr39-A-x-decl {{member found by ambiguous name lookup}}
+ // expected-note@#dr39-using-A-x {{member found by ambiguous name lookup}}
+
// FIXME: This is valid, because we find the same static data member either way.
- int &y = c.y(0); // expected-error {{found in multiple base classes}}
+ int &y = c.y(0);
+ // expected-error at -1 {{member 'y' found in multiple base classes of
diff erent types}}
+ // expected-note@#dr39-A-y-decl {{member found by ambiguous name lookup}}
+ // expected-note@#dr39-using-A-y {{member found by ambiguous name lookup}}
int &z = c.z(0);
}
@@ -588,21 +678,38 @@ namespace dr39 { // dr39: no
}
namespace example4 {
- struct A { int n; }; // expected-note {{found}}
+ struct A { int n; }; // #dr39-ex4-A-n
struct B : A {};
struct C : A {};
- struct D : B, C { int f() { return n; } }; // expected-error {{found in multiple base-class}}
+ struct D : B, C { int f() { return n; } };
+ /* expected-error at -1
+ {{non-static member 'n' found in multiple base-class subobjects of type 'A':
+ struct dr39::example4::D -> B -> A
+ struct dr39::example4::D -> C -> A}} */
+ // expected-note@#dr39-ex4-A-n {{member found by ambiguous name lookup}}
}
namespace PR5916 {
// FIXME: This is valid.
- struct A { int n; }; // expected-note +{{found}}
+ struct A { int n; }; // #dr39-A-n
struct B : A {};
struct C : A {};
struct D : B, C {};
- int k = sizeof(D::n); // expected-error {{found in multiple base}} expected-error {{unknown type name}}
+ int k = sizeof(D::n); // #dr39-sizeof
+ /* expected-error@#dr39-sizeof
+ {{non-static member 'n' found in multiple base-class subobjects of type 'A':
+ struct dr39::PR5916::D -> B -> A
+ struct dr39::PR5916::D -> C -> A}} */
+ // expected-note@#dr39-A-n {{member found by ambiguous name lookup}}
+
+ // expected-error@#dr39-sizeof {{unknown type name}}
#if __cplusplus >= 201103L
- decltype(D::n) n; // expected-error {{found in multiple base}}
+ decltype(D::n) n;
+ /* expected-error at -1
+ {{non-static member 'n' found in multiple base-class subobjects of type 'A':
+ struct dr39::PR5916::D -> B -> A
+ struct dr39::PR5916::D -> C -> A}} */
+ // expected-note@#dr39-A-n {{member found by ambiguous name lookup}}
#endif
}
}
@@ -637,15 +744,19 @@ namespace dr45 { // dr45: yes
namespace dr46 { // dr46: yes
template<typename> struct A { template<typename> struct B {}; };
- template template struct A<int>::B<int>; // expected-error {{expected unqualified-id}}
+ template template struct A<int>::B<int>;
+ // expected-error at -1 {{expected unqualified-id}}
}
namespace dr47 { // dr47: sup 329
template<typename T> struct A {
- friend void f() { T t; } // expected-error {{redefinition}} expected-note {{previous}}
+ friend void f() { T t; } // #dr47-f
+ // expected-error at -1 {{redefinition of 'f'}}
+ // expected-note@#dr47-b {{in instantiation of template class 'dr47::A<float>' requested here}}
+ // expected-note@#dr47-f {{previous definition is here}}
};
A<int> a;
- A<float> b; // expected-note {{instantiation of}}
+ A<float> b; // #dr47-b
void f();
void g() { f(); }
@@ -668,39 +779,44 @@ namespace dr48 { // dr48: yes
}
namespace dr49 { // dr49: 2.8
- template<int*> struct A {}; // expected-note 0-2{{here}}
+ template<int*> struct A {}; // #dr49-A
int k;
#if __has_feature(cxx_constexpr)
constexpr
#endif
- int *const p = &k; // expected-note 0-2{{here}}
+ int *const p = &k; // #dr49-p
A<&k> a;
- A<p> b;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{must have its address taken}}
-#endif
-#if __cplusplus < 201103L
- // expected-error at -5 {{internal linkage}}
-#endif
- int *q = &k;
- A<q> c;
-#if __cplusplus < 201103L
- // expected-error at -2 {{must have its address taken}}
-#else
- // expected-error at -4 {{constant expression}}
- // expected-note at -5 {{read of non-constexpr}}
- // expected-note at -7 {{declared here}}
-#endif
+ A<p> b; // #dr49-b
+ // cxx98-error@#dr49-b {{non-type template argument referring to object 'p' with internal linkage is a C++11 extension}}
+ // cxx98-note@#dr49-p {{non-type template argument refers to object here}}
+
+ // cxx98-14-error@#dr49-b {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+ // cxx98-14-note@#dr49-A {{template parameter is declared here}}
+ int *q = &k; // #dr49-q
+ A<q> c; // #dr49-c
+ // cxx98-error@#dr49-c {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+ // cxx98-note@#dr49-A {{template parameter is declared here}}
+
+ // cxx11-14-error@#dr49-c {{non-type template argument of type 'int *' is not a constant expression}}
+ // cxx11-14-note@#dr49-c {{read of non-constexpr variable 'q' is not allowed in a constant expression}}
+ // cxx11-14-note@#dr49-q {{declared here}}
+ // cxx11-14-note@#dr49-A {{template parameter is declared here}}
+
+ // since-cxx17-error@#dr49-c {{non-type template argument is not a constant expression}}
+ // since-cxx17-note@#dr49-c {{read of non-constexpr variable 'q' is not allowed in a constant expression}}
+ // since-cxx17-note@#dr49-q {{declared here}}
}
namespace dr50 { // dr50: yes
- struct X; // expected-note {{forward}}
+ struct X; // #dr50-X
extern X *p;
X *q = (X*)p;
X *r = static_cast<X*>(p);
X *s = const_cast<X*>(p);
X *t = reinterpret_cast<X*>(p);
- X *u = dynamic_cast<X*>(p); // expected-error {{incomplete}}
+ X *u = dynamic_cast<X*>(p);
+ // expected-error at -1 {{'dr50::X' is an incomplete type}}
+ // expected-note@#dr50-X {{forward declaration of 'dr50::X'}}
}
namespace dr51 { // dr51: 2.8
@@ -714,11 +830,16 @@ namespace dr51 { // dr51: 2.8
}
namespace dr52 { // dr52: 2.8
- struct A { int n; }; // expected-note {{here}}
- struct B : private A {} b; // expected-note 2{{private}}
+ struct A { int n; }; // #dr52-A
+ struct B : private A {} b; // #dr52-B
+ int k = b.A::n; // #dr52-k
// FIXME: This first diagnostic is very strangely worded, and seems to be bogus.
- int k = b.A::n; // expected-error {{'A' is a private member of 'dr52::A'}}
- // expected-error at -1 {{cannot cast 'struct B' to its private base}}
+ // expected-error@#dr52-k {{'A' is a private member of 'dr52::A'}}
+ // expected-note@#dr52-B {{constrained by private inheritance here}}
+ // expected-note@#dr52-A {{member is declared here}}
+
+ // expected-error@#dr52-k {{cannot cast 'struct B' to its private base class 'dr52::A'}}
+ // expected-note@#dr52-B {{declared private here}}
}
namespace dr53 { // dr53: yes
@@ -729,21 +850,37 @@ namespace dr53 { // dr53: yes
namespace dr54 { // dr54: 2.8
struct A { int a; } a;
struct V { int v; } v;
- struct B : private A, virtual V { int b; } b; // expected-note 6{{private here}}
-
- A &sab = static_cast<A&>(b); // expected-error {{private base}}
- A *spab = static_cast<A*>(&b); // expected-error {{private base}}
- int A::*smab = static_cast<int A::*>(&B::b); // expected-error {{private base}}
- B &sba = static_cast<B&>(a); // expected-error {{private base}}
- B *spba = static_cast<B*>(&a); // expected-error {{private base}}
- int B::*smba = static_cast<int B::*>(&A::a); // expected-error {{private base}}
+ struct B : private A, virtual V { int b; } b; // #dr54-B
+
+ A &sab = static_cast<A&>(b);
+ // expected-error at -1 {{cannot cast 'struct B' to its private base class 'A'}}
+ // expected-note@#dr54-B {{declared private here}}
+ A *spab = static_cast<A*>(&b);
+ // expected-error at -1 {{cannot cast 'struct B' to its private base class 'A'}}
+ // expected-note@#dr54-B {{declared private here}}
+ int A::*smab = static_cast<int A::*>(&B::b);
+ // expected-error at -1 {{cannot cast 'dr54::B' to its private base class 'dr54::A'}}
+ // expected-note@#dr54-B {{declared private here}}
+ B &sba = static_cast<B&>(a);
+ // expected-error at -1 {{cannot cast private base class 'dr54::A' to 'dr54::B'}}
+ // expected-note@#dr54-B {{declared private here}}
+ B *spba = static_cast<B*>(&a);
+ // expected-error at -1 {{cannot cast private base class 'dr54::A' to 'dr54::B'}}
+ // expected-note@#dr54-B {{declared private here}}
+ int B::*smba = static_cast<int B::*>(&A::a);
+ // expected-error at -1 {{cannot cast private base class 'dr54::A' to 'dr54::B'}}
+ // expected-note@#dr54-B {{declared private here}}
V &svb = static_cast<V&>(b);
V *spvb = static_cast<V*>(&b);
- int V::*smvb = static_cast<int V::*>(&B::b); // expected-error {{virtual base}}
- B &sbv = static_cast<B&>(v); // expected-error {{virtual base}}
- B *spbv = static_cast<B*>(&v); // expected-error {{virtual base}}
- int B::*smbv = static_cast<int B::*>(&V::v); // expected-error {{virtual base}}
+ int V::*smvb = static_cast<int V::*>(&B::b);
+ // expected-error at -1 {{conversion from pointer to member of class 'dr54::B' to pointer to member of class 'dr54::V' via virtual base 'dr54::V' is not allowed}}
+ B &sbv = static_cast<B&>(v);
+ // expected-error at -1 {{cannot cast 'struct V' to 'B &' via virtual base 'dr54::V'}}
+ B *spbv = static_cast<B*>(&v);
+ // expected-error at -1 {{cannot cast 'dr54::V *' to 'B *' via virtual base 'dr54::V'}}
+ int B::*smbv = static_cast<int B::*>(&V::v);
+ // expected-error at -1 {{conversion from pointer to member of class 'dr54::V' to pointer to member of class 'dr54::B' via virtual base 'dr54::V' is not allowed}}
A &cab = (A&)(b);
A *cpab = (A*)(&b);
@@ -754,10 +891,14 @@ namespace dr54 { // dr54: 2.8
V &cvb = (V&)(b);
V *cpvb = (V*)(&b);
- int V::*cmvb = (int V::*)(&B::b); // expected-error {{virtual base}}
- B &cbv = (B&)(v); // expected-error {{virtual base}}
- B *cpbv = (B*)(&v); // expected-error {{virtual base}}
- int B::*cmbv = (int B::*)(&V::v); // expected-error {{virtual base}}
+ int V::*cmvb = (int V::*)(&B::b);
+ // expected-error at -1 {{conversion from pointer to member of class 'dr54::B' to pointer to member of class 'dr54::V' via virtual base 'dr54::V' is not allowed}}
+ B &cbv = (B&)(v);
+ // expected-error at -1 {{cannot cast 'struct V' to 'B &' via virtual base 'dr54::V'}}
+ B *cpbv = (B*)(&v);
+ // expected-error at -1 {{cannot cast 'dr54::V *' to 'B *' via virtual base 'dr54::V'}}
+ int B::*cmbv = (int B::*)(&V::v);
+ // expected-error at -1 {{conversion from pointer to member of class 'dr54::V' to pointer to member of class 'dr54::B' via virtual base 'dr54::V' is not allowed}}
}
namespace dr55 { // dr55: yes
@@ -767,13 +908,17 @@ namespace dr55 { // dr55: yes
namespace dr56 { // dr56: yes
struct A {
- typedef int T; // expected-note {{previous}}
- typedef int T; // expected-error {{redefinition}}
+ typedef int T; // #dr56-typedef-int-T-first
+ typedef int T;
+ // expected-error at -1 {{redefinition of 'T'}}
+ // expected-note@#dr56-typedef-int-T-first {{previous definition is here}}
};
struct B {
struct X;
- typedef X X; // expected-note {{previous}}
- typedef X X; // expected-error {{redefinition}}
+ typedef X X; // #dr56-typedef-X-X-first
+ typedef X X;
+ // expected-error at -1 {{redefinition of 'X'}}
+ // expected-note@#dr56-typedef-X-X-first {{previous definition is here}}
};
}
@@ -792,32 +937,50 @@ namespace dr59 { // dr59: yes
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
template<typename T> struct convert_to { operator T() const; };
- struct A {}; // expected-note 5+{{candidate}}
- struct B : A {}; // expected-note 0+{{candidate}}
+ struct A {}; // #dr59-A
+ struct B : A {}; // #dr59-B
A a1 = convert_to<A>();
A a2 = convert_to<A&>();
A a3 = convert_to<const A>();
A a4 = convert_to<const volatile A>();
-#if __cplusplus <= 201402L
- // expected-error at -2 {{no viable}}
-#endif
- A a5 = convert_to<const volatile A&>(); // expected-error {{no viable}}
+ // cxx98-14-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::A'}}
+ // cxx98-14-note@#dr59-A {{candidate constructor (the implicit copy constructor) not viable: 1st argument ('const volatile dr59::A') would lose volatile qualifier}}
+ // cxx11-14-note@#dr59-A {{candidate constructor (the implicit move constructor) not viable: 1st argument ('const volatile dr59::A') would lose const and volatile qualifiers}}
+ // cxx98-14-note@#dr59-A {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+ A a5 = convert_to<const volatile A&>();
+ // expected-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::A'}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit copy constructor) not viable: 1st argument ('const volatile dr59::A') would lose volatile qualifier}}
+ // since-cxx11-note@#dr59-A {{candidate constructor (the implicit move constructor) not viable: 1st argument ('const volatile dr59::A') would lose const and volatile qualifiers}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
B b1 = convert_to<B>();
B b2 = convert_to<B&>();
B b3 = convert_to<const B>();
B b4 = convert_to<const volatile B>();
-#if __cplusplus <= 201402L
- // expected-error at -2 {{no viable}}
-#endif
- B b5 = convert_to<const volatile B&>(); // expected-error {{no viable}}
+ // cxx98-14-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::B'}}
+ // cxx98-14-note@#dr59-B {{candidate constructor (the implicit copy constructor) not viable: 1st argument ('const volatile dr59::B') would lose volatile qualifier}}
+ // cxx11-14-note@#dr59-B {{candidate constructor (the implicit move constructor) not viable: 1st argument ('const volatile dr59::B') would lose const and volatile qualifiers}}
+ // cxx98-14-note@#dr59-B {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+ B b5 = convert_to<const volatile B&>();
+ // expected-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::B'}}
+ // expected-note@#dr59-B {{candidate constructor (the implicit copy constructor) not viable: 1st argument ('const volatile dr59::B') would lose volatile qualifier}}
+ // since-cxx11-note@#dr59-B {{candidate constructor (the implicit move constructor) not viable: 1st argument ('const volatile dr59::B') would lose const and volatile qualifiers}}
+ // expected-note@#dr59-B {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
A c1 = convert_to<B>();
A c2 = convert_to<B&>();
A c3 = convert_to<const B>();
- A c4 = convert_to<const volatile B>(); // expected-error {{no viable}}
- A c5 = convert_to<const volatile B&>(); // expected-error {{no viable}}
+ A c4 = convert_to<const volatile B>();
+ // expected-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::B'}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'const volatile dr59::B' to 'const A &' for 1st argument}}
+ // since-cxx11-note@#dr59-A {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'const volatile dr59::B' to 'A &&' for 1st argument}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
+ A c5 = convert_to<const volatile B&>();
+ // expected-error at -1 {{no viable constructor copying variable of type 'const volatile dr59::B'}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'const volatile dr59::B' to 'const A &' for 1st argument}}
+ // since-cxx11-note@#dr59-A {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'const volatile dr59::B' to 'A &&' for 1st argument}}
+ // expected-note@#dr59-A {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
int n1 = convert_to<int>();
int n2 = convert_to<int&>();
@@ -845,8 +1008,10 @@ namespace dr61 { // dr61: 3.4
// This is (presumably) valid, because x.f does not refer to an overloaded
// function name.
void (*p)() = &x.f;
- void (*q)() = &y.f; // expected-error {{cannot create a non-constant pointer to member function}}
- void (*r)() = y.f; // expected-error {{cannot create a non-constant pointer to member function}}
+ void (*q)() = &y.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
+ void (*r)() = y.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
}
namespace dr62 { // dr62: 2.9
@@ -860,10 +1025,7 @@ namespace dr62 { // dr62: 2.9
X<A> x1;
A a = get<A>();
- typedef struct { } *NoNameForLinkagePtr;
-#if __cplusplus < 201103L
- // expected-note at -2 5{{here}}
-#endif
+ typedef struct { } *NoNameForLinkagePtr; // #dr62-unnamed
NoNameForLinkagePtr noNameForLinkagePtr;
struct Danger {
@@ -871,36 +1033,37 @@ namespace dr62 { // dr62: 2.9
};
X<NoNameForLinkagePtr> x2;
+ // cxx98-error at -1 {{template argument uses unnamed type}}
+ // cxx98-note@#dr62-unnamed {{unnamed type used in template argument was declared here}}
X<const NoNameForLinkagePtr> x3;
+ // cxx98-error at -1 {{template argument uses unnamed type}}
+ // cxx98-note@#dr62-unnamed {{unnamed type used in template argument was declared here}}
NoNameForLinkagePtr p1 = get<NoNameForLinkagePtr>();
+ // cxx98-error at -1 {{template argument uses unnamed type}}
+ // cxx98-note@#dr62-unnamed {{unnamed type used in template argument was declared here}}
NoNameForLinkagePtr p2 = get<const NoNameForLinkagePtr>();
+ // cxx98-error at -1 {{template argument uses unnamed type}}
+ // cxx98-note@#dr62-unnamed {{unnamed type used in template argument was declared here}}
int n1 = take(noNameForLinkagePtr);
-#if __cplusplus < 201103L
- // expected-error at -6 {{uses unnamed type}}
- // expected-error at -6 {{uses unnamed type}}
- // expected-error at -6 {{uses unnamed type}}
- // expected-error at -6 {{uses unnamed type}}
- // expected-error at -6 {{uses unnamed type}}
-#endif
+ // cxx98-error at -1 {{template argument uses unnamed type}}
+ // cxx98-note@#dr62-unnamed {{unnamed type used in template argument was declared here}}
X<Danger> x4;
void f() {
struct NoLinkage {};
X<NoLinkage> a;
+ // cxx98-error at -1 {{template argument uses local type }}
X<const NoLinkage> b;
+ // cxx98-error at -1 {{template argument uses local type }}
get<NoLinkage>();
+ // cxx98-error at -1 {{template argument uses local type }}
get<const NoLinkage>();
+ // cxx98-error at -1 {{template argument uses local type }}
X<void (*)(NoLinkage A::*)> c;
+ // cxx98-error at -1 {{template argument uses local type }}
X<int NoLinkage::*> d;
-#if __cplusplus < 201103L
- // expected-error at -7 {{uses local type}}
- // expected-error at -7 {{uses local type}}
- // expected-error at -7 {{uses local type}}
- // expected-error at -7 {{uses local type}}
- // expected-error at -7 {{uses local type}}
- // expected-error at -7 {{uses local type}}
-#endif
+ // cxx98-error at -1 {{template argument uses local type }}
}
}
@@ -922,7 +1085,7 @@ namespace dr64 { // dr64: yes
namespace dr66 { // dr66: no
namespace X {
- int f(int n); // expected-note 2{{candidate}}
+ int f(int n); // #dr66-f-first
}
using X::f;
namespace X {
@@ -930,9 +1093,13 @@ namespace dr66 { // dr66: no
int f(int, int);
}
// FIXME: The first two calls here should be accepted.
- int a = f(); // expected-error {{no matching function}}
+ int a = f();
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr66-f-first {{candidate function not viable: requires single argument 'n', but no arguments were provided}}
int b = f(1);
- int c = f(1, 2); // expected-error {{no matching function}}
+ int c = f(1, 2);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr66-f-first {{candidate function not viable: requires single argument 'n', but 2 arguments were provided}}
}
// dr67: na
@@ -941,24 +1108,18 @@ namespace dr68 { // dr68: 2.8
template<typename T> struct X {};
struct ::dr68::X<int> x1;
struct ::dr68::template X<int> x2;
-#if __cplusplus < 201103L
- // expected-error at -2 {{'template' keyword outside of a template}}
-#endif
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
struct Y {
friend struct X<int>;
friend struct ::dr68::X<char>;
friend struct ::dr68::template X<double>;
-#if __cplusplus < 201103L
- // expected-error at -2 {{'template' keyword outside of a template}}
-#endif
+ // cxx98-error at -1 {{'template' keyword outside of a template}}
};
template<typename>
struct Z {
friend struct ::dr68::template X<double>;
friend typename ::dr68::X<double>;
-#if __cplusplus < 201103L
- // expected-error at -2 {{C++11 extension}}
-#endif
+ // cxx98-error at -1 {{unelaborated friend declaration is a C++11 extension; specify 'struct' to befriend 'typename ::dr68::X<double>'}}
};
}
@@ -966,15 +1127,13 @@ namespace dr69 { // dr69: 9
template<typename T> static void f() {} // #dr69-f
// FIXME: Should we warn here?
inline void g() { f<int>(); }
- extern template void f<char>(); // expected-error {{explicit instantiation declaration of 'f' with internal linkage}}
-#if __cplusplus < 201103L
- // expected-error at -2 {{C++11 extension}}
-#endif
+ extern template void f<char>();
+ // cxx98-error at -1 {{extern templates are a C++11 extension}}
+ // expected-error at -2 {{explicit instantiation declaration of 'f' with internal linkage}}
template<void(*)()> struct Q {};
Q<&f<int> > q;
-#if __cplusplus < 201103L
- // expected-error at -2 {{internal linkage}} expected-note@#dr69-f {{here}}
-#endif
+ // cxx98-error at -1 {{non-type template argument referring to function 'f<int>' with internal linkage is a C++11 extension}}
+ // cxx98-note@#dr69-f {{non-type template argument refers to function here}}
}
namespace dr70 { // dr70: yes
@@ -990,8 +1149,9 @@ namespace dr70 { // dr70: yes
#if __cplusplus >= 201103L
namespace dr73 { // dr73: sup 1652
int a, b;
- static_assert(&a + 1 != &b, ""); // expected-error {{not an integral constant expression}}
- // expected-note at -1 {{comparison against pointer '&a + 1' that points past the end of a complete object}}
+ static_assert(&a + 1 != &b, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{comparison against pointer '&a + 1' that points past the end of a complete object has unspecified value}}
}
#endif
@@ -1002,13 +1162,18 @@ namespace dr74 { // dr74: yes
namespace dr75 { // dr75: yes
struct S {
- static int n = 0; // expected-error {{non-const}}
+ static int n = 0;
+ // expected-error at -1 {{non-const static data member must be initialized out of line}}
};
}
namespace dr76 { // dr76: yes
const volatile int n = 1;
- int arr[n]; // expected-error +{{variable length array}} expected-note {{read of volatile}}
+ int arr[n]; // #dr76-vla
+ // expected-error@#dr76-vla {{variable length arrays in C++ are a Clang extension}}
+ // expected-note@#dr76-vla {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
+
+ // expected-error@#dr76-vla {{variable length array declaration not allowed at file scope}}
}
namespace dr77 { // dr77: yes
@@ -1021,7 +1186,8 @@ namespace dr77 { // dr77: yes
namespace dr78 { // dr78: sup ????
// Under DR78, this is valid, because 'k' has static storage duration, so is
// zero-initialized.
- const int k; // expected-error {{default initialization of an object of const}}
+ const int k;
+ // expected-error at -1 {{default initialization of an object of const type 'const int'}}
}
// dr79: na
@@ -1031,15 +1197,18 @@ namespace dr80 { // dr80: 2.9
int A;
};
struct B {
- static int B; // expected-error {{same name as its class}}
+ static int B;
+ // expected-error at -1 {{member 'B' has the same name as its class}}
};
struct C {
- int C; // expected-error {{same name as its class}}
+ int C;
+ // expected-error at -1 {{member 'C' has the same name as its class}}
C();
};
struct D {
D();
- int D; // expected-error {{same name as its class}}
+ int D;
+ // expected-error at -1 {{member 'D' has the same name as its class}}
};
}
@@ -1057,44 +1226,54 @@ namespace dr84 { // dr84: yes
struct A { operator B() const; };
struct C {};
struct B {
- B(B&); // expected-note 0-1{{candidate}}
- B(C); // expected-note 0-1{{no known conversion from 'B' to 'C'}}
+ B(B&); // #dr84-copy-ctor
+ B(C); // #dr84-ctor-from-C
operator C() const;
};
A a;
// Cannot use B(C) / operator C() pair to construct the B from the B temporary
// here. In C++17, we initialize the B object directly using 'A::operator B()'.
B b = a;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{no viable}}
-#endif
+ // cxx98-14-error at -1 {{no viable constructor copying variable of type 'B'}}
+ // cxx98-14-note@#dr84-copy-ctor {{candidate constructor not viable: expects an lvalue for 1st argument}}
+ // cxx98-14-note@#dr84-ctor-from-C {{candidate constructor not viable: no known conversion from 'B' to 'C' for 1st argument}}
}
namespace dr85 { // dr85: 3.4
struct A {
struct B;
- struct B {}; // expected-note{{previous declaration is here}}
- struct B; // expected-error{{class member cannot be redeclared}}
+ struct B {}; // #dr85-B-def
+ struct B;
+ // expected-error at -1 {{class member cannot be redeclared}}
+ // expected-note@#dr85-B-def {{previous declaration is here}}
union U;
- union U {}; // expected-note{{previous declaration is here}}
- union U; // expected-error{{class member cannot be redeclared}}
+ union U {}; // #dr85-U-def
+ union U;
+ // expected-error at -1 {{class member cannot be redeclared}}
+ // expected-note@#dr85-U-def {{previous declaration is here}}
#if __cplusplus >= 201103L
enum E1 : int;
- enum E1 : int { e1 }; // expected-note{{previous declaration is here}}
- enum E1 : int; // expected-error{{class member cannot be redeclared}}
+ enum E1 : int { e1 }; // #dr85-E1-def
+ enum E1 : int;
+ // expected-error at -1 {{class member cannot be redeclared}}
+ // expected-note@#dr85-E1-def {{previous declaration is here}}
enum class E2;
- enum class E2 { e2 }; // expected-note{{previous declaration is here}}
- enum class E2; // expected-error{{class member cannot be redeclared}}
+ enum class E2 { e2 }; // #dr85-E2-def
+ enum class E2;
+ // expected-error at -1 {{class member cannot be redeclared}}
+ // expected-note@#dr85-E2-def {{previous declaration is here}}
#endif
};
template <typename T>
struct C {
- struct B {}; // expected-note{{previous declaration is here}}
- struct B; // expected-error{{class member cannot be redeclared}}
+ struct B {}; // #dr85-C-B-def
+ struct B;
+ // expected-error at -1 {{class member cannot be redeclared}}
+ // expected-note@#dr85-C-B-def {{previous declaration is here}}
};
}
@@ -1111,10 +1290,12 @@ namespace dr87 { // dr87: no
namespace dr88 { // dr88: 2.8
template<typename T> struct S {
- static const int a = 1; // expected-note {{previous}}
+ static const int a = 1; // #dr88-a
static const int b;
};
- template<> const int S<int>::a = 4; // expected-error {{already has an initializer}}
+ template<> const int S<int>::a = 4;
+ // expected-error at -1 {{static data member 'a' already has an initializer}}
+ // expected-note@#dr88-a {{previous initialization is here}}
template<> const int S<int>::b = 4;
}
@@ -1135,17 +1316,22 @@ namespace dr90 { // dr90: yes
void test() {
dr90_f(A());
dr90_f(B());
- dr90_f(B::C()); // expected-error {{undeclared identifier}}
- dr90_f(B::D()); // expected-error {{undeclared identifier}}
+ dr90_f(B::C());
+ // expected-error at -1 {{use of undeclared identifier 'dr90_f'}}
+ dr90_f(B::D());
+ // expected-error at -1 {{use of undeclared identifier 'dr90_f'}}
dr90_f(E());
- dr90_f(F()); // expected-error {{undeclared identifier}}
+ dr90_f(F());
+ // expected-error at -1 {{use of undeclared identifier 'dr90_f'}}
- dr90_g(A()); // expected-error {{undeclared identifier}}
+ dr90_g(A());
+ // expected-error at -1 {{use of undeclared identifier 'dr90_g'}}
dr90_g(B());
dr90_g(B::C());
dr90_g(B::D());
dr90_g(E());
- dr90_g(F()); // expected-error {{undeclared identifier}}
+ dr90_g(F());
+ // expected-error at -1 {{use of undeclared identifier 'dr90_g'}}
}
}
@@ -1155,25 +1341,33 @@ namespace dr91 { // dr91: yes
}
namespace dr92 { // dr92: 4 c++17
- void f() throw(int, float); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
- void (*p)() throw(int) = &f; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
-#if __cplusplus <= 201402L
- // expected-error at -2 {{target exception specification is not superset of source}}
-#else
- // expected-warning at -4 {{target exception specification is not superset of source}}
-#endif
- void (*q)() throw(int); // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ void f() throw(int, float);
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
+ void (*p)() throw(int) = &f; // #dr92-p
+ // since-cxx17-error@#dr92-p {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note@#dr92-p {{use 'noexcept(false)' instead}}
+
+ // cxx98-14-error@#dr92-p {{target exception specification is not superset of source}}
+ // since-cxx17-warning@#dr92-p {{target exception specification is not superset of source}}
+ void (*q)() throw(int);
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
void (**pp)() throw() = &q;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{exception specifications are not allowed}}
-#else
- // expected-error at -4 {{cannot initialize}}
-#endif
+ // cxx98-14-error at -1 {{exception specifications are not allowed beyond a single level of indirection}}
+ // since-cxx17-error at -2 {{cannot initialize a variable of type 'void (**)() throw()' with an rvalue of type 'void (**)() throw(int)'}}
- void g(void() throw()); // expected-note 0-2 {{no known conversion}} expected-warning 0-1{{mangled name of 'g' will change in C++17}}
+ void g(void() throw()); // #dr92-g
+ // cxx98-14-warning at -1 {{mangled name of 'g' will change in C++17 due to non-throwing exception specification in function signature}}
void h() throw() {
- g(f); // expected-error-re {{{{is not superset|no matching function}}}}
- g(q); // expected-error-re {{{{is not superset|no matching function}}}}
+ g(f);
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{no matching function for call to 'g'}}
+ // since-cxx17-note@#dr92-g {{candidate function not viable: no known conversion from 'void () throw(int, float)' to 'void (*)() throw()' for 1st argument}}
+ g(q);
+ // cxx98-14-error at -1 {{target exception specification is not superset of source}}
+ // since-cxx17-error at -2 {{no matching function for call to 'g'}}
+ // since-cxx17-note@#dr92-g {{candidate function not viable: no known conversion from 'void (*)() throw(int)' to 'void (*)() throw()' for 1st argument}}
}
// Prior to C++17, this is OK because the exception specification is not
@@ -1182,11 +1376,11 @@ namespace dr92 { // dr92: 4 c++17
// is part of the type of the parameter, so this is invalid.
template<void() throw()> struct X {};
X<&f> xp;
-#if __cplusplus > 201402L
- // expected-error at -2 {{not implicitly convertible}}
-#endif
+ // since-cxx17-error at -1 {{value of type 'void (*)() throw(int, float)' is not implicitly convertible to 'void (*)() throw()'}}
- template<void() throw(int)> struct Y {}; // expected-error 0-1{{ISO C++17 does not allow}} expected-note 0-1{{use 'noexcept}}
+ template<void() throw(int)> struct Y {};
+ // since-cxx17-error at -1 {{ISO C++17 does not allow dynamic exception specifications}}
+ // since-cxx17-note at -2 {{use 'noexcept(false)' instead}}
Y<&h> yp; // ok
}
@@ -1204,12 +1398,14 @@ namespace dr95 { // dr95: 3.3
class C {
friend struct A;
friend struct B;
- static void f(); // expected-note {{here}}
+ static void f(); // #dr95-C-f
};
struct A *p; // dr95::A, not dr95::N::A.
}
A *q = N::p; // ok, same type
- struct B { void f() { N::C::f(); } }; // expected-error {{private}}
+ struct B { void f() { N::C::f(); } };
+ // expected-error at -1 {{'f' is a private member of 'dr95::N::C'}}
+ // expected-note@#dr95-C-f {{implicitly declared private here}}
}
namespace dr96 { // dr96: no
@@ -1242,19 +1438,27 @@ namespace dr97 { // dr97: yes
namespace dr98 { // dr98: yes
void test(int n) {
switch (n) {
- try { // expected-note 2{{bypasses}}
- case 0: // expected-error {{cannot jump}}
+ try { // #dr98-try
+ case 0:
+ // expected-error at -1 {{cannot jump from switch statement to this case label}}
+ // expected-note@#dr98-try {{jump bypasses initialization of try block}}
x:
throw n;
- } catch (...) { // expected-note 2{{bypasses}}
- case 1: // expected-error {{cannot jump}}
+ } catch (...) { // #dr98-catch
+ case 1:
+ // expected-error at -1 {{cannot jump from switch statement to this case label}}
+ // expected-note@#dr98-catch {{jump bypasses initialization of catch block}}
y:
throw n;
}
case 2:
- goto x; // expected-error {{cannot jump}}
+ goto x;
+ // expected-error at -1 {{cannot jump from this goto statement to its label}}
+ // expected-note@#dr98-try {{jump bypasses initialization of try block}}
case 3:
- goto y; // expected-error {{cannot jump}}
+ goto y;
+ // expected-error at -1 {{cannot jump from this goto statement to its label}}
+ // expected-note@#dr98-catch {{jump bypasses initialization of catch block}}
}
}
}
More information about the cfe-commits
mailing list