Improved fix for PR3844, which recovers better for class template

partial specializations and explicit instantiations of non-templates.

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

diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td
index 48f58fb9a611311f04f3fd66ce0acf2a68cda8a0..1773f4c56c69f3055f0fc79159c5e99daa728c3f 100644 (file)
--- a/include/clang/Basic/DiagnosticParseKinds.td
+++ b/include/clang/Basic/DiagnosticParseKinds.td
@@ -283,7 +283,8 @@ def err_typename_refers_to_non_type_template : Error<
 def err_expected_type_name_after_typename : Error<
   "expected an identifier or template-id after '::'">;
 def err_explicit_spec_non_template : Error<
-  "explicit specialization of non-template %select{class|struct|union}0 %1">;
+  "explicit %select{specialization|instantiation}0 of non-template "
+  "%select{class|struct|union}1 %2">;
 
 def err_variadic_templates : Error<
   "variadic templates are only allowed in C++0x">;

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index 9cb4677f66370daee579b5c81d09becd7fec533f..4c7aa27d514d288c9857277282ff72f17c5bb8cd 100644 (file)
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -603,14 +603,17 @@ private:
       : Kind(NonTemplate), TemplateParams(0), TemplateLoc() { }
 
     ParsedTemplateInfo(TemplateParameterLists *TemplateParams,
-                       bool isSpecialization)
+                       bool isSpecialization,
+                       bool lastParameterListWasEmpty = false)
       : Kind(isSpecialization? ExplicitSpecialization : Template),
-        TemplateParams(TemplateParams) { }
+        TemplateParams(TemplateParams), 
+        LastParameterListWasEmpty(lastParameterListWasEmpty) { }
 
     explicit ParsedTemplateInfo(SourceLocation ExternLoc,
                                 SourceLocation TemplateLoc)
       : Kind(ExplicitInstantiation), TemplateParams(0),
-        ExternLoc(ExternLoc), TemplateLoc(TemplateLoc) { }
+        ExternLoc(ExternLoc), TemplateLoc(TemplateLoc),
+        LastParameterListWasEmpty(false){ }
 
     /// \brief The kind of template we are parsing.
     enum {
@@ -635,6 +638,9 @@ private:
     /// \brief The location of the 'template' keyword, for an explicit
     /// instantiation.
     SourceLocation TemplateLoc;
+    
+    /// \brief Whether the last template parameter list was empty.
+    bool LastParameterListWasEmpty;
   };
 
   void PushParsingClass(DeclPtrTy TagOrTemplate, bool TopLevelClass);

diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index 72c9f33cd8db9987d0aaf4a12549dfcbea247b12..65265afa9194d855ecb5c28ba573304fb5f5c206 100644 (file)
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -617,21 +617,35 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
       }
       
       Diag(NameLoc, diag::err_explicit_spec_non_template)
+        << (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
         << (TagType == DeclSpec::TST_class? 0
             : TagType == DeclSpec::TST_struct? 1
             : 2)
         << Name
         << SourceRange(LAngleLoc, RAngleLoc);
       
-      // If this is an explicit specialization, strip off the last template
-      // parameter list, since we've removed its template arguments.
-      if (TemplateParams && TemplateParams->size() > 1) {
-        TemplateParams->pop_back();
-      } else {
+      // 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;
+        }
+      } 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();
       }
+        
       
     }
   } else if (Tok.is(tok::annot_template_id)) {

diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp
index 8e63fb89db3177fc909ae3ed091df832af69f156..64c5a08933a2d686982f6d557fabdd010a5b756c 100644 (file)
--- a/lib/Parse/ParseTemplate.cpp
+++ b/lib/Parse/ParseTemplate.cpp
@@ -101,6 +101,7 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context,
   // (and retrieves the outer template parameter list from its
   // context).
   bool isSpecialization = true;
+  bool LastParamListWasEmpty = false;
   TemplateParameterLists ParamLists;
   TemplateParameterDepthCounter Depth(TemplateParameterDepth);
   do {
@@ -140,13 +141,16 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context,
     if (!TemplateParams.empty()) {
       isSpecialization = false;
       ++Depth;
+    } else {
+      LastParamListWasEmpty = true;
     }
   } while (Tok.is(tok::kw_export) || Tok.is(tok::kw_template));
 
   // Parse the actual template declaration.
   return ParseSingleDeclarationAfterTemplate(Context,
                                              ParsedTemplateInfo(&ParamLists,
-                                                             isSpecialization),
+                                                             isSpecialization,
+                                                         LastParamListWasEmpty),
                                              DeclEnd, AS);
 }
 

diff --git a/test/CXX/temp/temp.spec/temp.explicit/p5.cpp b/test/CXX/temp/temp.spec/temp.explicit/p5.cpp
index b85b62f262c8ffa3b58410afa9ae0b81799887b5..a992648d7c489bb423aa778272823a191520ca78 100644 (file)
--- a/test/CXX/temp/temp.spec/temp.explicit/p5.cpp
+++ b/test/CXX/temp/temp.spec/temp.explicit/p5.cpp
@@ -6,7 +6,7 @@ namespace N {
   };
 }
 
-template class Z<int>; // expected-error{{non-template class 'Z'}}
+template class Z<int>; // expected-error{{explicit instantiation of non-template class 'Z'}}
 
 // FIXME: This example from the standard is wrong; note posted to CWG reflector
 // on 10/27/2009