clang  7.0.0svn
SemaTemplateInstantiate.cpp
Go to the documentation of this file.
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 
14 #include "TreeTransform.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTLambda.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
22 #include "clang/Sema/DeclSpec.h"
24 #include "clang/Sema/Lookup.h"
26 #include "clang/Sema/Template.h"
29 
30 using namespace clang;
31 using namespace sema;
32 
33 //===----------------------------------------------------------------------===/
34 // Template Instantiation Support
35 //===----------------------------------------------------------------------===/
36 
37 /// \brief Retrieve the template argument list(s) that should be used to
38 /// instantiate the definition of the given declaration.
39 ///
40 /// \param D the declaration for which we are computing template instantiation
41 /// arguments.
42 ///
43 /// \param Innermost if non-NULL, the innermost template argument list.
44 ///
45 /// \param RelativeToPrimary true if we should get the template
46 /// arguments relative to the primary template, even when we're
47 /// dealing with a specialization. This is only relevant for function
48 /// template specializations.
49 ///
50 /// \param Pattern If non-NULL, indicates the pattern from which we will be
51 /// instantiating the definition of the given declaration, \p D. This is
52 /// used to determine the proper set of template instantiation arguments for
53 /// friend function template specializations.
56  const TemplateArgumentList *Innermost,
57  bool RelativeToPrimary,
58  const FunctionDecl *Pattern) {
59  // Accumulate the set of template argument lists in this structure.
61 
62  if (Innermost)
63  Result.addOuterTemplateArguments(Innermost);
64 
65  DeclContext *Ctx = dyn_cast<DeclContext>(D);
66  if (!Ctx) {
67  Ctx = D->getDeclContext();
68 
69  // Add template arguments from a variable template instantiation.
71  dyn_cast<VarTemplateSpecializationDecl>(D)) {
72  // We're done when we hit an explicit specialization.
73  if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
74  !isa<VarTemplatePartialSpecializationDecl>(Spec))
75  return Result;
76 
77  Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
78 
79  // If this variable template specialization was instantiated from a
80  // specialized member that is a variable template, we're done.
81  assert(Spec->getSpecializedTemplate() && "No variable template?");
82  llvm::PointerUnion<VarTemplateDecl*,
86  Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
87  if (Partial->isMemberSpecialization())
88  return Result;
89  } else {
90  VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
91  if (Tmpl->isMemberSpecialization())
92  return Result;
93  }
94  }
95 
96  // If we have a template template parameter with translation unit context,
97  // then we're performing substitution into a default template argument of
98  // this template template parameter before we've constructed the template
99  // that will own this template template parameter. In this case, we
100  // use empty template parameter lists for all of the outer templates
101  // to avoid performing any substitutions.
102  if (Ctx->isTranslationUnit()) {
103  if (TemplateTemplateParmDecl *TTP
104  = dyn_cast<TemplateTemplateParmDecl>(D)) {
105  for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
106  Result.addOuterTemplateArguments(None);
107  return Result;
108  }
109  }
110  }
111 
112  while (!Ctx->isFileContext()) {
113  // Add template arguments from a class template instantiation.
115  = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
116  // We're done when we hit an explicit specialization.
117  if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
118  !isa<ClassTemplatePartialSpecializationDecl>(Spec))
119  break;
120 
121  Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
122 
123  // If this class template specialization was instantiated from a
124  // specialized member that is a class template, we're done.
125  assert(Spec->getSpecializedTemplate() && "No class template?");
126  if (Spec->getSpecializedTemplate()->isMemberSpecialization())
127  break;
128  }
129  // Add template arguments from a function template specialization.
130  else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
131  if (!RelativeToPrimary &&
132  (Function->getTemplateSpecializationKind() ==
134  !Function->getClassScopeSpecializationPattern()))
135  break;
136 
137  if (const TemplateArgumentList *TemplateArgs
138  = Function->getTemplateSpecializationArgs()) {
139  // Add the template arguments for this specialization.
140  Result.addOuterTemplateArguments(TemplateArgs);
141 
142  // If this function was instantiated from a specialized member that is
143  // a function template, we're done.
144  assert(Function->getPrimaryTemplate() && "No function template?");
145  if (Function->getPrimaryTemplate()->isMemberSpecialization())
146  break;
147 
148  // If this function is a generic lambda specialization, we are done.
150  break;
151 
152  } else if (FunctionTemplateDecl *FunTmpl
153  = Function->getDescribedFunctionTemplate()) {
154  // Add the "injected" template arguments.
155  Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
156  }
157 
158  // If this is a friend declaration and it declares an entity at
159  // namespace scope, take arguments from its lexical parent
160  // instead of its semantic parent, unless of course the pattern we're
161  // instantiating actually comes from the file's context!
162  if (Function->getFriendObjectKind() &&
163  Function->getDeclContext()->isFileContext() &&
164  (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
165  Ctx = Function->getLexicalDeclContext();
166  RelativeToPrimary = false;
167  continue;
168  }
169  } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
170  if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
171  QualType T = ClassTemplate->getInjectedClassNameSpecialization();
172  const TemplateSpecializationType *TST =
173  cast<TemplateSpecializationType>(Context.getCanonicalType(T));
175  llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
176  if (ClassTemplate->isMemberSpecialization())
177  break;
178  }
179  }
180 
181  Ctx = Ctx->getParent();
182  RelativeToPrimary = false;
183  }
184 
185  return Result;
186 }
187 
189  switch (Kind) {
190  case TemplateInstantiation:
191  case ExceptionSpecInstantiation:
192  case DefaultTemplateArgumentInstantiation:
193  case DefaultFunctionArgumentInstantiation:
194  case ExplicitTemplateArgumentSubstitution:
195  case DeducedTemplateArgumentSubstitution:
196  case PriorTemplateArgumentSubstitution:
197  return true;
198 
199  case DefaultTemplateArgumentChecking:
200  case DeclaringSpecialMember:
201  case DefiningSynthesizedFunction:
202  return false;
203 
204  // This function should never be called when Kind's value is Memoization.
205  case Memoization:
206  break;
207  }
208 
209  llvm_unreachable("Invalid SynthesisKind!");
210 }
211 
214  SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
215  Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
216  sema::TemplateDeductionInfo *DeductionInfo)
217  : SemaRef(SemaRef) {
218  // Don't allow further instantiation if a fatal error and an uncompilable
219  // error have occurred. Any diagnostics we might have raised will not be
220  // visible, and we do not need to construct a correct AST.
221  if (SemaRef.Diags.hasFatalErrorOccurred() &&
223  Invalid = true;
224  return;
225  }
226  Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
227  if (!Invalid) {
229  Inst.Kind = Kind;
230  Inst.PointOfInstantiation = PointOfInstantiation;
231  Inst.Entity = Entity;
232  Inst.Template = Template;
233  Inst.TemplateArgs = TemplateArgs.data();
234  Inst.NumTemplateArgs = TemplateArgs.size();
235  Inst.DeductionInfo = DeductionInfo;
236  Inst.InstantiationRange = InstantiationRange;
237  SemaRef.pushCodeSynthesisContext(Inst);
238 
239  AlreadyInstantiating =
241  .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
242  .second;
243  atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
244  }
245 }
246 
248  Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
249  SourceRange InstantiationRange)
250  : InstantiatingTemplate(SemaRef,
251  CodeSynthesisContext::TemplateInstantiation,
252  PointOfInstantiation, InstantiationRange, Entity) {}
253 
255  Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
256  ExceptionSpecification, SourceRange InstantiationRange)
258  SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
259  PointOfInstantiation, InstantiationRange, Entity) {}
260 
262  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
263  TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
264  SourceRange InstantiationRange)
266  SemaRef,
267  CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
268  PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
269  Template, TemplateArgs) {}
270 
272  Sema &SemaRef, SourceLocation PointOfInstantiation,
273  FunctionTemplateDecl *FunctionTemplate,
274  ArrayRef<TemplateArgument> TemplateArgs,
276  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
277  : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
278  InstantiationRange, FunctionTemplate, nullptr,
279  TemplateArgs, &DeductionInfo) {
280  assert(
283 }
284 
286  Sema &SemaRef, SourceLocation PointOfInstantiation,
287  TemplateDecl *Template,
288  ArrayRef<TemplateArgument> TemplateArgs,
289  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
291  SemaRef,
292  CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
293  PointOfInstantiation, InstantiationRange, Template, nullptr,
294  TemplateArgs, &DeductionInfo) {}
295 
297  Sema &SemaRef, SourceLocation PointOfInstantiation,
299  ArrayRef<TemplateArgument> TemplateArgs,
300  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
302  SemaRef,
303  CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
304  PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
305  TemplateArgs, &DeductionInfo) {}
306 
308  Sema &SemaRef, SourceLocation PointOfInstantiation,
310  ArrayRef<TemplateArgument> TemplateArgs,
311  sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
313  SemaRef,
314  CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
315  PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
316  TemplateArgs, &DeductionInfo) {}
317 
319  Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
320  ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
322  SemaRef,
323  CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
324  PointOfInstantiation, InstantiationRange, Param, nullptr,
325  TemplateArgs) {}
326 
328  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
330  SourceRange InstantiationRange)
332  SemaRef,
333  CodeSynthesisContext::PriorTemplateArgumentSubstitution,
334  PointOfInstantiation, InstantiationRange, Param, Template,
335  TemplateArgs) {}
336 
338  Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
340  SourceRange InstantiationRange)
342  SemaRef,
343  CodeSynthesisContext::PriorTemplateArgumentSubstitution,
344  PointOfInstantiation, InstantiationRange, Param, Template,
345  TemplateArgs) {}
346 
348  Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
349  NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
350  SourceRange InstantiationRange)
352  SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
353  PointOfInstantiation, InstantiationRange, Param, Template,
354  TemplateArgs) {}
355 
359 
360  CodeSynthesisContexts.push_back(Ctx);
361 
362  if (!Ctx.isInstantiationRecord())
364 }
365 
367  auto &Active = CodeSynthesisContexts.back();
368  if (!Active.isInstantiationRecord()) {
369  assert(NonInstantiationEntries > 0);
371  }
372 
373  InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;
374 
375  // Name lookup no longer looks in this template's defining module.
376  assert(CodeSynthesisContexts.size() >=
378  "forgot to remove a lookup module for a template instantiation");
379  if (CodeSynthesisContexts.size() ==
382  LookupModulesCache.erase(M);
384  }
385 
386  // If we've left the code synthesis context for the current context stack,
387  // stop remembering that we've emitted that stack.
388  if (CodeSynthesisContexts.size() ==
391 
392  CodeSynthesisContexts.pop_back();
393 }
394 
396  if (!Invalid) {
397  if (!AlreadyInstantiating) {
398  auto &Active = SemaRef.CodeSynthesisContexts.back();
399  SemaRef.InstantiatingSpecializations.erase(
400  std::make_pair(Active.Entity, Active.Kind));
401  }
402 
403  atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
404  SemaRef.CodeSynthesisContexts.back());
405 
406  SemaRef.popCodeSynthesisContext();
407  Invalid = true;
408  }
409 }
410 
411 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
412  SourceLocation PointOfInstantiation,
413  SourceRange InstantiationRange) {
414  assert(SemaRef.NonInstantiationEntries <=
415  SemaRef.CodeSynthesisContexts.size());
416  if ((SemaRef.CodeSynthesisContexts.size() -
417  SemaRef.NonInstantiationEntries)
418  <= SemaRef.getLangOpts().InstantiationDepth)
419  return false;
420 
421  SemaRef.Diag(PointOfInstantiation,
422  diag::err_template_recursion_depth_exceeded)
423  << SemaRef.getLangOpts().InstantiationDepth
424  << InstantiationRange;
425  SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
426  << SemaRef.getLangOpts().InstantiationDepth;
427  return true;
428 }
429 
430 /// \brief Prints the current instantiation stack through a series of
431 /// notes.
433  // Determine which template instantiations to skip, if any.
434  unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
435  unsigned Limit = Diags.getTemplateBacktraceLimit();
436  if (Limit && Limit < CodeSynthesisContexts.size()) {
437  SkipStart = Limit / 2 + Limit % 2;
438  SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
439  }
440 
441  // FIXME: In all of these cases, we need to show the template arguments
442  unsigned InstantiationIdx = 0;
444  Active = CodeSynthesisContexts.rbegin(),
445  ActiveEnd = CodeSynthesisContexts.rend();
446  Active != ActiveEnd;
447  ++Active, ++InstantiationIdx) {
448  // Skip this instantiation?
449  if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
450  if (InstantiationIdx == SkipStart) {
451  // Note that we're skipping instantiations.
452  Diags.Report(Active->PointOfInstantiation,
453  diag::note_instantiation_contexts_suppressed)
454  << unsigned(CodeSynthesisContexts.size() - Limit);
455  }
456  continue;
457  }
458 
459  switch (Active->Kind) {
461  Decl *D = Active->Entity;
462  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
463  unsigned DiagID = diag::note_template_member_class_here;
464  if (isa<ClassTemplateSpecializationDecl>(Record))
465  DiagID = diag::note_template_class_instantiation_here;
466  Diags.Report(Active->PointOfInstantiation, DiagID)
467  << Record << Active->InstantiationRange;
468  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
469  unsigned DiagID;
470  if (Function->getPrimaryTemplate())
471  DiagID = diag::note_function_template_spec_here;
472  else
473  DiagID = diag::note_template_member_function_here;
474  Diags.Report(Active->PointOfInstantiation, DiagID)
475  << Function
476  << Active->InstantiationRange;
477  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
478  Diags.Report(Active->PointOfInstantiation,
479  VD->isStaticDataMember()?
480  diag::note_template_static_data_member_def_here
481  : diag::note_template_variable_def_here)
482  << VD
483  << Active->InstantiationRange;
484  } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
485  Diags.Report(Active->PointOfInstantiation,
486  diag::note_template_enum_def_here)
487  << ED
488  << Active->InstantiationRange;
489  } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
490  Diags.Report(Active->PointOfInstantiation,
491  diag::note_template_nsdmi_here)
492  << FD << Active->InstantiationRange;
493  } else {
494  Diags.Report(Active->PointOfInstantiation,
495  diag::note_template_type_alias_instantiation_here)
496  << cast<TypeAliasTemplateDecl>(D)
497  << Active->InstantiationRange;
498  }
499  break;
500  }
501 
503  TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
504  SmallVector<char, 128> TemplateArgsStr;
505  llvm::raw_svector_ostream OS(TemplateArgsStr);
506  Template->printName(OS);
507  printTemplateArgumentList(OS, Active->template_arguments(),
509  Diags.Report(Active->PointOfInstantiation,
510  diag::note_default_arg_instantiation_here)
511  << OS.str()
512  << Active->InstantiationRange;
513  break;
514  }
515 
517  FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
518  Diags.Report(Active->PointOfInstantiation,
519  diag::note_explicit_template_arg_substitution_here)
520  << FnTmpl
522  Active->TemplateArgs,
523  Active->NumTemplateArgs)
524  << Active->InstantiationRange;
525  break;
526  }
527 
529  if (FunctionTemplateDecl *FnTmpl =
530  dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
531  Diags.Report(Active->PointOfInstantiation,
532  diag::note_function_template_deduction_instantiation_here)
533  << FnTmpl
534  << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
535  Active->TemplateArgs,
536  Active->NumTemplateArgs)
537  << Active->InstantiationRange;
538  } else {
539  bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
540  isa<VarTemplateSpecializationDecl>(Active->Entity);
541  bool IsTemplate = false;
542  TemplateParameterList *Params;
543  if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
544  IsTemplate = true;
545  Params = D->getTemplateParameters();
546  } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
547  Active->Entity)) {
548  Params = D->getTemplateParameters();
549  } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
550  Active->Entity)) {
551  Params = D->getTemplateParameters();
552  } else {
553  llvm_unreachable("unexpected template kind");
554  }
555 
556  Diags.Report(Active->PointOfInstantiation,
557  diag::note_deduced_template_arg_substitution_here)
558  << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
559  << getTemplateArgumentBindingsText(Params, Active->TemplateArgs,
560  Active->NumTemplateArgs)
561  << Active->InstantiationRange;
562  }
563  break;
564  }
565 
567  ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
568  FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
569 
570  SmallVector<char, 128> TemplateArgsStr;
571  llvm::raw_svector_ostream OS(TemplateArgsStr);
572  FD->printName(OS);
573  printTemplateArgumentList(OS, Active->template_arguments(),
575  Diags.Report(Active->PointOfInstantiation,
576  diag::note_default_function_arg_instantiation_here)
577  << OS.str()
578  << Active->InstantiationRange;
579  break;
580  }
581 
583  NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
584  std::string Name;
585  if (!Parm->getName().empty())
586  Name = std::string(" '") + Parm->getName().str() + "'";
587 
588  TemplateParameterList *TemplateParams = nullptr;
589  if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
590  TemplateParams = Template->getTemplateParameters();
591  else
592  TemplateParams =
593  cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
594  ->getTemplateParameters();
595  Diags.Report(Active->PointOfInstantiation,
596  diag::note_prior_template_arg_substitution)
597  << isa<TemplateTemplateParmDecl>(Parm)
598  << Name
599  << getTemplateArgumentBindingsText(TemplateParams,
600  Active->TemplateArgs,
601  Active->NumTemplateArgs)
602  << Active->InstantiationRange;
603  break;
604  }
605 
607  TemplateParameterList *TemplateParams = nullptr;
608  if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
609  TemplateParams = Template->getTemplateParameters();
610  else
611  TemplateParams =
612  cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
613  ->getTemplateParameters();
614 
615  Diags.Report(Active->PointOfInstantiation,
616  diag::note_template_default_arg_checking)
617  << getTemplateArgumentBindingsText(TemplateParams,
618  Active->TemplateArgs,
619  Active->NumTemplateArgs)
620  << Active->InstantiationRange;
621  break;
622  }
623 
625  Diags.Report(Active->PointOfInstantiation,
626  diag::note_template_exception_spec_instantiation_here)
627  << cast<FunctionDecl>(Active->Entity)
628  << Active->InstantiationRange;
629  break;
630 
632  Diags.Report(Active->PointOfInstantiation,
633  diag::note_in_declaration_of_implicit_special_member)
634  << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
635  break;
636 
638  // FIXME: For synthesized members other than special members, produce a note.
639  auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
640  auto CSM = MD ? getSpecialMember(MD) : CXXInvalid;
641  if (CSM != CXXInvalid) {
642  Diags.Report(Active->PointOfInstantiation,
643  diag::note_member_synthesized_at)
644  << CSM << Context.getTagDeclType(MD->getParent());
645  }
646  break;
647  }
648 
650  break;
651  }
652  }
653 }
654 
657  return Optional<TemplateDeductionInfo *>(nullptr);
658 
660  Active = CodeSynthesisContexts.rbegin(),
661  ActiveEnd = CodeSynthesisContexts.rend();
662  Active != ActiveEnd;
663  ++Active)
664  {
665  switch (Active->Kind) {
667  // An instantiation of an alias template may or may not be a SFINAE
668  // context, depending on what else is on the stack.
669  if (isa<TypeAliasTemplateDecl>(Active->Entity))
670  break;
671  // Fall through.
674  // This is a template instantiation, so there is no SFINAE.
675  return None;
676 
680  // A default template argument instantiation and substitution into
681  // template parameters with arguments for prior parameters may or may
682  // not be a SFINAE context; look further up the stack.
683  break;
684 
687  // We're either substitution explicitly-specified template arguments
688  // or deduced template arguments, so SFINAE applies.
689  assert(Active->DeductionInfo && "Missing deduction info pointer");
690  return Active->DeductionInfo;
691 
694  // This happens in a context unrelated to template instantiation, so
695  // there is no SFINAE.
696  return None;
697 
699  break;
700  }
701 
702  // The inner context was transparent for SFINAE. If it occurred within a
703  // non-instantiation SFINAE context, then SFINAE applies.
704  if (Active->SavedInNonInstantiationSFINAEContext)
705  return Optional<TemplateDeductionInfo *>(nullptr);
706  }
707 
708  return None;
709 }
710 
711 /// \brief Retrieve the depth and index of a parameter pack.
712 static std::pair<unsigned, unsigned>
714  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
715  return std::make_pair(TTP->getDepth(), TTP->getIndex());
716 
717  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
718  return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
719 
720  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
721  return std::make_pair(TTP->getDepth(), TTP->getIndex());
722 }
723 
724 //===----------------------------------------------------------------------===/
725 // Template Instantiation for Types
726 //===----------------------------------------------------------------------===/
727 namespace {
728  class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
729  const MultiLevelTemplateArgumentList &TemplateArgs;
730  SourceLocation Loc;
731  DeclarationName Entity;
732 
733  public:
734  typedef TreeTransform<TemplateInstantiator> inherited;
735 
736  TemplateInstantiator(Sema &SemaRef,
737  const MultiLevelTemplateArgumentList &TemplateArgs,
738  SourceLocation Loc,
739  DeclarationName Entity)
740  : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
741  Entity(Entity) { }
742 
743  /// \brief Determine whether the given type \p T has already been
744  /// transformed.
745  ///
746  /// For the purposes of template instantiation, a type has already been
747  /// transformed if it is NULL or if it is not dependent.
748  bool AlreadyTransformed(QualType T);
749 
750  /// \brief Returns the location of the entity being instantiated, if known.
751  SourceLocation getBaseLocation() { return Loc; }
752 
753  /// \brief Returns the name of the entity being instantiated, if any.
754  DeclarationName getBaseEntity() { return Entity; }
755 
756  /// \brief Sets the "base" location and entity when that
757  /// information is known based on another transformation.
758  void setBase(SourceLocation Loc, DeclarationName Entity) {
759  this->Loc = Loc;
760  this->Entity = Entity;
761  }
762 
763  bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
764  SourceRange PatternRange,
766  bool &ShouldExpand, bool &RetainExpansion,
767  Optional<unsigned> &NumExpansions) {
768  return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
769  PatternRange, Unexpanded,
770  TemplateArgs,
771  ShouldExpand,
772  RetainExpansion,
773  NumExpansions);
774  }
775 
776  void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
778  }
779 
780  TemplateArgument ForgetPartiallySubstitutedPack() {
782  if (NamedDecl *PartialPack
784  MultiLevelTemplateArgumentList &TemplateArgs
785  = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
786  unsigned Depth, Index;
787  std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
788  if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
789  Result = TemplateArgs(Depth, Index);
790  TemplateArgs.setArgument(Depth, Index, TemplateArgument());
791  }
792  }
793 
794  return Result;
795  }
796 
797  void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
798  if (Arg.isNull())
799  return;
800 
801  if (NamedDecl *PartialPack
803  MultiLevelTemplateArgumentList &TemplateArgs
804  = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
805  unsigned Depth, Index;
806  std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
807  TemplateArgs.setArgument(Depth, Index, Arg);
808  }
809  }
810 
811  /// \brief Transform the given declaration by instantiating a reference to
812  /// this declaration.
813  Decl *TransformDecl(SourceLocation Loc, Decl *D);
814 
815  void transformAttrs(Decl *Old, Decl *New) {
816  SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
817  }
818 
819  void transformedLocalDecl(Decl *Old, Decl *New) {
820  // If we've instantiated the call operator of a lambda or the call
821  // operator template of a generic lambda, update the "instantiation of"
822  // information.
823  auto *NewMD = dyn_cast<CXXMethodDecl>(New);
824  if (NewMD && isLambdaCallOperator(NewMD)) {
825  auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
826  if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
827  NewTD->setInstantiatedFromMemberTemplate(
828  OldMD->getDescribedFunctionTemplate());
829  else
832  }
833 
834  SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
835 
836  // We recreated a local declaration, but not by instantiating it. There
837  // may be pending dependent diagnostics to produce.
838  if (auto *DC = dyn_cast<DeclContext>(Old))
839  SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
840  }
841 
842  /// \brief Transform the definition of the given declaration by
843  /// instantiating it.
844  Decl *TransformDefinition(SourceLocation Loc, Decl *D);
845 
846  /// \brief Transform the first qualifier within a scope by instantiating the
847  /// declaration.
848  NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
849 
850  /// \brief Rebuild the exception declaration and register the declaration
851  /// as an instantiated local.
852  VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
854  SourceLocation StartLoc,
855  SourceLocation NameLoc,
856  IdentifierInfo *Name);
857 
858  /// \brief Rebuild the Objective-C exception declaration and register the
859  /// declaration as an instantiated local.
860  VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
861  TypeSourceInfo *TSInfo, QualType T);
862 
863  /// \brief Check for tag mismatches when instantiating an
864  /// elaborated type.
865  QualType RebuildElaboratedType(SourceLocation KeywordLoc,
866  ElaboratedTypeKeyword Keyword,
867  NestedNameSpecifierLoc QualifierLoc,
868  QualType T);
869 
871  TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
872  SourceLocation NameLoc,
873  QualType ObjectType = QualType(),
874  NamedDecl *FirstQualifierInScope = nullptr,
875  bool AllowInjectedClassName = false);
876 
877  const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);
878 
879  ExprResult TransformPredefinedExpr(PredefinedExpr *E);
880  ExprResult TransformDeclRefExpr(DeclRefExpr *E);
881  ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
882 
883  ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
885  ExprResult TransformSubstNonTypeTemplateParmPackExpr(
887 
888  /// \brief Rebuild a DeclRefExpr for a ParmVarDecl reference.
889  ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc);
890 
891  /// \brief Transform a reference to a function parameter pack.
892  ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E,
893  ParmVarDecl *PD);
894 
895  /// \brief Transform a FunctionParmPackExpr which was built when we couldn't
896  /// expand a function parameter pack reference which refers to an expanded
897  /// pack.
898  ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);
899 
900  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
902  // Call the base version; it will forward to our overridden version below.
903  return inherited::TransformFunctionProtoType(TLB, TL);
904  }
905 
906  template<typename Fn>
907  QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
909  CXXRecordDecl *ThisContext,
910  unsigned ThisTypeQuals,
911  Fn TransformExceptionSpec);
912 
913  ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
914  int indexAdjustment,
915  Optional<unsigned> NumExpansions,
916  bool ExpectParameterPack);
917 
918  /// \brief Transforms a template type parameter type by performing
919  /// substitution of the corresponding template type argument.
920  QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
922 
923  /// \brief Transforms an already-substituted template type parameter pack
924  /// into either itself (if we aren't substituting into its pack expansion)
925  /// or the appropriate substituted argument.
926  QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
928 
929  ExprResult TransformLambdaExpr(LambdaExpr *E) {
930  LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
932  }
933 
934  TemplateParameterList *TransformTemplateParameterList(
935  TemplateParameterList *OrigTPL) {
936  if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
937 
938  DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
939  TemplateDeclInstantiator DeclInstantiator(getSema(),
940  /* DeclContext *Owner */ Owner, TemplateArgs);
941  return DeclInstantiator.SubstTemplateParams(OrigTPL);
942  }
943  private:
944  ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
945  SourceLocation loc,
946  TemplateArgument arg);
947  };
948 }
949 
950 bool TemplateInstantiator::AlreadyTransformed(QualType T) {
951  if (T.isNull())
952  return true;
953 
955  return false;
956 
957  getSema().MarkDeclarationsReferencedInType(Loc, T);
958  return true;
959 }
960 
961 static TemplateArgument
963  assert(S.ArgumentPackSubstitutionIndex >= 0);
964  assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size());
966  if (Arg.isPackExpansion())
967  Arg = Arg.getPackExpansionPattern();
968  return Arg;
969 }
970 
971 Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
972  if (!D)
973  return nullptr;
974 
975  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
976  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
977  // If the corresponding template argument is NULL or non-existent, it's
978  // because we are performing instantiation from explicitly-specified
979  // template arguments in a function template, but there were some
980  // arguments left unspecified.
981  if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
982  TTP->getPosition()))
983  return D;
984 
985  TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
986 
987  if (TTP->isParameterPack()) {
988  assert(Arg.getKind() == TemplateArgument::Pack &&
989  "Missing argument pack");
990  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
991  }
992 
994  assert(!Template.isNull() && Template.getAsTemplateDecl() &&
995  "Wrong kind of template template argument");
996  return Template.getAsTemplateDecl();
997  }
998 
999  // Fall through to find the instantiated declaration for this template
1000  // template parameter.
1001  }
1002 
1003  return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
1004 }
1005 
1006 Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
1007  Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
1008  if (!Inst)
1009  return nullptr;
1010 
1011  getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1012  return Inst;
1013 }
1014 
1015 NamedDecl *
1016 TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
1017  SourceLocation Loc) {
1018  // If the first part of the nested-name-specifier was a template type
1019  // parameter, instantiate that type parameter down to a tag type.
1020  if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
1021  const TemplateTypeParmType *TTP
1022  = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1023 
1024  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1025  // FIXME: This needs testing w/ member access expressions.
1026  TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
1027 
1028  if (TTP->isParameterPack()) {
1029  assert(Arg.getKind() == TemplateArgument::Pack &&
1030  "Missing argument pack");
1031 
1032  if (getSema().ArgumentPackSubstitutionIndex == -1)
1033  return nullptr;
1034 
1035  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1036  }
1037 
1038  QualType T = Arg.getAsType();
1039  if (T.isNull())
1040  return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1041 
1042  if (const TagType *Tag = T->getAs<TagType>())
1043  return Tag->getDecl();
1044 
1045  // The resulting type is not a tag; complain.
1046  getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1047  return nullptr;
1048  }
1049  }
1050 
1051  return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1052 }
1053 
1054 VarDecl *
1055 TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
1057  SourceLocation StartLoc,
1058  SourceLocation NameLoc,
1059  IdentifierInfo *Name) {
1060  VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1061  StartLoc, NameLoc, Name);
1062  if (Var)
1063  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1064  return Var;
1065 }
1066 
1067 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1068  TypeSourceInfo *TSInfo,
1069  QualType T) {
1070  VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1071  if (Var)
1072  getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1073  return Var;
1074 }
1075 
1076 QualType
1077 TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
1078  ElaboratedTypeKeyword Keyword,
1079  NestedNameSpecifierLoc QualifierLoc,
1080  QualType T) {
1081  if (const TagType *TT = T->getAs<TagType>()) {
1082  TagDecl* TD = TT->getDecl();
1083 
1084  SourceLocation TagLocation = KeywordLoc;
1085 
1086  IdentifierInfo *Id = TD->getIdentifier();
1087 
1088  // TODO: should we even warn on struct/class mismatches for this? Seems
1089  // like it's likely to produce a lot of spurious errors.
1090  if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {
1092  if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
1093  TagLocation, Id)) {
1094  SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
1095  << Id
1096  << FixItHint::CreateReplacement(SourceRange(TagLocation),
1097  TD->getKindName());
1098  SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
1099  }
1100  }
1101  }
1102 
1104  Keyword,
1105  QualifierLoc,
1106  T);
1107 }
1108 
1109 TemplateName TemplateInstantiator::TransformTemplateName(
1110  CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
1111  QualType ObjectType, NamedDecl *FirstQualifierInScope,
1112  bool AllowInjectedClassName) {
1113  if (TemplateTemplateParmDecl *TTP
1114  = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
1115  if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1116  // If the corresponding template argument is NULL or non-existent, it's
1117  // because we are performing instantiation from explicitly-specified
1118  // template arguments in a function template, but there were some
1119  // arguments left unspecified.
1120  if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1121  TTP->getPosition()))
1122  return Name;
1123 
1124  TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1125 
1126  if (TTP->isParameterPack()) {
1127  assert(Arg.getKind() == TemplateArgument::Pack &&
1128  "Missing argument pack");
1129 
1130  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1131  // We have the template argument pack to substitute, but we're not
1132  // actually expanding the enclosing pack expansion yet. So, just
1133  // keep the entire argument pack.
1134  return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1135  }
1136 
1137  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1138  }
1139 
1140  TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
1141  assert(!Template.isNull() && "Null template template argument");
1142  assert(!Template.getAsQualifiedTemplateName() &&
1143  "template decl to substitute is qualified?");
1144 
1145  Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1146  return Template;
1147  }
1148  }
1149 
1152  if (getSema().ArgumentPackSubstitutionIndex == -1)
1153  return Name;
1154 
1155  TemplateArgument Arg = SubstPack->getArgumentPack();
1156  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1157  return Arg.getAsTemplate().getNameToSubstitute();
1158  }
1159 
1160  return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1161  FirstQualifierInScope,
1162  AllowInjectedClassName);
1163 }
1164 
1165 ExprResult
1166 TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
1167  if (!E->isTypeDependent())
1168  return E;
1169 
1170  return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentType());
1171 }
1172 
1173 ExprResult
1174 TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
1175  NonTypeTemplateParmDecl *NTTP) {
1176  // If the corresponding template argument is NULL or non-existent, it's
1177  // because we are performing instantiation from explicitly-specified
1178  // template arguments in a function template, but there were some
1179  // arguments left unspecified.
1180  if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
1181  NTTP->getPosition()))
1182  return E;
1183 
1184  TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1185 
1186  if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
1187  // We're performing a partial substitution, so the substituted argument
1188  // could be dependent. As a result we can't create a SubstNonType*Expr
1189  // node now, since that represents a fully-substituted argument.
1190  // FIXME: We should have some AST representation for this.
1191  if (Arg.getKind() == TemplateArgument::Pack) {
1192  // FIXME: This won't work for alias templates.
1193  assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&
1194  "unexpected pack arguments in partial substitution");
1195  Arg = Arg.pack_begin()->getPackExpansionPattern();
1196  }
1197  assert(Arg.getKind() == TemplateArgument::Expression &&
1198  "unexpected nontype template argument kind in partial substitution");
1199  return Arg.getAsExpr();
1200  }
1201 
1202  if (NTTP->isParameterPack()) {
1203  assert(Arg.getKind() == TemplateArgument::Pack &&
1204  "Missing argument pack");
1205 
1206  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1207  // We have an argument pack, but we can't select a particular argument
1208  // out of it yet. Therefore, we'll build an expression to hold on to that
1209  // argument pack.
1210  QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
1211  E->getLocation(),
1212  NTTP->getDeclName());
1213  if (TargetType.isNull())
1214  return ExprError();
1215 
1216  return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
1217  TargetType.getNonLValueExprType(SemaRef.Context),
1218  TargetType->isReferenceType() ? VK_LValue : VK_RValue, NTTP,
1219  E->getLocation(), Arg);
1220  }
1221 
1222  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1223  }
1224 
1225  return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1226 }
1227 
1228 const LoopHintAttr *
1229 TemplateInstantiator::TransformLoopHintAttr(const LoopHintAttr *LH) {
1230  Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
1231 
1232  if (TransformedExpr == LH->getValue())
1233  return LH;
1234 
1235  // Generate error if there is a problem with the value.
1236  if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1237  return LH;
1238 
1239  // Create new LoopHintValueAttr with integral expression in place of the
1240  // non-type template parameter.
1241  return LoopHintAttr::CreateImplicit(
1242  getSema().Context, LH->getSemanticSpelling(), LH->getOption(),
1243  LH->getState(), TransformedExpr, LH->getRange());
1244 }
1245 
1246 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1248  SourceLocation loc,
1249  TemplateArgument arg) {
1250  ExprResult result;
1251  QualType type;
1252 
1253  // The template argument itself might be an expression, in which
1254  // case we just return that expression.
1255  if (arg.getKind() == TemplateArgument::Expression) {
1256  Expr *argExpr = arg.getAsExpr();
1257  result = argExpr;
1258  type = argExpr->getType();
1259 
1260  } else if (arg.getKind() == TemplateArgument::Declaration ||
1262  ValueDecl *VD;
1263  if (arg.getKind() == TemplateArgument::Declaration) {
1264  VD = cast<ValueDecl>(arg.getAsDecl());
1265 
1266  // Find the instantiation of the template argument. This is
1267  // required for nested templates.
1268  VD = cast_or_null<ValueDecl>(
1269  getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1270  if (!VD)
1271  return ExprError();
1272  } else {
1273  // Propagate NULL template argument.
1274  VD = nullptr;
1275  }
1276 
1277  // Derive the type we want the substituted decl to have. This had
1278  // better be non-dependent, or these checks will have serious problems.
1279  if (parm->isExpandedParameterPack()) {
1280  type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
1281  } else if (parm->isParameterPack() &&
1282  isa<PackExpansionType>(parm->getType())) {
1283  type = SemaRef.SubstType(
1284  cast<PackExpansionType>(parm->getType())->getPattern(),
1285  TemplateArgs, loc, parm->getDeclName());
1286  } else {
1287  type = SemaRef.SubstType(VD ? arg.getParamTypeForDecl() : arg.getNullPtrType(),
1288  TemplateArgs, loc, parm->getDeclName());
1289  }
1290  assert(!type.isNull() && "type substitution failed for param type");
1291  assert(!type->isDependentType() && "param type still dependent");
1292  result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc);
1293 
1294  if (!result.isInvalid()) type = result.get()->getType();
1295  } else {
1296  result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1297 
1298  // Note that this type can be different from the type of 'result',
1299  // e.g. if it's an enum type.
1300  type = arg.getIntegralType();
1301  }
1302  if (result.isInvalid()) return ExprError();
1303 
1304  Expr *resultExpr = result.get();
1305  return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
1306  type, resultExpr->getValueKind(), loc, parm, resultExpr);
1307 }
1308 
1309 ExprResult
1310 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1312  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1313  // We aren't expanding the parameter pack, so just return ourselves.
1314  return E;
1315  }
1316 
1317  TemplateArgument Arg = E->getArgumentPack();
1318  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1319  return transformNonTypeTemplateParmRef(E->getParameterPack(),
1321  Arg);
1322 }
1323 
1324 ExprResult
1325 TemplateInstantiator::RebuildParmVarDeclRefExpr(ParmVarDecl *PD,
1326  SourceLocation Loc) {
1327  DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
1328  return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
1329 }
1330 
1331 ExprResult
1332 TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
1333  if (getSema().ArgumentPackSubstitutionIndex != -1) {
1334  // We can expand this parameter pack now.
1336  ValueDecl *VD = cast_or_null<ValueDecl>(TransformDecl(E->getExprLoc(), D));
1337  if (!VD)
1338  return ExprError();
1339  return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->getExprLoc());
1340  }
1341 
1342  QualType T = TransformType(E->getType());
1343  if (T.isNull())
1344  return ExprError();
1345 
1346  // Transform each of the parameter expansions into the corresponding
1347  // parameters in the instantiation of the function decl.
1349  Parms.reserve(E->getNumExpansions());
1350  for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1351  I != End; ++I) {
1352  ParmVarDecl *D =
1353  cast_or_null<ParmVarDecl>(TransformDecl(E->getExprLoc(), *I));
1354  if (!D)
1355  return ExprError();
1356  Parms.push_back(D);
1357  }
1358 
1359  return FunctionParmPackExpr::Create(getSema().Context, T,
1360  E->getParameterPack(),
1361  E->getParameterPackLocation(), Parms);
1362 }
1363 
1364 ExprResult
1365 TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
1366  ParmVarDecl *PD) {
1367  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
1368  llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1369  = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1370  assert(Found && "no instantiation for parameter pack");
1371 
1372  Decl *TransformedDecl;
1373  if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1374  // If this is a reference to a function parameter pack which we can
1375  // substitute but can't yet expand, build a FunctionParmPackExpr for it.
1376  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1377  QualType T = TransformType(E->getType());
1378  if (T.isNull())
1379  return ExprError();
1380  return FunctionParmPackExpr::Create(getSema().Context, T, PD,
1381  E->getExprLoc(), *Pack);
1382  }
1383 
1384  TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1385  } else {
1386  TransformedDecl = Found->get<Decl*>();
1387  }
1388 
1389  // We have either an unexpanded pack or a specific expansion.
1390  return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1391  E->getExprLoc());
1392 }
1393 
1394 ExprResult
1395 TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
1396  NamedDecl *D = E->getDecl();
1397 
1398  // Handle references to non-type template parameters and non-type template
1399  // parameter packs.
1400  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
1401  if (NTTP->getDepth() < TemplateArgs.getNumLevels())
1402  return TransformTemplateParmRefExpr(E, NTTP);
1403 
1404  // We have a non-type template parameter that isn't fully substituted;
1405  // FindInstantiatedDecl will find it in the local instantiation scope.
1406  }
1407 
1408  // Handle references to function parameter packs.
1409  if (ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
1410  if (PD->isParameterPack())
1411  return TransformFunctionParmPackRefExpr(E, PD);
1412 
1414 }
1415 
1416 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1417  CXXDefaultArgExpr *E) {
1418  assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->
1419  getDescribedFunctionTemplate() &&
1420  "Default arg expressions are never formed in dependent cases.");
1421  return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
1422  cast<FunctionDecl>(E->getParam()->getDeclContext()),
1423  E->getParam());
1424 }
1425 
1426 template<typename Fn>
1427 QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1429  CXXRecordDecl *ThisContext,
1430  unsigned ThisTypeQuals,
1431  Fn TransformExceptionSpec) {
1432  // We need a local instantiation scope for this function prototype.
1433  LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1434  return inherited::TransformFunctionProtoType(
1435  TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1436 }
1437 
1438 ParmVarDecl *
1439 TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
1440  int indexAdjustment,
1441  Optional<unsigned> NumExpansions,
1442  bool ExpectParameterPack) {
1443  return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
1444  NumExpansions, ExpectParameterPack);
1445 }
1446 
1447 QualType
1448 TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1450  const TemplateTypeParmType *T = TL.getTypePtr();
1451  if (T->getDepth() < TemplateArgs.getNumLevels()) {
1452  // Replace the template type parameter with its corresponding
1453  // template argument.
1454 
1455  // If the corresponding template argument is NULL or doesn't exist, it's
1456  // because we are performing instantiation from explicitly-specified
1457  // template arguments in a function template class, but there were some
1458  // arguments left unspecified.
1459  if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
1461  = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
1462  NewTL.setNameLoc(TL.getNameLoc());
1463  return TL.getType();
1464  }
1465 
1466  TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1467 
1468  if (T->isParameterPack()) {
1469  assert(Arg.getKind() == TemplateArgument::Pack &&
1470  "Missing argument pack");
1471 
1472  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1473  // We have the template argument pack, but we're not expanding the
1474  // enclosing pack expansion yet. Just save the template argument
1475  // pack for later substitution.
1477  = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1480  NewTL.setNameLoc(TL.getNameLoc());
1481  return Result;
1482  }
1483 
1484  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1485  }
1486 
1487  assert(Arg.getKind() == TemplateArgument::Type &&
1488  "Template argument kind mismatch");
1489 
1490  QualType Replacement = Arg.getAsType();
1491 
1492  // TODO: only do this uniquing once, at the start of instantiation.
1494  = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1497  NewTL.setNameLoc(TL.getNameLoc());
1498  return Result;
1499  }
1500 
1501  // The template type parameter comes from an inner template (e.g.,
1502  // the template parameter list of a member template inside the
1503  // template we are instantiating). Create a new template type
1504  // parameter with the template "level" reduced by one.
1505  TemplateTypeParmDecl *NewTTPDecl = nullptr;
1506  if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
1507  NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1508  TransformDecl(TL.getNameLoc(), OldTTPDecl));
1509 
1510  QualType Result = getSema().Context.getTemplateTypeParmType(
1511  T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
1512  T->isParameterPack(), NewTTPDecl);
1514  NewTL.setNameLoc(TL.getNameLoc());
1515  return Result;
1516 }
1517 
1518 QualType
1519 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1520  TypeLocBuilder &TLB,
1522  if (getSema().ArgumentPackSubstitutionIndex == -1) {
1523  // We aren't expanding the parameter pack, so just return ourselves.
1526  NewTL.setNameLoc(TL.getNameLoc());
1527  return TL.getType();
1528  }
1529 
1531  Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1532  QualType Result = Arg.getAsType();
1533 
1534  Result = getSema().Context.getSubstTemplateTypeParmType(
1536  Result);
1539  NewTL.setNameLoc(TL.getNameLoc());
1540  return Result;
1541 }
1542 
1543 /// \brief Perform substitution on the type T with a given set of template
1544 /// arguments.
1545 ///
1546 /// This routine substitutes the given template arguments into the
1547 /// type T and produces the instantiated type.
1548 ///
1549 /// \param T the type into which the template arguments will be
1550 /// substituted. If this type is not dependent, it will be returned
1551 /// immediately.
1552 ///
1553 /// \param Args the template arguments that will be
1554 /// substituted for the top-level template parameters within T.
1555 ///
1556 /// \param Loc the location in the source code where this substitution
1557 /// is being performed. It will typically be the location of the
1558 /// declarator (if we're instantiating the type of some declaration)
1559 /// or the location of the type in the source code (if, e.g., we're
1560 /// instantiating the type of a cast expression).
1561 ///
1562 /// \param Entity the name of the entity associated with a declaration
1563 /// being instantiated (if any). May be empty to indicate that there
1564 /// is no such entity (if, e.g., this is a type that occurs as part of
1565 /// a cast expression) or that the entity has no name (e.g., an
1566 /// unnamed function parameter).
1567 ///
1568 /// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
1569 /// acceptable as the top level type of the result.
1570 ///
1571 /// \returns If the instantiation succeeds, the instantiated
1572 /// type. Otherwise, produces diagnostics and returns a NULL type.
1574  const MultiLevelTemplateArgumentList &Args,
1575  SourceLocation Loc,
1576  DeclarationName Entity,
1577  bool AllowDeducedTST) {
1578  assert(!CodeSynthesisContexts.empty() &&
1579  "Cannot perform an instantiation without some context on the "
1580  "instantiation stack");
1581 
1582  if (!T->getType()->isInstantiationDependentType() &&
1584  return T;
1585 
1586  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1587  return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1588  : Instantiator.TransformType(T);
1589 }
1590 
1592  const MultiLevelTemplateArgumentList &Args,
1593  SourceLocation Loc,
1594  DeclarationName Entity) {
1595  assert(!CodeSynthesisContexts.empty() &&
1596  "Cannot perform an instantiation without some context on the "
1597  "instantiation stack");
1598 
1599  if (TL.getType().isNull())
1600  return nullptr;
1601 
1602  if (!TL.getType()->isInstantiationDependentType() &&
1603  !TL.getType()->isVariablyModifiedType()) {
1604  // FIXME: Make a copy of the TypeLoc data here, so that we can
1605  // return a new TypeSourceInfo. Inefficient!
1606  TypeLocBuilder TLB;
1607  TLB.pushFullCopy(TL);
1608  return TLB.getTypeSourceInfo(Context, TL.getType());
1609  }
1610 
1611  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1612  TypeLocBuilder TLB;
1613  TLB.reserve(TL.getFullDataSize());
1614  QualType Result = Instantiator.TransformType(TLB, TL);
1615  if (Result.isNull())
1616  return nullptr;
1617 
1618  return TLB.getTypeSourceInfo(Context, Result);
1619 }
1620 
1621 /// Deprecated form of the above.
1623  const MultiLevelTemplateArgumentList &TemplateArgs,
1624  SourceLocation Loc, DeclarationName Entity) {
1625  assert(!CodeSynthesisContexts.empty() &&
1626  "Cannot perform an instantiation without some context on the "
1627  "instantiation stack");
1628 
1629  // If T is not a dependent type or a variably-modified type, there
1630  // is nothing to do.
1632  return T;
1633 
1634  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
1635  return Instantiator.TransformType(T);
1636 }
1637 
1639  if (T->getType()->isInstantiationDependentType() ||
1641  return true;
1642 
1643  TypeLoc TL = T->getTypeLoc().IgnoreParens();
1644  if (!TL.getAs<FunctionProtoTypeLoc>())
1645  return false;
1646 
1648  for (ParmVarDecl *P : FP.getParams()) {
1649  // This must be synthesized from a typedef.
1650  if (!P) continue;
1651 
1652  // If there are any parameters, a new TypeSourceInfo that refers to the
1653  // instantiated parameters must be built.
1654  return true;
1655  }
1656 
1657  return false;
1658 }
1659 
1660 /// A form of SubstType intended specifically for instantiating the
1661 /// type of a FunctionDecl. Its purpose is solely to force the
1662 /// instantiation of default-argument expressions and to avoid
1663 /// instantiating an exception-specification.
1665  const MultiLevelTemplateArgumentList &Args,
1666  SourceLocation Loc,
1667  DeclarationName Entity,
1668  CXXRecordDecl *ThisContext,
1669  unsigned ThisTypeQuals) {
1670  assert(!CodeSynthesisContexts.empty() &&
1671  "Cannot perform an instantiation without some context on the "
1672  "instantiation stack");
1673 
1675  return T;
1676 
1677  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1678 
1679  TypeLocBuilder TLB;
1680 
1681  TypeLoc TL = T->getTypeLoc();
1682  TLB.reserve(TL.getFullDataSize());
1683 
1684  QualType Result;
1685 
1686  if (FunctionProtoTypeLoc Proto =
1688  // Instantiate the type, other than its exception specification. The
1689  // exception specification is instantiated in InitFunctionInstantiation
1690  // once we've built the FunctionDecl.
1691  // FIXME: Set the exception specification to EST_Uninstantiated here,
1692  // instead of rebuilding the function type again later.
1693  Result = Instantiator.TransformFunctionProtoType(
1694  TLB, Proto, ThisContext, ThisTypeQuals,
1696  bool &Changed) { return false; });
1697  } else {
1698  Result = Instantiator.TransformType(TLB, TL);
1699  }
1700  if (Result.isNull())
1701  return nullptr;
1702 
1703  return TLB.getTypeSourceInfo(Context, Result);
1704 }
1705 
1708  SmallVectorImpl<QualType> &ExceptionStorage,
1709  const MultiLevelTemplateArgumentList &Args) {
1710  assert(ESI.Type != EST_Uninstantiated);
1711 
1712  bool Changed = false;
1713  TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
1714  return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1715  Changed);
1716 }
1717 
1719  const MultiLevelTemplateArgumentList &Args) {
1721  Proto->getExtProtoInfo().ExceptionSpec;
1722 
1723  SmallVector<QualType, 4> ExceptionStorage;
1725  ESI, ExceptionStorage, Args))
1726  // On error, recover by dropping the exception specification.
1727  ESI.Type = EST_None;
1728 
1729  UpdateExceptionSpec(New, ESI);
1730 }
1731 
1733  const MultiLevelTemplateArgumentList &TemplateArgs,
1734  int indexAdjustment,
1735  Optional<unsigned> NumExpansions,
1736  bool ExpectParameterPack) {
1737  TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
1738  TypeSourceInfo *NewDI = nullptr;
1739 
1740  TypeLoc OldTL = OldDI->getTypeLoc();
1741  if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
1742 
1743  // We have a function parameter pack. Substitute into the pattern of the
1744  // expansion.
1745  NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1746  OldParm->getLocation(), OldParm->getDeclName());
1747  if (!NewDI)
1748  return nullptr;
1749 
1750  if (NewDI->getType()->containsUnexpandedParameterPack()) {
1751  // We still have unexpanded parameter packs, which means that
1752  // our function parameter is still a function parameter pack.
1753  // Therefore, make its type a pack expansion type.
1754  NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
1755  NumExpansions);
1756  } else if (ExpectParameterPack) {
1757  // We expected to get a parameter pack but didn't (because the type
1758  // itself is not a pack expansion type), so complain. This can occur when
1759  // the substitution goes through an alias template that "loses" the
1760  // pack expansion.
1761  Diag(OldParm->getLocation(),
1762  diag::err_function_parameter_pack_without_parameter_packs)
1763  << NewDI->getType();
1764  return nullptr;
1765  }
1766  } else {
1767  NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
1768  OldParm->getDeclName());
1769  }
1770 
1771  if (!NewDI)
1772  return nullptr;
1773 
1774  if (NewDI->getType()->isVoidType()) {
1775  Diag(OldParm->getLocation(), diag::err_param_with_void_type);
1776  return nullptr;
1777  }
1778 
1780  OldParm->getInnerLocStart(),
1781  OldParm->getLocation(),
1782  OldParm->getIdentifier(),
1783  NewDI->getType(), NewDI,
1784  OldParm->getStorageClass());
1785  if (!NewParm)
1786  return nullptr;
1787 
1788  // Mark the (new) default argument as uninstantiated (if any).
1789  if (OldParm->hasUninstantiatedDefaultArg()) {
1790  Expr *Arg = OldParm->getUninstantiatedDefaultArg();
1791  NewParm->setUninstantiatedDefaultArg(Arg);
1792  } else if (OldParm->hasUnparsedDefaultArg()) {
1793  NewParm->setUnparsedDefaultArg();
1794  UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
1795  } else if (Expr *Arg = OldParm->getDefaultArg()) {
1796  FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
1797  if (OwningFunc->isLexicallyWithinFunctionOrMethod()) {
1798  // Instantiate default arguments for methods of local classes (DR1484)
1799  // and non-defining declarations.
1800  Sema::ContextRAII SavedContext(*this, OwningFunc);
1801  LocalInstantiationScope Local(*this, true);
1802  ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
1803  if (NewArg.isUsable()) {
1804  // It would be nice if we still had this.
1805  SourceLocation EqualLoc = NewArg.get()->getLocStart();
1806  SetParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
1807  }
1808  } else {
1809  // FIXME: if we non-lazily instantiated non-dependent default args for
1810  // non-dependent parameter types we could remove a bunch of duplicate
1811  // conversion warnings for such arguments.
1812  NewParm->setUninstantiatedDefaultArg(Arg);
1813  }
1814  }
1815 
1817 
1818  if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
1819  // Add the new parameter to the instantiated parameter pack.
1821  } else {
1822  // Introduce an Old -> New mapping
1823  CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
1824  }
1825 
1826  // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
1827  // can be anything, is this right ?
1828  NewParm->setDeclContext(CurContext);
1829 
1830  NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
1831  OldParm->getFunctionScopeIndex() + indexAdjustment);
1832 
1833  InstantiateAttrs(TemplateArgs, OldParm, NewParm);
1834 
1835  return NewParm;
1836 }
1837 
1838 /// \brief Substitute the given template arguments into the given set of
1839 /// parameters, producing the set of parameter types that would be generated
1840 /// from such a substitution.
1843  const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
1844  const MultiLevelTemplateArgumentList &TemplateArgs,
1845  SmallVectorImpl<QualType> &ParamTypes,
1846  SmallVectorImpl<ParmVarDecl *> *OutParams,
1847  ExtParameterInfoBuilder &ParamInfos) {
1848  assert(!CodeSynthesisContexts.empty() &&
1849  "Cannot perform an instantiation without some context on the "
1850  "instantiation stack");
1851 
1852  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
1853  DeclarationName());
1854  return Instantiator.TransformFunctionTypeParams(
1855  Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1856 }
1857 
1858 /// \brief Perform substitution on the base class specifiers of the
1859 /// given class template specialization.
1860 ///
1861 /// Produces a diagnostic and returns true on error, returns false and
1862 /// attaches the instantiated base classes to the class template
1863 /// specialization if successful.
1864 bool
1866  CXXRecordDecl *Pattern,
1867  const MultiLevelTemplateArgumentList &TemplateArgs) {
1868  bool Invalid = false;
1869  SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
1870  for (const auto &Base : Pattern->bases()) {
1871  if (!Base.getType()->isDependentType()) {
1872  if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
1873  if (RD->isInvalidDecl())
1874  Instantiation->setInvalidDecl();
1875  }
1876  InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(Base));
1877  continue;
1878  }
1879 
1880  SourceLocation EllipsisLoc;
1881  TypeSourceInfo *BaseTypeLoc;
1882  if (Base.isPackExpansion()) {
1883  // This is a pack expansion. See whether we should expand it now, or
1884  // wait until later.
1886  collectUnexpandedParameterPacks(Base.getTypeSourceInfo()->getTypeLoc(),
1887  Unexpanded);
1888  bool ShouldExpand = false;
1889  bool RetainExpansion = false;
1890  Optional<unsigned> NumExpansions;
1891  if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(),
1892  Base.getSourceRange(),
1893  Unexpanded,
1894  TemplateArgs, ShouldExpand,
1895  RetainExpansion,
1896  NumExpansions)) {
1897  Invalid = true;
1898  continue;
1899  }
1900 
1901  // If we should expand this pack expansion now, do so.
1902  if (ShouldExpand) {
1903  for (unsigned I = 0; I != *NumExpansions; ++I) {
1904  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
1905 
1906  TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1907  TemplateArgs,
1908  Base.getSourceRange().getBegin(),
1909  DeclarationName());
1910  if (!BaseTypeLoc) {
1911  Invalid = true;
1912  continue;
1913  }
1914 
1915  if (CXXBaseSpecifier *InstantiatedBase
1916  = CheckBaseSpecifier(Instantiation,
1917  Base.getSourceRange(),
1918  Base.isVirtual(),
1919  Base.getAccessSpecifierAsWritten(),
1920  BaseTypeLoc,
1921  SourceLocation()))
1922  InstantiatedBases.push_back(InstantiatedBase);
1923  else
1924  Invalid = true;
1925  }
1926 
1927  continue;
1928  }
1929 
1930  // The resulting base specifier will (still) be a pack expansion.
1931  EllipsisLoc = Base.getEllipsisLoc();
1932  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
1933  BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1934  TemplateArgs,
1935  Base.getSourceRange().getBegin(),
1936  DeclarationName());
1937  } else {
1938  BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1939  TemplateArgs,
1940  Base.getSourceRange().getBegin(),
1941  DeclarationName());
1942  }
1943 
1944  if (!BaseTypeLoc) {
1945  Invalid = true;
1946  continue;
1947  }
1948 
1949  if (CXXBaseSpecifier *InstantiatedBase
1950  = CheckBaseSpecifier(Instantiation,
1951  Base.getSourceRange(),
1952  Base.isVirtual(),
1953  Base.getAccessSpecifierAsWritten(),
1954  BaseTypeLoc,
1955  EllipsisLoc))
1956  InstantiatedBases.push_back(InstantiatedBase);
1957  else
1958  Invalid = true;
1959  }
1960 
1961  if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
1962  Invalid = true;
1963 
1964  return Invalid;
1965 }
1966 
1967 // Defined via #include from SemaTemplateInstantiateDecl.cpp
1968 namespace clang {
1969  namespace sema {
1971  const MultiLevelTemplateArgumentList &TemplateArgs);
1973  const Attr *At, ASTContext &C, Sema &S,
1974  const MultiLevelTemplateArgumentList &TemplateArgs);
1975  }
1976 }
1977 
1978 /// \brief Instantiate the definition of a class from a given pattern.
1979 ///
1980 /// \param PointOfInstantiation The point of instantiation within the
1981 /// source code.
1982 ///
1983 /// \param Instantiation is the declaration whose definition is being
1984 /// instantiated. This will be either a class template specialization
1985 /// or a member class of a class template specialization.
1986 ///
1987 /// \param Pattern is the pattern from which the instantiation
1988 /// occurs. This will be either the declaration of a class template or
1989 /// the declaration of a member class of a class template.
1990 ///
1991 /// \param TemplateArgs The template arguments to be substituted into
1992 /// the pattern.
1993 ///
1994 /// \param TSK the kind of implicit or explicit instantiation to perform.
1995 ///
1996 /// \param Complain whether to complain if the class cannot be instantiated due
1997 /// to the lack of a definition.
1998 ///
1999 /// \returns true if an error occurred, false otherwise.
2000 bool
2002  CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
2003  const MultiLevelTemplateArgumentList &TemplateArgs,
2005  bool Complain) {
2006  CXXRecordDecl *PatternDef
2007  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
2008  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2009  Instantiation->getInstantiatedFromMemberClass(),
2010  Pattern, PatternDef, TSK, Complain))
2011  return true;
2012  Pattern = PatternDef;
2013 
2014  // \brief Record the point of instantiation.
2015  if (MemberSpecializationInfo *MSInfo
2016  = Instantiation->getMemberSpecializationInfo()) {
2017  MSInfo->setTemplateSpecializationKind(TSK);
2018  MSInfo->setPointOfInstantiation(PointOfInstantiation);
2019  } else if (ClassTemplateSpecializationDecl *Spec
2020  = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2021  Spec->setTemplateSpecializationKind(TSK);
2022  Spec->setPointOfInstantiation(PointOfInstantiation);
2023  }
2024 
2025  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2026  if (Inst.isInvalid())
2027  return true;
2028  assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller");
2029  PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2030  "instantiating class definition");
2031 
2032  // Enter the scope of this instantiation. We don't use
2033  // PushDeclContext because we don't have a scope.
2034  ContextRAII SavedContext(*this, Instantiation);
2037 
2038  // If this is an instantiation of a local class, merge this local
2039  // instantiation scope with the enclosing scope. Otherwise, every
2040  // instantiation of a class has its own local instantiation scope.
2041  bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
2042  LocalInstantiationScope Scope(*this, MergeWithParentScope);
2043 
2044  // Some class state isn't processed immediately but delayed till class
2045  // instantiation completes. We may not be ready to handle any delayed state
2046  // already on the stack as it might correspond to a different class, so save
2047  // it now and put it back later.
2048  SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);
2049 
2050  // Pull attributes from the pattern onto the instantiation.
2051  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2052 
2053  // Start the definition of this instantiation.
2054  Instantiation->startDefinition();
2055 
2056  // The instantiation is visible here, even if it was first declared in an
2057  // unimported module.
2058  Instantiation->setVisibleDespiteOwningModule();
2059 
2060  // FIXME: This loses the as-written tag kind for an explicit instantiation.
2061  Instantiation->setTagKind(Pattern->getTagKind());
2062 
2063  // Do substitution on the base class specifiers.
2064  if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
2065  Instantiation->setInvalidDecl();
2066 
2067  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2068  SmallVector<Decl*, 4> Fields;
2069  // Delay instantiation of late parsed attributes.
2070  LateInstantiatedAttrVec LateAttrs;
2071  Instantiator.enableLateAttributeInstantiation(&LateAttrs);
2072 
2073  for (auto *Member : Pattern->decls()) {
2074  // Don't instantiate members not belonging in this semantic context.
2075  // e.g. for:
2076  // @code
2077  // template <int i> class A {
2078  // class B *g;
2079  // };
2080  // @endcode
2081  // 'class B' has the template as lexical context but semantically it is
2082  // introduced in namespace scope.
2083  if (Member->getDeclContext() != Pattern)
2084  continue;
2085 
2086  if (Member->isInvalidDecl()) {
2087  Instantiation->setInvalidDecl();
2088  continue;
2089  }
2090 
2091  Decl *NewMember = Instantiator.Visit(Member);
2092  if (NewMember) {
2093  if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2094  Fields.push_back(Field);
2095  } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2096  // C++11 [temp.inst]p1: The implicit instantiation of a class template
2097  // specialization causes the implicit instantiation of the definitions
2098  // of unscoped member enumerations.
2099  // Record a point of instantiation for this implicit instantiation.
2100  if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
2101  Enum->isCompleteDefinition()) {
2102  MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
2103  assert(MSInfo && "no spec info for member enum specialization");
2105  MSInfo->setPointOfInstantiation(PointOfInstantiation);
2106  }
2107  } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
2108  if (SA->isFailed()) {
2109  // A static_assert failed. Bail out; instantiating this
2110  // class is probably not meaningful.
2111  Instantiation->setInvalidDecl();
2112  break;
2113  }
2114  }
2115 
2116  if (NewMember->isInvalidDecl())
2117  Instantiation->setInvalidDecl();
2118  } else {
2119  // FIXME: Eventually, a NULL return will mean that one of the
2120  // instantiations was a semantic disaster, and we'll want to mark the
2121  // declaration invalid.
2122  // For now, we expect to skip some members that we can't yet handle.
2123  }
2124  }
2125 
2126  // See if trivial_abi has to be dropped.
2127  if (Instantiation && Instantiation->hasAttr<TrivialABIAttr>())
2128  checkIllFormedTrivialABIStruct(*Instantiation);
2129 
2130  // Finish checking fields.
2131  ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
2132  SourceLocation(), SourceLocation(), nullptr);
2133  CheckCompletedCXXClass(Instantiation);
2134 
2135  // Default arguments are parsed, if not instantiated. We can go instantiate
2136  // default arg exprs for default constructors if necessary now.
2137  ActOnFinishCXXNonNestedClass(Instantiation);
2138 
2139  // Instantiate late parsed attributes, and attach them to their decls.
2140  // See Sema::InstantiateAttrs
2141  for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2142  E = LateAttrs.end(); I != E; ++I) {
2143  assert(CurrentInstantiationScope == Instantiator.getStartingScope());
2144  CurrentInstantiationScope = I->Scope;
2145 
2146  // Allow 'this' within late-parsed attributes.
2147  NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
2148  CXXRecordDecl *ThisContext =
2149  dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
2150  CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
2151  ND && ND->isCXXInstanceMember());
2152 
2153  Attr *NewAttr =
2154  instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
2155  I->NewDecl->addAttr(NewAttr);
2157  Instantiator.getStartingScope());
2158  }
2159  Instantiator.disableLateAttributeInstantiation();
2160  LateAttrs.clear();
2161 
2162  ActOnFinishDelayedMemberInitializers(Instantiation);
2163 
2164  // FIXME: We should do something similar for explicit instantiations so they
2165  // end up in the right module.
2166  if (TSK == TSK_ImplicitInstantiation) {
2167  Instantiation->setLocation(Pattern->getLocation());
2168  Instantiation->setLocStart(Pattern->getInnerLocStart());
2169  Instantiation->setBraceRange(Pattern->getBraceRange());
2170  }
2171 
2172  if (!Instantiation->isInvalidDecl()) {
2173  // Perform any dependent diagnostics from the pattern.
2174  PerformDependentDiagnostics(Pattern, TemplateArgs);
2175 
2176  // Instantiate any out-of-line class template partial
2177  // specializations now.
2179  P = Instantiator.delayed_partial_spec_begin(),
2180  PEnd = Instantiator.delayed_partial_spec_end();
2181  P != PEnd; ++P) {
2183  P->first, P->second)) {
2184  Instantiation->setInvalidDecl();
2185  break;
2186  }
2187  }
2188 
2189  // Instantiate any out-of-line variable template partial
2190  // specializations now.
2192  P = Instantiator.delayed_var_partial_spec_begin(),
2193  PEnd = Instantiator.delayed_var_partial_spec_end();
2194  P != PEnd; ++P) {
2196  P->first, P->second)) {
2197  Instantiation->setInvalidDecl();
2198  break;
2199  }
2200  }
2201  }
2202 
2203  // Exit the scope of this instantiation.
2204  SavedContext.pop();
2205 
2206  if (!Instantiation->isInvalidDecl()) {
2207  Consumer.HandleTagDeclDefinition(Instantiation);
2208 
2209  // Always emit the vtable for an explicit instantiation definition
2210  // of a polymorphic class template specialization.
2212  MarkVTableUsed(PointOfInstantiation, Instantiation, true);
2213  }
2214 
2215  return Instantiation->isInvalidDecl();
2216 }
2217 
2218 /// \brief Instantiate the definition of an enum from a given pattern.
2219 ///
2220 /// \param PointOfInstantiation The point of instantiation within the
2221 /// source code.
2222 /// \param Instantiation is the declaration whose definition is being
2223 /// instantiated. This will be a member enumeration of a class
2224 /// temploid specialization, or a local enumeration within a
2225 /// function temploid specialization.
2226 /// \param Pattern The templated declaration from which the instantiation
2227 /// occurs.
2228 /// \param TemplateArgs The template arguments to be substituted into
2229 /// the pattern.
2230 /// \param TSK The kind of implicit or explicit instantiation to perform.
2231 ///
2232 /// \return \c true if an error occurred, \c false otherwise.
2233 bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2234  EnumDecl *Instantiation, EnumDecl *Pattern,
2235  const MultiLevelTemplateArgumentList &TemplateArgs,
2237  EnumDecl *PatternDef = Pattern->getDefinition();
2238  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2239  Instantiation->getInstantiatedFromMemberEnum(),
2240  Pattern, PatternDef, TSK,/*Complain*/true))
2241  return true;
2242  Pattern = PatternDef;
2243 
2244  // Record the point of instantiation.
2245  if (MemberSpecializationInfo *MSInfo
2246  = Instantiation->getMemberSpecializationInfo()) {
2247  MSInfo->setTemplateSpecializationKind(TSK);
2248  MSInfo->setPointOfInstantiation(PointOfInstantiation);
2249  }
2250 
2251  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2252  if (Inst.isInvalid())
2253  return true;
2254  if (Inst.isAlreadyInstantiating())
2255  return false;
2256  PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2257  "instantiating enum definition");
2258 
2259  // The instantiation is visible here, even if it was first declared in an
2260  // unimported module.
2261  Instantiation->setVisibleDespiteOwningModule();
2262 
2263  // Enter the scope of this instantiation. We don't use
2264  // PushDeclContext because we don't have a scope.
2265  ContextRAII SavedContext(*this, Instantiation);
2268 
2269  LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2270 
2271  // Pull attributes from the pattern onto the instantiation.
2272  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2273 
2274  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2275  Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2276 
2277  // Exit the scope of this instantiation.
2278  SavedContext.pop();
2279 
2280  return Instantiation->isInvalidDecl();
2281 }
2282 
2283 
2284 /// \brief Instantiate the definition of a field from the given pattern.
2285 ///
2286 /// \param PointOfInstantiation The point of instantiation within the
2287 /// source code.
2288 /// \param Instantiation is the declaration whose definition is being
2289 /// instantiated. This will be a class of a class temploid
2290 /// specialization, or a local enumeration within a function temploid
2291 /// specialization.
2292 /// \param Pattern The templated declaration from which the instantiation
2293 /// occurs.
2294 /// \param TemplateArgs The template arguments to be substituted into
2295 /// the pattern.
2296 ///
2297 /// \return \c true if an error occurred, \c false otherwise.
2299  SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
2300  FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
2301  // If there is no initializer, we don't need to do anything.
2302  if (!Pattern->hasInClassInitializer())
2303  return false;
2304 
2305  assert(Instantiation->getInClassInitStyle() ==
2306  Pattern->getInClassInitStyle() &&
2307  "pattern and instantiation disagree about init style");
2308 
2309  // Error out if we haven't parsed the initializer of the pattern yet because
2310  // we are waiting for the closing brace of the outer class.
2311  Expr *OldInit = Pattern->getInClassInitializer();
2312  if (!OldInit) {
2313  RecordDecl *PatternRD = Pattern->getParent();
2314  RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
2315  Diag(PointOfInstantiation,
2316  diag::err_in_class_initializer_not_yet_parsed)
2317  << OutermostClass << Pattern;
2318  Diag(Pattern->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
2319  Instantiation->setInvalidDecl();
2320  return true;
2321  }
2322 
2323  InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2324  if (Inst.isInvalid())
2325  return true;
2326  if (Inst.isAlreadyInstantiating()) {
2327  // Error out if we hit an instantiation cycle for this initializer.
2328  Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2329  << Instantiation;
2330  return true;
2331  }
2332  PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2333  "instantiating default member init");
2334 
2335  // Enter the scope of this instantiation. We don't use PushDeclContext because
2336  // we don't have a scope.
2337  ContextRAII SavedContext(*this, Instantiation->getParent());
2340 
2341  LocalInstantiationScope Scope(*this, true);
2342 
2343  // Instantiate the initializer.
2345  CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), /*TypeQuals=*/0);
2346 
2347  ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
2348  /*CXXDirectInit=*/false);
2349  Expr *Init = NewInit.get();
2350  assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class");
2352  Instantiation, Init ? Init->getLocStart() : SourceLocation(), Init);
2353 
2354  if (auto *L = getASTMutationListener())
2355  L->DefaultMemberInitializerInstantiated(Instantiation);
2356 
2357  // Return true if the in-class initializer is still missing.
2358  return !Instantiation->getInClassInitializer();
2359 }
2360 
2361 namespace {
2362  /// \brief A partial specialization whose template arguments have matched
2363  /// a given template-id.
2364  struct PartialSpecMatchResult {
2366  TemplateArgumentList *Args;
2367  };
2368 }
2369 
2371  SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
2372  if (ClassTemplateSpec->getTemplateSpecializationKind() ==
2374  return true;
2375 
2377  ClassTemplateSpec->getSpecializedTemplate()
2378  ->getPartialSpecializations(PartialSpecs);
2379  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2380  TemplateDeductionInfo Info(Loc);
2381  if (!DeduceTemplateArguments(PartialSpecs[I],
2382  ClassTemplateSpec->getTemplateArgs(), Info))
2383  return true;
2384  }
2385 
2386  return false;
2387 }
2388 
2389 /// Get the instantiation pattern to use to instantiate the definition of a
2390 /// given ClassTemplateSpecializationDecl (either the pattern of the primary
2391 /// template or of a partial specialization).
2392 static CXXRecordDecl *
2394  Sema &S, SourceLocation PointOfInstantiation,
2395  ClassTemplateSpecializationDecl *ClassTemplateSpec,
2396  TemplateSpecializationKind TSK, bool Complain) {
2397  Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
2398  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
2399  return nullptr;
2400 
2401  ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
2402  CXXRecordDecl *Pattern = nullptr;
2403 
2404  // C++ [temp.class.spec.match]p1:
2405  // When a class template is used in a context that requires an
2406  // instantiation of the class, it is necessary to determine
2407  // whether the instantiation is to be generated using the primary
2408  // template or one of the partial specializations. This is done by
2409  // matching the template arguments of the class template
2410  // specialization with the template argument lists of the partial
2411  // specializations.
2412  typedef PartialSpecMatchResult MatchResult;
2415  Template->getPartialSpecializations(PartialSpecs);
2416  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
2417  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2418  ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
2419  TemplateDeductionInfo Info(FailedCandidates.getLocation());
2421  Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
2422  // Store the failed-deduction information for use in diagnostics, later.
2423  // TODO: Actually use the failed-deduction info?
2424  FailedCandidates.addCandidate().set(
2425  DeclAccessPair::make(Template, AS_public), Partial,
2427  (void)Result;
2428  } else {
2429  Matched.push_back(PartialSpecMatchResult());
2430  Matched.back().Partial = Partial;
2431  Matched.back().Args = Info.take();
2432  }
2433  }
2434 
2435  // If we're dealing with a member template where the template parameters
2436  // have been instantiated, this provides the original template parameters
2437  // from which the member template's parameters were instantiated.
2438 
2439  if (Matched.size() >= 1) {
2440  SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
2441  if (Matched.size() == 1) {
2442  // -- If exactly one matching specialization is found, the
2443  // instantiation is generated from that specialization.
2444  // We don't need to do anything for this.
2445  } else {
2446  // -- If more than one matching specialization is found, the
2447  // partial order rules (14.5.4.2) are used to determine
2448  // whether one of the specializations is more specialized
2449  // than the others. If none of the specializations is more
2450  // specialized than all of the other matching
2451  // specializations, then the use of the class template is
2452  // ambiguous and the program is ill-formed.
2453  for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
2454  PEnd = Matched.end();
2455  P != PEnd; ++P) {
2457  P->Partial, Best->Partial, PointOfInstantiation) == P->Partial)
2458  Best = P;
2459  }
2460 
2461  // Determine if the best partial specialization is more specialized than
2462  // the others.
2463  bool Ambiguous = false;
2464  for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2465  PEnd = Matched.end();
2466  P != PEnd; ++P) {
2467  if (P != Best &&
2468  S.getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
2469  PointOfInstantiation) !=
2470  Best->Partial) {
2471  Ambiguous = true;
2472  break;
2473  }
2474  }
2475 
2476  if (Ambiguous) {
2477  // Partial ordering did not produce a clear winner. Complain.
2478  Inst.Clear();
2479  ClassTemplateSpec->setInvalidDecl();
2480  S.Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2481  << ClassTemplateSpec;
2482 
2483  // Print the matching partial specializations.
2484  for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2485  PEnd = Matched.end();
2486  P != PEnd; ++P)
2487  S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2489  P->Partial->getTemplateParameters(), *P->Args);
2490 
2491  return nullptr;
2492  }
2493  }
2494 
2495  // Instantiate using the best class template partial specialization.
2496  ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
2497  while (OrigPartialSpec->getInstantiatedFromMember()) {
2498  // If we've found an explicit specialization of this class template,
2499  // stop here and use that as the pattern.
2500  if (OrigPartialSpec->isMemberSpecialization())
2501  break;
2502 
2503  OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember();
2504  }
2505 
2506  Pattern = OrigPartialSpec;
2507  ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
2508  } else {
2509  // -- If no matches are found, the instantiation is generated
2510  // from the primary template.
2511  ClassTemplateDecl *OrigTemplate = Template;
2512  while (OrigTemplate->getInstantiatedFromMemberTemplate()) {
2513  // If we've found an explicit specialization of this class template,
2514  // stop here and use that as the pattern.
2515  if (OrigTemplate->isMemberSpecialization())
2516  break;
2517 
2518  OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate();
2519  }
2520 
2521  Pattern = OrigTemplate->getTemplatedDecl();
2522  }
2523 
2524  return Pattern;
2525 }
2526 
2528  SourceLocation PointOfInstantiation,
2529  ClassTemplateSpecializationDecl *ClassTemplateSpec,
2530  TemplateSpecializationKind TSK, bool Complain) {
2531  // Perform the actual instantiation on the canonical declaration.
2532  ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2533  ClassTemplateSpec->getCanonicalDecl());
2534  if (ClassTemplateSpec->isInvalidDecl())
2535  return true;
2536 
2538  *this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2539  if (!Pattern)
2540  return true;
2541 
2542  return InstantiateClass(PointOfInstantiation, ClassTemplateSpec, Pattern,
2543  getTemplateInstantiationArgs(ClassTemplateSpec), TSK,
2544  Complain);
2545 }
2546 
2547 /// \brief Instantiates the definitions of all of the member
2548 /// of the given class, which is an instantiation of a class template
2549 /// or a member class of a template.
2550 void
2552  CXXRecordDecl *Instantiation,
2553  const MultiLevelTemplateArgumentList &TemplateArgs,
2555  // FIXME: We need to notify the ASTMutationListener that we did all of these
2556  // things, in case we have an explicit instantiation definition in a PCM, a
2557  // module, or preamble, and the declaration is in an imported AST.
2558  assert(
2561  (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&
2562  "Unexpected template specialization kind!");
2563  for (auto *D : Instantiation->decls()) {
2564  bool SuppressNew = false;
2565  if (auto *Function = dyn_cast<FunctionDecl>(D)) {
2566  if (FunctionDecl *Pattern
2567  = Function->getInstantiatedFromMemberFunction()) {
2568  MemberSpecializationInfo *MSInfo
2569  = Function->getMemberSpecializationInfo();
2570  assert(MSInfo && "No member specialization information?");
2571  if (MSInfo->getTemplateSpecializationKind()
2573  continue;
2574 
2575  if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2576  Function,
2578  MSInfo->getPointOfInstantiation(),
2579  SuppressNew) ||
2580  SuppressNew)
2581  continue;
2582 
2583  // C++11 [temp.explicit]p8:
2584  // An explicit instantiation definition that names a class template
2585  // specialization explicitly instantiates the class template
2586  // specialization and is only an explicit instantiation definition
2587  // of members whose definition is visible at the point of
2588  // instantiation.
2589  if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
2590  continue;
2591 
2592  Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2593 
2594  if (Function->isDefined()) {
2595  // Let the ASTConsumer know that this function has been explicitly
2596  // instantiated now, and its linkage might have changed.
2598  } else if (TSK == TSK_ExplicitInstantiationDefinition) {
2599  InstantiateFunctionDefinition(PointOfInstantiation, Function);
2600  } else if (TSK == TSK_ImplicitInstantiation) {
2602  std::make_pair(Function, PointOfInstantiation));
2603  }
2604  }
2605  } else if (auto *Var = dyn_cast<VarDecl>(D)) {
2606  if (isa<VarTemplateSpecializationDecl>(Var))
2607  continue;
2608 
2609  if (Var->isStaticDataMember()) {
2610  MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
2611  assert(MSInfo && "No member specialization information?");
2612  if (MSInfo->getTemplateSpecializationKind()
2614  continue;
2615 
2616  if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2617  Var,
2619  MSInfo->getPointOfInstantiation(),
2620  SuppressNew) ||
2621  SuppressNew)
2622  continue;
2623 
2625  // C++0x [temp.explicit]p8:
2626  // An explicit instantiation definition that names a class template
2627  // specialization explicitly instantiates the class template
2628  // specialization and is only an explicit instantiation definition
2629  // of members whose definition is visible at the point of
2630  // instantiation.
2631  if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2632  continue;
2633 
2634  Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2635  InstantiateVariableDefinition(PointOfInstantiation, Var);
2636  } else {
2637  Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2638  }
2639  }
2640  } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2641  // Always skip the injected-class-name, along with any
2642  // redeclarations of nested classes, since both would cause us
2643  // to try to instantiate the members of a class twice.
2644  // Skip closure types; they'll get instantiated when we instantiate
2645  // the corresponding lambda-expression.
2646  if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2647  Record->isLambda())
2648  continue;
2649 
2650  MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
2651  assert(MSInfo && "No member specialization information?");
2652 
2653  if (MSInfo->getTemplateSpecializationKind()
2655  continue;
2656 
2658  Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
2660  // In MSVC and Windows Itanium mode, explicit instantiation decl of the
2661  // outer class doesn't affect the inner class.
2662  continue;
2663  }
2664 
2665  if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2666  Record,
2668  MSInfo->getPointOfInstantiation(),
2669  SuppressNew) ||
2670  SuppressNew)
2671  continue;
2672 
2673  CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
2674  assert(Pattern && "Missing instantiated-from-template information");
2675 
2676  if (!Record->getDefinition()) {
2677  if (!Pattern->getDefinition()) {
2678  // C++0x [temp.explicit]p8:
2679  // An explicit instantiation definition that names a class template
2680  // specialization explicitly instantiates the class template
2681  // specialization and is only an explicit instantiation definition
2682  // of members whose definition is visible at the point of
2683  // instantiation.
2685  MSInfo->setTemplateSpecializationKind(TSK);
2686  MSInfo->setPointOfInstantiation(PointOfInstantiation);
2687  }
2688 
2689  continue;
2690  }
2691 
2692  InstantiateClass(PointOfInstantiation, Record, Pattern,
2693  TemplateArgs,
2694  TSK);
2695  } else {
2697  Record->getTemplateSpecializationKind() ==
2699  Record->setTemplateSpecializationKind(TSK);
2700  MarkVTableUsed(PointOfInstantiation, Record, true);
2701  }
2702  }
2703 
2704  Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2705  if (Pattern)
2706  InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
2707  TSK);
2708  } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
2709  MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
2710  assert(MSInfo && "No member specialization information?");
2711 
2712  if (MSInfo->getTemplateSpecializationKind()
2714  continue;
2715 
2717  PointOfInstantiation, TSK, Enum,
2719  MSInfo->getPointOfInstantiation(), SuppressNew) ||
2720  SuppressNew)
2721  continue;
2722 
2723  if (Enum->getDefinition())
2724  continue;
2725 
2726  EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2727  assert(Pattern && "Missing instantiated-from-template information");
2728 
2730  if (!Pattern->getDefinition())
2731  continue;
2732 
2733  InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2734  } else {
2735  MSInfo->setTemplateSpecializationKind(TSK);
2736  MSInfo->setPointOfInstantiation(PointOfInstantiation);
2737  }
2738  } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
2739  // No need to instantiate in-class initializers during explicit
2740  // instantiation.
2741  if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
2742  CXXRecordDecl *ClassPattern =
2743  Instantiation->getTemplateInstantiationPattern();
2745  ClassPattern->lookup(Field->getDeclName());
2746  FieldDecl *Pattern = cast<FieldDecl>(Lookup.front());
2747  InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
2748  TemplateArgs);
2749  }
2750  }
2751  }
2752 }
2753 
2754 /// \brief Instantiate the definitions of all of the members of the
2755 /// given class template specialization, which was named as part of an
2756 /// explicit instantiation.
2757 void
2759  SourceLocation PointOfInstantiation,
2760  ClassTemplateSpecializationDecl *ClassTemplateSpec,
2762  // C++0x [temp.explicit]p7:
2763  // An explicit instantiation that names a class template
2764  // specialization is an explicit instantion of the same kind
2765  // (declaration or definition) of each of its members (not
2766  // including members inherited from base classes) that has not
2767  // been previously explicitly specialized in the translation unit
2768  // containing the explicit instantiation, except as described
2769  // below.
2770  InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
2771  getTemplateInstantiationArgs(ClassTemplateSpec),
2772  TSK);
2773 }
2774 
2775 StmtResult
2777  if (!S)
2778  return S;
2779 
2780  TemplateInstantiator Instantiator(*this, TemplateArgs,
2781  SourceLocation(),
2782  DeclarationName());
2783  return Instantiator.TransformStmt(S);
2784 }
2785 
2786 ExprResult
2788  if (!E)
2789  return E;
2790 
2791  TemplateInstantiator Instantiator(*this, TemplateArgs,
2792  SourceLocation(),
2793  DeclarationName());
2794  return Instantiator.TransformExpr(E);
2795 }
2796 
2798  const MultiLevelTemplateArgumentList &TemplateArgs,
2799  bool CXXDirectInit) {
2800  TemplateInstantiator Instantiator(*this, TemplateArgs,
2801  SourceLocation(),
2802  DeclarationName());
2803  return Instantiator.TransformInitializer(Init, CXXDirectInit);
2804 }
2805 
2806 bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
2807  const MultiLevelTemplateArgumentList &TemplateArgs,
2808  SmallVectorImpl<Expr *> &Outputs) {
2809  if (Exprs.empty())
2810  return false;
2811 
2812  TemplateInstantiator Instantiator(*this, TemplateArgs,
2813  SourceLocation(),
2814  DeclarationName());
2815  return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2816  IsCall, Outputs);
2817 }
2818 
2821  const MultiLevelTemplateArgumentList &TemplateArgs) {
2822  if (!NNS)
2823  return NestedNameSpecifierLoc();
2824 
2825  TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
2826  DeclarationName());
2827  return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2828 }
2829 
2830 /// \brief Do template substitution on declaration name info.
2833  const MultiLevelTemplateArgumentList &TemplateArgs) {
2834  TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
2835  NameInfo.getName());
2836  return Instantiator.TransformDeclarationNameInfo(NameInfo);
2837 }
2838 
2841  TemplateName Name, SourceLocation Loc,
2842  const MultiLevelTemplateArgumentList &TemplateArgs) {
2843  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2844  DeclarationName());
2845  CXXScopeSpec SS;
2846  SS.Adopt(QualifierLoc);
2847  return Instantiator.TransformTemplateName(SS, Name, Loc);
2848 }
2849 
2850 bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
2852  const MultiLevelTemplateArgumentList &TemplateArgs) {
2853  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
2854  DeclarationName());
2855 
2856  return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2857 }
2858 
2859 static const Decl *getCanonicalParmVarDecl(const Decl *D) {
2860  // When storing ParmVarDecls in the local instantiation scope, we always
2861  // want to use the ParmVarDecl from the canonical function declaration,
2862  // since the map is then valid for any redeclaration or definition of that
2863  // function.
2864  if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2865  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2866  unsigned i = PV->getFunctionScopeIndex();
2867  // This parameter might be from a freestanding function type within the
2868  // function and isn't necessarily referring to one of FD's parameters.
2869  if (FD->getParamDecl(i) == PV)
2870  return FD->getCanonicalDecl()->getParamDecl(i);
2871  }
2872  }
2873  return D;
2874 }
2875 
2876 
2877 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2879  D = getCanonicalParmVarDecl(D);
2880  for (LocalInstantiationScope *Current = this; Current;
2881  Current = Current->Outer) {
2882 
2883  // Check if we found something within this scope.
2884  const Decl *CheckD = D;
2885  do {
2886  LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2887  if (Found != Current->LocalDecls.end())
2888  return &Found->second;
2889 
2890  // If this is a tag declaration, it's possible that we need to look for
2891  // a previous declaration.
2892  if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2893  CheckD = Tag->getPreviousDecl();
2894  else
2895  CheckD = nullptr;
2896  } while (CheckD);
2897 
2898  // If we aren't combined with our outer scope, we're done.
2899  if (!Current->CombineWithOuterScope)
2900  break;
2901  }
2902 
2903  // If we're performing a partial substitution during template argument
2904  // deduction, we may not have values for template parameters yet.
2905  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2906  isa<TemplateTemplateParmDecl>(D))
2907  return nullptr;
2908 
2909  // Local types referenced prior to definition may require instantiation.
2910  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
2911  if (RD->isLocalClass())
2912  return nullptr;
2913 
2914  // Enumeration types referenced prior to definition may appear as a result of
2915  // error recovery.
2916  if (isa<EnumDecl>(D))
2917  return nullptr;
2918 
2919  // If we didn't find the decl, then we either have a sema bug, or we have a
2920  // forward reference to a label declaration. Return null to indicate that
2921  // we have an uninstantiated label.
2922  assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope");
2923  return nullptr;
2924 }
2925 
2927  D = getCanonicalParmVarDecl(D);
2928  llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2929  if (Stored.isNull()) {
2930 #ifndef NDEBUG
2931  // It should not be present in any surrounding scope either.
2932  LocalInstantiationScope *Current = this;
2933  while (Current->CombineWithOuterScope && Current->Outer) {
2934  Current = Current->Outer;
2935  assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2936  "Instantiated local in inner and outer scopes");
2937  }
2938 #endif
2939  Stored = Inst;
2940  } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
2941  Pack->push_back(cast<ParmVarDecl>(Inst));
2942  } else {
2943  assert(Stored.get<Decl *>() == Inst && "Already instantiated this local");
2944  }
2945 }
2946 
2948  ParmVarDecl *Inst) {
2949  D = getCanonicalParmVarDecl(D);
2950  DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2951  Pack->push_back(Inst);
2952 }
2953 
2955 #ifndef NDEBUG
2956  // This should be the first time we've been told about this decl.
2957  for (LocalInstantiationScope *Current = this;
2958  Current && Current->CombineWithOuterScope; Current = Current->Outer)
2959  assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2960  "Creating local pack after instantiation of local");
2961 #endif
2962 
2963  D = getCanonicalParmVarDecl(D);
2964  llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2965  DeclArgumentPack *Pack = new DeclArgumentPack;
2966  Stored = Pack;
2967  ArgumentPacks.push_back(Pack);
2968 }
2969 
2971  const TemplateArgument *ExplicitArgs,
2972  unsigned NumExplicitArgs) {
2973  assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2974  "Already have a partially-substituted pack");
2975  assert((!PartiallySubstitutedPack
2976  || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2977  "Wrong number of arguments in partially-substituted pack");
2978  PartiallySubstitutedPack = Pack;
2979  ArgsInPartiallySubstitutedPack = ExplicitArgs;
2980  NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2981 }
2982 
2984  const TemplateArgument **ExplicitArgs,
2985  unsigned *NumExplicitArgs) const {
2986  if (ExplicitArgs)
2987  *ExplicitArgs = nullptr;
2988  if (NumExplicitArgs)
2989  *NumExplicitArgs = 0;
2990 
2991  for (const LocalInstantiationScope *Current = this; Current;
2992  Current = Current->Outer) {
2993  if (Current->PartiallySubstitutedPack) {
2994  if (ExplicitArgs)
2995  *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
2996  if (NumExplicitArgs)
2997  *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
2998 
2999  return Current->PartiallySubstitutedPack;
3000  }
3001 
3002  if (!Current->CombineWithOuterScope)
3003  break;
3004  }
3005 
3006  return nullptr;
3007 }
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
ExprResult BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
Defines the clang::ASTContext interface.
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:568
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1548
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
We are defining a synthesized function (such as a defaulted special member).
Definition: Sema.h:7130
Represents a function declaration or definition.
Definition: Decl.h:1696
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
Definition: Template.h:515
no exception specification
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:497
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
Definition: ExprCXX.h:1086
A (possibly-)qualified type.
Definition: Type.h:653
ASTConsumer & Consumer
Definition: Sema.h:318
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6858
void InstantiatedLocal(const Decl *D, Decl *Inst)
base_class_range bases()
Definition: DeclCXX.h:784
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:62
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:228
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained)...
Definition: Sema.h:7251
SourceRange getBraceRange() const
Definition: Decl.h:3095
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2611
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:134
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:7146
bool isMemberSpecialization()
Determines whether this class template partial specialization template was a specialization of a memb...
Stmt - This represents one statement.
Definition: Stmt.h:66
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:39
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
Provides information about an attempted template argument deduction, whose success or failure was des...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1014
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
Definition: SemaExpr.cpp:4595
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1271
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Defines the C++ template declaration subclasses.
StringRef P
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7194
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:952
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation. ...
Definition: Sema.h:7205
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2667
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:7604
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
Declaration of a variable template.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
A container of type source information.
Definition: Decl.h:86
bool SubstExprs(ArrayRef< Expr *> Exprs, bool IsCall, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< Expr *> &Outputs)
Substitute the given template arguments into a list of expressions, expanding pack expansions if requ...
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
We are instantiating a default argument for a template parameter.
Definition: Sema.h:7094
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4228
void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)
Note that the given parameter pack has been partially substituted via explicit specification of templ...
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned NonInstantiationEntries
The number of CodeSynthesisContexts that are not template instantiations and, therefore, should not be counted as part of the instantiation depth.
Definition: Sema.h:7235
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2618
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
LocalInstantiationScope * getStartingScope() const
Definition: Template.h:499
void ActOnFinishCXXNonNestedClass(Decl *D)
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
unsigned getDepth() const
Get the nesting depth of the template parameter.
void InstantiatedLocalPackArg(const Decl *D, ParmVarDecl *Inst)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10680
Represents a variable declaration or definition.
Definition: Decl.h:812
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1753
DiagnosticsEngine & Diags
Definition: Sema.h:319
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6317
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2130
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, unsigned ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
bool hasInheritedDefaultArg() const
Definition: Decl.h:1641
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1580
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
Represents a variable template specialization, which refers to a variable template with a given set o...
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:5053
reference front() const
Definition: DeclBase.h:1230
bool isInvalidDecl() const
Definition: DeclBase.h:546
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7082
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:629
Represents a parameter to a function.
Definition: Decl.h:1515
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
iterator begin() const
Definition: ExprCXX.h:3998
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
Definition: Sema.h:7155
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1625
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1455
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
Definition: DeclBase.cpp:337
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
Represents a struct/union/class.
Definition: Decl.h:3510
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:96
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7524
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
TemplateName getNameToSubstitute() const
Get the template name to substitute when this template name is used as a template template argument...
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2531
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1182
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
Definition: SemaDecl.cpp:13305
Represents a member of a struct/union/class.
Definition: Decl.h:2488
The current expression is potentially evaluated at run time, which means that code may be generated t...
void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)
Clear out a specific template argument.
Definition: Template.h:123
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1568
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:772
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation, for substitutions of prior template arguments.
Definition: Sema.h:7151
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3739
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
bool isReferenceType() const
Definition: Type.h:5960
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3295
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
Definition: DeclBase.h:847
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, Optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:3897
delayed_var_partial_spec_iterator delayed_var_partial_spec_end()
Definition: Template.h:527
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:269
Describes a module or submodule.
Definition: Module.h:65
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:107
We are instantiating the exception specification for a function template which was deferred until it ...
Definition: Sema.h:7123
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
Definition: ExprCXX.h:4002
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:522
PtrTy get() const
Definition: Ownership.h:174
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Definition: ExprCXX.cpp:1342
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
Definition: Decl.cpp:3882
TagKind getTagKind() const
Definition: Decl.h:3178
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
Definition: ExprCXX.h:3928
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:878
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:275
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:839
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
Definition: Sema.h:7210
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1638
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:832
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced...
Definition: Sema.h:7243
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:7143
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3491
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity, SourceRange InstantiationRange=SourceRange())
Note that we are instantiating a class template, function template, variable template, alias template, or a member thereof.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:716
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Definition: Type.h:4572
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1625
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:820
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1583
const LangOptions & getLangOpts() const
Definition: Sema.h:1194
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1042
void setLocStart(SourceLocation L)
Definition: Decl.h:2806
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:869
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7265
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
A helper class for building up ExtParameterInfos.
Definition: Sema.h:7629
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1536
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Perform substitution on the base class specifiers of the given class template specialization.
bool hasAttr() const
Definition: DeclBase.h:535
We are substituting explicit template arguments provided for a function template. ...
Definition: Sema.h:7103
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:275
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3274
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1443
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
SourceLocation getLocation() const
Definition: Expr.h:1049
We are instantiating a template declaration.
Definition: Sema.h:7087
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
Added for Template instantiation observation.
Definition: Sema.h:7136
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
delayed_partial_spec_iterator delayed_partial_spec_begin()
Return an iterator to the beginning of the set of "delayed" partial specializations, which must be passed to InstantiateClassTemplatePartialSpecialization once the class definition has been completed.
Definition: Template.h:511
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1562
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
Expr - This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
StringRef getKindName() const
Definition: Decl.h:3174
SourceLocation End
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4729
int Id
Definition: ASTDiff.cpp:191
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
Definition: Diagnostic.h:750
const FunctionProtoType * T
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4225
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7398
We are substituting template argument determined as part of template argument deduction for either a ...
Definition: Sema.h:7110
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4711
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1470
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
Definition: Sema.h:7226
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isFileContext() const
Definition: DeclBase.h:1401
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
Definition: DeclBase.h:425
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:742
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
EnumDecl * getDefinition() const
Definition: Decl.h:3331
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
int Depth
Definition: ASTDiff.cpp:191
QualType getType() const
Definition: Expr.h:128
void CheckCompletedCXXClass(CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:65
bool isInvalid() const
Definition: Ownership.h:170
void setLocation(SourceLocation L)
Definition: DeclBase.h:417
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
Definition: DeclCXX.cpp:1421
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3841
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
ValueDecl * getDecl()
Definition: Expr.h:1041
SourceLocation getLocation() const
Definition: Expr.h:1217
bool isUsable() const
Definition: Ownership.h:171
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:155
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
Definition: ExprCXX.h:3997
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:297
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation. ...
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3908
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all otuer scopes, down to the given outermost scope. ...
Definition: Template.h:361
virtual void printName(raw_ostream &os) const
Definition: Decl.cpp:1468
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
Definition: Sema.h:7126
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3371
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1196
A stack object to be created when performing template instantiation.
Definition: Sema.h:7302
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3506
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
Encodes a location in the source.
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1880
void setBraceRange(SourceRange R)
Definition: Decl.h:3096
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
Definition: Sema.h:7174
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:121
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2968
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3176
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2625
SynthesisKind
The kind of template instantiation we are performing.
Definition: Sema.h:7084
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2019
We are checking the validity of a default template argument that has been used when naming a template...
Definition: Sema.h:7119
bool isParameterPack() const
Definition: Type.h:4226
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4339
static const Decl * getCanonicalParmVarDecl(const Decl *D)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
void setTagKind(TagKind TK)
Definition: Decl.h:3182
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
Definition: Sema.h:7197
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1629
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:161
IdentType getIdentType() const
Definition: Expr.h:1215
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3728
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema&#39;s representation of template deduction information to the form used in overload-can...
ArrayRef< ParmVarDecl * > getParams() const
Definition: TypeLoc.h:1462
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Definition: TypeLoc.h:163
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
Definition: Template.h:110
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Definition: Type.cpp:2478
ParmVarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
Definition: ExprCXX.h:4005
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1645
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1870
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2804
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:638
SourceLocation getLocation() const
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization, which was named as part of an explicit instantiation.
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Definition: ExprCXX.h:3961
Represents a template argument.
Definition: TemplateBase.h:51
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
TagTypeKind
The kind of a tag type.
Definition: Type.h:4692
bool isNull() const
Determine whether this template name is NULL.
Dataflow Directional Tag Classes.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:7259
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: Sema.h:7161
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1188
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:391
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Definition: ExprCXX.h:3925
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:130
We are instantiating a default argument for a function.
Definition: Sema.h:7099
QualType RebuildElaboratedType(SourceLocation KeywordLoc, ElaboratedTypeKeyword Keyword, NestedNameSpecifierLoc QualifierLoc, QualType Named)
Build a new qualified name type.
delayed_partial_spec_iterator delayed_partial_spec_end()
Return an iterator to the end of the set of "delayed" partial specializations, which must be passed t...
Definition: Template.h:523
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:157
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1682
DeclarationName - The name of a declaration.
Expr * getDefaultArg()
Definition: Decl.cpp:2494
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
Definition: Decl.h:2330
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
Definition: Sema.h:7179
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Definition: DeclCXX.cpp:1414
Represents an enum.
Definition: Decl.h:3261
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
Definition: ExprCXX.h:3993
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:340
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
Definition: SemaDecl.cpp:12104
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:238
iterator end() const
Definition: ExprCXX.h:3999
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
RetTy Visit(PTR(Decl) D)
Definition: DeclVisitor.h:41
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4577
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1637
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2536
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:153
static std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a parameter pack.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:715
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
Definition: Sema.h:1090
The template argument is a type.
Definition: TemplateBase.h:60
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
Definition: Template.h:505
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2677
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
const Expr * Replacement
Definition: AttributeList.h:66
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
Definition: Sema.h:7140
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2185
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
Definition: Sema.h:7402
A template argument list.
Definition: DeclTemplate.h:210
bool hasFatalErrorOccurred() const
Definition: Diagnostic.h:753
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
unsigned getDepth() const
Definition: Type.h:4224
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:989
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
bool isVoidType() const
Definition: Type.h:6175
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier *> Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
Definition: Template.h:488
void Clear()
Note that we have finished instantiating this template.
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:607
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
Definition: Template.h:502
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:329
Declaration of a class template.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
SourceLocation getNameLoc() const
Definition: TypeLoc.h:518
We are substituting prior template arguments into a new template parameter.
Definition: Sema.h:7115
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
ExprResult ExprError()
Definition: Ownership.h:283
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ParmVarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ParmVarDecl *> Params)
Definition: ExprCXX.cpp:1359
const ParmVarDecl * getParam() const
Definition: ExprCXX.h:1073
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1864
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4499
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Definition: ASTConsumer.cpp:19
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
Definition: Decl.h:3100
QualType getType() const
Definition: Decl.h:647
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Definition: ExprCXX.h:3990
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:111
Wrapper for template type parameters.
Definition: TypeLoc.h:733
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:317
This represents a decl that may have a name.
Definition: Decl.h:248
bool isTranslationUnit() const
Definition: DeclBase.h:1405
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
NamedDecl * getAsNamedDecl(TemplateParameter P)
No keyword precedes the qualified type name.
Definition: Type.h:4732
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:647
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:652
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
Definition: SemaDecl.cpp:15172
bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl *> Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl *> *OutParams, ExtParameterInfoBuilder &ParamInfos)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:277
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:729
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
Definition: Decl.cpp:2550
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3399
Declaration of a template function.
Definition: DeclTemplate.h:967
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:416
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
Definition: ASTConsumer.h:73
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1690
A RAII object to temporarily push a declaration context.
Definition: Sema.h:706
static CXXRecordDecl * getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain)
Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...