Improve the representation of template names in the AST. This

representation handles the various ways in which one can name a
template, including unqualified references ("vector"), qualified
references ("std::vector"), and dependent template names
("MetaFun::template apply").

One immediate effect of this change is that the representation of
nested-name-specifiers in type names for class template
specializations (e.g., std::vector<int>) is more accurate. Rather than
representing std::vector<int> as

  std::(vector<int>)

we represent it as

  (std::vector)<int>

which more closely follows the C++ grammar. 

Additionally, templates are no longer represented as declarations
(DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new
OpaquePtr type (TemplateTy) that holds the representation of a
TemplateName. This will simplify the handling of dependent
template-names, once we get there.

llvm-svn: 68074

1 files changed, 13 insertions, 12 deletions

diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp
index b962cbf646d..8eda6948644 100644
--- a/clang/lib/Parse/ParseTemplate.cpp
+++ b/clang/lib/Parse/ParseTemplate.cpp
@@ -406,7 +406,7 @@ Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
 /// last token in the stream (e.g., so that it can be replaced with an
 /// annotation token).
 bool 
-Parser::ParseTemplateIdAfterTemplateName(DeclPtrTy Template,
+Parser::ParseTemplateIdAfterTemplateName(TemplateTy Template,
                                          SourceLocation TemplateNameLoc, 
                                          const CXXScopeSpec *SS,
                                          bool ConsumeLastToken,
@@ -499,7 +499,7 @@ Parser::ParseTemplateIdAfterTemplateName(DeclPtrTy Template,
 /// replaced with a type annotation token. Otherwise, the
 /// simple-template-id is always replaced with a template-id
 /// annotation token.
-void Parser::AnnotateTemplateIdToken(DeclPtrTy Template, TemplateNameKind TNK,
+void Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
                                      const CXXScopeSpec *SS, 
                                      SourceLocation TemplateKWLoc,
                                      bool AllowTypeAnnotation) {
@@ -531,12 +531,13 @@ void Parser::AnnotateTemplateIdToken(DeclPtrTy Template, TemplateNameKind TNK,
     return; 
 
   // Build the annotation token.
+  // FIXME: Not just for class templates!
   if (TNK == TNK_Class_template && AllowTypeAnnotation) {
     Action::TypeResult Type 
-      = Actions.ActOnClassTemplateId(Template, TemplateNameLoc,
-                                     LAngleLoc, TemplateArgsPtr,
-                                     &TemplateArgLocations[0],
-                                     RAngleLoc, SS);
+      = Actions.ActOnTemplateIdType(Template, TemplateNameLoc,
+                                    LAngleLoc, TemplateArgsPtr,
+                                    &TemplateArgLocations[0],
+                                    RAngleLoc);
     if (Type.isInvalid()) // FIXME: better recovery?
       return;
 
@@ -603,12 +604,12 @@ bool Parser::AnnotateTemplateIdTokenAsType(const CXXScopeSpec *SS) {
                                      TemplateId->NumArgs);
 
   Action::TypeResult Type 
-    = Actions.ActOnClassTemplateId(DeclPtrTy::make(TemplateId->Template),
-                                   TemplateId->TemplateNameLoc,
-                                   TemplateId->LAngleLoc, 
-                                   TemplateArgsPtr,
-                                   TemplateId->getTemplateArgLocations(),
-                                   TemplateId->RAngleLoc, SS);
+    = Actions.ActOnTemplateIdType(TemplateTy::make(TemplateId->Template),
+                                  TemplateId->TemplateNameLoc,
+                                  TemplateId->LAngleLoc, 
+                                  TemplateArgsPtr,
+                                  TemplateId->getTemplateArgLocations(),
+                                  TemplateId->RAngleLoc);
   if (Type.isInvalid()) {
     // FIXME: better recovery?
     ConsumeToken();