blob: 60de75b917288324c6c5f87d273592a8b0114655 [file] [log] [blame]
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001//===------- SemaTemplateInstantiate.cpp - C++ Template Instantiation ------===/
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9// This file implements C++ template instantiation.
10//
11//===----------------------------------------------------------------------===/
12
John McCall83024632010-08-25 22:03:47 +000013#include "clang/Sema/SemaInternal.h"
Douglas Gregord6ff3322009-08-04 16:50:30 +000014#include "TreeTransform.h"
John McCall8b0666c2010-08-20 18:27:03 +000015#include "clang/Sema/DeclSpec.h"
Richard Smith938f40b2011-06-11 17:19:42 +000016#include "clang/Sema/Initialization.h"
Douglas Gregorc3a6ade2010-08-12 20:07:10 +000017#include "clang/Sema/Lookup.h"
John McCallde6836a2010-08-24 07:21:54 +000018#include "clang/Sema/Template.h"
John McCall19c1bfd2010-08-25 05:32:35 +000019#include "clang/Sema/TemplateDeduction.h"
Douglas Gregor28ad4b52009-05-26 20:50:29 +000020#include "clang/AST/ASTConsumer.h"
Douglas Gregorfe1e1102009-02-27 19:31:52 +000021#include "clang/AST/ASTContext.h"
22#include "clang/AST/Expr.h"
Douglas Gregorfe1e1102009-02-27 19:31:52 +000023#include "clang/AST/DeclTemplate.h"
Douglas Gregorfe1e1102009-02-27 19:31:52 +000024#include "clang/Basic/LangOptions.h"
25
26using namespace clang;
John McCall19c1bfd2010-08-25 05:32:35 +000027using namespace sema;
Douglas Gregorfe1e1102009-02-27 19:31:52 +000028
Douglas Gregor4ea568f2009-03-10 18:03:33 +000029//===----------------------------------------------------------------------===/
30// Template Instantiation Support
31//===----------------------------------------------------------------------===/
32
Douglas Gregor01afeef2009-08-28 20:31:08 +000033/// \brief Retrieve the template argument list(s) that should be used to
34/// instantiate the definition of the given declaration.
Douglas Gregor36d7c5f2009-11-09 19:17:50 +000035///
36/// \param D the declaration for which we are computing template instantiation
37/// arguments.
38///
39/// \param Innermost if non-NULL, the innermost template argument list.
Douglas Gregor8c702532010-02-05 07:33:43 +000040///
41/// \param RelativeToPrimary true if we should get the template
42/// arguments relative to the primary template, even when we're
43/// dealing with a specialization. This is only relevant for function
44/// template specializations.
Douglas Gregor1bd7a942010-05-03 23:29:10 +000045///
46/// \param Pattern If non-NULL, indicates the pattern from which we will be
47/// instantiating the definition of the given declaration, \p D. This is
48/// used to determine the proper set of template instantiation arguments for
49/// friend function template specializations.
Douglas Gregora654dd82009-08-28 17:37:35 +000050MultiLevelTemplateArgumentList
Douglas Gregor36d7c5f2009-11-09 19:17:50 +000051Sema::getTemplateInstantiationArgs(NamedDecl *D,
Douglas Gregor8c702532010-02-05 07:33:43 +000052 const TemplateArgumentList *Innermost,
Douglas Gregor1bd7a942010-05-03 23:29:10 +000053 bool RelativeToPrimary,
54 const FunctionDecl *Pattern) {
Douglas Gregora654dd82009-08-28 17:37:35 +000055 // Accumulate the set of template argument lists in this structure.
56 MultiLevelTemplateArgumentList Result;
Mike Stump11289f42009-09-09 15:08:12 +000057
Douglas Gregor36d7c5f2009-11-09 19:17:50 +000058 if (Innermost)
59 Result.addOuterTemplateArguments(Innermost);
60
Douglas Gregora654dd82009-08-28 17:37:35 +000061 DeclContext *Ctx = dyn_cast<DeclContext>(D);
Douglas Gregora51c9cc2011-05-22 00:21:10 +000062 if (!Ctx) {
Douglas Gregora654dd82009-08-28 17:37:35 +000063 Ctx = D->getDeclContext();
Douglas Gregora51c9cc2011-05-22 00:21:10 +000064
Douglas Gregor55462622011-06-15 14:20:42 +000065 // If we have a template template parameter with translation unit context,
66 // then we're performing substitution into a default template argument of
67 // this template template parameter before we've constructed the template
68 // that will own this template template parameter. In this case, we
69 // use empty template parameter lists for all of the outer templates
70 // to avoid performing any substitutions.
71 if (Ctx->isTranslationUnit()) {
72 if (TemplateTemplateParmDecl *TTP
73 = dyn_cast<TemplateTemplateParmDecl>(D)) {
74 for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
75 Result.addOuterTemplateArguments(0, 0);
76 return Result;
77 }
78 }
Douglas Gregora51c9cc2011-05-22 00:21:10 +000079 }
80
John McCall970d5302009-08-29 03:16:09 +000081 while (!Ctx->isFileContext()) {
Douglas Gregora654dd82009-08-28 17:37:35 +000082 // Add template arguments from a class template instantiation.
Mike Stump11289f42009-09-09 15:08:12 +000083 if (ClassTemplateSpecializationDecl *Spec
Douglas Gregora654dd82009-08-28 17:37:35 +000084 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
85 // We're done when we hit an explicit specialization.
Douglas Gregor9961ce92010-07-08 18:37:38 +000086 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
87 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
Douglas Gregora654dd82009-08-28 17:37:35 +000088 break;
Mike Stump11289f42009-09-09 15:08:12 +000089
Douglas Gregora654dd82009-08-28 17:37:35 +000090 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
Douglas Gregorcf915552009-10-13 16:30:37 +000091
92 // If this class template specialization was instantiated from a
93 // specialized member that is a class template, we're done.
94 assert(Spec->getSpecializedTemplate() && "No class template?");
95 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
96 break;
Mike Stump11289f42009-09-09 15:08:12 +000097 }
Douglas Gregora654dd82009-08-28 17:37:35 +000098 // Add template arguments from a function template specialization.
John McCall970d5302009-08-29 03:16:09 +000099 else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
Douglas Gregor8c702532010-02-05 07:33:43 +0000100 if (!RelativeToPrimary &&
Francois Pichet00c7e6c2011-08-14 03:52:19 +0000101 (Function->getTemplateSpecializationKind() ==
102 TSK_ExplicitSpecialization &&
103 !Function->getClassScopeSpecializationPattern()))
Douglas Gregorcf915552009-10-13 16:30:37 +0000104 break;
105
Douglas Gregora654dd82009-08-28 17:37:35 +0000106 if (const TemplateArgumentList *TemplateArgs
Douglas Gregorcf915552009-10-13 16:30:37 +0000107 = Function->getTemplateSpecializationArgs()) {
108 // Add the template arguments for this specialization.
Douglas Gregora654dd82009-08-28 17:37:35 +0000109 Result.addOuterTemplateArguments(TemplateArgs);
John McCall970d5302009-08-29 03:16:09 +0000110
Douglas Gregorcf915552009-10-13 16:30:37 +0000111 // If this function was instantiated from a specialized member that is
112 // a function template, we're done.
113 assert(Function->getPrimaryTemplate() && "No function template?");
114 if (Function->getPrimaryTemplate()->isMemberSpecialization())
115 break;
Douglas Gregor43669f82011-03-05 17:54:25 +0000116 } else if (FunctionTemplateDecl *FunTmpl
117 = Function->getDescribedFunctionTemplate()) {
118 // Add the "injected" template arguments.
119 std::pair<const TemplateArgument *, unsigned>
120 Injected = FunTmpl->getInjectedTemplateArgs();
121 Result.addOuterTemplateArguments(Injected.first, Injected.second);
Douglas Gregorcf915552009-10-13 16:30:37 +0000122 }
123
John McCall970d5302009-08-29 03:16:09 +0000124 // If this is a friend declaration and it declares an entity at
125 // namespace scope, take arguments from its lexical parent
Douglas Gregor1bd7a942010-05-03 23:29:10 +0000126 // instead of its semantic parent, unless of course the pattern we're
127 // instantiating actually comes from the file's context!
John McCall970d5302009-08-29 03:16:09 +0000128 if (Function->getFriendObjectKind() &&
Douglas Gregor1bd7a942010-05-03 23:29:10 +0000129 Function->getDeclContext()->isFileContext() &&
130 (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
John McCall970d5302009-08-29 03:16:09 +0000131 Ctx = Function->getLexicalDeclContext();
Douglas Gregor8c702532010-02-05 07:33:43 +0000132 RelativeToPrimary = false;
John McCall970d5302009-08-29 03:16:09 +0000133 continue;
134 }
Douglas Gregor9961ce92010-07-08 18:37:38 +0000135 } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
136 if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
137 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
138 const TemplateSpecializationType *TST
139 = cast<TemplateSpecializationType>(Context.getCanonicalType(T));
140 Result.addOuterTemplateArguments(TST->getArgs(), TST->getNumArgs());
141 if (ClassTemplate->isMemberSpecialization())
142 break;
143 }
Douglas Gregora654dd82009-08-28 17:37:35 +0000144 }
John McCall970d5302009-08-29 03:16:09 +0000145
146 Ctx = Ctx->getParent();
Douglas Gregor8c702532010-02-05 07:33:43 +0000147 RelativeToPrimary = false;
Douglas Gregorb4850462009-05-14 23:26:13 +0000148 }
Mike Stump11289f42009-09-09 15:08:12 +0000149
Douglas Gregora654dd82009-08-28 17:37:35 +0000150 return Result;
Douglas Gregorb4850462009-05-14 23:26:13 +0000151}
152
Douglas Gregor84d49a22009-11-11 21:54:23 +0000153bool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const {
154 switch (Kind) {
155 case TemplateInstantiation:
156 case DefaultTemplateArgumentInstantiation:
157 case DefaultFunctionArgumentInstantiation:
158 return true;
159
160 case ExplicitTemplateArgumentSubstitution:
161 case DeducedTemplateArgumentSubstitution:
162 case PriorTemplateArgumentSubstitution:
163 case DefaultTemplateArgumentChecking:
164 return false;
165 }
David Blaikie8a40f702012-01-17 06:56:22 +0000166
167 llvm_unreachable("Invalid InstantiationKind!");
Douglas Gregor84d49a22009-11-11 21:54:23 +0000168}
169
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000170Sema::InstantiatingTemplate::
171InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregor85673582009-05-18 17:01:57 +0000172 Decl *Entity,
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000173 SourceRange InstantiationRange)
Douglas Gregoredb76852011-01-27 22:31:44 +0000174 : SemaRef(SemaRef),
175 SavedInNonInstantiationSFINAEContext(
176 SemaRef.InNonInstantiationSFINAEContext)
177{
Douglas Gregor79cf6032009-03-10 20:44:00 +0000178 Invalid = CheckInstantiationDepth(PointOfInstantiation,
179 InstantiationRange);
180 if (!Invalid) {
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000181 ActiveTemplateInstantiation Inst;
Douglas Gregor79cf6032009-03-10 20:44:00 +0000182 Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation;
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000183 Inst.PointOfInstantiation = PointOfInstantiation;
Douglas Gregor79cf6032009-03-10 20:44:00 +0000184 Inst.Entity = reinterpret_cast<uintptr_t>(Entity);
Douglas Gregorc9220832009-03-12 18:36:18 +0000185 Inst.TemplateArgs = 0;
186 Inst.NumTemplateArgs = 0;
Douglas Gregor79cf6032009-03-10 20:44:00 +0000187 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000188 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregor79cf6032009-03-10 20:44:00 +0000189 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
Douglas Gregor79cf6032009-03-10 20:44:00 +0000190 }
191}
192
Mike Stump11289f42009-09-09 15:08:12 +0000193Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
Douglas Gregor79cf6032009-03-10 20:44:00 +0000194 SourceLocation PointOfInstantiation,
195 TemplateDecl *Template,
196 const TemplateArgument *TemplateArgs,
197 unsigned NumTemplateArgs,
198 SourceRange InstantiationRange)
Douglas Gregoredb76852011-01-27 22:31:44 +0000199 : SemaRef(SemaRef),
200 SavedInNonInstantiationSFINAEContext(
201 SemaRef.InNonInstantiationSFINAEContext)
202{
Douglas Gregor79cf6032009-03-10 20:44:00 +0000203 Invalid = CheckInstantiationDepth(PointOfInstantiation,
204 InstantiationRange);
205 if (!Invalid) {
206 ActiveTemplateInstantiation Inst;
Mike Stump11289f42009-09-09 15:08:12 +0000207 Inst.Kind
Douglas Gregor79cf6032009-03-10 20:44:00 +0000208 = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation;
209 Inst.PointOfInstantiation = PointOfInstantiation;
210 Inst.Entity = reinterpret_cast<uintptr_t>(Template);
211 Inst.TemplateArgs = TemplateArgs;
212 Inst.NumTemplateArgs = NumTemplateArgs;
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000213 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000214 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000215 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000216 }
217}
218
Mike Stump11289f42009-09-09 15:08:12 +0000219Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
Douglas Gregor637d9982009-06-10 23:47:09 +0000220 SourceLocation PointOfInstantiation,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000221 FunctionTemplateDecl *FunctionTemplate,
222 const TemplateArgument *TemplateArgs,
223 unsigned NumTemplateArgs,
224 ActiveTemplateInstantiation::InstantiationKind Kind,
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000225 sema::TemplateDeductionInfo &DeductionInfo,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000226 SourceRange InstantiationRange)
Douglas Gregoredb76852011-01-27 22:31:44 +0000227 : SemaRef(SemaRef),
228 SavedInNonInstantiationSFINAEContext(
229 SemaRef.InNonInstantiationSFINAEContext)
230{
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000231 Invalid = CheckInstantiationDepth(PointOfInstantiation,
232 InstantiationRange);
233 if (!Invalid) {
234 ActiveTemplateInstantiation Inst;
235 Inst.Kind = Kind;
236 Inst.PointOfInstantiation = PointOfInstantiation;
237 Inst.Entity = reinterpret_cast<uintptr_t>(FunctionTemplate);
238 Inst.TemplateArgs = TemplateArgs;
239 Inst.NumTemplateArgs = NumTemplateArgs;
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000240 Inst.DeductionInfo = &DeductionInfo;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000241 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000242 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000243 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
Douglas Gregor84d49a22009-11-11 21:54:23 +0000244
245 if (!Inst.isInstantiationRecord())
246 ++SemaRef.NonInstantiationEntries;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000247 }
248}
249
Mike Stump11289f42009-09-09 15:08:12 +0000250Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000251 SourceLocation PointOfInstantiation,
Douglas Gregor637d9982009-06-10 23:47:09 +0000252 ClassTemplatePartialSpecializationDecl *PartialSpec,
253 const TemplateArgument *TemplateArgs,
254 unsigned NumTemplateArgs,
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000255 sema::TemplateDeductionInfo &DeductionInfo,
Douglas Gregor637d9982009-06-10 23:47:09 +0000256 SourceRange InstantiationRange)
Douglas Gregoredb76852011-01-27 22:31:44 +0000257 : SemaRef(SemaRef),
258 SavedInNonInstantiationSFINAEContext(
259 SemaRef.InNonInstantiationSFINAEContext)
260{
Douglas Gregor84d49a22009-11-11 21:54:23 +0000261 Invalid = false;
262
263 ActiveTemplateInstantiation Inst;
264 Inst.Kind = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution;
265 Inst.PointOfInstantiation = PointOfInstantiation;
266 Inst.Entity = reinterpret_cast<uintptr_t>(PartialSpec);
267 Inst.TemplateArgs = TemplateArgs;
268 Inst.NumTemplateArgs = NumTemplateArgs;
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000269 Inst.DeductionInfo = &DeductionInfo;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000270 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000271 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000272 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
273
274 assert(!Inst.isInstantiationRecord());
275 ++SemaRef.NonInstantiationEntries;
Douglas Gregor637d9982009-06-10 23:47:09 +0000276}
277
Mike Stump11289f42009-09-09 15:08:12 +0000278Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
Douglas Gregore62e6a02009-11-11 19:13:48 +0000279 SourceLocation PointOfInstantiation,
Anders Carlsson657bad42009-09-05 05:14:19 +0000280 ParmVarDecl *Param,
281 const TemplateArgument *TemplateArgs,
282 unsigned NumTemplateArgs,
283 SourceRange InstantiationRange)
Douglas Gregoredb76852011-01-27 22:31:44 +0000284 : SemaRef(SemaRef),
285 SavedInNonInstantiationSFINAEContext(
286 SemaRef.InNonInstantiationSFINAEContext)
287{
Douglas Gregore62e6a02009-11-11 19:13:48 +0000288 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
Anders Carlsson657bad42009-09-05 05:14:19 +0000289
290 if (!Invalid) {
291 ActiveTemplateInstantiation Inst;
292 Inst.Kind
293 = ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation;
Douglas Gregore62e6a02009-11-11 19:13:48 +0000294 Inst.PointOfInstantiation = PointOfInstantiation;
Anders Carlsson657bad42009-09-05 05:14:19 +0000295 Inst.Entity = reinterpret_cast<uintptr_t>(Param);
296 Inst.TemplateArgs = TemplateArgs;
297 Inst.NumTemplateArgs = NumTemplateArgs;
298 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000299 SemaRef.InNonInstantiationSFINAEContext = false;
Anders Carlsson657bad42009-09-05 05:14:19 +0000300 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
Douglas Gregore62e6a02009-11-11 19:13:48 +0000301 }
302}
303
304Sema::InstantiatingTemplate::
305InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorca4686d2011-01-04 23:35:54 +0000306 NamedDecl *Template,
Douglas Gregore62e6a02009-11-11 19:13:48 +0000307 NonTypeTemplateParmDecl *Param,
308 const TemplateArgument *TemplateArgs,
309 unsigned NumTemplateArgs,
Douglas Gregoredb76852011-01-27 22:31:44 +0000310 SourceRange InstantiationRange)
311 : SemaRef(SemaRef),
312 SavedInNonInstantiationSFINAEContext(
313 SemaRef.InNonInstantiationSFINAEContext)
314{
Douglas Gregor84d49a22009-11-11 21:54:23 +0000315 Invalid = false;
Douglas Gregore62e6a02009-11-11 19:13:48 +0000316
Douglas Gregor84d49a22009-11-11 21:54:23 +0000317 ActiveTemplateInstantiation Inst;
318 Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution;
319 Inst.PointOfInstantiation = PointOfInstantiation;
320 Inst.Template = Template;
321 Inst.Entity = reinterpret_cast<uintptr_t>(Param);
322 Inst.TemplateArgs = TemplateArgs;
323 Inst.NumTemplateArgs = NumTemplateArgs;
324 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000325 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000326 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
327
328 assert(!Inst.isInstantiationRecord());
329 ++SemaRef.NonInstantiationEntries;
Douglas Gregore62e6a02009-11-11 19:13:48 +0000330}
331
332Sema::InstantiatingTemplate::
333InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorca4686d2011-01-04 23:35:54 +0000334 NamedDecl *Template,
Douglas Gregore62e6a02009-11-11 19:13:48 +0000335 TemplateTemplateParmDecl *Param,
336 const TemplateArgument *TemplateArgs,
337 unsigned NumTemplateArgs,
Douglas Gregoredb76852011-01-27 22:31:44 +0000338 SourceRange InstantiationRange)
339 : SemaRef(SemaRef),
340 SavedInNonInstantiationSFINAEContext(
341 SemaRef.InNonInstantiationSFINAEContext)
342{
Douglas Gregor84d49a22009-11-11 21:54:23 +0000343 Invalid = false;
344 ActiveTemplateInstantiation Inst;
345 Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution;
346 Inst.PointOfInstantiation = PointOfInstantiation;
347 Inst.Template = Template;
348 Inst.Entity = reinterpret_cast<uintptr_t>(Param);
349 Inst.TemplateArgs = TemplateArgs;
350 Inst.NumTemplateArgs = NumTemplateArgs;
351 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000352 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000353 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
Douglas Gregore62e6a02009-11-11 19:13:48 +0000354
Douglas Gregor84d49a22009-11-11 21:54:23 +0000355 assert(!Inst.isInstantiationRecord());
356 ++SemaRef.NonInstantiationEntries;
357}
358
359Sema::InstantiatingTemplate::
360InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
361 TemplateDecl *Template,
362 NamedDecl *Param,
363 const TemplateArgument *TemplateArgs,
364 unsigned NumTemplateArgs,
Douglas Gregoredb76852011-01-27 22:31:44 +0000365 SourceRange InstantiationRange)
366 : SemaRef(SemaRef),
367 SavedInNonInstantiationSFINAEContext(
368 SemaRef.InNonInstantiationSFINAEContext)
369{
Douglas Gregor84d49a22009-11-11 21:54:23 +0000370 Invalid = false;
371
372 ActiveTemplateInstantiation Inst;
373 Inst.Kind = ActiveTemplateInstantiation::DefaultTemplateArgumentChecking;
374 Inst.PointOfInstantiation = PointOfInstantiation;
375 Inst.Template = Template;
376 Inst.Entity = reinterpret_cast<uintptr_t>(Param);
377 Inst.TemplateArgs = TemplateArgs;
378 Inst.NumTemplateArgs = NumTemplateArgs;
379 Inst.InstantiationRange = InstantiationRange;
Douglas Gregoredb76852011-01-27 22:31:44 +0000380 SemaRef.InNonInstantiationSFINAEContext = false;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000381 SemaRef.ActiveTemplateInstantiations.push_back(Inst);
382
383 assert(!Inst.isInstantiationRecord());
384 ++SemaRef.NonInstantiationEntries;
Anders Carlsson657bad42009-09-05 05:14:19 +0000385}
386
Douglas Gregor85673582009-05-18 17:01:57 +0000387void Sema::InstantiatingTemplate::Clear() {
388 if (!Invalid) {
Douglas Gregor84d49a22009-11-11 21:54:23 +0000389 if (!SemaRef.ActiveTemplateInstantiations.back().isInstantiationRecord()) {
390 assert(SemaRef.NonInstantiationEntries > 0);
391 --SemaRef.NonInstantiationEntries;
392 }
Douglas Gregoredb76852011-01-27 22:31:44 +0000393 SemaRef.InNonInstantiationSFINAEContext
394 = SavedInNonInstantiationSFINAEContext;
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000395 SemaRef.ActiveTemplateInstantiations.pop_back();
Douglas Gregor85673582009-05-18 17:01:57 +0000396 Invalid = true;
397 }
Douglas Gregorfcd5db32009-03-10 00:06:19 +0000398}
399
Douglas Gregor79cf6032009-03-10 20:44:00 +0000400bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
401 SourceLocation PointOfInstantiation,
402 SourceRange InstantiationRange) {
Douglas Gregor84d49a22009-11-11 21:54:23 +0000403 assert(SemaRef.NonInstantiationEntries <=
404 SemaRef.ActiveTemplateInstantiations.size());
405 if ((SemaRef.ActiveTemplateInstantiations.size() -
406 SemaRef.NonInstantiationEntries)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000407 <= SemaRef.getLangOpts().InstantiationDepth)
Douglas Gregor79cf6032009-03-10 20:44:00 +0000408 return false;
409
Mike Stump11289f42009-09-09 15:08:12 +0000410 SemaRef.Diag(PointOfInstantiation,
Douglas Gregor79cf6032009-03-10 20:44:00 +0000411 diag::err_template_recursion_depth_exceeded)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000412 << SemaRef.getLangOpts().InstantiationDepth
Douglas Gregor79cf6032009-03-10 20:44:00 +0000413 << InstantiationRange;
414 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000415 << SemaRef.getLangOpts().InstantiationDepth;
Douglas Gregor79cf6032009-03-10 20:44:00 +0000416 return true;
417}
418
Douglas Gregor4ea568f2009-03-10 18:03:33 +0000419/// \brief Prints the current instantiation stack through a series of
420/// notes.
421void Sema::PrintInstantiationStack() {
Douglas Gregorffed1cb2010-04-20 07:18:24 +0000422 // Determine which template instantiations to skip, if any.
423 unsigned SkipStart = ActiveTemplateInstantiations.size(), SkipEnd = SkipStart;
424 unsigned Limit = Diags.getTemplateBacktraceLimit();
425 if (Limit && Limit < ActiveTemplateInstantiations.size()) {
426 SkipStart = Limit / 2 + Limit % 2;
427 SkipEnd = ActiveTemplateInstantiations.size() - Limit / 2;
428 }
429
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000430 // FIXME: In all of these cases, we need to show the template arguments
Douglas Gregorffed1cb2010-04-20 07:18:24 +0000431 unsigned InstantiationIdx = 0;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000432 for (SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator
Douglas Gregor4ea568f2009-03-10 18:03:33 +0000433 Active = ActiveTemplateInstantiations.rbegin(),
434 ActiveEnd = ActiveTemplateInstantiations.rend();
435 Active != ActiveEnd;
Douglas Gregorffed1cb2010-04-20 07:18:24 +0000436 ++Active, ++InstantiationIdx) {
437 // Skip this instantiation?
438 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
439 if (InstantiationIdx == SkipStart) {
440 // Note that we're skipping instantiations.
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000441 Diags.Report(Active->PointOfInstantiation,
Douglas Gregorffed1cb2010-04-20 07:18:24 +0000442 diag::note_instantiation_contexts_suppressed)
443 << unsigned(ActiveTemplateInstantiations.size() - Limit);
444 }
445 continue;
446 }
447
Douglas Gregor79cf6032009-03-10 20:44:00 +0000448 switch (Active->Kind) {
449 case ActiveTemplateInstantiation::TemplateInstantiation: {
Douglas Gregor85673582009-05-18 17:01:57 +0000450 Decl *D = reinterpret_cast<Decl *>(Active->Entity);
451 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
452 unsigned DiagID = diag::note_template_member_class_here;
453 if (isa<ClassTemplateSpecializationDecl>(Record))
454 DiagID = diag::note_template_class_instantiation_here;
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000455 Diags.Report(Active->PointOfInstantiation, DiagID)
Douglas Gregor85673582009-05-18 17:01:57 +0000456 << Context.getTypeDeclType(Record)
457 << Active->InstantiationRange;
Douglas Gregora6ef8f02009-07-24 20:34:43 +0000458 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
Douglas Gregor4adbc6d2009-06-26 00:10:03 +0000459 unsigned DiagID;
460 if (Function->getPrimaryTemplate())
461 DiagID = diag::note_function_template_spec_here;
462 else
463 DiagID = diag::note_template_member_function_here;
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000464 Diags.Report(Active->PointOfInstantiation, DiagID)
Douglas Gregor85673582009-05-18 17:01:57 +0000465 << Function
466 << Active->InstantiationRange;
Richard Smith3f1b5d02011-05-05 21:57:07 +0000467 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000468 Diags.Report(Active->PointOfInstantiation,
Douglas Gregora6ef8f02009-07-24 20:34:43 +0000469 diag::note_template_static_data_member_def_here)
Richard Smith3f1b5d02011-05-05 21:57:07 +0000470 << VD
471 << Active->InstantiationRange;
Richard Smith4b38ded2012-03-14 23:13:10 +0000472 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
473 Diags.Report(Active->PointOfInstantiation,
474 diag::note_template_enum_def_here)
475 << ED
476 << Active->InstantiationRange;
Richard Smith3f1b5d02011-05-05 21:57:07 +0000477 } else {
478 Diags.Report(Active->PointOfInstantiation,
479 diag::note_template_type_alias_instantiation_here)
480 << cast<TypeAliasTemplateDecl>(D)
Douglas Gregora6ef8f02009-07-24 20:34:43 +0000481 << Active->InstantiationRange;
Douglas Gregor85673582009-05-18 17:01:57 +0000482 }
Douglas Gregor79cf6032009-03-10 20:44:00 +0000483 break;
484 }
485
486 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: {
487 TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity);
488 std::string TemplateArgsStr
Douglas Gregordc572a32009-03-30 22:58:21 +0000489 = TemplateSpecializationType::PrintTemplateArgumentList(
Mike Stump11289f42009-09-09 15:08:12 +0000490 Active->TemplateArgs,
Douglas Gregor7de59662009-05-29 20:38:28 +0000491 Active->NumTemplateArgs,
Douglas Gregor75acd922011-09-27 23:30:47 +0000492 getPrintingPolicy());
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000493 Diags.Report(Active->PointOfInstantiation,
Douglas Gregor79cf6032009-03-10 20:44:00 +0000494 diag::note_default_arg_instantiation_here)
495 << (Template->getNameAsString() + TemplateArgsStr)
496 << Active->InstantiationRange;
497 break;
498 }
Douglas Gregor637d9982009-06-10 23:47:09 +0000499
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000500 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: {
Mike Stump11289f42009-09-09 15:08:12 +0000501 FunctionTemplateDecl *FnTmpl
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000502 = cast<FunctionTemplateDecl>((Decl *)Active->Entity);
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000503 Diags.Report(Active->PointOfInstantiation,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000504 diag::note_explicit_template_arg_substitution_here)
Douglas Gregor607f1412010-03-30 20:35:20 +0000505 << FnTmpl
506 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
507 Active->TemplateArgs,
508 Active->NumTemplateArgs)
509 << Active->InstantiationRange;
Douglas Gregor637d9982009-06-10 23:47:09 +0000510 break;
511 }
Mike Stump11289f42009-09-09 15:08:12 +0000512
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000513 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution:
514 if (ClassTemplatePartialSpecializationDecl *PartialSpec
515 = dyn_cast<ClassTemplatePartialSpecializationDecl>(
516 (Decl *)Active->Entity)) {
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000517 Diags.Report(Active->PointOfInstantiation,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000518 diag::note_partial_spec_deduct_instantiation_here)
519 << Context.getTypeDeclType(PartialSpec)
Douglas Gregor607f1412010-03-30 20:35:20 +0000520 << getTemplateArgumentBindingsText(
521 PartialSpec->getTemplateParameters(),
522 Active->TemplateArgs,
523 Active->NumTemplateArgs)
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000524 << Active->InstantiationRange;
525 } else {
526 FunctionTemplateDecl *FnTmpl
527 = cast<FunctionTemplateDecl>((Decl *)Active->Entity);
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000528 Diags.Report(Active->PointOfInstantiation,
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000529 diag::note_function_template_deduction_instantiation_here)
Douglas Gregor607f1412010-03-30 20:35:20 +0000530 << FnTmpl
531 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
532 Active->TemplateArgs,
533 Active->NumTemplateArgs)
534 << Active->InstantiationRange;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000535 }
536 break;
Douglas Gregor637d9982009-06-10 23:47:09 +0000537
Anders Carlsson657bad42009-09-05 05:14:19 +0000538 case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: {
539 ParmVarDecl *Param = cast<ParmVarDecl>((Decl *)Active->Entity);
540 FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
Mike Stump11289f42009-09-09 15:08:12 +0000541
Anders Carlsson657bad42009-09-05 05:14:19 +0000542 std::string TemplateArgsStr
543 = TemplateSpecializationType::PrintTemplateArgumentList(
Mike Stump11289f42009-09-09 15:08:12 +0000544 Active->TemplateArgs,
Anders Carlsson657bad42009-09-05 05:14:19 +0000545 Active->NumTemplateArgs,
Douglas Gregor75acd922011-09-27 23:30:47 +0000546 getPrintingPolicy());
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000547 Diags.Report(Active->PointOfInstantiation,
Anders Carlsson657bad42009-09-05 05:14:19 +0000548 diag::note_default_function_arg_instantiation_here)
Anders Carlssondc6d2c32009-09-05 05:38:54 +0000549 << (FD->getNameAsString() + TemplateArgsStr)
Anders Carlsson657bad42009-09-05 05:14:19 +0000550 << Active->InstantiationRange;
551 break;
552 }
Mike Stump11289f42009-09-09 15:08:12 +0000553
Douglas Gregore62e6a02009-11-11 19:13:48 +0000554 case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: {
555 NamedDecl *Parm = cast<NamedDecl>((Decl *)Active->Entity);
556 std::string Name;
557 if (!Parm->getName().empty())
558 Name = std::string(" '") + Parm->getName().str() + "'";
Douglas Gregorca4686d2011-01-04 23:35:54 +0000559
560 TemplateParameterList *TemplateParams = 0;
561 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
562 TemplateParams = Template->getTemplateParameters();
563 else
564 TemplateParams =
565 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
566 ->getTemplateParameters();
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000567 Diags.Report(Active->PointOfInstantiation,
Douglas Gregore62e6a02009-11-11 19:13:48 +0000568 diag::note_prior_template_arg_substitution)
569 << isa<TemplateTemplateParmDecl>(Parm)
570 << Name
Douglas Gregorca4686d2011-01-04 23:35:54 +0000571 << getTemplateArgumentBindingsText(TemplateParams,
Douglas Gregore62e6a02009-11-11 19:13:48 +0000572 Active->TemplateArgs,
573 Active->NumTemplateArgs)
574 << Active->InstantiationRange;
575 break;
576 }
Douglas Gregor84d49a22009-11-11 21:54:23 +0000577
578 case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: {
Douglas Gregorca4686d2011-01-04 23:35:54 +0000579 TemplateParameterList *TemplateParams = 0;
580 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
581 TemplateParams = Template->getTemplateParameters();
582 else
583 TemplateParams =
584 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
585 ->getTemplateParameters();
586
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +0000587 Diags.Report(Active->PointOfInstantiation,
Douglas Gregor84d49a22009-11-11 21:54:23 +0000588 diag::note_template_default_arg_checking)
Douglas Gregorca4686d2011-01-04 23:35:54 +0000589 << getTemplateArgumentBindingsText(TemplateParams,
Douglas Gregor84d49a22009-11-11 21:54:23 +0000590 Active->TemplateArgs,
591 Active->NumTemplateArgs)
592 << Active->InstantiationRange;
593 break;
594 }
Douglas Gregor79cf6032009-03-10 20:44:00 +0000595 }
Douglas Gregor4ea568f2009-03-10 18:03:33 +0000596 }
597}
598
Douglas Gregoredb76852011-01-27 22:31:44 +0000599llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
Douglas Gregoredb76852011-01-27 22:31:44 +0000600 if (InNonInstantiationSFINAEContext)
601 return llvm::Optional<TemplateDeductionInfo *>(0);
602
Douglas Gregor33834512009-06-14 07:33:30 +0000603 for (SmallVector<ActiveTemplateInstantiation, 16>::const_reverse_iterator
604 Active = ActiveTemplateInstantiations.rbegin(),
605 ActiveEnd = ActiveTemplateInstantiations.rend();
606 Active != ActiveEnd;
Douglas Gregor84d49a22009-11-11 21:54:23 +0000607 ++Active)
608 {
Douglas Gregor33834512009-06-14 07:33:30 +0000609 switch(Active->Kind) {
Anders Carlsson657bad42009-09-05 05:14:19 +0000610 case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation:
Douglas Gregoredb76852011-01-27 22:31:44 +0000611 case ActiveTemplateInstantiation::TemplateInstantiation:
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000612 // This is a template instantiation, so there is no SFINAE.
Douglas Gregoredb76852011-01-27 22:31:44 +0000613 return llvm::Optional<TemplateDeductionInfo *>();
Mike Stump11289f42009-09-09 15:08:12 +0000614
Douglas Gregor33834512009-06-14 07:33:30 +0000615 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation:
Douglas Gregore62e6a02009-11-11 19:13:48 +0000616 case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution:
Douglas Gregor84d49a22009-11-11 21:54:23 +0000617 case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking:
Douglas Gregore62e6a02009-11-11 19:13:48 +0000618 // A default template argument instantiation and substitution into
619 // template parameters with arguments for prior parameters may or may
620 // not be a SFINAE context; look further up the stack.
Douglas Gregor33834512009-06-14 07:33:30 +0000621 break;
Mike Stump11289f42009-09-09 15:08:12 +0000622
Douglas Gregorff6cbdf2009-07-01 22:01:06 +0000623 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution:
624 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution:
625 // We're either substitution explicitly-specified template arguments
626 // or deduced template arguments, so SFINAE applies.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000627 assert(Active->DeductionInfo && "Missing deduction info pointer");
628 return Active->DeductionInfo;
Douglas Gregor33834512009-06-14 07:33:30 +0000629 }
630 }
631
Douglas Gregoredb76852011-01-27 22:31:44 +0000632 return llvm::Optional<TemplateDeductionInfo *>();
Douglas Gregor33834512009-06-14 07:33:30 +0000633}
634
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000635/// \brief Retrieve the depth and index of a parameter pack.
636static std::pair<unsigned, unsigned>
637getDepthAndIndex(NamedDecl *ND) {
638 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
639 return std::make_pair(TTP->getDepth(), TTP->getIndex());
640
641 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
642 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
643
644 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
645 return std::make_pair(TTP->getDepth(), TTP->getIndex());
646}
647
Douglas Gregorfe1e1102009-02-27 19:31:52 +0000648//===----------------------------------------------------------------------===/
649// Template Instantiation for Types
650//===----------------------------------------------------------------------===/
Douglas Gregor17c0d7b2009-02-28 00:25:32 +0000651namespace {
Douglas Gregor14cf7522010-04-30 18:55:50 +0000652 class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
Douglas Gregor01afeef2009-08-28 20:31:08 +0000653 const MultiLevelTemplateArgumentList &TemplateArgs;
Douglas Gregor17c0d7b2009-02-28 00:25:32 +0000654 SourceLocation Loc;
655 DeclarationName Entity;
Douglas Gregorfe1e1102009-02-27 19:31:52 +0000656
Douglas Gregor17c0d7b2009-02-28 00:25:32 +0000657 public:
Douglas Gregorebe10102009-08-20 07:17:43 +0000658 typedef TreeTransform<TemplateInstantiator> inherited;
Mike Stump11289f42009-09-09 15:08:12 +0000659
660 TemplateInstantiator(Sema &SemaRef,
Douglas Gregor01afeef2009-08-28 20:31:08 +0000661 const MultiLevelTemplateArgumentList &TemplateArgs,
Douglas Gregord6ff3322009-08-04 16:50:30 +0000662 SourceLocation Loc,
Mike Stump11289f42009-09-09 15:08:12 +0000663 DeclarationName Entity)
664 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
Douglas Gregorebe10102009-08-20 07:17:43 +0000665 Entity(Entity) { }
Douglas Gregor17c0d7b2009-02-28 00:25:32 +0000666
Mike Stump11289f42009-09-09 15:08:12 +0000667 /// \brief Determine whether the given type \p T has already been
Douglas Gregord6ff3322009-08-04 16:50:30 +0000668 /// transformed.
669 ///
670 /// For the purposes of template instantiation, a type has already been
671 /// transformed if it is NULL or if it is not dependent.
Douglas Gregor5597ab42010-05-07 23:12:07 +0000672 bool AlreadyTransformed(QualType T);
Mike Stump11289f42009-09-09 15:08:12 +0000673
Douglas Gregord6ff3322009-08-04 16:50:30 +0000674 /// \brief Returns the location of the entity being instantiated, if known.
675 SourceLocation getBaseLocation() { return Loc; }
Mike Stump11289f42009-09-09 15:08:12 +0000676
Douglas Gregord6ff3322009-08-04 16:50:30 +0000677 /// \brief Returns the name of the entity being instantiated, if any.
678 DeclarationName getBaseEntity() { return Entity; }
Mike Stump11289f42009-09-09 15:08:12 +0000679
Douglas Gregoref6ab412009-10-27 06:26:26 +0000680 /// \brief Sets the "base" location and entity when that
681 /// information is known based on another transformation.
682 void setBase(SourceLocation Loc, DeclarationName Entity) {
683 this->Loc = Loc;
684 this->Entity = Entity;
685 }
Douglas Gregor840bd6c2010-12-20 22:05:00 +0000686
687 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
688 SourceRange PatternRange,
David Blaikieb9c168a2011-09-22 02:34:54 +0000689 llvm::ArrayRef<UnexpandedParameterPack> Unexpanded,
Douglas Gregor840bd6c2010-12-20 22:05:00 +0000690 bool &ShouldExpand,
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000691 bool &RetainExpansion,
Douglas Gregor0dca5fd2011-01-14 17:04:44 +0000692 llvm::Optional<unsigned> &NumExpansions) {
Douglas Gregor76aca7b2010-12-21 00:52:54 +0000693 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
694 PatternRange, Unexpanded,
Douglas Gregor76aca7b2010-12-21 00:52:54 +0000695 TemplateArgs,
696 ShouldExpand,
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000697 RetainExpansion,
Douglas Gregor76aca7b2010-12-21 00:52:54 +0000698 NumExpansions);
699 }
Douglas Gregor840bd6c2010-12-20 22:05:00 +0000700
Douglas Gregorf3010112011-01-07 16:43:16 +0000701 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
702 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
703 }
704
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000705 TemplateArgument ForgetPartiallySubstitutedPack() {
706 TemplateArgument Result;
707 if (NamedDecl *PartialPack
708 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
709 MultiLevelTemplateArgumentList &TemplateArgs
710 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
711 unsigned Depth, Index;
712 llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack);
713 if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
714 Result = TemplateArgs(Depth, Index);
715 TemplateArgs.setArgument(Depth, Index, TemplateArgument());
716 }
717 }
718
719 return Result;
720 }
721
722 void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
723 if (Arg.isNull())
724 return;
725
726 if (NamedDecl *PartialPack
727 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
728 MultiLevelTemplateArgumentList &TemplateArgs
729 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
730 unsigned Depth, Index;
731 llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack);
732 TemplateArgs.setArgument(Depth, Index, Arg);
733 }
734 }
735
Douglas Gregord6ff3322009-08-04 16:50:30 +0000736 /// \brief Transform the given declaration by instantiating a reference to
737 /// this declaration.
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000738 Decl *TransformDecl(SourceLocation Loc, Decl *D);
Douglas Gregora16548e2009-08-11 05:31:07 +0000739
Douglas Gregor0c46b2b2012-02-13 22:00:16 +0000740 void transformAttrs(Decl *Old, Decl *New) {
741 SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
742 }
743
744 void transformedLocalDecl(Decl *Old, Decl *New) {
745 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
746 }
747
Mike Stump11289f42009-09-09 15:08:12 +0000748 /// \brief Transform the definition of the given declaration by
Douglas Gregorebe10102009-08-20 07:17:43 +0000749 /// instantiating it.
Douglas Gregor25289362010-03-01 17:25:41 +0000750 Decl *TransformDefinition(SourceLocation Loc, Decl *D);
Mike Stump11289f42009-09-09 15:08:12 +0000751
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000752 /// \bried Transform the first qualifier within a scope by instantiating the
753 /// declaration.
754 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
755
Douglas Gregorebe10102009-08-20 07:17:43 +0000756 /// \brief Rebuild the exception declaration and register the declaration
757 /// as an instantiated local.
Douglas Gregor9f0e1aa2010-09-09 17:09:21 +0000758 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
John McCallbcd03502009-12-07 02:54:59 +0000759 TypeSourceInfo *Declarator,
Abramo Bagnaradff19302011-03-08 08:55:46 +0000760 SourceLocation StartLoc,
761 SourceLocation NameLoc,
762 IdentifierInfo *Name);
Mike Stump11289f42009-09-09 15:08:12 +0000763
Douglas Gregorf4e837f2010-04-26 17:57:08 +0000764 /// \brief Rebuild the Objective-C exception declaration and register the
765 /// declaration as an instantiated local.
766 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
767 TypeSourceInfo *TSInfo, QualType T);
768
John McCall7f41d982009-09-11 04:59:25 +0000769 /// \brief Check for tag mismatches when instantiating an
770 /// elaborated type.
John McCall954b5de2010-11-04 19:04:38 +0000771 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
772 ElaboratedTypeKeyword Keyword,
Douglas Gregor844cb502011-03-01 18:12:44 +0000773 NestedNameSpecifierLoc QualifierLoc,
774 QualType T);
John McCall7f41d982009-09-11 04:59:25 +0000775
Douglas Gregor9db53502011-03-02 18:07:45 +0000776 TemplateName TransformTemplateName(CXXScopeSpec &SS,
777 TemplateName Name,
778 SourceLocation NameLoc,
779 QualType ObjectType = QualType(),
780 NamedDecl *FirstQualifierInScope = 0);
781
John McCalldadc5752010-08-24 06:29:42 +0000782 ExprResult TransformPredefinedExpr(PredefinedExpr *E);
783 ExprResult TransformDeclRefExpr(DeclRefExpr *E);
784 ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
785 ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
Douglas Gregoreb5a39d2010-12-24 00:15:10 +0000786 NonTypeTemplateParmDecl *D);
Douglas Gregorcdbc5392011-01-15 01:15:58 +0000787 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
788 SubstNonTypeTemplateParmPackExpr *E);
789
Douglas Gregor14cf7522010-04-30 18:55:50 +0000790 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
John McCall31f82722010-11-12 08:19:04 +0000791 FunctionProtoTypeLoc TL);
Douglas Gregor3024f072012-04-16 07:05:22 +0000792 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
793 FunctionProtoTypeLoc TL,
794 CXXRecordDecl *ThisContext,
795 unsigned ThisTypeQuals);
796
Douglas Gregor715e4612011-01-14 22:40:04 +0000797 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
John McCall8fb0d9d2011-05-01 22:35:37 +0000798 int indexAdjustment,
Douglas Gregor0dd22bc2012-01-25 16:15:54 +0000799 llvm::Optional<unsigned> NumExpansions,
800 bool ExpectParameterPack);
John McCall58f10c32010-03-11 09:03:00 +0000801
Mike Stump11289f42009-09-09 15:08:12 +0000802 /// \brief Transforms a template type parameter type by performing
Douglas Gregord6ff3322009-08-04 16:50:30 +0000803 /// substitution of the corresponding template type argument.
John McCall550e0c22009-10-21 00:40:46 +0000804 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
John McCall31f82722010-11-12 08:19:04 +0000805 TemplateTypeParmTypeLoc TL);
Nick Lewyckyc96c37f2010-07-06 19:51:49 +0000806
Douglas Gregorada4b792011-01-14 02:55:32 +0000807 /// \brief Transforms an already-substituted template type parameter pack
808 /// into either itself (if we aren't substituting into its pack expansion)
809 /// or the appropriate substituted argument.
810 QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
811 SubstTemplateTypeParmPackTypeLoc TL);
812
John McCalldadc5752010-08-24 06:29:42 +0000813 ExprResult TransformCallExpr(CallExpr *CE) {
Nick Lewyckyc96c37f2010-07-06 19:51:49 +0000814 getSema().CallsUndergoingInstantiation.push_back(CE);
John McCalldadc5752010-08-24 06:29:42 +0000815 ExprResult Result =
Nick Lewyckyc96c37f2010-07-06 19:51:49 +0000816 TreeTransform<TemplateInstantiator>::TransformCallExpr(CE);
817 getSema().CallsUndergoingInstantiation.pop_back();
818 return move(Result);
819 }
John McCall7c454bb2011-07-15 05:09:51 +0000820
821 private:
822 ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
823 SourceLocation loc,
824 const TemplateArgument &arg);
Douglas Gregord6ff3322009-08-04 16:50:30 +0000825 };
Douglas Gregor04318252009-07-06 15:59:29 +0000826}
827
Douglas Gregor5597ab42010-05-07 23:12:07 +0000828bool TemplateInstantiator::AlreadyTransformed(QualType T) {
829 if (T.isNull())
830 return true;
831
Douglas Gregor678d76c2011-07-01 01:22:09 +0000832 if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
Douglas Gregor5597ab42010-05-07 23:12:07 +0000833 return false;
834
835 getSema().MarkDeclarationsReferencedInType(Loc, T);
836 return true;
837}
838
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000839Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
Douglas Gregor2b6ca462009-09-03 21:38:09 +0000840 if (!D)
841 return 0;
Mike Stump11289f42009-09-09 15:08:12 +0000842
Douglas Gregor2b6ca462009-09-03 21:38:09 +0000843 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
Douglas Gregor01afeef2009-08-28 20:31:08 +0000844 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
Douglas Gregorb93971082010-02-05 19:54:12 +0000845 // If the corresponding template argument is NULL or non-existent, it's
846 // because we are performing instantiation from explicitly-specified
847 // template arguments in a function template, but there were some
848 // arguments left unspecified.
849 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
850 TTP->getPosition()))
851 return D;
852
Douglas Gregorf5500772011-01-05 15:48:55 +0000853 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
854
855 if (TTP->isParameterPack()) {
856 assert(Arg.getKind() == TemplateArgument::Pack &&
857 "Missing argument pack");
858
Douglas Gregor5590be02011-01-15 06:45:20 +0000859 assert(getSema().ArgumentPackSubstitutionIndex >= 0);
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000860 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
Douglas Gregorf5500772011-01-05 15:48:55 +0000861 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
862 }
863
864 TemplateName Template = Arg.getAsTemplate();
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000865 assert(!Template.isNull() && Template.getAsTemplateDecl() &&
Douglas Gregor01afeef2009-08-28 20:31:08 +0000866 "Wrong kind of template template argument");
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000867 return Template.getAsTemplateDecl();
Douglas Gregor01afeef2009-08-28 20:31:08 +0000868 }
Mike Stump11289f42009-09-09 15:08:12 +0000869
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000870 // Fall through to find the instantiated declaration for this template
871 // template parameter.
Douglas Gregor71dc5092009-08-06 06:41:21 +0000872 }
Mike Stump11289f42009-09-09 15:08:12 +0000873
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000874 return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
Douglas Gregord6ff3322009-08-04 16:50:30 +0000875}
876
Douglas Gregor25289362010-03-01 17:25:41 +0000877Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
John McCall76d824f2009-08-25 22:02:44 +0000878 Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
Douglas Gregorebe10102009-08-20 07:17:43 +0000879 if (!Inst)
880 return 0;
Mike Stump11289f42009-09-09 15:08:12 +0000881
Douglas Gregorebe10102009-08-20 07:17:43 +0000882 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
883 return Inst;
884}
885
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000886NamedDecl *
887TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
888 SourceLocation Loc) {
889 // If the first part of the nested-name-specifier was a template type
890 // parameter, instantiate that type parameter down to a tag type.
891 if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
892 const TemplateTypeParmType *TTP
893 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
Douglas Gregor53c3f4e2010-12-20 22:48:17 +0000894
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000895 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
Douglas Gregor53c3f4e2010-12-20 22:48:17 +0000896 // FIXME: This needs testing w/ member access expressions.
897 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
898
899 if (TTP->isParameterPack()) {
900 assert(Arg.getKind() == TemplateArgument::Pack &&
901 "Missing argument pack");
902
Douglas Gregore1d60df2011-01-14 23:41:42 +0000903 if (getSema().ArgumentPackSubstitutionIndex == -1)
Douglas Gregor53c3f4e2010-12-20 22:48:17 +0000904 return 0;
Douglas Gregor53c3f4e2010-12-20 22:48:17 +0000905
Douglas Gregora8bac7f2011-01-10 07:32:04 +0000906 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
Douglas Gregor53c3f4e2010-12-20 22:48:17 +0000907 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
908 }
909
910 QualType T = Arg.getAsType();
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000911 if (T.isNull())
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000912 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000913
914 if (const TagType *Tag = T->getAs<TagType>())
915 return Tag->getDecl();
916
917 // The resulting type is not a tag; complain.
918 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
919 return 0;
920 }
921 }
922
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000923 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
Douglas Gregora5cb6da2009-10-20 05:58:46 +0000924}
925
Douglas Gregorebe10102009-08-20 07:17:43 +0000926VarDecl *
927TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
John McCallbcd03502009-12-07 02:54:59 +0000928 TypeSourceInfo *Declarator,
Abramo Bagnaradff19302011-03-08 08:55:46 +0000929 SourceLocation StartLoc,
930 SourceLocation NameLoc,
931 IdentifierInfo *Name) {
Douglas Gregor9f0e1aa2010-09-09 17:09:21 +0000932 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
Abramo Bagnaradff19302011-03-08 08:55:46 +0000933 StartLoc, NameLoc, Name);
Douglas Gregorf4e837f2010-04-26 17:57:08 +0000934 if (Var)
935 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
936 return Var;
937}
938
939VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
940 TypeSourceInfo *TSInfo,
941 QualType T) {
942 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
943 if (Var)
Douglas Gregorebe10102009-08-20 07:17:43 +0000944 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
945 return Var;
946}
947
John McCall7f41d982009-09-11 04:59:25 +0000948QualType
John McCall954b5de2010-11-04 19:04:38 +0000949TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
950 ElaboratedTypeKeyword Keyword,
Douglas Gregor844cb502011-03-01 18:12:44 +0000951 NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara6150c882010-05-11 21:36:43 +0000952 QualType T) {
John McCall7f41d982009-09-11 04:59:25 +0000953 if (const TagType *TT = T->getAs<TagType>()) {
954 TagDecl* TD = TT->getDecl();
955
John McCall954b5de2010-11-04 19:04:38 +0000956 SourceLocation TagLocation = KeywordLoc;
John McCall7f41d982009-09-11 04:59:25 +0000957
958 // FIXME: type might be anonymous.
959 IdentifierInfo *Id = TD->getIdentifier();
960
961 // TODO: should we even warn on struct/class mismatches for this? Seems
962 // like it's likely to produce a lot of spurious errors.
Abramo Bagnara6150c882010-05-11 21:36:43 +0000963 if (Keyword != ETK_None && Keyword != ETK_Typename) {
964 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
Richard Trieucaa33d32011-06-10 03:11:26 +0000965 if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
966 TagLocation, *Id)) {
Abramo Bagnara6150c882010-05-11 21:36:43 +0000967 SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
968 << Id
969 << FixItHint::CreateReplacement(SourceRange(TagLocation),
970 TD->getKindName());
971 SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
972 }
John McCall7f41d982009-09-11 04:59:25 +0000973 }
974 }
975
John McCall954b5de2010-11-04 19:04:38 +0000976 return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
977 Keyword,
Douglas Gregor844cb502011-03-01 18:12:44 +0000978 QualifierLoc,
979 T);
John McCall7f41d982009-09-11 04:59:25 +0000980}
981
Douglas Gregor9db53502011-03-02 18:07:45 +0000982TemplateName TemplateInstantiator::TransformTemplateName(CXXScopeSpec &SS,
983 TemplateName Name,
984 SourceLocation NameLoc,
985 QualType ObjectType,
986 NamedDecl *FirstQualifierInScope) {
987 if (TemplateTemplateParmDecl *TTP
988 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
989 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
990 // If the corresponding template argument is NULL or non-existent, it's
991 // because we are performing instantiation from explicitly-specified
992 // template arguments in a function template, but there were some
993 // arguments left unspecified.
994 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
995 TTP->getPosition()))
996 return Name;
997
998 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
999
1000 if (TTP->isParameterPack()) {
1001 assert(Arg.getKind() == TemplateArgument::Pack &&
1002 "Missing argument pack");
1003
1004 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1005 // We have the template argument pack to substitute, but we're not
1006 // actually expanding the enclosing pack expansion yet. So, just
1007 // keep the entire argument pack.
1008 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1009 }
1010
1011 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
1012 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1013 }
1014
1015 TemplateName Template = Arg.getAsTemplate();
Richard Smith3f1b5d02011-05-05 21:57:07 +00001016 assert(!Template.isNull() && "Null template template argument");
John McCalld9dfe3a2011-06-30 08:33:18 +00001017
Douglas Gregor9d9f8db2011-03-05 20:06:51 +00001018 // We don't ever want to substitute for a qualified template name, since
1019 // the qualifier is handled separately. So, look through the qualified
1020 // template name to its underlying declaration.
1021 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
1022 Template = TemplateName(QTN->getTemplateDecl());
John McCalld9dfe3a2011-06-30 08:33:18 +00001023
1024 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
Douglas Gregor9db53502011-03-02 18:07:45 +00001025 return Template;
1026 }
1027 }
1028
1029 if (SubstTemplateTemplateParmPackStorage *SubstPack
1030 = Name.getAsSubstTemplateTemplateParmPack()) {
1031 if (getSema().ArgumentPackSubstitutionIndex == -1)
1032 return Name;
1033
1034 const TemplateArgument &ArgPack = SubstPack->getArgumentPack();
1035 assert(getSema().ArgumentPackSubstitutionIndex < (int)ArgPack.pack_size() &&
1036 "Pack substitution index out-of-range");
1037 return ArgPack.pack_begin()[getSema().ArgumentPackSubstitutionIndex]
1038 .getAsTemplate();
1039 }
1040
1041 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1042 FirstQualifierInScope);
1043}
1044
John McCalldadc5752010-08-24 06:29:42 +00001045ExprResult
John McCall47f29ea2009-12-08 09:21:05 +00001046TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
Anders Carlsson0b209a82009-09-11 01:22:35 +00001047 if (!E->isTypeDependent())
John McCallc3007a22010-10-26 07:05:15 +00001048 return SemaRef.Owned(E);
Anders Carlsson0b209a82009-09-11 01:22:35 +00001049
1050 FunctionDecl *currentDecl = getSema().getCurFunctionDecl();
1051 assert(currentDecl && "Must have current function declaration when "
1052 "instantiating.");
1053
1054 PredefinedExpr::IdentType IT = E->getIdentType();
1055
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001056 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
Anders Carlsson0b209a82009-09-11 01:22:35 +00001057
1058 llvm::APInt LengthI(32, Length + 1);
John McCall8ccfcb52009-09-24 19:53:00 +00001059 QualType ResTy = getSema().Context.CharTy.withConst();
Anders Carlsson0b209a82009-09-11 01:22:35 +00001060 ResTy = getSema().Context.getConstantArrayType(ResTy, LengthI,
1061 ArrayType::Normal, 0);
1062 PredefinedExpr *PE =
1063 new (getSema().Context) PredefinedExpr(E->getLocation(), ResTy, IT);
1064 return getSema().Owned(PE);
1065}
1066
John McCalldadc5752010-08-24 06:29:42 +00001067ExprResult
John McCall13481c52010-02-06 08:42:39 +00001068TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
Douglas Gregor6c379e22010-02-08 23:41:45 +00001069 NonTypeTemplateParmDecl *NTTP) {
John McCall13481c52010-02-06 08:42:39 +00001070 // If the corresponding template argument is NULL or non-existent, it's
1071 // because we are performing instantiation from explicitly-specified
1072 // template arguments in a function template, but there were some
1073 // arguments left unspecified.
1074 if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
1075 NTTP->getPosition()))
John McCallc3007a22010-10-26 07:05:15 +00001076 return SemaRef.Owned(E);
Mike Stump11289f42009-09-09 15:08:12 +00001077
Douglas Gregoreb5a39d2010-12-24 00:15:10 +00001078 TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1079 if (NTTP->isParameterPack()) {
1080 assert(Arg.getKind() == TemplateArgument::Pack &&
1081 "Missing argument pack");
1082
1083 if (getSema().ArgumentPackSubstitutionIndex == -1) {
Douglas Gregorcdbc5392011-01-15 01:15:58 +00001084 // We have an argument pack, but we can't select a particular argument
1085 // out of it yet. Therefore, we'll build an expression to hold on to that
1086 // argument pack.
1087 QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
1088 E->getLocation(),
1089 NTTP->getDeclName());
1090 if (TargetType.isNull())
1091 return ExprError();
1092
1093 return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(TargetType,
1094 NTTP,
1095 E->getLocation(),
1096 Arg);
Douglas Gregoreb5a39d2010-12-24 00:15:10 +00001097 }
1098
Douglas Gregora8bac7f2011-01-10 07:32:04 +00001099 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
Douglas Gregoreb5a39d2010-12-24 00:15:10 +00001100 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1101 }
Mike Stump11289f42009-09-09 15:08:12 +00001102
John McCall7c454bb2011-07-15 05:09:51 +00001103 return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1104}
1105
1106ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1107 NonTypeTemplateParmDecl *parm,
1108 SourceLocation loc,
1109 const TemplateArgument &arg) {
1110 ExprResult result;
1111 QualType type;
1112
John McCall13481c52010-02-06 08:42:39 +00001113 // The template argument itself might be an expression, in which
1114 // case we just return that expression.
John McCall7c454bb2011-07-15 05:09:51 +00001115 if (arg.getKind() == TemplateArgument::Expression) {
1116 Expr *argExpr = arg.getAsExpr();
1117 result = SemaRef.Owned(argExpr);
1118 type = argExpr->getType();
Mike Stump11289f42009-09-09 15:08:12 +00001119
John McCall7c454bb2011-07-15 05:09:51 +00001120 } else if (arg.getKind() == TemplateArgument::Declaration) {
Douglas Gregor31f55dc2012-04-06 22:40:38 +00001121 ValueDecl *VD;
1122 if (Decl *D = arg.getAsDecl()) {
1123 VD = cast<ValueDecl>(D);
Mike Stump11289f42009-09-09 15:08:12 +00001124
Douglas Gregor31f55dc2012-04-06 22:40:38 +00001125 // Find the instantiation of the template argument. This is
1126 // required for nested templates.
1127 VD = cast_or_null<ValueDecl>(
1128 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1129 if (!VD)
1130 return ExprError();
1131 } else {
1132 // Propagate NULL template argument.
1133 VD = 0;
1134 }
1135
John McCall15dda372010-02-06 10:23:53 +00001136 // Derive the type we want the substituted decl to have. This had
1137 // better be non-dependent, or these checks will have serious problems.
John McCall7c454bb2011-07-15 05:09:51 +00001138 if (parm->isExpandedParameterPack()) {
1139 type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
1140 } else if (parm->isParameterPack() &&
1141 isa<PackExpansionType>(parm->getType())) {
1142 type = SemaRef.SubstType(
1143 cast<PackExpansionType>(parm->getType())->getPattern(),
1144 TemplateArgs, loc, parm->getDeclName());
1145 } else {
1146 type = SemaRef.SubstType(parm->getType(), TemplateArgs,
1147 loc, parm->getDeclName());
1148 }
1149 assert(!type.isNull() && "type substitution failed for param type");
1150 assert(!type->isDependentType() && "param type still dependent");
1151 result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc);
John McCall13481c52010-02-06 08:42:39 +00001152
John McCall7c454bb2011-07-15 05:09:51 +00001153 if (!result.isInvalid()) type = result.get()->getType();
1154 } else {
1155 result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1156
1157 // Note that this type can be different from the type of 'result',
1158 // e.g. if it's an enum type.
1159 type = arg.getIntegralType();
1160 }
1161 if (result.isInvalid()) return ExprError();
1162
1163 Expr *resultExpr = result.take();
1164 return SemaRef.Owned(new (SemaRef.Context)
1165 SubstNonTypeTemplateParmExpr(type,
1166 resultExpr->getValueKind(),
1167 loc, parm, resultExpr));
John McCall13481c52010-02-06 08:42:39 +00001168}
1169
Douglas Gregorcdbc5392011-01-15 01:15:58 +00001170ExprResult
1171TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1172 SubstNonTypeTemplateParmPackExpr *E) {
1173 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1174 // We aren't expanding the parameter pack, so just return ourselves.
1175 return getSema().Owned(E);
1176 }
1177
Douglas Gregorcdbc5392011-01-15 01:15:58 +00001178 const TemplateArgument &ArgPack = E->getArgumentPack();
1179 unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex;
1180 assert(Index < ArgPack.pack_size() && "Substitution index out-of-range");
1181
1182 const TemplateArgument &Arg = ArgPack.pack_begin()[Index];
John McCall7c454bb2011-07-15 05:09:51 +00001183 return transformNonTypeTemplateParmRef(E->getParameterPack(),
1184 E->getParameterPackLocation(),
1185 Arg);
Douglas Gregorcdbc5392011-01-15 01:15:58 +00001186}
John McCall13481c52010-02-06 08:42:39 +00001187
John McCalldadc5752010-08-24 06:29:42 +00001188ExprResult
John McCall13481c52010-02-06 08:42:39 +00001189TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
1190 NamedDecl *D = E->getDecl();
1191 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
1192 if (NTTP->getDepth() < TemplateArgs.getNumLevels())
1193 return TransformTemplateParmRefExpr(E, NTTP);
Douglas Gregor954de172009-10-31 17:21:17 +00001194
1195 // We have a non-type template parameter that isn't fully substituted;
1196 // FindInstantiatedDecl will find it in the local instantiation scope.
Douglas Gregora16548e2009-08-11 05:31:07 +00001197 }
Mike Stump11289f42009-09-09 15:08:12 +00001198
John McCall47f29ea2009-12-08 09:21:05 +00001199 return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
Douglas Gregora16548e2009-08-11 05:31:07 +00001200}
1201
John McCalldadc5752010-08-24 06:29:42 +00001202ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
John McCall47f29ea2009-12-08 09:21:05 +00001203 CXXDefaultArgExpr *E) {
Sebastian Redl14236c82009-11-08 13:56:19 +00001204 assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->
1205 getDescribedFunctionTemplate() &&
1206 "Default arg expressions are never formed in dependent cases.");
Douglas Gregor033f6752009-12-23 23:03:06 +00001207 return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
1208 cast<FunctionDecl>(E->getParam()->getDeclContext()),
1209 E->getParam());
Sebastian Redl14236c82009-11-08 13:56:19 +00001210}
1211
Douglas Gregor14cf7522010-04-30 18:55:50 +00001212QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
John McCall31f82722010-11-12 08:19:04 +00001213 FunctionProtoTypeLoc TL) {
Douglas Gregor14cf7522010-04-30 18:55:50 +00001214 // We need a local instantiation scope for this function prototype.
John McCall19c1bfd2010-08-25 05:32:35 +00001215 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
John McCall31f82722010-11-12 08:19:04 +00001216 return inherited::TransformFunctionProtoType(TLB, TL);
John McCall58f10c32010-03-11 09:03:00 +00001217}
1218
Douglas Gregor3024f072012-04-16 07:05:22 +00001219QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1220 FunctionProtoTypeLoc TL,
1221 CXXRecordDecl *ThisContext,
1222 unsigned ThisTypeQuals) {
1223 // We need a local instantiation scope for this function prototype.
1224 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1225 return inherited::TransformFunctionProtoType(TLB, TL, ThisContext,
1226 ThisTypeQuals);
1227}
1228
John McCall58f10c32010-03-11 09:03:00 +00001229ParmVarDecl *
Douglas Gregor715e4612011-01-14 22:40:04 +00001230TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
John McCall8fb0d9d2011-05-01 22:35:37 +00001231 int indexAdjustment,
Douglas Gregor0dd22bc2012-01-25 16:15:54 +00001232 llvm::Optional<unsigned> NumExpansions,
1233 bool ExpectParameterPack) {
John McCall8fb0d9d2011-05-01 22:35:37 +00001234 return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
Douglas Gregor0dd22bc2012-01-25 16:15:54 +00001235 NumExpansions, ExpectParameterPack);
John McCall58f10c32010-03-11 09:03:00 +00001236}
1237
Mike Stump11289f42009-09-09 15:08:12 +00001238QualType
John McCall550e0c22009-10-21 00:40:46 +00001239TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
John McCall31f82722010-11-12 08:19:04 +00001240 TemplateTypeParmTypeLoc TL) {
John McCall424cec92011-01-19 06:33:43 +00001241 const TemplateTypeParmType *T = TL.getTypePtr();
Douglas Gregor01afeef2009-08-28 20:31:08 +00001242 if (T->getDepth() < TemplateArgs.getNumLevels()) {
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001243 // Replace the template type parameter with its corresponding
1244 // template argument.
Mike Stump11289f42009-09-09 15:08:12 +00001245
1246 // If the corresponding template argument is NULL or doesn't exist, it's
1247 // because we are performing instantiation from explicitly-specified
1248 // template arguments in a function template class, but there were some
Douglas Gregore3f1f352009-07-01 00:28:38 +00001249 // arguments left unspecified.
John McCall550e0c22009-10-21 00:40:46 +00001250 if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
1251 TemplateTypeParmTypeLoc NewTL
1252 = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
1253 NewTL.setNameLoc(TL.getNameLoc());
1254 return TL.getType();
1255 }
Mike Stump11289f42009-09-09 15:08:12 +00001256
Douglas Gregor840bd6c2010-12-20 22:05:00 +00001257 TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1258
1259 if (T->isParameterPack()) {
1260 assert(Arg.getKind() == TemplateArgument::Pack &&
1261 "Missing argument pack");
1262
1263 if (getSema().ArgumentPackSubstitutionIndex == -1) {
Douglas Gregorada4b792011-01-14 02:55:32 +00001264 // We have the template argument pack, but we're not expanding the
1265 // enclosing pack expansion yet. Just save the template argument
1266 // pack for later substitution.
1267 QualType Result
1268 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1269 SubstTemplateTypeParmPackTypeLoc NewTL
1270 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
1271 NewTL.setNameLoc(TL.getNameLoc());
1272 return Result;
Douglas Gregor840bd6c2010-12-20 22:05:00 +00001273 }
1274
Douglas Gregora8bac7f2011-01-10 07:32:04 +00001275 assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
Douglas Gregor840bd6c2010-12-20 22:05:00 +00001276 Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1277 }
1278
1279 assert(Arg.getKind() == TemplateArgument::Type &&
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001280 "Template argument kind mismatch");
Douglas Gregor01afeef2009-08-28 20:31:08 +00001281
Douglas Gregor840bd6c2010-12-20 22:05:00 +00001282 QualType Replacement = Arg.getAsType();
John McCallcebee162009-10-18 09:09:24 +00001283
1284 // TODO: only do this uniquing once, at the start of instantiation.
John McCall550e0c22009-10-21 00:40:46 +00001285 QualType Result
1286 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1287 SubstTemplateTypeParmTypeLoc NewTL
1288 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1289 NewTL.setNameLoc(TL.getNameLoc());
1290 return Result;
Mike Stump11289f42009-09-09 15:08:12 +00001291 }
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001292
1293 // The template type parameter comes from an inner template (e.g.,
1294 // the template parameter list of a member template inside the
1295 // template we are instantiating). Create a new template type
1296 // parameter with the template "level" reduced by one.
Chandler Carruth08836322011-05-01 00:51:33 +00001297 TemplateTypeParmDecl *NewTTPDecl = 0;
1298 if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
1299 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1300 TransformDecl(TL.getNameLoc(), OldTTPDecl));
1301
John McCall550e0c22009-10-21 00:40:46 +00001302 QualType Result
1303 = getSema().Context.getTemplateTypeParmType(T->getDepth()
1304 - TemplateArgs.getNumLevels(),
1305 T->getIndex(),
1306 T->isParameterPack(),
Chandler Carruth08836322011-05-01 00:51:33 +00001307 NewTTPDecl);
John McCall550e0c22009-10-21 00:40:46 +00001308 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
1309 NewTL.setNameLoc(TL.getNameLoc());
1310 return Result;
Douglas Gregor17c0d7b2009-02-28 00:25:32 +00001311}
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001312
Douglas Gregorada4b792011-01-14 02:55:32 +00001313QualType
1314TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1315 TypeLocBuilder &TLB,
1316 SubstTemplateTypeParmPackTypeLoc TL) {
1317 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1318 // We aren't expanding the parameter pack, so just return ourselves.
1319 SubstTemplateTypeParmPackTypeLoc NewTL
1320 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
1321 NewTL.setNameLoc(TL.getNameLoc());
1322 return TL.getType();
1323 }
1324
1325 const TemplateArgument &ArgPack = TL.getTypePtr()->getArgumentPack();
1326 unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex;
1327 assert(Index < ArgPack.pack_size() && "Substitution index out-of-range");
1328
1329 QualType Result = ArgPack.pack_begin()[Index].getAsType();
1330 Result = getSema().Context.getSubstTemplateTypeParmType(
1331 TL.getTypePtr()->getReplacedParameter(),
1332 Result);
1333 SubstTemplateTypeParmTypeLoc NewTL
1334 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1335 NewTL.setNameLoc(TL.getNameLoc());
1336 return Result;
1337}
1338
John McCall76d824f2009-08-25 22:02:44 +00001339/// \brief Perform substitution on the type T with a given set of template
1340/// arguments.
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001341///
1342/// This routine substitutes the given template arguments into the
1343/// type T and produces the instantiated type.
1344///
1345/// \param T the type into which the template arguments will be
1346/// substituted. If this type is not dependent, it will be returned
1347/// immediately.
1348///
1349/// \param TemplateArgs the template arguments that will be
1350/// substituted for the top-level template parameters within T.
1351///
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001352/// \param Loc the location in the source code where this substitution
1353/// is being performed. It will typically be the location of the
1354/// declarator (if we're instantiating the type of some declaration)
1355/// or the location of the type in the source code (if, e.g., we're
1356/// instantiating the type of a cast expression).
1357///
1358/// \param Entity the name of the entity associated with a declaration
1359/// being instantiated (if any). May be empty to indicate that there
1360/// is no such entity (if, e.g., this is a type that occurs as part of
1361/// a cast expression) or that the entity has no name (e.g., an
1362/// unnamed function parameter).
1363///
1364/// \returns If the instantiation succeeds, the instantiated
1365/// type. Otherwise, produces diagnostics and returns a NULL type.
John McCallbcd03502009-12-07 02:54:59 +00001366TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
John McCall609459e2009-10-21 00:58:09 +00001367 const MultiLevelTemplateArgumentList &Args,
1368 SourceLocation Loc,
1369 DeclarationName Entity) {
1370 assert(!ActiveTemplateInstantiations.empty() &&
1371 "Cannot perform an instantiation without some context on the "
1372 "instantiation stack");
1373
Douglas Gregor678d76c2011-07-01 01:22:09 +00001374 if (!T->getType()->isInstantiationDependentType() &&
Douglas Gregor5a5073e2010-05-24 17:22:01 +00001375 !T->getType()->isVariablyModifiedType())
John McCall609459e2009-10-21 00:58:09 +00001376 return T;
1377
1378 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1379 return Instantiator.TransformType(T);
1380}
1381
Douglas Gregor5499af42011-01-05 23:12:31 +00001382TypeSourceInfo *Sema::SubstType(TypeLoc TL,
1383 const MultiLevelTemplateArgumentList &Args,
1384 SourceLocation Loc,
1385 DeclarationName Entity) {
1386 assert(!ActiveTemplateInstantiations.empty() &&
1387 "Cannot perform an instantiation without some context on the "
1388 "instantiation stack");
1389
1390 if (TL.getType().isNull())
1391 return 0;
1392
Douglas Gregor678d76c2011-07-01 01:22:09 +00001393 if (!TL.getType()->isInstantiationDependentType() &&
Douglas Gregor5499af42011-01-05 23:12:31 +00001394 !TL.getType()->isVariablyModifiedType()) {
1395 // FIXME: Make a copy of the TypeLoc data here, so that we can
1396 // return a new TypeSourceInfo. Inefficient!
1397 TypeLocBuilder TLB;
1398 TLB.pushFullCopy(TL);
1399 return TLB.getTypeSourceInfo(Context, TL.getType());
1400 }
1401
1402 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1403 TypeLocBuilder TLB;
1404 TLB.reserve(TL.getFullDataSize());
1405 QualType Result = Instantiator.TransformType(TLB, TL);
1406 if (Result.isNull())
1407 return 0;
1408
1409 return TLB.getTypeSourceInfo(Context, Result);
1410}
1411
John McCall609459e2009-10-21 00:58:09 +00001412/// Deprecated form of the above.
Mike Stump11289f42009-09-09 15:08:12 +00001413QualType Sema::SubstType(QualType T,
Douglas Gregor01afeef2009-08-28 20:31:08 +00001414 const MultiLevelTemplateArgumentList &TemplateArgs,
John McCall76d824f2009-08-25 22:02:44 +00001415 SourceLocation Loc, DeclarationName Entity) {
Douglas Gregor79cf6032009-03-10 20:44:00 +00001416 assert(!ActiveTemplateInstantiations.empty() &&
1417 "Cannot perform an instantiation without some context on the "
1418 "instantiation stack");
1419
Douglas Gregor5a5073e2010-05-24 17:22:01 +00001420 // If T is not a dependent type or a variably-modified type, there
1421 // is nothing to do.
Douglas Gregor678d76c2011-07-01 01:22:09 +00001422 if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001423 return T;
1424
Douglas Gregord6ff3322009-08-04 16:50:30 +00001425 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
1426 return Instantiator.TransformType(T);
Douglas Gregorfe1e1102009-02-27 19:31:52 +00001427}
Douglas Gregor463421d2009-03-03 04:44:36 +00001428
John McCallb29f78f2010-04-09 17:38:44 +00001429static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
Douglas Gregor678d76c2011-07-01 01:22:09 +00001430 if (T->getType()->isInstantiationDependentType() ||
1431 T->getType()->isVariablyModifiedType())
John McCallb29f78f2010-04-09 17:38:44 +00001432 return true;
1433
Abramo Bagnara6d810632010-12-14 22:11:44 +00001434 TypeLoc TL = T->getTypeLoc().IgnoreParens();
John McCallb29f78f2010-04-09 17:38:44 +00001435 if (!isa<FunctionProtoTypeLoc>(TL))
1436 return false;
1437
1438 FunctionProtoTypeLoc FP = cast<FunctionProtoTypeLoc>(TL);
1439 for (unsigned I = 0, E = FP.getNumArgs(); I != E; ++I) {
1440 ParmVarDecl *P = FP.getArg(I);
1441
Douglas Gregora7203e52011-05-09 20:45:16 +00001442 // The parameter's type as written might be dependent even if the
1443 // decayed type was not dependent.
1444 if (TypeSourceInfo *TSInfo = P->getTypeSourceInfo())
Douglas Gregor678d76c2011-07-01 01:22:09 +00001445 if (TSInfo->getType()->isInstantiationDependentType())
Douglas Gregora7203e52011-05-09 20:45:16 +00001446 return true;
1447
John McCallb29f78f2010-04-09 17:38:44 +00001448 // TODO: currently we always rebuild expressions. When we
1449 // properly get lazier about this, we should use the same
1450 // logic to avoid rebuilding prototypes here.
Douglas Gregor9cc278222011-01-05 21:14:17 +00001451 if (P->hasDefaultArg())
John McCallb29f78f2010-04-09 17:38:44 +00001452 return true;
1453 }
1454
1455 return false;
1456}
1457
1458/// A form of SubstType intended specifically for instantiating the
1459/// type of a FunctionDecl. Its purpose is solely to force the
1460/// instantiation of default-argument expressions.
1461TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
1462 const MultiLevelTemplateArgumentList &Args,
1463 SourceLocation Loc,
Douglas Gregor3024f072012-04-16 07:05:22 +00001464 DeclarationName Entity,
1465 CXXRecordDecl *ThisContext,
1466 unsigned ThisTypeQuals) {
John McCallb29f78f2010-04-09 17:38:44 +00001467 assert(!ActiveTemplateInstantiations.empty() &&
1468 "Cannot perform an instantiation without some context on the "
1469 "instantiation stack");
1470
1471 if (!NeedsInstantiationAsFunctionType(T))
1472 return T;
1473
1474 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1475
1476 TypeLocBuilder TLB;
1477
1478 TypeLoc TL = T->getTypeLoc();
1479 TLB.reserve(TL.getFullDataSize());
1480
Douglas Gregor3024f072012-04-16 07:05:22 +00001481 QualType Result;
1482
1483 if (FunctionProtoTypeLoc *Proto = dyn_cast<FunctionProtoTypeLoc>(&TL)) {
1484 Result = Instantiator.TransformFunctionProtoType(TLB, *Proto, ThisContext,
1485 ThisTypeQuals);
1486 } else {
1487 Result = Instantiator.TransformType(TLB, TL);
1488 }
John McCallb29f78f2010-04-09 17:38:44 +00001489 if (Result.isNull())
1490 return 0;
1491
1492 return TLB.getTypeSourceInfo(Context, Result);
1493}
1494
Douglas Gregor940bca72010-04-12 07:48:19 +00001495ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
Douglas Gregor715e4612011-01-14 22:40:04 +00001496 const MultiLevelTemplateArgumentList &TemplateArgs,
John McCall8fb0d9d2011-05-01 22:35:37 +00001497 int indexAdjustment,
Douglas Gregor0dd22bc2012-01-25 16:15:54 +00001498 llvm::Optional<unsigned> NumExpansions,
1499 bool ExpectParameterPack) {
Douglas Gregor940bca72010-04-12 07:48:19 +00001500 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
Douglas Gregor5499af42011-01-05 23:12:31 +00001501 TypeSourceInfo *NewDI = 0;
1502
Douglas Gregor5499af42011-01-05 23:12:31 +00001503 TypeLoc OldTL = OldDI->getTypeLoc();
1504 if (isa<PackExpansionTypeLoc>(OldTL)) {
1505 PackExpansionTypeLoc ExpansionTL = cast<PackExpansionTypeLoc>(OldTL);
Douglas Gregor5499af42011-01-05 23:12:31 +00001506
1507 // We have a function parameter pack. Substitute into the pattern of the
1508 // expansion.
1509 NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1510 OldParm->getLocation(), OldParm->getDeclName());
1511 if (!NewDI)
1512 return 0;
1513
1514 if (NewDI->getType()->containsUnexpandedParameterPack()) {
1515 // We still have unexpanded parameter packs, which means that
1516 // our function parameter is still a function parameter pack.
1517 // Therefore, make its type a pack expansion type.
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00001518 NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
Douglas Gregor715e4612011-01-14 22:40:04 +00001519 NumExpansions);
Douglas Gregor0dd22bc2012-01-25 16:15:54 +00001520 } else if (ExpectParameterPack) {
1521 // We expected to get a parameter pack but didn't (because the type
1522 // itself is not a pack expansion type), so complain. This can occur when
1523 // the substitution goes through an alias template that "loses" the
1524 // pack expansion.
1525 Diag(OldParm->getLocation(),
1526 diag::err_function_parameter_pack_without_parameter_packs)
1527 << NewDI->getType();
1528 return 0;
1529 }
Douglas Gregor5499af42011-01-05 23:12:31 +00001530 } else {
1531 NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
1532 OldParm->getDeclName());
1533 }
1534
Douglas Gregor940bca72010-04-12 07:48:19 +00001535 if (!NewDI)
1536 return 0;
1537
1538 if (NewDI->getType()->isVoidType()) {
1539 Diag(OldParm->getLocation(), diag::err_param_with_void_type);
1540 return 0;
1541 }
1542
1543 ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00001544 OldParm->getInnerLocStart(),
Douglas Gregor940bca72010-04-12 07:48:19 +00001545 OldParm->getLocation(),
Abramo Bagnaradff19302011-03-08 08:55:46 +00001546 OldParm->getIdentifier(),
1547 NewDI->getType(), NewDI,
Douglas Gregorc4df4072010-04-19 22:54:31 +00001548 OldParm->getStorageClass(),
1549 OldParm->getStorageClassAsWritten());
Douglas Gregor940bca72010-04-12 07:48:19 +00001550 if (!NewParm)
1551 return 0;
Douglas Gregor6044d692010-05-19 17:02:24 +00001552
Douglas Gregor940bca72010-04-12 07:48:19 +00001553 // Mark the (new) default argument as uninstantiated (if any).
1554 if (OldParm->hasUninstantiatedDefaultArg()) {
1555 Expr *Arg = OldParm->getUninstantiatedDefaultArg();
1556 NewParm->setUninstantiatedDefaultArg(Arg);
Douglas Gregor758cb672010-10-12 18:23:32 +00001557 } else if (OldParm->hasUnparsedDefaultArg()) {
1558 NewParm->setUnparsedDefaultArg();
1559 UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
Douglas Gregor940bca72010-04-12 07:48:19 +00001560 } else if (Expr *Arg = OldParm->getDefaultArg())
1561 NewParm->setUninstantiatedDefaultArg(Arg);
1562
1563 NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());
Douglas Gregor0dd22bc2012-01-25 16:15:54 +00001564
Douglas Gregorf3010112011-01-07 16:43:16 +00001565 if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
Richard Smith928be492012-01-25 02:14:59 +00001566 // Add the new parameter to the instantiated parameter pack.
Douglas Gregorf3010112011-01-07 16:43:16 +00001567 CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
1568 } else {
1569 // Introduce an Old -> New mapping
Douglas Gregor5499af42011-01-05 23:12:31 +00001570 CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
Douglas Gregorf3010112011-01-07 16:43:16 +00001571 }
Douglas Gregor5499af42011-01-05 23:12:31 +00001572
Argyrios Kyrtzidis3816ed42010-07-19 10:14:41 +00001573 // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
1574 // can be anything, is this right ?
Fariborz Jahanian714447b2010-07-13 21:05:02 +00001575 NewParm->setDeclContext(CurContext);
John McCall8fb0d9d2011-05-01 22:35:37 +00001576
1577 NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
1578 OldParm->getFunctionScopeIndex() + indexAdjustment);
Fariborz Jahaniana6c7efe2010-07-13 20:05:58 +00001579
Douglas Gregor940bca72010-04-12 07:48:19 +00001580 return NewParm;
1581}
1582
Douglas Gregordd472162011-01-07 00:20:55 +00001583/// \brief Substitute the given template arguments into the given set of
1584/// parameters, producing the set of parameter types that would be generated
1585/// from such a substitution.
1586bool Sema::SubstParmTypes(SourceLocation Loc,
1587 ParmVarDecl **Params, unsigned NumParams,
1588 const MultiLevelTemplateArgumentList &TemplateArgs,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001589 SmallVectorImpl<QualType> &ParamTypes,
1590 SmallVectorImpl<ParmVarDecl *> *OutParams) {
Douglas Gregordd472162011-01-07 00:20:55 +00001591 assert(!ActiveTemplateInstantiations.empty() &&
1592 "Cannot perform an instantiation without some context on the "
1593 "instantiation stack");
1594
1595 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
1596 DeclarationName());
1597 return Instantiator.TransformFunctionTypeParams(Loc, Params, NumParams, 0,
Douglas Gregorf3010112011-01-07 16:43:16 +00001598 ParamTypes, OutParams);
Douglas Gregordd472162011-01-07 00:20:55 +00001599}
1600
John McCall76d824f2009-08-25 22:02:44 +00001601/// \brief Perform substitution on the base class specifiers of the
1602/// given class template specialization.
Douglas Gregor463421d2009-03-03 04:44:36 +00001603///
1604/// Produces a diagnostic and returns true on error, returns false and
1605/// attaches the instantiated base classes to the class template
1606/// specialization if successful.
Mike Stump11289f42009-09-09 15:08:12 +00001607bool
John McCall76d824f2009-08-25 22:02:44 +00001608Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
1609 CXXRecordDecl *Pattern,
Douglas Gregor01afeef2009-08-28 20:31:08 +00001610 const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregor463421d2009-03-03 04:44:36 +00001611 bool Invalid = false;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001612 SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
Mike Stump11289f42009-09-09 15:08:12 +00001613 for (ClassTemplateSpecializationDecl::base_class_iterator
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001614 Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end();
Douglas Gregor2a72edd2009-03-10 18:52:44 +00001615 Base != BaseEnd; ++Base) {
Douglas Gregor463421d2009-03-03 04:44:36 +00001616 if (!Base->getType()->isDependentType()) {
Fariborz Jahanian5c14ec32009-07-22 17:41:53 +00001617 InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(*Base));
Douglas Gregor463421d2009-03-03 04:44:36 +00001618 continue;
1619 }
1620
Douglas Gregor752a5952011-01-03 22:36:02 +00001621 SourceLocation EllipsisLoc;
Douglas Gregorc52264e2011-03-02 02:04:06 +00001622 TypeSourceInfo *BaseTypeLoc;
Douglas Gregor752a5952011-01-03 22:36:02 +00001623 if (Base->isPackExpansion()) {
1624 // This is a pack expansion. See whether we should expand it now, or
1625 // wait until later.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001626 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregor752a5952011-01-03 22:36:02 +00001627 collectUnexpandedParameterPacks(Base->getTypeSourceInfo()->getTypeLoc(),
1628 Unexpanded);
1629 bool ShouldExpand = false;
Douglas Gregora8bac7f2011-01-10 07:32:04 +00001630 bool RetainExpansion = false;
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00001631 llvm::Optional<unsigned> NumExpansions;
Douglas Gregor752a5952011-01-03 22:36:02 +00001632 if (CheckParameterPacksForExpansion(Base->getEllipsisLoc(),
1633 Base->getSourceRange(),
David Blaikieb9c168a2011-09-22 02:34:54 +00001634 Unexpanded,
Douglas Gregor752a5952011-01-03 22:36:02 +00001635 TemplateArgs, ShouldExpand,
Douglas Gregora8bac7f2011-01-10 07:32:04 +00001636 RetainExpansion,
Douglas Gregor752a5952011-01-03 22:36:02 +00001637 NumExpansions)) {
Douglas Gregor752a5952011-01-03 22:36:02 +00001638 Invalid = true;
Douglas Gregor44e7df62011-01-04 00:32:56 +00001639 continue;
Douglas Gregor752a5952011-01-03 22:36:02 +00001640 }
1641
1642 // If we should expand this pack expansion now, do so.
1643 if (ShouldExpand) {
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00001644 for (unsigned I = 0; I != *NumExpansions; ++I) {
Douglas Gregor752a5952011-01-03 22:36:02 +00001645 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
1646
1647 TypeSourceInfo *BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1648 TemplateArgs,
1649 Base->getSourceRange().getBegin(),
1650 DeclarationName());
1651 if (!BaseTypeLoc) {
1652 Invalid = true;
1653 continue;
1654 }
1655
1656 if (CXXBaseSpecifier *InstantiatedBase
1657 = CheckBaseSpecifier(Instantiation,
1658 Base->getSourceRange(),
1659 Base->isVirtual(),
1660 Base->getAccessSpecifierAsWritten(),
1661 BaseTypeLoc,
1662 SourceLocation()))
1663 InstantiatedBases.push_back(InstantiatedBase);
1664 else
1665 Invalid = true;
1666 }
1667
1668 continue;
1669 }
1670
1671 // The resulting base specifier will (still) be a pack expansion.
1672 EllipsisLoc = Base->getEllipsisLoc();
Douglas Gregorc52264e2011-03-02 02:04:06 +00001673 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
1674 BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1675 TemplateArgs,
1676 Base->getSourceRange().getBegin(),
1677 DeclarationName());
1678 } else {
1679 BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1680 TemplateArgs,
1681 Base->getSourceRange().getBegin(),
1682 DeclarationName());
Douglas Gregor752a5952011-01-03 22:36:02 +00001683 }
1684
Nick Lewycky19b9f952010-07-26 16:56:01 +00001685 if (!BaseTypeLoc) {
Douglas Gregor463421d2009-03-03 04:44:36 +00001686 Invalid = true;
1687 continue;
1688 }
1689
1690 if (CXXBaseSpecifier *InstantiatedBase
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001691 = CheckBaseSpecifier(Instantiation,
Douglas Gregor463421d2009-03-03 04:44:36 +00001692 Base->getSourceRange(),
1693 Base->isVirtual(),
1694 Base->getAccessSpecifierAsWritten(),
Douglas Gregor752a5952011-01-03 22:36:02 +00001695 BaseTypeLoc,
1696 EllipsisLoc))
Douglas Gregor463421d2009-03-03 04:44:36 +00001697 InstantiatedBases.push_back(InstantiatedBase);
1698 else
1699 Invalid = true;
1700 }
1701
Douglas Gregor2a72edd2009-03-10 18:52:44 +00001702 if (!Invalid &&
Jay Foad7d0479f2009-05-21 09:52:38 +00001703 AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(),
Douglas Gregor463421d2009-03-03 04:44:36 +00001704 InstantiatedBases.size()))
1705 Invalid = true;
1706
1707 return Invalid;
1708}
1709
DeLesley Hutchins30398dd2012-01-20 22:50:54 +00001710// Defined via #include from SemaTemplateInstantiateDecl.cpp
Benjamin Kramerbf8da9d2012-02-06 11:13:08 +00001711namespace clang {
1712 namespace sema {
1713 Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
1714 const MultiLevelTemplateArgumentList &TemplateArgs);
1715 }
1716}
DeLesley Hutchins30398dd2012-01-20 22:50:54 +00001717
Richard Smith4b38ded2012-03-14 23:13:10 +00001718/// Determine whether we would be unable to instantiate this template (because
1719/// it either has no definition, or is in the process of being instantiated).
1720static bool DiagnoseUninstantiableTemplate(Sema &S,
1721 SourceLocation PointOfInstantiation,
1722 TagDecl *Instantiation,
1723 bool InstantiatedFromMember,
1724 TagDecl *Pattern,
1725 TagDecl *PatternDef,
1726 TemplateSpecializationKind TSK,
1727 bool Complain = true) {
1728 if (PatternDef && !PatternDef->isBeingDefined())
1729 return false;
1730
1731 if (!Complain || (PatternDef && PatternDef->isInvalidDecl())) {
1732 // Say nothing
1733 } else if (PatternDef) {
1734 assert(PatternDef->isBeingDefined());
1735 S.Diag(PointOfInstantiation,
1736 diag::err_template_instantiate_within_definition)
1737 << (TSK != TSK_ImplicitInstantiation)
1738 << S.Context.getTypeDeclType(Instantiation);
1739 // Not much point in noting the template declaration here, since
1740 // we're lexically inside it.
1741 Instantiation->setInvalidDecl();
1742 } else if (InstantiatedFromMember) {
1743 S.Diag(PointOfInstantiation,
1744 diag::err_implicit_instantiate_member_undefined)
1745 << S.Context.getTypeDeclType(Instantiation);
1746 S.Diag(Pattern->getLocation(), diag::note_member_of_template_here);
1747 } else {
1748 S.Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
1749 << (TSK != TSK_ImplicitInstantiation)
1750 << S.Context.getTypeDeclType(Instantiation);
1751 S.Diag(Pattern->getLocation(), diag::note_template_decl_here);
1752 }
1753
1754 // In general, Instantiation isn't marked invalid to get more than one
1755 // error for multiple undefined instantiations. But the code that does
1756 // explicit declaration -> explicit definition conversion can't handle
1757 // invalid declarations, so mark as invalid in that case.
1758 if (TSK == TSK_ExplicitInstantiationDeclaration)
1759 Instantiation->setInvalidDecl();
1760 return true;
1761}
1762
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001763/// \brief Instantiate the definition of a class from a given pattern.
1764///
1765/// \param PointOfInstantiation The point of instantiation within the
1766/// source code.
1767///
1768/// \param Instantiation is the declaration whose definition is being
1769/// instantiated. This will be either a class template specialization
1770/// or a member class of a class template specialization.
1771///
1772/// \param Pattern is the pattern from which the instantiation
1773/// occurs. This will be either the declaration of a class template or
1774/// the declaration of a member class of a class template.
1775///
1776/// \param TemplateArgs The template arguments to be substituted into
1777/// the pattern.
1778///
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00001779/// \param TSK the kind of implicit or explicit instantiation to perform.
Douglas Gregor8a2e6012009-08-24 15:23:48 +00001780///
1781/// \param Complain whether to complain if the class cannot be instantiated due
1782/// to the lack of a definition.
1783///
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001784/// \returns true if an error occurred, false otherwise.
1785bool
1786Sema::InstantiateClass(SourceLocation PointOfInstantiation,
1787 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregor01afeef2009-08-28 20:31:08 +00001788 const MultiLevelTemplateArgumentList &TemplateArgs,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00001789 TemplateSpecializationKind TSK,
Douglas Gregor8a2e6012009-08-24 15:23:48 +00001790 bool Complain) {
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001791 bool Invalid = false;
John McCall87a44eb2009-08-20 01:44:21 +00001792
Mike Stump11289f42009-09-09 15:08:12 +00001793 CXXRecordDecl *PatternDef
Douglas Gregor0a5a2212010-02-11 01:04:33 +00001794 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
Richard Smith4b38ded2012-03-14 23:13:10 +00001795 if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation,
1796 Instantiation->getInstantiatedFromMemberClass(),
1797 Pattern, PatternDef, TSK, Complain))
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001798 return true;
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001799 Pattern = PatternDef;
1800
Douglas Gregord6ba93d2009-10-15 15:54:05 +00001801 // \brief Record the point of instantiation.
1802 if (MemberSpecializationInfo *MSInfo
1803 = Instantiation->getMemberSpecializationInfo()) {
1804 MSInfo->setTemplateSpecializationKind(TSK);
1805 MSInfo->setPointOfInstantiation(PointOfInstantiation);
Douglas Gregoref6ab412009-10-27 06:26:26 +00001806 } else if (ClassTemplateSpecializationDecl *Spec
Nico Weber3ffc4c92011-12-20 20:32:49 +00001807 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
Douglas Gregoref6ab412009-10-27 06:26:26 +00001808 Spec->setTemplateSpecializationKind(TSK);
1809 Spec->setPointOfInstantiation(PointOfInstantiation);
Douglas Gregord6ba93d2009-10-15 15:54:05 +00001810 }
1811
Douglas Gregorf3430ae2009-03-25 21:23:52 +00001812 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001813 if (Inst)
1814 return true;
1815
1816 // Enter the scope of this instantiation. We don't use
1817 // PushDeclContext because we don't have a scope.
John McCall80e58cd2010-04-29 00:35:03 +00001818 ContextRAII SavedContext(*this, Instantiation);
Douglas Gregor17158422010-05-12 17:27:19 +00001819 EnterExpressionEvaluationContext EvalContext(*this,
John McCallfaf5fb42010-08-26 23:41:50 +00001820 Sema::PotentiallyEvaluated);
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001821
Douglas Gregor51121572010-03-24 01:33:17 +00001822 // If this is an instantiation of a local class, merge this local
1823 // instantiation scope with the enclosing scope. Otherwise, every
1824 // instantiation of a class has its own local instantiation scope.
1825 bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
John McCall19c1bfd2010-08-25 05:32:35 +00001826 LocalInstantiationScope Scope(*this, MergeWithParentScope);
Douglas Gregor51121572010-03-24 01:33:17 +00001827
John McCall6602bb12010-08-01 02:01:53 +00001828 // Pull attributes from the pattern onto the instantiation.
1829 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
1830
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001831 // Start the definition of this instantiation.
1832 Instantiation->startDefinition();
Douglas Gregore9029562010-05-06 00:28:52 +00001833
1834 Instantiation->setTagKind(Pattern->getTagKind());
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001835
John McCall76d824f2009-08-25 22:02:44 +00001836 // Do substitution on the base class specifiers.
1837 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001838 Invalid = true;
1839
Douglas Gregor869853e2010-11-10 19:44:59 +00001840 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001841 SmallVector<Decl*, 4> Fields;
1842 SmallVector<std::pair<FieldDecl*, FieldDecl*>, 4>
Richard Smith938f40b2011-06-11 17:19:42 +00001843 FieldsWithMemberInitializers;
DeLesley Hutchins30398dd2012-01-20 22:50:54 +00001844 // Delay instantiation of late parsed attributes.
1845 LateInstantiatedAttrVec LateAttrs;
1846 Instantiator.enableLateAttributeInstantiation(&LateAttrs);
1847
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001848 for (RecordDecl::decl_iterator Member = Pattern->decls_begin(),
Mike Stump11289f42009-09-09 15:08:12 +00001849 MemberEnd = Pattern->decls_end();
Douglas Gregorbcced4e2009-04-09 21:40:53 +00001850 Member != MemberEnd; ++Member) {
Argyrios Kyrtzidis9a94d9b2010-11-04 03:18:57 +00001851 // Don't instantiate members not belonging in this semantic context.
1852 // e.g. for:
1853 // @code
1854 // template <int i> class A {
1855 // class B *g;
1856 // };
1857 // @endcode
1858 // 'class B' has the template as lexical context but semantically it is
1859 // introduced in namespace scope.
1860 if ((*Member)->getDeclContext() != Pattern)
1861 continue;
1862
Douglas Gregor869853e2010-11-10 19:44:59 +00001863 if ((*Member)->isInvalidDecl()) {
1864 Invalid = true;
1865 continue;
1866 }
1867
1868 Decl *NewMember = Instantiator.Visit(*Member);
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001869 if (NewMember) {
Richard Smith938f40b2011-06-11 17:19:42 +00001870 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
John McCall48871652010-08-21 09:40:31 +00001871 Fields.push_back(Field);
Richard Smith938f40b2011-06-11 17:19:42 +00001872 FieldDecl *OldField = cast<FieldDecl>(*Member);
1873 if (OldField->getInClassInitializer())
1874 FieldsWithMemberInitializers.push_back(std::make_pair(OldField,
1875 Field));
Richard Smith7d137e32012-03-23 03:33:32 +00001876 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
1877 // C++11 [temp.inst]p1: The implicit instantiation of a class template
1878 // specialization causes the implicit instantiation of the definitions
1879 // of unscoped member enumerations.
1880 // Record a point of instantiation for this implicit instantiation.
Richard Smithb66d7772012-03-23 23:09:08 +00001881 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
1882 Enum->isCompleteDefinition()) {
Richard Smith7d137e32012-03-23 03:33:32 +00001883 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
1884 assert(MSInfo && "no spec info for member enum specialization");
1885 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
1886 MSInfo->setPointOfInstantiation(PointOfInstantiation);
1887 }
1888 }
1889
1890 if (NewMember->isInvalidDecl())
Eli Friedmand0e8de22009-12-07 00:22:08 +00001891 Invalid = true;
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001892 } else {
1893 // FIXME: Eventually, a NULL return will mean that one of the
Mike Stump87c57ac2009-05-16 07:39:55 +00001894 // instantiations was a semantic disaster, and we'll want to set Invalid =
1895 // true. For now, we expect to skip some members that we can't yet handle.
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001896 }
1897 }
1898
1899 // Finish checking fields.
David Blaikie751c5582011-09-22 02:58:26 +00001900 ActOnFields(0, Instantiation->getLocation(), Instantiation, Fields,
1901 SourceLocation(), SourceLocation(), 0);
Douglas Gregor0be31a22010-07-02 17:43:08 +00001902 CheckCompletedCXXClass(Instantiation);
Richard Smith938f40b2011-06-11 17:19:42 +00001903
1904 // Attach any in-class member initializers now the class is complete.
Douglas Gregor3024f072012-04-16 07:05:22 +00001905 {
1906 // C++11 [expr.prim.general]p4:
1907 // Otherwise, if a member-declarator declares a non-static data member
1908 // (9.2) of a class X, the expression this is a prvalue of type "pointer
1909 // to X" within the optional brace-or-equal-initializer. It shall not
1910 // appear elsewhere in the member-declarator.
1911 CXXThisScopeRAII ThisScope(*this, Instantiation, (unsigned)0);
1912
1913 for (unsigned I = 0, N = FieldsWithMemberInitializers.size(); I != N; ++I) {
1914 FieldDecl *OldField = FieldsWithMemberInitializers[I].first;
1915 FieldDecl *NewField = FieldsWithMemberInitializers[I].second;
1916 Expr *OldInit = OldField->getInClassInitializer();
Richard Smith938f40b2011-06-11 17:19:42 +00001917
Douglas Gregor3024f072012-04-16 07:05:22 +00001918 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
1919 /*CXXDirectInit=*/false);
1920 if (NewInit.isInvalid())
1921 NewField->setInvalidDecl();
1922 else {
1923 Expr *Init = NewInit.take();
1924 assert(Init && "no-argument initializer in class");
1925 assert(!isa<ParenListExpr>(Init) && "call-style init in class");
1926 ActOnCXXInClassMemberInitializer(NewField,
1927 Init->getSourceRange().getBegin(),
1928 Init);
1929 }
Richard Smithe3daab22011-07-20 00:12:52 +00001930 }
Richard Smith938f40b2011-06-11 17:19:42 +00001931 }
DeLesley Hutchins30398dd2012-01-20 22:50:54 +00001932 // Instantiate late parsed attributes, and attach them to their decls.
1933 // See Sema::InstantiateAttrs
1934 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
1935 E = LateAttrs.end(); I != E; ++I) {
1936 assert(CurrentInstantiationScope == Instantiator.getStartingScope());
1937 CurrentInstantiationScope = I->Scope;
1938 Attr *NewAttr =
1939 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
1940 I->NewDecl->addAttr(NewAttr);
1941 LocalInstantiationScope::deleteScopes(I->Scope,
1942 Instantiator.getStartingScope());
1943 }
1944 Instantiator.disableLateAttributeInstantiation();
1945 LateAttrs.clear();
1946
Richard Smith938f40b2011-06-11 17:19:42 +00001947 if (!FieldsWithMemberInitializers.empty())
1948 ActOnFinishDelayedMemberInitializers(Instantiation);
1949
Abramo Bagnara12dcbf32011-11-18 08:08:52 +00001950 if (TSK == TSK_ImplicitInstantiation) {
Argyrios Kyrtzidise3789482012-02-11 01:59:57 +00001951 Instantiation->setLocation(Pattern->getLocation());
Abramo Bagnara12dcbf32011-11-18 08:08:52 +00001952 Instantiation->setLocStart(Pattern->getInnerLocStart());
Abramo Bagnarafd3a4552011-10-03 20:34:03 +00001953 Instantiation->setRBraceLoc(Pattern->getRBraceLoc());
Abramo Bagnara12dcbf32011-11-18 08:08:52 +00001954 }
Abramo Bagnarafd3a4552011-10-03 20:34:03 +00001955
Douglas Gregor3c74d412009-10-14 20:14:33 +00001956 if (Instantiation->isInvalidDecl())
1957 Invalid = true;
Douglas Gregor869853e2010-11-10 19:44:59 +00001958 else {
1959 // Instantiate any out-of-line class template partial
1960 // specializations now.
1961 for (TemplateDeclInstantiator::delayed_partial_spec_iterator
1962 P = Instantiator.delayed_partial_spec_begin(),
1963 PEnd = Instantiator.delayed_partial_spec_end();
1964 P != PEnd; ++P) {
1965 if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
1966 P->first,
1967 P->second)) {
1968 Invalid = true;
1969 break;
1970 }
1971 }
1972 }
1973
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001974 // Exit the scope of this instantiation.
John McCall80e58cd2010-04-29 00:35:03 +00001975 SavedContext.pop();
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001976
Douglas Gregor88d292c2010-05-13 16:44:06 +00001977 if (!Invalid) {
Douglas Gregor28ad4b52009-05-26 20:50:29 +00001978 Consumer.HandleTagDeclDefinition(Instantiation);
1979
Douglas Gregor88d292c2010-05-13 16:44:06 +00001980 // Always emit the vtable for an explicit instantiation definition
1981 // of a polymorphic class template specialization.
1982 if (TSK == TSK_ExplicitInstantiationDefinition)
1983 MarkVTableUsed(PointOfInstantiation, Instantiation, true);
1984 }
1985
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001986 return Invalid;
1987}
1988
Richard Smith4b38ded2012-03-14 23:13:10 +00001989/// \brief Instantiate the definition of an enum from a given pattern.
1990///
1991/// \param PointOfInstantiation The point of instantiation within the
1992/// source code.
1993/// \param Instantiation is the declaration whose definition is being
1994/// instantiated. This will be a member enumeration of a class
1995/// temploid specialization, or a local enumeration within a
1996/// function temploid specialization.
1997/// \param Pattern The templated declaration from which the instantiation
1998/// occurs.
1999/// \param TemplateArgs The template arguments to be substituted into
2000/// the pattern.
2001/// \param TSK The kind of implicit or explicit instantiation to perform.
2002///
2003/// \return \c true if an error occurred, \c false otherwise.
2004bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2005 EnumDecl *Instantiation, EnumDecl *Pattern,
2006 const MultiLevelTemplateArgumentList &TemplateArgs,
2007 TemplateSpecializationKind TSK) {
2008 EnumDecl *PatternDef = Pattern->getDefinition();
2009 if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation,
2010 Instantiation->getInstantiatedFromMemberEnum(),
2011 Pattern, PatternDef, TSK,/*Complain*/true))
2012 return true;
2013 Pattern = PatternDef;
2014
2015 // Record the point of instantiation.
2016 if (MemberSpecializationInfo *MSInfo
2017 = Instantiation->getMemberSpecializationInfo()) {
2018 MSInfo->setTemplateSpecializationKind(TSK);
2019 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2020 }
2021
2022 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2023 if (Inst)
2024 return true;
2025
2026 // Enter the scope of this instantiation. We don't use
2027 // PushDeclContext because we don't have a scope.
2028 ContextRAII SavedContext(*this, Instantiation);
2029 EnterExpressionEvaluationContext EvalContext(*this,
2030 Sema::PotentiallyEvaluated);
2031
2032 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2033
2034 // Pull attributes from the pattern onto the instantiation.
2035 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2036
2037 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2038 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2039
2040 // Exit the scope of this instantiation.
2041 SavedContext.pop();
2042
2043 return Instantiation->isInvalidDecl();
2044}
2045
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002046namespace {
2047 /// \brief A partial specialization whose template arguments have matched
2048 /// a given template-id.
2049 struct PartialSpecMatchResult {
2050 ClassTemplatePartialSpecializationDecl *Partial;
2051 TemplateArgumentList *Args;
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002052 };
2053}
2054
Mike Stump11289f42009-09-09 15:08:12 +00002055bool
Douglas Gregor463421d2009-03-03 04:44:36 +00002056Sema::InstantiateClassTemplateSpecialization(
Douglas Gregoref6ab412009-10-27 06:26:26 +00002057 SourceLocation PointOfInstantiation,
Douglas Gregor463421d2009-03-03 04:44:36 +00002058 ClassTemplateSpecializationDecl *ClassTemplateSpec,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002059 TemplateSpecializationKind TSK,
Douglas Gregor8a2e6012009-08-24 15:23:48 +00002060 bool Complain) {
Douglas Gregor463421d2009-03-03 04:44:36 +00002061 // Perform the actual instantiation on the canonical declaration.
2062 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
Argyrios Kyrtzidis6b7e3762009-07-18 00:34:25 +00002063 ClassTemplateSpec->getCanonicalDecl());
Douglas Gregor463421d2009-03-03 04:44:36 +00002064
Douglas Gregor4aa04b12009-09-11 21:19:12 +00002065 // Check whether we have already instantiated or specialized this class
2066 // template specialization.
2067 if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) {
2068 if (ClassTemplateSpec->getSpecializationKind() ==
2069 TSK_ExplicitInstantiationDeclaration &&
2070 TSK == TSK_ExplicitInstantiationDefinition) {
2071 // An explicit instantiation definition follows an explicit instantiation
2072 // declaration (C++0x [temp.explicit]p10); go ahead and perform the
2073 // explicit instantiation.
2074 ClassTemplateSpec->setSpecializationKind(TSK);
Douglas Gregor88d292c2010-05-13 16:44:06 +00002075
2076 // If this is an explicit instantiation definition, mark the
2077 // vtable as used.
Nico Weber3ffc4c92011-12-20 20:32:49 +00002078 if (TSK == TSK_ExplicitInstantiationDefinition &&
2079 !ClassTemplateSpec->isInvalidDecl())
Douglas Gregor88d292c2010-05-13 16:44:06 +00002080 MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true);
2081
Douglas Gregor4aa04b12009-09-11 21:19:12 +00002082 return false;
2083 }
2084
2085 // We can only instantiate something that hasn't already been
2086 // instantiated or specialized. Fail without any diagnostics: our
2087 // caller will provide an error message.
Douglas Gregor463421d2009-03-03 04:44:36 +00002088 return true;
Douglas Gregor4aa04b12009-09-11 21:19:12 +00002089 }
Douglas Gregor463421d2009-03-03 04:44:36 +00002090
Douglas Gregor00a511f2009-09-15 16:51:42 +00002091 if (ClassTemplateSpec->isInvalidDecl())
2092 return true;
2093
Douglas Gregor463421d2009-03-03 04:44:36 +00002094 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
Douglas Gregor01afeef2009-08-28 20:31:08 +00002095 CXXRecordDecl *Pattern = 0;
Douglas Gregor2373c592009-05-31 09:31:02 +00002096
Douglas Gregor170bc422009-06-12 22:31:52 +00002097 // C++ [temp.class.spec.match]p1:
2098 // When a class template is used in a context that requires an
2099 // instantiation of the class, it is necessary to determine
2100 // whether the instantiation is to be generated using the primary
2101 // template or one of the partial specializations. This is done by
2102 // matching the template arguments of the class template
2103 // specialization with the template argument lists of the partial
2104 // specializations.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002105 typedef PartialSpecMatchResult MatchResult;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002106 SmallVector<MatchResult, 4> Matched;
2107 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
Douglas Gregor407e9612010-04-30 05:56:50 +00002108 Template->getPartialSpecializations(PartialSpecs);
2109 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2110 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
John McCallbc077cf2010-02-08 23:07:23 +00002111 TemplateDeductionInfo Info(Context, PointOfInstantiation);
Douglas Gregor181aa4a2009-06-12 18:26:56 +00002112 if (TemplateDeductionResult Result
Douglas Gregor407e9612010-04-30 05:56:50 +00002113 = DeduceTemplateArguments(Partial,
Douglas Gregor181aa4a2009-06-12 18:26:56 +00002114 ClassTemplateSpec->getTemplateArgs(),
2115 Info)) {
2116 // FIXME: Store the failed-deduction information for use in
2117 // diagnostics, later.
2118 (void)Result;
2119 } else {
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002120 Matched.push_back(PartialSpecMatchResult());
2121 Matched.back().Partial = Partial;
2122 Matched.back().Args = Info.take();
Douglas Gregor181aa4a2009-06-12 18:26:56 +00002123 }
Douglas Gregor2373c592009-05-31 09:31:02 +00002124 }
2125
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002126 // If we're dealing with a member template where the template parameters
2127 // have been instantiated, this provides the original template parameters
2128 // from which the member template's parameters were instantiated.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002129 SmallVector<const NamedDecl *, 4> InstantiatedTemplateParameters;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002130
Douglas Gregor21610382009-10-29 00:04:11 +00002131 if (Matched.size() >= 1) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002132 SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
Douglas Gregor21610382009-10-29 00:04:11 +00002133 if (Matched.size() == 1) {
2134 // -- If exactly one matching specialization is found, the
2135 // instantiation is generated from that specialization.
2136 // We don't need to do anything for this.
2137 } else {
2138 // -- If more than one matching specialization is found, the
2139 // partial order rules (14.5.4.2) are used to determine
2140 // whether one of the specializations is more specialized
2141 // than the others. If none of the specializations is more
2142 // specialized than all of the other matching
2143 // specializations, then the use of the class template is
2144 // ambiguous and the program is ill-formed.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002145 for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
Douglas Gregor21610382009-10-29 00:04:11 +00002146 PEnd = Matched.end();
2147 P != PEnd; ++P) {
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002148 if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
John McCallbc077cf2010-02-08 23:07:23 +00002149 PointOfInstantiation)
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002150 == P->Partial)
Douglas Gregor21610382009-10-29 00:04:11 +00002151 Best = P;
Douglas Gregorbe999392009-09-15 16:23:51 +00002152 }
Douglas Gregorbe999392009-09-15 16:23:51 +00002153
Douglas Gregor21610382009-10-29 00:04:11 +00002154 // Determine if the best partial specialization is more specialized than
2155 // the others.
2156 bool Ambiguous = false;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002157 for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
Douglas Gregorbe999392009-09-15 16:23:51 +00002158 PEnd = Matched.end();
Douglas Gregor21610382009-10-29 00:04:11 +00002159 P != PEnd; ++P) {
2160 if (P != Best &&
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002161 getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
John McCallbc077cf2010-02-08 23:07:23 +00002162 PointOfInstantiation)
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002163 != Best->Partial) {
Douglas Gregor21610382009-10-29 00:04:11 +00002164 Ambiguous = true;
2165 break;
2166 }
2167 }
2168
2169 if (Ambiguous) {
2170 // Partial ordering did not produce a clear winner. Complain.
2171 ClassTemplateSpec->setInvalidDecl();
2172 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2173 << ClassTemplateSpec;
2174
2175 // Print the matching partial specializations.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002176 for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
Douglas Gregor21610382009-10-29 00:04:11 +00002177 PEnd = Matched.end();
2178 P != PEnd; ++P)
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002179 Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2180 << getTemplateArgumentBindingsText(
2181 P->Partial->getTemplateParameters(),
2182 *P->Args);
Douglas Gregor01afeef2009-08-28 20:31:08 +00002183
Douglas Gregor21610382009-10-29 00:04:11 +00002184 return true;
2185 }
Douglas Gregorbe999392009-09-15 16:23:51 +00002186 }
2187
2188 // Instantiate using the best class template partial specialization.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002189 ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
Douglas Gregor21610382009-10-29 00:04:11 +00002190 while (OrigPartialSpec->getInstantiatedFromMember()) {
2191 // If we've found an explicit specialization of this class template,
2192 // stop here and use that as the pattern.
2193 if (OrigPartialSpec->isMemberSpecialization())
2194 break;
2195
2196 OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember();
2197 }
2198
2199 Pattern = OrigPartialSpec;
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00002200 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
Douglas Gregor170bc422009-06-12 22:31:52 +00002201 } else {
2202 // -- If no matches are found, the instantiation is generated
2203 // from the primary template.
Douglas Gregor01afeef2009-08-28 20:31:08 +00002204 ClassTemplateDecl *OrigTemplate = Template;
Douglas Gregorcf915552009-10-13 16:30:37 +00002205 while (OrigTemplate->getInstantiatedFromMemberTemplate()) {
2206 // If we've found an explicit specialization of this class template,
2207 // stop here and use that as the pattern.
2208 if (OrigTemplate->isMemberSpecialization())
2209 break;
2210
Douglas Gregor01afeef2009-08-28 20:31:08 +00002211 OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate();
Douglas Gregorcf915552009-10-13 16:30:37 +00002212 }
2213
Douglas Gregor01afeef2009-08-28 20:31:08 +00002214 Pattern = OrigTemplate->getTemplatedDecl();
Douglas Gregor2373c592009-05-31 09:31:02 +00002215 }
Douglas Gregor463421d2009-03-03 04:44:36 +00002216
Douglas Gregoref6ab412009-10-27 06:26:26 +00002217 bool Result = InstantiateClass(PointOfInstantiation, ClassTemplateSpec,
2218 Pattern,
2219 getTemplateInstantiationArgs(ClassTemplateSpec),
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002220 TSK,
Douglas Gregor8a2e6012009-08-24 15:23:48 +00002221 Complain);
Mike Stump11289f42009-09-09 15:08:12 +00002222
Douglas Gregorb7ae10f2009-06-05 00:53:49 +00002223 return Result;
Douglas Gregor463421d2009-03-03 04:44:36 +00002224}
Douglas Gregor90a1a652009-03-19 17:26:29 +00002225
John McCall76d824f2009-08-25 22:02:44 +00002226/// \brief Instantiates the definitions of all of the member
2227/// of the given class, which is an instantiation of a class template
2228/// or a member class of a template.
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002229void
2230Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002231 CXXRecordDecl *Instantiation,
2232 const MultiLevelTemplateArgumentList &TemplateArgs,
2233 TemplateSpecializationKind TSK) {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002234 for (DeclContext::decl_iterator D = Instantiation->decls_begin(),
2235 DEnd = Instantiation->decls_end();
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002236 D != DEnd; ++D) {
Douglas Gregor1d957a32009-10-27 18:42:08 +00002237 bool SuppressNew = false;
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002238 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) {
Douglas Gregor1d957a32009-10-27 18:42:08 +00002239 if (FunctionDecl *Pattern
2240 = Function->getInstantiatedFromMemberFunction()) {
2241 MemberSpecializationInfo *MSInfo
2242 = Function->getMemberSpecializationInfo();
2243 assert(MSInfo && "No member specialization information?");
Douglas Gregor06aa50412010-04-09 21:02:29 +00002244 if (MSInfo->getTemplateSpecializationKind()
2245 == TSK_ExplicitSpecialization)
2246 continue;
2247
Douglas Gregor1d957a32009-10-27 18:42:08 +00002248 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2249 Function,
2250 MSInfo->getTemplateSpecializationKind(),
Nico Weberd75488d2010-09-27 21:02:09 +00002251 MSInfo->getPointOfInstantiation(),
Douglas Gregor1d957a32009-10-27 18:42:08 +00002252 SuppressNew) ||
2253 SuppressNew)
Douglas Gregorbbe8f462009-10-08 15:14:33 +00002254 continue;
2255
Alexis Hunt4a8ea102011-05-06 20:44:56 +00002256 if (Function->isDefined())
Douglas Gregor1d957a32009-10-27 18:42:08 +00002257 continue;
2258
2259 if (TSK == TSK_ExplicitInstantiationDefinition) {
2260 // C++0x [temp.explicit]p8:
2261 // An explicit instantiation definition that names a class template
2262 // specialization explicitly instantiates the class template
2263 // specialization and is only an explicit instantiation definition
2264 // of members whose definition is visible at the point of
2265 // instantiation.
Alexis Hunt4a8ea102011-05-06 20:44:56 +00002266 if (!Pattern->isDefined())
Douglas Gregor1d957a32009-10-27 18:42:08 +00002267 continue;
2268
2269 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2270
2271 InstantiateFunctionDefinition(PointOfInstantiation, Function);
2272 } else {
2273 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2274 }
Douglas Gregorbbe8f462009-10-08 15:14:33 +00002275 }
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002276 } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) {
Douglas Gregor86d142a2009-10-08 07:24:58 +00002277 if (Var->isStaticDataMember()) {
Douglas Gregor1d957a32009-10-27 18:42:08 +00002278 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
2279 assert(MSInfo && "No member specialization information?");
Douglas Gregor06aa50412010-04-09 21:02:29 +00002280 if (MSInfo->getTemplateSpecializationKind()
2281 == TSK_ExplicitSpecialization)
2282 continue;
2283
Douglas Gregor1d957a32009-10-27 18:42:08 +00002284 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2285 Var,
2286 MSInfo->getTemplateSpecializationKind(),
Nico Weberd75488d2010-09-27 21:02:09 +00002287 MSInfo->getPointOfInstantiation(),
Douglas Gregor1d957a32009-10-27 18:42:08 +00002288 SuppressNew) ||
2289 SuppressNew)
Douglas Gregorbbe8f462009-10-08 15:14:33 +00002290 continue;
2291
Douglas Gregor1d957a32009-10-27 18:42:08 +00002292 if (TSK == TSK_ExplicitInstantiationDefinition) {
2293 // C++0x [temp.explicit]p8:
2294 // An explicit instantiation definition that names a class template
2295 // specialization explicitly instantiates the class template
2296 // specialization and is only an explicit instantiation definition
2297 // of members whose definition is visible at the point of
2298 // instantiation.
2299 if (!Var->getInstantiatedFromStaticDataMember()
2300 ->getOutOfLineDefinition())
2301 continue;
2302
2303 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
Douglas Gregor86d142a2009-10-08 07:24:58 +00002304 InstantiateStaticDataMemberDefinition(PointOfInstantiation, Var);
Douglas Gregor1d957a32009-10-27 18:42:08 +00002305 } else {
2306 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2307 }
2308 }
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002309 } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) {
Douglas Gregor1da22252010-04-18 18:11:38 +00002310 // Always skip the injected-class-name, along with any
2311 // redeclarations of nested classes, since both would cause us
2312 // to try to instantiate the members of a class twice.
Douglas Gregorec9fd132012-01-14 16:38:05 +00002313 if (Record->isInjectedClassName() || Record->getPreviousDecl())
Douglas Gregord801b062009-10-07 23:56:10 +00002314 continue;
2315
Douglas Gregor1d957a32009-10-27 18:42:08 +00002316 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
2317 assert(MSInfo && "No member specialization information?");
Douglas Gregor06aa50412010-04-09 21:02:29 +00002318
2319 if (MSInfo->getTemplateSpecializationKind()
2320 == TSK_ExplicitSpecialization)
2321 continue;
Nico Weberd75488d2010-09-27 21:02:09 +00002322
Douglas Gregor1d957a32009-10-27 18:42:08 +00002323 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2324 Record,
2325 MSInfo->getTemplateSpecializationKind(),
Nico Weberd75488d2010-09-27 21:02:09 +00002326 MSInfo->getPointOfInstantiation(),
Douglas Gregor1d957a32009-10-27 18:42:08 +00002327 SuppressNew) ||
2328 SuppressNew)
Douglas Gregorbbe8f462009-10-08 15:14:33 +00002329 continue;
2330
Douglas Gregor1d957a32009-10-27 18:42:08 +00002331 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
2332 assert(Pattern && "Missing instantiated-from-template information");
2333
Douglas Gregor0a5a2212010-02-11 01:04:33 +00002334 if (!Record->getDefinition()) {
2335 if (!Pattern->getDefinition()) {
Douglas Gregor1d957a32009-10-27 18:42:08 +00002336 // C++0x [temp.explicit]p8:
2337 // An explicit instantiation definition that names a class template
2338 // specialization explicitly instantiates the class template
2339 // specialization and is only an explicit instantiation definition
2340 // of members whose definition is visible at the point of
2341 // instantiation.
2342 if (TSK == TSK_ExplicitInstantiationDeclaration) {
2343 MSInfo->setTemplateSpecializationKind(TSK);
2344 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2345 }
2346
2347 continue;
2348 }
2349
2350 InstantiateClass(PointOfInstantiation, Record, Pattern,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002351 TemplateArgs,
2352 TSK);
Nico Weberd75488d2010-09-27 21:02:09 +00002353 } else {
2354 if (TSK == TSK_ExplicitInstantiationDefinition &&
2355 Record->getTemplateSpecializationKind() ==
2356 TSK_ExplicitInstantiationDeclaration) {
2357 Record->setTemplateSpecializationKind(TSK);
2358 MarkVTableUsed(PointOfInstantiation, Record, true);
2359 }
Douglas Gregor1d957a32009-10-27 18:42:08 +00002360 }
Douglas Gregorc093c1d2009-10-08 01:19:17 +00002361
Douglas Gregor0a5a2212010-02-11 01:04:33 +00002362 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
Douglas Gregor1d957a32009-10-27 18:42:08 +00002363 if (Pattern)
2364 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
2365 TSK);
Richard Smith4b38ded2012-03-14 23:13:10 +00002366 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(*D)) {
2367 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
2368 assert(MSInfo && "No member specialization information?");
2369
2370 if (MSInfo->getTemplateSpecializationKind()
2371 == TSK_ExplicitSpecialization)
2372 continue;
2373
2374 if (CheckSpecializationInstantiationRedecl(
2375 PointOfInstantiation, TSK, Enum,
2376 MSInfo->getTemplateSpecializationKind(),
2377 MSInfo->getPointOfInstantiation(), SuppressNew) ||
2378 SuppressNew)
2379 continue;
2380
2381 if (Enum->getDefinition())
2382 continue;
2383
2384 EnumDecl *Pattern = Enum->getInstantiatedFromMemberEnum();
2385 assert(Pattern && "Missing instantiated-from-template information");
2386
2387 if (TSK == TSK_ExplicitInstantiationDefinition) {
2388 if (!Pattern->getDefinition())
2389 continue;
2390
2391 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2392 } else {
2393 MSInfo->setTemplateSpecializationKind(TSK);
2394 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2395 }
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002396 }
2397 }
2398}
2399
2400/// \brief Instantiate the definitions of all of the members of the
2401/// given class template specialization, which was named as part of an
2402/// explicit instantiation.
Mike Stump11289f42009-09-09 15:08:12 +00002403void
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002404Sema::InstantiateClassTemplateSpecializationMembers(
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002405 SourceLocation PointOfInstantiation,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002406 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2407 TemplateSpecializationKind TSK) {
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002408 // C++0x [temp.explicit]p7:
2409 // An explicit instantiation that names a class template
2410 // specialization is an explicit instantion of the same kind
2411 // (declaration or definition) of each of its members (not
2412 // including members inherited from base classes) that has not
2413 // been previously explicitly specialized in the translation unit
2414 // containing the explicit instantiation, except as described
2415 // below.
2416 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002417 getTemplateInstantiationArgs(ClassTemplateSpec),
2418 TSK);
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00002419}
2420
John McCalldadc5752010-08-24 06:29:42 +00002421StmtResult
Douglas Gregor01afeef2009-08-28 20:31:08 +00002422Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregorebe10102009-08-20 07:17:43 +00002423 if (!S)
2424 return Owned(S);
2425
2426 TemplateInstantiator Instantiator(*this, TemplateArgs,
2427 SourceLocation(),
2428 DeclarationName());
2429 return Instantiator.TransformStmt(S);
2430}
2431
John McCalldadc5752010-08-24 06:29:42 +00002432ExprResult
Douglas Gregor01afeef2009-08-28 20:31:08 +00002433Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregora16548e2009-08-11 05:31:07 +00002434 if (!E)
2435 return Owned(E);
Mike Stump11289f42009-09-09 15:08:12 +00002436
Douglas Gregora16548e2009-08-11 05:31:07 +00002437 TemplateInstantiator Instantiator(*this, TemplateArgs,
2438 SourceLocation(),
2439 DeclarationName());
2440 return Instantiator.TransformExpr(E);
2441}
2442
Douglas Gregor2cd32a02011-01-07 19:35:17 +00002443bool Sema::SubstExprs(Expr **Exprs, unsigned NumExprs, bool IsCall,
2444 const MultiLevelTemplateArgumentList &TemplateArgs,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002445 SmallVectorImpl<Expr *> &Outputs) {
Douglas Gregor2cd32a02011-01-07 19:35:17 +00002446 if (NumExprs == 0)
2447 return false;
2448
2449 TemplateInstantiator Instantiator(*this, TemplateArgs,
2450 SourceLocation(),
2451 DeclarationName());
2452 return Instantiator.TransformExprs(Exprs, NumExprs, IsCall, Outputs);
2453}
2454
Douglas Gregor14454802011-02-25 02:25:35 +00002455NestedNameSpecifierLoc
2456Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
2457 const MultiLevelTemplateArgumentList &TemplateArgs) {
2458 if (!NNS)
2459 return NestedNameSpecifierLoc();
2460
2461 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
2462 DeclarationName());
2463 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2464}
2465
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002466/// \brief Do template substitution on declaration name info.
2467DeclarationNameInfo
2468Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
2469 const MultiLevelTemplateArgumentList &TemplateArgs) {
2470 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
2471 NameInfo.getName());
2472 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2473}
2474
Douglas Gregoraa594892009-03-31 18:38:02 +00002475TemplateName
Douglas Gregordf846d12011-03-02 18:46:51 +00002476Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
2477 TemplateName Name, SourceLocation Loc,
Douglas Gregor01afeef2009-08-28 20:31:08 +00002478 const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregor71dc5092009-08-06 06:41:21 +00002479 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2480 DeclarationName());
Douglas Gregordf846d12011-03-02 18:46:51 +00002481 CXXScopeSpec SS;
2482 SS.Adopt(QualifierLoc);
2483 return Instantiator.TransformTemplateName(SS, Name, Loc);
Douglas Gregoraa594892009-03-31 18:38:02 +00002484}
Douglas Gregorc43620d2009-06-11 00:06:24 +00002485
Douglas Gregor0f3feb42010-12-22 21:19:48 +00002486bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
2487 TemplateArgumentListInfo &Result,
John McCall0ad16662009-10-29 08:12:44 +00002488 const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregore922c772009-08-04 22:27:00 +00002489 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
2490 DeclarationName());
Douglas Gregor0f3feb42010-12-22 21:19:48 +00002491
2492 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
Douglas Gregorc43620d2009-06-11 00:06:24 +00002493}
Douglas Gregor14cf7522010-04-30 18:55:50 +00002494
Douglas Gregorf3010112011-01-07 16:43:16 +00002495llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2496LocalInstantiationScope::findInstantiationOf(const Decl *D) {
Chris Lattnercab02a62011-02-17 20:34:02 +00002497 for (LocalInstantiationScope *Current = this; Current;
Douglas Gregor14cf7522010-04-30 18:55:50 +00002498 Current = Current->Outer) {
Chris Lattnercab02a62011-02-17 20:34:02 +00002499
Douglas Gregor14cf7522010-04-30 18:55:50 +00002500 // Check if we found something within this scope.
Douglas Gregore9fc8dc2010-12-21 21:22:51 +00002501 const Decl *CheckD = D;
2502 do {
Douglas Gregorf3010112011-01-07 16:43:16 +00002503 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
Douglas Gregore9fc8dc2010-12-21 21:22:51 +00002504 if (Found != Current->LocalDecls.end())
Douglas Gregorf3010112011-01-07 16:43:16 +00002505 return &Found->second;
Douglas Gregore9fc8dc2010-12-21 21:22:51 +00002506
2507 // If this is a tag declaration, it's possible that we need to look for
2508 // a previous declaration.
2509 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
Douglas Gregorec9fd132012-01-14 16:38:05 +00002510 CheckD = Tag->getPreviousDecl();
Douglas Gregore9fc8dc2010-12-21 21:22:51 +00002511 else
2512 CheckD = 0;
2513 } while (CheckD);
2514
Douglas Gregor14cf7522010-04-30 18:55:50 +00002515 // If we aren't combined with our outer scope, we're done.
2516 if (!Current->CombineWithOuterScope)
2517 break;
2518 }
Chris Lattnercab02a62011-02-17 20:34:02 +00002519
2520 // If we didn't find the decl, then we either have a sema bug, or we have a
2521 // forward reference to a label declaration. Return null to indicate that
2522 // we have an uninstantiated label.
2523 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope");
Douglas Gregor14cf7522010-04-30 18:55:50 +00002524 return 0;
2525}
2526
John McCall19c1bfd2010-08-25 05:32:35 +00002527void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
Douglas Gregorf3010112011-01-07 16:43:16 +00002528 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
Douglas Gregora8bac7f2011-01-10 07:32:04 +00002529 if (Stored.isNull())
2530 Stored = Inst;
2531 else if (Stored.is<Decl *>()) {
2532 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local");
2533 Stored = Inst;
2534 } else
2535 LocalDecls[D].get<DeclArgumentPack *>()->push_back(Inst);
Douglas Gregor14cf7522010-04-30 18:55:50 +00002536}
Douglas Gregorf3010112011-01-07 16:43:16 +00002537
2538void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
2539 Decl *Inst) {
2540 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2541 Pack->push_back(Inst);
2542}
2543
2544void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
2545 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2546 assert(Stored.isNull() && "Already instantiated this local");
2547 DeclArgumentPack *Pack = new DeclArgumentPack;
2548 Stored = Pack;
2549 ArgumentPacks.push_back(Pack);
2550}
2551
Douglas Gregora8bac7f2011-01-10 07:32:04 +00002552void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
2553 const TemplateArgument *ExplicitArgs,
2554 unsigned NumExplicitArgs) {
2555 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2556 "Already have a partially-substituted pack");
2557 assert((!PartiallySubstitutedPack
2558 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2559 "Wrong number of arguments in partially-substituted pack");
2560 PartiallySubstitutedPack = Pack;
2561 ArgsInPartiallySubstitutedPack = ExplicitArgs;
2562 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2563}
2564
2565NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
2566 const TemplateArgument **ExplicitArgs,
2567 unsigned *NumExplicitArgs) const {
2568 if (ExplicitArgs)
2569 *ExplicitArgs = 0;
2570 if (NumExplicitArgs)
2571 *NumExplicitArgs = 0;
2572
2573 for (const LocalInstantiationScope *Current = this; Current;
2574 Current = Current->Outer) {
2575 if (Current->PartiallySubstitutedPack) {
2576 if (ExplicitArgs)
2577 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
2578 if (NumExplicitArgs)
2579 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
2580
2581 return Current->PartiallySubstitutedPack;
2582 }
2583
2584 if (!Current->CombineWithOuterScope)
2585 break;
2586 }
2587
2588 return 0;
2589}