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