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

Differential Revision: http://llvm-reviews.chandlerc.com/D2392

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@197295 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td
index 65a11cbc66556470ca2dbd1097f4620f196220eb..bcf3c41cdb648a51be91ed1fd7510c1eced97060 100644 (file)
--- a/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -77,8 +77,6 @@ def err_verify_missing_end : Error<
     "cannot find end ('}}') of expected %0">;
 def err_verify_invalid_content : Error<
     "invalid expected %0: %1">;
-def err_verify_missing_regex : Error<
-    "cannot find start of regex ('{{') in %0">;
 def err_verify_inconsistent_diags : Error<
     "'%0' diagnostics %select{expected|seen}1 but not %select{seen|expected}1: "
     "%2">;

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

diff --git a/lib/Frontend/VerifyDiagnosticConsumer.cpp b/lib/Frontend/VerifyDiagnosticConsumer.cpp
index 40992fec3f6aafbd5c40573b0ababb705575768a..ec45e36c7139625eaca60ff7d5492fda964cae29 100644 (file)
--- a/lib/Frontend/VerifyDiagnosticConsumer.cpp
+++ b/lib/Frontend/VerifyDiagnosticConsumer.cpp
@@ -356,16 +356,8 @@ static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
       return true;
 
     // Default directive kind.
-    bool RegexKind = false;
     const char* KindStr = "string";
 
-    // Next optional token: -
-    if (PH.Next("-re")) {
-      PH.Advance();
-      RegexKind = true;
-      KindStr = "regex";
-    }
-
     // Next optional token: @
     SourceLocation ExpectedLoc;
     if (!PH.Next("@")) {
@@ -483,16 +475,8 @@ static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
     if (Text.empty())
       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.
-    Directive *D = Directive::create(RegexKind, Pos, ExpectedLoc, Text,
-                                     Min, Max);
+    Directive *D = Directive::create(Pos, ExpectedLoc, Text, Min, Max);
     std::string Error;
     if (D->isValid(Error)) {
       DL->push_back(D);
@@ -851,10 +835,10 @@ void VerifyDiagnosticConsumer::CheckDiagnostics() {
   ED.Notes.clear();
 }
 
-Directive *Directive::create(bool RegexKind, SourceLocation DirectiveLoc,
+Directive *Directive::create(SourceLocation DirectiveLoc,
                              SourceLocation DiagnosticLoc, StringRef Text,
                              unsigned Min, unsigned Max) {
-  if (!RegexKind)
+  if (Text.find("}}") == StringRef::npos)
     return new StandardDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);
 
   // Parse the directive into a regular expression.

diff --git a/test/Analysis/analyzer-stats.c b/test/Analysis/analyzer-stats.c
index a0a50cbc9343448cd84229b84f93a3b01872a14a..93a1f13ac48525a6bccde89c16c33af5f685f80b 100644 (file)
--- a/test/Analysis/analyzer-stats.c
+++ b/test/Analysis/analyzer-stats.c
@@ -2,7 +2,7 @@
 
 int foo();
 
-int test() { // expected-warning-re{{test -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 0 | Exhausted Block: no | Empty WorkList: yes}}
+int test() { // expected-warning{{test -> Total CFGBlocks: {{[0-9]+}} | Unreachable CFGBlocks: 0 | Exhausted Block: no | Empty WorkList: yes}}
   int a = 1;
   a = 34 / 12;
 

diff --git a/test/CXX/class.access/p6.cpp b/test/CXX/class.access/p6.cpp
index 5007263a355b666ce98ce01c67f362aaebab6046..702dba51caa98783717bce35f0da318870e74fb9 100644 (file)
--- a/test/CXX/class.access/p6.cpp
+++ b/test/CXX/class.access/p6.cpp
@@ -177,7 +177,7 @@ namespace test8 {
   };
 
   void test(A &a) {
-    if (a) return; // expected-error-re {{'operator void *(class test8::A::*)(void){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}}
+    if (a) return; // expected-error {{'operator void *(class test8::A::*)(void){{( __attribute__\(\(thiscall\)\))?}} const' is a private member of 'test8::A'}}
   }
 }
 

diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp
index 08fefdc91fb5bdcaaadf4c1a1340f99fe060ac94..44aea7bfd63fefe0d3e39070c6d6f3b6587b5f73 100644 (file)
--- a/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp
+++ b/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p1.cpp
@@ -27,7 +27,7 @@ void f2(constexpr int i) {} // expected-error {{function parameter cannot be con
 struct s2 {
   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}}
-  mutable constexpr int mi3 = 3; // expected-error-re {{non-static data member cannot be constexpr{{$}}}} expected-error {{'mutable' and 'const' cannot be mixed}}
+  mutable constexpr int mi3 = 3; // expected-error {{non-static data member cannot be constexpr{{$}}}} expected-error {{'mutable' and 'const' cannot be mixed}}
 };
 // typedef
 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 {
   template<typename T> constexpr T f(); // expected-warning {{C++1y}}
   template <typename T>
-  T g() const; // expected-note-re {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}}
+  T g() const; // expected-note {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}}
 };
 
 // explicit specialization can differ in constepxr

diff --git a/test/CXX/drs/dr14xx.cpp b/test/CXX/drs/dr14xx.cpp
index 8de1b8d623a9243a91ee6a62cc0a7c504ae348aa..d038401cc94d5d2302628b00194f73ffdeb99b65 100644 (file)
--- a/test/CXX/drs/dr14xx.cpp
+++ b/test/CXX/drs/dr14xx.cpp
@@ -84,7 +84,7 @@ namespace dr1460 { // dr1460: 3.5
 
 #if __cplusplus > 201103L
   template<typename T> constexpr bool check() {
-    T t; // expected-note-re 2{{non-constexpr constructor '{{[BE]}}'}}
+    T t; // expected-note 2{{non-constexpr constructor '{{[BE]}}'}}
     return true;
   }
   static_assert(check<A>(), "");

diff --git a/test/CXX/expr/expr.const/p3-0x.cpp b/test/CXX/expr/expr.const/p3-0x.cpp
index d9d84853ebae92fff3b456ed0ac0377a27da2aa7..c202a4e53f72197e9434e0110594df4c862afd19 100644 (file)
--- a/test/CXX/expr/expr.const/p3-0x.cpp
+++ b/test/CXX/expr/expr.const/p3-0x.cpp
@@ -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<(bool)&S::operator int>();
 
-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}}
+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}}
 
 namespace NonConstLValue {
   struct S {

diff --git a/test/CXX/expr/expr.mptr.oper/p5.cpp b/test/CXX/expr/expr.mptr.oper/p5.cpp
index c26b30d43da19e6853367d7fc2b96c729d7fefb9..a86c44c698f02e8249eb55c777b1b4dc627e3341 100644 (file)
--- a/test/CXX/expr/expr.mptr.oper/p5.cpp
+++ b/test/CXX/expr/expr.mptr.oper/p5.cpp
@@ -24,19 +24,19 @@ void test_object_cvquals(void (X0::*pm)(),
   (p->*pmv)();
   (p->*pmcv)();
 
-  (pc->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
+  (pc->*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
   (pc->*pmc)();
-  (pc->*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
+  (pc->*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
   (pc->*pmcv)();
 
-  (pv->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}}
-  (pv->*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
+  (pv->*pm)(); // expected-error{{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->*pmv)();
   (pv->*pmcv)();
 
-  (pcv->*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}}
-  (pcv->*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
-  (pcv->*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
+  (pcv->*pm)(); // expected-error{{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->*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
   (pcv->*pmcv)();
 
   (o.*pm)();
@@ -44,18 +44,18 @@ void test_object_cvquals(void (X0::*pm)(),
   (o.*pmv)();
   (o.*pmcv)();
 
-  (oc.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
+  (oc.*pm)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const' qualifier}}
   (oc.*pmc)();
-  (oc.*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
+  (oc.*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
   (oc.*pmcv)();
 
-  (ov.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'volatile' qualifier}}
-  (ov.*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
+  (ov.*pm)(); // expected-error{{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.*pmv)();
   (ov.*pmcv)();
 
-  (ocv.*pm)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}}' drops 'const volatile' qualifiers}}
-  (ocv.*pmc)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} const' drops 'volatile' qualifier}}
-  (ocv.*pmv)(); // expected-error-re{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
+  (ocv.*pm)(); // expected-error{{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.*pmv)(); // expected-error{{call to pointer to member function of type 'void (){{( __attribute__\(\(thiscall\)\))?}} volatile' drops 'const' qualifier}}
   (ocv.*pmcv)();
 }

diff --git a/test/CXX/expr/expr.mptr.oper/p6-0x.cpp b/test/CXX/expr/expr.mptr.oper/p6-0x.cpp
index b1823e59fff28493fb466ea630a7ab91bd49d98a..b82519768b6a810d82c4bf0e2f5e9fc8191c2d9d 100644 (file)
--- a/test/CXX/expr/expr.mptr.oper/p6-0x.cpp
+++ b/test/CXX/expr/expr.mptr.oper/p6-0x.cpp
@@ -22,13 +22,13 @@ void test(X *xp, int (X::*pmf)(int), int (X::*l_pmf)(int) &,
 
   // Lvalue ref-qualifier.
   (lvalue<X>().*l_pmf)(17);
-  (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-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
+  (xvalue<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{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &' can only be called on an lvalue}}
   (xp->*l_pmf)(17);
 
   // Rvalue ref-qualifier.
-  (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}}
+  (lvalue<X>().*r_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
   (xvalue<X>().*r_pmf)(17);
   (prvalue<X>().*r_pmf)(17);
-  (xp->*r_pmf)(17);  // expected-error-re{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
+  (xp->*r_pmf)(17);  // expected-error{{pointer-to-member function type 'int (X::*)(int){{( __attribute__\(\(thiscall\)\))?}} &&' can only be called on an rvalue}}
 }

diff --git a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
index 9babf8728cc0617baced5ef363fed5e30ec0547b..8bf61c747994007edccd08e0c94e41321703c7b6 100644 (file)
--- a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
+++ b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
@@ -7,7 +7,7 @@ namespace test0 {
     template<typename T> void g(T);
 
     void test() {
-      foo(&g<int>); // expected-error-re {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}}
+      foo(&g<int>); // expected-error {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}}
     }
   };
 }

diff --git a/test/CXX/special/class.copy/implicit-move.cpp b/test/CXX/special/class.copy/implicit-move.cpp
index a10d139fe3cd91b002f21d44247299dd8600135a..845b5eb53b6edcbbdbdef600d229ec2715ccbbd2 100644 (file)
--- a/test/CXX/special/class.copy/implicit-move.cpp
+++ b/test/CXX/special/class.copy/implicit-move.cpp
@@ -258,8 +258,8 @@ namespace DR1402 {
 
     template<typename T>
     struct F :
-      E<T, 0>, // expected-note-re 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<}}
+      E<T, 0>, // expected-note 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<}}
 
     template<typename T>
     struct G : E<T, 0, true>, E<T, 0> {};
@@ -272,11 +272,11 @@ namespace DR1402 {
 
     template<typename T>
     struct J :
-      E<T, 0>, // expected-note-re 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
-      virtual T {}; // expected-note-re 2{{virtual base class '{{[BD]}}' declared here}}
+      E<T, 0>, // expected-note 2{{'{{[BD]}}' is a virtual base class of base class 'E<}}
+      virtual T {}; // expected-note 2{{virtual base class '{{[BD]}}' declared here}}
 
     template<typename T> void move(T t) { t = static_cast<T&&>(t); }
-    // expected-warning-re@-1 4{{defaulted move assignment operator of {{.*}} will move assign virtual base class '{{[BD]}}' multiple times}}
+    // expected-warning@-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<B>); // expected-note {{in instantiation of}}
     template void move(F<C>);

diff --git a/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp b/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
index e87153b9efe2e3c45b66106566f2f1998e648d5b..00090ca9b8fb53e0a41bdac92891c195c63815f0 100644 (file)
--- a/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
+++ b/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
@@ -184,7 +184,7 @@ namespace pointer_to_member_function {
   template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}}
   X0<&Y::f> x0a;
   X0<&Y::g> x0b;
-  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\)\))?}}'}}
+  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\)\))?}}'}}
 }
 
 //     -- For a non-type template-parameter of type pointer to data member,

diff --git a/test/Lexer/hexfloat.cpp b/test/Lexer/hexfloat.cpp
index bd53d4a89e5646aca43f648a284289f539c69e10..0244b285973c8ebefd783d16667ee4d6f3069daf 100644 (file)
--- a/test/Lexer/hexfloat.cpp
+++ b/test/Lexer/hexfloat.cpp
@@ -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}}
 #define PREFIX(x) foo ## x
 double foo0p = 1, j = PREFIX(0p+3); // ok
-double k = 0x42_amp+3; // expected-error-re{{{{invalid suffix '_amp' on integer constant|no matching literal operator for call to 'operator "" _amp'}}}}
+double k = 0x42_amp+3; // expected-error{{{{invalid suffix '_amp' on integer constant|no matching literal operator for call to 'operator "" _amp'}}}}

diff --git a/test/Misc/verify.c b/test/Misc/verify.c
index 9fe83e122e151ced80a32d63e5962f293256f487..b3843b1fa88628b3d9ddf74a8371f71855d4c0c8 100644 (file)
--- a/test/Misc/verify.c
+++ b/test/Misc/verify.c
@@ -8,7 +8,7 @@ struct s s2; // expected-error {{tentative definition has type}}
 
 // regex matching
 struct s r1; // expected-error    {{tentative definition has type 'struct s' that is never completed}}
-struct s r2; // expected-error-re {{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-re {{{{^}}tentative}}
-struct s r5; // expected-error-re {{completed{{$}}}}
+struct s r2; // expected-error {{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 r4; // expected-error {{{{^}}tentative}}
+struct s r5; // expected-error {{completed{{$}}}}

diff --git a/test/Parser/attributes.mm b/test/Parser/attributes.mm
index 024606bed3a106c2ee2ee2610d4bfc6f70b82842..de5b4c405df7f1a3f6bb5afb824a82948fc43488 100644 (file)
--- a/test/Parser/attributes.mm
+++ b/test/Parser/attributes.mm
@@ -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'}}
 EXP @interface I2 @end
 
-@implementation EXP I @end // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
+@implementation EXP I @end // expected-error {{postfix attributes are not allowed on Objective-C directives{{$}}}}
 // FIXME: Prefix attribute recovery skips until ';'
 EXP @implementation I2 @end; // expected-error {{prefix attribute must be followed by an interface or protocol}}
 
-@class EXP OC; // expected-error-re {{postfix attributes are not allowed on Objective-C directives{{$}}}}
+@class EXP OC; // expected-error {{postfix attributes are not allowed on Objective-C directives{{$}}}}
 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'}}

diff --git a/test/Sema/format-strings-scanf.c b/test/Sema/format-strings-scanf.c
index 381447c84a67e9241c0eda750afd867e87eea844..69112c0977efb0b076e5831471610d0791b7d388 100644 (file)
--- a/test/Sema/format-strings-scanf.c
+++ b/test/Sema/format-strings-scanf.c
@@ -107,9 +107,9 @@ void test_alloc_extension(char **sp, wchar_t **lsp, float *fp) {
 
   // 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-re{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}}
+  scanf("%mS", fp); // expected-warning{{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-re{{format specifies type 'wchar_t **' (aka '{{[^']+}}') but the argument has type 'float *'}}
+  scanf("%mC", fp); // expected-warning{{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 *'}}
 }
 

diff --git a/test/Sema/ms-wchar.c b/test/Sema/ms-wchar.c
index ead3d974d34fcb8804682f3db3da07a2d75b90cf..649827b1515e48100fce11cf664e49358b81f514 100644 (file)
--- a/test/Sema/ms-wchar.c
+++ b/test/Sema/ms-wchar.c
@@ -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'}}
 
 // The type of a wide string literal is actually not __wchar_t.
-__wchar_t s[] = L"Hello world!"; // expected-error-re {{array initializer must be an initializer list{{$}}}}
+__wchar_t s[] = L"Hello world!"; // expected-error {{array initializer must be an initializer list{{$}}}}
 
 // Do not suggest initializing with a string here, because it would not work.
-__wchar_t t[] = 1; // expected-error-re {{array initializer must be an initializer list{{$}}}}
+__wchar_t t[] = 1; // expected-error {{array initializer must be an initializer list{{$}}}}

diff --git a/test/Sema/thread-specifier.c b/test/Sema/thread-specifier.c
index 39243d1a760526807d9b4dfb883916cd289c8d53..f0e74628ce15350e837d1f76ce63f3dd47e7e44d 100644 (file)
--- a/test/Sema/thread-specifier.c
+++ b/test/Sema/thread-specifier.c
@@ -21,7 +21,7 @@ __thread static int t3;
 __thread __private_extern__ int t4;
 struct t5 { __thread int x; };
 #ifdef __cplusplus
-// expected-error-re@-2 {{'{{__thread|_Thread_local|thread_local}}' is only allowed on variable declarations}}
+// expected-error@-2 {{'{{__thread|_Thread_local|thread_local}}' is only allowed on variable declarations}}
 #else
 // 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}}
@@ -47,17 +47,17 @@ int f(__thread int t7) { // expected-error {{' is only allowed on variable decla
   static __thread int t10;
   __thread __private_extern__ int t11;
 #if __cplusplus < 201103L
-  __thread auto int t12a; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local}}' declaration specifier}}
+  __thread auto int t12a; // expected-error {{cannot combine with previous '{{__thread|_Thread_local}}' declaration specifier}}
   auto __thread int t12b; // expected-error {{cannot combine with previous 'auto' declaration specifier}}
 #elif !defined(CXX11)
   __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}}
 #endif
-  __thread register int t13a; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
+  __thread register int t13a; // expected-error {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
   register __thread int t13b; // expected-error {{cannot combine with previous 'register' declaration specifier}}
 }
 
-__thread typedef int t14; // expected-error-re {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
+__thread typedef int t14; // expected-error {{cannot combine with previous '{{__thread|_Thread_local|thread_local}}' declaration specifier}}
 __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 t16; // expected-note {{previous declaration is here}}

diff --git a/test/SemaCXX/addr-of-overloaded-function.cpp b/test/SemaCXX/addr-of-overloaded-function.cpp
index 358fe8d5b08e58c4441b66209a20dca83dbaf3ca..0ab2e603d7f44a32108537fe7759e8d751773862 100644 (file)
--- a/test/SemaCXX/addr-of-overloaded-function.cpp
+++ b/test/SemaCXX/addr-of-overloaded-function.cpp
@@ -84,7 +84,7 @@ struct C {
 
   void h() {
     // Do not suggest '()' since an int argument is required
-    q1<int>; // expected-error-re{{reference to non-static member function must be called{{$}}}}
+    q1<int>; // expected-error{{reference to non-static member function must be called{{$}}}}
     // Suggest '()' since there's a default value for the only argument & the
     // 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?}}
@@ -92,7 +92,7 @@ struct C {
     // already provided
     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
-    q4<int>; // expected-error-re{{reference to non-static member function must be called{{$}}}}
+    q4<int>; // expected-error{{reference to non-static member function must be called{{$}}}}
     // 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?}}
   }
@@ -220,20 +220,20 @@ namespace test1 {
 
   void QualifierTest() {
     void (Qualifiers::*X)();
-    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-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-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-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-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-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-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)}}
+    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::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::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::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::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::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::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)}}
   }
 
   struct Dummy {
     void N() {};
   };
 
-  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')}}
+  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')}}
 }
 
 template <typename T> class PR16561 {

diff --git a/test/SemaCXX/const-cast.cpp b/test/SemaCXX/const-cast.cpp
index cb9937c50d50c9472b05e8c35ec91f9b87f2ac31..29abee0ddff2fbcc3000f9a3a04c78802235850b 100644 (file)
--- a/test/SemaCXX/const-cast.cpp
+++ b/test/SemaCXX/const-cast.cpp
@@ -60,7 +60,7 @@ short *bad_const_cast_test(char const *volatile *const volatile *var)
   // 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}}
   void (A::*mfn)() = 0;
-  (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<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<int&&>(0); // expected-error {{const_cast from rvalue to reference type 'int &&'}} expected-warning {{C++11}}
   return **var3;
 }

diff --git a/test/SemaCXX/constexpr-printing.cpp b/test/SemaCXX/constexpr-printing.cpp
index e545f45d6011ebeb69cf9898d8f4c546870abc4d..026db70e9d29bea1712a17e067204ee29b8bbd95 100644 (file)
--- a/test/SemaCXX/constexpr-printing.cpp
+++ b/test/SemaCXX/constexpr-printing.cpp
@@ -38,7 +38,7 @@ constexpr int test_printing(int a, float b, _Complex int c, _Complex float d,
 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, ""); // \
 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 {
   // FIXME: when we can generate these as constexpr constructors, remove the
@@ -50,7 +50,7 @@ struct V {
 constexpr V v;
 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])'}}
-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 {
   constexpr Union(int n) : b(n) {}

diff --git a/test/SemaCXX/cstyle-cast.cpp b/test/SemaCXX/cstyle-cast.cpp
index afac6a137ec4a449f05657ad25540577078d6257..65a3217dff628a46c8fa09e8bcdbdc67a5b9bd43 100644 (file)
--- a/test/SemaCXX/cstyle-cast.cpp
+++ b/test/SemaCXX/cstyle-cast.cpp
@@ -227,6 +227,6 @@ void memptrs()
   void (structure::*psf)() = 0;
   (void)(int (structure::*)())(psf);
 
-  (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-re {{C-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}}
+  (void)(void (structure::*)())(psi); // expected-error {{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}}
 }

diff --git a/test/SemaCXX/functional-cast.cpp b/test/SemaCXX/functional-cast.cpp
index f5ca76c38c065465c3424714b077f93bcfd508ef..a01df03a3a66bae02999414258cb02749bbb1572 100644 (file)
--- a/test/SemaCXX/functional-cast.cpp
+++ b/test/SemaCXX/functional-cast.cpp
@@ -305,8 +305,8 @@ void memptrs()
   (void)structureimfp(psf);
 
   typedef void (structure::*structurevmfp)();
-  (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-re {{functional-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'structureimp' (aka 'int structure::*') is not allowed}}
+  (void)structurevmfp(psi); // expected-error {{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}}
 }
 
 // ---------------- misc ------------------

diff --git a/test/SemaCXX/member-expr.cpp b/test/SemaCXX/member-expr.cpp
index e0955aeb9ce9d06460dddb9ed03058b5462fd448..847036bbd1329026f620b3952c79c99648a5b8d0 100644 (file)
--- a/test/SemaCXX/member-expr.cpp
+++ b/test/SemaCXX/member-expr.cpp
@@ -193,7 +193,7 @@ namespace PR15045 {
   };
 
   template <class T> void call_func(T t) {
-    t->func();  // expected-error-re 2 {{member reference type 'PR15045::bar' is not a pointer{{$}}}} \
+    t->func();  // expected-error 2 {{member reference type 'PR15045::bar' is not a pointer{{$}}}} \
                 // 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
     // the problem (the problem is with the return value of an operator->).
-    f->func();  // expected-error-re {{member reference type 'PR15045::bar' is not a pointer{{$}}}}
+    f->func();  // expected-error {{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}}
 

diff --git a/test/SemaCXX/nested-name-spec.cpp b/test/SemaCXX/nested-name-spec.cpp
index a0bac059a20d5e58a0a581f524a536d940871dce..ba768b502afd5b61b45d615204e6f8694198e5c5 100644 (file)
--- a/test/SemaCXX/nested-name-spec.cpp
+++ b/test/SemaCXX/nested-name-spec.cpp
@@ -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 A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
+void A::f() {} // expected-error{{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'}}
 

diff --git a/test/SemaCXX/operator-arrow-depth.cpp b/test/SemaCXX/operator-arrow-depth.cpp
index 769dae0d2461efda48d20d95e78c10ab7c831ac1..edb90437f55022571a1f4def093a9c2102b4db96 100644 (file)
--- a/test/SemaCXX/operator-arrow-depth.cpp
+++ b/test/SemaCXX/operator-arrow-depth.cpp
@@ -9,7 +9,7 @@ template<int N> struct A {
 template<int N> struct B {
   A<N-1> operator->(); // expected-note +{{'operator->' declared here produces an object of type 'A<}}
 #if MAX != 2
-  // expected-note-re@-2 {{(skipping {{120|2}} 'operator->'s in backtrace)}}
+  // expected-note@-2 {{(skipping {{120|2}} 'operator->'s in backtrace)}}
 #endif
 };
 
@@ -22,5 +22,5 @@ A<MAX/2> good;
 int n = good->n;
 
 B<MAX/2 + 1> bad;
-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}}
+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}}
                 // expected-note@-1 {{use -foperator-arrow-depth=N to increase 'operator->' limit}}

diff --git a/test/SemaCXX/pr13394-crash-on-invalid.cpp b/test/SemaCXX/pr13394-crash-on-invalid.cpp
index 42b6508c71329d23d5ee7fae5ed6e7d0273821e2..9cb213ad36b69d2ada8706bf10c877239c24aa7b 100644 (file)
--- a/test/SemaCXX/pr13394-crash-on-invalid.cpp
+++ b/test/SemaCXX/pr13394-crash-on-invalid.cpp
@@ -13,7 +13,7 @@ namespace gatekeeper_v1 {
     };
   }
   // FIXME: Typo correction should remove the 'gatekeeper_v1::' name specifier
-  gatekeeper_v1::closure_t *x; // expected-error-re {{no type named 'closure_t' in namespace 'gatekeeper_v1'{{$}}}}
+  gatekeeper_v1::closure_t *x; // expected-error {{no type named 'closure_t' in namespace 'gatekeeper_v1'{{$}}}}
 }
 
 namespace Foo {

diff --git a/test/SemaCXX/qualified-id-lookup.cpp b/test/SemaCXX/qualified-id-lookup.cpp
index 8eef6f41827467c7c73dfd251d86092bba12292b..77da74d15e792d3febf4af3e0b90ff792765be48 100644 (file)
--- a/test/SemaCXX/qualified-id-lookup.cpp
+++ b/test/SemaCXX/qualified-id-lookup.cpp
@@ -94,7 +94,7 @@ namespace 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::a::i = 4;
-  a::a::j = 3; // expected-error-re{{no member named 'j' in namespace 'a::a'{{$}}}}
+  a::a::j = 3; // expected-error{{no member named 'j' in namespace 'a::a'{{$}}}}
 }
   
 struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}}

diff --git a/test/SemaCXX/reinterpret-cast.cpp b/test/SemaCXX/reinterpret-cast.cpp
index 4284032d9ba9bb3ef46c8d7ef93c2c45a866abb6..e57433ef344730d6e3c7548170814396050c09c0 100644 (file)
--- a/test/SemaCXX/reinterpret-cast.cpp
+++ b/test/SemaCXX/reinterpret-cast.cpp
@@ -96,12 +96,12 @@ void memptrs()
   void (structure::*psf)() = 0;
   (void)reinterpret_cast<int (structure::*)()>(psf);
 
-  (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-re {{reinterpret_cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'int structure::*' is not allowed}}
+  (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<int structure::*>(psf); // expected-error {{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
   // literal.
-  (void)reinterpret_cast<void (structure::*)()>(0); // expected-error-re {{reinterpret_cast from 'int' to 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' is not allowed}}
+  (void)reinterpret_cast<void (structure::*)()>(0); // expected-error {{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}}
 }
 

diff --git a/test/SemaCXX/static-cast.cpp b/test/SemaCXX/static-cast.cpp
index 03ee160ca3e0c237da666ef38650b78755cfa48a..89660f1718b085333389cc1eaaac7ca76535ccbf 100644 (file)
--- a/test/SemaCXX/static-cast.cpp
+++ b/test/SemaCXX/static-cast.cpp
@@ -192,6 +192,6 @@ namespace PR6072 {
     (void)static_cast<void (A::*)()>(&B::f);
     (void)static_cast<void (B::*)()>(&B::f);
     (void)static_cast<void (C::*)()>(&B::f);
-    (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\)\))?}}'}}
+    (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\)\))?}}'}}
   }
 }

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

diff --git a/test/SemaCXX/typo-correction.cpp b/test/SemaCXX/typo-correction.cpp
index 8dbedd2dc47f912c18f4afbaa378009150ead7e9..850f393ffb369ad60e0a143908d082df126c55d2 100644 (file)
--- a/test/SemaCXX/typo-correction.cpp
+++ b/test/SemaCXX/typo-correction.cpp
@@ -299,6 +299,6 @@ namespace CorrectTypo_has_reached_its_limit {
 int flibberdy();  // expected-note{{'flibberdy' declared here}}
 int no_correction() {
   return hibberdy() +  // expected-error{{use of undeclared identifier 'hibberdy'; did you mean 'flibberdy'?}}
-         gibberdy();  // expected-error-re{{use of undeclared identifier 'gibberdy'{{$}}}}
+         gibberdy();  // expected-error{{use of undeclared identifier 'gibberdy'{{$}}}}
 };
 }

diff --git a/test/SemaTemplate/dependent-names.cpp b/test/SemaTemplate/dependent-names.cpp
index 5a25030803ec413e91c8bf6633def953a7c4ce41..86451f5d8444cfb52b4dbea8b5cd24e1b593a738 100644 (file)
--- a/test/SemaTemplate/dependent-names.cpp
+++ b/test/SemaTemplate/dependent-names.cpp
@@ -232,7 +232,7 @@ namespace PR10053 {
       struct Data {};
     }
 
-    std::ostream &print(std::ostream &out, int); // expected-note-re {{should be declared prior to the call site{{$}}}}
+    std::ostream &print(std::ostream &out, int); // expected-note {{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, 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}}
@@ -397,5 +397,5 @@ namespace OperatorNew {
   struct X {};
 };
 using size_t = decltype(sizeof(0));
-void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
+void *operator new(size_t, OperatorNew::X); // expected-note {{should be declared prior to the call site{{$}}}}
 template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}

diff --git a/test/SemaTemplate/explicit-instantiation.cpp b/test/SemaTemplate/explicit-instantiation.cpp
index c28c5d183150bbea34576ffd4708cdd334c4a6e5..ea722b4a39048a4f3588a3eb39a7ec44932dc933 100644 (file)
--- a/test/SemaTemplate/explicit-instantiation.cpp
+++ b/test/SemaTemplate/explicit-instantiation.cpp
@@ -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 *'}}
 
-  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'}} \
+  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'}} \
                                                    // expected-note {{candidate template ignored: could not match 'int' against 'int *'}}
 };
 

diff --git a/test/SemaTemplate/instantiate-method.cpp b/test/SemaTemplate/instantiate-method.cpp
index 58cb8979555894a995d7bf42709ea99abdab6ba4..cd0487c21b7a72013f9c952af378bb4e2421ab1f 100644 (file)
--- a/test/SemaTemplate/instantiate-method.cpp
+++ b/test/SemaTemplate/instantiate-method.cpp
@@ -178,7 +178,7 @@ namespace PR7022 {
 namespace SameSignatureAfterInstantiation {
   template<typename T> struct S {
     void f(T *); // expected-note {{previous}}
-    void f(const T*); // expected-error-re {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}}
+    void f(const T*); // expected-error {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}}
   };
   S<const int> s; // expected-note {{instantiation}}
 }

diff --git a/test/SemaTemplate/ms-lookup-template-base-classes.cpp b/test/SemaTemplate/ms-lookup-template-base-classes.cpp
index e956cd11c54947287467c5f4b9a50dfcfb854020..7e297d36a15ee3ecca2594c34e4001a75790e00f 100644 (file)
--- a/test/SemaTemplate/ms-lookup-template-base-classes.cpp
+++ b/test/SemaTemplate/ms-lookup-template-base-classes.cpp
@@ -222,7 +222,7 @@ template <typename T> struct C : T {
 };
 
 template struct B<A>;
-template struct C<A>;  // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}}
+template struct C<A>;  // expected-note 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}}
 
 template <typename T> struct D : T {
   struct Inner {

diff --git a/test/SemaTemplate/temp_arg_nontype.cpp b/test/SemaTemplate/temp_arg_nontype.cpp
index 91b0c6e765088e339612ef6a20dc3b1ab64fdeb6..820ce2c3441f0eeb34565cd53b47cb6b45cb17c4 100644 (file)
--- a/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/test/SemaTemplate/temp_arg_nontype.cpp
@@ -82,7 +82,7 @@ struct Z {
 template<int (Z::*pmf)(int)> struct A6; // expected-note{{template parameter is declared here}}
 A6<&Z::foo> *a17_1;
 A6<&Z::bar> *a17_2;
-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\)\))?}}'}}
+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\)\))?}}'}}
 
 
 template<int Z::*pm> struct A7;  // expected-note{{template parameter is declared here}}

diff --git a/test/SemaTemplate/typename-specifier.cpp b/test/SemaTemplate/typename-specifier.cpp
index 6bd567f6ae93267edfb4dd09263ad43b8d3ccb1a..bcaf4ecb8848e9b12008c4f1b441966a7e994cfa 100644 (file)
--- a/test/SemaTemplate/typename-specifier.cpp
+++ b/test/SemaTemplate/typename-specifier.cpp
@@ -137,8 +137,8 @@ class ExampleClass1 {
 
   void foo() {
     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-re {{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<this->ExampleItemSet::iterator, int> i; // expected-error {{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::iterator, int> elt; // expected-error {{template argument for template type parameter must be a type; did you forget 'typename'?}}