[Lldb-commits] [flang] [libcxx] [lld] [libc] [clang] [lldb] [llvm] [clang][NFC] Refactor expected directives in C++ DRs 100-199 (PR #74061)
Vlad Serebrennikov via lldb-commits
lldb-commits at lists.llvm.org
Fri Dec 1 03:17:08 PST 2023
https://github.com/Endilll created https://github.com/llvm/llvm-project/pull/74061
This patch continues the work started with ea5b1ef016d020c37f903d6c7d4f623be975dab8. See that commit and its corresponding PR for details.
>From e6b9f54ce066e029b043e72281a7144338a84219 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Fri, 1 Dec 2023 13:35:23 +0300
Subject: [PATCH 1/2] [clang][NFC] Fill in historical data on when C++ DRs
100-199 were fixed
---
clang/test/CXX/drs/dr1xx.cpp | 20 ++++++++++----------
clang/www/cxx_dr_status.html | 20 ++++++++++----------
2 files changed, 20 insertions(+), 20 deletions(-)
diff --git a/clang/test/CXX/drs/dr1xx.cpp b/clang/test/CXX/drs/dr1xx.cpp
index 60e80a4c0e1c4f9..50236eb7c9499d4 100644
--- a/clang/test/CXX/drs/dr1xx.cpp
+++ b/clang/test/CXX/drs/dr1xx.cpp
@@ -72,7 +72,7 @@ namespace dr107 { // dr107: yes
extern "C" S operator+(S, S) { return S(); }
}
-namespace dr108 { // dr108: yes
+namespace dr108 { // dr108: 2.9
template<typename T> struct A {
struct B { typedef int X; };
B::X x;
@@ -143,7 +143,7 @@ namespace dr114 { // dr114: yes
} b; // expected-error {{abstract}}
}
-namespace dr115 { // dr115: yes
+namespace dr115 { // dr115: 3.0
template<typename T> int f(T); // expected-note +{{}}
template<typename T> int g(T); // expected-note +{{}}
template<typename T> int g(T, int); // expected-note +{{}}
@@ -480,7 +480,7 @@ namespace dr140 { // dr140: yes
void g(int n) { n = 2; }
}
-namespace dr141 { // dr141: yes
+namespace dr141 { // dr141: 3.1
template<typename T> void f();
template<typename T> struct S { int n; }; // expected-note {{'::dr141::S<int>::n' declared here}}
struct A : S<int> {
@@ -518,7 +518,7 @@ namespace dr141 { // dr141: yes
void i() { C<X>().i(); } // ok!!
}
-namespace dr142 { // dr142: yes
+namespace dr142 { // dr142: 2.8
class B { // expected-note +{{here}}
public:
int mi; // expected-note +{{here}}
@@ -602,7 +602,7 @@ namespace dr148 { // dr148: yes
// dr149: na
-namespace dr151 { // dr151: yes
+namespace dr151 { // dr151: 3.1
struct X {};
typedef int X::*p;
#if __cplusplus < 201103L
@@ -655,7 +655,7 @@ namespace dr159 { // dr159: 3.5
// dr160: na
-namespace dr161 { // dr161: yes
+namespace dr161 { // dr161: 3.1
class A {
protected:
struct B { int n; } b; // expected-note 2{{here}}
@@ -724,7 +724,7 @@ namespace dr165 { // dr165: no
void N::g() {}
}
-namespace dr166 { // dr166: yes
+namespace dr166 { // dr166: 2.9
namespace A { class X; }
template<typename T> int f(T t) { return t.n; }
@@ -827,7 +827,7 @@ namespace dr173 { // dr173: yes
// dr174: sup 1012
-namespace dr175 { // dr175: yes
+namespace dr175 { // dr175: 2.8
struct A {}; // expected-note {{here}}
struct B : private A {}; // expected-note {{constrained by private inheritance}}
struct C : B {
@@ -836,7 +836,7 @@ namespace dr175 { // dr175: yes
};
}
-namespace dr176 { // dr176: yes
+namespace dr176 { // dr176: 3.1
template<typename T> class Y;
template<> class Y<int> {
void f() {
@@ -904,7 +904,7 @@ namespace dr179 { // dr179: yes
int n = &f - &f; // expected-error {{arithmetic on pointers to the function type 'void ()'}}
}
-namespace dr180 { // dr180: yes
+namespace dr180 { // dr180: 2.8
template<typename T> struct X : T, T::some_base {
X() : T::some_type_that_might_be_T(), T::some_base() {}
friend class T::some_class;
diff --git a/clang/www/cxx_dr_status.html b/clang/www/cxx_dr_status.html
index 7cf657a47d64093..141b2aa515ad9ad 100755
--- a/clang/www/cxx_dr_status.html
+++ b/clang/www/cxx_dr_status.html
@@ -685,7 +685,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/108.html">108</a></td>
<td>TC1</td>
<td>Are classes nested in templates dependent?</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 2.9</td>
</tr>
<tr id="109">
<td><a href="https://cplusplus.github.io/CWG/issues/109.html">109</a></td>
@@ -727,7 +727,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/115.html">115</a></td>
<td>CD1</td>
<td>Address of template-id</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 3.0</td>
</tr>
<tr id="116">
<td><a href="https://cplusplus.github.io/CWG/issues/116.html">116</a></td>
@@ -883,13 +883,13 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/141.html">141</a></td>
<td>CD1</td>
<td>Non-member function templates in member access expressions</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 3.1</td>
</tr>
<tr id="142">
<td><a href="https://cplusplus.github.io/CWG/issues/142.html">142</a></td>
<td>TC1</td>
<td>Injection-related errors in access example</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 2.8</td>
</tr>
<tr id="143">
<td><a href="https://cplusplus.github.io/CWG/issues/143.html">143</a></td>
@@ -943,7 +943,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/151.html">151</a></td>
<td>TC1</td>
<td>Terminology of zero-initialization</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 3.1</td>
</tr>
<tr id="152">
<td><a href="https://cplusplus.github.io/CWG/issues/152.html">152</a></td>
@@ -1003,7 +1003,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/161.html">161</a></td>
<td>TC1</td>
<td>Access to protected nested type</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 3.1</td>
</tr>
<tr id="162">
<td><a href="https://cplusplus.github.io/CWG/issues/162.html">162</a></td>
@@ -1033,7 +1033,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/166.html">166</a></td>
<td>TC1</td>
<td>Friend declarations of <I>template-id</I>s</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 2.9</td>
</tr>
<tr id="167">
<td><a href="https://cplusplus.github.io/CWG/issues/167.html">167</a></td>
@@ -1087,13 +1087,13 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/175.html">175</a></td>
<td>CD1</td>
<td>Class name injection and base name access</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 2.8</td>
</tr>
<tr id="176">
<td><a href="https://cplusplus.github.io/CWG/issues/176.html">176</a></td>
<td>TC1</td>
<td>Name injection and templates</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 3.1</td>
</tr>
<tr id="177">
<td><a href="https://cplusplus.github.io/CWG/issues/177.html">177</a></td>
@@ -1117,7 +1117,7 @@ <h2 id="cxxdr">C++ defect report implementation status</h2>
<td><a href="https://cplusplus.github.io/CWG/issues/180.html">180</a></td>
<td>CD1</td>
<td><TT>typename</TT> and elaborated types</td>
- <td class="full" align="center">Yes</td>
+ <td class="full" align="center">Clang 2.8</td>
</tr>
<tr id="181">
<td><a href="https://cplusplus.github.io/CWG/issues/181.html">181</a></td>
>From 3b8c82776b64cd37ec5785ec30143ecab84065d1 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Fri, 1 Dec 2023 13:42:36 +0300
Subject: [PATCH 2/2] [clang][NFC] Refactor expected directives in C++ DRs
100-199
This patch continues the work started with ea5b1ef016d020c37f903d6c7d4f623be975dab8. See that commit and its corresponding PR for details.
---
clang/test/CXX/drs/dr1xx.cpp | 684 ++++++++++++++++++++++-------------
1 file changed, 436 insertions(+), 248 deletions(-)
diff --git a/clang/test/CXX/drs/dr1xx.cpp b/clang/test/CXX/drs/dr1xx.cpp
index 50236eb7c9499d4..e80999e7a2d0cff 100644
--- a/clang/test/CXX/drs/dr1xx.cpp
+++ b/clang/test/CXX/drs/dr1xx.cpp
@@ -1,30 +1,31 @@
-// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify=expected,cxx98,cxx98-11,cxx98-14,cxx98-17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,cxx98-11,cxx98-14,cxx98-17,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,cxx98-14,cxx98-17,cxx11-14 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17,cxx98-17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr100 { // dr100: yes
- template<const char (*)[4]> struct A {}; // expected-note 0-1{{declared here}}
- template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}}
- template<const char *> struct C {}; // expected-note 0-1{{declared here}}
- template<const char &> struct D {}; // expected-note 0-1{{declared here}}
- A<&"foo"> a; // #100a
- B<"bar"> b; // #100b
- C<"baz"> c; // #100c
- D<*"quux"> d; // #100d
-#if __cplusplus < 201703L
- // expected-error@#100a {{does not refer to any declaration}}
- // expected-error@#100b {{does not refer to any declaration}}
- // expected-error@#100c {{does not refer to any declaration}}
- // expected-error@#100d {{does not refer to any declaration}}
-#else
- // expected-error@#100a {{pointer to string literal is not allowed in a template argument}}
- // expected-error@#100b {{reference to string literal is not allowed in a template argument}}
- // expected-error@#100c {{pointer to subobject of string literal is not allowed in a template argument}}
- // expected-error@#100d {{reference to subobject of string literal is not allowed in a template argument}}
-#endif
+ template<const char (*)[4]> struct A {}; // #dr100-A
+ template<const char (&)[4]> struct B {}; // #dr100-B
+ template<const char *> struct C {}; // #dr100-C
+ template<const char &> struct D {}; // #dr100-D
+ A<&"foo"> a; // #dr100-a
+ // cxx98-14-error@#dr100-a {{non-type template argument does not refer to any declaration}}
+ // cxx98-14-note@#dr100-A {{template parameter is declared here}}
+ // since-cxx17-error@#dr100-a {{pointer to string literal is not allowed in a template argument}}
+ B<"bar"> b; // #dr100-b
+ // cxx98-14-error@#dr100-b {{non-type template argument does not refer to any declaration}}
+ // cxx98-14-note@#dr100-B {{template parameter is declared here}}
+ // since-cxx17-error@#dr100-b {{reference to string literal is not allowed in a template argument}}
+ C<"baz"> c; // #dr100-c
+ // cxx98-14-error@#dr100-c {{non-type template argument does not refer to any declaration}}
+ // cxx98-14-note@#dr100-C {{template parameter is declared here}}
+ // since-cxx17-error@#dr100-c {{pointer to subobject of string literal is not allowed in a template argument}}
+ D<*"quux"> d; // #dr100-d
+ // cxx98-14-error@#dr100-d {{non-type template argument does not refer to any declaration}}
+ // cxx98-14-note@#dr100-D {{template parameter is declared here}}
+ // since-cxx17-error@#dr100-d {{reference to subobject of string literal is not allowed in a template argument}}
}
namespace dr101 { // dr101: 3.5
@@ -42,13 +43,16 @@ namespace dr101 { // dr101: 3.5
namespace dr102 { // dr102: yes
namespace A {
- template<typename T> T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
+ template<typename T> T f(T a, T b) { return 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@#dr102-instantiation {{in instantiation of function template specialization 'dr102::A::f<dr102::B::S>' requested here}}
+ // expected-note@#dr102-operator-plus {{'operator+' should be declared prior to the call site or in namespace 'dr102::B'}}
}
namespace B {
struct S {};
}
- B::S operator+(B::S, B::S); // expected-note {{should be declared prior to the call site or in namespace 'dr102::B'}}
- template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}}
+ B::S operator+(B::S, B::S); // #dr102-operator-plus
+ template B::S A::f(B::S, B::S); // #dr102-instantiation
}
// dr103: na
@@ -58,13 +62,17 @@ namespace dr102 { // dr102: yes
namespace dr106 { // dr106: sup 540
typedef int &r1;
typedef r1 &r1;
- typedef const r1 r1; // expected-warning {{has no effect}}
- typedef const r1 &r1; // expected-warning {{has no effect}}
+ typedef const r1 r1;
+ // expected-warning at -1 {{'const' qualifier on reference type 'r1' (aka 'int &') has no effect}}
+ typedef const r1 &r1;
+ // expected-warning at -1 {{'const' qualifier on reference type 'r1' (aka 'int &') has no effect}}
typedef const int &r2;
typedef r2 &r2;
- typedef const r2 r2; // expected-warning {{has no effect}}
- typedef const r2 &r2; // expected-warning {{has no effect}}
+ typedef const r2 r2;
+ // expected-warning at -1 {{'const' qualifier on reference type 'r2' (aka 'const int &') has no effect}}
+ typedef const r2 &r2;
+ // expected-warning at -1 {{'const' qualifier on reference type 'r2' (aka 'const int &') has no effect}}
}
namespace dr107 { // dr107: yes
@@ -76,10 +84,9 @@ namespace dr108 { // dr108: 2.9
template<typename T> struct A {
struct B { typedef int X; };
B::X x;
-#if __cplusplus <= 201703L
- // expected-error at -2 {{implicit 'typename' is a C++20 extension}}
-#endif
- struct C : B { X x; }; // expected-error {{unknown type name}}
+ // cxx98-17-error at -1 {{missing 'typename' prior to dependent type name B::X; implicit 'typename' is a C++20 extension}}
+ struct C : B { X x; };
+ // expected-error at -1 {{unknown type name 'X'}}
};
template<> struct A<int>::B { int X; };
}
@@ -87,46 +94,55 @@ namespace dr108 { // dr108: 2.9
namespace dr109 { // dr109: yes
struct A { template<typename T> void f(T); };
template<typename T> struct B : T {
- using T::template f; // expected-error {{'template' keyword not permitted here}}
- using T::template f<int>; // expected-error {{'template' keyword not permitted here}} expected-error {{using declaration cannot refer to a template specialization}}
+ using T::template f;
+ // expected-error at -1 {{'template' keyword not permitted here}}
+ using T::template f<int>;
+ // expected-error at -1 {{'template' keyword not permitted here}}
+ // expected-error at -2 {{using declaration cannot refer to a template specialization}}
// FIXME: We shouldn't suggest using the 'template' keyword in a location where it's not valid.
- using T::f<int>; // expected-error {{use 'template' keyword}} expected-error {{using declaration cannot refer to a template specialization}}
- void g() { this->f<int>(123); } // expected-error {{use 'template' keyword}}
+ using T::f<int>;
+ // expected-error at -1 {{use 'template' keyword to treat 'f' as a dependent template name}}
+ // expected-error at -2 {{using declaration cannot refer to a template specialization}}
+ void g() { this->f<int>(123); }
+ // expected-error at -1 {{use 'template' keyword to treat 'f' as a dependent template name}}
};
}
namespace dr111 { // dr111: dup 535
struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); };
- struct B : A { B(); }; // expected-note +{{would lose const qualifier}} expected-note {{requires 0 arguments}}
+ struct B : A { B(); }; // #dr111-B
const B b1;
- B b2(b1); // expected-error {{no matching constructor}}
+ B b2(b1);
+ // expected-error at -1 {{no matching constructor for initialization of 'B'}}
+ // expected-note@#dr111-B {{candidate constructor (the implicit copy constructor) not viable: 1st argument ('const B') would lose const qualifier}}
+ // expected-note@#dr111-B {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
}
namespace dr112 { // dr112: yes
struct T { int n; };
typedef T Arr[1];
- const T a1[1] = {};
+ const T a1[1] = {}; // #dr112-a1
volatile T a2[1] = {};
- const Arr a3 = {};
+ const Arr a3 = {}; // #dr112-a3
volatile Arr a4 = {};
template<const volatile T*> struct X {};
+ // FIXME: Test this somehow in C++11 and on.
X<a1> x1;
+ // cxx98-error at -1 {{non-type template argument referring to object 'a1' with internal linkage is a C++11 extension}}
+ // cxx98-note@#dr112-a1 {{non-type template argument refers to object here}}
X<a2> x2;
X<a3> x3;
+ // cxx98-error at -1 {{non-type template argument referring to object 'a3' with internal linkage is a C++11 extension}}
+ // cxx98-note@#dr112-a3 {{non-type template argument refers to object here}}
X<a4> x4;
-#if __cplusplus < 201103L
- // expected-error at -5 {{internal linkage}} expected-note at -10 {{here}}
- // expected-error at -4 {{internal linkage}} expected-note at -9 {{here}}
-#else
- // FIXME: Test this somehow.
-#endif
}
namespace dr113 { // dr113: yes
extern void (*p)();
void f() {
- no_such_function(); // expected-error {{undeclared}}
+ no_such_function();
+ // expected-error at -1 {{use of undeclared identifier 'no_such_function'}}
p();
}
void g();
@@ -135,31 +151,48 @@ namespace dr113 { // dr113: yes
namespace dr114 { // dr114: yes
struct A {
- virtual void f(int) = 0; // expected-note {{unimplemented}}
+ virtual void f(int) = 0; // #dr114-A-f
};
struct B : A {
template<typename T> void f(T);
void g() { f(0); }
- } b; // expected-error {{abstract}}
+ } b;
+ // expected-error at -1 {{variable type 'struct B' is an abstract class}}
+ // expected-note@#dr114-A-f {{unimplemented pure virtual method 'f' in 'B'}}
}
namespace dr115 { // dr115: 3.0
- template<typename T> int f(T); // expected-note +{{}}
- template<typename T> int g(T); // expected-note +{{}}
- template<typename T> int g(T, int); // expected-note +{{}}
+ template<typename T> int f(T); // #dr115-f
+ template<typename T> int g(T); // #dr115-g
+ template<typename T> int g(T, int); // #dr115-g-int
- int k1 = f(&f); // expected-error {{no match}}
+ int k1 = f(&f);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr115-f {{candidate template ignored: couldn't infer template argument 'T'}}
int k2 = f(&f<int>);
- int k3 = f(&g<int>); // expected-error {{no match}}
+ int k3 = f(&g<int>);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr115-f {{candidate template ignored: couldn't infer template argument 'T'}}
void h() {
- (void)&f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}}
+ (void)&f;
+ // expected-error at -1 {{address of overloaded function 'f' cannot be cast to type 'void'}}
+ // expected-note@#dr115-f {{candidate function template}}
(void)&f<int>;
- (void)&g<int>; // expected-error {{address of overloaded function 'g' cannot be cast to type 'void'}}
-
- &f; // expected-error {{reference to overloaded function could not be resolved}}
- &f<int>; // expected-warning {{unused}}
- &g<int>; // expected-error {{reference to overloaded function could not be resolved}}
+ (void)&g<int>;
+ // expected-error at -1 {{address of overloaded function 'g' cannot be cast to type 'void'}}
+ // expected-note@#dr115-g-int {{candidate function template}}
+ // expected-note@#dr115-g {{candidate function template}}
+
+ &f;
+ // expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ // expected-note@#dr115-f {{possible target for call}}
+ &f<int>;
+ // expected-warning at -1 {{expression result unused}}
+ &g<int>;
+ // expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ // expected-note@#dr115-g-int {{possible target for call}}
+ // expected-note@#dr115-g {{possible target for call}}
}
struct S {
@@ -168,18 +201,25 @@ namespace dr115 { // dr115: 3.0
template<typename T> static int g(T, int);
} s;
- int k4 = f(&s.f); // expected-error {{non-constant pointer to member}}
+ int k4 = f(&s.f);
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
int k5 = f(&s.f<int>);
- int k6 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
+ int k6 = f(&s.g<int>);
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
void i() {
- (void)&s.f; // expected-error {{non-constant pointer to member}}
+ (void)&s.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
(void)&s.f<int>;
- (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
-
- &s.f; // expected-error {{non-constant pointer to member}}
- &s.f<int>; // expected-warning {{unused}}
- &s.g<int>; // expected-error {{non-constant pointer to member}}
+ (void)&s.g<int>;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
+
+ &s.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
+ &s.f<int>;
+ // expected-warning at -1 {{expression result unused}}
+ &s.g<int>;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
}
struct T {
@@ -188,40 +228,58 @@ namespace dr115 { // dr115: 3.0
template<typename T> int g(T, int);
} t;
- int k7 = f(&s.f); // expected-error {{non-constant pointer to member}}
+ int k7 = f(&s.f);
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
int k8 = f(&s.f<int>);
- int k9 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
+ int k9 = f(&s.g<int>);
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
void j() {
- (void)&s.f; // expected-error {{non-constant pointer to member}}
+ (void)&s.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
(void)&s.f<int>;
- (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
-
- &s.f; // expected-error {{non-constant pointer to member}}
- &s.f<int>; // expected-warning {{unused}}
- &s.g<int>; // expected-error {{non-constant pointer to member}}
+ (void)&s.g<int>;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
+
+ &s.f;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
+ &s.f<int>;
+ // expected-warning at -1 {{expression result unused}}
+ &s.g<int>;
+ // expected-error at -1 {{cannot create a non-constant pointer to member function}}
}
#if __cplusplus >= 201103L
// Special case kicks in only if a template argument list is specified.
- template<typename T=int> void with_default(); // expected-note +{{}}
- int k10 = f(&with_default); // expected-error {{no matching function}}
+ template<typename T=int> void with_default(); // #dr115-with-default
+ int k10 = f(&with_default);
+ // expected-error at -1 {{no matching function for call to 'f'}}
+ // expected-note@#dr115-f {{candidate template ignored: couldn't infer template argument 'T'}}
int k11 = f(&with_default<>);
void k() {
- (void)&with_default; // expected-error {{overloaded function}}
+ (void)&with_default;
+ // expected-error at -1 {{address of overloaded function 'with_default' cannot be cast to type 'void'}}
+ // expected-note@#dr115-with-default {{candidate function template}}
(void)&with_default<>;
- &with_default; // expected-error {{overloaded function}}
- &with_default<>; // expected-warning {{unused}}
+ &with_default;
+ // expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ // expected-note@#dr115-with-default {{possible target for call}}
+ &with_default<>;
+ // expected-warning at -1 {{expression result unused}}
}
#endif
}
namespace dr116 { // dr116: yes
template<int> struct A {};
- template<int N> void f(A<N>) {} // expected-note {{previous}}
- template<int M> void f(A<M>) {} // expected-error {{redefinition}}
- template<typename T> void f(A<sizeof(T)>) {} // expected-note {{previous}}
- template<typename U> void f(A<sizeof(U)>) {} // expected-error {{redefinition}}
+ template<int N> void f(A<N>) {} // #dr116-f-N
+ template<int M> void f(A<M>) {}
+ // expected-error at -1 {{redefinition of 'f'}}
+ // expected-note@#dr116-f-N {{previous definition is here}}
+ template<typename T> void f(A<sizeof(T)>) {} // #dr116-f-T
+ template<typename U> void f(A<sizeof(U)>) {}
+ // expected-error at -1 {{redefinition of 'f'}}
+ // expected-note@#dr116-f-T {{previous definition is here}}
}
// dr117: na
@@ -235,7 +293,9 @@ namespace dr121 { // dr121: yes
};
template<typename T> struct Z {
X::Y<T> x;
- T::Y<T> y; // expected-error +{{}}
+ T::Y<T> y;
+ // expected-error at -1 {{use 'template' keyword to treat 'Y' as a dependent template name}}
+ // cxx98-17-error at -2 {{missing 'typename' prior to dependent type name T::Y; implicit 'typename' is a C++20 extension}}
};
Z<X> z;
}
@@ -249,15 +309,19 @@ namespace dr122 { // dr122: yes
// dr124: dup 201
// dr125: yes
-struct dr125_A { struct dr125_B {}; }; // expected-note {{here}}
+struct dr125_A { struct dr125_B {}; }; // #dr125_B
dr125_A::dr125_B dr125_C();
namespace dr125_B { dr125_A dr125_C(); }
namespace dr125 {
struct X {
friend dr125_A::dr125_B (::dr125_C)(); // ok
friend dr125_A (::dr125_B::dr125_C)(); // ok
- friend dr125_A::dr125_B::dr125_C(); // expected-error {{did you mean the constructor name 'dr125_B'?}}
- // expected-error at -1 {{missing exception specification}}
+ friend dr125_A::dr125_B::dr125_C(); // #dr125_C
+ // expected-error@#dr125_C {{missing return type for function 'dr125_C'; did you mean the constructor name 'dr125_B'?}}
+ // cxx98-error@#dr125_C {{'dr125_B' is missing exception specification 'throw()'}}
+ // cxx98-note@#dr125_B {{previous declaration is here}}
+ // since-cxx11-error@#dr125_C {{'dr125_B' is missing exception specification 'noexcept'}}
+ // since-cxx11-note@#dr125_B {{previous declaration is here}}
};
}
@@ -275,7 +339,6 @@ namespace dr126 { // dr126: partial
// So, when catching by non-const (or volatile) reference to pointer, we
// should compare the exception type to the caught type and only accept an
// exact match.
-#if __cplusplus <= 201402L
struct C {};
struct D : C {};
struct E : private C { friend class A; friend class B; };
@@ -283,53 +346,64 @@ namespace dr126 { // dr126: partial
struct G : C {};
struct H : D, G {};
+#if __cplusplus <= 201402L
struct A {
virtual void cp() throw(C*);
virtual void dp() throw(C*);
- virtual void ep() throw(C*); // expected-note {{overridden}}
- virtual void fp() throw(C*); // expected-note {{overridden}}
+ virtual void ep() throw(C*); // #dr126-ep
+ virtual void fp() throw(C*); // #dr126-fp
virtual void gp() throw(C*);
- virtual void hp() throw(C*); // expected-note {{overridden}}
+ virtual void hp() throw(C*); // #dr126-hp
virtual void cr() throw(C&);
virtual void dr() throw(C&);
- virtual void er() throw(C&); // expected-note {{overridden}}
- virtual void fr() throw(C&); // expected-note {{overridden}}
+ virtual void er() throw(C&); // #dr126-er
+ virtual void fr() throw(C&); // #dr126-fr
virtual void gr() throw(C&);
- virtual void hr() throw(C&); // expected-note {{overridden}}
+ virtual void hr() throw(C&); // #dr126-hr
virtual void pv() throw(void*);
-#if __cplusplus >= 201103L
virtual void np() throw(C*);
virtual void npm() throw(int C::*);
- virtual void nr() throw(C*&); // expected-note {{overridden}}
+ virtual void nr() throw(C*&); // #dr126-nr
virtual void ncr() throw(C*const&);
-#endif
virtual void ref1() throw(C *const&);
virtual void ref2() throw(C *);
virtual void v() throw(int);
virtual void w() throw(const int);
- virtual void x() throw(int*); // expected-note {{overridden}}
+ virtual void x() throw(int*); // #dr126-x
virtual void y() throw(const int*);
- virtual void z() throw(int); // expected-note {{overridden}}
+ virtual void z() throw(int); // #dr126-z
};
struct B : A {
virtual void cp() throw(C*);
virtual void dp() throw(D*);
- virtual void ep() throw(E*); // expected-error {{more lax}}
- virtual void fp() throw(F*); // expected-error {{more lax}}
+ virtual void ep() throw(E*);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-ep {{overridden virtual function is here}}
+ virtual void fp() throw(F*);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-fp {{overridden virtual function is here}}
virtual void gp() throw(G*);
- virtual void hp() throw(H*); // expected-error {{more lax}}
+ virtual void hp() throw(H*);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-hp {{overridden virtual function is here}}
virtual void cr() throw(C&);
virtual void dr() throw(D&);
- virtual void er() throw(E&); // expected-error {{more lax}}
- virtual void fr() throw(F&); // expected-error {{more lax}}
+ virtual void er() throw(E&);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-er {{overridden virtual function is here}}
+ virtual void fr() throw(F&);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-fr {{overridden virtual function is here}}
virtual void gr() throw(G&);
- virtual void hr() throw(H&); // expected-error {{more lax}}
+ virtual void hr() throw(H&);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-hr {{overridden virtual function is here}}
virtual void pv() throw(C*);
@@ -337,22 +411,29 @@ namespace dr126 { // dr126: partial
using nullptr_t = decltype(nullptr);
virtual void np() throw(nullptr_t);
virtual void npm() throw(nullptr_t&);
- virtual void nr() throw(nullptr_t); // expected-error {{more lax}}
+ virtual void nr() throw(nullptr_t);
+ // cxx11-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx11-14-note@#dr126-nr {{overridden virtual function is here}}
virtual void ncr() throw(nullptr_t);
-#endif
+#endif // __cplusplus >= 201103L
virtual void ref1() throw(D *const &);
virtual void ref2() throw(D *);
virtual void v() throw(const int);
virtual void w() throw(int);
- virtual void x() throw(const int*); // expected-error {{more lax}}
+ virtual void x() throw(const int*);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-x {{overridden virtual function is here}}
virtual void y() throw(int*); // ok
- virtual void z() throw(long); // expected-error {{more lax}}
+ virtual void z() throw(long);
+ // cxx98-14-error at -1 {{exception specification of overriding function is more lax than base version}}
+ // cxx98-14-note@#dr126-z {{overridden virtual function is here}}
};
-#else
- void f() throw(int); // expected-error {{ISO C++17 does not allow}} expected-note {{use 'noexcept}}
-#endif
+#endif // __cplusplus <= 201402L
+ 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}}
}
namespace dr127 { // dr127: yes
@@ -360,11 +441,16 @@ namespace dr127 { // dr127: yes
template<typename T> struct A {
A() { throw 0; }
void *operator new(size_t, const char * = 0);
- void operator delete(void *, const char *) { T::error; } // expected-error 2{{no members}}
+ void operator delete(void *, const char *) { T::error; } // #dr127-delete-const-char
+ // expected-error@#dr127-delete-const-char {{type 'void' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr127-p {{in instantiation of member function 'dr127::A<void>::operator delete' requested here}}
+
+ // expected-error@#dr127-delete-const-char {{type 'int' cannot be used prior to '::' because it has no members}}
+ // expected-note@#dr127-q {{in instantiation of member function 'dr127::A<int>::operator delete' requested here}}
void operator delete(void *) { T::error; }
};
- A<void> *p = new A<void>; // expected-note {{instantiat}}
- A<int> *q = new ("") A<int>; // expected-note {{instantiat}}
+ A<void> *p = new A<void>; // #dr127-p
+ A<int> *q = new ("") A<int>; // #dr127-q
}
namespace dr128 { // dr128: yes
@@ -401,36 +487,50 @@ namespace dr135 { // dr135: yes
}
namespace dr136 { // dr136: 3.4
- void f(int, int, int = 0); // expected-note {{previous declaration is here}}
- void g(int, int, int); // expected-note {{previous declaration is here}}
+ void f(int, int, int = 0); // #dr136-f
+ void g(int, int, int); // #dr136-g
struct A {
- friend void f(int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
- friend void g(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
- friend void h(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be a definition}}
- friend void i(int, int, int = 0) {} // expected-note {{previous declaration is here}}
+ friend void f(int, int = 0, int);
+ // expected-error at -1 {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-f {{previous declaration is here}}
+ friend void g(int, int, int = 0);
+ // expected-error at -1 {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-g {{previous declaration is here}}
+ friend void h(int, int, int = 0);
+ // expected-error at -1 {{friend declaration specifying a default argument must be a definition}}
+ friend void i(int, int, int = 0) {} // #dr136-A-i
friend void j(int, int, int = 0) {}
operator int();
};
- void i(int, int, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
+ void i(int, int, int);
+ // expected-error at -1 {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-A-i {{previous declaration is here}}
void q() {
j(A(), A()); // ok, has default argument
}
- extern "C" void k(int, int, int, int); // expected-note 2{{previous declaration is here}}
+ extern "C" void k(int, int, int, int); // #dr136-k
namespace NSA {
struct A {
- friend void dr136::k(int, int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
+ friend void dr136::k(int, int, int, int = 0);
+ // expected-error at -1 {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-k {{previous declaration is here}}
};
}
namespace NSB {
struct A {
- friend void dr136::k(int, int, int = 0, int); // expected-error {{missing default argument on parameter}} expected-error {{must be the only declaration}}
+ friend void dr136::k(int, int, int = 0, int); // #dr136-friend-k
+ // expected-error@#dr136-friend-k {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-k {{previous declaration is here}}
+ // expected-error@#dr136-friend-k {{missing default argument on parameter}}
};
}
struct B {
- void f(int); // expected-note {{previous declaration is here}}
+ void f(int); // #dr136-B-f
};
struct C {
- friend void B::f(int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
+ friend void B::f(int = 0);
+ // expected-error at -1 {{friend declaration specifying a default argument must be the only declaration}}
+ // expected-note@#dr136-B-f {{previous declaration is here}}
};
}
@@ -440,13 +540,18 @@ namespace dr137 { // dr137: yes
extern volatile void *vp;
extern const volatile void *cvp;
int *q = static_cast<int*>(p);
- int *qc = static_cast<int*>(cp); // expected-error {{casts away qualifiers}}
- int *qv = static_cast<int*>(vp); // expected-error {{casts away qualifiers}}
- int *qcv = static_cast<int*>(cvp); // expected-error {{casts away qualifiers}}
+ int *qc = static_cast<int*>(cp);
+ // expected-error at -1 {{static_cast from 'const void *' to 'int *' casts away qualifiers}}
+ int *qv = static_cast<int*>(vp);
+ // expected-error at -1 {{static_cast from 'volatile void *' to 'int *' casts away qualifiers}}
+ int *qcv = static_cast<int*>(cvp);
+ // expected-error at -1 {{static_cast from 'const volatile void *' to 'int *' casts away qualifiers}}
const int *cq = static_cast<const int*>(p);
const int *cqc = static_cast<const int*>(cp);
- const int *cqv = static_cast<const int*>(vp); // expected-error {{casts away qualifiers}}
- const int *cqcv = static_cast<const int*>(cvp); // expected-error {{casts away qualifiers}}
+ const int *cqv = static_cast<const int*>(vp);
+ // expected-error at -1 {{static_cast from 'volatile void *' to 'const int *' casts away qualifiers}}
+ const int *cqcv = static_cast<const int*>(cvp);
+ // expected-error at -1 {{static_cast from 'const volatile void *' to 'const int *' casts away qualifiers}}
const volatile int *cvq = static_cast<const volatile int*>(p);
const volatile int *cvqc = static_cast<const volatile int*>(cp);
const volatile int *cvqv = static_cast<const volatile int*>(vp);
@@ -455,9 +560,11 @@ namespace dr137 { // dr137: yes
namespace dr139 { // dr139: yes
namespace example1 {
- typedef int f; // expected-note {{previous}}
+ typedef int f; // #dr139-typedef-f
struct A {
- friend void f(A &); // expected-error {{different kind of symbol}}
+ friend void f(A &);
+ // expected-error at -1 {{redefinition of 'f' as different kind of symbol}}
+ // expected-note@#dr139-typedef-f {{previous definition is here}}
};
}
@@ -474,35 +581,41 @@ namespace dr139 { // dr139: yes
}
namespace dr140 { // dr140: yes
- void f(int *const) {} // expected-note {{previous}}
- void f(int[3]) {} // expected-error {{redefinition}}
+ void f(int *const) {} // #dr140-f-first
+ void f(int[3]) {}
+ // expected-error at -1 {{redefinition of 'f'}}
+ // expected-note@#dr140-f-first {{previous definition is here}}
void g(const int);
void g(int n) { n = 2; }
}
namespace dr141 { // dr141: 3.1
template<typename T> void f();
- template<typename T> struct S { int n; }; // expected-note {{'::dr141::S<int>::n' declared here}}
+ template<typename T> struct S { int n; }; // #dr141-S
struct A : S<int> {
template<typename T> void f();
- template<typename T> struct S {};
+ template<typename T> struct S {}; // #dr141-A-S
} a;
struct B : S<int> {} b;
void g() {
a.f<int>();
- (void)a.S<int>::n; // expected-error {{no member named 'n' in 'dr141::A::S<int>'; did you mean '::dr141::S<int>::n'?}}
-#if __cplusplus < 201103L
- // expected-error at -2 {{ambiguous}}
- // expected-note at -11 {{lookup from the current scope}}
- // expected-note at -9 {{lookup in the object type}}
-#endif
- b.f<int>(); // expected-error {{no member}} expected-error +{{}}
+ (void)a.S<int>::n; // #dr141-a
+ // cxx98-error@#dr141-a {{lookup of 'S' in member access expression is ambiguous; using member of 'struct A'}}
+ // cxx98-note@#dr141-A-S {{lookup in the object type 'struct A' refers here}}
+ // cxx98-note@#dr141-S {{lookup from the current scope refers here}}
+ // expected-error@#dr141-a {{no member named 'n' in 'dr141::A::S<int>'; did you mean '::dr141::S<int>::n'?}}
+ // expected-note@#dr141-S {{'::dr141::S<int>::n' declared here}}
+ // FIXME: we issue a useful diagnostic first, then some bogus ones.
+ b.f<int>();
+ // expected-error at -1 {{no member named 'f' in 'dr141::B'}}
+ // expected-error at -2 +{{}}
(void)b.S<int>::n;
}
template<typename T> struct C {
T t;
void g() {
- t.f<int>(); // expected-error {{use 'template'}}
+ t.f<int>();
+ // expected-error at -1 {{use 'template' keyword to treat 'f' as a dependent template name}}
}
void h() {
(void)t.S<int>::n; // ok
@@ -519,28 +632,53 @@ namespace dr141 { // dr141: 3.1
}
namespace dr142 { // dr142: 2.8
- class B { // expected-note +{{here}}
+ class B { // #dr142-B
public:
- int mi; // expected-note +{{here}}
- static int si; // expected-note +{{here}}
+ int mi; // #dr142-B-mi
+ static int si; // #dr142-B-si
};
- class D : private B { // expected-note +{{here}}
+ class D : private B { // #dr142-D
};
class DD : public D {
void f();
};
void DD::f() {
- mi = 3; // expected-error {{private member}}
- si = 3; // expected-error {{private member}}
- B b_old; // expected-error {{private member}}
+ mi = 3;
+ // expected-error at -1 {{'mi' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B-mi {{member is declared here}}
+ si = 3;
+ // expected-error at -1 {{'si' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B-si {{member is declared here}}
+ B b_old;
+ // expected-error at -1 {{'B' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B {{member is declared here}}
dr142::B b;
b.mi = 3;
b.si = 3;
- B::si = 3; // expected-error {{private member}}
+ B::si = 3;
+ // expected-error at -1 {{'B' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B {{member is declared here}}
dr142::B::si = 3;
- B *bp1_old = this; // expected-error {{private member}} expected-error {{private base class}}
- dr142::B *bp1 = this; // expected-error {{private base class}}
- B *bp2_old = (B*)this; // expected-error 2{{private member}}
+ B *bp1_old = this; // #dr142-bp1_old
+ // expected-error@#dr142-bp1_old {{'B' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B {{member is declared here}}
+ // expected-error@#dr142-bp1_old {{cannot cast 'dr142::DD' to its private base class 'B'}}
+ // expected-note@#dr142-D {{declared private here}}
+ dr142::B *bp1 = this;
+ // expected-error at -1 {{cannot cast 'dr142::DD' to its private base class 'dr142::B'}}
+ // expected-note@#dr142-D {{declared private here}}
+ B *bp2_old = (B*)this; // #dr142-bp2_old
+ // expected-error@#dr142-bp2_old {{'B' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B {{member is declared here}}
+ // expected-error@#dr142-bp2_old {{'B' is a private member of 'dr142::B'}}
+ // expected-note@#dr142-D {{constrained by private inheritance here}}
+ // expected-note@#dr142-B {{member is declared here}}
dr142::B *bp2 = (dr142::B*)this;
bp2->mi = 3;
}
@@ -548,24 +686,25 @@ namespace dr142 { // dr142: 2.8
namespace dr143 { // dr143: yes
namespace A { struct X; }
- namespace B { void f(A::X); }
+ namespace B { void f(A::X); } // #dr143-f
namespace A {
struct X { friend void B::f(X); };
}
void g(A::X x) {
- f(x); // expected-error {{undeclared identifier 'f'}}
+ f(x);
+ // expected-error at -1 {{use of undeclared identifier 'f'; did you mean 'B::f'?}}
+ // expected-note@#dr143-f {{'B::f' declared here}}
}
}
namespace dr145 { // dr145: yes
void f(bool b) {
-#if __cplusplus <= 201402L
- ++b; // expected-warning {{deprecated}}
- b++; // expected-warning {{deprecated}}
-#else
- ++b; // expected-error {{increment}}
- b++; // expected-error {{increment}}
-#endif
+ ++b;
+ // cxx98-14-warning at -1 {{incrementing expression of type bool is deprecated and incompatible with C++17}}
+ // since-cxx17-error at -2 {{ISO C++17 does not allow incrementing expression of type bool}}
+ b++;
+ // cxx98-14-warning at -1 {{incrementing expression of type bool is deprecated and incompatible with C++17}}
+ // since-cxx17-error at -2 {{ISO C++17 does not allow incrementing expression of type bool}}
}
}
@@ -576,13 +715,15 @@ namespace dr147 { // dr147: yes
};
// Per core issue 1435, this is ill-formed because A<int>::A<int> does not
// name the injected-class-name. (A<int>::A does, though.)
- template<> template<> A<int>::A<int>(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}}
+ template<> template<> A<int>::A<int>(int) {}
+ // expected-error at -1 {{out-of-line constructor for 'A' cannot have template arguments}}
template<> template<> A<float>::A(float) {}
}
namespace example2 {
struct A { A(); };
struct B : A { B(); };
- A::A a1; // expected-error {{is a constructor}}
+ A::A a1;
+ // expected-error at -1 {{qualified reference to 'A' is a constructor name rather than a type in this context}}
B::A a2;
}
namespace example3 {
@@ -590,7 +731,8 @@ namespace dr147 { // dr147: yes
template<typename T> A(T);
static A a;
};
- template<> A<int>::A<int>(A<int>::a); // expected-error {{is a constructor}}
+ template<> A<int>::A<int>(A<int>::a);
+ // expected-error at -1 {{qualified reference to 'A' is a constructor name rather than a template name in this context}}
}
}
@@ -616,24 +758,28 @@ namespace dr151 { // dr151: 3.1
namespace dr152 { // dr152: yes
struct A {
- A(); // expected-note 0-2{{not viable}}
- explicit A(const A&); // expected-note 1-2{{not a candidate}}
+ A(); // #dr152-A-ctor
+ explicit A(const A&); // #dr152-A-explicit-ctor
};
A a1 = A();
-#if __cplusplus <= 201402L
- // expected-error at -2 {{no matching constructor}}
-#endif
+ // cxx98-14-error at -1 {{no matching constructor for initialization of 'A'}}
+ // cxx98-14-note@#dr152-A-explicit-ctor {{explicit constructor is not a candidate}}
+ // cxx98-14-note@#dr152-A-ctor {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
A a2((A()));
A &f();
- A a3 = f(); // expected-error {{no matching constructor}}
+ A a3 = f();
+ // expected-error at -1 {{no matching constructor for initialization of 'A'}}
+ // expected-note@#dr152-A-explicit-ctor {{explicit constructor is not a candidate}}
+ // expected-note@#dr152-A-ctor {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
A a4(f());
}
// dr153: na
namespace dr154 { // dr154: yes
- union { int a; }; // expected-error {{must be declared 'static'}}
+ union { int a; };
+ // expected-error at -1 {{nonymous unions at namespace or global scope must be declared 'static'}}
namespace {
union { int b; };
}
@@ -641,7 +787,8 @@ namespace dr154 { // dr154: yes
}
namespace dr155 { // dr155: dup 632
- struct S { int n; } s = { { 1 } }; // expected-warning {{braces around scalar initializer}}
+ struct S { int n; } s = { { 1 } };
+ // expected-warning at -1 {{braces around scalar initializer}}
}
// dr158 is in its own file.
@@ -649,7 +796,8 @@ namespace dr155 { // dr155: dup 632
namespace dr159 { // dr159: 3.5
namespace X { void f(); }
void f();
- void dr159::f() {} // expected-warning {{extra qualification}}
+ void dr159::f() {}
+ // expected-warning at -1 {{extra qualification on member 'f'}}
void dr159::X::f() {}
}
@@ -658,9 +806,9 @@ namespace dr159 { // dr159: 3.5
namespace dr161 { // dr161: 3.1
class A {
protected:
- struct B { int n; } b; // expected-note 2{{here}}
+ struct B { int n; } b; // #dr161-B
static B bs;
- void f(); // expected-note {{here}}
+ void f(); // #dr161-f
static void sf();
};
struct C : A {};
@@ -669,13 +817,19 @@ namespace dr161 { // dr161: 3.1
(void)b.n;
B b1;
C::B b2; // ok, accessible as a member of A
- (void)&C::b; // expected-error {{protected}}
+ (void)&C::b;
+ // expected-error at -1 {{'b' is a protected member of 'dr161::A'}}
+ // expected-note@#dr161-B {{declared protected here}}
(void)&C::bs;
- (void)c.b; // expected-error {{protected}}
+ (void)c.b;
+ // expected-error at -1 {{'b' is a protected member of 'dr161::A'}}
+ // expected-note@#dr161-B {{declared protected here}}
(void)c.bs;
f();
sf();
- c.f(); // expected-error {{protected}}
+ c.f();
+ // expected-error at -1 {{protected}}
+ // expected-note@#dr161-f {{declared protected here}}
c.sf();
A::f();
D::f();
@@ -692,13 +846,17 @@ namespace dr162 { // dr162: no
static int &f(int);
void g() {
- int &a = (&A::f)(0); // FIXME: expected-error {{could not be resolved}}
- char &b = (&A::f)('0'); // expected-error {{could not be resolved}}
+ int &a = (&A::f)(0);
+ // FIXME: expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ char &b = (&A::f)('0');
+ // expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
}
};
- int &c = (&A::f)(0); // FIXME: expected-error {{could not be resolved}}
- char &d = (&A::f)('0'); // expected-error {{could not be resolved}}
+ int &c = (&A::f)(0);
+ // FIXME: expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ char &d = (&A::f)('0');
+ // expected-error at -1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
}
// dr163: na
@@ -729,7 +887,10 @@ namespace dr166 { // dr166: 2.9
template<typename T> int f(T t) { return t.n; }
int g(A::X);
- template<typename T> int h(T t) { return t.n; } // expected-error {{private}}
+ template<typename T> int h(T t) { return t.n; }
+ // expected-error at -1 {{'n' is a private member of 'dr166::A::X'}}
+ // expected-note@#dr166-h-instantiation {{in instantiation of function template specialization 'dr166::h<dr166::A::X>' requested here}}
+ // expected-note@#dr166-X-n {{implicitly declared private here}}
int i(A::X);
namespace A {
@@ -738,7 +899,7 @@ namespace dr166 { // dr166: 2.9
friend int dr166::g(X);
friend int h(X);
friend int i(X);
- int n; // expected-note 2{{here}}
+ int n; // #dr166-X-n
};
int h(X x) { return x.n; }
@@ -747,8 +908,10 @@ namespace dr166 { // dr166: 2.9
template int f(A::X);
int g(A::X x) { return x.n; }
- template int h(A::X); // expected-note {{instantiation}}
- int i(A::X x) { return x.n; } // expected-error {{private}}
+ template int h(A::X); // #dr166-h-instantiation
+ int i(A::X x) { return x.n; }
+ // expected-error at -1 {{'n' is a private member of 'dr166::A::X'}}
+ // expected-note@#dr166-X-n {{implicitly declared private here}}
}
// dr167: sup 1012
@@ -768,23 +931,29 @@ namespace dr169 { // dr169: yes
struct B {
template<typename> struct C;
template<typename> void f();
- template<typename> static int n; // expected-error 0-1{{extension}}
+ template<typename> static int n;
+ // cxx98-11-error at -1 {{variable templates are a C++14 extension}}
};
struct D : A<int>, B {
using A<int>::n;
- using B::C<int>; // expected-error {{using declaration cannot refer to a template specialization}}
- using B::f<int>; // expected-error {{using declaration cannot refer to a template specialization}}
- using B::n<int>; // expected-error {{using declaration cannot refer to a template specialization}}
+ using B::C<int>;
+ // expected-error at -1 {{using declaration cannot refer to a template specialization}}
+ using B::f<int>;
+ // expected-error at -1 {{using declaration cannot refer to a template specialization}}
+ using B::n<int>;
+ // expected-error at -1 {{using declaration cannot refer to a template specialization}}
};
}
namespace { // dr171: yes
int dr171a;
}
-int dr171b; // expected-note {{here}}
+int dr171b; // #dr171b-int
namespace dr171 {
extern "C" void dr171a();
- extern "C" void dr171b(); // expected-error {{conflicts}}
+ extern "C" void dr171b();
+ // expected-error at -1 {{declaration of 'dr171b' with C language linkage conflicts with declaration in global scope}}
+ // expected-note@#dr171b-int {{declared in global scope here}}
}
namespace dr172 { // dr172: yes
@@ -810,12 +979,14 @@ namespace dr172 { // dr172: yes
int check6a[sizeof(d) == sizeof(unsigned long) ? 1 : -1];
int check6b[-d > 0 ? 1 : -1];
- enum { e = (unsigned long long)-1 / 2 }; // expected-error 0-1{{extension}}
- int check7a[sizeof(e) == sizeof(long) ? 1 : -1]; // expected-error 0-1{{extension}}
+ enum { e = (unsigned long long)-1 / 2 };
+ // cxx98-error at -1 {{'long long' is a C++11 extension}}
+ int check7a[sizeof(e) == sizeof(long) ? 1 : -1];
int check7b[-e < 0 ? 1 : -1];
- enum { f = (unsigned long long)-1 / 2 + 1 }; // expected-error 0-1{{extension}}
- int check8a[sizeof(f) == sizeof(unsigned long) ? 1 : -1]; // expected-error 0-1{{extension}}
+ enum { f = (unsigned long long)-1 / 2 + 1 };
+ // cxx98-error at -1 {{'long long' is a C++11 extension}}
+ int check8a[sizeof(f) == sizeof(unsigned long) ? 1 : -1];
int check8b[-f > 0 ? 1 : -1];
}
@@ -828,10 +999,13 @@ namespace dr173 { // dr173: yes
// dr174: sup 1012
namespace dr175 { // dr175: 2.8
- struct A {}; // expected-note {{here}}
- struct B : private A {}; // expected-note {{constrained by private inheritance}}
+ struct A {}; // #dr175-A
+ struct B : private A {}; // #dr175-B
struct C : B {
- A a; // expected-error {{private}}
+ A a;
+ // expected-error at -1 {{'A' is a private member of 'dr175::A'}}
+ // expected-note@#dr175-B {{constrained by private inheritance here}}
+ // expected-note@#dr175-A {{member is declared here}}
dr175::A b;
};
}
@@ -840,12 +1014,14 @@ namespace dr176 { // dr176: 3.1
template<typename T> class Y;
template<> class Y<int> {
void f() {
- typedef Y A; // expected-note {{here}}
- typedef Y<char> A; // expected-error {{different types ('Y<char>' vs 'Y<int>')}}
+ typedef Y A; // #dr176-A-first
+ typedef Y<char> A;
+ // expected-error at -1 {{typedef redefinition with different types ('Y<char>' vs 'Y<int>')}}
+ // expected-note@#dr176-A-first {{previous definition is here}}
}
};
- template<typename T> struct Base {}; // expected-note 2{{found}}
+ template<typename T> struct Base {}; // #dr176-Base
template<typename T> struct Derived : public Base<T> {
void f() {
typedef typename Derived::template Base<T> A;
@@ -855,35 +1031,44 @@ namespace dr176 { // dr176: 3.1
template struct Derived<int>;
template<typename T> struct Derived2 : Base<int>, Base<char> {
- typename Derived2::Base b; // expected-error {{found in multiple base classes}}
+ typename Derived2::Base b;
+ // expected-error at -1 {{member 'Base' found in multiple base classes of different types}}
+ // expected-note@#dr176-Base {{member type 'dr176::Base<int>' found by ambiguous name lookup}}
+ // expected-note@#dr176-Base {{member type 'dr176::Base<char>' found by ambiguous name lookup}}
typename Derived2::Base<double> d;
};
- template<typename T> class X { // expected-note {{here}}
+ template<typename T> class X { // #dr176-X
X *p1;
X<T> *p2;
X<int> *p3;
- dr176::X *p4; // expected-error {{requires template arguments}}
+ dr176::X *p4; // #dr176-p4
+ // cxx98-14-error@#dr176-p4 {{use of class template 'dr176::X' requires template arguments}}
+ // cxx98-14-note@#dr176-X {{template is declared here}}
+ // since-cxx17-error@#dr176-p4 {{use of class template 'X' requires template arguments; argument deduction not allowed in non-static class member}}
+ // since-cxx17-note@#dr176-X {{template is declared here}}
};
}
namespace dr177 { // dr177: yes
struct B {};
struct A {
- A(A &); // expected-note 0-1{{not viable: expects an lvalue}}
- A(const B &); // expected-note 0-1{{not viable: no known conversion from 'A' to}}
+ A(A &); // #dr177-A-copy-ctor
+ A(const B &); // #dr177-A-ctor-from-B
};
B b;
A a = b;
-#if __cplusplus <= 201402L
- // expected-error at -2 {{no viable constructor copying variable}}
-#endif
+ // cxx98-14-error at -1 {{no viable constructor copying variable of type 'A'}}
+ // cxx98-14-note@#dr177-A-copy-ctor {{candidate constructor not viable: expects an lvalue for 1st argument}}
+ // cxx98-14-note@#dr177-A-ctor-from-B {{candidate constructor not viable: no known conversion from 'A' to 'const B &' for 1st argument}}
- struct C { C(C&); }; // expected-note {{not viable: expects an lvalue for 1st argument}}
+ struct C { C(C&); }; // #dr177-C-copy-ctor
struct D : C {};
struct E { operator D(); };
E e;
- C c = e; // expected-error {{no viable constructor copying variable of type 'D'}}
+ C c = e;
+ // expected-error at -1 {{no viable constructor copying variable of type 'D'}}
+ // expected-note@#dr177-C-copy-ctor {{candidate constructor not viable: expects an lvalue for 1st argument}}
}
namespace dr178 { // dr178: yes
@@ -901,7 +1086,8 @@ namespace dr178 { // dr178: yes
namespace dr179 { // dr179: yes
void f();
- int n = &f - &f; // expected-error {{arithmetic on pointers to the function type 'void ()'}}
+ int n = &f - &f;
+ // expected-error at -1 {{arithmetic on pointers to the function type 'void ()'}}
}
namespace dr180 { // dr180: 2.8
@@ -916,8 +1102,10 @@ namespace dr180 { // dr180: 2.8
namespace dr181 { // dr181: yes
namespace X {
- template <template X<class T> > struct A { }; // expected-error +{{}}
- template <template X<class T> > void f(A<X>) { } // expected-error +{{}}
+ template <template X<class T> > struct A { };
+ // expected-error at -1 +{{}}
+ template <template X<class T> > void f(A<X>) { }
+ // expected-error at -1 +{{}}
}
namespace Y {
@@ -955,11 +1143,8 @@ namespace dr183 { // dr183: sup 382
typedef int X;
};
template<> struct A<int> {
-#if __cplusplus <= 199711
- typename B<int>::X x; // expected-error {{'typename' occurs outside of a template}}
-#else
typename B<int>::X x;
-#endif
+ // cxx98-error at -1 {{'typename' occurs outside of a template}}
};
}
@@ -971,8 +1156,10 @@ namespace dr184 { // dr184: yes
void g();
};
- template<template<typename TT> class T> void A<T>::f() { // expected-note {{here}}
- T<> t; // expected-error {{too few template arguments}}
+ template<template<typename TT> class T> void A<T>::f() { // #dr184-T
+ T<> t;
+ // expected-error at -1 {{too few template arguments for template template parameter 'T'}}
+ // expected-note@#dr184-T {{template is declared here}}
}
template<template<typename TT = char> class T> void A<T>::g() {
@@ -1035,10 +1222,12 @@ namespace dr191 { // dr191: yes
namespace dr194 { // dr194: yes
struct A {
A();
- void A(); // expected-error {{constructor cannot have a return type}}
+ void A();
+ // expected-error at -1 {{constructor cannot have a return type}}
};
struct B {
- void B(); // expected-error {{constructor cannot have a return type}}
+ void B();
+ // expected-error at -1 {{constructor cannot have a return type}}
B();
};
struct C {
@@ -1048,8 +1237,10 @@ namespace dr194 { // dr194: yes
namespace dr195 { // dr195: yes
void f();
- int *p = (int*)&f; // expected-error 0-1{{extension}}
- void (*q)() = (void(*)())&p; // expected-error 0-1{{extension}}
+ int *p = (int*)&f;
+ // cxx98-error at -1 {{cast between pointer-to-function and pointer-to-object is an extension}}
+ void (*q)() = (void(*)())&p;
+ // cxx98-error at -1 {{cast between pointer-to-function and pointer-to-object is an extension}}
}
namespace dr197 { // dr197: yes
@@ -1057,8 +1248,11 @@ namespace dr197 { // dr197: yes
template <class T> void g(T t) {
char &a = f(1);
- char &b = f(T(1)); // expected-error {{unrelated type 'int'}}
- char &c = f(t); // expected-error {{unrelated type 'int'}}
+ char &b = f(T(1));
+ // expected-error at -1 {{non-const lvalue reference to type 'char' cannot bind to a value of unrelated type 'int'}}
+ // expected-note@#dr197-g-e-call {{in instantiation of function template specialization 'dr197::g<dr197::E>' requested here}}
+ char &c = f(t);
+ // expected-error at -1 {{non-const lvalue reference to type 'char' cannot bind to a value of unrelated type 'int'}}
}
void f(int);
@@ -1069,7 +1263,7 @@ namespace dr197 { // dr197: yes
void h() {
g('a');
g(2);
- g(e); // expected-note {{in instantiation of}}
+ g(e); // #dr197-g-e-call
}
}
@@ -1078,9 +1272,7 @@ namespace dr198 { // dr198: yes
int n;
struct B {
int m[sizeof(n)];
-#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 'n'}}
int f() { return n; }
// expected-error at -1 {{use of non-static data member 'n' of 'A' from nested type 'B'}}
};
@@ -1089,17 +1281,13 @@ namespace dr198 { // dr198: yes
};
struct A::C {
int m[sizeof(n)];
-#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 'n'}}
int f() { return n; }
// expected-error at -1 {{use of non-static data member 'n' of 'A' from nested type 'C'}}
};
struct A::D : A {
int m[sizeof(n)];
-#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 'n'}}
int f() { return n; }
};
}
More information about the lldb-commits
mailing list