Implement basic parsing and semantic analysis for explicit

specialization of class templates, e.g.,

  template<typename T> class X;

  template<> class X<int> { /* blah */ };

Each specialization is a different *Decl node (naturally), and can
have different members. We keep track of forward declarations and
definitions as for other class/struct/union types.

This is only the basic framework: we still have to deal with checking
the template headers properly, improving recovery when there are
failures, handling nested name specifiers, etc.



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

1 files changed, 9 insertions, 5 deletions

diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp
index 81ef3ab70e..e10e270c7d 100644
--- a/lib/AST/DeclTemplate.cpp
+++ b/lib/AST/DeclTemplate.cpp
@@ -159,7 +159,7 @@ ClassTemplateSpecializationDecl(DeclContext *DC, SourceLocation L,
                   // class template specializations?
                   SpecializedTemplate->getIdentifier()),
     SpecializedTemplate(SpecializedTemplate),
-    NumTemplateArgs(NumTemplateArgs) {
+    NumTemplateArgs(NumTemplateArgs), SpecializationKind(TSK_Undeclared) {
   TemplateArgument *Arg = reinterpret_cast<TemplateArgument *>(this + 1);
   for (unsigned ArgIdx = 0; ArgIdx < NumTemplateArgs; ++ArgIdx, ++Arg)
     *Arg = TemplateArgs[ArgIdx];
@@ -170,12 +170,16 @@ ClassTemplateSpecializationDecl::Create(ASTContext &Context,
                                         DeclContext *DC, SourceLocation L,
                                         ClassTemplateDecl *SpecializedTemplate,
                                         TemplateArgument *TemplateArgs, 
-                                        unsigned NumTemplateArgs) {
+                                        unsigned NumTemplateArgs,
+                                   ClassTemplateSpecializationDecl *PrevDecl) {
   unsigned Size = sizeof(ClassTemplateSpecializationDecl) + 
                   sizeof(TemplateArgument) * NumTemplateArgs;
   unsigned Align = llvm::AlignOf<ClassTemplateSpecializationDecl>::Alignment;
   void *Mem = Context.Allocate(Size, Align);
-  return new (Mem) ClassTemplateSpecializationDecl(DC, L, SpecializedTemplate,
-                                                   TemplateArgs, 
-                                                   NumTemplateArgs);
+  ClassTemplateSpecializationDecl *Result
+    = new (Mem) ClassTemplateSpecializationDecl(DC, L, SpecializedTemplate,
+                                                TemplateArgs, NumTemplateArgs);
+  // FIXME: Do we want a prettier type here?
+  Context.getTypeDeclType(Result, PrevDecl);
+  return Result;
 }