Bug Summary

File:clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:line 1025, column 15
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 -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiate.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 -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-unknown-warning-option -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/build-llvm -ferror-limit 19 -fvisibility-inlines-hidden -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-10-17-004846-21170-1 -x c++ /build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp

/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp

1//===------- SemaTemplateInstantiate.cpp - C++ Template Instantiation ------===/
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// This file implements C++ template instantiation.
9//
10//===----------------------------------------------------------------------===/
11
12#include "TreeTransform.h"
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTLambda.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/DeclTemplate.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/PrettyDeclStackTrace.h"
20#include "clang/AST/TypeVisitor.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Basic/Stack.h"
23#include "clang/Basic/TargetInfo.h"
24#include "clang/Sema/DeclSpec.h"
25#include "clang/Sema/Initialization.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/SemaConcept.h"
28#include "clang/Sema/SemaInternal.h"
29#include "clang/Sema/Template.h"
30#include "clang/Sema/TemplateDeduction.h"
31#include "clang/Sema/TemplateInstCallback.h"
32#include "llvm/Support/TimeProfiler.h"
33
34using namespace clang;
35using namespace sema;
36
37//===----------------------------------------------------------------------===/
38// Template Instantiation Support
39//===----------------------------------------------------------------------===/
40
41/// Retrieve the template argument list(s) that should be used to
42/// instantiate the definition of the given declaration.
43///
44/// \param D the declaration for which we are computing template instantiation
45/// arguments.
46///
47/// \param Innermost if non-NULL, the innermost template argument list.
48///
49/// \param RelativeToPrimary true if we should get the template
50/// arguments relative to the primary template, even when we're
51/// dealing with a specialization. This is only relevant for function
52/// template specializations.
53///
54/// \param Pattern If non-NULL, indicates the pattern from which we will be
55/// instantiating the definition of the given declaration, \p D. This is
56/// used to determine the proper set of template instantiation arguments for
57/// friend function template specializations.
58MultiLevelTemplateArgumentList
59Sema::getTemplateInstantiationArgs(NamedDecl *D,
60 const TemplateArgumentList *Innermost,
61 bool RelativeToPrimary,
62 const FunctionDecl *Pattern) {
63 // Accumulate the set of template argument lists in this structure.
64 MultiLevelTemplateArgumentList Result;
65
66 if (Innermost)
67 Result.addOuterTemplateArguments(Innermost);
68
69 DeclContext *Ctx = dyn_cast<DeclContext>(D);
70 if (!Ctx) {
71 Ctx = D->getDeclContext();
72
73 // Add template arguments from a variable template instantiation. For a
74 // class-scope explicit specialization, there are no template arguments
75 // at this level, but there may be enclosing template arguments.
76 VarTemplateSpecializationDecl *Spec =
77 dyn_cast<VarTemplateSpecializationDecl>(D);
78 if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
79 // We're done when we hit an explicit specialization.
80 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
81 !isa<VarTemplatePartialSpecializationDecl>(Spec))
82 return Result;
83
84 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
85
86 // If this variable template specialization was instantiated from a
87 // specialized member that is a variable template, we're done.
88 assert(Spec->getSpecializedTemplate() && "No variable template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
"No variable template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 88, __extension__ __PRETTY_FUNCTION__))
;
89 llvm::PointerUnion<VarTemplateDecl*,
90 VarTemplatePartialSpecializationDecl*> Specialized
91 = Spec->getSpecializedTemplateOrPartial();
92 if (VarTemplatePartialSpecializationDecl *Partial =
93 Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
94 if (Partial->isMemberSpecialization())
95 return Result;
96 } else {
97 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
98 if (Tmpl->isMemberSpecialization())
99 return Result;
100 }
101 }
102
103 // If we have a template template parameter with translation unit context,
104 // then we're performing substitution into a default template argument of
105 // this template template parameter before we've constructed the template
106 // that will own this template template parameter. In this case, we
107 // use empty template parameter lists for all of the outer templates
108 // to avoid performing any substitutions.
109 if (Ctx->isTranslationUnit()) {
110 if (TemplateTemplateParmDecl *TTP
111 = dyn_cast<TemplateTemplateParmDecl>(D)) {
112 for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
113 Result.addOuterTemplateArguments(None);
114 return Result;
115 }
116 }
117 }
118
119 while (!Ctx->isFileContext()) {
120 // Add template arguments from a class template instantiation.
121 ClassTemplateSpecializationDecl *Spec
122 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
123 if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
124 // We're done when we hit an explicit specialization.
125 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
126 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
127 break;
128
129 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
130
131 // If this class template specialization was instantiated from a
132 // specialized member that is a class template, we're done.
133 assert(Spec->getSpecializedTemplate() && "No class template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
"No class template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 133, __extension__ __PRETTY_FUNCTION__))
;
134 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
135 break;
136 }
137 // Add template arguments from a function template specialization.
138 else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
139 if (!RelativeToPrimary &&
140 Function->getTemplateSpecializationKindForInstantiation() ==
141 TSK_ExplicitSpecialization)
142 break;
143
144 if (!RelativeToPrimary && Function->getTemplateSpecializationKind() ==
145 TSK_ExplicitSpecialization) {
146 // This is an implicit instantiation of an explicit specialization. We
147 // don't get any template arguments from this function but might get
148 // some from an enclosing template.
149 } else if (const TemplateArgumentList *TemplateArgs
150 = Function->getTemplateSpecializationArgs()) {
151 // Add the template arguments for this specialization.
152 Result.addOuterTemplateArguments(TemplateArgs);
153
154 // If this function was instantiated from a specialized member that is
155 // a function template, we're done.
156 assert(Function->getPrimaryTemplate() && "No function template?")(static_cast <bool> (Function->getPrimaryTemplate() &&
"No function template?") ? void (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 156, __extension__ __PRETTY_FUNCTION__))
;
157 if (Function->getPrimaryTemplate()->isMemberSpecialization())
158 break;
159
160 // If this function is a generic lambda specialization, we are done.
161 if (isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
162 break;
163
164 } else if (Function->getDescribedFunctionTemplate()) {
165 assert(Result.getNumSubstitutedLevels() == 0 &&(static_cast <bool> (Result.getNumSubstitutedLevels() ==
0 && "Outer template not instantiated?") ? void (0) :
__assert_fail ("Result.getNumSubstitutedLevels() == 0 && \"Outer template not instantiated?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 166, __extension__ __PRETTY_FUNCTION__))
166 "Outer template not instantiated?")(static_cast <bool> (Result.getNumSubstitutedLevels() ==
0 && "Outer template not instantiated?") ? void (0) :
__assert_fail ("Result.getNumSubstitutedLevels() == 0 && \"Outer template not instantiated?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 166, __extension__ __PRETTY_FUNCTION__))
;
167 }
168
169 // If this is a friend declaration and it declares an entity at
170 // namespace scope, take arguments from its lexical parent
171 // instead of its semantic parent, unless of course the pattern we're
172 // instantiating actually comes from the file's context!
173 if (Function->getFriendObjectKind() &&
174 Function->getDeclContext()->isFileContext() &&
175 (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
176 Ctx = Function->getLexicalDeclContext();
177 RelativeToPrimary = false;
178 continue;
179 }
180 } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
181 if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
182 assert(Result.getNumSubstitutedLevels() == 0 &&(static_cast <bool> (Result.getNumSubstitutedLevels() ==
0 && "Outer template not instantiated?") ? void (0) :
__assert_fail ("Result.getNumSubstitutedLevels() == 0 && \"Outer template not instantiated?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 183, __extension__ __PRETTY_FUNCTION__))
183 "Outer template not instantiated?")(static_cast <bool> (Result.getNumSubstitutedLevels() ==
0 && "Outer template not instantiated?") ? void (0) :
__assert_fail ("Result.getNumSubstitutedLevels() == 0 && \"Outer template not instantiated?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 183, __extension__ __PRETTY_FUNCTION__))
;
184 if (ClassTemplate->isMemberSpecialization())
185 break;
186 }
187 }
188
189 Ctx = Ctx->getParent();
190 RelativeToPrimary = false;
191 }
192
193 return Result;
194}
195
196bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
197 switch (Kind) {
198 case TemplateInstantiation:
199 case ExceptionSpecInstantiation:
200 case DefaultTemplateArgumentInstantiation:
201 case DefaultFunctionArgumentInstantiation:
202 case ExplicitTemplateArgumentSubstitution:
203 case DeducedTemplateArgumentSubstitution:
204 case PriorTemplateArgumentSubstitution:
205 case ConstraintsCheck:
206 case NestedRequirementConstraintsCheck:
207 return true;
208
209 case RequirementInstantiation:
210 case DefaultTemplateArgumentChecking:
211 case DeclaringSpecialMember:
212 case DeclaringImplicitEqualityComparison:
213 case DefiningSynthesizedFunction:
214 case ExceptionSpecEvaluation:
215 case ConstraintSubstitution:
216 case ParameterMappingSubstitution:
217 case ConstraintNormalization:
218 case RewritingOperatorAsSpaceship:
219 case InitializingStructuredBinding:
220 case MarkingClassDllexported:
221 return false;
222
223 // This function should never be called when Kind's value is Memoization.
224 case Memoization:
225 break;
226 }
227
228 llvm_unreachable("Invalid SynthesisKind!")::llvm::llvm_unreachable_internal("Invalid SynthesisKind!", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 228)
;
229}
230
231Sema::InstantiatingTemplate::InstantiatingTemplate(
232 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
233 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
234 Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
235 sema::TemplateDeductionInfo *DeductionInfo)
236 : SemaRef(SemaRef) {
237 // Don't allow further instantiation if a fatal error and an uncompilable
238 // error have occurred. Any diagnostics we might have raised will not be
239 // visible, and we do not need to construct a correct AST.
240 if (SemaRef.Diags.hasFatalErrorOccurred() &&
241 SemaRef.hasUncompilableErrorOccurred()) {
242 Invalid = true;
243 return;
244 }
245 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
246 if (!Invalid) {
247 CodeSynthesisContext Inst;
248 Inst.Kind = Kind;
249 Inst.PointOfInstantiation = PointOfInstantiation;
250 Inst.Entity = Entity;
251 Inst.Template = Template;
252 Inst.TemplateArgs = TemplateArgs.data();
253 Inst.NumTemplateArgs = TemplateArgs.size();
254 Inst.DeductionInfo = DeductionInfo;
255 Inst.InstantiationRange = InstantiationRange;
256 SemaRef.pushCodeSynthesisContext(Inst);
257
258 AlreadyInstantiating = !Inst.Entity ? false :
259 !SemaRef.InstantiatingSpecializations
260 .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
261 .second;
262 atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
263 }
264}
265
266Sema::InstantiatingTemplate::InstantiatingTemplate(
267 Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
268 SourceRange InstantiationRange)
269 : InstantiatingTemplate(SemaRef,
270 CodeSynthesisContext::TemplateInstantiation,
271 PointOfInstantiation, InstantiationRange, Entity) {}
272
273Sema::InstantiatingTemplate::InstantiatingTemplate(
274 Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
275 ExceptionSpecification, SourceRange InstantiationRange)
276 : InstantiatingTemplate(
277 SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
278 PointOfInstantiation, InstantiationRange, Entity) {}
279
280Sema::InstantiatingTemplate::InstantiatingTemplate(
281 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
282 TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
283 SourceRange InstantiationRange)
284 : InstantiatingTemplate(
285 SemaRef,
286 CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
287 PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
288 Template, TemplateArgs) {}
289
290Sema::InstantiatingTemplate::InstantiatingTemplate(
291 Sema &SemaRef, SourceLocation PointOfInstantiation,
292 FunctionTemplateDecl *FunctionTemplate,
293 ArrayRef<TemplateArgument> TemplateArgs,
294 CodeSynthesisContext::SynthesisKind Kind,
295 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
296 : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
297 InstantiationRange, FunctionTemplate, nullptr,
298 TemplateArgs, &DeductionInfo) {
299 assert((static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 301, __extension__ __PRETTY_FUNCTION__))
300 Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 301, __extension__ __PRETTY_FUNCTION__))
301 Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 301, __extension__ __PRETTY_FUNCTION__))
;
302}
303
304Sema::InstantiatingTemplate::InstantiatingTemplate(
305 Sema &SemaRef, SourceLocation PointOfInstantiation,
306 TemplateDecl *Template,
307 ArrayRef<TemplateArgument> TemplateArgs,
308 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
309 : InstantiatingTemplate(
310 SemaRef,
311 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
312 PointOfInstantiation, InstantiationRange, Template, nullptr,
313 TemplateArgs, &DeductionInfo) {}
314
315Sema::InstantiatingTemplate::InstantiatingTemplate(
316 Sema &SemaRef, SourceLocation PointOfInstantiation,
317 ClassTemplatePartialSpecializationDecl *PartialSpec,
318 ArrayRef<TemplateArgument> TemplateArgs,
319 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
320 : InstantiatingTemplate(
321 SemaRef,
322 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
323 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
324 TemplateArgs, &DeductionInfo) {}
325
326Sema::InstantiatingTemplate::InstantiatingTemplate(
327 Sema &SemaRef, SourceLocation PointOfInstantiation,
328 VarTemplatePartialSpecializationDecl *PartialSpec,
329 ArrayRef<TemplateArgument> TemplateArgs,
330 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
331 : InstantiatingTemplate(
332 SemaRef,
333 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
334 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
335 TemplateArgs, &DeductionInfo) {}
336
337Sema::InstantiatingTemplate::InstantiatingTemplate(
338 Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
339 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
340 : InstantiatingTemplate(
341 SemaRef,
342 CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
343 PointOfInstantiation, InstantiationRange, Param, nullptr,
344 TemplateArgs) {}
345
346Sema::InstantiatingTemplate::InstantiatingTemplate(
347 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
348 NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
349 SourceRange InstantiationRange)
350 : InstantiatingTemplate(
351 SemaRef,
352 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
353 PointOfInstantiation, InstantiationRange, Param, Template,
354 TemplateArgs) {}
355
356Sema::InstantiatingTemplate::InstantiatingTemplate(
357 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
358 TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
359 SourceRange InstantiationRange)
360 : InstantiatingTemplate(
361 SemaRef,
362 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
363 PointOfInstantiation, InstantiationRange, Param, Template,
364 TemplateArgs) {}
365
366Sema::InstantiatingTemplate::InstantiatingTemplate(
367 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
368 NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
369 SourceRange InstantiationRange)
370 : InstantiatingTemplate(
371 SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
372 PointOfInstantiation, InstantiationRange, Param, Template,
373 TemplateArgs) {}
374
375Sema::InstantiatingTemplate::InstantiatingTemplate(
376 Sema &SemaRef, SourceLocation PointOfInstantiation,
377 concepts::Requirement *Req, sema::TemplateDeductionInfo &DeductionInfo,
378 SourceRange InstantiationRange)
379 : InstantiatingTemplate(
380 SemaRef, CodeSynthesisContext::RequirementInstantiation,
381 PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
382 /*Template=*/nullptr, /*TemplateArgs=*/None, &DeductionInfo) {}
383
384
385Sema::InstantiatingTemplate::InstantiatingTemplate(
386 Sema &SemaRef, SourceLocation PointOfInstantiation,
387 concepts::NestedRequirement *Req, ConstraintsCheck,
388 SourceRange InstantiationRange)
389 : InstantiatingTemplate(
390 SemaRef, CodeSynthesisContext::NestedRequirementConstraintsCheck,
391 PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
392 /*Template=*/nullptr, /*TemplateArgs=*/None) {}
393
394
395Sema::InstantiatingTemplate::InstantiatingTemplate(
396 Sema &SemaRef, SourceLocation PointOfInstantiation,
397 ConstraintsCheck, NamedDecl *Template,
398 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
399 : InstantiatingTemplate(
400 SemaRef, CodeSynthesisContext::ConstraintsCheck,
401 PointOfInstantiation, InstantiationRange, Template, nullptr,
402 TemplateArgs) {}
403
404Sema::InstantiatingTemplate::InstantiatingTemplate(
405 Sema &SemaRef, SourceLocation PointOfInstantiation,
406 ConstraintSubstitution, NamedDecl *Template,
407 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
408 : InstantiatingTemplate(
409 SemaRef, CodeSynthesisContext::ConstraintSubstitution,
410 PointOfInstantiation, InstantiationRange, Template, nullptr,
411 {}, &DeductionInfo) {}
412
413Sema::InstantiatingTemplate::InstantiatingTemplate(
414 Sema &SemaRef, SourceLocation PointOfInstantiation,
415 ConstraintNormalization, NamedDecl *Template,
416 SourceRange InstantiationRange)
417 : InstantiatingTemplate(
418 SemaRef, CodeSynthesisContext::ConstraintNormalization,
419 PointOfInstantiation, InstantiationRange, Template) {}
420
421Sema::InstantiatingTemplate::InstantiatingTemplate(
422 Sema &SemaRef, SourceLocation PointOfInstantiation,
423 ParameterMappingSubstitution, NamedDecl *Template,
424 SourceRange InstantiationRange)
425 : InstantiatingTemplate(
426 SemaRef, CodeSynthesisContext::ParameterMappingSubstitution,
427 PointOfInstantiation, InstantiationRange, Template) {}
428
429void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
430 Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
431 InNonInstantiationSFINAEContext = false;
432
433 CodeSynthesisContexts.push_back(Ctx);
434
435 if (!Ctx.isInstantiationRecord())
436 ++NonInstantiationEntries;
437
438 // Check to see if we're low on stack space. We can't do anything about this
439 // from here, but we can at least warn the user.
440 if (isStackNearlyExhausted())
441 warnStackExhausted(Ctx.PointOfInstantiation);
442}
443
444void Sema::popCodeSynthesisContext() {
445 auto &Active = CodeSynthesisContexts.back();
446 if (!Active.isInstantiationRecord()) {
447 assert(NonInstantiationEntries > 0)(static_cast <bool> (NonInstantiationEntries > 0) ? void
(0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 447, __extension__ __PRETTY_FUNCTION__))
;
448 --NonInstantiationEntries;
449 }
450
451 InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;
452
453 // Name lookup no longer looks in this template's defining module.
454 assert(CodeSynthesisContexts.size() >=(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 456, __extension__ __PRETTY_FUNCTION__))
455 CodeSynthesisContextLookupModules.size() &&(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 456, __extension__ __PRETTY_FUNCTION__))
456 "forgot to remove a lookup module for a template instantiation")(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 456, __extension__ __PRETTY_FUNCTION__))
;
457 if (CodeSynthesisContexts.size() ==
458 CodeSynthesisContextLookupModules.size()) {
459 if (Module *M = CodeSynthesisContextLookupModules.back())
460 LookupModulesCache.erase(M);
461 CodeSynthesisContextLookupModules.pop_back();
462 }
463
464 // If we've left the code synthesis context for the current context stack,
465 // stop remembering that we've emitted that stack.
466 if (CodeSynthesisContexts.size() ==
467 LastEmittedCodeSynthesisContextDepth)
468 LastEmittedCodeSynthesisContextDepth = 0;
469
470 CodeSynthesisContexts.pop_back();
471}
472
473void Sema::InstantiatingTemplate::Clear() {
474 if (!Invalid) {
475 if (!AlreadyInstantiating) {
476 auto &Active = SemaRef.CodeSynthesisContexts.back();
477 if (Active.Entity)
478 SemaRef.InstantiatingSpecializations.erase(
479 {Active.Entity->getCanonicalDecl(), Active.Kind});
480 }
481
482 atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
483 SemaRef.CodeSynthesisContexts.back());
484
485 SemaRef.popCodeSynthesisContext();
486 Invalid = true;
487 }
488}
489
490bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
491 SourceLocation PointOfInstantiation,
492 SourceRange InstantiationRange) {
493 assert(SemaRef.NonInstantiationEntries <=(static_cast <bool> (SemaRef.NonInstantiationEntries <=
SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 494, __extension__ __PRETTY_FUNCTION__))
494 SemaRef.CodeSynthesisContexts.size())(static_cast <bool> (SemaRef.NonInstantiationEntries <=
SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 494, __extension__ __PRETTY_FUNCTION__))
;
495 if ((SemaRef.CodeSynthesisContexts.size() -
496 SemaRef.NonInstantiationEntries)
497 <= SemaRef.getLangOpts().InstantiationDepth)
498 return false;
499
500 SemaRef.Diag(PointOfInstantiation,
501 diag::err_template_recursion_depth_exceeded)
502 << SemaRef.getLangOpts().InstantiationDepth
503 << InstantiationRange;
504 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
505 << SemaRef.getLangOpts().InstantiationDepth;
506 return true;
507}
508
509/// Prints the current instantiation stack through a series of
510/// notes.
511void Sema::PrintInstantiationStack() {
512 // Determine which template instantiations to skip, if any.
513 unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
514 unsigned Limit = Diags.getTemplateBacktraceLimit();
515 if (Limit && Limit < CodeSynthesisContexts.size()) {
516 SkipStart = Limit / 2 + Limit % 2;
517 SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
518 }
519
520 // FIXME: In all of these cases, we need to show the template arguments
521 unsigned InstantiationIdx = 0;
522 for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
523 Active = CodeSynthesisContexts.rbegin(),
524 ActiveEnd = CodeSynthesisContexts.rend();
525 Active != ActiveEnd;
526 ++Active, ++InstantiationIdx) {
527 // Skip this instantiation?
528 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
529 if (InstantiationIdx == SkipStart) {
530 // Note that we're skipping instantiations.
531 Diags.Report(Active->PointOfInstantiation,
532 diag::note_instantiation_contexts_suppressed)
533 << unsigned(CodeSynthesisContexts.size() - Limit);
534 }
535 continue;
536 }
537
538 switch (Active->Kind) {
539 case CodeSynthesisContext::TemplateInstantiation: {
540 Decl *D = Active->Entity;
541 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
542 unsigned DiagID = diag::note_template_member_class_here;
543 if (isa<ClassTemplateSpecializationDecl>(Record))
544 DiagID = diag::note_template_class_instantiation_here;
545 Diags.Report(Active->PointOfInstantiation, DiagID)
546 << Record << Active->InstantiationRange;
547 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
548 unsigned DiagID;
549 if (Function->getPrimaryTemplate())
550 DiagID = diag::note_function_template_spec_here;
551 else
552 DiagID = diag::note_template_member_function_here;
553 Diags.Report(Active->PointOfInstantiation, DiagID)
554 << Function
555 << Active->InstantiationRange;
556 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
557 Diags.Report(Active->PointOfInstantiation,
558 VD->isStaticDataMember()?
559 diag::note_template_static_data_member_def_here
560 : diag::note_template_variable_def_here)
561 << VD
562 << Active->InstantiationRange;
563 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
564 Diags.Report(Active->PointOfInstantiation,
565 diag::note_template_enum_def_here)
566 << ED
567 << Active->InstantiationRange;
568 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
569 Diags.Report(Active->PointOfInstantiation,
570 diag::note_template_nsdmi_here)
571 << FD << Active->InstantiationRange;
572 } else {
573 Diags.Report(Active->PointOfInstantiation,
574 diag::note_template_type_alias_instantiation_here)
575 << cast<TypeAliasTemplateDecl>(D)
576 << Active->InstantiationRange;
577 }
578 break;
579 }
580
581 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
582 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
583 SmallString<128> TemplateArgsStr;
584 llvm::raw_svector_ostream OS(TemplateArgsStr);
585 Template->printName(OS);
586 printTemplateArgumentList(OS, Active->template_arguments(),
587 getPrintingPolicy());
588 Diags.Report(Active->PointOfInstantiation,
589 diag::note_default_arg_instantiation_here)
590 << OS.str()
591 << Active->InstantiationRange;
592 break;
593 }
594
595 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
596 FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
597 Diags.Report(Active->PointOfInstantiation,
598 diag::note_explicit_template_arg_substitution_here)
599 << FnTmpl
600 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
601 Active->TemplateArgs,
602 Active->NumTemplateArgs)
603 << Active->InstantiationRange;
604 break;
605 }
606
607 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
608 if (FunctionTemplateDecl *FnTmpl =
609 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
610 Diags.Report(Active->PointOfInstantiation,
611 diag::note_function_template_deduction_instantiation_here)
612 << FnTmpl
613 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
614 Active->TemplateArgs,
615 Active->NumTemplateArgs)
616 << Active->InstantiationRange;
617 } else {
618 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
619 isa<VarTemplateSpecializationDecl>(Active->Entity);
620 bool IsTemplate = false;
621 TemplateParameterList *Params;
622 if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
623 IsTemplate = true;
624 Params = D->getTemplateParameters();
625 } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
626 Active->Entity)) {
627 Params = D->getTemplateParameters();
628 } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
629 Active->Entity)) {
630 Params = D->getTemplateParameters();
631 } else {
632 llvm_unreachable("unexpected template kind")::llvm::llvm_unreachable_internal("unexpected template kind",
"/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 632)
;
633 }
634
635 Diags.Report(Active->PointOfInstantiation,
636 diag::note_deduced_template_arg_substitution_here)
637 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
638 << getTemplateArgumentBindingsText(Params, Active->TemplateArgs,
639 Active->NumTemplateArgs)
640 << Active->InstantiationRange;
641 }
642 break;
643 }
644
645 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation: {
646 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
647 FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
648
649 SmallString<128> TemplateArgsStr;
650 llvm::raw_svector_ostream OS(TemplateArgsStr);
651 FD->printName(OS);
652 printTemplateArgumentList(OS, Active->template_arguments(),
653 getPrintingPolicy());
654 Diags.Report(Active->PointOfInstantiation,
655 diag::note_default_function_arg_instantiation_here)
656 << OS.str()
657 << Active->InstantiationRange;
658 break;
659 }
660
661 case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {
662 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
663 std::string Name;
664 if (!Parm->getName().empty())
665 Name = std::string(" '") + Parm->getName().str() + "'";
666
667 TemplateParameterList *TemplateParams = nullptr;
668 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
669 TemplateParams = Template->getTemplateParameters();
670 else
671 TemplateParams =
672 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
673 ->getTemplateParameters();
674 Diags.Report(Active->PointOfInstantiation,
675 diag::note_prior_template_arg_substitution)
676 << isa<TemplateTemplateParmDecl>(Parm)
677 << Name
678 << getTemplateArgumentBindingsText(TemplateParams,
679 Active->TemplateArgs,
680 Active->NumTemplateArgs)
681 << Active->InstantiationRange;
682 break;
683 }
684
685 case CodeSynthesisContext::DefaultTemplateArgumentChecking: {
686 TemplateParameterList *TemplateParams = nullptr;
687 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
688 TemplateParams = Template->getTemplateParameters();
689 else
690 TemplateParams =
691 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
692 ->getTemplateParameters();
693
694 Diags.Report(Active->PointOfInstantiation,
695 diag::note_template_default_arg_checking)
696 << getTemplateArgumentBindingsText(TemplateParams,
697 Active->TemplateArgs,
698 Active->NumTemplateArgs)
699 << Active->InstantiationRange;
700 break;
701 }
702
703 case CodeSynthesisContext::ExceptionSpecEvaluation:
704 Diags.Report(Active->PointOfInstantiation,
705 diag::note_evaluating_exception_spec_here)
706 << cast<FunctionDecl>(Active->Entity);
707 break;
708
709 case CodeSynthesisContext::ExceptionSpecInstantiation:
710 Diags.Report(Active->PointOfInstantiation,
711 diag::note_template_exception_spec_instantiation_here)
712 << cast<FunctionDecl>(Active->Entity)
713 << Active->InstantiationRange;
714 break;
715
716 case CodeSynthesisContext::RequirementInstantiation:
717 Diags.Report(Active->PointOfInstantiation,
718 diag::note_template_requirement_instantiation_here)
719 << Active->InstantiationRange;
720 break;
721
722 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
723 Diags.Report(Active->PointOfInstantiation,
724 diag::note_nested_requirement_here)
725 << Active->InstantiationRange;
726 break;
727
728 case CodeSynthesisContext::DeclaringSpecialMember:
729 Diags.Report(Active->PointOfInstantiation,
730 diag::note_in_declaration_of_implicit_special_member)
731 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
732 break;
733
734 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
735 Diags.Report(Active->Entity->getLocation(),
736 diag::note_in_declaration_of_implicit_equality_comparison);
737 break;
738
739 case CodeSynthesisContext::DefiningSynthesizedFunction: {
740 // FIXME: For synthesized functions that are not defaulted,
741 // produce a note.
742 auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
743 DefaultedFunctionKind DFK =
744 FD ? getDefaultedFunctionKind(FD) : DefaultedFunctionKind();
745 if (DFK.isSpecialMember()) {
746 auto *MD = cast<CXXMethodDecl>(FD);
747 Diags.Report(Active->PointOfInstantiation,
748 diag::note_member_synthesized_at)
749 << MD->isExplicitlyDefaulted() << DFK.asSpecialMember()
750 << Context.getTagDeclType(MD->getParent());
751 } else if (DFK.isComparison()) {
752 Diags.Report(Active->PointOfInstantiation,
753 diag::note_comparison_synthesized_at)
754 << (int)DFK.asComparison()
755 << Context.getTagDeclType(
756 cast<CXXRecordDecl>(FD->getLexicalDeclContext()));
757 }
758 break;
759 }
760
761 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
762 Diags.Report(Active->Entity->getLocation(),
763 diag::note_rewriting_operator_as_spaceship);
764 break;
765
766 case CodeSynthesisContext::InitializingStructuredBinding:
767 Diags.Report(Active->PointOfInstantiation,
768 diag::note_in_binding_decl_init)
769 << cast<BindingDecl>(Active->Entity);
770 break;
771
772 case CodeSynthesisContext::MarkingClassDllexported:
773 Diags.Report(Active->PointOfInstantiation,
774 diag::note_due_to_dllexported_class)
775 << cast<CXXRecordDecl>(Active->Entity) << !getLangOpts().CPlusPlus11;
776 break;
777
778 case CodeSynthesisContext::Memoization:
779 break;
780
781 case CodeSynthesisContext::ConstraintsCheck: {
782 unsigned DiagID = 0;
783 if (!Active->Entity) {
784 Diags.Report(Active->PointOfInstantiation,
785 diag::note_nested_requirement_here)
786 << Active->InstantiationRange;
787 break;
788 }
789 if (isa<ConceptDecl>(Active->Entity))
790 DiagID = diag::note_concept_specialization_here;
791 else if (isa<TemplateDecl>(Active->Entity))
792 DiagID = diag::note_checking_constraints_for_template_id_here;
793 else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))
794 DiagID = diag::note_checking_constraints_for_var_spec_id_here;
795 else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))
796 DiagID = diag::note_checking_constraints_for_class_spec_id_here;
797 else {
798 assert(isa<FunctionDecl>(Active->Entity))(static_cast <bool> (isa<FunctionDecl>(Active->
Entity)) ? void (0) : __assert_fail ("isa<FunctionDecl>(Active->Entity)"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 798, __extension__ __PRETTY_FUNCTION__))
;
799 DiagID = diag::note_checking_constraints_for_function_here;
800 }
801 SmallString<128> TemplateArgsStr;
802 llvm::raw_svector_ostream OS(TemplateArgsStr);
803 cast<NamedDecl>(Active->Entity)->printName(OS);
804 if (!isa<FunctionDecl>(Active->Entity)) {
805 printTemplateArgumentList(OS, Active->template_arguments(),
806 getPrintingPolicy());
807 }
808 Diags.Report(Active->PointOfInstantiation, DiagID) << OS.str()
809 << Active->InstantiationRange;
810 break;
811 }
812 case CodeSynthesisContext::ConstraintSubstitution:
813 Diags.Report(Active->PointOfInstantiation,
814 diag::note_constraint_substitution_here)
815 << Active->InstantiationRange;
816 break;
817 case CodeSynthesisContext::ConstraintNormalization:
818 Diags.Report(Active->PointOfInstantiation,
819 diag::note_constraint_normalization_here)
820 << cast<NamedDecl>(Active->Entity)->getName()
821 << Active->InstantiationRange;
822 break;
823 case CodeSynthesisContext::ParameterMappingSubstitution:
824 Diags.Report(Active->PointOfInstantiation,
825 diag::note_parameter_mapping_substitution_here)
826 << Active->InstantiationRange;
827 break;
828 }
829 }
830}
831
832Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
833 if (InNonInstantiationSFINAEContext)
834 return Optional<TemplateDeductionInfo *>(nullptr);
835
836 for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
837 Active = CodeSynthesisContexts.rbegin(),
838 ActiveEnd = CodeSynthesisContexts.rend();
839 Active != ActiveEnd;
840 ++Active)
841 {
842 switch (Active->Kind) {
843 case CodeSynthesisContext::TemplateInstantiation:
844 // An instantiation of an alias template may or may not be a SFINAE
845 // context, depending on what else is on the stack.
846 if (isa<TypeAliasTemplateDecl>(Active->Entity))
847 break;
848 LLVM_FALLTHROUGH[[gnu::fallthrough]];
849 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
850 case CodeSynthesisContext::ExceptionSpecInstantiation:
851 case CodeSynthesisContext::ConstraintsCheck:
852 case CodeSynthesisContext::ParameterMappingSubstitution:
853 case CodeSynthesisContext::ConstraintNormalization:
854 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
855 // This is a template instantiation, so there is no SFINAE.
856 return None;
857
858 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
859 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
860 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
861 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
862 // A default template argument instantiation and substitution into
863 // template parameters with arguments for prior parameters may or may
864 // not be a SFINAE context; look further up the stack.
865 break;
866
867 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
868 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
869 case CodeSynthesisContext::ConstraintSubstitution:
870 case CodeSynthesisContext::RequirementInstantiation:
871 // We're either substituting explicitly-specified template arguments,
872 // deduced template arguments, a constraint expression or a requirement
873 // in a requires expression, so SFINAE applies.
874 assert(Active->DeductionInfo && "Missing deduction info pointer")(static_cast <bool> (Active->DeductionInfo &&
"Missing deduction info pointer") ? void (0) : __assert_fail
("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 874, __extension__ __PRETTY_FUNCTION__))
;
875 return Active->DeductionInfo;
876
877 case CodeSynthesisContext::DeclaringSpecialMember:
878 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
879 case CodeSynthesisContext::DefiningSynthesizedFunction:
880 case CodeSynthesisContext::InitializingStructuredBinding:
881 case CodeSynthesisContext::MarkingClassDllexported:
882 // This happens in a context unrelated to template instantiation, so
883 // there is no SFINAE.
884 return None;
885
886 case CodeSynthesisContext::ExceptionSpecEvaluation:
887 // FIXME: This should not be treated as a SFINAE context, because
888 // we will cache an incorrect exception specification. However, clang
889 // bootstrap relies this! See PR31692.
890 break;
891
892 case CodeSynthesisContext::Memoization:
893 break;
894 }
895
896 // The inner context was transparent for SFINAE. If it occurred within a
897 // non-instantiation SFINAE context, then SFINAE applies.
898 if (Active->SavedInNonInstantiationSFINAEContext)
899 return Optional<TemplateDeductionInfo *>(nullptr);
900 }
901
902 return None;
903}
904
905//===----------------------------------------------------------------------===/
906// Template Instantiation for Types
907//===----------------------------------------------------------------------===/
908namespace {
909 class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
910 const MultiLevelTemplateArgumentList &TemplateArgs;
911 SourceLocation Loc;
912 DeclarationName Entity;
913
914 public:
915 typedef TreeTransform<TemplateInstantiator> inherited;
916
917 TemplateInstantiator(Sema &SemaRef,
918 const MultiLevelTemplateArgumentList &TemplateArgs,
919 SourceLocation Loc,
920 DeclarationName Entity)
921 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
922 Entity(Entity) { }
923
924 /// Determine whether the given type \p T has already been
925 /// transformed.
926 ///
927 /// For the purposes of template instantiation, a type has already been
928 /// transformed if it is NULL or if it is not dependent.
929 bool AlreadyTransformed(QualType T);
930
931 /// Returns the location of the entity being instantiated, if known.
932 SourceLocation getBaseLocation() { return Loc; }
933
934 /// Returns the name of the entity being instantiated, if any.
935 DeclarationName getBaseEntity() { return Entity; }
936
937 /// Sets the "base" location and entity when that
938 /// information is known based on another transformation.
939 void setBase(SourceLocation Loc, DeclarationName Entity) {
940 this->Loc = Loc;
941 this->Entity = Entity;
942 }
943
944 unsigned TransformTemplateDepth(unsigned Depth) {
945 return TemplateArgs.getNewDepth(Depth);
946 }
947
948 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
949 SourceRange PatternRange,
950 ArrayRef<UnexpandedParameterPack> Unexpanded,
951 bool &ShouldExpand, bool &RetainExpansion,
952 Optional<unsigned> &NumExpansions) {
953 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
954 PatternRange, Unexpanded,
955 TemplateArgs,
956 ShouldExpand,
957 RetainExpansion,
958 NumExpansions);
959 }
960
961 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
962 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
963 }
964
965 TemplateArgument ForgetPartiallySubstitutedPack() {
966 TemplateArgument Result;
967 if (NamedDecl *PartialPack
968 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
969 MultiLevelTemplateArgumentList &TemplateArgs
970 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
971 unsigned Depth, Index;
972 std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
973 if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
974 Result = TemplateArgs(Depth, Index);
975 TemplateArgs.setArgument(Depth, Index, TemplateArgument());
976 }
977 }
978
979 return Result;
980 }
981
982 void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
983 if (Arg.isNull())
984 return;
985
986 if (NamedDecl *PartialPack
987 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
988 MultiLevelTemplateArgumentList &TemplateArgs
989 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
990 unsigned Depth, Index;
991 std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
992 TemplateArgs.setArgument(Depth, Index, Arg);
993 }
994 }
995
996 /// Transform the given declaration by instantiating a reference to
997 /// this declaration.
998 Decl *TransformDecl(SourceLocation Loc, Decl *D);
999
1000 void transformAttrs(Decl *Old, Decl *New) {
1001 SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
1002 }
1003
1004 void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
1005 if (Old->isParameterPack()) {
1
Assuming the condition is false
1006 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Old);
1007 for (auto *New : NewDecls)
1008 SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(
1009 Old, cast<VarDecl>(New));
1010 return;
1011 }
1012
1013 assert(NewDecls.size() == 1 &&(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1014, __extension__ __PRETTY_FUNCTION__))
2
Taking false branch
3
Assuming the condition is true
4
'?' condition is true
1014 "should only have multiple expansions for a pack")(static_cast <bool> (NewDecls.size() == 1 && "should only have multiple expansions for a pack"
) ? void (0) : __assert_fail ("NewDecls.size() == 1 && \"should only have multiple expansions for a pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1014, __extension__ __PRETTY_FUNCTION__))
;
1015 Decl *New = NewDecls.front();
1016
1017 // If we've instantiated the call operator of a lambda or the call
1018 // operator template of a generic lambda, update the "instantiation of"
1019 // information.
1020 auto *NewMD = dyn_cast<CXXMethodDecl>(New);
5
Assuming 'New' is a 'CXXMethodDecl'
1021 if (NewMD
5.1
'NewMD' is non-null
5.1
'NewMD' is non-null
5.1
'NewMD' is non-null
&& isLambdaCallOperator(NewMD)) {
6
Calling 'isLambdaCallOperator'
15
Returning from 'isLambdaCallOperator'
16
Taking true branch
1022 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
17
Assuming 'Old' is not a 'CXXMethodDecl'
18
'OldMD' initialized to a null pointer value
1023 if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
19
Assuming 'NewTD' is non-null
20
Taking true branch
1024 NewTD->setInstantiatedFromMemberTemplate(
1025 OldMD->getDescribedFunctionTemplate());
21
Called C++ object pointer is null
1026 else
1027 NewMD->setInstantiationOfMemberFunction(OldMD,
1028 TSK_ImplicitInstantiation);
1029 }
1030
1031 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
1032
1033 // We recreated a local declaration, but not by instantiating it. There
1034 // may be pending dependent diagnostics to produce.
1035 if (auto *DC = dyn_cast<DeclContext>(Old))
1036 SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
1037 }
1038
1039 /// Transform the definition of the given declaration by
1040 /// instantiating it.
1041 Decl *TransformDefinition(SourceLocation Loc, Decl *D);
1042
1043 /// Transform the first qualifier within a scope by instantiating the
1044 /// declaration.
1045 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
1046
1047 /// Rebuild the exception declaration and register the declaration
1048 /// as an instantiated local.
1049 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1050 TypeSourceInfo *Declarator,
1051 SourceLocation StartLoc,
1052 SourceLocation NameLoc,
1053 IdentifierInfo *Name);
1054
1055 /// Rebuild the Objective-C exception declaration and register the
1056 /// declaration as an instantiated local.
1057 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1058 TypeSourceInfo *TSInfo, QualType T);
1059
1060 /// Check for tag mismatches when instantiating an
1061 /// elaborated type.
1062 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
1063 ElaboratedTypeKeyword Keyword,
1064 NestedNameSpecifierLoc QualifierLoc,
1065 QualType T);
1066
1067 TemplateName
1068 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
1069 SourceLocation NameLoc,
1070 QualType ObjectType = QualType(),
1071 NamedDecl *FirstQualifierInScope = nullptr,
1072 bool AllowInjectedClassName = false);
1073
1074 const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);
1075
1076 ExprResult TransformPredefinedExpr(PredefinedExpr *E);
1077 ExprResult TransformDeclRefExpr(DeclRefExpr *E);
1078 ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
1079
1080 ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
1081 NonTypeTemplateParmDecl *D);
1082 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
1083 SubstNonTypeTemplateParmPackExpr *E);
1084 ExprResult TransformSubstNonTypeTemplateParmExpr(
1085 SubstNonTypeTemplateParmExpr *E);
1086
1087 /// Rebuild a DeclRefExpr for a VarDecl reference.
1088 ExprResult RebuildVarDeclRefExpr(VarDecl *PD, SourceLocation Loc);
1089
1090 /// Transform a reference to a function or init-capture parameter pack.
1091 ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E, VarDecl *PD);
1092
1093 /// Transform a FunctionParmPackExpr which was built when we couldn't
1094 /// expand a function parameter pack reference which refers to an expanded
1095 /// pack.
1096 ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);
1097
1098 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
1099 FunctionProtoTypeLoc TL) {
1100 // Call the base version; it will forward to our overridden version below.
1101 return inherited::TransformFunctionProtoType(TLB, TL);
1102 }
1103
1104 template<typename Fn>
1105 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
1106 FunctionProtoTypeLoc TL,
1107 CXXRecordDecl *ThisContext,
1108 Qualifiers ThisTypeQuals,
1109 Fn TransformExceptionSpec);
1110
1111 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
1112 int indexAdjustment,
1113 Optional<unsigned> NumExpansions,
1114 bool ExpectParameterPack);
1115
1116 /// Transforms a template type parameter type by performing
1117 /// substitution of the corresponding template type argument.
1118 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1119 TemplateTypeParmTypeLoc TL);
1120
1121 /// Transforms an already-substituted template type parameter pack
1122 /// into either itself (if we aren't substituting into its pack expansion)
1123 /// or the appropriate substituted argument.
1124 QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
1125 SubstTemplateTypeParmPackTypeLoc TL);
1126
1127 ExprResult TransformLambdaExpr(LambdaExpr *E) {
1128 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1129 return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E);
1130 }
1131
1132 ExprResult TransformRequiresExpr(RequiresExpr *E) {
1133 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1134 return TreeTransform<TemplateInstantiator>::TransformRequiresExpr(E);
1135 }
1136
1137 bool TransformRequiresExprRequirements(
1138 ArrayRef<concepts::Requirement *> Reqs,
1139 SmallVectorImpl<concepts::Requirement *> &Transformed) {
1140 bool SatisfactionDetermined = false;
1141 for (concepts::Requirement *Req : Reqs) {
1142 concepts::Requirement *TransReq = nullptr;
1143 if (!SatisfactionDetermined) {
1144 if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
1145 TransReq = TransformTypeRequirement(TypeReq);
1146 else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
1147 TransReq = TransformExprRequirement(ExprReq);
1148 else
1149 TransReq = TransformNestedRequirement(
1150 cast<concepts::NestedRequirement>(Req));
1151 if (!TransReq)
1152 return true;
1153 if (!TransReq->isDependent() && !TransReq->isSatisfied())
1154 // [expr.prim.req]p6
1155 // [...] The substitution and semantic constraint checking
1156 // proceeds in lexical order and stops when a condition that
1157 // determines the result of the requires-expression is
1158 // encountered. [..]
1159 SatisfactionDetermined = true;
1160 } else
1161 TransReq = Req;
1162 Transformed.push_back(TransReq);
1163 }
1164 return false;
1165 }
1166
1167 TemplateParameterList *TransformTemplateParameterList(
1168 TemplateParameterList *OrigTPL) {
1169 if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
1170
1171 DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
1172 TemplateDeclInstantiator DeclInstantiator(getSema(),
1173 /* DeclContext *Owner */ Owner, TemplateArgs);
1174 return DeclInstantiator.SubstTemplateParams(OrigTPL);
1175 }
1176
1177 concepts::TypeRequirement *
1178 TransformTypeRequirement(concepts::TypeRequirement *Req);
1179 concepts::ExprRequirement *
1180 TransformExprRequirement(concepts::ExprRequirement *Req);
1181 concepts::NestedRequirement *
1182 TransformNestedRequirement(concepts::NestedRequirement *Req);
1183
1184 private:
1185 ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
1186 SourceLocation loc,
1187 TemplateArgument arg);
1188 };
1189}
1190
1191bool TemplateInstantiator::AlreadyTransformed(QualType T) {
1192 if (T.isNull())
1193 return true;
1194
1195 if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
1196 return false;
1197
1198 getSema().MarkDeclarationsReferencedInType(Loc, T);
1199 return true;
1200}
1201
1202static TemplateArgument
1203getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
1204 assert(S.ArgumentPackSubstitutionIndex >= 0)(static_cast <bool> (S.ArgumentPackSubstitutionIndex >=
0) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__))
;
1205 assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())(static_cast <bool> (S.ArgumentPackSubstitutionIndex <
(int)Arg.pack_size()) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1205, __extension__ __PRETTY_FUNCTION__))
;
1206 Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex];
1207 if (Arg.isPackExpansion())
1208 Arg = Arg.getPackExpansionPattern();
1209 return Arg;
1210}
1211
1212Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
1213 if (!D)
1214 return nullptr;
1215
1216 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
1217 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1218 // If the corresponding template argument is NULL or non-existent, it's
1219 // because we are performing instantiation from explicitly-specified
1220 // template arguments in a function template, but there were some
1221 // arguments left unspecified.
1222 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1223 TTP->getPosition()))
1224 return D;
1225
1226 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1227
1228 if (TTP->isParameterPack()) {
1229 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1230, __extension__ __PRETTY_FUNCTION__))
1230 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1230, __extension__ __PRETTY_FUNCTION__))
;
1231 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1232 }
1233
1234 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
1235 assert(!Template.isNull() && Template.getAsTemplateDecl() &&(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1236, __extension__ __PRETTY_FUNCTION__))
1236 "Wrong kind of template template argument")(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1236, __extension__ __PRETTY_FUNCTION__))
;
1237 return Template.getAsTemplateDecl();
1238 }
1239
1240 // Fall through to find the instantiated declaration for this template
1241 // template parameter.
1242 }
1243
1244 return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
1245}
1246
1247Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
1248 Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
1249 if (!Inst)
1250 return nullptr;
1251
1252 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1253 return Inst;
1254}
1255
1256NamedDecl *
1257TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
1258 SourceLocation Loc) {
1259 // If the first part of the nested-name-specifier was a template type
1260 // parameter, instantiate that type parameter down to a tag type.
1261 if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
1262 const TemplateTypeParmType *TTP
1263 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1264
1265 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1266 // FIXME: This needs testing w/ member access expressions.
1267 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
1268
1269 if (TTP->isParameterPack()) {
1270 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1271, __extension__ __PRETTY_FUNCTION__))
1271 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1271, __extension__ __PRETTY_FUNCTION__))
;
1272
1273 if (getSema().ArgumentPackSubstitutionIndex == -1)
1274 return nullptr;
1275
1276 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1277 }
1278
1279 QualType T = Arg.getAsType();
1280 if (T.isNull())
1281 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1282
1283 if (const TagType *Tag = T->getAs<TagType>())
1284 return Tag->getDecl();
1285
1286 // The resulting type is not a tag; complain.
1287 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1288 return nullptr;
1289 }
1290 }
1291
1292 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1293}
1294
1295VarDecl *
1296TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
1297 TypeSourceInfo *Declarator,
1298 SourceLocation StartLoc,
1299 SourceLocation NameLoc,
1300 IdentifierInfo *Name) {
1301 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1302 StartLoc, NameLoc, Name);
1303 if (Var)
1304 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1305 return Var;
1306}
1307
1308VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1309 TypeSourceInfo *TSInfo,
1310 QualType T) {
1311 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1312 if (Var)
1313 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1314 return Var;
1315}
1316
1317QualType
1318TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
1319 ElaboratedTypeKeyword Keyword,
1320 NestedNameSpecifierLoc QualifierLoc,
1321 QualType T) {
1322 if (const TagType *TT = T->getAs<TagType>()) {
1323 TagDecl* TD = TT->getDecl();
1324
1325 SourceLocation TagLocation = KeywordLoc;
1326
1327 IdentifierInfo *Id = TD->getIdentifier();
1328
1329 // TODO: should we even warn on struct/class mismatches for this? Seems
1330 // like it's likely to produce a lot of spurious errors.
1331 if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {
1332 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1333 if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
1334 TagLocation, Id)) {
1335 SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
1336 << Id
1337 << FixItHint::CreateReplacement(SourceRange(TagLocation),
1338 TD->getKindName());
1339 SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
1340 }
1341 }
1342 }
1343
1344 return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
1345 Keyword,
1346 QualifierLoc,
1347 T);
1348}
1349
1350TemplateName TemplateInstantiator::TransformTemplateName(
1351 CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
1352 QualType ObjectType, NamedDecl *FirstQualifierInScope,
1353 bool AllowInjectedClassName) {
1354 if (TemplateTemplateParmDecl *TTP
1355 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
1356 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1357 // If the corresponding template argument is NULL or non-existent, it's
1358 // because we are performing instantiation from explicitly-specified
1359 // template arguments in a function template, but there were some
1360 // arguments left unspecified.
1361 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1362 TTP->getPosition()))
1363 return Name;
1364
1365 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1366
1367 if (TemplateArgs.isRewrite()) {
1368 // We're rewriting the template parameter as a reference to another
1369 // template parameter.
1370 if (Arg.getKind() == TemplateArgument::Pack) {
1371 assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1372, __extension__ __PRETTY_FUNCTION__))
1372 "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1372, __extension__ __PRETTY_FUNCTION__))
;
1373 Arg = Arg.pack_begin()->getPackExpansionPattern();
1374 }
1375 assert(Arg.getKind() == TemplateArgument::Template &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1376, __extension__ __PRETTY_FUNCTION__))
1376 "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Template && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Template && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1376, __extension__ __PRETTY_FUNCTION__))
;
1377 return Arg.getAsTemplate();
1378 }
1379
1380 if (TTP->isParameterPack()) {
1381 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1382, __extension__ __PRETTY_FUNCTION__))
1382 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1382, __extension__ __PRETTY_FUNCTION__))
;
1383
1384 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1385 // We have the template argument pack to substitute, but we're not
1386 // actually expanding the enclosing pack expansion yet. So, just
1387 // keep the entire argument pack.
1388 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1389 }
1390
1391 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1392 }
1393
1394 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
1395 assert(!Template.isNull() && "Null template template argument")(static_cast <bool> (!Template.isNull() && "Null template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1395, __extension__ __PRETTY_FUNCTION__))
;
1396 assert(!Template.getAsQualifiedTemplateName() &&(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
(0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1397, __extension__ __PRETTY_FUNCTION__))
1397 "template decl to substitute is qualified?")(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
(0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1397, __extension__ __PRETTY_FUNCTION__))
;
1398
1399 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1400 return Template;
1401 }
1402 }
1403
1404 if (SubstTemplateTemplateParmPackStorage *SubstPack
1405 = Name.getAsSubstTemplateTemplateParmPack()) {
1406 if (getSema().ArgumentPackSubstitutionIndex == -1)
1407 return Name;
1408
1409 TemplateArgument Arg = SubstPack->getArgumentPack();
1410 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1411 return Arg.getAsTemplate().getNameToSubstitute();
1412 }
1413
1414 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1415 FirstQualifierInScope,
1416 AllowInjectedClassName);
1417}
1418
1419ExprResult
1420TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
1421 if (!E->isTypeDependent())
1422 return E;
1423
1424 return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentKind());
1425}
1426
1427ExprResult
1428TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
1429 NonTypeTemplateParmDecl *NTTP) {
1430 // If the corresponding template argument is NULL or non-existent, it's
1431 // because we are performing instantiation from explicitly-specified
1432 // template arguments in a function template, but there were some
1433 // arguments left unspecified.
1434 if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
1435 NTTP->getPosition()))
1436 return E;
1437
1438 TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1439
1440 if (TemplateArgs.isRewrite()) {
1441 // We're rewriting the template parameter as a reference to another
1442 // template parameter.
1443 if (Arg.getKind() == TemplateArgument::Pack) {
1444 assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1445, __extension__ __PRETTY_FUNCTION__))
1445 "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1445, __extension__ __PRETTY_FUNCTION__))
;
1446 Arg = Arg.pack_begin()->getPackExpansionPattern();
1447 }
1448 assert(Arg.getKind() == TemplateArgument::Expression &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1449, __extension__ __PRETTY_FUNCTION__))
1449 "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1449, __extension__ __PRETTY_FUNCTION__))
;
1450 // FIXME: This can lead to the same subexpression appearing multiple times
1451 // in a complete expression.
1452 return Arg.getAsExpr();
1453 }
1454
1455 if (NTTP->isParameterPack()) {
1456 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1457, __extension__ __PRETTY_FUNCTION__))
1457 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1457, __extension__ __PRETTY_FUNCTION__))
;
1458
1459 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1460 // We have an argument pack, but we can't select a particular argument
1461 // out of it yet. Therefore, we'll build an expression to hold on to that
1462 // argument pack.
1463 QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
1464 E->getLocation(),
1465 NTTP->getDeclName());
1466 if (TargetType.isNull())
1467 return ExprError();
1468
1469 QualType ExprType = TargetType.getNonLValueExprType(SemaRef.Context);
1470 if (TargetType->isRecordType())
1471 ExprType.addConst();
1472
1473 return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
1474 ExprType, TargetType->isReferenceType() ? VK_LValue : VK_PRValue,
1475 NTTP, E->getLocation(), Arg);
1476 }
1477
1478 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1479 }
1480
1481 return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1482}
1483
1484const LoopHintAttr *
1485TemplateInstantiator::TransformLoopHintAttr(const LoopHintAttr *LH) {
1486 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
1487
1488 if (TransformedExpr == LH->getValue())
1489 return LH;
1490
1491 // Generate error if there is a problem with the value.
1492 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1493 return LH;
1494
1495 // Create new LoopHintValueAttr with integral expression in place of the
1496 // non-type template parameter.
1497 return LoopHintAttr::CreateImplicit(getSema().Context, LH->getOption(),
1498 LH->getState(), TransformedExpr, *LH);
1499}
1500
1501ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1502 NonTypeTemplateParmDecl *parm,
1503 SourceLocation loc,
1504 TemplateArgument arg) {
1505 ExprResult result;
1506
1507 // Determine the substituted parameter type. We can usually infer this from
1508 // the template argument, but not always.
1509 auto SubstParamType = [&] {
1510 QualType T;
1511 if (parm->isExpandedParameterPack())
1512 T = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
1513 else
1514 T = parm->getType();
1515 if (parm->isParameterPack() && isa<PackExpansionType>(T))
1516 T = cast<PackExpansionType>(T)->getPattern();
1517 return SemaRef.SubstType(T, TemplateArgs, loc, parm->getDeclName());
1518 };
1519
1520 bool refParam = false;
1521
1522 // The template argument itself might be an expression, in which case we just
1523 // return that expression. This happens when substituting into an alias
1524 // template.
1525 if (arg.getKind() == TemplateArgument::Expression) {
1526 Expr *argExpr = arg.getAsExpr();
1527 result = argExpr;
1528 if (argExpr->isLValue()) {
1529 if (argExpr->getType()->isRecordType()) {
1530 // Check whether the parameter was actually a reference.
1531 QualType paramType = SubstParamType();
1532 if (paramType.isNull())
1533 return ExprError();
1534 refParam = paramType->isReferenceType();
1535 } else {
1536 refParam = true;
1537 }
1538 }
1539 } else if (arg.getKind() == TemplateArgument::Declaration ||
1540 arg.getKind() == TemplateArgument::NullPtr) {
1541 ValueDecl *VD;
1542 if (arg.getKind() == TemplateArgument::Declaration) {
1543 VD = arg.getAsDecl();
1544
1545 // Find the instantiation of the template argument. This is
1546 // required for nested templates.
1547 VD = cast_or_null<ValueDecl>(
1548 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1549 if (!VD)
1550 return ExprError();
1551 } else {
1552 // Propagate NULL template argument.
1553 VD = nullptr;
1554 }
1555
1556 QualType paramType = VD ? arg.getParamTypeForDecl() : arg.getNullPtrType();
1557 assert(!paramType.isNull() && "type substitution failed for param type")(static_cast <bool> (!paramType.isNull() && "type substitution failed for param type"
) ? void (0) : __assert_fail ("!paramType.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1557, __extension__ __PRETTY_FUNCTION__))
;
1558 assert(!paramType->isDependentType() && "param type still dependent")(static_cast <bool> (!paramType->isDependentType() &&
"param type still dependent") ? void (0) : __assert_fail ("!paramType->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1558, __extension__ __PRETTY_FUNCTION__))
;
1559 result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, paramType, loc);
1560 refParam = paramType->isReferenceType();
1561 } else {
1562 result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1563 assert(result.isInvalid() ||(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1565, __extension__ __PRETTY_FUNCTION__))
1564 SemaRef.Context.hasSameType(result.get()->getType(),(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1565, __extension__ __PRETTY_FUNCTION__))
1565 arg.getIntegralType()))(static_cast <bool> (result.isInvalid() || SemaRef.Context
.hasSameType(result.get()->getType(), arg.getIntegralType(
))) ? void (0) : __assert_fail ("result.isInvalid() || SemaRef.Context.hasSameType(result.get()->getType(), arg.getIntegralType())"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1565, __extension__ __PRETTY_FUNCTION__))
;
1566 }
1567
1568 if (result.isInvalid())
1569 return ExprError();
1570
1571 Expr *resultExpr = result.get();
1572 return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
1573 resultExpr->getType(), resultExpr->getValueKind(), loc, parm, refParam,
1574 resultExpr);
1575}
1576
1577ExprResult
1578TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1579 SubstNonTypeTemplateParmPackExpr *E) {
1580 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1581 // We aren't expanding the parameter pack, so just return ourselves.
1582 return E;
1583 }
1584
1585 TemplateArgument Arg = E->getArgumentPack();
1586 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1587 return transformNonTypeTemplateParmRef(E->getParameterPack(),
1588 E->getParameterPackLocation(),
1589 Arg);
1590}
1591
1592ExprResult
1593TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
1594 SubstNonTypeTemplateParmExpr *E) {
1595 ExprResult SubstReplacement = E->getReplacement();
1596 if (!isa<ConstantExpr>(SubstReplacement.get()))
1597 SubstReplacement = TransformExpr(E->getReplacement());
1598 if (SubstReplacement.isInvalid())
1599 return true;
1600 QualType SubstType = TransformType(E->getParameterType(getSema().Context));
1601 if (SubstType.isNull())
1602 return true;
1603 // The type may have been previously dependent and not now, which means we
1604 // might have to implicit cast the argument to the new type, for example:
1605 // template<auto T, decltype(T) U>
1606 // concept C = sizeof(U) == 4;
1607 // void foo() requires C<2, 'a'> { }
1608 // When normalizing foo(), we first form the normalized constraints of C:
1609 // AtomicExpr(sizeof(U) == 4,
1610 // U=SubstNonTypeTemplateParmExpr(Param=U,
1611 // Expr=DeclRef(U),
1612 // Type=decltype(T)))
1613 // Then we substitute T = 2, U = 'a' into the parameter mapping, and need to
1614 // produce:
1615 // AtomicExpr(sizeof(U) == 4,
1616 // U=SubstNonTypeTemplateParmExpr(Param=U,
1617 // Expr=ImpCast(
1618 // decltype(2),
1619 // SubstNTTPE(Param=U, Expr='a',
1620 // Type=char)),
1621 // Type=decltype(2)))
1622 // The call to CheckTemplateArgument here produces the ImpCast.
1623 TemplateArgument Converted;
1624 if (SemaRef.CheckTemplateArgument(E->getParameter(), SubstType,
1625 SubstReplacement.get(),
1626 Converted).isInvalid())
1627 return true;
1628 return transformNonTypeTemplateParmRef(E->getParameter(),
1629 E->getExprLoc(), Converted);
1630}
1631
1632ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(VarDecl *PD,
1633 SourceLocation Loc) {
1634 DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
1635 return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
1636}
1637
1638ExprResult
1639TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
1640 if (getSema().ArgumentPackSubstitutionIndex != -1) {
1641 // We can expand this parameter pack now.
1642 VarDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex);
1643 VarDecl *VD = cast_or_null<VarDecl>(TransformDecl(E->getExprLoc(), D));
1644 if (!VD)
1645 return ExprError();
1646 return RebuildVarDeclRefExpr(VD, E->getExprLoc());
1647 }
1648
1649 QualType T = TransformType(E->getType());
1650 if (T.isNull())
1651 return ExprError();
1652
1653 // Transform each of the parameter expansions into the corresponding
1654 // parameters in the instantiation of the function decl.
1655 SmallVector<VarDecl *, 8> Vars;
1656 Vars.reserve(E->getNumExpansions());
1657 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1658 I != End; ++I) {
1659 VarDecl *D = cast_or_null<VarDecl>(TransformDecl(E->getExprLoc(), *I));
1660 if (!D)
1661 return ExprError();
1662 Vars.push_back(D);
1663 }
1664
1665 auto *PackExpr =
1666 FunctionParmPackExpr::Create(getSema().Context, T, E->getParameterPack(),
1667 E->getParameterPackLocation(), Vars);
1668 getSema().MarkFunctionParmPackReferenced(PackExpr);
1669 return PackExpr;
1670}
1671
1672ExprResult
1673TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
1674 VarDecl *PD) {
1675 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
1676 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1677 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1678 assert(Found && "no instantiation for parameter pack")(static_cast <bool> (Found && "no instantiation for parameter pack"
) ? void (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1678, __extension__ __PRETTY_FUNCTION__))
;
1679
1680 Decl *TransformedDecl;
1681 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1682 // If this is a reference to a function parameter pack which we can
1683 // substitute but can't yet expand, build a FunctionParmPackExpr for it.
1684 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1685 QualType T = TransformType(E->getType());
1686 if (T.isNull())
1687 return ExprError();
1688 auto *PackExpr = FunctionParmPackExpr::Create(getSema().Context, T, PD,
1689 E->getExprLoc(), *Pack);
1690 getSema().MarkFunctionParmPackReferenced(PackExpr);
1691 return PackExpr;
1692 }
1693
1694 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1695 } else {
1696 TransformedDecl = Found->get<Decl*>();
1697 }
1698
1699 // We have either an unexpanded pack or a specific expansion.
1700 return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl), E->getExprLoc());
1701}
1702
1703ExprResult
1704TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
1705 NamedDecl *D = E->getDecl();
1706
1707 // Handle references to non-type template parameters and non-type template
1708 // parameter packs.
1709 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
1710 if (NTTP->getDepth() < TemplateArgs.getNumLevels())
1711 return TransformTemplateParmRefExpr(E, NTTP);
1712
1713 // We have a non-type template parameter that isn't fully substituted;
1714 // FindInstantiatedDecl will find it in the local instantiation scope.
1715 }
1716
1717 // Handle references to function parameter packs.
1718 if (VarDecl *PD = dyn_cast<VarDecl>(D))
1719 if (PD->isParameterPack())
1720 return TransformFunctionParmPackRefExpr(E, PD);
1721
1722 return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
1723}
1724
1725ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1726 CXXDefaultArgExpr *E) {
1727 assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__))
1728 getDescribedFunctionTemplate() &&(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__))
1729 "Default arg expressions are never formed in dependent cases.")(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__))
;
1730 return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
1731 cast<FunctionDecl>(E->getParam()->getDeclContext()),
1732 E->getParam());
1733}
1734
1735template<typename Fn>
1736QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1737 FunctionProtoTypeLoc TL,
1738 CXXRecordDecl *ThisContext,
1739 Qualifiers ThisTypeQuals,
1740 Fn TransformExceptionSpec) {
1741 // We need a local instantiation scope for this function prototype.
1742 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1743 return inherited::TransformFunctionProtoType(
1744 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1745}
1746
1747ParmVarDecl *
1748TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
1749 int indexAdjustment,
1750 Optional<unsigned> NumExpansions,
1751 bool ExpectParameterPack) {
1752 auto NewParm =
1753 SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
1754 NumExpansions, ExpectParameterPack);
1755 if (NewParm && SemaRef.getLangOpts().OpenCL)
1756 SemaRef.deduceOpenCLAddressSpace(NewParm);
1757 return NewParm;
1758}
1759
1760QualType
1761TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1762 TemplateTypeParmTypeLoc TL) {
1763 const TemplateTypeParmType *T = TL.getTypePtr();
1764 if (T->getDepth() < TemplateArgs.getNumLevels()) {
1765 // Replace the template type parameter with its corresponding
1766 // template argument.
1767
1768 // If the corresponding template argument is NULL or doesn't exist, it's
1769 // because we are performing instantiation from explicitly-specified
1770 // template arguments in a function template class, but there were some
1771 // arguments left unspecified.
1772 if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
1773 TemplateTypeParmTypeLoc NewTL
1774 = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
1775 NewTL.setNameLoc(TL.getNameLoc());
1776 return TL.getType();
1777 }
1778
1779 TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1780
1781 if (TemplateArgs.isRewrite()) {
1782 // We're rewriting the template parameter as a reference to another
1783 // template parameter.
1784 if (Arg.getKind() == TemplateArgument::Pack) {
1785 assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1786, __extension__ __PRETTY_FUNCTION__))
1786 "unexpected pack arguments in template rewrite")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in template rewrite"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1786, __extension__ __PRETTY_FUNCTION__))
;
1787 Arg = Arg.pack_begin()->getPackExpansionPattern();
1788 }
1789 assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1790, __extension__ __PRETTY_FUNCTION__))
1790 "unexpected nontype template argument kind in template rewrite")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "unexpected nontype template argument kind in template rewrite"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"unexpected nontype template argument kind in template rewrite\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1790, __extension__ __PRETTY_FUNCTION__))
;
1791 QualType NewT = Arg.getAsType();
1792 assert(isa<TemplateTypeParmType>(NewT) &&(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1793, __extension__ __PRETTY_FUNCTION__))
1793 "type parm not rewritten to type parm")(static_cast <bool> (isa<TemplateTypeParmType>(NewT
) && "type parm not rewritten to type parm") ? void (
0) : __assert_fail ("isa<TemplateTypeParmType>(NewT) && \"type parm not rewritten to type parm\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1793, __extension__ __PRETTY_FUNCTION__))
;
1794 auto NewTL = TLB.push<TemplateTypeParmTypeLoc>(NewT);
1795 NewTL.setNameLoc(TL.getNameLoc());
1796 return NewT;
1797 }
1798
1799 if (T->isParameterPack()) {
1800 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1801, __extension__ __PRETTY_FUNCTION__))
1801 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1801, __extension__ __PRETTY_FUNCTION__))
;
1802
1803 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1804 // We have the template argument pack, but we're not expanding the
1805 // enclosing pack expansion yet. Just save the template argument
1806 // pack for later substitution.
1807 QualType Result
1808 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1809 SubstTemplateTypeParmPackTypeLoc NewTL
1810 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
1811 NewTL.setNameLoc(TL.getNameLoc());
1812 return Result;
1813 }
1814
1815 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1816 }
1817
1818 assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
: __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1819, __extension__ __PRETTY_FUNCTION__))
1819 "Template argument kind mismatch")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
: __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1819, __extension__ __PRETTY_FUNCTION__))
;
1820
1821 QualType Replacement = Arg.getAsType();
1822
1823 // TODO: only do this uniquing once, at the start of instantiation.
1824 QualType Result
1825 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1826 SubstTemplateTypeParmTypeLoc NewTL
1827 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1828 NewTL.setNameLoc(TL.getNameLoc());
1829 return Result;
1830 }
1831
1832 // The template type parameter comes from an inner template (e.g.,
1833 // the template parameter list of a member template inside the
1834 // template we are instantiating). Create a new template type
1835 // parameter with the template "level" reduced by one.
1836 TemplateTypeParmDecl *NewTTPDecl = nullptr;
1837 if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
1838 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1839 TransformDecl(TL.getNameLoc(), OldTTPDecl));
1840
1841 QualType Result = getSema().Context.getTemplateTypeParmType(
1842 T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
1843 T->isParameterPack(), NewTTPDecl);
1844 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
1845 NewTL.setNameLoc(TL.getNameLoc());
1846 return Result;
1847}
1848
1849QualType
1850TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1851 TypeLocBuilder &TLB,
1852 SubstTemplateTypeParmPackTypeLoc TL) {
1853 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1854 // We aren't expanding the parameter pack, so just return ourselves.
1855 SubstTemplateTypeParmPackTypeLoc NewTL
1856 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
1857 NewTL.setNameLoc(TL.getNameLoc());
1858 return TL.getType();
1859 }
1860
1861 TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
1862 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1863 QualType Result = Arg.getAsType();
1864
1865 Result = getSema().Context.getSubstTemplateTypeParmType(
1866 TL.getTypePtr()->getReplacedParameter(),
1867 Result);
1868 SubstTemplateTypeParmTypeLoc NewTL
1869 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1870 NewTL.setNameLoc(TL.getNameLoc());
1871 return Result;
1872}
1873
1874template<typename EntityPrinter>
1875static concepts::Requirement::SubstitutionDiagnostic *
1876createSubstDiag(Sema &S, TemplateDeductionInfo &Info, EntityPrinter Printer) {
1877 SmallString<128> Message;
1878 SourceLocation ErrorLoc;
1879 if (Info.hasSFINAEDiagnostic()) {
1880 PartialDiagnosticAt PDA(SourceLocation(),
1881 PartialDiagnostic::NullDiagnostic{});
1882 Info.takeSFINAEDiagnostic(PDA);
1883 PDA.second.EmitToString(S.getDiagnostics(), Message);
1884 ErrorLoc = PDA.first;
1885 } else {
1886 ErrorLoc = Info.getLocation();
1887 }
1888 char *MessageBuf = new (S.Context) char[Message.size()];
1889 std::copy(Message.begin(), Message.end(), MessageBuf);
1890 SmallString<128> Entity;
1891 llvm::raw_svector_ostream OS(Entity);
1892 Printer(OS);
1893 char *EntityBuf = new (S.Context) char[Entity.size()];
1894 std::copy(Entity.begin(), Entity.end(), EntityBuf);
1895 return new (S.Context) concepts::Requirement::SubstitutionDiagnostic{
1896 StringRef(EntityBuf, Entity.size()), ErrorLoc,
1897 StringRef(MessageBuf, Message.size())};
1898}
1899
1900concepts::TypeRequirement *
1901TemplateInstantiator::TransformTypeRequirement(concepts::TypeRequirement *Req) {
1902 if (!Req->isDependent() && !AlwaysRebuild())
1903 return Req;
1904 if (Req->isSubstitutionFailure()) {
1905 if (AlwaysRebuild())
1906 return RebuildTypeRequirement(
1907 Req->getSubstitutionDiagnostic());
1908 return Req;
1909 }
1910
1911 Sema::SFINAETrap Trap(SemaRef);
1912 TemplateDeductionInfo Info(Req->getType()->getTypeLoc().getBeginLoc());
1913 Sema::InstantiatingTemplate TypeInst(SemaRef,
1914 Req->getType()->getTypeLoc().getBeginLoc(), Req, Info,
1915 Req->getType()->getTypeLoc().getSourceRange());
1916 if (TypeInst.isInvalid())
1917 return nullptr;
1918 TypeSourceInfo *TransType = TransformType(Req->getType());
1919 if (!TransType || Trap.hasErrorOccurred())
1920 return RebuildTypeRequirement(createSubstDiag(SemaRef, Info,
1921 [&] (llvm::raw_ostream& OS) {
1922 Req->getType()->getType().print(OS, SemaRef.getPrintingPolicy());
1923 }));
1924 return RebuildTypeRequirement(TransType);
1925}
1926
1927concepts::ExprRequirement *
1928TemplateInstantiator::TransformExprRequirement(concepts::ExprRequirement *Req) {
1929 if (!Req->isDependent() && !AlwaysRebuild())
1930 return Req;
1931
1932 Sema::SFINAETrap Trap(SemaRef);
1933
1934 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
1935 TransExpr;
1936 if (Req->isExprSubstitutionFailure())
1937 TransExpr = Req->getExprSubstitutionDiagnostic();
1938 else {
1939 Expr *E = Req->getExpr();
1940 TemplateDeductionInfo Info(E->getBeginLoc());
1941 Sema::InstantiatingTemplate ExprInst(SemaRef, E->getBeginLoc(), Req, Info,
1942 E->getSourceRange());
1943 if (ExprInst.isInvalid())
1944 return nullptr;
1945 ExprResult TransExprRes = TransformExpr(E);
1946 if (TransExprRes.isInvalid() || Trap.hasErrorOccurred())
1947 TransExpr = createSubstDiag(SemaRef, Info, [&](llvm::raw_ostream &OS) {
1948 E->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
1949 });
1950 else
1951 TransExpr = TransExprRes.get();
1952 }
1953
1954 llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
1955 const auto &RetReq = Req->getReturnTypeRequirement();
1956 if (RetReq.isEmpty())
1957 TransRetReq.emplace();
1958 else if (RetReq.isSubstitutionFailure())
1959 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
1960 else if (RetReq.isTypeConstraint()) {
1961 TemplateParameterList *OrigTPL =
1962 RetReq.getTypeConstraintTemplateParameterList();
1963 TemplateDeductionInfo Info(OrigTPL->getTemplateLoc());
1964 Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
1965 Req, Info, OrigTPL->getSourceRange());
1966 if (TPLInst.isInvalid())
1967 return nullptr;
1968 TemplateParameterList *TPL =
1969 TransformTemplateParameterList(OrigTPL);
1970 if (!TPL)
1971 TransRetReq.emplace(createSubstDiag(SemaRef, Info,
1972 [&] (llvm::raw_ostream& OS) {
1973 RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
1974 ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
1975 }));
1976 else {
1977 TPLInst.Clear();
1978 TransRetReq.emplace(TPL);
1979 }
1980 }
1981 assert(TransRetReq.hasValue() &&(static_cast <bool> (TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1982, __extension__ __PRETTY_FUNCTION__))
1982 "All code paths leading here must set TransRetReq")(static_cast <bool> (TransRetReq.hasValue() && "All code paths leading here must set TransRetReq"
) ? void (0) : __assert_fail ("TransRetReq.hasValue() && \"All code paths leading here must set TransRetReq\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1982, __extension__ __PRETTY_FUNCTION__))
;
1983 if (Expr *E = TransExpr.dyn_cast<Expr *>())
1984 return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(),
1985 std::move(*TransRetReq));
1986 return RebuildExprRequirement(
1987 TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
1988 Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
1989}
1990
1991concepts::NestedRequirement *
1992TemplateInstantiator::TransformNestedRequirement(
1993 concepts::NestedRequirement *Req) {
1994 if (!Req->isDependent() && !AlwaysRebuild())
1995 return Req;
1996 if (Req->isSubstitutionFailure()) {
1997 if (AlwaysRebuild())
1998 return RebuildNestedRequirement(
1999 Req->getSubstitutionDiagnostic());
2000 return Req;
2001 }
2002 Sema::InstantiatingTemplate ReqInst(SemaRef,
2003 Req->getConstraintExpr()->getBeginLoc(), Req,
2004 Sema::InstantiatingTemplate::ConstraintsCheck{},
2005 Req->getConstraintExpr()->getSourceRange());
2006
2007 ExprResult TransConstraint;
2008 TemplateDeductionInfo Info(Req->getConstraintExpr()->getBeginLoc());
2009 {
2010 EnterExpressionEvaluationContext ContextRAII(
2011 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
2012 Sema::SFINAETrap Trap(SemaRef);
2013 Sema::InstantiatingTemplate ConstrInst(SemaRef,
2014 Req->getConstraintExpr()->getBeginLoc(), Req, Info,
2015 Req->getConstraintExpr()->getSourceRange());
2016 if (ConstrInst.isInvalid())
2017 return nullptr;
2018 TransConstraint = TransformExpr(Req->getConstraintExpr());
2019 if (TransConstraint.isInvalid() || Trap.hasErrorOccurred())
2020 return RebuildNestedRequirement(createSubstDiag(SemaRef, Info,
2021 [&] (llvm::raw_ostream& OS) {
2022 Req->getConstraintExpr()->printPretty(OS, nullptr,
2023 SemaRef.getPrintingPolicy());
2024 }));
2025 }
2026 return RebuildNestedRequirement(TransConstraint.get());
2027}
2028
2029
2030/// Perform substitution on the type T with a given set of template
2031/// arguments.
2032///
2033/// This routine substitutes the given template arguments into the
2034/// type T and produces the instantiated type.
2035///
2036/// \param T the type into which the template arguments will be
2037/// substituted. If this type is not dependent, it will be returned
2038/// immediately.
2039///
2040/// \param Args the template arguments that will be
2041/// substituted for the top-level template parameters within T.
2042///
2043/// \param Loc the location in the source code where this substitution
2044/// is being performed. It will typically be the location of the
2045/// declarator (if we're instantiating the type of some declaration)
2046/// or the location of the type in the source code (if, e.g., we're
2047/// instantiating the type of a cast expression).
2048///
2049/// \param Entity the name of the entity associated with a declaration
2050/// being instantiated (if any). May be empty to indicate that there
2051/// is no such entity (if, e.g., this is a type that occurs as part of
2052/// a cast expression) or that the entity has no name (e.g., an
2053/// unnamed function parameter).
2054///
2055/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
2056/// acceptable as the top level type of the result.
2057///
2058/// \returns If the instantiation succeeds, the instantiated
2059/// type. Otherwise, produces diagnostics and returns a NULL type.
2060TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
2061 const MultiLevelTemplateArgumentList &Args,
2062 SourceLocation Loc,
2063 DeclarationName Entity,
2064 bool AllowDeducedTST) {
2065 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2067, __extension__ __PRETTY_FUNCTION__))
2066 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2067, __extension__ __PRETTY_FUNCTION__))
2067 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2067, __extension__ __PRETTY_FUNCTION__))
;
2068
2069 if (!T->getType()->isInstantiationDependentType() &&
2070 !T->getType()->isVariablyModifiedType())
2071 return T;
2072
2073 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
2074 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
2075 : Instantiator.TransformType(T);
2076}
2077
2078TypeSourceInfo *Sema::SubstType(TypeLoc TL,
2079 const MultiLevelTemplateArgumentList &Args,
2080 SourceLocation Loc,
2081 DeclarationName Entity) {
2082 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2084, __extension__ __PRETTY_FUNCTION__))
2083 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2084, __extension__ __PRETTY_FUNCTION__))
2084 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2084, __extension__ __PRETTY_FUNCTION__))
;
2085
2086 if (TL.getType().isNull())
2087 return nullptr;
2088
2089 if (!TL.getType()->isInstantiationDependentType() &&
2090 !TL.getType()->isVariablyModifiedType()) {
2091 // FIXME: Make a copy of the TypeLoc data here, so that we can
2092 // return a new TypeSourceInfo. Inefficient!
2093 TypeLocBuilder TLB;
2094 TLB.pushFullCopy(TL);
2095 return TLB.getTypeSourceInfo(Context, TL.getType());
2096 }
2097
2098 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
2099 TypeLocBuilder TLB;
2100 TLB.reserve(TL.getFullDataSize());
2101 QualType Result = Instantiator.TransformType(TLB, TL);
2102 if (Result.isNull())
2103 return nullptr;
2104
2105 return TLB.getTypeSourceInfo(Context, Result);
2106}
2107
2108/// Deprecated form of the above.
2109QualType Sema::SubstType(QualType T,
2110 const MultiLevelTemplateArgumentList &TemplateArgs,
2111 SourceLocation Loc, DeclarationName Entity) {
2112 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2114, __extension__ __PRETTY_FUNCTION__))
2113 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2114, __extension__ __PRETTY_FUNCTION__))
2114 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2114, __extension__ __PRETTY_FUNCTION__))
;
2115
2116 // If T is not a dependent type or a variably-modified type, there
2117 // is nothing to do.
2118 if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
2119 return T;
2120
2121 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
2122 return Instantiator.TransformType(T);
2123}
2124
2125static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
2126 if (T->getType()->isInstantiationDependentType() ||
2127 T->getType()->isVariablyModifiedType())
2128 return true;
2129
2130 TypeLoc TL = T->getTypeLoc().IgnoreParens();
2131 if (!TL.getAs<FunctionProtoTypeLoc>())
2132 return false;
2133
2134 FunctionProtoTypeLoc FP = TL.castAs<FunctionProtoTypeLoc>();
2135 for (ParmVarDecl *P : FP.getParams()) {
2136 // This must be synthesized from a typedef.
2137 if (!P) continue;
2138
2139 // If there are any parameters, a new TypeSourceInfo that refers to the
2140 // instantiated parameters must be built.
2141 return true;
2142 }
2143
2144 return false;
2145}
2146
2147/// A form of SubstType intended specifically for instantiating the
2148/// type of a FunctionDecl. Its purpose is solely to force the
2149/// instantiation of default-argument expressions and to avoid
2150/// instantiating an exception-specification.
2151TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
2152 const MultiLevelTemplateArgumentList &Args,
2153 SourceLocation Loc,
2154 DeclarationName Entity,
2155 CXXRecordDecl *ThisContext,
2156 Qualifiers ThisTypeQuals) {
2157 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2159, __extension__ __PRETTY_FUNCTION__))
2158 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2159, __extension__ __PRETTY_FUNCTION__))
2159 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2159, __extension__ __PRETTY_FUNCTION__))
;
2160
2161 if (!NeedsInstantiationAsFunctionType(T))
2162 return T;
2163
2164 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
2165
2166 TypeLocBuilder TLB;
2167
2168 TypeLoc TL = T->getTypeLoc();
2169 TLB.reserve(TL.getFullDataSize());
2170
2171 QualType Result;
2172
2173 if (FunctionProtoTypeLoc Proto =
2174 TL.IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
2175 // Instantiate the type, other than its exception specification. The
2176 // exception specification is instantiated in InitFunctionInstantiation
2177 // once we've built the FunctionDecl.
2178 // FIXME: Set the exception specification to EST_Uninstantiated here,
2179 // instead of rebuilding the function type again later.
2180 Result = Instantiator.TransformFunctionProtoType(
2181 TLB, Proto, ThisContext, ThisTypeQuals,
2182 [](FunctionProtoType::ExceptionSpecInfo &ESI,
2183 bool &Changed) { return false; });
2184 } else {
2185 Result = Instantiator.TransformType(TLB, TL);
2186 }
2187 if (Result.isNull())
2188 return nullptr;
2189
2190 return TLB.getTypeSourceInfo(Context, Result);
2191}
2192
2193bool Sema::SubstExceptionSpec(SourceLocation Loc,
2194 FunctionProtoType::ExceptionSpecInfo &ESI,
2195 SmallVectorImpl<QualType> &ExceptionStorage,
2196 const MultiLevelTemplateArgumentList &Args) {
2197 assert(ESI.Type != EST_Uninstantiated)(static_cast <bool> (ESI.Type != EST_Uninstantiated) ? void
(0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2197, __extension__ __PRETTY_FUNCTION__))
;
2198
2199 bool Changed = false;
2200 TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
2201 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
2202 Changed);
2203}
2204
2205void Sema::SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
2206 const MultiLevelTemplateArgumentList &Args) {
2207 FunctionProtoType::ExceptionSpecInfo ESI =
2208 Proto->getExtProtoInfo().ExceptionSpec;
2209
2210 SmallVector<QualType, 4> ExceptionStorage;
2211 if (SubstExceptionSpec(New->getTypeSourceInfo()->getTypeLoc().getEndLoc(),
2212 ESI, ExceptionStorage, Args))
2213 // On error, recover by dropping the exception specification.
2214 ESI.Type = EST_None;
2215
2216 UpdateExceptionSpec(New, ESI);
2217}
2218
2219namespace {
2220
2221 struct GetContainedInventedTypeParmVisitor :
2222 public TypeVisitor<GetContainedInventedTypeParmVisitor,
2223 TemplateTypeParmDecl *> {
2224 using TypeVisitor<GetContainedInventedTypeParmVisitor,
2225 TemplateTypeParmDecl *>::Visit;
2226
2227 TemplateTypeParmDecl *Visit(QualType T) {
2228 if (T.isNull())
2229 return nullptr;
2230 return Visit(T.getTypePtr());
2231 }
2232 // The deduced type itself.
2233 TemplateTypeParmDecl *VisitTemplateTypeParmType(
2234 const TemplateTypeParmType *T) {
2235 if (!T->getDecl() || !T->getDecl()->isImplicit())
2236 return nullptr;
2237 return T->getDecl();
2238 }
2239
2240 // Only these types can contain 'auto' types, and subsequently be replaced
2241 // by references to invented parameters.
2242
2243 TemplateTypeParmDecl *VisitElaboratedType(const ElaboratedType *T) {
2244 return Visit(T->getNamedType());
2245 }
2246
2247 TemplateTypeParmDecl *VisitPointerType(const PointerType *T) {
2248 return Visit(T->getPointeeType());
2249 }
2250
2251 TemplateTypeParmDecl *VisitBlockPointerType(const BlockPointerType *T) {
2252 return Visit(T->getPointeeType());
2253 }
2254
2255 TemplateTypeParmDecl *VisitReferenceType(const ReferenceType *T) {
2256 return Visit(T->getPointeeTypeAsWritten());
2257 }
2258
2259 TemplateTypeParmDecl *VisitMemberPointerType(const MemberPointerType *T) {
2260 return Visit(T->getPointeeType());
2261 }
2262
2263 TemplateTypeParmDecl *VisitArrayType(const ArrayType *T) {
2264 return Visit(T->getElementType());
2265 }
2266
2267 TemplateTypeParmDecl *VisitDependentSizedExtVectorType(
2268 const DependentSizedExtVectorType *T) {
2269 return Visit(T->getElementType());
2270 }
2271
2272 TemplateTypeParmDecl *VisitVectorType(const VectorType *T) {
2273 return Visit(T->getElementType());
2274 }
2275
2276 TemplateTypeParmDecl *VisitFunctionProtoType(const FunctionProtoType *T) {
2277 return VisitFunctionType(T);
2278 }
2279
2280 TemplateTypeParmDecl *VisitFunctionType(const FunctionType *T) {
2281 return Visit(T->getReturnType());
2282 }
2283
2284 TemplateTypeParmDecl *VisitParenType(const ParenType *T) {
2285 return Visit(T->getInnerType());
2286 }
2287
2288 TemplateTypeParmDecl *VisitAttributedType(const AttributedType *T) {
2289 return Visit(T->getModifiedType());
2290 }
2291
2292 TemplateTypeParmDecl *VisitMacroQualifiedType(const MacroQualifiedType *T) {
2293 return Visit(T->getUnderlyingType());
2294 }
2295
2296 TemplateTypeParmDecl *VisitAdjustedType(const AdjustedType *T) {
2297 return Visit(T->getOriginalType());
2298 }
2299
2300 TemplateTypeParmDecl *VisitPackExpansionType(const PackExpansionType *T) {
2301 return Visit(T->getPattern());
2302 }
2303 };
2304
2305} // namespace
2306
2307bool Sema::SubstTypeConstraint(
2308 TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
2309 const MultiLevelTemplateArgumentList &TemplateArgs) {
2310 const ASTTemplateArgumentListInfo *TemplArgInfo =
2311 TC->getTemplateArgsAsWritten();
2312 TemplateArgumentListInfo InstArgs;
2313
2314 if (TemplArgInfo) {
2315 InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
2316 InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
2317 if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
2318 InstArgs))
2319 return true;
2320 }
2321 return AttachTypeConstraint(
2322 TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
2323 TC->getNamedConcept(), &InstArgs, Inst,
2324 Inst->isParameterPack()
2325 ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2326 ->getEllipsisLoc()
2327 : SourceLocation());
2328}
2329
2330ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
2331 const MultiLevelTemplateArgumentList &TemplateArgs,
2332 int indexAdjustment,
2333 Optional<unsigned> NumExpansions,
2334 bool ExpectParameterPack) {
2335 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
2336 TypeSourceInfo *NewDI = nullptr;
2337
2338 TypeLoc OldTL = OldDI->getTypeLoc();
2339 if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
2340
2341 // We have a function parameter pack. Substitute into the pattern of the
2342 // expansion.
2343 NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
2344 OldParm->getLocation(), OldParm->getDeclName());
2345 if (!NewDI)
2346 return nullptr;
2347
2348 if (NewDI->getType()->containsUnexpandedParameterPack()) {
2349 // We still have unexpanded parameter packs, which means that
2350 // our function parameter is still a function parameter pack.
2351 // Therefore, make its type a pack expansion type.
2352 NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
2353 NumExpansions);
2354 } else if (ExpectParameterPack) {
2355 // We expected to get a parameter pack but didn't (because the type
2356 // itself is not a pack expansion type), so complain. This can occur when
2357 // the substitution goes through an alias template that "loses" the
2358 // pack expansion.
2359 Diag(OldParm->getLocation(),
2360 diag::err_function_parameter_pack_without_parameter_packs)
2361 << NewDI->getType();
2362 return nullptr;
2363 }
2364 } else {
2365 NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
2366 OldParm->getDeclName());
2367 }
2368
2369 if (!NewDI)
2370 return nullptr;
2371
2372 if (NewDI->getType()->isVoidType()) {
2373 Diag(OldParm->getLocation(), diag::err_param_with_void_type);
2374 return nullptr;
2375 }
2376
2377 // In abbreviated templates, TemplateTypeParmDecls with possible
2378 // TypeConstraints are created when the parameter list is originally parsed.
2379 // The TypeConstraints can therefore reference other functions parameters in
2380 // the abbreviated function template, which is why we must instantiate them
2381 // here, when the instantiated versions of those referenced parameters are in
2382 // scope.
2383 if (TemplateTypeParmDecl *TTP =
2384 GetContainedInventedTypeParmVisitor().Visit(OldDI->getType())) {
2385 if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
2386 auto *Inst = cast_or_null<TemplateTypeParmDecl>(
2387 FindInstantiatedDecl(TTP->getLocation(), TTP, TemplateArgs));
2388 // We will first get here when instantiating the abbreviated function
2389 // template's described function, but we might also get here later.
2390 // Make sure we do not instantiate the TypeConstraint more than once.
2391 if (Inst && !Inst->getTypeConstraint()) {
2392 // TODO: Concepts: do not instantiate the constraint (delayed constraint
2393 // substitution)
2394 if (SubstTypeConstraint(Inst, TC, TemplateArgs))
2395 return nullptr;
2396 }
2397 }
2398 }
2399
2400 ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
2401 OldParm->getInnerLocStart(),
2402 OldParm->getLocation(),
2403 OldParm->getIdentifier(),
2404 NewDI->getType(), NewDI,
2405 OldParm->getStorageClass());
2406 if (!NewParm)
2407 return nullptr;
2408
2409 // Mark the (new) default argument as uninstantiated (if any).
2410 if (OldParm->hasUninstantiatedDefaultArg()) {
2411 Expr *Arg = OldParm->getUninstantiatedDefaultArg();
2412 NewParm->setUninstantiatedDefaultArg(Arg);
2413 } else if (OldParm->hasUnparsedDefaultArg()) {
2414 NewParm->setUnparsedDefaultArg();
2415 UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
2416 } else if (Expr *Arg = OldParm->getDefaultArg()) {
2417 FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
2418 if (OwningFunc->isInLocalScopeForInstantiation()) {
2419 // Instantiate default arguments for methods of local classes (DR1484)
2420 // and non-defining declarations.
2421 Sema::ContextRAII SavedContext(*this, OwningFunc);
2422 LocalInstantiationScope Local(*this, true);
2423 ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
2424 if (NewArg.isUsable()) {
2425 // It would be nice if we still had this.
2426 SourceLocation EqualLoc = NewArg.get()->getBeginLoc();
2427 ExprResult Result =
2428 ConvertParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
2429 if (Result.isInvalid())
2430 return nullptr;
2431
2432 SetParamDefaultArgument(NewParm, Result.getAs<Expr>(), EqualLoc);
2433 }
2434 } else {
2435 // FIXME: if we non-lazily instantiated non-dependent default args for
2436 // non-dependent parameter types we could remove a bunch of duplicate
2437 // conversion warnings for such arguments.
2438 NewParm->setUninstantiatedDefaultArg(Arg);
2439 }
2440 }
2441
2442 NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());
2443
2444 if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
2445 // Add the new parameter to the instantiated parameter pack.
2446 CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
2447 } else {
2448 // Introduce an Old -> New mapping
2449 CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
2450 }
2451
2452 // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
2453 // can be anything, is this right ?
2454 NewParm->setDeclContext(CurContext);
2455
2456 NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
2457 OldParm->getFunctionScopeIndex() + indexAdjustment);
2458
2459 InstantiateAttrs(TemplateArgs, OldParm, NewParm);
2460
2461 return NewParm;
2462}
2463
2464/// Substitute the given template arguments into the given set of
2465/// parameters, producing the set of parameter types that would be generated
2466/// from such a substitution.
2467bool Sema::SubstParmTypes(
2468 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
2469 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
2470 const MultiLevelTemplateArgumentList &TemplateArgs,
2471 SmallVectorImpl<QualType> &ParamTypes,
2472 SmallVectorImpl<ParmVarDecl *> *OutParams,
2473 ExtParameterInfoBuilder &ParamInfos) {
2474 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2476, __extension__ __PRETTY_FUNCTION__))
2475 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2476, __extension__ __PRETTY_FUNCTION__))
2476 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2476, __extension__ __PRETTY_FUNCTION__))
;
2477
2478 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2479 DeclarationName());
2480 return Instantiator.TransformFunctionTypeParams(
2481 Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
2482}
2483
2484/// Perform substitution on the base class specifiers of the
2485/// given class template specialization.
2486///
2487/// Produces a diagnostic and returns true on error, returns false and
2488/// attaches the instantiated base classes to the class template
2489/// specialization if successful.
2490bool
2491Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
2492 CXXRecordDecl *Pattern,
2493 const MultiLevelTemplateArgumentList &TemplateArgs) {
2494 bool Invalid = false;
2495 SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
2496 for (const auto &Base : Pattern->bases()) {
2497 if (!Base.getType()->isDependentType()) {
2498 if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
2499 if (RD->isInvalidDecl())
2500 Instantiation->setInvalidDecl();
2501 }
2502 InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(Base));
2503 continue;
2504 }
2505
2506 SourceLocation EllipsisLoc;
2507 TypeSourceInfo *BaseTypeLoc;
2508 if (Base.isPackExpansion()) {
2509 // This is a pack expansion. See whether we should expand it now, or
2510 // wait until later.
2511 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2512 collectUnexpandedParameterPacks(Base.getTypeSourceInfo()->getTypeLoc(),
2513 Unexpanded);
2514 bool ShouldExpand = false;
2515 bool RetainExpansion = false;
2516 Optional<unsigned> NumExpansions;
2517 if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(),
2518 Base.getSourceRange(),
2519 Unexpanded,
2520 TemplateArgs, ShouldExpand,
2521 RetainExpansion,
2522 NumExpansions)) {
2523 Invalid = true;
2524 continue;
2525 }
2526
2527 // If we should expand this pack expansion now, do so.
2528 if (ShouldExpand) {
2529 for (unsigned I = 0; I != *NumExpansions; ++I) {
2530 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
2531
2532 TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
2533 TemplateArgs,
2534 Base.getSourceRange().getBegin(),
2535 DeclarationName());
2536 if (!BaseTypeLoc) {
2537 Invalid = true;
2538 continue;
2539 }
2540
2541 if (CXXBaseSpecifier *InstantiatedBase
2542 = CheckBaseSpecifier(Instantiation,
2543 Base.getSourceRange(),
2544 Base.isVirtual(),
2545 Base.getAccessSpecifierAsWritten(),
2546 BaseTypeLoc,
2547 SourceLocation()))
2548 InstantiatedBases.push_back(InstantiatedBase);
2549 else
2550 Invalid = true;
2551 }
2552
2553 continue;
2554 }
2555
2556 // The resulting base specifier will (still) be a pack expansion.
2557 EllipsisLoc = Base.getEllipsisLoc();
2558 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
2559 BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
2560 TemplateArgs,
2561 Base.getSourceRange().getBegin(),
2562 DeclarationName());
2563 } else {
2564 BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
2565 TemplateArgs,
2566 Base.getSourceRange().getBegin(),
2567 DeclarationName());
2568 }
2569
2570 if (!BaseTypeLoc) {
2571 Invalid = true;
2572 continue;
2573 }
2574
2575 if (CXXBaseSpecifier *InstantiatedBase
2576 = CheckBaseSpecifier(Instantiation,
2577 Base.getSourceRange(),
2578 Base.isVirtual(),
2579 Base.getAccessSpecifierAsWritten(),
2580 BaseTypeLoc,
2581 EllipsisLoc))
2582 InstantiatedBases.push_back(InstantiatedBase);
2583 else
2584 Invalid = true;
2585 }
2586
2587 if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
2588 Invalid = true;
2589
2590 return Invalid;
2591}
2592
2593// Defined via #include from SemaTemplateInstantiateDecl.cpp
2594namespace clang {
2595 namespace sema {
2596 Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
2597 const MultiLevelTemplateArgumentList &TemplateArgs);
2598 Attr *instantiateTemplateAttributeForDecl(
2599 const Attr *At, ASTContext &C, Sema &S,
2600 const MultiLevelTemplateArgumentList &TemplateArgs);
2601 }
2602}
2603
2604/// Instantiate the definition of a class from a given pattern.
2605///
2606/// \param PointOfInstantiation The point of instantiation within the
2607/// source code.
2608///
2609/// \param Instantiation is the declaration whose definition is being
2610/// instantiated. This will be either a class template specialization
2611/// or a member class of a class template specialization.
2612///
2613/// \param Pattern is the pattern from which the instantiation
2614/// occurs. This will be either the declaration of a class template or
2615/// the declaration of a member class of a class template.
2616///
2617/// \param TemplateArgs The template arguments to be substituted into
2618/// the pattern.
2619///
2620/// \param TSK the kind of implicit or explicit instantiation to perform.
2621///
2622/// \param Complain whether to complain if the class cannot be instantiated due
2623/// to the lack of a definition.
2624///
2625/// \returns true if an error occurred, false otherwise.
2626bool
2627Sema::InstantiateClass(SourceLocation PointOfInstantiation,
2628 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
2629 const MultiLevelTemplateArgumentList &TemplateArgs,
2630 TemplateSpecializationKind TSK,
2631 bool Complain) {
2632 CXXRecordDecl *PatternDef
2633 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
2634 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2635 Instantiation->getInstantiatedFromMemberClass(),
2636 Pattern, PatternDef, TSK, Complain))
2637 return true;
2638
2639 llvm::TimeTraceScope TimeScope("InstantiateClass", [&]() {
2640 std::string Name;
2641 llvm::raw_string_ostream OS(Name);
2642 Instantiation->getNameForDiagnostic(OS, getPrintingPolicy(),
2643 /*Qualified=*/true);
2644 return Name;
2645 });
2646
2647 Pattern = PatternDef;
2648
2649 // Record the point of instantiation.
2650 if (MemberSpecializationInfo *MSInfo
2651 = Instantiation->getMemberSpecializationInfo()) {
2652 MSInfo->setTemplateSpecializationKind(TSK);
2653 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2654 } else if (ClassTemplateSpecializationDecl *Spec
2655 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2656 Spec->setTemplateSpecializationKind(TSK);
2657 Spec->setPointOfInstantiation(PointOfInstantiation);
2658 }
2659
2660 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2661 if (Inst.isInvalid())
2662 return true;
2663 assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")(static_cast <bool> (!Inst.isAlreadyInstantiating() &&
"should have been caught by caller") ? void (0) : __assert_fail
("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2663, __extension__ __PRETTY_FUNCTION__))
;
2664 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
2665 "instantiating class definition");
2666
2667 // Enter the scope of this instantiation. We don't use
2668 // PushDeclContext because we don't have a scope.
2669 ContextRAII SavedContext(*this, Instantiation);
2670 EnterExpressionEvaluationContext EvalContext(
2671 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2672
2673 // If this is an instantiation of a local class, merge this local
2674 // instantiation scope with the enclosing scope. Otherwise, every
2675 // instantiation of a class has its own local instantiation scope.
2676 bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
2677 LocalInstantiationScope Scope(*this, MergeWithParentScope);
2678
2679 // Some class state isn't processed immediately but delayed till class
2680 // instantiation completes. We may not be ready to handle any delayed state
2681 // already on the stack as it might correspond to a different class, so save
2682 // it now and put it back later.
2683 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);
2684
2685 // Pull attributes from the pattern onto the instantiation.
2686 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2687
2688 // Start the definition of this instantiation.
2689 Instantiation->startDefinition();
2690
2691 // The instantiation is visible here, even if it was first declared in an
2692 // unimported module.
2693 Instantiation->setVisibleDespiteOwningModule();
2694
2695 // FIXME: This loses the as-written tag kind for an explicit instantiation.
2696 Instantiation->setTagKind(Pattern->getTagKind());
2697
2698 // Do substitution on the base class specifiers.
2699 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
2700 Instantiation->setInvalidDecl();
2701
2702 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2703 SmallVector<Decl*, 4> Fields;
2704 // Delay instantiation of late parsed attributes.
2705 LateInstantiatedAttrVec LateAttrs;
2706 Instantiator.enableLateAttributeInstantiation(&LateAttrs);
2707
2708 bool MightHaveConstexprVirtualFunctions = false;
2709 for (auto *Member : Pattern->decls()) {
2710 // Don't instantiate members not belonging in this semantic context.
2711 // e.g. for:
2712 // @code
2713 // template <int i> class A {
2714 // class B *g;
2715 // };
2716 // @endcode
2717 // 'class B' has the template as lexical context but semantically it is
2718 // introduced in namespace scope.
2719 if (Member->getDeclContext() != Pattern)
2720 continue;
2721
2722 // BlockDecls can appear in a default-member-initializer. They must be the
2723 // child of a BlockExpr, so we only know how to instantiate them from there.
2724 // Similarly, lambda closure types are recreated when instantiating the
2725 // corresponding LambdaExpr.
2726 if (isa<BlockDecl>(Member) ||
2727 (isa<CXXRecordDecl>(Member) && cast<CXXRecordDecl>(Member)->isLambda()))
2728 continue;
2729
2730 if (Member->isInvalidDecl()) {
2731 Instantiation->setInvalidDecl();
2732 continue;
2733 }
2734
2735 Decl *NewMember = Instantiator.Visit(Member);
2736 if (NewMember) {
2737 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2738 Fields.push_back(Field);
2739 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2740 // C++11 [temp.inst]p1: The implicit instantiation of a class template
2741 // specialization causes the implicit instantiation of the definitions
2742 // of unscoped member enumerations.
2743 // Record a point of instantiation for this implicit instantiation.
2744 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
2745 Enum->isCompleteDefinition()) {
2746 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
2747 assert(MSInfo && "no spec info for member enum specialization")(static_cast <bool> (MSInfo && "no spec info for member enum specialization"
) ? void (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2747, __extension__ __PRETTY_FUNCTION__))
;
2748 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
2749 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2750 }
2751 } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
2752 if (SA->isFailed()) {
2753 // A static_assert failed. Bail out; instantiating this
2754 // class is probably not meaningful.
2755 Instantiation->setInvalidDecl();
2756 break;
2757 }
2758 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
2759 if (MD->isConstexpr() && !MD->getFriendObjectKind() &&
2760 (MD->isVirtualAsWritten() || Instantiation->getNumBases()))
2761 MightHaveConstexprVirtualFunctions = true;
2762 }
2763
2764 if (NewMember->isInvalidDecl())
2765 Instantiation->setInvalidDecl();
2766 } else {
2767 // FIXME: Eventually, a NULL return will mean that one of the
2768 // instantiations was a semantic disaster, and we'll want to mark the
2769 // declaration invalid.
2770 // For now, we expect to skip some members that we can't yet handle.
2771 }
2772 }
2773
2774 // Finish checking fields.
2775 ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
2776 SourceLocation(), SourceLocation(), ParsedAttributesView());
2777 CheckCompletedCXXClass(nullptr, Instantiation);
2778
2779 // Default arguments are parsed, if not instantiated. We can go instantiate
2780 // default arg exprs for default constructors if necessary now. Unless we're
2781 // parsing a class, in which case wait until that's finished.
2782 if (ParsingClassDepth == 0)
2783 ActOnFinishCXXNonNestedClass();
2784
2785 // Instantiate late parsed attributes, and attach them to their decls.
2786 // See Sema::InstantiateAttrs
2787 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2788 E = LateAttrs.end(); I != E; ++I) {
2789 assert(CurrentInstantiationScope == Instantiator.getStartingScope())(static_cast <bool> (CurrentInstantiationScope == Instantiator
.getStartingScope()) ? void (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2789, __extension__ __PRETTY_FUNCTION__))
;
2790 CurrentInstantiationScope = I->Scope;
2791
2792 // Allow 'this' within late-parsed attributes.
2793 NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
2794 CXXRecordDecl *ThisContext =
2795 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
2796 CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
2797 ND && ND->isCXXInstanceMember());
2798
2799 Attr *NewAttr =
2800 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
2801 if (NewAttr)
2802 I->NewDecl->addAttr(NewAttr);
2803 LocalInstantiationScope::deleteScopes(I->Scope,
2804 Instantiator.getStartingScope());
2805 }
2806 Instantiator.disableLateAttributeInstantiation();
2807 LateAttrs.clear();
2808
2809 ActOnFinishDelayedMemberInitializers(Instantiation);
2810
2811 // FIXME: We should do something similar for explicit instantiations so they
2812 // end up in the right module.
2813 if (TSK == TSK_ImplicitInstantiation) {
2814 Instantiation->setLocation(Pattern->getLocation());
2815 Instantiation->setLocStart(Pattern->getInnerLocStart());
2816 Instantiation->setBraceRange(Pattern->getBraceRange());
2817 }
2818
2819 if (!Instantiation->isInvalidDecl()) {
2820 // Perform any dependent diagnostics from the pattern.
2821 if (Pattern->isDependentContext())
2822 PerformDependentDiagnostics(Pattern, TemplateArgs);
2823
2824 // Instantiate any out-of-line class template partial
2825 // specializations now.
2826 for (TemplateDeclInstantiator::delayed_partial_spec_iterator
2827 P = Instantiator.delayed_partial_spec_begin(),
2828 PEnd = Instantiator.delayed_partial_spec_end();
2829 P != PEnd; ++P) {
2830 if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
2831 P->first, P->second)) {
2832 Instantiation->setInvalidDecl();
2833 break;
2834 }
2835 }
2836
2837 // Instantiate any out-of-line variable template partial
2838 // specializations now.
2839 for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
2840 P = Instantiator.delayed_var_partial_spec_begin(),
2841 PEnd = Instantiator.delayed_var_partial_spec_end();
2842 P != PEnd; ++P) {
2843 if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
2844 P->first, P->second)) {
2845 Instantiation->setInvalidDecl();
2846 break;
2847 }
2848 }
2849 }
2850
2851 // Exit the scope of this instantiation.
2852 SavedContext.pop();
2853
2854 if (!Instantiation->isInvalidDecl()) {
2855 // Always emit the vtable for an explicit instantiation definition
2856 // of a polymorphic class template specialization. Otherwise, eagerly
2857 // instantiate only constexpr virtual functions in preparation for their use
2858 // in constant evaluation.
2859 if (TSK == TSK_ExplicitInstantiationDefinition)
2860 MarkVTableUsed(PointOfInstantiation, Instantiation, true);
2861 else if (MightHaveConstexprVirtualFunctions)
2862 MarkVirtualMembersReferenced(PointOfInstantiation, Instantiation,
2863 /*ConstexprOnly*/ true);
2864 }
2865
2866 Consumer.HandleTagDeclDefinition(Instantiation);
2867
2868 return Instantiation->isInvalidDecl();
2869}
2870
2871/// Instantiate the definition of an enum from a given pattern.
2872///
2873/// \param PointOfInstantiation The point of instantiation within the
2874/// source code.
2875/// \param Instantiation is the declaration whose definition is being
2876/// instantiated. This will be a member enumeration of a class
2877/// temploid specialization, or a local enumeration within a
2878/// function temploid specialization.
2879/// \param Pattern The templated declaration from which the instantiation
2880/// occurs.
2881/// \param TemplateArgs The template arguments to be substituted into
2882/// the pattern.
2883/// \param TSK The kind of implicit or explicit instantiation to perform.
2884///
2885/// \return \c true if an error occurred, \c false otherwise.
2886bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2887 EnumDecl *Instantiation, EnumDecl *Pattern,
2888 const MultiLevelTemplateArgumentList &TemplateArgs,
2889 TemplateSpecializationKind TSK) {
2890 EnumDecl *PatternDef = Pattern->getDefinition();
2891 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2892 Instantiation->getInstantiatedFromMemberEnum(),
2893 Pattern, PatternDef, TSK,/*Complain*/true))
2894 return true;
2895 Pattern = PatternDef;
2896
2897 // Record the point of instantiation.
2898 if (MemberSpecializationInfo *MSInfo
2899 = Instantiation->getMemberSpecializationInfo()) {
2900 MSInfo->setTemplateSpecializationKind(TSK);
2901 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2902 }
2903
2904 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2905 if (Inst.isInvalid())
2906 return true;
2907 if (Inst.isAlreadyInstantiating())
2908 return false;
2909 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
2910 "instantiating enum definition");
2911
2912 // The instantiation is visible here, even if it was first declared in an
2913 // unimported module.
2914 Instantiation->setVisibleDespiteOwningModule();
2915
2916 // Enter the scope of this instantiation. We don't use
2917 // PushDeclContext because we don't have a scope.
2918 ContextRAII SavedContext(*this, Instantiation);
2919 EnterExpressionEvaluationContext EvalContext(
2920 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2921
2922 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2923
2924 // Pull attributes from the pattern onto the instantiation.
2925 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2926
2927 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2928 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2929
2930 // Exit the scope of this instantiation.
2931 SavedContext.pop();
2932
2933 return Instantiation->isInvalidDecl();
2934}
2935
2936
2937/// Instantiate the definition of a field from the given pattern.
2938///
2939/// \param PointOfInstantiation The point of instantiation within the
2940/// source code.
2941/// \param Instantiation is the declaration whose definition is being
2942/// instantiated. This will be a class of a class temploid
2943/// specialization, or a local enumeration within a function temploid
2944/// specialization.
2945/// \param Pattern The templated declaration from which the instantiation
2946/// occurs.
2947/// \param TemplateArgs The template arguments to be substituted into
2948/// the pattern.
2949///
2950/// \return \c true if an error occurred, \c false otherwise.
2951bool Sema::InstantiateInClassInitializer(
2952 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
2953 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
2954 // If there is no initializer, we don't need to do anything.
2955 if (!Pattern->hasInClassInitializer())
2956 return false;
2957
2958 assert(Instantiation->getInClassInitStyle() ==(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
2959 Pattern->getInClassInitStyle() &&(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
2960 "pattern and instantiation disagree about init style")(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
;
2961
2962 // Error out if we haven't parsed the initializer of the pattern yet because
2963 // we are waiting for the closing brace of the outer class.
2964 Expr *OldInit = Pattern->getInClassInitializer();
2965 if (!OldInit) {
2966 RecordDecl *PatternRD = Pattern->getParent();
2967 RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
2968 Diag(PointOfInstantiation,
2969 diag::err_default_member_initializer_not_yet_parsed)
2970 << OutermostClass << Pattern;
2971 Diag(Pattern->getEndLoc(),
2972 diag::note_default_member_initializer_not_yet_parsed);
2973 Instantiation->setInvalidDecl();
2974 return true;
2975 }
2976
2977 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2978 if (Inst.isInvalid())
2979 return true;
2980 if (Inst.isAlreadyInstantiating()) {
2981 // Error out if we hit an instantiation cycle for this initializer.
2982 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
2983 << Instantiation;
2984 return true;
2985 }
2986 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
2987 "instantiating default member init");
2988
2989 // Enter the scope of this instantiation. We don't use PushDeclContext because
2990 // we don't have a scope.
2991 ContextRAII SavedContext(*this, Instantiation->getParent());
2992 EnterExpressionEvaluationContext EvalContext(
2993 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2994
2995 LocalInstantiationScope Scope(*this, true);
2996
2997 // Instantiate the initializer.
2998 ActOnStartCXXInClassMemberInitializer();
2999 CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), Qualifiers());
3000
3001 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
3002 /*CXXDirectInit=*/false);
3003 Expr *Init = NewInit.get();
3004 assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(static_cast <bool> ((!Init || !isa<ParenListExpr>
(Init)) && "call-style init in class") ? void (0) : __assert_fail
("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3004, __extension__ __PRETTY_FUNCTION__))
;
3005 ActOnFinishCXXInClassMemberInitializer(
3006 Instantiation, Init ? Init->getBeginLoc() : SourceLocation(), Init);
3007
3008 if (auto *L = getASTMutationListener())
3009 L->DefaultMemberInitializerInstantiated(Instantiation);
3010
3011 // Return true if the in-class initializer is still missing.
3012 return !Instantiation->getInClassInitializer();
3013}
3014
3015namespace {
3016 /// A partial specialization whose template arguments have matched
3017 /// a given template-id.
3018 struct PartialSpecMatchResult {
3019 ClassTemplatePartialSpecializationDecl *Partial;
3020 TemplateArgumentList *Args;
3021 };
3022}
3023
3024bool Sema::usesPartialOrExplicitSpecialization(
3025 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
3026 if (ClassTemplateSpec->getTemplateSpecializationKind() ==
3027 TSK_ExplicitSpecialization)
3028 return true;
3029
3030 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
3031 ClassTemplateSpec->getSpecializedTemplate()
3032 ->getPartialSpecializations(PartialSpecs);
3033 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3034 TemplateDeductionInfo Info(Loc);
3035 if (!DeduceTemplateArguments(PartialSpecs[I],
3036 ClassTemplateSpec->getTemplateArgs(), Info))
3037 return true;
3038 }
3039
3040 return false;
3041}
3042
3043/// Get the instantiation pattern to use to instantiate the definition of a
3044/// given ClassTemplateSpecializationDecl (either the pattern of the primary
3045/// template or of a partial specialization).
3046static ActionResult<CXXRecordDecl *>
3047getPatternForClassTemplateSpecialization(
3048 Sema &S, SourceLocation PointOfInstantiation,
3049 ClassTemplateSpecializationDecl *ClassTemplateSpec,
3050 TemplateSpecializationKind TSK) {
3051 Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
3052 if (Inst.isInvalid())
3053 return {/*Invalid=*/true};
3054 if (Inst.isAlreadyInstantiating())
3055 return {/*Invalid=*/false};
3056
3057 llvm::PointerUnion<ClassTemplateDecl *,
3058 ClassTemplatePartialSpecializationDecl *>
3059 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
3060 if (!Specialized.is<ClassTemplatePartialSpecializationDecl *>()) {
3061 // Find best matching specialization.
3062 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
3063
3064 // C++ [temp.class.spec.match]p1:
3065 // When a class template is used in a context that requires an
3066 // instantiation of the class, it is necessary to determine
3067 // whether the instantiation is to be generated using the primary
3068 // template or one of the partial specializations. This is done by
3069 // matching the template arguments of the class template
3070 // specialization with the template argument lists of the partial
3071 // specializations.
3072 typedef PartialSpecMatchResult MatchResult;
3073 SmallVector<MatchResult, 4> Matched;
3074 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
3075 Template->getPartialSpecializations(PartialSpecs);
3076 TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
3077 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3078 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
3079 TemplateDeductionInfo Info(FailedCandidates.getLocation());
3080 if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments(
3081 Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
3082 // Store the failed-deduction information for use in diagnostics, later.
3083 // TODO: Actually use the failed-deduction info?
3084 FailedCandidates.addCandidate().set(
3085 DeclAccessPair::make(Template, AS_public), Partial,
3086 MakeDeductionFailureInfo(S.Context, Result, Info));
3087 (void)Result;
3088 } else {
3089 Matched.push_back(PartialSpecMatchResult());
3090 Matched.back().Partial = Partial;
3091 Matched.back().Args = Info.take();
3092 }
3093 }
3094
3095 // If we're dealing with a member template where the template parameters
3096 // have been instantiated, this provides the original template parameters
3097 // from which the member template's parameters were instantiated.
3098
3099 if (Matched.size() >= 1) {
3100 SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
3101 if (Matched.size() == 1) {
3102 // -- If exactly one matching specialization is found, the
3103 // instantiation is generated from that specialization.
3104 // We don't need to do anything for this.
3105 } else {
3106 // -- If more than one matching specialization is found, the
3107 // partial order rules (14.5.4.2) are used to determine
3108 // whether one of the specializations is more specialized
3109 // than the others. If none of the specializations is more
3110 // specialized than all of the other matching
3111 // specializations, then the use of the class template is
3112 // ambiguous and the program is ill-formed.
3113 for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
3114 PEnd = Matched.end();
3115 P != PEnd; ++P) {
3116 if (S.getMoreSpecializedPartialSpecialization(
3117 P->Partial, Best->Partial, PointOfInstantiation) ==
3118 P->Partial)
3119 Best = P;
3120 }
3121
3122 // Determine if the best partial specialization is more specialized than
3123 // the others.
3124 bool Ambiguous = false;
3125 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
3126 PEnd = Matched.end();
3127 P != PEnd; ++P) {
3128 if (P != Best && S.getMoreSpecializedPartialSpecialization(
3129 P->Partial, Best->Partial,
3130 PointOfInstantiation) != Best->Partial) {
3131 Ambiguous = true;
3132 break;
3133 }
3134 }
3135
3136 if (Ambiguous) {
3137 // Partial ordering did not produce a clear winner. Complain.
3138 Inst.Clear();
3139 ClassTemplateSpec->setInvalidDecl();
3140 S.Diag(PointOfInstantiation,
3141 diag::err_partial_spec_ordering_ambiguous)
3142 << ClassTemplateSpec;
3143
3144 // Print the matching partial specializations.
3145 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
3146 PEnd = Matched.end();
3147 P != PEnd; ++P)
3148 S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
3149 << S.getTemplateArgumentBindingsText(
3150 P->Partial->getTemplateParameters(), *P->Args);
3151
3152 return {/*Invalid=*/true};
3153 }
3154 }
3155
3156 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
3157 } else {
3158 // -- If no matches are found, the instantiation is generated
3159 // from the primary template.
3160 }
3161 }
3162
3163 CXXRecordDecl *Pattern = nullptr;
3164 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
3165 if (auto *PartialSpec =
3166 Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
3167 // Instantiate using the best class template partial specialization.
3168 while (PartialSpec->getInstantiatedFromMember()) {
3169 // If we've found an explicit specialization of this class template,
3170 // stop here and use that as the pattern.
3171 if (PartialSpec->isMemberSpecialization())
3172 break;
3173
3174 PartialSpec = PartialSpec->getInstantiatedFromMember();
3175 }
3176 Pattern = PartialSpec;
3177 } else {
3178 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
3179 while (Template->getInstantiatedFromMemberTemplate()) {
3180 // If we've found an explicit specialization of this class template,
3181 // stop here and use that as the pattern.
3182 if (Template->isMemberSpecialization())
3183 break;
3184
3185 Template = Template->getInstantiatedFromMemberTemplate();
3186 }
3187 Pattern = Template->getTemplatedDecl();
3188 }
3189
3190 return Pattern;
3191}
3192
3193bool Sema::InstantiateClassTemplateSpecialization(
3194 SourceLocation PointOfInstantiation,
3195 ClassTemplateSpecializationDecl *ClassTemplateSpec,
3196 TemplateSpecializationKind TSK, bool Complain) {
3197 // Perform the actual instantiation on the canonical declaration.
3198 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
3199 ClassTemplateSpec->getCanonicalDecl());
3200 if (ClassTemplateSpec->isInvalidDecl())
3201 return true;
3202
3203 ActionResult<CXXRecordDecl *> Pattern =
3204 getPatternForClassTemplateSpecialization(*this, PointOfInstantiation,
3205 ClassTemplateSpec, TSK);
3206 if (!Pattern.isUsable())
3207 return Pattern.isInvalid();
3208
3209 return InstantiateClass(
3210 PointOfInstantiation, ClassTemplateSpec, Pattern.get(),
3211 getTemplateInstantiationArgs(ClassTemplateSpec), TSK, Complain);
3212}
3213
3214/// Instantiates the definitions of all of the member
3215/// of the given class, which is an instantiation of a class template
3216/// or a member class of a template.
3217void
3218Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
3219 CXXRecordDecl *Instantiation,
3220 const MultiLevelTemplateArgumentList &TemplateArgs,
3221 TemplateSpecializationKind TSK) {
3222 // FIXME: We need to notify the ASTMutationListener that we did all of these
3223 // things, in case we have an explicit instantiation definition in a PCM, a
3224 // module, or preamble, and the declaration is in an imported AST.
3225 assert((static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3229, __extension__ __PRETTY_FUNCTION__))
3226 (TSK == TSK_ExplicitInstantiationDefinition ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3229, __extension__ __PRETTY_FUNCTION__))
3227 TSK == TSK_ExplicitInstantiationDeclaration ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3229, __extension__ __PRETTY_FUNCTION__))
3228 (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3229, __extension__ __PRETTY_FUNCTION__))
3229 "Unexpected template specialization kind!")(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3229, __extension__ __PRETTY_FUNCTION__))
;
3230 for (auto *D : Instantiation->decls()) {
3231 bool SuppressNew = false;
3232 if (auto *Function = dyn_cast<FunctionDecl>(D)) {
3233 if (FunctionDecl *Pattern =
3234 Function->getInstantiatedFromMemberFunction()) {
3235
3236 if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
3237 continue;
3238
3239 MemberSpecializationInfo *MSInfo =
3240 Function->getMemberSpecializationInfo();
3241 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3241, __extension__ __PRETTY_FUNCTION__))
;
3242 if (MSInfo->getTemplateSpecializationKind()
3243 == TSK_ExplicitSpecialization)
3244 continue;
3245
3246 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
3247 Function,
3248 MSInfo->getTemplateSpecializationKind(),
3249 MSInfo->getPointOfInstantiation(),
3250 SuppressNew) ||
3251 SuppressNew)
3252 continue;
3253
3254 // C++11 [temp.explicit]p8:
3255 // An explicit instantiation definition that names a class template
3256 // specialization explicitly instantiates the class template
3257 // specialization and is only an explicit instantiation definition
3258 // of members whose definition is visible at the point of
3259 // instantiation.
3260 if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
3261 continue;
3262
3263 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
3264
3265 if (Function->isDefined()) {
3266 // Let the ASTConsumer know that this function has been explicitly
3267 // instantiated now, and its linkage might have changed.
3268 Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
3269 } else if (TSK == TSK_ExplicitInstantiationDefinition) {
3270 InstantiateFunctionDefinition(PointOfInstantiation, Function);
3271 } else if (TSK == TSK_ImplicitInstantiation) {
3272 PendingLocalImplicitInstantiations.push_back(
3273 std::make_pair(Function, PointOfInstantiation));
3274 }
3275 }
3276 } else if (auto *Var = dyn_cast<VarDecl>(D)) {
3277 if (isa<VarTemplateSpecializationDecl>(Var))
3278 continue;
3279
3280 if (Var->isStaticDataMember()) {
3281 if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>())
3282 continue;
3283
3284 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
3285 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3285, __extension__ __PRETTY_FUNCTION__))
;
3286 if (MSInfo->getTemplateSpecializationKind()
3287 == TSK_ExplicitSpecialization)
3288 continue;
3289
3290 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
3291 Var,
3292 MSInfo->getTemplateSpecializationKind(),
3293 MSInfo->getPointOfInstantiation(),
3294 SuppressNew) ||
3295 SuppressNew)
3296 continue;
3297
3298 if (TSK == TSK_ExplicitInstantiationDefinition) {
3299 // C++0x [temp.explicit]p8:
3300 // An explicit instantiation definition that names a class template
3301 // specialization explicitly instantiates the class template
3302 // specialization and is only an explicit instantiation definition
3303 // of members whose definition is visible at the point of
3304 // instantiation.
3305 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
3306 continue;
3307
3308 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
3309 InstantiateVariableDefinition(PointOfInstantiation, Var);
3310 } else {
3311 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
3312 }
3313 }
3314 } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
3315 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
3316 continue;
3317
3318 // Always skip the injected-class-name, along with any
3319 // redeclarations of nested classes, since both would cause us
3320 // to try to instantiate the members of a class twice.
3321 // Skip closure types; they'll get instantiated when we instantiate
3322 // the corresponding lambda-expression.
3323 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
3324 Record->isLambda())
3325 continue;
3326
3327 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
3328 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3328, __extension__ __PRETTY_FUNCTION__))
;
3329
3330 if (MSInfo->getTemplateSpecializationKind()
3331 == TSK_ExplicitSpecialization)
3332 continue;
3333
3334 if (Context.getTargetInfo().getTriple().isOSWindows() &&
3335 TSK == TSK_ExplicitInstantiationDeclaration) {
3336 // On Windows, explicit instantiation decl of the outer class doesn't
3337 // affect the inner class. Typically extern template declarations are
3338 // used in combination with dll import/export annotations, but those
3339 // are not propagated from the outer class templates to inner classes.
3340 // Therefore, do not instantiate inner classes on this platform, so
3341 // that users don't end up with undefined symbols during linking.
3342 continue;
3343 }
3344
3345 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
3346 Record,
3347 MSInfo->getTemplateSpecializationKind(),
3348 MSInfo->getPointOfInstantiation(),
3349 SuppressNew) ||
3350 SuppressNew)
3351 continue;
3352
3353 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
3354 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3354, __extension__ __PRETTY_FUNCTION__))
;
3355
3356 if (!Record->getDefinition()) {
3357 if (!Pattern->getDefinition()) {
3358 // C++0x [temp.explicit]p8:
3359 // An explicit instantiation definition that names a class template
3360 // specialization explicitly instantiates the class template
3361 // specialization and is only an explicit instantiation definition
3362 // of members whose definition is visible at the point of
3363 // instantiation.
3364 if (TSK == TSK_ExplicitInstantiationDeclaration) {
3365 MSInfo->setTemplateSpecializationKind(TSK);
3366 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3367 }
3368
3369 continue;
3370 }
3371
3372 InstantiateClass(PointOfInstantiation, Record, Pattern,
3373 TemplateArgs,
3374 TSK);
3375 } else {
3376 if (TSK == TSK_ExplicitInstantiationDefinition &&
3377 Record->getTemplateSpecializationKind() ==
3378 TSK_ExplicitInstantiationDeclaration) {
3379 Record->setTemplateSpecializationKind(TSK);
3380 MarkVTableUsed(PointOfInstantiation, Record, true);
3381 }
3382 }
3383
3384 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
3385 if (Pattern)
3386 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
3387 TSK);
3388 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
3389 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
3390 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3390, __extension__ __PRETTY_FUNCTION__))
;
3391
3392 if (MSInfo->getTemplateSpecializationKind()
3393 == TSK_ExplicitSpecialization)
3394 continue;
3395
3396 if (CheckSpecializationInstantiationRedecl(
3397 PointOfInstantiation, TSK, Enum,
3398 MSInfo->getTemplateSpecializationKind(),
3399 MSInfo->getPointOfInstantiation(), SuppressNew) ||
3400 SuppressNew)
3401 continue;
3402
3403 if (Enum->getDefinition())
3404 continue;
3405
3406 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
3407 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3407, __extension__ __PRETTY_FUNCTION__))
;
3408
3409 if (TSK == TSK_ExplicitInstantiationDefinition) {
3410 if (!Pattern->getDefinition())
3411 continue;
3412
3413 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
3414 } else {
3415 MSInfo->setTemplateSpecializationKind(TSK);
3416 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3417 }
3418 } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
3419 // No need to instantiate in-class initializers during explicit
3420 // instantiation.
3421 if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
3422 CXXRecordDecl *ClassPattern =
3423 Instantiation->getTemplateInstantiationPattern();
3424 DeclContext::lookup_result Lookup =
3425 ClassPattern->lookup(Field->getDeclName());
3426 FieldDecl *Pattern = Lookup.find_first<FieldDecl>();
3427 assert(Pattern)(static_cast <bool> (Pattern) ? void (0) : __assert_fail
("Pattern", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3427, __extension__ __PRETTY_FUNCTION__))
;
3428 InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
3429 TemplateArgs);
3430 }
3431 }
3432 }
3433}
3434
3435/// Instantiate the definitions of all of the members of the
3436/// given class template specialization, which was named as part of an
3437/// explicit instantiation.
3438void
3439Sema::InstantiateClassTemplateSpecializationMembers(
3440 SourceLocation PointOfInstantiation,
3441 ClassTemplateSpecializationDecl *ClassTemplateSpec,
3442 TemplateSpecializationKind TSK) {
3443 // C++0x [temp.explicit]p7:
3444 // An explicit instantiation that names a class template
3445 // specialization is an explicit instantion of the same kind
3446 // (declaration or definition) of each of its members (not
3447 // including members inherited from base classes) that has not
3448 // been previously explicitly specialized in the translation unit
3449 // containing the explicit instantiation, except as described
3450 // below.
3451 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
3452 getTemplateInstantiationArgs(ClassTemplateSpec),
3453 TSK);
3454}
3455
3456StmtResult
3457Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
3458 if (!S)
3459 return S;
3460
3461 TemplateInstantiator Instantiator(*this, TemplateArgs,
3462 SourceLocation(),
3463 DeclarationName());
3464 return Instantiator.TransformStmt(S);
3465}
3466
3467bool Sema::SubstTemplateArguments(
3468 ArrayRef<TemplateArgumentLoc> Args,
3469 const MultiLevelTemplateArgumentList &TemplateArgs,
3470 TemplateArgumentListInfo &Out) {
3471 TemplateInstantiator Instantiator(*this, TemplateArgs,
3472 SourceLocation(),
3473 DeclarationName());
3474 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(),
3475 Out);
3476}
3477
3478ExprResult
3479Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
3480 if (!E)
3481 return E;
3482
3483 TemplateInstantiator Instantiator(*this, TemplateArgs,
3484 SourceLocation(),
3485 DeclarationName());
3486 return Instantiator.TransformExpr(E);
3487}
3488
3489ExprResult Sema::SubstInitializer(Expr *Init,
3490 const MultiLevelTemplateArgumentList &TemplateArgs,
3491 bool CXXDirectInit) {
3492 TemplateInstantiator Instantiator(*this, TemplateArgs,
3493 SourceLocation(),
3494 DeclarationName());
3495 return Instantiator.TransformInitializer(Init, CXXDirectInit);
3496}
3497
3498bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
3499 const MultiLevelTemplateArgumentList &TemplateArgs,
3500 SmallVectorImpl<Expr *> &Outputs) {
3501 if (Exprs.empty())
3502 return false;
3503
3504 TemplateInstantiator Instantiator(*this, TemplateArgs,
3505 SourceLocation(),
3506 DeclarationName());
3507 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
3508 IsCall, Outputs);
3509}
3510
3511NestedNameSpecifierLoc
3512Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
3513 const MultiLevelTemplateArgumentList &TemplateArgs) {
3514 if (!NNS)
3515 return NestedNameSpecifierLoc();
3516
3517 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
3518 DeclarationName());
3519 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
3520}
3521
3522/// Do template substitution on declaration name info.
3523DeclarationNameInfo
3524Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
3525 const MultiLevelTemplateArgumentList &TemplateArgs) {
3526 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
3527 NameInfo.getName());
3528 return Instantiator.TransformDeclarationNameInfo(NameInfo);
3529}
3530
3531TemplateName
3532Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
3533 TemplateName Name, SourceLocation Loc,
3534 const MultiLevelTemplateArgumentList &TemplateArgs) {
3535 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
3536 DeclarationName());
3537 CXXScopeSpec SS;
3538 SS.Adopt(QualifierLoc);
3539 return Instantiator.TransformTemplateName(SS, Name, Loc);
3540}
3541
3542static const Decl *getCanonicalParmVarDecl(const Decl *D) {
3543 // When storing ParmVarDecls in the local instantiation scope, we always
3544 // want to use the ParmVarDecl from the canonical function declaration,
3545 // since the map is then valid for any redeclaration or definition of that
3546 // function.
3547 if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
3548 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
3549 unsigned i = PV->getFunctionScopeIndex();
3550 // This parameter might be from a freestanding function type within the
3551 // function and isn't necessarily referring to one of FD's parameters.
3552 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
3553 return FD->getCanonicalDecl()->getParamDecl(i);
3554 }
3555 }
3556 return D;
3557}
3558
3559
3560llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
3561LocalInstantiationScope::findInstantiationOf(const Decl *D) {
3562 D = getCanonicalParmVarDecl(D);
3563 for (LocalInstantiationScope *Current = this; Current;
3564 Current = Current->Outer) {
3565
3566 // Check if we found something within this scope.
3567 const Decl *CheckD = D;
3568 do {
3569 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
3570 if (Found != Current->LocalDecls.end())
3571 return &Found->second;
3572
3573 // If this is a tag declaration, it's possible that we need to look for
3574 // a previous declaration.
3575 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
3576 CheckD = Tag->getPreviousDecl();
3577 else
3578 CheckD = nullptr;
3579 } while (CheckD);
3580
3581 // If we aren't combined with our outer scope, we're done.
3582 if (!Current->CombineWithOuterScope)
3583 break;
3584 }
3585
3586 // If we're performing a partial substitution during template argument
3587 // deduction, we may not have values for template parameters yet.
3588 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
3589 isa<TemplateTemplateParmDecl>(D))
3590 return nullptr;
3591
3592 // Local types referenced prior to definition may require instantiation.
3593 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
3594 if (RD->isLocalClass())
3595 return nullptr;
3596
3597 // Enumeration types referenced prior to definition may appear as a result of
3598 // error recovery.
3599 if (isa<EnumDecl>(D))
3600 return nullptr;
3601
3602 // Materialized typedefs/type alias for implicit deduction guides may require
3603 // instantiation.
3604 if (isa<TypedefNameDecl>(D) &&
3605 isa<CXXDeductionGuideDecl>(D->getDeclContext()))
3606 return nullptr;
3607
3608 // If we didn't find the decl, then we either have a sema bug, or we have a
3609 // forward reference to a label declaration. Return null to indicate that
3610 // we have an uninstantiated label.
3611 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")(static_cast <bool> (isa<LabelDecl>(D) &&
"declaration not instantiated in this scope") ? void (0) : __assert_fail
("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3611, __extension__ __PRETTY_FUNCTION__))
;
3612 return nullptr;
3613}
3614
3615void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
3616 D = getCanonicalParmVarDecl(D);
3617 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
3618 if (Stored.isNull()) {
3619#ifndef NDEBUG
3620 // It should not be present in any surrounding scope either.
3621 LocalInstantiationScope *Current = this;
3622 while (Current->CombineWithOuterScope && Current->Outer) {
3623 Current = Current->Outer;
3624 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3625, __extension__ __PRETTY_FUNCTION__))
3625 "Instantiated local in inner and outer scopes")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3625, __extension__ __PRETTY_FUNCTION__))
;
3626 }
3627#endif
3628 Stored = Inst;
3629 } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
3630 Pack->push_back(cast<VarDecl>(Inst));
3631 } else {
3632 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")(static_cast <bool> (Stored.get<Decl *>() == Inst
&& "Already instantiated this local") ? void (0) : __assert_fail
("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3632, __extension__ __PRETTY_FUNCTION__))
;
3633 }
3634}
3635
3636void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
3637 VarDecl *Inst) {
3638 D = getCanonicalParmVarDecl(D);
3639 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
3640 Pack->push_back(Inst);
3641}
3642
3643void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
3644#ifndef NDEBUG
3645 // This should be the first time we've been told about this decl.
3646 for (LocalInstantiationScope *Current = this;
3647 Current && Current->CombineWithOuterScope; Current = Current->Outer)
3648 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__))
3649 "Creating local pack after instantiation of local")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3649, __extension__ __PRETTY_FUNCTION__))
;
3650#endif
3651
3652 D = getCanonicalParmVarDecl(D);
3653 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
3654 DeclArgumentPack *Pack = new DeclArgumentPack;
3655 Stored = Pack;
3656 ArgumentPacks.push_back(Pack);
3657}
3658
3659bool LocalInstantiationScope::isLocalPackExpansion(const Decl *D) {
3660 for (DeclArgumentPack *Pack : ArgumentPacks)
3661 if (llvm::is_contained(*Pack, D))
3662 return true;
3663 return false;
3664}
3665
3666void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
3667 const TemplateArgument *ExplicitArgs,
3668 unsigned NumExplicitArgs) {
3669 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3670, __extension__ __PRETTY_FUNCTION__))
3670 "Already have a partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3670, __extension__ __PRETTY_FUNCTION__))
;
3671 assert((!PartiallySubstitutedPack(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3673, __extension__ __PRETTY_FUNCTION__))
3672 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3673, __extension__ __PRETTY_FUNCTION__))
3673 "Wrong number of arguments in partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 3673, __extension__ __PRETTY_FUNCTION__))
;
3674 PartiallySubstitutedPack = Pack;
3675 ArgsInPartiallySubstitutedPack = ExplicitArgs;
3676 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
3677}
3678
3679NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
3680 const TemplateArgument **ExplicitArgs,
3681 unsigned *NumExplicitArgs) const {
3682 if (ExplicitArgs)
3683 *ExplicitArgs = nullptr;
3684 if (NumExplicitArgs)
3685 *NumExplicitArgs = 0;
3686
3687 for (const LocalInstantiationScope *Current = this; Current;
3688 Current = Current->Outer) {
3689 if (Current->PartiallySubstitutedPack) {
3690 if (ExplicitArgs)
3691 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
3692 if (NumExplicitArgs)
3693 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
3694
3695 return Current->PartiallySubstitutedPack;
3696 }
3697
3698 if (!Current->CombineWithOuterScope)
3699 break;
3700 }
3701
3702 return nullptr;
3703}

/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/ASTLambda.h

1//===--- ASTLambda.h - Lambda Helper Functions --------------*- C++ -*-===//
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/// \file
10/// This file provides some common utility functions for processing
11/// Lambda related AST Constructs.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_ASTLAMBDA_H
16#define LLVM_CLANG_AST_ASTLAMBDA_H
17
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclTemplate.h"
20
21namespace clang {
22inline StringRef getLambdaStaticInvokerName() {
23 return "__invoke";
24}
25// This function returns true if M is a specialization, a template,
26// or a non-generic lambda call operator.
27inline bool isLambdaCallOperator(const CXXMethodDecl *MD) {
28 const CXXRecordDecl *LambdaClass = MD->getParent();
29 if (!LambdaClass
6.1
'LambdaClass' is non-null, which participates in a condition later
6.1
'LambdaClass' is non-null, which participates in a condition later
6.1
'LambdaClass' is non-null, which participates in a condition later
|| !LambdaClass->isLambda()) return false;
7
Calling 'CXXRecordDecl::isLambda'
10
Returning from 'CXXRecordDecl::isLambda'
11
Assuming the condition is false
12
Taking false branch
30 return MD->getOverloadedOperator() == OO_Call;
13
Assuming the condition is true
14
Returning the value 1, which participates in a condition later
31}
32
33inline bool isLambdaCallOperator(const DeclContext *DC) {
34 if (!DC || !isa<CXXMethodDecl>(DC)) return false;
35 return isLambdaCallOperator(cast<CXXMethodDecl>(DC));
36}
37
38inline bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD) {
39 if (!MD) return false;
40 const CXXRecordDecl *LambdaClass = MD->getParent();
41 if (LambdaClass && LambdaClass->isGenericLambda())
42 return isLambdaCallOperator(MD) &&
43 MD->isFunctionTemplateSpecialization();
44 return false;
45}
46
47inline bool isLambdaConversionOperator(CXXConversionDecl *C) {
48 return C ? C->getParent()->isLambda() : false;
49}
50
51inline bool isLambdaConversionOperator(Decl *D) {
52 if (!D) return false;
53 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D))
54 return isLambdaConversionOperator(Conv);
55 if (FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(D))
56 if (CXXConversionDecl *Conv =
57 dyn_cast_or_null<CXXConversionDecl>(F->getTemplatedDecl()))
58 return isLambdaConversionOperator(Conv);
59 return false;
60}
61
62inline bool isGenericLambdaCallOperatorSpecialization(DeclContext *DC) {
63 return isGenericLambdaCallOperatorSpecialization(
64 dyn_cast<CXXMethodDecl>(DC));
65}
66
67inline bool isGenericLambdaCallOperatorOrStaticInvokerSpecialization(
68 DeclContext *DC) {
69 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC);
70 if (!MD) return false;
71 const CXXRecordDecl *LambdaClass = MD->getParent();
72 if (LambdaClass && LambdaClass->isGenericLambda())
73 return (isLambdaCallOperator(MD) || MD->isLambdaStaticInvoker()) &&
74 MD->isFunctionTemplateSpecialization();
75 return false;
76}
77
78
79// This returns the parent DeclContext ensuring that the correct
80// parent DeclContext is returned for Lambdas
81inline DeclContext *getLambdaAwareParentOfDeclContext(DeclContext *DC) {
82 if (isLambdaCallOperator(DC))
83 return DC->getParent()->getParent();
84 else
85 return DC->getParent();
86}
87
88} // clang
89
90#endif

/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h

1//===- DeclCXX.h - Classes for representing C++ declarations --*- C++ -*-=====//
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/// \file
10/// Defines the C++ Decl subclasses, other than those for templates
11/// (found in DeclTemplate.h) and friends (in DeclFriend.h).
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_DECLCXX_H
16#define LLVM_CLANG_AST_DECLCXX_H
17
18#include "clang/AST/ASTUnresolvedSet.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclarationName.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExternalASTSource.h"
24#include "clang/AST/LambdaCapture.h"
25#include "clang/AST/NestedNameSpecifier.h"
26#include "clang/AST/Redeclarable.h"
27#include "clang/AST/Stmt.h"
28#include "clang/AST/Type.h"
29#include "clang/AST/TypeLoc.h"
30#include "clang/AST/UnresolvedSet.h"
31#include "clang/Basic/LLVM.h"
32#include "clang/Basic/Lambda.h"
33#include "clang/Basic/LangOptions.h"
34#include "clang/Basic/OperatorKinds.h"
35#include "clang/Basic/SourceLocation.h"
36#include "clang/Basic/Specifiers.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/STLExtras.h"
42#include "llvm/ADT/TinyPtrVector.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/TrailingObjects.h"
48#include <cassert>
49#include <cstddef>
50#include <iterator>
51#include <memory>
52#include <vector>
53
54namespace clang {
55
56class ASTContext;
57class ClassTemplateDecl;
58class ConstructorUsingShadowDecl;
59class CXXBasePath;
60class CXXBasePaths;
61class CXXConstructorDecl;
62class CXXDestructorDecl;
63class CXXFinalOverriderMap;
64class CXXIndirectPrimaryBaseSet;
65class CXXMethodDecl;
66class DecompositionDecl;
67class DiagnosticBuilder;
68class FriendDecl;
69class FunctionTemplateDecl;
70class IdentifierInfo;
71class MemberSpecializationInfo;
72class BaseUsingDecl;
73class TemplateDecl;
74class TemplateParameterList;
75class UsingDecl;
76
77/// Represents an access specifier followed by colon ':'.
78///
79/// An objects of this class represents sugar for the syntactic occurrence
80/// of an access specifier followed by a colon in the list of member
81/// specifiers of a C++ class definition.
82///
83/// Note that they do not represent other uses of access specifiers,
84/// such as those occurring in a list of base specifiers.
85/// Also note that this class has nothing to do with so-called
86/// "access declarations" (C++98 11.3 [class.access.dcl]).
87class AccessSpecDecl : public Decl {
88 /// The location of the ':'.
89 SourceLocation ColonLoc;
90
91 AccessSpecDecl(AccessSpecifier AS, DeclContext *DC,
92 SourceLocation ASLoc, SourceLocation ColonLoc)
93 : Decl(AccessSpec, DC, ASLoc), ColonLoc(ColonLoc) {
94 setAccess(AS);
95 }
96
97 AccessSpecDecl(EmptyShell Empty) : Decl(AccessSpec, Empty) {}
98
99 virtual void anchor();
100
101public:
102 /// The location of the access specifier.
103 SourceLocation getAccessSpecifierLoc() const { return getLocation(); }
104
105 /// Sets the location of the access specifier.
106 void setAccessSpecifierLoc(SourceLocation ASLoc) { setLocation(ASLoc); }
107
108 /// The location of the colon following the access specifier.
109 SourceLocation getColonLoc() const { return ColonLoc; }
110
111 /// Sets the location of the colon.
112 void setColonLoc(SourceLocation CLoc) { ColonLoc = CLoc; }
113
114 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
115 return SourceRange(getAccessSpecifierLoc(), getColonLoc());
116 }
117
118 static AccessSpecDecl *Create(ASTContext &C, AccessSpecifier AS,
119 DeclContext *DC, SourceLocation ASLoc,
120 SourceLocation ColonLoc) {
121 return new (C, DC) AccessSpecDecl(AS, DC, ASLoc, ColonLoc);
122 }
123
124 static AccessSpecDecl *CreateDeserialized(ASTContext &C, unsigned ID);
125
126 // Implement isa/cast/dyncast/etc.
127 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
128 static bool classofKind(Kind K) { return K == AccessSpec; }
129};
130
131/// Represents a base class of a C++ class.
132///
133/// Each CXXBaseSpecifier represents a single, direct base class (or
134/// struct) of a C++ class (or struct). It specifies the type of that
135/// base class, whether it is a virtual or non-virtual base, and what
136/// level of access (public, protected, private) is used for the
137/// derivation. For example:
138///
139/// \code
140/// class A { };
141/// class B { };
142/// class C : public virtual A, protected B { };
143/// \endcode
144///
145/// In this code, C will have two CXXBaseSpecifiers, one for "public
146/// virtual A" and the other for "protected B".
147class CXXBaseSpecifier {
148 /// The source code range that covers the full base
149 /// specifier, including the "virtual" (if present) and access
150 /// specifier (if present).
151 SourceRange Range;
152
153 /// The source location of the ellipsis, if this is a pack
154 /// expansion.
155 SourceLocation EllipsisLoc;
156
157 /// Whether this is a virtual base class or not.
158 unsigned Virtual : 1;
159
160 /// Whether this is the base of a class (true) or of a struct (false).
161 ///
162 /// This determines the mapping from the access specifier as written in the
163 /// source code to the access specifier used for semantic analysis.
164 unsigned BaseOfClass : 1;
165
166 /// Access specifier as written in the source code (may be AS_none).
167 ///
168 /// The actual type of data stored here is an AccessSpecifier, but we use
169 /// "unsigned" here to work around a VC++ bug.
170 unsigned Access : 2;
171
172 /// Whether the class contains a using declaration
173 /// to inherit the named class's constructors.
174 unsigned InheritConstructors : 1;
175
176 /// The type of the base class.
177 ///
178 /// This will be a class or struct (or a typedef of such). The source code
179 /// range does not include the \c virtual or the access specifier.
180 TypeSourceInfo *BaseTypeInfo;
181
182public:
183 CXXBaseSpecifier() = default;
184 CXXBaseSpecifier(SourceRange R, bool V, bool BC, AccessSpecifier A,
185 TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
186 : Range(R), EllipsisLoc(EllipsisLoc), Virtual(V), BaseOfClass(BC),
187 Access(A), InheritConstructors(false), BaseTypeInfo(TInfo) {}
188
189 /// Retrieves the source range that contains the entire base specifier.
190 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
191 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
192 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
193
194 /// Get the location at which the base class type was written.
195 SourceLocation getBaseTypeLoc() const LLVM_READONLY__attribute__((__pure__)) {
196 return BaseTypeInfo->getTypeLoc().getBeginLoc();
197 }
198
199 /// Determines whether the base class is a virtual base class (or not).
200 bool isVirtual() const { return Virtual; }
201
202 /// Determine whether this base class is a base of a class declared
203 /// with the 'class' keyword (vs. one declared with the 'struct' keyword).
204 bool isBaseOfClass() const { return BaseOfClass; }
205
206 /// Determine whether this base specifier is a pack expansion.
207 bool isPackExpansion() const { return EllipsisLoc.isValid(); }
208
209 /// Determine whether this base class's constructors get inherited.
210 bool getInheritConstructors() const { return InheritConstructors; }
211
212 /// Set that this base class's constructors should be inherited.
213 void setInheritConstructors(bool Inherit = true) {
214 InheritConstructors = Inherit;
215 }
216
217 /// For a pack expansion, determine the location of the ellipsis.
218 SourceLocation getEllipsisLoc() const {
219 return EllipsisLoc;
220 }
221
222 /// Returns the access specifier for this base specifier.
223 ///
224 /// This is the actual base specifier as used for semantic analysis, so
225 /// the result can never be AS_none. To retrieve the access specifier as
226 /// written in the source code, use getAccessSpecifierAsWritten().
227 AccessSpecifier getAccessSpecifier() const {
228 if ((AccessSpecifier)Access == AS_none)
229 return BaseOfClass? AS_private : AS_public;
230 else
231 return (AccessSpecifier)Access;
232 }
233
234 /// Retrieves the access specifier as written in the source code
235 /// (which may mean that no access specifier was explicitly written).
236 ///
237 /// Use getAccessSpecifier() to retrieve the access specifier for use in
238 /// semantic analysis.
239 AccessSpecifier getAccessSpecifierAsWritten() const {
240 return (AccessSpecifier)Access;
241 }
242
243 /// Retrieves the type of the base class.
244 ///
245 /// This type will always be an unqualified class type.
246 QualType getType() const {
247 return BaseTypeInfo->getType().getUnqualifiedType();
248 }
249
250 /// Retrieves the type and source location of the base class.
251 TypeSourceInfo *getTypeSourceInfo() const { return BaseTypeInfo; }
252};
253
254/// Represents a C++ struct/union/class.
255class CXXRecordDecl : public RecordDecl {
256 friend class ASTDeclReader;
257 friend class ASTDeclWriter;
258 friend class ASTNodeImporter;
259 friend class ASTReader;
260 friend class ASTRecordWriter;
261 friend class ASTWriter;
262 friend class DeclContext;
263 friend class LambdaExpr;
264
265 friend void FunctionDecl::setPure(bool);
266 friend void TagDecl::startDefinition();
267
268 /// Values used in DefinitionData fields to represent special members.
269 enum SpecialMemberFlags {
270 SMF_DefaultConstructor = 0x1,
271 SMF_CopyConstructor = 0x2,
272 SMF_MoveConstructor = 0x4,
273 SMF_CopyAssignment = 0x8,
274 SMF_MoveAssignment = 0x10,
275 SMF_Destructor = 0x20,
276 SMF_All = 0x3f
277 };
278
279 struct DefinitionData {
280 #define FIELD(Name, Width, Merge) \
281 unsigned Name : Width;
282 #include "CXXRecordDeclDefinitionBits.def"
283
284 /// Whether this class describes a C++ lambda.
285 unsigned IsLambda : 1;
286
287 /// Whether we are currently parsing base specifiers.
288 unsigned IsParsingBaseSpecifiers : 1;
289
290 /// True when visible conversion functions are already computed
291 /// and are available.
292 unsigned ComputedVisibleConversions : 1;
293
294 unsigned HasODRHash : 1;
295
296 /// A hash of parts of the class to help in ODR checking.
297 unsigned ODRHash = 0;
298
299 /// The number of base class specifiers in Bases.
300 unsigned NumBases = 0;
301
302 /// The number of virtual base class specifiers in VBases.
303 unsigned NumVBases = 0;
304
305 /// Base classes of this class.
306 ///
307 /// FIXME: This is wasted space for a union.
308 LazyCXXBaseSpecifiersPtr Bases;
309
310 /// direct and indirect virtual base classes of this class.
311 LazyCXXBaseSpecifiersPtr VBases;
312
313 /// The conversion functions of this C++ class (but not its
314 /// inherited conversion functions).
315 ///
316 /// Each of the entries in this overload set is a CXXConversionDecl.
317 LazyASTUnresolvedSet Conversions;
318
319 /// The conversion functions of this C++ class and all those
320 /// inherited conversion functions that are visible in this class.
321 ///
322 /// Each of the entries in this overload set is a CXXConversionDecl or a
323 /// FunctionTemplateDecl.
324 LazyASTUnresolvedSet VisibleConversions;
325
326 /// The declaration which defines this record.
327 CXXRecordDecl *Definition;
328
329 /// The first friend declaration in this class, or null if there
330 /// aren't any.
331 ///
332 /// This is actually currently stored in reverse order.
333 LazyDeclPtr FirstFriend;
334
335 DefinitionData(CXXRecordDecl *D);
336
337 /// Retrieve the set of direct base classes.
338 CXXBaseSpecifier *getBases() const {
339 if (!Bases.isOffset())
340 return Bases.get(nullptr);
341 return getBasesSlowCase();
342 }
343
344 /// Retrieve the set of virtual base classes.
345 CXXBaseSpecifier *getVBases() const {
346 if (!VBases.isOffset())
347 return VBases.get(nullptr);
348 return getVBasesSlowCase();
349 }
350
351 ArrayRef<CXXBaseSpecifier> bases() const {
352 return llvm::makeArrayRef(getBases(), NumBases);
353 }
354
355 ArrayRef<CXXBaseSpecifier> vbases() const {
356 return llvm::makeArrayRef(getVBases(), NumVBases);
357 }
358
359 private:
360 CXXBaseSpecifier *getBasesSlowCase() const;
361 CXXBaseSpecifier *getVBasesSlowCase() const;
362 };
363
364 struct DefinitionData *DefinitionData;
365
366 /// Describes a C++ closure type (generated by a lambda expression).
367 struct LambdaDefinitionData : public DefinitionData {
368 using Capture = LambdaCapture;
369
370 /// Whether this lambda is known to be dependent, even if its
371 /// context isn't dependent.
372 ///
373 /// A lambda with a non-dependent context can be dependent if it occurs
374 /// within the default argument of a function template, because the
375 /// lambda will have been created with the enclosing context as its
376 /// declaration context, rather than function. This is an unfortunate
377 /// artifact of having to parse the default arguments before.
378 unsigned Dependent : 1;
379
380 /// Whether this lambda is a generic lambda.
381 unsigned IsGenericLambda : 1;
382
383 /// The Default Capture.
384 unsigned CaptureDefault : 2;
385
386 /// The number of captures in this lambda is limited 2^NumCaptures.
387 unsigned NumCaptures : 15;
388
389 /// The number of explicit captures in this lambda.
390 unsigned NumExplicitCaptures : 13;
391
392 /// Has known `internal` linkage.
393 unsigned HasKnownInternalLinkage : 1;
394
395 /// The number used to indicate this lambda expression for name
396 /// mangling in the Itanium C++ ABI.
397 unsigned ManglingNumber : 31;
398
399 /// The declaration that provides context for this lambda, if the
400 /// actual DeclContext does not suffice. This is used for lambdas that
401 /// occur within default arguments of function parameters within the class
402 /// or within a data member initializer.
403 LazyDeclPtr ContextDecl;
404
405 /// The list of captures, both explicit and implicit, for this
406 /// lambda.
407 Capture *Captures = nullptr;
408
409 /// The type of the call method.
410 TypeSourceInfo *MethodTyInfo;
411
412 LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, bool Dependent,
413 bool IsGeneric, LambdaCaptureDefault CaptureDefault)
414 : DefinitionData(D), Dependent(Dependent), IsGenericLambda(IsGeneric),
415 CaptureDefault(CaptureDefault), NumCaptures(0),
416 NumExplicitCaptures(0), HasKnownInternalLinkage(0), ManglingNumber(0),
417 MethodTyInfo(Info) {
418 IsLambda = true;
419
420 // C++1z [expr.prim.lambda]p4:
421 // This class type is not an aggregate type.
422 Aggregate = false;
423 PlainOldData = false;
424 }
425 };
426
427 struct DefinitionData *dataPtr() const {
428 // Complete the redecl chain (if necessary).
429 getMostRecentDecl();
430 return DefinitionData;
431 }
432
433 struct DefinitionData &data() const {
434 auto *DD = dataPtr();
435 assert(DD && "queried property of class with no definition")(static_cast <bool> (DD && "queried property of class with no definition"
) ? void (0) : __assert_fail ("DD && \"queried property of class with no definition\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 435, __extension__ __PRETTY_FUNCTION__))
;
436 return *DD;
437 }
438
439 struct LambdaDefinitionData &getLambdaData() const {
440 // No update required: a merged definition cannot change any lambda
441 // properties.
442 auto *DD = DefinitionData;
443 assert(DD && DD->IsLambda && "queried lambda property of non-lambda class")(static_cast <bool> (DD && DD->IsLambda &&
"queried lambda property of non-lambda class") ? void (0) : __assert_fail
("DD && DD->IsLambda && \"queried lambda property of non-lambda class\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 443, __extension__ __PRETTY_FUNCTION__))
;
444 return static_cast<LambdaDefinitionData&>(*DD);
445 }
446
447 /// The template or declaration that this declaration
448 /// describes or was instantiated from, respectively.
449 ///
450 /// For non-templates, this value will be null. For record
451 /// declarations that describe a class template, this will be a
452 /// pointer to a ClassTemplateDecl. For member
453 /// classes of class template specializations, this will be the
454 /// MemberSpecializationInfo referring to the member class that was
455 /// instantiated or specialized.
456 llvm::PointerUnion<ClassTemplateDecl *, MemberSpecializationInfo *>
457 TemplateOrInstantiation;
458
459 /// Called from setBases and addedMember to notify the class that a
460 /// direct or virtual base class or a member of class type has been added.
461 void addedClassSubobject(CXXRecordDecl *Base);
462
463 /// Notify the class that member has been added.
464 ///
465 /// This routine helps maintain information about the class based on which
466 /// members have been added. It will be invoked by DeclContext::addDecl()
467 /// whenever a member is added to this record.
468 void addedMember(Decl *D);
469
470 void markedVirtualFunctionPure();
471
472 /// Get the head of our list of friend declarations, possibly
473 /// deserializing the friends from an external AST source.
474 FriendDecl *getFirstFriend() const;
475
476 /// Determine whether this class has an empty base class subobject of type X
477 /// or of one of the types that might be at offset 0 within X (per the C++
478 /// "standard layout" rules).
479 bool hasSubobjectAtOffsetZeroOfEmptyBaseType(ASTContext &Ctx,
480 const CXXRecordDecl *X);
481
482protected:
483 CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, DeclContext *DC,
484 SourceLocation StartLoc, SourceLocation IdLoc,
485 IdentifierInfo *Id, CXXRecordDecl *PrevDecl);
486
487public:
488 /// Iterator that traverses the base classes of a class.
489 using base_class_iterator = CXXBaseSpecifier *;
490
491 /// Iterator that traverses the base classes of a class.
492 using base_class_const_iterator = const CXXBaseSpecifier *;
493
494 CXXRecordDecl *getCanonicalDecl() override {
495 return cast<CXXRecordDecl>(RecordDecl::getCanonicalDecl());
496 }
497
498 const CXXRecordDecl *getCanonicalDecl() const {
499 return const_cast<CXXRecordDecl*>(this)->getCanonicalDecl();
500 }
501
502 CXXRecordDecl *getPreviousDecl() {
503 return cast_or_null<CXXRecordDecl>(
504 static_cast<RecordDecl *>(this)->getPreviousDecl());
505 }
506
507 const CXXRecordDecl *getPreviousDecl() const {
508 return const_cast<CXXRecordDecl*>(this)->getPreviousDecl();
509 }
510
511 CXXRecordDecl *getMostRecentDecl() {
512 return cast<CXXRecordDecl>(
513 static_cast<RecordDecl *>(this)->getMostRecentDecl());
514 }
515
516 const CXXRecordDecl *getMostRecentDecl() const {
517 return const_cast<CXXRecordDecl*>(this)->getMostRecentDecl();
518 }
519
520 CXXRecordDecl *getMostRecentNonInjectedDecl() {
521 CXXRecordDecl *Recent =
522 static_cast<CXXRecordDecl *>(this)->getMostRecentDecl();
523 while (Recent->isInjectedClassName()) {
524 // FIXME: Does injected class name need to be in the redeclarations chain?
525 assert(Recent->getPreviousDecl())(static_cast <bool> (Recent->getPreviousDecl()) ? void
(0) : __assert_fail ("Recent->getPreviousDecl()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 525, __extension__ __PRETTY_FUNCTION__))
;
526 Recent = Recent->getPreviousDecl();
527 }
528 return Recent;
529 }
530
531 const CXXRecordDecl *getMostRecentNonInjectedDecl() const {
532 return const_cast<CXXRecordDecl*>(this)->getMostRecentNonInjectedDecl();
533 }
534
535 CXXRecordDecl *getDefinition() const {
536 // We only need an update if we don't already know which
537 // declaration is the definition.
538 auto *DD = DefinitionData ? DefinitionData : dataPtr();
539 return DD ? DD->Definition : nullptr;
540 }
541
542 bool hasDefinition() const { return DefinitionData || dataPtr(); }
543
544 static CXXRecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
545 SourceLocation StartLoc, SourceLocation IdLoc,
546 IdentifierInfo *Id,
547 CXXRecordDecl *PrevDecl = nullptr,
548 bool DelayTypeCreation = false);
549 static CXXRecordDecl *CreateLambda(const ASTContext &C, DeclContext *DC,
550 TypeSourceInfo *Info, SourceLocation Loc,
551 bool DependentLambda, bool IsGeneric,
552 LambdaCaptureDefault CaptureDefault);
553 static CXXRecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
554
555 bool isDynamicClass() const {
556 return data().Polymorphic || data().NumVBases != 0;
557 }
558
559 /// @returns true if class is dynamic or might be dynamic because the
560 /// definition is incomplete of dependent.
561 bool mayBeDynamicClass() const {
562 return !hasDefinition() || isDynamicClass() || hasAnyDependentBases();
563 }
564
565 /// @returns true if class is non dynamic or might be non dynamic because the
566 /// definition is incomplete of dependent.
567 bool mayBeNonDynamicClass() const {
568 return !hasDefinition() || !isDynamicClass() || hasAnyDependentBases();
569 }
570
571 void setIsParsingBaseSpecifiers() { data().IsParsingBaseSpecifiers = true; }
572
573 bool isParsingBaseSpecifiers() const {
574 return data().IsParsingBaseSpecifiers;
575 }
576
577 unsigned getODRHash() const;
578
579 /// Sets the base classes of this struct or class.
580 void setBases(CXXBaseSpecifier const * const *Bases, unsigned NumBases);
581
582 /// Retrieves the number of base classes of this class.
583 unsigned getNumBases() const { return data().NumBases; }
584
585 using base_class_range = llvm::iterator_range<base_class_iterator>;
586 using base_class_const_range =
587 llvm::iterator_range<base_class_const_iterator>;
588
589 base_class_range bases() {
590 return base_class_range(bases_begin(), bases_end());
591 }
592 base_class_const_range bases() const {
593 return base_class_const_range(bases_begin(), bases_end());
594 }
595
596 base_class_iterator bases_begin() { return data().getBases(); }
597 base_class_const_iterator bases_begin() const { return data().getBases(); }
598 base_class_iterator bases_end() { return bases_begin() + data().NumBases; }
599 base_class_const_iterator bases_end() const {
600 return bases_begin() + data().NumBases;
601 }
602
603 /// Retrieves the number of virtual base classes of this class.
604 unsigned getNumVBases() const { return data().NumVBases; }
605
606 base_class_range vbases() {
607 return base_class_range(vbases_begin(), vbases_end());
608 }
609 base_class_const_range vbases() const {
610 return base_class_const_range(vbases_begin(), vbases_end());
611 }
612
613 base_class_iterator vbases_begin() { return data().getVBases(); }
614 base_class_const_iterator vbases_begin() const { return data().getVBases(); }
615 base_class_iterator vbases_end() { return vbases_begin() + data().NumVBases; }
616 base_class_const_iterator vbases_end() const {
617 return vbases_begin() + data().NumVBases;
618 }
619
620 /// Determine whether this class has any dependent base classes which
621 /// are not the current instantiation.
622 bool hasAnyDependentBases() const;
623
624 /// Iterator access to method members. The method iterator visits
625 /// all method members of the class, including non-instance methods,
626 /// special methods, etc.
627 using method_iterator = specific_decl_iterator<CXXMethodDecl>;
628 using method_range =
629 llvm::iterator_range<specific_decl_iterator<CXXMethodDecl>>;
630
631 method_range methods() const {
632 return method_range(method_begin(), method_end());
633 }
634
635 /// Method begin iterator. Iterates in the order the methods
636 /// were declared.
637 method_iterator method_begin() const {
638 return method_iterator(decls_begin());
639 }
640
641 /// Method past-the-end iterator.
642 method_iterator method_end() const {
643 return method_iterator(decls_end());
644 }
645
646 /// Iterator access to constructor members.
647 using ctor_iterator = specific_decl_iterator<CXXConstructorDecl>;
648 using ctor_range =
649 llvm::iterator_range<specific_decl_iterator<CXXConstructorDecl>>;
650
651 ctor_range ctors() const { return ctor_range(ctor_begin(), ctor_end()); }
652
653 ctor_iterator ctor_begin() const {
654 return ctor_iterator(decls_begin());
655 }
656
657 ctor_iterator ctor_end() const {
658 return ctor_iterator(decls_end());
659 }
660
661 /// An iterator over friend declarations. All of these are defined
662 /// in DeclFriend.h.
663 class friend_iterator;
664 using friend_range = llvm::iterator_range<friend_iterator>;
665
666 friend_range friends() const;
667 friend_iterator friend_begin() const;
668 friend_iterator friend_end() const;
669 void pushFriendDecl(FriendDecl *FD);
670
671 /// Determines whether this record has any friends.
672 bool hasFriends() const {
673 return data().FirstFriend.isValid();
674 }
675
676 /// \c true if a defaulted copy constructor for this class would be
677 /// deleted.
678 bool defaultedCopyConstructorIsDeleted() const {
679 assert((!needsOverloadResolutionForCopyConstructor() ||(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 681, __extension__ __PRETTY_FUNCTION__))
680 (data().DeclaredSpecialMembers & SMF_CopyConstructor)) &&(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 681, __extension__ __PRETTY_FUNCTION__))
681 "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 681, __extension__ __PRETTY_FUNCTION__))
;
682 return data().DefaultedCopyConstructorIsDeleted;
683 }
684
685 /// \c true if a defaulted move constructor for this class would be
686 /// deleted.
687 bool defaultedMoveConstructorIsDeleted() const {
688 assert((!needsOverloadResolutionForMoveConstructor() ||(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 690, __extension__ __PRETTY_FUNCTION__))
689 (data().DeclaredSpecialMembers & SMF_MoveConstructor)) &&(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 690, __extension__ __PRETTY_FUNCTION__))
690 "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 690, __extension__ __PRETTY_FUNCTION__))
;
691 return data().DefaultedMoveConstructorIsDeleted;
692 }
693
694 /// \c true if a defaulted destructor for this class would be deleted.
695 bool defaultedDestructorIsDeleted() const {
696 assert((!needsOverloadResolutionForDestructor() ||(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
"this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 698, __extension__ __PRETTY_FUNCTION__))
697 (data().DeclaredSpecialMembers & SMF_Destructor)) &&(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
"this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 698, __extension__ __PRETTY_FUNCTION__))
698 "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
"this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 698, __extension__ __PRETTY_FUNCTION__))
;
699 return data().DefaultedDestructorIsDeleted;
700 }
701
702 /// \c true if we know for sure that this class has a single,
703 /// accessible, unambiguous copy constructor that is not deleted.
704 bool hasSimpleCopyConstructor() const {
705 return !hasUserDeclaredCopyConstructor() &&
706 !data().DefaultedCopyConstructorIsDeleted;
707 }
708
709 /// \c true if we know for sure that this class has a single,
710 /// accessible, unambiguous move constructor that is not deleted.
711 bool hasSimpleMoveConstructor() const {
712 return !hasUserDeclaredMoveConstructor() && hasMoveConstructor() &&
713 !data().DefaultedMoveConstructorIsDeleted;
714 }
715
716 /// \c true if we know for sure that this class has a single,
717 /// accessible, unambiguous copy assignment operator that is not deleted.
718 bool hasSimpleCopyAssignment() const {
719 return !hasUserDeclaredCopyAssignment() &&
720 !data().DefaultedCopyAssignmentIsDeleted;
721 }
722
723 /// \c true if we know for sure that this class has a single,
724 /// accessible, unambiguous move assignment operator that is not deleted.
725 bool hasSimpleMoveAssignment() const {
726 return !hasUserDeclaredMoveAssignment() && hasMoveAssignment() &&
727 !data().DefaultedMoveAssignmentIsDeleted;
728 }
729
730 /// \c true if we know for sure that this class has an accessible
731 /// destructor that is not deleted.
732 bool hasSimpleDestructor() const {
733 return !hasUserDeclaredDestructor() &&
734 !data().DefaultedDestructorIsDeleted;
735 }
736
737 /// Determine whether this class has any default constructors.
738 bool hasDefaultConstructor() const {
739 return (data().DeclaredSpecialMembers & SMF_DefaultConstructor) ||
740 needsImplicitDefaultConstructor();
741 }
742
743 /// Determine if we need to declare a default constructor for
744 /// this class.
745 ///
746 /// This value is used for lazy creation of default constructors.
747 bool needsImplicitDefaultConstructor() const {
748 return (!data().UserDeclaredConstructor &&
749 !(data().DeclaredSpecialMembers & SMF_DefaultConstructor) &&
750 (!isLambda() || lambdaIsDefaultConstructibleAndAssignable())) ||
751 // FIXME: Proposed fix to core wording issue: if a class inherits
752 // a default constructor and doesn't explicitly declare one, one
753 // is declared implicitly.
754 (data().HasInheritedDefaultConstructor &&
755 !(data().DeclaredSpecialMembers & SMF_DefaultConstructor));
756 }
757
758 /// Determine whether this class has any user-declared constructors.
759 ///
760 /// When true, a default constructor will not be implicitly declared.
761 bool hasUserDeclaredConstructor() const {
762 return data().UserDeclaredConstructor;
763 }
764
765 /// Whether this class has a user-provided default constructor
766 /// per C++11.
767 bool hasUserProvidedDefaultConstructor() const {
768 return data().UserProvidedDefaultConstructor;
769 }
770
771 /// Determine whether this class has a user-declared copy constructor.
772 ///
773 /// When false, a copy constructor will be implicitly declared.
774 bool hasUserDeclaredCopyConstructor() const {
775 return data().UserDeclaredSpecialMembers & SMF_CopyConstructor;
776 }
777
778 /// Determine whether this class needs an implicit copy
779 /// constructor to be lazily declared.
780 bool needsImplicitCopyConstructor() const {
781 return !(data().DeclaredSpecialMembers & SMF_CopyConstructor);
782 }
783
784 /// Determine whether we need to eagerly declare a defaulted copy
785 /// constructor for this class.
786 bool needsOverloadResolutionForCopyConstructor() const {
787 // C++17 [class.copy.ctor]p6:
788 // If the class definition declares a move constructor or move assignment
789 // operator, the implicitly declared copy constructor is defined as
790 // deleted.
791 // In MSVC mode, sometimes a declared move assignment does not delete an
792 // implicit copy constructor, so defer this choice to Sema.
793 if (data().UserDeclaredSpecialMembers &
794 (SMF_MoveConstructor | SMF_MoveAssignment))
795 return true;
796 return data().NeedOverloadResolutionForCopyConstructor;
797 }
798
799 /// Determine whether an implicit copy constructor for this type
800 /// would have a parameter with a const-qualified reference type.
801 bool implicitCopyConstructorHasConstParam() const {
802 return data().ImplicitCopyConstructorCanHaveConstParamForNonVBase &&
803 (isAbstract() ||
804 data().ImplicitCopyConstructorCanHaveConstParamForVBase);
805 }
806
807 /// Determine whether this class has a copy constructor with
808 /// a parameter type which is a reference to a const-qualified type.
809 bool hasCopyConstructorWithConstParam() const {
810 return data().HasDeclaredCopyConstructorWithConstParam ||
811 (needsImplicitCopyConstructor() &&
812 implicitCopyConstructorHasConstParam());
813 }
814
815 /// Whether this class has a user-declared move constructor or
816 /// assignment operator.
817 ///
818 /// When false, a move constructor and assignment operator may be
819 /// implicitly declared.
820 bool hasUserDeclaredMoveOperation() const {
821 return data().UserDeclaredSpecialMembers &
822 (SMF_MoveConstructor | SMF_MoveAssignment);
823 }
824
825 /// Determine whether this class has had a move constructor
826 /// declared by the user.
827 bool hasUserDeclaredMoveConstructor() const {
828 return data().UserDeclaredSpecialMembers & SMF_MoveConstructor;
829 }
830
831 /// Determine whether this class has a move constructor.
832 bool hasMoveConstructor() const {
833 return (data().DeclaredSpecialMembers & SMF_MoveConstructor) ||
834 needsImplicitMoveConstructor();
835 }
836
837 /// Set that we attempted to declare an implicit copy
838 /// constructor, but overload resolution failed so we deleted it.
839 void setImplicitCopyConstructorIsDeleted() {
840 assert((data().DefaultedCopyConstructorIsDeleted ||(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
|| needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 842, __extension__ __PRETTY_FUNCTION__))
841 needsOverloadResolutionForCopyConstructor()) &&(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
|| needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 842, __extension__ __PRETTY_FUNCTION__))
842 "Copy constructor should not be deleted")(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
|| needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 842, __extension__ __PRETTY_FUNCTION__))
;
843 data().DefaultedCopyConstructorIsDeleted = true;
844 }
845
846 /// Set that we attempted to declare an implicit move
847 /// constructor, but overload resolution failed so we deleted it.
848 void setImplicitMoveConstructorIsDeleted() {
849 assert((data().DefaultedMoveConstructorIsDeleted ||(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
|| needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 851, __extension__ __PRETTY_FUNCTION__))
850 needsOverloadResolutionForMoveConstructor()) &&(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
|| needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 851, __extension__ __PRETTY_FUNCTION__))
851 "move constructor should not be deleted")(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
|| needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 851, __extension__ __PRETTY_FUNCTION__))
;
852 data().DefaultedMoveConstructorIsDeleted = true;
853 }
854
855 /// Set that we attempted to declare an implicit destructor,
856 /// but overload resolution failed so we deleted it.
857 void setImplicitDestructorIsDeleted() {
858 assert((data().DefaultedDestructorIsDeleted ||(static_cast <bool> ((data().DefaultedDestructorIsDeleted
|| needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 860, __extension__ __PRETTY_FUNCTION__))
859 needsOverloadResolutionForDestructor()) &&(static_cast <bool> ((data().DefaultedDestructorIsDeleted
|| needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 860, __extension__ __PRETTY_FUNCTION__))
860 "destructor should not be deleted")(static_cast <bool> ((data().DefaultedDestructorIsDeleted
|| needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 860, __extension__ __PRETTY_FUNCTION__))
;
861 data().DefaultedDestructorIsDeleted = true;
862 }
863
864 /// Determine whether this class should get an implicit move
865 /// constructor or if any existing special member function inhibits this.
866 bool needsImplicitMoveConstructor() const {
867 return !(data().DeclaredSpecialMembers & SMF_MoveConstructor) &&
868 !hasUserDeclaredCopyConstructor() &&
869 !hasUserDeclaredCopyAssignment() &&
870 !hasUserDeclaredMoveAssignment() &&
871 !hasUserDeclaredDestructor();
872 }
873
874 /// Determine whether we need to eagerly declare a defaulted move
875 /// constructor for this class.
876 bool needsOverloadResolutionForMoveConstructor() const {
877 return data().NeedOverloadResolutionForMoveConstructor;
878 }
879
880 /// Determine whether this class has a user-declared copy assignment
881 /// operator.
882 ///
883 /// When false, a copy assignment operator will be implicitly declared.
884 bool hasUserDeclaredCopyAssignment() const {
885 return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
886 }
887
888 /// Set that we attempted to declare an implicit copy assignment
889 /// operator, but overload resolution failed so we deleted it.
890 void setImplicitCopyAssignmentIsDeleted() {
891 assert((data().DefaultedCopyAssignmentIsDeleted ||(static_cast <bool> ((data().DefaultedCopyAssignmentIsDeleted
|| needsOverloadResolutionForCopyAssignment()) && "copy assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyAssignmentIsDeleted || needsOverloadResolutionForCopyAssignment()) && \"copy assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__))
892 needsOverloadResolutionForCopyAssignment()) &&(static_cast <bool> ((data().DefaultedCopyAssignmentIsDeleted
|| needsOverloadResolutionForCopyAssignment()) && "copy assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyAssignmentIsDeleted || needsOverloadResolutionForCopyAssignment()) && \"copy assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__))
893 "copy assignment should not be deleted")(static_cast <bool> ((data().DefaultedCopyAssignmentIsDeleted
|| needsOverloadResolutionForCopyAssignment()) && "copy assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyAssignmentIsDeleted || needsOverloadResolutionForCopyAssignment()) && \"copy assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__))
;
894 data().DefaultedCopyAssignmentIsDeleted = true;
895 }
896
897 /// Determine whether this class needs an implicit copy
898 /// assignment operator to be lazily declared.
899 bool needsImplicitCopyAssignment() const {
900 return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);
901 }
902
903 /// Determine whether we need to eagerly declare a defaulted copy
904 /// assignment operator for this class.
905 bool needsOverloadResolutionForCopyAssignment() const {
906 // C++20 [class.copy.assign]p2:
907 // If the class definition declares a move constructor or move assignment
908 // operator, the implicitly declared copy assignment operator is defined
909 // as deleted.
910 // In MSVC mode, sometimes a declared move constructor does not delete an
911 // implicit copy assignment, so defer this choice to Sema.
912 if (data().UserDeclaredSpecialMembers &
913 (SMF_MoveConstructor | SMF_MoveAssignment))
914 return true;
915 return data().NeedOverloadResolutionForCopyAssignment;
916 }
917
918 /// Determine whether an implicit copy assignment operator for this
919 /// type would have a parameter with a const-qualified reference type.
920 bool implicitCopyAssignmentHasConstParam() const {
921 return data().ImplicitCopyAssignmentHasConstParam;
922 }
923
924 /// Determine whether this class has a copy assignment operator with
925 /// a parameter type which is a reference to a const-qualified type or is not
926 /// a reference.
927 bool hasCopyAssignmentWithConstParam() const {
928 return data().HasDeclaredCopyAssignmentWithConstParam ||
929 (needsImplicitCopyAssignment() &&
930 implicitCopyAssignmentHasConstParam());
931 }
932
933 /// Determine whether this class has had a move assignment
934 /// declared by the user.
935 bool hasUserDeclaredMoveAssignment() const {
936 return data().UserDeclaredSpecialMembers & SMF_MoveAssignment;
937 }
938
939 /// Determine whether this class has a move assignment operator.
940 bool hasMoveAssignment() const {
941 return (data().DeclaredSpecialMembers & SMF_MoveAssignment) ||
942 needsImplicitMoveAssignment();
943 }
944
945 /// Set that we attempted to declare an implicit move assignment
946 /// operator, but overload resolution failed so we deleted it.
947 void setImplicitMoveAssignmentIsDeleted() {
948 assert((data().DefaultedMoveAssignmentIsDeleted ||(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
|| needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 950, __extension__ __PRETTY_FUNCTION__))
949 needsOverloadResolutionForMoveAssignment()) &&(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
|| needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 950, __extension__ __PRETTY_FUNCTION__))
950 "move assignment should not be deleted")(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
|| needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 950, __extension__ __PRETTY_FUNCTION__))
;
951 data().DefaultedMoveAssignmentIsDeleted = true;
952 }
953
954 /// Determine whether this class should get an implicit move
955 /// assignment operator or if any existing special member function inhibits
956 /// this.
957 bool needsImplicitMoveAssignment() const {
958 return !(data().DeclaredSpecialMembers & SMF_MoveAssignment) &&
959 !hasUserDeclaredCopyConstructor() &&
960 !hasUserDeclaredCopyAssignment() &&
961 !hasUserDeclaredMoveConstructor() &&
962 !hasUserDeclaredDestructor() &&
963 (!isLambda() || lambdaIsDefaultConstructibleAndAssignable());
964 }
965
966 /// Determine whether we need to eagerly declare a move assignment
967 /// operator for this class.
968 bool needsOverloadResolutionForMoveAssignment() const {
969 return data().NeedOverloadResolutionForMoveAssignment;
970 }
971
972 /// Determine whether this class has a user-declared destructor.
973 ///
974 /// When false, a destructor will be implicitly declared.
975 bool hasUserDeclaredDestructor() const {
976 return data().UserDeclaredSpecialMembers & SMF_Destructor;
977 }
978
979 /// Determine whether this class needs an implicit destructor to
980 /// be lazily declared.
981 bool needsImplicitDestructor() const {
982 return !(data().DeclaredSpecialMembers & SMF_Destructor);
983 }
984
985 /// Determine whether we need to eagerly declare a destructor for this
986 /// class.
987 bool needsOverloadResolutionForDestructor() const {
988 return data().NeedOverloadResolutionForDestructor;
989 }
990
991 /// Determine whether this class describes a lambda function object.
992 bool isLambda() const {
993 // An update record can't turn a non-lambda into a lambda.
994 auto *DD = DefinitionData;
995 return DD && DD->IsLambda;
8
Assuming 'DD' is non-null
9
Returning value, which participates in a condition later
996 }
997
998 /// Determine whether this class describes a generic
999 /// lambda function object (i.e. function call operator is
1000 /// a template).
1001 bool isGenericLambda() const;
1002
1003 /// Determine whether this lambda should have an implicit default constructor
1004 /// and copy and move assignment operators.
1005 bool lambdaIsDefaultConstructibleAndAssignable() const;
1006
1007 /// Retrieve the lambda call operator of the closure type
1008 /// if this is a closure type.
1009 CXXMethodDecl *getLambdaCallOperator() const;
1010
1011 /// Retrieve the dependent lambda call operator of the closure type
1012 /// if this is a templated closure type.
1013 FunctionTemplateDecl *getDependentLambdaCallOperator() const;
1014
1015 /// Retrieve the lambda static invoker, the address of which
1016 /// is returned by the conversion operator, and the body of which
1017 /// is forwarded to the lambda call operator. The version that does not
1018 /// take a calling convention uses the 'default' calling convention for free
1019 /// functions if the Lambda's calling convention was not modified via
1020 /// attribute. Otherwise, it will return the calling convention specified for
1021 /// the lambda.
1022 CXXMethodDecl *getLambdaStaticInvoker() const;
1023 CXXMethodDecl *getLambdaStaticInvoker(CallingConv CC) const;
1024
1025 /// Retrieve the generic lambda's template parameter list.
1026 /// Returns null if the class does not represent a lambda or a generic
1027 /// lambda.
1028 TemplateParameterList *getGenericLambdaTemplateParameterList() const;
1029
1030 /// Retrieve the lambda template parameters that were specified explicitly.
1031 ArrayRef<NamedDecl *> getLambdaExplicitTemplateParameters() const;
1032
1033 LambdaCaptureDefault getLambdaCaptureDefault() const {
1034 assert(isLambda())(static_cast <bool> (isLambda()) ? void (0) : __assert_fail
("isLambda()", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 1034, __extension__ __PRETTY_FUNCTION__))
;
1035 return static_cast<LambdaCaptureDefault>(getLambdaData().CaptureDefault);
1036 }
1037
1038 /// Set the captures for this lambda closure type.
1039 void setCaptures(ASTContext &Context, ArrayRef<LambdaCapture> Captures);
1040
1041 /// For a closure type, retrieve the mapping from captured
1042 /// variables and \c this to the non-static data members that store the
1043 /// values or references of the captures.
1044 ///
1045 /// \param Captures Will be populated with the mapping from captured
1046 /// variables to the corresponding fields.
1047 ///
1048 /// \param ThisCapture Will be set to the field declaration for the
1049 /// \c this capture.
1050 ///
1051 /// \note No entries will be added for init-captures, as they do not capture
1052 /// variables.
1053 void getCaptureFields(llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
1054 FieldDecl *&ThisCapture) const;
1055
1056 using capture_const_iterator = const LambdaCapture *;
1057 using capture_const_range = llvm::iterator_range<capture_const_iterator>;
1058
1059 capture_const_range captures() const {
1060 return capture_const_range(captures_begin(), captures_end());
1061 }
1062
1063 capture_const_iterator captures_begin() const {
1064 return isLambda() ? getLambdaData().Captures : nullptr;
1065 }
1066
1067 capture_const_iterator captures_end() const {
1068 return isLambda() ? captures_begin() + getLambdaData().NumCaptures
1069 : nullptr;
1070 }
1071
1072 unsigned capture_size() const { return getLambdaData().NumCaptures; }
1073
1074 using conversion_iterator = UnresolvedSetIterator;
1075
1076 conversion_iterator conversion_begin() const {
1077 return data().Conversions.get(getASTContext()).begin();
1078 }
1079
1080 conversion_iterator conversion_end() const {
1081 return data().Conversions.get(getASTContext()).end();
1082 }
1083
1084 /// Removes a conversion function from this class. The conversion
1085 /// function must currently be a member of this class. Furthermore,
1086 /// this class must currently be in the process of being defined.
1087 void removeConversion(const NamedDecl *Old);
1088
1089 /// Get all conversion functions visible in current class,
1090 /// including conversion function templates.
1091 llvm::iterator_range<conversion_iterator>
1092 getVisibleConversionFunctions() const;
1093
1094 /// Determine whether this class is an aggregate (C++ [dcl.init.aggr]),
1095 /// which is a class with no user-declared constructors, no private
1096 /// or protected non-static data members, no base classes, and no virtual
1097 /// functions (C++ [dcl.init.aggr]p1).
1098 bool isAggregate() const { return data().Aggregate; }
1099
1100 /// Whether this class has any in-class initializers
1101 /// for non-static data members (including those in anonymous unions or
1102 /// structs).
1103 bool hasInClassInitializer() const { return data().HasInClassInitializer; }
1104
1105 /// Whether this class or any of its subobjects has any members of
1106 /// reference type which would make value-initialization ill-formed.
1107 ///
1108 /// Per C++03 [dcl.init]p5:
1109 /// - if T is a non-union class type without a user-declared constructor,
1110 /// then every non-static data member and base-class component of T is
1111 /// value-initialized [...] A program that calls for [...]
1112 /// value-initialization of an entity of reference type is ill-formed.
1113 bool hasUninitializedReferenceMember() const {
1114 return !isUnion() && !hasUserDeclaredConstructor() &&
1115 data().HasUninitializedReferenceMember;
1116 }
1117
1118 /// Whether this class is a POD-type (C++ [class]p4)
1119 ///
1120 /// For purposes of this function a class is POD if it is an aggregate
1121 /// that has no non-static non-POD data members, no reference data
1122 /// members, no user-defined copy assignment operator and no
1123 /// user-defined destructor.
1124 ///
1125 /// Note that this is the C++ TR1 definition of POD.
1126 bool isPOD() const { return data().PlainOldData; }
1127
1128 /// True if this class is C-like, without C++-specific features, e.g.
1129 /// it contains only public fields, no bases, tag kind is not 'class', etc.
1130 bool isCLike() const;
1131
1132 /// Determine whether this is an empty class in the sense of
1133 /// (C++11 [meta.unary.prop]).
1134 ///
1135 /// The CXXRecordDecl is a class type, but not a union type,
1136 /// with no non-static data members other than bit-fields of length 0,
1137 /// no virtual member functions, no virtual base classes,
1138 /// and no base class B for which is_empty<B>::value is false.
1139 ///
1140 /// \note This does NOT include a check for union-ness.
1141 bool isEmpty() const { return data().Empty; }
1142
1143 bool hasPrivateFields() const {
1144 return data().HasPrivateFields;
1145 }
1146
1147 bool hasProtectedFields() const {
1148 return data().HasProtectedFields;
1149 }
1150
1151 /// Determine whether this class has direct non-static data members.
1152 bool hasDirectFields() const {
1153 auto &D = data();
1154 return D.HasPublicFields || D.HasProtectedFields || D.HasPrivateFields;
1155 }
1156
1157 /// Whether this class is polymorphic (C++ [class.virtual]),
1158 /// which means that the class contains or inherits a virtual function.
1159 bool isPolymorphic() const { return data().Polymorphic; }
1160
1161 /// Determine whether this class has a pure virtual function.
1162 ///
1163 /// The class is is abstract per (C++ [class.abstract]p2) if it declares
1164 /// a pure virtual function or inherits a pure virtual function that is
1165 /// not overridden.
1166 bool isAbstract() const { return data().Abstract; }
1167
1168 /// Determine whether this class is standard-layout per
1169 /// C++ [class]p7.
1170 bool isStandardLayout() const { return data().IsStandardLayout; }
1171
1172 /// Determine whether this class was standard-layout per
1173 /// C++11 [class]p7, specifically using the C++11 rules without any DRs.
1174 bool isCXX11StandardLayout() const { return data().IsCXX11StandardLayout; }
1175
1176 /// Determine whether this class, or any of its class subobjects,
1177 /// contains a mutable field.
1178 bool hasMutableFields() const { return data().HasMutableFields; }
1179
1180 /// Determine whether this class has any variant members.
1181 bool hasVariantMembers() const { return data().HasVariantMembers; }
1182
1183 /// Determine whether this class has a trivial default constructor
1184 /// (C++11 [class.ctor]p5).
1185 bool hasTrivialDefaultConstructor() const {
1186 return hasDefaultConstructor() &&
1187 (data().HasTrivialSpecialMembers & SMF_DefaultConstructor);
1188 }
1189
1190 /// Determine whether this class has a non-trivial default constructor
1191 /// (C++11 [class.ctor]p5).
1192 bool hasNonTrivialDefaultConstructor() const {
1193 return (data().DeclaredNonTrivialSpecialMembers & SMF_DefaultConstructor) ||
1194 (needsImplicitDefaultConstructor() &&
1195 !(data().HasTrivialSpecialMembers & SMF_DefaultConstructor));
1196 }
1197
1198 /// Determine whether this class has at least one constexpr constructor
1199 /// other than the copy or move constructors.
1200 bool hasConstexprNonCopyMoveConstructor() const {
1201 return data().HasConstexprNonCopyMoveConstructor ||
1202 (needsImplicitDefaultConstructor() &&
1203 defaultedDefaultConstructorIsConstexpr());
1204 }
1205
1206 /// Determine whether a defaulted default constructor for this class
1207 /// would be constexpr.
1208 bool defaultedDefaultConstructorIsConstexpr() const {
1209 return data().DefaultedDefaultConstructorIsConstexpr &&
1210 (!isUnion() || hasInClassInitializer() || !hasVariantMembers() ||
1211 getLangOpts().CPlusPlus20);
1212 }
1213
1214 /// Determine whether this class has a constexpr default constructor.
1215 bool hasConstexprDefaultConstructor() const {
1216 return data().HasConstexprDefaultConstructor ||
1217 (needsImplicitDefaultConstructor() &&
1218 defaultedDefaultConstructorIsConstexpr());
1219 }
1220
1221 /// Determine whether this class has a trivial copy constructor
1222 /// (C++ [class.copy]p6, C++11 [class.copy]p12)
1223 bool hasTrivialCopyConstructor() const {
1224 return data().HasTrivialSpecialMembers & SMF_CopyConstructor;
1225 }
1226
1227 bool hasTrivialCopyConstructorForCall() const {
1228 return data().HasTrivialSpecialMembersForCall & SMF_CopyConstructor;
1229 }
1230
1231 /// Determine whether this class has a non-trivial copy constructor
1232 /// (C++ [class.copy]p6, C++11 [class.copy]p12)
1233 bool hasNonTrivialCopyConstructor() const {
1234 return data().DeclaredNonTrivialSpecialMembers & SMF_CopyConstructor ||
1235 !hasTrivialCopyConstructor();
1236 }
1237
1238 bool hasNonTrivialCopyConstructorForCall() const {
1239 return (data().DeclaredNonTrivialSpecialMembersForCall &
1240 SMF_CopyConstructor) ||
1241 !hasTrivialCopyConstructorForCall();
1242 }
1243
1244 /// Determine whether this class has a trivial move constructor
1245 /// (C++11 [class.copy]p12)
1246 bool hasTrivialMoveConstructor() const {
1247 return hasMoveConstructor() &&
1248 (data().HasTrivialSpecialMembers & SMF_MoveConstructor);
1249 }
1250
1251 bool hasTrivialMoveConstructorForCall() const {
1252 return hasMoveConstructor() &&
1253 (data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor);
1254 }
1255
1256 /// Determine whether this class has a non-trivial move constructor
1257 /// (C++11 [class.copy]p12)
1258 bool hasNonTrivialMoveConstructor() const {
1259 return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveConstructor) ||
1260 (needsImplicitMoveConstructor() &&
1261 !(data().HasTrivialSpecialMembers & SMF_MoveConstructor));
1262 }
1263
1264 bool hasNonTrivialMoveConstructorForCall() const {
1265 return (data().DeclaredNonTrivialSpecialMembersForCall &
1266 SMF_MoveConstructor) ||
1267 (needsImplicitMoveConstructor() &&
1268 !(data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor));
1269 }
1270
1271 /// Determine whether this class has a trivial copy assignment operator
1272 /// (C++ [class.copy]p11, C++11 [class.copy]p25)
1273 bool hasTrivialCopyAssignment() const {
1274 return data().HasTrivialSpecialMembers & SMF_CopyAssignment;
1275 }
1276
1277 /// Determine whether this class has a non-trivial copy assignment
1278 /// operator (C++ [class.copy]p11, C++11 [class.copy]p25)
1279 bool hasNonTrivialCopyAssignment() const {
1280 return data().DeclaredNonTrivialSpecialMembers & SMF_CopyAssignment ||
1281 !hasTrivialCopyAssignment();
1282 }
1283
1284 /// Determine whether this class has a trivial move assignment operator
1285 /// (C++11 [class.copy]p25)
1286 bool hasTrivialMoveAssignment() const {
1287 return hasMoveAssignment() &&
1288 (data().HasTrivialSpecialMembers & SMF_MoveAssignment);
1289 }
1290
1291 /// Determine whether this class has a non-trivial move assignment
1292 /// operator (C++11 [class.copy]p25)
1293 bool hasNonTrivialMoveAssignment() const {
1294 return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveAssignment) ||
1295 (needsImplicitMoveAssignment() &&
1296 !(data().HasTrivialSpecialMembers & SMF_MoveAssignment));
1297 }
1298
1299 /// Determine whether a defaulted default constructor for this class
1300 /// would be constexpr.
1301 bool defaultedDestructorIsConstexpr() const {
1302 return data().DefaultedDestructorIsConstexpr &&
1303 getLangOpts().CPlusPlus20;
1304 }
1305
1306 /// Determine whether this class has a constexpr destructor.
1307 bool hasConstexprDestructor() const;
1308
1309 /// Determine whether this class has a trivial destructor
1310 /// (C++ [class.dtor]p3)
1311 bool hasTrivialDestructor() const {
1312 return data().HasTrivialSpecialMembers & SMF_Destructor;
1313 }
1314
1315 bool hasTrivialDestructorForCall() const {
1316 return data().HasTrivialSpecialMembersForCall & SMF_Destructor;
1317 }
1318
1319 /// Determine whether this class has a non-trivial destructor
1320 /// (C++ [class.dtor]p3)
1321 bool hasNonTrivialDestructor() const {
1322 return !(data().HasTrivialSpecialMembers & SMF_Destructor);
1323 }
1324
1325 bool hasNonTrivialDestructorForCall() const {
1326 return !(data().HasTrivialSpecialMembersForCall & SMF_Destructor);
1327 }
1328
1329 void setHasTrivialSpecialMemberForCall() {
1330 data().HasTrivialSpecialMembersForCall =
1331 (SMF_CopyConstructor | SMF_MoveConstructor | SMF_Destructor);
1332 }
1333
1334 /// Determine whether declaring a const variable with this type is ok
1335 /// per core issue 253.
1336 bool allowConstDefaultInit() const {
1337 return !data().HasUninitializedFields ||
1338 !(data().HasDefaultedDefaultConstructor ||
1339 needsImplicitDefaultConstructor());
1340 }
1341
1342 /// Determine whether this class has a destructor which has no
1343 /// semantic effect.
1344 ///
1345 /// Any such destructor will be trivial, public, defaulted and not deleted,
1346 /// and will call only irrelevant destructors.
1347 bool hasIrrelevantDestructor() const {
1348 return data().HasIrrelevantDestructor;
1349 }
1350
1351 /// Determine whether this class has a non-literal or/ volatile type
1352 /// non-static data member or base class.
1353 bool hasNonLiteralTypeFieldsOrBases() const {
1354 return data().HasNonLiteralTypeFieldsOrBases;
1355 }
1356
1357 /// Determine whether this class has a using-declaration that names
1358 /// a user-declared base class constructor.
1359 bool hasInheritedConstructor() const {
1360 return data().HasInheritedConstructor;
1361 }
1362
1363 /// Determine whether this class has a using-declaration that names
1364 /// a base class assignment operator.
1365 bool hasInheritedAssignment() const {
1366 return data().HasInheritedAssignment;
1367 }
1368
1369 /// Determine whether this class is considered trivially copyable per
1370 /// (C++11 [class]p6).
1371 bool isTriviallyCopyable() const;
1372
1373 /// Determine whether this class is considered trivial.
1374 ///
1375 /// C++11 [class]p6:
1376 /// "A trivial class is a class that has a trivial default constructor and
1377 /// is trivially copyable."
1378 bool isTrivial() const {
1379 return isTriviallyCopyable() && hasTrivialDefaultConstructor();
1380 }
1381
1382 /// Determine whether this class is a literal type.
1383 ///
1384 /// C++11 [basic.types]p10:
1385 /// A class type that has all the following properties:
1386 /// - it has a trivial destructor
1387 /// - every constructor call and full-expression in the
1388 /// brace-or-equal-intializers for non-static data members (if any) is
1389 /// a constant expression.
1390 /// - it is an aggregate type or has at least one constexpr constructor
1391 /// or constructor template that is not a copy or move constructor, and
1392 /// - all of its non-static data members and base classes are of literal
1393 /// types
1394 ///
1395 /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
1396 /// treating types with trivial default constructors as literal types.
1397 ///
1398 /// Only in C++17 and beyond, are lambdas literal types.
1399 bool isLiteral() const {
1400 const LangOptions &LangOpts = getLangOpts();
1401 return (LangOpts.CPlusPlus20 ? hasConstexprDestructor()
1402 : hasTrivialDestructor()) &&
1403 (!isLambda() || LangOpts.CPlusPlus17) &&
1404 !hasNonLiteralTypeFieldsOrBases() &&
1405 (isAggregate() || isLambda() ||
1406 hasConstexprNonCopyMoveConstructor() ||
1407 hasTrivialDefaultConstructor());
1408 }
1409
1410 /// Determine whether this is a structural type.
1411 bool isStructural() const {
1412 return isLiteral() && data().StructuralIfLiteral;
1413 }
1414
1415 /// If this record is an instantiation of a member class,
1416 /// retrieves the member class from which it was instantiated.
1417 ///
1418 /// This routine will return non-null for (non-templated) member
1419 /// classes of class templates. For example, given:
1420 ///
1421 /// \code
1422 /// template<typename T>
1423 /// struct X {
1424 /// struct A { };
1425 /// };
1426 /// \endcode
1427 ///
1428 /// The declaration for X<int>::A is a (non-templated) CXXRecordDecl
1429 /// whose parent is the class template specialization X<int>. For
1430 /// this declaration, getInstantiatedFromMemberClass() will return
1431 /// the CXXRecordDecl X<T>::A. When a complete definition of
1432 /// X<int>::A is required, it will be instantiated from the
1433 /// declaration returned by getInstantiatedFromMemberClass().
1434 CXXRecordDecl *getInstantiatedFromMemberClass() const;
1435
1436 /// If this class is an instantiation of a member class of a
1437 /// class template specialization, retrieves the member specialization
1438 /// information.
1439 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1440
1441 /// Specify that this record is an instantiation of the
1442 /// member class \p RD.
1443 void setInstantiationOfMemberClass(CXXRecordDecl *RD,
1444 TemplateSpecializationKind TSK);
1445
1446 /// Retrieves the class template that is described by this
1447 /// class declaration.
1448 ///
1449 /// Every class template is represented as a ClassTemplateDecl and a
1450 /// CXXRecordDecl. The former contains template properties (such as
1451 /// the template parameter lists) while the latter contains the
1452 /// actual description of the template's
1453 /// contents. ClassTemplateDecl::getTemplatedDecl() retrieves the
1454 /// CXXRecordDecl that from a ClassTemplateDecl, while
1455 /// getDescribedClassTemplate() retrieves the ClassTemplateDecl from
1456 /// a CXXRecordDecl.
1457 ClassTemplateDecl *getDescribedClassTemplate() const;
1458
1459 void setDescribedClassTemplate(ClassTemplateDecl *Template);
1460
1461 /// Determine whether this particular class is a specialization or
1462 /// instantiation of a class template or member class of a class template,
1463 /// and how it was instantiated or specialized.
1464 TemplateSpecializationKind getTemplateSpecializationKind() const;
1465
1466 /// Set the kind of specialization or template instantiation this is.
1467 void setTemplateSpecializationKind(TemplateSpecializationKind TSK);
1468
1469 /// Retrieve the record declaration from which this record could be
1470 /// instantiated. Returns null if this class is not a template instantiation.
1471 const CXXRecordDecl *getTemplateInstantiationPattern() const;
1472
1473 CXXRecordDecl *getTemplateInstantiationPattern() {
1474 return const_cast<CXXRecordDecl *>(const_cast<const CXXRecordDecl *>(this)
1475 ->getTemplateInstantiationPattern());
1476 }
1477
1478 /// Returns the destructor decl for this class.
1479 CXXDestructorDecl *getDestructor() const;
1480
1481 /// Returns true if the class destructor, or any implicitly invoked
1482 /// destructors are marked noreturn.
1483 bool isAnyDestructorNoReturn() const { return data().IsAnyDestructorNoReturn; }
1484
1485 /// If the class is a local class [class.local], returns
1486 /// the enclosing function declaration.
1487 const FunctionDecl *isLocalClass() const {
1488 if (const auto *RD = dyn_cast<CXXRecordDecl>(getDeclContext()))
1489 return RD->isLocalClass();
1490
1491 return dyn_cast<FunctionDecl>(getDeclContext());
1492 }
1493
1494 FunctionDecl *isLocalClass() {
1495 return const_cast<FunctionDecl*>(
1496 const_cast<const CXXRecordDecl*>(this)->isLocalClass());
1497 }
1498
1499 /// Determine whether this dependent class is a current instantiation,
1500 /// when viewed from within the given context.
1501 bool isCurrentInstantiation(const DeclContext *CurContext) const;
1502
1503 /// Determine whether this class is derived from the class \p Base.
1504 ///
1505 /// This routine only determines whether this class is derived from \p Base,
1506 /// but does not account for factors that may make a Derived -> Base class
1507 /// ill-formed, such as private/protected inheritance or multiple, ambiguous
1508 /// base class subobjects.
1509 ///
1510 /// \param Base the base class we are searching for.
1511 ///
1512 /// \returns true if this class is derived from Base, false otherwise.
1513 bool isDerivedFrom(const CXXRecordDecl *Base) const;
1514
1515 /// Determine whether this class is derived from the type \p Base.
1516 ///
1517 /// This routine only determines whether this class is derived from \p Base,
1518 /// but does not account for factors that may make a Derived -> Base class
1519 /// ill-formed, such as private/protected inheritance or multiple, ambiguous
1520 /// base class subobjects.
1521 ///
1522 /// \param Base the base class we are searching for.
1523 ///
1524 /// \param Paths will contain the paths taken from the current class to the
1525 /// given \p Base class.
1526 ///
1527 /// \returns true if this class is derived from \p Base, false otherwise.
1528 ///
1529 /// \todo add a separate parameter to configure IsDerivedFrom, rather than
1530 /// tangling input and output in \p Paths
1531 bool isDerivedFrom(const CXXRecordDecl *Base, CXXBasePaths &Paths) const;
1532
1533 /// Determine whether this class is virtually derived from
1534 /// the class \p Base.
1535 ///
1536 /// This routine only determines whether this class is virtually
1537 /// derived from \p Base, but does not account for factors that may
1538 /// make a Derived -> Base class ill-formed, such as
1539 /// private/protected inheritance or multiple, ambiguous base class
1540 /// subobjects.
1541 ///
1542 /// \param Base the base class we are searching for.
1543 ///
1544 /// \returns true if this class is virtually derived from Base,
1545 /// false otherwise.
1546 bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const;
1547
1548 /// Determine whether this class is provably not derived from
1549 /// the type \p Base.
1550 bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const;
1551
1552 /// Function type used by forallBases() as a callback.
1553 ///
1554 /// \param BaseDefinition the definition of the base class
1555 ///
1556 /// \returns true if this base matched the search criteria
1557 using ForallBasesCallback =
1558 llvm::function_ref<bool(const CXXRecordDecl *BaseDefinition)>;
1559
1560 /// Determines if the given callback holds for all the direct
1561 /// or indirect base classes of this type.
1562 ///
1563 /// The class itself does not count as a base class. This routine
1564 /// returns false if the class has non-computable base classes.
1565 ///
1566 /// \param BaseMatches Callback invoked for each (direct or indirect) base
1567 /// class of this type until a call returns false.
1568 bool forallBases(ForallBasesCallback BaseMatches) const;
1569
1570 /// Function type used by lookupInBases() to determine whether a
1571 /// specific base class subobject matches the lookup criteria.
1572 ///
1573 /// \param Specifier the base-class specifier that describes the inheritance
1574 /// from the base class we are trying to match.
1575 ///
1576 /// \param Path the current path, from the most-derived class down to the
1577 /// base named by the \p Specifier.
1578 ///
1579 /// \returns true if this base matched the search criteria, false otherwise.
1580 using BaseMatchesCallback =
1581 llvm::function_ref<bool(const CXXBaseSpecifier *Specifier,
1582 CXXBasePath &Path)>;
1583
1584 /// Look for entities within the base classes of this C++ class,
1585 /// transitively searching all base class subobjects.
1586 ///
1587 /// This routine uses the callback function \p BaseMatches to find base
1588 /// classes meeting some search criteria, walking all base class subobjects
1589 /// and populating the given \p Paths structure with the paths through the
1590 /// inheritance hierarchy that resulted in a match. On a successful search,
1591 /// the \p Paths structure can be queried to retrieve the matching paths and
1592 /// to determine if there were any ambiguities.
1593 ///
1594 /// \param BaseMatches callback function used to determine whether a given
1595 /// base matches the user-defined search criteria.
1596 ///
1597 /// \param Paths used to record the paths from this class to its base class
1598 /// subobjects that match the search criteria.
1599 ///
1600 /// \param LookupInDependent can be set to true to extend the search to
1601 /// dependent base classes.
1602 ///
1603 /// \returns true if there exists any path from this class to a base class
1604 /// subobject that matches the search criteria.
1605 bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths,
1606 bool LookupInDependent = false) const;
1607
1608 /// Base-class lookup callback that determines whether the given
1609 /// base class specifier refers to a specific class declaration.
1610 ///
1611 /// This callback can be used with \c lookupInBases() to determine whether
1612 /// a given derived class has is a base class subobject of a particular type.
1613 /// The base record pointer should refer to the canonical CXXRecordDecl of the
1614 /// base class that we are searching for.
1615 static bool FindBaseClass(const CXXBaseSpecifier *Specifier,
1616 CXXBasePath &Path, const CXXRecordDecl *BaseRecord);
1617
1618 /// Base-class lookup callback that determines whether the
1619 /// given base class specifier refers to a specific class
1620 /// declaration and describes virtual derivation.
1621 ///
1622 /// This callback can be used with \c lookupInBases() to determine
1623 /// whether a given derived class has is a virtual base class
1624 /// subobject of a particular type. The base record pointer should
1625 /// refer to the canonical CXXRecordDecl of the base class that we
1626 /// are searching for.
1627 static bool FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,
1628 CXXBasePath &Path,
1629 const CXXRecordDecl *BaseRecord);
1630
1631 /// Retrieve the final overriders for each virtual member
1632 /// function in the class hierarchy where this class is the
1633 /// most-derived class in the class hierarchy.
1634 void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const;
1635
1636 /// Get the indirect primary bases for this class.
1637 void getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const;
1638
1639 /// Determine whether this class has a member with the given name, possibly
1640 /// in a non-dependent base class.
1641 ///
1642 /// No check for ambiguity is performed, so this should never be used when
1643 /// implementing language semantics, but it may be appropriate for warnings,
1644 /// static analysis, or similar.
1645 bool hasMemberName(DeclarationName N) const;
1646
1647 /// Performs an imprecise lookup of a dependent name in this class.
1648 ///
1649 /// This function does not follow strict semantic rules and should be used
1650 /// only when lookup rules can be relaxed, e.g. indexing.
1651 std::vector<const NamedDecl *>
1652 lookupDependentName(DeclarationName Name,
1653 llvm::function_ref<bool(const NamedDecl *ND)> Filter);
1654
1655 /// Renders and displays an inheritance diagram
1656 /// for this C++ class and all of its base classes (transitively) using
1657 /// GraphViz.
1658 void viewInheritance(ASTContext& Context) const;
1659
1660 /// Calculates the access of a decl that is reached
1661 /// along a path.
1662 static AccessSpecifier MergeAccess(AccessSpecifier PathAccess,
1663 AccessSpecifier DeclAccess) {
1664 assert(DeclAccess != AS_none)(static_cast <bool> (DeclAccess != AS_none) ? void (0) :
__assert_fail ("DeclAccess != AS_none", "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 1664, __extension__ __PRETTY_FUNCTION__))
;
1665 if (DeclAccess == AS_private) return AS_none;
1666 return (PathAccess > DeclAccess ? PathAccess : DeclAccess);
1667 }
1668
1669 /// Indicates that the declaration of a defaulted or deleted special
1670 /// member function is now complete.
1671 void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD);
1672
1673 void setTrivialForCallFlags(CXXMethodDecl *MD);
1674
1675 /// Indicates that the definition of this class is now complete.
1676 void completeDefinition() override;
1677
1678 /// Indicates that the definition of this class is now complete,
1679 /// and provides a final overrider map to help determine
1680 ///
1681 /// \param FinalOverriders The final overrider map for this class, which can
1682 /// be provided as an optimization for abstract-class checking. If NULL,
1683 /// final overriders will be computed if they are needed to complete the
1684 /// definition.
1685 void completeDefinition(CXXFinalOverriderMap *FinalOverriders);
1686
1687 /// Determine whether this class may end up being abstract, even though
1688 /// it is not yet known to be abstract.
1689 ///
1690 /// \returns true if this class is not known to be abstract but has any
1691 /// base classes that are abstract. In this case, \c completeDefinition()
1692 /// will need to compute final overriders to determine whether the class is
1693 /// actually abstract.
1694 bool mayBeAbstract() const;
1695
1696 /// Determine whether it's impossible for a class to be derived from this
1697 /// class. This is best-effort, and may conservatively return false.
1698 bool isEffectivelyFinal() const;
1699
1700 /// If this is the closure type of a lambda expression, retrieve the
1701 /// number to be used for name mangling in the Itanium C++ ABI.
1702 ///
1703 /// Zero indicates that this closure type has internal linkage, so the
1704 /// mangling number does not matter, while a non-zero value indicates which
1705 /// lambda expression this is in this particular context.
1706 unsigned getLambdaManglingNumber() const {
1707 assert(isLambda() && "Not a lambda closure type!")(static_cast <bool> (isLambda() && "Not a lambda closure type!"
) ? void (0) : __assert_fail ("isLambda() && \"Not a lambda closure type!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 1707, __extension__ __PRETTY_FUNCTION__))
;
1708 return getLambdaData().ManglingNumber;
1709 }
1710
1711 /// The lambda is known to has internal linkage no matter whether it has name
1712 /// mangling number.
1713 bool hasKnownLambdaInternalLinkage() const {
1714 assert(isLambda() && "Not a lambda closure type!")(static_cast <bool> (isLambda() && "Not a lambda closure type!"
) ? void (0) : __assert_fail ("isLambda() && \"Not a lambda closure type!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 1714, __extension__ __PRETTY_FUNCTION__))
;
1715 return getLambdaData().HasKnownInternalLinkage;
1716 }
1717
1718 /// Retrieve the declaration that provides additional context for a
1719 /// lambda, when the normal declaration context is not specific enough.
1720 ///
1721 /// Certain contexts (default arguments of in-class function parameters and
1722 /// the initializers of data members) have separate name mangling rules for
1723 /// lambdas within the Itanium C++ ABI. For these cases, this routine provides
1724 /// the declaration in which the lambda occurs, e.g., the function parameter
1725 /// or the non-static data member. Otherwise, it returns NULL to imply that
1726 /// the declaration context suffices.
1727 Decl *getLambdaContextDecl() const;
1728
1729 /// Set the mangling number and context declaration for a lambda
1730 /// class.
1731 void setLambdaMangling(unsigned ManglingNumber, Decl *ContextDecl,
1732 bool HasKnownInternalLinkage = false) {
1733 assert(isLambda() && "Not a lambda closure type!")(static_cast <bool> (isLambda() && "Not a lambda closure type!"
) ? void (0) : __assert_fail ("isLambda() && \"Not a lambda closure type!\""
, "/build/llvm-toolchain-snapshot-14~++20211016100712+8e1d532707fd/clang/include/clang/AST/DeclCXX.h"
, 1733, __extension__ __PRETTY_FUNCTION__))
;
1734 getLambdaData().ManglingNumber = ManglingNumber;
1735 getLambdaData().ContextDecl = ContextDecl;
1736 getLambdaData().HasKnownInternalLinkage = HasKnownInternalLinkage;
1737 }
1738
1739 /// Set the device side mangling number.
1740 void setDeviceLambdaManglingNumber(unsigned Num) const;
1741
1742 /// Retrieve the device side mangling number.
1743 unsigned getDeviceLambdaManglingNumber() const;
1744
1745 /// Returns the inheritance model used for this record.
1746 MSInheritanceModel getMSInheritanceModel() const;
1747
1748 /// Calculate what the inheritance model would be for this class.
1749 MSInheritanceModel calculateInheritanceModel() const;
1750
1751 /// In the Microsoft C++ ABI, use zero for the field offset of a null data
1752 /// member pointer if we can guarantee that zero is not a valid field offset,
1753 /// or if the member pointer has multiple fields. Polymorphic classes have a
1754 /// vfptr at offset zero, so we can use zero for null. If there are multiple
1755 /// fields, we can use zero even if it is a valid field offset because
1756 /// null-ness testing will check the other fields.
1757 bool nullFieldOffsetIsZero() const;
1758
1759 /// Controls when vtordisps will be emitted if this record is used as a
1760 /// virtual base.
1761 MSVtorDispMode getMSVtorDispMode() const;
1762
1763 /// Determine whether this lambda expression was known to be dependent
1764 /// at the time it was created, even if its context does not appear to be
1765 /// dependent.
1766 ///
1767 /// This flag is a workaround for an issue with parsing, where default
1768 /// arguments are parsed before their enclosing function declarations have
1769 /// been created. This means that any lambda expressions within those
1770 /// default arguments will have as their DeclContext the context enclosing
1771 /// the function declaration, which may be non-dependent even when the
1772 /// function declaration itself is dependent. This flag indicates when we
1773 /// know that the lambda is dependent despite that.
1774 bool isDependentLambda() const {
1775 return isLambda() && getLambdaData().Dependent;
1776 }
1777
1778 TypeSourceInfo *getLambdaTypeInfo() const {
1779 return getLambdaData().MethodTyInfo;
1780 }
1781
1782 // Determine whether this type is an Interface Like type for
1783 // __interface inheritance purposes.
1784 bool isInterfaceLike() const;
1785
1786 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1787 static bool classofKind(Kind K) {
1788 return K >= firstCXXRecord && K <= lastCXXRecord;
1789 }
1790 void markAbstract() { data().Abstract = true; }
1791};
1792
1793/// Store information needed for an explicit specifier.
1794/// Used by CXXDeductionGuideDecl, CXXConstructorDecl and CXXConversionDecl.
1795class ExplicitSpecifier {
1796 llvm::PointerIntPair<Expr *, 2, ExplicitSpecKind> ExplicitSpec{
1797 nullptr, ExplicitSpecKind::ResolvedFalse};
1798
1799public:
1800 ExplicitSpecifier() = default;
1801 ExplicitSpecifier(Expr *Expression, ExplicitSpecKind Kind)
1802 : ExplicitSpec(Expression, Kind) {}
1803 ExplicitSpecKind getKind() const { return ExplicitSpec.getInt(); }
1804 const Expr *getExpr() const { return ExplicitSpec.getPointer(); }
1805 Expr *getExpr() { return ExplicitSpec.getPointer(); }
1806
1807 /// Determine if the declaration had an explicit specifier of any kind.
1808 bool isSpecified() const {
1809 return ExplicitSpec.getInt() != ExplicitSpecKind::ResolvedFalse ||
1810 ExplicitSpec.getPointer();
1811 }
1812
1813 /// Check for equivalence of explicit specifiers.
1814 /// \return true if the explicit specifier are equivalent, false otherwise.