Bug Summary

File:clang/lib/AST/DeclTemplate.cpp
Warning:line 83, column 9
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DeclTemplate.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-12/lib/clang/12.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/include -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/build-llvm/include -I /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-12/lib/clang/12.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-08-06-171148-17323-1 -x c++ /build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp
1//===- DeclTemplate.cpp - Template Declaration AST Node Implementation ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the C++ related Decl classes for templates.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/DeclTemplate.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclarationName.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/ExternalASTSource.h"
20#include "clang/AST/TemplateBase.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/AST/Type.h"
23#include "clang/AST/TypeLoc.h"
24#include "clang/Basic/Builtins.h"
25#include "clang/Basic/LLVM.h"
26#include "clang/Basic/SourceLocation.h"
27#include "llvm/ADT/ArrayRef.h"
28#include "llvm/ADT/FoldingSet.h"
29#include "llvm/ADT/None.h"
30#include "llvm/ADT/PointerUnion.h"
31#include "llvm/ADT/SmallVector.h"
32#include "llvm/Support/Casting.h"
33#include "llvm/Support/ErrorHandling.h"
34#include <algorithm>
35#include <cassert>
36#include <cstdint>
37#include <memory>
38#include <utility>
39
40using namespace clang;
41
42//===----------------------------------------------------------------------===//
43// TemplateParameterList Implementation
44//===----------------------------------------------------------------------===//
45
46
47TemplateParameterList::TemplateParameterList(const ASTContext& C,
48 SourceLocation TemplateLoc,
49 SourceLocation LAngleLoc,
50 ArrayRef<NamedDecl *> Params,
51 SourceLocation RAngleLoc,
52 Expr *RequiresClause)
53 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
54 NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
55 HasRequiresClause(RequiresClause != nullptr),
56 HasConstrainedParameters(false) {
57 for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
9
Assuming 'Idx' is < field 'NumParams'
10
Loop condition is true. Entering loop body
16
Assuming 'Idx' is >= field 'NumParams'
17
Loop condition is false. Execution continues on line 82
58 NamedDecl *P = Params[Idx];
59 begin()[Idx] = P;
60
61 bool IsPack = P->isTemplateParameterPack();
62 if (const auto *NTTP
11.1
'NTTP' is null
= dyn_cast<NonTypeTemplateParmDecl>(P)) {
11
Assuming 'P' is not a 'NonTypeTemplateParmDecl'
12
Taking false branch
63 if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
64 ContainsUnexpandedParameterPack = true;
65 if (NTTP->hasPlaceholderTypeConstraint())
66 HasConstrainedParameters = true;
67 } else if (const auto *TTP
13.1
'TTP' is non-null
= dyn_cast<TemplateTemplateParmDecl>(P)) {
13
Assuming 'P' is a 'TemplateTemplateParmDecl'
14
Taking true branch
68 if (!IsPack &&
15
Assuming 'IsPack' is true
69 TTP->getTemplateParameters()->containsUnexpandedParameterPack())
70 ContainsUnexpandedParameterPack = true;
71 } else if (const TypeConstraint *TC =
72 cast<TemplateTypeParmDecl>(P)->getTypeConstraint()) {
73 if (TC->getImmediatelyDeclaredConstraint()
74 ->containsUnexpandedParameterPack())
75 ContainsUnexpandedParameterPack = true;
76 HasConstrainedParameters = true;
77 }
78 // FIXME: If a default argument contains an unexpanded parameter pack, the
79 // template parameter list does too.
80 }
81
82 if (HasRequiresClause) {
18
Assuming field 'HasRequiresClause' is not equal to 0
19
Taking true branch
83 if (RequiresClause->containsUnexpandedParameterPack())
20
Called C++ object pointer is null
84 ContainsUnexpandedParameterPack = true;
85 *getTrailingObjects<Expr *>() = RequiresClause;
86 }
87}
88
89TemplateParameterList *
90TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
91 SourceLocation LAngleLoc,
92 ArrayRef<NamedDecl *> Params,
93 SourceLocation RAngleLoc, Expr *RequiresClause) {
94 void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
95 Params.size(), RequiresClause
5.1
'RequiresClause' is null
? 1u : 0u),
6
'?' condition is false
96 alignof(TemplateParameterList));
97 return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params,
8
Calling constructor for 'TemplateParameterList'
98 RAngleLoc, RequiresClause);
7
Passing null pointer value via 6th parameter 'RequiresClause'
99}
100
101unsigned TemplateParameterList::getMinRequiredArguments() const {
102 unsigned NumRequiredArgs = 0;
103 for (const NamedDecl *P : asArray()) {
104 if (P->isTemplateParameterPack()) {
105 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
106 if (NTTP->isExpandedParameterPack()) {
107 NumRequiredArgs += NTTP->getNumExpansionTypes();
108 continue;
109 }
110 } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
111 if (TTP->isExpandedParameterPack()) {
112 NumRequiredArgs += TTP->getNumExpansionParameters();
113 continue;
114 }
115 } else {
116 const auto *TP = cast<TemplateTemplateParmDecl>(P);
117 if (TP->isExpandedParameterPack()) {
118 NumRequiredArgs += TP->getNumExpansionTemplateParameters();
119 continue;
120 }
121 }
122
123 break;
124 }
125
126 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
127 if (TTP->hasDefaultArgument())
128 break;
129 } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
130 if (NTTP->hasDefaultArgument())
131 break;
132 } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
133 break;
134
135 ++NumRequiredArgs;
136 }
137
138 return NumRequiredArgs;
139}
140
141unsigned TemplateParameterList::getDepth() const {
142 if (size() == 0)
143 return 0;
144
145 const NamedDecl *FirstParm = getParam(0);
146 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
147 return TTP->getDepth();
148 else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
149 return NTTP->getDepth();
150 else
151 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
152}
153
154static void AdoptTemplateParameterList(TemplateParameterList *Params,
155 DeclContext *Owner) {
156 for (NamedDecl *P : *Params) {
157 P->setDeclContext(Owner);
158
159 if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
160 AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
161 }
162}
163
164void TemplateParameterList::
165getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
166 if (HasConstrainedParameters)
167 for (const NamedDecl *Param : *this) {
168 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
169 if (const auto *TC = TTP->getTypeConstraint())
170 AC.push_back(TC->getImmediatelyDeclaredConstraint());
171 } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
172 if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
173 AC.push_back(E);
174 }
175 }
176 if (HasRequiresClause)
177 AC.push_back(getRequiresClause());
178}
179
180bool TemplateParameterList::hasAssociatedConstraints() const {
181 return HasRequiresClause || HasConstrainedParameters;
182}
183
184namespace clang {
185
186void *allocateDefaultArgStorageChain(const ASTContext &C) {
187 return new (C) char[sizeof(void*) * 2];
188}
189
190} // namespace clang
191
192//===----------------------------------------------------------------------===//
193// TemplateDecl Implementation
194//===----------------------------------------------------------------------===//
195
196TemplateDecl::TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L,
197 DeclarationName Name, TemplateParameterList *Params,
198 NamedDecl *Decl)
199 : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {}
200
201void TemplateDecl::anchor() {}
202
203void TemplateDecl::
204getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
205 TemplateParams->getAssociatedConstraints(AC);
206 if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
207 if (const Expr *TRC = FD->getTrailingRequiresClause())
208 AC.push_back(TRC);
209}
210
211bool TemplateDecl::hasAssociatedConstraints() const {
212 if (TemplateParams->hasAssociatedConstraints())
213 return true;
214 if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
215 return FD->getTrailingRequiresClause();
216 return false;
217}
218
219//===----------------------------------------------------------------------===//
220// RedeclarableTemplateDecl Implementation
221//===----------------------------------------------------------------------===//
222
223void RedeclarableTemplateDecl::anchor() {}
224
225RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
226 if (Common)
227 return Common;
228
229 // Walk the previous-declaration chain until we either find a declaration
230 // with a common pointer or we run out of previous declarations.
231 SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
232 for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
233 Prev = Prev->getPreviousDecl()) {
234 if (Prev->Common) {
235 Common = Prev->Common;
236 break;
237 }
238
239 PrevDecls.push_back(Prev);
240 }
241
242 // If we never found a common pointer, allocate one now.
243 if (!Common) {
244 // FIXME: If any of the declarations is from an AST file, we probably
245 // need an update record to add the common data.
246
247 Common = newCommon(getASTContext());
248 }
249
250 // Update any previous declarations we saw with the common pointer.
251 for (const RedeclarableTemplateDecl *Prev : PrevDecls)
252 Prev->Common = Common;
253
254 return Common;
255}
256
257void RedeclarableTemplateDecl::loadLazySpecializationsImpl() const {
258 // Grab the most recent declaration to ensure we've loaded any lazy
259 // redeclarations of this template.
260 CommonBase *CommonBasePtr = getMostRecentDecl()->getCommonPtr();
261 if (CommonBasePtr->LazySpecializations) {
262 ASTContext &Context = getASTContext();
263 uint32_t *Specs = CommonBasePtr->LazySpecializations;
264 CommonBasePtr->LazySpecializations = nullptr;
265 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
266 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
267 }
268}
269
270template<class EntryType, typename... ProfileArguments>
271typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
272RedeclarableTemplateDecl::findSpecializationImpl(
273 llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos,
274 ProfileArguments&&... ProfileArgs) {
275 using SETraits = SpecEntryTraits<EntryType>;
276
277 llvm::FoldingSetNodeID ID;
278 EntryType::Profile(ID, std::forward<ProfileArguments>(ProfileArgs)...,
279 getASTContext());
280 EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
281 return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
282}
283
284template<class Derived, class EntryType>
285void RedeclarableTemplateDecl::addSpecializationImpl(
286 llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
287 void *InsertPos) {
288 using SETraits = SpecEntryTraits<EntryType>;
289
290 if (InsertPos) {
291#ifndef NDEBUG
292 void *CorrectInsertPos;
293 assert(!findSpecializationImpl(Specializations,((!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits
::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos
&& "given incorrect InsertPos for specialization") ?
static_cast<void> (0) : __assert_fail ("!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && \"given incorrect InsertPos for specialization\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 297, __PRETTY_FUNCTION__))
294 CorrectInsertPos,((!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits
::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos
&& "given incorrect InsertPos for specialization") ?
static_cast<void> (0) : __assert_fail ("!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && \"given incorrect InsertPos for specialization\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 297, __PRETTY_FUNCTION__))
295 SETraits::getTemplateArgs(Entry)) &&((!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits
::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos
&& "given incorrect InsertPos for specialization") ?
static_cast<void> (0) : __assert_fail ("!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && \"given incorrect InsertPos for specialization\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 297, __PRETTY_FUNCTION__))
296 InsertPos == CorrectInsertPos &&((!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits
::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos
&& "given incorrect InsertPos for specialization") ?
static_cast<void> (0) : __assert_fail ("!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && \"given incorrect InsertPos for specialization\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 297, __PRETTY_FUNCTION__))
297 "given incorrect InsertPos for specialization")((!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits
::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos
&& "given incorrect InsertPos for specialization") ?
static_cast<void> (0) : __assert_fail ("!findSpecializationImpl(Specializations, CorrectInsertPos, SETraits::getTemplateArgs(Entry)) && InsertPos == CorrectInsertPos && \"given incorrect InsertPos for specialization\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 297, __PRETTY_FUNCTION__))
;
298#endif
299 Specializations.InsertNode(Entry, InsertPos);
300 } else {
301 EntryType *Existing = Specializations.GetOrInsertNode(Entry);
302 (void)Existing;
303 assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&((SETraits::getDecl(Existing)->isCanonicalDecl() &&
"non-canonical specialization?") ? static_cast<void> (
0) : __assert_fail ("SETraits::getDecl(Existing)->isCanonicalDecl() && \"non-canonical specialization?\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 304, __PRETTY_FUNCTION__))
304 "non-canonical specialization?")((SETraits::getDecl(Existing)->isCanonicalDecl() &&
"non-canonical specialization?") ? static_cast<void> (
0) : __assert_fail ("SETraits::getDecl(Existing)->isCanonicalDecl() && \"non-canonical specialization?\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 304, __PRETTY_FUNCTION__))
;
305 }
306
307 if (ASTMutationListener *L = getASTMutationListener())
308 L->AddedCXXTemplateSpecialization(cast<Derived>(this),
309 SETraits::getDecl(Entry));
310}
311
312//===----------------------------------------------------------------------===//
313// FunctionTemplateDecl Implementation
314//===----------------------------------------------------------------------===//
315
316FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
317 DeclContext *DC,
318 SourceLocation L,
319 DeclarationName Name,
320 TemplateParameterList *Params,
321 NamedDecl *Decl) {
322 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
323 return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
324}
325
326FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
327 unsigned ID) {
328 return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
329 DeclarationName(), nullptr, nullptr);
330}
331
332RedeclarableTemplateDecl::CommonBase *
333FunctionTemplateDecl::newCommon(ASTContext &C) const {
334 auto *CommonPtr = new (C) Common;
335 C.addDestruction(CommonPtr);
336 return CommonPtr;
337}
338
339void FunctionTemplateDecl::LoadLazySpecializations() const {
340 loadLazySpecializationsImpl();
341}
342
343llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
344FunctionTemplateDecl::getSpecializations() const {
345 LoadLazySpecializations();
346 return getCommonPtr()->Specializations;
347}
348
349FunctionDecl *
350FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
351 void *&InsertPos) {
352 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
353}
354
355void FunctionTemplateDecl::addSpecialization(
356 FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
357 addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
358 InsertPos);
359}
360
361ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
362 TemplateParameterList *Params = getTemplateParameters();
363 Common *CommonPtr = getCommonPtr();
364 if (!CommonPtr->InjectedArgs) {
365 auto &Context = getASTContext();
366 SmallVector<TemplateArgument, 16> TemplateArgs;
367 Context.getInjectedTemplateArgs(Params, TemplateArgs);
368 CommonPtr->InjectedArgs =
369 new (Context) TemplateArgument[TemplateArgs.size()];
370 std::copy(TemplateArgs.begin(), TemplateArgs.end(),
371 CommonPtr->InjectedArgs);
372 }
373
374 return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
375}
376
377void FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) {
378 using Base = RedeclarableTemplateDecl;
379
380 // If we haven't created a common pointer yet, then it can just be created
381 // with the usual method.
382 if (!Base::Common)
383 return;
384
385 Common *ThisCommon = static_cast<Common *>(Base::Common);
386 Common *PrevCommon = nullptr;
387 SmallVector<FunctionTemplateDecl *, 8> PreviousDecls;
388 for (; Prev; Prev = Prev->getPreviousDecl()) {
389 if (Prev->Base::Common) {
390 PrevCommon = static_cast<Common *>(Prev->Base::Common);
391 break;
392 }
393 PreviousDecls.push_back(Prev);
394 }
395
396 // If the previous redecl chain hasn't created a common pointer yet, then just
397 // use this common pointer.
398 if (!PrevCommon) {
399 for (auto *D : PreviousDecls)
400 D->Base::Common = ThisCommon;
401 return;
402 }
403
404 // Ensure we don't leak any important state.
405 assert(ThisCommon->Specializations.size() == 0 &&((ThisCommon->Specializations.size() == 0 && "Can't merge incompatible declarations!"
) ? static_cast<void> (0) : __assert_fail ("ThisCommon->Specializations.size() == 0 && \"Can't merge incompatible declarations!\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 406, __PRETTY_FUNCTION__))
406 "Can't merge incompatible declarations!")((ThisCommon->Specializations.size() == 0 && "Can't merge incompatible declarations!"
) ? static_cast<void> (0) : __assert_fail ("ThisCommon->Specializations.size() == 0 && \"Can't merge incompatible declarations!\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 406, __PRETTY_FUNCTION__))
;
407
408 Base::Common = PrevCommon;
409}
410
411//===----------------------------------------------------------------------===//
412// ClassTemplateDecl Implementation
413//===----------------------------------------------------------------------===//
414
415ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
416 DeclContext *DC,
417 SourceLocation L,
418 DeclarationName Name,
419 TemplateParameterList *Params,
420 NamedDecl *Decl) {
421 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
422
423 return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
424}
425
426ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
427 unsigned ID) {
428 return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
429 DeclarationName(), nullptr, nullptr);
430}
431
432void ClassTemplateDecl::LoadLazySpecializations() const {
433 loadLazySpecializationsImpl();
434}
435
436llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
437ClassTemplateDecl::getSpecializations() const {
438 LoadLazySpecializations();
439 return getCommonPtr()->Specializations;
440}
441
442llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
443ClassTemplateDecl::getPartialSpecializations() {
444 LoadLazySpecializations();
445 return getCommonPtr()->PartialSpecializations;
446}
447
448RedeclarableTemplateDecl::CommonBase *
449ClassTemplateDecl::newCommon(ASTContext &C) const {
450 auto *CommonPtr = new (C) Common;
451 C.addDestruction(CommonPtr);
452 return CommonPtr;
453}
454
455ClassTemplateSpecializationDecl *
456ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
457 void *&InsertPos) {
458 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
459}
460
461void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
462 void *InsertPos) {
463 addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
464}
465
466ClassTemplatePartialSpecializationDecl *
467ClassTemplateDecl::findPartialSpecialization(
468 ArrayRef<TemplateArgument> Args,
469 TemplateParameterList *TPL, void *&InsertPos) {
470 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
471 TPL);
472}
473
474static void ProfileTemplateParameterList(ASTContext &C,
475 llvm::FoldingSetNodeID &ID, const TemplateParameterList *TPL) {
476 const Expr *RC = TPL->getRequiresClause();
477 ID.AddBoolean(RC != nullptr);
478 if (RC)
479 RC->Profile(ID, C, /*Canonical=*/true);
480 ID.AddInteger(TPL->size());
481 for (NamedDecl *D : *TPL) {
482 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
483 ID.AddInteger(0);
484 ID.AddBoolean(NTTP->isParameterPack());
485 NTTP->getType().getCanonicalType().Profile(ID);
486 continue;
487 }
488 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
489 ID.AddInteger(1);
490 ID.AddBoolean(TTP->isParameterPack());
491 ID.AddBoolean(TTP->hasTypeConstraint());
492 if (const TypeConstraint *TC = TTP->getTypeConstraint())
493 TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
494 /*Canonical=*/true);
495 continue;
496 }
497 const auto *TTP = cast<TemplateTemplateParmDecl>(D);
498 ID.AddInteger(2);
499 ID.AddBoolean(TTP->isParameterPack());
500 ProfileTemplateParameterList(C, ID, TTP->getTemplateParameters());
501 }
502}
503
504void
505ClassTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
506 ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
507 ASTContext &Context) {
508 ID.AddInteger(TemplateArgs.size());
509 for (const TemplateArgument &TemplateArg : TemplateArgs)
510 TemplateArg.Profile(ID, Context);
511 ProfileTemplateParameterList(Context, ID, TPL);
512}
513
514void ClassTemplateDecl::AddPartialSpecialization(
515 ClassTemplatePartialSpecializationDecl *D,
516 void *InsertPos) {
517 if (InsertPos)
518 getPartialSpecializations().InsertNode(D, InsertPos);
519 else {
520 ClassTemplatePartialSpecializationDecl *Existing
521 = getPartialSpecializations().GetOrInsertNode(D);
522 (void)Existing;
523 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?")((Existing->isCanonicalDecl() && "Non-canonical specialization?"
) ? static_cast<void> (0) : __assert_fail ("Existing->isCanonicalDecl() && \"Non-canonical specialization?\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 523, __PRETTY_FUNCTION__))
;
524 }
525
526 if (ASTMutationListener *L = getASTMutationListener())
527 L->AddedCXXTemplateSpecialization(this, D);
528}
529
530void ClassTemplateDecl::getPartialSpecializations(
531 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
532 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
533 = getPartialSpecializations();
534 PS.clear();
535 PS.reserve(PartialSpecs.size());
536 for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
537 PS.push_back(P.getMostRecentDecl());
538}
539
540ClassTemplatePartialSpecializationDecl *
541ClassTemplateDecl::findPartialSpecialization(QualType T) {
542 ASTContext &Context = getASTContext();
543 for (ClassTemplatePartialSpecializationDecl &P :
544 getPartialSpecializations()) {
545 if (Context.hasSameType(P.getInjectedSpecializationType(), T))
546 return P.getMostRecentDecl();
547 }
548
549 return nullptr;
550}
551
552ClassTemplatePartialSpecializationDecl *
553ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
554 ClassTemplatePartialSpecializationDecl *D) {
555 Decl *DCanon = D->getCanonicalDecl();
556 for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
557 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
558 return P.getMostRecentDecl();
559 }
560
561 return nullptr;
562}
563
564QualType
565ClassTemplateDecl::getInjectedClassNameSpecialization() {
566 Common *CommonPtr = getCommonPtr();
567 if (!CommonPtr->InjectedClassNameType.isNull())
568 return CommonPtr->InjectedClassNameType;
569
570 // C++0x [temp.dep.type]p2:
571 // The template argument list of a primary template is a template argument
572 // list in which the nth template argument has the value of the nth template
573 // parameter of the class template. If the nth template parameter is a
574 // template parameter pack (14.5.3), the nth template argument is a pack
575 // expansion (14.5.3) whose pattern is the name of the template parameter
576 // pack.
577 ASTContext &Context = getASTContext();
578 TemplateParameterList *Params = getTemplateParameters();
579 SmallVector<TemplateArgument, 16> TemplateArgs;
580 Context.getInjectedTemplateArgs(Params, TemplateArgs);
581 CommonPtr->InjectedClassNameType
582 = Context.getTemplateSpecializationType(TemplateName(this),
583 TemplateArgs);
584 return CommonPtr->InjectedClassNameType;
585}
586
587//===----------------------------------------------------------------------===//
588// TemplateTypeParm Allocation/Deallocation Method Implementations
589//===----------------------------------------------------------------------===//
590
591TemplateTypeParmDecl *
592TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
593 SourceLocation KeyLoc, SourceLocation NameLoc,
594 unsigned D, unsigned P, IdentifierInfo *Id,
595 bool Typename, bool ParameterPack,
596 bool HasTypeConstraint,
597 Optional<unsigned> NumExpanded) {
598 auto *TTPDecl =
599 new (C, DC,
600 additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
601 TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
602 HasTypeConstraint, NumExpanded);
603 QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
604 TTPDecl->setTypeForDecl(TTPType.getTypePtr());
605 return TTPDecl;
606}
607
608TemplateTypeParmDecl *
609TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
610 return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
611 SourceLocation(), nullptr, false,
612 false, None);
613}
614
615TemplateTypeParmDecl *
616TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID,
617 bool HasTypeConstraint) {
618 return new (C, ID,
619 additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
620 TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(),
621 nullptr, false, HasTypeConstraint, None);
622}
623
624SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
625 return hasDefaultArgument()
626 ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
627 : SourceLocation();
628}
629
630SourceRange TemplateTypeParmDecl::getSourceRange() const {
631 if (hasDefaultArgument() && !defaultArgumentWasInherited())
632 return SourceRange(getBeginLoc(),
633 getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
634 // TypeDecl::getSourceRange returns a range containing name location, which is
635 // wrong for unnamed template parameters. e.g:
636 // it will return <[[typename>]] instead of <[[typename]]>
637 else if (getDeclName().isEmpty())
638 return SourceRange(getBeginLoc());
639 return TypeDecl::getSourceRange();
640}
641
642unsigned TemplateTypeParmDecl::getDepth() const {
643 return getTypeForDecl()->castAs<TemplateTypeParmType>()->getDepth();
644}
645
646unsigned TemplateTypeParmDecl::getIndex() const {
647 return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
648}
649
650bool TemplateTypeParmDecl::isParameterPack() const {
651 return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
652}
653
654void TemplateTypeParmDecl::setTypeConstraint(NestedNameSpecifierLoc NNS,
655 DeclarationNameInfo NameInfo, NamedDecl *FoundDecl, ConceptDecl *CD,
656 const ASTTemplateArgumentListInfo *ArgsAsWritten,
657 Expr *ImmediatelyDeclaredConstraint) {
658 assert(HasTypeConstraint &&((HasTypeConstraint && "HasTypeConstraint=true must be passed at construction in order to "
"call setTypeConstraint") ? static_cast<void> (0) : __assert_fail
("HasTypeConstraint && \"HasTypeConstraint=true must be passed at construction in order to \" \"call setTypeConstraint\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 660, __PRETTY_FUNCTION__))
659 "HasTypeConstraint=true must be passed at construction in order to "((HasTypeConstraint && "HasTypeConstraint=true must be passed at construction in order to "
"call setTypeConstraint") ? static_cast<void> (0) : __assert_fail
("HasTypeConstraint && \"HasTypeConstraint=true must be passed at construction in order to \" \"call setTypeConstraint\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 660, __PRETTY_FUNCTION__))
660 "call setTypeConstraint")((HasTypeConstraint && "HasTypeConstraint=true must be passed at construction in order to "
"call setTypeConstraint") ? static_cast<void> (0) : __assert_fail
("HasTypeConstraint && \"HasTypeConstraint=true must be passed at construction in order to \" \"call setTypeConstraint\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 660, __PRETTY_FUNCTION__))
;
661 assert(!TypeConstraintInitialized &&((!TypeConstraintInitialized && "TypeConstraint was already initialized!"
) ? static_cast<void> (0) : __assert_fail ("!TypeConstraintInitialized && \"TypeConstraint was already initialized!\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 662, __PRETTY_FUNCTION__))
662 "TypeConstraint was already initialized!")((!TypeConstraintInitialized && "TypeConstraint was already initialized!"
) ? static_cast<void> (0) : __assert_fail ("!TypeConstraintInitialized && \"TypeConstraint was already initialized!\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 662, __PRETTY_FUNCTION__))
;
663 new (getTrailingObjects<TypeConstraint>()) TypeConstraint(NNS, NameInfo,
664 FoundDecl, CD, ArgsAsWritten, ImmediatelyDeclaredConstraint);
665 TypeConstraintInitialized = true;
666}
667
668//===----------------------------------------------------------------------===//
669// NonTypeTemplateParmDecl Method Implementations
670//===----------------------------------------------------------------------===//
671
672NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
673 DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
674 unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
675 ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
676 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
677 TemplateParmPosition(D, P), ParameterPack(true),
678 ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
679 if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
680 auto TypesAndInfos =
681 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
682 for (unsigned I = 0; I != NumExpandedTypes; ++I) {
683 new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
684 TypesAndInfos[I].second = ExpandedTInfos[I];
685 }
686 }
687}
688
689NonTypeTemplateParmDecl *
690NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
691 SourceLocation StartLoc, SourceLocation IdLoc,
692 unsigned D, unsigned P, IdentifierInfo *Id,
693 QualType T, bool ParameterPack,
694 TypeSourceInfo *TInfo) {
695 AutoType *AT =
696 C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
697 return new (C, DC,
698 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
699 Expr *>(0,
700 AT && AT->isConstrained() ? 1 : 0))
701 NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
702 TInfo);
703}
704
705NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
706 const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
707 SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
708 QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
709 ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
710 AutoType *AT = TInfo->getType()->getContainedAutoType();
711 return new (C, DC,
712 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
713 Expr *>(
714 ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
715 NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
716 ExpandedTypes, ExpandedTInfos);
717}
718
719NonTypeTemplateParmDecl *
720NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
721 bool HasTypeConstraint) {
722 return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
723 TypeSourceInfo *>,
724 Expr *>(0,
725 HasTypeConstraint ? 1 : 0))
726 NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
727 0, 0, nullptr, QualType(), false, nullptr);
728}
729
730NonTypeTemplateParmDecl *
731NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
732 unsigned NumExpandedTypes,
733 bool HasTypeConstraint) {
734 auto *NTTP =
735 new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
736 Expr *>(
737 NumExpandedTypes, HasTypeConstraint ? 1 : 0))
738 NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
739 0, 0, nullptr, QualType(), nullptr, None,
740 None);
741 NTTP->NumExpandedTypes = NumExpandedTypes;
742 return NTTP;
743}
744
745SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
746 if (hasDefaultArgument() && !defaultArgumentWasInherited())
747 return SourceRange(getOuterLocStart(),
748 getDefaultArgument()->getSourceRange().getEnd());
749 return DeclaratorDecl::getSourceRange();
750}
751
752SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
753 return hasDefaultArgument()
754 ? getDefaultArgument()->getSourceRange().getBegin()
755 : SourceLocation();
756}
757
758//===----------------------------------------------------------------------===//
759// TemplateTemplateParmDecl Method Implementations
760//===----------------------------------------------------------------------===//
761
762void TemplateTemplateParmDecl::anchor() {}
763
764TemplateTemplateParmDecl::TemplateTemplateParmDecl(
765 DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
766 IdentifierInfo *Id, TemplateParameterList *Params,
767 ArrayRef<TemplateParameterList *> Expansions)
768 : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
769 TemplateParmPosition(D, P), ParameterPack(true),
770 ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
771 if (!Expansions.empty())
772 std::uninitialized_copy(Expansions.begin(), Expansions.end(),
773 getTrailingObjects<TemplateParameterList *>());
774}
775
776TemplateTemplateParmDecl *
777TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
778 SourceLocation L, unsigned D, unsigned P,
779 bool ParameterPack, IdentifierInfo *Id,
780 TemplateParameterList *Params) {
781 return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
782 Params);
783}
784
785TemplateTemplateParmDecl *
786TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
787 SourceLocation L, unsigned D, unsigned P,
788 IdentifierInfo *Id,
789 TemplateParameterList *Params,
790 ArrayRef<TemplateParameterList *> Expansions) {
791 return new (C, DC,
792 additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
793 TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
794}
795
796TemplateTemplateParmDecl *
797TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
798 return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
799 false, nullptr, nullptr);
800}
801
802TemplateTemplateParmDecl *
803TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
804 unsigned NumExpansions) {
805 auto *TTP =
806 new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
807 TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
808 nullptr, None);
809 TTP->NumExpandedParams = NumExpansions;
810 return TTP;
811}
812
813SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
814 return hasDefaultArgument() ? getDefaultArgument().getLocation()
815 : SourceLocation();
816}
817
818void TemplateTemplateParmDecl::setDefaultArgument(
819 const ASTContext &C, const TemplateArgumentLoc &DefArg) {
820 if (DefArg.getArgument().isNull())
821 DefaultArgument.set(nullptr);
822 else
823 DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
824}
825
826//===----------------------------------------------------------------------===//
827// TemplateArgumentList Implementation
828//===----------------------------------------------------------------------===//
829TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
830 : Arguments(getTrailingObjects<TemplateArgument>()),
831 NumArguments(Args.size()) {
832 std::uninitialized_copy(Args.begin(), Args.end(),
833 getTrailingObjects<TemplateArgument>());
834}
835
836TemplateArgumentList *
837TemplateArgumentList::CreateCopy(ASTContext &Context,
838 ArrayRef<TemplateArgument> Args) {
839 void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
840 return new (Mem) TemplateArgumentList(Args);
841}
842
843FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create(
844 ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
845 TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
846 const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
847 MemberSpecializationInfo *MSInfo) {
848 const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
849 if (TemplateArgsAsWritten)
850 ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
851 *TemplateArgsAsWritten);
852
853 void *Mem =
854 C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
855 return new (Mem) FunctionTemplateSpecializationInfo(
856 FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);
857}
858
859//===----------------------------------------------------------------------===//
860// ClassTemplateSpecializationDecl Implementation
861//===----------------------------------------------------------------------===//
862
863ClassTemplateSpecializationDecl::
864ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
865 DeclContext *DC, SourceLocation StartLoc,
866 SourceLocation IdLoc,
867 ClassTemplateDecl *SpecializedTemplate,
868 ArrayRef<TemplateArgument> Args,
869 ClassTemplateSpecializationDecl *PrevDecl)
870 : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
871 SpecializedTemplate->getIdentifier(), PrevDecl),
872 SpecializedTemplate(SpecializedTemplate),
873 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
874 SpecializationKind(TSK_Undeclared) {
875}
876
877ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
878 Kind DK)
879 : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
880 SourceLocation(), nullptr, nullptr),
881 SpecializationKind(TSK_Undeclared) {}
882
883ClassTemplateSpecializationDecl *
884ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
885 DeclContext *DC,
886 SourceLocation StartLoc,
887 SourceLocation IdLoc,
888 ClassTemplateDecl *SpecializedTemplate,
889 ArrayRef<TemplateArgument> Args,
890 ClassTemplateSpecializationDecl *PrevDecl) {
891 auto *Result =
892 new (Context, DC) ClassTemplateSpecializationDecl(
893 Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
894 SpecializedTemplate, Args, PrevDecl);
895 Result->setMayHaveOutOfDateDef(false);
896
897 Context.getTypeDeclType(Result, PrevDecl);
898 return Result;
899}
900
901ClassTemplateSpecializationDecl *
902ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
903 unsigned ID) {
904 auto *Result =
905 new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
906 Result->setMayHaveOutOfDateDef(false);
907 return Result;
908}
909
910void ClassTemplateSpecializationDecl::getNameForDiagnostic(
911 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
912 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
913
914 const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
915 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
916 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
917 printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
918 } else {
919 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
920 printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
921 }
922}
923
924ClassTemplateDecl *
925ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
926 if (const auto *PartialSpec =
927 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
928 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
929 return SpecializedTemplate.get<ClassTemplateDecl*>();
930}
931
932SourceRange
933ClassTemplateSpecializationDecl::getSourceRange() const {
934 if (ExplicitInfo) {
935 SourceLocation Begin = getTemplateKeywordLoc();
936 if (Begin.isValid()) {
937 // Here we have an explicit (partial) specialization or instantiation.
938 assert(getSpecializationKind() == TSK_ExplicitSpecialization ||((getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind
() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind
() == TSK_ExplicitInstantiationDefinition) ? static_cast<void
> (0) : __assert_fail ("getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind() == TSK_ExplicitInstantiationDefinition"
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 940, __PRETTY_FUNCTION__))
939 getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||((getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind
() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind
() == TSK_ExplicitInstantiationDefinition) ? static_cast<void
> (0) : __assert_fail ("getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind() == TSK_ExplicitInstantiationDefinition"
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 940, __PRETTY_FUNCTION__))
940 getSpecializationKind() == TSK_ExplicitInstantiationDefinition)((getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind
() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind
() == TSK_ExplicitInstantiationDefinition) ? static_cast<void
> (0) : __assert_fail ("getSpecializationKind() == TSK_ExplicitSpecialization || getSpecializationKind() == TSK_ExplicitInstantiationDeclaration || getSpecializationKind() == TSK_ExplicitInstantiationDefinition"
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 940, __PRETTY_FUNCTION__))
;
941 if (getExternLoc().isValid())
942 Begin = getExternLoc();
943 SourceLocation End = getBraceRange().getEnd();
944 if (End.isInvalid())
945 End = getTypeAsWritten()->getTypeLoc().getEndLoc();
946 return SourceRange(Begin, End);
947 }
948 // An implicit instantiation of a class template partial specialization
949 // uses ExplicitInfo to record the TypeAsWritten, but the source
950 // locations should be retrieved from the instantiation pattern.
951 using CTPSDecl = ClassTemplatePartialSpecializationDecl;
952 auto *ctpsd = const_cast<CTPSDecl *>(cast<CTPSDecl>(this));
953 CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
954 assert(inst_from != nullptr)((inst_from != nullptr) ? static_cast<void> (0) : __assert_fail
("inst_from != nullptr", "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 954, __PRETTY_FUNCTION__))
;
955 return inst_from->getSourceRange();
956 }
957 else {
958 // No explicit info available.
959 llvm::PointerUnion<ClassTemplateDecl *,
960 ClassTemplatePartialSpecializationDecl *>
961 inst_from = getInstantiatedFrom();
962 if (inst_from.isNull())
963 return getSpecializedTemplate()->getSourceRange();
964 if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
965 return ctd->getSourceRange();
966 return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
967 ->getSourceRange();
968 }
969}
970
971//===----------------------------------------------------------------------===//
972// ConceptDecl Implementation
973//===----------------------------------------------------------------------===//
974ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
975 SourceLocation L, DeclarationName Name,
976 TemplateParameterList *Params,
977 Expr *ConstraintExpr) {
978 AdoptTemplateParameterList(Params, DC);
979 return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
980}
981
982ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C,
983 unsigned ID) {
984 ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
985 DeclarationName(),
986 nullptr, nullptr);
987
988 return Result;
989}
990
991//===----------------------------------------------------------------------===//
992// ClassTemplatePartialSpecializationDecl Implementation
993//===----------------------------------------------------------------------===//
994void ClassTemplatePartialSpecializationDecl::anchor() {}
995
996ClassTemplatePartialSpecializationDecl::
997ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
998 DeclContext *DC,
999 SourceLocation StartLoc,
1000 SourceLocation IdLoc,
1001 TemplateParameterList *Params,
1002 ClassTemplateDecl *SpecializedTemplate,
1003 ArrayRef<TemplateArgument> Args,
1004 const ASTTemplateArgumentListInfo *ArgInfos,
1005 ClassTemplatePartialSpecializationDecl *PrevDecl)
1006 : ClassTemplateSpecializationDecl(Context,
1007 ClassTemplatePartialSpecialization,
1008 TK, DC, StartLoc, IdLoc,
1009 SpecializedTemplate, Args, PrevDecl),
1010 TemplateParams(Params), ArgsAsWritten(ArgInfos),
1011 InstantiatedFromMember(nullptr, false) {
1012 AdoptTemplateParameterList(Params, this);
1013}
1014
1015ClassTemplatePartialSpecializationDecl *
1016ClassTemplatePartialSpecializationDecl::
1017Create(ASTContext &Context, TagKind TK,DeclContext *DC,
1018 SourceLocation StartLoc, SourceLocation IdLoc,
1019 TemplateParameterList *Params,
1020 ClassTemplateDecl *SpecializedTemplate,
1021 ArrayRef<TemplateArgument> Args,
1022 const TemplateArgumentListInfo &ArgInfos,
1023 QualType CanonInjectedType,
1024 ClassTemplatePartialSpecializationDecl *PrevDecl) {
1025 const ASTTemplateArgumentListInfo *ASTArgInfos =
1026 ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1027
1028 auto *Result = new (Context, DC)
1029 ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
1030 Params, SpecializedTemplate, Args,
1031 ASTArgInfos, PrevDecl);
1032 Result->setSpecializationKind(TSK_ExplicitSpecialization);
1033 Result->setMayHaveOutOfDateDef(false);
1034
1035 Context.getInjectedClassNameType(Result, CanonInjectedType);
1036 return Result;
1037}
1038
1039ClassTemplatePartialSpecializationDecl *
1040ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1041 unsigned ID) {
1042 auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C);
1043 Result->setMayHaveOutOfDateDef(false);
1044 return Result;
1045}
1046
1047//===----------------------------------------------------------------------===//
1048// FriendTemplateDecl Implementation
1049//===----------------------------------------------------------------------===//
1050
1051void FriendTemplateDecl::anchor() {}
1052
1053FriendTemplateDecl *
1054FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
1055 SourceLocation L,
1056 MutableArrayRef<TemplateParameterList *> Params,
1057 FriendUnion Friend, SourceLocation FLoc) {
1058 return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
1059}
1060
1061FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
1062 unsigned ID) {
1063 return new (C, ID) FriendTemplateDecl(EmptyShell());
1064}
1065
1066//===----------------------------------------------------------------------===//
1067// TypeAliasTemplateDecl Implementation
1068//===----------------------------------------------------------------------===//
1069
1070TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
1071 DeclContext *DC,
1072 SourceLocation L,
1073 DeclarationName Name,
1074 TemplateParameterList *Params,
1075 NamedDecl *Decl) {
1076 AdoptTemplateParameterList(Params, DC);
1077 return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
1078}
1079
1080TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
1081 unsigned ID) {
1082 return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
1083 DeclarationName(), nullptr, nullptr);
1084}
1085
1086RedeclarableTemplateDecl::CommonBase *
1087TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
1088 auto *CommonPtr = new (C) Common;
1089 C.addDestruction(CommonPtr);
1090 return CommonPtr;
1091}
1092
1093//===----------------------------------------------------------------------===//
1094// ClassScopeFunctionSpecializationDecl Implementation
1095//===----------------------------------------------------------------------===//
1096
1097void ClassScopeFunctionSpecializationDecl::anchor() {}
1098
1099ClassScopeFunctionSpecializationDecl *
1100ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
1101 unsigned ID) {
1102 return new (C, ID) ClassScopeFunctionSpecializationDecl(
1103 nullptr, SourceLocation(), nullptr, nullptr);
1104}
1105
1106//===----------------------------------------------------------------------===//
1107// VarTemplateDecl Implementation
1108//===----------------------------------------------------------------------===//
1109
1110VarTemplateDecl *VarTemplateDecl::getDefinition() {
1111 VarTemplateDecl *CurD = this;
1112 while (CurD) {
1113 if (CurD->isThisDeclarationADefinition())
1114 return CurD;
1115 CurD = CurD->getPreviousDecl();
1116 }
1117 return nullptr;
1118}
1119
1120VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
1121 SourceLocation L, DeclarationName Name,
1122 TemplateParameterList *Params,
1123 VarDecl *Decl) {
1124 AdoptTemplateParameterList(Params, DC);
1125 return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
1126}
1127
1128VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
1129 unsigned ID) {
1130 return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
1131 DeclarationName(), nullptr, nullptr);
1132}
1133
1134void VarTemplateDecl::LoadLazySpecializations() const {
1135 loadLazySpecializationsImpl();
1136}
1137
1138llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
1139VarTemplateDecl::getSpecializations() const {
1140 LoadLazySpecializations();
1141 return getCommonPtr()->Specializations;
1142}
1143
1144llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
1145VarTemplateDecl::getPartialSpecializations() {
1146 LoadLazySpecializations();
1147 return getCommonPtr()->PartialSpecializations;
1148}
1149
1150RedeclarableTemplateDecl::CommonBase *
1151VarTemplateDecl::newCommon(ASTContext &C) const {
1152 auto *CommonPtr = new (C) Common;
1153 C.addDestruction(CommonPtr);
1154 return CommonPtr;
1155}
1156
1157VarTemplateSpecializationDecl *
1158VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
1159 void *&InsertPos) {
1160 return findSpecializationImpl(getSpecializations(), InsertPos, Args);
1161}
1162
1163void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
1164 void *InsertPos) {
1165 addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1166}
1167
1168VarTemplatePartialSpecializationDecl *
1169VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1170 TemplateParameterList *TPL, void *&InsertPos) {
1171 return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
1172 TPL);
1173}
1174
1175void
1176VarTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
1177 ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
1178 ASTContext &Context) {
1179 ID.AddInteger(TemplateArgs.size());
1180 for (const TemplateArgument &TemplateArg : TemplateArgs)
1181 TemplateArg.Profile(ID, Context);
1182 ProfileTemplateParameterList(Context, ID, TPL);
1183}
1184
1185void VarTemplateDecl::AddPartialSpecialization(
1186 VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1187 if (InsertPos)
1188 getPartialSpecializations().InsertNode(D, InsertPos);
1189 else {
1190 VarTemplatePartialSpecializationDecl *Existing =
1191 getPartialSpecializations().GetOrInsertNode(D);
1192 (void)Existing;
1193 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?")((Existing->isCanonicalDecl() && "Non-canonical specialization?"
) ? static_cast<void> (0) : __assert_fail ("Existing->isCanonicalDecl() && \"Non-canonical specialization?\""
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 1193, __PRETTY_FUNCTION__))
;
1194 }
1195
1196 if (ASTMutationListener *L = getASTMutationListener())
1197 L->AddedCXXTemplateSpecialization(this, D);
1198}
1199
1200void VarTemplateDecl::getPartialSpecializations(
1201 SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
1202 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1203 getPartialSpecializations();
1204 PS.clear();
1205 PS.reserve(PartialSpecs.size());
1206 for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1207 PS.push_back(P.getMostRecentDecl());
1208}
1209
1210VarTemplatePartialSpecializationDecl *
1211VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1212 VarTemplatePartialSpecializationDecl *D) {
1213 Decl *DCanon = D->getCanonicalDecl();
1214 for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1215 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1216 return P.getMostRecentDecl();
1217 }
1218
1219 return nullptr;
1220}
1221
1222//===----------------------------------------------------------------------===//
1223// VarTemplateSpecializationDecl Implementation
1224//===----------------------------------------------------------------------===//
1225
1226VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1227 Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1228 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1229 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1230 : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1231 SpecializedTemplate->getIdentifier(), T, TInfo, S),
1232 SpecializedTemplate(SpecializedTemplate),
1233 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1234 SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1235
1236VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1237 ASTContext &C)
1238 : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1239 QualType(), nullptr, SC_None),
1240 SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1241
1242VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1243 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1244 SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1245 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1246 return new (Context, DC) VarTemplateSpecializationDecl(
1247 VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1248 SpecializedTemplate, T, TInfo, S, Args);
1249}
1250
1251VarTemplateSpecializationDecl *
1252VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1253 return new (C, ID)
1254 VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1255}
1256
1257void VarTemplateSpecializationDecl::getNameForDiagnostic(
1258 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1259 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1260
1261 const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1262 if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1263 PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1264 printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
1265 } else {
1266 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1267 printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1268 }
1269}
1270
1271VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1272 if (const auto *PartialSpec =
1273 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1274 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1275 return SpecializedTemplate.get<VarTemplateDecl *>();
1276}
1277
1278void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1279 const TemplateArgumentListInfo &ArgsInfo) {
1280 TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1281 TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1282 for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1283 TemplateArgsInfo.addArgument(Loc);
1284}
1285
1286//===----------------------------------------------------------------------===//
1287// VarTemplatePartialSpecializationDecl Implementation
1288//===----------------------------------------------------------------------===//
1289
1290void VarTemplatePartialSpecializationDecl::anchor() {}
1291
1292VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1293 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1294 SourceLocation IdLoc, TemplateParameterList *Params,
1295 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1296 StorageClass S, ArrayRef<TemplateArgument> Args,
1297 const ASTTemplateArgumentListInfo *ArgInfos)
1298 : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1299 DC, StartLoc, IdLoc, SpecializedTemplate, T,
1300 TInfo, S, Args),
1301 TemplateParams(Params), ArgsAsWritten(ArgInfos),
1302 InstantiatedFromMember(nullptr, false) {
1303 // TODO: The template parameters should be in DC by now. Verify.
1304 // AdoptTemplateParameterList(Params, DC);
1305}
1306
1307VarTemplatePartialSpecializationDecl *
1308VarTemplatePartialSpecializationDecl::Create(
1309 ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1310 SourceLocation IdLoc, TemplateParameterList *Params,
1311 VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1312 StorageClass S, ArrayRef<TemplateArgument> Args,
1313 const TemplateArgumentListInfo &ArgInfos) {
1314 const ASTTemplateArgumentListInfo *ASTArgInfos
1315 = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1316
1317 auto *Result =
1318 new (Context, DC) VarTemplatePartialSpecializationDecl(
1319 Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1320 S, Args, ASTArgInfos);
1321 Result->setSpecializationKind(TSK_ExplicitSpecialization);
1322 return Result;
1323}
1324
1325VarTemplatePartialSpecializationDecl *
1326VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1327 unsigned ID) {
1328 return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1329}
1330
1331static TemplateParameterList *
1332createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1333 // typename T
1334 auto *T = TemplateTypeParmDecl::Create(
1335 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1336 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
1337 /*HasTypeConstraint=*/false);
1338 T->setImplicit(true);
1339
1340 // T ...Ints
1341 TypeSourceInfo *TI =
1342 C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1343 auto *N = NonTypeTemplateParmDecl::Create(
1344 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1345 /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1346 N->setImplicit(true);
1347
1348 // <typename T, T ...Ints>
1349 NamedDecl *P[2] = {T, N};
1350 auto *TPL = TemplateParameterList::Create(
1351 C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1352
1353 // template <typename T, ...Ints> class IntSeq
1354 auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1355 C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1356 /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1357 TemplateTemplateParm->setImplicit(true);
1358
1359 // typename T
1360 auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1361 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1362 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
1363 /*HasTypeConstraint=*/false);
1364 TemplateTypeParm->setImplicit(true);
1365
1366 // T N
1367 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1368 QualType(TemplateTypeParm->getTypeForDecl(), 0));
1369 auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1370 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1371 /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1372 NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1373 NonTypeTemplateParm};
1374
1375 // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1376 return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1377 Params, SourceLocation(), nullptr);
1378}
1379
1380static TemplateParameterList *
1381createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1382 // std::size_t Index
1383 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1384 auto *Index = NonTypeTemplateParmDecl::Create(
1385 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1386 /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1387
1388 // typename ...T
1389 auto *Ts = TemplateTypeParmDecl::Create(
1390 C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1391 /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true,
1392 /*HasTypeConstraint=*/false);
1393 Ts->setImplicit(true);
1394
1395 // template <std::size_t Index, typename ...T>
1396 NamedDecl *Params[] = {Index, Ts};
1397 return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
5
Calling 'TemplateParameterList::Create'
1398 llvm::makeArrayRef(Params),
1399 SourceLocation(), nullptr);
4
Passing null pointer value via 6th parameter 'RequiresClause'
1400}
1401
1402static TemplateParameterList *createBuiltinTemplateParameterList(
1403 const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1404 switch (BTK) {
2
Control jumps to 'case BTK__type_pack_element:' at line 1407
1405 case BTK__make_integer_seq:
1406 return createMakeIntegerSeqParameterList(C, DC);
1407 case BTK__type_pack_element:
1408 return createTypePackElementParameterList(C, DC);
3
Calling 'createTypePackElementParameterList'
1409 }
1410
1411 llvm_unreachable("unhandled BuiltinTemplateKind!")::llvm::llvm_unreachable_internal("unhandled BuiltinTemplateKind!"
, "/build/llvm-toolchain-snapshot-12~++20200806111125+5446ec85070/clang/lib/AST/DeclTemplate.cpp"
, 1411)
;
1412}
1413
1414void BuiltinTemplateDecl::anchor() {}
1415
1416BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1417 DeclarationName Name,
1418 BuiltinTemplateKind BTK)
1419 : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1420 createBuiltinTemplateParameterList(C, DC, BTK)),
1
Calling 'createBuiltinTemplateParameterList'
1421 BTK(BTK) {}
1422
1423void TypeConstraint::print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
1424 if (NestedNameSpec)
1425 NestedNameSpec.getNestedNameSpecifier()->print(OS, Policy);
1426 ConceptName.printName(OS, Policy);
1427 if (hasExplicitTemplateArgs()) {
1428 OS << "<";
1429 for (auto &ArgLoc : ArgsAsWritten->arguments())
1430 ArgLoc.getArgument().print(Policy, OS);
1431 OS << ">";
1432 }
1433}