dnrops
/
clang
mirror of https://github.com/microsoft/clang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "Don't require -re suffix on -verify directives with regexes." 

This patch was submitted to the list for review and didn't receive a LGTM.

(In fact one explicit objection and one query were raised.)

This reverts commit r197295.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@197299 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Alp Toker 2013-12-14 01:07:05 +00:00
parent 3f13c4ec64
commit da46e89f75
39 changed files with 120 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/clang/Basic/DiagnosticFrontendKinds.td
View File

@ -77,6 +77,8 @@ def err_verify_missing_end : Error<
"cannot find end ('}}') of expected %0">; "cannot find end ('}}') of expected %0">;
def err_verify_invalid_content : Error< def err_verify_invalid_content : Error<
"invalid expected %0: %1">; "invalid expected %0: %1">;
def err_verify_missing_regex : Error<
"cannot find start of regex ('{{') in %0">;
def err_verify_inconsistent_diags : Error< def err_verify_inconsistent_diags : Error<
"'%0' diagnostics %select{expected|seen}1 but not %select{seen|expected}1: " "'%0' diagnostics %select{expected|seen}1 but not %select{seen|expected}1: "
"%2">; "%2">;

15
include/clang/Frontend/VerifyDiagnosticConsumer.h
View File

@ -108,10 +108,11 @@ class FileEntry;
/// ///
/// In this example, the diagnostic may appear only once, if at all. /// In this example, the diagnostic may appear only once, if at all.
/// ///
/// Regular expressions can be embedded inside double curly braces, for example: /// Regex matching mode may be selected by appending '-re' to type and
/// including regexes wrapped in double curly braces in the directive, such as:
/// ///
/// \code /// \code
/// expected-error {{format specifies type 'wchar_t **' (aka '{{.+}}')}} /// expected-error-re {{format specifies type 'wchar_t **' (aka '{{.+}}')}}
/// \endcode /// \endcode
/// ///
/// Examples matching error: "variable has incomplete type 'struct s'" /// Examples matching error: "variable has incomplete type 'struct s'"
@ -120,10 +121,10 @@ class FileEntry;
/// // expected-error {{variable has incomplete type 'struct s'}} /// // expected-error {{variable has incomplete type 'struct s'}}
/// // expected-error {{variable has incomplete type}} /// // expected-error {{variable has incomplete type}}
/// ///
/// // expected-error {{variable has type 'struct {{.}}'}} /// // expected-error-re {{variable has type 'struct {{.}}'}}
/// // expected-error {{variable has type 'struct {{.*}}'}} /// // expected-error-re {{variable has type 'struct {{.*}}'}}
/// // expected-error {{variable has type 'struct {{(.*)}}'}} /// // expected-error-re {{variable has type 'struct {{(.*)}}'}}
/// // expected-error {{variable has type 'struct{{[[:space:]](.*)}}'}} /// // expected-error-re {{variable has type 'struct{{[[:space:]](.*)}}'}}
/// \endcode /// \endcode
/// ///
/// VerifyDiagnosticConsumer expects at least one expected-* directive to /// VerifyDiagnosticConsumer expects at least one expected-* directive to
@ -141,7 +142,7 @@ public:
/// ///
class Directive { class Directive {
public: public:
static Directive *create(SourceLocation DirectiveLoc, static Directive *create(bool RegexKind, SourceLocation DirectiveLoc,
SourceLocation DiagnosticLoc, SourceLocation DiagnosticLoc,
StringRef Text, unsigned Min, unsigned Max); StringRef Text, unsigned Min, unsigned Max);
public: public:

22
lib/Frontend/VerifyDiagnosticConsumer.cpp
View File

@ -356,8 +356,16 @@ static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
return true; return true;
// Default directive kind. // Default directive kind.
bool RegexKind = false;
const char* KindStr = "string"; const char* KindStr = "string";
// Next optional token: -
if (PH.Next("-re")) {
PH.Advance();
RegexKind = true;
KindStr = "regex";
}
// Next optional token: @ // Next optional token: @
SourceLocation ExpectedLoc; SourceLocation ExpectedLoc;
if (!PH.Next("@")) { if (!PH.Next("@")) {
@ -475,8 +483,16 @@ static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
if (Text.empty()) if (Text.empty())
Text.assign(ContentBegin, ContentEnd); Text.assign(ContentBegin, ContentEnd);
// Check that regex directives contain at least one regex.
if (RegexKind && Text.find("{{") == StringRef::npos) {
Diags.Report(Pos.getLocWithOffset(ContentBegin-PH.Begin),
diag::err_verify_missing_regex) << Text;
return false;
}
// Construct new directive. // Construct new directive.
Directive *D = Directive::create(Pos, ExpectedLoc, Text, Min, Max); Directive *D = Directive::create(RegexKind, Pos, ExpectedLoc, Text,
Min, Max);
std::string Error; std::string Error;
if (D->isValid(Error)) { if (D->isValid(Error)) {
DL->push_back(D); DL->push_back(D);
@ -835,10 +851,10 @@ void VerifyDiagnosticConsumer::CheckDiagnostics() {
ED.Notes.clear(); ED.Notes.clear();
} }
Directive *Directive::create(SourceLocation DirectiveLoc, Directive *Directive::create(bool RegexKind, SourceLocation DirectiveLoc,
SourceLocation DiagnosticLoc, StringRef Text, SourceLocation DiagnosticLoc, StringRef Text,
unsigned Min, unsigned Max) { unsigned Min, unsigned Max) {
if (Text.find("}}") == StringRef::npos) if (!RegexKind)
return new StandardDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max); return new StandardDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);
// Parse the directive into a regular expression. // Parse the directive into a regular expression.

2
test/Analysis/analyzer-stats.c
View File

@ -2,7 +2,7 @@
int foo(); int foo();
int test() { // expected-warning{{test -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 0 | Exhausted Block: no | Empty WorkList: yes}} int test() { // expected-warning-re{{test -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 0 | Exhausted Block: no | Empty WorkList: yes}}
int a = 1; int a = 1;
a = 34 / 12; a = 34 / 12;

2
test/CXX/class.access/p6.cpp
View File

@ -177,7 +177,7 @@ namespace test8 {
}; };
void test(A &a) { void test(A &a) {
if (a) return; // expected-error {{'operator void *(class test8::A::*)(void){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}} if (a) return; // expected-error-re {{'operator void *(class test8::A::*)(void){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}}
} }
} }

4
test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp
View File

@ -27,7 +27,7 @@ void f2(constexpr int i) {} // expected-error {{function parameter cannot be con
struct s2 { struct s2 {
constexpr int mi1; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} constexpr int mi1; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
static constexpr int mi2; // expected-error {{requires an initializer}} static constexpr int mi2; // expected-error {{requires an initializer}}
mutable constexpr int mi3 = 3; // expected-error {{non-static data member cannot be constexpr{{$}}}} expected-error {{'mutable' and 'const' cannot be mixed}} mutable constexpr int mi3 = 3; // expected-error-re {{non-static data member cannot be constexpr{{$}}}} expected-error {{'mutable' and 'const' cannot be mixed}}
}; };
// typedef // typedef
typedef constexpr int CI; // expected-error {{typedef cannot be constexpr}} typedef constexpr int CI; // expected-error {{typedef cannot be constexpr}}
@ -73,7 +73,7 @@ template <typename T> T gt(T t) { return t; }
struct S { struct S {
template<typename T> constexpr T f(); // expected-warning {{C++1y}} template<typename T> constexpr T f(); // expected-warning {{C++1y}}
template <typename T> template <typename T>
T g() const; // expected-note {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}} T g() const; // expected-note-re {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}}
}; };
// explicit specialization can differ in constepxr // explicit specialization can differ in constepxr

2
test/CXX/drs/dr14xx.cpp
View File

@ -84,7 +84,7 @@ namespace dr1460 { // dr1460: 3.5
#if __cplusplus > 201103L #if __cplusplus > 201103L
template<typename T> constexpr bool check() { template<typename T> constexpr bool check() {
T t; // expected-note 2{{non-constexpr constructor '{{[BE]}}'}} T t; // expected-note-re 2{{non-constexpr constructor '{{[BE]}}'}}
return true; return true;
} }
static_assert(check<A>(), ""); static_assert(check<A>(), "");

2
test/CXX/expr/expr.const/p3-0x.cpp
View File

@ -97,7 +97,7 @@ template <bool B> int f() { return B; } // expected-note {{candidate template ig
template int f<&S::operator int>(); // expected-error {{does not refer to a function template}} template int f<&S::operator int>(); // expected-error {{does not refer to a function template}}
template int f<(bool)&S::operator int>(); template int f<(bool)&S::operator int>();
int n = Val<bool, &S::operator int>::value; // expected-error {{conversion from 'int (S::*)(){{( __attribute__\(\(thiscall\)\))?}} const' to 'bool' is not allowed in a converted constant expression}} int n = Val<bool, &S::operator int>::value; // expected-error-re {{conversion from 'int (S::*)(){{( __attribute__\(\(thiscall\)\))?}} const' to 'bool' is not allowed in a converted constant expression}}
namespace NonConstLValue { namespace NonConstLValue {
struct S { struct S {

28
test/CXX/expr/expr.mptr.oper/p5.cpp
View File

@ -24,19 +24,19 @@ void test_object_cvquals(void (X0::*pm)(),
(p->*pmv)(); (p->*pmv)();
(p->*pmcv)(); (p->*pmcv)();
(pc->*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}} (pc->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
(pc->*pmc)(); (pc->*pmc)();
(pc->*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}} (pc->*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
(pc->*pmcv)(); (pc->*pmcv)();
(pv->*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}} (pv->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}}
(pv->*pmc)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}} (pv->*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
(pv->*pmv)(); (pv->*pmv)();
(pv->*pmcv)(); (pv->*pmcv)();
(pcv->*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}} (pcv->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}}
(pcv->*pmc)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}} (pcv->*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
(pcv->*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}} (pcv->*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
(pcv->*pmcv)(); (pcv->*pmcv)();
(o.*pm)(); (o.*pm)();
@ -44,18 +44,18 @@ void test_object_cvquals(void (X0::*pm)(),
(o.*pmv)(); (o.*pmv)();
(o.*pmcv)(); (o.*pmcv)();
(oc.*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}} (oc.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
(oc.*pmc)(); (oc.*pmc)();
(oc.*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}} (oc.*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
(oc.*pmcv)(); (oc.*pmcv)();
(ov.*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}} (ov.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}}
(ov.*pmc)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}} (ov.*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
(ov.*pmv)(); (ov.*pmv)();
(ov.*pmcv)(); (ov.*pmcv)();
(ocv.*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}} (ocv.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}}
(ocv.*pmc)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}} (ocv.*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
(ocv.*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}} (ocv.*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
(ocv.*pmcv)(); (ocv.*pmcv)();
} }

8
test/CXX/expr/expr.mptr.oper/p6-0x.cpp
View File

@ -22,13 +22,13 @@ void test(X *xp, int (X::*pmf)(int), int (X::*l_pmf)(int) &,
// Lvalue ref-qualifier. // Lvalue ref-qualifier.
(lvalue<X>().*l_pmf)(17); (lvalue<X>().*l_pmf)(17);
(xvalue<X>().*l_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}} (xvalue<X>().*l_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
(prvalue<X>().*l_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}} (prvalue<X>().*l_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
(xp->*l_pmf)(17); (xp->*l_pmf)(17);
// Rvalue ref-qualifier. // Rvalue ref-qualifier.
(lvalue<X>().*r_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}} (lvalue<X>().*r_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
(xvalue<X>().*r_pmf)(17); (xvalue<X>().*r_pmf)(17);
(prvalue<X>().*r_pmf)(17); (prvalue<X>().*r_pmf)(17);
(xp->*r_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}} (xp->*r_pmf)(17); // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
} }

2
test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
View File

@ -7,7 +7,7 @@ namespace test0 {
template<typename T> void g(T); template<typename T> void g(T);
void test() { void test() {
foo(&g<int>); // expected-error {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}} foo(&g<int>); // expected-error-re {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}}
} }
}; };
} }

10
test/CXX/special/class.copy/implicit-move.cpp
View File

@ -258,8 +258,8 @@ namespace DR1402 {
template<typename T> template<typename T>
struct F : struct F :
E<T, 0>, // expected-note 2{{'{{[BD]}}' is a virtual base class of base class 'E<}} E<T, 0>, // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
E<T, 1> {}; // expected-note 2{{'{{[BD]}}' is a virtual base class of base class 'E<}} E<T, 1> {}; // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
template<typename T> template<typename T>
struct G : E<T, 0, true>, E<T, 0> {}; struct G : E<T, 0, true>, E<T, 0> {};
@ -272,11 +272,11 @@ namespace DR1402 {
template<typename T> template<typename T>
struct J : struct J :
E<T, 0>, // expected-note 2{{'{{[BD]}}' is a virtual base class of base class 'E<}} E<T, 0>, // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
virtual T {}; // expected-note 2{{virtual base class '{{[BD]}}' declared here}} virtual T {}; // expected-note-re 2{{virtual base class '{{[BD]}}' declared here}}
template<typename T> void move(T t) { t = static_cast<T&&>(t); } template<typename T> void move(T t) { t = static_cast<T&&>(t); }
// expected-warning@-1 4{{defaulted move assignment operator of {{.*}} will move assign virtual base class '{{[BD]}}' multiple times}} // expected-warning-re@-1 4{{defaulted move assignment operator of {{.*}} will move assign virtual base class '{{[BD]}}' multiple times}}
template void move(F<A>); template void move(F<A>);
template void move(F<B>); // expected-note {{in instantiation of}} template void move(F<B>); // expected-note {{in instantiation of}}
template void move(F<C>); template void move(F<C>);

2
test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
View File

@ -184,7 +184,7 @@ namespace pointer_to_member_function {
template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}} template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}}
X0<&Y::f> x0a; X0<&Y::f> x0a;
X0<&Y::g> x0b; X0<&Y::g> x0b;
X0<&Y::h> x0c; // expected-error{{non-type template argument of type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}} X0<&Y::h> x0c; // expected-error-re{{non-type template argument of type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
} }
// -- For a non-type template-parameter of type pointer to data member, // -- For a non-type template-parameter of type pointer to data member,

2
test/Lexer/hexfloat.cpp
View File

@ -12,4 +12,4 @@ double h = 0x1.p2; // expected-warning{{hexadecimal floating constants are a C99
double i = 0p+3; // expected-error{{invalid suffix 'p' on integer constant}} double i = 0p+3; // expected-error{{invalid suffix 'p' on integer constant}}
#define PREFIX(x) foo ## x #define PREFIX(x) foo ## x
double foo0p = 1, j = PREFIX(0p+3); // ok double foo0p = 1, j = PREFIX(0p+3); // ok
double k = 0x42_amp+3; // expected-error{{{{invalid suffix '_amp' on integer constant|no matching literal operator for call to 'operator "" _amp'}}}} double k = 0x42_amp+3; // expected-error-re{{{{invalid suffix '_amp' on integer constant|no matching literal operator for call to 'operator "" _amp'}}}}

8
test/Misc/verify.c
View File

@ -8,7 +8,7 @@ struct s s2; // expected-error {{tentative definition has type}}
// regex matching // regex matching
struct s r1; // expected-error {{tentative definition has type 'struct s' that is never completed}} struct s r1; // expected-error {{tentative definition has type 'struct s' that is never completed}}
struct s r2; // expected-error {{tentative definition has type '{{.*[[:space:]]*.*}}' that is never completed}} struct s r2; // expected-error-re {{tentative definition has type '{{.*[[:space:]]*.*}}' that is never completed}}
struct s r3; // expected-error {{tentative definition has type '{{(.*)[[:space:]]*(.*)}}' that is never completed}} struct s r3; // expected-error-re {{tentative definition has type '{{(.*)[[:space:]]*(.*)}}' that is never completed}}
struct s r4; // expected-error {{{{^}}tentative}} struct s r4; // expected-error-re {{{{^}}tentative}}
struct s r5; // expected-error {{completed{{$}}}} struct s r5; // expected-error-re {{completed{{$}}}}

4
test/Parser/attributes.mm
View File

@ -14,11 +14,11 @@ EXP class C2 {}; // expected-warning {{attribute 'visibility' is ignored, place
@interface EXP I @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@interface'}} @interface EXP I @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@interface'}}
EXP @interface I2 @end EXP @interface I2 @end
@implementation EXP I @end // expected-error {{postfix attributes are not allowed on Objective-C directives{{$}}}} @implementation EXP I @end // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
// FIXME: Prefix attribute recovery skips until ';' // FIXME: Prefix attribute recovery skips until ';'
EXP @implementation I2 @end; // expected-error {{prefix attribute must be followed by an interface or protocol}} EXP @implementation I2 @end; // expected-error {{prefix attribute must be followed by an interface or protocol}}
@class EXP OC; // expected-error {{postfix attributes are not allowed on Objective-C directives{{$}}}} @class EXP OC; // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
EXP @class OC2; // expected-error {{prefix attribute must be followed by an interface or protocol}} EXP @class OC2; // expected-error {{prefix attribute must be followed by an interface or protocol}}
@protocol EXP P @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@protocol'}} @protocol EXP P @end // expected-error {{postfix attributes are not allowed on Objective-C directives, place them in front of '@protocol'}}

4
test/Sema/format-strings-scanf.c
View File

@ -107,9 +107,9 @@ void test_alloc_extension(char **sp, wchar_t **lsp, float *fp) {
// Test argument type check for the 'm' length modifier. // Test argument type check for the 'm' length modifier.
scanf("%ms", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} scanf("%ms", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
scanf("%mS", fp); // expected-warning{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}} scanf("%mS", fp); // expected-warning-re{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}}
scanf("%mc", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} scanf("%mc", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
scanf("%mC", fp); // expected-warning{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}} scanf("%mC", fp); // expected-warning-re{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}}
scanf("%m[abc]", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}} scanf("%m[abc]", fp); // expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
} }

4
test/Sema/ms-wchar.c
View File

@ -12,7 +12,7 @@ __wchar_t g = L'a'; // expected-note {{previous}}
unsigned short g; // expected-error {{redefinition of 'g' with a different type: 'unsigned short' vs '__wchar_t'}} unsigned short g; // expected-error {{redefinition of 'g' with a different type: 'unsigned short' vs '__wchar_t'}}
// The type of a wide string literal is actually not __wchar_t. // The type of a wide string literal is actually not __wchar_t.
__wchar_t s[] = L"Hello world!"; // expected-error {{array initializer must be an initializer list{{$}}}} __wchar_t s[] = L"Hello world!"; // expected-error-re {{array initializer must be an initializer list{{$}}}}
// Do not suggest initializing with a string here, because it would not work. // Do not suggest initializing with a string here, because it would not work.
__wchar_t t[] = 1; // expected-error {{array initializer must be an initializer list{{$}}}} __wchar_t t[] = 1; // expected-error-re {{array initializer must be an initializer list{{$}}}}

8
test/Sema/thread-specifier.c
View File

@ -21,7 +21,7 @@ __thread static int t3;
__thread __private_extern__ int t4; __thread __private_extern__ int t4;
struct t5 { __thread int x; }; struct t5 { __thread int x; };
#ifdef __cplusplus #ifdef __cplusplus
// expected-error@-2 {{'{{__thread|_Thread_local|thread_local}}' is only allowed on variable declarations}} // expected-error-re@-2 {{'{{__thread|_Thread_local|thread_local}}' is only allowed on variable declarations}}
#else #else
// FIXME: The 'is only allowed on variable declarations' diagnostic is better here. // FIXME: The 'is only allowed on variable declarations' diagnostic is better here.
// expected-error@-5 {{type name does not allow storage class to be specified}} // expected-error@-5 {{type name does not allow storage class to be specified}}
@ -47,17 +47,17 @@ int f(__thread int t7) { // expected-error {{' is only allowed on variable decla
static __thread int t10; static __thread int t10;
__thread __private_extern__ int t11; __thread __private_extern__ int t11;
#if __cplusplus < 201103L #if __cplusplus < 201103L
__thread auto int t12a; // expected-error {{cannot combine with previous '{{__thread|_Thread_local}}' declaration specifier}} __thread auto int t12a; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local}}' declaration specifier}}
auto __thread int t12b; // expected-error {{cannot combine with previous 'auto' declaration specifier}} auto __thread int t12b; // expected-error {{cannot combine with previous 'auto' declaration specifier}}
#elif !defined(CXX11) #elif !defined(CXX11)
__thread auto t12a = 0; // expected-error {{'_Thread_local' variables must have global storage}} __thread auto t12a = 0; // expected-error {{'_Thread_local' variables must have global storage}}
auto __thread t12b = 0; // expected-error {{'_Thread_local' variables must have global storage}} auto __thread t12b = 0; // expected-error {{'_Thread_local' variables must have global storage}}
#endif #endif
__thread register int t13a; // expected-error {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}} __thread register int t13a; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
register __thread int t13b; // expected-error {{cannot combine with previous 'register' declaration specifier}} register __thread int t13b; // expected-error {{cannot combine with previous 'register' declaration specifier}}
} }
__thread typedef int t14; // expected-error {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}} __thread typedef int t14; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
__thread int t15; // expected-note {{previous declaration is here}} __thread int t15; // expected-note {{previous declaration is here}}
extern int t15; // expected-error {{non-thread-local declaration of 't15' follows thread-local declaration}} extern int t15; // expected-error {{non-thread-local declaration of 't15' follows thread-local declaration}}
extern int t16; // expected-note {{previous declaration is here}} extern int t16; // expected-note {{previous declaration is here}}

20
test/SemaCXX/addr-of-overloaded-function.cpp
View File

@ -84,7 +84,7 @@ struct C {
void h() { void h() {
// Do not suggest '()' since an int argument is required // Do not suggest '()' since an int argument is required
q1<int>; // expected-error{{reference to non-static member function must be called{{$}}}} q1<int>; // expected-error-re{{reference to non-static member function must be called{{$}}}}
// Suggest '()' since there's a default value for the only argument & the // Suggest '()' since there's a default value for the only argument & the
// type argument is already provided // type argument is already provided
q2<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} q2<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
@ -92,7 +92,7 @@ struct C {
// already provided // already provided
q3<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} q3<int>; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
// Do not suggest '()' since another type argument is required // Do not suggest '()' since another type argument is required
q4<int>; // expected-error{{reference to non-static member function must be called{{$}}}} q4<int>; // expected-error-re{{reference to non-static member function must be called{{$}}}}
// Suggest '()' since the type parameter has a default value // Suggest '()' since the type parameter has a default value
q5; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}} q5; // expected-error{{reference to non-static member function must be called; did you mean to call it with no arguments?}}
} }
@ -220,20 +220,20 @@ namespace test1 {
void QualifierTest() { void QualifierTest() {
void (Qualifiers::*X)(); void (Qualifiers::*X)();
X = &Qualifiers::C; // expected-error {{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const': different qualifiers (none vs const)}} X = &Qualifiers::C; // expected-error-re {{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const': different qualifiers (none vs const)}}
X = &Qualifiers::V; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile': different qualifiers (none vs volatile)}} X = &Qualifiers::V; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile': different qualifiers (none vs volatile)}}
X = &Qualifiers::R; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} restrict': different qualifiers (none vs restrict)}} X = &Qualifiers::R; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} restrict': different qualifiers (none vs restrict)}}
X = &Qualifiers::CV; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile': different qualifiers (none vs const and volatile)}} X = &Qualifiers::CV; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile': different qualifiers (none vs const and volatile)}}
X = &Qualifiers::CR; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const restrict': different qualifiers (none vs const and restrict)}} X = &Qualifiers::CR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const restrict': different qualifiers (none vs const and restrict)}}
X = &Qualifiers::VR; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile restrict': different qualifiers (none vs volatile and restrict)}} X = &Qualifiers::VR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} volatile restrict': different qualifiers (none vs volatile and restrict)}}
X = &Qualifiers::CVR; // expected-error{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile restrict': different qualifiers (none vs const, volatile, and restrict)}} X = &Qualifiers::CVR; // expected-error-re{{assigning to 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' from incompatible type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}} const volatile restrict': different qualifiers (none vs const, volatile, and restrict)}}
} }
struct Dummy { struct Dummy {
void N() {}; void N() {};
}; };
void (Qualifiers::*X)() = &Dummy::N; // expected-error{{cannot initialize a variable of type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (test1::Dummy::*)(){{( __attribute__\(\(thiscall\)\))?}}': different classes ('test1::Qualifiers' vs 'test1::Dummy')}} void (Qualifiers::*X)() = &Dummy::N; // expected-error-re{{cannot initialize a variable of type 'void (test1::Qualifiers::*)(){{( __attribute__\(\(thiscall\)\))?}}' with an rvalue of type 'void (test1::Dummy::*)(){{( __attribute__\(\(thiscall\)\))?}}': different classes ('test1::Qualifiers' vs 'test1::Dummy')}}
} }
template <typename T> class PR16561 { template <typename T> class PR16561 {

2
test/SemaCXX/const-cast.cpp
View File

@ -60,7 +60,7 @@ short *bad_const_cast_test(char const *volatile *const volatile *var)
// Function pointers. // Function pointers.
f fp2 = const_cast<f>(fp1); // expected-error {{const_cast to 'f' (aka 'int (*)(int)'), which is not a reference, pointer-to-object, or pointer-to-data-member}} f fp2 = const_cast<f>(fp1); // expected-error {{const_cast to 'f' (aka 'int (*)(int)'), which is not a reference, pointer-to-object, or pointer-to-data-member}}
void (A::*mfn)() = 0; void (A::*mfn)() = 0;
(void)const_cast<void (A::*)()>(mfn); // expected-error {{const_cast to 'void (A::*)(){{( __attribute__\(\(thiscall\)\))?}}', which is not a reference, pointer-to-object, or pointer-to-data-member}} (void)const_cast<void (A::*)()>(mfn); // expected-error-re {{const_cast to 'void (A::*)(){{( __attribute__\(\(thiscall\)\))?}}', which is not a reference, pointer-to-object, or pointer-to-data-member}}
(void)const_cast<int&&>(0); // expected-error {{const_cast from rvalue to reference type 'int &&'}} expected-warning {{C++11}} (void)const_cast<int&&>(0); // expected-error {{const_cast from rvalue to reference type 'int &&'}} expected-warning {{C++11}}
return **var3; return **var3;
} }

4
test/SemaCXX/constexpr-printing.cpp
View File

@ -38,7 +38,7 @@ constexpr int test_printing(int a, float b, _Complex int c, _Complex float d,
U u2(0); // expected-note {{here}} U u2(0); // expected-note {{here}}
static_assert(test_printing(12, 39.762, 3 + 4i, 12.9 + 3.6i, &u2.arr[4], u2.another.arr[2], (vector_int){5, 1, 2, 3}, u1) == 0, ""); // \ static_assert(test_printing(12, 39.762, 3 + 4i, 12.9 + 3.6i, &u2.arr[4], u2.another.arr[2], (vector_int){5, 1, 2, 3}, u1) == 0, ""); // \
expected-error {{constant expression}} \ expected-error {{constant expression}} \
expected-note {{in call to 'test_printing(12, 3.976200e+01, 3+4i, 1.290000e+01+3.600000e+00i, &u2.T::arr[4], u2.another.arr[2], {5, 1, 2, 3}, {{[{][{][{][}][}]}}, {{[{][{][}][}]}}}}, &u1.T::arr[2]})'}} expected-note {{in call to 'test_printing(12, 3.976200e+01, 3+4i, 1.290000e+01+3.600000e+00i, &u2.T::arr[4], u2.another.arr[2], {5, 1, 2, 3}, {{{}}, {{}}, &u1.T::arr[2]})'}}
struct V { struct V {
// FIXME: when we can generate these as constexpr constructors, remove the // FIXME: when we can generate these as constexpr constructors, remove the
@ -50,7 +50,7 @@ struct V {
constexpr V v; constexpr V v;
constexpr int get(const int *p) { return *p; } // expected-note {{read of dereferenced one-past-the-end pointer}} constexpr int get(const int *p) { return *p; } // expected-note {{read of dereferenced one-past-the-end pointer}}
constexpr int passLargeArray(V v) { return get(v.arr+256); } // expected-note {{in call to 'get(&v.arr[256])'}} constexpr int passLargeArray(V v) { return get(v.arr+256); } // expected-note {{in call to 'get(&v.arr[256])'}}
static_assert(passLargeArray(v) == 0, ""); // expected-error {{constant expression}} expected-note {{in call to 'passLargeArray({{[{][{]}}0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...{{[}][}]}})'}} static_assert(passLargeArray(v) == 0, ""); // expected-error {{constant expression}} expected-note {{in call to 'passLargeArray({{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...}})'}}
union Union { union Union {
constexpr Union(int n) : b(n) {} constexpr Union(int n) : b(n) {}

4
test/SemaCXX/cstyle-cast.cpp
View File

@ -227,6 +227,6 @@ void memptrs()
void (structure::*psf)() = 0; void (structure::*psf)() = 0;
(void)(int (structure::*)())(psf); (void)(int (structure::*)())(psf);
(void)(void (structure::*)())(psi); // expected-error {{C-style cast from 'const int structure::*' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}} (void)(void (structure::*)())(psi); // expected-error-re {{C-style cast from 'const int structure::*' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}}
(void)(int structure::*)(psf); // expected-error {{C-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}} (void)(int structure::*)(psf); // expected-error-re {{C-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}}
} }

4
test/SemaCXX/functional-cast.cpp
View File

@ -305,8 +305,8 @@ void memptrs()
(void)structureimfp(psf); (void)structureimfp(psf);
typedef void (structure::*structurevmfp)(); typedef void (structure::*structurevmfp)();
(void)structurevmfp(psi); // expected-error {{functional-style cast from 'const int structure::*' to 'structurevmfp' (aka 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}') is not allowed}} (void)structurevmfp(psi); // expected-error-re {{functional-style cast from 'const int structure::*' to 'structurevmfp' (aka 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}') is not allowed}}
(void)structureimp(psf); // expected-error {{functional-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'structureimp' (aka 'int structure::*') is not allowed}} (void)structureimp(psf); // expected-error-re {{functional-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'structureimp' (aka 'int structure::*') is not allowed}}
} }
// ---------------- misc ------------------ // ---------------- misc ------------------

4
test/SemaCXX/member-expr.cpp
View File

@ -193,7 +193,7 @@ namespace PR15045 {
}; };
template <class T> void call_func(T t) { template <class T> void call_func(T t) {
t->func(); // expected-error 2 {{member reference type 'PR15045::bar' is not a pointer{{$}}}} \ t->func(); // expected-error-re 2 {{member reference type 'PR15045::bar' is not a pointer{{$}}}} \
// expected-note {{did you mean to use '.' instead?}} // expected-note {{did you mean to use '.' instead?}}
} }
@ -207,7 +207,7 @@ namespace PR15045 {
// Make sure a fixit isn't given in the case that the '->' isn't actually // Make sure a fixit isn't given in the case that the '->' isn't actually
// the problem (the problem is with the return value of an operator->). // the problem (the problem is with the return value of an operator->).
f->func(); // expected-error {{member reference type 'PR15045::bar' is not a pointer{{$}}}} f->func(); // expected-error-re {{member reference type 'PR15045::bar' is not a pointer{{$}}}}
call_func(e); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::bar>' requested here}} call_func(e); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::bar>' requested here}}

2
test/SemaCXX/nested-name-spec.cpp
View File

@ -143,7 +143,7 @@ namespace A {
void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}} void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}}
} }
void A::f() {} // expected-error{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}} void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}} void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}

4
test/SemaCXX/operator-arrow-depth.cpp
View File

@ -9,7 +9,7 @@ template<int N> struct A {
template<int N> struct B { template<int N> struct B {
A<N-1> operator->(); // expected-note +{{'operator->' declared here produces an object of type 'A<}} A<N-1> operator->(); // expected-note +{{'operator->' declared here produces an object of type 'A<}}
#if MAX != 2 #if MAX != 2
// expected-note@-2 {{(skipping {{120|2}} 'operator->'s in backtrace)}} // expected-note-re@-2 {{(skipping {{120|2}} 'operator->'s in backtrace)}}
#endif #endif
}; };
@ -22,5 +22,5 @@ A<MAX/2> good;
int n = good->n; int n = good->n;
B<MAX/2 + 1> bad; B<MAX/2 + 1> bad;
int m = bad->n; // expected-error {{use of 'operator->' on type 'B<{{2|10|128}} / 2 + 1>' would invoke a sequence of more than {{2|10|128}} 'operator->' calls}} int m = bad->n; // expected-error-re {{use of 'operator->' on type 'B<{{2|10|128}} / 2 + 1>' would invoke a sequence of more than {{2|10|128}} 'operator->' calls}}
// expected-note@-1 {{use -foperator-arrow-depth=N to increase 'operator->' limit}} // expected-note@-1 {{use -foperator-arrow-depth=N to increase 'operator->' limit}}

2
test/SemaCXX/pr13394-crash-on-invalid.cpp
View File

@ -13,7 +13,7 @@ namespace gatekeeper_v1 {
}; };
} }
// FIXME: Typo correction should remove the 'gatekeeper_v1::' name specifier // FIXME: Typo correction should remove the 'gatekeeper_v1::' name specifier
gatekeeper_v1::closure_t *x; // expected-error {{no type named 'closure_t' in namespace 'gatekeeper_v1'{{$}}}} gatekeeper_v1::closure_t *x; // expected-error-re {{no type named 'closure_t' in namespace 'gatekeeper_v1'{{$}}}}
} }
namespace Foo { namespace Foo {

2
test/SemaCXX/qualified-id-lookup.cpp
View File

@ -94,7 +94,7 @@ namespace a {
void test_a() { void test_a() {
a::a::i = 3; // expected-error{{no member named 'i' in namespace 'a::a'; did you mean 'a::a::a::i'?}} a::a::i = 3; // expected-error{{no member named 'i' in namespace 'a::a'; did you mean 'a::a::a::i'?}}
a::a::a::i = 4; a::a::a::i = 4;
a::a::j = 3; // expected-error{{no member named 'j' in namespace 'a::a'{{$}}}} a::a::j = 3; // expected-error-re{{no member named 'j' in namespace 'a::a'{{$}}}}
} }
struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}} struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}}

6
test/SemaCXX/reinterpret-cast.cpp
View File

@ -96,12 +96,12 @@ void memptrs()
void (structure::*psf)() = 0; void (structure::*psf)() = 0;
(void)reinterpret_cast<int (structure::*)()>(psf); (void)reinterpret_cast<int (structure::*)()>(psf);
(void)reinterpret_cast<void (structure::*)()>(psi); // expected-error {{reinterpret_cast from 'const int structure::*' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}} (void)reinterpret_cast<void (structure::*)()>(psi); // expected-error-re {{reinterpret_cast from 'const int structure::*' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}}
(void)reinterpret_cast<int structure::*>(psf); // expected-error {{reinterpret_cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}} (void)reinterpret_cast<int structure::*>(psf); // expected-error-re {{reinterpret_cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}}
// Cannot cast from integers to member pointers, not even the null pointer // Cannot cast from integers to member pointers, not even the null pointer
// literal. // literal.
(void)reinterpret_cast<void (structure::*)()>(0); // expected-error {{reinterpret_cast from 'int' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}} (void)reinterpret_cast<void (structure::*)()>(0); // expected-error-re {{reinterpret_cast from 'int' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}}
(void)reinterpret_cast<int structure::*>(0); // expected-error {{reinterpret_cast from 'int' to 'int structure::*' is not allowed}} (void)reinterpret_cast<int structure::*>(0); // expected-error {{reinterpret_cast from 'int' to 'int structure::*' is not allowed}}
} }

2
test/SemaCXX/static-cast.cpp
View File

@ -192,6 +192,6 @@ namespace PR6072 {
(void)static_cast<void (A::*)()>(&B::f); (void)static_cast<void (A::*)()>(&B::f);
(void)static_cast<void (B::*)()>(&B::f); (void)static_cast<void (B::*)()>(&B::f);
(void)static_cast<void (C::*)()>(&B::f); (void)static_cast<void (C::*)()>(&B::f);
(void)static_cast<void (D::*)()>(&B::f); // expected-error{{address of overloaded function 'f' cannot be static_cast to type 'void (PR6072::D::*)(){{( __attribute__\(\(thiscall\)\))?}}'}} (void)static_cast<void (D::*)()>(&B::f); // expected-error-re{{address of overloaded function 'f' cannot be static_cast to type 'void (PR6072::D::*)(){{( __attribute__\(\(thiscall\)\))?}}'}}
} }
} }

16
test/SemaCXX/typo-correction-pt2.cpp
View File

@ -7,8 +7,8 @@
namespace bogus_keyword_suggestion { namespace bogus_keyword_suggestion {
void test() { void test() {
status = "OK"; // expected-error {{use of undeclared identifier 'status'{{$}}}} status = "OK"; // expected-error-re {{use of undeclared identifier 'status'{{$}}}}
return status; // expected-error {{use of undeclared identifier 'status'{{$}}}} return status; // expected-error-re {{use of undeclared identifier 'status'{{$}}}}
} }
} }
@ -33,7 +33,7 @@ struct T {
}; };
// should be void T::f(); // should be void T::f();
void f() { void f() {
data_struct->foo(); // expected-error{{use of undeclared identifier 'data_struct'{{$}}}} data_struct->foo(); // expected-error-re{{use of undeclared identifier 'data_struct'{{$}}}}
} }
namespace PR12287 { namespace PR12287 {
@ -116,9 +116,9 @@ public:
void testAccess() { void testAccess() {
Figure obj; Figure obj;
switch (obj.type()) { // expected-warning {{enumeration values 'SQUARE', 'TRIANGLE', and 'CIRCLE' not handled in switch}} switch (obj.type()) { // expected-warning {{enumeration values 'SQUARE', 'TRIANGLE', and 'CIRCLE' not handled in switch}}
case SQUARE: // expected-error {{use of undeclared identifier 'SQUARE'{{$}}}} case SQUARE: // expected-error-re {{use of undeclared identifier 'SQUARE'{{$}}}}
case TRIANGLE: // expected-error {{use of undeclared identifier 'TRIANGLE'{{$}}}} case TRIANGLE: // expected-error-re {{use of undeclared identifier 'TRIANGLE'{{$}}}}
case CIRCE: // expected-error {{use of undeclared identifier 'CIRCE'{{$}}}} case CIRCE: // expected-error-re {{use of undeclared identifier 'CIRCE'{{$}}}}
break; break;
} }
} }
@ -126,13 +126,13 @@ void testAccess() {
long readline(const char *, char *, unsigned long); long readline(const char *, char *, unsigned long);
void assign_to_unknown_var() { void assign_to_unknown_var() {
deadline_ = 1; // expected-error {{use of undeclared identifier 'deadline_'{{$}}}} deadline_ = 1; // expected-error-re {{use of undeclared identifier 'deadline_'{{$}}}}
} }
namespace no_ns_before_dot { namespace no_ns_before_dot {
namespace re2 {} namespace re2 {}
void test() { void test() {
req.set_check(false); // expected-error {{use of undeclared identifier 'req'{{$}}}} req.set_check(false); // expected-error-re {{use of undeclared identifier 'req'{{$}}}}
} }
} }

2
test/SemaCXX/typo-correction.cpp
View File

@ -299,6 +299,6 @@ namespace CorrectTypo_has_reached_its_limit {
int flibberdy(); // expected-note{{'flibberdy' declared here}} int flibberdy(); // expected-note{{'flibberdy' declared here}}
int no_correction() { int no_correction() {
return hibberdy() + // expected-error{{use of undeclared identifier 'hibberdy'; did you mean 'flibberdy'?}} return hibberdy() + // expected-error{{use of undeclared identifier 'hibberdy'; did you mean 'flibberdy'?}}
gibberdy(); // expected-error{{use of undeclared identifier 'gibberdy'{{$}}}} gibberdy(); // expected-error-re{{use of undeclared identifier 'gibberdy'{{$}}}}
}; };
} }

4
test/SemaTemplate/dependent-names.cpp
View File

@ -232,7 +232,7 @@ namespace PR10053 {
struct Data {}; struct Data {};
} }
std::ostream &print(std::ostream &out, int); // expected-note {{should be declared prior to the call site{{$}}}} std::ostream &print(std::ostream &out, int); // expected-note-re {{should be declared prior to the call site{{$}}}}
std::ostream &print(std::ostream &out, ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns'}} std::ostream &print(std::ostream &out, ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns'}}
std::ostream &print(std::ostream &out, std::vector<ns2::Data>); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns2'}} std::ostream &print(std::ostream &out, std::vector<ns2::Data>); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns2'}}
std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>); // expected-note {{should be declared prior to the call site or in an associated namespace of one of its arguments}} std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>); // expected-note {{should be declared prior to the call site or in an associated namespace of one of its arguments}}
@ -397,5 +397,5 @@ namespace OperatorNew {
struct X {}; struct X {};
}; };
using size_t = decltype(sizeof(0)); using size_t = decltype(sizeof(0));
void *operator new(size_t, OperatorNew::X); // expected-note {{should be declared prior to the call site{{$}}}} void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}} template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}

2
test/SemaTemplate/explicit-instantiation.cpp
View File

@ -16,7 +16,7 @@ struct X0 {
} }
T* f0(T*, T*) { return T(); } // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}} T* f0(T*, T*) { return T(); } // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
template <typename U> T f0(T, U) { return T(); } // expected-note {{candidate template ignored: could not match 'int (int, U){{( __attribute__\(\(thiscall\)\))?}}' against 'int (int){{( __attribute__\(\(thiscall\)\))?}} const'}} \ template <typename U> T f0(T, U) { return T(); } // expected-note-re {{candidate template ignored: could not match 'int (int, U){{( __attribute__\(\(thiscall\)\))?}}' against 'int (int){{( __attribute__\(\(thiscall\)\))?}} const'}} \
// expected-note {{candidate template ignored: could not match 'int' against 'int *'}} // expected-note {{candidate template ignored: could not match 'int' against 'int *'}}
}; };

2
test/SemaTemplate/instantiate-method.cpp
View File

@ -178,7 +178,7 @@ namespace PR7022 {
namespace SameSignatureAfterInstantiation { namespace SameSignatureAfterInstantiation {
template<typename T> struct S { template<typename T> struct S {
void f(T *); // expected-note {{previous}} void f(T *); // expected-note {{previous}}
void f(const T*); // expected-error {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}} void f(const T*); // expected-error-re {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}}
}; };
S<const int> s; // expected-note {{instantiation}} S<const int> s; // expected-note {{instantiation}}
} }

2
test/SemaTemplate/ms-lookup-template-base-classes.cpp
View File

@ -222,7 +222,7 @@ template <typename T> struct C : T {
}; };
template struct B<A>; template struct B<A>;
template struct C<A>; // expected-note 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}} template struct C<A>; // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}}
template <typename T> struct D : T { template <typename T> struct D : T {
struct Inner { struct Inner {

2
test/SemaTemplate/temp_arg_nontype.cpp
View File

@ -82,7 +82,7 @@ struct Z {
template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}} template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
A6<&Z::foo> *a17_1; A6<&Z::foo> *a17_1;
A6<&Z::bar> *a17_2; A6<&Z::bar> *a17_2;
A6<&Z::baz> *a17_3; // expected-error{{non-type template argument of type 'double (Z::*)(double){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (Z::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}} A6<&Z::baz> *a17_3; // expected-error-re{{non-type template argument of type 'double (Z::*)(double){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (Z::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
template<int Z::*pm> struct A7; // expected-note{{template parameter is declared here}} template<int Z::*pm> struct A7; // expected-note{{template parameter is declared here}}

4
test/SemaTemplate/typename-specifier.cpp
View File

@ -137,8 +137,8 @@ class ExampleClass1 {
void foo() { void foo() {
pair<ExampleItemSet::iterator, int> i; // expected-error {{template argument for template type parameter must be a type; did you forget 'typename'?}} pair<ExampleItemSet::iterator, int> i; // expected-error {{template argument for template type parameter must be a type; did you forget 'typename'?}}
pair<this->ExampleItemSet::iterator, int> i; // expected-error {{template argument for template type parameter must be a type{{$}}}} pair<this->ExampleItemSet::iterator, int> i; // expected-error-re {{template argument for template type parameter must be a type{{$}}}}
pair<ExampleItemSet::operator[], int> i; // expected-error {{template argument for template type parameter must be a type{{$}}}} pair<ExampleItemSet::operator[], int> i; // expected-error-re {{template argument for template type parameter must be a type{{$}}}}
} }
pair<ExampleItemSet::iterator, int> elt; // expected-error {{template argument for template type parameter must be a type; did you forget 'typename'?}} pair<ExampleItemSet::iterator, int> elt; // expected-error {{template argument for template type parameter must be a type; did you forget 'typename'?}}