clang  9.0.0
SemaTemplateInstantiateDecl.cpp
Go to the documentation of this file.
1 //===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //===----------------------------------------------------------------------===/
7 //
8 // This file implements C++ template instantiation for declarations.
9 //
10 //===----------------------------------------------------------------------===/
12 #include "clang/AST/ASTConsumer.h"
13 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclTemplate.h"
16 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/TypeLoc.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Template.h"
26 #include "llvm/Support/TimeProfiler.h"
27 
28 using namespace clang;
29 
30 static bool isDeclWithinFunction(const Decl *D) {
31  const DeclContext *DC = D->getDeclContext();
32  if (DC->isFunctionOrMethod())
33  return true;
34 
35  if (DC->isRecord())
36  return cast<CXXRecordDecl>(DC)->isLocalClass();
37 
38  return false;
39 }
40 
41 template<typename DeclT>
42 static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
43  const MultiLevelTemplateArgumentList &TemplateArgs) {
44  if (!OldDecl->getQualifierLoc())
45  return false;
46 
47  assert((NewDecl->getFriendObjectKind() ||
48  !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
49  "non-friend with qualified name defined in dependent context");
50  Sema::ContextRAII SavedContext(
51  SemaRef,
52  const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
53  ? NewDecl->getLexicalDeclContext()
54  : OldDecl->getLexicalDeclContext()));
55 
56  NestedNameSpecifierLoc NewQualifierLoc
57  = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
58  TemplateArgs);
59 
60  if (!NewQualifierLoc)
61  return true;
62 
63  NewDecl->setQualifierInfo(NewQualifierLoc);
64  return false;
65 }
66 
68  DeclaratorDecl *NewDecl) {
69  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
70 }
71 
73  TagDecl *NewDecl) {
74  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
75 }
76 
77 // Include attribute instantiation code.
78 #include "clang/Sema/AttrTemplateInstantiate.inc"
79 
81  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
82  const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
83  if (Aligned->isAlignmentExpr()) {
84  // The alignment expression is a constant expression.
87  ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
88  if (!Result.isInvalid())
89  S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
90  Aligned->getSpellingListIndex(), IsPackExpansion);
91  } else {
92  TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
93  TemplateArgs, Aligned->getLocation(),
94  DeclarationName());
95  if (Result)
96  S.AddAlignedAttr(Aligned->getLocation(), New, Result,
97  Aligned->getSpellingListIndex(), IsPackExpansion);
98  }
99 }
100 
102  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
103  const AlignedAttr *Aligned, Decl *New) {
104  if (!Aligned->isPackExpansion()) {
105  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
106  return;
107  }
108 
110  if (Aligned->isAlignmentExpr())
111  S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
112  Unexpanded);
113  else
114  S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
115  Unexpanded);
116  assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
117 
118  // Determine whether we can expand this attribute pack yet.
119  bool Expand = true, RetainExpansion = false;
120  Optional<unsigned> NumExpansions;
121  // FIXME: Use the actual location of the ellipsis.
122  SourceLocation EllipsisLoc = Aligned->getLocation();
123  if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
124  Unexpanded, TemplateArgs, Expand,
125  RetainExpansion, NumExpansions))
126  return;
127 
128  if (!Expand) {
129  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
130  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
131  } else {
132  for (unsigned I = 0; I != *NumExpansions; ++I) {
134  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
135  }
136  }
137 }
138 
140  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
141  const AssumeAlignedAttr *Aligned, Decl *New) {
142  // The alignment expression is a constant expression.
145 
146  Expr *E, *OE = nullptr;
147  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
148  if (Result.isInvalid())
149  return;
150  E = Result.getAs<Expr>();
151 
152  if (Aligned->getOffset()) {
153  Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
154  if (Result.isInvalid())
155  return;
156  OE = Result.getAs<Expr>();
157  }
158 
159  S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
160  Aligned->getSpellingListIndex());
161 }
162 
164  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
165  const AlignValueAttr *Aligned, Decl *New) {
166  // The alignment expression is a constant expression.
169  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
170  if (!Result.isInvalid())
171  S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
172  Aligned->getSpellingListIndex());
173 }
174 
176  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
177  const AllocAlignAttr *Align, Decl *New) {
178  Expr *Param = IntegerLiteral::Create(
179  S.getASTContext(),
180  llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
181  S.getASTContext().UnsignedLongLongTy, Align->getLocation());
182  S.AddAllocAlignAttr(Align->getLocation(), New, Param,
183  Align->getSpellingListIndex());
184 }
185 
187  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
188  const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
189  Expr *Cond = nullptr;
190  {
191  Sema::ContextRAII SwitchContext(S, New);
194  ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
195  if (Result.isInvalid())
196  return nullptr;
197  Cond = Result.getAs<Expr>();
198  }
199  if (!Cond->isTypeDependent()) {
200  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
201  if (Converted.isInvalid())
202  return nullptr;
203  Cond = Converted.get();
204  }
205 
207  if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
208  !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
209  S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
210  for (const auto &P : Diags)
211  S.Diag(P.first, P.second);
212  return nullptr;
213  }
214  return Cond;
215 }
216 
218  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
219  const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
221  S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
222 
223  if (Cond)
224  New->addAttr(new (S.getASTContext()) EnableIfAttr(
225  EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
226  EIA->getSpellingListIndex()));
227 }
228 
230  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
231  const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
233  S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
234 
235  if (Cond)
236  New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
237  DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
238  DIA->getDiagnosticType(), DIA->getArgDependent(), New,
239  DIA->getSpellingListIndex()));
240 }
241 
242 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
243 // template A as the base and arguments from TemplateArgs.
245  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
246  const CUDALaunchBoundsAttr &Attr, Decl *New) {
247  // The alignment expression is a constant expression.
250 
251  ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
252  if (Result.isInvalid())
253  return;
254  Expr *MaxThreads = Result.getAs<Expr>();
255 
256  Expr *MinBlocks = nullptr;
257  if (Attr.getMinBlocks()) {
258  Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
259  if (Result.isInvalid())
260  return;
261  MinBlocks = Result.getAs<Expr>();
262  }
263 
264  S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
265  Attr.getSpellingListIndex());
266 }
267 
268 static void
270  const MultiLevelTemplateArgumentList &TemplateArgs,
271  const ModeAttr &Attr, Decl *New) {
272  S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
273  Attr.getSpellingListIndex(), /*InInstantiation=*/true);
274 }
275 
276 /// Instantiation of 'declare simd' attribute and its arguments.
278  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
279  const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
280  // Allow 'this' in clauses with varlists.
281  if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
282  New = FTD->getTemplatedDecl();
283  auto *FD = cast<FunctionDecl>(New);
284  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
285  SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
286  SmallVector<unsigned, 4> LinModifiers;
287 
288  auto SubstExpr = [&](Expr *E) -> ExprResult {
289  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
290  if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
291  Sema::ContextRAII SavedContext(S, FD);
292  LocalInstantiationScope Local(S);
293  if (FD->getNumParams() > PVD->getFunctionScopeIndex())
294  Local.InstantiatedLocal(
295  PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
296  return S.SubstExpr(E, TemplateArgs);
297  }
298  Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
299  FD->isCXXInstanceMember());
300  return S.SubstExpr(E, TemplateArgs);
301  };
302 
303  // Substitute a single OpenMP clause, which is a potentially-evaluated
304  // full-expression.
305  auto Subst = [&](Expr *E) -> ExprResult {
308  ExprResult Res = SubstExpr(E);
309  if (Res.isInvalid())
310  return Res;
311  return S.ActOnFinishFullExpr(Res.get(), false);
312  };
313 
314  ExprResult Simdlen;
315  if (auto *E = Attr.getSimdlen())
316  Simdlen = Subst(E);
317 
318  if (Attr.uniforms_size() > 0) {
319  for(auto *E : Attr.uniforms()) {
320  ExprResult Inst = Subst(E);
321  if (Inst.isInvalid())
322  continue;
323  Uniforms.push_back(Inst.get());
324  }
325  }
326 
327  auto AI = Attr.alignments_begin();
328  for (auto *E : Attr.aligneds()) {
329  ExprResult Inst = Subst(E);
330  if (Inst.isInvalid())
331  continue;
332  Aligneds.push_back(Inst.get());
333  Inst = ExprEmpty();
334  if (*AI)
335  Inst = S.SubstExpr(*AI, TemplateArgs);
336  Alignments.push_back(Inst.get());
337  ++AI;
338  }
339 
340  auto SI = Attr.steps_begin();
341  for (auto *E : Attr.linears()) {
342  ExprResult Inst = Subst(E);
343  if (Inst.isInvalid())
344  continue;
345  Linears.push_back(Inst.get());
346  Inst = ExprEmpty();
347  if (*SI)
348  Inst = S.SubstExpr(*SI, TemplateArgs);
349  Steps.push_back(Inst.get());
350  ++SI;
351  }
352  LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
354  S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
355  Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
356  Attr.getRange());
357 }
358 
360  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
361  const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) {
362  // Both min and max expression are constant expressions.
365 
366  ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
367  if (Result.isInvalid())
368  return;
369  Expr *MinExpr = Result.getAs<Expr>();
370 
371  Result = S.SubstExpr(Attr.getMax(), TemplateArgs);
372  if (Result.isInvalid())
373  return;
374  Expr *MaxExpr = Result.getAs<Expr>();
375 
376  S.addAMDGPUFlatWorkGroupSizeAttr(Attr.getLocation(), New, MinExpr, MaxExpr,
377  Attr.getSpellingListIndex());
378 }
379 
380 static ExplicitSpecifier
382  const MultiLevelTemplateArgumentList &TemplateArgs,
383  ExplicitSpecifier ES, FunctionDecl *New) {
384  if (!ES.getExpr())
385  return ES;
386  Expr *OldCond = ES.getExpr();
387  Expr *Cond = nullptr;
388  {
391  ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs);
392  if (SubstResult.isInvalid()) {
394  }
395  Cond = SubstResult.get();
396  }
397  ExplicitSpecifier Result(Cond, ES.getKind());
398  if (!Cond->isTypeDependent())
400  return Result;
401 }
402 
404  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
405  const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
406  // Both min and max expression are constant expressions.
409 
410  ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
411  if (Result.isInvalid())
412  return;
413  Expr *MinExpr = Result.getAs<Expr>();
414 
415  Expr *MaxExpr = nullptr;
416  if (auto Max = Attr.getMax()) {
417  Result = S.SubstExpr(Max, TemplateArgs);
418  if (Result.isInvalid())
419  return;
420  MaxExpr = Result.getAs<Expr>();
421  }
422 
423  S.addAMDGPUWavesPerEUAttr(Attr.getLocation(), New, MinExpr, MaxExpr,
424  Attr.getSpellingListIndex());
425 }
426 
428  const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
429  Decl *New, LateInstantiatedAttrVec *LateAttrs,
430  LocalInstantiationScope *OuterMostScope) {
431  if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
432  for (const auto *TmplAttr : Tmpl->attrs()) {
433  // FIXME: If any of the special case versions from InstantiateAttrs become
434  // applicable to template declaration, we'll need to add them here.
435  CXXThisScopeRAII ThisScope(
436  *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
437  Qualifiers(), ND->isCXXInstanceMember());
438 
440  TmplAttr, Context, *this, TemplateArgs);
441  if (NewAttr)
442  New->addAttr(NewAttr);
443  }
444  }
445 }
446 
449  switch (A->getKind()) {
450  case clang::attr::CFConsumed:
452  case clang::attr::OSConsumed:
454  case clang::attr::NSConsumed:
456  default:
457  llvm_unreachable("Wrong argument supplied");
458  }
459 }
460 
462  const Decl *Tmpl, Decl *New,
463  LateInstantiatedAttrVec *LateAttrs,
464  LocalInstantiationScope *OuterMostScope) {
465  for (const auto *TmplAttr : Tmpl->attrs()) {
466  // FIXME: This should be generalized to more than just the AlignedAttr.
467  const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
468  if (Aligned && Aligned->isAlignmentDependent()) {
469  instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
470  continue;
471  }
472 
473  const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
474  if (AssumeAligned) {
475  instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
476  continue;
477  }
478 
479  const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
480  if (AlignValue) {
481  instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
482  continue;
483  }
484 
485  if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
486  instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
487  continue;
488  }
489 
490 
491  if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
492  instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
493  cast<FunctionDecl>(New));
494  continue;
495  }
496 
497  if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
498  instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
499  cast<FunctionDecl>(New));
500  continue;
501  }
502 
503  if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
504  dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
505  instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
506  *CUDALaunchBounds, New);
507  continue;
508  }
509 
510  if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
511  instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
512  continue;
513  }
514 
515  if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
516  instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
517  continue;
518  }
519 
520  if (const AMDGPUFlatWorkGroupSizeAttr *AMDGPUFlatWorkGroupSize =
521  dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
523  *this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
524  }
525 
526  if (const AMDGPUWavesPerEUAttr *AMDGPUFlatWorkGroupSize =
527  dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
528  instantiateDependentAMDGPUWavesPerEUAttr(*this, TemplateArgs,
529  *AMDGPUFlatWorkGroupSize, New);
530  }
531 
532  // Existing DLL attribute on the instantiation takes precedence.
533  if (TmplAttr->getKind() == attr::DLLExport ||
534  TmplAttr->getKind() == attr::DLLImport) {
535  if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
536  continue;
537  }
538  }
539 
540  if (auto ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
541  AddParameterABIAttr(ABIAttr->getRange(), New, ABIAttr->getABI(),
542  ABIAttr->getSpellingListIndex());
543  continue;
544  }
545 
546  if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
547  isa<CFConsumedAttr>(TmplAttr)) {
548  AddXConsumedAttr(New, TmplAttr->getRange(),
549  TmplAttr->getSpellingListIndex(),
550  attrToRetainOwnershipKind(TmplAttr),
551  /*template instantiation=*/true);
552  continue;
553  }
554 
555  assert(!TmplAttr->isPackExpansion());
556  if (TmplAttr->isLateParsed() && LateAttrs) {
557  // Late parsed attributes must be instantiated and attached after the
558  // enclosing class has been instantiated. See Sema::InstantiateClass.
559  LocalInstantiationScope *Saved = nullptr;
560  if (CurrentInstantiationScope)
561  Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
562  LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
563  } else {
564  // Allow 'this' within late-parsed attributes.
565  NamedDecl *ND = dyn_cast<NamedDecl>(New);
566  CXXRecordDecl *ThisContext =
567  dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
568  CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
569  ND && ND->isCXXInstanceMember());
570 
571  Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
572  *this, TemplateArgs);
573  if (NewAttr)
574  New->addAttr(NewAttr);
575  }
576  }
577 }
578 
579 /// Get the previous declaration of a declaration for the purposes of template
580 /// instantiation. If this finds a previous declaration, then the previous
581 /// declaration of the instantiation of D should be an instantiation of the
582 /// result of this function.
583 template<typename DeclT>
584 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
585  DeclT *Result = D->getPreviousDecl();
586 
587  // If the declaration is within a class, and the previous declaration was
588  // merged from a different definition of that class, then we don't have a
589  // previous declaration for the purpose of template instantiation.
590  if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
591  D->getLexicalDeclContext() != Result->getLexicalDeclContext())
592  return nullptr;
593 
594  return Result;
595 }
596 
597 Decl *
598 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
599  llvm_unreachable("Translation units cannot be instantiated");
600 }
601 
602 Decl *
603 TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
604  llvm_unreachable("pragma comment cannot be instantiated");
605 }
606 
607 Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
609  llvm_unreachable("pragma comment cannot be instantiated");
610 }
611 
612 Decl *
613 TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
614  llvm_unreachable("extern \"C\" context cannot be instantiated");
615 }
616 
617 Decl *
618 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
619  LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
620  D->getIdentifier());
621  Owner->addDecl(Inst);
622  return Inst;
623 }
624 
625 Decl *
626 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
627  llvm_unreachable("Namespaces cannot be instantiated");
628 }
629 
630 Decl *
631 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
632  NamespaceAliasDecl *Inst
633  = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
634  D->getNamespaceLoc(),
635  D->getAliasLoc(),
636  D->getIdentifier(),
637  D->getQualifierLoc(),
638  D->getTargetNameLoc(),
639  D->getNamespace());
640  Owner->addDecl(Inst);
641  return Inst;
642 }
643 
645  bool IsTypeAlias) {
646  bool Invalid = false;
648  if (DI->getType()->isInstantiationDependentType() ||
649  DI->getType()->isVariablyModifiedType()) {
650  DI = SemaRef.SubstType(DI, TemplateArgs,
651  D->getLocation(), D->getDeclName());
652  if (!DI) {
653  Invalid = true;
654  DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
655  }
656  } else {
658  }
659 
660  // HACK: g++ has a bug where it gets the value kind of ?: wrong.
661  // libstdc++ relies upon this bug in its implementation of common_type.
662  // If we happen to be processing that implementation, fake up the g++ ?:
663  // semantics. See LWG issue 2141 for more information on the bug.
664  const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
665  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
666  if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
667  DT->isReferenceType() &&
668  RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
669  RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
670  D->getIdentifier() && D->getIdentifier()->isStr("type") &&
672  // Fold it to the (non-reference) type which g++ would have produced.
673  DI = SemaRef.Context.getTrivialTypeSourceInfo(
674  DI->getType().getNonReferenceType());
675 
676  // Create the new typedef
677  TypedefNameDecl *Typedef;
678  if (IsTypeAlias)
679  Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
680  D->getLocation(), D->getIdentifier(), DI);
681  else
682  Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
683  D->getLocation(), D->getIdentifier(), DI);
684  if (Invalid)
685  Typedef->setInvalidDecl();
686 
687  // If the old typedef was the name for linkage purposes of an anonymous
688  // tag decl, re-establish that relationship for the new typedef.
689  if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
690  TagDecl *oldTag = oldTagType->getDecl();
691  if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
692  TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
693  assert(!newTag->hasNameForLinkage());
694  newTag->setTypedefNameForAnonDecl(Typedef);
695  }
696  }
697 
699  NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
700  TemplateArgs);
701  if (!InstPrev)
702  return nullptr;
703 
704  TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
705 
706  // If the typedef types are not identical, reject them.
707  SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
708 
709  Typedef->setPreviousDecl(InstPrevTypedef);
710  }
711 
712  SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
713 
714  Typedef->setAccess(D->getAccess());
715 
716  return Typedef;
717 }
718 
719 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
720  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
721  if (Typedef)
722  Owner->addDecl(Typedef);
723  return Typedef;
724 }
725 
726 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
727  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
728  if (Typedef)
729  Owner->addDecl(Typedef);
730  return Typedef;
731 }
732 
733 Decl *
734 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
735  // Create a local instantiation scope for this type alias template, which
736  // will contain the instantiations of the template parameters.
738 
739  TemplateParameterList *TempParams = D->getTemplateParameters();
740  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
741  if (!InstParams)
742  return nullptr;
743 
744  TypeAliasDecl *Pattern = D->getTemplatedDecl();
745 
746  TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
747  if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
748  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
749  if (!Found.empty()) {
750  PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
751  }
752  }
753 
754  TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
755  InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
756  if (!AliasInst)
757  return nullptr;
758 
760  = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
761  D->getDeclName(), InstParams, AliasInst);
762  AliasInst->setDescribedAliasTemplate(Inst);
763  if (PrevAliasTemplate)
764  Inst->setPreviousDecl(PrevAliasTemplate);
765 
766  Inst->setAccess(D->getAccess());
767 
768  if (!PrevAliasTemplate)
770 
771  Owner->addDecl(Inst);
772 
773  return Inst;
774 }
775 
776 Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
777  auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
778  D->getIdentifier());
779  NewBD->setReferenced(D->isReferenced());
780  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
781  return NewBD;
782 }
783 
784 Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
785  // Transform the bindings first.
786  SmallVector<BindingDecl*, 16> NewBindings;
787  for (auto *OldBD : D->bindings())
788  NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
789  ArrayRef<BindingDecl*> NewBindingArray = NewBindings;
790 
791  auto *NewDD = cast_or_null<DecompositionDecl>(
792  VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));
793 
794  if (!NewDD || NewDD->isInvalidDecl())
795  for (auto *NewBD : NewBindings)
796  NewBD->setInvalidDecl();
797 
798  return NewDD;
799 }
800 
802  return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
803 }
804 
806  bool InstantiatingVarTemplate,
807  ArrayRef<BindingDecl*> *Bindings) {
808 
809  // Do substitution on the type of the declaration
810  TypeSourceInfo *DI = SemaRef.SubstType(
811  D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
812  D->getDeclName(), /*AllowDeducedTST*/true);
813  if (!DI)
814  return nullptr;
815 
816  if (DI->getType()->isFunctionType()) {
817  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
818  << D->isStaticDataMember() << DI->getType();
819  return nullptr;
820  }
821 
822  DeclContext *DC = Owner;
823  if (D->isLocalExternDecl())
825 
826  // Build the instantiated declaration.
827  VarDecl *Var;
828  if (Bindings)
829  Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
830  D->getLocation(), DI->getType(), DI,
831  D->getStorageClass(), *Bindings);
832  else
833  Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
834  D->getLocation(), D->getIdentifier(), DI->getType(),
835  DI, D->getStorageClass());
836 
837  // In ARC, infer 'retaining' for variables of retainable type.
838  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
839  SemaRef.inferObjCARCLifetime(Var))
840  Var->setInvalidDecl();
841 
842  // Substitute the nested name specifier, if any.
843  if (SubstQualifier(D, Var))
844  return nullptr;
845 
846  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
847  StartingScope, InstantiatingVarTemplate);
848 
849  if (D->isNRVOVariable()) {
850  QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
851  if (SemaRef.isCopyElisionCandidate(ReturnType, Var, Sema::CES_Strict))
852  Var->setNRVOVariable(true);
853  }
854 
855  Var->setImplicit(D->isImplicit());
856 
857  if (Var->isStaticLocal())
858  SemaRef.CheckStaticLocalForDllExport(Var);
859 
860  return Var;
861 }
862 
863 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
864  AccessSpecDecl* AD
865  = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
867  Owner->addHiddenDecl(AD);
868  return AD;
869 }
870 
871 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
872  bool Invalid = false;
874  if (DI->getType()->isInstantiationDependentType() ||
875  DI->getType()->isVariablyModifiedType()) {
876  DI = SemaRef.SubstType(DI, TemplateArgs,
877  D->getLocation(), D->getDeclName());
878  if (!DI) {
879  DI = D->getTypeSourceInfo();
880  Invalid = true;
881  } else if (DI->getType()->isFunctionType()) {
882  // C++ [temp.arg.type]p3:
883  // If a declaration acquires a function type through a type
884  // dependent on a template-parameter and this causes a
885  // declaration that does not use the syntactic form of a
886  // function declarator to have function type, the program is
887  // ill-formed.
888  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
889  << DI->getType();
890  Invalid = true;
891  }
892  } else {
894  }
895 
896  Expr *BitWidth = D->getBitWidth();
897  if (Invalid)
898  BitWidth = nullptr;
899  else if (BitWidth) {
900  // The bit-width expression is a constant expression.
903 
904  ExprResult InstantiatedBitWidth
905  = SemaRef.SubstExpr(BitWidth, TemplateArgs);
906  if (InstantiatedBitWidth.isInvalid()) {
907  Invalid = true;
908  BitWidth = nullptr;
909  } else
910  BitWidth = InstantiatedBitWidth.getAs<Expr>();
911  }
912 
913  FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
914  DI->getType(), DI,
915  cast<RecordDecl>(Owner),
916  D->getLocation(),
917  D->isMutable(),
918  BitWidth,
919  D->getInClassInitStyle(),
920  D->getInnerLocStart(),
921  D->getAccess(),
922  nullptr);
923  if (!Field) {
924  cast<Decl>(Owner)->setInvalidDecl();
925  return nullptr;
926  }
927 
928  SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
929 
930  if (Field->hasAttrs())
931  SemaRef.CheckAlignasUnderalignment(Field);
932 
933  if (Invalid)
934  Field->setInvalidDecl();
935 
936  if (!Field->getDeclName()) {
937  // Keep track of where this decl came from.
939  }
940  if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
941  if (Parent->isAnonymousStructOrUnion() &&
942  Parent->getRedeclContext()->isFunctionOrMethod())
943  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
944  }
945 
946  Field->setImplicit(D->isImplicit());
947  Field->setAccess(D->getAccess());
948  Owner->addDecl(Field);
949 
950  return Field;
951 }
952 
953 Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
954  bool Invalid = false;
956 
957  if (DI->getType()->isVariablyModifiedType()) {
958  SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
959  << D;
960  Invalid = true;
961  } else if (DI->getType()->isInstantiationDependentType()) {
962  DI = SemaRef.SubstType(DI, TemplateArgs,
963  D->getLocation(), D->getDeclName());
964  if (!DI) {
965  DI = D->getTypeSourceInfo();
966  Invalid = true;
967  } else if (DI->getType()->isFunctionType()) {
968  // C++ [temp.arg.type]p3:
969  // If a declaration acquires a function type through a type
970  // dependent on a template-parameter and this causes a
971  // declaration that does not use the syntactic form of a
972  // function declarator to have function type, the program is
973  // ill-formed.
974  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
975  << DI->getType();
976  Invalid = true;
977  }
978  } else {
980  }
981 
983  SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
984  DI, D->getBeginLoc(), D->getGetterId(), D->getSetterId());
985 
986  SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
987  StartingScope);
988 
989  if (Invalid)
990  Property->setInvalidDecl();
991 
992  Property->setAccess(D->getAccess());
993  Owner->addDecl(Property);
994 
995  return Property;
996 }
997 
998 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
999  NamedDecl **NamedChain =
1000  new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
1001 
1002  int i = 0;
1003  for (auto *PI : D->chain()) {
1004  NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
1005  TemplateArgs);
1006  if (!Next)
1007  return nullptr;
1008 
1009  NamedChain[i++] = Next;
1010  }
1011 
1012  QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
1014  SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
1015  {NamedChain, D->getChainingSize()});
1016 
1017  for (const auto *Attr : D->attrs())
1018  IndirectField->addAttr(Attr->clone(SemaRef.Context));
1019 
1020  IndirectField->setImplicit(D->isImplicit());
1021  IndirectField->setAccess(D->getAccess());
1022  Owner->addDecl(IndirectField);
1023  return IndirectField;
1024 }
1025 
1026 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
1027  // Handle friend type expressions by simply substituting template
1028  // parameters into the pattern type and checking the result.
1029  if (TypeSourceInfo *Ty = D->getFriendType()) {
1030  TypeSourceInfo *InstTy;
1031  // If this is an unsupported friend, don't bother substituting template
1032  // arguments into it. The actual type referred to won't be used by any
1033  // parts of Clang, and may not be valid for instantiating. Just use the
1034  // same info for the instantiated friend.
1035  if (D->isUnsupportedFriend()) {
1036  InstTy = Ty;
1037  } else {
1038  InstTy = SemaRef.SubstType(Ty, TemplateArgs,
1039  D->getLocation(), DeclarationName());
1040  }
1041  if (!InstTy)
1042  return nullptr;
1043 
1044  FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getBeginLoc(),
1045  D->getFriendLoc(), InstTy);
1046  if (!FD)
1047  return nullptr;
1048 
1049  FD->setAccess(AS_public);
1051  Owner->addDecl(FD);
1052  return FD;
1053  }
1054 
1055  NamedDecl *ND = D->getFriendDecl();
1056  assert(ND && "friend decl must be a decl or a type!");
1057 
1058  // All of the Visit implementations for the various potential friend
1059  // declarations have to be carefully written to work for friend
1060  // objects, with the most important detail being that the target
1061  // decl should almost certainly not be placed in Owner.
1062  Decl *NewND = Visit(ND);
1063  if (!NewND) return nullptr;
1064 
1065  FriendDecl *FD =
1066  FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1067  cast<NamedDecl>(NewND), D->getFriendLoc());
1068  FD->setAccess(AS_public);
1070  Owner->addDecl(FD);
1071  return FD;
1072 }
1073 
1074 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
1075  Expr *AssertExpr = D->getAssertExpr();
1076 
1077  // The expression in a static assertion is a constant expression.
1080 
1081  ExprResult InstantiatedAssertExpr
1082  = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
1083  if (InstantiatedAssertExpr.isInvalid())
1084  return nullptr;
1085 
1086  return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
1087  InstantiatedAssertExpr.get(),
1088  D->getMessage(),
1089  D->getRParenLoc(),
1090  D->isFailed());
1091 }
1092 
1093 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
1094  EnumDecl *PrevDecl = nullptr;
1095  if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1096  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1097  PatternPrev,
1098  TemplateArgs);
1099  if (!Prev) return nullptr;
1100  PrevDecl = cast<EnumDecl>(Prev);
1101  }
1102 
1103  EnumDecl *Enum =
1104  EnumDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
1105  D->getLocation(), D->getIdentifier(), PrevDecl,
1106  D->isScoped(), D->isScopedUsingClassTag(), D->isFixed());
1107  if (D->isFixed()) {
1108  if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
1109  // If we have type source information for the underlying type, it means it
1110  // has been explicitly set by the user. Perform substitution on it before
1111  // moving on.
1112  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1113  TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
1114  DeclarationName());
1115  if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
1116  Enum->setIntegerType(SemaRef.Context.IntTy);
1117  else
1118  Enum->setIntegerTypeSourceInfo(NewTI);
1119  } else {
1120  assert(!D->getIntegerType()->isDependentType()
1121  && "Dependent type without type source info");
1122  Enum->setIntegerType(D->getIntegerType());
1123  }
1124  }
1125 
1126  SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
1127 
1128  Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
1129  Enum->setAccess(D->getAccess());
1130  // Forward the mangling number from the template to the instantiated decl.
1131  SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
1132  // See if the old tag was defined along with a declarator.
1133  // If it did, mark the new tag as being associated with that declarator.
1135  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
1136  // See if the old tag was defined along with a typedef.
1137  // If it did, mark the new tag as being associated with that typedef.
1139  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
1140  if (SubstQualifier(D, Enum)) return nullptr;
1141  Owner->addDecl(Enum);
1142 
1143  EnumDecl *Def = D->getDefinition();
1144  if (Def && Def != D) {
1145  // If this is an out-of-line definition of an enum member template, check
1146  // that the underlying types match in the instantiation of both
1147  // declarations.
1148  if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
1149  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1150  QualType DefnUnderlying =
1151  SemaRef.SubstType(TI->getType(), TemplateArgs,
1152  UnderlyingLoc, DeclarationName());
1153  SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
1154  DefnUnderlying, /*IsFixed=*/true, Enum);
1155  }
1156  }
1157 
1158  // C++11 [temp.inst]p1: The implicit instantiation of a class template
1159  // specialization causes the implicit instantiation of the declarations, but
1160  // not the definitions of scoped member enumerations.
1161  //
1162  // DR1484 clarifies that enumeration definitions inside of a template
1163  // declaration aren't considered entities that can be separately instantiated
1164  // from the rest of the entity they are declared inside of.
1165  if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
1166  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
1167  InstantiateEnumDefinition(Enum, Def);
1168  }
1169 
1170  return Enum;
1171 }
1172 
1174  EnumDecl *Enum, EnumDecl *Pattern) {
1175  Enum->startDefinition();
1176 
1177  // Update the location to refer to the definition.
1178  Enum->setLocation(Pattern->getLocation());
1179 
1180  SmallVector<Decl*, 4> Enumerators;
1181 
1182  EnumConstantDecl *LastEnumConst = nullptr;
1183  for (auto *EC : Pattern->enumerators()) {
1184  // The specified value for the enumerator.
1185  ExprResult Value((Expr *)nullptr);
1186  if (Expr *UninstValue = EC->getInitExpr()) {
1187  // The enumerator's value expression is a constant expression.
1190 
1191  Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
1192  }
1193 
1194  // Drop the initial value and continue.
1195  bool isInvalid = false;
1196  if (Value.isInvalid()) {
1197  Value = nullptr;
1198  isInvalid = true;
1199  }
1200 
1201  EnumConstantDecl *EnumConst
1202  = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
1203  EC->getLocation(), EC->getIdentifier(),
1204  Value.get());
1205 
1206  if (isInvalid) {
1207  if (EnumConst)
1208  EnumConst->setInvalidDecl();
1209  Enum->setInvalidDecl();
1210  }
1211 
1212  if (EnumConst) {
1213  SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
1214 
1215  EnumConst->setAccess(Enum->getAccess());
1216  Enum->addDecl(EnumConst);
1217  Enumerators.push_back(EnumConst);
1218  LastEnumConst = EnumConst;
1219 
1220  if (Pattern->getDeclContext()->isFunctionOrMethod() &&
1221  !Enum->isScoped()) {
1222  // If the enumeration is within a function or method, record the enum
1223  // constant as a local.
1224  SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
1225  }
1226  }
1227  }
1228 
1229  SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
1230  Enumerators, nullptr, ParsedAttributesView());
1231 }
1232 
1233 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
1234  llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
1235 }
1236 
1237 Decl *
1238 TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1239  llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.");
1240 }
1241 
1242 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1243  bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1244 
1245  // Create a local instantiation scope for this class template, which
1246  // will contain the instantiations of the template parameters.
1247  LocalInstantiationScope Scope(SemaRef);
1248  TemplateParameterList *TempParams = D->getTemplateParameters();
1249  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1250  if (!InstParams)
1251  return nullptr;
1252 
1253  CXXRecordDecl *Pattern = D->getTemplatedDecl();
1254 
1255  // Instantiate the qualifier. We have to do this first in case
1256  // we're a friend declaration, because if we are then we need to put
1257  // the new declaration in the appropriate context.
1258  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
1259  if (QualifierLoc) {
1260  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1261  TemplateArgs);
1262  if (!QualifierLoc)
1263  return nullptr;
1264  }
1265 
1266  CXXRecordDecl *PrevDecl = nullptr;
1267  ClassTemplateDecl *PrevClassTemplate = nullptr;
1268 
1269  if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
1270  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1271  if (!Found.empty()) {
1272  PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
1273  if (PrevClassTemplate)
1274  PrevDecl = PrevClassTemplate->getTemplatedDecl();
1275  }
1276  }
1277 
1278  // If this isn't a friend, then it's a member template, in which
1279  // case we just want to build the instantiation in the
1280  // specialization. If it is a friend, we want to build it in
1281  // the appropriate context.
1282  DeclContext *DC = Owner;
1283  if (isFriend) {
1284  if (QualifierLoc) {
1285  CXXScopeSpec SS;
1286  SS.Adopt(QualifierLoc);
1287  DC = SemaRef.computeDeclContext(SS);
1288  if (!DC) return nullptr;
1289  } else {
1290  DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
1291  Pattern->getDeclContext(),
1292  TemplateArgs);
1293  }
1294 
1295  // Look for a previous declaration of the template in the owning
1296  // context.
1297  LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
1299  SemaRef.forRedeclarationInCurContext());
1300  SemaRef.LookupQualifiedName(R, DC);
1301 
1302  if (R.isSingleResult()) {
1303  PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
1304  if (PrevClassTemplate)
1305  PrevDecl = PrevClassTemplate->getTemplatedDecl();
1306  }
1307 
1308  if (!PrevClassTemplate && QualifierLoc) {
1309  SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
1310  << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
1311  << QualifierLoc.getSourceRange();
1312  return nullptr;
1313  }
1314 
1315  bool AdoptedPreviousTemplateParams = false;
1316  if (PrevClassTemplate) {
1317  bool Complain = true;
1318 
1319  // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
1320  // template for struct std::tr1::__detail::_Map_base, where the
1321  // template parameters of the friend declaration don't match the
1322  // template parameters of the original declaration. In this one
1323  // case, we don't complain about the ill-formed friend
1324  // declaration.
1325  if (isFriend && Pattern->getIdentifier() &&
1326  Pattern->getIdentifier()->isStr("_Map_base") &&
1327  DC->isNamespace() &&
1328  cast<NamespaceDecl>(DC)->getIdentifier() &&
1329  cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
1330  DeclContext *DCParent = DC->getParent();
1331  if (DCParent->isNamespace() &&
1332  cast<NamespaceDecl>(DCParent)->getIdentifier() &&
1333  cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
1334  if (cast<Decl>(DCParent)->isInStdNamespace())
1335  Complain = false;
1336  }
1337  }
1338 
1339  TemplateParameterList *PrevParams
1340  = PrevClassTemplate->getMostRecentDecl()->getTemplateParameters();
1341 
1342  // Make sure the parameter lists match.
1343  if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
1344  Complain,
1346  if (Complain)
1347  return nullptr;
1348 
1349  AdoptedPreviousTemplateParams = true;
1350  InstParams = PrevParams;
1351  }
1352 
1353  // Do some additional validation, then merge default arguments
1354  // from the existing declarations.
1355  if (!AdoptedPreviousTemplateParams &&
1356  SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1358  return nullptr;
1359  }
1360  }
1361 
1362  CXXRecordDecl *RecordInst = CXXRecordDecl::Create(
1363  SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(),
1364  Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl,
1365  /*DelayTypeCreation=*/true);
1366 
1367  if (QualifierLoc)
1368  RecordInst->setQualifierInfo(QualifierLoc);
1369 
1370  SemaRef.InstantiateAttrsForDecl(TemplateArgs, Pattern, RecordInst, LateAttrs,
1371  StartingScope);
1372 
1373  ClassTemplateDecl *Inst
1374  = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
1375  D->getIdentifier(), InstParams, RecordInst);
1376  assert(!(isFriend && Owner->isDependentContext()));
1377  Inst->setPreviousDecl(PrevClassTemplate);
1378 
1379  RecordInst->setDescribedClassTemplate(Inst);
1380 
1381  if (isFriend) {
1382  if (PrevClassTemplate)
1383  Inst->setAccess(PrevClassTemplate->getAccess());
1384  else
1385  Inst->setAccess(D->getAccess());
1386 
1387  Inst->setObjectOfFriendDecl();
1388  // TODO: do we want to track the instantiation progeny of this
1389  // friend target decl?
1390  } else {
1391  Inst->setAccess(D->getAccess());
1392  if (!PrevClassTemplate)
1394  }
1395 
1396  // Trigger creation of the type for the instantiation.
1397  SemaRef.Context.getInjectedClassNameType(RecordInst,
1399 
1400  // Finish handling of friends.
1401  if (isFriend) {
1402  DC->makeDeclVisibleInContext(Inst);
1403  Inst->setLexicalDeclContext(Owner);
1404  RecordInst->setLexicalDeclContext(Owner);
1405  return Inst;
1406  }
1407 
1408  if (D->isOutOfLine()) {
1410  RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1411  }
1412 
1413  Owner->addDecl(Inst);
1414 
1415  if (!PrevClassTemplate) {
1416  // Queue up any out-of-line partial specializations of this member
1417  // class template; the client will force their instantiation once
1418  // the enclosing class has been instantiated.
1420  D->getPartialSpecializations(PartialSpecs);
1421  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1422  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1423  OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1424  }
1425 
1426  return Inst;
1427 }
1428 
1429 Decl *
1430 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1432  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
1433 
1434  // Lookup the already-instantiated declaration in the instantiation
1435  // of the class template and return that.
1437  = Owner->lookup(ClassTemplate->getDeclName());
1438  if (Found.empty())
1439  return nullptr;
1440 
1441  ClassTemplateDecl *InstClassTemplate
1442  = dyn_cast<ClassTemplateDecl>(Found.front());
1443  if (!InstClassTemplate)
1444  return nullptr;
1445 
1447  = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1448  return Result;
1449 
1450  return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1451 }
1452 
1453 Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1454  assert(D->getTemplatedDecl()->isStaticDataMember() &&
1455  "Only static data member templates are allowed.");
1456 
1457  // Create a local instantiation scope for this variable template, which
1458  // will contain the instantiations of the template parameters.
1459  LocalInstantiationScope Scope(SemaRef);
1460  TemplateParameterList *TempParams = D->getTemplateParameters();
1461  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1462  if (!InstParams)
1463  return nullptr;
1464 
1465  VarDecl *Pattern = D->getTemplatedDecl();
1466  VarTemplateDecl *PrevVarTemplate = nullptr;
1467 
1468  if (getPreviousDeclForInstantiation(Pattern)) {
1469  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1470  if (!Found.empty())
1471  PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1472  }
1473 
1474  VarDecl *VarInst =
1475  cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1476  /*InstantiatingVarTemplate=*/true));
1477  if (!VarInst) return nullptr;
1478 
1479  DeclContext *DC = Owner;
1480 
1482  SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
1483  VarInst);
1484  VarInst->setDescribedVarTemplate(Inst);
1485  Inst->setPreviousDecl(PrevVarTemplate);
1486 
1487  Inst->setAccess(D->getAccess());
1488  if (!PrevVarTemplate)
1490 
1491  if (D->isOutOfLine()) {
1494  }
1495 
1496  Owner->addDecl(Inst);
1497 
1498  if (!PrevVarTemplate) {
1499  // Queue up any out-of-line partial specializations of this member
1500  // variable template; the client will force their instantiation once
1501  // the enclosing class has been instantiated.
1503  D->getPartialSpecializations(PartialSpecs);
1504  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1505  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1506  OutOfLineVarPartialSpecs.push_back(
1507  std::make_pair(Inst, PartialSpecs[I]));
1508  }
1509 
1510  return Inst;
1511 }
1512 
1513 Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1515  assert(D->isStaticDataMember() &&
1516  "Only static data member templates are allowed.");
1517 
1518  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1519 
1520  // Lookup the already-instantiated declaration and return that.
1521  DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1522  assert(!Found.empty() && "Instantiation found nothing?");
1523 
1524  VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1525  assert(InstVarTemplate && "Instantiation did not find a variable template?");
1526 
1528  InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1529  return Result;
1530 
1531  return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1532 }
1533 
1534 Decl *
1535 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1536  // Create a local instantiation scope for this function template, which
1537  // will contain the instantiations of the template parameters and then get
1538  // merged with the local instantiation scope for the function template
1539  // itself.
1540  LocalInstantiationScope Scope(SemaRef);
1541 
1542  TemplateParameterList *TempParams = D->getTemplateParameters();
1543  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1544  if (!InstParams)
1545  return nullptr;
1546 
1547  FunctionDecl *Instantiated = nullptr;
1548  if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1549  Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1550  InstParams));
1551  else
1552  Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1553  D->getTemplatedDecl(),
1554  InstParams));
1555 
1556  if (!Instantiated)
1557  return nullptr;
1558 
1559  // Link the instantiated function template declaration to the function
1560  // template from which it was instantiated.
1561  FunctionTemplateDecl *InstTemplate
1562  = Instantiated->getDescribedFunctionTemplate();
1563  InstTemplate->setAccess(D->getAccess());
1564  assert(InstTemplate &&
1565  "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1566 
1567  bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1568 
1569  // Link the instantiation back to the pattern *unless* this is a
1570  // non-definition friend declaration.
1571  if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1572  !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1573  InstTemplate->setInstantiatedFromMemberTemplate(D);
1574 
1575  // Make declarations visible in the appropriate context.
1576  if (!isFriend) {
1577  Owner->addDecl(InstTemplate);
1578  } else if (InstTemplate->getDeclContext()->isRecord() &&
1580  SemaRef.CheckFriendAccess(InstTemplate);
1581  }
1582 
1583  return InstTemplate;
1584 }
1585 
1586 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1587  CXXRecordDecl *PrevDecl = nullptr;
1588  if (D->isInjectedClassName())
1589  PrevDecl = cast<CXXRecordDecl>(Owner);
1590  else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1591  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1592  PatternPrev,
1593  TemplateArgs);
1594  if (!Prev) return nullptr;
1595  PrevDecl = cast<CXXRecordDecl>(Prev);
1596  }
1597 
1599  SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(),
1600  D->getLocation(), D->getIdentifier(), PrevDecl);
1601 
1602  // Substitute the nested name specifier, if any.
1603  if (SubstQualifier(D, Record))
1604  return nullptr;
1605 
1606  SemaRef.InstantiateAttrsForDecl(TemplateArgs, D, Record, LateAttrs,
1607  StartingScope);
1608 
1609  Record->setImplicit(D->isImplicit());
1610  // FIXME: Check against AS_none is an ugly hack to work around the issue that
1611  // the tag decls introduced by friend class declarations don't have an access
1612  // specifier. Remove once this area of the code gets sorted out.
1613  if (D->getAccess() != AS_none)
1614  Record->setAccess(D->getAccess());
1615  if (!D->isInjectedClassName())
1616  Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
1617 
1618  // If the original function was part of a friend declaration,
1619  // inherit its namespace state.
1620  if (D->getFriendObjectKind())
1621  Record->setObjectOfFriendDecl();
1622 
1623  // Make sure that anonymous structs and unions are recorded.
1624  if (D->isAnonymousStructOrUnion())
1625  Record->setAnonymousStructOrUnion(true);
1626 
1627  if (D->isLocalClass())
1628  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1629 
1630  // Forward the mangling number from the template to the instantiated decl.
1631  SemaRef.Context.setManglingNumber(Record,
1632  SemaRef.Context.getManglingNumber(D));
1633 
1634  // See if the old tag was defined along with a declarator.
1635  // If it did, mark the new tag as being associated with that declarator.
1637  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);
1638 
1639  // See if the old tag was defined along with a typedef.
1640  // If it did, mark the new tag as being associated with that typedef.
1642  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);
1643 
1644  Owner->addDecl(Record);
1645 
1646  // DR1484 clarifies that the members of a local class are instantiated as part
1647  // of the instantiation of their enclosing entity.
1648  if (D->isCompleteDefinition() && D->isLocalClass()) {
1649  Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);
1650 
1651  SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1653  /*Complain=*/true);
1654 
1655  // For nested local classes, we will instantiate the members when we
1656  // reach the end of the outermost (non-nested) local class.
1657  if (!D->isCXXClassMember())
1658  SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1660 
1661  // This class may have local implicit instantiations that need to be
1662  // performed within this scope.
1663  LocalInstantiations.perform();
1664  }
1665 
1666  SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1667 
1668  return Record;
1669 }
1670 
1671 /// Adjust the given function type for an instantiation of the
1672 /// given declaration, to cope with modifications to the function's type that
1673 /// aren't reflected in the type-source information.
1674 ///
1675 /// \param D The declaration we're instantiating.
1676 /// \param TInfo The already-instantiated type.
1678  FunctionDecl *D,
1679  TypeSourceInfo *TInfo) {
1680  const FunctionProtoType *OrigFunc
1681  = D->getType()->castAs<FunctionProtoType>();
1682  const FunctionProtoType *NewFunc
1683  = TInfo->getType()->castAs<FunctionProtoType>();
1684  if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1685  return TInfo->getType();
1686 
1687  FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1688  NewEPI.ExtInfo = OrigFunc->getExtInfo();
1689  return Context.getFunctionType(NewFunc->getReturnType(),
1690  NewFunc->getParamTypes(), NewEPI);
1691 }
1692 
1693 /// Normal class members are of more specific types and therefore
1694 /// don't make it here. This function serves three purposes:
1695 /// 1) instantiating function templates
1696 /// 2) substituting friend declarations
1697 /// 3) substituting deduction guide declarations for nested class templates
1699  TemplateParameterList *TemplateParams) {
1700  // Check whether there is already a function template specialization for
1701  // this declaration.
1702  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1703  if (FunctionTemplate && !TemplateParams) {
1704  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1705 
1706  void *InsertPos = nullptr;
1707  FunctionDecl *SpecFunc
1708  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1709 
1710  // If we already have a function template specialization, return it.
1711  if (SpecFunc)
1712  return SpecFunc;
1713  }
1714 
1715  bool isFriend;
1716  if (FunctionTemplate)
1717  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1718  else
1719  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1720 
1721  bool MergeWithParentScope = (TemplateParams != nullptr) ||
1722  Owner->isFunctionOrMethod() ||
1723  !(isa<Decl>(Owner) &&
1724  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1725  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1726 
1727  ExplicitSpecifier InstantiatedExplicitSpecifier;
1728  if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
1729  InstantiatedExplicitSpecifier = instantiateExplicitSpecifier(
1730  SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide);
1731  if (InstantiatedExplicitSpecifier.isInvalid())
1732  return nullptr;
1733  }
1734 
1736  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1737  if (!TInfo)
1738  return nullptr;
1739  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1740 
1741  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1742  if (QualifierLoc) {
1743  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1744  TemplateArgs);
1745  if (!QualifierLoc)
1746  return nullptr;
1747  }
1748 
1749  // If we're instantiating a local function declaration, put the result
1750  // in the enclosing namespace; otherwise we need to find the instantiated
1751  // context.
1752  DeclContext *DC;
1753  if (D->isLocalExternDecl()) {
1754  DC = Owner;
1755  SemaRef.adjustContextForLocalExternDecl(DC);
1756  } else if (isFriend && QualifierLoc) {
1757  CXXScopeSpec SS;
1758  SS.Adopt(QualifierLoc);
1759  DC = SemaRef.computeDeclContext(SS);
1760  if (!DC) return nullptr;
1761  } else {
1762  DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1763  TemplateArgs);
1764  }
1765 
1766  DeclarationNameInfo NameInfo
1767  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1768 
1769  FunctionDecl *Function;
1770  if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
1771  Function = CXXDeductionGuideDecl::Create(
1772  SemaRef.Context, DC, D->getInnerLocStart(),
1773  InstantiatedExplicitSpecifier, NameInfo, T, TInfo,
1774  D->getSourceRange().getEnd());
1775  if (DGuide->isCopyDeductionCandidate())
1776  cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
1777  Function->setAccess(D->getAccess());
1778  } else {
1779  Function = FunctionDecl::Create(
1780  SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
1783  Function->setRangeEnd(D->getSourceRange().getEnd());
1784  }
1785 
1786  if (D->isInlined())
1787  Function->setImplicitlyInline();
1788 
1789  if (QualifierLoc)
1790  Function->setQualifierInfo(QualifierLoc);
1791 
1792  if (D->isLocalExternDecl())
1793  Function->setLocalExternDecl();
1794 
1795  DeclContext *LexicalDC = Owner;
1796  if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
1797  assert(D->getDeclContext()->isFileContext());
1798  LexicalDC = D->getDeclContext();
1799  }
1800 
1801  Function->setLexicalDeclContext(LexicalDC);
1802 
1803  // Attach the parameters
1804  for (unsigned P = 0; P < Params.size(); ++P)
1805  if (Params[P])
1806  Params[P]->setOwningFunction(Function);
1807  Function->setParams(Params);
1808 
1809  if (TemplateParams) {
1810  // Our resulting instantiation is actually a function template, since we
1811  // are substituting only the outer template parameters. For example, given
1812  //
1813  // template<typename T>
1814  // struct X {
1815  // template<typename U> friend void f(T, U);
1816  // };
1817  //
1818  // X<int> x;
1819  //
1820  // We are instantiating the friend function template "f" within X<int>,
1821  // which means substituting int for T, but leaving "f" as a friend function
1822  // template.
1823  // Build the function template itself.
1824  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1825  Function->getLocation(),
1826  Function->getDeclName(),
1827  TemplateParams, Function);
1828  Function->setDescribedFunctionTemplate(FunctionTemplate);
1829 
1830  FunctionTemplate->setLexicalDeclContext(LexicalDC);
1831 
1832  if (isFriend && D->isThisDeclarationADefinition()) {
1833  FunctionTemplate->setInstantiatedFromMemberTemplate(
1835  }
1836  } else if (FunctionTemplate) {
1837  // Record this function template specialization.
1838  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1839  Function->setFunctionTemplateSpecialization(FunctionTemplate,
1841  Innermost),
1842  /*InsertPos=*/nullptr);
1843  } else if (isFriend && D->isThisDeclarationADefinition()) {
1844  // Do not connect the friend to the template unless it's actually a
1845  // definition. We don't want non-template functions to be marked as being
1846  // template instantiations.
1847  Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1848  }
1849 
1850  if (isFriend)
1851  Function->setObjectOfFriendDecl();
1852 
1853  if (InitFunctionInstantiation(Function, D))
1854  Function->setInvalidDecl();
1855 
1856  bool IsExplicitSpecialization = false;
1857 
1859  SemaRef, Function->getDeclName(), SourceLocation(),
1863  : SemaRef.forRedeclarationInCurContext());
1864 
1867  assert(isFriend && "non-friend has dependent specialization info?");
1868 
1869  // Instantiate the explicit template arguments.
1870  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1871  Info->getRAngleLoc());
1872  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1873  ExplicitArgs, TemplateArgs))
1874  return nullptr;
1875 
1876  // Map the candidate templates to their instantiations.
1877  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1878  Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1879  Info->getTemplate(I),
1880  TemplateArgs);
1881  if (!Temp) return nullptr;
1882 
1883  Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1884  }
1885 
1886  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1887  &ExplicitArgs,
1888  Previous))
1889  Function->setInvalidDecl();
1890 
1891  IsExplicitSpecialization = true;
1892  } else if (const ASTTemplateArgumentListInfo *Info =
1894  // The name of this function was written as a template-id.
1895  SemaRef.LookupQualifiedName(Previous, DC);
1896 
1897  // Instantiate the explicit template arguments.
1898  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1899  Info->getRAngleLoc());
1900  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1901  ExplicitArgs, TemplateArgs))
1902  return nullptr;
1903 
1904  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1905  &ExplicitArgs,
1906  Previous))
1907  Function->setInvalidDecl();
1908 
1909  IsExplicitSpecialization = true;
1910  } else if (TemplateParams || !FunctionTemplate) {
1911  // Look only into the namespace where the friend would be declared to
1912  // find a previous declaration. This is the innermost enclosing namespace,
1913  // as described in ActOnFriendFunctionDecl.
1914  SemaRef.LookupQualifiedName(Previous, DC);
1915 
1916  // In C++, the previous declaration we find might be a tag type
1917  // (class or enum). In this case, the new declaration will hide the
1918  // tag type. Note that this does does not apply if we're declaring a
1919  // typedef (C++ [dcl.typedef]p4).
1920  if (Previous.isSingleTagDecl())
1921  Previous.clear();
1922  }
1923 
1924  SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
1925  IsExplicitSpecialization);
1926 
1927  NamedDecl *PrincipalDecl = (TemplateParams
1928  ? cast<NamedDecl>(FunctionTemplate)
1929  : Function);
1930 
1931  // If the original function was part of a friend declaration,
1932  // inherit its namespace state and add it to the owner.
1933  if (isFriend) {
1934  Function->setObjectOfFriendDecl();
1935  if (FunctionTemplateDecl *FT = Function->getDescribedFunctionTemplate())
1936  FT->setObjectOfFriendDecl();
1937  DC->makeDeclVisibleInContext(PrincipalDecl);
1938 
1939  bool QueuedInstantiation = false;
1940 
1941  // C++11 [temp.friend]p4 (DR329):
1942  // When a function is defined in a friend function declaration in a class
1943  // template, the function is instantiated when the function is odr-used.
1944  // The same restrictions on multiple declarations and definitions that
1945  // apply to non-template function declarations and definitions also apply
1946  // to these implicit definitions.
1947  if (D->isThisDeclarationADefinition()) {
1948  SemaRef.CheckForFunctionRedefinition(Function);
1949  if (!Function->isInvalidDecl()) {
1950  for (auto R : Function->redecls()) {
1951  if (R == Function)
1952  continue;
1953 
1954  // If some prior declaration of this function has been used, we need
1955  // to instantiate its definition.
1956  if (!QueuedInstantiation && R->isUsed(false)) {
1957  if (MemberSpecializationInfo *MSInfo =
1958  Function->getMemberSpecializationInfo()) {
1959  if (MSInfo->getPointOfInstantiation().isInvalid()) {
1960  SourceLocation Loc = R->getLocation(); // FIXME
1961  MSInfo->setPointOfInstantiation(Loc);
1962  SemaRef.PendingLocalImplicitInstantiations.push_back(
1963  std::make_pair(Function, Loc));
1964  QueuedInstantiation = true;
1965  }
1966  }
1967  }
1968  }
1969  }
1970  }
1971 
1972  // Check the template parameter list against the previous declaration. The
1973  // goal here is to pick up default arguments added since the friend was
1974  // declared; we know the template parameter lists match, since otherwise
1975  // we would not have picked this template as the previous declaration.
1976  if (TemplateParams && FunctionTemplate->getPreviousDecl()) {
1978  TemplateParams,
1979  FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
1980  Function->isThisDeclarationADefinition()
1983  }
1984  }
1985 
1986  if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1987  DC->makeDeclVisibleInContext(PrincipalDecl);
1988 
1989  if (Function->isOverloadedOperator() && !DC->isRecord() &&
1991  PrincipalDecl->setNonMemberOperator();
1992 
1993  assert(!D->isDefaulted() && "only methods should be defaulted");
1994  return Function;
1995 }
1996 
1998  CXXMethodDecl *D, TemplateParameterList *TemplateParams,
2000  ClassScopeSpecializationArgs) {
2001  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
2002  if (FunctionTemplate && !TemplateParams) {
2003  // We are creating a function template specialization from a function
2004  // template. Check whether there is already a function template
2005  // specialization for this particular set of template arguments.
2006  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2007 
2008  void *InsertPos = nullptr;
2009  FunctionDecl *SpecFunc
2010  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
2011 
2012  // If we already have a function template specialization, return it.
2013  if (SpecFunc)
2014  return SpecFunc;
2015  }
2016 
2017  bool isFriend;
2018  if (FunctionTemplate)
2019  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
2020  else
2021  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
2022 
2023  bool MergeWithParentScope = (TemplateParams != nullptr) ||
2024  !(isa<Decl>(Owner) &&
2025  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2026  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
2027 
2028  // Instantiate enclosing template arguments for friends.
2030  unsigned NumTempParamLists = 0;
2031  if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
2032  TempParamLists.resize(NumTempParamLists);
2033  for (unsigned I = 0; I != NumTempParamLists; ++I) {
2034  TemplateParameterList *TempParams = D->getTemplateParameterList(I);
2035  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2036  if (!InstParams)
2037  return nullptr;
2038  TempParamLists[I] = InstParams;
2039  }
2040  }
2041 
2042  ExplicitSpecifier InstantiatedExplicitSpecifier =
2043  instantiateExplicitSpecifier(SemaRef, TemplateArgs,
2045  if (InstantiatedExplicitSpecifier.isInvalid())
2046  return nullptr;
2047 
2049  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
2050  if (!TInfo)
2051  return nullptr;
2052  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
2053 
2054  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
2055  if (QualifierLoc) {
2056  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
2057  TemplateArgs);
2058  if (!QualifierLoc)
2059  return nullptr;
2060  }
2061 
2062  DeclContext *DC = Owner;
2063  if (isFriend) {
2064  if (QualifierLoc) {
2065  CXXScopeSpec SS;
2066  SS.Adopt(QualifierLoc);
2067  DC = SemaRef.computeDeclContext(SS);
2068 
2069  if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
2070  return nullptr;
2071  } else {
2072  DC = SemaRef.FindInstantiatedContext(D->getLocation(),
2073  D->getDeclContext(),
2074  TemplateArgs);
2075  }
2076  if (!DC) return nullptr;
2077  }
2078 
2079  // Build the instantiated method declaration.
2080  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
2081  CXXMethodDecl *Method = nullptr;
2082 
2083  SourceLocation StartLoc = D->getInnerLocStart();
2084  DeclarationNameInfo NameInfo
2085  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2086  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
2087  Method = CXXConstructorDecl::Create(
2088  SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
2089  InstantiatedExplicitSpecifier, Constructor->isInlineSpecified(), false,
2090  Constructor->getConstexprKind());
2091  Method->setRangeEnd(Constructor->getEndLoc());
2092  } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
2093  Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
2094  StartLoc, NameInfo, T, TInfo,
2095  Destructor->isInlineSpecified(),
2096  false);
2097  Method->setRangeEnd(Destructor->getEndLoc());
2098  } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
2099  Method = CXXConversionDecl::Create(
2100  SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
2101  Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier,
2102  Conversion->getConstexprKind(), Conversion->getEndLoc());
2103  } else {
2104  StorageClass SC = D->isStatic() ? SC_Static : SC_None;
2105  Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
2106  T, TInfo, SC, D->isInlineSpecified(),
2107  D->getConstexprKind(), D->getEndLoc());
2108  }
2109 
2110  if (D->isInlined())
2111  Method->setImplicitlyInline();
2112 
2113  if (QualifierLoc)
2114  Method->setQualifierInfo(QualifierLoc);
2115 
2116  if (TemplateParams) {
2117  // Our resulting instantiation is actually a function template, since we
2118  // are substituting only the outer template parameters. For example, given
2119  //
2120  // template<typename T>
2121  // struct X {
2122  // template<typename U> void f(T, U);
2123  // };
2124  //
2125  // X<int> x;
2126  //
2127  // We are instantiating the member template "f" within X<int>, which means
2128  // substituting int for T, but leaving "f" as a member function template.
2129  // Build the function template itself.
2130  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
2131  Method->getLocation(),
2132  Method->getDeclName(),
2133  TemplateParams, Method);
2134  if (isFriend) {
2135  FunctionTemplate->setLexicalDeclContext(Owner);
2136  FunctionTemplate->setObjectOfFriendDecl();
2137  } else if (D->isOutOfLine())
2138  FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
2139  Method->setDescribedFunctionTemplate(FunctionTemplate);
2140  } else if (FunctionTemplate) {
2141  // Record this function template specialization.
2142  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2143  Method->setFunctionTemplateSpecialization(FunctionTemplate,
2145  Innermost),
2146  /*InsertPos=*/nullptr);
2147  } else if (!isFriend) {
2148  // Record that this is an instantiation of a member function.
2149  Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
2150  }
2151 
2152  // If we are instantiating a member function defined
2153  // out-of-line, the instantiation will have the same lexical
2154  // context (which will be a namespace scope) as the template.
2155  if (isFriend) {
2156  if (NumTempParamLists)
2157  Method->setTemplateParameterListsInfo(
2158  SemaRef.Context,
2159  llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
2160 
2161  Method->setLexicalDeclContext(Owner);
2162  Method->setObjectOfFriendDecl();
2163  } else if (D->isOutOfLine())
2164  Method->setLexicalDeclContext(D->getLexicalDeclContext());
2165 
2166  // Attach the parameters
2167  for (unsigned P = 0; P < Params.size(); ++P)
2168  Params[P]->setOwningFunction(Method);
2169  Method->setParams(Params);
2170 
2171  if (InitMethodInstantiation(Method, D))
2172  Method->setInvalidDecl();
2173 
2174  LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
2176 
2177  bool IsExplicitSpecialization = false;
2178 
2179  // If the name of this function was written as a template-id, instantiate
2180  // the explicit template arguments.
2183  assert(isFriend && "non-friend has dependent specialization info?");
2184 
2185  // Instantiate the explicit template arguments.
2186  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2187  Info->getRAngleLoc());
2188  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2189  ExplicitArgs, TemplateArgs))
2190  return nullptr;
2191 
2192  // Map the candidate templates to their instantiations.
2193  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
2194  Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
2195  Info->getTemplate(I),
2196  TemplateArgs);
2197  if (!Temp) return nullptr;
2198 
2199  Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
2200  }
2201 
2202  if (SemaRef.CheckFunctionTemplateSpecialization(Method,
2203  &ExplicitArgs,
2204  Previous))
2205  Method->setInvalidDecl();
2206 
2207  IsExplicitSpecialization = true;
2208  } else if (const ASTTemplateArgumentListInfo *Info =
2209  ClassScopeSpecializationArgs.getValueOr(
2211  SemaRef.LookupQualifiedName(Previous, DC);
2212 
2213  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2214  Info->getRAngleLoc());
2215  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2216  ExplicitArgs, TemplateArgs))
2217  return nullptr;
2218 
2219  if (SemaRef.CheckFunctionTemplateSpecialization(Method,
2220  &ExplicitArgs,
2221  Previous))
2222  Method->setInvalidDecl();
2223 
2224  IsExplicitSpecialization = true;
2225  } else if (ClassScopeSpecializationArgs) {
2226  // Class-scope explicit specialization written without explicit template
2227  // arguments.
2228  SemaRef.LookupQualifiedName(Previous, DC);
2229  if (SemaRef.CheckFunctionTemplateSpecialization(Method, nullptr, Previous))
2230  Method->setInvalidDecl();
2231 
2232  IsExplicitSpecialization = true;
2233  } else if (!FunctionTemplate || TemplateParams || isFriend) {
2234  SemaRef.LookupQualifiedName(Previous, Record);
2235 
2236  // In C++, the previous declaration we find might be a tag type
2237  // (class or enum). In this case, the new declaration will hide the
2238  // tag type. Note that this does does not apply if we're declaring a
2239  // typedef (C++ [dcl.typedef]p4).
2240  if (Previous.isSingleTagDecl())
2241  Previous.clear();
2242  }
2243 
2244  SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous,
2245  IsExplicitSpecialization);
2246 
2247  if (D->isPure())
2248  SemaRef.CheckPureMethod(Method, SourceRange());
2249 
2250  // Propagate access. For a non-friend declaration, the access is
2251  // whatever we're propagating from. For a friend, it should be the
2252  // previous declaration we just found.
2253  if (isFriend && Method->getPreviousDecl())
2254  Method->setAccess(Method->getPreviousDecl()->getAccess());
2255  else
2256  Method->setAccess(D->getAccess());
2257  if (FunctionTemplate)
2258  FunctionTemplate->setAccess(Method->getAccess());
2259 
2260  SemaRef.CheckOverrideControl(Method);
2261 
2262  // If a function is defined as defaulted or deleted, mark it as such now.
2263  if (D->isExplicitlyDefaulted())
2264  SemaRef.SetDeclDefaulted(Method, Method->getLocation());
2265  if (D->isDeletedAsWritten())
2266  SemaRef.SetDeclDeleted(Method, Method->getLocation());
2267 
2268  // If this is an explicit specialization, mark the implicitly-instantiated
2269  // template specialization as being an explicit specialization too.
2270  // FIXME: Is this necessary?
2271  if (IsExplicitSpecialization && !isFriend)
2272  SemaRef.CompleteMemberSpecialization(Method, Previous);
2273 
2274  // If there's a function template, let our caller handle it.
2275  if (FunctionTemplate) {
2276  // do nothing
2277 
2278  // Don't hide a (potentially) valid declaration with an invalid one.
2279  } else if (Method->isInvalidDecl() && !Previous.empty()) {
2280  // do nothing
2281 
2282  // Otherwise, check access to friends and make them visible.
2283  } else if (isFriend) {
2284  // We only need to re-check access for methods which we didn't
2285  // manage to match during parsing.
2286  if (!D->getPreviousDecl())
2287  SemaRef.CheckFriendAccess(Method);
2288 
2289  Record->makeDeclVisibleInContext(Method);
2290 
2291  // Otherwise, add the declaration. We don't need to do this for
2292  // class-scope specializations because we'll have matched them with
2293  // the appropriate template.
2294  } else {
2295  Owner->addDecl(Method);
2296  }
2297 
2298  // PR17480: Honor the used attribute to instantiate member function
2299  // definitions
2300  if (Method->hasAttr<UsedAttr>()) {
2301  if (const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
2302  SourceLocation Loc;
2303  if (const MemberSpecializationInfo *MSInfo =
2304  A->getMemberSpecializationInfo())
2305  Loc = MSInfo->getPointOfInstantiation();
2306  else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
2307  Loc = Spec->getPointOfInstantiation();
2308  SemaRef.MarkFunctionReferenced(Loc, Method);
2309  }
2310  }
2311 
2312  return Method;
2313 }
2314 
2315 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2316  return VisitCXXMethodDecl(D);
2317 }
2318 
2319 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2320  return VisitCXXMethodDecl(D);
2321 }
2322 
2323 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
2324  return VisitCXXMethodDecl(D);
2325 }
2326 
2327 Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
2328  return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2329  /*ExpectParameterPack=*/ false);
2330 }
2331 
2332 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2333  TemplateTypeParmDecl *D) {
2334  // TODO: don't always clone when decls are refcounted.
2335  assert(D->getTypeForDecl()->isTemplateTypeParmType());
2336 
2338  SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(),
2339  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
2341  Inst->setAccess(AS_public);
2342 
2343  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2344  TypeSourceInfo *InstantiatedDefaultArg =
2345  SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2346  D->getDefaultArgumentLoc(), D->getDeclName());
2347  if (InstantiatedDefaultArg)
2348  Inst->setDefaultArgument(InstantiatedDefaultArg);
2349  }
2350 
2351  // Introduce this template parameter's instantiation into the instantiation
2352  // scope.
2353  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2354 
2355  return Inst;
2356 }
2357 
2358 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2360  // Substitute into the type of the non-type template parameter.
2361  TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
2362  SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2363  SmallVector<QualType, 4> ExpandedParameterPackTypes;
2364  bool IsExpandedParameterPack = false;
2365  TypeSourceInfo *DI;
2366  QualType T;
2367  bool Invalid = false;
2368 
2369  if (D->isExpandedParameterPack()) {
2370  // The non-type template parameter pack is an already-expanded pack
2371  // expansion of types. Substitute into each of the expanded types.
2372  ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2373  ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2374  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2375  TypeSourceInfo *NewDI =
2376  SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2377  D->getLocation(), D->getDeclName());
2378  if (!NewDI)
2379  return nullptr;
2380 
2381  QualType NewT =
2382  SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2383  if (NewT.isNull())
2384  return nullptr;
2385 
2386  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2387  ExpandedParameterPackTypes.push_back(NewT);
2388  }
2389 
2390  IsExpandedParameterPack = true;
2391  DI = D->getTypeSourceInfo();
2392  T = DI->getType();
2393  } else if (D->isPackExpansion()) {
2394  // The non-type template parameter pack's type is a pack expansion of types.
2395  // Determine whether we need to expand this parameter pack into separate
2396  // types.
2398  TypeLoc Pattern = Expansion.getPatternLoc();
2400  SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2401 
2402  // Determine whether the set of unexpanded parameter packs can and should
2403  // be expanded.
2404  bool Expand = true;
2405  bool RetainExpansion = false;
2406  Optional<unsigned> OrigNumExpansions
2407  = Expansion.getTypePtr()->getNumExpansions();
2408  Optional<unsigned> NumExpansions = OrigNumExpansions;
2409  if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2410  Pattern.getSourceRange(),
2411  Unexpanded,
2412  TemplateArgs,
2413  Expand, RetainExpansion,
2414  NumExpansions))
2415  return nullptr;
2416 
2417  if (Expand) {
2418  for (unsigned I = 0; I != *NumExpansions; ++I) {
2419  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2420  TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2421  D->getLocation(),
2422  D->getDeclName());
2423  if (!NewDI)
2424  return nullptr;
2425 
2426  QualType NewT =
2427  SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2428  if (NewT.isNull())
2429  return nullptr;
2430 
2431  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2432  ExpandedParameterPackTypes.push_back(NewT);
2433  }
2434 
2435  // Note that we have an expanded parameter pack. The "type" of this
2436  // expanded parameter pack is the original expansion type, but callers
2437  // will end up using the expanded parameter pack types for type-checking.
2438  IsExpandedParameterPack = true;
2439  DI = D->getTypeSourceInfo();
2440  T = DI->getType();
2441  } else {
2442  // We cannot fully expand the pack expansion now, so substitute into the
2443  // pattern and create a new pack expansion type.
2444  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2445  TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2446  D->getLocation(),
2447  D->getDeclName());
2448  if (!NewPattern)
2449  return nullptr;
2450 
2451  SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
2452  DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2453  NumExpansions);
2454  if (!DI)
2455  return nullptr;
2456 
2457  T = DI->getType();
2458  }
2459  } else {
2460  // Simple case: substitution into a parameter that is not a parameter pack.
2461  DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2462  D->getLocation(), D->getDeclName());
2463  if (!DI)
2464  return nullptr;
2465 
2466  // Check that this type is acceptable for a non-type template parameter.
2467  T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
2468  if (T.isNull()) {
2469  T = SemaRef.Context.IntTy;
2470  Invalid = true;
2471  }
2472  }
2473 
2474  NonTypeTemplateParmDecl *Param;
2475  if (IsExpandedParameterPack)
2477  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2478  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2479  D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
2480  ExpandedParameterPackTypesAsWritten);
2481  else
2483  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2484  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2485  D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
2486 
2487  Param->setAccess(AS_public);
2488  if (Invalid)
2489  Param->setInvalidDecl();
2490 
2491  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2492  EnterExpressionEvaluationContext ConstantEvaluated(
2494  ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2495  if (!Value.isInvalid())
2496  Param->setDefaultArgument(Value.get());
2497  }
2498 
2499  // Introduce this template parameter's instantiation into the instantiation
2500  // scope.
2501  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2502  return Param;
2503 }
2504 
2506  Sema &S,
2507  TemplateParameterList *Params,
2509  for (const auto &P : *Params) {
2510  if (P->isTemplateParameterPack())
2511  continue;
2512  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2513  S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2514  Unexpanded);
2515  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2516  collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2517  Unexpanded);
2518  }
2519 }
2520 
2521 Decl *
2522 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2524  // Instantiate the template parameter list of the template template parameter.
2525  TemplateParameterList *TempParams = D->getTemplateParameters();
2526  TemplateParameterList *InstParams;
2528 
2529  bool IsExpandedParameterPack = false;
2530 
2531  if (D->isExpandedParameterPack()) {
2532  // The template template parameter pack is an already-expanded pack
2533  // expansion of template parameters. Substitute into each of the expanded
2534  // parameters.
2535  ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2536  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2537  I != N; ++I) {
2538  LocalInstantiationScope Scope(SemaRef);
2539  TemplateParameterList *Expansion =
2541  if (!Expansion)
2542  return nullptr;
2543  ExpandedParams.push_back(Expansion);
2544  }
2545 
2546  IsExpandedParameterPack = true;
2547  InstParams = TempParams;
2548  } else if (D->isPackExpansion()) {
2549  // The template template parameter pack expands to a pack of template
2550  // template parameters. Determine whether we need to expand this parameter
2551  // pack into separate parameters.
2554  Unexpanded);
2555 
2556  // Determine whether the set of unexpanded parameter packs can and should
2557  // be expanded.
2558  bool Expand = true;
2559  bool RetainExpansion = false;
2560  Optional<unsigned> NumExpansions;
2562  TempParams->getSourceRange(),
2563  Unexpanded,
2564  TemplateArgs,
2565  Expand, RetainExpansion,
2566  NumExpansions))
2567  return nullptr;
2568 
2569  if (Expand) {
2570  for (unsigned I = 0; I != *NumExpansions; ++I) {
2571  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2572  LocalInstantiationScope Scope(SemaRef);
2573  TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2574  if (!Expansion)
2575  return nullptr;
2576  ExpandedParams.push_back(Expansion);
2577  }
2578 
2579  // Note that we have an expanded parameter pack. The "type" of this
2580  // expanded parameter pack is the original expansion type, but callers
2581  // will end up using the expanded parameter pack types for type-checking.
2582  IsExpandedParameterPack = true;
2583  InstParams = TempParams;
2584  } else {
2585  // We cannot fully expand the pack expansion now, so just substitute
2586  // into the pattern.
2587  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2588 
2589  LocalInstantiationScope Scope(SemaRef);
2590  InstParams = SubstTemplateParams(TempParams);
2591  if (!InstParams)
2592  return nullptr;
2593  }
2594  } else {
2595  // Perform the actual substitution of template parameters within a new,
2596  // local instantiation scope.
2597  LocalInstantiationScope Scope(SemaRef);
2598  InstParams = SubstTemplateParams(TempParams);
2599  if (!InstParams)
2600  return nullptr;
2601  }
2602 
2603  // Build the template template parameter.
2604  TemplateTemplateParmDecl *Param;
2605  if (IsExpandedParameterPack)
2607  SemaRef.Context, Owner, D->getLocation(),
2608  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2609  D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
2610  else
2612  SemaRef.Context, Owner, D->getLocation(),
2613  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2614  D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
2615  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2616  NestedNameSpecifierLoc QualifierLoc =
2618  QualifierLoc =
2619  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2620  TemplateName TName = SemaRef.SubstTemplateName(
2621  QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2622  D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2623  if (!TName.isNull())
2624  Param->setDefaultArgument(
2625  SemaRef.Context,
2629  }
2630  Param->setAccess(AS_public);
2631 
2632  // Introduce this template parameter's instantiation into the instantiation
2633  // scope.
2634  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2635 
2636  return Param;
2637 }
2638 
2639 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2640  // Using directives are never dependent (and never contain any types or
2641  // expressions), so they require no explicit instantiation work.
2642 
2643  UsingDirectiveDecl *Inst
2644  = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2646  D->getQualifierLoc(),
2647  D->getIdentLocation(),
2648  D->getNominatedNamespace(),
2649  D->getCommonAncestor());
2650 
2651  // Add the using directive to its declaration context
2652  // only if this is not a function or method.
2653  if (!Owner->isFunctionOrMethod())
2654  Owner->addDecl(Inst);
2655 
2656  return Inst;
2657 }
2658 
2659 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2660 
2661  // The nested name specifier may be dependent, for example
2662  // template <typename T> struct t {
2663  // struct s1 { T f1(); };
2664  // struct s2 : s1 { using s1::f1; };
2665  // };
2666  // template struct t<int>;
2667  // Here, in using s1::f1, s1 refers to t<T>::s1;
2668  // we need to substitute for t<int>::s1.
2669  NestedNameSpecifierLoc QualifierLoc
2671  TemplateArgs);
2672  if (!QualifierLoc)
2673  return nullptr;
2674 
2675  // For an inheriting constructor declaration, the name of the using
2676  // declaration is the name of a constructor in this class, not in the
2677  // base class.
2678  DeclarationNameInfo NameInfo = D->getNameInfo();
2680  if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
2682  SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
2683 
2684  // We only need to do redeclaration lookups if we're in a class
2685  // scope (in fact, it's not really even possible in non-class
2686  // scopes).
2687  bool CheckRedeclaration = Owner->isRecord();
2688 
2689  LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2691 
2692  UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2693  D->getUsingLoc(),
2694  QualifierLoc,
2695  NameInfo,
2696  D->hasTypename());
2697 
2698  CXXScopeSpec SS;
2699  SS.Adopt(QualifierLoc);
2700  if (CheckRedeclaration) {
2701  Prev.setHideTags(false);
2702  SemaRef.LookupQualifiedName(Prev, Owner);
2703 
2704  // Check for invalid redeclarations.
2705  if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2706  D->hasTypename(), SS,
2707  D->getLocation(), Prev))
2708  NewUD->setInvalidDecl();
2709 
2710  }
2711 
2712  if (!NewUD->isInvalidDecl() &&
2713  SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
2714  SS, NameInfo, D->getLocation()))
2715  NewUD->setInvalidDecl();
2716 
2717  SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2718  NewUD->setAccess(D->getAccess());
2719  Owner->addDecl(NewUD);
2720 
2721  // Don't process the shadow decls for an invalid decl.
2722  if (NewUD->isInvalidDecl())
2723  return NewUD;
2724 
2725  if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2726  SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
2727 
2728  bool isFunctionScope = Owner->isFunctionOrMethod();
2729 
2730  // Process the shadow decls.
2731  for (auto *Shadow : D->shadows()) {
2732  // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
2733  // reconstruct it in the case where it matters.
2734  NamedDecl *OldTarget = Shadow->getTargetDecl();
2735  if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
2736  if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
2737  OldTarget = BaseShadow;
2738 
2739  NamedDecl *InstTarget =
2740  cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2741  Shadow->getLocation(), OldTarget, TemplateArgs));
2742  if (!InstTarget)
2743  return nullptr;
2744 
2745  UsingShadowDecl *PrevDecl = nullptr;
2746  if (CheckRedeclaration) {
2747  if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2748  continue;
2749  } else if (UsingShadowDecl *OldPrev =
2751  PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2752  Shadow->getLocation(), OldPrev, TemplateArgs));
2753  }
2754 
2755  UsingShadowDecl *InstShadow =
2756  SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2757  PrevDecl);
2758  SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2759 
2760  if (isFunctionScope)
2761  SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2762  }
2763 
2764  return NewUD;
2765 }
2766 
2767 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2768  // Ignore these; we handle them in bulk when processing the UsingDecl.
2769  return nullptr;
2770 }
2771 
2772 Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
2774  // Ignore these; we handle them in bulk when processing the UsingDecl.
2775  return nullptr;
2776 }
2777 
2778 template <typename T>
2779 Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
2780  T *D, bool InstantiatingPackElement) {
2781  // If this is a pack expansion, expand it now.
2782  if (D->isPackExpansion() && !InstantiatingPackElement) {
2784  SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
2785  SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
2786 
2787  // Determine whether the set of unexpanded parameter packs can and should
2788  // be expanded.
2789  bool Expand = true;
2790  bool RetainExpansion = false;
2791  Optional<unsigned> NumExpansions;
2792  if (SemaRef.CheckParameterPacksForExpansion(
2793  D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
2794  Expand, RetainExpansion, NumExpansions))
2795  return nullptr;
2796 
2797  // This declaration cannot appear within a function template signature,
2798  // so we can't have a partial argument list for a parameter pack.
2799  assert(!RetainExpansion &&
2800  "should never need to retain an expansion for UsingPackDecl");
2801 
2802  if (!Expand) {
2803  // We cannot fully expand the pack expansion now, so substitute into the
2804  // pattern and create a new pack expansion.
2805  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2806  return instantiateUnresolvedUsingDecl(D, true);
2807  }
2808 
2809  // Within a function, we don't have any normal way to check for conflicts
2810  // between shadow declarations from different using declarations in the
2811  // same pack expansion, but this is always ill-formed because all expansions
2812  // must produce (conflicting) enumerators.
2813  //
2814  // Sadly we can't just reject this in the template definition because it
2815  // could be valid if the pack is empty or has exactly one expansion.
2816  if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
2817  SemaRef.Diag(D->getEllipsisLoc(),
2818  diag::err_using_decl_redeclaration_expansion);
2819  return nullptr;
2820  }
2821 
2822  // Instantiate the slices of this pack and build a UsingPackDecl.
2823  SmallVector<NamedDecl*, 8> Expansions;
2824  for (unsigned I = 0; I != *NumExpansions; ++I) {
2825  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2826  Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
2827  if (!Slice)
2828  return nullptr;
2829  // Note that we can still get unresolved using declarations here, if we
2830  // had arguments for all packs but the pattern also contained other
2831  // template arguments (this only happens during partial substitution, eg
2832  // into the body of a generic lambda in a function template).
2833  Expansions.push_back(cast<NamedDecl>(Slice));
2834  }
2835 
2836  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2837  if (isDeclWithinFunction(D))
2838  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2839  return NewD;
2840  }
2841 
2843  SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
2844 
2845  NestedNameSpecifierLoc QualifierLoc
2846  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2847  TemplateArgs);
2848  if (!QualifierLoc)
2849  return nullptr;
2850 
2851  CXXScopeSpec SS;
2852  SS.Adopt(QualifierLoc);
2853 
2854  DeclarationNameInfo NameInfo
2855  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2856 
2857  // Produce a pack expansion only if we're not instantiating a particular
2858  // slice of a pack expansion.
2859  bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
2860  SemaRef.ArgumentPackSubstitutionIndex != -1;
2861  SourceLocation EllipsisLoc =
2862  InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
2863 
2864  NamedDecl *UD = SemaRef.BuildUsingDeclaration(
2865  /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
2866  /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
2868  /*IsInstantiation*/ true);
2869  if (UD)
2870  SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
2871 
2872  return UD;
2873 }
2874 
2875 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
2877  return instantiateUnresolvedUsingDecl(D);
2878 }
2879 
2880 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
2882  return instantiateUnresolvedUsingDecl(D);
2883 }
2884 
2885 Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
2886  SmallVector<NamedDecl*, 8> Expansions;
2887  for (auto *UD : D->expansions()) {
2888  if (NamedDecl *NewUD =
2889  SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
2890  Expansions.push_back(NewUD);
2891  else
2892  return nullptr;
2893  }
2894 
2895  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2896  if (isDeclWithinFunction(D))
2897  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2898  return NewD;
2899 }
2900 
2901 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2903  CXXMethodDecl *OldFD = Decl->getSpecialization();
2904  return cast_or_null<CXXMethodDecl>(
2905  VisitCXXMethodDecl(OldFD, nullptr, Decl->getTemplateArgsAsWritten()));
2906 }
2907 
2908 Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2909  OMPThreadPrivateDecl *D) {
2911  for (auto *I : D->varlists()) {
2912  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2913  assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
2914  Vars.push_back(Var);
2915  }
2916 
2917  OMPThreadPrivateDecl *TD =
2918  SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2919 
2920  TD->setAccess(AS_public);
2921  Owner->addDecl(TD);
2922 
2923  return TD;
2924 }
2925 
2926 Decl *TemplateDeclInstantiator::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
2928  for (auto *I : D->varlists()) {
2929  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2930  assert(isa<DeclRefExpr>(Var) && "allocate arg is not a DeclRefExpr");
2931  Vars.push_back(Var);
2932  }
2934  // Copy map clauses from the original mapper.
2935  for (OMPClause *C : D->clauselists()) {
2936  auto *AC = cast<OMPAllocatorClause>(C);
2937  ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs);
2938  if (!NewE.isUsable())
2939  continue;
2940  OMPClause *IC = SemaRef.ActOnOpenMPAllocatorClause(
2941  NewE.get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
2942  Clauses.push_back(IC);
2943  }
2944 
2946  D->getLocation(), Vars, Clauses, Owner);
2947  if (Res.get().isNull())
2948  return nullptr;
2949  return Res.get().getSingleDecl();
2950 }
2951 
2952 Decl *TemplateDeclInstantiator::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
2953  llvm_unreachable(
2954  "Requires directive cannot be instantiated within a dependent context");
2955 }
2956 
2957 Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
2959  // Instantiate type and check if it is allowed.
2960  const bool RequiresInstantiation =
2961  D->getType()->isDependentType() ||
2964  QualType SubstReductionType;
2965  if (RequiresInstantiation) {
2966  SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
2967  D->getLocation(),
2968  ParsedType::make(SemaRef.SubstType(
2969  D->getType(), TemplateArgs, D->getLocation(), DeclarationName())));
2970  } else {
2971  SubstReductionType = D->getType();
2972  }
2973  if (SubstReductionType.isNull())
2974  return nullptr;
2975  bool IsCorrect = !SubstReductionType.isNull();
2976  // Create instantiated copy.
2977  std::pair<QualType, SourceLocation> ReductionTypes[] = {
2978  std::make_pair(SubstReductionType, D->getLocation())};
2979  auto *PrevDeclInScope = D->getPrevDeclInScope();
2980  if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
2981  PrevDeclInScope = cast<OMPDeclareReductionDecl>(
2982  SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
2983  ->get<Decl *>());
2984  }
2985  auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
2986  /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
2987  PrevDeclInScope);
2988  auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
2989  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
2990  if (!RequiresInstantiation) {
2991  if (Expr *Combiner = D->getCombiner()) {
2992  NewDRD->setCombinerData(D->getCombinerIn(), D->getCombinerOut());
2993  NewDRD->setCombiner(Combiner);
2994  if (Expr *Init = D->getInitializer()) {
2995  NewDRD->setInitializerData(D->getInitOrig(), D->getInitPriv());
2996  NewDRD->setInitializer(Init, D->getInitializerKind());
2997  }
2998  }
3000  /*S=*/nullptr, DRD, IsCorrect && !D->isInvalidDecl());
3001  return NewDRD;
3002  }
3003  Expr *SubstCombiner = nullptr;
3004  Expr *SubstInitializer = nullptr;
3005  // Combiners instantiation sequence.
3006  if (D->getCombiner()) {
3008  /*S=*/nullptr, NewDRD);
3010  cast<DeclRefExpr>(D->getCombinerIn())->getDecl(),
3011  cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
3013  cast<DeclRefExpr>(D->getCombinerOut())->getDecl(),
3014  cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
3015  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3016  Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
3017  ThisContext);
3018  SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
3019  SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
3020  // Initializers instantiation sequence.
3021  if (D->getInitializer()) {
3022  VarDecl *OmpPrivParm =
3024  /*S=*/nullptr, NewDRD);
3026  cast<DeclRefExpr>(D->getInitOrig())->getDecl(),
3027  cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
3029  cast<DeclRefExpr>(D->getInitPriv())->getDecl(),
3030  cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
3032  SubstInitializer =
3033  SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
3034  } else {
3035  IsCorrect = IsCorrect && OmpPrivParm->hasInit();
3036  }
3038  NewDRD, SubstInitializer, OmpPrivParm);
3039  }
3040  IsCorrect =
3041  IsCorrect && SubstCombiner &&
3042  (!D->getInitializer() ||
3044  SubstInitializer) ||
3046  !SubstInitializer && !SubstInitializer));
3047  } else {
3048  IsCorrect = false;
3049  }
3050 
3051  (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
3052  IsCorrect);
3053 
3054  return NewDRD;
3055 }
3056 
3057 Decl *
3058 TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
3059  // Instantiate type and check if it is allowed.
3060  const bool RequiresInstantiation =
3061  D->getType()->isDependentType() ||
3064  QualType SubstMapperTy;
3065  DeclarationName VN = D->getVarName();
3066  if (RequiresInstantiation) {
3067  SubstMapperTy = SemaRef.ActOnOpenMPDeclareMapperType(
3068  D->getLocation(),
3069  ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
3070  D->getLocation(), VN)));
3071  } else {
3072  SubstMapperTy = D->getType();
3073  }
3074  if (SubstMapperTy.isNull())
3075  return nullptr;
3076  // Create an instantiated copy of mapper.
3077  auto *PrevDeclInScope = D->getPrevDeclInScope();
3078  if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3079  PrevDeclInScope = cast<OMPDeclareMapperDecl>(
3080  SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
3081  ->get<Decl *>());
3082  }
3084  /*S=*/nullptr, Owner, D->getDeclName(), SubstMapperTy, D->getLocation(),
3085  VN, D->getAccess(), PrevDeclInScope);
3086  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDMD);
3088  bool IsCorrect = true;
3089  if (!RequiresInstantiation) {
3090  // Copy the mapper variable.
3091  NewDMD->setMapperVarRef(D->getMapperVarRef());
3092  // Copy map clauses from the original mapper.
3093  for (OMPClause *C : D->clauselists())
3094  Clauses.push_back(C);
3095  } else {
3096  // Instantiate the mapper variable.
3097  DeclarationNameInfo DirName;
3098  SemaRef.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, /*S=*/nullptr,
3099  (*D->clauselist_begin())->getBeginLoc());
3101  NewDMD, /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);
3103  cast<DeclRefExpr>(D->getMapperVarRef())->getDecl(),
3104  cast<DeclRefExpr>(NewDMD->getMapperVarRef())->getDecl());
3105  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3106  Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
3107  ThisContext);
3108  // Instantiate map clauses.
3109  for (OMPClause *C : D->clauselists()) {
3110  auto *OldC = cast<OMPMapClause>(C);
3111  SmallVector<Expr *, 4> NewVars;
3112  for (Expr *OE : OldC->varlists()) {
3113  Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
3114  if (!NE) {
3115  IsCorrect = false;
3116  break;
3117  }
3118  NewVars.push_back(NE);
3119  }
3120  if (!IsCorrect)
3121  break;
3122  NestedNameSpecifierLoc NewQualifierLoc =
3123  SemaRef.SubstNestedNameSpecifierLoc(OldC->getMapperQualifierLoc(),
3124  TemplateArgs);
3125  CXXScopeSpec SS;
3126  SS.Adopt(NewQualifierLoc);
3127  DeclarationNameInfo NewNameInfo = SemaRef.SubstDeclarationNameInfo(
3128  OldC->getMapperIdInfo(), TemplateArgs);
3129  OMPVarListLocTy Locs(OldC->getBeginLoc(), OldC->getLParenLoc(),
3130  OldC->getEndLoc());
3131  OMPClause *NewC = SemaRef.ActOnOpenMPMapClause(
3132  OldC->getMapTypeModifiers(), OldC->getMapTypeModifiersLoc(), SS,
3133  NewNameInfo, OldC->getMapType(), OldC->isImplicitMapType(),
3134  OldC->getMapLoc(), OldC->getColonLoc(), NewVars, Locs);
3135  Clauses.push_back(NewC);
3136  }
3137  SemaRef.EndOpenMPDSABlock(nullptr);
3138  }
3139  (void)SemaRef.ActOnOpenMPDeclareMapperDirectiveEnd(NewDMD, /*S=*/nullptr,
3140  Clauses);
3141  if (!IsCorrect)
3142  return nullptr;
3143  return NewDMD;
3144 }
3145 
3146 Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
3147  OMPCapturedExprDecl * /*D*/) {
3148  llvm_unreachable("Should not be met in templates");
3149 }
3150 
3152  return VisitFunctionDecl(D, nullptr);
3153 }
3154 
3155 Decl *
3156 TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
3157  Decl *Inst = VisitFunctionDecl(D, nullptr);
3158  if (Inst && !D->getDescribedFunctionTemplate())
3159  Owner->addDecl(Inst);
3160  return Inst;
3161 }
3162 
3164  return VisitCXXMethodDecl(D, nullptr);
3165 }
3166 
3167 Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
3168  llvm_unreachable("There are only CXXRecordDecls in C++");
3169 }
3170 
3171 Decl *
3172 TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
3174  // As a MS extension, we permit class-scope explicit specialization
3175  // of member class templates.
3176  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
3177  assert(ClassTemplate->getDeclContext()->isRecord() &&
3179  "can only instantiate an explicit specialization "
3180  "for a member class template");
3181 
3182  // Lookup the already-instantiated declaration in the instantiation
3183  // of the class template.
3184  ClassTemplateDecl *InstClassTemplate =
3185  cast_or_null<ClassTemplateDecl>(SemaRef.FindInstantiatedDecl(
3186  D->getLocation(), ClassTemplate, TemplateArgs));
3187  if (!InstClassTemplate)
3188  return nullptr;
3189 
3190  // Substitute into the template arguments of the class template explicit
3191  // specialization.
3193  castAs<TemplateSpecializationTypeLoc>();
3194  TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
3195  Loc.getRAngleLoc());
3197  for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
3198  ArgLocs.push_back(Loc.getArgLoc(I));
3199  if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
3200  InstTemplateArgs, TemplateArgs))
3201  return nullptr;
3202 
3203  // Check that the template argument list is well-formed for this
3204  // class template.
3206  if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
3207  D->getLocation(),
3208  InstTemplateArgs,
3209  false,
3210  Converted))
3211  return nullptr;
3212 
3213  // Figure out where to insert this class template explicit specialization
3214  // in the member template's set of class template explicit specializations.
3215  void *InsertPos = nullptr;
3217  InstClassTemplate->findSpecialization(Converted, InsertPos);
3218 
3219  // Check whether we've already seen a conflicting instantiation of this
3220  // declaration (for instance, if there was a prior implicit instantiation).
3221  bool Ignored;
3222  if (PrevDecl &&
3224  D->getSpecializationKind(),
3225  PrevDecl,
3226  PrevDecl->getSpecializationKind(),
3227  PrevDecl->getPointOfInstantiation(),
3228  Ignored))
3229  return nullptr;
3230 
3231  // If PrevDecl was a definition and D is also a definition, diagnose.
3232  // This happens in cases like:
3233  //
3234  // template<typename T, typename U>
3235  // struct Outer {
3236  // template<typename X> struct Inner;
3237  // template<> struct Inner<T> {};
3238  // template<> struct Inner<U> {};
3239  // };
3240  //
3241  // Outer<int, int> outer; // error: the explicit specializations of Inner
3242  // // have the same signature.
3243  if (PrevDecl && PrevDecl->getDefinition() &&
3245  SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
3246  SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
3247  diag::note_previous_definition);
3248  return nullptr;
3249  }
3250 
3251  // Create the class template partial specialization declaration.
3254  SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(),
3255  D->getLocation(), InstClassTemplate, Converted, PrevDecl);
3256 
3257  // Add this partial specialization to the set of class template partial
3258  // specializations.
3259  if (!PrevDecl)
3260  InstClassTemplate->AddSpecialization(InstD, InsertPos);
3261 
3262  // Substitute the nested name specifier, if any.
3263  if (SubstQualifier(D, InstD))
3264  return nullptr;
3265 
3266  // Build the canonical type that describes the converted template
3267  // arguments of the class template explicit specialization.
3268  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3269  TemplateName(InstClassTemplate), Converted,
3270  SemaRef.Context.getRecordType(InstD));
3271 
3272  // Build the fully-sugared type for this class template
3273  // specialization as the user wrote in the specialization
3274  // itself. This means that we'll pretty-print the type retrieved
3275  // from the specialization's declaration the way that the user
3276  // actually wrote the specialization, rather than formatting the
3277  // name based on the "canonical" representation used to store the
3278  // template arguments in the specialization.
3280  TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
3281  CanonType);
3282 
3283  InstD->setAccess(D->getAccess());
3286  InstD->setTypeAsWritten(WrittenTy);
3287  InstD->setExternLoc(D->getExternLoc());
3289 
3290  Owner->addDecl(InstD);
3291 
3292  // Instantiate the members of the class-scope explicit specialization eagerly.
3293  // We don't have support for lazy instantiation of an explicit specialization
3294  // yet, and MSVC eagerly instantiates in this case.
3295  // FIXME: This is wrong in standard C++.
3296  if (D->isThisDeclarationADefinition() &&
3297  SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
3299  /*Complain=*/true))
3300  return nullptr;
3301 
3302  return InstD;
3303 }
3304 
3307 
3308  TemplateArgumentListInfo VarTemplateArgsInfo;
3309  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
3310  assert(VarTemplate &&
3311  "A template specialization without specialized template?");
3312 
3313  VarTemplateDecl *InstVarTemplate =
3314  cast_or_null<VarTemplateDecl>(SemaRef.FindInstantiatedDecl(
3315  D->getLocation(), VarTemplate, TemplateArgs));
3316  if (!InstVarTemplate)
3317  return nullptr;
3318 
3319  // Substitute the current template arguments.
3320  const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
3321  VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
3322  VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
3323 
3324  if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
3325  TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
3326  return nullptr;
3327 
3328  // Check that the template argument list is well-formed for this template.
3330  if (SemaRef.CheckTemplateArgumentList(InstVarTemplate, D->getLocation(),
3331  VarTemplateArgsInfo, false, Converted))
3332  return nullptr;
3333 
3334  // Check whether we've already seen a declaration of this specialization.
3335  void *InsertPos = nullptr;
3336  VarTemplateSpecializationDecl *PrevDecl =
3337  InstVarTemplate->findSpecialization(Converted, InsertPos);
3338 
3339  // Check whether we've already seen a conflicting instantiation of this
3340  // declaration (for instance, if there was a prior implicit instantiation).
3341  bool Ignored;
3342  if (PrevDecl && SemaRef.CheckSpecializationInstantiationRedecl(
3343  D->getLocation(), D->getSpecializationKind(), PrevDecl,
3344  PrevDecl->getSpecializationKind(),
3345  PrevDecl->getPointOfInstantiation(), Ignored))
3346  return nullptr;
3347 
3349  InstVarTemplate, D, InsertPos, VarTemplateArgsInfo, Converted, PrevDecl);
3350 }
3351 
3353  VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
3354  const TemplateArgumentListInfo &TemplateArgsInfo,
3355  ArrayRef<TemplateArgument> Converted,
3356  VarTemplateSpecializationDecl *PrevDecl) {
3357 
3358  // Do substitution on the type of the declaration
3359  TypeSourceInfo *DI =
3360  SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
3361  D->getTypeSpecStartLoc(), D->getDeclName());
3362  if (!DI)
3363  return nullptr;
3364 
3365  if (DI->getType()->isFunctionType()) {
3366  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
3367  << D->isStaticDataMember() << DI->getType();
3368  return nullptr;
3369  }
3370 
3371  // Build the instantiated declaration
3373  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
3374  VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
3375  Var->setTemplateArgsInfo(TemplateArgsInfo);
3376  if (InsertPos)
3377  VarTemplate->AddSpecialization(Var, InsertPos);
3378 
3379  // Substitute the nested name specifier, if any.
3380  if (SubstQualifier(D, Var))
3381  return nullptr;
3382 
3383  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
3384  StartingScope, false, PrevDecl);
3385 
3386  return Var;
3387 }
3388 
3389 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3390  llvm_unreachable("@defs is not supported in Objective-C++");
3391 }
3392 
3393 Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3394  // FIXME: We need to be able to instantiate FriendTemplateDecls.
3395  unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3397  "cannot instantiate %0 yet");
3398  SemaRef.Diag(D->getLocation(), DiagID)
3399  << D->getDeclKindName();
3400 
3401  return nullptr;
3402 }
3403 
3404 Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
3405  llvm_unreachable("Concept definitions cannot reside inside a template");
3406 }
3407 
3409  llvm_unreachable("Unexpected decl");
3410 }
3411 
3412 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
3413  const MultiLevelTemplateArgumentList &TemplateArgs) {
3414  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3415  if (D->isInvalidDecl())
3416  return nullptr;
3417 
3418  return Instantiator.Visit(D);
3419 }
3420 
3421 /// Instantiates a nested template parameter list in the current
3422 /// instantiation context.
3423 ///
3424 /// \param L The parameter list to instantiate
3425 ///
3426 /// \returns NULL if there was an error
3429  // Get errors for all the parameters before bailing out.
3430  bool Invalid = false;
3431 
3432  unsigned N = L->size();
3433  typedef SmallVector<NamedDecl *, 8> ParamVector;
3434  ParamVector Params;
3435  Params.reserve(N);
3436  for (auto &P : *L) {
3437  NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
3438  Params.push_back(D);
3439  Invalid = Invalid || !D || D->isInvalidDecl();
3440  }
3441 
3442  // Clean up if we had an error.
3443  if (Invalid)
3444  return nullptr;
3445 
3446  // Note: we substitute into associated constraints later
3447  Expr *const UninstantiatedRequiresClause = L->getRequiresClause();
3448 
3449  TemplateParameterList *InstL
3450  = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
3451  L->getLAngleLoc(), Params,
3452  L->getRAngleLoc(),
3453  UninstantiatedRequiresClause);
3454  return InstL;
3455 }
3456 
3459  const MultiLevelTemplateArgumentList &TemplateArgs) {
3460  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3461  return Instantiator.SubstTemplateParams(Params);
3462 }
3463 
3464 /// Instantiate the declaration of a class template partial
3465 /// specialization.
3466 ///
3467 /// \param ClassTemplate the (instantiated) class template that is partially
3468 // specialized by the instantiation of \p PartialSpec.
3469 ///
3470 /// \param PartialSpec the (uninstantiated) class template partial
3471 /// specialization that we are instantiating.
3472 ///
3473 /// \returns The instantiated partial specialization, if successful; otherwise,
3474 /// NULL to indicate an error.
3477  ClassTemplateDecl *ClassTemplate,
3479  // Create a local instantiation scope for this class template partial
3480  // specialization, which will contain the instantiations of the template
3481  // parameters.
3482  LocalInstantiationScope Scope(SemaRef);
3483 
3484  // Substitute into the template parameters of the class template partial
3485  // specialization.
3486  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3487  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3488  if (!InstParams)
3489  return nullptr;
3490 
3491  // Substitute into the template arguments of the class template partial
3492  // specialization.
3493  const ASTTemplateArgumentListInfo *TemplArgInfo
3494  = PartialSpec->getTemplateArgsAsWritten();
3495  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3496  TemplArgInfo->RAngleLoc);
3497  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3498  TemplArgInfo->NumTemplateArgs,
3499  InstTemplateArgs, TemplateArgs))
3500  return nullptr;
3501 
3502  // Check that the template argument list is well-formed for this
3503  // class template.
3505  if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
3506  PartialSpec->getLocation(),
3507  InstTemplateArgs,
3508  false,
3509  Converted))
3510  return nullptr;
3511 
3512  // Check these arguments are valid for a template partial specialization.
3514  PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
3515  Converted))
3516  return nullptr;
3517 
3518  // Figure out where to insert this class template partial specialization
3519  // in the member template's set of class template partial specializations.
3520  void *InsertPos = nullptr;
3522  = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
3523 
3524  // Build the canonical type that describes the converted template
3525  // arguments of the class template partial specialization.
3526  QualType CanonType
3527  = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
3528  Converted);
3529 
3530  // Build the fully-sugared type for this class template
3531  // specialization as the user wrote in the specialization
3532  // itself. This means that we'll pretty-print the type retrieved
3533  // from the specialization's declaration the way that the user
3534  // actually wrote the specialization, rather than formatting the
3535  // name based on the "canonical" representation used to store the
3536  // template arguments in the specialization.
3537  TypeSourceInfo *WrittenTy
3539  TemplateName(ClassTemplate),
3540  PartialSpec->getLocation(),
3541  InstTemplateArgs,
3542  CanonType);
3543 
3544  if (PrevDecl) {
3545  // We've already seen a partial specialization with the same template
3546  // parameters and template arguments. This can happen, for example, when
3547  // substituting the outer template arguments ends up causing two
3548  // class template partial specializations of a member class template
3549  // to have identical forms, e.g.,
3550  //
3551  // template<typename T, typename U>
3552  // struct Outer {
3553  // template<typename X, typename Y> struct Inner;
3554  // template<typename Y> struct Inner<T, Y>;
3555  // template<typename Y> struct Inner<U, Y>;
3556  // };
3557  //
3558  // Outer<int, int> outer; // error: the partial specializations of Inner
3559  // // have the same signature.
3560  SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
3561  << WrittenTy->getType();
3562  SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
3563  << SemaRef.Context.getTypeDeclType(PrevDecl);
3564  return nullptr;
3565  }
3566 
3567 
3568  // Create the class template partial specialization declaration.
3569  ClassTemplatePartialSpecializationDecl *InstPartialSpec =
3571  SemaRef.Context, PartialSpec->getTagKind(), Owner,
3572  PartialSpec->getBeginLoc(), PartialSpec->getLocation(), InstParams,
3573  ClassTemplate, Converted, InstTemplateArgs, CanonType, nullptr);
3574  // Substitute the nested name specifier, if any.
3575  if (SubstQualifier(PartialSpec, InstPartialSpec))
3576  return nullptr;
3577 
3578  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3579  InstPartialSpec->setTypeAsWritten(WrittenTy);
3580 
3581  // Check the completed partial specialization.
3582  SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3583 
3584  // Add this partial specialization to the set of class template partial
3585  // specializations.
3586  ClassTemplate->AddPartialSpecialization(InstPartialSpec,
3587  /*InsertPos=*/nullptr);
3588  return InstPartialSpec;
3589 }
3590 
3591 /// Instantiate the declaration of a variable template partial
3592 /// specialization.
3593 ///
3594 /// \param VarTemplate the (instantiated) variable template that is partially
3595 /// specialized by the instantiation of \p PartialSpec.
3596 ///
3597 /// \param PartialSpec the (uninstantiated) variable template partial
3598 /// specialization that we are instantiating.
3599 ///
3600 /// \returns The instantiated partial specialization, if successful; otherwise,
3601 /// NULL to indicate an error.
3604  VarTemplateDecl *VarTemplate,
3605  VarTemplatePartialSpecializationDecl *PartialSpec) {
3606  // Create a local instantiation scope for this variable template partial
3607  // specialization, which will contain the instantiations of the template
3608  // parameters.
3609  LocalInstantiationScope Scope(SemaRef);
3610 
3611  // Substitute into the template parameters of the variable template partial
3612  // specialization.
3613  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3614  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3615  if (!InstParams)
3616  return nullptr;
3617 
3618  // Substitute into the template arguments of the variable template partial
3619  // specialization.
3620  const ASTTemplateArgumentListInfo *TemplArgInfo
3621  = PartialSpec->getTemplateArgsAsWritten();
3622  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3623  TemplArgInfo->RAngleLoc);
3624  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3625  TemplArgInfo->NumTemplateArgs,
3626  InstTemplateArgs, TemplateArgs))
3627  return nullptr;
3628 
3629  // Check that the template argument list is well-formed for this
3630  // class template.
3632  if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
3633  InstTemplateArgs, false, Converted))
3634  return nullptr;
3635 
3636  // Check these arguments are valid for a template partial specialization.
3638  PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
3639  Converted))
3640  return nullptr;
3641 
3642  // Figure out where to insert this variable template partial specialization
3643  // in the member template's set of variable template partial specializations.
3644  void *InsertPos = nullptr;
3645  VarTemplateSpecializationDecl *PrevDecl =
3646  VarTemplate->findPartialSpecialization(Converted, InsertPos);
3647 
3648  // Build the canonical type that describes the converted template
3649  // arguments of the variable template partial specialization.
3650  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3651  TemplateName(VarTemplate), Converted);
3652 
3653  // Build the fully-sugared type for this variable template
3654  // specialization as the user wrote in the specialization
3655  // itself. This means that we'll pretty-print the type retrieved
3656  // from the specialization's declaration the way that the user
3657  // actually wrote the specialization, rather than formatting the
3658  // name based on the "canonical" representation used to store the
3659  // template arguments in the specialization.
3661  TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
3662  CanonType);
3663 
3664  if (PrevDecl) {
3665  // We've already seen a partial specialization with the same template
3666  // parameters and template arguments. This can happen, for example, when
3667  // substituting the outer template arguments ends up causing two
3668  // variable template partial specializations of a member variable template
3669  // to have identical forms, e.g.,
3670  //
3671  // template<typename T, typename U>
3672  // struct Outer {
3673  // template<typename X, typename Y> pair<X,Y> p;
3674  // template<typename Y> pair<T, Y> p;
3675  // template<typename Y> pair<U, Y> p;
3676  // };
3677  //
3678  // Outer<int, int> outer; // error: the partial specializations of Inner
3679  // // have the same signature.
3680  SemaRef.Diag(PartialSpec->getLocation(),
3681  diag::err_var_partial_spec_redeclared)
3682  << WrittenTy->getType();
3683  SemaRef.Diag(PrevDecl->getLocation(),
3684  diag::note_var_prev_partial_spec_here);
3685  return nullptr;
3686  }
3687 
3688  // Do substitution on the type of the declaration
3689  TypeSourceInfo *DI = SemaRef.SubstType(
3690  PartialSpec->getTypeSourceInfo(), TemplateArgs,
3691  PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
3692  if (!DI)
3693  return nullptr;
3694 
3695  if (DI->getType()->isFunctionType()) {
3696  SemaRef.Diag(PartialSpec->getLocation(),
3697  diag::err_variable_instantiates_to_function)
3698  << PartialSpec->isStaticDataMember() << DI->getType();
3699  return nullptr;
3700  }
3701 
3702  // Create the variable template partial specialization declaration.
3703  VarTemplatePartialSpecializationDecl *InstPartialSpec =
3705  SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
3706  PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
3707  DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
3708 
3709  // Substitute the nested name specifier, if any.
3710  if (SubstQualifier(PartialSpec, InstPartialSpec))
3711  return nullptr;
3712 
3713  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3714  InstPartialSpec->setTypeAsWritten(WrittenTy);
3715 
3716  // Check the completed partial specialization.
3717  SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3718 
3719  // Add this partial specialization to the set of variable template partial
3720  // specializations. The instantiation of the initializer is not necessary.
3721  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
3722 
3723  SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
3724  LateAttrs, Owner, StartingScope);
3725 
3726  return InstPartialSpec;
3727 }
3728 
3732  TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3733  assert(OldTInfo && "substituting function without type source info");
3734  assert(Params.empty() && "parameter vector is non-empty at start");
3735 
3736  CXXRecordDecl *ThisContext = nullptr;
3737  Qualifiers ThisTypeQuals;
3738  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3739  ThisContext = cast<CXXRecordDecl>(Owner);
3740  ThisTypeQuals = Method->getMethodQualifiers();
3741  }
3742 
3743  TypeSourceInfo *NewTInfo
3744  = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3745  D->getTypeSpecStartLoc(),
3746  D->getDeclName(),
3747  ThisContext, ThisTypeQuals);
3748  if (!NewTInfo)
3749  return nullptr;
3750 
3751  TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3752  if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3753  if (NewTInfo != OldTInfo) {
3754  // Get parameters from the new type info.
3755  TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
3756  FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
3757  unsigned NewIdx = 0;
3758  for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
3759  OldIdx != NumOldParams; ++OldIdx) {
3760  ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
3762 
3763  Optional<unsigned> NumArgumentsInExpansion;
3764  if (OldParam->isParameterPack())
3765  NumArgumentsInExpansion =
3766  SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3767  TemplateArgs);
3768  if (!NumArgumentsInExpansion) {
3769  // Simple case: normal parameter, or a parameter pack that's
3770  // instantiated to a (still-dependent) parameter pack.
3771  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3772  Params.push_back(NewParam);
3773  Scope->InstantiatedLocal(OldParam, NewParam);
3774  } else {
3775  // Parameter pack expansion: make the instantiation an argument pack.
3776  Scope->MakeInstantiatedLocalArgPack(OldParam);
3777  for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
3778  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3779  Params.push_back(NewParam);
3780  Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3781  }
3782  }
3783  }
3784  } else {
3785  // The function type itself was not dependent and therefore no
3786  // substitution occurred. However, we still need to instantiate
3787  // the function parameters themselves.
3788  const FunctionProtoType *OldProto =
3789  cast<FunctionProtoType>(OldProtoLoc.getType());
3790  for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3791  ++i) {
3792  ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
3793  if (!OldParam) {
3794  Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
3795  D, D->getLocation(), OldProto->getParamType(i)));
3796  continue;
3797  }
3798 
3799  ParmVarDecl *Parm =
3800  cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
3801  if (!Parm)
3802  return nullptr;
3803  Params.push_back(Parm);
3804  }
3805  }
3806  } else {
3807  // If the type of this function, after ignoring parentheses, is not
3808  // *directly* a function type, then we're instantiating a function that
3809  // was declared via a typedef or with attributes, e.g.,
3810  //
3811  // typedef int functype(int, int);
3812  // functype func;
3813  // int __cdecl meth(int, int);
3814  //
3815  // In this case, we'll just go instantiate the ParmVarDecls that we
3816  // synthesized in the method declaration.
3817  SmallVector<QualType, 4> ParamTypes;
3818  Sema::ExtParameterInfoBuilder ExtParamInfos;
3819  if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
3820  TemplateArgs, ParamTypes, &Params,
3821  ExtParamInfos))
3822  return nullptr;
3823  }
3824 
3825  return NewTInfo;
3826 }
3827 
3828 /// Introduce the instantiated function parameters into the local
3829 /// instantiation scope, and set the parameter names to those used
3830 /// in the template.
3832  const FunctionDecl *PatternDecl,
3834  const MultiLevelTemplateArgumentList &TemplateArgs) {
3835  unsigned FParamIdx = 0;
3836  for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3837  const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3838  if (!PatternParam->isParameterPack()) {
3839  // Simple case: not a parameter pack.
3840  assert(FParamIdx < Function->getNumParams());
3841  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3842  FunctionParam->setDeclName(PatternParam->getDeclName());
3843  // If the parameter's type is not dependent, update it to match the type
3844  // in the pattern. They can differ in top-level cv-qualifiers, and we want
3845  // the pattern's type here. If the type is dependent, they can't differ,
3846  // per core issue 1668. Substitute into the type from the pattern, in case
3847  // it's instantiation-dependent.
3848  // FIXME: Updating the type to work around this is at best fragile.
3849  if (!PatternDecl->getType()->isDependentType()) {
3850  QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3851  FunctionParam->getLocation(),
3852  FunctionParam->getDeclName());
3853  if (T.isNull())
3854  return true;
3855  FunctionParam->setType(T);
3856  }
3857 
3858  Scope.InstantiatedLocal(PatternParam, FunctionParam);
3859  ++FParamIdx;
3860  continue;
3861  }
3862 
3863  // Expand the parameter pack.
3864  Scope.MakeInstantiatedLocalArgPack(PatternParam);
3865  Optional<unsigned> NumArgumentsInExpansion
3866  = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
3867  if (NumArgumentsInExpansion) {
3868  QualType PatternType =
3869  PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
3870  for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
3871  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3872  FunctionParam->setDeclName(PatternParam->getDeclName());
3873  if (!PatternDecl->getType()->isDependentType()) {
3874  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3875  QualType T = S.SubstType(PatternType, TemplateArgs,
3876  FunctionParam->getLocation(),
3877  FunctionParam->getDeclName());
3878  if (T.isNull())
3879  return true;
3880  FunctionParam->setType(T);
3881  }
3882 
3883  Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3884  ++FParamIdx;
3885  }
3886  }
3887  }
3888 
3889  return false;
3890 }
3891 
3893  FunctionDecl *Decl) {
3894  const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3895  if (Proto->getExceptionSpecType() != EST_Uninstantiated)
3896  return;
3897 
3898  InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3900  if (Inst.isInvalid()) {
3901  // We hit the instantiation depth limit. Clear the exception specification
3902  // so that our callers don't have to cope with EST_Uninstantiated.
3903  UpdateExceptionSpec(Decl, EST_None);
3904  return;
3905  }
3906  if (Inst.isAlreadyInstantiating()) {
3907  // This exception specification indirectly depends on itself. Reject.
3908  // FIXME: Corresponding rule in the standard?
3909  Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
3910  UpdateExceptionSpec(Decl, EST_None);
3911  return;
3912  }
3913 
3914  // Enter the scope of this instantiation. We don't use
3915  // PushDeclContext because we don't have a scope.
3916  Sema::ContextRAII savedContext(*this, Decl);
3918 
3919  MultiLevelTemplateArgumentList TemplateArgs =
3920  getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
3921 
3922  FunctionDecl *Template = Proto->getExceptionSpecTemplate();
3923  if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3924  TemplateArgs)) {
3925  UpdateExceptionSpec(Decl, EST_None);
3926  return;
3927  }
3928 
3929  SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3930  TemplateArgs);
3931 }
3932 
3933 /// Initializes the common fields of an instantiation function
3934 /// declaration (New) from the corresponding fields of its template (Tmpl).
3935 ///
3936 /// \returns true if there was an error
3937 bool
3939  FunctionDecl *Tmpl) {
3940  if (Tmpl->isDeleted())
3941  New->setDeletedAsWritten();
3942 
3943  New->setImplicit(Tmpl->isImplicit());
3944 
3945  // Forward the mangling number from the template to the instantiated decl.
3946  SemaRef.Context.setManglingNumber(New,
3947  SemaRef.Context.getManglingNumber(Tmpl));
3948 
3949  // If we are performing substituting explicitly-specified template arguments
3950  // or deduced template arguments into a function template and we reach this
3951  // point, we are now past the point where SFINAE applies and have committed
3952  // to keeping the new function template specialization. We therefore
3953  // convert the active template instantiation for the function template
3954  // into a template instantiation for this specific function template
3955  // specialization, which is not a SFINAE context, so that we diagnose any
3956  // further errors in the declaration itself.
3957  typedef Sema::CodeSynthesisContext ActiveInstType;
3958  ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
3959  if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3960  ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
3961  if (FunctionTemplateDecl *FunTmpl
3962  = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
3963  assert(FunTmpl->getTemplatedDecl() == Tmpl &&
3964  "Deduction from the wrong function template?");
3965  (void) FunTmpl;
3966  atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
3967  ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
3968  ActiveInst.Entity = New;
3969  atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
3970  }
3971  }
3972 
3973  const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3974  assert(Proto && "Function template without prototype?");
3975 
3976  if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3978 
3979  // DR1330: In C++11, defer instantiation of a non-trivial
3980  // exception specification.
3981  // DR1484: Local classes and their members are instantiated along with the
3982  // containing function.
3983  if (SemaRef.getLangOpts().CPlusPlus11 &&
3984  EPI.ExceptionSpec.Type != EST_None &&
3988  FunctionDecl *ExceptionSpecTemplate = Tmpl;
3990  ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
3992  if (EPI.ExceptionSpec.Type == EST_Unevaluated)
3993  NewEST = EST_Unevaluated;
3994 
3995  // Mark the function has having an uninstantiated exception specification.
3996  const FunctionProtoType *NewProto
3997  = New->getType()->getAs<FunctionProtoType>();
3998  assert(NewProto && "Template instantiation without function prototype?");
3999  EPI = NewProto->getExtProtoInfo();
4000  EPI.ExceptionSpec.Type = NewEST;
4001  EPI.ExceptionSpec.SourceDecl = New;
4002  EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
4003  New->setType(SemaRef.Context.getFunctionType(
4004  NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
4005  } else {
4006  Sema::ContextRAII SwitchContext(SemaRef, New);
4007  SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
4008  }
4009  }
4010 
4011  // Get the definition. Leaves the variable unchanged if undefined.
4012  const FunctionDecl *Definition = Tmpl;
4013  Tmpl->isDefined(Definition);
4014 
4015  SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
4016  LateAttrs, StartingScope);
4017 
4018  return false;
4019 }
4020 
4021 /// Initializes common fields of an instantiated method
4022 /// declaration (New) from the corresponding fields of its template
4023 /// (Tmpl).
4024 ///
4025 /// \returns true if there was an error
4026 bool
4028  CXXMethodDecl *Tmpl) {
4029  if (InitFunctionInstantiation(New, Tmpl))
4030  return true;
4031 
4032  if (isa<CXXDestructorDecl>(New) && SemaRef.getLangOpts().CPlusPlus11)
4033  SemaRef.AdjustDestructorExceptionSpec(cast<CXXDestructorDecl>(New));
4034 
4035  New->setAccess(Tmpl->getAccess());
4036  if (Tmpl->isVirtualAsWritten())
4037  New->setVirtualAsWritten(true);
4038 
4039  // FIXME: New needs a pointer to Tmpl
4040  return false;
4041 }
4042 
4043 /// Instantiate (or find existing instantiation of) a function template with a
4044 /// given set of template arguments.
4045 ///
4046 /// Usually this should not be used, and template argument deduction should be
4047 /// used in its place.
4048 FunctionDecl *
4050  const TemplateArgumentList *Args,
4051  SourceLocation Loc) {
4052  FunctionDecl *FD = FTD->getTemplatedDecl();
4053 
4054  sema::TemplateDeductionInfo Info(Loc);
4055  InstantiatingTemplate Inst(
4056  *this, Loc, FTD, Args->asArray(),
4057  CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
4058  if (Inst.isInvalid())
4059  return nullptr;
4060 
4061  ContextRAII SavedContext(*this, FD);
4062  MultiLevelTemplateArgumentList MArgs(*Args);
4063 
4064  return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
4065 }
4066 
4067 /// In the MS ABI, we need to instantiate default arguments of dllexported
4068 /// default constructors along with the constructor definition. This allows IR
4069 /// gen to emit a constructor closure which calls the default constructor with
4070 /// its default arguments.
4072  CXXConstructorDecl *Ctor) {
4073  assert(S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
4074  Ctor->isDefaultConstructor());
4075  unsigned NumParams = Ctor->getNumParams();
4076  if (NumParams == 0)
4077  return;
4078  DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
4079  if (!Attr)
4080  return;
4081  for (unsigned I = 0; I != NumParams; ++I) {
4082  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
4083  Ctor->getParamDecl(I));
4085  }
4086 }
4087 
4088 /// Instantiate the definition of the given function from its
4089 /// template.
4090 ///
4091 /// \param PointOfInstantiation the point at which the instantiation was
4092 /// required. Note that this is not precisely a "point of instantiation"
4093 /// for the function, but it's close.
4094 ///
4095 /// \param Function the already-instantiated declaration of a
4096 /// function template specialization or member function of a class template
4097 /// specialization.
4098 ///
4099 /// \param Recursive if true, recursively instantiates any functions that
4100 /// are required by this instantiation.
4101 ///
4102 /// \param DefinitionRequired if true, then we are performing an explicit
4103 /// instantiation where the body of the function is required. Complain if
4104 /// there is no such body.
4106  FunctionDecl *Function,
4107  bool Recursive,
4108  bool DefinitionRequired,
4109  bool AtEndOfTU) {
4110  if (Function->isInvalidDecl() || Function->isDefined() ||
4111  isa<CXXDeductionGuideDecl>(Function))
4112  return;
4113 
4114  // Never instantiate an explicit specialization except if it is a class scope
4115  // explicit specialization.
4118  if (TSK == TSK_ExplicitSpecialization)
4119  return;
4120 
4121  // Find the function body that we'll be substituting.
4122  const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
4123  assert(PatternDecl && "instantiating a non-template");
4124 
4125  const FunctionDecl *PatternDef = PatternDecl->getDefinition();
4126  Stmt *Pattern = nullptr;
4127  if (PatternDef) {
4128  Pattern = PatternDef->getBody(PatternDef);
4129  PatternDecl = PatternDef;
4130  if (PatternDef->willHaveBody())
4131  PatternDef = nullptr;
4132  }
4133 
4134  // FIXME: We need to track the instantiation stack in order to know which
4135  // definitions should be visible within this instantiation.
4136  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
4138  PatternDecl, PatternDef, TSK,
4139  /*Complain*/DefinitionRequired)) {
4140  if (DefinitionRequired)
4141  Function->setInvalidDecl();
4142  else if (TSK == TSK_ExplicitInstantiationDefinition) {
4143  // Try again at the end of the translation unit (at which point a
4144  // definition will be required).
4145  assert(!Recursive);
4146  Function->setInstantiationIsPending(true);
4147  PendingInstantiations.push_back(
4148  std::make_pair(Function, PointOfInstantiation));
4149  } else if (TSK == TSK_ImplicitInstantiation) {
4150  if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
4151  !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
4152  Diag(PointOfInstantiation, diag::warn_func_template_missing)
4153  << Function;
4154  Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4155  if (getLangOpts().CPlusPlus11)
4156  Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
4157  << Function;
4158  }
4159  }
4160 
4161  return;
4162  }
4163 
4164  // Postpone late parsed template instantiations.
4165  if (PatternDecl->isLateTemplateParsed() &&
4166  !LateTemplateParser) {
4167  Function->setInstantiationIsPending(true);
4168  LateParsedInstantiations.push_back(
4169  std::make_pair(Function, PointOfInstantiation));
4170  return;
4171  }
4172 
4173  llvm::TimeTraceScope TimeScope("InstantiateFunction", [&]() {
4174  std::string Name;
4175  llvm::raw_string_ostream OS(Name);
4176  Function->getNameForDiagnostic(OS, getPrintingPolicy(),
4177  /*Qualified=*/true);
4178  return Name;
4179  });
4180 
4181  // If we're performing recursive template instantiation, create our own
4182  // queue of pending implicit instantiations that we will instantiate later,
4183  // while we're still within our own instantiation context.
4184  // This has to happen before LateTemplateParser below is called, so that
4185  // it marks vtables used in late parsed templates as used.
4186  GlobalEagerInstantiationScope GlobalInstantiations(*this,
4187  /*Enabled=*/Recursive);
4188  LocalEagerInstantiationScope LocalInstantiations(*this);
4189 
4190  // Call the LateTemplateParser callback if there is a need to late parse
4191  // a templated function definition.
4192  if (!Pattern && PatternDecl->isLateTemplateParsed() &&
4193  LateTemplateParser) {
4194  // FIXME: Optimize to allow individual templates to be deserialized.
4195  if (PatternDecl->isFromASTFile())
4196  ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
4197 
4198  auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
4199  assert(LPTIter != LateParsedTemplateMap.end() &&
4200  "missing LateParsedTemplate");
4201  LateTemplateParser(OpaqueParser, *LPTIter->second);
4202  Pattern = PatternDecl->getBody(PatternDecl);
4203  }
4204 
4205  // Note, we should never try to instantiate a deleted function template.
4206  assert((Pattern || PatternDecl->isDefaulted() ||
4207  PatternDecl->hasSkippedBody()) &&
4208  "unexpected kind of function template definition");
4209 
4210  // C++1y [temp.explicit]p10:
4211  // Except for inline functions, declarations with types deduced from their
4212  // initializer or return value, and class template specializations, other
4213  // explicit instantiation declarations have the effect of suppressing the
4214  // implicit instantiation of the entity to which they refer.
4216  !PatternDecl->isInlined() &&
4217  !PatternDecl->getReturnType()->getContainedAutoType())
4218  return;
4219 
4220  if (PatternDecl->isInlined()) {
4221  // Function, and all later redeclarations of it (from imported modules,
4222  // for instance), are now implicitly inline.
4223  for (auto *D = Function->getMostRecentDecl(); /**/;
4224  D = D->getPreviousDecl()) {
4225  D->setImplicitlyInline();
4226  if (D == Function)
4227  break;
4228  }
4229  }
4230 
4231  InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
4232  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4233  return;
4234  PrettyDeclStackTraceEntry CrashInfo(Context, Function, SourceLocation(),
4235  "instantiating function definition");
4236 
4237  // The instantiation is visible here, even if it was first declared in an
4238  // unimported module.
4239  Function->setVisibleDespiteOwningModule();
4240 
4241  // Copy the inner loc start from the pattern.
4242  Function->setInnerLocStart(PatternDecl->getInnerLocStart());
4243 
4246 
4247  // Introduce a new scope where local variable instantiations will be
4248  // recorded, unless we're actually a member function within a local
4249  // class, in which case we need to merge our results with the parent
4250  // scope (of the enclosing function).
4251  bool MergeWithParentScope = false;
4252  if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
4253  MergeWithParentScope = Rec->isLocalClass();
4254 
4255  LocalInstantiationScope Scope(*this, MergeWithParentScope);
4256 
4257  if (PatternDecl->isDefaulted())
4258  SetDeclDefaulted(Function, PatternDecl->getLocation());
4259  else {
4260  MultiLevelTemplateArgumentList TemplateArgs =
4261  getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
4262 
4263  // Substitute into the qualifier; we can get a substitution failure here
4264  // through evil use of alias templates.
4265  // FIXME: Is CurContext correct for this? Should we go to the (instantiation
4266  // of the) lexical context of the pattern?
4267  SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
4268 
4269  ActOnStartOfFunctionDef(nullptr, Function);
4270 
4271  // Enter the scope of this instantiation. We don't use
4272  // PushDeclContext because we don't have a scope.
4273  Sema::ContextRAII savedContext(*this, Function);
4274 
4275  if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
4276  TemplateArgs))
4277  return;
4278 
4279  StmtResult Body;
4280  if (PatternDecl->hasSkippedBody()) {
4281  ActOnSkippedFunctionBody(Function);
4282  Body = nullptr;
4283  } else {
4284  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
4285  // If this is a constructor, instantiate the member initializers.
4286  InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
4287  TemplateArgs);
4288 
4289  // If this is an MS ABI dllexport default constructor, instantiate any
4290  // default arguments.
4291  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
4292  Ctor->isDefaultConstructor()) {
4293  InstantiateDefaultCtorDefaultArgs(*this, Ctor);
4294  }
4295  }
4296 
4297  // Instantiate the function body.
4298  Body = SubstStmt(Pattern, TemplateArgs);
4299 
4300  if (Body.isInvalid())
4301  Function->setInvalidDecl();
4302  }
4303  // FIXME: finishing the function body while in an expression evaluation
4304  // context seems wrong. Investigate more.
4305  ActOnFinishFunctionBody(Function, Body.get(), /*IsInstantiation=*/true);
4306 
4307  PerformDependentDiagnostics(PatternDecl, TemplateArgs);
4308 
4309  if (auto *Listener = getASTMutationListener())
4310  Listener->FunctionDefinitionInstantiated(Function);
4311 
4312  savedContext.pop();
4313  }
4314 
4315  DeclGroupRef DG(Function);
4316  Consumer.HandleTopLevelDecl(DG);
4317 
4318  // This class may have local implicit instantiations that need to be
4319  // instantiation within this scope.
4320  LocalInstantiations.perform();
4321  Scope.Exit();
4322  GlobalInstantiations.perform();
4323 }
4324 
4326  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
4327  const TemplateArgumentList &TemplateArgList,
4328  const TemplateArgumentListInfo &TemplateArgsInfo,
4330  SourceLocation PointOfInstantiation, void *InsertPos,
4331  LateInstantiatedAttrVec *LateAttrs,
4332  LocalInstantiationScope *StartingScope) {
4333  if (FromVar->isInvalidDecl())
4334  return nullptr;
4335 
4336  InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
4337  if (Inst.isInvalid())
4338  return nullptr;
4339 
4340  MultiLevelTemplateArgumentList TemplateArgLists;
4341  TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
4342 
4343  // Instantiate the first declaration of the variable template: for a partial
4344  // specialization of a static data member template, the first declaration may
4345  // or may not be the declaration in the class; if it's in the class, we want
4346  // to instantiate a member in the class (a declaration), and if it's outside,
4347  // we want to instantiate a definition.
4348  //
4349  // If we're instantiating an explicitly-specialized member template or member
4350  // partial specialization, don't do this. The member specialization completely
4351  // replaces the original declaration in this case.
4352  bool IsMemberSpec = false;
4353  if (VarTemplatePartialSpecializationDecl *PartialSpec =
4354  dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
4355  IsMemberSpec = PartialSpec->isMemberSpecialization();
4356  else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
4357  IsMemberSpec = FromTemplate->isMemberSpecialization();
4358  if (!IsMemberSpec)
4359  FromVar = FromVar->getFirstDecl();
4360 
4361  MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
4362  TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
4363  MultiLevelList);
4364 
4365  // TODO: Set LateAttrs and StartingScope ...
4366 
4367  return cast_or_null<VarTemplateSpecializationDecl>(
4368  Instantiator.VisitVarTemplateSpecializationDecl(
4369  VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
4370 }
4371 
4372 /// Instantiates a variable template specialization by completing it
4373 /// with appropriate type information and initializer.
4375  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
4376  const MultiLevelTemplateArgumentList &TemplateArgs) {
4377  assert(PatternDecl->isThisDeclarationADefinition() &&
4378  "don't have a definition to instantiate from");
4379 
4380  // Do substitution on the type of the declaration
4381  TypeSourceInfo *DI =
4382  SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
4383  PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
4384  if (!DI)
4385  return nullptr;
4386 
4387  // Update the type of this variable template specialization.
4388  VarSpec->setType(DI->getType());
4389 
4390  // Convert the declaration into a definition now.
4391  VarSpec->setCompleteDefinition();
4392 
4393  // Instantiate the initializer.
4394  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
4395 
4396  return VarSpec;
4397 }
4398 
4399 /// BuildVariableInstantiation - Used after a new variable has been created.
4400 /// Sets basic variable data and decides whether to postpone the
4401 /// variable instantiation.
4403  VarDecl *NewVar, VarDecl *OldVar,
4404  const MultiLevelTemplateArgumentList &TemplateArgs,
4405  LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
4406  LocalInstantiationScope *StartingScope,
4407  bool InstantiatingVarTemplate,
4408  VarTemplateSpecializationDecl *PrevDeclForVarTemplateSpecialization) {
4409  // Instantiating a partial specialization to produce a partial
4410  // specialization.
4411  bool InstantiatingVarTemplatePartialSpec =
4412  isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
4413  isa<VarTemplatePartialSpecializationDecl>(NewVar);
4414  // Instantiating from a variable template (or partial specialization) to
4415  // produce a variable template specialization.
4416  bool InstantiatingSpecFromTemplate =
4417  isa<VarTemplateSpecializationDecl>(NewVar) &&
4418  (OldVar->getDescribedVarTemplate() ||
4419  isa<VarTemplatePartialSpecializationDecl>(OldVar));
4420 
4421  // If we are instantiating a local extern declaration, the
4422  // instantiation belongs lexically to the containing function.
4423  // If we are instantiating a static data member defined
4424  // out-of-line, the instantiation will have the same lexical
4425  // context (which will be a namespace scope) as the template.
4426  if (OldVar->isLocalExternDecl()) {
4427  NewVar->setLocalExternDecl();
4428  NewVar->setLexicalDeclContext(Owner);
4429  } else if (OldVar->isOutOfLine())
4430  NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
4431  NewVar->setTSCSpec(OldVar->getTSCSpec());
4432  NewVar->setInitStyle(OldVar->getInitStyle());
4433  NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
4434  NewVar->setObjCForDecl(OldVar->isObjCForDecl());
4435  NewVar->setConstexpr(OldVar->isConstexpr());
4436  NewVar->setInitCapture(OldVar->isInitCapture());
4438  OldVar->isPreviousDeclInSameBlockScope());
4439  NewVar->setAccess(OldVar->getAccess());
4440 
4441  if (!OldVar->isStaticDataMember()) {
4442  if (OldVar->isUsed(false))
4443  NewVar->setIsUsed();
4444  NewVar->setReferenced(OldVar->isReferenced());
4445  }
4446 
4447  InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
4448 
4450  *this, NewVar->getDeclName(), NewVar->getLocation(),
4454  : forRedeclarationInCurContext());
4455 
4456  if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
4458  OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
4459  // We have a previous declaration. Use that one, so we merge with the
4460  // right type.
4461  if (NamedDecl *NewPrev = FindInstantiatedDecl(
4462  NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
4463  Previous.addDecl(NewPrev);
4464  } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
4465  OldVar->hasLinkage()) {
4466  LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
4467  } else if (PrevDeclForVarTemplateSpecialization) {
4468  Previous.addDecl(PrevDeclForVarTemplateSpecialization);
4469  }
4470  CheckVariableDeclaration(NewVar, Previous);
4471 
4472  if (!InstantiatingVarTemplate) {
4473  NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
4474  if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
4475  NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
4476  }
4477 
4478  if (!OldVar->isOutOfLine()) {
4479  if (NewVar->getDeclContext()->isFunctionOrMethod())
4480  CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
4481  }
4482 
4483  // Link instantiations of static data members back to the template from
4484  // which they were instantiated.
4485  //
4486  // Don't do this when instantiating a template (we link the template itself
4487  // back in that case) nor when instantiating a static data member template
4488  // (that's not a member specialization).
4489  if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate &&
4490  !InstantiatingSpecFromTemplate)
4491  NewVar->setInstantiationOfStaticDataMember(OldVar,
4493 
4494  // If the pattern is an (in-class) explicit specialization, then the result
4495  // is also an explicit specialization.
4496  if (VarTemplateSpecializationDecl *OldVTSD =
4497  dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
4498  if (OldVTSD->getSpecializationKind() == TSK_ExplicitSpecialization &&
4499  !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
4500  cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
4502  }
4503 
4504  // Forward the mangling number from the template to the instantiated decl.
4505  Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
4506  Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
4507 
4508  // Figure out whether to eagerly instantiate the initializer.
4509  if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
4510  // We're producing a template. Don't instantiate the initializer yet.
4511  } else if (NewVar->getType()->isUndeducedType()) {
4512  // We need the type to complete the declaration of the variable.
4513  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4514  } else if (InstantiatingSpecFromTemplate ||
4515  (OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
4516  !NewVar->isThisDeclarationADefinition())) {
4517  // Delay instantiation of the initializer for variable template
4518  // specializations or inline static data members until a definition of the
4519  // variable is needed.
4520  } else {
4521  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4522  }
4523 
4524  // Diagnose unused local variables with dependent types, where the diagnostic
4525  // will have been deferred.
4526  if (!NewVar->isInvalidDecl() &&
4527  NewVar->getDeclContext()->isFunctionOrMethod() &&
4528  OldVar->getType()->isDependentType())
4529  DiagnoseUnusedDecl(NewVar);
4530 }
4531 
4532 /// Instantiate the initializer of a variable.
4534  VarDecl *Var, VarDecl *OldVar,
4535  const MultiLevelTemplateArgumentList &TemplateArgs) {
4536  if (ASTMutationListener *L = getASTContext().getASTMutationListener())
4537  L->VariableDefinitionInstantiated(Var);
4538 
4539  // We propagate the 'inline' flag with the initializer, because it
4540  // would otherwise imply that the variable is a definition for a
4541  // non-static data member.
4542  if (OldVar->isInlineSpecified())
4543  Var->setInlineSpecified();
4544  else if (OldVar->isInline())
4545  Var->setImplicitlyInline();
4546 
4547  if (OldVar->getInit()) {
4550 
4551  // Instantiate the initializer.
4552  ExprResult Init;
4553 
4554  {
4555  ContextRAII SwitchContext(*this, Var->getDeclContext());
4556  Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
4557  OldVar->getInitStyle() == VarDecl::CallInit);
4558  }
4559 
4560  if (!Init.isInvalid()) {
4561  Expr *InitExpr = Init.get();
4562 
4563  if (Var->hasAttr<DLLImportAttr>() &&
4564  (!InitExpr ||
4565  !InitExpr->isConstantInitializer(getASTContext(), false))) {
4566  // Do not dynamically initialize dllimport variables.
4567  } else if (InitExpr) {
4568  bool DirectInit = OldVar->isDirectInit();
4569  AddInitializerToDecl(Var, InitExpr, DirectInit);
4570  } else
4571  ActOnUninitializedDecl(Var);
4572  } else {
4573  // FIXME: Not too happy about invalidating the declaration
4574  // because of a bogus initializer.
4575  Var->setInvalidDecl();
4576  }
4577  } else {
4578  // `inline` variables are a definition and declaration all in one; we won't
4579  // pick up an initializer from anywhere else.
4580  if (Var->isStaticDataMember() && !Var->isInline()) {
4581  if (!Var->isOutOfLine())
4582  return;
4583 
4584  // If the declaration inside the class had an initializer, don't add
4585  // another one to the out-of-line definition.
4586  if (OldVar->getFirstDecl()->hasInit())
4587  return;
4588  }
4589 
4590  // We'll add an initializer to a for-range declaration later.
4591  if (Var->isCXXForRangeDecl() || Var->isObjCForDecl())
4592  return;
4593 
4594  ActOnUninitializedDecl(Var);
4595  }
4596 
4597  if (getLangOpts().CUDA)
4598  checkAllowedCUDAInitializer(Var);
4599 }
4600 
4601 /// Instantiate the definition of the given variable from its
4602 /// template.
4603 ///
4604 /// \param PointOfInstantiation the point at which the instantiation was
4605 /// required. Note that this is not precisely a "point of instantiation"
4606 /// for the variable, but it's close.
4607 ///
4608 /// \param Var the already-instantiated declaration of a templated variable.
4609 ///
4610 /// \param Recursive if true, recursively instantiates any functions that
4611 /// are required by this instantiation.
4612 ///
4613 /// \param DefinitionRequired if true, then we are performing an explicit
4614 /// instantiation where a definition of the variable is required. Complain
4615 /// if there is no such definition.
4617  VarDecl *Var, bool Recursive,
4618  bool DefinitionRequired, bool AtEndOfTU) {
4619  if (Var->isInvalidDecl())
4620  return;
4621 
4622  // Never instantiate an explicitly-specialized entity.
4625  if (TSK == TSK_ExplicitSpecialization)
4626  return;
4627 
4628  // Find the pattern and the arguments to substitute into it.
4629  VarDecl *PatternDecl = Var->getTemplateInstantiationPattern();
4630  assert(PatternDecl && "no pattern for templated variable");
4631  MultiLevelTemplateArgumentList TemplateArgs =
4632  getTemplateInstantiationArgs(Var);
4633 
4635  dyn_cast<VarTemplateSpecializationDecl>(Var);
4636  if (VarSpec) {
4637  // If this is a variable template specialization, make sure that it is
4638  // non-dependent.
4639  bool InstantiationDependent = false;
4641  VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
4642  "Only instantiate variable template specializations that are "
4643  "not type-dependent");
4644  (void)InstantiationDependent;
4645 
4646  // If this is a static data member template, there might be an
4647  // uninstantiated initializer on the declaration. If so, instantiate
4648  // it now.
4649  //
4650  // FIXME: This largely duplicates what we would do below. The difference
4651  // is that along this path we may instantiate an initializer from an
4652  // in-class declaration of the template and instantiate the definition
4653  // from a separate out-of-class definition.
4654  if (PatternDecl->isStaticDataMember() &&
4655  (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
4656  !Var->hasInit()) {
4657  // FIXME: Factor out the duplicated instantiation context setup/tear down
4658  // code here.
4659  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4660  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4661  return;
4662  PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
4663  "instantiating variable initializer");
4664 
4665  // The instantiation is visible here, even if it was first declared in an
4666  // unimported module.
4668 
4669  // If we're performing recursive template instantiation, create our own
4670  // queue of pending implicit instantiations that we will instantiate
4671  // later, while we're still within our own instantiation context.
4672  GlobalEagerInstantiationScope GlobalInstantiations(*this,
4673  /*Enabled=*/Recursive);
4674  LocalInstantiationScope Local(*this);
4675  LocalEagerInstantiationScope LocalInstantiations(*this);
4676 
4677  // Enter the scope of this instantiation. We don't use
4678  // PushDeclContext because we don't have a scope.
4679  ContextRAII PreviousContext(*this, Var->getDeclContext());
4680  InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
4681  PreviousContext.pop();
4682 
4683  // This variable may have local implicit instantiations that need to be
4684  // instantiated within this scope.
4685  LocalInstantiations.perform();
4686  Local.Exit();
4687  GlobalInstantiations.perform();
4688  }
4689  } else {
4690  assert(Var->isStaticDataMember() && PatternDecl->isStaticDataMember() &&
4691  "not a static data member?");
4692  }
4693 
4694  VarDecl *Def = PatternDecl->getDefinition(getASTContext());
4695 
4696  // If we don't have a definition of the variable template, we won't perform
4697  // any instantiation. Rather, we rely on the user to instantiate this
4698  // definition (or provide a specialization for it) in another translation
4699  // unit.
4700  if (!Def && !DefinitionRequired) {
4702  PendingInstantiations.push_back(
4703  std::make_pair(Var, PointOfInstantiation));
4704  } else if (TSK == TSK_ImplicitInstantiation) {
4705  // Warn about missing definition at the end of translation unit.
4706  if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
4707  !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
4708  Diag(PointOfInstantiation, diag::warn_var_template_missing)
4709  << Var;
4710  Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4711  if (getLangOpts().CPlusPlus11)
4712  Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
4713  }
4714  return;
4715  }
4716  }
4717 
4718  // FIXME: We need to track the instantiation stack in order to know which
4719  // definitions should be visible within this instantiation.
4720  // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
4721  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
4722  /*InstantiatedFromMember*/false,
4723  PatternDecl, Def, TSK,
4724  /*Complain*/DefinitionRequired))
4725  return;
4726 
4727  // C++11 [temp.explicit]p10:
4728  // Except for inline functions, const variables of literal types, variables
4729  // of reference types, [...] explicit instantiation declarations
4730  // have the effect of suppressing the implicit instantiation of the entity
4731  // to which they refer.
4732  //
4733  // FIXME: That's not exactly the same as "might be usable in constant
4734  // expressions", which only allows constexpr variables and const integral
4735  // types, not arbitrary const literal types.
4737  !Var->mightBeUsableInConstantExpressions(getASTContext()))
4738  return;
4739 
4740  // Make sure to pass the instantiated variable to the consumer at the end.
4741  struct PassToConsumerRAII {
4742  ASTConsumer &Consumer;
4743  VarDecl *Var;
4744 
4745  PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
4746  : Consumer(Consumer), Var(Var) { }
4747 
4748  ~PassToConsumerRAII() {
4750  }
4751  } PassToConsumerRAII(Consumer, Var);
4752 
4753  // If we already have a definition, we're done.
4754  if (VarDecl *Def = Var->getDefinition()) {
4755  // We may be explicitly instantiating something we've already implicitly
4756  // instantiated.
4757  Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
4758  PointOfInstantiation);
4759  return;
4760  }
4761 
4762  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4763  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4764  return;
4765  PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
4766  "instantiating variable definition");
4767 
4768  // If we're performing recursive template instantiation, create our own
4769  // queue of pending implicit instantiations that we will instantiate later,
4770  // while we're still within our own instantiation context.
4771  GlobalEagerInstantiationScope GlobalInstantiations(*this,
4772  /*Enabled=*/Recursive);
4773 
4774  // Enter the scope of this instantiation. We don't use
4775  // PushDeclContext because we don't have a scope.
4776  ContextRAII PreviousContext(*this, Var->getDeclContext());
4777  LocalInstantiationScope Local(*this);
4778 
4779  LocalEagerInstantiationScope LocalInstantiations(*this);
4780 
4781  VarDecl *OldVar = Var;
4782  if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
4783  // We're instantiating an inline static data member whose definition was
4784  // provided inside the class.
4785  InstantiateVariableInitializer(Var, Def, TemplateArgs);
4786  } else if (!VarSpec) {
4787  Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
4788  TemplateArgs));
4789  } else if (Var->isStaticDataMember() &&
4790  Var->getLexicalDeclContext()->isRecord()) {
4791  // We need to instantiate the definition of a static data member template,
4792  // and all we have is the in-class declaration of it. Instantiate a separate
4793  // declaration of the definition.
4794  TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
4795  TemplateArgs);
4796  Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
4797  VarSpec->getSpecializedTemplate(), Def, nullptr,
4798  VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
4799  if (Var) {
4800  llvm::PointerUnion<VarTemplateDecl *,
4801  VarTemplatePartialSpecializationDecl *> PatternPtr =
4804  PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
4805  cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
4806  Partial, &VarSpec->getTemplateInstantiationArgs());
4807 
4808  // Merge the definition with the declaration.
4809  LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
4810  LookupOrdinaryName, forRedeclarationInCurContext());
4811  R.addDecl(OldVar);
4812  MergeVarDecl(Var, R);
4813 
4814  // Attach the initializer.
4815  InstantiateVariableInitializer(Var, Def, TemplateArgs);
4816  }
4817  } else
4818  // Complete the existing variable's definition with an appropriately
4819  // substituted type and initializer.
4820  Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
4821 
4822  PreviousContext.pop();
4823 
4824  if (Var) {
4825  PassToConsumerRAII.Var = Var;
4827  OldVar->getPointOfInstantiation());
4828  }
4829 
4830  // This variable may have local implicit instantiations that need to be
4831  // instantiated within this scope.
4832  LocalInstantiations.perform();
4833  Local.Exit();
4834  GlobalInstantiations.perform();
4835 }
4836 
4837 void
4839  const CXXConstructorDecl *Tmpl,
4840  const MultiLevelTemplateArgumentList &TemplateArgs) {
4841 
4843  bool AnyErrors = Tmpl->isInvalidDecl();
4844 
4845  // Instantiate all the initializers.
4846  for (const auto *Init : Tmpl->inits()) {
4847  // Only instantiate written initializers, let Sema re-construct implicit
4848  // ones.
4849  if (!Init->isWritten())
4850  continue;
4851 
4852  SourceLocation EllipsisLoc;
4853 
4854  if (Init->isPackExpansion()) {
4855  // This is a pack expansion. We should expand it now.
4856  TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
4858  collectUnexpandedParameterPacks(BaseTL, Unexpanded);
4859  collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
4860  bool ShouldExpand = false;
4861  bool RetainExpansion = false;
4862  Optional<unsigned> NumExpansions;
4863  if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
4864  BaseTL.getSourceRange(),
4865  Unexpanded,
4866  TemplateArgs, ShouldExpand,
4867  RetainExpansion,
4868  NumExpansions)) {
4869  AnyErrors = true;
4870  New->setInvalidDecl();
4871  continue;
4872  }
4873  assert(ShouldExpand && "Partial instantiation of base initializer?");
4874 
4875  // Loop over all of the arguments in the argument pack(s),
4876  for (unsigned I = 0; I != *NumExpansions; ++I) {
4877  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4878 
4879  // Instantiate the initializer.
4880  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4881  /*CXXDirectInit=*/true);
4882  if (TempInit.isInvalid()) {
4883  AnyErrors = true;
4884  break;
4885  }
4886 
4887  // Instantiate the base type.
4888  TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
4889  TemplateArgs,
4890  Init->getSourceLocation(),
4891  New->getDeclName());
4892  if (!BaseTInfo) {
4893  AnyErrors = true;
4894  break;
4895  }
4896 
4897  // Build the initializer.
4898  MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
4899  BaseTInfo, TempInit.get(),
4900  New->getParent(),
4901  SourceLocation());
4902  if (NewInit.isInvalid()) {
4903  AnyErrors = true;
4904  break;
4905  }
4906 
4907  NewInits.push_back(NewInit.get());
4908  }
4909 
4910  continue;
4911  }
4912 
4913  // Instantiate the initializer.
4914  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4915  /*CXXDirectInit=*/true);
4916  if (TempInit.isInvalid()) {
4917  AnyErrors = true;
4918  continue;
4919  }
4920 
4921  MemInitResult NewInit;
4922  if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4923  TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4924  TemplateArgs,
4925  Init->getSourceLocation(),
4926  New->getDeclName());
4927  if (!TInfo) {
4928  AnyErrors = true;
4929  New->setInvalidDecl();
4930  continue;
4931  }
4932 
4933  if (Init->isBaseInitializer())
4934  NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
4935  New->getParent(), EllipsisLoc);
4936  else
4937  NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
4938  cast<CXXRecordDecl>(CurContext->getParent()));
4939  } else if (Init->isMemberInitializer()) {
4940  FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
4941  Init->getMemberLocation(),
4942  Init->getMember(),
4943  TemplateArgs));
4944  if (!Member) {
4945  AnyErrors = true;
4946  New->setInvalidDecl();
4947  continue;
4948  }
4949 
4950  NewInit = BuildMemberInitializer(Member, TempInit.get(),
4951  Init->getSourceLocation());
4952  } else if (Init->isIndirectMemberInitializer()) {
4953  IndirectFieldDecl *IndirectMember =
4954  cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
4955  Init->getMemberLocation(),
4956  Init->getIndirectMember(), TemplateArgs));
4957 
4958  if (!IndirectMember) {
4959  AnyErrors = true;
4960  New->setInvalidDecl();
4961  continue;
4962  }
4963 
4964  NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
4965  Init->getSourceLocation());
4966  }
4967 
4968  if (NewInit.isInvalid()) {
4969  AnyErrors = true;
4970  New->setInvalidDecl();
4971  } else {
4972  NewInits.push_back(NewInit.get());
4973  }
4974  }
4975 
4976  // Assign all the initializers to the new constructor.
4977  ActOnMemInitializers(New,
4978  /*FIXME: ColonLoc */
4979  SourceLocation(),
4980  NewInits,
4981  AnyErrors);
4982 }
4983 
4984 // TODO: this could be templated if the various decl types used the
4985 // same method name.
4987  ClassTemplateDecl *Instance) {
4988  Pattern = Pattern->getCanonicalDecl();
4989 
4990  do {
4991  Instance = Instance->getCanonicalDecl();
4992  if (Pattern == Instance) return true;
4993  Instance = Instance->getInstantiatedFromMemberTemplate();
4994  } while (Instance);
4995 
4996  return false;
4997 }
4998 
5000  FunctionTemplateDecl *Instance) {
5001  Pattern = Pattern->getCanonicalDecl();
5002 
5003  do {
5004  Instance = Instance->getCanonicalDecl();
5005  if (Pattern == Instance) return true;
5006  Instance = Instance->getInstantiatedFromMemberTemplate();
5007  } while (Instance);
5008 
5009  return false;
5010 }
5011 
5012 static bool
5015  Pattern
5016  = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
5017  do {
5018  Instance = cast<ClassTemplatePartialSpecializationDecl>(
5019  Instance->getCanonicalDecl());
5020  if (Pattern == Instance)
5021  return true;
5022  Instance = Instance->getInstantiatedFromMember();
5023  } while (Instance);
5024 
5025  return false;
5026 }
5027 
5028 static bool isInstantiationOf(CXXRecordDecl *Pattern,
5029  CXXRecordDecl *Instance) {
5030  Pattern = Pattern->getCanonicalDecl();
5031 
5032  do {
5033  Instance = Instance->getCanonicalDecl();
5034  if (Pattern == Instance) return true;
5035  Instance = Instance->getInstantiatedFromMemberClass();
5036  } while (Instance);
5037 
5038  return false;
5039 }
5040 
5041 static bool isInstantiationOf(FunctionDecl *Pattern,
5042  FunctionDecl *Instance) {
5043  Pattern = Pattern->getCanonicalDecl();
5044 
5045  do {
5046  Instance = Instance->getCanonicalDecl();
5047  if (Pattern == Instance) return true;
5048  Instance = Instance->getInstantiatedFromMemberFunction();
5049  } while (Instance);
5050 
5051  return false;
5052 }
5053 
5054 static bool isInstantiationOf(EnumDecl *Pattern,
5055  EnumDecl *Instance) {
5056  Pattern = Pattern->getCanonicalDecl();
5057 
5058  do {
5059  Instance = Instance->getCanonicalDecl();
5060  if (Pattern == Instance) return true;
5061  Instance = Instance->getInstantiatedFromMemberEnum();
5062  } while (Instance);
5063 
5064  return false;
5065 }
5066 
5067 static bool isInstantiationOf(UsingShadowDecl *Pattern,
5068  UsingShadowDecl *Instance,
5069  ASTContext &C) {
5071  Pattern);
5072 }
5073 
5074 static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
5075  ASTContext &C) {
5076  return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
5077 }
5078 
5079 template<typename T>
5080 static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
5081  ASTContext &Ctx) {
5082  // An unresolved using declaration can instantiate to an unresolved using
5083  // declaration, or to a using declaration or a using declaration pack.
5084  //
5085  // Multiple declarations can claim to be instantiated from an unresolved
5086  // using declaration if it's a pack expansion. We want the UsingPackDecl
5087  // in that case, not the individual UsingDecls within the pack.
5088  bool OtherIsPackExpansion;
5089  NamedDecl *OtherFrom;
5090  if (auto *OtherUUD = dyn_cast<T>(Other)) {
5091  OtherIsPackExpansion = OtherUUD->isPackExpansion();
5092  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
5093  } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
5094  OtherIsPackExpansion = true;
5095  OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
5096  } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
5097  OtherIsPackExpansion = false;
5098  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
5099  } else {
5100  return false;
5101  }
5102  return Pattern->isPackExpansion() == OtherIsPackExpansion &&
5103  declaresSameEntity(OtherFrom, Pattern);
5104 }
5105 
5107  VarDecl *Instance) {
5108  assert(Instance->isStaticDataMember());
5109 
5110  Pattern = Pattern->getCanonicalDecl();
5111 
5112  do {
5113  Instance = Instance->getCanonicalDecl();
5114  if (Pattern == Instance) return true;
5115  Instance = Instance->getInstantiatedFromStaticDataMember();
5116  } while (Instance);
5117 
5118  return false;
5119 }
5120 
5121 // Other is the prospective instantiation
5122 // D is the prospective pattern
5123 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
5124  if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
5125  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
5126 
5127  if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
5128  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
5129 
5130  if (D->getKind() != Other->getKind())
5131  return false;
5132 
5133  if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
5134  return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
5135 
5136  if (auto *Function = dyn_cast<FunctionDecl>(Other))
5137  return isInstantiationOf(cast<FunctionDecl>(D), Function);
5138 
5139  if (auto *Enum = dyn_cast<EnumDecl>(Other))
5140  return isInstantiationOf(cast<EnumDecl>(D), Enum);
5141 
5142  if (auto *Var = dyn_cast<VarDecl>(Other))
5143  if (Var->isStaticDataMember())
5144  return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
5145 
5146  if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
5147  return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
5148 
5149  if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
5150  return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
5151 
5152  if (auto *PartialSpec =
5153  dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
5154  return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
5155  PartialSpec);
5156 
5157  if (auto *Field = dyn_cast<FieldDecl>(Other)) {
5158  if (!Field->getDeclName()) {
5159  // This is an unnamed field.
5161  cast<FieldDecl>(D));
5162  }
5163  }
5164 
5165  if (auto *Using = dyn_cast<UsingDecl>(Other))
5166  return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
5167 
5168  if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
5169  return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
5170 
5171  return D->getDeclName() &&
5172  D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
5173 }
5174 
5175 template<typename ForwardIterator>
5177  NamedDecl *D,
5178  ForwardIterator first,
5179  ForwardIterator last) {
5180  for (; first != last; ++first)
5181  if (isInstantiationOf(Ctx, D, *first))
5182  return cast<NamedDecl>(*first);
5183 
5184  return nullptr;
5185 }
5186 
5187 /// Finds the instantiation of the given declaration context
5188 /// within the current instantiation.
5189 ///
5190 /// \returns NULL if there was an error
5192  const MultiLevelTemplateArgumentList &TemplateArgs) {
5193  if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
5194  Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
5195  return cast_or_null<DeclContext>(ID);
5196  } else return DC;
5197 }
5198 
5199 /// Find the instantiation of the given declaration within the
5200 /// current instantiation.
5201 ///
5202 /// This routine is intended to be used when \p D is a declaration
5203 /// referenced from within a template, that needs to mapped into the
5204 /// corresponding declaration within an instantiation. For example,
5205 /// given:
5206 ///
5207 /// \code
5208 /// template<typename T>
5209 /// struct X {
5210 /// enum Kind {
5211 /// KnownValue = sizeof(T)
5212 /// };
5213 ///
5214 /// bool getKind() const { return KnownValue; }
5215 /// };
5216 ///
5217 /// template struct X<int>;
5218 /// \endcode
5219 ///
5220 /// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
5221 /// \p EnumConstantDecl for \p KnownValue (which refers to
5222 /// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
5223 /// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
5224 /// this mapping from within the instantiation of <tt>X<int></tt>.
5226  const MultiLevelTemplateArgumentList &TemplateArgs,
5227  bool FindingInstantiatedContext) {
5228  DeclContext *ParentDC = D->getDeclContext();
5229  // FIXME: Parmeters of pointer to functions (y below) that are themselves
5230  // parameters (p below) can have their ParentDC set to the translation-unit
5231  // - thus we can not consistently check if the ParentDC of such a parameter
5232  // is Dependent or/and a FunctionOrMethod.
5233  // For e.g. this code, during Template argument deduction tries to
5234  // find an instantiated decl for (T y) when the ParentDC for y is
5235  // the translation unit.
5236  // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
5237  // float baz(float(*)()) { return 0.0; }
5238  // Foo(baz);
5239  // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
5240  // it gets here, always has a FunctionOrMethod as its ParentDC??
5241  // For now:
5242  // - as long as we have a ParmVarDecl whose parent is non-dependent and
5243  // whose type is not instantiation dependent, do nothing to the decl
5244  // - otherwise find its instantiated decl.
5245  if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
5246  !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
5247  return D;
5248  if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
5249  isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
5250  ((ParentDC->isFunctionOrMethod() ||
5251  isa<OMPDeclareReductionDecl>(ParentDC) ||
5252  isa<OMPDeclareMapperDecl>(ParentDC)) &&
5253  ParentDC->isDependentContext()) ||
5254  (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
5255  // D is a local of some kind. Look into the map of local
5256  // declarations to their instantiations.
5257  if (CurrentInstantiationScope) {
5258  if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
5259  if (Decl *FD = Found->dyn_cast<Decl *>())
5260  return cast<NamedDecl>(FD);
5261 
5262  int PackIdx = ArgumentPackSubstitutionIndex;
5263  assert(PackIdx != -1 &&
5264  "found declaration pack but not pack expanding");
5265  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
5266  return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
5267  }
5268  }
5269 
5270  // If we're performing a partial substitution during template argument
5271  // deduction, we may not have values for template parameters yet. They
5272  // just map to themselves.
5273  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
5274  isa<TemplateTemplateParmDecl>(D))
5275  return D;
5276 
5277  if (D->isInvalidDecl())
5278  return nullptr;
5279 
5280  // Normally this function only searches for already instantiated declaration
5281  // however we have to make an exclusion for local types used before
5282  // definition as in the code:
5283  //
5284  // template<typename T> void f1() {
5285  // void g1(struct x1);
5286  // struct x1 {};
5287  // }
5288  //
5289  // In this case instantiation of the type of 'g1' requires definition of
5290  // 'x1', which is defined later. Error recovery may produce an enum used
5291  // before definition. In these cases we need to instantiate relevant
5292  // declarations here.
5293  bool NeedInstantiate = false;
5294  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
5295  NeedInstantiate = RD->isLocalClass();
5296  else
5297  NeedInstantiate = isa<EnumDecl>(D);
5298  if (NeedInstantiate) {
5299  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
5300  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
5301  return cast<TypeDecl>(Inst);
5302  }
5303 
5304  // If we didn't find the decl, then we must have a label decl that hasn't
5305  // been found yet. Lazily instantiate it and return it now.
5306  assert(isa<LabelDecl>(D));
5307 
5308  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
5309  assert(Inst && "Failed to instantiate label??");
5310 
5311  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
5312  return cast<LabelDecl>(Inst);
5313  }
5314 
5315  // For variable template specializations, update those that are still
5316  // type-dependent.
5317  if (VarTemplateSpecializationDecl *VarSpec =
5318  dyn_cast<VarTemplateSpecializationDecl>(D)) {
5319  bool InstantiationDependent = false;
5320  const TemplateArgumentListInfo &VarTemplateArgs =
5321  VarSpec->getTemplateArgsInfo();
5323  VarTemplateArgs, InstantiationDependent))
5324  D = cast<NamedDecl>(
5325  SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
5326  return D;
5327  }
5328 
5329  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
5330  if (!Record->isDependentContext())
5331  return D;
5332 
5333  // Determine whether this record is the "templated" declaration describing
5334  // a class template or class template partial specialization.
5335  ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
5336  if (ClassTemplate)
5337  ClassTemplate = ClassTemplate->getCanonicalDecl();
5338  else if (ClassTemplatePartialSpecializationDecl *PartialSpec
5339  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
5340  ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
5341 
5342  // Walk the current context to find either the record or an instantiation of
5343  // it.
5344  DeclContext *DC = CurContext;
5345  while (!DC->isFileContext()) {
5346  // If we're performing substitution while we're inside the template
5347  // definition, we'll find our own context. We're done.
5348  if (DC->Equals(Record))
5349  return Record;
5350 
5351  if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
5352  // Check whether we're in the process of instantiating a class template
5353  // specialization of the template we're mapping.
5354  if (ClassTemplateSpecializationDecl *InstSpec
5355  = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
5356  ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
5357  if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
5358  return InstRecord;
5359  }
5360 
5361  // Check whether we're in the process of instantiating a member class.
5362  if (isInstantiationOf(Record, InstRecord))
5363  return InstRecord;
5364  }
5365 
5366  // Move to the outer template scope.
5367  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
5368  if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
5369  DC = FD->getLexicalDeclContext();
5370  continue;
5371  }
5372  // An implicit deduction guide acts as if it's within the class template
5373  // specialization described by its name and first N template params.
5374  auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
5375  if (Guide && Guide->isImplicit()) {
5376  TemplateDecl *TD = Guide->getDeducedTemplate();
5377  // Convert the arguments to an "as-written" list.
5378  TemplateArgumentListInfo Args(Loc, Loc);
5379  for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
5380  TD->getTemplateParameters()->size())) {
5381  ArrayRef<TemplateArgument> Unpacked(Arg);
5382  if (Arg.getKind() == TemplateArgument::Pack)
5383  Unpacked = Arg.pack_elements();
5384  for (TemplateArgument UnpackedArg : Unpacked)
5385  Args.addArgument(
5386  getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
5387  }
5388  QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
5389  if (T.isNull())
5390  return nullptr;
5391  auto *SubstRecord = T->getAsCXXRecordDecl();
5392  assert(SubstRecord && "class template id not a class type?");
5393  // Check that this template-id names the primary template and not a
5394  // partial or explicit specialization. (In the latter cases, it's
5395  // meaningless to attempt to find an instantiation of D within the
5396  // specialization.)
5397  // FIXME: The standard doesn't say what should happen here.
5398  if (FindingInstantiatedContext &&
5399  usesPartialOrExplicitSpecialization(
5400  Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
5401  Diag(Loc, diag::err_specialization_not_primary_template)
5402  << T << (SubstRecord->getTemplateSpecializationKind() ==
5404  return nullptr;
5405  }
5406  DC = SubstRecord;
5407  continue;
5408  }
5409  }
5410 
5411  DC = DC->getParent();
5412  }
5413 
5414  // Fall through to deal with other dependent record types (e.g.,
5415  // anonymous unions in class templates).
5416  }
5417 
5418  if (!ParentDC->isDependentContext())
5419  return D;
5420 
5421  ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
5422  if (!ParentDC)
5423  return nullptr;
5424 
5425  if (ParentDC != D->getDeclContext()) {
5426  // We performed some kind of instantiation in the parent context,
5427  // so now we need to look into the instantiated parent context to
5428  // find the instantiation of the declaration D.
5429 
5430  // If our context used to be dependent, we may need to instantiate
5431  // it before performing lookup into that context.
5432  bool IsBeingInstantiated = false;
5433  if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
5434  if (!Spec->isDependentContext()) {
5435  QualType T = Context.getTypeDeclType(Spec);
5436  const RecordType *Tag = T->getAs<RecordType>();
5437  assert(Tag && "type of non-dependent record is not a RecordType");
5438  if (Tag->isBeingDefined())
5439  IsBeingInstantiated = true;
5440  if (!Tag->isBeingDefined() &&
5441  RequireCompleteType(Loc, T, diag::err_incomplete_type))
5442  return nullptr;
5443 
5444  ParentDC = Tag->getDecl();
5445  }
5446  }
5447 
5448  NamedDecl *Result = nullptr;
5449  // FIXME: If the name is a dependent name, this lookup won't necessarily
5450  // find it. Does that ever matter?
5451  if (auto Name = D->getDeclName()) {
5452  DeclarationNameInfo NameInfo(Name, D->getLocation());
5453  Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
5454  if (!Name)
5455  return nullptr;
5456  DeclContext::lookup_result Found = ParentDC->lookup(Name);
5457  Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
5458  } else {
5459  // Since we don't have a name for the entity we're looking for,
5460  // our only option is to walk through all of the declarations to
5461  // find that name. This will occur in a few cases:
5462  //
5463  // - anonymous struct/union within a template
5464  // - unnamed class/struct/union/enum within a template
5465  //
5466  // FIXME: Find a better way to find these instantiations!
5467  Result = findInstantiationOf(Context, D,
5468  ParentDC->decls_begin(),
5469  ParentDC->decls_end());
5470  }
5471 
5472  if (!Result) {
5473  if (isa<UsingShadowDecl>(D)) {
5474  // UsingShadowDecls can instantiate to nothing because of using hiding.
5475  } else if (Diags.hasErrorOccurred()) {
5476  // We've already complained about something, so most likely this
5477  // declaration failed to instantiate. There's no point in complaining
5478  // further, since this is normal in invalid code.
5479  } else if (IsBeingInstantiated) {
5480  // The class in which this member exists is currently being
5481  // instantiated, and we haven't gotten around to instantiating this
5482  // member yet. This can happen when the code uses forward declarations
5483  // of member classes, and introduces ordering dependencies via
5484  // template instantiation.
5485  Diag(Loc, diag::err_member_not_yet_instantiated)
5486  << D->getDeclName()
5487  << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
5488  Diag(D->getLocation(), diag::note_non_instantiated_member_here);
5489  } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
5490  // This enumeration constant was found when the template was defined,
5491  // but can't be found in the instantiation. This can happen if an
5492  // unscoped enumeration member is explicitly specialized.
5493  EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
5494  EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
5495  TemplateArgs));
5496  assert(Spec->getTemplateSpecializationKind() ==
5498  Diag(Loc, diag::err_enumerator_does_not_exist)
5499  << D->getDeclName()
5500  << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
5501  Diag(Spec->getLocation(), diag::note_enum_specialized_here)
5502  << Context.getTypeDeclType(Spec);
5503  } else {
5504  // We should have found something, but didn't.
5505  llvm_unreachable("Unable to find instantiation of declaration!");
5506  }
5507  }
5508 
5509  D = Result;
5510  }
5511 
5512  return D;
5513 }
5514 
5515 /// Performs template instantiation for all implicit template
5516 /// instantiations we have seen until this point.
5518  while (!PendingLocalImplicitInstantiations.empty() ||
5519  (!LocalOnly && !PendingInstantiations.empty())) {
5521 
5522  if (PendingLocalImplicitInstantiations.empty()) {
5523  Inst = PendingInstantiations.front();
5524  PendingInstantiations.pop_front();
5525  } else {
5526  Inst = PendingLocalImplicitInstantiations.front();
5527  PendingLocalImplicitInstantiations.pop_front();
5528  }
5529 
5530  // Instantiate function definitions
5531  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
5532  bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
5534  if (Function->isMultiVersion()) {
5535  getASTContext().forEachMultiversionedFunctionVersion(
5536  Function, [this, Inst, DefinitionRequired](FunctionDecl *CurFD) {
5537  InstantiateFunctionDefinition(/*FIXME:*/ Inst.second, CurFD, true,
5538  DefinitionRequired, true);
5539  if (CurFD->isDefined())
5540  CurFD->setInstantiationIsPending(false);
5541  });
5542  } else {
5543  InstantiateFunctionDefinition(/*FIXME:*/ Inst.second, Function, true,
5544  DefinitionRequired, true);
5545  if (Function->isDefined())
5546  Function->setInstantiationIsPending(false);
5547  }
5548  continue;
5549  }
5550 
5551  // Instantiate variable definitions
5552  VarDecl *Var = cast<VarDecl>(Inst.first);
5553 
5554  assert((Var->isStaticDataMember() ||
5555  isa<VarTemplateSpecializationDecl>(Var)) &&
5556  "Not a static data member, nor a variable template"
5557  " specialization?");
5558 
5559  // Don't try to instantiate declarations if the most recent redeclaration
5560  // is invalid.
5561  if (Var->getMostRecentDecl()->isInvalidDecl())
5562  continue;
5563 
5564  // Check if the most recent declaration has changed the specialization kind
5565  // and removed the need for implicit instantiation.
5566  switch (Var->getMostRecentDecl()
5568  case TSK_Undeclared:
5569  llvm_unreachable("Cannot instantitiate an undeclared specialization.");
5572  continue; // No longer need to instantiate this type.
5574  // We only need an instantiation if the pending instantiation *is* the
5575  // explicit instantiation.
5576  if (Var != Var->getMostRecentDecl())
5577  continue;
5578  break;
5580  break;
5581  }
5582 
5583  PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
5584  "instantiating variable definition");
5585  bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
5587 
5588  // Instantiate static data member definitions or variable template
5589  // specializations.
5590  InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
5591  DefinitionRequired, true);
5592  }
5593 }
5594 
5596  const MultiLevelTemplateArgumentList &TemplateArgs) {
5597  for (auto DD : Pattern->ddiags()) {
5598  switch (DD->getKind()) {
5600  HandleDependentAccessCheck(*DD, TemplateArgs);
5601  break;
5602  }
5603  }
5604 }
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2536
clauselist_range clauselists()
Definition: DeclOpenMP.h:270
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
Definition: Sema.h:3281
Defines the clang::ASTContext interface.
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition: Decl.h:1969
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 ...
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:3277
bool mightBeUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value might be usable in a constant expression, according to the re...
Definition: Decl.cpp:2248
void setImplicit(bool I=true)
Definition: DeclBase.h:559
Represents a function declaration or definition.
Definition: Decl.h:1748
NamespaceDecl * getStdNamespace() const
OMPDeclareMapperDecl * getPrevDeclInScope()
Get reference to previous declare mapper construct in the same scope with the same name...
Definition: DeclOpenMP.cpp:218
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=CSK_unspecified)
Definition: Decl.h:1895
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
OMPDeclareMapperDecl * ActOnOpenMPDeclareMapperDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)
Called on start of &#39;#pragma omp declare mapper&#39;.
virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D)
HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.
Definition: ASTConsumer.h:111
PtrTy get() const
Definition: Ownership.h:80
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
A (possibly-)qualified type.
Definition: Type.h:643
void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
const char * getDeclKindName() const
Definition: DeclBase.cpp:122
void InstantiatedLocal(const Decl *D, Decl *Inst)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
Decl * VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate, ArrayRef< BindingDecl *> *Bindings=nullptr)
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2403
Decl * VisitCXXMethodDecl(CXXMethodDecl *D, TemplateParameterList *TemplateParams, Optional< const ASTTemplateArgumentListInfo *> ClassScopeSpecializationArgs=llvm::None)
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:227
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:405
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
void EndOpenMPDSABlock(Stmt *CurDirective)
Called on end of data sharing attribute block.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained)...
Definition: Sema.h:7641
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3224
SourceRange getBraceRange() const
Definition: Decl.h:3178
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2248
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
static void instantiateDependentAllocAlignAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AllocAlignAttr *Align, Decl *New)
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2740
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:531
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:133
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Expr * getUnderlyingExpr() const
Definition: Type.h:4324
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl *> CH)
Definition: Decl.cpp:4656
Stmt - This represents one statement.
Definition: Stmt.h:66
Expr * getBitWidth() const
Definition: Decl.h:2696
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:6776
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4355
This represents &#39;#pragma omp allocate ...&#39; directive.
Definition: DeclOpenMP.h:422
const ASTTemplateArgumentListInfo * getTemplateSpecializationArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
Definition: Decl.cpp:3562
Provides information about an attempted template argument deduction, whose success or failure was des...
static bool isDeclWithinFunction(const Decl *D)
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function...
Definition: Decl.cpp:3728
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2819
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1019
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:4021
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3051
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
void AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr, unsigned SpellingListIndex)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList &TemplateArgList, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, void *InsertPos, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
bool isSingleTagDecl() const
Asks if the result is a single tag decl.
Definition: Lookup.h:530
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation)
Builds a using declaration.
const Type * getTypeForDecl() const
Definition: Decl.h:2931
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1362
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1922
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:421
static Expr * instantiateDependentFunctionAttrCondition(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New)
IdentifierInfo * getGetterId() const
Definition: DeclCXX.h:4081
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2166
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1028
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
bool hasWrittenPrototype() const
Whether this function has a written prototype.
Definition: Decl.h:2086
Decl * VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *FromVar, void *InsertPos, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef< TemplateArgument > Converted, VarTemplateSpecializationDecl *PrevDecl=nullptr)
Decl * InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7584
Not a friend object.
Definition: DeclBase.h:1102
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:960
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6333
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
Definition: DeclCXX.h:154
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement...
Definition: Decl.h:1339
ExplicitSpecKind getKind() const
Definition: DeclCXX.h:2009
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:7998
Declaration of a variable template.
void ActOnOpenMPDeclareMapperDirectiveVarDecl(OMPDeclareMapperDecl *DMD, Scope *S, QualType MapperType, SourceLocation StartLoc, DeclarationName VN)
Build the mapper variable of &#39;#pragma omp declare mapper&#39;.
Represent a C++ namespace.
Definition: Decl.h:514
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:425
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
Definition: Type.h:3653
A container of type source information.
Definition: Decl.h:86
Store information needed for an explicit specifier.
Definition: DeclCXX.h:2001
Wrapper for void* pointer.
Definition: Ownership.h:50
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
Definition: Sema.h:7943
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
clauselist_iterator clauselist_begin()
Definition: DeclOpenMP.h:276
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument&#39;s source information, if any.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2797
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:2758
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1269
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &Converted, bool UpdateArgsWithConversions=true)
Check that the given template arguments can be be provided to the given template, converting the argu...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2574
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4771
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:15013
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2014
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.
static void instantiateDependentEnableIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New)
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
Definition: DeclCXX.h:3248
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3202
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name, unsigned SpellingListIndex, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a #pragma comment line.
Definition: Decl.h:139
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2463
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> Expansions)
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:124
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:574
unsigned getDepth() const
Get the nesting depth of the template parameter.
enumerator_range enumerators() const
Definition: Decl.h:3486
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:53
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:11259
Represents a variable declaration or definition.
Definition: Decl.h:812
QualType getReturnType() const
Definition: Decl.h:2329
bool SubstQualifier(const DeclaratorDecl *OldDecl, DeclaratorDecl *NewDecl)
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3562
static void instantiateDependentAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion)
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Extra information about a function prototype.
Definition: Type.h:3799
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:221
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:3025
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition: Sema.h:5584
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:5351
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
static void instantiateDependentCUDALaunchBoundsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const CUDALaunchBoundsAttr &Attr, Decl *New)
reference front() const
Definition: DeclBase.h:1242
bool isInvalidDecl() const
Definition: DeclBase.h:553
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:67
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7466
static void instantiateDependentAssumeAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AssumeAlignedAttr *Aligned, Decl *New)
bool isStatic() const
Definition: DeclCXX.cpp:1938
Look up an ordinary name that is going to be redeclared as a name with linkage.
Definition: Sema.h:3253
Represents a parameter to a function.
Definition: Decl.h:1564
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:163
Defines the clang::Expr interface and subclasses for C++ expressions.
long i
Definition: xmmintrin.h:1456
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:728
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
The collection of all-type qualifiers we support.
Definition: Type.h:137
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation)
Definition: DeclCXX.cpp:2009
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1660
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, ArrayRef< std::pair< QualType, SourceLocation >> ReductionTypes, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)
Called on start of &#39;#pragma omp declare reduction&#39;.
DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef< Expr *> Uniforms, ArrayRef< Expr *> Aligneds, ArrayRef< Expr *> Alignments, ArrayRef< Expr *> Linears, ArrayRef< unsigned > LinModifiers, ArrayRef< Expr *> Steps, SourceRange SR)
Called on well-formed &#39;#pragma omp declare simd&#39; after parsing of the associated method/function.
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
Definition: SemaExpr.cpp:16587
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:334
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
Represents a struct/union/class.
Definition: Decl.h:3626
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3529
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3800
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:1054
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7914
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:123
unsigned getDepth() const
Retrieve the depth of the template parameter.
StringLiteral * getMessage()
Definition: DeclCXX.h:3908
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
DeclGroupPtrTy ActOnOpenMPDeclareMapperDirectiveEnd(OMPDeclareMapperDecl *D, Scope *S, ArrayRef< OMPClause *> ClauseList)
Called at the end of &#39;#pragma omp declare mapper&#39;.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A C++ nested-name-specifier augmented with source location information.
ExprResult ExprEmpty()
Definition: Ownership.h:285
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3928
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1195
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3229
ConstexprSpecKind getConstexprKind() const
Definition: Decl.h:2114
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
Definition: SemaDecl.cpp:14218
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3356
void setObjCForDecl(bool FRD)
Definition: Decl.h:1353
NameKind getNameKind() const
Determine what kind of name this is.
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl *> Bindings)
Definition: DeclCXX.cpp:2985
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
Definition: Decl.h:2242
Represents a member of a struct/union/class.
Definition: Decl.h:2607
The current expression is potentially evaluated at run time, which means that code may be generated t...
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
unsigned getStaticLocalNumber(const VarDecl *VD) const
bool isNamespace() const
Definition: DeclBase.h:1863
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:780
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template...
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:4030
void StartOpenMPDSABlock(OpenMPDirectiveKind K, const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc)
Called on start of new data sharing attribute block.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
bool isReferenceType() const
Definition: Type.h:6396
InitKind getInitializerKind() const
Get initializer kind.
Definition: DeclOpenMP.h:173
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:138
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:803
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1443
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1903
QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in &#39;omp declare mapper&#39; construct.
void Exit()
Exit this local instantiation scope early.
Definition: Template.h:307
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...
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:132
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:738
Declaration of a function specialization at template class scope.
static void instantiateDependentAMDGPUWavesPerEUAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUWavesPerEUAttr &Attr, Decl *New)
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration&#39;s previous declaration was declared in the same block ...
Definition: Decl.h:1409
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Definition: SemaDecl.cpp:6319
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2289
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2526
void InstantiateMemInitializers(CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl, const MultiLevelTemplateArgumentList &TemplateArgs)
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
SourceLocation getLAngleLoc() const
Definition: TypeLoc.h:1599
Expr * getMapperVarRef()
Get the variable declared in the mapper.
Definition: DeclOpenMP.h:282
Represents a C++ using-declaration.
Definition: DeclCXX.h:3488
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4022
static void instantiateDependentDiagnoseIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New)
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:170
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1921
Represents the results of name lookup.
Definition: Lookup.h:46
PtrTy get() const
Definition: Ownership.h:170
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2808
TagKind getTagKind() const
Definition: Decl.h:3276
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:422
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Look up all declarations in a scope with the given name, including resolved using declarations...
Definition: Sema.h:3248
bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3444
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2880
bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl)
Initializes the common fields of an instantiation function declaration (New) from the corresponding f...
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:2934
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1859
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2505
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
SourceLocation RAngleLoc
The source location of the right angle bracket (&#39;>&#39;).
Definition: TemplateBase.h:617
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:752
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1386
const TemplateArgumentLoc * getArgumentArray() const
Definition: TemplateBase.h:578
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void setSpecializationKind(TemplateSpecializationKind TSK)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:730
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1166
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3303
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
Definition: SemaDecl.cpp:2116
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1952
const LangOptions & getLangOpts() const
Definition: Sema.h:1285
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2743
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1627
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:919
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don&#39;t have one.
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:176
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3416
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor())
Definition: DeclCXX.cpp:2434
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:426
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1799
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
Definition: SemaDecl.cpp:12388
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3785
A binding in a decomposition declaration.
Definition: DeclCXX.h:3931
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3423
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Ordinary names.
Definition: DeclBase.h:146
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7655
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:3699
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a &#39;using&#39; declaration.
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:8023
VarDecl * ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1602
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:3913
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1289
NodeId Parent
Definition: ASTDiff.cpp:191
bool hasAttr() const
Definition: DeclBase.h:542
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3071
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1636
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3719
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition: Decl.h:2386
SourceLocation getTypenameLoc() const
Returns the source location of the &#39;typename&#39; keyword.
Definition: DeclCXX.h:3835
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1665
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5948
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:688
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:572
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...
static QualType adjustFunctionTypeForInstantiation(ASTContext &Context, FunctionDecl *D, TypeSourceInfo *TInfo)
Adjust the given function type for an instantiation of the given declaration, to cope with modificati...
DeclarationName getVarName()
Get the name of the variable declared in the mapper.
Definition: DeclOpenMP.h:288
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
Definition: Template.h:94
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
bool isInlineSpecified() const
Definition: Decl.h:1371
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:152
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2999
This represents &#39;#pragma omp requires...&#39; directive.
Definition: DeclOpenMP.h:345
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:2572
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
Definition: Template.h:154
void CheckAlignasUnderalignment(Decl *D)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:436
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation)
Definition: DeclCXX.cpp:2603
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2377
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3376
This represents one expression.
Definition: Expr.h:108
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3528
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
unsigned getChainingSize() const
Definition: Decl.h:2886
SourceLocation getAliasLoc() const
Returns the location of the alias name, i.e.
Definition: DeclCXX.h:3242
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2048
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3556
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner)
Finish current declare reduction construct initializer.
StateNode * Previous
Declaration of a template type parameter.
OMPThreadPrivateDecl * CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef< Expr *> VarList)
Builds a new OpenMPThreadPrivateDecl and checks its correctness.
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3535
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: TemplateBase.h:620
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:288
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
OMPDeclareReductionDecl * getPrevDeclInScope()
Get reference to previous declare reduction construct in the same scope with the same name...
Definition: DeclOpenMP.cpp:158
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6916
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7788
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
static DeclT * getPreviousDeclForInstantiation(DeclT *D)
Get the previous declaration of a declaration for the purposes of template instantiation.
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2838
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1997
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:131
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1060
bool isFileContext() const
Definition: DeclBase.h:1849
TemplateParameterList * getTemplateParameterList(unsigned index) const
Definition: Decl.h:763
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
Definition: DeclBase.h:438
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:771
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:2211
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2366
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:268
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:187
Represents the type decltype(expr) (C++11).
Definition: Type.h:4314
const Expr * getExpr() const
Definition: DeclCXX.h:2010
EnumDecl * getDefinition() const
Definition: Decl.h:3460
static void InstantiateDefaultCtorDefaultArgs(Sema &S, CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
Defines the clang::TypeLoc interface and its subclasses.
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3608
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:14836
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
Definition: Decl.cpp:2440
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:2209
void setConstexpr(bool IC)
Definition: Decl.h:1389
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
Definition: SemaDecl.cpp:15787
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
bool isFunctionOrMethod() const
Definition: DeclBase.h:1831
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
Definition: SemaDecl.cpp:14235
StorageClass
Storage classes.
Definition: Specifiers.h:234
IdentifierInfo * getSetterId() const
Definition: DeclCXX.h:4083
Declaration of an alias template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1779
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:64
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
QualType getRecordType(const RecordDecl *Decl) const
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
clauselist_range clauselists()
Definition: DeclOpenMP.h:502
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1382
void setLocation(SourceLocation L)
Definition: DeclBase.h:430
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1082
Expr * getInitPriv()
Get Priv variable of the initializer.
Definition: DeclOpenMP.h:180
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of a (possibly unresolved) using decl from a templat...
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:2056
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1661
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2899
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1398
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:180
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1283
static StringRef getIdentifier(const Token &Tok)
void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex)
AddAlignValueAttr - Adds an align_value attribute to a particular declaration.
static void instantiateOMPDeclareSimdDeclAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareSimdDeclAttr &Attr, Decl *New)
Instantiation of &#39;declare simd&#39; attribute and its arguments.
static void instantiateDependentModeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const ModeAttr &Attr, Decl *New)
DeclContext * FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, const MultiLevelTemplateArgumentList &TemplateArgs)
Finds the instantiation of the given declaration context within the current instantiation.
TypeSourceInfo * SubstFunctionType(FunctionDecl *D, SmallVectorImpl< ParmVarDecl *> &Params)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2060
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation. ...
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
Definition: Decl.h:1288
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1111
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:215
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:123
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:4214
RecordDecl * getDecl() const
Definition: Type.h:4448
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Definition: SemaDecl.cpp:13148
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:4282
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1792
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:2227
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3775
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1162
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
A stack object to be created when performing template instantiation.
Definition: Sema.h:7692
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3932
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
ASTContext & getASTContext() const
Definition: Sema.h:1292
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:34
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:294
bool isParameterPack() const
Returns whether this is a parameter pack.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3645
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2023
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1378
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:312
static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other, ASTContext &Ctx)
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2124
Attr * clone(ASTContext &C) const
static ExplicitSpecifier instantiateExplicitSpecifier(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, ExplicitSpecifier ES, FunctionDecl *New)
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:3127
DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, ArrayRef< Expr *> VarList, ArrayRef< OMPClause *> Clauses, DeclContext *Owner=nullptr)
Called on well-formed &#39;#pragma omp allocate&#39;.
unsigned getManglingNumber(const NamedDecl *ND) const
OMPClause * ActOnOpenMPAllocatorClause(Expr *Allocator, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed &#39;allocator&#39; clause.
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the &#39;typename&#39; keyword.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3097
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3521
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
void addAMDGPUFlatWorkGroupSizeAttr(SourceRange AttrRange, Decl *D, Expr *Min, Expr *Max, unsigned SpellingListIndex)
addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size attribute to a particular declar...
void setReferenced(bool R=true)
Definition: DeclBase.h:588
Represents the declaration of a label.
Definition: Decl.h:468
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3707
void setIsCopyDeductionCandidate(bool isCDC=true)
Definition: DeclCXX.h:2097
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
SourceLocation getFriendLoc() const
Retrieves the location of the &#39;friend&#39; keyword.
Definition: DeclFriend.h:143
static bool isInstantiationOf(ClassTemplateDecl *Pattern, ClassTemplateDecl *Instance)
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3961
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:3438
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
SourceLocation getIdentLocation() const
Returns the location of this using declaration&#39;s identifier.
Definition: DeclCXX.h:3130
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2312
static void instantiateDependentAlignValueAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignValueAttr *Aligned, Decl *New)
SourceLocation getLocation() const
Definition: Attr.h:93
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:3097
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:50
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3553
void setDeclName(DeclarationName N)
Set the name of this declaration.
Definition: Decl.h:300
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
const TemplateArgumentListInfo & getTemplateArgsInfo() const
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
ClassTemplateDecl * getMostRecentDecl()
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:702
void setMapperVarRef(Expr *MapperVarRefE)
Set the variable declared in the mapper.
Definition: DeclOpenMP.h:285
static ExplicitSpecifier Invalid()
Definition: DeclCXX.h:2041
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:778
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:192
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:177
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
Definition: DeclCXX.cpp:1908
SourceLocation getRAngleLoc() const
Definition: TypeLoc.h:1607
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2053
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1915
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3882
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5450
void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst)
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:573
SourceLocation getAccessSpecifierLoc() const
The location of the access specifier.
Definition: DeclCXX.h:148
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:98
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, Expr *AssociatedConstraints=nullptr)
Create a class template node.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2114
bool isTemplateTypeParmType() const
Definition: Type.h:6606
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3955
Expr * getInitOrig()
Get Orig variable of the initializer.
Definition: DeclOpenMP.h:177
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
Definition: Decl.h:2019
Represents a pack expansion of types.
Definition: Type.h:5425
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4727
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:3324
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
Definition: TemplateBase.h:626
ddiag_range ddiags() const
void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE, unsigned SpellingListIndex)
AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular declaration.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
Definition: Decl.cpp:2577
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2949
Represents a template argument.
Definition: TemplateBase.h:50
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
static bool isInvalid(LocType Loc, bool *Invalid)
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2670
bool isNull() const
Determine whether this template name is NULL.
static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function, const FunctionDecl *PatternDecl, LocalInstantiationScope &Scope, const MultiLevelTemplateArgumentList &TemplateArgs)
Introduce the instantiated function parameters into the local instantiation scope, and set the parameter names to those used in the template.
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:7649
ExtInfo getExtInfo() const
Definition: Type.h:3656
Decl * VisitFunctionDecl(FunctionDecl *D, TemplateParameterList *TemplateParams)
Normal class members are of more specific types and therefore don&#39;t make it here. ...
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:12910
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
not evaluated yet, for special member function
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:2027
LocalInstantiationScope * cloneScopes(LocalInstantiationScope *Outermost)
Clone this scope, and all outer scopes, down to the given outermost scope.
Definition: Template.h:320
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
void InstantiateVariableInitializer(VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the initializer of a variable.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:403
bool isRecord() const
Definition: DeclBase.h:1858
attr_range attrs() const
Definition: DeclBase.h:501
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2858
QualType getUnderlyingType() const
Definition: Decl.h:3004
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:3220
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1025
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
Definition: DeclCXX.h:3119
const Expr * getInit() const
Definition: Decl.h:1219
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
static NamedDecl * findInstantiationOf(ASTContext &Ctx, NamedDecl *D, ForwardIterator first, ForwardIterator last)
A decomposition declaration.
Definition: DeclCXX.h:3988
void addAMDGPUWavesPerEUAttr(SourceRange AttrRange, Decl *D, Expr *Min, Expr *Max, unsigned SpellingListIndex)
addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a particular declaration.
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:188
unsigned getIndex() const
Retrieve the index of the template parameter.
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3803
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3495
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2649
The name of a declaration.
void setInstantiationIsPending(bool IC)
State that the instantiation of this function is pending.
Definition: Decl.h:2136
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.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2237
Kind getKind() const
Definition: DeclBase.h:432
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:1636
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:759
Represents an enum.
Definition: Decl.h:3359
SourceLocation LAngleLoc
The source location of the left angle bracket (&#39;<&#39;).
Definition: TemplateBase.h:614
void setInlineSpecified()
Definition: Decl.h:1375
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack...
Definition: Decl.cpp:2420
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:174
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid)
Called at the end of &#39;#pragma omp declare reduction&#39;.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1395
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1414
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition: Decl.cpp:4128
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6766
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
Definition: Decl.cpp:4525
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it&#39;s the object of a friend declaration...
Definition: DeclBase.h:1071
void setInitCapture(bool IC)
Definition: Decl.h:1398
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it&#39;s a function-local extern declaration...
Definition: DeclBase.h:1042
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
void setImplicitlyInline()
Definition: Decl.h:1380
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3789
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4438
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:573
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:4076
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:987
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Get the template specialization kind of this variable for the purposes of template instantiation...
Definition: Decl.cpp:2516
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:184
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:3108
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:1120
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1805
T * getAttr() const
Definition: DeclBase.h:538
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl *> Elements, Scope *S, const ParsedAttributesView &Attr)
Definition: SemaDecl.cpp:17139
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
Definition: SemaDecl.cpp:16689
bool isObjCForDecl() const
Determine whether this variable is a for-loop declaration for a for-in statement in Objective-C...
Definition: Decl.h:1349
bool isFunctionType() const
Definition: Type.h:6380
void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, VarDecl *OmpPrivParm)
Finish current declare reduction construct initializer.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2605
static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:715
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in &#39;omp declare reduction&#39; construct.
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1342
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1514
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
Definition: DeclCXX.cpp:1648
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
Definition: TemplateBase.h:90
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Determine the kind of template specialization this function represents for the purpose of template in...
Definition: Decl.cpp:3655
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:3228
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3543
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:730
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:2955
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2391
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
RedeclarationKind forRedeclarationInCurContext()
Definition: Sema.h:3284
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2280
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
Definition: Sema.h:7792
A template argument list.
Definition: DeclTemplate.h:214
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:240
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
shadow_range shadows() const
Definition: DeclCXX.h:3588
QualType getParamType(unsigned i) const
Definition: Type.h:3923
Call-style initialization (C++98)
Definition: Decl.h:820
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:2011
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3307
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:10064
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2682
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
Definition: Decl.h:3197
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
Definition: Decl.cpp:2498
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:1024
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1329
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2541
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member...
Definition: Decl.cpp:2223
VarTemplateSpecializationDecl * CompleteVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiates a variable template specialization by completing it with appropriate type information an...
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1488
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4677
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:664
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:386
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:177
bool isFailed() const
Definition: DeclCXX.h:3911
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2846
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Declaration of a class template.
void addAttr(Attr *A)
Definition: DeclBase.cpp:829
SourceManager & getSourceManager() const
Definition: Sema.h:1290
This represents &#39;#pragma omp declare mapper ...&#39; directive.
Definition: DeclOpenMP.h:217
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, VarDecl *Instance)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:153
varlist_range varlists()
Definition: DeclOpenMP.h:491
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3751
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3513
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:3448
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
SourceLocation getLAngleLoc() const
Definition: TemplateBase.h:570
FriendDecl * CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo)
Perform semantic analysis of the given friend type declaration.
Expr * getCombinerIn()
Get In variable of the combiner.
Definition: DeclOpenMP.h:155
CanQualType IntTy
Definition: ASTContext.h:1023
static Sema::RetainOwnershipKind attrToRetainOwnershipKind(const Attr *A)
static OpaquePtr make(QualType P)
Definition: Ownership.h:60
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
The top declaration context.
Definition: Decl.h:107
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2108
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2163
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:538
bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD, CopyElisionSemanticsKind CESK)
Definition: SemaStmt.cpp:2939
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:2063
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.
This structure contains most locations needed for by an OMPVarListClause.
Definition: OpenMPClause.h:169
varlist_range varlists()
Definition: DeclOpenMP.h:77
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1134
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4059
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:3245
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluted - Return true if this expression might be usable in a constant expr...
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
QualType getType() const
Definition: Decl.h:647
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads, Expr *MinBlocks, unsigned SpellingListIndex)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration. ...
A trivial tuple used to represent a source range.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:298
ASTContext & Context
Definition: Sema.h:374
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3062
This represents a decl that may have a name.
Definition: Decl.h:248
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
Definition: Type.h:4017
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:468
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
Represents a C++ namespace alias.
Definition: DeclCXX.h:3156
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1368
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:280
Declaration of a friend template.
ArrayRef< NamedDecl * > expansions() const
Get the set of using declarations that this pack expanded into.
Definition: DeclCXX.h:3674
Represents C++ using-directive.
Definition: DeclCXX.h:3052
Represents a #pragma detect_mismatch line.
Definition: Decl.h:173
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:571
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
attr::Kind getKind() const
Definition: Attr.h:86
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...
Expr * getCombinerOut()
Get Out variable of the combiner.
Definition: DeclOpenMP.h:158
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3138
void setType(QualType newType)
Definition: Decl.h:648
bool hasInit() const
Definition: Decl.cpp:2198
static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New)
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:175
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:729
bool isInvalid() const
Return true if the ExplicitSpecifier isn&#39;t valid.
Definition: DeclCXX.h:2028
bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl)
Initializes common fields of an instantiated method declaration (New) from the corresponding fields o...
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2171
This represents &#39;#pragma omp threadprivate ...&#39; directive.
Definition: DeclOpenMP.h:39
RetainOwnershipKind
Definition: Sema.h:8879
bool isUnsupportedFriend() const
Determines if this friend kind is unsupported.
Definition: DeclFriend.h:174
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3805
Declaration of a template function.
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1754
Attr - This represents one attribute.
Definition: Attr.h:43
bool isDeletedAsWritten() const
Definition: Decl.h:2167
SourceLocation getLocation() const
Definition: DeclBase.h:429
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3275
Represents a pack of using declarations that a single using-declarator pack-expanded into...
Definition: DeclCXX.h:3638
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
void BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs, LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner, LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate=false, VarTemplateSpecializationDecl *PrevVTSD=nullptr)
BuildVariableInstantiation - Used after a new variable has been created.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
decl_iterator decls_end() const
Definition: DeclBase.h:2030
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1772
OMPClause * ActOnOpenMPMapClause(ArrayRef< OpenMPMapModifierKind > MapTypeModifiers, ArrayRef< SourceLocation > MapTypeModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef< Expr *> VarList, const OMPVarListLocTy &Locs, ArrayRef< Expr *> UnresolvedMappers=llvm::None)
Called on well-formed &#39;map&#39; clause.
A RAII object to temporarily push a declaration context.
Definition: Sema.h:768
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
Definition: SemaDecl.cpp:1776