Improve the AST representation and semantic analysis for extern

templates. We now distinguish between an explicit instantiation
declaration and an explicit instantiation definition, and know not to
instantiate explicit instantiation declarations. Unfortunately, there
is some remaining confusion w.r.t. instantiation of out-of-line member
function definitions that causes trouble here.
 


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

1 files changed, 23 insertions, 12 deletions

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index 41ba1f1df9..ca1ae63ff8 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -640,7 +640,7 @@ FunctionDecl::setFunctionTemplateSpecialization(ASTContext &Context,
   
   Info->Function = this;
   Info->Template.setPointer(Template);
-  Info->Template.setInt(0); // Implicit instantiation, unless told otherwise
+  Info->Template.setInt(TSK_ImplicitInstantiation - 1);
   Info->TemplateArguments = TemplateArgs;
   TemplateOrSpecialization = Info;
   
@@ -649,24 +649,35 @@ FunctionDecl::setFunctionTemplateSpecialization(ASTContext &Context,
   Template->getSpecializations().InsertNode(Info, InsertPos);
 }
 
-bool FunctionDecl::isExplicitSpecialization() const {
-  // FIXME: check this property for explicit specializations of member
-  // functions of class templates.
+TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const {
+  // For a function template specialization, query the specialization 
+  // information object.
   FunctionTemplateSpecializationInfo *Info 
     = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
-  if (!Info)
-    return false;
+  if (Info)
+    return Info->getTemplateSpecializationKind();
+  
+  if (!getInstantiatedFromMemberFunction())
+    return TSK_Undeclared;
   
-  return Info->isExplicitSpecialization();
+  // Find the class template specialization corresponding to this instantiation
+  // of a member function.
+  const DeclContext *Parent = getDeclContext();
+  while (Parent && !isa<ClassTemplateSpecializationDecl>(Parent))
+    Parent = Parent->getParent();
+  
+  if (!Parent)
+    return TSK_Undeclared;
+
+  return cast<ClassTemplateSpecializationDecl>(Parent)->getSpecializationKind();
 }
 
-void FunctionDecl::setExplicitSpecialization(bool ES) {
-  // FIXME: set this property for explicit specializations of member functions
-  // of class templates.
+void 
+FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
   FunctionTemplateSpecializationInfo *Info 
     = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
-  if (Info)
-    Info->setExplicitSpecialization(ES);
+  assert(Info && "Not a function template specialization");
+  Info->setTemplateSpecializationKind(TSK);
 }
 
 //===----------------------------------------------------------------------===//