Don't parse non-template name as template name

[ismailp]

Summary

PR18127: misparse of 'new struct S < ...' where S is not a template-name

If clang sees '<' token after an elaborated-type-specifier, it assumes elaborated-type-specifier refers to a template name, and then issues diagnostics concerning missing '>'.

We try to find corresponding '>' for diagnostics location purpose, and perform name lookup. Parser knows that it is not parsing a template. If name lookup doesn't find a name, we will keep issuing explicit instantiation/specialization of non-template class error.

[ismailp]

See PR18127.

lib/Parse/ParseDeclCXX.cpp

 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/SmallString.h"
+#include "clang/Sema/Lookup.h"
+
 using namespace clang;
 
 /// ParseNamespace - We know that the current token is a namespace keyword. This
 /// may either be a top level namespace or a block-level namespace alias. If
 /// there was an inline keyword, it has already been parsed.
 ///
 ///       namespace-definition: [C++ 7.3: basic.namespace]
 ///         named-namespace-definition
if (Tok.is(tok::identifier)) {
     NameLoc = ConsumeToken();
 
     if (Tok.is(tok::less) && getLangOpts().CPlusPlus) {
       // The name was supposed to refer to a template, but didn't.
       // Eat the template argument list and try to continue parsing this as
       // a class (or template thereof).
       TemplateArgList TemplateArgs;
       SourceLocation LAngleLoc, RAngleLoc;
-      if (ParseTemplateIdAfterTemplateName(TemplateTy(), NameLoc, SS,
-                                           true, LAngleLoc,
-                                           TemplateArgs, RAngleLoc)) {
-        // We couldn't parse the template argument list at all, so don't
-        // try to give any location information for the list.
-        LAngleLoc = RAngleLoc = SourceLocation();
-      }
-
+      LAngleLoc = ConsumeToken();
+      if (SkipUntil(tok::greater, StopBeforeMatch | StopAtSemi))
+        RAngleLoc = ConsumeToken();
+      // If a name was not found, this might be an explicit instantiation or
+      // specialization attempt. If a name was found, that name does not refer
+      // to a template name.
+      LookupResult Result(Actions, Name, NameLoc, Sema::LookupTagName);
+      Actions.LookupName(Result, getCurScope());
+      if (Result.getResultKind() != LookupResult::Found)
         Diag(NameLoc, diag::err_explicit_spec_non_template)
             << (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
             << TagTokKind << Name << SourceRange(LAngleLoc, RAngleLoc);
 
       // Strip off the last template parameter list if it was empty, since
       // we've removed its template argument list.
       if (TemplateParams && TemplateInfo.LastParameterListWasEmpty) {
         if (TemplateParams && TemplateParams->size() > 1) {
           TemplateParams->pop_back();
         } else {
           TemplateParams = 0;
-          const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
-            = ParsedTemplateInfo::NonTemplate;
+          const_cast<ParsedTemplateInfo &>(TemplateInfo).Kind =
+              ParsedTemplateInfo::NonTemplate;
         }
-      } else if (TemplateInfo.Kind
-                                == ParsedTemplateInfo::ExplicitInstantiation) {
+      } else if (TemplateInfo.Kind ==
+                 ParsedTemplateInfo::ExplicitInstantiation) {
         // Pretend this is just a forward declaration.
         TemplateParams = 0;
-        const_cast<ParsedTemplateInfo&>(TemplateInfo).Kind
-          = ParsedTemplateInfo::NonTemplate;
-        const_cast<ParsedTemplateInfo&>(TemplateInfo).TemplateLoc
-          = SourceLocation();
-        const_cast<ParsedTemplateInfo&>(TemplateInfo).ExternLoc
-          = SourceLocation();
+        const_cast<ParsedTemplateInfo &>(TemplateInfo).Kind =
+            ParsedTemplateInfo::NonTemplate;
+        const_cast<ParsedTemplateInfo &>(TemplateInfo).TemplateLoc =
+            SourceLocation();
+        const_cast<ParsedTemplateInfo &>(TemplateInfo).ExternLoc =
+            SourceLocation();
       }
     }
   } else if (Tok.is(tok::annot_template_id)) {
     TemplateId = takeTemplateIdAnnotation(Tok);
     NameLoc = ConsumeToken();
 
     if (TemplateId->Kind != TNK_Type_template &&
         TemplateId->Kind != TNK_Dependent_template_name) {

test/Parser/cxx-template-argument.cpp

UnknownBase<Known<int,int>,X<int,X<int,int>>> // expected-error {{unknown template name 'UnknownBase'}} \
                                                   // expected-error {{use '> >'}}
   { };
 
   template<int N1, int N2> struct foo11 :
     UnknownBase<2<N1,N2<4> // expected-error {{unknown template name 'UnknownBase'}}
   { };
 
 }
+
+namespace PR18127 {
+    struct A {} *a;
+    bool f = new struct A < 0;
+    bool g = new struct A < a;
+
+    template<typename T>
+    struct B { };
+
+    bool h = new struct B < 0;  // expected-error{{expected '>'}}
+    bool i = new struct B<int> < 0;
+    bool operator<(const struct O &, const struct O &);
+    struct O { } *p;
+    bool j = *(new struct O) < *p;
+    bool k = new struct IDontExist < 0;  // expected-error{{explicit specialization of non-template struct 'IDontExist'}}
+    // expected-error@-1{{allocation of incomplete type 'struct IDontExist'}}
+    // expected-note@-2{{forward declaration of 'PR18127::IDontExist'}}
+}