Bug Summary

File:tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
Warning:line 4418, column 7
Called C++ object pointer is null

Annotated Source Code

/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

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

/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h

<
1//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_SEMA_SEMA_H
16#define LLVM_CLANG_SEMA_SEMA_H
17
18#include "clang/AST/Attr.h"
19#include "clang/AST/Availability.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprObjC.h"
24#include "clang/AST/ExternalASTSource.h"
25#include "clang/AST/LocInfoType.h"
26#include "clang/AST/MangleNumberingContext.h"
27#include "clang/AST/NSAPI.h"
28#include "clang/AST/PrettyPrinter.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/TypeLoc.h"
31#include "clang/AST/TypeOrdering.h"
32#include "clang/Basic/ExpressionTraits.h"
33#include "clang/Basic/LangOptions.h"
34#include "clang/Basic/Module.h"
35#include "clang/Basic/OpenMPKinds.h"
36#include "clang/Basic/PragmaKinds.h"
37#include "clang/Basic/Specifiers.h"
38#include "clang/Basic/TemplateKinds.h"
39#include "clang/Basic/TypeTraits.h"
40#include "clang/Sema/AnalysisBasedWarnings.h"
41#include "clang/Sema/CleanupInfo.h"
42#include "clang/Sema/DeclSpec.h"
43#include "clang/Sema/ExternalSemaSource.h"
44#include "clang/Sema/IdentifierResolver.h"
45#include "clang/Sema/ObjCMethodList.h"
46#include "clang/Sema/Ownership.h"
47#include "clang/Sema/Scope.h"
48#include "clang/Sema/ScopeInfo.h"
49#include "clang/Sema/TypoCorrection.h"
50#include "clang/Sema/Weak.h"
51#include "llvm/ADT/ArrayRef.h"
52#include "llvm/ADT/Optional.h"
53#include "llvm/ADT/SetVector.h"
54#include "llvm/ADT/SmallPtrSet.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/TinyPtrVector.h"
57#include <deque>
58#include <memory>
59#include <string>
60#include <vector>
61
62namespace llvm {
63 class APSInt;
64 template <typename ValueT> struct DenseMapInfo;
65 template <typename ValueT, typename ValueInfoT> class DenseSet;
66 class SmallBitVector;
67 struct InlineAsmIdentifierInfo;
68}
69
70namespace clang {
71 class ADLResult;
72 class ASTConsumer;
73 class ASTContext;
74 class ASTMutationListener;
75 class ASTReader;
76 class ASTWriter;
77 class ArrayType;
78 class AttributeList;
79 class BindingDecl;
80 class BlockDecl;
81 class CapturedDecl;
82 class CXXBasePath;
83 class CXXBasePaths;
84 class CXXBindTemporaryExpr;
85 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
86 class CXXConstructorDecl;
87 class CXXConversionDecl;
88 class CXXDeleteExpr;
89 class CXXDestructorDecl;
90 class CXXFieldCollector;
91 class CXXMemberCallExpr;
92 class CXXMethodDecl;
93 class CXXScopeSpec;
94 class CXXTemporary;
95 class CXXTryStmt;
96 class CallExpr;
97 class ClassTemplateDecl;
98 class ClassTemplatePartialSpecializationDecl;
99 class ClassTemplateSpecializationDecl;
100 class VarTemplatePartialSpecializationDecl;
101 class CodeCompleteConsumer;
102 class CodeCompletionAllocator;
103 class CodeCompletionTUInfo;
104 class CodeCompletionResult;
105 class CoroutineBodyStmt;
106 class Decl;
107 class DeclAccessPair;
108 class DeclContext;
109 class DeclRefExpr;
110 class DeclaratorDecl;
111 class DeducedTemplateArgument;
112 class DependentDiagnostic;
113 class DesignatedInitExpr;
114 class Designation;
115 class EnableIfAttr;
116 class EnumConstantDecl;
117 class Expr;
118 class ExtVectorType;
119 class FormatAttr;
120 class FriendDecl;
121 class FunctionDecl;
122 class FunctionProtoType;
123 class FunctionTemplateDecl;
124 class ImplicitConversionSequence;
125 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
126 class InitListExpr;
127 class InitializationKind;
128 class InitializationSequence;
129 class InitializedEntity;
130 class IntegerLiteral;
131 class LabelStmt;
132 class LambdaExpr;
133 class LangOptions;
134 class LocalInstantiationScope;
135 class LookupResult;
136 class MacroInfo;
137 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
138 class ModuleLoader;
139 class MultiLevelTemplateArgumentList;
140 class NamedDecl;
141 class ObjCCategoryDecl;
142 class ObjCCategoryImplDecl;
143 class ObjCCompatibleAliasDecl;
144 class ObjCContainerDecl;
145 class ObjCImplDecl;
146 class ObjCImplementationDecl;
147 class ObjCInterfaceDecl;
148 class ObjCIvarDecl;
149 template <class T> class ObjCList;
150 class ObjCMessageExpr;
151 class ObjCMethodDecl;
152 class ObjCPropertyDecl;
153 class ObjCProtocolDecl;
154 class OMPThreadPrivateDecl;
155 class OMPDeclareReductionDecl;
156 class OMPDeclareSimdDecl;
157 class OMPClause;
158 struct OverloadCandidate;
159 class OverloadCandidateSet;
160 class OverloadExpr;
161 class ParenListExpr;
162 class ParmVarDecl;
163 class Preprocessor;
164 class PseudoDestructorTypeStorage;
165 class PseudoObjectExpr;
166 class QualType;
167 class StandardConversionSequence;
168 class Stmt;
169 class StringLiteral;
170 class SwitchStmt;
171 class TemplateArgument;
172 class TemplateArgumentList;
173 class TemplateArgumentLoc;
174 class TemplateDecl;
175 class TemplateParameterList;
176 class TemplatePartialOrderingContext;
177 class TemplateTemplateParmDecl;
178 class Token;
179 class TypeAliasDecl;
180 class TypedefDecl;
181 class TypedefNameDecl;
182 class TypeLoc;
183 class TypoCorrectionConsumer;
184 class UnqualifiedId;
185 class UnresolvedLookupExpr;
186 class UnresolvedMemberExpr;
187 class UnresolvedSetImpl;
188 class UnresolvedSetIterator;
189 class UsingDecl;
190 class UsingShadowDecl;
191 class ValueDecl;
192 class VarDecl;
193 class VarTemplateSpecializationDecl;
194 class VisibilityAttr;
195 class VisibleDeclConsumer;
196 class IndirectFieldDecl;
197 struct DeductionFailureInfo;
198 class TemplateSpecCandidateSet;
199
200namespace sema {
201 class AccessedEntity;
202 class BlockScopeInfo;
203 class CapturedRegionScopeInfo;
204 class CapturingScopeInfo;
205 class CompoundScopeInfo;
206 class DelayedDiagnostic;
207 class DelayedDiagnosticPool;
208 class FunctionScopeInfo;
209 class LambdaScopeInfo;
210 class PossiblyUnreachableDiag;
211 class SemaPPCallbacks;
212 class TemplateDeductionInfo;
213}
214
215namespace threadSafety {
216 class BeforeSet;
217 void threadSafetyCleanup(BeforeSet* Cache);
218}
219
220// FIXME: No way to easily map from TemplateTypeParmTypes to
221// TemplateTypeParmDecls, so we have this horrible PointerUnion.
222typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
223 SourceLocation> UnexpandedParameterPack;
224
225/// Describes whether we've seen any nullability information for the given
226/// file.
227struct FileNullability {
228 /// The first pointer declarator (of any pointer kind) in the file that does
229 /// not have a corresponding nullability annotation.
230 SourceLocation PointerLoc;
231
232 /// The end location for the first pointer declarator in the file. Used for
233 /// placing fix-its.
234 SourceLocation PointerEndLoc;
235
236 /// Which kind of pointer declarator we saw.
237 uint8_t PointerKind;
238
239 /// Whether we saw any type nullability annotations in the given file.
240 bool SawTypeNullability = false;
241};
242
243/// A mapping from file IDs to a record of whether we've seen nullability
244/// information in that file.
245class FileNullabilityMap {
246 /// A mapping from file IDs to the nullability information for each file ID.
247 llvm::DenseMap<FileID, FileNullability> Map;
248
249 /// A single-element cache based on the file ID.
250 struct {
251 FileID File;
252 FileNullability Nullability;
253 } Cache;
254
255public:
256 FileNullability &operator[](FileID file) {
257 // Check the single-element cache.
258 if (file == Cache.File)
259 return Cache.Nullability;
260
261 // It's not in the single-element cache; flush the cache if we have one.
262 if (!Cache.File.isInvalid()) {
263 Map[Cache.File] = Cache.Nullability;
264 }
265
266 // Pull this entry into the cache.
267 Cache.File = file;
268 Cache.Nullability = Map[file];
269 return Cache.Nullability;
270 }
271};
272
273/// Sema - This implements semantic analysis and AST building for C.
274class Sema {
275 Sema(const Sema &) = delete;
276 void operator=(const Sema &) = delete;
277
278 ///\brief Source of additional semantic information.
279 ExternalSemaSource *ExternalSource;
280
281 ///\brief Whether Sema has generated a multiplexer and has to delete it.
282 bool isMultiplexExternalSource;
283
284 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
285
286 bool isVisibleSlow(const NamedDecl *D);
287
288 /// Determine whether two declarations should be linked together, given that
289 /// the old declaration might not be visible and the new declaration might
290 /// not have external linkage.
291 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
292 const NamedDecl *New) {
293 if (isVisible(Old))
294 return true;
295 // See comment in below overload for why it's safe to compute the linkage
296 // of the new declaration here.
297 if (New->isExternallyDeclarable()) {
298 assert(Old->isExternallyDeclarable() &&(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
299 "should not have found a non-externally-declarable previous decl")(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300 return true;
301 }
302 return false;
303 }
304 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
305
306public:
307 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
308 typedef OpaquePtr<TemplateName> TemplateTy;
309 typedef OpaquePtr<QualType> TypeTy;
310
311 OpenCLOptions OpenCLFeatures;
312 FPOptions FPFeatures;
313
314 const LangOptions &LangOpts;
315 Preprocessor &PP;
316 ASTContext &Context;
317 ASTConsumer &Consumer;
318 DiagnosticsEngine &Diags;
319 SourceManager &SourceMgr;
320
321 /// \brief Flag indicating whether or not to collect detailed statistics.
322 bool CollectStats;
323
324 /// \brief Code-completion consumer.
325 CodeCompleteConsumer *CodeCompleter;
326
327 /// CurContext - This is the current declaration context of parsing.
328 DeclContext *CurContext;
329
330 /// \brief Generally null except when we temporarily switch decl contexts,
331 /// like in \see ActOnObjCTemporaryExitContainerContext.
332 DeclContext *OriginalLexicalContext;
333
334 /// VAListTagName - The declaration name corresponding to __va_list_tag.
335 /// This is used as part of a hack to omit that class from ADL results.
336 DeclarationName VAListTagName;
337
338 bool MSStructPragmaOn; // True when \#pragma ms_struct on
339
340 /// \brief Controls member pointer representation format under the MS ABI.
341 LangOptions::PragmaMSPointersToMembersKind
342 MSPointerToMemberRepresentationMethod;
343
344 /// Stack of active SEH __finally scopes. Can be empty.
345 SmallVector<Scope*, 2> CurrentSEHFinally;
346
347 /// \brief Source location for newly created implicit MSInheritanceAttrs
348 SourceLocation ImplicitMSInheritanceAttrLoc;
349
350 /// \brief pragma clang section kind
351 enum PragmaClangSectionKind {
352 PCSK_Invalid = 0,
353 PCSK_BSS = 1,
354 PCSK_Data = 2,
355 PCSK_Rodata = 3,
356 PCSK_Text = 4
357 };
358
359 enum PragmaClangSectionAction {
360 PCSA_Set = 0,
361 PCSA_Clear = 1
362 };
363
364 struct PragmaClangSection {
365 std::string SectionName;
366 bool Valid = false;
367 SourceLocation PragmaLocation;
368
369 void Act(SourceLocation PragmaLocation,
370 PragmaClangSectionAction Action,
371 StringLiteral* Name);
372 };
373
374 PragmaClangSection PragmaClangBSSSection;
375 PragmaClangSection PragmaClangDataSection;
376 PragmaClangSection PragmaClangRodataSection;
377 PragmaClangSection PragmaClangTextSection;
378
379 enum PragmaMsStackAction {
380 PSK_Reset = 0x0, // #pragma ()
381 PSK_Set = 0x1, // #pragma (value)
382 PSK_Push = 0x2, // #pragma (push[, id])
383 PSK_Pop = 0x4, // #pragma (pop[, id])
384 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
385 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
386 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
387 };
388
389 template<typename ValueType>
390 struct PragmaStack {
391 struct Slot {
392 llvm::StringRef StackSlotLabel;
393 ValueType Value;
394 SourceLocation PragmaLocation;
395 SourceLocation PragmaPushLocation;
396 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
397 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
398 : StackSlotLabel(StackSlotLabel), Value(Value),
399 PragmaLocation(PragmaLocation),
400 PragmaPushLocation(PragmaPushLocation) {}
401 };
402 void Act(SourceLocation PragmaLocation,
403 PragmaMsStackAction Action,
404 llvm::StringRef StackSlotLabel,
405 ValueType Value);
406
407 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
408 // method body to restore the stacks on exit, so it works like this:
409 //
410 // struct S {
411 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
412 // void Method {}
413 // #pragma <name>(pop, InternalPragmaSlot)
414 // };
415 //
416 // It works even with #pragma vtordisp, although MSVC doesn't support
417 // #pragma vtordisp(push [, id], n)
418 // syntax.
419 //
420 // Push / pop a named sentinel slot.
421 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
422 assert((Action == PSK_Push || Action == PSK_Pop) &&(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
423 "Can only push / pop #pragma stack sentinels!")(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
;
424 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
425 }
426
427 // Constructors.
428 explicit PragmaStack(const ValueType &Default)
429 : DefaultValue(Default), CurrentValue(Default) {}
430
431 bool hasValue() const { return CurrentValue != DefaultValue; }
432
433 SmallVector<Slot, 2> Stack;
434 ValueType DefaultValue; // Value used for PSK_Reset action.
435 ValueType CurrentValue;
436 SourceLocation CurrentPragmaLocation;
437 };
438 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
439 // we shouldn't do so if they're in a module).
440
441 /// \brief Whether to insert vtordisps prior to virtual bases in the Microsoft
442 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
443 ///
444 /// 0: Suppress all vtordisps
445 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
446 /// structors
447 /// 2: Always insert vtordisps to support RTTI on partially constructed
448 /// objects
449 PragmaStack<MSVtorDispAttr::Mode> VtorDispStack;
450 // #pragma pack.
451 // Sentinel to represent when the stack is set to mac68k alignment.
452 static const unsigned kMac68kAlignmentSentinel = ~0U;
453 PragmaStack<unsigned> PackStack;
454 // The current #pragma pack values and locations at each #include.
455 struct PackIncludeState {
456 unsigned CurrentValue;
457 SourceLocation CurrentPragmaLocation;
458 bool HasNonDefaultValue, ShouldWarnOnInclude;
459 };
460 SmallVector<PackIncludeState, 8> PackIncludeStack;
461 // Segment #pragmas.
462 PragmaStack<StringLiteral *> DataSegStack;
463 PragmaStack<StringLiteral *> BSSSegStack;
464 PragmaStack<StringLiteral *> ConstSegStack;
465 PragmaStack<StringLiteral *> CodeSegStack;
466
467 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
468 // Actions should be performed only if we enter / exit a C++ method body.
469 class PragmaStackSentinelRAII {
470 public:
471 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
472 ~PragmaStackSentinelRAII();
473
474 private:
475 Sema &S;
476 StringRef SlotLabel;
477 bool ShouldAct;
478 };
479
480 /// A mapping that describes the nullability we've seen in each header file.
481 FileNullabilityMap NullabilityMap;
482
483 /// Last section used with #pragma init_seg.
484 StringLiteral *CurInitSeg;
485 SourceLocation CurInitSegLoc;
486
487 /// VisContext - Manages the stack for \#pragma GCC visibility.
488 void *VisContext; // Really a "PragmaVisStack*"
489
490 /// \brief This represents the stack of attributes that were pushed by
491 /// \#pragma clang attribute.
492 struct PragmaAttributeEntry {
493 SourceLocation Loc;
494 AttributeList *Attribute;
495 SmallVector<attr::SubjectMatchRule, 4> MatchRules;
496 bool IsUsed;
497 };
498 SmallVector<PragmaAttributeEntry, 2> PragmaAttributeStack;
499
500 /// \brief The declaration that is currently receiving an attribute from the
501 /// #pragma attribute stack.
502 const Decl *PragmaAttributeCurrentTargetDecl;
503
504 /// \brief This represents the last location of a "#pragma clang optimize off"
505 /// directive if such a directive has not been closed by an "on" yet. If
506 /// optimizations are currently "on", this is set to an invalid location.
507 SourceLocation OptimizeOffPragmaLocation;
508
509 /// \brief Flag indicating if Sema is building a recovery call expression.
510 ///
511 /// This flag is used to avoid building recovery call expressions
512 /// if Sema is already doing so, which would cause infinite recursions.
513 bool IsBuildingRecoveryCallExpr;
514
515 /// Used to control the generation of ExprWithCleanups.
516 CleanupInfo Cleanup;
517
518 /// ExprCleanupObjects - This is the stack of objects requiring
519 /// cleanup that are created by the current full expression. The
520 /// element type here is ExprWithCleanups::Object.
521 SmallVector<BlockDecl*, 8> ExprCleanupObjects;
522
523 /// \brief Store a list of either DeclRefExprs or MemberExprs
524 /// that contain a reference to a variable (constant) that may or may not
525 /// be odr-used in this Expr, and we won't know until all lvalue-to-rvalue
526 /// and discarded value conversions have been applied to all subexpressions
527 /// of the enclosing full expression. This is cleared at the end of each
528 /// full expression.
529 llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs;
530
531 /// \brief Stack containing information about each of the nested
532 /// function, block, and method scopes that are currently active.
533 ///
534 /// This array is never empty. Clients should ignore the first
535 /// element, which is used to cache a single FunctionScopeInfo
536 /// that's used to parse every top-level function.
537 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
538
539 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
540 &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
541 ExtVectorDeclsType;
542
543 /// ExtVectorDecls - This is a list all the extended vector types. This allows
544 /// us to associate a raw vector type with one of the ext_vector type names.
545 /// This is only necessary for issuing pretty diagnostics.
546 ExtVectorDeclsType ExtVectorDecls;
547
548 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
549 std::unique_ptr<CXXFieldCollector> FieldCollector;
550
551 typedef llvm::SmallSetVector<const NamedDecl*, 16> NamedDeclSetType;
552
553 /// \brief Set containing all declared private fields that are not used.
554 NamedDeclSetType UnusedPrivateFields;
555
556 /// \brief Set containing all typedefs that are likely unused.
557 llvm::SmallSetVector<const TypedefNameDecl *, 4>
558 UnusedLocalTypedefNameCandidates;
559
560 /// \brief Delete-expressions to be analyzed at the end of translation unit
561 ///
562 /// This list contains class members, and locations of delete-expressions
563 /// that could not be proven as to whether they mismatch with new-expression
564 /// used in initializer of the field.
565 typedef std::pair<SourceLocation, bool> DeleteExprLoc;
566 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
567 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
568
569 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
570
571 /// PureVirtualClassDiagSet - a set of class declarations which we have
572 /// emitted a list of pure virtual functions. Used to prevent emitting the
573 /// same list more than once.
574 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
575
576 /// ParsingInitForAutoVars - a set of declarations with auto types for which
577 /// we are currently parsing the initializer.
578 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
579
580 /// \brief Look for a locally scoped extern "C" declaration by the given name.
581 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
582
583 typedef LazyVector<VarDecl *, ExternalSemaSource,
584 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
585 TentativeDefinitionsType;
586
587 /// \brief All the tentative definitions encountered in the TU.
588 TentativeDefinitionsType TentativeDefinitions;
589
590 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
591 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
592 UnusedFileScopedDeclsType;
593
594 /// \brief The set of file scoped decls seen so far that have not been used
595 /// and must warn if not used. Only contains the first declaration.
596 UnusedFileScopedDeclsType UnusedFileScopedDecls;
597
598 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
599 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
600 DelegatingCtorDeclsType;
601
602 /// \brief All the delegating constructors seen so far in the file, used for
603 /// cycle detection at the end of the TU.
604 DelegatingCtorDeclsType DelegatingCtorDecls;
605
606 /// \brief All the overriding functions seen during a class definition
607 /// that had their exception spec checks delayed, plus the overridden
608 /// function.
609 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
610 DelayedExceptionSpecChecks;
611
612 /// \brief All the members seen during a class definition which were both
613 /// explicitly defaulted and had explicitly-specified exception
614 /// specifications, along with the function type containing their
615 /// user-specified exception specification. Those exception specifications
616 /// were overridden with the default specifications, but we still need to
617 /// check whether they are compatible with the default specification, and
618 /// we can't do that until the nesting set of class definitions is complete.
619 SmallVector<std::pair<CXXMethodDecl*, const FunctionProtoType*>, 2>
620 DelayedDefaultedMemberExceptionSpecs;
621
622 typedef llvm::MapVector<const FunctionDecl *,
623 std::unique_ptr<LateParsedTemplate>>
624 LateParsedTemplateMapT;
625 LateParsedTemplateMapT LateParsedTemplateMap;
626
627 /// \brief Callback to the parser to parse templated functions when needed.
628 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
629 typedef void LateTemplateParserCleanupCB(void *P);
630 LateTemplateParserCB *LateTemplateParser;
631 LateTemplateParserCleanupCB *LateTemplateParserCleanup;
632 void *OpaqueParser;
633
634 void SetLateTemplateParser(LateTemplateParserCB *LTP,
635 LateTemplateParserCleanupCB *LTPCleanup,
636 void *P) {
637 LateTemplateParser = LTP;
638 LateTemplateParserCleanup = LTPCleanup;
639 OpaqueParser = P;
640 }
641
642 class DelayedDiagnostics;
643
644 class DelayedDiagnosticsState {
645 sema::DelayedDiagnosticPool *SavedPool;
646 friend class Sema::DelayedDiagnostics;
647 };
648 typedef DelayedDiagnosticsState ParsingDeclState;
649 typedef DelayedDiagnosticsState ProcessingContextState;
650
651 /// A class which encapsulates the logic for delaying diagnostics
652 /// during parsing and other processing.
653 class DelayedDiagnostics {
654 /// \brief The current pool of diagnostics into which delayed
655 /// diagnostics should go.
656 sema::DelayedDiagnosticPool *CurPool;
657
658 public:
659 DelayedDiagnostics() : CurPool(nullptr) {}
660
661 /// Adds a delayed diagnostic.
662 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
663
664 /// Determines whether diagnostics should be delayed.
665 bool shouldDelayDiagnostics() { return CurPool != nullptr; }
666
667 /// Returns the current delayed-diagnostics pool.
668 sema::DelayedDiagnosticPool *getCurrentPool() const {
669 return CurPool;
670 }
671
672 /// Enter a new scope. Access and deprecation diagnostics will be
673 /// collected in this pool.
674 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
675 DelayedDiagnosticsState state;
676 state.SavedPool = CurPool;
677 CurPool = &pool;
678 return state;
679 }
680
681 /// Leave a delayed-diagnostic state that was previously pushed.
682 /// Do not emit any of the diagnostics. This is performed as part
683 /// of the bookkeeping of popping a pool "properly".
684 void popWithoutEmitting(DelayedDiagnosticsState state) {
685 CurPool = state.SavedPool;
686 }
687
688 /// Enter a new scope where access and deprecation diagnostics are
689 /// not delayed.
690 DelayedDiagnosticsState pushUndelayed() {
691 DelayedDiagnosticsState state;
692 state.SavedPool = CurPool;
693 CurPool = nullptr;
694 return state;
695 }
696
697 /// Undo a previous pushUndelayed().
698 void popUndelayed(DelayedDiagnosticsState state) {
699 assert(CurPool == nullptr)(static_cast <bool> (CurPool == nullptr) ? void (0) : __assert_fail
("CurPool == nullptr", "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 699, __extension__ __PRETTY_FUNCTION__))
;
700 CurPool = state.SavedPool;
701 }
702 } DelayedDiagnostics;
703
704 /// A RAII object to temporarily push a declaration context.
705 class ContextRAII {
706 private:
707 Sema &S;
708 DeclContext *SavedContext;
709 ProcessingContextState SavedContextState;
710 QualType SavedCXXThisTypeOverride;
711
712 public:
713 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
714 : S(S), SavedContext(S.CurContext),
715 SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
716 SavedCXXThisTypeOverride(S.CXXThisTypeOverride)
717 {
718 assert(ContextToPush && "pushing null context")(static_cast <bool> (ContextToPush && "pushing null context"
) ? void (0) : __assert_fail ("ContextToPush && \"pushing null context\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 718, __extension__ __PRETTY_FUNCTION__))
;
719 S.CurContext = ContextToPush;
720 if (NewThisContext)
721 S.CXXThisTypeOverride = QualType();
722 }
723
724 void pop() {
725 if (!SavedContext) return;
726 S.CurContext = SavedContext;
727 S.DelayedDiagnostics.popUndelayed(SavedContextState);
728 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
729 SavedContext = nullptr;
730 }
731
732 ~ContextRAII() {
733 pop();
734 }
735 };
736
737 /// \brief RAII object to handle the state changes required to synthesize
738 /// a function body.
739 class SynthesizedFunctionScope {
740 Sema &S;
741 Sema::ContextRAII SavedContext;
742 bool PushedCodeSynthesisContext = false;
743
744 public:
745 SynthesizedFunctionScope(Sema &S, DeclContext *DC)
746 : S(S), SavedContext(S, DC) {
747 S.PushFunctionScope();
748 S.PushExpressionEvaluationContext(
749 Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
750 if (auto *FD = dyn_cast<FunctionDecl>(DC))
751 FD->setWillHaveBody(true);
752 else
753 assert(isa<ObjCMethodDecl>(DC))(static_cast <bool> (isa<ObjCMethodDecl>(DC)) ? void
(0) : __assert_fail ("isa<ObjCMethodDecl>(DC)", "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 753, __extension__ __PRETTY_FUNCTION__))
;
754 }
755
756 void addContextNote(SourceLocation UseLoc) {
757 assert(!PushedCodeSynthesisContext)(static_cast <bool> (!PushedCodeSynthesisContext) ? void
(0) : __assert_fail ("!PushedCodeSynthesisContext", "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 757, __extension__ __PRETTY_FUNCTION__))
;
758
759 Sema::CodeSynthesisContext Ctx;
760 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
761 Ctx.PointOfInstantiation = UseLoc;
762 Ctx.Entity = cast<Decl>(S.CurContext);
763 S.pushCodeSynthesisContext(Ctx);
764
765 PushedCodeSynthesisContext = true;
766 }
767
768 ~SynthesizedFunctionScope() {
769 if (PushedCodeSynthesisContext)
770 S.popCodeSynthesisContext();
771 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
772 FD->setWillHaveBody(false);
773 S.PopExpressionEvaluationContext();
774 S.PopFunctionScopeInfo();
775 }
776 };
777
778 /// WeakUndeclaredIdentifiers - Identifiers contained in
779 /// \#pragma weak before declared. rare. may alias another
780 /// identifier, declared or undeclared
781 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
782
783 /// ExtnameUndeclaredIdentifiers - Identifiers contained in
784 /// \#pragma redefine_extname before declared. Used in Solaris system headers
785 /// to define functions that occur in multiple standards to call the version
786 /// in the currently selected standard.
787 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
788
789
790 /// \brief Load weak undeclared identifiers from the external source.
791 void LoadExternalWeakUndeclaredIdentifiers();
792
793 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
794 /// \#pragma weak during processing of other Decls.
795 /// I couldn't figure out a clean way to generate these in-line, so
796 /// we store them here and handle separately -- which is a hack.
797 /// It would be best to refactor this.
798 SmallVector<Decl*,2> WeakTopLevelDecl;
799
800 IdentifierResolver IdResolver;
801
802 /// Translation Unit Scope - useful to Objective-C actions that need
803 /// to lookup file scope declarations in the "ordinary" C decl namespace.
804 /// For example, user-defined classes, built-in "id" type, etc.
805 Scope *TUScope;
806
807 /// \brief The C++ "std" namespace, where the standard library resides.
808 LazyDeclPtr StdNamespace;
809
810 /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
811 /// standard library.
812 LazyDeclPtr StdBadAlloc;
813
814 /// \brief The C++ "std::align_val_t" enum class, which is defined by the C++
815 /// standard library.
816 LazyDeclPtr StdAlignValT;
817
818 /// \brief The C++ "std::experimental" namespace, where the experimental parts
819 /// of the standard library resides.
820 NamespaceDecl *StdExperimentalNamespaceCache;
821
822 /// \brief The C++ "std::initializer_list" template, which is defined in
823 /// \<initializer_list>.
824 ClassTemplateDecl *StdInitializerList;
825
826 /// \brief The C++ "type_info" declaration, which is defined in \<typeinfo>.
827 RecordDecl *CXXTypeInfoDecl;
828
829 /// \brief The MSVC "_GUID" struct, which is defined in MSVC header files.
830 RecordDecl *MSVCGuidDecl;
831
832 /// \brief Caches identifiers/selectors for NSFoundation APIs.
833 std::unique_ptr<NSAPI> NSAPIObj;
834
835 /// \brief The declaration of the Objective-C NSNumber class.
836 ObjCInterfaceDecl *NSNumberDecl;
837
838 /// \brief The declaration of the Objective-C NSValue class.
839 ObjCInterfaceDecl *NSValueDecl;
840
841 /// \brief Pointer to NSNumber type (NSNumber *).
842 QualType NSNumberPointer;
843
844 /// \brief Pointer to NSValue type (NSValue *).
845 QualType NSValuePointer;
846
847 /// \brief The Objective-C NSNumber methods used to create NSNumber literals.
848 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
849
850 /// \brief The declaration of the Objective-C NSString class.
851 ObjCInterfaceDecl *NSStringDecl;
852
853 /// \brief Pointer to NSString type (NSString *).
854 QualType NSStringPointer;
855
856 /// \brief The declaration of the stringWithUTF8String: method.
857 ObjCMethodDecl *StringWithUTF8StringMethod;
858
859 /// \brief The declaration of the valueWithBytes:objCType: method.
860 ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
861
862 /// \brief The declaration of the Objective-C NSArray class.
863 ObjCInterfaceDecl *NSArrayDecl;
864
865 /// \brief The declaration of the arrayWithObjects:count: method.
866 ObjCMethodDecl *ArrayWithObjectsMethod;
867
868 /// \brief The declaration of the Objective-C NSDictionary class.
869 ObjCInterfaceDecl *NSDictionaryDecl;
870
871 /// \brief The declaration of the dictionaryWithObjects:forKeys:count: method.
872 ObjCMethodDecl *DictionaryWithObjectsMethod;
873
874 /// \brief id<NSCopying> type.
875 QualType QIDNSCopying;
876
877 /// \brief will hold 'respondsToSelector:'
878 Selector RespondsToSelectorSel;
879
880 /// A flag to remember whether the implicit forms of operator new and delete
881 /// have been declared.
882 bool GlobalNewDeleteDeclared;
883
884 /// A flag to indicate that we're in a context that permits abstract
885 /// references to fields. This is really a
886 bool AllowAbstractFieldReference;
887
888 /// \brief Describes how the expressions currently being parsed are
889 /// evaluated at run-time, if at all.
890 enum class ExpressionEvaluationContext {
891 /// \brief The current expression and its subexpressions occur within an
892 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
893 /// \c sizeof, where the type of the expression may be significant but
894 /// no code will be generated to evaluate the value of the expression at
895 /// run time.
896 Unevaluated,
897
898 /// \brief The current expression occurs within a braced-init-list within
899 /// an unevaluated operand. This is mostly like a regular unevaluated
900 /// context, except that we still instantiate constexpr functions that are
901 /// referenced here so that we can perform narrowing checks correctly.
902 UnevaluatedList,
903
904 /// \brief The current expression occurs within a discarded statement.
905 /// This behaves largely similarly to an unevaluated operand in preventing
906 /// definitions from being required, but not in other ways.
907 DiscardedStatement,
908
909 /// \brief The current expression occurs within an unevaluated
910 /// operand that unconditionally permits abstract references to
911 /// fields, such as a SIZE operator in MS-style inline assembly.
912 UnevaluatedAbstract,
913
914 /// \brief The current context is "potentially evaluated" in C++11 terms,
915 /// but the expression is evaluated at compile-time (like the values of
916 /// cases in a switch statement).
917 ConstantEvaluated,
918
919 /// \brief The current expression is potentially evaluated at run time,
920 /// which means that code may be generated to evaluate the value of the
921 /// expression at run time.
922 PotentiallyEvaluated,
923
924 /// \brief The current expression is potentially evaluated, but any
925 /// declarations referenced inside that expression are only used if
926 /// in fact the current expression is used.
927 ///
928 /// This value is used when parsing default function arguments, for which
929 /// we would like to provide diagnostics (e.g., passing non-POD arguments
930 /// through varargs) but do not want to mark declarations as "referenced"
931 /// until the default argument is used.
932 PotentiallyEvaluatedIfUsed
933 };
934
935 /// \brief Data structure used to record current or nested
936 /// expression evaluation contexts.
937 struct ExpressionEvaluationContextRecord {
938 /// \brief The expression evaluation context.
939 ExpressionEvaluationContext Context;
940
941 /// \brief Whether the enclosing context needed a cleanup.
942 CleanupInfo ParentCleanup;
943
944 /// \brief Whether we are in a decltype expression.
945 bool IsDecltype;
946
947 /// \brief The number of active cleanup objects when we entered
948 /// this expression evaluation context.
949 unsigned NumCleanupObjects;
950
951 /// \brief The number of typos encountered during this expression evaluation
952 /// context (i.e. the number of TypoExprs created).
953 unsigned NumTypos;
954
955 llvm::SmallPtrSet<Expr*, 2> SavedMaybeODRUseExprs;
956
957 /// \brief The lambdas that are present within this context, if it
958 /// is indeed an unevaluated context.
959 SmallVector<LambdaExpr *, 2> Lambdas;
960
961 /// \brief The declaration that provides context for lambda expressions
962 /// and block literals if the normal declaration context does not
963 /// suffice, e.g., in a default function argument.
964 Decl *ManglingContextDecl;
965
966 /// \brief The context information used to mangle lambda expressions
967 /// and block literals within this context.
968 ///
969 /// This mangling information is allocated lazily, since most contexts
970 /// do not have lambda expressions or block literals.
971 std::unique_ptr<MangleNumberingContext> MangleNumbering;
972
973 /// \brief If we are processing a decltype type, a set of call expressions
974 /// for which we have deferred checking the completeness of the return type.
975 SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
976
977 /// \brief If we are processing a decltype type, a set of temporary binding
978 /// expressions for which we have deferred checking the destructor.
979 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
980
981 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
982 unsigned NumCleanupObjects,
983 CleanupInfo ParentCleanup,
984 Decl *ManglingContextDecl,
985 bool IsDecltype)
986 : Context(Context), ParentCleanup(ParentCleanup),
987 IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects),
988 NumTypos(0),
989 ManglingContextDecl(ManglingContextDecl), MangleNumbering() { }
990
991 /// \brief Retrieve the mangling numbering context, used to consistently
992 /// number constructs like lambdas for mangling.
993 MangleNumberingContext &getMangleNumberingContext(ASTContext &Ctx);
994
995 bool isUnevaluated() const {
996 return Context == ExpressionEvaluationContext::Unevaluated ||
997 Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
998 Context == ExpressionEvaluationContext::UnevaluatedList;
999 }
1000 bool isConstantEvaluated() const {
1001 return Context == ExpressionEvaluationContext::ConstantEvaluated;
1002 }
1003 };
1004
1005 /// A stack of expression evaluation contexts.
1006 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1007
1008 /// \brief Compute the mangling number context for a lambda expression or
1009 /// block literal.
1010 ///
1011 /// \param DC - The DeclContext containing the lambda expression or
1012 /// block literal.
1013 /// \param[out] ManglingContextDecl - Returns the ManglingContextDecl
1014 /// associated with the context, if relevant.
1015 MangleNumberingContext *getCurrentMangleNumberContext(
1016 const DeclContext *DC,
1017 Decl *&ManglingContextDecl);
1018
1019
1020 /// SpecialMemberOverloadResult - The overloading result for a special member
1021 /// function.
1022 ///
1023 /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1024 /// integer are used to determine whether overload resolution succeeded.
1025 class SpecialMemberOverloadResult {
1026 public:
1027 enum Kind {
1028 NoMemberOrDeleted,
1029 Ambiguous,
1030 Success
1031 };
1032
1033 private:
1034 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1035
1036 public:
1037 SpecialMemberOverloadResult() : Pair() {}
1038 SpecialMemberOverloadResult(CXXMethodDecl *MD)
1039 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1040
1041 CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1042 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1043
1044 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1045 void setKind(Kind K) { Pair.setInt(K); }
1046 };
1047
1048 class SpecialMemberOverloadResultEntry
1049 : public llvm::FastFoldingSetNode,
1050 public SpecialMemberOverloadResult {
1051 public:
1052 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1053 : FastFoldingSetNode(ID)
1054 {}
1055 };
1056
1057 /// \brief A cache of special member function overload resolution results
1058 /// for C++ records.
1059 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1060
1061 /// \brief A cache of the flags available in enumerations with the flag_bits
1062 /// attribute.
1063 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1064
1065 /// \brief The kind of translation unit we are processing.
1066 ///
1067 /// When we're processing a complete translation unit, Sema will perform
1068 /// end-of-translation-unit semantic tasks (such as creating
1069 /// initializers for tentative definitions in C) once parsing has
1070 /// completed. Modules and precompiled headers perform different kinds of
1071 /// checks.
1072 TranslationUnitKind TUKind;
1073
1074 llvm::BumpPtrAllocator BumpAlloc;
1075
1076 /// \brief The number of SFINAE diagnostics that have been trapped.
1077 unsigned NumSFINAEErrors;
1078
1079 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1080 UnparsedDefaultArgInstantiationsMap;
1081
1082 /// \brief A mapping from parameters with unparsed default arguments to the
1083 /// set of instantiations of each parameter.
1084 ///
1085 /// This mapping is a temporary data structure used when parsing
1086 /// nested class templates or nested classes of class templates,
1087 /// where we might end up instantiating an inner class before the
1088 /// default arguments of its methods have been parsed.
1089 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1090
1091 // Contains the locations of the beginning of unparsed default
1092 // argument locations.
1093 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1094
1095 /// UndefinedInternals - all the used, undefined objects which require a
1096 /// definition in this translation unit.
1097 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1098
1099 /// Determine if VD, which must be a variable or function, is an external
1100 /// symbol that nonetheless can't be referenced from outside this translation
1101 /// unit because its type has no linkage and it's not extern "C".
1102 bool isExternalWithNoLinkageType(ValueDecl *VD);
1103
1104 /// Obtain a sorted list of functions that are undefined but ODR-used.
1105 void getUndefinedButUsed(
1106 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1107
1108 /// Retrieves list of suspicious delete-expressions that will be checked at
1109 /// the end of translation unit.
1110 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1111 getMismatchingDeleteExpressions() const;
1112
1113 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1114 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1115
1116 /// Method Pool - allows efficient lookup when typechecking messages to "id".
1117 /// We need to maintain a list, since selectors can have differing signatures
1118 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1119 /// of selectors are "overloaded").
1120 /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1121 /// methods inside categories with a particular selector.
1122 GlobalMethodPool MethodPool;
1123
1124 /// Method selectors used in a \@selector expression. Used for implementation
1125 /// of -Wselector.
1126 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1127
1128 /// Kinds of C++ special members.
1129 enum CXXSpecialMember {
1130 CXXDefaultConstructor,
1131 CXXCopyConstructor,
1132 CXXMoveConstructor,
1133 CXXCopyAssignment,
1134 CXXMoveAssignment,
1135 CXXDestructor,
1136 CXXInvalid
1137 };
1138
1139 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1140 SpecialMemberDecl;
1141
1142 /// The C++ special members which we are currently in the process of
1143 /// declaring. If this process recursively triggers the declaration of the
1144 /// same special member, we should act as if it is not yet declared.
1145 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1146
1147 /// The function definitions which were renamed as part of typo-correction
1148 /// to match their respective declarations. We want to keep track of them
1149 /// to ensure that we don't emit a "redefinition" error if we encounter a
1150 /// correctly named definition after the renamed definition.
1151 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1152
1153 /// Stack of types that correspond to the parameter entities that are
1154 /// currently being copy-initialized. Can be empty.
1155 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1156
1157 void ReadMethodPool(Selector Sel);
1158 void updateOutOfDateSelector(Selector Sel);
1159
1160 /// Private Helper predicate to check for 'self'.
1161 bool isSelfExpr(Expr *RExpr);
1162 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1163
1164 /// \brief Cause the active diagnostic on the DiagosticsEngine to be
1165 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1166 /// should not be used elsewhere.
1167 void EmitCurrentDiagnostic(unsigned DiagID);
1168
1169 /// Records and restores the FP_CONTRACT state on entry/exit of compound
1170 /// statements.
1171 class FPContractStateRAII {
1172 public:
1173 FPContractStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.FPFeatures) {}
1174 ~FPContractStateRAII() { S.FPFeatures = OldFPFeaturesState; }
1175
1176 private:
1177 Sema& S;
1178 FPOptions OldFPFeaturesState;
1179 };
1180
1181 void addImplicitTypedef(StringRef Name, QualType T);
1182
1183public:
1184 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1185 TranslationUnitKind TUKind = TU_Complete,
1186 CodeCompleteConsumer *CompletionConsumer = nullptr);
1187 ~Sema();
1188
1189 /// \brief Perform initialization that occurs after the parser has been
1190 /// initialized but before it parses anything.
1191 void Initialize();
1192
1193 const LangOptions &getLangOpts() const { return LangOpts; }
1194 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1195 FPOptions &getFPOptions() { return FPFeatures; }
1196
1197 DiagnosticsEngine &getDiagnostics() const { return Diags; }
1198 SourceManager &getSourceManager() const { return SourceMgr; }
1199 Preprocessor &getPreprocessor() const { return PP; }
1200 ASTContext &getASTContext() const { return Context; }
1201 ASTConsumer &getASTConsumer() const { return Consumer; }
1202 ASTMutationListener *getASTMutationListener() const;
1203 ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1204
1205 ///\brief Registers an external source. If an external source already exists,
1206 /// creates a multiplex external source and appends to it.
1207 ///
1208 ///\param[in] E - A non-null external sema source.
1209 ///
1210 void addExternalSource(ExternalSemaSource *E);
1211
1212 void PrintStats() const;
1213
1214 /// \brief Helper class that creates diagnostics with optional
1215 /// template instantiation stacks.
1216 ///
1217 /// This class provides a wrapper around the basic DiagnosticBuilder
1218 /// class that emits diagnostics. SemaDiagnosticBuilder is
1219 /// responsible for emitting the diagnostic (as DiagnosticBuilder
1220 /// does) and, if the diagnostic comes from inside a template
1221 /// instantiation, printing the template instantiation stack as
1222 /// well.
1223 class SemaDiagnosticBuilder : public DiagnosticBuilder {
1224 Sema &SemaRef;
1225 unsigned DiagID;
1226
1227 public:
1228 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1229 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
1230
1231 // This is a cunning lie. DiagnosticBuilder actually performs move
1232 // construction in its copy constructor (but due to varied uses, it's not
1233 // possible to conveniently express this as actual move construction). So
1234 // the default copy ctor here is fine, because the base class disables the
1235 // source anyway, so the user-defined ~SemaDiagnosticBuilder is a safe no-op
1236 // in that case anwyay.
1237 SemaDiagnosticBuilder(const SemaDiagnosticBuilder&) = default;
1238
1239 ~SemaDiagnosticBuilder() {
1240 // If we aren't active, there is nothing to do.
1241 if (!isActive()) return;
1242
1243 // Otherwise, we need to emit the diagnostic. First flush the underlying
1244 // DiagnosticBuilder data, and clear the diagnostic builder itself so it
1245 // won't emit the diagnostic in its own destructor.
1246 //
1247 // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1248 // do its own needless checks to see if the diagnostic needs to be
1249 // emitted. However, because we take care to ensure that the builder
1250 // objects never escape, a sufficiently smart compiler will be able to
1251 // eliminate that code.
1252 FlushCounts();
1253 Clear();
1254
1255 // Dispatch to Sema to emit the diagnostic.
1256 SemaRef.EmitCurrentDiagnostic(DiagID);
1257 }
1258
1259 /// Teach operator<< to produce an object of the correct type.
1260 template<typename T>
1261 friend const SemaDiagnosticBuilder &operator<<(
1262 const SemaDiagnosticBuilder &Diag, const T &Value) {
1263 const DiagnosticBuilder &BaseDiag = Diag;
1264 BaseDiag << Value;
1265 return Diag;
1266 }
1267 };
1268
1269 /// \brief Emit a diagnostic.
1270 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
1271 DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
1272 return SemaDiagnosticBuilder(DB, *this, DiagID);
1273 }
1274
1275 /// \brief Emit a partial diagnostic.
1276 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
1277
1278 /// \brief Build a partial diagnostic.
1279 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1280
1281 bool findMacroSpelling(SourceLocation &loc, StringRef name);
1282
1283 /// \brief Get a string to suggest for zero-initialization of a type.
1284 std::string
1285 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1286 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1287
1288 /// \brief Calls \c Lexer::getLocForEndOfToken()
1289 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1290
1291 /// \brief Retrieve the module loader associated with the preprocessor.
1292 ModuleLoader &getModuleLoader() const;
1293
1294 void emitAndClearUnusedLocalTypedefWarnings();
1295
1296 void ActOnStartOfTranslationUnit();
1297 void ActOnEndOfTranslationUnit();
1298
1299 void CheckDelegatingCtorCycles();
1300
1301 Scope *getScopeForContext(DeclContext *Ctx);
1302
1303 void PushFunctionScope();
1304 void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1305 sema::LambdaScopeInfo *PushLambdaScope();
1306
1307 /// \brief This is used to inform Sema what the current TemplateParameterDepth
1308 /// is during Parsing. Currently it is used to pass on the depth
1309 /// when parsing generic lambda 'auto' parameters.
1310 void RecordParsingTemplateParameterDepth(unsigned Depth);
1311
1312 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1313 RecordDecl *RD,
1314 CapturedRegionKind K);
1315 void
1316 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1317 const Decl *D = nullptr,
1318 const BlockExpr *blkExpr = nullptr);
1319
1320 sema::FunctionScopeInfo *getCurFunction() const {
1321 return FunctionScopes.back();
1322 }
1323
1324 sema::FunctionScopeInfo *getEnclosingFunction() const {
1325 if (FunctionScopes.empty())
1326 return nullptr;
1327
1328 for (int e = FunctionScopes.size()-1; e >= 0; --e) {
1329 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1330 continue;
1331 return FunctionScopes[e];
1332 }
1333 return nullptr;
1334 }
1335
1336 template <typename ExprT>
1337 void recordUseOfEvaluatedWeak(const ExprT *E, bool IsRead=true) {
1338 if (!isUnevaluatedContext())
1339 getCurFunction()->recordUseOfWeak(E, IsRead);
1340 }
1341
1342 void PushCompoundScope();
1343 void PopCompoundScope();
1344
1345 sema::CompoundScopeInfo &getCurCompoundScope() const;
1346
1347 bool hasAnyUnrecoverableErrorsInThisFunction() const;
1348
1349 /// \brief Retrieve the current block, if any.
1350 sema::BlockScopeInfo *getCurBlock();
1351
1352 /// Retrieve the current lambda scope info, if any.
1353 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1354 /// lambda scope info ignoring all inner capturing scopes that are not
1355 /// lambda scopes.
1356 sema::LambdaScopeInfo *
1357 getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1358
1359 /// \brief Retrieve the current generic lambda info, if any.
1360 sema::LambdaScopeInfo *getCurGenericLambda();
1361
1362 /// \brief Retrieve the current captured region, if any.
1363 sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1364
1365 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1366 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1367
1368 void ActOnComment(SourceRange Comment);
1369
1370 //===--------------------------------------------------------------------===//
1371 // Type Analysis / Processing: SemaType.cpp.
1372 //
1373
1374 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1375 const DeclSpec *DS = nullptr);
1376 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1377 const DeclSpec *DS = nullptr);
1378 QualType BuildPointerType(QualType T,
1379 SourceLocation Loc, DeclarationName Entity);
1380 QualType BuildReferenceType(QualType T, bool LValueRef,
1381 SourceLocation Loc, DeclarationName Entity);
1382 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1383 Expr *ArraySize, unsigned Quals,
1384 SourceRange Brackets, DeclarationName Entity);
1385 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1386 SourceLocation AttrLoc);
1387 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1388 SourceLocation AttrLoc);
1389
1390 bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1391
1392 /// \brief Build a function type.
1393 ///
1394 /// This routine checks the function type according to C++ rules and
1395 /// under the assumption that the result type and parameter types have
1396 /// just been instantiated from a template. It therefore duplicates
1397 /// some of the behavior of GetTypeForDeclarator, but in a much
1398 /// simpler form that is only suitable for this narrow use case.
1399 ///
1400 /// \param T The return type of the function.
1401 ///
1402 /// \param ParamTypes The parameter types of the function. This array
1403 /// will be modified to account for adjustments to the types of the
1404 /// function parameters.
1405 ///
1406 /// \param Loc The location of the entity whose type involves this
1407 /// function type or, if there is no such entity, the location of the
1408 /// type that will have function type.
1409 ///
1410 /// \param Entity The name of the entity that involves the function
1411 /// type, if known.
1412 ///
1413 /// \param EPI Extra information about the function type. Usually this will
1414 /// be taken from an existing function with the same prototype.
1415 ///
1416 /// \returns A suitable function type, if there are no errors. The
1417 /// unqualified type will always be a FunctionProtoType.
1418 /// Otherwise, returns a NULL type.
1419 QualType BuildFunctionType(QualType T,
1420 MutableArrayRef<QualType> ParamTypes,
1421 SourceLocation Loc, DeclarationName Entity,
1422 const FunctionProtoType::ExtProtoInfo &EPI);
1423
1424 QualType BuildMemberPointerType(QualType T, QualType Class,
1425 SourceLocation Loc,
1426 DeclarationName Entity);
1427 QualType BuildBlockPointerType(QualType T,
1428 SourceLocation Loc, DeclarationName Entity);
1429 QualType BuildParenType(QualType T);
1430 QualType BuildAtomicType(QualType T, SourceLocation Loc);
1431 QualType BuildReadPipeType(QualType T,
1432 SourceLocation Loc);
1433 QualType BuildWritePipeType(QualType T,
1434 SourceLocation Loc);
1435
1436 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
1437 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1438 TypeSourceInfo *GetTypeSourceInfoForDeclarator(Declarator &D, QualType T,
1439 TypeSourceInfo *ReturnTypeInfo);
1440
1441 /// \brief Package the given type and TSI into a ParsedType.
1442 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1443 DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1444 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1445 static QualType GetTypeFromParser(ParsedType Ty,
1446 TypeSourceInfo **TInfo = nullptr);
1447 CanThrowResult canThrow(const Expr *E);
1448 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1449 const FunctionProtoType *FPT);
1450 void UpdateExceptionSpec(FunctionDecl *FD,
1451 const FunctionProtoType::ExceptionSpecInfo &ESI);
1452 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
1453 bool CheckDistantExceptionSpec(QualType T);
1454 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
1455 bool CheckEquivalentExceptionSpec(
1456 const FunctionProtoType *Old, SourceLocation OldLoc,
1457 const FunctionProtoType *New, SourceLocation NewLoc);
1458 bool CheckEquivalentExceptionSpec(
1459 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
1460 const FunctionProtoType *Old, SourceLocation OldLoc,
1461 const FunctionProtoType *New, SourceLocation NewLoc);
1462 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
1463 const PartialDiagnostic &NestedDiagID,
1464 const PartialDiagnostic &NoteID,
1465 const FunctionProtoType *Superset,
1466 SourceLocation SuperLoc,
1467 const FunctionProtoType *Subset,
1468 SourceLocation SubLoc);
1469 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
1470 const PartialDiagnostic &NoteID,
1471 const FunctionProtoType *Target,
1472 SourceLocation TargetLoc,
1473 const FunctionProtoType *Source,
1474 SourceLocation SourceLoc);
1475
1476 TypeResult ActOnTypeName(Scope *S, Declarator &D);
1477
1478 /// \brief The parser has parsed the context-sensitive type 'instancetype'
1479 /// in an Objective-C message declaration. Return the appropriate type.
1480 ParsedType ActOnObjCInstanceType(SourceLocation Loc);
1481
1482 /// \brief Abstract class used to diagnose incomplete types.
1483 struct TypeDiagnoser {
1484 TypeDiagnoser() {}
1485
1486 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
1487 virtual ~TypeDiagnoser() {}
1488 };
1489
1490 static int getPrintable(int I) { return I; }
1491 static unsigned getPrintable(unsigned I) { return I; }
1492 static bool getPrintable(bool B) { return B; }
1493 static const char * getPrintable(const char *S) { return S; }
1494 static StringRef getPrintable(StringRef S) { return S; }
1495 static const std::string &getPrintable(const std::string &S) { return S; }
1496 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
1497 return II;
1498 }
1499 static DeclarationName getPrintable(DeclarationName N) { return N; }
1500 static QualType getPrintable(QualType T) { return T; }
1501 static SourceRange getPrintable(SourceRange R) { return R; }
1502 static SourceRange getPrintable(SourceLocation L) { return L; }
1503 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
1504 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
1505
1506 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
1507 unsigned DiagID;
1508 std::tuple<const Ts &...> Args;
1509
1510 template <std::size_t... Is>
1511 void emit(const SemaDiagnosticBuilder &DB,
1512 llvm::index_sequence<Is...>) const {
1513 // Apply all tuple elements to the builder in order.
1514 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
1515 (void)Dummy;
1516 }
1517
1518 public:
1519 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
1520 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
1521 assert(DiagID != 0 && "no diagnostic for type diagnoser")(static_cast <bool> (DiagID != 0 && "no diagnostic for type diagnoser"
) ? void (0) : __assert_fail ("DiagID != 0 && \"no diagnostic for type diagnoser\""
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1521, __extension__ __PRETTY_FUNCTION__))
;
1522 }
1523
1524 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
1525 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
1526 emit(DB, llvm::index_sequence_for<Ts...>());
1527 DB << T;
1528 }
1529 };
1530
1531private:
1532 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
1533 TypeDiagnoser *Diagnoser);
1534
1535 struct ModuleScope {
1536 clang::Module *Module = nullptr;
1537 bool ModuleInterface = false;
1538 VisibleModuleSet OuterVisibleModules;
1539 };
1540 /// The modules we're currently parsing.
1541 llvm::SmallVector<ModuleScope, 16> ModuleScopes;
1542
1543 /// Get the module whose scope we are currently within.
1544 Module *getCurrentModule() const {
1545 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
1546 }
1547
1548 VisibleModuleSet VisibleModules;
1549
1550public:
1551 /// \brief Get the module owning an entity.
1552 Module *getOwningModule(Decl *Entity) { return Entity->getOwningModule(); }
1553
1554 /// \brief Make a merged definition of an existing hidden definition \p ND
1555 /// visible at the specified location.
1556 void makeMergedDefinitionVisible(NamedDecl *ND);
1557
1558 bool isModuleVisible(const Module *M) { return VisibleModules.isVisible(M); }
1559
1560 /// Determine whether a declaration is visible to name lookup.
1561 bool isVisible(const NamedDecl *D) {
1562 return !D->isHidden() || isVisibleSlow(D);
1563 }
1564
1565 /// Determine whether any declaration of an entity is visible.
1566 bool
1567 hasVisibleDeclaration(const NamedDecl *D,
1568 llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
1569 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
1570 }
1571 bool hasVisibleDeclarationSlow(const NamedDecl *D,
1572 llvm::SmallVectorImpl<Module *> *Modules);
1573
1574 bool hasVisibleMergedDefinition(NamedDecl *Def);
1575 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
1576
1577 /// Determine if \p D and \p Suggested have a structurally compatible
1578 /// layout as described in C11 6.2.7/1.
1579 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
1580
1581 /// Determine if \p D has a visible definition. If not, suggest a declaration
1582 /// that should be made visible to expose the definition.
1583 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
1584 bool OnlyNeedComplete = false);
1585 bool hasVisibleDefinition(const NamedDecl *D) {
1586 NamedDecl *Hidden;
1587 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
1588 }
1589
1590 /// Determine if the template parameter \p D has a visible default argument.
1591 bool
1592 hasVisibleDefaultArgument(const NamedDecl *D,
1593 llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1594
1595 /// Determine if there is a visible declaration of \p D that is an explicit
1596 /// specialization declaration for a specialization of a template. (For a
1597 /// member specialization, use hasVisibleMemberSpecialization.)
1598 bool hasVisibleExplicitSpecialization(
1599 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1600
1601 /// Determine if there is a visible declaration of \p D that is a member
1602 /// specialization declaration (as opposed to an instantiated declaration).
1603 bool hasVisibleMemberSpecialization(
1604 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1605
1606 /// Determine if \p A and \p B are equivalent internal linkage declarations
1607 /// from different modules, and thus an ambiguity error can be downgraded to
1608 /// an extension warning.
1609 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
1610 const NamedDecl *B);
1611 void diagnoseEquivalentInternalLinkageDeclarations(
1612 SourceLocation Loc, const NamedDecl *D,
1613 ArrayRef<const NamedDecl *> Equiv);
1614
1615 bool isCompleteType(SourceLocation Loc, QualType T) {
1616 return !RequireCompleteTypeImpl(Loc, T, nullptr);
1617 }
1618 bool RequireCompleteType(SourceLocation Loc, QualType T,
1619 TypeDiagnoser &Diagnoser);
1620 bool RequireCompleteType(SourceLocation Loc, QualType T,
1621 unsigned DiagID);
1622
1623 template <typename... Ts>
1624 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
1625 const Ts &...Args) {
1626 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1627 return RequireCompleteType(Loc, T, Diagnoser);
1628 }
1629
1630 void completeExprArrayBound(Expr *E);
1631 bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser);
1632 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1633
1634 template <typename... Ts>
1635 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
1636 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1637 return RequireCompleteExprType(E, Diagnoser);
1638 }
1639
1640 bool RequireLiteralType(SourceLocation Loc, QualType T,
1641 TypeDiagnoser &Diagnoser);
1642 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
1643
1644 template <typename... Ts>
1645 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
1646 const Ts &...Args) {
1647 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1648 return RequireLiteralType(Loc, T, Diagnoser);
1649 }
1650
1651 QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
1652 const CXXScopeSpec &SS, QualType T);
1653
1654 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1655 /// If AsUnevaluated is false, E is treated as though it were an evaluated
1656 /// context, such as when building a type for decltype(auto).
1657 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
1658 bool AsUnevaluated = true);
1659 QualType BuildUnaryTransformType(QualType BaseType,
1660 UnaryTransformType::UTTKind UKind,
1661 SourceLocation Loc);
1662
1663 //===--------------------------------------------------------------------===//
1664 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
1665 //
1666
1667 struct SkipBodyInfo {
1668 SkipBodyInfo()
1669 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
1670 New(nullptr) {}
1671 bool ShouldSkip;
1672 bool CheckSameAsPrevious;
1673 NamedDecl *Previous;
1674 NamedDecl *New;
1675 };
1676
1677 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
1678
1679 void DiagnoseUseOfUnimplementedSelectors();
1680
1681 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
1682
1683 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
1684 Scope *S, CXXScopeSpec *SS = nullptr,
1685 bool isClassName = false, bool HasTrailingDot = false,
1686 ParsedType ObjectType = nullptr,
1687 bool IsCtorOrDtorName = false,
1688 bool WantNontrivialTypeSourceInfo = false,
1689 bool IsClassTemplateDeductionContext = true,
1690 IdentifierInfo **CorrectedII = nullptr);
1691 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
1692 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
1693 void DiagnoseUnknownTypeName(IdentifierInfo *&II,
1694 SourceLocation IILoc,
1695 Scope *S,
1696 CXXScopeSpec *SS,
1697 ParsedType &SuggestedType,
1698 bool IsTemplateName = false);
1699
1700 /// Attempt to behave like MSVC in situations where lookup of an unqualified
1701 /// type name has failed in a dependent context. In these situations, we
1702 /// automatically form a DependentTypeName that will retry lookup in a related
1703 /// scope during instantiation.
1704 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
1705 SourceLocation NameLoc,
1706 bool IsTemplateTypeArg);
1707
1708 /// \brief Describes the result of the name lookup and resolution performed
1709 /// by \c ClassifyName().
1710 enum NameClassificationKind {
1711 NC_Unknown,
1712 NC_Error,
1713 NC_Keyword,
1714 NC_Type,
1715 NC_Expression,
1716 NC_NestedNameSpecifier,
1717 NC_TypeTemplate,
1718 NC_VarTemplate,
1719 NC_FunctionTemplate
1720 };
1721
1722 class NameClassification {
1723 NameClassificationKind Kind;
1724 ExprResult Expr;
1725 TemplateName Template;
1726 ParsedType Type;
1727
1728 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
1729
1730 public:
1731 NameClassification(ExprResult Expr) : Kind(NC_Expression), Expr(Expr) {}
1732
1733 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
1734
1735 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
1736
1737 static NameClassification Error() {
1738 return NameClassification(NC_Error);
1739 }
1740
1741 static NameClassification Unknown() {
1742 return NameClassification(NC_Unknown);
1743 }
1744
1745 static NameClassification NestedNameSpecifier() {
1746 return NameClassification(NC_NestedNameSpecifier);
1747 }
1748
1749 static NameClassification TypeTemplate(TemplateName Name) {
1750 NameClassification Result(NC_TypeTemplate);
1751 Result.Template = Name;
1752 return Result;
1753 }
1754
1755 static NameClassification VarTemplate(TemplateName Name) {
1756 NameClassification Result(NC_VarTemplate);
1757 Result.Template = Name;
1758 return Result;
1759 }
1760
1761 static NameClassification FunctionTemplate(TemplateName Name) {
1762 NameClassification Result(NC_FunctionTemplate);
1763 Result.Template = Name;
1764 return Result;
1765 }
1766
1767 NameClassificationKind getKind() const { return Kind; }
1768
1769 ParsedType getType() const {
1770 assert(Kind == NC_Type)(static_cast <bool> (Kind == NC_Type) ? void (0) : __assert_fail
("Kind == NC_Type", "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1770, __extension__ __PRETTY_FUNCTION__))
;
1771 return Type;
1772 }
1773
1774 ExprResult getExpression() const {
1775 assert(Kind == NC_Expression)(static_cast <bool> (Kind == NC_Expression) ? void (0) :
__assert_fail ("Kind == NC_Expression", "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1775, __extension__ __PRETTY_FUNCTION__))
;
1776 return Expr;
1777 }
1778
1779 TemplateName getTemplateName() const {
1780 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate"
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1781, __extension__ __PRETTY_FUNCTION__))
1781 Kind == NC_VarTemplate)(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate"
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1781, __extension__ __PRETTY_FUNCTION__))
;
1782 return Template;
1783 }
1784
1785 TemplateNameKind getTemplateNameKind() const {
1786 switch (Kind) {
1787 case NC_TypeTemplate:
1788 return TNK_Type_template;
1789 case NC_FunctionTemplate:
1790 return TNK_Function_template;
1791 case NC_VarTemplate:
1792 return TNK_Var_template;
1793 default:
1794 llvm_unreachable("unsupported name classification.")::llvm::llvm_unreachable_internal("unsupported name classification."
, "/build/llvm-toolchain-snapshot-6.0~svn320417/tools/clang/include/clang/Sema/Sema.h"
, 1794)
;
1795 }
1796 }
1797 };
1798
1799 /// \brief Perform name lookup on the given name, classifying it based on
1800 /// the results of name lookup and the following token.
1801 ///
1802 /// This routine is used by the parser to resolve identifiers and help direct
1803 /// parsing. When the identifier cannot be found, this routine will attempt
1804 /// to correct the typo and classify based on the resulting name.
1805 ///
1806 /// \param S The scope in which we're performing name lookup.
1807 ///
1808 /// \param SS The nested-name-specifier that precedes the name.
1809 ///
1810 /// \param Name The identifier. If typo correction finds an alternative name,
1811 /// this pointer parameter will be updated accordingly.
1812 ///
1813 /// \param NameLoc The location of the identifier.
1814 ///
1815 /// \param NextToken The token following the identifier. Used to help
1816 /// disambiguate the name.
1817 ///
1818 /// \param IsAddressOfOperand True if this name is the operand of a unary
1819 /// address of ('&') expression, assuming it is classified as an
1820 /// expression.
1821 ///
1822 /// \param CCC The correction callback, if typo correction is desired.
1823 NameClassification
1824 ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
1825 SourceLocation NameLoc, const Token &NextToken,
1826 bool IsAddressOfOperand,
1827 std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
1828
1829 /// Describes the detailed kind of a template name. Used in diagnostics.
1830 enum class TemplateNameKindForDiagnostics {
1831 ClassTemplate,
1832 FunctionTemplate,
1833 VarTemplate,
1834 AliasTemplate,
1835 TemplateTemplateParam,
1836 DependentTemplate
1837 };
1838 TemplateNameKindForDiagnostics
1839 getTemplateNameKindForDiagnostics(TemplateName Name);
1840
1841 /// Determine whether it's plausible that E was intended to be a
1842 /// template-name.
1843 bool mightBeIntendedToBeTemplateName(ExprResult E) {
1844 if (!getLangOpts().CPlusPlus || E.isInvalid())
1845 return false;
1846 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
1847 return !DRE->hasExplicitTemplateArgs();
1848 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
1849 return !ME->hasExplicitTemplateArgs();
1850 // Any additional cases recognized here should also be handled by
1851 // diagnoseExprIntendedAsTemplateName.
1852 return false;
1853 }
1854 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
1855 SourceLocation Less,
1856 SourceLocation Greater);
1857
1858 Decl *ActOnDeclarator(Scope *S, Declarator &D);
1859
1860 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
1861 MultiTemplateParamsArg TemplateParameterLists);
1862 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
1863 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
1864 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
1865 DeclarationName Name,
1866 SourceLocation Loc);
1867 void
1868 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
1869 SourceLocation FallbackLoc,
1870 SourceLocation ConstQualLoc = SourceLocation(),
1871 SourceLocation VolatileQualLoc = SourceLocation(),
1872 SourceLocation RestrictQualLoc = SourceLocation(),
1873 SourceLocation AtomicQualLoc = SourceLocation(),
1874 SourceLocation UnalignedQualLoc = SourceLocation());
1875
1876 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
1877 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
1878 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
1879 const LookupResult &R);
1880 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
1881 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
1882 const LookupResult &R);
1883 void CheckShadow(Scope *S, VarDecl *D);
1884
1885 /// Warn if 'E', which is an expression that is about to be modified, refers
1886 /// to a shadowing declaration.
1887 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
1888
1889 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
1890
1891private:
1892 /// Map of current shadowing declarations to shadowed declarations. Warn if
1893 /// it looks like the user is trying to modify the shadowing declaration.
1894 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
1895
1896public:
1897 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
1898 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
1899 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
1900 TypedefNameDecl *NewTD);
1901 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
1902 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1903 TypeSourceInfo *TInfo,
1904 LookupResult &Previous);
1905 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
1906 LookupResult &Previous, bool &Redeclaration);
1907 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
1908 TypeSourceInfo *TInfo,
1909 LookupResult &Previous,
1910 MultiTemplateParamsArg TemplateParamLists,
1911 bool &AddToScope,
1912 ArrayRef<BindingDecl *> Bindings = None);
1913 NamedDecl *
1914 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
1915 MultiTemplateParamsArg TemplateParamLists);
1916 // Returns true if the variable declaration is a redeclaration
1917 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
1918 void CheckVariableDeclarationType(VarDecl *NewVD);
1919 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
1920 Expr *Init);
1921 void CheckCompleteVariableDeclaration(VarDecl *VD);
1922 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
1923 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
1924
1925 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1926 TypeSourceInfo *TInfo,
1927 LookupResult &Previous,
1928 MultiTemplateParamsArg TemplateParamLists,
1929 bool &AddToScope);
1930 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1931
1932 bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
1933 bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
1934
1935 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
1936 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
1937 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1938 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
1939 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1940 // Returns true if the function declaration is a redeclaration
1941 bool CheckFunctionDeclaration(Scope *S,
1942 FunctionDecl *NewFD, LookupResult &Previous,
1943 bool IsMemberSpecialization);
1944 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
1945 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
1946 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
1947 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
1948 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
1949 SourceLocation Loc,
1950 QualType T);
1951 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
1952 SourceLocation NameLoc, IdentifierInfo *Name,
1953 QualType T, TypeSourceInfo *TSInfo,
1954 StorageClass SC);
1955 void ActOnParamDefaultArgument(Decl *param,
1956 SourceLocation EqualLoc,
1957 Expr *defarg);
1958 void ActOnParamUnparsedDefaultArgument(Decl *param,
1959 SourceLocation EqualLoc,
1960 SourceLocation ArgLoc);
1961 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
1962 bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
1963 SourceLocation EqualLoc);
1964
1965 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
1966 void ActOnUninitializedDecl(Decl *dcl);
1967 void ActOnInitializerError(Decl *Dcl);
1968
1969 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
1970 void ActOnCXXForRangeDecl(Decl *D);
1971 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
1972 IdentifierInfo *Ident,
1973 ParsedAttributes &Attrs,
1974 SourceLocation AttrEnd);
1975 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
1976 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
1977 void FinalizeDeclaration(Decl *D);
1978 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
1979 ArrayRef<Decl *> Group);
1980 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
1981
1982 /// Should be called on all declarations that might have attached
1983 /// documentation comments.
1984 void ActOnDocumentableDecl(Decl *D);
1985 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
1986
1987 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
1988 SourceLocation LocAfterDecls);
1989 void CheckForFunctionRedefinition(
1990 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
1991 SkipBodyInfo *SkipBody = nullptr);
1992 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
1993 MultiTemplateParamsArg TemplateParamLists,
1994 SkipBodyInfo *SkipBody = nullptr);
1995 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
1996 SkipBodyInfo *SkipBody = nullptr);
1997 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
1998 bool isObjCMethodDecl(Decl *D) {
1999 return D && isa<ObjCMethodDecl>(D);
2000 }
2001
2002 /// \brief Determine whether we can delay parsing the body of a function or
2003 /// function template until it is used, assuming we don't care about emitting
2004 /// code for that function.
2005 ///
2006 /// This will be \c false if we may need the body of the function in the
2007 /// middle of parsing an expression (where it's impractical to switch to
2008 /// parsing a different function), for instance, if it's constexpr in C++11
2009 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2010 bool canDelayFunctionBody(const Declarator &D);
2011
2012 /// \brief Determine whether we can skip parsing the body of a function
2013 /// definition, assuming we don't care about analyzing its body or emitting