Bug Summary

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

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/build/llvm-toolchain-snapshot-6.0~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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 three purposes:
1591/// 1) instantiating function templates
1592/// 2) substituting friend declarations
1593/// 3) substituting deduction guide declarations for nested class templates
1594Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
1595 TemplateParameterList *TemplateParams) {
1596 // Check whether there is already a function template specialization for
1597 // this declaration.
1598 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1599 if (FunctionTemplate && !TemplateParams) {
1600 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1601
1602 void *InsertPos = nullptr;
1603 FunctionDecl *SpecFunc
1604 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1605
1606 // If we already have a function template specialization, return it.
1607 if (SpecFunc)
1608 return SpecFunc;
1609 }
1610
1611 bool isFriend;
1612 if (FunctionTemplate)
1613 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1614 else
1615 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1616
1617 bool MergeWithParentScope = (TemplateParams != nullptr) ||
1618 Owner->isFunctionOrMethod() ||
1619 !(isa<Decl>(Owner) &&
1620 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1621 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1622
1623 SmallVector<ParmVarDecl *, 4> Params;
1624 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1625 if (!TInfo)
1626 return nullptr;
1627 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1628
1629 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1630 if (QualifierLoc) {
1631 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1632 TemplateArgs);
1633 if (!QualifierLoc)
1634 return nullptr;
1635 }
1636
1637 // If we're instantiating a local function declaration, put the result
1638 // in the enclosing namespace; otherwise we need to find the instantiated
1639 // context.
1640 DeclContext *DC;
1641 if (D->isLocalExternDecl()) {
1642 DC = Owner;
1643 SemaRef.adjustContextForLocalExternDecl(DC);
1644 } else if (isFriend && QualifierLoc) {
1645 CXXScopeSpec SS;
1646 SS.Adopt(QualifierLoc);
1647 DC = SemaRef.computeDeclContext(SS);
1648 if (!DC) return nullptr;
1649 } else {
1650 DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1651 TemplateArgs);
1652 }
1653
1654 DeclarationNameInfo NameInfo
1655 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1656
1657 FunctionDecl *Function;
1658 if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
1659 Function = CXXDeductionGuideDecl::Create(
1660 SemaRef.Context, DC, D->getInnerLocStart(), DGuide->isExplicit(),
1661 NameInfo, T, TInfo, D->getSourceRange().getEnd());
1662 if (DGuide->isCopyDeductionCandidate())
1663 cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
1664 } else {
1665 Function = FunctionDecl::Create(
1666 SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
1667 D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
1668 D->hasWrittenPrototype(), D->isConstexpr());
1669 Function->setRangeEnd(D->getSourceRange().getEnd());
1670 }
1671
1672 if (D->isInlined())
1673 Function->setImplicitlyInline();
1674
1675 if (QualifierLoc)
1676 Function->setQualifierInfo(QualifierLoc);
1677
1678 if (D->isLocalExternDecl())
1679 Function->setLocalExternDecl();
1680
1681 DeclContext *LexicalDC = Owner;
1682 if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
1683 assert(D->getDeclContext()->isFileContext())(static_cast <bool> (D->getDeclContext()->isFileContext
()) ? void (0) : __assert_fail ("D->getDeclContext()->isFileContext()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1683, __extension__ __PRETTY_FUNCTION__))
;
1684 LexicalDC = D->getDeclContext();
1685 }
1686
1687 Function->setLexicalDeclContext(LexicalDC);
1688
1689 // Attach the parameters
1690 for (unsigned P = 0; P < Params.size(); ++P)
1691 if (Params[P])
1692 Params[P]->setOwningFunction(Function);
1693 Function->setParams(Params);
1694
1695 if (TemplateParams) {
1696 // Our resulting instantiation is actually a function template, since we
1697 // are substituting only the outer template parameters. For example, given
1698 //
1699 // template<typename T>
1700 // struct X {
1701 // template<typename U> friend void f(T, U);
1702 // };
1703 //
1704 // X<int> x;
1705 //
1706 // We are instantiating the friend function template "f" within X<int>,
1707 // which means substituting int for T, but leaving "f" as a friend function
1708 // template.
1709 // Build the function template itself.
1710 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1711 Function->getLocation(),
1712 Function->getDeclName(),
1713 TemplateParams, Function);
1714 Function->setDescribedFunctionTemplate(FunctionTemplate);
1715
1716 FunctionTemplate->setLexicalDeclContext(LexicalDC);
1717
1718 if (isFriend && D->isThisDeclarationADefinition()) {
1719 FunctionTemplate->setInstantiatedFromMemberTemplate(
1720 D->getDescribedFunctionTemplate());
1721 }
1722 } else if (FunctionTemplate) {
1723 // Record this function template specialization.
1724 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1725 Function->setFunctionTemplateSpecialization(FunctionTemplate,
1726 TemplateArgumentList::CreateCopy(SemaRef.Context,
1727 Innermost),
1728 /*InsertPos=*/nullptr);
1729 } else if (isFriend && D->isThisDeclarationADefinition()) {
1730 // Do not connect the friend to the template unless it's actually a
1731 // definition. We don't want non-template functions to be marked as being
1732 // template instantiations.
1733 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1734 }
1735
1736 if (InitFunctionInstantiation(Function, D))
1737 Function->setInvalidDecl();
1738
1739 bool isExplicitSpecialization = false;
1740
1741 LookupResult Previous(
1742 SemaRef, Function->getDeclName(), SourceLocation(),
1743 D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
1744 : Sema::LookupOrdinaryName,
1745 D->isLocalExternDecl() ? Sema::ForExternalRedeclaration
1746 : SemaRef.forRedeclarationInCurContext());
1747
1748 if (DependentFunctionTemplateSpecializationInfo *Info
1749 = D->getDependentSpecializationInfo()) {
1750 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1750, __extension__ __PRETTY_FUNCTION__))
;
1751
1752 // This needs to be set now for future sanity.
1753 Function->setObjectOfFriendDecl();
1754
1755 // Instantiate the explicit template arguments.
1756 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1757 Info->getRAngleLoc());
1758 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1759 ExplicitArgs, TemplateArgs))
1760 return nullptr;
1761
1762 // Map the candidate templates to their instantiations.
1763 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1764 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1765 Info->getTemplate(I),
1766 TemplateArgs);
1767 if (!Temp) return nullptr;
1768
1769 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1770 }
1771
1772 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1773 &ExplicitArgs,
1774 Previous))
1775 Function->setInvalidDecl();
1776
1777 isExplicitSpecialization = true;
1778
1779 } else if (TemplateParams || !FunctionTemplate) {
1780 // Look only into the namespace where the friend would be declared to
1781 // find a previous declaration. This is the innermost enclosing namespace,
1782 // as described in ActOnFriendFunctionDecl.
1783 SemaRef.LookupQualifiedName(Previous, DC);
1784
1785 // In C++, the previous declaration we find might be a tag type
1786 // (class or enum). In this case, the new declaration will hide the
1787 // tag type. Note that this does does not apply if we're declaring a
1788 // typedef (C++ [dcl.typedef]p4).
1789 if (Previous.isSingleTagDecl())
1790 Previous.clear();
1791 }
1792
1793 if (isFriend)
1794 Function->setObjectOfFriendDecl();
1795
1796 SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
1797 isExplicitSpecialization);
1798
1799 NamedDecl *PrincipalDecl = (TemplateParams
1800 ? cast<NamedDecl>(FunctionTemplate)
1801 : Function);
1802
1803 // If the original function was part of a friend declaration,
1804 // inherit its namespace state and add it to the owner.
1805 if (isFriend) {
1806 PrincipalDecl->setObjectOfFriendDecl();
1807 DC->makeDeclVisibleInContext(PrincipalDecl);
1808
1809 bool QueuedInstantiation = false;
1810
1811 // C++11 [temp.friend]p4 (DR329):
1812 // When a function is defined in a friend function declaration in a class
1813 // template, the function is instantiated when the function is odr-used.
1814 // The same restrictions on multiple declarations and definitions that
1815 // apply to non-template function declarations and definitions also apply
1816 // to these implicit definitions.
1817 if (D->isThisDeclarationADefinition()) {
1818 // Check for a function body.
1819 const FunctionDecl *Definition = nullptr;
1820 if (Function->isDefined(Definition) &&
1821 Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1822 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1823 << Function->getDeclName();
1824 SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1825 }
1826 // Check for redefinitions due to other instantiations of this or
1827 // a similar friend function.
1828 else for (auto R : Function->redecls()) {
1829 if (R == Function)
1830 continue;
1831
1832 // If some prior declaration of this function has been used, we need
1833 // to instantiate its definition.
1834 if (!QueuedInstantiation && R->isUsed(false)) {
1835 if (MemberSpecializationInfo *MSInfo =
1836 Function->getMemberSpecializationInfo()) {
1837 if (MSInfo->getPointOfInstantiation().isInvalid()) {
1838 SourceLocation Loc = R->getLocation(); // FIXME
1839 MSInfo->setPointOfInstantiation(Loc);
1840 SemaRef.PendingLocalImplicitInstantiations.push_back(
1841 std::make_pair(Function, Loc));
1842 QueuedInstantiation = true;
1843 }
1844 }
1845 }
1846
1847 // If some prior declaration of this function was a friend with an
1848 // uninstantiated definition, reject it.
1849 if (R->getFriendObjectKind()) {
1850 if (const FunctionDecl *RPattern =
1851 R->getTemplateInstantiationPattern()) {
1852 if (RPattern->isDefined(RPattern)) {
1853 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1854 << Function->getDeclName();
1855 SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1856 break;
1857 }
1858 }
1859 }
1860 }
1861 }
1862
1863 // Check the template parameter list against the previous declaration. The
1864 // goal here is to pick up default arguments added since the friend was
1865 // declared; we know the template parameter lists match, since otherwise
1866 // we would not have picked this template as the previous declaration.
1867 if (TemplateParams && FunctionTemplate->getPreviousDecl()) {
1868 SemaRef.CheckTemplateParameterList(
1869 TemplateParams,
1870 FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
1871 Function->isThisDeclarationADefinition()
1872 ? Sema::TPC_FriendFunctionTemplateDefinition
1873 : Sema::TPC_FriendFunctionTemplate);
1874 }
1875 }
1876
1877 if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1878 DC->makeDeclVisibleInContext(PrincipalDecl);
1879
1880 if (Function->isOverloadedOperator() && !DC->isRecord() &&
1881 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1882 PrincipalDecl->setNonMemberOperator();
1883
1884 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 1884, __extension__ __PRETTY_FUNCTION__))
;
1885 return Function;
1886}
1887
1888Decl *
1889TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
1890 TemplateParameterList *TemplateParams,
1891 bool IsClassScopeSpecialization) {
1892 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1893 if (FunctionTemplate && !TemplateParams) {
1894 // We are creating a function template specialization from a function
1895 // template. Check whether there is already a function template
1896 // specialization for this particular set of template arguments.
1897 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1898
1899 void *InsertPos = nullptr;
1900 FunctionDecl *SpecFunc
1901 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1902
1903 // If we already have a function template specialization, return it.
1904 if (SpecFunc)
1905 return SpecFunc;
1906 }
1907
1908 bool isFriend;
1909 if (FunctionTemplate)
1910 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1911 else
1912 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1913
1914 bool MergeWithParentScope = (TemplateParams != nullptr) ||
1915 !(isa<Decl>(Owner) &&
1916 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1917 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1918
1919 // Instantiate enclosing template arguments for friends.
1920 SmallVector<TemplateParameterList *, 4> TempParamLists;
1921 unsigned NumTempParamLists = 0;
1922 if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1923 TempParamLists.resize(NumTempParamLists);
1924 for (unsigned I = 0; I != NumTempParamLists; ++I) {
1925 TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1926 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1927 if (!InstParams)
1928 return nullptr;
1929 TempParamLists[I] = InstParams;
1930 }
1931 }
1932
1933 SmallVector<ParmVarDecl *, 4> Params;
1934 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1935 if (!TInfo)
1936 return nullptr;
1937 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1938
1939 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1940 if (QualifierLoc) {
1941 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1942 TemplateArgs);
1943 if (!QualifierLoc)
1944 return nullptr;
1945 }
1946
1947 DeclContext *DC = Owner;
1948 if (isFriend) {
1949 if (QualifierLoc) {
1950 CXXScopeSpec SS;
1951 SS.Adopt(QualifierLoc);
1952 DC = SemaRef.computeDeclContext(SS);
1953
1954 if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1955 return nullptr;
1956 } else {
1957 DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1958 D->getDeclContext(),
1959 TemplateArgs);
1960 }
1961 if (!DC) return nullptr;
1962 }
1963
1964 // Build the instantiated method declaration.
1965 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1966 CXXMethodDecl *Method = nullptr;
1967
1968 SourceLocation StartLoc = D->getInnerLocStart();
1969 DeclarationNameInfo NameInfo
1970 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1971 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1972 Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1973 StartLoc, NameInfo, T, TInfo,
1974 Constructor->isExplicit(),
1975 Constructor->isInlineSpecified(),
1976 false, Constructor->isConstexpr());
1977 Method->setRangeEnd(Constructor->getLocEnd());
1978 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1979 Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1980 StartLoc, NameInfo, T, TInfo,
1981 Destructor->isInlineSpecified(),
1982 false);
1983 Method->setRangeEnd(Destructor->getLocEnd());
1984 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1985 Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1986 StartLoc, NameInfo, T, TInfo,
1987 Conversion->isInlineSpecified(),
1988 Conversion->isExplicit(),
1989 Conversion->isConstexpr(),
1990 Conversion->getLocEnd());
1991 } else {
1992 StorageClass SC = D->isStatic() ? SC_Static : SC_None;
1993 Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1994 StartLoc, NameInfo, T, TInfo,
1995 SC, D->isInlineSpecified(),
1996 D->isConstexpr(), D->getLocEnd());
1997 }
1998
1999 if (D->isInlined())
2000 Method->setImplicitlyInline();
2001
2002 if (QualifierLoc)
2003 Method->setQualifierInfo(QualifierLoc);
2004
2005 if (TemplateParams) {
2006 // Our resulting instantiation is actually a function template, since we
2007 // are substituting only the outer template parameters. For example, given
2008 //
2009 // template<typename T>
2010 // struct X {
2011 // template<typename U> void f(T, U);
2012 // };
2013 //
2014 // X<int> x;
2015 //
2016 // We are instantiating the member template "f" within X<int>, which means
2017 // substituting int for T, but leaving "f" as a member function template.
2018 // Build the function template itself.
2019 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
2020 Method->getLocation(),
2021 Method->getDeclName(),
2022 TemplateParams, Method);
2023 if (isFriend) {
2024 FunctionTemplate->setLexicalDeclContext(Owner);
2025 FunctionTemplate->setObjectOfFriendDecl();
2026 } else if (D->isOutOfLine())
2027 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
2028 Method->setDescribedFunctionTemplate(FunctionTemplate);
2029 } else if (FunctionTemplate) {
2030 // Record this function template specialization.
2031 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2032 Method->setFunctionTemplateSpecialization(FunctionTemplate,
2033 TemplateArgumentList::CreateCopy(SemaRef.Context,
2034 Innermost),
2035 /*InsertPos=*/nullptr);
2036 } else if (!isFriend) {
2037 // Record that this is an instantiation of a member function.
2038 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
2039 }
2040
2041 // If we are instantiating a member function defined
2042 // out-of-line, the instantiation will have the same lexical
2043 // context (which will be a namespace scope) as the template.
2044 if (isFriend) {
2045 if (NumTempParamLists)
2046 Method->setTemplateParameterListsInfo(
2047 SemaRef.Context,
2048 llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
2049
2050 Method->setLexicalDeclContext(Owner);
2051 Method->setObjectOfFriendDecl();
2052 } else if (D->isOutOfLine())
2053 Method->setLexicalDeclContext(D->getLexicalDeclContext());
2054
2055 // Attach the parameters
2056 for (unsigned P = 0; P < Params.size(); ++P)
2057 Params[P]->setOwningFunction(Method);
2058 Method->setParams(Params);
2059
2060 if (InitMethodInstantiation(Method, D))
2061 Method->setInvalidDecl();
2062
2063 LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
2064 Sema::ForExternalRedeclaration);
2065
2066 if (!FunctionTemplate || TemplateParams || isFriend) {
2067 SemaRef.LookupQualifiedName(Previous, Record);
2068
2069 // In C++, the previous declaration we find might be a tag type
2070 // (class or enum). In this case, the new declaration will hide the
2071 // tag type. Note that this does does not apply if we're declaring a
2072 // typedef (C++ [dcl.typedef]p4).
2073 if (Previous.isSingleTagDecl())
2074 Previous.clear();
2075 }
2076
2077 if (!IsClassScopeSpecialization)
2078 SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);
2079
2080 if (D->isPure())
2081 SemaRef.CheckPureMethod(Method, SourceRange());
2082
2083 // Propagate access. For a non-friend declaration, the access is
2084 // whatever we're propagating from. For a friend, it should be the
2085 // previous declaration we just found.
2086 if (isFriend && Method->getPreviousDecl())
2087 Method->setAccess(Method->getPreviousDecl()->getAccess());
2088 else
2089 Method->setAccess(D->getAccess());
2090 if (FunctionTemplate)
2091 FunctionTemplate->setAccess(Method->getAccess());
2092
2093 SemaRef.CheckOverrideControl(Method);
2094
2095 // If a function is defined as defaulted or deleted, mark it as such now.
2096 if (D->isExplicitlyDefaulted())
2097 SemaRef.SetDeclDefaulted(Method, Method->getLocation());
2098 if (D->isDeletedAsWritten())
2099 SemaRef.SetDeclDeleted(Method, Method->getLocation());
2100
2101 // If there's a function template, let our caller handle it.
2102 if (FunctionTemplate) {
2103 // do nothing
2104
2105 // Don't hide a (potentially) valid declaration with an invalid one.
2106 } else if (Method->isInvalidDecl() && !Previous.empty()) {
2107 // do nothing
2108
2109 // Otherwise, check access to friends and make them visible.
2110 } else if (isFriend) {
2111 // We only need to re-check access for methods which we didn't
2112 // manage to match during parsing.
2113 if (!D->getPreviousDecl())
2114 SemaRef.CheckFriendAccess(Method);
2115
2116 Record->makeDeclVisibleInContext(Method);
2117
2118 // Otherwise, add the declaration. We don't need to do this for
2119 // class-scope specializations because we'll have matched them with
2120 // the appropriate template.
2121 } else if (!IsClassScopeSpecialization) {
2122 Owner->addDecl(Method);
2123 }
2124
2125 return Method;
2126}
2127
2128Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2129 return VisitCXXMethodDecl(D);
2130}
2131
2132Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2133 return VisitCXXMethodDecl(D);
2134}
2135
2136Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
2137 return VisitCXXMethodDecl(D);
2138}
2139
2140Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
2141 return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2142 /*ExpectParameterPack=*/ false);
2143}
2144
2145Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2146 TemplateTypeParmDecl *D) {
2147 // TODO: don't always clone when decls are refcounted.
2148 assert(D->getTypeForDecl()->isTemplateTypeParmType())(static_cast <bool> (D->getTypeForDecl()->isTemplateTypeParmType
()) ? void (0) : __assert_fail ("D->getTypeForDecl()->isTemplateTypeParmType()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2148, __extension__ __PRETTY_FUNCTION__))
;
2149
2150 TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
2151 SemaRef.Context, Owner, D->getLocStart(), D->getLocation(),
2152 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
2153 D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack());
2154 Inst->setAccess(AS_public);
2155
2156 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2157 TypeSourceInfo *InstantiatedDefaultArg =
2158 SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2159 D->getDefaultArgumentLoc(), D->getDeclName());
2160 if (InstantiatedDefaultArg)
2161 Inst->setDefaultArgument(InstantiatedDefaultArg);
2162 }
2163
2164 // Introduce this template parameter's instantiation into the instantiation
2165 // scope.
2166 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2167
2168 return Inst;
2169}
2170
2171Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2172 NonTypeTemplateParmDecl *D) {
2173 // Substitute into the type of the non-type template parameter.
2174 TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
2175 SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2176 SmallVector<QualType, 4> ExpandedParameterPackTypes;
2177 bool IsExpandedParameterPack = false;
2178 TypeSourceInfo *DI;
2179 QualType T;
2180 bool Invalid = false;
2181
2182 if (D->isExpandedParameterPack()) {
2183 // The non-type template parameter pack is an already-expanded pack
2184 // expansion of types. Substitute into each of the expanded types.
2185 ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2186 ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2187 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2188 TypeSourceInfo *NewDI =
2189 SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2190 D->getLocation(), D->getDeclName());
2191 if (!NewDI)
2192 return nullptr;
2193
2194 QualType NewT =
2195 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2196 if (NewT.isNull())
2197 return nullptr;
2198
2199 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2200 ExpandedParameterPackTypes.push_back(NewT);
2201 }
2202
2203 IsExpandedParameterPack = true;
2204 DI = D->getTypeSourceInfo();
2205 T = DI->getType();
2206 } else if (D->isPackExpansion()) {
2207 // The non-type template parameter pack's type is a pack expansion of types.
2208 // Determine whether we need to expand this parameter pack into separate
2209 // types.
2210 PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
2211 TypeLoc Pattern = Expansion.getPatternLoc();
2212 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2213 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2214
2215 // Determine whether the set of unexpanded parameter packs can and should
2216 // be expanded.
2217 bool Expand = true;
2218 bool RetainExpansion = false;
2219 Optional<unsigned> OrigNumExpansions
2220 = Expansion.getTypePtr()->getNumExpansions();
2221 Optional<unsigned> NumExpansions = OrigNumExpansions;
2222 if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2223 Pattern.getSourceRange(),
2224 Unexpanded,
2225 TemplateArgs,
2226 Expand, RetainExpansion,
2227 NumExpansions))
2228 return nullptr;
2229
2230 if (Expand) {
2231 for (unsigned I = 0; I != *NumExpansions; ++I) {
2232 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2233 TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2234 D->getLocation(),
2235 D->getDeclName());
2236 if (!NewDI)
2237 return nullptr;
2238
2239 QualType NewT =
2240 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2241 if (NewT.isNull())
2242 return nullptr;
2243
2244 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2245 ExpandedParameterPackTypes.push_back(NewT);
2246 }
2247
2248 // Note that we have an expanded parameter pack. The "type" of this
2249 // expanded parameter pack is the original expansion type, but callers
2250 // will end up using the expanded parameter pack types for type-checking.
2251 IsExpandedParameterPack = true;
2252 DI = D->getTypeSourceInfo();
2253 T = DI->getType();
2254 } else {
2255 // We cannot fully expand the pack expansion now, so substitute into the
2256 // pattern and create a new pack expansion type.
2257 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2258 TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2259 D->getLocation(),
2260 D->getDeclName());
2261 if (!NewPattern)
2262 return nullptr;
2263
2264 SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
2265 DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2266 NumExpansions);
2267 if (!DI)
2268 return nullptr;
2269
2270 T = DI->getType();
2271 }
2272 } else {
2273 // Simple case: substitution into a parameter that is not a parameter pack.
2274 DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2275 D->getLocation(), D->getDeclName());
2276 if (!DI)
2277 return nullptr;
2278
2279 // Check that this type is acceptable for a non-type template parameter.
2280 T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
2281 if (T.isNull()) {
2282 T = SemaRef.Context.IntTy;
2283 Invalid = true;
2284 }
2285 }
2286
2287 NonTypeTemplateParmDecl *Param;
2288 if (IsExpandedParameterPack)
2289 Param = NonTypeTemplateParmDecl::Create(
2290 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2291 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2292 D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
2293 ExpandedParameterPackTypesAsWritten);
2294 else
2295 Param = NonTypeTemplateParmDecl::Create(
2296 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2297 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2298 D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
2299
2300 Param->setAccess(AS_public);
2301 if (Invalid)
2302 Param->setInvalidDecl();
2303
2304 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2305 EnterExpressionEvaluationContext ConstantEvaluated(
2306 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
2307 ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2308 if (!Value.isInvalid())
2309 Param->setDefaultArgument(Value.get());
2310 }
2311
2312 // Introduce this template parameter's instantiation into the instantiation
2313 // scope.
2314 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2315 return Param;
2316}
2317
2318static void collectUnexpandedParameterPacks(
2319 Sema &S,
2320 TemplateParameterList *Params,
2321 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
2322 for (const auto &P : *Params) {
2323 if (P->isTemplateParameterPack())
2324 continue;
2325 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2326 S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2327 Unexpanded);
2328 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2329 collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2330 Unexpanded);
2331 }
2332}
2333
2334Decl *
2335TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2336 TemplateTemplateParmDecl *D) {
2337 // Instantiate the template parameter list of the template template parameter.
2338 TemplateParameterList *TempParams = D->getTemplateParameters();
2339 TemplateParameterList *InstParams;
2340 SmallVector<TemplateParameterList*, 8> ExpandedParams;
2341
2342 bool IsExpandedParameterPack = false;
2343
2344 if (D->isExpandedParameterPack()) {
2345 // The template template parameter pack is an already-expanded pack
2346 // expansion of template parameters. Substitute into each of the expanded
2347 // parameters.
2348 ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2349 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2350 I != N; ++I) {
2351 LocalInstantiationScope Scope(SemaRef);
2352 TemplateParameterList *Expansion =
2353 SubstTemplateParams(D->getExpansionTemplateParameters(I));
2354 if (!Expansion)
2355 return nullptr;
2356 ExpandedParams.push_back(Expansion);
2357 }
2358
2359 IsExpandedParameterPack = true;
2360 InstParams = TempParams;
2361 } else if (D->isPackExpansion()) {
2362 // The template template parameter pack expands to a pack of template
2363 // template parameters. Determine whether we need to expand this parameter
2364 // pack into separate parameters.
2365 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2366 collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
2367 Unexpanded);
2368
2369 // Determine whether the set of unexpanded parameter packs can and should
2370 // be expanded.
2371 bool Expand = true;
2372 bool RetainExpansion = false;
2373 Optional<unsigned> NumExpansions;
2374 if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
2375 TempParams->getSourceRange(),
2376 Unexpanded,
2377 TemplateArgs,
2378 Expand, RetainExpansion,
2379 NumExpansions))
2380 return nullptr;
2381
2382 if (Expand) {
2383 for (unsigned I = 0; I != *NumExpansions; ++I) {
2384 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2385 LocalInstantiationScope Scope(SemaRef);
2386 TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2387 if (!Expansion)
2388 return nullptr;
2389 ExpandedParams.push_back(Expansion);
2390 }
2391
2392 // Note that we have an expanded parameter pack. The "type" of this
2393 // expanded parameter pack is the original expansion type, but callers
2394 // will end up using the expanded parameter pack types for type-checking.
2395 IsExpandedParameterPack = true;
2396 InstParams = TempParams;
2397 } else {
2398 // We cannot fully expand the pack expansion now, so just substitute
2399 // into the pattern.
2400 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2401
2402 LocalInstantiationScope Scope(SemaRef);
2403 InstParams = SubstTemplateParams(TempParams);
2404 if (!InstParams)
2405 return nullptr;
2406 }
2407 } else {
2408 // Perform the actual substitution of template parameters within a new,
2409 // local instantiation scope.
2410 LocalInstantiationScope Scope(SemaRef);
2411 InstParams = SubstTemplateParams(TempParams);
2412 if (!InstParams)
2413 return nullptr;
2414 }
2415
2416 // Build the template template parameter.
2417 TemplateTemplateParmDecl *Param;
2418 if (IsExpandedParameterPack)
2419 Param = TemplateTemplateParmDecl::Create(
2420 SemaRef.Context, Owner, D->getLocation(),
2421 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2422 D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
2423 else
2424 Param = TemplateTemplateParmDecl::Create(
2425 SemaRef.Context, Owner, D->getLocation(),
2426 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2427 D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
2428 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2429 NestedNameSpecifierLoc QualifierLoc =
2430 D->getDefaultArgument().getTemplateQualifierLoc();
2431 QualifierLoc =
2432 SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2433 TemplateName TName = SemaRef.SubstTemplateName(
2434 QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2435 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2436 if (!TName.isNull())
2437 Param->setDefaultArgument(
2438 SemaRef.Context,
2439 TemplateArgumentLoc(TemplateArgument(TName),
2440 D->getDefaultArgument().getTemplateQualifierLoc(),
2441 D->getDefaultArgument().getTemplateNameLoc()));
2442 }
2443 Param->setAccess(AS_public);
2444
2445 // Introduce this template parameter's instantiation into the instantiation
2446 // scope.
2447 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2448
2449 return Param;
2450}
2451
2452Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2453 // Using directives are never dependent (and never contain any types or
2454 // expressions), so they require no explicit instantiation work.
2455
2456 UsingDirectiveDecl *Inst
2457 = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2458 D->getNamespaceKeyLocation(),
2459 D->getQualifierLoc(),
2460 D->getIdentLocation(),
2461 D->getNominatedNamespace(),
2462 D->getCommonAncestor());
2463
2464 // Add the using directive to its declaration context
2465 // only if this is not a function or method.
2466 if (!Owner->isFunctionOrMethod())
2467 Owner->addDecl(Inst);
2468
2469 return Inst;
2470}
2471
2472Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2473
2474 // The nested name specifier may be dependent, for example
2475 // template <typename T> struct t {
2476 // struct s1 { T f1(); };
2477 // struct s2 : s1 { using s1::f1; };
2478 // };
2479 // template struct t<int>;
2480 // Here, in using s1::f1, s1 refers to t<T>::s1;
2481 // we need to substitute for t<int>::s1.
2482 NestedNameSpecifierLoc QualifierLoc
2483 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2484 TemplateArgs);
2485 if (!QualifierLoc)
2486 return nullptr;
2487
2488 // For an inheriting constructor declaration, the name of the using
2489 // declaration is the name of a constructor in this class, not in the
2490 // base class.
2491 DeclarationNameInfo NameInfo = D->getNameInfo();
2492 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2493 if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
2494 NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
2495 SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
2496
2497 // We only need to do redeclaration lookups if we're in a class
2498 // scope (in fact, it's not really even possible in non-class
2499 // scopes).
2500 bool CheckRedeclaration = Owner->isRecord();
2501
2502 LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2503 Sema::ForVisibleRedeclaration);
2504
2505 UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2506 D->getUsingLoc(),
2507 QualifierLoc,
2508 NameInfo,
2509 D->hasTypename());
2510
2511 CXXScopeSpec SS;
2512 SS.Adopt(QualifierLoc);
2513 if (CheckRedeclaration) {
2514 Prev.setHideTags(false);
2515 SemaRef.LookupQualifiedName(Prev, Owner);
2516
2517 // Check for invalid redeclarations.
2518 if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2519 D->hasTypename(), SS,
2520 D->getLocation(), Prev))
2521 NewUD->setInvalidDecl();
2522
2523 }
2524
2525 if (!NewUD->isInvalidDecl() &&
2526 SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
2527 SS, NameInfo, D->getLocation()))
2528 NewUD->setInvalidDecl();
2529
2530 SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2531 NewUD->setAccess(D->getAccess());
2532 Owner->addDecl(NewUD);
2533
2534 // Don't process the shadow decls for an invalid decl.
2535 if (NewUD->isInvalidDecl())
2536 return NewUD;
2537
2538 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2539 SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
2540
2541 bool isFunctionScope = Owner->isFunctionOrMethod();
2542
2543 // Process the shadow decls.
2544 for (auto *Shadow : D->shadows()) {
2545 // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
2546 // reconstruct it in the case where it matters.
2547 NamedDecl *OldTarget = Shadow->getTargetDecl();
2548 if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
2549 if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
2550 OldTarget = BaseShadow;
2551
2552 NamedDecl *InstTarget =
2553 cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2554 Shadow->getLocation(), OldTarget, TemplateArgs));
2555 if (!InstTarget)
2556 return nullptr;
2557
2558 UsingShadowDecl *PrevDecl = nullptr;
2559 if (CheckRedeclaration) {
2560 if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2561 continue;
2562 } else if (UsingShadowDecl *OldPrev =
2563 getPreviousDeclForInstantiation(Shadow)) {
2564 PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2565 Shadow->getLocation(), OldPrev, TemplateArgs));
2566 }
2567
2568 UsingShadowDecl *InstShadow =
2569 SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2570 PrevDecl);
2571 SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2572
2573 if (isFunctionScope)
2574 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2575 }
2576
2577 return NewUD;
2578}
2579
2580Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2581 // Ignore these; we handle them in bulk when processing the UsingDecl.
2582 return nullptr;
2583}
2584
2585Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
2586 ConstructorUsingShadowDecl *D) {
2587 // Ignore these; we handle them in bulk when processing the UsingDecl.
2588 return nullptr;
2589}
2590
2591template <typename T>
2592Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
2593 T *D, bool InstantiatingPackElement) {
2594 // If this is a pack expansion, expand it now.
2595 if (D->isPackExpansion() && !InstantiatingPackElement) {
2596 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2597 SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
2598 SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
2599
2600 // Determine whether the set of unexpanded parameter packs can and should
2601 // be expanded.
2602 bool Expand = true;
2603 bool RetainExpansion = false;
2604 Optional<unsigned> NumExpansions;
2605 if (SemaRef.CheckParameterPacksForExpansion(
2606 D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
2607 Expand, RetainExpansion, NumExpansions))
2608 return nullptr;
2609
2610 // This declaration cannot appear within a function template signature,
2611 // so we can't have a partial argument list for a parameter pack.
2612 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2613, __extension__ __PRETTY_FUNCTION__))
2613 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2613, __extension__ __PRETTY_FUNCTION__))
;
2614
2615 if (!Expand) {
2616 // We cannot fully expand the pack expansion now, so substitute into the
2617 // pattern and create a new pack expansion.
2618 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2619 return instantiateUnresolvedUsingDecl(D, true);
2620 }
2621
2622 // Within a function, we don't have any normal way to check for conflicts
2623 // between shadow declarations from different using declarations in the
2624 // same pack expansion, but this is always ill-formed because all expansions
2625 // must produce (conflicting) enumerators.
2626 //
2627 // Sadly we can't just reject this in the template definition because it
2628 // could be valid if the pack is empty or has exactly one expansion.
2629 if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
2630 SemaRef.Diag(D->getEllipsisLoc(),
2631 diag::err_using_decl_redeclaration_expansion);
2632 return nullptr;
2633 }
2634
2635 // Instantiate the slices of this pack and build a UsingPackDecl.
2636 SmallVector<NamedDecl*, 8> Expansions;
2637 for (unsigned I = 0; I != *NumExpansions; ++I) {
2638 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2639 Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
2640 if (!Slice)
2641 return nullptr;
2642 // Note that we can still get unresolved using declarations here, if we
2643 // had arguments for all packs but the pattern also contained other
2644 // template arguments (this only happens during partial substitution, eg
2645 // into the body of a generic lambda in a function template).
2646 Expansions.push_back(cast<NamedDecl>(Slice));
2647 }
2648
2649 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2650 if (isDeclWithinFunction(D))
2651 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2652 return NewD;
2653 }
2654
2655 UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
2656 SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
2657
2658 NestedNameSpecifierLoc QualifierLoc
2659 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2660 TemplateArgs);
2661 if (!QualifierLoc)
2662 return nullptr;
2663
2664 CXXScopeSpec SS;
2665 SS.Adopt(QualifierLoc);
2666
2667 DeclarationNameInfo NameInfo
2668 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2669
2670 // Produce a pack expansion only if we're not instantiating a particular
2671 // slice of a pack expansion.
2672 bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
2673 SemaRef.ArgumentPackSubstitutionIndex != -1;
2674 SourceLocation EllipsisLoc =
2675 InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
2676
2677 NamedDecl *UD = SemaRef.BuildUsingDeclaration(
2678 /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
2679 /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc, nullptr,
2680 /*IsInstantiation*/ true);
2681 if (UD)
2682 SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
2683
2684 return UD;
2685}
2686
2687Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
2688 UnresolvedUsingTypenameDecl *D) {
2689 return instantiateUnresolvedUsingDecl(D);
2690}
2691
2692Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
2693 UnresolvedUsingValueDecl *D) {
2694 return instantiateUnresolvedUsingDecl(D);
2695}
2696
2697Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
2698 SmallVector<NamedDecl*, 8> Expansions;
2699 for (auto *UD : D->expansions()) {
2700 if (auto *NewUD =
2701 SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
2702 Expansions.push_back(cast<NamedDecl>(NewUD));
2703 else
2704 return nullptr;
2705 }
2706
2707 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2708 if (isDeclWithinFunction(D))
2709 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2710 return NewD;
2711}
2712
2713Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2714 ClassScopeFunctionSpecializationDecl *Decl) {
2715 CXXMethodDecl *OldFD = Decl->getSpecialization();
2716 CXXMethodDecl *NewFD =
2717 cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
2718 if (!NewFD)
2719 return nullptr;
2720
2721 LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
2722 Sema::ForExternalRedeclaration);
2723
2724 TemplateArgumentListInfo TemplateArgs;
2725 TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
2726 if (Decl->hasExplicitTemplateArgs()) {
2727 TemplateArgs = Decl->templateArgs();
2728 TemplateArgsPtr = &TemplateArgs;
2729 }
2730
2731 SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
2732 if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2733 Previous)) {
2734 NewFD->setInvalidDecl();
2735 return NewFD;
2736 }
2737
2738 // Associate the specialization with the pattern.
2739 FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2740 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2740, __extension__ __PRETTY_FUNCTION__))
;
2741 SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2742
2743 return NewFD;
2744}
2745
2746Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2747 OMPThreadPrivateDecl *D) {
2748 SmallVector<Expr *, 5> Vars;
2749 for (auto *I : D->varlists()) {
2750 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2751 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2751, __extension__ __PRETTY_FUNCTION__))
;
2752 Vars.push_back(Var);
2753 }
2754
2755 OMPThreadPrivateDecl *TD =
2756 SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2757
2758 TD->setAccess(AS_public);
2759 Owner->addDecl(TD);
2760
2761 return TD;
2762}
2763
2764Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
2765 OMPDeclareReductionDecl *D) {
2766 // Instantiate type and check if it is allowed.
2767 QualType SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
2768 D->getLocation(),
2769 ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
2770 D->getLocation(), DeclarationName())));
2771 if (SubstReductionType.isNull())
2772 return nullptr;
2773 bool IsCorrect = !SubstReductionType.isNull();
2774 // Create instantiated copy.
2775 std::pair<QualType, SourceLocation> ReductionTypes[] = {
2776 std::make_pair(SubstReductionType, D->getLocation())};
2777 auto *PrevDeclInScope = D->getPrevDeclInScope();
2778 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
2779 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
2780 SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
2781 ->get<Decl *>());
2782 }
2783 auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
2784 /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
2785 PrevDeclInScope);
2786 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
2787 if (isDeclWithinFunction(NewDRD))
2788 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
2789 Expr *SubstCombiner = nullptr;
2790 Expr *SubstInitializer = nullptr;
2791 // Combiners instantiation sequence.
2792 if (D->getCombiner()) {
2793 SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
2794 /*S=*/nullptr, NewDRD);
2795 const char *Names[] = {"omp_in", "omp_out"};
2796 for (auto &Name : Names) {
2797 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2798 auto OldLookup = D->lookup(DN);
2799 auto Lookup = NewDRD->lookup(DN);
2800 if (!OldLookup.empty() && !Lookup.empty()) {
2801 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2801, __extension__ __PRETTY_FUNCTION__))
;
2802 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldLookup.front(),
2803 Lookup.front());
2804 }
2805 }
2806 SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
2807 SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
2808 // Initializers instantiation sequence.
2809 if (D->getInitializer()) {
2810 VarDecl *OmpPrivParm =
2811 SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
2812 /*S=*/nullptr, NewDRD);
2813 const char *Names[] = {"omp_orig", "omp_priv"};
2814 for (auto &Name : Names) {
2815 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2816 auto OldLookup = D->lookup(DN);
2817 auto Lookup = NewDRD->lookup(DN);
2818 if (!OldLookup.empty() && !Lookup.empty()) {
2819 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2819, __extension__ __PRETTY_FUNCTION__))
;
2820 auto *OldVD = cast<VarDecl>(OldLookup.front());
2821 auto *NewVD = cast<VarDecl>(Lookup.front());
2822 SemaRef.InstantiateVariableInitializer(NewVD, OldVD, TemplateArgs);
2823 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldVD, NewVD);
2824 }
2825 }
2826 if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
2827 SubstInitializer =
2828 SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
2829 } else {
2830 IsCorrect = IsCorrect && OmpPrivParm->hasInit();
2831 }
2832 SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(
2833 NewDRD, SubstInitializer, OmpPrivParm);
2834 }
2835 IsCorrect =
2836 IsCorrect && SubstCombiner &&
2837 (!D->getInitializer() ||
2838 (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
2839 SubstInitializer) ||
2840 (D->getInitializerKind() != OMPDeclareReductionDecl::CallInit &&
2841 !SubstInitializer && !SubstInitializer));
2842 } else
2843 IsCorrect = false;
2844
2845 (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
2846 IsCorrect);
2847
2848 return NewDRD;
2849}
2850
2851Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
2852 OMPCapturedExprDecl * /*D*/) {
2853 llvm_unreachable("Should not be met in templates")::llvm::llvm_unreachable_internal("Should not be met in templates"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2853)
;
2854}
2855
2856Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
2857 return VisitFunctionDecl(D, nullptr);
2858}
2859
2860Decl *
2861TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
2862 return VisitFunctionDecl(D, nullptr);
2863}
2864
2865Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
2866 return VisitCXXMethodDecl(D, nullptr);
2867}
2868
2869Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2870 llvm_unreachable("There are only CXXRecordDecls in C++")::llvm::llvm_unreachable_internal("There are only CXXRecordDecls in C++"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2870)
;
2871}
2872
2873Decl *
2874TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2875 ClassTemplateSpecializationDecl *D) {
2876 // As a MS extension, we permit class-scope explicit specialization
2877 // of member class templates.
2878 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
2879 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2882, __extension__ __PRETTY_FUNCTION__))
2880 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2882, __extension__ __PRETTY_FUNCTION__))
2881 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2882, __extension__ __PRETTY_FUNCTION__))
2882 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 2882, __extension__ __PRETTY_FUNCTION__))
;
2883
2884 // Lookup the already-instantiated declaration in the instantiation
2885 // of the class template. FIXME: Diagnose or assert if this fails?
2886 DeclContext::lookup_result Found
2887 = Owner->lookup(ClassTemplate->getDeclName());
2888 if (Found.empty())
2889 return nullptr;
2890 ClassTemplateDecl *InstClassTemplate
2891 = dyn_cast<ClassTemplateDecl>(Found.front());
2892 if (!InstClassTemplate)
2893 return nullptr;
2894
2895 // Substitute into the template arguments of the class template explicit
2896 // specialization.
2897 TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
2898 castAs<TemplateSpecializationTypeLoc>();
2899 TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
2900 Loc.getRAngleLoc());
2901 SmallVector<TemplateArgumentLoc, 4> ArgLocs;
2902 for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
2903 ArgLocs.push_back(Loc.getArgLoc(I));
2904 if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
2905 InstTemplateArgs, TemplateArgs))
2906 return nullptr;
2907
2908 // Check that the template argument list is well-formed for this
2909 // class template.
2910 SmallVector<TemplateArgument, 4> Converted;
2911 if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
2912 D->getLocation(),
2913 InstTemplateArgs,
2914 false,
2915 Converted))
2916 return nullptr;
2917
2918 // Figure out where to insert this class template explicit specialization
2919 // in the member template's set of class template explicit specializations.
2920 void *InsertPos = nullptr;
2921 ClassTemplateSpecializationDecl *PrevDecl =
2922 InstClassTemplate->findSpecialization(Converted, InsertPos);
2923
2924 // Check whether we've already seen a conflicting instantiation of this
2925 // declaration (for instance, if there was a prior implicit instantiation).
2926 bool Ignored;
2927 if (PrevDecl &&
2928 SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
2929 D->getSpecializationKind(),
2930 PrevDecl,
2931 PrevDecl->getSpecializationKind(),
2932 PrevDecl->getPointOfInstantiation(),
2933 Ignored))
2934 return nullptr;
2935
2936 // If PrevDecl was a definition and D is also a definition, diagnose.
2937 // This happens in cases like:
2938 //
2939 // template<typename T, typename U>
2940 // struct Outer {
2941 // template<typename X> struct Inner;
2942 // template<> struct Inner<T> {};
2943 // template<> struct Inner<U> {};
2944 // };
2945 //
2946 // Outer<int, int> outer; // error: the explicit specializations of Inner
2947 // // have the same signature.
2948 if (PrevDecl && PrevDecl->getDefinition() &&
2949 D->isThisDeclarationADefinition()) {
2950 SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
2951 SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
2952 diag::note_previous_definition);
2953 return nullptr;
2954 }
2955
2956 // Create the class template partial specialization declaration.
2957 ClassTemplateSpecializationDecl *InstD
2958 = ClassTemplateSpecializationDecl::Create(SemaRef.Context,
2959 D->getTagKind(),
2960 Owner,
2961 D->getLocStart(),
2962 D->getLocation(),
2963 InstClassTemplate,
2964 Converted,
2965 PrevDecl);
2966
2967 // Add this partial specialization to the set of class template partial
2968 // specializations.
2969 if (!PrevDecl)
2970 InstClassTemplate->AddSpecialization(InstD, InsertPos);
2971
2972 // Substitute the nested name specifier, if any.
2973 if (SubstQualifier(D, InstD))
2974 return nullptr;
2975
2976 // Build the canonical type that describes the converted template
2977 // arguments of the class template explicit specialization.
2978 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2979 TemplateName(InstClassTemplate), Converted,
2980 SemaRef.Context.getRecordType(InstD));
2981
2982 // Build the fully-sugared type for this class template
2983 // specialization as the user wrote in the specialization
2984 // itself. This means that we'll pretty-print the type retrieved
2985 // from the specialization's declaration the way that the user
2986 // actually wrote the specialization, rather than formatting the
2987 // name based on the "canonical" representation used to store the
2988 // template arguments in the specialization.
2989 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
2990 TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
2991 CanonType);
2992
2993 InstD->setAccess(D->getAccess());
2994 InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
2995 InstD->setSpecializationKind(D->getSpecializationKind());
2996 InstD->setTypeAsWritten(WrittenTy);
2997 InstD->setExternLoc(D->getExternLoc());
2998 InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
2999
3000 Owner->addDecl(InstD);
3001
3002 // Instantiate the members of the class-scope explicit specialization eagerly.
3003 // We don't have support for lazy instantiation of an explicit specialization
3004 // yet, and MSVC eagerly instantiates in this case.
3005 if (D->isThisDeclarationADefinition() &&
3006 SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
3007 TSK_ImplicitInstantiation,
3008 /*Complain=*/true))
3009 return nullptr;
3010
3011 return InstD;
3012}
3013
3014Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3015 VarTemplateSpecializationDecl *D) {
3016
3017 TemplateArgumentListInfo VarTemplateArgsInfo;
3018 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
3019 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3020, __extension__ __PRETTY_FUNCTION__))
3020 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3020, __extension__ __PRETTY_FUNCTION__))
;
3021
3022 // Substitute the current template arguments.
3023 const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
3024 VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
3025 VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
3026
3027 if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
3028 TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
3029 return nullptr;
3030
3031 // Check that the template argument list is well-formed for this template.
3032 SmallVector<TemplateArgument, 4> Converted;
3033 if (SemaRef.CheckTemplateArgumentList(
3034 VarTemplate, VarTemplate->getLocStart(),
3035 const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
3036 Converted))
3037 return nullptr;
3038
3039 // Find the variable template specialization declaration that
3040 // corresponds to these arguments.
3041 void *InsertPos = nullptr;
3042 if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
3043 Converted, InsertPos))
3044 // If we already have a variable template specialization, return it.
3045 return VarSpec;
3046
3047 return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
3048 VarTemplateArgsInfo, Converted);
3049}
3050
3051Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3052 VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
3053 const TemplateArgumentListInfo &TemplateArgsInfo,
3054 ArrayRef<TemplateArgument> Converted) {
3055
3056 // Do substitution on the type of the declaration
3057 TypeSourceInfo *DI =
3058 SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
3059 D->getTypeSpecStartLoc(), D->getDeclName());
3060 if (!DI)
3061 return nullptr;
3062
3063 if (DI->getType()->isFunctionType()) {
3064 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
3065 << D->isStaticDataMember() << DI->getType();
3066 return nullptr;
3067 }
3068
3069 // Build the instantiated declaration
3070 VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
3071 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
3072 VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
3073 Var->setTemplateArgsInfo(TemplateArgsInfo);
3074 if (InsertPos)
3075 VarTemplate->AddSpecialization(Var, InsertPos);
3076
3077 // Substitute the nested name specifier, if any.
3078 if (SubstQualifier(D, Var))
3079 return nullptr;
3080
3081 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
3082 Owner, StartingScope);
3083
3084 return Var;
3085}
3086
3087Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3088 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3088)
;
3089}
3090
3091Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3092 // FIXME: We need to be able to instantiate FriendTemplateDecls.
3093 unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3094 DiagnosticsEngine::Error,
3095 "cannot instantiate %0 yet");
3096 SemaRef.Diag(D->getLocation(), DiagID)
3097 << D->getDeclKindName();
3098
3099 return nullptr;
3100}
3101
3102Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
3103 llvm_unreachable("Unexpected decl")::llvm::llvm_unreachable_internal("Unexpected decl", "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3103)
;
3104}
3105
3106Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
3107 const MultiLevelTemplateArgumentList &TemplateArgs) {
3108 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3109 if (D->isInvalidDecl())
3110 return nullptr;
3111
3112 return Instantiator.Visit(D);
3113}
3114
3115/// \brief Instantiates a nested template parameter list in the current
3116/// instantiation context.
3117///
3118/// \param L The parameter list to instantiate
3119///
3120/// \returns NULL if there was an error
3121TemplateParameterList *
3122TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
3123 // Get errors for all the parameters before bailing out.
3124 bool Invalid = false;
3125
3126 unsigned N = L->size();
3127 typedef SmallVector<NamedDecl *, 8> ParamVector;
3128 ParamVector Params;
3129 Params.reserve(N);
3130 for (auto &P : *L) {
3131 NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
3132 Params.push_back(D);
3133 Invalid = Invalid || !D || D->isInvalidDecl();
3134 }
3135
3136 // Clean up if we had an error.
3137 if (Invalid)
3138 return nullptr;
3139
3140 // Note: we substitute into associated constraints later
3141 Expr *const UninstantiatedRequiresClause = L->getRequiresClause();
3142
3143 TemplateParameterList *InstL
3144 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
3145 L->getLAngleLoc(), Params,
3146 L->getRAngleLoc(),
3147 UninstantiatedRequiresClause);
3148 return InstL;
3149}
3150
3151/// \brief Instantiate the declaration of a class template partial
3152/// specialization.
3153///
3154/// \param ClassTemplate the (instantiated) class template that is partially
3155// specialized by the instantiation of \p PartialSpec.
3156///
3157/// \param PartialSpec the (uninstantiated) class template partial
3158/// specialization that we are instantiating.
3159///
3160/// \returns The instantiated partial specialization, if successful; otherwise,
3161/// NULL to indicate an error.
3162ClassTemplatePartialSpecializationDecl *
3163TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
3164 ClassTemplateDecl *ClassTemplate,
3165 ClassTemplatePartialSpecializationDecl *PartialSpec) {
3166 // Create a local instantiation scope for this class template partial
3167 // specialization, which will contain the instantiations of the template
3168 // parameters.
3169 LocalInstantiationScope Scope(SemaRef);
3170
3171 // Substitute into the template parameters of the class template partial
3172 // specialization.
3173 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3174 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3175 if (!InstParams)
3176 return nullptr;
3177
3178 // Substitute into the template arguments of the class template partial
3179 // specialization.
3180 const ASTTemplateArgumentListInfo *TemplArgInfo
3181 = PartialSpec->getTemplateArgsAsWritten();
3182 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3183 TemplArgInfo->RAngleLoc);
3184 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3185 TemplArgInfo->NumTemplateArgs,
3186 InstTemplateArgs, TemplateArgs))
3187 return nullptr;
3188
3189 // Check that the template argument list is well-formed for this
3190 // class template.
3191 SmallVector<TemplateArgument, 4> Converted;
3192 if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
3193 PartialSpec->getLocation(),
3194 InstTemplateArgs,
3195 false,
3196 Converted))
3197 return nullptr;
3198
3199 // Check these arguments are valid for a template partial specialization.
3200 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3201 PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
3202 Converted))
3203 return nullptr;
3204
3205 // Figure out where to insert this class template partial specialization
3206 // in the member template's set of class template partial specializations.
3207 void *InsertPos = nullptr;
3208 ClassTemplateSpecializationDecl *PrevDecl
3209 = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
3210
3211 // Build the canonical type that describes the converted template
3212 // arguments of the class template partial specialization.
3213 QualType CanonType
3214 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
3215 Converted);
3216
3217 // Build the fully-sugared type for this class template
3218 // specialization as the user wrote in the specialization
3219 // itself. This means that we'll pretty-print the type retrieved
3220 // from the specialization's declaration the way that the user
3221 // actually wrote the specialization, rather than formatting the
3222 // name based on the "canonical" representation used to store the
3223 // template arguments in the specialization.
3224 TypeSourceInfo *WrittenTy
3225 = SemaRef.Context.getTemplateSpecializationTypeInfo(
3226 TemplateName(ClassTemplate),
3227 PartialSpec->getLocation(),
3228 InstTemplateArgs,
3229 CanonType);
3230
3231 if (PrevDecl) {
3232 // We've already seen a partial specialization with the same template
3233 // parameters and template arguments. This can happen, for example, when
3234 // substituting the outer template arguments ends up causing two
3235 // class template partial specializations of a member class template
3236 // to have identical forms, e.g.,
3237 //
3238 // template<typename T, typename U>
3239 // struct Outer {
3240 // template<typename X, typename Y> struct Inner;
3241 // template<typename Y> struct Inner<T, Y>;
3242 // template<typename Y> struct Inner<U, Y>;
3243 // };
3244 //
3245 // Outer<int, int> outer; // error: the partial specializations of Inner
3246 // // have the same signature.
3247 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
3248 << WrittenTy->getType();
3249 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
3250 << SemaRef.Context.getTypeDeclType(PrevDecl);
3251 return nullptr;
3252 }
3253
3254
3255 // Create the class template partial specialization declaration.
3256 ClassTemplatePartialSpecializationDecl *InstPartialSpec
3257 = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
3258 PartialSpec->getTagKind(),
3259 Owner,
3260 PartialSpec->getLocStart(),
3261 PartialSpec->getLocation(),
3262 InstParams,
3263 ClassTemplate,
3264 Converted,
3265 InstTemplateArgs,
3266 CanonType,
3267 nullptr);
3268 // Substitute the nested name specifier, if any.
3269 if (SubstQualifier(PartialSpec, InstPartialSpec))
3270 return nullptr;
3271
3272 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3273 InstPartialSpec->setTypeAsWritten(WrittenTy);
3274
3275 // Check the completed partial specialization.
3276 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3277
3278 // Add this partial specialization to the set of class template partial
3279 // specializations.
3280 ClassTemplate->AddPartialSpecialization(InstPartialSpec,
3281 /*InsertPos=*/nullptr);
3282 return InstPartialSpec;
3283}
3284
3285/// \brief Instantiate the declaration of a variable template partial
3286/// specialization.
3287///
3288/// \param VarTemplate the (instantiated) variable template that is partially
3289/// specialized by the instantiation of \p PartialSpec.
3290///
3291/// \param PartialSpec the (uninstantiated) variable template partial
3292/// specialization that we are instantiating.
3293///
3294/// \returns The instantiated partial specialization, if successful; otherwise,
3295/// NULL to indicate an error.
3296VarTemplatePartialSpecializationDecl *
3297TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
3298 VarTemplateDecl *VarTemplate,
3299 VarTemplatePartialSpecializationDecl *PartialSpec) {
3300 // Create a local instantiation scope for this variable template partial
3301 // specialization, which will contain the instantiations of the template
3302 // parameters.
3303 LocalInstantiationScope Scope(SemaRef);
3304
3305 // Substitute into the template parameters of the variable template partial
3306 // specialization.
3307 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3308 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3309 if (!InstParams)
3310 return nullptr;
3311
3312 // Substitute into the template arguments of the variable template partial
3313 // specialization.
3314 const ASTTemplateArgumentListInfo *TemplArgInfo
3315 = PartialSpec->getTemplateArgsAsWritten();
3316 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3317 TemplArgInfo->RAngleLoc);
3318 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3319 TemplArgInfo->NumTemplateArgs,
3320 InstTemplateArgs, TemplateArgs))
3321 return nullptr;
3322
3323 // Check that the template argument list is well-formed for this
3324 // class template.
3325 SmallVector<TemplateArgument, 4> Converted;
3326 if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
3327 InstTemplateArgs, false, Converted))
3328 return nullptr;
3329
3330 // Check these arguments are valid for a template partial specialization.
3331 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3332 PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
3333 Converted))
3334 return nullptr;
3335
3336 // Figure out where to insert this variable template partial specialization
3337 // in the member template's set of variable template partial specializations.
3338 void *InsertPos = nullptr;
3339 VarTemplateSpecializationDecl *PrevDecl =
3340 VarTemplate->findPartialSpecialization(Converted, InsertPos);
3341
3342 // Build the canonical type that describes the converted template
3343 // arguments of the variable template partial specialization.
3344 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3345 TemplateName(VarTemplate), Converted);
3346
3347 // Build the fully-sugared type for this variable template
3348 // specialization as the user wrote in the specialization
3349 // itself. This means that we'll pretty-print the type retrieved
3350 // from the specialization's declaration the way that the user
3351 // actually wrote the specialization, rather than formatting the
3352 // name based on the "canonical" representation used to store the
3353 // template arguments in the specialization.
3354 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
3355 TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
3356 CanonType);
3357
3358 if (PrevDecl) {
3359 // We've already seen a partial specialization with the same template
3360 // parameters and template arguments. This can happen, for example, when
3361 // substituting the outer template arguments ends up causing two
3362 // variable template partial specializations of a member variable template
3363 // to have identical forms, e.g.,
3364 //
3365 // template<typename T, typename U>
3366 // struct Outer {
3367 // template<typename X, typename Y> pair<X,Y> p;
3368 // template<typename Y> pair<T, Y> p;
3369 // template<typename Y> pair<U, Y> p;
3370 // };
3371 //
3372 // Outer<int, int> outer; // error: the partial specializations of Inner
3373 // // have the same signature.
3374 SemaRef.Diag(PartialSpec->getLocation(),
3375 diag::err_var_partial_spec_redeclared)
3376 << WrittenTy->getType();
3377 SemaRef.Diag(PrevDecl->getLocation(),
3378 diag::note_var_prev_partial_spec_here);
3379 return nullptr;
3380 }
3381
3382 // Do substitution on the type of the declaration
3383 TypeSourceInfo *DI = SemaRef.SubstType(
3384 PartialSpec->getTypeSourceInfo(), TemplateArgs,
3385 PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
3386 if (!DI)
3387 return nullptr;
3388
3389 if (DI->getType()->isFunctionType()) {
3390 SemaRef.Diag(PartialSpec->getLocation(),
3391 diag::err_variable_instantiates_to_function)
3392 << PartialSpec->isStaticDataMember() << DI->getType();
3393 return nullptr;
3394 }
3395
3396 // Create the variable template partial specialization declaration.
3397 VarTemplatePartialSpecializationDecl *InstPartialSpec =
3398 VarTemplatePartialSpecializationDecl::Create(
3399 SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
3400 PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
3401 DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
3402
3403 // Substitute the nested name specifier, if any.
3404 if (SubstQualifier(PartialSpec, InstPartialSpec))
3405 return nullptr;
3406
3407 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3408 InstPartialSpec->setTypeAsWritten(WrittenTy);
3409
3410 // Check the completed partial specialization.
3411 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3412
3413 // Add this partial specialization to the set of variable template partial
3414 // specializations. The instantiation of the initializer is not necessary.
3415 VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
3416
3417 SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
3418 LateAttrs, Owner, StartingScope);
3419
3420 return InstPartialSpec;
3421}
3422
3423TypeSourceInfo*
3424TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
3425 SmallVectorImpl<ParmVarDecl *> &Params) {
3426 TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3427 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3427, __extension__ __PRETTY_FUNCTION__))
;
3428 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3428, __extension__ __PRETTY_FUNCTION__))
;
3429
3430 CXXRecordDecl *ThisContext = nullptr;
3431 unsigned ThisTypeQuals = 0;
3432 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3433 ThisContext = cast<CXXRecordDecl>(Owner);
3434 ThisTypeQuals = Method->getTypeQualifiers();
3435 }
3436
3437 TypeSourceInfo *NewTInfo
3438 = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3439 D->getTypeSpecStartLoc(),
3440 D->getDeclName(),
3441 ThisContext, ThisTypeQuals);
3442 if (!NewTInfo)
3443 return nullptr;
3444
3445 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3446 if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3447 if (NewTInfo != OldTInfo) {
3448 // Get parameters from the new type info.
3449 TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
3450 FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
3451 unsigned NewIdx = 0;
3452 for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
3453 OldIdx != NumOldParams; ++OldIdx) {
3454 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
3455 LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
3456
3457 Optional<unsigned> NumArgumentsInExpansion;
3458 if (OldParam->isParameterPack())
3459 NumArgumentsInExpansion =
3460 SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3461 TemplateArgs);
3462 if (!NumArgumentsInExpansion) {
3463 // Simple case: normal parameter, or a parameter pack that's
3464 // instantiated to a (still-dependent) parameter pack.
3465 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3466 Params.push_back(NewParam);
3467 Scope->InstantiatedLocal(OldParam, NewParam);
3468 } else {
3469 // Parameter pack expansion: make the instantiation an argument pack.
3470 Scope->MakeInstantiatedLocalArgPack(OldParam);
3471 for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
3472 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3473 Params.push_back(NewParam);
3474 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3475 }
3476 }
3477 }
3478 } else {
3479 // The function type itself was not dependent and therefore no
3480 // substitution occurred. However, we still need to instantiate
3481 // the function parameters themselves.
3482 const FunctionProtoType *OldProto =
3483 cast<FunctionProtoType>(OldProtoLoc.getType());
3484 for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3485 ++i) {
3486 ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
3487 if (!OldParam) {
3488 Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
3489 D, D->getLocation(), OldProto->getParamType(i)));
3490 continue;
3491 }
3492
3493 ParmVarDecl *Parm =
3494 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
3495 if (!Parm)
3496 return nullptr;
3497 Params.push_back(Parm);
3498 }
3499 }
3500 } else {
3501 // If the type of this function, after ignoring parentheses, is not
3502 // *directly* a function type, then we're instantiating a function that
3503 // was declared via a typedef or with attributes, e.g.,
3504 //
3505 // typedef int functype(int, int);
3506 // functype func;
3507 // int __cdecl meth(int, int);
3508 //
3509 // In this case, we'll just go instantiate the ParmVarDecls that we
3510 // synthesized in the method declaration.
3511 SmallVector<QualType, 4> ParamTypes;
3512 Sema::ExtParameterInfoBuilder ExtParamInfos;
3513 if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
3514 TemplateArgs, ParamTypes, &Params,
3515 ExtParamInfos))
3516 return nullptr;
3517 }
3518
3519 return NewTInfo;
3520}
3521
3522/// Introduce the instantiated function parameters into the local
3523/// instantiation scope, and set the parameter names to those used
3524/// in the template.
3525static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
3526 const FunctionDecl *PatternDecl,
3527 LocalInstantiationScope &Scope,
3528 const MultiLevelTemplateArgumentList &TemplateArgs) {
3529 unsigned FParamIdx = 0;
3530 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3531 const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3532 if (!PatternParam->isParameterPack()) {
3533 // Simple case: not a parameter pack.
3534 assert(FParamIdx < Function->getNumParams())(static_cast <bool> (FParamIdx < Function->getNumParams
()) ? void (0) : __assert_fail ("FParamIdx < Function->getNumParams()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3534, __extension__ __PRETTY_FUNCTION__))
;
3535 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3536 FunctionParam->setDeclName(PatternParam->getDeclName());
3537 // If the parameter's type is not dependent, update it to match the type
3538 // in the pattern. They can differ in top-level cv-qualifiers, and we want
3539 // the pattern's type here. If the type is dependent, they can't differ,
3540 // per core issue 1668. Substitute into the type from the pattern, in case
3541 // it's instantiation-dependent.
3542 // FIXME: Updating the type to work around this is at best fragile.
3543 if (!PatternDecl->getType()->isDependentType()) {
3544 QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3545 FunctionParam->getLocation(),
3546 FunctionParam->getDeclName());
3547 if (T.isNull())
3548 return true;
3549 FunctionParam->setType(T);
3550 }
3551
3552 Scope.InstantiatedLocal(PatternParam, FunctionParam);
3553 ++FParamIdx;
3554 continue;
3555 }
3556
3557 // Expand the parameter pack.
3558 Scope.MakeInstantiatedLocalArgPack(PatternParam);
3559 Optional<unsigned> NumArgumentsInExpansion
3560 = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
3561 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3562, __extension__ __PRETTY_FUNCTION__))
3562 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3562, __extension__ __PRETTY_FUNCTION__))
;
3563 QualType PatternType =
3564 PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
3565 for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
3566 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3567 FunctionParam->setDeclName(PatternParam->getDeclName());
3568 if (!PatternDecl->getType()->isDependentType()) {
3569 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3570 QualType T = S.SubstType(PatternType, TemplateArgs,
3571 FunctionParam->getLocation(),
3572 FunctionParam->getDeclName());
3573 if (T.isNull())
3574 return true;
3575 FunctionParam->setType(T);
3576 }
3577
3578 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3579 ++FParamIdx;
3580 }
3581 }
3582
3583 return false;
3584}
3585
3586void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
3587 FunctionDecl *Decl) {
3588 const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3589 if (Proto->getExceptionSpecType() != EST_Uninstantiated)
3590 return;
3591
3592 InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3593 InstantiatingTemplate::ExceptionSpecification());
3594 if (Inst.isInvalid()) {
3595 // We hit the instantiation depth limit. Clear the exception specification
3596 // so that our callers don't have to cope with EST_Uninstantiated.
3597 UpdateExceptionSpec(Decl, EST_None);
3598 return;
3599 }
3600 if (Inst.isAlreadyInstantiating()) {
3601 // This exception specification indirectly depends on itself. Reject.
3602 // FIXME: Corresponding rule in the standard?
3603 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
3604 UpdateExceptionSpec(Decl, EST_None);
3605 return;
3606 }
3607
3608 // Enter the scope of this instantiation. We don't use
3609 // PushDeclContext because we don't have a scope.
3610 Sema::ContextRAII savedContext(*this, Decl);
3611 LocalInstantiationScope Scope(*this);
3612
3613 MultiLevelTemplateArgumentList TemplateArgs =
3614 getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
3615
3616 FunctionDecl *Template = Proto->getExceptionSpecTemplate();
3617 if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3618 TemplateArgs)) {
3619 UpdateExceptionSpec(Decl, EST_None);
3620 return;
3621 }
3622
3623 SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3624 TemplateArgs);
3625}
3626
3627/// \brief Initializes the common fields of an instantiation function
3628/// declaration (New) from the corresponding fields of its template (Tmpl).
3629///
3630/// \returns true if there was an error
3631bool
3632TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
3633 FunctionDecl *Tmpl) {
3634 if (Tmpl->isDeleted())
3635 New->setDeletedAsWritten();
3636
3637 New->setImplicit(Tmpl->isImplicit());
3638
3639 // Forward the mangling number from the template to the instantiated decl.
3640 SemaRef.Context.setManglingNumber(New,
3641 SemaRef.Context.getManglingNumber(Tmpl));
3642
3643 // If we are performing substituting explicitly-specified template arguments
3644 // or deduced template arguments into a function template and we reach this
3645 // point, we are now past the point where SFINAE applies and have committed
3646 // to keeping the new function template specialization. We therefore
3647 // convert the active template instantiation for the function template
3648 // into a template instantiation for this specific function template
3649 // specialization, which is not a SFINAE context, so that we diagnose any
3650 // further errors in the declaration itself.
3651 typedef Sema::CodeSynthesisContext ActiveInstType;
3652 ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
3653 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3654 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
3655 if (FunctionTemplateDecl *FunTmpl
3656 = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
3657 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3658, __extension__ __PRETTY_FUNCTION__))
3658 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3658, __extension__ __PRETTY_FUNCTION__))
;
3659 (void) FunTmpl;
3660 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
3661 ActiveInst.Entity = New;
3662 }
3663 }
3664
3665 const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3666 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3666, __extension__ __PRETTY_FUNCTION__))
;
3667
3668 if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3669 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
3670
3671 // DR1330: In C++11, defer instantiation of a non-trivial
3672 // exception specification.
3673 // DR1484: Local classes and their members are instantiated along with the
3674 // containing function.
3675 if (SemaRef.getLangOpts().CPlusPlus11 &&
3676 EPI.ExceptionSpec.Type != EST_None &&
3677 EPI.ExceptionSpec.Type != EST_DynamicNone &&
3678 EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
3679 !Tmpl->isLexicallyWithinFunctionOrMethod()) {
3680 FunctionDecl *ExceptionSpecTemplate = Tmpl;
3681 if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
3682 ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
3683 ExceptionSpecificationType NewEST = EST_Uninstantiated;
3684 if (EPI.ExceptionSpec.Type == EST_Unevaluated)
3685 NewEST = EST_Unevaluated;
3686
3687 // Mark the function has having an uninstantiated exception specification.
3688 const FunctionProtoType *NewProto
3689 = New->getType()->getAs<FunctionProtoType>();
3690 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3690, __extension__ __PRETTY_FUNCTION__))
;
3691 EPI = NewProto->getExtProtoInfo();
3692 EPI.ExceptionSpec.Type = NewEST;
3693 EPI.ExceptionSpec.SourceDecl = New;
3694 EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
3695 New->setType(SemaRef.Context.getFunctionType(
3696 NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
3697 } else {
3698 Sema::ContextRAII SwitchContext(SemaRef, New);
3699 SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
3700 }
3701 }
3702
3703 // Get the definition. Leaves the variable unchanged if undefined.
3704 const FunctionDecl *Definition = Tmpl;
3705 Tmpl->isDefined(Definition);
3706
3707 SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3708 LateAttrs, StartingScope);
3709
3710 return false;
3711}
3712
3713/// \brief Initializes common fields of an instantiated method
3714/// declaration (New) from the corresponding fields of its template
3715/// (Tmpl).
3716///
3717/// \returns true if there was an error
3718bool
3719TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
3720 CXXMethodDecl *Tmpl) {
3721 if (InitFunctionInstantiation(New, Tmpl))
3722 return true;
3723
3724 New->setAccess(Tmpl->getAccess());
3725 if (Tmpl->isVirtualAsWritten())
3726 New->setVirtualAsWritten(true);
3727
3728 // FIXME: New needs a pointer to Tmpl
3729 return false;
3730}
3731
3732/// In the MS ABI, we need to instantiate default arguments of dllexported
3733/// default constructors along with the constructor definition. This allows IR
3734/// gen to emit a constructor closure which calls the default constructor with
3735/// its default arguments.
3736static void InstantiateDefaultCtorDefaultArgs(Sema &S,
3737 CXXConstructorDecl *Ctor) {
3738 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3739, __extension__ __PRETTY_FUNCTION__))
3739 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3739, __extension__ __PRETTY_FUNCTION__))
;
3740 unsigned NumParams = Ctor->getNumParams();
3741 if (NumParams == 0)
3742 return;
3743 DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
3744 if (!Attr)
3745 return;
3746 for (unsigned I = 0; I != NumParams; ++I) {
3747 (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
3748 Ctor->getParamDecl(I));
3749 S.DiscardCleanupsInEvaluationContext();
3750 }
3751}
3752
3753/// \brief Instantiate the definition of the given function from its
3754/// template.
3755///
3756/// \param PointOfInstantiation the point at which the instantiation was
3757/// required. Note that this is not precisely a "point of instantiation"
3758/// for the function, but it's close.
3759///
3760/// \param Function the already-instantiated declaration of a
3761/// function template specialization or member function of a class template
3762/// specialization.
3763///
3764/// \param Recursive if true, recursively instantiates any functions that
3765/// are required by this instantiation.
3766///
3767/// \param DefinitionRequired if true, then we are performing an explicit
3768/// instantiation where the body of the function is required. Complain if
3769/// there is no such body.
3770void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
3771 FunctionDecl *Function,
3772 bool Recursive,
3773 bool DefinitionRequired,
3774 bool AtEndOfTU) {
3775 if (Function->isInvalidDecl() || Function->isDefined() ||
3776 isa<CXXDeductionGuideDecl>(Function))
3777 return;
3778
3779 // Never instantiate an explicit specialization except if it is a class scope
3780 // explicit specialization.
3781 TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
3782 if (TSK == TSK_ExplicitSpecialization &&
3783 !Function->getClassScopeSpecializationPattern())
3784 return;
3785
3786 // Find the function body that we'll be substituting.
3787 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
3788 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3788, __extension__ __PRETTY_FUNCTION__))
;
3789
3790 const FunctionDecl *PatternDef = PatternDecl->getDefinition();
3791 Stmt *Pattern = nullptr;
3792 if (PatternDef) {
3793 Pattern = PatternDef->getBody(PatternDef);
3794 PatternDecl = PatternDef;
3795 if (PatternDef->willHaveBody())
3796 PatternDef = nullptr;
3797 }
3798
3799 // FIXME: We need to track the instantiation stack in order to know which
3800 // definitions should be visible within this instantiation.
3801 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
3802 Function->getInstantiatedFromMemberFunction(),
3803 PatternDecl, PatternDef, TSK,
3804 /*Complain*/DefinitionRequired)) {
3805 if (DefinitionRequired)
3806 Function->setInvalidDecl();
3807 else if (TSK == TSK_ExplicitInstantiationDefinition) {
3808 // Try again at the end of the translation unit (at which point a
3809 // definition will be required).
3810 assert(!Recursive)(static_cast <bool> (!Recursive) ? void (0) : __assert_fail
("!Recursive", "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3810, __extension__ __PRETTY_FUNCTION__))
;
3811 Function->setInstantiationIsPending(true);
3812 PendingInstantiations.push_back(
3813 std::make_pair(Function, PointOfInstantiation));
3814 } else if (TSK == TSK_ImplicitInstantiation) {
3815 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
3816 Diag(PointOfInstantiation, diag::warn_func_template_missing)
3817 << Function;
3818 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
3819 if (getLangOpts().CPlusPlus11)
3820 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
3821 << Function;
3822 }
3823 }
3824
3825 return;
3826 }
3827
3828 // Postpone late parsed template instantiations.
3829 if (PatternDecl->isLateTemplateParsed() &&
3830 !LateTemplateParser) {
3831 Function->setInstantiationIsPending(true);
3832 PendingInstantiations.push_back(
3833 std::make_pair(Function, PointOfInstantiation));
3834 return;
3835 }
3836
3837 // If we're performing recursive template instantiation, create our own
3838 // queue of pending implicit instantiations that we will instantiate later,
3839 // while we're still within our own instantiation context.
3840 // This has to happen before LateTemplateParser below is called, so that
3841 // it marks vtables used in late parsed templates as used.
3842 GlobalEagerInstantiationScope GlobalInstantiations(*this,
3843 /*Enabled=*/Recursive);
3844 LocalEagerInstantiationScope LocalInstantiations(*this);
3845
3846 // Call the LateTemplateParser callback if there is a need to late parse
3847 // a templated function definition.
3848 if (!Pattern && PatternDecl->isLateTemplateParsed() &&
3849 LateTemplateParser) {
3850 // FIXME: Optimize to allow individual templates to be deserialized.
3851 if (PatternDecl->isFromASTFile())
3852 ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
3853
3854 auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
3855 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3856, __extension__ __PRETTY_FUNCTION__))
3856 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3856, __extension__ __PRETTY_FUNCTION__))
;
3857 LateTemplateParser(OpaqueParser, *LPTIter->second);
3858 Pattern = PatternDecl->getBody(PatternDecl);
3859 }
3860
3861 // Note, we should never try to instantiate a deleted function template.
3862 assert((Pattern || PatternDecl->isDefaulted() ||(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3864, __extension__ __PRETTY_FUNCTION__))
3863 PatternDecl->hasSkippedBody()) &&(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3864, __extension__ __PRETTY_FUNCTION__))
3864 "unexpected kind of function template definition")(static_cast <bool> ((Pattern || PatternDecl->isDefaulted
() || PatternDecl->hasSkippedBody()) && "unexpected kind of function template definition"
) ? void (0) : __assert_fail ("(Pattern || PatternDecl->isDefaulted() || PatternDecl->hasSkippedBody()) && \"unexpected kind of function template definition\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 3864, __extension__ __PRETTY_FUNCTION__))
;
3865
3866 // C++1y [temp.explicit]p10:
3867 // Except for inline functions, declarations with types deduced from their
3868 // initializer or return value, and class template specializations, other
3869 // explicit instantiation declarations have the effect of suppressing the
3870 // implicit instantiation of the entity to which they refer.
3871 if (TSK == TSK_ExplicitInstantiationDeclaration &&
3872 !PatternDecl->isInlined() &&
3873 !PatternDecl->getReturnType()->getContainedAutoType())
3874 return;
3875
3876 if (PatternDecl->isInlined()) {
3877 // Function, and all later redeclarations of it (from imported modules,
3878 // for instance), are now implicitly inline.
3879 for (auto *D = Function->getMostRecentDecl(); /**/;
3880 D = D->getPreviousDecl()) {
3881 D->setImplicitlyInline();
3882 if (D == Function)
3883 break;
3884 }
3885 }
3886
3887 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
3888 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
3889 return;
3890 PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3891 "instantiating function definition");
3892
3893 // The instantiation is visible here, even if it was first declared in an
3894 // unimported module.
3895 Function->setVisibleDespiteOwningModule();
3896
3897 // Copy the inner loc start from the pattern.
3898 Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3899
3900 EnterExpressionEvaluationContext EvalContext(
3901 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
3902
3903 // Introduce a new scope where local variable instantiations will be
3904 // recorded, unless we're actually a member function within a local
3905 // class, in which case we need to merge our results with the parent
3906 // scope (of the enclosing function).
3907 bool MergeWithParentScope = false;
3908 if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3909 MergeWithParentScope = Rec->isLocalClass();
3910
3911 LocalInstantiationScope Scope(*this, MergeWithParentScope);
3912
3913 if (PatternDecl->isDefaulted())
3914 SetDeclDefaulted(Function, PatternDecl->getLocation());
3915 else {
3916 MultiLevelTemplateArgumentList TemplateArgs =
3917 getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
3918
3919 // Substitute into the qualifier; we can get a substitution failure here
3920 // through evil use of alias templates.
3921 // FIXME: Is CurContext correct for this? Should we go to the (instantiation
3922 // of the) lexical context of the pattern?
3923 SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
3924
3925 ActOnStartOfFunctionDef(nullptr, Function);
3926
3927 // Enter the scope of this instantiation. We don't use
3928 // PushDeclContext because we don't have a scope.
3929 Sema::ContextRAII savedContext(*this, Function);
3930
3931 if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3932 TemplateArgs))
3933 return;
3934
3935 if (PatternDecl->hasSkippedBody()) {
3936 ActOnSkippedFunctionBody(Function);
3937 } else {
3938 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
3939 // If this is a constructor, instantiate the member initializers.
3940 InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
3941 TemplateArgs);
3942
3943 // If this is an MS ABI dllexport default constructor, instantiate any
3944 // default arguments.
3945 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3946 Ctor->isDefaultConstructor()) {
3947 InstantiateDefaultCtorDefaultArgs(*this, Ctor);
3948 }
3949 }
3950
3951 // Instantiate the function body.
3952 StmtResult Body = SubstStmt(Pattern, TemplateArgs);
3953
3954 if (Body.isInvalid())
3955 Function->setInvalidDecl();
3956
3957 // FIXME: finishing the function body while in an expression evaluation
3958 // context seems wrong. Investigate more.
3959 ActOnFinishFunctionBody(Function, Body.get(),
3960 /*IsInstantiation=*/true);
3961 }
3962
3963 PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3964
3965 if (auto *Listener = getASTMutationListener())
3966 Listener->FunctionDefinitionInstantiated(Function);
3967
3968 savedContext.pop();
3969 }
3970
3971 DeclGroupRef DG(Function);
3972 Consumer.HandleTopLevelDecl(DG);
3973
3974 // This class may have local implicit instantiations that need to be
3975 // instantiation within this scope.
3976 LocalInstantiations.perform();
3977 Scope.Exit();
3978 GlobalInstantiations.perform();
3979}
3980
3981VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
3982 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
3983 const TemplateArgumentList &TemplateArgList,
3984 const TemplateArgumentListInfo &TemplateArgsInfo,
3985 SmallVectorImpl<TemplateArgument> &Converted,
3986 SourceLocation PointOfInstantiation, void *InsertPos,
3987 LateInstantiatedAttrVec *LateAttrs,
3988 LocalInstantiationScope *StartingScope) {
3989 if (FromVar->isInvalidDecl())
3990 return nullptr;
3991
3992 InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
3993 if (Inst.isInvalid())
3994 return nullptr;
3995
3996 MultiLevelTemplateArgumentList TemplateArgLists;
3997 TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
3998
3999 // Instantiate the first declaration of the variable template: for a partial
4000 // specialization of a static data member template, the first declaration may
4001 // or may not be the declaration in the class; if it's in the class, we want
4002 // to instantiate a member in the class (a declaration), and if it's outside,
4003 // we want to instantiate a definition.
4004 //
4005 // If we're instantiating an explicitly-specialized member template or member
4006 // partial specialization, don't do this. The member specialization completely
4007 // replaces the original declaration in this case.
4008 bool IsMemberSpec = false;
4009 if (VarTemplatePartialSpecializationDecl *PartialSpec =
4010 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
4011 IsMemberSpec = PartialSpec->isMemberSpecialization();
4012 else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
4013 IsMemberSpec = FromTemplate->isMemberSpecialization();
4014 if (!IsMemberSpec)
4015 FromVar = FromVar->getFirstDecl();
4016
4017 MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
4018 TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
4019 MultiLevelList);
4020
4021 // TODO: Set LateAttrs and StartingScope ...
4022
4023 return cast_or_null<VarTemplateSpecializationDecl>(
4024 Instantiator.VisitVarTemplateSpecializationDecl(
4025 VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
4026}
4027
4028/// \brief Instantiates a variable template specialization by completing it
4029/// with appropriate type information and initializer.
4030VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
4031 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
4032 const MultiLevelTemplateArgumentList &TemplateArgs) {
4033 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4034, __extension__ __PRETTY_FUNCTION__))
4034 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4034, __extension__ __PRETTY_FUNCTION__))
;
4035
4036 // Do substitution on the type of the declaration
4037 TypeSourceInfo *DI =
4038 SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
4039 PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
4040 if (!DI)
4041 return nullptr;
4042
4043 // Update the type of this variable template specialization.
4044 VarSpec->setType(DI->getType());
4045
4046 // Convert the declaration into a definition now.
4047 VarSpec->setCompleteDefinition();
4048
4049 // Instantiate the initializer.
4050 InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
4051
4052 return VarSpec;
4053}
4054
4055/// BuildVariableInstantiation - Used after a new variable has been created.
4056/// Sets basic variable data and decides whether to postpone the
4057/// variable instantiation.
4058void Sema::BuildVariableInstantiation(
4059 VarDecl *NewVar, VarDecl *OldVar,
4060 const MultiLevelTemplateArgumentList &TemplateArgs,
4061 LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
4062 LocalInstantiationScope *StartingScope,
4063 bool InstantiatingVarTemplate) {
4064
4065 // If we are instantiating a local extern declaration, the
4066 // instantiation belongs lexically to the containing function.
4067 // If we are instantiating a static data member defined
4068 // out-of-line, the instantiation will have the same lexical
4069 // context (which will be a namespace scope) as the template.
4070 if (OldVar->isLocalExternDecl()) {
4071 NewVar->setLocalExternDecl();
4072 NewVar->setLexicalDeclContext(Owner);
4073 } else if (OldVar->isOutOfLine())
4074 NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
4075 NewVar->setTSCSpec(OldVar->getTSCSpec());
4076 NewVar->setInitStyle(OldVar->getInitStyle());
4077 NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
4078 NewVar->setConstexpr(OldVar->isConstexpr());
4079 NewVar->setInitCapture(OldVar->isInitCapture());
4080 NewVar->setPreviousDeclInSameBlockScope(
4081 OldVar->isPreviousDeclInSameBlockScope());
4082 NewVar->setAccess(OldVar->getAccess());
4083
4084 if (!OldVar->isStaticDataMember()) {
4085 if (OldVar->isUsed(false))
4086 NewVar->setIsUsed();
4087 NewVar->setReferenced(OldVar->isReferenced());
4088 }
4089
4090 InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
4091
4092 LookupResult Previous(
4093 *this, NewVar->getDeclName(), NewVar->getLocation(),
4094 NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
4095 : Sema::LookupOrdinaryName,
4096 NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
4097 : forRedeclarationInCurContext());
4098
4099 if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
4100 (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
4101 OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
4102 // We have a previous declaration. Use that one, so we merge with the
4103 // right type.
4104 if (NamedDecl *NewPrev = FindInstantiatedDecl(
4105 NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
4106 Previous.addDecl(NewPrev);
4107 } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
4108 OldVar->hasLinkage())
4109 LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
4110 CheckVariableDeclaration(NewVar, Previous);
4111
4112 if (!InstantiatingVarTemplate) {
4113 NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
4114 if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
4115 NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
4116 }
4117
4118 if (!OldVar->isOutOfLine()) {
4119 if (NewVar->getDeclContext()->isFunctionOrMethod())
4120 CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
4121 }
4122
4123 // Link instantiations of static data members back to the template from
4124 // which they were instantiated.
4125 if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
4126 NewVar->setInstantiationOfStaticDataMember(OldVar,
4127 TSK_ImplicitInstantiation);
4128
4129 // Forward the mangling number from the template to the instantiated decl.
4130 Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
4131 Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
4132
4133 // Delay instantiation of the initializer for variable templates or inline
4134 // static data members until a definition of the variable is needed. We need
4135 // it right away if the type contains 'auto'.
4136 if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
4137 !InstantiatingVarTemplate &&
4138 !(OldVar->isInline() && OldVar->isThisDeclarationADefinition())) ||
4139 NewVar->getType()->isUndeducedType())
4140 InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4141
4142 // Diagnose unused local variables with dependent types, where the diagnostic
4143 // will have been deferred.
4144 if (!NewVar->isInvalidDecl() &&
4145 NewVar->getDeclContext()->isFunctionOrMethod() &&
4146 OldVar->getType()->isDependentType())
4147 DiagnoseUnusedDecl(NewVar);
4148}
4149
4150/// \brief Instantiate the initializer of a variable.
4151void Sema::InstantiateVariableInitializer(
4152 VarDecl *Var, VarDecl *OldVar,
4153 const MultiLevelTemplateArgumentList &TemplateArgs) {
4154 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
4155 L->VariableDefinitionInstantiated(Var);
4156
4157 // We propagate the 'inline' flag with the initializer, because it
4158 // would otherwise imply that the variable is a definition for a
4159 // non-static data member.
4160 if (OldVar->isInlineSpecified())
4161 Var->setInlineSpecified();
4162 else if (OldVar->isInline())
4163 Var->setImplicitlyInline();
4164
4165 if (OldVar->getInit()) {
4166 EnterExpressionEvaluationContext Evaluated(
4167 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);
4168
4169 // Instantiate the initializer.
4170 ExprResult Init;
4171
4172 {
4173 ContextRAII SwitchContext(*this, Var->getDeclContext());
4174 Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
4175 OldVar->getInitStyle() == VarDecl::CallInit);
4176 }
4177
4178 if (!Init.isInvalid()) {
4179 Expr *InitExpr = Init.get();
4180
4181 if (Var->hasAttr<DLLImportAttr>() &&
4182 (!InitExpr ||
4183 !InitExpr->isConstantInitializer(getASTContext(), false))) {
4184 // Do not dynamically initialize dllimport variables.
4185 } else if (InitExpr) {
4186 bool DirectInit = OldVar->isDirectInit();
4187 AddInitializerToDecl(Var, InitExpr, DirectInit);
4188 } else
4189 ActOnUninitializedDecl(Var);
4190 } else {
4191 // FIXME: Not too happy about invalidating the declaration
4192 // because of a bogus initializer.
4193 Var->setInvalidDecl();
4194 }
4195 } else {
4196 if (Var->isStaticDataMember()) {
4197 if (!Var->isOutOfLine())
4198 return;
4199
4200 // If the declaration inside the class had an initializer, don't add
4201 // another one to the out-of-line definition.
4202 if (OldVar->getFirstDecl()->hasInit())
4203 return;
4204 }
4205
4206 // We'll add an initializer to a for-range declaration later.
4207 if (Var->isCXXForRangeDecl())
4208 return;
4209
4210 ActOnUninitializedDecl(Var);
4211 }
4212}
4213
4214/// \brief Instantiate the definition of the given variable from its
4215/// template.
4216///
4217/// \param PointOfInstantiation the point at which the instantiation was
4218/// required. Note that this is not precisely a "point of instantiation"
4219/// for the variable, but it's close.
4220///
4221/// \param Var the already-instantiated declaration of a templated variable.
4222///
4223/// \param Recursive if true, recursively instantiates any functions that
4224/// are required by this instantiation.
4225///
4226/// \param DefinitionRequired if true, then we are performing an explicit
4227/// instantiation where a definition of the variable is required. Complain
4228/// if there is no such definition.
4229void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
4230 VarDecl *Var, bool Recursive,
4231 bool DefinitionRequired, bool AtEndOfTU) {
4232 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
179
Assuming the condition is false
180
Taking false branch
4233 return;
4234
4235 VarTemplateSpecializationDecl *VarSpec =
4236 dyn_cast<VarTemplateSpecializationDecl>(Var);
4237 VarDecl *PatternDecl = nullptr, *Def = nullptr;
4238 MultiLevelTemplateArgumentList TemplateArgs =
4239 getTemplateInstantiationArgs(Var);
4240
4241 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
181
Assuming 'VarSpec' is null
182
Taking false branch
4242 // If this is a variable template specialization, make sure that it is
4243 // non-dependent, then find its instantiation pattern.
4244 bool InstantiationDependent = false;
4245 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4248, __extension__ __PRETTY_FUNCTION__))
4246 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4248, __extension__ __PRETTY_FUNCTION__))
4247 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4248, __extension__ __PRETTY_FUNCTION__))
4248 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4248, __extension__ __PRETTY_FUNCTION__))
;
4249 (void)InstantiationDependent;
4250
4251 // Find the variable initialization that we'll be substituting. If the
4252 // pattern was instantiated from a member template, look back further to
4253 // find the real pattern.
4254 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4255, __extension__ __PRETTY_FUNCTION__))
4255 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4255, __extension__ __PRETTY_FUNCTION__))
;
4256 llvm::PointerUnion<VarTemplateDecl *,
4257 VarTemplatePartialSpecializationDecl *> PatternPtr =
4258 VarSpec->getSpecializedTemplateOrPartial();
4259 if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
4260 VarTemplatePartialSpecializationDecl *Tmpl =
4261 PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
4262 while (VarTemplatePartialSpecializationDecl *From =
4263 Tmpl->getInstantiatedFromMember()) {
4264 if (Tmpl->isMemberSpecialization())
4265 break;
4266
4267 Tmpl = From;
4268 }
4269 PatternDecl = Tmpl;
4270 } else {
4271 VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
4272 while (VarTemplateDecl *From =
4273 Tmpl->getInstantiatedFromMemberTemplate()) {
4274 if (Tmpl->isMemberSpecialization())
4275 break;
4276
4277 Tmpl = From;
4278 }
4279 PatternDecl = Tmpl->getTemplatedDecl();
4280 }
4281
4282 // If this is a static data member template, there might be an
4283 // uninstantiated initializer on the declaration. If so, instantiate
4284 // it now.
4285 //
4286 // FIXME: This largely duplicates what we would do below. The difference
4287 // is that along this path we may instantiate an initializer from an
4288 // in-class declaration of the template and instantiate the definition
4289 // from a separate out-of-class definition.
4290 if (PatternDecl->isStaticDataMember() &&
4291 (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
4292 !Var->hasInit()) {
4293 // FIXME: Factor out the duplicated instantiation context setup/tear down
4294 // code here.
4295 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4296 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4297 return;
4298 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4299 "instantiating variable initializer");
4300
4301 // The instantiation is visible here, even if it was first declared in an
4302 // unimported module.
4303 Var->setVisibleDespiteOwningModule();
4304
4305 // If we're performing recursive template instantiation, create our own
4306 // queue of pending implicit instantiations that we will instantiate
4307 // later, while we're still within our own instantiation context.
4308 GlobalEagerInstantiationScope GlobalInstantiations(*this,
4309 /*Enabled=*/Recursive);
4310 LocalInstantiationScope Local(*this);
4311 LocalEagerInstantiationScope LocalInstantiations(*this);
4312
4313 // Enter the scope of this instantiation. We don't use
4314 // PushDeclContext because we don't have a scope.
4315 ContextRAII PreviousContext(*this, Var->getDeclContext());
4316 InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
4317 PreviousContext.pop();
4318
4319 // This variable may have local implicit instantiations that need to be
4320 // instantiated within this scope.
4321 LocalInstantiations.perform();
4322 Local.Exit();
4323 GlobalInstantiations.perform();
4324 }
4325
4326 // Find actual definition
4327 Def = PatternDecl->getDefinition(getASTContext());
4328 } else {
4329 // If this is a static data member, find its out-of-line definition.
4330 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4330, __extension__ __PRETTY_FUNCTION__))
;
4331 PatternDecl = Var->getInstantiatedFromStaticDataMember();
4332
4333 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4333, __extension__ __PRETTY_FUNCTION__))
;
4334 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4334, __extension__ __PRETTY_FUNCTION__))
;
4335 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'
183
Calling 'VarDecl::getDefinition'
184
Returning from 'VarDecl::getDefinition'
185
Value assigned to 'Def'
4336 }
4337
4338 TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
4339
4340 // If we don't have a definition of the variable template, we won't perform
4341 // any instantiation. Rather, we rely on the user to instantiate this
4342 // definition (or provide a specialization for it) in another translation
4343 // unit.
4344 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
186
Assuming 'Def' is null
187
Taking true branch
4345 if (TSK == TSK_ExplicitInstantiationDefinition) {
188
Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDefinition
189
Taking false branch
4346 PendingInstantiations.push_back(
4347 std::make_pair(Var, PointOfInstantiation));
4348 } else if (TSK == TSK_ImplicitInstantiation) {
190
Assuming 'TSK' is not equal to TSK_ImplicitInstantiation
191
Taking false branch
4349 // Warn about missing definition at the end of translation unit.
4350 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
4351 Diag(PointOfInstantiation, diag::warn_var_template_missing)
4352 << Var;
4353 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4354 if (getLangOpts().CPlusPlus11)
4355 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
4356 }
4357 return;
4358 }
4359
4360 }
4361
4362 // FIXME: We need to track the instantiation stack in order to know which
4363 // definitions should be visible within this instantiation.
4364 // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
4365 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
192
Assuming the condition is false
193
Taking false branch
4366 /*InstantiatedFromMember*/false,
4367 PatternDecl, Def, TSK,
4368 /*Complain*/DefinitionRequired))
4369 return;
4370
4371
4372 // Never instantiate an explicit specialization.
4373 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
194
Assuming 'TSK' is not equal to TSK_ExplicitSpecialization
195
Taking false branch
4374 return;
4375
4376 // C++11 [temp.explicit]p10:
4377 // Except for inline functions, const variables of literal types, variables
4378 // of reference types, [...] explicit instantiation declarations
4379 // have the effect of suppressing the implicit instantiation of the entity
4380 // to which they refer.
4381 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
196
Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDeclaration
4382 !Var->isUsableInConstantExpressions(getASTContext()))
4383 return;
4384
4385 // Make sure to pass the instantiated variable to the consumer at the end.
4386 struct PassToConsumerRAII {
4387 ASTConsumer &Consumer;
4388 VarDecl *Var;
4389
4390 PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
4391 : Consumer(Consumer), Var(Var) { }
4392
4393 ~PassToConsumerRAII() {
4394 Consumer.HandleCXXStaticMemberVarInstantiation(Var);
4395 }
4396 } PassToConsumerRAII(Consumer, Var);
4397
4398 // If we already have a definition, we're done.
4399 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 null
160
Taking false branch
197
Assuming 'Def' is null
198
Taking false branch
4400 // We may be explicitly instantiating something we've already implicitly
4401 // instantiated.
4402 Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
4403 PointOfInstantiation);
4404 return;
4405 }
4406
4407 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4408 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
161
Assuming the condition is false
162
Assuming the condition is false
163
Taking false branch
199
Assuming the condition is false
200
Assuming the condition is false
201
Taking false branch
4409 return;
4410 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4411 "instantiating variable definition");
4412
4413 // If we're performing recursive template instantiation, create our own
4414 // queue of pending implicit instantiations that we will instantiate later,
4415 // while we're still within our own instantiation context.
4416 GlobalEagerInstantiationScope GlobalInstantiations(*this,
4417 /*Enabled=*/Recursive);
4418
4419 // Enter the scope of this instantiation. We don't use
4420 // PushDeclContext because we don't have a scope.
4421 ContextRAII PreviousContext(*this, Var->getDeclContext());
4422 LocalInstantiationScope Local(*this);
4423
4424 LocalEagerInstantiationScope LocalInstantiations(*this);
4425
4426 VarDecl *OldVar = Var;
4427 if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
96
Assuming the condition is false
130
Assuming the condition is false
164
Assuming the condition is false
202
Called C++ object pointer is null
4428 // We're instantiating an inline static data member whose definition was
4429 // provided inside the class.
4430 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4431 } else if (!VarSpec) {
61
Taking true branch
97
Taking true branch
131
Taking true branch
165
Taking true branch
4432 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
4433 TemplateArgs));
4434 } else if (Var->isStaticDataMember() &&
4435 Var->getLexicalDeclContext()->isRecord()) {
4436 // We need to instantiate the definition of a static data member template,
4437 // and all we have is the in-class declaration of it. Instantiate a separate
4438 // declaration of the definition.
4439 TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
4440 TemplateArgs);
4441 Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
4442 VarSpec->getSpecializedTemplate(), Def, nullptr,
4443 VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
4444 if (Var) {
4445 llvm::PointerUnion<VarTemplateDecl *,
4446 VarTemplatePartialSpecializationDecl *> PatternPtr =
4447 VarSpec->getSpecializedTemplateOrPartial();
4448 if (VarTemplatePartialSpecializationDecl *Partial =
4449 PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
4450 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
4451 Partial, &VarSpec->getTemplateInstantiationArgs());
4452
4453 // Merge the definition with the declaration.
4454 LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
4455 LookupOrdinaryName, forRedeclarationInCurContext());
4456 R.addDecl(OldVar);
4457 MergeVarDecl(Var, R);
4458
4459 // Attach the initializer.
4460 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4461 }
4462 } else
4463 // Complete the existing variable's definition with an appropriately
4464 // substituted type and initializer.
4465 Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
4466
4467 PreviousContext.pop();
4468
4469 if (Var) {
62
Taking true branch
98
Assuming 'Var' is null
99
Taking false branch
132
Assuming 'Var' is null
133
Taking false branch
166
Assuming 'Var' is null
167
Taking false branch
4470 PassToConsumerRAII.Var = Var;
4471 Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
4472 OldVar->getPointOfInstantiation());
4473 }
4474
4475 // This variable may have local implicit instantiations that need to be
4476 // instantiated within this scope.
4477 LocalInstantiations.perform();
4478 Local.Exit();
4479 GlobalInstantiations.perform();
63
Calling 'GlobalEagerInstantiationScope::perform'
4480}
4481
4482void
4483Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
4484 const CXXConstructorDecl *Tmpl,
4485 const MultiLevelTemplateArgumentList &TemplateArgs) {
4486
4487 SmallVector<CXXCtorInitializer*, 4> NewInits;
4488 bool AnyErrors = Tmpl->isInvalidDecl();
4489
4490 // Instantiate all the initializers.
4491 for (const auto *Init : Tmpl->inits()) {
4492 // Only instantiate written initializers, let Sema re-construct implicit
4493 // ones.
4494 if (!Init->isWritten())
4495 continue;
4496
4497 SourceLocation EllipsisLoc;
4498
4499 if (Init->isPackExpansion()) {
4500 // This is a pack expansion. We should expand it now.
4501 TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
4502 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
4503 collectUnexpandedParameterPacks(BaseTL, Unexpanded);
4504 collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
4505 bool ShouldExpand = false;
4506 bool RetainExpansion = false;
4507 Optional<unsigned> NumExpansions;
4508 if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
4509 BaseTL.getSourceRange(),
4510 Unexpanded,
4511 TemplateArgs, ShouldExpand,
4512 RetainExpansion,
4513 NumExpansions)) {
4514 AnyErrors = true;
4515 New->setInvalidDecl();
4516 continue;
4517 }
4518 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4518, __extension__ __PRETTY_FUNCTION__))
;
4519
4520 // Loop over all of the arguments in the argument pack(s),
4521 for (unsigned I = 0; I != *NumExpansions; ++I) {
4522 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4523
4524 // Instantiate the initializer.
4525 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4526 /*CXXDirectInit=*/true);
4527 if (TempInit.isInvalid()) {
4528 AnyErrors = true;
4529 break;
4530 }
4531
4532 // Instantiate the base type.
4533 TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
4534 TemplateArgs,
4535 Init->getSourceLocation(),
4536 New->getDeclName());
4537 if (!BaseTInfo) {
4538 AnyErrors = true;
4539 break;
4540 }
4541
4542 // Build the initializer.
4543 MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
4544 BaseTInfo, TempInit.get(),
4545 New->getParent(),
4546 SourceLocation());
4547 if (NewInit.isInvalid()) {
4548 AnyErrors = true;
4549 break;
4550 }
4551
4552 NewInits.push_back(NewInit.get());
4553 }
4554
4555 continue;
4556 }
4557
4558 // Instantiate the initializer.
4559 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4560 /*CXXDirectInit=*/true);
4561 if (TempInit.isInvalid()) {
4562 AnyErrors = true;
4563 continue;
4564 }
4565
4566 MemInitResult NewInit;
4567 if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4568 TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4569 TemplateArgs,
4570 Init->getSourceLocation(),
4571 New->getDeclName());
4572 if (!TInfo) {
4573 AnyErrors = true;
4574 New->setInvalidDecl();
4575 continue;
4576 }
4577
4578 if (Init->isBaseInitializer())
4579 NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
4580 New->getParent(), EllipsisLoc);
4581 else
4582 NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
4583 cast<CXXRecordDecl>(CurContext->getParent()));
4584 } else if (Init->isMemberInitializer()) {
4585 FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
4586 Init->getMemberLocation(),
4587 Init->getMember(),
4588 TemplateArgs));
4589 if (!Member) {
4590 AnyErrors = true;
4591 New->setInvalidDecl();
4592 continue;
4593 }
4594
4595 NewInit = BuildMemberInitializer(Member, TempInit.get(),
4596 Init->getSourceLocation());
4597 } else if (Init->isIndirectMemberInitializer()) {
4598 IndirectFieldDecl *IndirectMember =
4599 cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
4600 Init->getMemberLocation(),
4601 Init->getIndirectMember(), TemplateArgs));
4602
4603 if (!IndirectMember) {
4604 AnyErrors = true;
4605 New->setInvalidDecl();
4606 continue;
4607 }
4608
4609 NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
4610 Init->getSourceLocation());
4611 }
4612
4613 if (NewInit.isInvalid()) {
4614 AnyErrors = true;
4615 New->setInvalidDecl();
4616 } else {
4617 NewInits.push_back(NewInit.get());
4618 }
4619 }
4620
4621 // Assign all the initializers to the new constructor.
4622 ActOnMemInitializers(New,
4623 /*FIXME: ColonLoc */
4624 SourceLocation(),
4625 NewInits,
4626 AnyErrors);
4627}
4628
4629// TODO: this could be templated if the various decl types used the
4630// same method name.
4631static bool isInstantiationOf(ClassTemplateDecl *Pattern,
4632 ClassTemplateDecl *Instance) {
4633 Pattern = Pattern->getCanonicalDecl();
4634
4635 do {
4636 Instance = Instance->getCanonicalDecl();
4637 if (Pattern == Instance) return true;
4638 Instance = Instance->getInstantiatedFromMemberTemplate();
4639 } while (Instance);
4640
4641 return false;
4642}
4643
4644static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
4645 FunctionTemplateDecl *Instance) {
4646 Pattern = Pattern->getCanonicalDecl();
4647
4648 do {
4649 Instance = Instance->getCanonicalDecl();
4650 if (Pattern == Instance) return true;
4651 Instance = Instance->getInstantiatedFromMemberTemplate();
4652 } while (Instance);
4653
4654 return false;
4655}
4656
4657static bool
4658isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
4659 ClassTemplatePartialSpecializationDecl *Instance) {
4660 Pattern
4661 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
4662 do {
4663 Instance = cast<ClassTemplatePartialSpecializationDecl>(
4664 Instance->getCanonicalDecl());
4665 if (Pattern == Instance)
4666 return true;
4667 Instance = Instance->getInstantiatedFromMember();
4668 } while (Instance);
4669
4670 return false;
4671}
4672
4673static bool isInstantiationOf(CXXRecordDecl *Pattern,
4674 CXXRecordDecl *Instance) {
4675 Pattern = Pattern->getCanonicalDecl();
4676
4677 do {
4678 Instance = Instance->getCanonicalDecl();
4679 if (Pattern == Instance) return true;
4680 Instance = Instance->getInstantiatedFromMemberClass();
4681 } while (Instance);
4682
4683 return false;
4684}
4685
4686static bool isInstantiationOf(FunctionDecl *Pattern,
4687 FunctionDecl *Instance) {
4688 Pattern = Pattern->getCanonicalDecl();
4689
4690 do {
4691 Instance = Instance->getCanonicalDecl();
4692 if (Pattern == Instance) return true;
4693 Instance = Instance->getInstantiatedFromMemberFunction();
4694 } while (Instance);
4695
4696 return false;
4697}
4698
4699static bool isInstantiationOf(EnumDecl *Pattern,
4700 EnumDecl *Instance) {
4701 Pattern = Pattern->getCanonicalDecl();
4702
4703 do {
4704 Instance = Instance->getCanonicalDecl();
4705 if (Pattern == Instance) return true;
4706 Instance = Instance->getInstantiatedFromMemberEnum();
4707 } while (Instance);
4708
4709 return false;
4710}
4711
4712static bool isInstantiationOf(UsingShadowDecl *Pattern,
4713 UsingShadowDecl *Instance,
4714 ASTContext &C) {
4715 return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
4716 Pattern);
4717}
4718
4719static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
4720 ASTContext &C) {
4721 return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4722}
4723
4724template<typename T>
4725static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
4726 ASTContext &Ctx) {
4727 // An unresolved using declaration can instantiate to an unresolved using
4728 // declaration, or to a using declaration or a using declaration pack.
4729 //
4730 // Multiple declarations can claim to be instantiated from an unresolved
4731 // using declaration if it's a pack expansion. We want the UsingPackDecl
4732 // in that case, not the individual UsingDecls within the pack.
4733 bool OtherIsPackExpansion;
4734 NamedDecl *OtherFrom;
4735 if (auto *OtherUUD = dyn_cast<T>(Other)) {
4736 OtherIsPackExpansion = OtherUUD->isPackExpansion();
4737 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
4738 } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
4739 OtherIsPackExpansion = true;
4740 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
4741 } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
4742 OtherIsPackExpansion = false;
4743 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
4744 } else {
4745 return false;
4746 }
4747 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
4748 declaresSameEntity(OtherFrom, Pattern);
4749}
4750
4751static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
4752 VarDecl *Instance) {
4753 assert(Instance->isStaticDataMember())(static_cast <bool> (Instance->isStaticDataMember())
? void (0) : __assert_fail ("Instance->isStaticDataMember()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4753, __extension__ __PRETTY_FUNCTION__))
;
4754
4755 Pattern = Pattern->getCanonicalDecl();
4756
4757 do {
4758 Instance = Instance->getCanonicalDecl();
4759 if (Pattern == Instance) return true;
4760 Instance = Instance->getInstantiatedFromStaticDataMember();
4761 } while (Instance);
4762
4763 return false;
4764}
4765
4766// Other is the prospective instantiation
4767// D is the prospective pattern
4768static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
4769 if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
4770 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4771
4772 if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
4773 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4774
4775 if (D->getKind() != Other->getKind())
4776 return false;
4777
4778 if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
4779 return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
4780
4781 if (auto *Function = dyn_cast<FunctionDecl>(Other))
4782 return isInstantiationOf(cast<FunctionDecl>(D), Function);
4783
4784 if (auto *Enum = dyn_cast<EnumDecl>(Other))
4785 return isInstantiationOf(cast<EnumDecl>(D), Enum);
4786
4787 if (auto *Var = dyn_cast<VarDecl>(Other))
4788 if (Var->isStaticDataMember())
4789 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
4790
4791 if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
4792 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
4793
4794 if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
4795 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
4796
4797 if (auto *PartialSpec =
4798 dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
4799 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
4800 PartialSpec);
4801
4802 if (auto *Field = dyn_cast<FieldDecl>(Other)) {
4803 if (!Field->getDeclName()) {
4804 // This is an unnamed field.
4805 return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
4806 cast<FieldDecl>(D));
4807 }
4808 }
4809
4810 if (auto *Using = dyn_cast<UsingDecl>(Other))
4811 return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
4812
4813 if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
4814 return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
4815
4816 return D->getDeclName() &&
4817 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
4818}
4819
4820template<typename ForwardIterator>
4821static NamedDecl *findInstantiationOf(ASTContext &Ctx,
4822 NamedDecl *D,
4823 ForwardIterator first,
4824 ForwardIterator last) {
4825 for (; first != last; ++first)
4826 if (isInstantiationOf(Ctx, D, *first))
4827 return cast<NamedDecl>(*first);
4828
4829 return nullptr;
4830}
4831
4832/// \brief Finds the instantiation of the given declaration context
4833/// within the current instantiation.
4834///
4835/// \returns NULL if there was an error
4836DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
4837 const MultiLevelTemplateArgumentList &TemplateArgs) {
4838 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
4839 Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
4840 return cast_or_null<DeclContext>(ID);
4841 } else return DC;
4842}
4843
4844/// \brief Find the instantiation of the given declaration within the
4845/// current instantiation.
4846///
4847/// This routine is intended to be used when \p D is a declaration
4848/// referenced from within a template, that needs to mapped into the
4849/// corresponding declaration within an instantiation. For example,
4850/// given:
4851///
4852/// \code
4853/// template<typename T>
4854/// struct X {
4855/// enum Kind {
4856/// KnownValue = sizeof(T)
4857/// };
4858///
4859/// bool getKind() const { return KnownValue; }
4860/// };
4861///
4862/// template struct X<int>;
4863/// \endcode
4864///
4865/// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4866/// \p EnumConstantDecl for \p KnownValue (which refers to
4867/// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4868/// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4869/// this mapping from within the instantiation of <tt>X<int></tt>.
4870NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
4871 const MultiLevelTemplateArgumentList &TemplateArgs,
4872 bool FindingInstantiatedContext) {
4873 DeclContext *ParentDC = D->getDeclContext();
4874 // FIXME: Parmeters of pointer to functions (y below) that are themselves
4875 // parameters (p below) can have their ParentDC set to the translation-unit
4876 // - thus we can not consistently check if the ParentDC of such a parameter
4877 // is Dependent or/and a FunctionOrMethod.
4878 // For e.g. this code, during Template argument deduction tries to
4879 // find an instantiated decl for (T y) when the ParentDC for y is
4880 // the translation unit.
4881 // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
4882 // float baz(float(*)()) { return 0.0; }
4883 // Foo(baz);
4884 // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
4885 // it gets here, always has a FunctionOrMethod as its ParentDC??
4886 // For now:
4887 // - as long as we have a ParmVarDecl whose parent is non-dependent and
4888 // whose type is not instantiation dependent, do nothing to the decl
4889 // - otherwise find its instantiated decl.
4890 if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
4891 !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
4892 return D;
4893 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
4894 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
4895 (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4896 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
4897 // D is a local of some kind. Look into the map of local
4898 // declarations to their instantiations.
4899 if (CurrentInstantiationScope) {
4900 if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
4901 if (Decl *FD = Found->dyn_cast<Decl *>())
4902 return cast<NamedDecl>(FD);
4903
4904 int PackIdx = ArgumentPackSubstitutionIndex;
4905 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4906, __extension__ __PRETTY_FUNCTION__))
4906 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4906, __extension__ __PRETTY_FUNCTION__))
;
4907 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4908 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4909 }
4910 }
4911
4912 // If we're performing a partial substitution during template argument
4913 // deduction, we may not have values for template parameters yet. They
4914 // just map to themselves.
4915 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4916 isa<TemplateTemplateParmDecl>(D))
4917 return D;
4918
4919 if (D->isInvalidDecl())
4920 return nullptr;
4921
4922 // Normally this function only searches for already instantiated declaration
4923 // however we have to make an exclusion for local types used before
4924 // definition as in the code:
4925 //
4926 // template<typename T> void f1() {
4927 // void g1(struct x1);
4928 // struct x1 {};
4929 // }
4930 //
4931 // In this case instantiation of the type of 'g1' requires definition of
4932 // 'x1', which is defined later. Error recovery may produce an enum used
4933 // before definition. In these cases we need to instantiate relevant
4934 // declarations here.
4935 bool NeedInstantiate = false;
4936 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
4937 NeedInstantiate = RD->isLocalClass();
4938 else
4939 NeedInstantiate = isa<EnumDecl>(D);
4940 if (NeedInstantiate) {
4941 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4942 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4943 return cast<TypeDecl>(Inst);
4944 }
4945
4946 // If we didn't find the decl, then we must have a label decl that hasn't
4947 // been found yet. Lazily instantiate it and return it now.
4948 assert(isa<LabelDecl>(D))(static_cast <bool> (isa<LabelDecl>(D)) ? void (0
) : __assert_fail ("isa<LabelDecl>(D)", "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4948, __extension__ __PRETTY_FUNCTION__))
;
4949
4950 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4951 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 4951, __extension__ __PRETTY_FUNCTION__))
;
4952
4953 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4954 return cast<LabelDecl>(Inst);
4955 }
4956
4957 // For variable template specializations, update those that are still
4958 // type-dependent.
4959 if (VarTemplateSpecializationDecl *VarSpec =
4960 dyn_cast<VarTemplateSpecializationDecl>(D)) {
4961 bool InstantiationDependent = false;
4962 const TemplateArgumentListInfo &VarTemplateArgs =
4963 VarSpec->getTemplateArgsInfo();
4964 if (TemplateSpecializationType::anyDependentTemplateArguments(
4965 VarTemplateArgs, InstantiationDependent))
4966 D = cast<NamedDecl>(
4967 SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4968 return D;
4969 }
4970
4971 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4972 if (!Record->isDependentContext())
4973 return D;
4974
4975 // Determine whether this record is the "templated" declaration describing
4976 // a class template or class template partial specialization.
4977 ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
4978 if (ClassTemplate)
4979 ClassTemplate = ClassTemplate->getCanonicalDecl();
4980 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4981 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
4982 ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
4983
4984 // Walk the current context to find either the record or an instantiation of
4985 // it.
4986 DeclContext *DC = CurContext;
4987 while (!DC->isFileContext()) {
4988 // If we're performing substitution while we're inside the template
4989 // definition, we'll find our own context. We're done.
4990 if (DC->Equals(Record))
4991 return Record;
4992
4993 if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
4994 // Check whether we're in the process of instantiating a class template
4995 // specialization of the template we're mapping.
4996 if (ClassTemplateSpecializationDecl *InstSpec
4997 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
4998 ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
4999 if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
5000 return InstRecord;
5001 }
5002
5003 // Check whether we're in the process of instantiating a member class.
5004 if (isInstantiationOf(Record, InstRecord))
5005 return InstRecord;
5006 }
5007
5008 // Move to the outer template scope.
5009 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
5010 if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
5011 DC = FD->getLexicalDeclContext();
5012 continue;
5013 }
5014 // An implicit deduction guide acts as if it's within the class template
5015 // specialization described by its name and first N template params.
5016 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
5017 if (Guide && Guide->isImplicit()) {
5018 TemplateDecl *TD = Guide->getDeducedTemplate();
5019 // Convert the arguments to an "as-written" list.
5020 TemplateArgumentListInfo Args(Loc, Loc);
5021 for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
5022 TD->getTemplateParameters()->size())) {
5023 ArrayRef<TemplateArgument> Unpacked(Arg);
5024 if (Arg.getKind() == TemplateArgument::Pack)
5025 Unpacked = Arg.pack_elements();
5026 for (TemplateArgument UnpackedArg : Unpacked)
5027 Args.addArgument(
5028 getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
5029 }
5030 QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
5031 if (T.isNull())
5032 return nullptr;
5033 auto *SubstRecord = T->getAsCXXRecordDecl();
5034 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5034, __extension__ __PRETTY_FUNCTION__))
;
5035 // Check that this template-id names the primary template and not a
5036 // partial or explicit specialization. (In the latter cases, it's
5037 // meaningless to attempt to find an instantiation of D within the
5038 // specialization.)
5039 // FIXME: The standard doesn't say what should happen here.
5040 if (FindingInstantiatedContext &&
5041 usesPartialOrExplicitSpecialization(
5042 Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
5043 Diag(Loc, diag::err_specialization_not_primary_template)
5044 << T << (SubstRecord->getTemplateSpecializationKind() ==
5045 TSK_ExplicitSpecialization);
5046 return nullptr;
5047 }
5048 DC = SubstRecord;
5049 continue;
5050 }
5051 }
5052
5053 DC = DC->getParent();
5054 }
5055
5056 // Fall through to deal with other dependent record types (e.g.,
5057 // anonymous unions in class templates).
5058 }
5059
5060 if (!ParentDC->isDependentContext())
5061 return D;
5062
5063 ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
5064 if (!ParentDC)
5065 return nullptr;
5066
5067 if (ParentDC != D->getDeclContext()) {
5068 // We performed some kind of instantiation in the parent context,
5069 // so now we need to look into the instantiated parent context to
5070 // find the instantiation of the declaration D.
5071
5072 // If our context used to be dependent, we may need to instantiate
5073 // it before performing lookup into that context.
5074 bool IsBeingInstantiated = false;
5075 if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
5076 if (!Spec->isDependentContext()) {
5077 QualType T = Context.getTypeDeclType(Spec);
5078 const RecordType *Tag = T->getAs<RecordType>();
5079 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5079, __extension__ __PRETTY_FUNCTION__))
;
5080 if (Tag->isBeingDefined())
5081 IsBeingInstantiated = true;
5082 if (!Tag->isBeingDefined() &&
5083 RequireCompleteType(Loc, T, diag::err_incomplete_type))
5084 return nullptr;
5085
5086 ParentDC = Tag->getDecl();
5087 }
5088 }
5089
5090 NamedDecl *Result = nullptr;
5091 // FIXME: If the name is a dependent name, this lookup won't necessarily
5092 // find it. Does that ever matter?
5093 if (auto Name = D->getDeclName()) {
5094 DeclarationNameInfo NameInfo(Name, D->getLocation());
5095 Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
5096 if (!Name)
5097 return nullptr;
5098 DeclContext::lookup_result Found = ParentDC->lookup(Name);
5099 Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
5100 } else {
5101 // Since we don't have a name for the entity we're looking for,
5102 // our only option is to walk through all of the declarations to
5103 // find that name. This will occur in a few cases:
5104 //
5105 // - anonymous struct/union within a template
5106 // - unnamed class/struct/union/enum within a template
5107 //
5108 // FIXME: Find a better way to find these instantiations!
5109 Result = findInstantiationOf(Context, D,
5110 ParentDC->decls_begin(),
5111 ParentDC->decls_end());
5112 }
5113
5114 if (!Result) {
5115 if (isa<UsingShadowDecl>(D)) {
5116 // UsingShadowDecls can instantiate to nothing because of using hiding.
5117 } else if (Diags.hasErrorOccurred()) {
5118 // We've already complained about something, so most likely this
5119 // declaration failed to instantiate. There's no point in complaining
5120 // further, since this is normal in invalid code.
5121 } else if (IsBeingInstantiated) {
5122 // The class in which this member exists is currently being
5123 // instantiated, and we haven't gotten around to instantiating this
5124 // member yet. This can happen when the code uses forward declarations
5125 // of member classes, and introduces ordering dependencies via
5126 // template instantiation.
5127 Diag(Loc, diag::err_member_not_yet_instantiated)
5128 << D->getDeclName()
5129 << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
5130 Diag(D->getLocation(), diag::note_non_instantiated_member_here);
5131 } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
5132 // This enumeration constant was found when the template was defined,
5133 // but can't be found in the instantiation. This can happen if an
5134 // unscoped enumeration member is explicitly specialized.
5135 EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
5136 EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
5137 TemplateArgs));
5138 assert(Spec->getTemplateSpecializationKind() ==(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5139, __extension__ __PRETTY_FUNCTION__))
5139 TSK_ExplicitSpecialization)(static_cast <bool> (Spec->getTemplateSpecializationKind
() == TSK_ExplicitSpecialization) ? void (0) : __assert_fail (
"Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5139, __extension__ __PRETTY_FUNCTION__))
;
5140 Diag(Loc, diag::err_enumerator_does_not_exist)
5141 << D->getDeclName()
5142 << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
5143 Diag(Spec->getLocation(), diag::note_enum_specialized_here)
5144 << Context.getTypeDeclType(Spec);
5145 } else {
5146 // We should have found something, but didn't.
5147 llvm_unreachable("Unable to find instantiation of declaration!")::llvm::llvm_unreachable_internal("Unable to find instantiation of declaration!"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5147)
;
5148 }
5149 }
5150
5151 D = Result;
5152 }
5153
5154 return D;
5155}
5156
5157/// \brief Performs template instantiation for all implicit template
5158/// instantiations we have seen until this point.
5159void Sema::PerformPendingInstantiations(bool LocalOnly) {
5160 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
169
Assuming the condition is true
5161 (!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
5162 PendingImplicitInstantiation Inst;
5163
5164 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
170
Assuming the condition is false
171
Taking false branch
5165 Inst = PendingInstantiations.front();
5166 PendingInstantiations.pop_front();
5167 } else {
5168 Inst = PendingLocalImplicitInstantiations.front();
5169 PendingLocalImplicitInstantiations.pop_front();
5170 }
5171
5172 // Instantiate function definitions
5173 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
172
Taking false branch
5174 bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
5175 TSK_ExplicitInstantiationDefinition;
5176 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
5177 DefinitionRequired, true);
5178 if (Function->isDefined())
5179 Function->setInstantiationIsPending(false);
5180 continue;
5181 }
5182
5183 // Instantiate variable definitions
5184 VarDecl *Var = cast<VarDecl>(Inst.first);
5185
5186 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
5187 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
5188 "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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
5189 " 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~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
;
5190
5191 // Don't try to instantiate declarations if the most recent redeclaration
5192 // is invalid.
5193 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
173
Assuming the condition is false
174
Taking false branch
5194 continue;
5195
5196 // Check if the most recent declaration has changed the specialization kind
5197 // and removed the need for implicit instantiation.
5198 switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
10
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
21
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
32
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
43
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
75
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
109
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
143
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
175
Control jumps to 'case TSK_ImplicitInstantiation:' at line 5210
5199 case TSK_Undeclared:
5200 llvm_unreachable("Cannot instantitiate an undeclared specialization.")::llvm::llvm_unreachable_internal("Cannot instantitiate an undeclared specialization."
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp"
, 5200)
;
5201 case TSK_ExplicitInstantiationDeclaration:
5202 case TSK_ExplicitSpecialization:
5203 continue; // No longer need to instantiate this type.
5204 case TSK_ExplicitInstantiationDefinition:
5205 // We only need an instantiation if the pending instantiation *is* the
5206 // explicit instantiation.
5207 if (Var != Var->getMostRecentDecl())
5208 continue;
5209 break;
5210 case TSK_ImplicitInstantiation:
5211 break;
11
Execution continues on line 5214
22
Execution continues on line 5214
33
Execution continues on line 5214
44
Execution continues on line 5214
76
Execution continues on line 5214
110
Execution continues on line 5214
144
Execution continues on line 5214
176
Execution continues on line 5214
5212 }
5213
5214 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
5215 "instantiating variable definition");
5216 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
177
Assuming the condition is false
5217 TSK_ExplicitInstantiationDefinition;
5218
5219 // Instantiate static data member definitions or variable template
5220 // specializations.
5221 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'
168
Returning from 'Sema::InstantiateVariableDefinition'
178
Calling 'Sema::InstantiateVariableDefinition'
5222 DefinitionRequired, true);
5223 }
5224}
5225
5226void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
5227 const MultiLevelTemplateArgumentList &TemplateArgs) {
5228 for (auto DD : Pattern->ddiags()) {
5229 switch (DD->getKind()) {
5230 case DependentDiagnostic::Access:
5231 HandleDependentAccessCheck(*DD, TemplateArgs);
5232 break;
5233 }
5234 }
5235}

/build/llvm-toolchain-snapshot-6.0~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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~svn321639/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, So