Bug Summary

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

Annotated Source Code

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

/build/llvm-toolchain-snapshot-6.0~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/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(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~svn318601/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~svn318601/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~svn318601/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~svn318601/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~svn318601/tools/clang/include/clang/Sema/Sema.h"
, 1794)
;
1795 }
1796 }
1797 };
1798
1799 /// \brief Perform name lookup on the given name, classifying it based on
1800 /// the results of name lookup and the following token.
1801 ///
1802 /// This routine is used by the parser to resolve identifiers and help direct
1803 /// parsing. When the identifier cannot be found, this routine will attempt
1804 /// to correct the typo and classify based on the resulting name.
1805 ///
1806 /// \param S The scope in which we're performing name lookup.
1807 ///
1808 /// \param SS The nested-name-specifier that precedes the name.
1809 ///
1810 /// \param Name The identifier. If typo correction finds an alternative name,
1811 /// this pointer parameter will be updated accordingly.
1812 ///
1813 /// \param NameLoc The location of the identifier.
1814 ///
1815 /// \param NextToken The token following the identifier. Used to help
1816 /// disambiguate the name.
1817 ///
1818 /// \param IsAddressOfOperand True if this name is the operand of a unary
1819 /// address of ('&') expression, assuming it is classified as an
1820 /// expression.
1821 ///
1822 /// \param CCC The correction callback, if typo correction is desired.
1823 NameClassification
1824 ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
1825 SourceLocation NameLoc, const Token &NextToken,
1826 bool IsAddressOfOperand,
1827 std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
1828
1829 /// Describes the detailed kind of a template name. Used in diagnostics.
1830 enum class TemplateNameKindForDiagnostics {
1831 ClassTemplate,
1832 FunctionTemplate,
1833 VarTemplate,
1834 AliasTemplate,
1835 TemplateTemplateParam,
1836 DependentTemplate
1837 };
1838 TemplateNameKindForDiagnostics
1839 getTemplateNameKindForDiagnostics(TemplateName Name);
1840
1841 /// Determine whether it's plausible that E was intended to be a
1842 /// template-name.
1843 bool mightBeIntendedToBeTemplateName(ExprResult E) {
1844 if (!getLangOpts().CPlusPlus || E.isInvalid())
1845 return false;
1846 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
1847 return !DRE->hasExplicitTemplateArgs();
1848 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
1849 return !ME->hasExplicitTemplateArgs();
1850 // Any additional cases recognized here should also be handled by
1851 // diagnoseExprIntendedAsTemplateName.
1852 return false;
1853 }
1854 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
1855 SourceLocation Less,
1856 SourceLocation Greater);
1857
1858 Decl *ActOnDeclarator(Scope *S, Declarator &D);
1859
1860 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
1861 MultiTemplateParamsArg TemplateParameterLists);
1862 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
1863 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
1864 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
1865 DeclarationName Name,
1866 SourceLocation Loc);
1867 void
1868 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
1869 SourceLocation FallbackLoc,
1870 SourceLocation ConstQualLoc = SourceLocation(),
1871 SourceLocation VolatileQualLoc = SourceLocation(),
1872 SourceLocation RestrictQualLoc = SourceLocation(),
1873 SourceLocation AtomicQualLoc = SourceLocation(),
1874 SourceLocation UnalignedQualLoc = SourceLocation());
1875
1876 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
1877 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
1878 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
1879 const LookupResult &R);
1880 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
1881 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
1882 const LookupResult &R);
1883 void CheckShadow(Scope *S, VarDecl *D);
1884
1885 /// Warn if 'E', which is an expression that is about to be modified, refers
1886 /// to a shadowing declaration.
1887 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
1888
1889 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
1890
1891private:
1892 /// Map of current shadowing declarations to shadowed declarations. Warn if
1893 /// it looks like the user is trying to modify the shadowing declaration.
1894 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
1895
1896public:
1897 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
1898 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
1899 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
1900 TypedefNameDecl *NewTD);
1901 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
1902 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1903 TypeSourceInfo *TInfo,
1904 LookupResult &Previous);
1905 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
1906 LookupResult &Previous, bool &Redeclaration);
1907 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
1908 TypeSourceInfo *TInfo,
1909 LookupResult &Previous,
1910 MultiTemplateParamsArg TemplateParamLists,
1911 bool &AddToScope,
1912 ArrayRef<BindingDecl *> Bindings = None);
1913 NamedDecl *
1914 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
1915 MultiTemplateParamsArg TemplateParamLists);
1916 // Returns true if the variable declaration is a redeclaration
1917 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
1918 void CheckVariableDeclarationType(VarDecl *NewVD);
1919 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
1920 Expr *Init);
1921 void CheckCompleteVariableDeclaration(VarDecl *VD);
1922 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
1923 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
1924
1925 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1926 TypeSourceInfo *TInfo,
1927 LookupResult &Previous,
1928 MultiTemplateParamsArg TemplateParamLists,
1929 bool &AddToScope);
1930 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1931
1932 bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
1933 bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
1934
1935 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
1936 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
1937 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1938 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
1939 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1940 // Returns true if the function declaration is a redeclaration
1941 bool CheckFunctionDeclaration(Scope *S,
1942 FunctionDecl *NewFD, LookupResult &Previous,
1943 bool IsMemberSpecialization);
1944 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
1945 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
1946 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
1947 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
1948 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
1949 SourceLocation Loc,
1950 QualType T);
1951 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
1952 SourceLocation NameLoc, IdentifierInfo *Name,
1953 QualType T, TypeSourceInfo *TSInfo,
1954 StorageClass SC);
1955 void ActOnParamDefaultArgument(Decl *param,
1956 SourceLocation EqualLoc,
1957 Expr *defarg);
1958 void ActOnParamUnparsedDefaultArgument(Decl *param,
1959 SourceLocation EqualLoc,
1960 SourceLocation ArgLoc);
1961 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
1962 bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
1963 SourceLocation EqualLoc);
1964
1965 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
1966 void ActOnUninitializedDecl(Decl *dcl);
1967 void ActOnInitializerError(Decl *Dcl);
1968
1969 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
1970 void ActOnCXXForRangeDecl(Decl *D);
1971 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
1972 IdentifierInfo *Ident,
1973 ParsedAttributes &Attrs,
1974 SourceLocation AttrEnd);
1975 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
1976 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
1977 void FinalizeDeclaration(Decl *D);
1978 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
1979 ArrayRef<Decl *> Group);
1980 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
1981
1982 /// Should be called on all declarations that might have attached
1983 /// documentation comments.
1984 void ActOnDocumentableDecl(Decl *D);
1985 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
1986
1987 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
1988 SourceLocation LocAfterDecls);
1989 void CheckForFunctionRedefinition(
1990 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
1991 SkipBodyInfo *SkipBody = nullptr);
1992 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
1993 MultiTemplateParamsArg TemplateParamLists,
1994 SkipBodyInfo *SkipBody = nullptr);
1995 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
1996 SkipBodyInfo *SkipBody = nullptr);
1997 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
1998 bool isObjCMethodDecl(Decl *D) {
1999 return D && isa<ObjCMethodDecl>(D);
2000 }
2001
2002 /// \brief Determine whether we can delay parsing the body of a function or
2003 /// function template until it is used, assuming we don't care about emitting
2004 /// code for that function.
2005 ///
2006 /// This will be \c false if we may need the body of the function in the
2007 /// middle of parsing an expression (where it's impractical to switch to
2008 /// parsing a different function), for instance, if it's constexpr in C++11
2009 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2010 bool canDelayFunctionBody(const Declarator &D);
2011
2012 /// \brief Determine whether we can skip parsing the body of a function
2013 /// definition, assuming we don't care about analyzing its body or emitting
2014 /// code for that function.
2015 ///
2016 /// This will be \c false only if we may need the body of the function in
2017 /// order to parse the rest of the program (for instance, if it is
2018 /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2019 bool canSkipFunctionBody(Decl *D);
2020
2021 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2022 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2023 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2024 Decl *ActOnSkippedFunctionBody(Decl *Decl);
2025 void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2026
2027 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2028 /// attribute for which parsing is delayed.
2029 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2030
2031 /// \brief Diagnose any unused parameters in the given sequence of
2032 /// ParmVarDecl pointers.
2033 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2034
2035 /// \brief Diagnose whether the size of parameters or return value of a
2036 /// function or obj-c method definition is pass-by-value and larger than a
2037 /// specified threshold.
2038 void
2039 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2040 QualType ReturnTy, NamedDecl *D);
2041
2042 void DiagnoseInvalidJumps(Stmt *Body);
2043 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2044 SourceLocation AsmLoc,
2045 SourceLocation RParenLoc);
2046
2047 /// \brief Handle a C++11 empty-declaration and attribute-declaration.
2048 Decl *ActOnEmptyDeclaration(Scope *S,
2049 AttributeList *AttrList,
2050 SourceLocation SemiLoc);
2051
2052 enum class ModuleDeclKind {
2053 Interface, ///< 'export module X;'
2054 Implementation, ///< 'module X;'
2055 Partition, ///< 'module partition X;'
2056 };
2057
2058 /// The parser has processed a module-declaration that begins the definition
2059 /// of a module interface or implementation.
2060 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2061 SourceLocation ModuleLoc, ModuleDeclKind MDK,
2062 ModuleIdPath Path);
2063
2064 /// \brief The parser has processed a module import declaration.
2065 ///
2066 /// \param AtLoc The location of the '@' symbol, if any.
2067 ///
2068 /// \param ImportLoc The location of the 'import' keyword.
2069 ///
2070 /// \param Path The module access path.
2071 DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc,
2072 ModuleIdPath Path);
2073
2074 /// \brief The parser has processed a module import translated from a
2075 /// #include or similar preprocessing directive.
2076 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2077 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2078
2079 /// \brief The parsed has entered a submodule.
2080 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2081 /// \brief The parser has left a submodule.
2082 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2083
2084 /// \brief Create an implicit import of the given module at the given
2085 /// source location, for error recovery, if possible.
2086 ///
2087 /// This routine is typically used when an entity found by name lookup
2088 /// is actually hidden within a module that we know about but the user
2089 /// has forgotten to import.
2090 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2091 Module *Mod);
2092
2093 /// Kinds of missing import. Note, the values of these enumerators correspond
2094 /// to %select values in diagnostics.
2095 enum class MissingImportKind {
2096 Declaration,
2097 Definition,
2098 DefaultArgument,
2099 ExplicitSpecialization,
2100 PartialSpecialization
2101 };
2102
2103 /// \brief Diagnose that the specified declaration needs to be visible but
2104 /// isn't, and suggest a module import that would resolve the problem.
2105 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2106 MissingImportKind MIK, bool Recover = true);
2107 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2108 SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2109 MissingImportKind MIK, bool Recover);
2110
2111 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2112 SourceLocation LBraceLoc);
2113 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2114 SourceLocation RBraceLoc);
2115
2116 /// \brief We've found a use of a templated declaration that would trigger an
2117 /// implicit instantiation. Check that any relevant explicit specializations
2118 /// and partial specializations are visible, and diagnose if not.
2119 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2120
2121 /// \brief We've found a use of a template specialization that would select a
2122 /// partial specialization. Check that the partial specialization is visible,
2123 /// and diagnose if not.
2124 void checkPartialSpecializationVisibility(SourceLocation Loc,
2125 NamedDecl *Spec);
2126
2127 /// \brief Retrieve a suitable printing policy.
2128 PrintingPolicy getPrintingPolicy() const {
2129 return getPrintingPolicy(Context, PP);
2130 }
2131
2132 /// \brief Retrieve a suitable printing policy.
2133 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2134 const Preprocessor &PP);
2135
2136 /// Scope actions.
2137 void ActOnPopScope(SourceLocation Loc, Scope *S);
2138 void ActOnTranslationUnitScope(Scope *S);
2139
2140 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2141 RecordDecl *&AnonRecord);
2142 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2143 MultiTemplateParamsArg TemplateParams,
2144 bool IsExplicitInstantiation,
2145 RecordDecl *&AnonRecord);
2146
2147 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2148 AccessSpecifier AS,
2149 RecordDecl *Record,
2150 const PrintingPolicy &Policy);
2151
2152 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2153 RecordDecl *Record);
2154
2155 /// Common ways to introduce type names without a tag for use in diagnostics.
2156 /// Keep in sync with err_tag_reference_non_tag.
2157 enum NonTagKind {
2158 NTK_NonStruct,
2159 NTK_NonClass,
2160 NTK_NonUnion,
2161 NTK_NonEnum,
2162 NTK_Typedef,
2163 NTK_TypeAlias,
2164 NTK_Template,
2165 NTK_TypeAliasTemplate,
2166 NTK_TemplateTemplateArgument,
2167 };
2168
2169 /// Given a non-tag type declaration, returns an enum useful for indicating
2170 /// what kind of non-tag type this is.
2171 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
2172
2173 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
2174 TagTypeKind NewTag, bool isDefinition,
2175 SourceLocation NewTagLoc,
2176 const IdentifierInfo *Name);
2177
2178 enum TagUseKind {
2179 TUK_Reference, // Reference to a tag: 'struct foo *X;'
2180 TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
2181 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'