When instantiating the definition of a member function of a class
template, introduce that member function into the template
instantiation stack. Also, add diagnostics showing the member function
within the instantiation stack and clean up the qualified-name
printing so that we get something like:
note: in instantiation of member function 'Switch1<int, 2, 2>::f'
requested here
in the template instantiation backtrace.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@72015 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index c62c1e2..20fe39d 100644
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -212,7 +212,15 @@
// scope class/struct/union. How do we handle this case?
break;
- if (const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx))
+ if (const ClassTemplateSpecializationDecl *Spec
+ = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
+ const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+ std::string TemplateArgsStr
+ = TemplateSpecializationType::PrintTemplateArgumentList(
+ TemplateArgs.getFlatArgumentList(),
+ TemplateArgs.flat_size());
+ Names.push_back(Spec->getIdentifier()->getName() + TemplateArgsStr);
+ } else if (const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx))
Names.push_back(ND->getNameAsString());
else
break;
diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index a5f50a8..de3944a 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -2070,9 +2070,10 @@
/// Destruction of this object will pop the named instantiation off
/// the stack.
struct InstantiatingTemplate {
- /// \brief Note that we are instantiating a class template.
+ /// \brief Note that we are instantiating a class template,
+ /// function template, or a member thereof.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
- CXXRecordDecl *Entity,
+ Decl *Entity,
SourceRange InstantiationRange = SourceRange());
/// \brief Note that we are instantiating a default argument in a
@@ -2083,7 +2084,10 @@
unsigned NumTemplateArgs,
SourceRange InstantiationRange = SourceRange());
- ~InstantiatingTemplate();
+ /// \brief Note that we have finished instantiating this template.
+ void Clear();
+
+ ~InstantiatingTemplate() { Clear(); }
/// \brief Determines whether we have exceeded the maximum
/// recursive template instantiations.
@@ -2216,7 +2220,8 @@
InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
const TemplateArgumentList &TemplateArgs);
- void InstantiateFunctionDefinition(FunctionDecl *Function);
+ void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
+ FunctionDecl *Function);
void InstantiateVariableDefinition(VarDecl *Var);
// Simple function for cloning expressions.
diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 79d7e2c..47388ac 100644
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -2340,11 +2340,8 @@
// instantiation.
if (SpecializationRequiresInstantiation)
InstantiateClassTemplateSpecialization(Specialization, true);
- else {
- // Instantiate the members of this class template specialization.
- InstantiatingTemplate Inst(*this, TemplateLoc, Specialization);
+ else // Instantiate the members of this class template specialization.
InstantiateClassTemplateSpecializationMembers(TemplateLoc, Specialization);
- }
return DeclPtrTy::make(Specialization);
}
@@ -2405,12 +2402,9 @@
getTemplateInstantiationArgs(Record),
/*ExplicitInstantiation=*/true))
return true;
- } else {
- // Instantiate all of the members of class.
- InstantiatingTemplate Inst(*this, TemplateLoc, Record);
+ } else // Instantiate all of the members of class.
InstantiateClassMembers(TemplateLoc, Record,
getTemplateInstantiationArgs(Record));
- }
// FIXME: We don't have any representation for explicit instantiations of
// member classes. Such a representation is not needed for compilation, but it
diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp
index a5411bd..08019aa 100644
--- a/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/lib/Sema/SemaTemplateInstantiate.cpp
@@ -46,7 +46,7 @@
Sema::InstantiatingTemplate::
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
- CXXRecordDecl *Entity,
+ Decl *Entity,
SourceRange InstantiationRange)
: SemaRef(SemaRef) {
@@ -89,9 +89,11 @@
}
}
-Sema::InstantiatingTemplate::~InstantiatingTemplate() {
- if (!Invalid)
+void Sema::InstantiatingTemplate::Clear() {
+ if (!Invalid) {
SemaRef.ActiveTemplateInstantiations.pop_back();
+ Invalid = true;
+ }
}
bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
@@ -120,14 +122,24 @@
++Active) {
switch (Active->Kind) {
case ActiveTemplateInstantiation::TemplateInstantiation: {
- unsigned DiagID = diag::note_template_member_class_here;
- CXXRecordDecl *Record = (CXXRecordDecl *)Active->Entity;
- if (isa<ClassTemplateSpecializationDecl>(Record))
- DiagID = diag::note_template_class_instantiation_here;
- Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr),
- DiagID)
- << Context.getTypeDeclType(Record)
- << Active->InstantiationRange;
+ Decl *D = reinterpret_cast<Decl *>(Active->Entity);
+ if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
+ unsigned DiagID = diag::note_template_member_class_here;
+ if (isa<ClassTemplateSpecializationDecl>(Record))
+ DiagID = diag::note_template_class_instantiation_here;
+ Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr),
+ DiagID)
+ << Context.getTypeDeclType(Record)
+ << Active->InstantiationRange;
+ } else {
+ FunctionDecl *Function = cast<FunctionDecl>(D);
+ unsigned DiagID = diag::note_template_member_function_here;
+ // FIXME: check for a function template
+ Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr),
+ DiagID)
+ << Function
+ << Active->InstantiationRange;
+ }
break;
}
@@ -768,8 +780,10 @@
CurContext = PreviousContext;
// If this is an explicit instantiation, instantiate our members, too.
- if (!Invalid && ExplicitInstantiation)
+ if (!Invalid && ExplicitInstantiation) {
+ Inst.Clear();
InstantiateClassMembers(PointOfInstantiation, Instantiation, TemplateArgs);
+ }
return Invalid;
}
@@ -820,7 +834,7 @@
D != DEnd; ++D) {
if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) {
if (!Function->getBody(Context))
- InstantiateFunctionDefinition(Function);
+ InstantiateFunctionDefinition(PointOfInstantiation, Function);
} else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) {
const VarDecl *Def = 0;
if (!Var->getDefinition(Def))
@@ -829,7 +843,7 @@
if (!Record->isInjectedClassName() && !Record->getDefinition(Context)) {
assert(Record->getInstantiatedFromMemberClass() &&
"Missing instantiated-from-template information");
- InstantiateClass(Record->getLocation(), Record,
+ InstantiateClass(PointOfInstantiation, Record,
Record->getInstantiatedFromMemberClass(),
TemplateArgs, true);
}
diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 0c13027..c08841a 100644
--- a/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -574,7 +574,8 @@
///
/// \param Function the already-instantiated declaration of a
/// function.
-void Sema::InstantiateFunctionDefinition(FunctionDecl *Function) {
+void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
+ FunctionDecl *Function) {
// FIXME: make this work for function template specializations, too.
if (Function->isInvalidDecl())
@@ -590,7 +591,9 @@
if (!Pattern)
return;
- // FIXME: add to the instantiation stack.
+ InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
+ if (Inst)
+ return;
ActOnStartOfFunctionDef(0, DeclPtrTy::make(Function));