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