When parsing an identifier as an expression in C++, only try to annotate it

as a type or scope token if the next token requires it.

This eliminates a lot of redundant lookups in C++, but there's room for
improvement;  a better solution would do a single lookup whose kind and
results would be passed through the parser.

llvm-svn: 92930

2 files changed, 14 insertions, 5 deletions

diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
index bdbc67f782d..4d6988d5f2c 100644
--- a/clang/lib/Parse/ParseExpr.cpp
+++ b/clang/lib/Parse/ParseExpr.cpp
@@ -616,9 +616,17 @@ Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression,
     // Turn a potentially qualified name into a annot_typename or
     // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
     if (getLang().CPlusPlus) {
-      // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
-      if (TryAnnotateTypeOrScopeToken())
-        return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
+      // Avoid the unnecessary parse-time lookup in the common case
+      // where the syntax forbids a type.
+      const Token &Next = NextToken();
+      if (Next.is(tok::coloncolon) ||
+          (!ColonIsSacred && Next.is(tok::colon)) ||
+          Next.is(tok::less) ||
+          Next.is(tok::l_paren)) {
+        // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
+        if (TryAnnotateTypeOrScopeToken())
+          return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
+      }
     }
 
     // Consume the identifier so that we can see if it is followed by a '(' or
diff --git a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
index f2dc64b8074..23da98ce7ee 100644
--- a/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
+++ b/clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.cpp
@@ -166,7 +166,8 @@ namespace test3 {
 
   template <class T> struct C : A<T> {
     using typename A<T>::type;
-    using typename A<T>::hiding; // expected-error {{'typename' keyword used on a non-type}}
+    using typename A<T>::hiding; // expected-note {{declared at}} \
+                                 // expected-error {{'typename' keyword used on a non-type}}
     using typename A<T>::union_member; // expected-error {{'typename' keyword used on a non-type}}
     using typename A<T>::enumerator; // expected-error {{'typename' keyword used on a non-type}}
 
@@ -175,7 +176,7 @@ namespace test3 {
     }
 
     void test7() {
-      Opaque0 _ = hiding; // expected-error {{expected '(' for function-style cast or type construction}}
+      Opaque0 _ = hiding; // expected-error {{does not refer to a value}}
     }
   };