SemaTemplateInstantiate.cpp revision 6098381c29c2693832aa81ef046cf21a49729436 
1//===------- 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
13#include "clang/Sema/SemaInternal.h"
14#include "TreeTransform.h"
15#include "clang/Sema/DeclSpec.h"
16#include "clang/Sema/Initialization.h"
17#include "clang/Sema/Lookup.h"
18#include "clang/Sema/Template.h"
19#include "clang/Sema/TemplateDeduction.h"
20#include "clang/AST/ASTConsumer.h"
21#include "clang/AST/ASTContext.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/Basic/LangOptions.h"
25
26using namespace clang;
27using namespace sema;
28
29//===----------------------------------------------------------------------===/
30// Template Instantiation Support
31//===----------------------------------------------------------------------===/
32
33/// \brief Retrieve the template argument list(s) that should be used to
34/// instantiate the definition of the given declaration.
35///
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.
40///
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.
45///
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.
50MultiLevelTemplateArgumentList
51Sema::getTemplateInstantiationArgs(NamedDecl *D,
52                                   const TemplateArgumentList *Innermost,
53                                   bool RelativeToPrimary,
54                                   const FunctionDecl *Pattern) {
55  // Accumulate the set of template argument lists in this structure.
56  MultiLevelTemplateArgumentList Result;
57
58  if (Innermost)
59    Result.addOuterTemplateArguments(Innermost);
60
61  DeclContext *Ctx = dyn_cast<DeclContext>(D);
62  if (!Ctx) {
63    Ctx = D->getDeclContext();
64
65    // 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    }
79  }
80
81  while (!Ctx->isFileContext()) {
82    // Add template arguments from a class template instantiation.
83    if (ClassTemplateSpecializationDecl *Spec
84          = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
85      // We're done when we hit an explicit specialization.
86      if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
87          !isa<ClassTemplatePartialSpecializationDecl>(Spec))
88        break;
89
90      Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
91
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;
97    }
98    // Add template arguments from a function template specialization.
99    else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
100      if (!RelativeToPrimary &&
101          (Function->getTemplateSpecializationKind() ==
102                                                  TSK_ExplicitSpecialization &&
103           !Function->getClassScopeSpecializationPattern()))
104        break;
105
106      if (const TemplateArgumentList *TemplateArgs
107            = Function->getTemplateSpecializationArgs()) {
108        // Add the template arguments for this specialization.
109        Result.addOuterTemplateArguments(TemplateArgs);
110
111        // 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;
116      } 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);
122      }
123
124      // If this is a friend declaration and it declares an entity at
125      // namespace scope, take arguments from its lexical parent
126      // instead of its semantic parent, unless of course the pattern we're
127      // instantiating actually comes from the file's context!
128      if (Function->getFriendObjectKind() &&
129          Function->getDeclContext()->isFileContext() &&
130          (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
131        Ctx = Function->getLexicalDeclContext();
132        RelativeToPrimary = false;
133        continue;
134      }
135    } 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      }
144    }
145
146    Ctx = Ctx->getParent();
147    RelativeToPrimary = false;
148  }
149
150  return Result;
151}
152
153bool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const {
154  switch (Kind) {
155  case TemplateInstantiation:
156  case ExceptionSpecInstantiation:
157  case DefaultTemplateArgumentInstantiation:
158  case DefaultFunctionArgumentInstantiation:
159  case ExplicitTemplateArgumentSubstitution:
160  case DeducedTemplateArgumentSubstitution:
161  case PriorTemplateArgumentSubstitution:
162    return true;
163
164  case DefaultTemplateArgumentChecking:
165    return false;
166  }
167
168  llvm_unreachable("Invalid InstantiationKind!");
169}
170
171Sema::InstantiatingTemplate::
172InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
173                      Decl *Entity,
174                      SourceRange InstantiationRange)
175  : SemaRef(SemaRef),
176    SavedInNonInstantiationSFINAEContext(
177                                        SemaRef.InNonInstantiationSFINAEContext)
178{
179  Invalid = CheckInstantiationDepth(PointOfInstantiation,
180                                    InstantiationRange);
181  if (!Invalid) {
182    ActiveTemplateInstantiation Inst;
183    Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation;
184    Inst.PointOfInstantiation = PointOfInstantiation;
185    Inst.Entity = reinterpret_cast<uintptr_t>(Entity);
186    Inst.TemplateArgs = 0;
187    Inst.NumTemplateArgs = 0;
188    Inst.InstantiationRange = InstantiationRange;
189    SemaRef.InNonInstantiationSFINAEContext = false;
190    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
191  }
192}
193
194Sema::InstantiatingTemplate::
195InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
196                      FunctionDecl *Entity, ExceptionSpecification,
197                      SourceRange InstantiationRange)
198  : SemaRef(SemaRef),
199    SavedInNonInstantiationSFINAEContext(
200                                        SemaRef.InNonInstantiationSFINAEContext)
201{
202  Invalid = CheckInstantiationDepth(PointOfInstantiation,
203                                    InstantiationRange);
204  if (!Invalid) {
205    ActiveTemplateInstantiation Inst;
206    Inst.Kind = ActiveTemplateInstantiation::ExceptionSpecInstantiation;
207    Inst.PointOfInstantiation = PointOfInstantiation;
208    Inst.Entity = reinterpret_cast<uintptr_t>(Entity);
209    Inst.TemplateArgs = 0;
210    Inst.NumTemplateArgs = 0;
211    Inst.InstantiationRange = InstantiationRange;
212    SemaRef.InNonInstantiationSFINAEContext = false;
213    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
214  }
215}
216
217Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
218                                         SourceLocation PointOfInstantiation,
219                                         TemplateDecl *Template,
220                                         const TemplateArgument *TemplateArgs,
221                                         unsigned NumTemplateArgs,
222                                         SourceRange InstantiationRange)
223  : SemaRef(SemaRef),
224    SavedInNonInstantiationSFINAEContext(
225                                     SemaRef.InNonInstantiationSFINAEContext)
226{
227  Invalid = CheckInstantiationDepth(PointOfInstantiation,
228                                    InstantiationRange);
229  if (!Invalid) {
230    ActiveTemplateInstantiation Inst;
231    Inst.Kind
232      = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation;
233    Inst.PointOfInstantiation = PointOfInstantiation;
234    Inst.Entity = reinterpret_cast<uintptr_t>(Template);
235    Inst.TemplateArgs = TemplateArgs;
236    Inst.NumTemplateArgs = NumTemplateArgs;
237    Inst.InstantiationRange = InstantiationRange;
238    SemaRef.InNonInstantiationSFINAEContext = false;
239    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
240  }
241}
242
243Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
244                                         SourceLocation PointOfInstantiation,
245                                      FunctionTemplateDecl *FunctionTemplate,
246                                        const TemplateArgument *TemplateArgs,
247                                                   unsigned NumTemplateArgs,
248                         ActiveTemplateInstantiation::InstantiationKind Kind,
249                                   sema::TemplateDeductionInfo &DeductionInfo,
250                                              SourceRange InstantiationRange)
251  : SemaRef(SemaRef),
252    SavedInNonInstantiationSFINAEContext(
253                                     SemaRef.InNonInstantiationSFINAEContext)
254{
255  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
256  if (!Invalid) {
257    ActiveTemplateInstantiation Inst;
258    Inst.Kind = Kind;
259    Inst.PointOfInstantiation = PointOfInstantiation;
260    Inst.Entity = reinterpret_cast<uintptr_t>(FunctionTemplate);
261    Inst.TemplateArgs = TemplateArgs;
262    Inst.NumTemplateArgs = NumTemplateArgs;
263    Inst.DeductionInfo = &DeductionInfo;
264    Inst.InstantiationRange = InstantiationRange;
265    SemaRef.InNonInstantiationSFINAEContext = false;
266    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
267
268    if (!Inst.isInstantiationRecord())
269      ++SemaRef.NonInstantiationEntries;
270  }
271}
272
273Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
274                                         SourceLocation PointOfInstantiation,
275                          ClassTemplatePartialSpecializationDecl *PartialSpec,
276                                         const TemplateArgument *TemplateArgs,
277                                         unsigned NumTemplateArgs,
278                                    sema::TemplateDeductionInfo &DeductionInfo,
279                                         SourceRange InstantiationRange)
280  : SemaRef(SemaRef),
281    SavedInNonInstantiationSFINAEContext(
282                                     SemaRef.InNonInstantiationSFINAEContext)
283{
284  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
285  if (!Invalid) {
286    ActiveTemplateInstantiation Inst;
287    Inst.Kind = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution;
288    Inst.PointOfInstantiation = PointOfInstantiation;
289    Inst.Entity = reinterpret_cast<uintptr_t>(PartialSpec);
290    Inst.TemplateArgs = TemplateArgs;
291    Inst.NumTemplateArgs = NumTemplateArgs;
292    Inst.DeductionInfo = &DeductionInfo;
293    Inst.InstantiationRange = InstantiationRange;
294    SemaRef.InNonInstantiationSFINAEContext = false;
295    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
296  }
297}
298
299Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef,
300                                          SourceLocation PointOfInstantiation,
301                                          ParmVarDecl *Param,
302                                          const TemplateArgument *TemplateArgs,
303                                          unsigned NumTemplateArgs,
304                                          SourceRange InstantiationRange)
305  : SemaRef(SemaRef),
306    SavedInNonInstantiationSFINAEContext(
307                                     SemaRef.InNonInstantiationSFINAEContext)
308{
309  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
310  if (!Invalid) {
311    ActiveTemplateInstantiation Inst;
312    Inst.Kind
313      = ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation;
314    Inst.PointOfInstantiation = PointOfInstantiation;
315    Inst.Entity = reinterpret_cast<uintptr_t>(Param);
316    Inst.TemplateArgs = TemplateArgs;
317    Inst.NumTemplateArgs = NumTemplateArgs;
318    Inst.InstantiationRange = InstantiationRange;
319    SemaRef.InNonInstantiationSFINAEContext = false;
320    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
321  }
322}
323
324Sema::InstantiatingTemplate::
325InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
326                      NamedDecl *Template,
327                      NonTypeTemplateParmDecl *Param,
328                      const TemplateArgument *TemplateArgs,
329                      unsigned NumTemplateArgs,
330                      SourceRange InstantiationRange)
331  : SemaRef(SemaRef),
332    SavedInNonInstantiationSFINAEContext(
333                                     SemaRef.InNonInstantiationSFINAEContext)
334{
335  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
336  if (!Invalid) {
337    ActiveTemplateInstantiation Inst;
338    Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution;
339    Inst.PointOfInstantiation = PointOfInstantiation;
340    Inst.Template = Template;
341    Inst.Entity = reinterpret_cast<uintptr_t>(Param);
342    Inst.TemplateArgs = TemplateArgs;
343    Inst.NumTemplateArgs = NumTemplateArgs;
344    Inst.InstantiationRange = InstantiationRange;
345    SemaRef.InNonInstantiationSFINAEContext = false;
346    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
347  }
348}
349
350Sema::InstantiatingTemplate::
351InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
352                      NamedDecl *Template,
353                      TemplateTemplateParmDecl *Param,
354                      const TemplateArgument *TemplateArgs,
355                      unsigned NumTemplateArgs,
356                      SourceRange InstantiationRange)
357  : SemaRef(SemaRef),
358    SavedInNonInstantiationSFINAEContext(
359                                     SemaRef.InNonInstantiationSFINAEContext)
360{
361  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
362  if (!Invalid) {
363    ActiveTemplateInstantiation Inst;
364    Inst.Kind = ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution;
365    Inst.PointOfInstantiation = PointOfInstantiation;
366    Inst.Template = Template;
367    Inst.Entity = reinterpret_cast<uintptr_t>(Param);
368    Inst.TemplateArgs = TemplateArgs;
369    Inst.NumTemplateArgs = NumTemplateArgs;
370    Inst.InstantiationRange = InstantiationRange;
371    SemaRef.InNonInstantiationSFINAEContext = false;
372    SemaRef.ActiveTemplateInstantiations.push_back(Inst);
373  }
374}
375
376Sema::InstantiatingTemplate::
377InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
378                      TemplateDecl *Template,
379                      NamedDecl *Param,
380                      const TemplateArgument *TemplateArgs,
381                      unsigned NumTemplateArgs,
382                      SourceRange InstantiationRange)
383  : SemaRef(SemaRef),
384    SavedInNonInstantiationSFINAEContext(
385                                     SemaRef.InNonInstantiationSFINAEContext)
386{
387  Invalid = false;
388
389  ActiveTemplateInstantiation Inst;
390  Inst.Kind = ActiveTemplateInstantiation::DefaultTemplateArgumentChecking;
391  Inst.PointOfInstantiation = PointOfInstantiation;
392  Inst.Template = Template;
393  Inst.Entity = reinterpret_cast<uintptr_t>(Param);
394  Inst.TemplateArgs = TemplateArgs;
395  Inst.NumTemplateArgs = NumTemplateArgs;
396  Inst.InstantiationRange = InstantiationRange;
397  SemaRef.InNonInstantiationSFINAEContext = false;
398  SemaRef.ActiveTemplateInstantiations.push_back(Inst);
399
400  assert(!Inst.isInstantiationRecord());
401  ++SemaRef.NonInstantiationEntries;
402}
403
404void Sema::InstantiatingTemplate::Clear() {
405  if (!Invalid) {
406    if (!SemaRef.ActiveTemplateInstantiations.back().isInstantiationRecord()) {
407      assert(SemaRef.NonInstantiationEntries > 0);
408      --SemaRef.NonInstantiationEntries;
409    }
410    SemaRef.InNonInstantiationSFINAEContext
411      = SavedInNonInstantiationSFINAEContext;
412    SemaRef.ActiveTemplateInstantiations.pop_back();
413    Invalid = true;
414  }
415}
416
417bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
418                                        SourceLocation PointOfInstantiation,
419                                           SourceRange InstantiationRange) {
420  assert(SemaRef.NonInstantiationEntries <=
421                                   SemaRef.ActiveTemplateInstantiations.size());
422  if ((SemaRef.ActiveTemplateInstantiations.size() -
423          SemaRef.NonInstantiationEntries)
424        <= SemaRef.getLangOpts().InstantiationDepth)
425    return false;
426
427  SemaRef.Diag(PointOfInstantiation,
428               diag::err_template_recursion_depth_exceeded)
429    << SemaRef.getLangOpts().InstantiationDepth
430    << InstantiationRange;
431  SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
432    << SemaRef.getLangOpts().InstantiationDepth;
433  return true;
434}
435
436/// \brief Prints the current instantiation stack through a series of
437/// notes.
438void Sema::PrintInstantiationStack() {
439  // Determine which template instantiations to skip, if any.
440  unsigned SkipStart = ActiveTemplateInstantiations.size(), SkipEnd = SkipStart;
441  unsigned Limit = Diags.getTemplateBacktraceLimit();
442  if (Limit && Limit < ActiveTemplateInstantiations.size()) {
443    SkipStart = Limit / 2 + Limit % 2;
444    SkipEnd = ActiveTemplateInstantiations.size() - Limit / 2;
445  }
446
447  // FIXME: In all of these cases, we need to show the template arguments
448  unsigned InstantiationIdx = 0;
449  for (SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator
450         Active = ActiveTemplateInstantiations.rbegin(),
451         ActiveEnd = ActiveTemplateInstantiations.rend();
452       Active != ActiveEnd;
453       ++Active, ++InstantiationIdx) {
454    // Skip this instantiation?
455    if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
456      if (InstantiationIdx == SkipStart) {
457        // Note that we're skipping instantiations.
458        Diags.Report(Active->PointOfInstantiation,
459                     diag::note_instantiation_contexts_suppressed)
460          << unsigned(ActiveTemplateInstantiations.size() - Limit);
461      }
462      continue;
463    }
464
465    switch (Active->Kind) {
466    case ActiveTemplateInstantiation::TemplateInstantiation: {
467      Decl *D = reinterpret_cast<Decl *>(Active->Entity);
468      if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
469        unsigned DiagID = diag::note_template_member_class_here;
470        if (isa<ClassTemplateSpecializationDecl>(Record))
471          DiagID = diag::note_template_class_instantiation_here;
472        Diags.Report(Active->PointOfInstantiation, DiagID)
473          << Context.getTypeDeclType(Record)
474          << Active->InstantiationRange;
475      } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
476        unsigned DiagID;
477        if (Function->getPrimaryTemplate())
478          DiagID = diag::note_function_template_spec_here;
479        else
480          DiagID = diag::note_template_member_function_here;
481        Diags.Report(Active->PointOfInstantiation, DiagID)
482          << Function
483          << Active->InstantiationRange;
484      } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
485        Diags.Report(Active->PointOfInstantiation,
486                     diag::note_template_static_data_member_def_here)
487          << VD
488          << Active->InstantiationRange;
489      } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
490        Diags.Report(Active->PointOfInstantiation,
491                     diag::note_template_enum_def_here)
492          << ED
493          << Active->InstantiationRange;
494      } else {
495        Diags.Report(Active->PointOfInstantiation,
496                     diag::note_template_type_alias_instantiation_here)
497          << cast<TypeAliasTemplateDecl>(D)
498          << Active->InstantiationRange;
499      }
500      break;
501    }
502
503    case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: {
504      TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity);
505      std::string TemplateArgsStr
506        = TemplateSpecializationType::PrintTemplateArgumentList(
507                                                         Active->TemplateArgs,
508                                                      Active->NumTemplateArgs,
509                                                      getPrintingPolicy());
510      Diags.Report(Active->PointOfInstantiation,
511                   diag::note_default_arg_instantiation_here)
512        << (Template->getNameAsString() + TemplateArgsStr)
513        << Active->InstantiationRange;
514      break;
515    }
516
517    case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: {
518      FunctionTemplateDecl *FnTmpl
519        = cast<FunctionTemplateDecl>((Decl *)Active->Entity);
520      Diags.Report(Active->PointOfInstantiation,
521                   diag::note_explicit_template_arg_substitution_here)
522        << FnTmpl
523        << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
524                                           Active->TemplateArgs,
525                                           Active->NumTemplateArgs)
526        << Active->InstantiationRange;
527      break;
528    }
529
530    case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution:
531      if (ClassTemplatePartialSpecializationDecl *PartialSpec
532            = dyn_cast<ClassTemplatePartialSpecializationDecl>(
533                                                    (Decl *)Active->Entity)) {
534        Diags.Report(Active->PointOfInstantiation,
535                     diag::note_partial_spec_deduct_instantiation_here)
536          << Context.getTypeDeclType(PartialSpec)
537          << getTemplateArgumentBindingsText(
538                                         PartialSpec->getTemplateParameters(),
539                                             Active->TemplateArgs,
540                                             Active->NumTemplateArgs)
541          << Active->InstantiationRange;
542      } else {
543        FunctionTemplateDecl *FnTmpl
544          = cast<FunctionTemplateDecl>((Decl *)Active->Entity);
545        Diags.Report(Active->PointOfInstantiation,
546                     diag::note_function_template_deduction_instantiation_here)
547          << FnTmpl
548          << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
549                                             Active->TemplateArgs,
550                                             Active->NumTemplateArgs)
551          << Active->InstantiationRange;
552      }
553      break;
554
555    case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: {
556      ParmVarDecl *Param = cast<ParmVarDecl>((Decl *)Active->Entity);
557      FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
558
559      std::string TemplateArgsStr
560        = TemplateSpecializationType::PrintTemplateArgumentList(
561                                                         Active->TemplateArgs,
562                                                      Active->NumTemplateArgs,
563                                                      getPrintingPolicy());
564      Diags.Report(Active->PointOfInstantiation,
565                   diag::note_default_function_arg_instantiation_here)
566        << (FD->getNameAsString() + TemplateArgsStr)
567        << Active->InstantiationRange;
568      break;
569    }
570
571    case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: {
572      NamedDecl *Parm = cast<NamedDecl>((Decl *)Active->Entity);
573      std::string Name;
574      if (!Parm->getName().empty())
575        Name = std::string(" '") + Parm->getName().str() + "'";
576
577      TemplateParameterList *TemplateParams = 0;
578      if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
579        TemplateParams = Template->getTemplateParameters();
580      else
581        TemplateParams =
582          cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
583                                                      ->getTemplateParameters();
584      Diags.Report(Active->PointOfInstantiation,
585                   diag::note_prior_template_arg_substitution)
586        << isa<TemplateTemplateParmDecl>(Parm)
587        << Name
588        << getTemplateArgumentBindingsText(TemplateParams,
589                                           Active->TemplateArgs,
590                                           Active->NumTemplateArgs)
591        << Active->InstantiationRange;
592      break;
593    }
594
595    case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking: {
596      TemplateParameterList *TemplateParams = 0;
597      if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
598        TemplateParams = Template->getTemplateParameters();
599      else
600        TemplateParams =
601          cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
602                                                      ->getTemplateParameters();
603
604      Diags.Report(Active->PointOfInstantiation,
605                   diag::note_template_default_arg_checking)
606        << getTemplateArgumentBindingsText(TemplateParams,
607                                           Active->TemplateArgs,
608                                           Active->NumTemplateArgs)
609        << Active->InstantiationRange;
610      break;
611    }
612
613    case ActiveTemplateInstantiation::ExceptionSpecInstantiation:
614      Diags.Report(Active->PointOfInstantiation,
615                   diag::note_template_exception_spec_instantiation_here)
616        << cast<FunctionDecl>((Decl *)Active->Entity)
617        << Active->InstantiationRange;
618      break;
619    }
620  }
621}
622
623llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
624  if (InNonInstantiationSFINAEContext)
625    return llvm::Optional<TemplateDeductionInfo *>(0);
626
627  for (SmallVector<ActiveTemplateInstantiation, 16>::const_reverse_iterator
628         Active = ActiveTemplateInstantiations.rbegin(),
629         ActiveEnd = ActiveTemplateInstantiations.rend();
630       Active != ActiveEnd;
631       ++Active)
632  {
633    switch(Active->Kind) {
634    case ActiveTemplateInstantiation::TemplateInstantiation:
635      // An instantiation of an alias template may or may not be a SFINAE
636      // context, depending on what else is on the stack.
637      if (isa<TypeAliasTemplateDecl>(reinterpret_cast<Decl *>(Active->Entity)))
638        break;
639      // Fall through.
640    case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation:
641    case ActiveTemplateInstantiation::ExceptionSpecInstantiation:
642      // This is a template instantiation, so there is no SFINAE.
643      return llvm::Optional<TemplateDeductionInfo *>();
644
645    case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation:
646    case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution:
647    case ActiveTemplateInstantiation::DefaultTemplateArgumentChecking:
648      // A default template argument instantiation and substitution into
649      // template parameters with arguments for prior parameters may or may
650      // not be a SFINAE context; look further up the stack.
651      break;
652
653    case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution:
654    case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution:
655      // We're either substitution explicitly-specified template arguments
656      // or deduced template arguments, so SFINAE applies.
657      assert(Active->DeductionInfo && "Missing deduction info pointer");
658      return Active->DeductionInfo;
659    }
660  }
661
662  return llvm::Optional<TemplateDeductionInfo *>();
663}
664
665/// \brief Retrieve the depth and index of a parameter pack.
666static std::pair<unsigned, unsigned>
667getDepthAndIndex(NamedDecl *ND) {
668  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
669    return std::make_pair(TTP->getDepth(), TTP->getIndex());
670
671  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
672    return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
673
674  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
675  return std::make_pair(TTP->getDepth(), TTP->getIndex());
676}
677
678//===----------------------------------------------------------------------===/
679// Template Instantiation for Types
680//===----------------------------------------------------------------------===/
681namespace {
682  class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
683    const MultiLevelTemplateArgumentList &TemplateArgs;
684    SourceLocation Loc;
685    DeclarationName Entity;
686
687  public:
688    typedef TreeTransform<TemplateInstantiator> inherited;
689
690    TemplateInstantiator(Sema &SemaRef,
691                         const MultiLevelTemplateArgumentList &TemplateArgs,
692                         SourceLocation Loc,
693                         DeclarationName Entity)
694      : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
695        Entity(Entity) { }
696
697    /// \brief Determine whether the given type \p T has already been
698    /// transformed.
699    ///
700    /// For the purposes of template instantiation, a type has already been
701    /// transformed if it is NULL or if it is not dependent.
702    bool AlreadyTransformed(QualType T);
703
704    /// \brief Returns the location of the entity being instantiated, if known.
705    SourceLocation getBaseLocation() { return Loc; }
706
707    /// \brief Returns the name of the entity being instantiated, if any.
708    DeclarationName getBaseEntity() { return Entity; }
709
710    /// \brief Sets the "base" location and entity when that
711    /// information is known based on another transformation.
712    void setBase(SourceLocation Loc, DeclarationName Entity) {
713      this->Loc = Loc;
714      this->Entity = Entity;
715    }
716
717    bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
718                                 SourceRange PatternRange,
719                             llvm::ArrayRef<UnexpandedParameterPack> Unexpanded,
720                                 bool &ShouldExpand,
721                                 bool &RetainExpansion,
722                                 llvm::Optional<unsigned> &NumExpansions) {
723      return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
724                                                       PatternRange, Unexpanded,
725                                                       TemplateArgs,
726                                                       ShouldExpand,
727                                                       RetainExpansion,
728                                                       NumExpansions);
729    }
730
731    void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
732      SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
733    }
734
735    TemplateArgument ForgetPartiallySubstitutedPack() {
736      TemplateArgument Result;
737      if (NamedDecl *PartialPack
738            = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
739        MultiLevelTemplateArgumentList &TemplateArgs
740          = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
741        unsigned Depth, Index;
742        llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack);
743        if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
744          Result = TemplateArgs(Depth, Index);
745          TemplateArgs.setArgument(Depth, Index, TemplateArgument());
746        }
747      }
748
749      return Result;
750    }
751
752    void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
753      if (Arg.isNull())
754        return;
755
756      if (NamedDecl *PartialPack
757            = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
758        MultiLevelTemplateArgumentList &TemplateArgs
759        = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
760        unsigned Depth, Index;
761        llvm::tie(Depth, Index) = getDepthAndIndex(PartialPack);
762        TemplateArgs.setArgument(Depth, Index, Arg);
763      }
764    }
765
766    /// \brief Transform the given declaration by instantiating a reference to
767    /// this declaration.
768    Decl *TransformDecl(SourceLocation Loc, Decl *D);
769
770    void transformAttrs(Decl *Old, Decl *New) {
771      SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
772    }
773
774    void transformedLocalDecl(Decl *Old, Decl *New) {
775      SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
776    }
777
778    /// \brief Transform the definition of the given declaration by
779    /// instantiating it.
780    Decl *TransformDefinition(SourceLocation Loc, Decl *D);
781
782    /// \bried Transform the first qualifier within a scope by instantiating the
783    /// declaration.
784    NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
785
786    /// \brief Rebuild the exception declaration and register the declaration
787    /// as an instantiated local.
788    VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
789                                  TypeSourceInfo *Declarator,
790                                  SourceLocation StartLoc,
791                                  SourceLocation NameLoc,
792                                  IdentifierInfo *Name);
793
794    /// \brief Rebuild the Objective-C exception declaration and register the
795    /// declaration as an instantiated local.
796    VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
797                                      TypeSourceInfo *TSInfo, QualType T);
798
799    /// \brief Check for tag mismatches when instantiating an
800    /// elaborated type.
801    QualType RebuildElaboratedType(SourceLocation KeywordLoc,
802                                   ElaboratedTypeKeyword Keyword,
803                                   NestedNameSpecifierLoc QualifierLoc,
804                                   QualType T);
805
806    TemplateName TransformTemplateName(CXXScopeSpec &SS,
807                                       TemplateName Name,
808                                       SourceLocation NameLoc,
809                                       QualType ObjectType = QualType(),
810                                       NamedDecl *FirstQualifierInScope = 0);
811
812    ExprResult TransformPredefinedExpr(PredefinedExpr *E);
813    ExprResult TransformDeclRefExpr(DeclRefExpr *E);
814    ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
815    ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
816                                            NonTypeTemplateParmDecl *D);
817    ExprResult TransformSubstNonTypeTemplateParmPackExpr(
818                                           SubstNonTypeTemplateParmPackExpr *E);
819
820    QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
821                                        FunctionProtoTypeLoc TL);
822    QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
823                                        FunctionProtoTypeLoc TL,
824                                        CXXRecordDecl *ThisContext,
825                                        unsigned ThisTypeQuals);
826
827    ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
828                                            int indexAdjustment,
829                                        llvm::Optional<unsigned> NumExpansions,
830                                            bool ExpectParameterPack);
831
832    /// \brief Transforms a template type parameter type by performing
833    /// substitution of the corresponding template type argument.
834    QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
835                                           TemplateTypeParmTypeLoc TL);
836
837    /// \brief Transforms an already-substituted template type parameter pack
838    /// into either itself (if we aren't substituting into its pack expansion)
839    /// or the appropriate substituted argument.
840    QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
841                                           SubstTemplateTypeParmPackTypeLoc TL);
842
843    ExprResult TransformCallExpr(CallExpr *CE) {
844      getSema().CallsUndergoingInstantiation.push_back(CE);
845      ExprResult Result =
846          TreeTransform<TemplateInstantiator>::TransformCallExpr(CE);
847      getSema().CallsUndergoingInstantiation.pop_back();
848      return move(Result);
849    }
850
851  private:
852    ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
853                                               SourceLocation loc,
854                                               TemplateArgument arg);
855  };
856}
857
858bool TemplateInstantiator::AlreadyTransformed(QualType T) {
859  if (T.isNull())
860    return true;
861
862  if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
863    return false;
864
865  getSema().MarkDeclarationsReferencedInType(Loc, T);
866  return true;
867}
868
869Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
870  if (!D)
871    return 0;
872
873  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
874    if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
875      // If the corresponding template argument is NULL or non-existent, it's
876      // because we are performing instantiation from explicitly-specified
877      // template arguments in a function template, but there were some
878      // arguments left unspecified.
879      if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
880                                            TTP->getPosition()))
881        return D;
882
883      TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
884
885      if (TTP->isParameterPack()) {
886        assert(Arg.getKind() == TemplateArgument::Pack &&
887               "Missing argument pack");
888
889        assert(getSema().ArgumentPackSubstitutionIndex >= 0);
890        assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
891        Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
892      }
893
894      TemplateName Template = Arg.getAsTemplate();
895      assert(!Template.isNull() && Template.getAsTemplateDecl() &&
896             "Wrong kind of template template argument");
897      return Template.getAsTemplateDecl();
898    }
899
900    // Fall through to find the instantiated declaration for this template
901    // template parameter.
902  }
903
904  return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
905}
906
907Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
908  Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
909  if (!Inst)
910    return 0;
911
912  getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
913  return Inst;
914}
915
916NamedDecl *
917TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
918                                                     SourceLocation Loc) {
919  // If the first part of the nested-name-specifier was a template type
920  // parameter, instantiate that type parameter down to a tag type.
921  if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
922    const TemplateTypeParmType *TTP
923      = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
924
925    if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
926      // FIXME: This needs testing w/ member access expressions.
927      TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
928
929      if (TTP->isParameterPack()) {
930        assert(Arg.getKind() == TemplateArgument::Pack &&
931               "Missing argument pack");
932
933        if (getSema().ArgumentPackSubstitutionIndex == -1)
934          return 0;
935
936        assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
937        Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
938      }
939
940      QualType T = Arg.getAsType();
941      if (T.isNull())
942        return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
943
944      if (const TagType *Tag = T->getAs<TagType>())
945        return Tag->getDecl();
946
947      // The resulting type is not a tag; complain.
948      getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
949      return 0;
950    }
951  }
952
953  return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
954}
955
956VarDecl *
957TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
958                                           TypeSourceInfo *Declarator,
959                                           SourceLocation StartLoc,
960                                           SourceLocation NameLoc,
961                                           IdentifierInfo *Name) {
962  VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
963                                                 StartLoc, NameLoc, Name);
964  if (Var)
965    getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
966  return Var;
967}
968
969VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
970                                                        TypeSourceInfo *TSInfo,
971                                                        QualType T) {
972  VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
973  if (Var)
974    getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
975  return Var;
976}
977
978QualType
979TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
980                                            ElaboratedTypeKeyword Keyword,
981                                            NestedNameSpecifierLoc QualifierLoc,
982                                            QualType T) {
983  if (const TagType *TT = T->getAs<TagType>()) {
984    TagDecl* TD = TT->getDecl();
985
986    SourceLocation TagLocation = KeywordLoc;
987
988    // FIXME: type might be anonymous.
989    IdentifierInfo *Id = TD->getIdentifier();
990
991    // TODO: should we even warn on struct/class mismatches for this?  Seems
992    // like it's likely to produce a lot of spurious errors.
993    if (Keyword != ETK_None && Keyword != ETK_Typename) {
994      TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
995      if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
996                                                TagLocation, *Id)) {
997        SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
998          << Id
999          << FixItHint::CreateReplacement(SourceRange(TagLocation),
1000                                          TD->getKindName());
1001        SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
1002      }
1003    }
1004  }
1005
1006  return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
1007                                                                    Keyword,
1008                                                                  QualifierLoc,
1009                                                                    T);
1010}
1011
1012TemplateName TemplateInstantiator::TransformTemplateName(CXXScopeSpec &SS,
1013                                                         TemplateName Name,
1014                                                         SourceLocation NameLoc,
1015                                                         QualType ObjectType,
1016                                             NamedDecl *FirstQualifierInScope) {
1017  if (TemplateTemplateParmDecl *TTP
1018       = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
1019    if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1020      // If the corresponding template argument is NULL or non-existent, it's
1021      // because we are performing instantiation from explicitly-specified
1022      // template arguments in a function template, but there were some
1023      // arguments left unspecified.
1024      if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1025                                            TTP->getPosition()))
1026        return Name;
1027
1028      TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1029
1030      if (TTP->isParameterPack()) {
1031        assert(Arg.getKind() == TemplateArgument::Pack &&
1032               "Missing argument pack");
1033
1034        if (getSema().ArgumentPackSubstitutionIndex == -1) {
1035          // We have the template argument pack to substitute, but we're not
1036          // actually expanding the enclosing pack expansion yet. So, just
1037          // keep the entire argument pack.
1038          return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1039        }
1040
1041        assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
1042        Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1043      }
1044
1045      TemplateName Template = Arg.getAsTemplate();
1046      assert(!Template.isNull() && "Null template template argument");
1047
1048      // We don't ever want to substitute for a qualified template name, since
1049      // the qualifier is handled separately. So, look through the qualified
1050      // template name to its underlying declaration.
1051      if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
1052        Template = TemplateName(QTN->getTemplateDecl());
1053
1054      Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1055      return Template;
1056    }
1057  }
1058
1059  if (SubstTemplateTemplateParmPackStorage *SubstPack
1060      = Name.getAsSubstTemplateTemplateParmPack()) {
1061    if (getSema().ArgumentPackSubstitutionIndex == -1)
1062      return Name;
1063
1064    const TemplateArgument &ArgPack = SubstPack->getArgumentPack();
1065    assert(getSema().ArgumentPackSubstitutionIndex < (int)ArgPack.pack_size() &&
1066           "Pack substitution index out-of-range");
1067    return ArgPack.pack_begin()[getSema().ArgumentPackSubstitutionIndex]
1068    .getAsTemplate();
1069  }
1070
1071  return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1072                                          FirstQualifierInScope);
1073}
1074
1075ExprResult
1076TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
1077  if (!E->isTypeDependent())
1078    return SemaRef.Owned(E);
1079
1080  FunctionDecl *currentDecl = getSema().getCurFunctionDecl();
1081  assert(currentDecl && "Must have current function declaration when "
1082                        "instantiating.");
1083
1084  PredefinedExpr::IdentType IT = E->getIdentType();
1085
1086  unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
1087
1088  llvm::APInt LengthI(32, Length + 1);
1089  QualType ResTy;
1090  if (IT == PredefinedExpr::LFunction)
1091    ResTy = getSema().Context.WCharTy.withConst();
1092  else
1093    ResTy = getSema().Context.CharTy.withConst();
1094  ResTy = getSema().Context.getConstantArrayType(ResTy, LengthI,
1095                                                 ArrayType::Normal, 0);
1096  PredefinedExpr *PE =
1097    new (getSema().Context) PredefinedExpr(E->getLocation(), ResTy, IT);
1098  return getSema().Owned(PE);
1099}
1100
1101ExprResult
1102TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
1103                                               NonTypeTemplateParmDecl *NTTP) {
1104  // If the corresponding template argument is NULL or non-existent, it's
1105  // because we are performing instantiation from explicitly-specified
1106  // template arguments in a function template, but there were some
1107  // arguments left unspecified.
1108  if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
1109                                        NTTP->getPosition()))
1110    return SemaRef.Owned(E);
1111
1112  TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1113  if (NTTP->isParameterPack()) {
1114    assert(Arg.getKind() == TemplateArgument::Pack &&
1115           "Missing argument pack");
1116
1117    if (getSema().ArgumentPackSubstitutionIndex == -1) {
1118      // We have an argument pack, but we can't select a particular argument
1119      // out of it yet. Therefore, we'll build an expression to hold on to that
1120      // argument pack.
1121      QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
1122                                              E->getLocation(),
1123                                              NTTP->getDeclName());
1124      if (TargetType.isNull())
1125        return ExprError();
1126
1127      return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(TargetType,
1128                                                                    NTTP,
1129                                                              E->getLocation(),
1130                                                                    Arg);
1131    }
1132
1133    assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
1134    Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1135  }
1136
1137  return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1138}
1139
1140ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1141                                                 NonTypeTemplateParmDecl *parm,
1142                                                 SourceLocation loc,
1143                                                 TemplateArgument arg) {
1144  ExprResult result;
1145  QualType type;
1146
1147  // If the argument is a pack expansion, the parameter must actually be a
1148  // parameter pack, and we should substitute the pattern itself, producing
1149  // an expression which contains an unexpanded parameter pack.
1150  if (arg.isPackExpansion()) {
1151    assert(parm->isParameterPack() && "pack expansion for non-pack");
1152    arg = arg.getPackExpansionPattern();
1153  }
1154
1155  // The template argument itself might be an expression, in which
1156  // case we just return that expression.
1157  if (arg.getKind() == TemplateArgument::Expression) {
1158    Expr *argExpr = arg.getAsExpr();
1159    result = SemaRef.Owned(argExpr);
1160    type = argExpr->getType();
1161
1162  } else if (arg.getKind() == TemplateArgument::Declaration) {
1163    ValueDecl *VD;
1164    if (Decl *D = arg.getAsDecl()) {
1165      VD = cast<ValueDecl>(D);
1166
1167      // Find the instantiation of the template argument.  This is
1168      // required for nested templates.
1169      VD = cast_or_null<ValueDecl>(
1170             getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1171      if (!VD)
1172        return ExprError();
1173    } else {
1174      // Propagate NULL template argument.
1175      VD = 0;
1176    }
1177
1178    // Derive the type we want the substituted decl to have.  This had
1179    // better be non-dependent, or these checks will have serious problems.
1180    if (parm->isExpandedParameterPack()) {
1181      type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
1182    } else if (parm->isParameterPack() &&
1183               isa<PackExpansionType>(parm->getType())) {
1184      type = SemaRef.SubstType(
1185                        cast<PackExpansionType>(parm->getType())->getPattern(),
1186                                     TemplateArgs, loc, parm->getDeclName());
1187    } else {
1188      type = SemaRef.SubstType(parm->getType(), TemplateArgs,
1189                               loc, parm->getDeclName());
1190    }
1191    assert(!type.isNull() && "type substitution failed for param type");
1192    assert(!type->isDependentType() && "param type still dependent");
1193    result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc);
1194
1195    if (!result.isInvalid()) type = result.get()->getType();
1196  } else {
1197    result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1198
1199    // Note that this type can be different from the type of 'result',
1200    // e.g. if it's an enum type.
1201    type = arg.getIntegralType();
1202  }
1203  if (result.isInvalid()) return ExprError();
1204
1205  Expr *resultExpr = result.take();
1206  return SemaRef.Owned(new (SemaRef.Context)
1207                SubstNonTypeTemplateParmExpr(type,
1208                                             resultExpr->getValueKind(),
1209                                             loc, parm, resultExpr));
1210}
1211
1212ExprResult
1213TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1214                                          SubstNonTypeTemplateParmPackExpr *E) {
1215  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1216    // We aren't expanding the parameter pack, so just return ourselves.
1217    return getSema().Owned(E);
1218  }
1219
1220  const TemplateArgument &ArgPack = E->getArgumentPack();
1221  unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex;
1222  assert(Index < ArgPack.pack_size() && "Substitution index out-of-range");
1223
1224  const TemplateArgument &Arg = ArgPack.pack_begin()[Index];
1225  return transformNonTypeTemplateParmRef(E->getParameterPack(),
1226                                         E->getParameterPackLocation(),
1227                                         Arg);
1228}
1229
1230ExprResult
1231TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
1232  NamedDecl *D = E->getDecl();
1233  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
1234    if (NTTP->getDepth() < TemplateArgs.getNumLevels())
1235      return TransformTemplateParmRefExpr(E, NTTP);
1236
1237    // We have a non-type template parameter that isn't fully substituted;
1238    // FindInstantiatedDecl will find it in the local instantiation scope.
1239  }
1240
1241  return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
1242}
1243
1244ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1245    CXXDefaultArgExpr *E) {
1246  assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->
1247             getDescribedFunctionTemplate() &&
1248         "Default arg expressions are never formed in dependent cases.");
1249  return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
1250                           cast<FunctionDecl>(E->getParam()->getDeclContext()),
1251                                        E->getParam());
1252}
1253
1254QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1255                                                      FunctionProtoTypeLoc TL) {
1256  // We need a local instantiation scope for this function prototype.
1257  LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1258  return inherited::TransformFunctionProtoType(TLB, TL);
1259}
1260
1261QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1262                                 FunctionProtoTypeLoc TL,
1263                                 CXXRecordDecl *ThisContext,
1264                                 unsigned ThisTypeQuals) {
1265  // We need a local instantiation scope for this function prototype.
1266  LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1267  return inherited::TransformFunctionProtoType(TLB, TL, ThisContext,
1268                                               ThisTypeQuals);
1269}
1270
1271ParmVarDecl *
1272TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
1273                                                 int indexAdjustment,
1274                                       llvm::Optional<unsigned> NumExpansions,
1275                                                 bool ExpectParameterPack) {
1276  return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
1277                                  NumExpansions, ExpectParameterPack);
1278}
1279
1280QualType
1281TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1282                                                TemplateTypeParmTypeLoc TL) {
1283  const TemplateTypeParmType *T = TL.getTypePtr();
1284  if (T->getDepth() < TemplateArgs.getNumLevels()) {
1285    // Replace the template type parameter with its corresponding
1286    // template argument.
1287
1288    // If the corresponding template argument is NULL or doesn't exist, it's
1289    // because we are performing instantiation from explicitly-specified
1290    // template arguments in a function template class, but there were some
1291    // arguments left unspecified.
1292    if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
1293      TemplateTypeParmTypeLoc NewTL
1294        = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
1295      NewTL.setNameLoc(TL.getNameLoc());
1296      return TL.getType();
1297    }
1298
1299    TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1300
1301    if (T->isParameterPack()) {
1302      assert(Arg.getKind() == TemplateArgument::Pack &&
1303             "Missing argument pack");
1304
1305      if (getSema().ArgumentPackSubstitutionIndex == -1) {
1306        // We have the template argument pack, but we're not expanding the
1307        // enclosing pack expansion yet. Just save the template argument
1308        // pack for later substitution.
1309        QualType Result
1310          = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1311        SubstTemplateTypeParmPackTypeLoc NewTL
1312          = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
1313        NewTL.setNameLoc(TL.getNameLoc());
1314        return Result;
1315      }
1316
1317      assert(getSema().ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
1318      Arg = Arg.pack_begin()[getSema().ArgumentPackSubstitutionIndex];
1319    }
1320
1321    assert(Arg.getKind() == TemplateArgument::Type &&
1322           "Template argument kind mismatch");
1323
1324    QualType Replacement = Arg.getAsType();
1325
1326    // TODO: only do this uniquing once, at the start of instantiation.
1327    QualType Result
1328      = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1329    SubstTemplateTypeParmTypeLoc NewTL
1330      = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1331    NewTL.setNameLoc(TL.getNameLoc());
1332    return Result;
1333  }
1334
1335  // The template type parameter comes from an inner template (e.g.,
1336  // the template parameter list of a member template inside the
1337  // template we are instantiating). Create a new template type
1338  // parameter with the template "level" reduced by one.
1339  TemplateTypeParmDecl *NewTTPDecl = 0;
1340  if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
1341    NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1342                                  TransformDecl(TL.getNameLoc(), OldTTPDecl));
1343
1344  QualType Result
1345    = getSema().Context.getTemplateTypeParmType(T->getDepth()
1346                                                 - TemplateArgs.getNumLevels(),
1347                                                T->getIndex(),
1348                                                T->isParameterPack(),
1349                                                NewTTPDecl);
1350  TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
1351  NewTL.setNameLoc(TL.getNameLoc());
1352  return Result;
1353}
1354
1355QualType
1356TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1357                                                            TypeLocBuilder &TLB,
1358                                         SubstTemplateTypeParmPackTypeLoc TL) {
1359  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1360    // We aren't expanding the parameter pack, so just return ourselves.
1361    SubstTemplateTypeParmPackTypeLoc NewTL
1362      = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
1363    NewTL.setNameLoc(TL.getNameLoc());
1364    return TL.getType();
1365  }
1366
1367  const TemplateArgument &ArgPack = TL.getTypePtr()->getArgumentPack();
1368  unsigned Index = (unsigned)getSema().ArgumentPackSubstitutionIndex;
1369  assert(Index < ArgPack.pack_size() && "Substitution index out-of-range");
1370
1371  QualType Result = ArgPack.pack_begin()[Index].getAsType();
1372  Result = getSema().Context.getSubstTemplateTypeParmType(
1373                                      TL.getTypePtr()->getReplacedParameter(),
1374                                                          Result);
1375  SubstTemplateTypeParmTypeLoc NewTL
1376    = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1377  NewTL.setNameLoc(TL.getNameLoc());
1378  return Result;
1379}
1380
1381/// \brief Perform substitution on the type T with a given set of template
1382/// arguments.
1383///
1384/// This routine substitutes the given template arguments into the
1385/// type T and produces the instantiated type.
1386///
1387/// \param T the type into which the template arguments will be
1388/// substituted. If this type is not dependent, it will be returned
1389/// immediately.
1390///
1391/// \param Args the template arguments that will be
1392/// substituted for the top-level template parameters within T.
1393///
1394/// \param Loc the location in the source code where this substitution
1395/// is being performed. It will typically be the location of the
1396/// declarator (if we're instantiating the type of some declaration)
1397/// or the location of the type in the source code (if, e.g., we're
1398/// instantiating the type of a cast expression).
1399///
1400/// \param Entity the name of the entity associated with a declaration
1401/// being instantiated (if any). May be empty to indicate that there
1402/// is no such entity (if, e.g., this is a type that occurs as part of
1403/// a cast expression) or that the entity has no name (e.g., an
1404/// unnamed function parameter).
1405///
1406/// \returns If the instantiation succeeds, the instantiated
1407/// type. Otherwise, produces diagnostics and returns a NULL type.
1408TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
1409                                const MultiLevelTemplateArgumentList &Args,
1410                                SourceLocation Loc,
1411                                DeclarationName Entity) {
1412  assert(!ActiveTemplateInstantiations.empty() &&
1413         "Cannot perform an instantiation without some context on the "
1414         "instantiation stack");
1415
1416  if (!T->getType()->isInstantiationDependentType() &&
1417      !T->getType()->isVariablyModifiedType())
1418    return T;
1419
1420  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1421  return Instantiator.TransformType(T);
1422}
1423
1424TypeSourceInfo *Sema::SubstType(TypeLoc TL,
1425                                const MultiLevelTemplateArgumentList &Args,
1426                                SourceLocation Loc,
1427                                DeclarationName Entity) {
1428  assert(!ActiveTemplateInstantiations.empty() &&
1429         "Cannot perform an instantiation without some context on the "
1430         "instantiation stack");
1431
1432  if (TL.getType().isNull())
1433    return 0;
1434
1435  if (!TL.getType()->isInstantiationDependentType() &&
1436      !TL.getType()->isVariablyModifiedType()) {
1437    // FIXME: Make a copy of the TypeLoc data here, so that we can
1438    // return a new TypeSourceInfo. Inefficient!
1439    TypeLocBuilder TLB;
1440    TLB.pushFullCopy(TL);
1441    return TLB.getTypeSourceInfo(Context, TL.getType());
1442  }
1443
1444  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1445  TypeLocBuilder TLB;
1446  TLB.reserve(TL.getFullDataSize());
1447  QualType Result = Instantiator.TransformType(TLB, TL);
1448  if (Result.isNull())
1449    return 0;
1450
1451  return TLB.getTypeSourceInfo(Context, Result);
1452}
1453
1454/// Deprecated form of the above.
1455QualType Sema::SubstType(QualType T,
1456                         const MultiLevelTemplateArgumentList &TemplateArgs,
1457                         SourceLocation Loc, DeclarationName Entity) {
1458  assert(!ActiveTemplateInstantiations.empty() &&
1459         "Cannot perform an instantiation without some context on the "
1460         "instantiation stack");
1461
1462  // If T is not a dependent type or a variably-modified type, there
1463  // is nothing to do.
1464  if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
1465    return T;
1466
1467  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
1468  return Instantiator.TransformType(T);
1469}
1470
1471static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
1472  if (T->getType()->isInstantiationDependentType() ||
1473      T->getType()->isVariablyModifiedType())
1474    return true;
1475
1476  TypeLoc TL = T->getTypeLoc().IgnoreParens();
1477  if (!isa<FunctionProtoTypeLoc>(TL))
1478    return false;
1479
1480  FunctionProtoTypeLoc FP = cast<FunctionProtoTypeLoc>(TL);
1481  for (unsigned I = 0, E = FP.getNumArgs(); I != E; ++I) {
1482    ParmVarDecl *P = FP.getArg(I);
1483
1484    // The parameter's type as written might be dependent even if the
1485    // decayed type was not dependent.
1486    if (TypeSourceInfo *TSInfo = P->getTypeSourceInfo())
1487      if (TSInfo->getType()->isInstantiationDependentType())
1488        return true;
1489
1490    // TODO: currently we always rebuild expressions.  When we
1491    // properly get lazier about this, we should use the same
1492    // logic to avoid rebuilding prototypes here.
1493    if (P->hasDefaultArg())
1494      return true;
1495  }
1496
1497  return false;
1498}
1499
1500/// A form of SubstType intended specifically for instantiating the
1501/// type of a FunctionDecl.  Its purpose is solely to force the
1502/// instantiation of default-argument expressions.
1503TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
1504                                const MultiLevelTemplateArgumentList &Args,
1505                                SourceLocation Loc,
1506                                DeclarationName Entity,
1507                                CXXRecordDecl *ThisContext,
1508                                unsigned ThisTypeQuals) {
1509  assert(!ActiveTemplateInstantiations.empty() &&
1510         "Cannot perform an instantiation without some context on the "
1511         "instantiation stack");
1512
1513  if (!NeedsInstantiationAsFunctionType(T))
1514    return T;
1515
1516  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1517
1518  TypeLocBuilder TLB;
1519
1520  TypeLoc TL = T->getTypeLoc();
1521  TLB.reserve(TL.getFullDataSize());
1522
1523  QualType Result;
1524
1525  if (FunctionProtoTypeLoc *Proto = dyn_cast<FunctionProtoTypeLoc>(&TL)) {
1526    Result = Instantiator.TransformFunctionProtoType(TLB, *Proto, ThisContext,
1527                                                     ThisTypeQuals);
1528  } else {
1529    Result = Instantiator.TransformType(TLB, TL);
1530  }
1531  if (Result.isNull())
1532    return 0;
1533
1534  return TLB.getTypeSourceInfo(Context, Result);
1535}
1536
1537ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
1538                            const MultiLevelTemplateArgumentList &TemplateArgs,
1539                                    int indexAdjustment,
1540                                    llvm::Optional<unsigned> NumExpansions,
1541                                    bool ExpectParameterPack) {
1542  TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
1543  TypeSourceInfo *NewDI = 0;
1544
1545  TypeLoc OldTL = OldDI->getTypeLoc();
1546  if (isa<PackExpansionTypeLoc>(OldTL)) {
1547    PackExpansionTypeLoc ExpansionTL = cast<PackExpansionTypeLoc>(OldTL);
1548
1549    // We have a function parameter pack. Substitute into the pattern of the
1550    // expansion.
1551    NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1552                      OldParm->getLocation(), OldParm->getDeclName());
1553    if (!NewDI)
1554      return 0;
1555
1556    if (NewDI->getType()->containsUnexpandedParameterPack()) {
1557      // We still have unexpanded parameter packs, which means that
1558      // our function parameter is still a function parameter pack.
1559      // Therefore, make its type a pack expansion type.
1560      NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
1561                                 NumExpansions);
1562    } else if (ExpectParameterPack) {
1563      // We expected to get a parameter pack but didn't (because the type
1564      // itself is not a pack expansion type), so complain. This can occur when
1565      // the substitution goes through an alias template that "loses" the
1566      // pack expansion.
1567      Diag(OldParm->getLocation(),
1568           diag::err_function_parameter_pack_without_parameter_packs)
1569        << NewDI->getType();
1570      return 0;
1571    }
1572  } else {
1573    NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
1574                      OldParm->getDeclName());
1575  }
1576
1577  if (!NewDI)
1578    return 0;
1579
1580  if (NewDI->getType()->isVoidType()) {
1581    Diag(OldParm->getLocation(), diag::err_param_with_void_type);
1582    return 0;
1583  }
1584
1585  ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
1586                                        OldParm->getInnerLocStart(),
1587                                        OldParm->getLocation(),
1588                                        OldParm->getIdentifier(),
1589                                        NewDI->getType(), NewDI,
1590                                        OldParm->getStorageClass(),
1591                                        OldParm->getStorageClassAsWritten());
1592  if (!NewParm)
1593    return 0;
1594
1595  // Mark the (new) default argument as uninstantiated (if any).
1596  if (OldParm->hasUninstantiatedDefaultArg()) {
1597    Expr *Arg = OldParm->getUninstantiatedDefaultArg();
1598    NewParm->setUninstantiatedDefaultArg(Arg);
1599  } else if (OldParm->hasUnparsedDefaultArg()) {
1600    NewParm->setUnparsedDefaultArg();
1601    UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
1602  } else if (Expr *Arg = OldParm->getDefaultArg())
1603    // FIXME: if we non-lazily instantiated non-dependent default args for
1604    // non-dependent parameter types we could remove a bunch of duplicate
1605    // conversion warnings for such arguments.
1606    NewParm->setUninstantiatedDefaultArg(Arg);
1607
1608  NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());
1609
1610  if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
1611    // Add the new parameter to the instantiated parameter pack.
1612    CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
1613  } else {
1614    // Introduce an Old -> New mapping
1615    CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
1616  }
1617
1618  // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
1619  // can be anything, is this right ?
1620  NewParm->setDeclContext(CurContext);
1621
1622  NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
1623                        OldParm->getFunctionScopeIndex() + indexAdjustment);
1624
1625  return NewParm;
1626}
1627
1628/// \brief Substitute the given template arguments into the given set of
1629/// parameters, producing the set of parameter types that would be generated
1630/// from such a substitution.
1631bool Sema::SubstParmTypes(SourceLocation Loc,
1632                          ParmVarDecl **Params, unsigned NumParams,
1633                          const MultiLevelTemplateArgumentList &TemplateArgs,
1634                          SmallVectorImpl<QualType> &ParamTypes,
1635                          SmallVectorImpl<ParmVarDecl *> *OutParams) {
1636  assert(!ActiveTemplateInstantiations.empty() &&
1637         "Cannot perform an instantiation without some context on the "
1638         "instantiation stack");
1639
1640  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
1641                                    DeclarationName());
1642  return Instantiator.TransformFunctionTypeParams(Loc, Params, NumParams, 0,
1643                                                  ParamTypes, OutParams);
1644}
1645
1646/// \brief Perform substitution on the base class specifiers of the
1647/// given class template specialization.
1648///
1649/// Produces a diagnostic and returns true on error, returns false and
1650/// attaches the instantiated base classes to the class template
1651/// specialization if successful.
1652bool
1653Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
1654                          CXXRecordDecl *Pattern,
1655                          const MultiLevelTemplateArgumentList &TemplateArgs) {
1656  bool Invalid = false;
1657  SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
1658  for (ClassTemplateSpecializationDecl::base_class_iterator
1659         Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end();
1660       Base != BaseEnd; ++Base) {
1661    if (!Base->getType()->isDependentType()) {
1662      InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(*Base));
1663      continue;
1664    }
1665
1666    SourceLocation EllipsisLoc;
1667    TypeSourceInfo *BaseTypeLoc;
1668    if (Base->isPackExpansion()) {
1669      // This is a pack expansion. See whether we should expand it now, or
1670      // wait until later.
1671      SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1672      collectUnexpandedParameterPacks(Base->getTypeSourceInfo()->getTypeLoc(),
1673                                      Unexpanded);
1674      bool ShouldExpand = false;
1675      bool RetainExpansion = false;
1676      llvm::Optional<unsigned> NumExpansions;
1677      if (CheckParameterPacksForExpansion(Base->getEllipsisLoc(),
1678                                          Base->getSourceRange(),
1679                                          Unexpanded,
1680                                          TemplateArgs, ShouldExpand,
1681                                          RetainExpansion,
1682                                          NumExpansions)) {
1683        Invalid = true;
1684        continue;
1685      }
1686
1687      // If we should expand this pack expansion now, do so.
1688      if (ShouldExpand) {
1689        for (unsigned I = 0; I != *NumExpansions; ++I) {
1690            Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
1691
1692          TypeSourceInfo *BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1693                                                  TemplateArgs,
1694                                              Base->getSourceRange().getBegin(),
1695                                                  DeclarationName());
1696          if (!BaseTypeLoc) {
1697            Invalid = true;
1698            continue;
1699          }
1700
1701          if (CXXBaseSpecifier *InstantiatedBase
1702                = CheckBaseSpecifier(Instantiation,
1703                                     Base->getSourceRange(),
1704                                     Base->isVirtual(),
1705                                     Base->getAccessSpecifierAsWritten(),
1706                                     BaseTypeLoc,
1707                                     SourceLocation()))
1708            InstantiatedBases.push_back(InstantiatedBase);
1709          else
1710            Invalid = true;
1711        }
1712
1713        continue;
1714      }
1715
1716      // The resulting base specifier will (still) be a pack expansion.
1717      EllipsisLoc = Base->getEllipsisLoc();
1718      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
1719      BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1720                              TemplateArgs,
1721                              Base->getSourceRange().getBegin(),
1722                              DeclarationName());
1723    } else {
1724      BaseTypeLoc = SubstType(Base->getTypeSourceInfo(),
1725                              TemplateArgs,
1726                              Base->getSourceRange().getBegin(),
1727                              DeclarationName());
1728    }
1729
1730    if (!BaseTypeLoc) {
1731      Invalid = true;
1732      continue;
1733    }
1734
1735    if (CXXBaseSpecifier *InstantiatedBase
1736          = CheckBaseSpecifier(Instantiation,
1737                               Base->getSourceRange(),
1738                               Base->isVirtual(),
1739                               Base->getAccessSpecifierAsWritten(),
1740                               BaseTypeLoc,
1741                               EllipsisLoc))
1742      InstantiatedBases.push_back(InstantiatedBase);
1743    else
1744      Invalid = true;
1745  }
1746
1747  if (!Invalid &&
1748      AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(),
1749                           InstantiatedBases.size()))
1750    Invalid = true;
1751
1752  return Invalid;
1753}
1754
1755// Defined via #include from SemaTemplateInstantiateDecl.cpp
1756namespace clang {
1757  namespace sema {
1758    Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
1759                            const MultiLevelTemplateArgumentList &TemplateArgs);
1760  }
1761}
1762
1763/// Determine whether we would be unable to instantiate this template (because
1764/// it either has no definition, or is in the process of being instantiated).
1765static bool DiagnoseUninstantiableTemplate(Sema &S,
1766                                           SourceLocation PointOfInstantiation,
1767                                           TagDecl *Instantiation,
1768                                           bool InstantiatedFromMember,
1769                                           TagDecl *Pattern,
1770                                           TagDecl *PatternDef,
1771                                           TemplateSpecializationKind TSK,
1772                                           bool Complain = true) {
1773  if (PatternDef && !PatternDef->isBeingDefined())
1774    return false;
1775
1776  if (!Complain || (PatternDef && PatternDef->isInvalidDecl())) {
1777    // Say nothing
1778  } else if (PatternDef) {
1779    assert(PatternDef->isBeingDefined());
1780    S.Diag(PointOfInstantiation,
1781           diag::err_template_instantiate_within_definition)
1782      << (TSK != TSK_ImplicitInstantiation)
1783      << S.Context.getTypeDeclType(Instantiation);
1784    // Not much point in noting the template declaration here, since
1785    // we're lexically inside it.
1786    Instantiation->setInvalidDecl();
1787  } else if (InstantiatedFromMember) {
1788    S.Diag(PointOfInstantiation,
1789           diag::err_implicit_instantiate_member_undefined)
1790      << S.Context.getTypeDeclType(Instantiation);
1791    S.Diag(Pattern->getLocation(), diag::note_member_of_template_here);
1792  } else {
1793    S.Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
1794      << (TSK != TSK_ImplicitInstantiation)
1795      << S.Context.getTypeDeclType(Instantiation);
1796    S.Diag(Pattern->getLocation(), diag::note_template_decl_here);
1797  }
1798
1799  // In general, Instantiation isn't marked invalid to get more than one
1800  // error for multiple undefined instantiations. But the code that does
1801  // explicit declaration -> explicit definition conversion can't handle
1802  // invalid declarations, so mark as invalid in that case.
1803  if (TSK == TSK_ExplicitInstantiationDeclaration)
1804    Instantiation->setInvalidDecl();
1805  return true;
1806}
1807
1808/// \brief Instantiate the definition of a class from a given pattern.
1809///
1810/// \param PointOfInstantiation The point of instantiation within the
1811/// source code.
1812///
1813/// \param Instantiation is the declaration whose definition is being
1814/// instantiated. This will be either a class template specialization
1815/// or a member class of a class template specialization.
1816///
1817/// \param Pattern is the pattern from which the instantiation
1818/// occurs. This will be either the declaration of a class template or
1819/// the declaration of a member class of a class template.
1820///
1821/// \param TemplateArgs The template arguments to be substituted into
1822/// the pattern.
1823///
1824/// \param TSK the kind of implicit or explicit instantiation to perform.
1825///
1826/// \param Complain whether to complain if the class cannot be instantiated due
1827/// to the lack of a definition.
1828///
1829/// \returns true if an error occurred, false otherwise.
1830bool
1831Sema::InstantiateClass(SourceLocation PointOfInstantiation,
1832                       CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
1833                       const MultiLevelTemplateArgumentList &TemplateArgs,
1834                       TemplateSpecializationKind TSK,
1835                       bool Complain) {
1836  CXXRecordDecl *PatternDef
1837    = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
1838  if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation,
1839                                Instantiation->getInstantiatedFromMemberClass(),
1840                                     Pattern, PatternDef, TSK, Complain))
1841    return true;
1842  Pattern = PatternDef;
1843
1844  // \brief Record the point of instantiation.
1845  if (MemberSpecializationInfo *MSInfo
1846        = Instantiation->getMemberSpecializationInfo()) {
1847    MSInfo->setTemplateSpecializationKind(TSK);
1848    MSInfo->setPointOfInstantiation(PointOfInstantiation);
1849  } else if (ClassTemplateSpecializationDecl *Spec
1850        = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
1851    Spec->setTemplateSpecializationKind(TSK);
1852    Spec->setPointOfInstantiation(PointOfInstantiation);
1853  }
1854
1855  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
1856  if (Inst)
1857    return true;
1858
1859  // Enter the scope of this instantiation. We don't use
1860  // PushDeclContext because we don't have a scope.
1861  ContextRAII SavedContext(*this, Instantiation);
1862  EnterExpressionEvaluationContext EvalContext(*this,
1863                                               Sema::PotentiallyEvaluated);
1864
1865  // If this is an instantiation of a local class, merge this local
1866  // instantiation scope with the enclosing scope. Otherwise, every
1867  // instantiation of a class has its own local instantiation scope.
1868  bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
1869  LocalInstantiationScope Scope(*this, MergeWithParentScope);
1870
1871  // Pull attributes from the pattern onto the instantiation.
1872  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
1873
1874  // Start the definition of this instantiation.
1875  Instantiation->startDefinition();
1876
1877  Instantiation->setTagKind(Pattern->getTagKind());
1878
1879  // Do substitution on the base class specifiers.
1880  if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
1881    Instantiation->setInvalidDecl();
1882
1883  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
1884  SmallVector<Decl*, 4> Fields;
1885  SmallVector<std::pair<FieldDecl*, FieldDecl*>, 4>
1886    FieldsWithMemberInitializers;
1887  // Delay instantiation of late parsed attributes.
1888  LateInstantiatedAttrVec LateAttrs;
1889  Instantiator.enableLateAttributeInstantiation(&LateAttrs);
1890
1891  for (RecordDecl::decl_iterator Member = Pattern->decls_begin(),
1892         MemberEnd = Pattern->decls_end();
1893       Member != MemberEnd; ++Member) {
1894    // Don't instantiate members not belonging in this semantic context.
1895    // e.g. for:
1896    // @code
1897    //    template <int i> class A {
1898    //      class B *g;
1899    //    };
1900    // @endcode
1901    // 'class B' has the template as lexical context but semantically it is
1902    // introduced in namespace scope.
1903    if ((*Member)->getDeclContext() != Pattern)
1904      continue;
1905
1906    if ((*Member)->isInvalidDecl()) {
1907      Instantiation->setInvalidDecl();
1908      continue;
1909    }
1910
1911    Decl *NewMember = Instantiator.Visit(*Member);
1912    if (NewMember) {
1913      if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
1914        Fields.push_back(Field);
1915        FieldDecl *OldField = cast<FieldDecl>(*Member);
1916        if (OldField->getInClassInitializer())
1917          FieldsWithMemberInitializers.push_back(std::make_pair(OldField,
1918                                                                Field));
1919      } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
1920        // C++11 [temp.inst]p1: The implicit instantiation of a class template
1921        // specialization causes the implicit instantiation of the definitions
1922        // of unscoped member enumerations.
1923        // Record a point of instantiation for this implicit instantiation.
1924        if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
1925            Enum->isCompleteDefinition()) {
1926          MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
1927          assert(MSInfo && "no spec info for member enum specialization");
1928          MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
1929          MSInfo->setPointOfInstantiation(PointOfInstantiation);
1930        }
1931      }
1932
1933      if (NewMember->isInvalidDecl())
1934        Instantiation->setInvalidDecl();
1935    } else {
1936      // FIXME: Eventually, a NULL return will mean that one of the
1937      // instantiations was a semantic disaster, and we'll want to mark the
1938      // declaration invalid.
1939      // For now, we expect to skip some members that we can't yet handle.
1940    }
1941  }
1942
1943  // Finish checking fields.
1944  ActOnFields(0, Instantiation->getLocation(), Instantiation, Fields,
1945              SourceLocation(), SourceLocation(), 0);
1946  CheckCompletedCXXClass(Instantiation);
1947
1948  // Attach any in-class member initializers now the class is complete.
1949  if (!FieldsWithMemberInitializers.empty()) {
1950    // C++11 [expr.prim.general]p4:
1951    //   Otherwise, if a member-declarator declares a non-static data member
1952    //  (9.2) of a class X, the expression this is a prvalue of type "pointer
1953    //  to X" within the optional brace-or-equal-initializer. It shall not
1954    //  appear elsewhere in the member-declarator.
1955    CXXThisScopeRAII ThisScope(*this, Instantiation, (unsigned)0);
1956
1957    for (unsigned I = 0, N = FieldsWithMemberInitializers.size(); I != N; ++I) {
1958      FieldDecl *OldField = FieldsWithMemberInitializers[I].first;
1959      FieldDecl *NewField = FieldsWithMemberInitializers[I].second;
1960      Expr *OldInit = OldField->getInClassInitializer();
1961
1962      ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
1963                                            /*CXXDirectInit=*/false);
1964      if (NewInit.isInvalid())
1965        NewField->setInvalidDecl();
1966      else {
1967        Expr *Init = NewInit.take();
1968        assert(Init && "no-argument initializer in class");
1969        assert(!isa<ParenListExpr>(Init) && "call-style init in class");
1970        ActOnCXXInClassMemberInitializer(NewField, Init->getLocStart(), Init);
1971      }
1972    }
1973  }
1974  // Instantiate late parsed attributes, and attach them to their decls.
1975  // See Sema::InstantiateAttrs
1976  for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
1977       E = LateAttrs.end(); I != E; ++I) {
1978    assert(CurrentInstantiationScope == Instantiator.getStartingScope());
1979    CurrentInstantiationScope = I->Scope;
1980    Attr *NewAttr =
1981      instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
1982    I->NewDecl->addAttr(NewAttr);
1983    LocalInstantiationScope::deleteScopes(I->Scope,
1984                                          Instantiator.getStartingScope());
1985  }
1986  Instantiator.disableLateAttributeInstantiation();
1987  LateAttrs.clear();
1988
1989  if (!FieldsWithMemberInitializers.empty())
1990    ActOnFinishDelayedMemberInitializers(Instantiation);
1991
1992  if (TSK == TSK_ImplicitInstantiation) {
1993    Instantiation->setLocation(Pattern->getLocation());
1994    Instantiation->setLocStart(Pattern->getInnerLocStart());
1995    Instantiation->setRBraceLoc(Pattern->getRBraceLoc());
1996  }
1997
1998  if (!Instantiation->isInvalidDecl()) {
1999    // Instantiate any out-of-line class template partial
2000    // specializations now.
2001    for (TemplateDeclInstantiator::delayed_partial_spec_iterator
2002              P = Instantiator.delayed_partial_spec_begin(),
2003           PEnd = Instantiator.delayed_partial_spec_end();
2004         P != PEnd; ++P) {
2005      if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
2006                                                                P->first,
2007                                                                P->second)) {
2008        Instantiation->setInvalidDecl();
2009        break;
2010      }
2011    }
2012  }
2013
2014  // Exit the scope of this instantiation.
2015  SavedContext.pop();
2016
2017  if (!Instantiation->isInvalidDecl()) {
2018    Consumer.HandleTagDeclDefinition(Instantiation);
2019
2020    // Always emit the vtable for an explicit instantiation definition
2021    // of a polymorphic class template specialization.
2022    if (TSK == TSK_ExplicitInstantiationDefinition)
2023      MarkVTableUsed(PointOfInstantiation, Instantiation, true);
2024  }
2025
2026  return Instantiation->isInvalidDecl();
2027}
2028
2029/// \brief Instantiate the definition of an enum from a given pattern.
2030///
2031/// \param PointOfInstantiation The point of instantiation within the
2032///        source code.
2033/// \param Instantiation is the declaration whose definition is being
2034///        instantiated. This will be a member enumeration of a class
2035///        temploid specialization, or a local enumeration within a
2036///        function temploid specialization.
2037/// \param Pattern The templated declaration from which the instantiation
2038///        occurs.
2039/// \param TemplateArgs The template arguments to be substituted into
2040///        the pattern.
2041/// \param TSK The kind of implicit or explicit instantiation to perform.
2042///
2043/// \return \c true if an error occurred, \c false otherwise.
2044bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2045                           EnumDecl *Instantiation, EnumDecl *Pattern,
2046                           const MultiLevelTemplateArgumentList &TemplateArgs,
2047                           TemplateSpecializationKind TSK) {
2048  EnumDecl *PatternDef = Pattern->getDefinition();
2049  if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation,
2050                                 Instantiation->getInstantiatedFromMemberEnum(),
2051                                     Pattern, PatternDef, TSK,/*Complain*/true))
2052    return true;
2053  Pattern = PatternDef;
2054
2055  // Record the point of instantiation.
2056  if (MemberSpecializationInfo *MSInfo
2057        = Instantiation->getMemberSpecializationInfo()) {
2058    MSInfo->setTemplateSpecializationKind(TSK);
2059    MSInfo->setPointOfInstantiation(PointOfInstantiation);
2060  }
2061
2062  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2063  if (Inst)
2064    return true;
2065
2066  // Enter the scope of this instantiation. We don't use
2067  // PushDeclContext because we don't have a scope.
2068  ContextRAII SavedContext(*this, Instantiation);
2069  EnterExpressionEvaluationContext EvalContext(*this,
2070                                               Sema::PotentiallyEvaluated);
2071
2072  LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2073
2074  // Pull attributes from the pattern onto the instantiation.
2075  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2076
2077  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2078  Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2079
2080  // Exit the scope of this instantiation.
2081  SavedContext.pop();
2082
2083  return Instantiation->isInvalidDecl();
2084}
2085
2086namespace {
2087  /// \brief A partial specialization whose template arguments have matched
2088  /// a given template-id.
2089  struct PartialSpecMatchResult {
2090    ClassTemplatePartialSpecializationDecl *Partial;
2091    TemplateArgumentList *Args;
2092  };
2093}
2094
2095bool
2096Sema::InstantiateClassTemplateSpecialization(
2097                           SourceLocation PointOfInstantiation,
2098                           ClassTemplateSpecializationDecl *ClassTemplateSpec,
2099                           TemplateSpecializationKind TSK,
2100                           bool Complain) {
2101  // Perform the actual instantiation on the canonical declaration.
2102  ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2103                                         ClassTemplateSpec->getCanonicalDecl());
2104
2105  // Check whether we have already instantiated or specialized this class
2106  // template specialization.
2107  if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) {
2108    if (ClassTemplateSpec->getSpecializationKind() ==
2109          TSK_ExplicitInstantiationDeclaration &&
2110        TSK == TSK_ExplicitInstantiationDefinition) {
2111      // An explicit instantiation definition follows an explicit instantiation
2112      // declaration (C++0x [temp.explicit]p10); go ahead and perform the
2113      // explicit instantiation.
2114      ClassTemplateSpec->setSpecializationKind(TSK);
2115
2116      // If this is an explicit instantiation definition, mark the
2117      // vtable as used.
2118      if (TSK == TSK_ExplicitInstantiationDefinition &&
2119          !ClassTemplateSpec->isInvalidDecl())
2120        MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true);
2121
2122      return false;
2123    }
2124
2125    // We can only instantiate something that hasn't already been
2126    // instantiated or specialized. Fail without any diagnostics: our
2127    // caller will provide an error message.
2128    return true;
2129  }
2130
2131  if (ClassTemplateSpec->isInvalidDecl())
2132    return true;
2133
2134  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
2135  CXXRecordDecl *Pattern = 0;
2136
2137  // C++ [temp.class.spec.match]p1:
2138  //   When a class template is used in a context that requires an
2139  //   instantiation of the class, it is necessary to determine
2140  //   whether the instantiation is to be generated using the primary
2141  //   template or one of the partial specializations. This is done by
2142  //   matching the template arguments of the class template
2143  //   specialization with the template argument lists of the partial
2144  //   specializations.
2145  typedef PartialSpecMatchResult MatchResult;
2146  SmallVector<MatchResult, 4> Matched;
2147  SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
2148  Template->getPartialSpecializations(PartialSpecs);
2149  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2150    ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
2151    TemplateDeductionInfo Info(Context, PointOfInstantiation);
2152    if (TemplateDeductionResult Result
2153          = DeduceTemplateArguments(Partial,
2154                                    ClassTemplateSpec->getTemplateArgs(),
2155                                    Info)) {
2156      // FIXME: Store the failed-deduction information for use in
2157      // diagnostics, later.
2158      (void)Result;
2159    } else {
2160      Matched.push_back(PartialSpecMatchResult());
2161      Matched.back().Partial = Partial;
2162      Matched.back().Args = Info.take();
2163    }
2164  }
2165
2166  // If we're dealing with a member template where the template parameters
2167  // have been instantiated, this provides the original template parameters
2168  // from which the member template's parameters were instantiated.
2169  SmallVector<const NamedDecl *, 4> InstantiatedTemplateParameters;
2170
2171  if (Matched.size() >= 1) {
2172    SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
2173    if (Matched.size() == 1) {
2174      //   -- If exactly one matching specialization is found, the
2175      //      instantiation is generated from that specialization.
2176      // We don't need to do anything for this.
2177    } else {
2178      //   -- If more than one matching specialization is found, the
2179      //      partial order rules (14.5.4.2) are used to determine
2180      //      whether one of the specializations is more specialized
2181      //      than the others. If none of the specializations is more
2182      //      specialized than all of the other matching
2183      //      specializations, then the use of the class template is
2184      //      ambiguous and the program is ill-formed.
2185      for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
2186                                                    PEnd = Matched.end();
2187           P != PEnd; ++P) {
2188        if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
2189                                                    PointOfInstantiation)
2190              == P->Partial)
2191          Best = P;
2192      }
2193
2194      // Determine if the best partial specialization is more specialized than
2195      // the others.
2196      bool Ambiguous = false;
2197      for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
2198                                                    PEnd = Matched.end();
2199           P != PEnd; ++P) {
2200        if (P != Best &&
2201            getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
2202                                                    PointOfInstantiation)
2203              != Best->Partial) {
2204          Ambiguous = true;
2205          break;
2206        }
2207      }
2208
2209      if (Ambiguous) {
2210        // Partial ordering did not produce a clear winner. Complain.
2211        ClassTemplateSpec->setInvalidDecl();
2212        Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2213          << ClassTemplateSpec;
2214
2215        // Print the matching partial specializations.
2216        for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
2217                                                      PEnd = Matched.end();
2218             P != PEnd; ++P)
2219          Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2220            << getTemplateArgumentBindingsText(
2221                                            P->Partial->getTemplateParameters(),
2222                                               *P->Args);
2223
2224        return true;
2225      }
2226    }
2227
2228    // Instantiate using the best class template partial specialization.
2229    ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
2230    while (OrigPartialSpec->getInstantiatedFromMember()) {
2231      // If we've found an explicit specialization of this class template,
2232      // stop here and use that as the pattern.
2233      if (OrigPartialSpec->isMemberSpecialization())
2234        break;
2235
2236      OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember();
2237    }
2238
2239    Pattern = OrigPartialSpec;
2240    ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
2241  } else {
2242    //   -- If no matches are found, the instantiation is generated
2243    //      from the primary template.
2244    ClassTemplateDecl *OrigTemplate = Template;
2245    while (OrigTemplate->getInstantiatedFromMemberTemplate()) {
2246      // If we've found an explicit specialization of this class template,
2247      // stop here and use that as the pattern.
2248      if (OrigTemplate->isMemberSpecialization())
2249        break;
2250
2251      OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate();
2252    }
2253
2254    Pattern = OrigTemplate->getTemplatedDecl();
2255  }
2256
2257  bool Result = InstantiateClass(PointOfInstantiation, ClassTemplateSpec,
2258                                 Pattern,
2259                                getTemplateInstantiationArgs(ClassTemplateSpec),
2260                                 TSK,
2261                                 Complain);
2262
2263  return Result;
2264}
2265
2266/// \brief Instantiates the definitions of all of the member
2267/// of the given class, which is an instantiation of a class template
2268/// or a member class of a template.
2269void
2270Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
2271                              CXXRecordDecl *Instantiation,
2272                        const MultiLevelTemplateArgumentList &TemplateArgs,
2273                              TemplateSpecializationKind TSK) {
2274  for (DeclContext::decl_iterator D = Instantiation->decls_begin(),
2275                               DEnd = Instantiation->decls_end();
2276       D != DEnd; ++D) {
2277    bool SuppressNew = false;
2278    if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) {
2279      if (FunctionDecl *Pattern
2280            = Function->getInstantiatedFromMemberFunction()) {
2281        MemberSpecializationInfo *MSInfo
2282          = Function->getMemberSpecializationInfo();
2283        assert(MSInfo && "No member specialization information?");
2284        if (MSInfo->getTemplateSpecializationKind()
2285                                                 == TSK_ExplicitSpecialization)
2286          continue;
2287
2288        if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2289                                                   Function,
2290                                        MSInfo->getTemplateSpecializationKind(),
2291                                              MSInfo->getPointOfInstantiation(),
2292                                                   SuppressNew) ||
2293            SuppressNew)
2294          continue;
2295
2296        if (Function->isDefined())
2297          continue;
2298
2299        if (TSK == TSK_ExplicitInstantiationDefinition) {
2300          // C++0x [temp.explicit]p8:
2301          //   An explicit instantiation definition that names a class template
2302          //   specialization explicitly instantiates the class template
2303          //   specialization and is only an explicit instantiation definition
2304          //   of members whose definition is visible at the point of
2305          //   instantiation.
2306          if (!Pattern->isDefined())
2307            continue;
2308
2309          Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2310
2311          InstantiateFunctionDefinition(PointOfInstantiation, Function);
2312        } else {
2313          Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2314        }
2315      }
2316    } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) {
2317      if (Var->isStaticDataMember()) {
2318        MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
2319        assert(MSInfo && "No member specialization information?");
2320        if (MSInfo->getTemplateSpecializationKind()
2321                                                 == TSK_ExplicitSpecialization)
2322          continue;
2323
2324        if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2325                                                   Var,
2326                                        MSInfo->getTemplateSpecializationKind(),
2327                                              MSInfo->getPointOfInstantiation(),
2328                                                   SuppressNew) ||
2329            SuppressNew)
2330          continue;
2331
2332        if (TSK == TSK_ExplicitInstantiationDefinition) {
2333          // C++0x [temp.explicit]p8:
2334          //   An explicit instantiation definition that names a class template
2335          //   specialization explicitly instantiates the class template
2336          //   specialization and is only an explicit instantiation definition
2337          //   of members whose definition is visible at the point of
2338          //   instantiation.
2339          if (!Var->getInstantiatedFromStaticDataMember()
2340                                                     ->getOutOfLineDefinition())
2341            continue;
2342
2343          Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2344          InstantiateStaticDataMemberDefinition(PointOfInstantiation, Var);
2345        } else {
2346          Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2347        }
2348      }
2349    } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) {
2350      // Always skip the injected-class-name, along with any
2351      // redeclarations of nested classes, since both would cause us
2352      // to try to instantiate the members of a class twice.
2353      if (Record->isInjectedClassName() || Record->getPreviousDecl())
2354        continue;
2355
2356      MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
2357      assert(MSInfo && "No member specialization information?");
2358
2359      if (MSInfo->getTemplateSpecializationKind()
2360                                                == TSK_ExplicitSpecialization)
2361        continue;
2362
2363      if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2364                                                 Record,
2365                                        MSInfo->getTemplateSpecializationKind(),
2366                                              MSInfo->getPointOfInstantiation(),
2367                                                 SuppressNew) ||
2368          SuppressNew)
2369        continue;
2370
2371      CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
2372      assert(Pattern && "Missing instantiated-from-template information");
2373
2374      if (!Record->getDefinition()) {
2375        if (!Pattern->getDefinition()) {
2376          // C++0x [temp.explicit]p8:
2377          //   An explicit instantiation definition that names a class template
2378          //   specialization explicitly instantiates the class template
2379          //   specialization and is only an explicit instantiation definition
2380          //   of members whose definition is visible at the point of
2381          //   instantiation.
2382          if (TSK == TSK_ExplicitInstantiationDeclaration) {
2383            MSInfo->setTemplateSpecializationKind(TSK);
2384            MSInfo->setPointOfInstantiation(PointOfInstantiation);
2385          }
2386
2387          continue;
2388        }
2389
2390        InstantiateClass(PointOfInstantiation, Record, Pattern,
2391                         TemplateArgs,
2392                         TSK);
2393      } else {
2394        if (TSK == TSK_ExplicitInstantiationDefinition &&
2395            Record->getTemplateSpecializationKind() ==
2396                TSK_ExplicitInstantiationDeclaration) {
2397          Record->setTemplateSpecializationKind(TSK);
2398          MarkVTableUsed(PointOfInstantiation, Record, true);
2399        }
2400      }
2401
2402      Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2403      if (Pattern)
2404        InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
2405                                TSK);
2406    } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(*D)) {
2407      MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
2408      assert(MSInfo && "No member specialization information?");
2409
2410      if (MSInfo->getTemplateSpecializationKind()
2411            == TSK_ExplicitSpecialization)
2412        continue;
2413
2414      if (CheckSpecializationInstantiationRedecl(
2415            PointOfInstantiation, TSK, Enum,
2416            MSInfo->getTemplateSpecializationKind(),
2417            MSInfo->getPointOfInstantiation(), SuppressNew) ||
2418          SuppressNew)
2419        continue;
2420
2421      if (Enum->getDefinition())
2422        continue;
2423
2424      EnumDecl *Pattern = Enum->getInstantiatedFromMemberEnum();
2425      assert(Pattern && "Missing instantiated-from-template information");
2426
2427      if (TSK == TSK_ExplicitInstantiationDefinition) {
2428        if (!Pattern->getDefinition())
2429          continue;
2430
2431        InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2432      } else {
2433        MSInfo->setTemplateSpecializationKind(TSK);
2434        MSInfo->setPointOfInstantiation(PointOfInstantiation);
2435      }
2436    }
2437  }
2438}
2439
2440/// \brief Instantiate the definitions of all of the members of the
2441/// given class template specialization, which was named as part of an
2442/// explicit instantiation.
2443void
2444Sema::InstantiateClassTemplateSpecializationMembers(
2445                                           SourceLocation PointOfInstantiation,
2446                            ClassTemplateSpecializationDecl *ClassTemplateSpec,
2447                                               TemplateSpecializationKind TSK) {
2448  // C++0x [temp.explicit]p7:
2449  //   An explicit instantiation that names a class template
2450  //   specialization is an explicit instantion of the same kind
2451  //   (declaration or definition) of each of its members (not
2452  //   including members inherited from base classes) that has not
2453  //   been previously explicitly specialized in the translation unit
2454  //   containing the explicit instantiation, except as described
2455  //   below.
2456  InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
2457                          getTemplateInstantiationArgs(ClassTemplateSpec),
2458                          TSK);
2459}
2460
2461StmtResult
2462Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
2463  if (!S)
2464    return Owned(S);
2465
2466  TemplateInstantiator Instantiator(*this, TemplateArgs,
2467                                    SourceLocation(),
2468                                    DeclarationName());
2469  return Instantiator.TransformStmt(S);
2470}
2471
2472ExprResult
2473Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
2474  if (!E)
2475    return Owned(E);
2476
2477  TemplateInstantiator Instantiator(*this, TemplateArgs,
2478                                    SourceLocation(),
2479                                    DeclarationName());
2480  return Instantiator.TransformExpr(E);
2481}
2482
2483bool Sema::SubstExprs(Expr **Exprs, unsigned NumExprs, bool IsCall,
2484                      const MultiLevelTemplateArgumentList &TemplateArgs,
2485                      SmallVectorImpl<Expr *> &Outputs) {
2486  if (NumExprs == 0)
2487    return false;
2488
2489  TemplateInstantiator Instantiator(*this, TemplateArgs,
2490                                    SourceLocation(),
2491                                    DeclarationName());
2492  return Instantiator.TransformExprs(Exprs, NumExprs, IsCall, Outputs);
2493}
2494
2495NestedNameSpecifierLoc
2496Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
2497                        const MultiLevelTemplateArgumentList &TemplateArgs) {
2498  if (!NNS)
2499    return NestedNameSpecifierLoc();
2500
2501  TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
2502                                    DeclarationName());
2503  return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2504}
2505
2506/// \brief Do template substitution on declaration name info.
2507DeclarationNameInfo
2508Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
2509                         const MultiLevelTemplateArgumentList &TemplateArgs) {
2510  TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
2511                                    NameInfo.getName());
2512  return Instantiator.TransformDeclarationNameInfo(NameInfo);
2513}
2514
2515TemplateName
2516Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
2517                        TemplateName Name, SourceLocation Loc,
2518                        const MultiLevelTemplateArgumentList &TemplateArgs) {
2519  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2520                                    DeclarationName());
2521  CXXScopeSpec SS;
2522  SS.Adopt(QualifierLoc);
2523  return Instantiator.TransformTemplateName(SS, Name, Loc);
2524}
2525
2526bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
2527                 TemplateArgumentListInfo &Result,
2528                 const MultiLevelTemplateArgumentList &TemplateArgs) {
2529  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
2530                                    DeclarationName());
2531
2532  return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2533}
2534
2535llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2536LocalInstantiationScope::findInstantiationOf(const Decl *D) {
2537  for (LocalInstantiationScope *Current = this; Current;
2538       Current = Current->Outer) {
2539
2540    // Check if we found something within this scope.
2541    const Decl *CheckD = D;
2542    do {
2543      LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2544      if (Found != Current->LocalDecls.end())
2545        return &Found->second;
2546
2547      // If this is a tag declaration, it's possible that we need to look for
2548      // a previous declaration.
2549      if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2550        CheckD = Tag->getPreviousDecl();
2551      else
2552        CheckD = 0;
2553    } while (CheckD);
2554
2555    // If we aren't combined with our outer scope, we're done.
2556    if (!Current->CombineWithOuterScope)
2557      break;
2558  }
2559
2560  // If we didn't find the decl, then we either have a sema bug, or we have a
2561  // forward reference to a label declaration.  Return null to indicate that
2562  // we have an uninstantiated label.
2563  assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope");
2564  return 0;
2565}
2566
2567void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
2568  llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2569  if (Stored.isNull())
2570    Stored = Inst;
2571  else if (Stored.is<Decl *>()) {
2572    assert(Stored.get<Decl *>() == Inst && "Already instantiated this local");
2573    Stored = Inst;
2574  } else
2575    LocalDecls[D].get<DeclArgumentPack *>()->push_back(Inst);
2576}
2577
2578void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
2579                                                       Decl *Inst) {
2580  DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2581  Pack->push_back(Inst);
2582}
2583
2584void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
2585  llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2586  assert(Stored.isNull() && "Already instantiated this local");
2587  DeclArgumentPack *Pack = new DeclArgumentPack;
2588  Stored = Pack;
2589  ArgumentPacks.push_back(Pack);
2590}
2591
2592void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
2593                                          const TemplateArgument *ExplicitArgs,
2594                                                    unsigned NumExplicitArgs) {
2595  assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2596         "Already have a partially-substituted pack");
2597  assert((!PartiallySubstitutedPack
2598          || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2599         "Wrong number of arguments in partially-substituted pack");
2600  PartiallySubstitutedPack = Pack;
2601  ArgsInPartiallySubstitutedPack = ExplicitArgs;
2602  NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2603}
2604
2605NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
2606                                         const TemplateArgument **ExplicitArgs,
2607                                              unsigned *NumExplicitArgs) const {
2608  if (ExplicitArgs)
2609    *ExplicitArgs = 0;
2610  if (NumExplicitArgs)
2611    *NumExplicitArgs = 0;
2612
2613  for (const LocalInstantiationScope *Current = this; Current;
2614       Current = Current->Outer) {
2615    if (Current->PartiallySubstitutedPack) {
2616      if (ExplicitArgs)
2617        *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
2618      if (NumExplicitArgs)
2619        *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
2620
2621      return Current->PartiallySubstitutedPack;
2622    }
2623
2624    if (!Current->CombineWithOuterScope)
2625      break;
2626  }
2627
2628  return 0;
2629}
2630