Index: tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp
==================================================================
--- tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp
+++ tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp
@@ -224,14 +224,26 @@
     return true;
   }
 
   // Return true if string literal is found.
   // When true, P marks begin-position of S in content.
-  bool Search(StringRef S) {
-    P = std::search(C, End, S.begin(), S.end());
-    PEnd = P + S.size();
-    return P != End;
+  bool Search(StringRef S, bool EnsureWordStart = false) {
+    do {
+      P = std::search(C, End, S.begin(), S.end());
+      PEnd = P + S.size();
+      if (P == End)
+        break;
+      if (!EnsureWordStart
+            // Check if string literal starts a new word.
+            || P == Begin || isspace(P[-1])
+            // Or it could be preceeded by the start of a comment.
+            || (P > (Begin + 1) && (P[-1] == '/' || P[-1] == '*')
+                                &&  P[-2] == '/'))
+        return true;
+      // Otherwise, skip and search again.
+    } while (Advance());
+    return false;
   }
 
   // Advance 1-past previous next/search.
   // Behavior is undefined if previous next/search failed.
   bool Advance() {
@@ -269,11 +280,11 @@
                            SourceLocation Pos, DiagnosticsEngine &Diags) {
   // A single comment may contain multiple directives.
   bool FoundDirective = false;
   for (ParseHelper PH(S); !PH.Done();) {
     // Search for token: expected
-    if (!PH.Search("expected"))
+    if (!PH.Search("expected", true))
       break;
     PH.Advance();
 
     // Next token: -
     if (!PH.Next("-"))

Index: tools/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp
==================================================================
--- tools/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp
+++ tools/clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp
@@ -1,13 +1,13 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-void nondecl(int (*f)(int x = 5)) // {expected-error {{default arguments can only be specified}}}
+void nondecl(int (*f)(int x = 5)) // expected-error {{default arguments can only be specified}}
 {
-  void (*f2)(int = 17)  // {expected-error {{default arguments can only be specified}}}
-  = (void (*)(int = 42))f; // {expected-error {{default arguments can only be specified}}}
+  void (*f2)(int = 17)  // expected-error {{default arguments can only be specified}}
+  = (void (*)(int = 42))f; // expected-error {{default arguments can only be specified}}
 }
 
 struct X0 {
   int (*f)(int = 17); // expected-error{{default arguments can only be specified for parameters in a function declaration}}
   
   void mem8(int (*fp)(int) = (int (*)(int = 17))0); // expected-error{{default arguments can only be specified for parameters in a function declaration}}  
 };

Index: tools/clang/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
==================================================================
--- tools/clang/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
+++ tools/clang/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
@@ -89,13 +89,13 @@
   }
 }
 
 namespace PR12564 {
   struct Base {
-    void bar(Base&) {} // unexpected-note {{here}}
+    void bar(Base&) {} // FIXME: expected-note {{here}}
   };
 
   struct Derived : Base {
     // FIXME: This should be accepted.
-    void foo(Derived& d) noexcept(noexcept(d.bar(d))) {} // unexpected-error {{cannot bind to a value of unrelated type}}
+    void foo(Derived& d) noexcept(noexcept(d.bar(d))) {} // FIXME: expected-error {{cannot bind to a value of unrelated type}}
   };
 }

Index: tools/clang/test/Frontend/verify.c
==================================================================
--- tools/clang/test/Frontend/verify.c
+++ tools/clang/test/Frontend/verify.c
@@ -20,11 +20,11 @@
 
 #ifdef TEST1
 #if 0
 // expected-error {{should be ignored}}
 #endif
-
+// eexpected-error {{should also be ignored: unrecognised directive}}
 #error should not be ignored
 // expected-error@-1 1+ {{should not be ignored}}
 
 #line 90
 unexpected a; // expected-error@+0 + {{unknown type}}

Index: tools/clang/test/Sema/compound-literal.c
==================================================================
--- tools/clang/test/Sema/compound-literal.c
+++ tools/clang/test/Sema/compound-literal.c
@@ -4,19 +4,19 @@
 struct foo { int a, b; };
 
 static struct foo t = (struct foo){0,0};
 static struct foo t1 = __builtin_choose_expr(0, (struct foo){0,0}, (struct foo){0,0});
 static struct foo t2 = {0,0};
-static struct foo t3 = t2; // -expected-error {{initializer element is not a compile-time constant}}
+static struct foo t3 = t2; // expected-error {{initializer element is not a compile-time constant}}
 static int *p = (int []){2,4};
 static int x = (int){1};
 
-static int *p2 = (int []){2,x}; // -expected-error {{initializer element is not a compile-time constant}}
-static long *p3 = (long []){2,"x"}; // -expected-warning {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [2]'}}
+static int *p2 = (int []){2,x}; // expected-error {{initializer element is not a compile-time constant}}
+static long *p3 = (long []){2,"x"}; // expected-warning {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [2]'}}
 
-typedef struct { } cache_t; // -expected-warning{{empty struct is a GNU extension}}
-static cache_t clo_I1_cache = ((cache_t) { } ); // -expected-warning{{use of GNU empty initializer extension}}
+typedef struct { } cache_t; // expected-warning{{empty struct is a GNU extension}}
+static cache_t clo_I1_cache = ((cache_t) { } ); // expected-warning{{use of GNU empty initializer extension}}
 
 typedef struct Test {int a;int b;} Test;
 static Test* ll = &(Test) {0,0};
 
 extern void fooFunc(struct foo *pfoo);
@@ -25,14 +25,14 @@
  int *l = (int []){x, *p, *p2};
  fooFunc(&(struct foo){ 1, 2 });
 }
 
 struct Incomplete; // expected-note{{forward declaration of 'struct Incomplete'}}
-struct Incomplete* I1 = &(struct Incomplete){1, 2, 3}; // -expected-error {{variable has incomplete type}}
+struct Incomplete* I1 = &(struct Incomplete){1, 2, 3}; // expected-error {{variable has incomplete type}}
 void IncompleteFunc(unsigned x) {
-  struct Incomplete* I2 = (struct foo[x]){1, 2, 3}; // -expected-error {{variable-sized object may not be initialized}}
-  (void){1,2,3}; // -expected-error {{variable has incomplete type}}
-  (void(void)) { 0 }; // -expected-error{{illegal initializer type 'void (void)'}}
+  struct Incomplete* I2 = (struct foo[x]){1, 2, 3}; // expected-error {{variable-sized object may not be initialized}}
+  (void){1,2,3}; // expected-error {{variable has incomplete type}}
+  (void(void)) { 0 }; // expected-error{{illegal initializer type 'void (void)'}}
 }
 
 // PR6080
 int array[(sizeof(int[3]) == sizeof( (int[]) {0,1,2} )) ? 1 : -1];

Index: tools/clang/test/Sema/vector-cast.c
==================================================================
--- tools/clang/test/Sema/vector-cast.c
+++ tools/clang/test/Sema/vector-cast.c
@@ -8,26 +8,26 @@
 {  
   t1 v1;
   t2 v2;
   t3 v3;
   
-  v2 = (t2)v1; // -expected-error {{invalid conversion between vector type \
+  v2 = (t2)v1; // expected-error {{invalid conversion between vector type \
 't2' and 't1' of different size}}
-  v1 = (t1)v2; // -expected-error {{invalid conversion between vector type \
+  v1 = (t1)v2; // expected-error {{invalid conversion between vector type \
 't1' and 't2' of different size}}
   v3 = (t3)v2;
   
-  v1 = (t1)(char *)10; // -expected-error {{invalid conversion between vector \
+  v1 = (t1)(char *)10; // expected-error {{invalid conversion between vector \
 type 't1' and scalar type 'char *'}}
   v1 = (t1)(long long)10;
-  v1 = (t1)(short)10; // -expected-error {{invalid conversion between vector \
+  v1 = (t1)(short)10; // expected-error {{invalid conversion between vector \
 type 't1' and integer type 'short' of different size}}
   
   long long r1 = (long long)v1;
-  short r2 = (short)v1; // -expected-error {{invalid conversion between vector \
+  short r2 = (short)v1; // expected-error {{invalid conversion between vector \
 type 't1' and integer type 'short' of different size}}
-  char *r3 = (char *)v1; // -expected-error {{invalid conversion between vector\
+  char *r3 = (char *)v1; // expected-error {{invalid conversion between vector\
  type 't1' and scalar type 'char *'}}
 }
 
 
 void f2(t2 X); // expected-note{{passing argument to parameter 'X' here}}

Index: tools/clang/test/SemaCXX/new-delete-0x.cpp
==================================================================
--- tools/clang/test/SemaCXX/new-delete-0x.cpp
+++ tools/clang/test/SemaCXX/new-delete-0x.cpp
@@ -26,7 +26,7 @@
 
 void good_deletes()
 {
   delete [&]{ return (int*)0; }();
   // FIXME: This appears to be legal.
-  delete []{ return (int*)0; }(); // unexpected-error {{expected expression}}
+  delete []{ return (int*)0; }(); // FIXME: expected-error {{expected expression}}
 }