Bug Summary

File:clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:line 2793, column 41
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name 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 -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/Sema -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 /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/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-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~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-08-28-193554-24367-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/Sema/SemaTemplateInstantiate.cpp

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

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h

1//===--- Sema.h - Semantic Analysis & AST Building --------------*- 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// This file defines the Sema class, which performs semantic analysis and
10// builds ASTs.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_SEMA_SEMA_H
15#define LLVM_CLANG_SEMA_SEMA_H
16
17#include "clang/AST/ASTConcept.h"
18#include "clang/AST/ASTFwd.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/Availability.h"
21#include "clang/AST/ComparisonCategories.h"
22#include "clang/AST/DeclTemplate.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
26#include "clang/AST/ExprConcepts.h"
27#include "clang/AST/ExprObjC.h"
28#include "clang/AST/ExprOpenMP.h"
29#include "clang/AST/ExternalASTSource.h"
30#include "clang/AST/LocInfoType.h"
31#include "clang/AST/MangleNumberingContext.h"
32#include "clang/AST/NSAPI.h"
33#include "clang/AST/PrettyPrinter.h"
34#include "clang/AST/StmtCXX.h"
35#include "clang/AST/StmtOpenMP.h"
36#include "clang/AST/TypeLoc.h"
37#include "clang/AST/TypeOrdering.h"
38#include "clang/Basic/BitmaskEnum.h"
39#include "clang/Basic/Builtins.h"
40#include "clang/Basic/DarwinSDKInfo.h"
41#include "clang/Basic/ExpressionTraits.h"
42#include "clang/Basic/Module.h"
43#include "clang/Basic/OpenCLOptions.h"
44#include "clang/Basic/OpenMPKinds.h"
45#include "clang/Basic/PragmaKinds.h"
46#include "clang/Basic/Specifiers.h"
47#include "clang/Basic/TemplateKinds.h"
48#include "clang/Basic/TypeTraits.h"
49#include "clang/Sema/AnalysisBasedWarnings.h"
50#include "clang/Sema/CleanupInfo.h"
51#include "clang/Sema/DeclSpec.h"
52#include "clang/Sema/ExternalSemaSource.h"
53#include "clang/Sema/IdentifierResolver.h"
54#include "clang/Sema/ObjCMethodList.h"
55#include "clang/Sema/Ownership.h"
56#include "clang/Sema/Scope.h"
57#include "clang/Sema/SemaConcept.h"
58#include "clang/Sema/TypoCorrection.h"
59#include "clang/Sema/Weak.h"
60#include "llvm/ADT/ArrayRef.h"
61#include "llvm/ADT/Optional.h"
62#include "llvm/ADT/SetVector.h"
63#include "llvm/ADT/SmallBitVector.h"
64#include "llvm/ADT/SmallPtrSet.h"
65#include "llvm/ADT/SmallSet.h"
66#include "llvm/ADT/SmallVector.h"
67#include "llvm/ADT/TinyPtrVector.h"
68#include "llvm/Frontend/OpenMP/OMPConstants.h"
69#include <deque>
70#include <memory>
71#include <string>
72#include <tuple>
73#include <vector>
74
75namespace llvm {
76 class APSInt;
77 template <typename ValueT> struct DenseMapInfo;
78 template <typename ValueT, typename ValueInfoT> class DenseSet;
79 class SmallBitVector;
80 struct InlineAsmIdentifierInfo;
81}
82
83namespace clang {
84 class ADLResult;
85 class ASTConsumer;
86 class ASTContext;
87 class ASTMutationListener;
88 class ASTReader;
89 class ASTWriter;
90 class ArrayType;
91 class ParsedAttr;
92 class BindingDecl;
93 class BlockDecl;
94 class CapturedDecl;
95 class CXXBasePath;
96 class CXXBasePaths;
97 class CXXBindTemporaryExpr;
98 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
99 class CXXConstructorDecl;
100 class CXXConversionDecl;
101 class CXXDeleteExpr;
102 class CXXDestructorDecl;
103 class CXXFieldCollector;
104 class CXXMemberCallExpr;
105 class CXXMethodDecl;
106 class CXXScopeSpec;
107 class CXXTemporary;
108 class CXXTryStmt;
109 class CallExpr;
110 class ClassTemplateDecl;
111 class ClassTemplatePartialSpecializationDecl;
112 class ClassTemplateSpecializationDecl;
113 class VarTemplatePartialSpecializationDecl;
114 class CodeCompleteConsumer;
115 class CodeCompletionAllocator;
116 class CodeCompletionTUInfo;
117 class CodeCompletionResult;
118 class CoroutineBodyStmt;
119 class Decl;
120 class DeclAccessPair;
121 class DeclContext;
122 class DeclRefExpr;
123 class DeclaratorDecl;
124 class DeducedTemplateArgument;
125 class DependentDiagnostic;
126 class DesignatedInitExpr;
127 class Designation;
128 class EnableIfAttr;
129 class EnumConstantDecl;
130 class Expr;
131 class ExtVectorType;
132 class FormatAttr;
133 class FriendDecl;
134 class FunctionDecl;
135 class FunctionProtoType;
136 class FunctionTemplateDecl;
137 class ImplicitConversionSequence;
138 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
139 class InitListExpr;
140 class InitializationKind;
141 class InitializationSequence;
142 class InitializedEntity;
143 class IntegerLiteral;
144 class LabelStmt;
145 class LambdaExpr;
146 class LangOptions;
147 class LocalInstantiationScope;
148 class LookupResult;
149 class MacroInfo;
150 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
151 class ModuleLoader;
152 class MultiLevelTemplateArgumentList;
153 class NamedDecl;
154 class ObjCCategoryDecl;
155 class ObjCCategoryImplDecl;
156 class ObjCCompatibleAliasDecl;
157 class ObjCContainerDecl;
158 class ObjCImplDecl;
159 class ObjCImplementationDecl;
160 class ObjCInterfaceDecl;
161 class ObjCIvarDecl;
162 template <class T> class ObjCList;
163 class ObjCMessageExpr;
164 class ObjCMethodDecl;
165 class ObjCPropertyDecl;
166 class ObjCProtocolDecl;
167 class OMPThreadPrivateDecl;
168 class OMPRequiresDecl;
169 class OMPDeclareReductionDecl;
170 class OMPDeclareSimdDecl;
171 class OMPClause;
172 struct OMPVarListLocTy;
173 struct OverloadCandidate;
174 enum class OverloadCandidateParamOrder : char;
175 enum OverloadCandidateRewriteKind : unsigned;
176 class OverloadCandidateSet;
177 class OverloadExpr;
178 class ParenListExpr;
179 class ParmVarDecl;
180 class Preprocessor;
181 class PseudoDestructorTypeStorage;
182 class PseudoObjectExpr;
183 class QualType;
184 class StandardConversionSequence;
185 class Stmt;
186 class StringLiteral;
187 class SwitchStmt;
188 class TemplateArgument;
189 class TemplateArgumentList;
190 class TemplateArgumentLoc;
191 class TemplateDecl;
192 class TemplateInstantiationCallback;
193 class TemplateParameterList;
194 class TemplatePartialOrderingContext;
195 class TemplateTemplateParmDecl;
196 class Token;
197 class TypeAliasDecl;
198 class TypedefDecl;
199 class TypedefNameDecl;
200 class TypeLoc;
201 class TypoCorrectionConsumer;
202 class UnqualifiedId;
203 class UnresolvedLookupExpr;
204 class UnresolvedMemberExpr;
205 class UnresolvedSetImpl;
206 class UnresolvedSetIterator;
207 class UsingDecl;
208 class UsingShadowDecl;
209 class ValueDecl;
210 class VarDecl;
211 class VarTemplateSpecializationDecl;
212 class VisibilityAttr;
213 class VisibleDeclConsumer;
214 class IndirectFieldDecl;
215 struct DeductionFailureInfo;
216 class TemplateSpecCandidateSet;
217
218namespace sema {
219 class AccessedEntity;
220 class BlockScopeInfo;
221 class Capture;
222 class CapturedRegionScopeInfo;
223 class CapturingScopeInfo;
224 class CompoundScopeInfo;
225 class DelayedDiagnostic;
226 class DelayedDiagnosticPool;
227 class FunctionScopeInfo;
228 class LambdaScopeInfo;
229 class PossiblyUnreachableDiag;
230 class SemaPPCallbacks;
231 class TemplateDeductionInfo;
232}
233
234namespace threadSafety {
235 class BeforeSet;
236 void threadSafetyCleanup(BeforeSet* Cache);
237}
238
239// FIXME: No way to easily map from TemplateTypeParmTypes to
240// TemplateTypeParmDecls, so we have this horrible PointerUnion.
241typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
242 SourceLocation> UnexpandedParameterPack;
243
244/// Describes whether we've seen any nullability information for the given
245/// file.
246struct FileNullability {
247 /// The first pointer declarator (of any pointer kind) in the file that does
248 /// not have a corresponding nullability annotation.
249 SourceLocation PointerLoc;
250
251 /// The end location for the first pointer declarator in the file. Used for
252 /// placing fix-its.
253 SourceLocation PointerEndLoc;
254
255 /// Which kind of pointer declarator we saw.
256 uint8_t PointerKind;
257
258 /// Whether we saw any type nullability annotations in the given file.
259 bool SawTypeNullability = false;
260};
261
262/// A mapping from file IDs to a record of whether we've seen nullability
263/// information in that file.
264class FileNullabilityMap {
265 /// A mapping from file IDs to the nullability information for each file ID.
266 llvm::DenseMap<FileID, FileNullability> Map;
267
268 /// A single-element cache based on the file ID.
269 struct {
270 FileID File;
271 FileNullability Nullability;
272 } Cache;
273
274public:
275 FileNullability &operator[](FileID file) {
276 // Check the single-element cache.
277 if (file == Cache.File)
278 return Cache.Nullability;
279
280 // It's not in the single-element cache; flush the cache if we have one.
281 if (!Cache.File.isInvalid()) {
282 Map[Cache.File] = Cache.Nullability;
283 }
284
285 // Pull this entry into the cache.
286 Cache.File = file;
287 Cache.Nullability = Map[file];
288 return Cache.Nullability;
289 }
290};
291
292/// Tracks expected type during expression parsing, for use in code completion.
293/// The type is tied to a particular token, all functions that update or consume
294/// the type take a start location of the token they are looking at as a
295/// parameter. This avoids updating the type on hot paths in the parser.
296class PreferredTypeBuilder {
297public:
298 PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {}
299
300 void enterCondition(Sema &S, SourceLocation Tok);
301 void enterReturn(Sema &S, SourceLocation Tok);
302 void enterVariableInit(SourceLocation Tok, Decl *D);
303 /// Handles e.g. BaseType{ .D = Tok...
304 void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,
305 const Designation &D);
306 /// Computing a type for the function argument may require running
307 /// overloading, so we postpone its computation until it is actually needed.
308 ///
309 /// Clients should be very careful when using this funciton, as it stores a
310 /// function_ref, clients should make sure all calls to get() with the same
311 /// location happen while function_ref is alive.
312 ///
313 /// The callback should also emit signature help as a side-effect, but only
314 /// if the completion point has been reached.
315 void enterFunctionArgument(SourceLocation Tok,
316 llvm::function_ref<QualType()> ComputeType);
317
318 void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);
319 void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,
320 SourceLocation OpLoc);
321 void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
322 void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
323 void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
324 /// Handles all type casts, including C-style cast, C++ casts, etc.
325 void enterTypeCast(SourceLocation Tok, QualType CastType);
326
327 /// Get the expected type associated with this location, if any.
328 ///
329 /// If the location is a function argument, determining the expected type
330 /// involves considering all function overloads and the arguments so far.
331 /// In this case, signature help for these function overloads will be reported
332 /// as a side-effect (only if the completion point has been reached).
333 QualType get(SourceLocation Tok) const {
334 if (!Enabled || Tok != ExpectedLoc)
335 return QualType();
336 if (!Type.isNull())
337 return Type;
338 if (ComputeType)
339 return ComputeType();
340 return QualType();
341 }
342
343private:
344 bool Enabled;
345 /// Start position of a token for which we store expected type.
346 SourceLocation ExpectedLoc;
347 /// Expected type for a token starting at ExpectedLoc.
348 QualType Type;
349 /// A function to compute expected type at ExpectedLoc. It is only considered
350 /// if Type is null.
351 llvm::function_ref<QualType()> ComputeType;
352};
353
354/// Sema - This implements semantic analysis and AST building for C.
355class Sema final {
356 Sema(const Sema &) = delete;
357 void operator=(const Sema &) = delete;
358
359 ///Source of additional semantic information.
360 ExternalSemaSource *ExternalSource;
361
362 ///Whether Sema has generated a multiplexer and has to delete it.
363 bool isMultiplexExternalSource;
364
365 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
366
367 bool isVisibleSlow(const NamedDecl *D);
368
369 /// Determine whether two declarations should be linked together, given that
370 /// the old declaration might not be visible and the new declaration might
371 /// not have external linkage.
372 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
373 const NamedDecl *New) {
374 if (isVisible(Old))
375 return true;
376 // See comment in below overload for why it's safe to compute the linkage
377 // of the new declaration here.
378 if (New->isExternallyDeclarable()) {
379 assert(Old->isExternallyDeclarable() &&(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 380, __extension__ __PRETTY_FUNCTION__))
380 "should not have found a non-externally-declarable previous decl")(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 380, __extension__ __PRETTY_FUNCTION__))
;
381 return true;
382 }
383 return false;
384 }
385 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
386
387 void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
388 QualType ResultTy,
389 ArrayRef<QualType> Args);
390
391public:
392 /// The maximum alignment, same as in llvm::Value. We duplicate them here
393 /// because that allows us not to duplicate the constants in clang code,
394 /// which we must to since we can't directly use the llvm constants.
395 /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp
396 ///
397 /// This is the greatest alignment value supported by load, store, and alloca
398 /// instructions, and global values.
399 static const unsigned MaxAlignmentExponent = 30;
400 static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
401
402 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
403 typedef OpaquePtr<TemplateName> TemplateTy;
404 typedef OpaquePtr<QualType> TypeTy;
405
406 OpenCLOptions OpenCLFeatures;
407 FPOptions CurFPFeatures;
408
409 const LangOptions &LangOpts;
410 Preprocessor &PP;
411 ASTContext &Context;
412 ASTConsumer &Consumer;
413 DiagnosticsEngine &Diags;
414 SourceManager &SourceMgr;
415
416 /// Flag indicating whether or not to collect detailed statistics.
417 bool CollectStats;
418
419 /// Code-completion consumer.
420 CodeCompleteConsumer *CodeCompleter;
421
422 /// CurContext - This is the current declaration context of parsing.
423 DeclContext *CurContext;
424
425 /// Generally null except when we temporarily switch decl contexts,
426 /// like in \see ActOnObjCTemporaryExitContainerContext.
427 DeclContext *OriginalLexicalContext;
428
429 /// VAListTagName - The declaration name corresponding to __va_list_tag.
430 /// This is used as part of a hack to omit that class from ADL results.
431 DeclarationName VAListTagName;
432
433 bool MSStructPragmaOn; // True when \#pragma ms_struct on
434
435 /// Controls member pointer representation format under the MS ABI.
436 LangOptions::PragmaMSPointersToMembersKind
437 MSPointerToMemberRepresentationMethod;
438
439 /// Stack of active SEH __finally scopes. Can be empty.
440 SmallVector<Scope*, 2> CurrentSEHFinally;
441
442 /// Source location for newly created implicit MSInheritanceAttrs
443 SourceLocation ImplicitMSInheritanceAttrLoc;
444
445 /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by
446 /// `TransformTypos` in order to keep track of any TypoExprs that are created
447 /// recursively during typo correction and wipe them away if the correction
448 /// fails.
449 llvm::SmallVector<TypoExpr *, 2> TypoExprs;
450
451 /// pragma clang section kind
452 enum PragmaClangSectionKind {
453 PCSK_Invalid = 0,
454 PCSK_BSS = 1,
455 PCSK_Data = 2,
456 PCSK_Rodata = 3,
457 PCSK_Text = 4,
458 PCSK_Relro = 5
459 };
460
461 enum PragmaClangSectionAction {
462 PCSA_Set = 0,
463 PCSA_Clear = 1
464 };
465
466 struct PragmaClangSection {
467 std::string SectionName;
468 bool Valid = false;
469 SourceLocation PragmaLocation;
470 };
471
472 PragmaClangSection PragmaClangBSSSection;
473 PragmaClangSection PragmaClangDataSection;
474 PragmaClangSection PragmaClangRodataSection;
475 PragmaClangSection PragmaClangRelroSection;
476 PragmaClangSection PragmaClangTextSection;
477
478 enum PragmaMsStackAction {
479 PSK_Reset = 0x0, // #pragma ()
480 PSK_Set = 0x1, // #pragma (value)
481 PSK_Push = 0x2, // #pragma (push[, id])
482 PSK_Pop = 0x4, // #pragma (pop[, id])
483 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
484 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
485 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
486 };
487
488 // #pragma pack and align.
489 class AlignPackInfo {
490 public:
491 // `Native` represents default align mode, which may vary based on the
492 // platform.
493 enum Mode : unsigned char { Native, Natural, Packed, Mac68k };
494
495 // #pragma pack info constructor
496 AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL)
497 : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
498 assert(Num == PackNumber && "The pack number has been truncated.")(static_cast <bool> (Num == PackNumber && "The pack number has been truncated."
) ? void (0) : __assert_fail ("Num == PackNumber && \"The pack number has been truncated.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 498, __extension__ __PRETTY_FUNCTION__))
;
499 }
500
501 // #pragma align info constructor
502 AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)
503 : PackAttr(false), AlignMode(M),
504 PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
505
506 explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {}
507
508 AlignPackInfo() : AlignPackInfo(Native, false) {}
509
510 // When a AlignPackInfo itself cannot be used, this returns an 32-bit
511 // integer encoding for it. This should only be passed to
512 // AlignPackInfo::getFromRawEncoding, it should not be inspected directly.
513 static uint32_t getRawEncoding(const AlignPackInfo &Info) {
514 std::uint32_t Encoding{};
515 if (Info.IsXLStack())
516 Encoding |= IsXLMask;
517
518 Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1;
519
520 if (Info.IsPackAttr())
521 Encoding |= PackAttrMask;
522
523 Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4;
524
525 return Encoding;
526 }
527
528 static AlignPackInfo getFromRawEncoding(unsigned Encoding) {
529 bool IsXL = static_cast<bool>(Encoding & IsXLMask);
530 AlignPackInfo::Mode M =
531 static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1);
532 int PackNumber = (Encoding & PackNumMask) >> 4;
533
534 if (Encoding & PackAttrMask)
535 return AlignPackInfo(M, PackNumber, IsXL);
536
537 return AlignPackInfo(M, IsXL);
538 }
539
540 bool IsPackAttr() const { return PackAttr; }
541
542 bool IsAlignAttr() const { return !PackAttr; }
543
544 Mode getAlignMode() const { return AlignMode; }
545
546 unsigned getPackNumber() const { return PackNumber; }
547
548 bool IsPackSet() const {
549 // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack
550 // attriute on a decl.
551 return PackNumber != UninitPackVal && PackNumber != 0;
552 }
553
554 bool IsXLStack() const { return XLStack; }
555
556 bool operator==(const AlignPackInfo &Info) const {
557 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
558 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
559 Info.XLStack);
560 }
561
562 bool operator!=(const AlignPackInfo &Info) const {
563 return !(*this == Info);
564 }
565
566 private:
567 /// \brief True if this is a pragma pack attribute,
568 /// not a pragma align attribute.
569 bool PackAttr;
570
571 /// \brief The alignment mode that is in effect.
572 Mode AlignMode;
573
574 /// \brief The pack number of the stack.
575 unsigned char PackNumber;
576
577 /// \brief True if it is a XL #pragma align/pack stack.
578 bool XLStack;
579
580 /// \brief Uninitialized pack value.
581 static constexpr unsigned char UninitPackVal = -1;
582
583 // Masks to encode and decode an AlignPackInfo.
584 static constexpr uint32_t IsXLMask{0x0000'0001};
585 static constexpr uint32_t AlignModeMask{0x0000'0006};
586 static constexpr uint32_t PackAttrMask{0x00000'0008};
587 static constexpr uint32_t PackNumMask{0x0000'01F0};
588 };
589
590 template<typename ValueType>
591 struct PragmaStack {
592 struct Slot {
593 llvm::StringRef StackSlotLabel;
594 ValueType Value;
595 SourceLocation PragmaLocation;
596 SourceLocation PragmaPushLocation;
597 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
598 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
599 : StackSlotLabel(StackSlotLabel), Value(Value),
600 PragmaLocation(PragmaLocation),
601 PragmaPushLocation(PragmaPushLocation) {}
602 };
603
604 void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,
605 llvm::StringRef StackSlotLabel, ValueType Value) {
606 if (Action == PSK_Reset) {
607 CurrentValue = DefaultValue;
608 CurrentPragmaLocation = PragmaLocation;
609 return;
610 }
611 if (Action & PSK_Push)
612 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
613 PragmaLocation);
614 else if (Action & PSK_Pop) {
615 if (!StackSlotLabel.empty()) {
616 // If we've got a label, try to find it and jump there.
617 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
618 return x.StackSlotLabel == StackSlotLabel;
619 });
620 // If we found the label so pop from there.
621 if (I != Stack.rend()) {
622 CurrentValue = I->Value;
623 CurrentPragmaLocation = I->PragmaLocation;
624 Stack.erase(std::prev(I.base()), Stack.end());
625 }
626 } else if (!Stack.empty()) {
627 // We do not have a label, just pop the last entry.
628 CurrentValue = Stack.back().Value;
629 CurrentPragmaLocation = Stack.back().PragmaLocation;
630 Stack.pop_back();
631 }
632 }
633 if (Action & PSK_Set) {
634 CurrentValue = Value;
635 CurrentPragmaLocation = PragmaLocation;
636 }
637 }
638
639 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
640 // method body to restore the stacks on exit, so it works like this:
641 //
642 // struct S {
643 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
644 // void Method {}
645 // #pragma <name>(pop, InternalPragmaSlot)
646 // };
647 //
648 // It works even with #pragma vtordisp, although MSVC doesn't support
649 // #pragma vtordisp(push [, id], n)
650 // syntax.
651 //
652 // Push / pop a named sentinel slot.
653 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
654 assert((Action == PSK_Push || Action == PSK_Pop) &&(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 655, __extension__ __PRETTY_FUNCTION__))
655 "Can only push / pop #pragma stack sentinels!")(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 655, __extension__ __PRETTY_FUNCTION__))
;
656 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
657 }
658
659 // Constructors.
660 explicit PragmaStack(const ValueType &Default)
661 : DefaultValue(Default), CurrentValue(Default) {}
662
663 bool hasValue() const { return CurrentValue != DefaultValue; }
664
665 SmallVector<Slot, 2> Stack;
666 ValueType DefaultValue; // Value used for PSK_Reset action.
667 ValueType CurrentValue;
668 SourceLocation CurrentPragmaLocation;
669 };
670 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
671 // we shouldn't do so if they're in a module).
672
673 /// Whether to insert vtordisps prior to virtual bases in the Microsoft
674 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
675 ///
676 /// 0: Suppress all vtordisps
677 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
678 /// structors
679 /// 2: Always insert vtordisps to support RTTI on partially constructed
680 /// objects
681 PragmaStack<MSVtorDispMode> VtorDispStack;
682 PragmaStack<AlignPackInfo> AlignPackStack;
683 // The current #pragma align/pack values and locations at each #include.
684 struct AlignPackIncludeState {
685 AlignPackInfo CurrentValue;
686 SourceLocation CurrentPragmaLocation;
687 bool HasNonDefaultValue, ShouldWarnOnInclude;
688 };
689 SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack;
690 // Segment #pragmas.
691 PragmaStack<StringLiteral *> DataSegStack;
692 PragmaStack<StringLiteral *> BSSSegStack;
693 PragmaStack<StringLiteral *> ConstSegStack;
694 PragmaStack<StringLiteral *> CodeSegStack;
695
696 // This stack tracks the current state of Sema.CurFPFeatures.
697 PragmaStack<FPOptionsOverride> FpPragmaStack;
698 FPOptionsOverride CurFPFeatureOverrides() {
699 FPOptionsOverride result;
700 if (!FpPragmaStack.hasValue()) {
701 result = FPOptionsOverride();
702 } else {
703 result = FpPragmaStack.CurrentValue;
704 }
705 return result;
706 }
707
708 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
709 // Actions should be performed only if we enter / exit a C++ method body.
710 class PragmaStackSentinelRAII {
711 public:
712 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
713 ~PragmaStackSentinelRAII();
714
715 private:
716 Sema &S;
717 StringRef SlotLabel;
718 bool ShouldAct;
719 };
720
721 /// A mapping that describes the nullability we've seen in each header file.
722 FileNullabilityMap NullabilityMap;
723
724 /// Last section used with #pragma init_seg.
725 StringLiteral *CurInitSeg;
726 SourceLocation CurInitSegLoc;
727
728 /// VisContext - Manages the stack for \#pragma GCC visibility.
729 void *VisContext; // Really a "PragmaVisStack*"
730
731 /// This an attribute introduced by \#pragma clang attribute.
732 struct PragmaAttributeEntry {
733 SourceLocation Loc;
734 ParsedAttr *Attribute;
735 SmallVector<attr::SubjectMatchRule, 4> MatchRules;
736 bool IsUsed;
737 };
738
739 /// A push'd group of PragmaAttributeEntries.
740 struct PragmaAttributeGroup {
741 /// The location of the push attribute.
742 SourceLocation Loc;
743 /// The namespace of this push group.
744 const IdentifierInfo *Namespace;
745 SmallVector<PragmaAttributeEntry, 2> Entries;
746 };
747
748 SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
749
750 /// The declaration that is currently receiving an attribute from the
751 /// #pragma attribute stack.
752 const Decl *PragmaAttributeCurrentTargetDecl;
753
754 /// This represents the last location of a "#pragma clang optimize off"
755 /// directive if such a directive has not been closed by an "on" yet. If
756 /// optimizations are currently "on", this is set to an invalid location.
757 SourceLocation OptimizeOffPragmaLocation;
758
759 /// Flag indicating if Sema is building a recovery call expression.
760 ///
761 /// This flag is used to avoid building recovery call expressions
762 /// if Sema is already doing so, which would cause infinite recursions.
763 bool IsBuildingRecoveryCallExpr;
764
765 /// Used to control the generation of ExprWithCleanups.
766 CleanupInfo Cleanup;
767
768 /// ExprCleanupObjects - This is the stack of objects requiring
769 /// cleanup that are created by the current full expression.
770 SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
771
772 /// Store a set of either DeclRefExprs or MemberExprs that contain a reference
773 /// to a variable (constant) that may or may not be odr-used in this Expr, and
774 /// we won't know until all lvalue-to-rvalue and discarded value conversions
775 /// have been applied to all subexpressions of the enclosing full expression.
776 /// This is cleared at the end of each full expression.
777 using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>,
778 llvm::SmallPtrSet<Expr *, 4>>;
779 MaybeODRUseExprSet MaybeODRUseExprs;
780
781 std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
782
783 /// Stack containing information about each of the nested
784 /// function, block, and method scopes that are currently active.
785 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
786
787 /// The index of the first FunctionScope that corresponds to the current
788 /// context.
789 unsigned FunctionScopesStart = 0;
790
791 ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
792 return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
793 FunctionScopes.end());
794 }
795
796 /// Stack containing information needed when in C++2a an 'auto' is encountered
797 /// in a function declaration parameter type specifier in order to invent a
798 /// corresponding template parameter in the enclosing abbreviated function
799 /// template. This information is also present in LambdaScopeInfo, stored in
800 /// the FunctionScopes stack.
801 SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;
802
803 /// The index of the first InventedParameterInfo that refers to the current
804 /// context.
805 unsigned InventedParameterInfosStart = 0;
806
807 ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
808 return llvm::makeArrayRef(InventedParameterInfos.begin() +
809 InventedParameterInfosStart,
810 InventedParameterInfos.end());
811 }
812
813 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
814 &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
815 ExtVectorDeclsType;
816
817 /// ExtVectorDecls - This is a list all the extended vector types. This allows
818 /// us to associate a raw vector type with one of the ext_vector type names.
819 /// This is only necessary for issuing pretty diagnostics.
820 ExtVectorDeclsType ExtVectorDecls;
821
822 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
823 std::unique_ptr<CXXFieldCollector> FieldCollector;
824
825 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
826
827 /// Set containing all declared private fields that are not used.
828 NamedDeclSetType UnusedPrivateFields;
829
830 /// Set containing all typedefs that are likely unused.
831 llvm::SmallSetVector<const TypedefNameDecl *, 4>
832 UnusedLocalTypedefNameCandidates;
833
834 /// Delete-expressions to be analyzed at the end of translation unit
835 ///
836 /// This list contains class members, and locations of delete-expressions
837 /// that could not be proven as to whether they mismatch with new-expression
838 /// used in initializer of the field.
839 typedef std::pair<SourceLocation, bool> DeleteExprLoc;
840 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
841 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
842
843 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
844
845 /// PureVirtualClassDiagSet - a set of class declarations which we have
846 /// emitted a list of pure virtual functions. Used to prevent emitting the
847 /// same list more than once.
848 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
849
850 /// ParsingInitForAutoVars - a set of declarations with auto types for which
851 /// we are currently parsing the initializer.
852 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
853
854 /// Look for a locally scoped extern "C" declaration by the given name.
855 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
856
857 typedef LazyVector<VarDecl *, ExternalSemaSource,
858 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
859 TentativeDefinitionsType;
860
861 /// All the tentative definitions encountered in the TU.
862 TentativeDefinitionsType TentativeDefinitions;
863
864 /// All the external declarations encoutered and used in the TU.
865 SmallVector<VarDecl *, 4> ExternalDeclarations;
866
867 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
868 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
869 UnusedFileScopedDeclsType;
870
871 /// The set of file scoped decls seen so far that have not been used
872 /// and must warn if not used. Only contains the first declaration.
873 UnusedFileScopedDeclsType UnusedFileScopedDecls;
874
875 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
876 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
877 DelegatingCtorDeclsType;
878
879 /// All the delegating constructors seen so far in the file, used for
880 /// cycle detection at the end of the TU.
881 DelegatingCtorDeclsType DelegatingCtorDecls;
882
883 /// All the overriding functions seen during a class definition
884 /// that had their exception spec checks delayed, plus the overridden
885 /// function.
886 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
887 DelayedOverridingExceptionSpecChecks;
888
889 /// All the function redeclarations seen during a class definition that had
890 /// their exception spec checks delayed, plus the prior declaration they
891 /// should be checked against. Except during error recovery, the new decl
892 /// should always be a friend declaration, as that's the only valid way to
893 /// redeclare a special member before its class is complete.
894 SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2>
895 DelayedEquivalentExceptionSpecChecks;
896
897 typedef llvm::MapVector<const FunctionDecl *,
898 std::unique_ptr<LateParsedTemplate>>
899 LateParsedTemplateMapT;
900 LateParsedTemplateMapT LateParsedTemplateMap;
901
902 /// Callback to the parser to parse templated functions when needed.
903 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
904 typedef void LateTemplateParserCleanupCB(void *P);
905 LateTemplateParserCB *LateTemplateParser;
906 LateTemplateParserCleanupCB *LateTemplateParserCleanup;
907 void *OpaqueParser;
908
909 void SetLateTemplateParser(LateTemplateParserCB *LTP,
910 LateTemplateParserCleanupCB *LTPCleanup,
911 void *P) {
912 LateTemplateParser = LTP;
913 LateTemplateParserCleanup = LTPCleanup;
914 OpaqueParser = P;
915 }
916
917 // Does the work necessary to deal with a SYCL kernel lambda. At the moment,
918 // this just marks the list of lambdas required to name the kernel.
919 void AddSYCLKernelLambda(const FunctionDecl *FD);
920
921 class DelayedDiagnostics;
922
923 class DelayedDiagnosticsState {
924 sema::DelayedDiagnosticPool *SavedPool;
925 friend class Sema::DelayedDiagnostics;
926 };
927 typedef DelayedDiagnosticsState ParsingDeclState;
928 typedef DelayedDiagnosticsState ProcessingContextState;
929
930 /// A class which encapsulates the logic for delaying diagnostics
931 /// during parsing and other processing.
932 class DelayedDiagnostics {
933 /// The current pool of diagnostics into which delayed
934 /// diagnostics should go.
935 sema::DelayedDiagnosticPool *CurPool;
936
937 public:
938 DelayedDiagnostics() : CurPool(nullptr) {}
939
940 /// Adds a delayed diagnostic.
941 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
942
943 /// Determines whether diagnostics should be delayed.
944 bool shouldDelayDiagnostics() { return CurPool != nullptr; }
945
946 /// Returns the current delayed-diagnostics pool.
947 sema::DelayedDiagnosticPool *getCurrentPool() const {
948 return CurPool;
949 }
950
951 /// Enter a new scope. Access and deprecation diagnostics will be
952 /// collected in this pool.
953 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
954 DelayedDiagnosticsState state;
955 state.SavedPool = CurPool;
956 CurPool = &pool;
957 return state;
958 }
959
960 /// Leave a delayed-diagnostic state that was previously pushed.
961 /// Do not emit any of the diagnostics. This is performed as part
962 /// of the bookkeeping of popping a pool "properly".
963 void popWithoutEmitting(DelayedDiagnosticsState state) {
964 CurPool = state.SavedPool;
965 }
966
967 /// Enter a new scope where access and deprecation diagnostics are
968 /// not delayed.
969 DelayedDiagnosticsState pushUndelayed() {
970 DelayedDiagnosticsState state;
971 state.SavedPool = CurPool;
972 CurPool = nullptr;
973 return state;
974 }
975
976 /// Undo a previous pushUndelayed().
977 void popUndelayed(DelayedDiagnosticsState state) {
978 assert(CurPool == nullptr)(static_cast <bool> (CurPool == nullptr) ? void (0) : __assert_fail
("CurPool == nullptr", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 978, __extension__ __PRETTY_FUNCTION__))
;
979 CurPool = state.SavedPool;
980 }
981 } DelayedDiagnostics;
982
983 /// A RAII object to temporarily push a declaration context.
984 class ContextRAII {
985 private:
986 Sema &S;
987 DeclContext *SavedContext;
988 ProcessingContextState SavedContextState;
989 QualType SavedCXXThisTypeOverride;
990 unsigned SavedFunctionScopesStart;
991 unsigned SavedInventedParameterInfosStart;
992
993 public:
994 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
995 : S(S), SavedContext(S.CurContext),
996 SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
997 SavedCXXThisTypeOverride(S.CXXThisTypeOverride),
998 SavedFunctionScopesStart(S.FunctionScopesStart),
999 SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
1000 {
1001 assert(ContextToPush && "pushing null context")(static_cast <bool> (ContextToPush && "pushing null context"
) ? void (0) : __assert_fail ("ContextToPush && \"pushing null context\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 1001, __extension__ __PRETTY_FUNCTION__))
;
1002 S.CurContext = ContextToPush;
1003 if (NewThisContext)
1004 S.CXXThisTypeOverride = QualType();
1005 // Any saved FunctionScopes do not refer to this context.
1006 S.FunctionScopesStart = S.FunctionScopes.size();
1007 S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1008 }
1009
1010 void pop() {
1011 if (!SavedContext) return;
1012 S.CurContext = SavedContext;
1013 S.DelayedDiagnostics.popUndelayed(SavedContextState);
1014 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1015 S.FunctionScopesStart = SavedFunctionScopesStart;
1016 S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1017 SavedContext = nullptr;
1018 }
1019
1020 ~ContextRAII() {
1021 pop();
1022 }
1023 };
1024
1025 /// Whether the AST is currently being rebuilt to correct immediate
1026 /// invocations. Immediate invocation candidates and references to consteval
1027 /// functions aren't tracked when this is set.
1028 bool RebuildingImmediateInvocation = false;
1029
1030 /// Used to change context to isConstantEvaluated without pushing a heavy
1031 /// ExpressionEvaluationContextRecord object.
1032 bool isConstantEvaluatedOverride;
1033
1034 bool isConstantEvaluated() {
1035 return ExprEvalContexts.back().isConstantEvaluated() ||
1036 isConstantEvaluatedOverride;
1037 }
1038
1039 /// RAII object to handle the state changes required to synthesize
1040 /// a function body.
1041 class SynthesizedFunctionScope {
1042 Sema &S;
1043 Sema::ContextRAII SavedContext;
1044 bool PushedCodeSynthesisContext = false;
1045
1046 public:
1047 SynthesizedFunctionScope(Sema &S, DeclContext *DC)
1048 : S(S), SavedContext(S, DC) {
1049 S.PushFunctionScope();
1050 S.PushExpressionEvaluationContext(
1051 Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1052 if (auto *FD = dyn_cast<FunctionDecl>(DC))
1053 FD->setWillHaveBody(true);
1054 else
1055 assert(isa<ObjCMethodDecl>(DC))(static_cast <bool> (isa<ObjCMethodDecl>(DC)) ? void
(0) : __assert_fail ("isa<ObjCMethodDecl>(DC)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 1055, __extension__ __PRETTY_FUNCTION__))
;
1056 }
1057
1058 void addContextNote(SourceLocation UseLoc) {
1059 assert(!PushedCodeSynthesisContext)(static_cast <bool> (!PushedCodeSynthesisContext) ? void
(0) : __assert_fail ("!PushedCodeSynthesisContext", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 1059, __extension__ __PRETTY_FUNCTION__))
;
1060
1061 Sema::CodeSynthesisContext Ctx;
1062 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
1063 Ctx.PointOfInstantiation = UseLoc;
1064 Ctx.Entity = cast<Decl>(S.CurContext);
1065 S.pushCodeSynthesisContext(Ctx);
1066
1067 PushedCodeSynthesisContext = true;
1068 }
1069
1070 ~SynthesizedFunctionScope() {
1071 if (PushedCodeSynthesisContext)
1072 S.popCodeSynthesisContext();
1073 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1074 FD->setWillHaveBody(false);
1075 S.PopExpressionEvaluationContext();
1076 S.PopFunctionScopeInfo();
1077 }
1078 };
1079
1080 /// WeakUndeclaredIdentifiers - Identifiers contained in
1081 /// \#pragma weak before declared. rare. may alias another
1082 /// identifier, declared or undeclared
1083 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
1084
1085 /// ExtnameUndeclaredIdentifiers - Identifiers contained in
1086 /// \#pragma redefine_extname before declared. Used in Solaris system headers
1087 /// to define functions that occur in multiple standards to call the version
1088 /// in the currently selected standard.
1089 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
1090
1091
1092 /// Load weak undeclared identifiers from the external source.
1093 void LoadExternalWeakUndeclaredIdentifiers();
1094
1095 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
1096 /// \#pragma weak during processing of other Decls.
1097 /// I couldn't figure out a clean way to generate these in-line, so
1098 /// we store them here and handle separately -- which is a hack.
1099 /// It would be best to refactor this.
1100 SmallVector<Decl*,2> WeakTopLevelDecl;
1101
1102 IdentifierResolver IdResolver;
1103
1104 /// Translation Unit Scope - useful to Objective-C actions that need
1105 /// to lookup file scope declarations in the "ordinary" C decl namespace.
1106 /// For example, user-defined classes, built-in "id" type, etc.
1107 Scope *TUScope;
1108
1109 /// The C++ "std" namespace, where the standard library resides.
1110 LazyDeclPtr StdNamespace;
1111
1112 /// The C++ "std::bad_alloc" class, which is defined by the C++
1113 /// standard library.
1114 LazyDeclPtr StdBadAlloc;
1115
1116 /// The C++ "std::align_val_t" enum class, which is defined by the C++
1117 /// standard library.
1118 LazyDeclPtr StdAlignValT;
1119
1120 /// The C++ "std::experimental" namespace, where the experimental parts
1121 /// of the standard library resides.
1122 NamespaceDecl *StdExperimentalNamespaceCache;
1123
1124 /// The C++ "std::initializer_list" template, which is defined in
1125 /// \<initializer_list>.
1126 ClassTemplateDecl *StdInitializerList;
1127
1128 /// The C++ "std::coroutine_traits" template, which is defined in
1129 /// \<coroutine_traits>
1130 ClassTemplateDecl *StdCoroutineTraitsCache;
1131
1132 /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
1133 RecordDecl *CXXTypeInfoDecl;
1134
1135 /// The MSVC "_GUID" struct, which is defined in MSVC header files.
1136 RecordDecl *MSVCGuidDecl;
1137
1138 /// Caches identifiers/selectors for NSFoundation APIs.
1139 std::unique_ptr<NSAPI> NSAPIObj;
1140
1141 /// The declaration of the Objective-C NSNumber class.
1142 ObjCInterfaceDecl *NSNumberDecl;
1143
1144 /// The declaration of the Objective-C NSValue class.
1145 ObjCInterfaceDecl *NSValueDecl;
1146
1147 /// Pointer to NSNumber type (NSNumber *).
1148 QualType NSNumberPointer;
1149
1150 /// Pointer to NSValue type (NSValue *).
1151 QualType NSValuePointer;
1152
1153 /// The Objective-C NSNumber methods used to create NSNumber literals.
1154 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
1155
1156 /// The declaration of the Objective-C NSString class.
1157 ObjCInterfaceDecl *NSStringDecl;
1158
1159 /// Pointer to NSString type (NSString *).
1160 QualType NSStringPointer;
1161
1162 /// The declaration of the stringWithUTF8String: method.
1163 ObjCMethodDecl *StringWithUTF8StringMethod;
1164
1165 /// The declaration of the valueWithBytes:objCType: method.
1166 ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1167
1168 /// The declaration of the Objective-C NSArray class.
1169 ObjCInterfaceDecl *NSArrayDecl;
1170
1171 /// The declaration of the arrayWithObjects:count: method.
1172 ObjCMethodDecl *ArrayWithObjectsMethod;
1173
1174 /// The declaration of the Objective-C NSDictionary class.
1175 ObjCInterfaceDecl *NSDictionaryDecl;
1176
1177 /// The declaration of the dictionaryWithObjects:forKeys:count: method.
1178 ObjCMethodDecl *DictionaryWithObjectsMethod;
1179
1180 /// id<NSCopying> type.
1181 QualType QIDNSCopying;
1182
1183 /// will hold 'respondsToSelector:'
1184 Selector RespondsToSelectorSel;
1185
1186 /// A flag to remember whether the implicit forms of operator new and delete
1187 /// have been declared.
1188 bool GlobalNewDeleteDeclared;
1189
1190 /// Describes how the expressions currently being parsed are
1191 /// evaluated at run-time, if at all.
1192 enum class ExpressionEvaluationContext {
1193 /// The current expression and its subexpressions occur within an
1194 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1195 /// \c sizeof, where the type of the expression may be significant but
1196 /// no code will be generated to evaluate the value of the expression at
1197 /// run time.
1198 Unevaluated,
1199
1200 /// The current expression occurs within a braced-init-list within
1201 /// an unevaluated operand. This is mostly like a regular unevaluated
1202 /// context, except that we still instantiate constexpr functions that are
1203 /// referenced here so that we can perform narrowing checks correctly.
1204 UnevaluatedList,
1205
1206 /// The current expression occurs within a discarded statement.
1207 /// This behaves largely similarly to an unevaluated operand in preventing
1208 /// definitions from being required, but not in other ways.
1209 DiscardedStatement,
1210
1211 /// The current expression occurs within an unevaluated
1212 /// operand that unconditionally permits abstract references to
1213 /// fields, such as a SIZE operator in MS-style inline assembly.
1214 UnevaluatedAbstract,
1215
1216 /// The current context is "potentially evaluated" in C++11 terms,
1217 /// but the expression is evaluated at compile-time (like the values of
1218 /// cases in a switch statement).
1219 ConstantEvaluated,
1220
1221 /// The current expression is potentially evaluated at run time,
1222 /// which means that code may be generated to evaluate the value of the
1223 /// expression at run time.
1224 PotentiallyEvaluated,
1225
1226 /// The current expression is potentially evaluated, but any
1227 /// declarations referenced inside that expression are only used if
1228 /// in fact the current expression is used.
1229 ///
1230 /// This value is used when parsing default function arguments, for which
1231 /// we would like to provide diagnostics (e.g., passing non-POD arguments
1232 /// through varargs) but do not want to mark declarations as "referenced"
1233 /// until the default argument is used.
1234 PotentiallyEvaluatedIfUsed
1235 };
1236
1237 using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
1238
1239 /// Data structure used to record current or nested
1240 /// expression evaluation contexts.
1241 struct ExpressionEvaluationContextRecord {
1242 /// The expression evaluation context.
1243 ExpressionEvaluationContext Context;
1244
1245 /// Whether the enclosing context needed a cleanup.
1246 CleanupInfo ParentCleanup;
1247
1248 /// The number of active cleanup objects when we entered
1249 /// this expression evaluation context.
1250 unsigned NumCleanupObjects;
1251
1252 /// The number of typos encountered during this expression evaluation
1253 /// context (i.e. the number of TypoExprs created).
1254 unsigned NumTypos;
1255
1256 MaybeODRUseExprSet SavedMaybeODRUseExprs;
1257
1258 /// The lambdas that are present within this context, if it
1259 /// is indeed an unevaluated context.
1260 SmallVector<LambdaExpr *, 2> Lambdas;
1261
1262 /// The declaration that provides context for lambda expressions
1263 /// and block literals if the normal declaration context does not
1264 /// suffice, e.g., in a default function argument.
1265 Decl *ManglingContextDecl;
1266
1267 /// If we are processing a decltype type, a set of call expressions
1268 /// for which we have deferred checking the completeness of the return type.
1269 SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
1270
1271 /// If we are processing a decltype type, a set of temporary binding
1272 /// expressions for which we have deferred checking the destructor.
1273 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
1274
1275 llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1276
1277 /// Expressions appearing as the LHS of a volatile assignment in this
1278 /// context. We produce a warning for these when popping the context if
1279 /// they are not discarded-value expressions nor unevaluated operands.
1280 SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1281
1282 /// Set of candidates for starting an immediate invocation.
1283 llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;
1284
1285 /// Set of DeclRefExprs referencing a consteval function when used in a
1286 /// context not already known to be immediately invoked.
1287 llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;
1288
1289 /// \brief Describes whether we are in an expression constext which we have
1290 /// to handle differently.
1291 enum ExpressionKind {
1292 EK_Decltype, EK_TemplateArgument, EK_Other
1293 } ExprContext;
1294
1295 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1296 unsigned NumCleanupObjects,
1297 CleanupInfo ParentCleanup,
1298 Decl *ManglingContextDecl,
1299 ExpressionKind ExprContext)
1300 : Context(Context), ParentCleanup(ParentCleanup),
1301 NumCleanupObjects(NumCleanupObjects), NumTypos(0),
1302 ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
1303
1304 bool isUnevaluated() const {
1305 return Context == ExpressionEvaluationContext::Unevaluated ||
1306 Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
1307 Context == ExpressionEvaluationContext::UnevaluatedList;
1308 }
1309 bool isConstantEvaluated() const {
1310 return Context == ExpressionEvaluationContext::ConstantEvaluated;
1311 }
1312 };
1313
1314 /// A stack of expression evaluation contexts.
1315 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1316
1317 /// Emit a warning for all pending noderef expressions that we recorded.
1318 void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1319
1320 /// Compute the mangling number context for a lambda expression or
1321 /// block literal. Also return the extra mangling decl if any.
1322 ///
1323 /// \param DC - The DeclContext containing the lambda expression or
1324 /// block literal.
1325 std::tuple<MangleNumberingContext *, Decl *>
1326 getCurrentMangleNumberContext(const DeclContext *DC);
1327
1328
1329 /// SpecialMemberOverloadResult - The overloading result for a special member
1330 /// function.
1331 ///
1332 /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1333 /// integer are used to determine whether overload resolution succeeded.
1334 class SpecialMemberOverloadResult {
1335 public:
1336 enum Kind {
1337 NoMemberOrDeleted,
1338 Ambiguous,
1339 Success
1340 };
1341
1342 private:
1343 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1344
1345 public:
1346 SpecialMemberOverloadResult() : Pair() {}
1347 SpecialMemberOverloadResult(CXXMethodDecl *MD)
1348 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1349
1350 CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1351 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1352
1353 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1354 void setKind(Kind K) { Pair.setInt(K); }
1355 };
1356
1357 class SpecialMemberOverloadResultEntry
1358 : public llvm::FastFoldingSetNode,
1359 public SpecialMemberOverloadResult {
1360 public:
1361 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1362 : FastFoldingSetNode(ID)
1363 {}
1364 };
1365
1366 /// A cache of special member function overload resolution results
1367 /// for C++ records.
1368 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1369
1370 /// A cache of the flags available in enumerations with the flag_bits
1371 /// attribute.
1372 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1373
1374 /// The kind of translation unit we are processing.
1375 ///
1376 /// When we're processing a complete translation unit, Sema will perform
1377 /// end-of-translation-unit semantic tasks (such as creating
1378 /// initializers for tentative definitions in C) once parsing has
1379 /// completed. Modules and precompiled headers perform different kinds of
1380 /// checks.
1381 const TranslationUnitKind TUKind;
1382
1383 llvm::BumpPtrAllocator BumpAlloc;
1384
1385 /// The number of SFINAE diagnostics that have been trapped.
1386 unsigned NumSFINAEErrors;
1387
1388 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1389 UnparsedDefaultArgInstantiationsMap;
1390
1391 /// A mapping from parameters with unparsed default arguments to the
1392 /// set of instantiations of each parameter.
1393 ///
1394 /// This mapping is a temporary data structure used when parsing
1395 /// nested class templates or nested classes of class templates,
1396 /// where we might end up instantiating an inner class before the
1397 /// default arguments of its methods have been parsed.
1398 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1399
1400 // Contains the locations of the beginning of unparsed default
1401 // argument locations.
1402 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1403
1404 /// UndefinedInternals - all the used, undefined objects which require a
1405 /// definition in this translation unit.
1406 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1407
1408 /// Determine if VD, which must be a variable or function, is an external
1409 /// symbol that nonetheless can't be referenced from outside this translation
1410 /// unit because its type has no linkage and it's not extern "C".
1411 bool isExternalWithNoLinkageType(ValueDecl *VD);
1412
1413 /// Obtain a sorted list of functions that are undefined but ODR-used.
1414 void getUndefinedButUsed(
1415 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1416
1417 /// Retrieves list of suspicious delete-expressions that will be checked at
1418 /// the end of translation unit.
1419 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1420 getMismatchingDeleteExpressions() const;
1421
1422 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1423 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1424
1425 /// Method Pool - allows efficient lookup when typechecking messages to "id".
1426 /// We need to maintain a list, since selectors can have differing signatures
1427 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1428 /// of selectors are "overloaded").
1429 /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1430 /// methods inside categories with a particular selector.
1431 GlobalMethodPool MethodPool;
1432
1433 /// Method selectors used in a \@selector expression. Used for implementation
1434 /// of -Wselector.
1435 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1436
1437 /// List of SourceLocations where 'self' is implicitly retained inside a
1438 /// block.
1439 llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>
1440 ImplicitlyRetainedSelfLocs;
1441
1442 /// Kinds of C++ special members.
1443 enum CXXSpecialMember {
1444 CXXDefaultConstructor,
1445 CXXCopyConstructor,
1446 CXXMoveConstructor,
1447 CXXCopyAssignment,
1448 CXXMoveAssignment,
1449 CXXDestructor,
1450 CXXInvalid
1451 };
1452
1453 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1454 SpecialMemberDecl;
1455
1456 /// The C++ special members which we are currently in the process of
1457 /// declaring. If this process recursively triggers the declaration of the
1458 /// same special member, we should act as if it is not yet declared.
1459 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1460
1461 /// Kinds of defaulted comparison operator functions.
1462 enum class DefaultedComparisonKind : unsigned char {
1463 /// This is not a defaultable comparison operator.
1464 None,
1465 /// This is an operator== that should be implemented as a series of
1466 /// subobject comparisons.
1467 Equal,
1468 /// This is an operator<=> that should be implemented as a series of
1469 /// subobject comparisons.
1470 ThreeWay,
1471 /// This is an operator!= that should be implemented as a rewrite in terms
1472 /// of a == comparison.
1473 NotEqual,
1474 /// This is an <, <=, >, or >= that should be implemented as a rewrite in
1475 /// terms of a <=> comparison.
1476 Relational,
1477 };
1478
1479 /// The function definitions which were renamed as part of typo-correction
1480 /// to match their respective declarations. We want to keep track of them
1481 /// to ensure that we don't emit a "redefinition" error if we encounter a
1482 /// correctly named definition after the renamed definition.
1483 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1484
1485 /// Stack of types that correspond to the parameter entities that are
1486 /// currently being copy-initialized. Can be empty.
1487 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1488
1489 void ReadMethodPool(Selector Sel);
1490 void updateOutOfDateSelector(Selector Sel);
1491
1492 /// Private Helper predicate to check for 'self'.
1493 bool isSelfExpr(Expr *RExpr);
1494 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1495
1496 /// Cause the active diagnostic on the DiagosticsEngine to be
1497 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1498 /// should not be used elsewhere.
1499 void EmitCurrentDiagnostic(unsigned DiagID);
1500
1501 /// Records and restores the CurFPFeatures state on entry/exit of compound
1502 /// statements.
1503 class FPFeaturesStateRAII {
1504 public:
1505 FPFeaturesStateRAII(Sema &S);
1506 ~FPFeaturesStateRAII();
1507 FPOptionsOverride getOverrides() { return OldOverrides; }
1508
1509 private:
1510 Sema& S;
1511 FPOptions OldFPFeaturesState;
1512 FPOptionsOverride OldOverrides;
1513 int OldEvalMethod;
1514 };
1515
1516 void addImplicitTypedef(StringRef Name, QualType T);
1517
1518 bool WarnedStackExhausted = false;
1519
1520 /// Increment when we find a reference; decrement when we find an ignored
1521 /// assignment. Ultimately the value is 0 if every reference is an ignored
1522 /// assignment.
1523 llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;
1524
1525 Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1526
1527public:
1528 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1529 TranslationUnitKind TUKind = TU_Complete,
1530 CodeCompleteConsumer *CompletionConsumer = nullptr);
1531 ~Sema();
1532
1533 /// Perform initialization that occurs after the parser has been
1534 /// initialized but before it parses anything.
1535 void Initialize();
1536
1537 /// This virtual key function only exists to limit the emission of debug info
1538 /// describing the Sema class. GCC and Clang only emit debug info for a class
1539 /// with a vtable when the vtable is emitted. Sema is final and not
1540 /// polymorphic, but the debug info size savings are so significant that it is
1541 /// worth adding a vtable just to take advantage of this optimization.
1542 virtual void anchor();
1543
1544 const LangOptions &getLangOpts() const { return LangOpts; }
1545 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1546 FPOptions &getCurFPFeatures() { return CurFPFeatures; }
1547
1548 DiagnosticsEngine &getDiagnostics() const { return Diags; }
1549 SourceManager &getSourceManager() const { return SourceMgr; }
1550 Preprocessor &getPreprocessor() const { return PP; }
1551 ASTContext &getASTContext() const { return Context; }
1552 ASTConsumer &getASTConsumer() const { return Consumer; }
1553 ASTMutationListener *getASTMutationListener() const;
1554 ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1555 DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,
1556 StringRef Platform);
1557
1558 ///Registers an external source. If an external source already exists,
1559 /// creates a multiplex external source and appends to it.
1560 ///
1561 ///\param[in] E - A non-null external sema source.
1562 ///
1563 void addExternalSource(ExternalSemaSource *E);
1564
1565 void PrintStats() const;
1566
1567 /// Warn that the stack is nearly exhausted.
1568 void warnStackExhausted(SourceLocation Loc);
1569
1570 /// Run some code with "sufficient" stack space. (Currently, at least 256K is
1571 /// guaranteed). Produces a warning if we're low on stack space and allocates
1572 /// more in that case. Use this in code that may recurse deeply (for example,
1573 /// in template instantiation) to avoid stack overflow.
1574 void runWithSufficientStackSpace(SourceLocation Loc,
1575 llvm::function_ref<void()> Fn);
1576
1577 /// Helper class that creates diagnostics with optional
1578 /// template instantiation stacks.
1579 ///
1580 /// This class provides a wrapper around the basic DiagnosticBuilder
1581 /// class that emits diagnostics. ImmediateDiagBuilder is
1582 /// responsible for emitting the diagnostic (as DiagnosticBuilder
1583 /// does) and, if the diagnostic comes from inside a template
1584 /// instantiation, printing the template instantiation stack as
1585 /// well.
1586 class ImmediateDiagBuilder : public DiagnosticBuilder {
1587 Sema &SemaRef;
1588 unsigned DiagID;
1589
1590 public:
1591 ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1592 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1593 ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1594 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1595
1596 // This is a cunning lie. DiagnosticBuilder actually performs move
1597 // construction in its copy constructor (but due to varied uses, it's not
1598 // possible to conveniently express this as actual move construction). So
1599 // the default copy ctor here is fine, because the base class disables the
1600 // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1601 // in that case anwyay.
1602 ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1603
1604 ~ImmediateDiagBuilder() {
1605 // If we aren't active, there is nothing to do.
1606 if (!isActive()) return;
1607
1608 // Otherwise, we need to emit the diagnostic. First clear the diagnostic
1609 // builder itself so it won't emit the diagnostic in its own destructor.
1610 //
1611 // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1612 // do its own needless checks to see if the diagnostic needs to be
1613 // emitted. However, because we take care to ensure that the builder
1614 // objects never escape, a sufficiently smart compiler will be able to
1615 // eliminate that code.
1616 Clear();
1617
1618 // Dispatch to Sema to emit the diagnostic.
1619 SemaRef.EmitCurrentDiagnostic(DiagID);
1620 }
1621
1622 /// Teach operator<< to produce an object of the correct type.
1623 template <typename T>
1624 friend const ImmediateDiagBuilder &
1625 operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1626 const DiagnosticBuilder &BaseDiag = Diag;
1627 BaseDiag << Value;
1628 return Diag;
1629 }
1630
1631 // It is necessary to limit this to rvalue reference to avoid calling this
1632 // function with a bitfield lvalue argument since non-const reference to
1633 // bitfield is not allowed.
1634 template <typename T, typename = typename std::enable_if<
1635 !std::is_lvalue_reference<T>::value>::type>
1636 const ImmediateDiagBuilder &operator<<(T &&V) const {
1637 const DiagnosticBuilder &BaseDiag = *this;
1638 BaseDiag << std::move(V);
1639 return *this;
1640 }
1641 };
1642
1643 /// A generic diagnostic builder for errors which may or may not be deferred.
1644 ///
1645 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1646 /// which are not allowed to appear inside __device__ functions and are
1647 /// allowed to appear in __host__ __device__ functions only if the host+device
1648 /// function is never codegen'ed.
1649 ///
1650 /// To handle this, we use the notion of "deferred diagnostics", where we
1651 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1652 ///
1653 /// This class lets you emit either a regular diagnostic, a deferred
1654 /// diagnostic, or no diagnostic at all, according to an argument you pass to
1655 /// its constructor, thus simplifying the process of creating these "maybe
1656 /// deferred" diagnostics.
1657 class SemaDiagnosticBuilder {
1658 public:
1659 enum Kind {
1660 /// Emit no diagnostics.
1661 K_Nop,
1662 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1663 K_Immediate,
1664 /// Emit the diagnostic immediately, and, if it's a warning or error, also
1665 /// emit a call stack showing how this function can be reached by an a
1666 /// priori known-emitted function.
1667 K_ImmediateWithCallStack,
1668 /// Create a deferred diagnostic, which is emitted only if the function
1669 /// it's attached to is codegen'ed. Also emit a call stack as with
1670 /// K_ImmediateWithCallStack.
1671 K_Deferred
1672 };
1673
1674 SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1675 FunctionDecl *Fn, Sema &S);
1676 SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1677 SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1678 ~SemaDiagnosticBuilder();
1679
1680 bool isImmediate() const { return ImmediateDiag.hasValue(); }
1681
1682 /// Convertible to bool: True if we immediately emitted an error, false if
1683 /// we didn't emit an error or we created a deferred error.
1684 ///
1685 /// Example usage:
1686 ///
1687 /// if (SemaDiagnosticBuilder(...) << foo << bar)
1688 /// return ExprError();
1689 ///
1690 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1691 /// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1692 operator bool() const { return isImmediate(); }
1693
1694 template <typename T>
1695 friend const SemaDiagnosticBuilder &
1696 operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1697 if (Diag.ImmediateDiag.hasValue())
1698 *Diag.ImmediateDiag << Value;
1699 else if (Diag.PartialDiagId.hasValue())
1700 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1701 << Value;
1702 return Diag;
1703 }
1704
1705 // It is necessary to limit this to rvalue reference to avoid calling this
1706 // function with a bitfield lvalue argument since non-const reference to
1707 // bitfield is not allowed.
1708 template <typename T, typename = typename std::enable_if<
1709 !std::is_lvalue_reference<T>::value>::type>
1710 const SemaDiagnosticBuilder &operator<<(T &&V) const {
1711 if (ImmediateDiag.hasValue())
1712 *ImmediateDiag << std::move(V);
1713 else if (PartialDiagId.hasValue())
1714 S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V);
1715 return *this;
1716 }
1717
1718 friend const SemaDiagnosticBuilder &
1719 operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {
1720 if (Diag.ImmediateDiag.hasValue())
1721 PD.Emit(*Diag.ImmediateDiag);
1722 else if (Diag.PartialDiagId.hasValue())
1723 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD;
1724 return Diag;
1725 }
1726
1727 void AddFixItHint(const FixItHint &Hint) const {
1728 if (ImmediateDiag.hasValue())
1729 ImmediateDiag->AddFixItHint(Hint);
1730 else if (PartialDiagId.hasValue())
1731 S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint);
1732 }
1733
1734 friend ExprResult ExprError(const SemaDiagnosticBuilder &) {
1735 return ExprError();
1736 }
1737 friend StmtResult StmtError(const SemaDiagnosticBuilder &) {
1738 return StmtError();
1739 }
1740 operator ExprResult() const { return ExprError(); }
1741 operator StmtResult() const { return StmtError(); }
1742 operator TypeResult() const { return TypeError(); }
1743 operator DeclResult() const { return DeclResult(true); }
1744 operator MemInitResult() const { return MemInitResult(true); }
1745
1746 private:
1747 Sema &S;
1748 SourceLocation Loc;
1749 unsigned DiagID;
1750 FunctionDecl *Fn;
1751 bool ShowCallStack;
1752
1753 // Invariant: At most one of these Optionals has a value.
1754 // FIXME: Switch these to a Variant once that exists.
1755 llvm::Optional<ImmediateDiagBuilder> ImmediateDiag;
1756 llvm::Optional<unsigned> PartialDiagId;
1757 };
1758
1759 /// Is the last error level diagnostic immediate. This is used to determined
1760 /// whether the next info diagnostic should be immediate.
1761 bool IsLastErrorImmediate = true;
1762
1763 /// Emit a diagnostic.
1764 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,
1765 bool DeferHint = false);
1766
1767 /// Emit a partial diagnostic.
1768 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
1769 bool DeferHint = false);
1770
1771 /// Build a partial diagnostic.
1772 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1773
1774 /// Whether deferrable diagnostics should be deferred.
1775 bool DeferDiags = false;
1776
1777 /// RAII class to control scope of DeferDiags.
1778 class DeferDiagsRAII {
1779 Sema &S;
1780 bool SavedDeferDiags = false;
1781
1782 public:
1783 DeferDiagsRAII(Sema &S, bool DeferDiags)
1784 : S(S), SavedDeferDiags(S.DeferDiags) {
1785 S.DeferDiags = DeferDiags;
1786 }
1787 ~DeferDiagsRAII() { S.DeferDiags = SavedDeferDiags; }
1788 };
1789
1790 /// Whether uncompilable error has occurred. This includes error happens
1791 /// in deferred diagnostics.
1792 bool hasUncompilableErrorOccurred() const;
1793
1794 bool findMacroSpelling(SourceLocation &loc, StringRef name);
1795
1796 /// Get a string to suggest for zero-initialization of a type.
1797 std::string
1798 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1799 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1800
1801 /// Calls \c Lexer::getLocForEndOfToken()
1802 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1803
1804 /// Retrieve the module loader associated with the preprocessor.
1805 ModuleLoader &getModuleLoader() const;
1806
1807 /// Invent a new identifier for parameters of abbreviated templates.
1808 IdentifierInfo *
1809 InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1810 unsigned Index);
1811
1812 void emitAndClearUnusedLocalTypedefWarnings();
1813
1814 private:
1815 /// Function or variable declarations to be checked for whether the deferred
1816 /// diagnostics should be emitted.
1817 llvm::SmallSetVector<Decl *, 4> DeclsToCheckForDeferredDiags;
1818
1819 public:
1820 // Emit all deferred diagnostics.
1821 void emitDeferredDiags();
1822
1823 enum TUFragmentKind {
1824 /// The global module fragment, between 'module;' and a module-declaration.
1825 Global,
1826 /// A normal translation unit fragment. For a non-module unit, this is the
1827 /// entire translation unit. Otherwise, it runs from the module-declaration
1828 /// to the private-module-fragment (if any) or the end of the TU (if not).
1829 Normal,
1830 /// The private module fragment, between 'module :private;' and the end of
1831 /// the translation unit.
1832 Private
1833 };
1834
1835 void ActOnStartOfTranslationUnit();
1836 void ActOnEndOfTranslationUnit();
1837 void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1838
1839 void CheckDelegatingCtorCycles();
1840
1841 Scope *getScopeForContext(DeclContext *Ctx);
1842
1843 void PushFunctionScope();
1844 void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1845 sema::LambdaScopeInfo *PushLambdaScope();
1846
1847 /// This is used to inform Sema what the current TemplateParameterDepth
1848 /// is during Parsing. Currently it is used to pass on the depth
1849 /// when parsing generic lambda 'auto' parameters.
1850 void RecordParsingTemplateParameterDepth(unsigned Depth);
1851
1852 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1853 RecordDecl *RD, CapturedRegionKind K,
1854 unsigned OpenMPCaptureLevel = 0);
1855
1856 /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1857 /// time after they've been popped.
1858 class PoppedFunctionScopeDeleter {
1859 Sema *Self;
1860
1861 public:
1862 explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1863 void operator()(sema::FunctionScopeInfo *Scope) const;
1864 };
1865
1866 using PoppedFunctionScopePtr =
1867 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1868
1869 PoppedFunctionScopePtr
1870 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1871 const Decl *D = nullptr,
1872 QualType BlockType = QualType());
1873
1874 sema::FunctionScopeInfo *getCurFunction() const {
1875 return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1876 }
1877
1878 sema::FunctionScopeInfo *getEnclosingFunction() const;
1879
1880 void setFunctionHasBranchIntoScope();
1881 void setFunctionHasBranchProtectedScope();
1882 void setFunctionHasIndirectGoto();
1883 void setFunctionHasMustTail();
1884
1885 void PushCompoundScope(bool IsStmtExpr);
1886 void PopCompoundScope();
1887
1888 sema::CompoundScopeInfo &getCurCompoundScope() const;
1889
1890 bool hasAnyUnrecoverableErrorsInThisFunction() const;
1891
1892 /// Retrieve the current block, if any.
1893 sema::BlockScopeInfo *getCurBlock();
1894
1895 /// Get the innermost lambda enclosing the current location, if any. This
1896 /// looks through intervening non-lambda scopes such as local functions and
1897 /// blocks.
1898 sema::LambdaScopeInfo *getEnclosingLambda() const;
1899
1900 /// Retrieve the current lambda scope info, if any.
1901 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1902 /// lambda scope info ignoring all inner capturing scopes that are not
1903 /// lambda scopes.
1904 sema::LambdaScopeInfo *
1905 getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1906
1907 /// Retrieve the current generic lambda info, if any.
1908 sema::LambdaScopeInfo *getCurGenericLambda();
1909
1910 /// Retrieve the current captured region, if any.
1911 sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1912
1913 /// Retrieve the current function, if any, that should be analyzed for
1914 /// potential availability violations.
1915 sema::FunctionScopeInfo *getCurFunctionAvailabilityContext();
1916
1917 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1918 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1919
1920 /// Called before parsing a function declarator belonging to a function
1921 /// declaration.
1922 void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1923 unsigned TemplateParameterDepth);
1924
1925 /// Called after parsing a function declarator belonging to a function
1926 /// declaration.
1927 void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1928
1929 void ActOnComment(SourceRange Comment);
1930
1931 //===--------------------------------------------------------------------===//
1932 // Type Analysis / Processing: SemaType.cpp.
1933 //
1934
1935 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1936 const DeclSpec *DS = nullptr);
1937 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1938 const DeclSpec *DS = nullptr);
1939 QualType BuildPointerType(QualType T,
1940 SourceLocation Loc, DeclarationName Entity);
1941 QualType BuildReferenceType(QualType T, bool LValueRef,
1942 SourceLocation Loc, DeclarationName Entity);
1943 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1944 Expr *ArraySize, unsigned Quals,
1945 SourceRange Brackets, DeclarationName Entity);
1946 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1947 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1948 SourceLocation AttrLoc);
1949 QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns,
1950 SourceLocation AttrLoc);
1951
1952 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1953 SourceLocation AttrLoc);
1954
1955 /// Same as above, but constructs the AddressSpace index if not provided.
1956 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1957 SourceLocation AttrLoc);
1958
1959 bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1960
1961 bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1962
1963 /// Build a function type.
1964 ///
1965 /// This routine checks the function type according to C++ rules and
1966 /// under the assumption that the result type and parameter types have
1967 /// just been instantiated from a template. It therefore duplicates
1968 /// some of the behavior of GetTypeForDeclarator, but in a much
1969 /// simpler form that is only suitable for this narrow use case.
1970 ///
1971 /// \param T The return type of the function.
1972 ///
1973 /// \param ParamTypes The parameter types of the function. This array
1974 /// will be modified to account for adjustments to the types of the
1975 /// function parameters.
1976 ///
1977 /// \param Loc The location of the entity whose type involves this
1978 /// function type or, if there is no such entity, the location of the
1979 /// type that will have function type.
1980 ///
1981 /// \param Entity The name of the entity that involves the function
1982 /// type, if known.
1983 ///
1984 /// \param EPI Extra information about the function type. Usually this will
1985 /// be taken from an existing function with the same prototype.
1986 ///
1987 /// \returns A suitable function type, if there are no errors. The
1988 /// unqualified type will always be a FunctionProtoType.
1989 /// Otherwise, returns a NULL type.
1990 QualType BuildFunctionType(QualType T,
1991 MutableArrayRef<QualType> ParamTypes,
1992 SourceLocation Loc, DeclarationName Entity,
1993 const FunctionProtoType::ExtProtoInfo &EPI);
1994
1995 QualType BuildMemberPointerType(QualType T, QualType Class,
1996 SourceLocation Loc,
1997 DeclarationName Entity);
1998 QualType BuildBlockPointerType(QualType T,
1999 SourceLocation Loc, DeclarationName Entity);
2000 QualType BuildParenType(QualType T);
2001 QualType BuildAtomicType(QualType T, SourceLocation Loc);
2002 QualType BuildReadPipeType(QualType T,
2003 SourceLocation Loc);
2004 QualType BuildWritePipeType(QualType T,
2005 SourceLocation Loc);
2006 QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc);
2007
2008 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
2009 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
2010
2011 /// Package the given type and TSI into a ParsedType.
2012 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
2013 DeclarationNameInfo GetNameForDeclarator(Declarator &D);
2014 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
2015 static QualType GetTypeFromParser(ParsedType Ty,
2016 TypeSourceInfo **TInfo = nullptr);
2017 CanThrowResult canThrow(const Stmt *E);
2018 /// Determine whether the callee of a particular function call can throw.
2019 /// E, D and Loc are all optional.
2020 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D,
2021 SourceLocation Loc = SourceLocation());
2022 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
2023 const FunctionProtoType *FPT);
2024 void UpdateExceptionSpec(FunctionDecl *FD,
2025 const FunctionProtoType::ExceptionSpecInfo &ESI);
2026 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
2027 bool CheckDistantExceptionSpec(QualType T);
2028 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
2029 bool CheckEquivalentExceptionSpec(
2030 const FunctionProtoType *Old, SourceLocation OldLoc,
2031 const FunctionProtoType *New, SourceLocation NewLoc);
2032 bool CheckEquivalentExceptionSpec(
2033 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
2034 const FunctionProtoType *Old, SourceLocation OldLoc,
2035 const FunctionProtoType *New, SourceLocation NewLoc);
2036 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
2037 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
2038 const PartialDiagnostic &NestedDiagID,
2039 const PartialDiagnostic &NoteID,
2040 const PartialDiagnostic &NoThrowDiagID,
2041 const FunctionProtoType *Superset,
2042 SourceLocation SuperLoc,
2043 const FunctionProtoType *Subset,
2044 SourceLocation SubLoc);
2045 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
2046 const PartialDiagnostic &NoteID,
2047 const FunctionProtoType *Target,
2048 SourceLocation TargetLoc,
2049 const FunctionProtoType *Source,
2050 SourceLocation SourceLoc);
2051
2052 TypeResult ActOnTypeName(Scope *S, Declarator &D);
2053
2054 /// The parser has parsed the context-sensitive type 'instancetype'
2055 /// in an Objective-C message declaration. Return the appropriate type.
2056 ParsedType ActOnObjCInstanceType(SourceLocation Loc);
2057
2058 /// Abstract class used to diagnose incomplete types.
2059 struct TypeDiagnoser {
2060 TypeDiagnoser() {}
2061
2062 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
2063 virtual ~TypeDiagnoser() {}
2064 };
2065
2066 static int getPrintable(int I) { return I; }
2067 static unsigned getPrintable(unsigned I) { return I; }
2068 static bool getPrintable(bool B) { return B; }
2069 static const char * getPrintable(const char *S) { return S; }
2070 static StringRef getPrintable(StringRef S) { return S; }
2071 static const std::string &getPrintable(const std::string &S) { return S; }
2072 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
2073 return II;
2074 }
2075 static DeclarationName getPrintable(DeclarationName N) { return N; }
2076 static QualType getPrintable(QualType T) { return T; }
2077 static SourceRange getPrintable(SourceRange R) { return R; }
2078 static SourceRange getPrintable(SourceLocation L) { return L; }
2079 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
2080 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
2081
2082 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
2083 protected:
2084 unsigned DiagID;
2085 std::tuple<const Ts &...> Args;
2086
2087 template <std::size_t... Is>
2088 void emit(const SemaDiagnosticBuilder &DB,
2089 std::index_sequence<Is...>) const {
2090 // Apply all tuple elements to the builder in order.
2091 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
2092 (void)Dummy;
2093 }
2094
2095 public:
2096 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
2097 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
2098 assert(DiagID != 0 && "no diagnostic for type diagnoser")(static_cast <bool> (DiagID != 0 && "no diagnostic for type diagnoser"
) ? void (0) : __assert_fail ("DiagID != 0 && \"no diagnostic for type diagnoser\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2098, __extension__ __PRETTY_FUNCTION__))
;
2099 }
2100
2101 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2102 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
2103 emit(DB, std::index_sequence_for<Ts...>());
2104 DB << T;
2105 }
2106 };
2107
2108 /// Do a check to make sure \p Name looks like a legal argument for the
2109 /// swift_name attribute applied to decl \p D. Raise a diagnostic if the name
2110 /// is invalid for the given declaration.
2111 ///
2112 /// \p AL is used to provide caret diagnostics in case of a malformed name.
2113 ///
2114 /// \returns true if the name is a valid swift name for \p D, false otherwise.
2115 bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc,
2116 const ParsedAttr &AL, bool IsAsync);
2117
2118 /// A derivative of BoundTypeDiagnoser for which the diagnostic's type
2119 /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless.
2120 /// For example, a diagnostic with no other parameters would generally have
2121 /// the form "...%select{incomplete|sizeless}0 type %1...".
2122 template <typename... Ts>
2123 class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> {
2124 public:
2125 SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args)
2126 : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {}
2127
2128 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2129 const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID);
2130 this->emit(DB, std::index_sequence_for<Ts...>());
2131 DB << T->isSizelessType() << T;
2132 }
2133 };
2134
2135 enum class CompleteTypeKind {
2136 /// Apply the normal rules for complete types. In particular,
2137 /// treat all sizeless types as incomplete.
2138 Normal,
2139
2140 /// Relax the normal rules for complete types so that they include
2141 /// sizeless built-in types.
2142 AcceptSizeless,
2143
2144 // FIXME: Eventually we should flip the default to Normal and opt in
2145 // to AcceptSizeless rather than opt out of it.
2146 Default = AcceptSizeless
2147 };
2148
2149private:
2150 /// Methods for marking which expressions involve dereferencing a pointer
2151 /// marked with the 'noderef' attribute. Expressions are checked bottom up as
2152 /// they are parsed, meaning that a noderef pointer may not be accessed. For
2153 /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
2154 /// `*p`, but need to check that `address of` is called on it. This requires
2155 /// keeping a container of all pending expressions and checking if the address
2156 /// of them are eventually taken.
2157 void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E);
2158 void CheckAddressOfNoDeref(const Expr *E);
2159 void CheckMemberAccessOfNoDeref(const MemberExpr *E);
2160
2161 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
2162 CompleteTypeKind Kind, TypeDiagnoser *Diagnoser);
2163
2164 struct ModuleScope {
2165 SourceLocation BeginLoc;
2166 clang::Module *Module = nullptr;
2167 bool ModuleInterface = false;
2168 bool ImplicitGlobalModuleFragment = false;
2169 VisibleModuleSet OuterVisibleModules;
2170 };
2171 /// The modules we're currently parsing.
2172 llvm::SmallVector<ModuleScope, 16> ModuleScopes;
2173
2174 /// Namespace definitions that we will export when they finish.
2175 llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
2176
2177 /// Get the module whose scope we are currently within.
2178 Module *getCurrentModule() const {
2179 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2180 }
2181
2182 VisibleModuleSet VisibleModules;
2183
2184public:
2185 /// Get the module owning an entity.
2186 Module *getOwningModule(const Decl *Entity) {
2187 return Entity->getOwningModule();
2188 }
2189
2190 /// Make a merged definition of an existing hidden definition \p ND
2191 /// visible at the specified location.
2192 void makeMergedDefinitionVisible(NamedDecl *ND);
2193
2194 bool isModuleVisible(const Module *M, bool ModulePrivate = false);
2195
2196 // When loading a non-modular PCH files, this is used to restore module
2197 // visibility.
2198 void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) {
2199 VisibleModules.setVisible(Mod, ImportLoc);
2200 }
2201
2202 /// Determine whether a declaration is visible to name lookup.
2203 bool isVisible(const NamedDecl *D) {
2204 return D->isUnconditionallyVisible() || isVisibleSlow(D);
2205 }
2206
2207 /// Determine whether any declaration of an entity is visible.
2208 bool
2209 hasVisibleDeclaration(const NamedDecl *D,
2210 llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
2211 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
2212 }
2213 bool hasVisibleDeclarationSlow(const NamedDecl *D,
2214 llvm::SmallVectorImpl<Module *> *Modules);
2215
2216 bool hasVisibleMergedDefinition(NamedDecl *Def);
2217 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
2218
2219 /// Determine if \p D and \p Suggested have a structurally compatible
2220 /// layout as described in C11 6.2.7/1.
2221 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
2222
2223 /// Determine if \p D has a visible definition. If not, suggest a declaration
2224 /// that should be made visible to expose the definition.
2225 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
2226 bool OnlyNeedComplete = false);
2227 bool hasVisibleDefinition(const NamedDecl *D) {
2228 NamedDecl *Hidden;
2229 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
2230 }
2231
2232 /// Determine if the template parameter \p D has a visible default argument.
2233 bool
2234 hasVisibleDefaultArgument(const NamedDecl *D,
2235 llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2236
2237 /// Determine if there is a visible declaration of \p D that is an explicit
2238 /// specialization declaration for a specialization of a template. (For a
2239 /// member specialization, use hasVisibleMemberSpecialization.)
2240 bool hasVisibleExplicitSpecialization(
2241 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2242
2243 /// Determine if there is a visible declaration of \p D that is a member
2244 /// specialization declaration (as opposed to an instantiated declaration).
2245 bool hasVisibleMemberSpecialization(
2246 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2247
2248 /// Determine if \p A and \p B are equivalent internal linkage declarations
2249 /// from different modules, and thus an ambiguity error can be downgraded to
2250 /// an extension warning.
2251 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
2252 const NamedDecl *B);
2253 void diagnoseEquivalentInternalLinkageDeclarations(
2254 SourceLocation Loc, const NamedDecl *D,
2255 ArrayRef<const NamedDecl *> Equiv);
2256
2257 bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
2258
2259 bool isCompleteType(SourceLocation Loc, QualType T,
2260 CompleteTypeKind Kind = CompleteTypeKind::Default) {
2261 return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
2262 }
2263 bool RequireCompleteType(SourceLocation Loc, QualType T,
2264 CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
2265 bool RequireCompleteType(SourceLocation Loc, QualType T,
2266 CompleteTypeKind Kind, unsigned DiagID);
2267
2268 bool RequireCompleteType(SourceLocation Loc, QualType T,
2269 TypeDiagnoser &Diagnoser) {
2270 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
2271 }
2272 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
2273 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
2274 }
2275
2276 template <typename... Ts>
2277 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
2278 const Ts &...Args) {
2279 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2280 return RequireCompleteType(Loc, T, Diagnoser);
2281 }
2282
2283 template <typename... Ts>
2284 bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
2285 const Ts &... Args) {
2286 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2287 return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
2288 }
2289
2290 /// Get the type of expression E, triggering instantiation to complete the
2291 /// type if necessary -- that is, if the expression refers to a templated
2292 /// static data member of incomplete array type.
2293 ///
2294 /// May still return an incomplete type if instantiation was not possible or
2295 /// if the type is incomplete for a different reason. Use
2296 /// RequireCompleteExprType instead if a diagnostic is expected for an
2297 /// incomplete expression type.
2298 QualType getCompletedType(Expr *E);
2299
2300 void completeExprArrayBound(Expr *E);
2301 bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
2302 TypeDiagnoser &Diagnoser);
2303 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
2304
2305 template <typename... Ts>
2306 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
2307 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2308 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
2309 }
2310
2311 template <typename... Ts>
2312 bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
2313 const Ts &... Args) {
2314 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2315 return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
2316 }
2317
2318 bool RequireLiteralType(SourceLocation Loc, QualType T,
2319 TypeDiagnoser &Diagnoser);
2320 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
2321
2322 template <typename... Ts>
2323 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
2324 const Ts &...Args) {
2325 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2326 return RequireLiteralType(Loc, T, Diagnoser);
2327 }
2328
2329 QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
2330 const CXXScopeSpec &SS, QualType T,
2331 TagDecl *OwnedTagDecl = nullptr);
2332
2333 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
2334 /// If AsUnevaluated is false, E is treated as though it were an evaluated
2335 /// context, such as when building a type for decltype(auto).
2336 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
2337 bool AsUnevaluated = true);
2338 QualType BuildUnaryTransformType(QualType BaseType,
2339 UnaryTransformType::UTTKind UKind,
2340 SourceLocation Loc);
2341
2342 //===--------------------------------------------------------------------===//
2343 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
2344 //
2345
2346 struct SkipBodyInfo {
2347 SkipBodyInfo()
2348 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
2349 New(nullptr) {}
2350 bool ShouldSkip;
2351 bool CheckSameAsPrevious;
2352 NamedDecl *Previous;
2353 NamedDecl *New;
2354 };
2355
2356 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
2357
2358 void DiagnoseUseOfUnimplementedSelectors();
2359
2360 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
2361
2362 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
2363 Scope *S, CXXScopeSpec *SS = nullptr,
2364 bool isClassName = false, bool HasTrailingDot = false,
2365 ParsedType ObjectType = nullptr,
2366 bool IsCtorOrDtorName = false,
2367 bool WantNontrivialTypeSourceInfo = false,
2368 bool IsClassTemplateDeductionContext = true,
2369 IdentifierInfo **CorrectedII = nullptr);
2370 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
2371 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
2372 void DiagnoseUnknownTypeName(IdentifierInfo *&II,
2373 SourceLocation IILoc,
2374 Scope *S,
2375 CXXScopeSpec *SS,
2376 ParsedType &SuggestedType,
2377 bool IsTemplateName = false);
2378
2379 /// Attempt to behave like MSVC in situations where lookup of an unqualified
2380 /// type name has failed in a dependent context. In these situations, we
2381 /// automatically form a DependentTypeName that will retry lookup in a related
2382 /// scope during instantiation.
2383 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
2384 SourceLocation NameLoc,
2385 bool IsTemplateTypeArg);
2386
2387 /// Describes the result of the name lookup and resolution performed
2388 /// by \c ClassifyName().
2389 enum NameClassificationKind {
2390 /// This name is not a type or template in this context, but might be
2391 /// something else.
2392 NC_Unknown,
2393 /// Classification failed; an error has been produced.
2394 NC_Error,
2395 /// The name has been typo-corrected to a keyword.
2396 NC_Keyword,
2397 /// The name was classified as a type.
2398 NC_Type,
2399 /// The name was classified as a specific non-type, non-template
2400 /// declaration. ActOnNameClassifiedAsNonType should be called to
2401 /// convert the declaration to an expression.
2402 NC_NonType,
2403 /// The name was classified as an ADL-only function name.
2404 /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the
2405 /// result to an expression.
2406 NC_UndeclaredNonType,
2407 /// The name denotes a member of a dependent type that could not be
2408 /// resolved. ActOnNameClassifiedAsDependentNonType should be called to
2409 /// convert the result to an expression.
2410 NC_DependentNonType,
2411 /// The name was classified as an overload set, and an expression
2412 /// representing that overload set has been formed.
2413 /// ActOnNameClassifiedAsOverloadSet should be called to form a suitable
2414 /// expression referencing the overload set.
2415 NC_OverloadSet,
2416 /// The name was classified as a template whose specializations are types.
2417 NC_TypeTemplate,
2418 /// The name was classified as a variable template name.
2419 NC_VarTemplate,
2420 /// The name was classified as a function template name.
2421 NC_FunctionTemplate,
2422 /// The name was classified as an ADL-only function template name.
2423 NC_UndeclaredTemplate,
2424 /// The name was classified as a concept name.
2425 NC_Concept,
2426 };
2427
2428 class NameClassification {
2429 NameClassificationKind Kind;
2430 union {
2431 ExprResult Expr;
2432 NamedDecl *NonTypeDecl;
2433 TemplateName Template;
2434 ParsedType Type;
2435 };
2436
2437 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
2438
2439 public:
2440 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
2441
2442 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
2443
2444 static NameClassification Error() {
2445 return NameClassification(NC_Error);
2446 }
2447
2448 static NameClassification Unknown() {
2449 return NameClassification(NC_Unknown);
2450 }
2451
2452 static NameClassification OverloadSet(ExprResult E) {
2453 NameClassification Result(NC_OverloadSet);
2454 Result.Expr = E;
2455 return Result;
2456 }
2457
2458 static NameClassification NonType(NamedDecl *D) {
2459 NameClassification Result(NC_NonType);
2460 Result.NonTypeDecl = D;
2461 return Result;
2462 }
2463
2464 static NameClassification UndeclaredNonType() {
2465 return NameClassification(NC_UndeclaredNonType);
2466 }
2467
2468 static NameClassification DependentNonType() {
2469 return NameClassification(NC_DependentNonType);
2470 }
2471
2472 static NameClassification TypeTemplate(TemplateName Name) {
2473 NameClassification Result(NC_TypeTemplate);
2474 Result.Template = Name;
2475 return Result;
2476 }
2477
2478 static NameClassification VarTemplate(TemplateName Name) {
2479 NameClassification Result(NC_VarTemplate);
2480 Result.Template = Name;
2481 return Result;
2482 }
2483
2484 static NameClassification FunctionTemplate(TemplateName Name) {
2485 NameClassification Result(NC_FunctionTemplate);
2486 Result.Template = Name;
2487 return Result;
2488 }
2489
2490 static NameClassification Concept(TemplateName Name) {
2491 NameClassification Result(NC_Concept);
2492 Result.Template = Name;
2493 return Result;
2494 }
2495
2496 static NameClassification UndeclaredTemplate(TemplateName Name) {
2497 NameClassification Result(NC_UndeclaredTemplate);
2498 Result.Template = Name;
2499 return Result;
2500 }
2501
2502 NameClassificationKind getKind() const { return Kind; }
2503
2504 ExprResult getExpression() const {
2505 assert(Kind == NC_OverloadSet)(static_cast <bool> (Kind == NC_OverloadSet) ? void (0)
: __assert_fail ("Kind == NC_OverloadSet", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2505, __extension__ __PRETTY_FUNCTION__))
;
2506 return Expr;
2507 }
2508
2509 ParsedType getType() const {
2510 assert(Kind == NC_Type)(static_cast <bool> (Kind == NC_Type) ? void (0) : __assert_fail
("Kind == NC_Type", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2510, __extension__ __PRETTY_FUNCTION__))
;
2511 return Type;
2512 }
2513
2514 NamedDecl *getNonTypeDecl() const {
2515 assert(Kind == NC_NonType)(static_cast <bool> (Kind == NC_NonType) ? void (0) : __assert_fail
("Kind == NC_NonType", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2515, __extension__ __PRETTY_FUNCTION__))
;
2516 return NonTypeDecl;
2517 }
2518
2519 TemplateName getTemplateName() const {
2520 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept
|| Kind == NC_UndeclaredTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept || Kind == NC_UndeclaredTemplate"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2522, __extension__ __PRETTY_FUNCTION__))
2521 Kind == NC_VarTemplate || Kind == NC_Concept ||(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept
|| Kind == NC_UndeclaredTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept || Kind == NC_UndeclaredTemplate"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2522, __extension__ __PRETTY_FUNCTION__))
2522 Kind == NC_UndeclaredTemplate)(static_cast <bool> (Kind == NC_TypeTemplate || Kind ==
NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept
|| Kind == NC_UndeclaredTemplate) ? void (0) : __assert_fail
("Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || Kind == NC_VarTemplate || Kind == NC_Concept || Kind == NC_UndeclaredTemplate"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2522, __extension__ __PRETTY_FUNCTION__))
;
2523 return Template;
2524 }
2525
2526 TemplateNameKind getTemplateNameKind() const {
2527 switch (Kind) {
2528 case NC_TypeTemplate:
2529 return TNK_Type_template;
2530 case NC_FunctionTemplate:
2531 return TNK_Function_template;
2532 case NC_VarTemplate:
2533 return TNK_Var_template;
2534 case NC_Concept:
2535 return TNK_Concept_template;
2536 case NC_UndeclaredTemplate:
2537 return TNK_Undeclared_template;
2538 default:
2539 llvm_unreachable("unsupported name classification.")::llvm::llvm_unreachable_internal("unsupported name classification."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 2539)
;
2540 }
2541 }
2542 };
2543
2544 /// Perform name lookup on the given name, classifying it based on
2545 /// the results of name lookup and the following token.
2546 ///
2547 /// This routine is used by the parser to resolve identifiers and help direct
2548 /// parsing. When the identifier cannot be found, this routine will attempt
2549 /// to correct the typo and classify based on the resulting name.
2550 ///
2551 /// \param S The scope in which we're performing name lookup.
2552 ///
2553 /// \param SS The nested-name-specifier that precedes the name.
2554 ///
2555 /// \param Name The identifier. If typo correction finds an alternative name,
2556 /// this pointer parameter will be updated accordingly.
2557 ///
2558 /// \param NameLoc The location of the identifier.
2559 ///
2560 /// \param NextToken The token following the identifier. Used to help
2561 /// disambiguate the name.
2562 ///
2563 /// \param CCC The correction callback, if typo correction is desired.
2564 NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS,
2565 IdentifierInfo *&Name, SourceLocation NameLoc,
2566 const Token &NextToken,
2567 CorrectionCandidateCallback *CCC = nullptr);
2568
2569 /// Act on the result of classifying a name as an undeclared (ADL-only)
2570 /// non-type declaration.
2571 ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
2572 SourceLocation NameLoc);
2573 /// Act on the result of classifying a name as an undeclared member of a
2574 /// dependent base class.
2575 ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
2576 IdentifierInfo *Name,
2577 SourceLocation NameLoc,
2578 bool IsAddressOfOperand);
2579 /// Act on the result of classifying a name as a specific non-type
2580 /// declaration.
2581 ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
2582 NamedDecl *Found,
2583 SourceLocation NameLoc,
2584 const Token &NextToken);
2585 /// Act on the result of classifying a name as an overload set.
2586 ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet);
2587
2588 /// Describes the detailed kind of a template name. Used in diagnostics.
2589 enum class TemplateNameKindForDiagnostics {
2590 ClassTemplate,
2591 FunctionTemplate,
2592 VarTemplate,
2593 AliasTemplate,
2594 TemplateTemplateParam,
2595 Concept,
2596 DependentTemplate
2597 };
2598 TemplateNameKindForDiagnostics
2599 getTemplateNameKindForDiagnostics(TemplateName Name);
2600
2601 /// Determine whether it's plausible that E was intended to be a
2602 /// template-name.
2603 bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
2604 if (!getLangOpts().CPlusPlus || E.isInvalid())
2605 return false;
2606 Dependent = false;
2607 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
2608 return !DRE->hasExplicitTemplateArgs();
2609 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
2610 return !ME->hasExplicitTemplateArgs();
2611 Dependent = true;
2612 if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get()))
2613 return !DSDRE->hasExplicitTemplateArgs();
2614 if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get()))
2615 return !DSME->hasExplicitTemplateArgs();
2616 // Any additional cases recognized here should also be handled by
2617 // diagnoseExprIntendedAsTemplateName.
2618 return false;
2619 }
2620 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
2621 SourceLocation Less,
2622 SourceLocation Greater);
2623
2624 void warnOnReservedIdentifier(const NamedDecl *D);
2625
2626 Decl *ActOnDeclarator(Scope *S, Declarator &D);
2627
2628 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
2629 MultiTemplateParamsArg TemplateParameterLists);
2630 bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo,
2631 QualType &T, SourceLocation Loc,
2632 unsigned FailedFoldDiagID);
2633 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
2634 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
2635 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
2636 DeclarationName Name, SourceLocation Loc,
2637 bool IsTemplateId);
2638 void
2639 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2640 SourceLocation FallbackLoc,
2641 SourceLocation ConstQualLoc = SourceLocation(),
2642 SourceLocation VolatileQualLoc = SourceLocation(),
2643 SourceLocation RestrictQualLoc = SourceLocation(),
2644 SourceLocation AtomicQualLoc = SourceLocation(),
2645 SourceLocation UnalignedQualLoc = SourceLocation());
2646
2647 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
2648 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
2649 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
2650 const LookupResult &R);
2651 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
2652 NamedDecl *getShadowedDeclaration(const BindingDecl *D,
2653 const LookupResult &R);
2654 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
2655 const LookupResult &R);
2656 void CheckShadow(Scope *S, VarDecl *D);
2657
2658 /// Warn if 'E', which is an expression that is about to be modified, refers
2659 /// to a shadowing declaration.
2660 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2661
2662 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
2663
2664private:
2665 /// Map of current shadowing declarations to shadowed declarations. Warn if
2666 /// it looks like the user is trying to modify the shadowing declaration.
2667 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2668
2669public:
2670 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2671 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
2672 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
2673 TypedefNameDecl *NewTD);
2674 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
2675 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2676 TypeSourceInfo *TInfo,
2677 LookupResult &Previous);
2678 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
2679 LookupResult &Previous, bool &Redeclaration);
2680 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
2681 TypeSourceInfo *TInfo,
2682 LookupResult &Previous,
2683 MultiTemplateParamsArg TemplateParamLists,
2684 bool &AddToScope,
2685 ArrayRef<BindingDecl *> Bindings = None);
2686 NamedDecl *
2687 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
2688 MultiTemplateParamsArg TemplateParamLists);
2689 // Returns true if the variable declaration is a redeclaration
2690 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
2691 void CheckVariableDeclarationType(VarDecl *NewVD);
2692 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
2693 Expr *Init);
2694 void CheckCompleteVariableDeclaration(VarDecl *VD);
2695 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
2696 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
2697
2698 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2699 TypeSourceInfo *TInfo,
2700 LookupResult &Previous,
2701 MultiTemplateParamsArg TemplateParamLists,
2702 bool &AddToScope);
2703 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
2704
2705 enum class CheckConstexprKind {
2706 /// Diagnose issues that are non-constant or that are extensions.
2707 Diagnose,
2708 /// Identify whether this function satisfies the formal rules for constexpr
2709 /// functions in the current lanugage mode (with no extensions).
2710 CheckValid
2711 };
2712
2713 bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,
2714 CheckConstexprKind Kind);
2715
2716 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
2717 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
2718 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2719 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
2720 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2721 // Returns true if the function declaration is a redeclaration
2722 bool CheckFunctionDeclaration(Scope *S,
2723 FunctionDecl *NewFD, LookupResult &Previous,
2724 bool IsMemberSpecialization);
2725 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
2726 bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,
2727 QualType NewT, QualType OldT);
2728 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
2729 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
2730 Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
2731 bool IsDefinition);
2732 void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);
2733 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
2734 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
2735 SourceLocation Loc,
2736 QualType T);
2737 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
2738 SourceLocation NameLoc, IdentifierInfo *Name,
2739 QualType T, TypeSourceInfo *TSInfo,
2740 StorageClass SC);
2741 void ActOnParamDefaultArgument(Decl *param,
2742 SourceLocation EqualLoc,
2743 Expr *defarg);
2744 void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,
2745 SourceLocation ArgLoc);
2746 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
2747 ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2748 SourceLocation EqualLoc);
2749 void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2750 SourceLocation EqualLoc);
2751
2752 // Contexts where using non-trivial C union types can be disallowed. This is
2753 // passed to err_non_trivial_c_union_in_invalid_context.
2754 enum NonTrivialCUnionContext {
2755 // Function parameter.
2756 NTCUC_FunctionParam,
2757 // Function return.
2758 NTCUC_FunctionReturn,
2759 // Default-initialized object.
2760 NTCUC_DefaultInitializedObject,
2761 // Variable with automatic storage duration.
2762 NTCUC_AutoVar,
2763 // Initializer expression that might copy from another object.
2764 NTCUC_CopyInit,
2765 // Assignment.
2766 NTCUC_Assignment,
2767 // Compound literal.
2768 NTCUC_CompoundLiteral,
2769 // Block capture.
2770 NTCUC_BlockCapture,
2771 // lvalue-to-rvalue conversion of volatile type.
2772 NTCUC_LValueToRValueVolatile,
2773 };
2774
2775 /// Emit diagnostics if the initializer or any of its explicit or
2776 /// implicitly-generated subexpressions require copying or
2777 /// default-initializing a type that is or contains a C union type that is
2778 /// non-trivial to copy or default-initialize.
2779 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2780
2781 // These flags are passed to checkNonTrivialCUnion.
2782 enum NonTrivialCUnionKind {
2783 NTCUK_Init = 0x1,
2784 NTCUK_Destruct = 0x2,
2785 NTCUK_Copy = 0x4,
2786 };
2787
2788 /// Emit diagnostics if a non-trivial C union type or a struct that contains
2789 /// a non-trivial C union is used in an invalid context.
2790 void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
2791 NonTrivialCUnionContext UseContext,
2792 unsigned NonTrivialKind);
2793
2794 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
2795 void ActOnUninitializedDecl(Decl *dcl);
2796 void ActOnInitializerError(Decl *Dcl);
2797
2798 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
2799 void ActOnCXXForRangeDecl(Decl *D);
2800 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
2801 IdentifierInfo *Ident,
2802 ParsedAttributes &Attrs,
2803 SourceLocation AttrEnd);
2804 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
2805 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
2806 void CheckStaticLocalForDllExport(VarDecl *VD);
2807 void FinalizeDeclaration(Decl *D);
2808 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
2809 ArrayRef<Decl *> Group);
2810 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
2811
2812 /// Should be called on all declarations that might have attached
2813 /// documentation comments.
2814 void ActOnDocumentableDecl(Decl *D);
2815 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
2816
2817 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2818 SourceLocation LocAfterDecls);
2819 void CheckForFunctionRedefinition(
2820 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
2821 SkipBodyInfo *SkipBody = nullptr);
2822 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
2823 MultiTemplateParamsArg TemplateParamLists,
2824 SkipBodyInfo *SkipBody = nullptr);
2825 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
2826 SkipBodyInfo *SkipBody = nullptr);
2827 void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);
2828 ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);
2829 ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);
2830 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
2831 bool isObjCMethodDecl(Decl *D) {
2832 return D && isa<ObjCMethodDecl>(D);
2833 }
2834
2835 /// Determine whether we can delay parsing the body of a function or
2836 /// function template until it is used, assuming we don't care about emitting
2837 /// code for that function.
2838 ///
2839 /// This will be \c false if we may need the body of the function in the
2840 /// middle of parsing an expression (where it's impractical to switch to
2841 /// parsing a different function), for instance, if it's constexpr in C++11
2842 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2843 bool canDelayFunctionBody(const Declarator &D);
2844
2845 /// Determine whether we can skip parsing the body of a function
2846 /// definition, assuming we don't care about analyzing its body or emitting
2847 /// code for that function.
2848 ///
2849 /// This will be \c false only if we may need the body of the function in
2850 /// order to parse the rest of the program (for instance, if it is
2851 /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2852 bool canSkipFunctionBody(Decl *D);
2853
2854 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2855 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2856 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2857 Decl *ActOnSkippedFunctionBody(Decl *Decl);
2858 void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2859
2860 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2861 /// attribute for which parsing is delayed.
2862 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2863
2864 /// Diagnose any unused parameters in the given sequence of
2865 /// ParmVarDecl pointers.
2866 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2867
2868 /// Diagnose whether the size of parameters or return value of a
2869 /// function or obj-c method definition is pass-by-value and larger than a
2870 /// specified threshold.
2871 void
2872 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2873 QualType ReturnTy, NamedDecl *D);
2874
2875 void DiagnoseInvalidJumps(Stmt *Body);
2876 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2877 SourceLocation AsmLoc,
2878 SourceLocation RParenLoc);
2879
2880 /// Handle a C++11 empty-declaration and attribute-declaration.
2881 Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,
2882 SourceLocation SemiLoc);
2883
2884 enum class ModuleDeclKind {
2885 Interface, ///< 'export module X;'
2886 Implementation, ///< 'module X;'
2887 };
2888
2889 /// The parser has processed a module-declaration that begins the definition
2890 /// of a module interface or implementation.
2891 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2892 SourceLocation ModuleLoc, ModuleDeclKind MDK,
2893 ModuleIdPath Path, bool IsFirstDecl);
2894
2895 /// The parser has processed a global-module-fragment declaration that begins
2896 /// the definition of the global module fragment of the current module unit.
2897 /// \param ModuleLoc The location of the 'module' keyword.
2898 DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
2899
2900 /// The parser has processed a private-module-fragment declaration that begins
2901 /// the definition of the private module fragment of the current module unit.
2902 /// \param ModuleLoc The location of the 'module' keyword.
2903 /// \param PrivateLoc The location of the 'private' keyword.
2904 DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
2905 SourceLocation PrivateLoc);
2906
2907 /// The parser has processed a module import declaration.
2908 ///
2909 /// \param StartLoc The location of the first token in the declaration. This
2910 /// could be the location of an '@', 'export', or 'import'.
2911 /// \param ExportLoc The location of the 'export' keyword, if any.
2912 /// \param ImportLoc The location of the 'import' keyword.
2913 /// \param Path The module access path.
2914 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2915 SourceLocation ExportLoc,
2916 SourceLocation ImportLoc, ModuleIdPath Path);
2917 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2918 SourceLocation ExportLoc,
2919 SourceLocation ImportLoc, Module *M,
2920 ModuleIdPath Path = {});
2921
2922 /// The parser has processed a module import translated from a
2923 /// #include or similar preprocessing directive.
2924 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2925 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2926
2927 /// The parsed has entered a submodule.
2928 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2929 /// The parser has left a submodule.
2930 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2931
2932 /// Create an implicit import of the given module at the given
2933 /// source location, for error recovery, if possible.
2934 ///
2935 /// This routine is typically used when an entity found by name lookup
2936 /// is actually hidden within a module that we know about but the user
2937 /// has forgotten to import.
2938 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2939 Module *Mod);
2940
2941 /// Kinds of missing import. Note, the values of these enumerators correspond
2942 /// to %select values in diagnostics.
2943 enum class MissingImportKind {
2944 Declaration,
2945 Definition,
2946 DefaultArgument,
2947 ExplicitSpecialization,
2948 PartialSpecialization
2949 };
2950
2951 /// Diagnose that the specified declaration needs to be visible but
2952 /// isn't, and suggest a module import that would resolve the problem.
2953 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2954 MissingImportKind MIK, bool Recover = true);
2955 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2956 SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2957 MissingImportKind MIK, bool Recover);
2958
2959 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2960 SourceLocation LBraceLoc);
2961 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2962 SourceLocation RBraceLoc);
2963
2964 /// We've found a use of a templated declaration that would trigger an
2965 /// implicit instantiation. Check that any relevant explicit specializations
2966 /// and partial specializations are visible, and diagnose if not.
2967 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2968
2969 /// Retrieve a suitable printing policy for diagnostics.
2970 PrintingPolicy getPrintingPolicy() const {
2971 return getPrintingPolicy(Context, PP);
2972 }
2973
2974 /// Retrieve a suitable printing policy for diagnostics.
2975 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2976 const Preprocessor &PP);
2977
2978 /// Scope actions.
2979 void ActOnPopScope(SourceLocation Loc, Scope *S);
2980 void ActOnTranslationUnitScope(Scope *S);
2981
2982 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2983 RecordDecl *&AnonRecord);
2984 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2985 MultiTemplateParamsArg TemplateParams,
2986 bool IsExplicitInstantiation,
2987 RecordDecl *&AnonRecord);
2988
2989 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2990 AccessSpecifier AS,
2991 RecordDecl *Record,
2992 const PrintingPolicy &Policy);
2993
2994 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2995 RecordDecl *Record);
2996
2997 /// Common ways to introduce type names without a tag for use in diagnostics.
2998 /// Keep in sync with err_tag_reference_non_tag.
2999 enum NonTagKind {
3000 NTK_NonStruct,
3001 NTK_NonClass,
3002 NTK_NonUnion,
3003 NTK_NonEnum,
3004 NTK_Typedef,
3005 NTK_TypeAlias,
3006 NTK_Template,
3007 NTK_TypeAliasTemplate,
3008 NTK_TemplateTemplateArgument,
3009 };
3010
3011 /// Given a non-tag type declaration, returns an enum useful for indicating
3012 /// what kind of non-tag type this is.
3013 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
3014
3015 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
3016 TagTypeKind NewTag, bool isDefinition,
3017 SourceLocation NewTagLoc,
3018 const IdentifierInfo *Name);
3019
3020 enum TagUseKind {
3021 TUK_Reference, // Reference to a tag: 'struct foo *X;'
3022 TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
3023 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
3024 TUK_Friend // Friend declaration: 'friend struct foo;'
3025 };
3026
3027 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
3028 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
3029 SourceLocation NameLoc, const ParsedAttributesView &Attr,
3030 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
3031 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
3032 bool &IsDependent, SourceLocation ScopedEnumKWLoc,
3033 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
3034 bool IsTypeSpecifier, bool IsTemplateParamOrArg,
3035 SkipBodyInfo *SkipBody = nullptr);
3036
3037 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
3038 unsigned TagSpec, SourceLocation TagLoc,
3039 CXXScopeSpec &SS, IdentifierInfo *Name,
3040 SourceLocation NameLoc,
3041 const ParsedAttributesView &Attr,
3042 MultiTemplateParamsArg TempParamLists);
3043
3044 TypeResult ActOnDependentTag(Scope *S,
3045 unsigned TagSpec,
3046 TagUseKind TUK,
3047 const CXXScopeSpec &SS,
3048 IdentifierInfo *Name,
3049 SourceLocation TagLoc,
3050 SourceLocation NameLoc);
3051
3052 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
3053 IdentifierInfo *ClassName,
3054 SmallVectorImpl<Decl *> &Decls);
3055 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
3056 Declarator &D, Expr *BitfieldWidth);
3057
3058 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
3059 Declarator &D, Expr *BitfieldWidth,
3060 InClassInitStyle InitStyle,
3061 AccessSpecifier AS);
3062 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
3063 SourceLocation DeclStart, Declarator &D,
3064 Expr *BitfieldWidth,
3065 InClassInitStyle InitStyle,
3066 AccessSpecifier AS,
3067 const ParsedAttr &MSPropertyAttr);
3068
3069 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
3070 TypeSourceInfo *TInfo,
3071 RecordDecl *Record, SourceLocation Loc,
3072 bool Mutable, Expr *BitfieldWidth,
3073 InClassInitStyle InitStyle,
3074 SourceLocation TSSL,
3075 AccessSpecifier AS, NamedDecl *PrevDecl,
3076 Declarator *D = nullptr);
3077
3078 bool CheckNontrivialField(FieldDecl *FD);
3079 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
3080
3081 enum TrivialABIHandling {
3082 /// The triviality of a method unaffected by "trivial_abi".
3083 TAH_IgnoreTrivialABI,
3084
3085 /// The triviality of a method affected by "trivial_abi".
3086 TAH_ConsiderTrivialABI
3087 };
3088
3089 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
3090 TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
3091 bool Diagnose = false);
3092
3093 /// For a defaulted function, the kind of defaulted function that it is.
3094 class DefaultedFunctionKind {
3095 CXXSpecialMember SpecialMember : 8;
3096 DefaultedComparisonKind Comparison : 8;
3097
3098 public:
3099 DefaultedFunctionKind()
3100 : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {
3101 }
3102 DefaultedFunctionKind(CXXSpecialMember CSM)
3103 : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}
3104 DefaultedFunctionKind(DefaultedComparisonKind Comp)
3105 : SpecialMember(CXXInvalid), Comparison(Comp) {}
3106
3107 bool isSpecialMember() const { return SpecialMember != CXXInvalid; }
3108 bool isComparison() const {
3109 return Comparison != DefaultedComparisonKind::None;
3110 }
3111
3112 explicit operator bool() const {
3113 return isSpecialMember() || isComparison();
3114 }
3115
3116 CXXSpecialMember asSpecialMember() const { return SpecialMember; }
3117 DefaultedComparisonKind asComparison() const { return Comparison; }
3118
3119 /// Get the index of this function kind for use in diagnostics.
3120 unsigned getDiagnosticIndex() const {
3121 static_assert(CXXInvalid > CXXDestructor,
3122 "invalid should have highest index");
3123 static_assert((unsigned)DefaultedComparisonKind::None == 0,
3124 "none should be equal to zero");
3125 return SpecialMember + (unsigned)Comparison;
3126 }
3127 };
3128
3129 DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);
3130
3131 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {
3132 return getDefaultedFunctionKind(MD).asSpecialMember();
3133 }
3134 DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {
3135 return getDefaultedFunctionKind(FD).asComparison();
3136 }
3137
3138 void ActOnLastBitfield(SourceLocation DeclStart,
3139 SmallVectorImpl<Decl *> &AllIvarDecls);
3140 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
3141 Declarator &D, Expr *BitfieldWidth,
3142 tok::ObjCKeywordKind visibility);
3143
3144 // This is used for both record definitions and ObjC interface declarations.
3145 void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,
3146 ArrayRef<Decl *> Fields, SourceLocation LBrac,
3147 SourceLocation RBrac, const ParsedAttributesView &AttrList);
3148
3149 /// ActOnTagStartDefinition - Invoked when we have entered the
3150 /// scope of a tag's definition (e.g., for an enumeration, class,
3151 /// struct, or union).
3152 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
3153
3154 /// Perform ODR-like check for C/ObjC when merging tag types from modules.
3155 /// Differently from C++, actually parse the body and reject / error out
3156 /// in case of a structural mismatch.
3157 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
3158 SkipBodyInfo &SkipBody);
3159
3160 typedef void *SkippedDefinitionContext;
3161
3162 /// Invoked when we enter a tag definition that we're skipping.
3163 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
3164
3165 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
3166
3167 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
3168 /// C++ record definition's base-specifiers clause and are starting its
3169 /// member declarations.
3170 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
3171 SourceLocation FinalLoc,
3172 bool IsFinalSpelledSealed,
3173 bool IsAbstract,
3174 SourceLocation LBraceLoc);
3175
3176 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
3177 /// the definition of a tag (enumeration, class, struct, or union).
3178 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
3179 SourceRange BraceRange);
3180
3181 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
3182
3183 void ActOnObjCContainerFinishDefinition();
3184
3185 /// Invoked when we must temporarily exit the objective-c container
3186 /// scope for parsing/looking-up C constructs.
3187 ///
3188 /// Must be followed by a call to \see ActOnObjCReenterContainerContext
3189 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
3190 void ActOnObjCReenterContainerContext(DeclContext *DC);
3191
3192 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
3193 /// error parsing the definition of a tag.
3194 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
3195
3196 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
3197 EnumConstantDecl *LastEnumConst,
3198 SourceLocation IdLoc,
3199 IdentifierInfo *Id,
3200 Expr *val);
3201 bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
3202 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
3203 QualType EnumUnderlyingTy, bool IsFixed,
3204 const EnumDecl *Prev);
3205
3206 /// Determine whether the body of an anonymous enumeration should be skipped.
3207 /// \param II The name of the first enumerator.
3208 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
3209 SourceLocation IILoc);
3210
3211 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
3212 SourceLocation IdLoc, IdentifierInfo *Id,
3213 const ParsedAttributesView &Attrs,
3214 SourceLocation EqualLoc, Expr *Val);
3215 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
3216 Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S,
3217 const ParsedAttributesView &Attr);
3218
3219 /// Set the current declaration context until it gets popped.
3220 void PushDeclContext(Scope *S, DeclContext *DC);
3221 void PopDeclContext();
3222
3223 /// EnterDeclaratorContext - Used when we must lookup names in the context
3224 /// of a declarator's nested name specifier.
3225 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
3226 void ExitDeclaratorContext(Scope *S);
3227
3228 /// Enter a template parameter scope, after it's been associated with a particular
3229 /// DeclContext. Causes lookup within the scope to chain through enclosing contexts
3230 /// in the correct order.
3231 void EnterTemplatedContext(Scope *S, DeclContext *DC);
3232
3233 /// Push the parameters of D, which must be a function, into scope.
3234 void ActOnReenterFunctionContext(Scope* S, Decl* D);
3235 void ActOnExitFunctionContext();
3236
3237 DeclContext *getFunctionLevelDeclContext();
3238
3239 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
3240 /// to the function decl for the function being parsed. If we're currently
3241 /// in a 'block', this returns the containing context.
3242 FunctionDecl *getCurFunctionDecl();
3243
3244 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
3245 /// the method decl for the method being parsed. If we're currently
3246 /// in a 'block', this returns the containing context.
3247 ObjCMethodDecl *getCurMethodDecl();
3248
3249 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
3250 /// or C function we're in, otherwise return null. If we're currently
3251 /// in a 'block', this returns the containing context.
3252 NamedDecl *getCurFunctionOrMethodDecl();
3253
3254 /// Add this decl to the scope shadowed decl chains.
3255 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
3256
3257 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
3258 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
3259 /// true if 'D' belongs to the given declaration context.
3260 ///
3261 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
3262 /// enclosing namespace set of the context, rather than contained
3263 /// directly within it.
3264 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
3265 bool AllowInlineNamespace = false);
3266
3267 /// Finds the scope corresponding to the given decl context, if it
3268 /// happens to be an enclosing scope. Otherwise return NULL.
3269 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
3270
3271 /// Subroutines of ActOnDeclarator().
3272 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
3273 TypeSourceInfo *TInfo);
3274 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
3275
3276 /// Describes the kind of merge to perform for availability
3277 /// attributes (including "deprecated", "unavailable", and "availability").
3278 enum AvailabilityMergeKind {
3279 /// Don't merge availability attributes at all.
3280 AMK_None,
3281 /// Merge availability attributes for a redeclaration, which requires
3282 /// an exact match.
3283 AMK_Redeclaration,
3284 /// Merge availability attributes for an override, which requires
3285 /// an exact match or a weakening of constraints.
3286 AMK_Override,
3287 /// Merge availability attributes for an implementation of
3288 /// a protocol requirement.
3289 AMK_ProtocolImplementation,
3290 /// Merge availability attributes for an implementation of
3291 /// an optional protocol requirement.
3292 AMK_OptionalProtocolImplementation
3293 };
3294
3295 /// Describes the kind of priority given to an availability attribute.
3296 ///
3297 /// The sum of priorities deteremines the final priority of the attribute.
3298 /// The final priority determines how the attribute will be merged.
3299 /// An attribute with a lower priority will always remove higher priority
3300 /// attributes for the specified platform when it is being applied. An
3301 /// attribute with a higher priority will not be applied if the declaration
3302 /// already has an availability attribute with a lower priority for the
3303 /// specified platform. The final prirority values are not expected to match
3304 /// the values in this enumeration, but instead should be treated as a plain
3305 /// integer value. This enumeration just names the priority weights that are
3306 /// used to calculate that final vaue.
3307 enum AvailabilityPriority : int {
3308 /// The availability attribute was specified explicitly next to the
3309 /// declaration.
3310 AP_Explicit = 0,
3311
3312 /// The availability attribute was applied using '#pragma clang attribute'.
3313 AP_PragmaClangAttribute = 1,
3314
3315 /// The availability attribute for a specific platform was inferred from
3316 /// an availability attribute for another platform.
3317 AP_InferredFromOtherPlatform = 2
3318 };
3319
3320 /// Attribute merging methods. Return true if a new attribute was added.
3321 AvailabilityAttr *
3322 mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,
3323 IdentifierInfo *Platform, bool Implicit,
3324 VersionTuple Introduced, VersionTuple Deprecated,
3325 VersionTuple Obsoleted, bool IsUnavailable,
3326 StringRef Message, bool IsStrict, StringRef Replacement,
3327 AvailabilityMergeKind AMK, int Priority);
3328 TypeVisibilityAttr *
3329 mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3330 TypeVisibilityAttr::VisibilityType Vis);
3331 VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3332 VisibilityAttr::VisibilityType Vis);
3333 UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
3334 StringRef UuidAsWritten, MSGuidDecl *GuidDecl);
3335 DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);
3336 DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);
3337 MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,
3338 const AttributeCommonInfo &CI,
3339 bool BestCase,
3340 MSInheritanceModel Model);
3341 ErrorAttr *mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI,
3342 StringRef NewUserDiagnostic);
3343 FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,
3344 IdentifierInfo *Format, int FormatIdx,
3345 int FirstArg);
3346 SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,
3347 StringRef Name);
3348 CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
3349 StringRef Name);
3350 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,
3351 const AttributeCommonInfo &CI,
3352 const IdentifierInfo *Ident);
3353 MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);
3354 SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,
3355 StringRef Name);
3356 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,
3357 const AttributeCommonInfo &CI);
3358 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);
3359 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,
3360 const InternalLinkageAttr &AL);
3361 WebAssemblyImportNameAttr *mergeImportNameAttr(
3362 Decl *D, const WebAssemblyImportNameAttr &AL);
3363 WebAssemblyImportModuleAttr *mergeImportModuleAttr(
3364 Decl *D, const WebAssemblyImportModuleAttr &AL);
3365 EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL);
3366 EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D,
3367 const EnforceTCBLeafAttr &AL);
3368 BTFTagAttr *mergeBTFTagAttr(Decl *D, const BTFTagAttr &AL);
3369
3370 void mergeDeclAttributes(NamedDecl *New, Decl *Old,
3371 AvailabilityMergeKind AMK = AMK_Redeclaration);
3372 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
3373 LookupResult &OldDecls);
3374 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
3375 bool MergeTypeWithOld);
3376 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
3377 Scope *S, bool MergeTypeWithOld);
3378 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
3379 void MergeVarDecl(VarDecl *New, LookupResult &Previous);
3380 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
3381 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
3382 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
3383 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
3384 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
3385
3386 // AssignmentAction - This is used by all the assignment diagnostic functions
3387 // to represent what is actually causing the operation
3388 enum AssignmentAction {
3389 AA_Assigning,
3390 AA_Passing,
3391 AA_Returning,
3392 AA_Converting,
3393 AA_Initializing,
3394 AA_Sending,
3395 AA_Casting,
3396 AA_Passing_CFAudited
3397 };
3398
3399 /// C++ Overloading.
3400 enum OverloadKind {
3401 /// This is a legitimate overload: the existing declarations are
3402 /// functions or function templates with different signatures.
3403 Ovl_Overload,
3404
3405 /// This is not an overload because the signature exactly matches
3406 /// an existing declaration.
3407 Ovl_Match,
3408
3409 /// This is not an overload because the lookup results contain a
3410 /// non-function.
3411 Ovl_NonFunction
3412 };
3413 OverloadKind CheckOverload(Scope *S,
3414 FunctionDecl *New,
3415 const LookupResult &OldDecls,
3416 NamedDecl *&OldDecl,
3417 bool IsForUsingDecl);
3418 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
3419 bool ConsiderCudaAttrs = true,
3420 bool ConsiderRequiresClauses = true);
3421
3422 enum class AllowedExplicit {
3423 /// Allow no explicit functions to be used.
3424 None,
3425 /// Allow explicit conversion functions but not explicit constructors.
3426 Conversions,
3427 /// Allow both explicit conversion functions and explicit constructors.
3428 All
3429 };
3430
3431 ImplicitConversionSequence
3432 TryImplicitConversion(Expr *From, QualType ToType,
3433 bool SuppressUserConversions,
3434 AllowedExplicit AllowExplicit,
3435 bool InOverloadResolution,
3436 bool CStyle,
3437 bool AllowObjCWritebackConversion);
3438
3439 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
3440 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
3441 bool IsComplexPromotion(QualType FromType, QualType ToType);
3442 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
3443 bool InOverloadResolution,
3444 QualType& ConvertedType, bool &IncompatibleObjC);
3445 bool isObjCPointerConversion(QualType FromType, QualType ToType,
3446 QualType& ConvertedType, bool &IncompatibleObjC);
3447 bool isObjCWritebackConversion(QualType FromType, QualType ToType,
3448 QualType &ConvertedType);
3449 bool IsBlockPointerConversion(QualType FromType, QualType ToType,
3450 QualType& ConvertedType);
3451 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3452 const FunctionProtoType *NewType,
3453 unsigned *ArgPos = nullptr);
3454 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3455 QualType FromType, QualType ToType);
3456
3457 void maybeExtendBlockObject(ExprResult &E);
3458 CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
3459 bool CheckPointerConversion(Expr *From, QualType ToType,
3460 CastKind &Kind,
3461 CXXCastPath& BasePath,
3462 bool IgnoreBaseAccess,
3463 bool Diagnose = true);
3464 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
3465 bool InOverloadResolution,
3466 QualType &ConvertedType);
3467 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
3468 CastKind &Kind,
3469 CXXCastPath &BasePath,
3470 bool IgnoreBaseAccess);
3471 bool IsQualificationConversion(QualType FromType, QualType ToType,
3472 bool CStyle, bool &ObjCLifetimeConversion);
3473 bool IsFunctionConversion(QualType FromType, QualType ToType,
3474 QualType &ResultTy);
3475 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
3476 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
3477
3478 bool CanPerformAggregateInitializationForOverloadResolution(
3479 const InitializedEntity &Entity, InitListExpr *From);
3480
3481 bool IsStringInit(Expr *Init, const ArrayType *AT);
3482
3483 bool CanPerformCopyInitialization(const InitializedEntity &Entity,
3484 ExprResult Init);
3485 ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
3486 SourceLocation EqualLoc,
3487 ExprResult Init,
3488 bool TopLevelOfInitList = false,
3489 bool AllowExplicit = false);
3490 ExprResult PerformObjectArgumentInitialization(Expr *From,
3491 NestedNameSpecifier *Qualifier,
3492 NamedDecl *FoundDecl,
3493 CXXMethodDecl *Method);
3494
3495 /// Check that the lifetime of the initializer (and its subobjects) is
3496 /// sufficient for initializing the entity, and perform lifetime extension
3497 /// (when permitted) if not.
3498 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
3499
3500 ExprResult PerformContextuallyConvertToBool(Expr *From);
3501 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
3502
3503 /// Contexts in which a converted constant expression is required.
3504 enum CCEKind {
3505 CCEK_CaseValue, ///< Expression in a case label.
3506 CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
3507 CCEK_TemplateArg, ///< Value of a non-type template parameter.
3508 CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.
3509 CCEK_ExplicitBool, ///< Condition in an explicit(bool) specifier.
3510 CCEK_Noexcept ///< Condition in a noexcept(bool) specifier.
3511 };
3512 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3513 llvm::APSInt &Value, CCEKind CCE);
3514 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3515 APValue &Value, CCEKind CCE,
3516 NamedDecl *Dest = nullptr);
3517
3518 /// Abstract base class used to perform a contextual implicit
3519 /// conversion from an expression to any type passing a filter.
3520 class ContextualImplicitConverter {
3521 public:
3522 bool Suppress;
3523 bool SuppressConversion;
3524
3525 ContextualImplicitConverter(bool Suppress = false,
3526 bool SuppressConversion = false)
3527 : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
3528
3529 /// Determine whether the specified type is a valid destination type
3530 /// for this conversion.
3531 virtual bool match(QualType T) = 0;
3532
3533 /// Emits a diagnostic complaining that the expression does not have
3534 /// integral or enumeration type.
3535 virtual SemaDiagnosticBuilder
3536 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
3537
3538 /// Emits a diagnostic when the expression has incomplete class type.
3539 virtual SemaDiagnosticBuilder
3540 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
3541
3542 /// Emits a diagnostic when the only matching conversion function
3543 /// is explicit.
3544 virtual SemaDiagnosticBuilder diagnoseExplicitConv(
3545 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3546
3547 /// Emits a note for the explicit conversion function.
3548 virtual SemaDiagnosticBuilder
3549 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3550
3551 /// Emits a diagnostic when there are multiple possible conversion
3552 /// functions.
3553 virtual SemaDiagnosticBuilder
3554 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
3555
3556 /// Emits a note for one of the candidate conversions.
3557 virtual SemaDiagnosticBuilder
3558 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3559
3560 /// Emits a diagnostic when we picked a conversion function
3561 /// (for cases when we are not allowed to pick a conversion function).
3562 virtual SemaDiagnosticBuilder diagnoseConversion(
3563 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3564
3565 virtual ~ContextualImplicitConverter() {}
3566 };
3567
3568 class ICEConvertDiagnoser : public ContextualImplicitConverter {
3569 bool AllowScopedEnumerations;
3570
3571 public:
3572 ICEConvertDiagnoser(bool AllowScopedEnumerations,
3573 bool Suppress, bool SuppressConversion)
3574 : ContextualImplicitConverter(Suppress, SuppressConversion),
3575 AllowScopedEnumerations(AllowScopedEnumerations) {}
3576
3577 /// Match an integral or (possibly scoped) enumeration type.
3578 bool match(QualType T) override;
3579
3580 SemaDiagnosticBuilder
3581 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
3582 return diagnoseNotInt(S, Loc, T);
3583 }
3584
3585 /// Emits a diagnostic complaining that the expression does not have
3586 /// integral or enumeration type.
3587 virtual SemaDiagnosticBuilder
3588 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
3589 };
3590
3591 /// Perform a contextual implicit conversion.
3592 ExprResult PerformContextualImplicitConversion(
3593 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3594
3595
3596 enum ObjCSubscriptKind {
3597 OS_Array,
3598 OS_Dictionary,
3599 OS_Error
3600 };
3601 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3602
3603 // Note that LK_String is intentionally after the other literals, as
3604 // this is used for diagnostics logic.
3605 enum ObjCLiteralKind {
3606 LK_Array,
3607 LK_Dictionary,
3608 LK_Numeric,
3609 LK_Boxed,
3610 LK_String,
3611 LK_Block,
3612 LK_None
3613 };
3614 ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3615
3616 ExprResult PerformObjectMemberConversion(Expr *From,
3617 NestedNameSpecifier *Qualifier,
3618 NamedDecl *FoundDecl,
3619 NamedDecl *Member);
3620
3621 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
3622 // TODO: make this is a typesafe union.
3623 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet;
3624 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
3625
3626 using ADLCallKind = CallExpr::ADLCallKind;
3627
3628 void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
3629 ArrayRef<Expr *> Args,
3630 OverloadCandidateSet &CandidateSet,
3631 bool SuppressUserConversions = false,
3632 bool PartialOverloading = false,
3633 bool AllowExplicit = true,
3634 bool AllowExplicitConversion = false,
3635 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3636 ConversionSequenceList EarlyConversions = None,
3637 OverloadCandidateParamOrder PO = {});
3638 void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
3639 ArrayRef<Expr *> Args,
3640 OverloadCandidateSet &CandidateSet,
3641 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
3642 bool SuppressUserConversions = false,
3643 bool PartialOverloading = false,
3644 bool FirstArgumentIsBase = false);
3645 void AddMethodCandidate(DeclAccessPair FoundDecl,
3646 QualType ObjectType,
3647 Expr::Classification ObjectClassification,
3648 ArrayRef<Expr *> Args,
3649 OverloadCandidateSet& CandidateSet,
3650 bool SuppressUserConversion = false,
3651 OverloadCandidateParamOrder PO = {});
3652 void AddMethodCandidate(CXXMethodDecl *Method,
3653 DeclAccessPair FoundDecl,
3654 CXXRecordDecl *ActingContext, QualType ObjectType,
3655 Expr::Classification ObjectClassification,
3656 ArrayRef<Expr *> Args,
3657 OverloadCandidateSet& CandidateSet,
3658 bool SuppressUserConversions = false,
3659 bool PartialOverloading = false,
3660 ConversionSequenceList EarlyConversions = None,
3661 OverloadCandidateParamOrder PO = {});
3662 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
3663 DeclAccessPair FoundDecl,
3664 CXXRecordDecl *ActingContext,
3665 TemplateArgumentListInfo *ExplicitTemplateArgs,
3666 QualType ObjectType,
3667 Expr::Classification ObjectClassification,
3668 ArrayRef<Expr *> Args,
3669 OverloadCandidateSet& CandidateSet,
3670 bool SuppressUserConversions = false,
3671 bool PartialOverloading = false,
3672 OverloadCandidateParamOrder PO = {});
3673 void AddTemplateOverloadCandidate(
3674 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3675 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3676 OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
3677 bool PartialOverloading = false, bool AllowExplicit = true,
3678 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3679 OverloadCandidateParamOrder PO = {});
3680 bool CheckNonDependentConversions(
3681 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
3682 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3683 ConversionSequenceList &Conversions, bool SuppressUserConversions,
3684 CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),
3685 Expr::Classification ObjectClassification = {},
3686 OverloadCandidateParamOrder PO = {});
3687 void AddConversionCandidate(
3688 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
3689 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3690 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3691 bool AllowExplicit, bool AllowResultConversion = true);
3692 void AddTemplateConversionCandidate(
3693 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3694 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3695 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3696 bool AllowExplicit, bool AllowResultConversion = true);
3697 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
3698 DeclAccessPair FoundDecl,
3699 CXXRecordDecl *ActingContext,
3700 const FunctionProtoType *Proto,
3701 Expr *Object, ArrayRef<Expr *> Args,
3702 OverloadCandidateSet& CandidateSet);
3703 void AddNonMemberOperatorCandidates(
3704 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3705 OverloadCandidateSet &CandidateSet,
3706 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
3707 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3708 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3709 OverloadCandidateSet &CandidateSet,
3710 OverloadCandidateParamOrder PO = {});
3711 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
3712 OverloadCandidateSet& CandidateSet,
3713 bool IsAssignmentOperator = false,
3714 unsigned NumContextualBoolArguments = 0);
3715 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
3716 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3717 OverloadCandidateSet& CandidateSet);
3718 void AddArgumentDependentLookupCandidates(DeclarationName Name,
3719 SourceLocation Loc,
3720 ArrayRef<Expr *> Args,
3721 TemplateArgumentListInfo *ExplicitTemplateArgs,
3722 OverloadCandidateSet& CandidateSet,
3723 bool PartialOverloading = false);
3724
3725 // Emit as a 'note' the specific overload candidate
3726 void NoteOverloadCandidate(
3727 NamedDecl *Found, FunctionDecl *Fn,
3728 OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
3729 QualType DestType = QualType(), bool TakingAddress = false);
3730
3731 // Emit as a series of 'note's all template and non-templates identified by
3732 // the expression Expr
3733 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
3734 bool TakingAddress = false);
3735
3736 /// Check the enable_if expressions on the given function. Returns the first
3737 /// failing attribute, or NULL if they were all successful.
3738 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,
3739 ArrayRef<Expr *> Args,
3740 bool MissingImplicitThis = false);
3741
3742 /// Find the failed Boolean condition within a given Boolean
3743 /// constant expression, and describe it with a string.
3744 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3745
3746 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3747 /// non-ArgDependent DiagnoseIfAttrs.
3748 ///
3749 /// Argument-dependent diagnose_if attributes should be checked each time a
3750 /// function is used as a direct callee of a function call.
3751 ///
3752 /// Returns true if any errors were emitted.
3753 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
3754 const Expr *ThisArg,
3755 ArrayRef<const Expr *> Args,
3756 SourceLocation Loc);
3757
3758 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3759 /// ArgDependent DiagnoseIfAttrs.
3760 ///
3761 /// Argument-independent diagnose_if attributes should be checked on every use
3762 /// of a function.
3763 ///
3764 /// Returns true if any errors were emitted.
3765 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
3766 SourceLocation Loc);
3767
3768 /// Returns whether the given function's address can be taken or not,
3769 /// optionally emitting a diagnostic if the address can't be taken.
3770 ///
3771 /// Returns false if taking the address of the function is illegal.
3772 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
3773 bool Complain = false,
3774 SourceLocation Loc = SourceLocation());
3775
3776 // [PossiblyAFunctionType] --> [Return]
3777 // NonFunctionType --> NonFunctionType
3778 // R (A) --> R(A)
3779 // R (*)(A) --> R (A)
3780 // R (&)(A) --> R (A)
3781 // R (S::*)(A) --> R (A)
3782 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
3783
3784 FunctionDecl *
3785 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3786 QualType TargetType,
3787 bool Complain,
3788 DeclAccessPair &Found,
3789 bool *pHadMultipleCandidates = nullptr);
3790
3791 FunctionDecl *
3792 resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
3793
3794 bool resolveAndFixAddressOfSingleOverloadCandidate(
3795 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
3796
3797 FunctionDecl *
3798 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
3799 bool Complain = false,
3800 DeclAccessPair *Found = nullptr);
3801
3802 bool ResolveAndFixSingleFunctionTemplateSpecialization(
3803 ExprResult &SrcExpr,
3804 bool DoFunctionPointerConverion = false,
3805 bool Complain = false,
3806 SourceRange OpRangeForComplaining = SourceRange(),
3807 QualType DestTypeForComplaining = QualType(),
3808 unsigned DiagIDForComplaining = 0);
3809
3810
3811 Expr *FixOverloadedFunctionReference(Expr *E,
3812 DeclAccessPair FoundDecl,
3813 FunctionDecl *Fn);
3814 ExprResult FixOverloadedFunctionReference(ExprResult,
3815 DeclAccessPair FoundDecl,
3816 FunctionDecl *Fn);
3817
3818 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
3819 ArrayRef<Expr *> Args,
3820 OverloadCandidateSet &CandidateSet,
3821 bool PartialOverloading = false);
3822 void AddOverloadedCallCandidates(
3823 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
3824 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
3825
3826 // An enum used to represent the different possible results of building a
3827 // range-based for loop.
3828 enum ForRangeStatus {
3829 FRS_Success,
3830 FRS_NoViableFunction,
3831 FRS_DiagnosticIssued
3832 };
3833
3834 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
3835 SourceLocation RangeLoc,
3836 const DeclarationNameInfo &NameInfo,
3837 LookupResult &MemberLookup,
3838 OverloadCandidateSet *CandidateSet,
3839 Expr *Range, ExprResult *CallExpr);
3840
3841 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
3842 UnresolvedLookupExpr *ULE,
3843 SourceLocation LParenLoc,
3844 MultiExprArg Args,
3845 SourceLocation RParenLoc,
3846 Expr *ExecConfig,
3847 bool AllowTypoCorrection=true,
3848 bool CalleesAddressIsTaken=false);
3849
3850 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
3851 MultiExprArg Args, SourceLocation RParenLoc,
3852 OverloadCandidateSet *CandidateSet,
3853 ExprResult *Result);
3854
3855 ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
3856 NestedNameSpecifierLoc NNSLoc,
3857 DeclarationNameInfo DNI,
3858 const UnresolvedSetImpl &Fns,
3859 bool PerformADL = true);
3860
3861 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
3862 UnaryOperatorKind Opc,
3863 const UnresolvedSetImpl &Fns,
3864 Expr *input, bool RequiresADL = true);
3865
3866 void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
3867 OverloadedOperatorKind Op,
3868 const UnresolvedSetImpl &Fns,
3869 ArrayRef<Expr *> Args, bool RequiresADL = true);
3870 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
3871 BinaryOperatorKind Opc,
3872 const UnresolvedSetImpl &Fns,
3873 Expr *LHS, Expr *RHS,
3874 bool RequiresADL = true,
3875 bool AllowRewrittenCandidates = true,
3876 FunctionDecl *DefaultedFn = nullptr);
3877 ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
3878 const UnresolvedSetImpl &Fns,
3879 Expr *LHS, Expr *RHS,
3880 FunctionDecl *DefaultedFn);
3881
3882 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
3883 SourceLocation RLoc,
3884 Expr *Base,Expr *Idx);
3885
3886 ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
3887 SourceLocation LParenLoc,
3888 MultiExprArg Args,
3889 SourceLocation RParenLoc,
3890 bool AllowRecovery = false);
3891 ExprResult
3892 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
3893 MultiExprArg Args,
3894 SourceLocation RParenLoc);
3895
3896 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
3897 SourceLocation OpLoc,
3898 bool *NoArrowOperatorFound = nullptr);
3899
3900 /// CheckCallReturnType - Checks that a call expression's return type is
3901 /// complete. Returns true on failure. The location passed in is the location
3902 /// that best represents the call.
3903 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
3904 CallExpr *CE, FunctionDecl *FD);
3905
3906 /// Helpers for dealing with blocks and functions.
3907 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
3908 bool CheckParameterNames);
3909 void CheckCXXDefaultArguments(FunctionDecl *FD);
3910 void CheckExtraCXXDefaultArguments(Declarator &D);
3911 Scope *getNonFieldDeclScope(Scope *S);
3912
3913 /// \name Name lookup
3914 ///
3915 /// These routines provide name lookup that is used during semantic
3916 /// analysis to resolve the various kinds of names (identifiers,
3917 /// overloaded operator names, constructor names, etc.) into zero or
3918 /// more declarations within a particular scope. The major entry
3919 /// points are LookupName, which performs unqualified name lookup,
3920 /// and LookupQualifiedName, which performs qualified name lookup.
3921 ///
3922 /// All name lookup is performed based on some specific criteria,
3923 /// which specify what names will be visible to name lookup and how
3924 /// far name lookup should work. These criteria are important both
3925 /// for capturing language semantics (certain lookups will ignore
3926 /// certain names, for example) and for performance, since name
3927 /// lookup is often a bottleneck in the compilation of C++. Name
3928 /// lookup criteria is specified via the LookupCriteria enumeration.
3929 ///
3930 /// The results of name lookup can vary based on the kind of name
3931 /// lookup performed, the current language, and the translation
3932 /// unit. In C, for example, name lookup will either return nothing
3933 /// (no entity found) or a single declaration. In C++, name lookup
3934 /// can additionally refer to a set of overloaded functions or
3935 /// result in an ambiguity. All of the possible results of name
3936 /// lookup are captured by the LookupResult class, which provides
3937 /// the ability to distinguish among them.
3938 //@{
3939
3940 /// Describes the kind of name lookup to perform.
3941 enum LookupNameKind {
3942 /// Ordinary name lookup, which finds ordinary names (functions,
3943 /// variables, typedefs, etc.) in C and most kinds of names
3944 /// (functions, variables, members, types, etc.) in C++.
3945 LookupOrdinaryName = 0,
3946 /// Tag name lookup, which finds the names of enums, classes,
3947 /// structs, and unions.
3948 LookupTagName,
3949 /// Label name lookup.
3950 LookupLabel,
3951 /// Member name lookup, which finds the names of
3952 /// class/struct/union members.
3953 LookupMemberName,
3954 /// Look up of an operator name (e.g., operator+) for use with
3955 /// operator overloading. This lookup is similar to ordinary name
3956 /// lookup, but will ignore any declarations that are class members.
3957 LookupOperatorName,
3958 /// Look up a name following ~ in a destructor name. This is an ordinary
3959 /// lookup, but prefers tags to typedefs.
3960 LookupDestructorName,
3961 /// Look up of a name that precedes the '::' scope resolution
3962 /// operator in C++. This lookup completely ignores operator, object,
3963 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3964 LookupNestedNameSpecifierName,
3965 /// Look up a namespace name within a C++ using directive or
3966 /// namespace alias definition, ignoring non-namespace names (C++
3967 /// [basic.lookup.udir]p1).
3968 LookupNamespaceName,
3969 /// Look up all declarations in a scope with the given name,
3970 /// including resolved using declarations. This is appropriate
3971 /// for checking redeclarations for a using declaration.
3972 LookupUsingDeclName,
3973 /// Look up an ordinary name that is going to be redeclared as a
3974 /// name with linkage. This lookup ignores any declarations that
3975 /// are outside of the current scope unless they have linkage. See
3976 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3977 LookupRedeclarationWithLinkage,
3978 /// Look up a friend of a local class. This lookup does not look
3979 /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3980 LookupLocalFriendName,
3981 /// Look up the name of an Objective-C protocol.
3982 LookupObjCProtocolName,
3983 /// Look up implicit 'self' parameter of an objective-c method.
3984 LookupObjCImplicitSelfParam,
3985 /// Look up the name of an OpenMP user-defined reduction operation.
3986 LookupOMPReductionName,
3987 /// Look up the name of an OpenMP user-defined mapper.
3988 LookupOMPMapperName,
3989 /// Look up any declaration with any name.
3990 LookupAnyName
3991 };
3992
3993 /// Specifies whether (or how) name lookup is being performed for a
3994 /// redeclaration (vs. a reference).
3995 enum RedeclarationKind {
3996 /// The lookup is a reference to this name that is not for the
3997 /// purpose of redeclaring the name.
3998 NotForRedeclaration = 0,
3999 /// The lookup results will be used for redeclaration of a name,
4000 /// if an entity by that name already exists and is visible.
4001 ForVisibleRedeclaration,
4002 /// The lookup results will be used for redeclaration of a name
4003 /// with external linkage; non-visible lookup results with external linkage
4004 /// may also be found.
4005 ForExternalRedeclaration
4006 };
4007
4008 RedeclarationKind forRedeclarationInCurContext() {
4009 // A declaration with an owning module for linkage can never link against
4010 // anything that is not visible. We don't need to check linkage here; if
4011 // the context has internal linkage, redeclaration lookup won't find things
4012 // from other TUs, and we can't safely compute linkage yet in general.
4013 if (cast<Decl>(CurContext)
4014 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
4015 return ForVisibleRedeclaration;
4016 return ForExternalRedeclaration;
4017 }
4018
4019 /// The possible outcomes of name lookup for a literal operator.
4020 enum LiteralOperatorLookupResult {
4021 /// The lookup resulted in an error.
4022 LOLR_Error,
4023 /// The lookup found no match but no diagnostic was issued.
4024 LOLR_ErrorNoDiagnostic,
4025 /// The lookup found a single 'cooked' literal operator, which
4026 /// expects a normal literal to be built and passed to it.
4027 LOLR_Cooked,
4028 /// The lookup found a single 'raw' literal operator, which expects
4029 /// a string literal containing the spelling of the literal token.
4030 LOLR_Raw,
4031 /// The lookup found an overload set of literal operator templates,
4032 /// which expect the characters of the spelling of the literal token to be
4033 /// passed as a non-type template argument pack.
4034 LOLR_Template,
4035 /// The lookup found an overload set of literal operator templates,
4036 /// which expect the character type and characters of the spelling of the
4037 /// string literal token to be passed as template arguments.
4038 LOLR_StringTemplatePack,
4039 };
4040
4041 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
4042 CXXSpecialMember SM,
4043 bool ConstArg,
4044 bool VolatileArg,
4045 bool RValueThis,
4046 bool ConstThis,
4047 bool VolatileThis);
4048
4049 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
4050 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
4051 TypoRecoveryCallback;
4052
4053private:
4054 bool CppLookupName(LookupResult &R, Scope *S);
4055
4056 struct TypoExprState {
4057 std::unique_ptr<TypoCorrectionConsumer> Consumer;
4058 TypoDiagnosticGenerator DiagHandler;
4059 TypoRecoveryCallback RecoveryHandler;
4060 TypoExprState();
4061 TypoExprState(TypoExprState &&other) noexcept;
4062 TypoExprState &operator=(TypoExprState &&other) noexcept;
4063 };
4064
4065 /// The set of unhandled TypoExprs and their associated state.
4066 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
4067
4068 /// Creates a new TypoExpr AST node.
4069 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
4070 TypoDiagnosticGenerator TDG,
4071 TypoRecoveryCallback TRC, SourceLocation TypoLoc);
4072
4073 // The set of known/encountered (unique, canonicalized) NamespaceDecls.
4074 //
4075 // The boolean value will be true to indicate that the namespace was loaded
4076 // from an AST/PCH file, or false otherwise.
4077 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
4078
4079 /// Whether we have already loaded known namespaces from an extenal
4080 /// source.
4081 bool LoadedExternalKnownNamespaces;
4082
4083 /// Helper for CorrectTypo and CorrectTypoDelayed used to create and
4084 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
4085 /// should be skipped entirely.
4086 std::unique_ptr<TypoCorrectionConsumer>
4087 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
4088 Sema::LookupNameKind LookupKind, Scope *S,
4089 CXXScopeSpec *SS,
4090 CorrectionCandidateCallback &CCC,
4091 DeclContext *MemberContext, bool EnteringContext,
4092 const ObjCObjectPointerType *OPT,
4093 bool ErrorRecovery);
4094
4095public:
4096 const TypoExprState &getTypoExprState(TypoExpr *TE) const;
4097
4098 /// Clears the state of the given TypoExpr.
4099 void clearDelayedTypo(TypoExpr *TE);
4100
4101 /// Look up a name, looking for a single declaration. Return
4102 /// null if the results were absent, ambiguous, or overloaded.
4103 ///
4104 /// It is preferable to use the elaborated form and explicitly handle
4105 /// ambiguity and overloaded.
4106 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
4107 SourceLocation Loc,
4108 LookupNameKind NameKind,
4109 RedeclarationKind Redecl
4110 = NotForRedeclaration);
4111 bool LookupBuiltin(LookupResult &R);
4112 void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID);
4113 bool LookupName(LookupResult &R, Scope *S,
4114 bool AllowBuiltinCreation = false);
4115 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4116 bool InUnqualifiedLookup = false);
4117 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4118 CXXScopeSpec &SS);
4119 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
4120 bool AllowBuiltinCreation = false,
4121 bool EnteringContext = false);
4122 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
4123 RedeclarationKind Redecl
4124 = NotForRedeclaration);
4125 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
4126
4127 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
4128 UnresolvedSetImpl &Functions);
4129
4130 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
4131 SourceLocation GnuLabelLoc = SourceLocation());
4132
4133 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
4134 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
4135 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
4136 unsigned Quals);
4137 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
4138 bool RValueThis, unsigned ThisQuals);
4139 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
4140 unsigned Quals);
4141 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
4142 bool RValueThis, unsigned ThisQuals);
4143 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
4144
4145 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id,
4146 bool IsUDSuffix);
4147 LiteralOperatorLookupResult
4148 LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys,
4149 bool AllowRaw, bool AllowTemplate,
4150 bool AllowStringTemplate, bool DiagnoseMissing,
4151 StringLiteral *StringLit = nullptr);
4152 bool isKnownName(StringRef name);
4153
4154 /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
4155 enum class FunctionEmissionStatus {
4156 Emitted,
4157 CUDADiscarded, // Discarded due to CUDA/HIP hostness
4158 OMPDiscarded, // Discarded due to OpenMP hostness
4159 TemplateDiscarded, // Discarded due to uninstantiated templates
4160 Unknown,
4161 };
4162 FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
4163 bool Final = false);
4164
4165 // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
4166 bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
4167
4168 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
4169 ArrayRef<Expr *> Args, ADLResult &Functions);
4170
4171 void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
4172 VisibleDeclConsumer &Consumer,
4173 bool IncludeGlobalScope = true,
4174 bool LoadExternal = true);
4175 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
4176 VisibleDeclConsumer &Consumer,
4177 bool IncludeGlobalScope = true,
4178 bool IncludeDependentBases = false,
4179 bool LoadExternal = true);
4180
4181 enum CorrectTypoKind {
4182 CTK_NonError, // CorrectTypo used in a non error recovery situation.
4183 CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
4184 };
4185
4186 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
4187 Sema::LookupNameKind LookupKind,
4188 Scope *S, CXXScopeSpec *SS,
4189 CorrectionCandidateCallback &CCC,
4190 CorrectTypoKind Mode,
4191 DeclContext *MemberContext = nullptr,
4192 bool EnteringContext = false,
4193 const ObjCObjectPointerType *OPT = nullptr,
4194 bool RecordFailure = true);
4195
4196 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
4197 Sema::LookupNameKind LookupKind, Scope *S,
4198 CXXScopeSpec *SS,
4199 CorrectionCandidateCallback &CCC,
4200 TypoDiagnosticGenerator TDG,
4201 TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4202 DeclContext *MemberContext = nullptr,
4203 bool EnteringContext = false,
4204 const ObjCObjectPointerType *OPT = nullptr);
4205
4206 /// Process any TypoExprs in the given Expr and its children,
4207 /// generating diagnostics as appropriate and returning a new Expr if there
4208 /// were typos that were all successfully corrected and ExprError if one or
4209 /// more typos could not be corrected.
4210 ///
4211 /// \param E The Expr to check for TypoExprs.
4212 ///
4213 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
4214 /// initializer.
4215 ///
4216 /// \param RecoverUncorrectedTypos If true, when typo correction fails, it
4217 /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.
4218 ///
4219 /// \param Filter A function applied to a newly rebuilt Expr to determine if
4220 /// it is an acceptable/usable result from a single combination of typo
4221 /// corrections. As long as the filter returns ExprError, different
4222 /// combinations of corrections will be tried until all are exhausted.
4223 ExprResult CorrectDelayedTyposInExpr(
4224 Expr *E, VarDecl *InitDecl = nullptr,
4225 bool RecoverUncorrectedTypos = false,
4226 llvm::function_ref<ExprResult(Expr *)> Filter =
4227 [](Expr *E) -> ExprResult { return E; });
4228
4229 ExprResult CorrectDelayedTyposInExpr(
4230 ExprResult ER, VarDecl *InitDecl = nullptr,
4231 bool RecoverUncorrectedTypos = false,
4232 llvm::function_ref<ExprResult(Expr *)> Filter =
4233 [](Expr *E) -> ExprResult { return E; }) {
4234 return ER.isInvalid()
4235 ? ER
4236 : CorrectDelayedTyposInExpr(ER.get(), InitDecl,
4237 RecoverUncorrectedTypos, Filter);
4238 }
4239
4240 void diagnoseTypo(const TypoCorrection &Correction,
4241 const PartialDiagnostic &TypoDiag,
4242 bool ErrorRecovery = true);
4243
4244 void diagnoseTypo(const TypoCorrection &Correction,
4245 const PartialDiagnostic &TypoDiag,
4246 const PartialDiagnostic &PrevNote,
4247 bool ErrorRecovery = true);
4248
4249 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
4250
4251 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
4252 ArrayRef<Expr *> Args,
4253 AssociatedNamespaceSet &AssociatedNamespaces,
4254 AssociatedClassSet &AssociatedClasses);
4255
4256 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
4257 bool ConsiderLinkage, bool AllowInlineNamespace);
4258
4259 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
4260
4261 void DiagnoseAmbiguousLookup(LookupResult &Result);
4262 //@}
4263
4264 /// Attempts to produce a RecoveryExpr after some AST node cannot be created.
4265 ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
4266 ArrayRef<Expr *> SubExprs,
4267 QualType T = QualType());
4268
4269 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
4270 SourceLocation IdLoc,
4271 bool TypoCorrection = false);
4272 FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,
4273 SourceLocation Loc);
4274 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
4275 Scope *S, bool ForRedeclaration,
4276 SourceLocation Loc);
4277 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
4278 Scope *S);
4279 void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
4280 FunctionDecl *FD);
4281 void AddKnownFunctionAttributes(FunctionDecl *FD);
4282
4283 // More parsing and symbol table subroutines.
4284
4285 void ProcessPragmaWeak(Scope *S, Decl *D);
4286 // Decl attributes - this routine is the top level dispatcher.
4287 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
4288 // Helper for delayed processing of attributes.
4289 void ProcessDeclAttributeDelayed(Decl *D,
4290 const ParsedAttributesView &AttrList);
4291 void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
4292 bool IncludeCXX11Attributes = true);
4293 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4294 const ParsedAttributesView &AttrList);
4295
4296 void checkUnusedDeclAttributes(Declarator &D);
4297
4298 /// Handles semantic checking for features that are common to all attributes,
4299 /// such as checking whether a parameter was properly specified, or the
4300 /// correct number of arguments were passed, etc. Returns true if the
4301 /// attribute has been diagnosed.
4302 bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A);
4303 bool checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A);
4304
4305 /// Determine if type T is a valid subject for a nonnull and similar
4306 /// attributes. By default, we look through references (the behavior used by
4307 /// nonnull), but if the second parameter is true, then we treat a reference
4308 /// type as valid.
4309 bool isValidPointerAttrType(QualType T, bool RefOkay = false);
4310
4311 bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);
4312 bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,
4313 const FunctionDecl *FD = nullptr);
4314 bool CheckAttrTarget(const ParsedAttr &CurrAttr);
4315 bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
4316 bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
4317 StringRef &Str,
4318 SourceLocation *ArgLocation = nullptr);
4319 llvm::Error isValidSectionSpecifier(StringRef Str);
4320 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
4321 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
4322 bool checkMSInheritanceAttrOnDefinition(
4323 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
4324 MSInheritanceModel SemanticSpelling);
4325
4326 void CheckAlignasUnderalignment(Decl *D);
4327
4328 /// Adjust the calling convention of a method to be the ABI default if it
4329 /// wasn't specified explicitly. This handles method types formed from
4330 /// function type typedefs and typename template arguments.
4331 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
4332 SourceLocation Loc);
4333
4334 // Check if there is an explicit attribute, but only look through parens.
4335 // The intent is to look for an attribute on the current declarator, but not
4336 // one that came from a typedef.
4337 bool hasExplicitCallingConv(QualType T);
4338
4339 /// Get the outermost AttributedType node that sets a calling convention.
4340 /// Valid types should not have multiple attributes with different CCs.
4341 const AttributedType *getCallingConvAttributedType(QualType T) const;
4342
4343 /// Process the attributes before creating an attributed statement. Returns
4344 /// the semantic attributes that have been processed.
4345 void ProcessStmtAttributes(Stmt *Stmt,
4346 const ParsedAttributesWithRange &InAttrs,
4347 SmallVectorImpl<const Attr *> &OutAttrs);
4348
4349 void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
4350 ObjCMethodDecl *MethodDecl,
4351 bool IsProtocolMethodDecl);
4352
4353 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
4354 ObjCMethodDecl *Overridden,
4355 bool IsProtocolMethodDecl);
4356
4357 /// WarnExactTypedMethods - This routine issues a warning if method
4358 /// implementation declaration matches exactly that of its declaration.
4359 void WarnExactTypedMethods(ObjCMethodDecl *Method,
4360 ObjCMethodDecl *MethodDecl,
4361 bool IsProtocolMethodDecl);
4362
4363 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
4364
4365 /// CheckImplementationIvars - This routine checks if the instance variables
4366 /// listed in the implelementation match those listed in the interface.
4367 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
4368 ObjCIvarDecl **Fields, unsigned nIvars,
4369 SourceLocation Loc);
4370
4371 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
4372 /// remains unimplemented in the class or category \@implementation.
4373 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
4374 ObjCContainerDecl* IDecl,
4375 bool IncompleteImpl = false);
4376
4377 /// DiagnoseUnimplementedProperties - This routine warns on those properties
4378 /// which must be implemented by this implementation.
4379 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
4380 ObjCContainerDecl *CDecl,
4381 bool SynthesizeProperties);
4382
4383 /// Diagnose any null-resettable synthesized setters.
4384 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
4385
4386 /// DefaultSynthesizeProperties - This routine default synthesizes all
4387 /// properties which must be synthesized in the class's \@implementation.
4388 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
4389 ObjCInterfaceDecl *IDecl,
4390 SourceLocation AtEnd);
4391 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);
4392
4393 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
4394 /// an ivar synthesized for 'Method' and 'Method' is a property accessor
4395 /// declared in class 'IFace'.
4396 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
4397 ObjCMethodDecl *Method, ObjCIvarDecl *IV);
4398
4399 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
4400 /// backs the property is not used in the property's accessor.
4401 void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
4402 const ObjCImplementationDecl *ImplD);
4403
4404 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
4405 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
4406 /// It also returns ivar's property on success.
4407 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
4408 const ObjCPropertyDecl *&PDecl) const;
4409
4410 /// Called by ActOnProperty to handle \@property declarations in
4411 /// class extensions.
4412 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,
4413 SourceLocation AtLoc,
4414 SourceLocation LParenLoc,
4415 FieldDeclarator &FD,
4416 Selector GetterSel,
4417 SourceLocation GetterNameLoc,
4418 Selector SetterSel,
4419 SourceLocation SetterNameLoc,
4420 const bool isReadWrite,
4421 unsigned &Attributes,
4422 const unsigned AttributesAsWritten,
4423 QualType T,
4424 TypeSourceInfo *TSI,
4425 tok::ObjCKeywordKind MethodImplKind);
4426
4427 /// Called by ActOnProperty and HandlePropertyInClassExtension to
4428 /// handle creating the ObjcPropertyDecl for a category or \@interface.
4429 ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
4430 ObjCContainerDecl *CDecl,
4431 SourceLocation AtLoc,
4432 SourceLocation LParenLoc,
4433 FieldDeclarator &FD,
4434 Selector GetterSel,
4435 SourceLocation GetterNameLoc,
4436 Selector SetterSel,
4437 SourceLocation SetterNameLoc,
4438 const bool isReadWrite,
4439 const unsigned Attributes,
4440 const unsigned AttributesAsWritten,
4441 QualType T,
4442 TypeSourceInfo *TSI,
4443 tok::ObjCKeywordKind MethodImplKind,
4444 DeclContext *lexicalDC = nullptr);
4445
4446 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
4447 /// warning) when atomic property has one but not the other user-declared
4448 /// setter or getter.
4449 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
4450 ObjCInterfaceDecl* IDecl);
4451
4452 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
4453
4454 void DiagnoseMissingDesignatedInitOverrides(
4455 const ObjCImplementationDecl *ImplD,
4456 const ObjCInterfaceDecl *IFD);
4457
4458 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
4459
4460 enum MethodMatchStrategy {
4461 MMS_loose,
4462 MMS_strict
4463 };
4464
4465 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
4466 /// true, or false, accordingly.
4467 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
4468 const ObjCMethodDecl *PrevMethod,
4469 MethodMatchStrategy strategy = MMS_strict);
4470
4471 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
4472 /// or protocol against those declared in their implementations.
4473 void MatchAllMethodDeclarations(const SelectorSet &InsMap,
4474 const SelectorSet &ClsMap,
4475 SelectorSet &InsMapSeen,
4476 SelectorSet &ClsMapSeen,
4477 ObjCImplDecl* IMPDecl,
4478 ObjCContainerDecl* IDecl,
4479 bool &IncompleteImpl,
4480 bool ImmediateClass,
4481 bool WarnCategoryMethodImpl=false);
4482
4483 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
4484 /// category matches with those implemented in its primary class and
4485 /// warns each time an exact match is found.
4486 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
4487
4488 /// Add the given method to the list of globally-known methods.
4489 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
4490
4491 /// Returns default addr space for method qualifiers.
4492 LangAS getDefaultCXXMethodAddrSpace() const;
4493
4494private:
4495 /// AddMethodToGlobalPool - Add an instance or factory method to the global
4496 /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
4497 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
4498
4499 /// LookupMethodInGlobalPool - Returns the instance or factory method and
4500 /// optionally warns if there are multiple signatures.
4501 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
4502 bool receiverIdOrClass,
4503 bool instance);
4504
4505public:
4506 /// - Returns instance or factory methods in global method pool for
4507 /// given selector. It checks the desired kind first, if none is found, and
4508 /// parameter checkTheOther is set, it then checks the other kind. If no such
4509 /// method or only one method is found, function returns false; otherwise, it
4510 /// returns true.
4511 bool
4512 CollectMultipleMethodsInGlobalPool(Selector Sel,
4513 SmallVectorImpl<ObjCMethodDecl*>& Methods,
4514 bool InstanceFirst, bool CheckTheOther,
4515 const ObjCObjectType *TypeBound = nullptr);
4516
4517 bool
4518 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
4519 SourceRange R, bool receiverIdOrClass,
4520 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4521
4522 void
4523 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
4524 Selector Sel, SourceRange R,
4525 bool receiverIdOrClass);
4526
4527private:
4528 /// - Returns a selector which best matches given argument list or
4529 /// nullptr if none could be found
4530 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
4531 bool IsInstance,
4532 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4533
4534
4535 /// Record the typo correction failure and return an empty correction.
4536 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
4537 bool RecordFailure = true) {
4538 if (RecordFailure)
4539 TypoCorrectionFailures[Typo].insert(TypoLoc);
4540 return TypoCorrection();
4541 }
4542
4543public:
4544 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
4545 /// unit are added to a global pool. This allows us to efficiently associate
4546 /// a selector with a method declaraation for purposes of typechecking
4547 /// messages sent to "id" (where the class of the object is unknown).
4548 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4549 AddMethodToGlobalPool(Method, impl, /*instance*/true);
4550 }
4551
4552 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
4553 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4554 AddMethodToGlobalPool(Method, impl, /*instance*/false);
4555 }
4556
4557 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
4558 /// pool.
4559 void AddAnyMethodToGlobalPool(Decl *D);
4560
4561 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
4562 /// there are multiple signatures.
4563 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
4564 bool receiverIdOrClass=false) {
4565 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4566 /*instance*/true);
4567 }
4568
4569 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
4570 /// there are multiple signatures.
4571 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
4572 bool receiverIdOrClass=false) {
4573 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4574 /*instance*/false);
4575 }
4576
4577 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
4578 QualType ObjectType=QualType());
4579 /// LookupImplementedMethodInGlobalPool - Returns the method which has an
4580 /// implementation.
4581 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
4582
4583 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4584 /// initialization.
4585 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
4586 SmallVectorImpl<ObjCIvarDecl*> &Ivars);
4587
4588 //===--------------------------------------------------------------------===//
4589 // Statement Parsing Callbacks: SemaStmt.cpp.
4590public:
4591 class FullExprArg {
4592 public:
4593 FullExprArg() : E(nullptr) { }
4594 FullExprArg(Sema &actions) : E(nullptr) { }
4595
4596 ExprResult release() {
4597 return E;
4598 }
4599
4600 Expr *get() const { return E; }
4601
4602 Expr *operator->() {
4603 return E;
4604 }
4605
4606 private:
4607 // FIXME: No need to make the entire Sema class a friend when it's just
4608 // Sema::MakeFullExpr that needs access to the constructor below.
4609 friend class Sema;
4610
4611 explicit FullExprArg(Expr *expr) : E(expr) {}
4612
4613 Expr *E;
4614 };
4615
4616 FullExprArg MakeFullExpr(Expr *Arg) {
4617 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
4618 }
4619 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
4620 return FullExprArg(
4621 ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get());
4622 }
4623 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
4624 ExprResult FE =
4625 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),
4626 /*DiscardedValue*/ true);
4627 return FullExprArg(FE.get());
4628 }
4629
4630 StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);
4631 StmtResult ActOnExprStmtError();
4632
4633 StmtResult ActOnNullStmt(SourceLocation SemiLoc,
4634 bool HasLeadingEmptyMacro = false);
4635
4636 void ActOnStartOfCompoundStmt(bool IsStmtExpr);
4637 void ActOnAfterCompoundStatementLeadingPragmas();
4638 void ActOnFinishOfCompoundStmt();
4639 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
4640 ArrayRef<Stmt *> Elts, bool isStmtExpr);
4641
4642 /// A RAII object to enter scope of a compound statement.
4643 class CompoundScopeRAII {
4644 public:
4645 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {
4646 S.ActOnStartOfCompoundStmt(IsStmtExpr);
4647 }
4648
4649 ~CompoundScopeRAII() {
4650 S.ActOnFinishOfCompoundStmt();
4651 }
4652
4653 private:
4654 Sema &S;
4655 };
4656
4657 /// An RAII helper that pops function a function scope on exit.
4658 struct FunctionScopeRAII {
4659 Sema &S;
4660 bool Active;
4661 FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
4662 ~FunctionScopeRAII() {
4663 if (Active)
4664 S.PopFunctionScopeInfo();
4665 }
4666 void disable() { Active = false; }
4667 };
4668
4669 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
4670 SourceLocation StartLoc,
4671 SourceLocation EndLoc);
4672 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
4673 StmtResult ActOnForEachLValueExpr(Expr *E);
4674 ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);
4675 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,
4676 SourceLocation DotDotDotLoc, ExprResult RHS,
4677 SourceLocation ColonLoc);
4678 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
4679
4680 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
4681 SourceLocation ColonLoc,
4682 Stmt *SubStmt, Scope *CurScope);
4683 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
4684 SourceLocation ColonLoc, Stmt *SubStmt);
4685
4686 StmtResult BuildAttributedStmt(SourceLocation AttrsLoc,
4687 ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
4688 StmtResult ActOnAttributedStmt(const ParsedAttributesWithRange &AttrList,
4689 Stmt *SubStmt);
4690
4691 class ConditionResult;
4692 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4693 SourceLocation LParenLoc, Stmt *InitStmt,
4694 ConditionResult Cond, SourceLocation RParenLoc,
4695 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4696 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4697 SourceLocation LParenLoc, Stmt *InitStmt,
4698 ConditionResult Cond, SourceLocation RParenLoc,
4699 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4700 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
4701 SourceLocation LParenLoc, Stmt *InitStmt,
4702 ConditionResult Cond,
4703 SourceLocation RParenLoc);
4704 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
4705 Stmt *Switch, Stmt *Body);
4706 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
4707 ConditionResult Cond, SourceLocation RParenLoc,
4708 Stmt *Body);
4709 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
4710 SourceLocation WhileLoc, SourceLocation CondLParen,
4711 Expr *Cond, SourceLocation CondRParen);
4712
4713 StmtResult ActOnForStmt(SourceLocation ForLoc,
4714 SourceLocation LParenLoc,
4715 Stmt *First,
4716 ConditionResult Second,
4717 FullExprArg Third,
4718 SourceLocation RParenLoc,
4719 Stmt *Body);
4720 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
4721 Expr *collection);
4722 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
4723 Stmt *First, Expr *collection,
4724 SourceLocation RParenLoc);
4725 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
4726
4727 enum BuildForRangeKind {
4728 /// Initial building of a for-range statement.
4729 BFRK_Build,
4730 /// Instantiation or recovery rebuild of a for-range statement. Don't
4731 /// attempt any typo-correction.
4732 BFRK_Rebuild,
4733 /// Determining whether a for-range statement could be built. Avoid any
4734 /// unnecessary or irreversible actions.
4735 BFRK_Check
4736 };
4737
4738 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
4739 SourceLocation CoawaitLoc,
4740 Stmt *InitStmt,
4741 Stmt *LoopVar,
4742 SourceLocation ColonLoc, Expr *Collection,
4743 SourceLocation RParenLoc,
4744 BuildForRangeKind Kind);
4745 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
4746 SourceLocation CoawaitLoc,
4747 Stmt *InitStmt,
4748 SourceLocation ColonLoc,
4749 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4750 Expr *Cond, Expr *Inc,
4751 Stmt *LoopVarDecl,
4752 SourceLocation RParenLoc,
4753 BuildForRangeKind Kind);
4754 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
4755
4756 StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
4757 SourceLocation LabelLoc,
4758 LabelDecl *TheDecl);
4759 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
4760 SourceLocation StarLoc,
4761 Expr *DestExp);
4762 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
4763 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
4764
4765 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4766 CapturedRegionKind Kind, unsigned NumParams);
4767 typedef std::pair<StringRef, QualType> CapturedParamNameType;
4768 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4769 CapturedRegionKind Kind,
4770 ArrayRef<CapturedParamNameType> Params,
4771 unsigned OpenMPCaptureLevel = 0);
4772 StmtResult ActOnCapturedRegionEnd(Stmt *S);
4773 void ActOnCapturedRegionError();
4774 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
4775 SourceLocation Loc,
4776 unsigned NumParams);
4777
4778 struct NamedReturnInfo {
4779 const VarDecl *Candidate;
4780
4781 enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable };
4782 Status S;
4783
4784 bool isMoveEligible() const { return S != None; };
4785 bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
4786 };
4787 enum class SimplerImplicitMoveMode { ForceOff, Normal, ForceOn };
4788 NamedReturnInfo getNamedReturnInfo(
4789 Expr *&E, SimplerImplicitMoveMode Mode = SimplerImplicitMoveMode::Normal);
4790 NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
4791 const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
4792 QualType ReturnType);
4793
4794 ExprResult
4795 PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
4796 const NamedReturnInfo &NRInfo, Expr *Value,
4797 bool SupressSimplerImplicitMoves = false);
4798
4799 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4800 Scope *CurScope);
4801 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4802 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4803 NamedReturnInfo &NRInfo,
4804 bool SupressSimplerImplicitMoves);
4805
4806 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
4807 bool IsVolatile, unsigned NumOutputs,
4808 unsigned NumInputs, IdentifierInfo **Names,
4809 MultiExprArg Constraints, MultiExprArg Exprs,
4810 Expr *AsmString, MultiExprArg Clobbers,
4811 unsigned NumLabels,
4812 SourceLocation RParenLoc);
4813
4814 void FillInlineAsmIdentifierInfo(Expr *Res,
4815 llvm::InlineAsmIdentifierInfo &Info);
4816 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
4817 SourceLocation TemplateKWLoc,
4818 UnqualifiedId &Id,
4819 bool IsUnevaluatedContext);
4820 bool LookupInlineAsmField(StringRef Base, StringRef Member,
4821 unsigned &Offset, SourceLocation AsmLoc);
4822 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
4823 SourceLocation AsmLoc);
4824 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
4825 ArrayRef<Token> AsmToks,
4826 StringRef AsmString,
4827 unsigned NumOutputs, unsigned NumInputs,
4828 ArrayRef<StringRef> Constraints,
4829 ArrayRef<StringRef> Clobbers,
4830 ArrayRef<Expr*> Exprs,
4831 SourceLocation EndLoc);
4832 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
4833 SourceLocation Location,
4834 bool AlwaysCreate);
4835
4836 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
4837 SourceLocation StartLoc,
4838 SourceLocation IdLoc, IdentifierInfo *Id,
4839 bool Invalid = false);
4840
4841 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
4842
4843 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
4844 Decl *Parm, Stmt *Body);
4845
4846 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
4847
4848 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
4849 MultiStmtArg Catch, Stmt *Finally);
4850
4851 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
4852 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
4853 Scope *CurScope);
4854 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
4855 Expr *operand);
4856 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
4857 Expr *SynchExpr,
4858 Stmt *SynchBody);
4859
4860 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
4861
4862 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
4863 SourceLocation StartLoc,
4864 SourceLocation IdLoc,
4865 IdentifierInfo *Id);
4866
4867 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
4868
4869 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
4870 Decl *ExDecl, Stmt *HandlerBlock);
4871 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4872 ArrayRef<Stmt *> Handlers);
4873
4874 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
4875 SourceLocation TryLoc, Stmt *TryBlock,
4876 Stmt *Handler);
4877 StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
4878 Expr *FilterExpr,
4879 Stmt *Block);
4880 void ActOnStartSEHFinallyBlock();
4881 void ActOnAbortSEHFinallyBlock();
4882 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
4883 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
4884
4885 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
4886
4887 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
4888
4889 /// If it's a file scoped decl that must warn if not used, keep track
4890 /// of it.
4891 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
4892
4893 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
4894 /// whose result is unused, warn.
4895 void DiagnoseUnusedExprResult(const Stmt *S);
4896 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
4897 void DiagnoseUnusedDecl(const NamedDecl *ND);
4898
4899 /// If VD is set but not otherwise used, diagnose, for a parameter or a
4900 /// variable.
4901 void DiagnoseUnusedButSetDecl(const VarDecl *VD);
4902
4903 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
4904 /// statement as a \p Body, and it is located on the same line.
4905 ///
4906 /// This helps prevent bugs due to typos, such as:
4907 /// if (condition);
4908 /// do_stuff();
4909 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
4910 const Stmt *Body,
4911 unsigned DiagID);
4912
4913 /// Warn if a for/while loop statement \p S, which is followed by
4914 /// \p PossibleBody, has a suspicious null statement as a body.
4915 void DiagnoseEmptyLoopBody(const Stmt *S,
4916 const Stmt *PossibleBody);
4917
4918 /// Warn if a value is moved to itself.
4919 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
4920 SourceLocation OpLoc);
4921
4922 /// Warn if we're implicitly casting from a _Nullable pointer type to a
4923 /// _Nonnull one.
4924 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
4925 SourceLocation Loc);
4926
4927 /// Warn when implicitly casting 0 to nullptr.
4928 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
4929
4930 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
4931 return DelayedDiagnostics.push(pool);
4932 }
4933 void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
4934
4935 typedef ProcessingContextState ParsingClassState;
4936 ParsingClassState PushParsingClass() {
4937 ParsingClassDepth++;
4938 return DelayedDiagnostics.pushUndelayed();
4939 }
4940 void PopParsingClass(ParsingClassState state) {
4941 ParsingClassDepth--;
4942 DelayedDiagnostics.popUndelayed(state);
4943 }
4944
4945 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
4946
4947 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4948 const ObjCInterfaceDecl *UnknownObjCClass,
4949 bool ObjCPropertyAccess,
4950 bool AvoidPartialAvailabilityChecks = false,
4951 ObjCInterfaceDecl *ClassReceiver = nullptr);
4952
4953 bool makeUnavailableInSystemHeader(SourceLocation loc,
4954 UnavailableAttr::ImplicitReason reason);
4955
4956 /// Issue any -Wunguarded-availability warnings in \c FD
4957 void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
4958
4959 void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
4960
4961 //===--------------------------------------------------------------------===//
4962 // Expression Parsing Callbacks: SemaExpr.cpp.
4963
4964 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
4965 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4966 const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
4967 bool ObjCPropertyAccess = false,
4968 bool AvoidPartialAvailabilityChecks = false,
4969 ObjCInterfaceDecl *ClassReciever = nullptr);
4970 void NoteDeletedFunction(FunctionDecl *FD);
4971 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
4972 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
4973 ObjCMethodDecl *Getter,
4974 SourceLocation Loc);
4975 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
4976 ArrayRef<Expr *> Args);
4977
4978 void PushExpressionEvaluationContext(
4979 ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,
4980 ExpressionEvaluationContextRecord::ExpressionKind Type =
4981 ExpressionEvaluationContextRecord::EK_Other);
4982 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
4983 void PushExpressionEvaluationContext(
4984 ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
4985 ExpressionEvaluationContextRecord::ExpressionKind Type =
4986 ExpressionEvaluationContextRecord::EK_Other);
4987 void PopExpressionEvaluationContext();
4988
4989 void DiscardCleanupsInEvaluationContext();
4990
4991 ExprResult TransformToPotentiallyEvaluated(Expr *E);
4992 ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
4993
4994 ExprResult CheckUnevaluatedOperand(Expr *E);
4995 void CheckUnusedVolatileAssignment(Expr *E);
4996
4997 ExprResult ActOnConstantExpression(ExprResult Res);
4998
4999 // Functions for marking a declaration referenced. These functions also
5000 // contain the relevant logic for marking if a reference to a function or
5001 // variable is an odr-use (in the C++11 sense). There are separate variants
5002 // for expressions referring to a decl; these exist because odr-use marking
5003 // needs to be delayed for some constant variables when we build one of the
5004 // named expressions.
5005 //
5006 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
5007 // should usually be true. This only needs to be set to false if the lack of
5008 // odr-use cannot be determined from the current context (for instance,
5009 // because the name denotes a virtual function and was written without an
5010 // explicit nested-name-specifier).
5011 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
5012 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
5013 bool MightBeOdrUse = true);
5014 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
5015 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
5016 void MarkMemberReferenced(MemberExpr *E);
5017 void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);
5018 void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,
5019 unsigned CapturingScopeIndex);
5020
5021 ExprResult CheckLValueToRValueConversionOperand(Expr *E);
5022 void CleanupVarDeclMarking();
5023
5024 enum TryCaptureKind {
5025 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
5026 };
5027
5028 /// Try to capture the given variable.
5029 ///
5030 /// \param Var The variable to capture.
5031 ///
5032 /// \param Loc The location at which the capture occurs.
5033 ///
5034 /// \param Kind The kind of capture, which may be implicit (for either a
5035 /// block or a lambda), or explicit by-value or by-reference (for a lambda).
5036 ///
5037 /// \param EllipsisLoc The location of the ellipsis, if one is provided in
5038 /// an explicit lambda capture.
5039 ///
5040 /// \param BuildAndDiagnose Whether we are actually supposed to add the
5041 /// captures or diagnose errors. If false, this routine merely check whether
5042 /// the capture can occur without performing the capture itself or complaining
5043 /// if the variable cannot be captured.
5044 ///
5045 /// \param CaptureType Will be set to the type of the field used to capture
5046 /// this variable in the innermost block or lambda. Only valid when the
5047 /// variable can be captured.
5048 ///
5049 /// \param DeclRefType Will be set to the type of a reference to the capture
5050 /// from within the current scope. Only valid when the variable can be
5051 /// captured.
5052 ///
5053 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
5054 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
5055 /// This is useful when enclosing lambdas must speculatively capture
5056 /// variables that may or may not be used in certain specializations of
5057 /// a nested generic lambda.
5058 ///
5059 /// \returns true if an error occurred (i.e., the variable cannot be
5060 /// captured) and false if the capture succeeded.
5061 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
5062 SourceLocation EllipsisLoc, bool BuildAndDiagnose,
5063 QualType &CaptureType,
5064 QualType &DeclRefType,
5065 const unsigned *const FunctionScopeIndexToStopAt);
5066
5067 /// Try to capture the given variable.
5068 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
5069 TryCaptureKind Kind = TryCapture_Implicit,
5070 SourceLocation EllipsisLoc = SourceLocation());
5071
5072 /// Checks if the variable must be captured.
5073 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
5074
5075 /// Given a variable, determine the type that a reference to that
5076 /// variable will have in the given scope.
5077 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
5078
5079 /// Mark all of the declarations referenced within a particular AST node as
5080 /// referenced. Used when template instantiation instantiates a non-dependent
5081 /// type -- entities referenced by the type are now referenced.
5082 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
5083 void MarkDeclarationsReferencedInExpr(Expr *E,
5084 bool SkipLocalVariables = false);
5085
5086 /// Try to recover by turning the given expression into a
5087 /// call. Returns true if recovery was attempted or an error was
5088 /// emitted; this may also leave the ExprResult invalid.
5089 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
5090 bool ForceComplain = false,
5091 bool (*IsPlausibleResult)(QualType) = nullptr);
5092
5093 /// Figure out if an expression could be turned into a call.
5094 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
5095 UnresolvedSetImpl &NonTemplateOverloads);
5096
5097 /// Try to convert an expression \p E to type \p Ty. Returns the result of the
5098 /// conversion.
5099 ExprResult tryConvertExprToType(Expr *E, QualType Ty);
5100
5101 /// Conditionally issue a diagnostic based on the current
5102 /// evaluation context.
5103 ///
5104 /// \param Statement If Statement is non-null, delay reporting the
5105 /// diagnostic until the function body is parsed, and then do a basic
5106 /// reachability analysis to determine if the statement is reachable.
5107 /// If it is unreachable, the diagnostic will not be emitted.
5108 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
5109 const PartialDiagnostic &PD);
5110 /// Similar, but diagnostic is only produced if all the specified statements
5111 /// are reachable.
5112 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
5113 const PartialDiagnostic &PD);
5114
5115 // Primary Expressions.
5116 SourceRange getExprRange(Expr *E) const;
5117
5118 ExprResult ActOnIdExpression(
5119 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5120 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
5121 CorrectionCandidateCallback *CCC = nullptr,
5122 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
5123
5124 void DecomposeUnqualifiedId(const UnqualifiedId &Id,
5125 TemplateArgumentListInfo &Buffer,
5126 DeclarationNameInfo &NameInfo,
5127 const TemplateArgumentListInfo *&TemplateArgs);
5128
5129 bool DiagnoseDependentMemberLookup(LookupResult &R);
5130
5131 bool
5132 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
5133 CorrectionCandidateCallback &CCC,
5134 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
5135 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
5136
5137 DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,
5138 IdentifierInfo *II);
5139 ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV);
5140
5141 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
5142 IdentifierInfo *II,
5143 bool AllowBuiltinCreation=false);
5144
5145 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
5146 SourceLocation TemplateKWLoc,
5147 const DeclarationNameInfo &NameInfo,
5148 bool isAddressOfOperand,
5149 const TemplateArgumentListInfo *TemplateArgs);
5150
5151 /// If \p D cannot be odr-used in the current expression evaluation context,
5152 /// return a reason explaining why. Otherwise, return NOUR_None.
5153 NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);
5154
5155 DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5156 SourceLocation Loc,
5157 const CXXScopeSpec *SS = nullptr);
5158 DeclRefExpr *
5159 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5160 const DeclarationNameInfo &NameInfo,
5161 const CXXScopeSpec *SS = nullptr,
5162 NamedDecl *FoundD = nullptr,
5163 SourceLocation TemplateKWLoc = SourceLocation(),
5164 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5165 DeclRefExpr *
5166 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5167 const DeclarationNameInfo &NameInfo,
5168 NestedNameSpecifierLoc NNS,
5169 NamedDecl *FoundD = nullptr,
5170 SourceLocation TemplateKWLoc = SourceLocation(),
5171 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5172
5173 ExprResult
5174 BuildAnonymousStructUnionMemberReference(
5175 const CXXScopeSpec &SS,
5176 SourceLocation nameLoc,
5177 IndirectFieldDecl *indirectField,
5178 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
5179 Expr *baseObjectExpr = nullptr,
5180 SourceLocation opLoc = SourceLocation());
5181
5182 ExprResult BuildPossibleImplicitMemberExpr(
5183 const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
5184 const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
5185 UnresolvedLookupExpr *AsULE = nullptr);
5186 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
5187 SourceLocation TemplateKWLoc,
5188 LookupResult &R,
5189 const TemplateArgumentListInfo *TemplateArgs,
5190 bool IsDefiniteInstance,
5191 const Scope *S);
5192 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
5193 const LookupResult &R,
5194 bool HasTrailingLParen);
5195
5196 ExprResult
5197 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
5198 const DeclarationNameInfo &NameInfo,
5199 bool IsAddressOfOperand, const Scope *S,
5200 TypeSourceInfo **RecoveryTSI = nullptr);
5201
5202 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
5203 SourceLocation TemplateKWLoc,
5204 const DeclarationNameInfo &NameInfo,
5205 const TemplateArgumentListInfo *TemplateArgs);
5206
5207 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
5208 LookupResult &R,
5209 bool NeedsADL,
5210 bool AcceptInvalidDecl = false);
5211 ExprResult BuildDeclarationNameExpr(
5212 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
5213 NamedDecl *FoundD = nullptr,
5214 const TemplateArgumentListInfo *TemplateArgs = nullptr,
5215 bool AcceptInvalidDecl = false);
5216
5217 ExprResult BuildLiteralOperatorCall(LookupResult &R,
5218 DeclarationNameInfo &SuffixInfo,
5219 ArrayRef<Expr *> Args,
5220 SourceLocation LitEndLoc,
5221 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
5222
5223 ExprResult BuildPredefinedExpr(SourceLocation Loc,
5224 PredefinedExpr::IdentKind IK);
5225 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
5226 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
5227
5228 ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5229 SourceLocation LParen,
5230 SourceLocation RParen,
5231 TypeSourceInfo *TSI);
5232 ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5233 SourceLocation LParen,
5234 SourceLocation RParen,
5235 ParsedType ParsedTy);
5236
5237 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
5238
5239 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
5240 ExprResult ActOnCharacterConstant(const Token &Tok,
5241 Scope *UDLScope = nullptr);
5242 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
5243 ExprResult ActOnParenListExpr(SourceLocation L,
5244 SourceLocation R,
5245 MultiExprArg Val);
5246
5247 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
5248 /// fragments (e.g. "foo" "bar" L"baz").
5249 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
5250 Scope *UDLScope = nullptr);
5251
5252 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
5253 SourceLocation DefaultLoc,
5254 SourceLocation RParenLoc,
5255 Expr *ControllingExpr,
5256 ArrayRef<ParsedType> ArgTypes,
5257 ArrayRef<Expr *> ArgExprs);
5258 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
5259 SourceLocation DefaultLoc,
5260 SourceLocation RParenLoc,
5261 Expr *ControllingExpr,
5262 ArrayRef<TypeSourceInfo *> Types,
5263 ArrayRef<Expr *> Exprs);
5264
5265 // Binary/Unary Operators. 'Tok' is the token for the operator.
5266 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
5267 Expr *InputExpr);
5268 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
5269 UnaryOperatorKind Opc, Expr *Input);
5270 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5271 tok::TokenKind Op, Expr *Input);
5272
5273 bool isQualifiedMemberAccess(Expr *E);
5274 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
5275
5276 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
5277 SourceLocation OpLoc,
5278 UnaryExprOrTypeTrait ExprKind,
5279 SourceRange R);
5280 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
5281 UnaryExprOrTypeTrait ExprKind);
5282 ExprResult
5283 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
5284 UnaryExprOrTypeTrait ExprKind,
5285 bool IsType, void *TyOrEx,
5286 SourceRange ArgRange);
5287
5288 ExprResult CheckPlaceholderExpr(Expr *E);
5289 bool CheckVecStepExpr(Expr *E);
5290
5291 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
5292 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
5293 SourceRange ExprRange,
5294 UnaryExprOrTypeTrait ExprKind);
5295 ExprResult ActOnSizeofParameterPackExpr(Scope *S,
5296 SourceLocation OpLoc,
5297 IdentifierInfo &Name,
5298 SourceLocation NameLoc,
5299 SourceLocation RParenLoc);
5300 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
5301 tok::TokenKind Kind, Expr *Input);
5302
5303 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
5304 Expr *Idx, SourceLocation RLoc);
5305 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
5306 Expr *Idx, SourceLocation RLoc);
5307
5308 ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
5309 Expr *ColumnIdx,
5310 SourceLocation RBLoc);
5311
5312 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
5313 Expr *LowerBound,
5314 SourceLocation ColonLocFirst,
5315 SourceLocation ColonLocSecond,
5316 Expr *Length, Expr *Stride,
5317 SourceLocation RBLoc);
5318 ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
5319 SourceLocation RParenLoc,
5320 ArrayRef<Expr *> Dims,
5321 ArrayRef<SourceRange> Brackets);
5322
5323 /// Data structure for iterator expression.
5324 struct OMPIteratorData {
5325 IdentifierInfo *DeclIdent = nullptr;
5326 SourceLocation DeclIdentLoc;
5327 ParsedType Type;
5328 OMPIteratorExpr::IteratorRange Range;
5329 SourceLocation AssignLoc;
5330 SourceLocation ColonLoc;
5331 SourceLocation SecColonLoc;
5332 };
5333
5334 ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
5335 SourceLocation LLoc, SourceLocation RLoc,
5336 ArrayRef<OMPIteratorData> Data);
5337
5338 // This struct is for use by ActOnMemberAccess to allow
5339 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
5340 // changing the access operator from a '.' to a '->' (to see if that is the
5341 // change needed to fix an error about an unknown member, e.g. when the class
5342 // defines a custom operator->).
5343 struct ActOnMemberAccessExtraArgs {
5344 Scope *S;
5345 UnqualifiedId &Id;
5346 Decl *ObjCImpDecl;
5347 };
5348
5349 ExprResult BuildMemberReferenceExpr(
5350 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
5351 CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5352 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,
5353 const TemplateArgumentListInfo *TemplateArgs,
5354 const Scope *S,
5355 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5356
5357 ExprResult
5358 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
5359 bool IsArrow, const CXXScopeSpec &SS,
5360 SourceLocation TemplateKWLoc,
5361 NamedDecl *FirstQualifierInScope, LookupResult &R,
5362 const TemplateArgumentListInfo *TemplateArgs,
5363 const Scope *S,
5364 bool SuppressQualifierCheck = false,
5365 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5366
5367 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
5368 SourceLocation OpLoc,
5369 const CXXScopeSpec &SS, FieldDecl *Field,
5370 DeclAccessPair FoundDecl,
5371 const DeclarationNameInfo &MemberNameInfo);
5372
5373 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
5374
5375 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
5376 const CXXScopeSpec &SS,
5377 const LookupResult &R);
5378
5379 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
5380 bool IsArrow, SourceLocation OpLoc,
5381 const CXXScopeSpec &SS,
5382 SourceLocation TemplateKWLoc,
5383 NamedDecl *FirstQualifierInScope,
5384 const DeclarationNameInfo &NameInfo,
5385 const TemplateArgumentListInfo *TemplateArgs);
5386
5387 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
5388 SourceLocation OpLoc,
5389 tok::TokenKind OpKind,
5390 CXXScopeSpec &SS,
5391 SourceLocation TemplateKWLoc,
5392 UnqualifiedId &Member,
5393 Decl *ObjCImpDecl);
5394
5395 MemberExpr *
5396 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5397 const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,
5398 ValueDecl *Member, DeclAccessPair FoundDecl,
5399 bool HadMultipleCandidates,
5400 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5401 ExprValueKind VK, ExprObjectKind OK,
5402 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5403 MemberExpr *
5404 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5405 NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
5406 ValueDecl *Member, DeclAccessPair FoundDecl,
5407 bool HadMultipleCandidates,
5408 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5409 ExprValueKind VK, ExprObjectKind OK,
5410 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5411
5412 void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
5413 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
5414 FunctionDecl *FDecl,
5415 const FunctionProtoType *Proto,
5416 ArrayRef<Expr *> Args,
5417 SourceLocation RParenLoc,
5418 bool ExecConfig = false);
5419 void CheckStaticArrayArgument(SourceLocation CallLoc,
5420 ParmVarDecl *Param,
5421 const Expr *ArgExpr);
5422
5423 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
5424 /// This provides the location of the left/right parens and a list of comma
5425 /// locations.
5426 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5427 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5428 Expr *ExecConfig = nullptr);
5429 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5430 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5431 Expr *ExecConfig = nullptr,
5432 bool IsExecConfig = false,
5433 bool AllowRecovery = false);
5434 Expr *BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
5435 MultiExprArg CallArgs);
5436 enum class AtomicArgumentOrder { API, AST };
5437 ExprResult
5438 BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
5439 SourceLocation RParenLoc, MultiExprArg Args,
5440 AtomicExpr::AtomicOp Op,
5441 AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
5442 ExprResult
5443 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
5444 ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
5445 Expr *Config = nullptr, bool IsExecConfig = false,
5446 ADLCallKind UsesADL = ADLCallKind::NotADL);
5447
5448 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
5449 MultiExprArg ExecConfig,
5450 SourceLocation GGGLoc);
5451
5452 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
5453 Declarator &D, ParsedType &Ty,
5454 SourceLocation RParenLoc, Expr *CastExpr);
5455 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
5456 TypeSourceInfo *Ty,
5457 SourceLocation RParenLoc,
5458 Expr *Op);
5459 CastKind PrepareScalarCast(ExprResult &src, QualType destType);
5460
5461 /// Build an altivec or OpenCL literal.
5462 ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
5463 SourceLocation RParenLoc, Expr *E,
5464 TypeSourceInfo *TInfo);
5465
5466 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
5467
5468 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
5469 ParsedType Ty,
5470 SourceLocation RParenLoc,
5471 Expr *InitExpr);
5472
5473 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
5474 TypeSourceInfo *TInfo,
5475 SourceLocation RParenLoc,
5476 Expr *LiteralExpr);
5477
5478 ExprResult ActOnInitList(SourceLocation LBraceLoc,
5479 MultiExprArg InitArgList,
5480 SourceLocation RBraceLoc);
5481
5482 ExprResult BuildInitList(SourceLocation LBraceLoc,
5483 MultiExprArg InitArgList,
5484 SourceLocation RBraceLoc);
5485
5486 ExprResult ActOnDesignatedInitializer(Designation &Desig,
5487 SourceLocation EqualOrColonLoc,
5488 bool GNUSyntax,
5489 ExprResult Init);
5490
5491private:
5492 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
5493
5494public:
5495 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
5496 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
5497 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
5498 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
5499 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
5500 Expr *LHSExpr, Expr *RHSExpr);
5501 void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
5502 UnresolvedSetImpl &Functions);
5503
5504 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
5505
5506 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
5507 /// in the case of a the GNU conditional expr extension.
5508 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
5509 SourceLocation ColonLoc,
5510 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
5511
5512 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
5513 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
5514 LabelDecl *TheDecl);
5515
5516 void ActOnStartStmtExpr();
5517 ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
5518 SourceLocation RPLoc);
5519 ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
5520 SourceLocation RPLoc, unsigned TemplateDepth);
5521 // Handle the final expression in a statement expression.
5522 ExprResult ActOnStmtExprResult(ExprResult E);
5523 void ActOnStmtExprError();
5524
5525 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
5526 struct OffsetOfComponent {
5527 SourceLocation LocStart, LocEnd;
5528 bool isBrackets; // true if [expr], false if .ident
5529 union {
5530 IdentifierInfo *IdentInfo;
5531 Expr *E;
5532 } U;
5533 };
5534
5535 /// __builtin_offsetof(type, a.b[123][456].c)
5536 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
5537 TypeSourceInfo *TInfo,
5538 ArrayRef<OffsetOfComponent> Components,
5539 SourceLocation RParenLoc);
5540 ExprResult ActOnBuiltinOffsetOf(Scope *S,
5541 SourceLocation BuiltinLoc,
5542 SourceLocation TypeLoc,
5543 ParsedType ParsedArgTy,
5544 ArrayRef<OffsetOfComponent> Components,
5545 SourceLocation RParenLoc);
5546
5547 // __builtin_choose_expr(constExpr, expr1, expr2)
5548 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
5549 Expr *CondExpr, Expr *LHSExpr,
5550 Expr *RHSExpr, SourceLocation RPLoc);
5551
5552 // __builtin_va_arg(expr, type)
5553 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
5554 SourceLocation RPLoc);
5555 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
5556 TypeSourceInfo *TInfo, SourceLocation RPLoc);
5557
5558 // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
5559 // __builtin_COLUMN()
5560 ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
5561 SourceLocation BuiltinLoc,
5562 SourceLocation RPLoc);
5563
5564 // Build a potentially resolved SourceLocExpr.
5565 ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
5566 SourceLocation BuiltinLoc, SourceLocation RPLoc,
5567 DeclContext *ParentContext);
5568
5569 // __null
5570 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
5571
5572 bool CheckCaseExpression(Expr *E);
5573
5574 /// Describes the result of an "if-exists" condition check.
5575 enum IfExistsResult {
5576 /// The symbol exists.
5577 IER_Exists,
5578
5579 /// The symbol does not exist.
5580 IER_DoesNotExist,
5581
5582 /// The name is a dependent name, so the results will differ
5583 /// from one instantiation to the next.
5584 IER_Dependent,
5585
5586 /// An error occurred.
5587 IER_Error
5588 };
5589
5590 IfExistsResult
5591 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
5592 const DeclarationNameInfo &TargetNameInfo);
5593
5594 IfExistsResult
5595 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
5596 bool IsIfExists, CXXScopeSpec &SS,
5597 UnqualifiedId &Name);
5598
5599 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
5600 bool IsIfExists,
5601 NestedNameSpecifierLoc QualifierLoc,
5602 DeclarationNameInfo NameInfo,
5603 Stmt *Nested);
5604 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
5605 bool IsIfExists,
5606 CXXScopeSpec &SS, UnqualifiedId &Name,
5607 Stmt *Nested);
5608
5609 //===------------------------- "Block" Extension ------------------------===//
5610
5611 /// ActOnBlockStart - This callback is invoked when a block literal is
5612 /// started.
5613 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
5614
5615 /// ActOnBlockArguments - This callback allows processing of block arguments.
5616 /// If there are no arguments, this is still invoked.
5617 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
5618 Scope *CurScope);
5619
5620 /// ActOnBlockError - If there is an error parsing a block, this callback
5621 /// is invoked to pop the information about the block from the action impl.
5622 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
5623
5624 /// ActOnBlockStmtExpr - This is called when the body of a block statement
5625 /// literal was successfully completed. ^(int x){...}
5626 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
5627 Scope *CurScope);
5628
5629 //===---------------------------- Clang Extensions ----------------------===//
5630
5631 /// __builtin_convertvector(...)
5632 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
5633 SourceLocation BuiltinLoc,
5634 SourceLocation RParenLoc);
5635
5636 //===---------------------------- OpenCL Features -----------------------===//
5637
5638 /// __builtin_astype(...)
5639 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
5640 SourceLocation BuiltinLoc,
5641 SourceLocation RParenLoc);
5642 ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy,
5643 SourceLocation BuiltinLoc,
5644 SourceLocation RParenLoc);
5645
5646 //===---------------------------- C++ Features --------------------------===//
5647
5648 // Act on C++ namespaces
5649 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
5650 SourceLocation NamespaceLoc,
5651 SourceLocation IdentLoc, IdentifierInfo *Ident,
5652 SourceLocation LBrace,
5653 const ParsedAttributesView &AttrList,
5654 UsingDirectiveDecl *&UsingDecl);
5655 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
5656
5657 NamespaceDecl *getStdNamespace() const;
5658 NamespaceDecl *getOrCreateStdNamespace();
5659
5660 NamespaceDecl *lookupStdExperimentalNamespace();
5661
5662 CXXRecordDecl *getStdBadAlloc() const;
5663 EnumDecl *getStdAlignValT() const;
5664
5665private:
5666 // A cache representing if we've fully checked the various comparison category
5667 // types stored in ASTContext. The bit-index corresponds to the integer value
5668 // of a ComparisonCategoryType enumerator.
5669 llvm::SmallBitVector FullyCheckedComparisonCategories;
5670
5671 ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
5672 CXXScopeSpec &SS,
5673 ParsedType TemplateTypeTy,
5674 IdentifierInfo *MemberOrBase);
5675
5676public:
5677 enum class ComparisonCategoryUsage {
5678 /// The '<=>' operator was used in an expression and a builtin operator
5679 /// was selected.
5680 OperatorInExpression,
5681 /// A defaulted 'operator<=>' needed the comparison category. This
5682 /// typically only applies to 'std::strong_ordering', due to the implicit
5683 /// fallback return value.
5684 DefaultedOperator,
5685 };
5686
5687 /// Lookup the specified comparison category types in the standard
5688 /// library, an check the VarDecls possibly returned by the operator<=>
5689 /// builtins for that type.
5690 ///
5691 /// \return The type of the comparison category type corresponding to the
5692 /// specified Kind, or a null type if an error occurs
5693 QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,
5694 SourceLocation Loc,
5695 ComparisonCategoryUsage Usage);
5696
5697 /// Tests whether Ty is an instance of std::initializer_list and, if
5698 /// it is and Element is not NULL, assigns the element type to Element.
5699 bool isStdInitializerList(QualType Ty, QualType *Element);
5700
5701 /// Looks for the std::initializer_list template and instantiates it
5702 /// with Element, or emits an error if it's not found.
5703 ///
5704 /// \returns The instantiated template, or null on error.
5705 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
5706
5707 /// Determine whether Ctor is an initializer-list constructor, as
5708 /// defined in [dcl.init.list]p2.
5709 bool isInitListConstructor(const FunctionDecl *Ctor);
5710
5711 Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc,
5712 SourceLocation NamespcLoc, CXXScopeSpec &SS,
5713 SourceLocation IdentLoc,
5714 IdentifierInfo *NamespcName,
5715 const ParsedAttributesView &AttrList);
5716
5717 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
5718
5719 Decl *ActOnNamespaceAliasDef(Scope *CurScope,
5720 SourceLocation NamespaceLoc,
5721 SourceLocation AliasLoc,
5722 IdentifierInfo *Alias,
5723 CXXScopeSpec &SS,
5724 SourceLocation IdentLoc,
5725 IdentifierInfo *Ident);
5726
5727 void FilterUsingLookup(Scope *S, LookupResult &lookup);
5728 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
5729 bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target,
5730 const LookupResult &PreviousDecls,
5731 UsingShadowDecl *&PrevShadow);
5732 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
5733 NamedDecl *Target,
5734 UsingShadowDecl *PrevDecl);
5735
5736 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
5737 bool HasTypenameKeyword,
5738 const CXXScopeSpec &SS,
5739 SourceLocation NameLoc,
5740 const LookupResult &Previous);
5741 bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
5742 const CXXScopeSpec &SS,
5743 const DeclarationNameInfo &NameInfo,
5744 SourceLocation NameLoc,
5745 const LookupResult *R = nullptr,
5746 const UsingDecl *UD = nullptr);
5747
5748 NamedDecl *BuildUsingDeclaration(
5749 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
5750 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
5751 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
5752 const ParsedAttributesView &AttrList, bool IsInstantiation,
5753 bool IsUsingIfExists);
5754 NamedDecl *BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
5755 SourceLocation UsingLoc,
5756 SourceLocation EnumLoc,
5757 SourceLocation NameLoc, EnumDecl *ED);
5758 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
5759 ArrayRef<NamedDecl *> Expansions);
5760
5761 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
5762
5763 /// Given a derived-class using shadow declaration for a constructor and the
5764 /// correspnding base class constructor, find or create the implicit
5765 /// synthesized derived class constructor to use for this initialization.
5766 CXXConstructorDecl *
5767 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
5768 ConstructorUsingShadowDecl *DerivedShadow);
5769
5770 Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,
5771 SourceLocation UsingLoc,
5772 SourceLocation TypenameLoc, CXXScopeSpec &SS,
5773 UnqualifiedId &Name, SourceLocation EllipsisLoc,
5774 const ParsedAttributesView &AttrList);
5775 Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS,
5776 SourceLocation UsingLoc,
5777 SourceLocation EnumLoc, const DeclSpec &);
5778 Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,
5779 MultiTemplateParamsArg TemplateParams,
5780 SourceLocation UsingLoc, UnqualifiedId &Name,
5781 const ParsedAttributesView &AttrList,
5782 TypeResult Type, Decl *DeclFromDeclSpec);
5783
5784 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
5785 /// including handling of its default argument expressions.
5786 ///
5787 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind
5788 ExprResult
5789 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5790 NamedDecl *FoundDecl,
5791 CXXConstructorDecl *Constructor, MultiExprArg Exprs,
5792 bool HadMultipleCandidates, bool IsListInitialization,
5793 bool IsStdInitListInitialization,
5794 bool RequiresZeroInit, unsigned ConstructKind,
5795 SourceRange ParenRange);
5796
5797 /// Build a CXXConstructExpr whose constructor has already been resolved if
5798 /// it denotes an inherited constructor.
5799 ExprResult
5800 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5801 CXXConstructorDecl *Constructor, bool Elidable,
5802 MultiExprArg Exprs,
5803 bool HadMultipleCandidates, bool IsListInitialization,
5804 bool IsStdInitListInitialization,
5805 bool RequiresZeroInit, unsigned ConstructKind,
5806 SourceRange ParenRange);
5807
5808 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
5809 // the constructor can be elidable?
5810 ExprResult
5811 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5812 NamedDecl *FoundDecl,
5813 CXXConstructorDecl *Constructor, bool Elidable,
5814 MultiExprArg Exprs, bool HadMultipleCandidates,
5815 bool IsListInitialization,
5816 bool IsStdInitListInitialization, bool RequiresZeroInit,
5817 unsigned ConstructKind, SourceRange ParenRange);
5818
5819 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
5820
5821
5822 /// Instantiate or parse a C++ default argument expression as necessary.
5823 /// Return true on error.
5824 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
5825 ParmVarDecl *Param);
5826
5827 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
5828 /// the default expr if needed.
5829 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
5830 FunctionDecl *FD,
5831 ParmVarDecl *Param);
5832
5833 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
5834 /// constructed variable.
5835 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
5836
5837 /// Helper class that collects exception specifications for
5838 /// implicitly-declared special member functions.
5839 class ImplicitExceptionSpecification {
5840 // Pointer to allow copying
5841 Sema *Self;
5842 // We order exception specifications thus:
5843 // noexcept is the most restrictive, but is only used in C++11.
5844 // throw() comes next.
5845 // Then a throw(collected exceptions)
5846 // Finally no specification, which is expressed as noexcept(false).
5847 // throw(...) is used instead if any called function uses it.
5848 ExceptionSpecificationType ComputedEST;
5849 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;
5850 SmallVector<QualType, 4> Exceptions;
5851
5852 void ClearExceptions() {
5853 ExceptionsSeen.clear();
5854 Exceptions.clear();
5855 }
5856
5857 public:
5858 explicit ImplicitExceptionSpecification(Sema &Self)
5859 : Self(&Self), ComputedEST(EST_BasicNoexcept) {
5860 if (!Self.getLangOpts().CPlusPlus11)
5861 ComputedEST = EST_DynamicNone;
5862 }
5863
5864 /// Get the computed exception specification type.
5865 ExceptionSpecificationType getExceptionSpecType() const {
5866 assert(!isComputedNoexcept(ComputedEST) &&(static_cast <bool> (!isComputedNoexcept(ComputedEST) &&
"noexcept(expr) should not be a possible result") ? void (0)
: __assert_fail ("!isComputedNoexcept(ComputedEST) && \"noexcept(expr) should not be a possible result\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 5867, __extension__ __PRETTY_FUNCTION__))
5867 "noexcept(expr) should not be a possible result")(static_cast <bool> (!isComputedNoexcept(ComputedEST) &&
"noexcept(expr) should not be a possible result") ? void (0)
: __assert_fail ("!isComputedNoexcept(ComputedEST) && \"noexcept(expr) should not be a possible result\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 5867, __extension__ __PRETTY_FUNCTION__))
;
5868 return ComputedEST;
5869 }
5870
5871 /// The number of exceptions in the exception specification.
5872 unsigned size() const { return Exceptions.size(); }
5873
5874 /// The set of exceptions in the exception specification.
5875 const QualType *data() const { return Exceptions.data(); }
5876
5877 /// Integrate another called method into the collected data.
5878 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
5879
5880 /// Integrate an invoked expression into the collected data.
5881 void CalledExpr(Expr *E) { CalledStmt(E); }
5882
5883 /// Integrate an invoked statement into the collected data.
5884 void CalledStmt(Stmt *S);
5885
5886 /// Overwrite an EPI's exception specification with this
5887 /// computed exception specification.
5888 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {
5889 FunctionProtoType::ExceptionSpecInfo ESI;
5890 ESI.Type = getExceptionSpecType();
5891 if (ESI.Type == EST_Dynamic) {
5892 ESI.Exceptions = Exceptions;
5893 } else if (ESI.Type == EST_None) {
5894 /// C++11 [except.spec]p14:
5895 /// The exception-specification is noexcept(false) if the set of
5896 /// potential exceptions of the special member function contains "any"
5897 ESI.Type = EST_NoexceptFalse;
5898 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),
5899 tok::kw_false).get();
5900 }
5901 return ESI;
5902 }
5903 };
5904
5905 /// Evaluate the implicit exception specification for a defaulted
5906 /// special member function.
5907 void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);
5908
5909 /// Check the given noexcept-specifier, convert its expression, and compute
5910 /// the appropriate ExceptionSpecificationType.
5911 ExprResult ActOnNoexceptSpec(Expr *NoexceptExpr,
5912 ExceptionSpecificationType &EST);
5913
5914 /// Check the given exception-specification and update the
5915 /// exception specification information with the results.
5916 void checkExceptionSpecification(bool IsTopLevel,
5917 ExceptionSpecificationType EST,
5918 ArrayRef<ParsedType> DynamicExceptions,
5919 ArrayRef<SourceRange> DynamicExceptionRanges,
5920 Expr *NoexceptExpr,
5921 SmallVectorImpl<QualType> &Exceptions,
5922 FunctionProtoType::ExceptionSpecInfo &ESI);
5923
5924 /// Determine if we're in a case where we need to (incorrectly) eagerly
5925 /// parse an exception specification to work around a libstdc++ bug.
5926 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
5927
5928 /// Add an exception-specification to the given member function
5929 /// (or member function template). The exception-specification was parsed
5930 /// after the method itself was declared.
5931 void actOnDelayedExceptionSpecification(Decl *Method,
5932 ExceptionSpecificationType EST,
5933 SourceRange SpecificationRange,
5934 ArrayRef<ParsedType> DynamicExceptions,
5935 ArrayRef<SourceRange> DynamicExceptionRanges,
5936 Expr *NoexceptExpr);
5937
5938 class InheritedConstructorInfo;
5939
5940 /// Determine if a special member function should have a deleted
5941 /// definition when it is defaulted.
5942 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5943 InheritedConstructorInfo *ICI = nullptr,
5944 bool Diagnose = false);
5945
5946 /// Produce notes explaining why a defaulted function was defined as deleted.
5947 void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);
5948
5949 /// Declare the implicit default constructor for the given class.
5950 ///
5951 /// \param ClassDecl The class declaration into which the implicit
5952 /// default constructor will be added.
5953 ///
5954 /// \returns The implicitly-declared default constructor.
5955 CXXConstructorDecl *DeclareImplicitDefaultConstructor(
5956 CXXRecordDecl *ClassDecl);
5957
5958 /// DefineImplicitDefaultConstructor - Checks for feasibility of
5959 /// defining this constructor as the default constructor.
5960 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
5961 CXXConstructorDecl *Constructor);
5962
5963 /// Declare the implicit destructor for the given class.
5964 ///
5965 /// \param ClassDecl The class declaration into which the implicit
5966 /// destructor will be added.
5967 ///
5968 /// \returns The implicitly-declared destructor.
5969 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);
5970
5971 /// DefineImplicitDestructor - Checks for feasibility of
5972 /// defining this destructor as the default destructor.
5973 void DefineImplicitDestructor(SourceLocation CurrentLocation,
5974 CXXDestructorDecl *Destructor);
5975
5976 /// Build an exception spec for destructors that don't have one.
5977 ///
5978 /// C++11 says that user-defined destructors with no exception spec get one
5979 /// that looks as if the destructor was implicitly declared.
5980 void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);
5981
5982 /// Define the specified inheriting constructor.
5983 void DefineInheritingConstructor(SourceLocation UseLoc,
5984 CXXConstructorDecl *Constructor);
5985
5986 /// Declare the implicit copy constructor for the given class.
5987 ///
5988 /// \param ClassDecl The class declaration into which the implicit
5989 /// copy constructor will be added.
5990 ///
5991 /// \returns The implicitly-declared copy constructor.
5992 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);
5993
5994 /// DefineImplicitCopyConstructor - Checks for feasibility of
5995 /// defining this constructor as the copy constructor.
5996 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
5997 CXXConstructorDecl *Constructor);
5998
5999 /// Declare the implicit move constructor for the given class.
6000 ///
6001 /// \param ClassDecl The Class declaration into which the implicit
6002 /// move constructor will be added.
6003 ///
6004 /// \returns The implicitly-declared move constructor, or NULL if it wasn't
6005 /// declared.
6006 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);
6007
6008 /// DefineImplicitMoveConstructor - Checks for feasibility of
6009 /// defining this constructor as the move constructor.
6010 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
6011 CXXConstructorDecl *Constructor);
6012
6013 /// Declare the implicit copy assignment operator for the given class.
6014 ///
6015 /// \param ClassDecl The class declaration into which the implicit
6016 /// copy assignment operator will be added.
6017 ///
6018 /// \returns The implicitly-declared copy assignment operator.
6019 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);
6020
6021 /// Defines an implicitly-declared copy assignment operator.
6022 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
6023 CXXMethodDecl *MethodDecl);
6024
6025 /// Declare the implicit move assignment operator for the given class.
6026 ///
6027 /// \param ClassDecl The Class declaration into which the implicit
6028 /// move assignment operator will be added.
6029 ///
6030 /// \returns The implicitly-declared move assignment operator, or NULL if it
6031 /// wasn't declared.
6032 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);
6033
6034 /// Defines an implicitly-declared move assignment operator.
6035 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
6036 CXXMethodDecl *MethodDecl);
6037
6038 /// Force the declaration of any implicitly-declared members of this
6039 /// class.
6040 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
6041
6042 /// Check a completed declaration of an implicit special member.
6043 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);
6044
6045 /// Determine whether the given function is an implicitly-deleted
6046 /// special member function.
6047 bool isImplicitlyDeleted(FunctionDecl *FD);
6048
6049 /// Check whether 'this' shows up in the type of a static member
6050 /// function after the (naturally empty) cv-qualifier-seq would be.
6051 ///
6052 /// \returns true if an error occurred.
6053 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
6054
6055 /// Whether this' shows up in the exception specification of a static
6056 /// member function.
6057 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
6058
6059 /// Check whether 'this' shows up in the attributes of the given
6060 /// static member function.
6061 ///
6062 /// \returns true if an error occurred.
6063 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
6064
6065 /// MaybeBindToTemporary - If the passed in expression has a record type with
6066 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
6067 /// it simply returns the passed in expression.
6068 ExprResult MaybeBindToTemporary(Expr *E);
6069
6070 /// Wrap the expression in a ConstantExpr if it is a potential immediate
6071 /// invocation.
6072 ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
6073
6074 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
6075 QualType DeclInitType, MultiExprArg ArgsPtr,
6076 SourceLocation Loc,
6077 SmallVectorImpl<Expr *> &ConvertedArgs,
6078 bool AllowExplicit = false,
6079 bool IsListInitialization = false);
6080
6081 ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
6082 SourceLocation NameLoc,
6083 IdentifierInfo &Name);
6084
6085 ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,
6086 Scope *S, CXXScopeSpec &SS,
6087 bool EnteringContext);
6088 ParsedType getDestructorName(SourceLocation TildeLoc,
6089 IdentifierInfo &II, SourceLocation NameLoc,
6090 Scope *S, CXXScopeSpec &SS,
6091 ParsedType ObjectType,
6092 bool EnteringContext);
6093
6094 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
6095 ParsedType ObjectType);
6096
6097 // Checks that reinterpret casts don't have undefined behavior.
6098 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
6099 bool IsDereference, SourceRange Range);
6100
6101 // Checks that the vector type should be initialized from a scalar
6102 // by splatting the value rather than populating a single element.
6103 // This is the case for AltiVecVector types as well as with
6104 // AltiVecPixel and AltiVecBool when -faltivec-src-compat=xl is specified.
6105 bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy);
6106
6107 // Checks if the -faltivec-src-compat=gcc option is specified.
6108 // If so, AltiVecVector, AltiVecBool and AltiVecPixel types are
6109 // treated the same way as they are when trying to initialize
6110 // these vectors on gcc (an error is emitted).
6111 bool CheckAltivecInitFromScalar(SourceRange R, QualType VecTy,
6112 QualType SrcTy);
6113
6114 /// ActOnCXXNamedCast - Parse
6115 /// {dynamic,static,reinterpret,const,addrspace}_cast's.
6116 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
6117 tok::TokenKind Kind,
6118 SourceLocation LAngleBracketLoc,
6119 Declarator &D,
6120 SourceLocation RAngleBracketLoc,
6121 SourceLocation LParenLoc,
6122 Expr *E,
6123 SourceLocation RParenLoc);
6124
6125 ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
6126 tok::TokenKind Kind,
6127 TypeSourceInfo *Ty,
6128 Expr *E,
6129 SourceRange AngleBrackets,
6130 SourceRange Parens);
6131
6132 ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,
6133 ExprResult Operand,
6134 SourceLocation RParenLoc);
6135
6136 ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,
6137 Expr *Operand, SourceLocation RParenLoc);
6138
6139 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6140 SourceLocation TypeidLoc,
6141 TypeSourceInfo *Operand,
6142 SourceLocation RParenLoc);
6143 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6144 SourceLocation TypeidLoc,
6145 Expr *Operand,
6146 SourceLocation RParenLoc);
6147
6148 /// ActOnCXXTypeid - Parse typeid( something ).
6149 ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
6150 SourceLocation LParenLoc, bool isType,
6151 void *TyOrExpr,
6152 SourceLocation RParenLoc);
6153
6154 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6155 SourceLocation TypeidLoc,
6156 TypeSourceInfo *Operand,
6157 SourceLocation RParenLoc);
6158 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6159 SourceLocation TypeidLoc,
6160 Expr *Operand,
6161 SourceLocation RParenLoc);
6162
6163 /// ActOnCXXUuidof - Parse __uuidof( something ).
6164 ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
6165 SourceLocation LParenLoc, bool isType,
6166 void *TyOrExpr,
6167 SourceLocation RParenLoc);
6168
6169 /// Handle a C++1z fold-expression: ( expr op ... op expr ).
6170 ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,
6171 tok::TokenKind Operator,
6172 SourceLocation EllipsisLoc, Expr *RHS,
6173 SourceLocation RParenLoc);
6174 ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,
6175 SourceLocation LParenLoc, Expr *LHS,
6176 BinaryOperatorKind Operator,
6177 SourceLocation EllipsisLoc, Expr *RHS,
6178 SourceLocation RParenLoc,
6179 Optional<unsigned> NumExpansions);
6180 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
6181 BinaryOperatorKind Operator);
6182
6183 //// ActOnCXXThis - Parse 'this' pointer.
6184 ExprResult ActOnCXXThis(SourceLocation loc);
6185
6186 /// Build a CXXThisExpr and mark it referenced in the current context.
6187 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);
6188 void MarkThisReferenced(CXXThisExpr *This);
6189
6190 /// Try to retrieve the type of the 'this' pointer.
6191 ///
6192 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
6193 QualType getCurrentThisType();
6194
6195 /// When non-NULL, the C++ 'this' expression is allowed despite the
6196 /// current context not being a non-static member function. In such cases,
6197 /// this provides the type used for 'this'.
6198 QualType CXXThisTypeOverride;
6199
6200 /// RAII object used to temporarily allow the C++ 'this' expression
6201 /// to be used, with the given qualifiers on the current class type.
6202 class CXXThisScopeRAII {
6203 Sema &S;
6204 QualType OldCXXThisTypeOverride;
6205 bool Enabled;
6206
6207 public:
6208 /// Introduce a new scope where 'this' may be allowed (when enabled),
6209 /// using the given declaration (which is either a class template or a
6210 /// class) along with the given qualifiers.
6211 /// along with the qualifiers placed on '*this'.
6212 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,
6213 bool Enabled = true);
6214
6215 ~CXXThisScopeRAII();
6216 };
6217
6218 /// Make sure the value of 'this' is actually available in the current
6219 /// context, if it is a potentially evaluated context.
6220 ///
6221 /// \param Loc The location at which the capture of 'this' occurs.
6222 ///
6223 /// \param Explicit Whether 'this' is explicitly captured in a lambda
6224 /// capture list.
6225 ///
6226 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
6227 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
6228 /// This is useful when enclosing lambdas must speculatively capture
6229 /// 'this' that may or may not be used in certain specializations of
6230 /// a nested generic lambda (depending on whether the name resolves to
6231 /// a non-static member function or a static function).
6232 /// \return returns 'true' if failed, 'false' if success.
6233 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
6234 bool BuildAndDiagnose = true,
6235 const unsigned *const FunctionScopeIndexToStopAt = nullptr,
6236 bool ByCopy = false);
6237
6238 /// Determine whether the given type is the type of *this that is used
6239 /// outside of the body of a member function for a type that is currently
6240 /// being defined.
6241 bool isThisOutsideMemberFunctionBody(QualType BaseType);
6242
6243 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
6244 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6245
6246
6247 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
6248 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6249
6250 ExprResult
6251 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
6252 SourceLocation AtLoc, SourceLocation RParen);
6253
6254 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
6255 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
6256
6257 //// ActOnCXXThrow - Parse throw expressions.
6258 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
6259 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
6260 bool IsThrownVarInScope);
6261 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
6262
6263 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
6264 /// Can be interpreted either as function-style casting ("int(x)")
6265 /// or class type construction ("ClassType(x,y,z)")
6266 /// or creation of a value-initialized type ("int()").
6267 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
6268 SourceLocation LParenOrBraceLoc,
6269 MultiExprArg Exprs,
6270 SourceLocation RParenOrBraceLoc,
6271 bool ListInitialization);
6272
6273 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
6274 SourceLocation LParenLoc,
6275 MultiExprArg Exprs,
6276 SourceLocation RParenLoc,
6277 bool ListInitialization);
6278
6279 /// ActOnCXXNew - Parsed a C++ 'new' expression.
6280 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
6281 SourceLocation PlacementLParen,
6282 MultiExprArg PlacementArgs,
6283 SourceLocation PlacementRParen,
6284 SourceRange TypeIdParens, Declarator &D,
6285 Expr *Initializer);
6286 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
6287 SourceLocation PlacementLParen,
6288 MultiExprArg PlacementArgs,
6289 SourceLocation PlacementRParen,
6290 SourceRange TypeIdParens,
6291 QualType AllocType,
6292 TypeSourceInfo *AllocTypeInfo,
6293 Optional<Expr *> ArraySize,
6294 SourceRange DirectInitRange,
6295 Expr *Initializer);
6296
6297 /// Determine whether \p FD is an aligned allocation or deallocation
6298 /// function that is unavailable.
6299 bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;
6300
6301 /// Produce diagnostics if \p FD is an aligned allocation or deallocation
6302 /// function that is unavailable.
6303 void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
6304 SourceLocation Loc);
6305
6306 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
6307 SourceRange R);
6308
6309 /// The scope in which to find allocation functions.
6310 enum AllocationFunctionScope {
6311 /// Only look for allocation functions in the global scope.
6312 AFS_Global,
6313 /// Only look for allocation functions in the scope of the
6314 /// allocated class.
6315 AFS_Class,
6316 /// Look for allocation functions in both the global scope
6317 /// and in the scope of the allocated class.
6318 AFS_Both
6319 };
6320
6321 /// Finds the overloads of operator new and delete that are appropriate
6322 /// for the allocation.
6323 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
6324 AllocationFunctionScope NewScope,
6325 AllocationFunctionScope DeleteScope,
6326 QualType AllocType, bool IsArray,
6327 bool &PassAlignment, MultiExprArg PlaceArgs,
6328 FunctionDecl *&OperatorNew,
6329 FunctionDecl *&OperatorDelete,
6330 bool Diagnose = true);
6331 void DeclareGlobalNewDelete();
6332 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
6333 ArrayRef<QualType> Params);
6334
6335 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
6336 DeclarationName Name, FunctionDecl* &Operator,
6337 bool Diagnose = true);
6338 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
6339 bool CanProvideSize,
6340 bool Overaligned,
6341 DeclarationName Name);
6342 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
6343 CXXRecordDecl *RD);
6344
6345 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
6346 ExprResult ActOnCXXDelete(SourceLocation StartLoc,
6347 bool UseGlobal, bool ArrayForm,
6348 Expr *Operand);
6349 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
6350 bool IsDelete, bool CallCanBeVirtual,
6351 bool WarnOnNonAbstractTypes,
6352 SourceLocation DtorLoc);
6353
6354 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
6355 Expr *Operand, SourceLocation RParen);
6356 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6357 SourceLocation RParen);
6358
6359 /// Parsed one of the type trait support pseudo-functions.
6360 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6361 ArrayRef<ParsedType> Args,
6362 SourceLocation RParenLoc);
6363 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6364 ArrayRef<TypeSourceInfo *> Args,
6365 SourceLocation RParenLoc);
6366
6367 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support
6368 /// pseudo-functions.
6369 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
6370 SourceLocation KWLoc,
6371 ParsedType LhsTy,
6372 Expr *DimExpr,
6373 SourceLocation RParen);
6374
6375 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
6376 SourceLocation KWLoc,
6377 TypeSourceInfo *TSInfo,
6378 Expr *DimExpr,
6379 SourceLocation RParen);
6380
6381 /// ActOnExpressionTrait - Parsed one of the unary type trait support
6382 /// pseudo-functions.
6383 ExprResult ActOnExpressionTrait(ExpressionTrait OET,
6384 SourceLocation KWLoc,
6385 Expr *Queried,
6386 SourceLocation RParen);
6387
6388 ExprResult BuildExpressionTrait(ExpressionTrait OET,
6389 SourceLocation KWLoc,
6390 Expr *Queried,
6391 SourceLocation RParen);
6392
6393 ExprResult ActOnStartCXXMemberReference(Scope *S,
6394 Expr *Base,
6395 SourceLocation OpLoc,
6396 tok::TokenKind OpKind,
6397 ParsedType &ObjectType,
6398 bool &MayBePseudoDestructor);
6399
6400 ExprResult BuildPseudoDestructorExpr(Expr *Base,
6401 SourceLocation OpLoc,
6402 tok::TokenKind OpKind,
6403 const CXXScopeSpec &SS,
6404 TypeSourceInfo *ScopeType,
6405 SourceLocation CCLoc,
6406 SourceLocation TildeLoc,
6407 PseudoDestructorTypeStorage DestroyedType);
6408
6409 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6410 SourceLocation OpLoc,
6411 tok::TokenKind OpKind,
6412 CXXScopeSpec &SS,
6413 UnqualifiedId &FirstTypeName,
6414 SourceLocation CCLoc,
6415 SourceLocation TildeLoc,
6416 UnqualifiedId &SecondTypeName);
6417
6418 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6419 SourceLocation OpLoc,
6420 tok::TokenKind OpKind,
6421 SourceLocation TildeLoc,
6422 const DeclSpec& DS);
6423
6424 /// MaybeCreateExprWithCleanups - If the current full-expression
6425 /// requires any cleanups, surround it with a ExprWithCleanups node.
6426 /// Otherwise, just returns the passed-in expression.
6427 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
6428 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
6429 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
6430
6431 MaterializeTemporaryExpr *
6432 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6433 bool BoundToLvalueReference);
6434
6435 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {
6436 return ActOnFinishFullExpr(
6437 Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue);
6438 }
6439 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
6440 bool DiscardedValue, bool IsConstexpr = false);
6441 StmtResult ActOnFinishFullStmt(Stmt *Stmt);
6442
6443 // Marks SS invalid if it represents an incomplete type.
6444 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
6445 // Complete an enum decl, maybe without a scope spec.
6446 bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L,
6447 CXXScopeSpec *SS = nullptr);
6448
6449 DeclContext *computeDeclContext(QualType T);
6450 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
6451 bool EnteringContext = false);
6452 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
6453 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
6454
6455 /// The parser has parsed a global nested-name-specifier '::'.
6456 ///
6457 /// \param CCLoc The location of the '::'.
6458 ///
6459 /// \param SS The nested-name-specifier, which will be updated in-place
6460 /// to reflect the parsed nested-name-specifier.
6461 ///
6462 /// \returns true if an error occurred, false otherwise.
6463 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
6464
6465 /// The parser has parsed a '__super' nested-name-specifier.
6466 ///
6467 /// \param SuperLoc The location of the '__super' keyword.
6468 ///
6469 /// \param ColonColonLoc The location of the '::'.
6470 ///
6471 /// \param SS The nested-name-specifier, which will be updated in-place
6472 /// to reflect the parsed nested-name-specifier.
6473 ///
6474 /// \returns true if an error occurred, false otherwise.
6475 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
6476 SourceLocation ColonColonLoc, CXXScopeSpec &SS);
6477
6478 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
6479 bool *CanCorrect = nullptr);
6480 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
6481
6482 /// Keeps information about an identifier in a nested-name-spec.
6483 ///
6484 struct NestedNameSpecInfo {
6485 /// The type of the object, if we're parsing nested-name-specifier in
6486 /// a member access expression.
6487 ParsedType ObjectType;
6488
6489 /// The identifier preceding the '::'.
6490 IdentifierInfo *Identifier;
6491
6492 /// The location of the identifier.
6493 SourceLocation IdentifierLoc;
6494
6495 /// The location of the '::'.
6496 SourceLocation CCLoc;
6497
6498 /// Creates info object for the most typical case.
6499 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6500 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())
6501 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),
6502 CCLoc(ColonColonLoc) {
6503 }
6504
6505 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6506 SourceLocation ColonColonLoc, QualType ObjectType)
6507 : ObjectType(ParsedType::make(ObjectType)), Identifier(II),
6508 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {
6509 }
6510 };
6511
6512 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
6513 NestedNameSpecInfo &IdInfo);
6514
6515 bool BuildCXXNestedNameSpecifier(Scope *S,
6516 NestedNameSpecInfo &IdInfo,
6517 bool EnteringContext,
6518 CXXScopeSpec &SS,
6519 NamedDecl *ScopeLookupResult,
6520 bool ErrorRecoveryLookup,
6521 bool *IsCorrectedToColon = nullptr,
6522 bool OnlyNamespace = false);
6523
6524 /// The parser has parsed a nested-name-specifier 'identifier::'.
6525 ///
6526 /// \param S The scope in which this nested-name-specifier occurs.
6527 ///
6528 /// \param IdInfo Parser information about an identifier in the
6529 /// nested-name-spec.
6530 ///
6531 /// \param EnteringContext Whether we're entering the context nominated by
6532 /// this nested-name-specifier.
6533 ///
6534 /// \param SS The nested-name-specifier, which is both an input
6535 /// parameter (the nested-name-specifier before this type) and an
6536 /// output parameter (containing the full nested-name-specifier,
6537 /// including this new type).
6538 ///
6539 /// \param ErrorRecoveryLookup If true, then this method is called to improve
6540 /// error recovery. In this case do not emit error message.
6541 ///
6542 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
6543 /// are allowed. The bool value pointed by this parameter is set to 'true'
6544 /// if the identifier is treated as if it was followed by ':', not '::'.
6545 ///
6546 /// \param OnlyNamespace If true, only considers namespaces in lookup.
6547 ///
6548 /// \returns true if an error occurred, false otherwise.
6549 bool ActOnCXXNestedNameSpecifier(Scope *S,
6550 NestedNameSpecInfo &IdInfo,
6551 bool EnteringContext,
6552 CXXScopeSpec &SS,
6553 bool ErrorRecoveryLookup = false,
6554 bool *IsCorrectedToColon = nullptr,
6555 bool OnlyNamespace = false);
6556
6557 ExprResult ActOnDecltypeExpression(Expr *E);
6558
6559 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
6560 const DeclSpec &DS,
6561 SourceLocation ColonColonLoc);
6562
6563 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
6564 NestedNameSpecInfo &IdInfo,
6565 bool EnteringContext);
6566
6567 /// The parser has parsed a nested-name-specifier
6568 /// 'template[opt] template-name < template-args >::'.
6569 ///
6570 /// \param S The scope in which this nested-name-specifier occurs.
6571 ///
6572 /// \param SS The nested-name-specifier, which is both an input
6573 /// parameter (the nested-name-specifier before this type) and an
6574 /// output parameter (containing the full nested-name-specifier,
6575 /// including this new type).
6576 ///
6577 /// \param TemplateKWLoc the location of the 'template' keyword, if any.
6578 /// \param TemplateName the template name.
6579 /// \param TemplateNameLoc The location of the template name.
6580 /// \param LAngleLoc The location of the opening angle bracket ('<').
6581 /// \param TemplateArgs The template arguments.
6582 /// \param RAngleLoc The location of the closing angle bracket ('>').
6583 /// \param CCLoc The location of the '::'.
6584 ///
6585 /// \param EnteringContext Whether we're entering the context of the
6586 /// nested-name-specifier.
6587 ///
6588 ///
6589 /// \returns true if an error occurred, false otherwise.
6590 bool ActOnCXXNestedNameSpecifier(Scope *S,
6591 CXXScopeSpec &SS,
6592 SourceLocation TemplateKWLoc,
6593 TemplateTy TemplateName,
6594 SourceLocation TemplateNameLoc,
6595 SourceLocation LAngleLoc,
6596 ASTTemplateArgsPtr TemplateArgs,
6597 SourceLocation RAngleLoc,
6598 SourceLocation CCLoc,
6599 bool EnteringContext);
6600
6601 /// Given a C++ nested-name-specifier, produce an annotation value
6602 /// that the parser can use later to reconstruct the given
6603 /// nested-name-specifier.
6604 ///
6605 /// \param SS A nested-name-specifier.
6606 ///
6607 /// \returns A pointer containing all of the information in the
6608 /// nested-name-specifier \p SS.
6609 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
6610
6611 /// Given an annotation pointer for a nested-name-specifier, restore
6612 /// the nested-name-specifier structure.
6613 ///
6614 /// \param Annotation The annotation pointer, produced by
6615 /// \c SaveNestedNameSpecifierAnnotation().
6616 ///
6617 /// \param AnnotationRange The source range corresponding to the annotation.
6618 ///
6619 /// \param SS The nested-name-specifier that will be updated with the contents
6620 /// of the annotation pointer.
6621 void RestoreNestedNameSpecifierAnnotation(void *Annotation,
6622 SourceRange AnnotationRange,
6623 CXXScopeSpec &SS);
6624
6625 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6626
6627 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
6628 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
6629 /// After this method is called, according to [C++ 3.4.3p3], names should be
6630 /// looked up in the declarator-id's scope, until the declarator is parsed and
6631 /// ActOnCXXExitDeclaratorScope is called.
6632 /// The 'SS' should be a non-empty valid CXXScopeSpec.
6633 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
6634
6635 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
6636 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
6637 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
6638 /// Used to indicate that names should revert to being looked up in the
6639 /// defining scope.
6640 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6641
6642 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
6643 /// initializer for the declaration 'Dcl'.
6644 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
6645 /// static data member of class X, names should be looked up in the scope of
6646 /// class X.
6647 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);
6648
6649 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
6650 /// initializer for the declaration 'Dcl'.
6651 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
6652
6653 /// Create a new lambda closure type.
6654 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
6655 TypeSourceInfo *Info,
6656 bool KnownDependent,
6657 LambdaCaptureDefault CaptureDefault);
6658
6659 /// Start the definition of a lambda expression.
6660 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
6661 SourceRange IntroducerRange,
6662 TypeSourceInfo *MethodType,
6663 SourceLocation EndLoc,
6664 ArrayRef<ParmVarDecl *> Params,
6665 ConstexprSpecKind ConstexprKind,
6666 Expr *TrailingRequiresClause);
6667
6668 /// Number lambda for linkage purposes if necessary.
6669 void handleLambdaNumbering(
6670 CXXRecordDecl *Class, CXXMethodDecl *Method,
6671 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
6672
6673 /// Endow the lambda scope info with the relevant properties.
6674 void buildLambdaScope(sema::LambdaScopeInfo *LSI,
6675 CXXMethodDecl *CallOperator,
6676 SourceRange IntroducerRange,
6677 LambdaCaptureDefault CaptureDefault,
6678 SourceLocation CaptureDefaultLoc,
6679 bool ExplicitParams,
6680 bool ExplicitResultType,
6681 bool Mutable);
6682
6683 /// Perform initialization analysis of the init-capture and perform
6684 /// any implicit conversions such as an lvalue-to-rvalue conversion if
6685 /// not being used to initialize a reference.
6686 ParsedType actOnLambdaInitCaptureInitialization(
6687 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6688 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {
6689 return ParsedType::make(buildLambdaInitCaptureInitialization(
6690 Loc, ByRef, EllipsisLoc, None, Id,
6691 InitKind != LambdaCaptureInitKind::CopyInit, Init));
6692 }
6693 QualType buildLambdaInitCaptureInitialization(
6694 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6695 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,
6696 Expr *&Init);
6697
6698 /// Create a dummy variable within the declcontext of the lambda's
6699 /// call operator, for name lookup purposes for a lambda init capture.
6700 ///
6701 /// CodeGen handles emission of lambda captures, ignoring these dummy
6702 /// variables appropriately.
6703 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
6704 QualType InitCaptureType,
6705 SourceLocation EllipsisLoc,
6706 IdentifierInfo *Id,
6707 unsigned InitStyle, Expr *Init);
6708
6709 /// Add an init-capture to a lambda scope.
6710 void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);
6711
6712 /// Note that we have finished the explicit captures for the
6713 /// given lambda.
6714 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
6715
6716 /// \brief This is called after parsing the explicit template parameter list
6717 /// on a lambda (if it exists) in C++2a.
6718 void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
6719 ArrayRef<NamedDecl *> TParams,
6720 SourceLocation RAngleLoc,
6721 ExprResult RequiresClause);
6722
6723 /// Introduce the lambda parameters into scope.
6724 void addLambdaParameters(
6725 ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
6726 CXXMethodDecl *CallOperator, Scope *CurScope);
6727
6728 /// Deduce a block or lambda's return type based on the return
6729 /// statements present in the body.
6730 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
6731
6732 /// ActOnStartOfLambdaDefinition - This is called just before we start
6733 /// parsing the body of a lambda; it analyzes the explicit captures and
6734 /// arguments, and sets up various data-structures for the body of the
6735 /// lambda.
6736 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
6737 Declarator &ParamInfo, Scope *CurScope);
6738
6739 /// ActOnLambdaError - If there is an error parsing a lambda, this callback
6740 /// is invoked to pop the information about the lambda.
6741 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
6742 bool IsInstantiation = false);
6743
6744 /// ActOnLambdaExpr - This is called when the body of a lambda expression
6745 /// was successfully completed.
6746 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
6747 Scope *CurScope);
6748
6749 /// Does copying/destroying the captured variable have side effects?
6750 bool CaptureHasSideEffects(const sema::Capture &From);
6751
6752 /// Diagnose if an explicit lambda capture is unused. Returns true if a
6753 /// diagnostic is emitted.
6754 bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
6755 const sema::Capture &From);
6756
6757 /// Build a FieldDecl suitable to hold the given capture.
6758 FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture);
6759
6760 /// Initialize the given capture with a suitable expression.
6761 ExprResult BuildCaptureInit(const sema::Capture &Capture,
6762 SourceLocation ImplicitCaptureLoc,
6763 bool IsOpenMPMapping = false);
6764
6765 /// Complete a lambda-expression having processed and attached the
6766 /// lambda body.
6767 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
6768 sema::LambdaScopeInfo *LSI);
6769
6770 /// Get the return type to use for a lambda's conversion function(s) to
6771 /// function pointer type, given the type of the call operator.
6772 QualType
6773 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,
6774 CallingConv CC);
6775
6776 /// Define the "body" of the conversion from a lambda object to a
6777 /// function pointer.
6778 ///
6779 /// This routine doesn't actually define a sensible body; rather, it fills
6780 /// in the initialization expression needed to copy the lambda object into
6781 /// the block, and IR generation actually generates the real body of the
6782 /// block pointer conversion.
6783 void DefineImplicitLambdaToFunctionPointerConversion(
6784 SourceLocation CurrentLoc, CXXConversionDecl *Conv);
6785
6786 /// Define the "body" of the conversion from a lambda object to a
6787 /// block pointer.
6788 ///
6789 /// This routine doesn't actually define a sensible body; rather, it fills
6790 /// in the initialization expression needed to copy the lambda object into
6791 /// the block, and IR generation actually generates the real body of the
6792 /// block pointer conversion.
6793 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
6794 CXXConversionDecl *Conv);
6795
6796 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
6797 SourceLocation ConvLocation,
6798 CXXConversionDecl *Conv,
6799 Expr *Src);
6800
6801 /// Check whether the given expression is a valid constraint expression.
6802 /// A diagnostic is emitted if it is not, false is returned, and
6803 /// PossibleNonPrimary will be set to true if the failure might be due to a
6804 /// non-primary expression being used as an atomic constraint.
6805 bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),
6806 bool *PossibleNonPrimary = nullptr,
6807 bool IsTrailingRequiresClause = false);
6808
6809private:
6810 /// Caches pairs of template-like decls whose associated constraints were
6811 /// checked for subsumption and whether or not the first's constraints did in
6812 /// fact subsume the second's.
6813 llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;
6814 /// Caches the normalized associated constraints of declarations (concepts or
6815 /// constrained declarations). If an error occurred while normalizing the
6816 /// associated constraints of the template or concept, nullptr will be cached
6817 /// here.
6818 llvm::DenseMap<NamedDecl *, NormalizedConstraint *>
6819 NormalizationCache;
6820
6821 llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>
6822 SatisfactionCache;
6823
6824public:
6825 const NormalizedConstraint *
6826 getNormalizedAssociatedConstraints(
6827 NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
6828
6829 /// \brief Check whether the given declaration's associated constraints are
6830 /// at least as constrained than another declaration's according to the
6831 /// partial ordering of constraints.
6832 ///
6833 /// \param Result If no error occurred, receives the result of true if D1 is
6834 /// at least constrained than D2, and false otherwise.
6835 ///
6836 /// \returns true if an error occurred, false otherwise.
6837 bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
6838 NamedDecl *D2, ArrayRef<const Expr *> AC2,
6839 bool &Result);
6840
6841 /// If D1 was not at least as constrained as D2, but would've been if a pair
6842 /// of atomic constraints involved had been declared in a concept and not
6843 /// repeated in two separate places in code.
6844 /// \returns true if such a diagnostic was emitted, false otherwise.
6845 bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
6846 ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);
6847
6848 /// \brief Check whether the given list of constraint expressions are
6849 /// satisfied (as if in a 'conjunction') given template arguments.
6850 /// \param Template the template-like entity that triggered the constraints
6851 /// check (either a concept or a constrained entity).
6852 /// \param ConstraintExprs a list of constraint expressions, treated as if
6853 /// they were 'AND'ed together.
6854 /// \param TemplateArgs the list of template arguments to substitute into the
6855 /// constraint expression.
6856 /// \param TemplateIDRange The source range of the template id that
6857 /// caused the constraints check.
6858 /// \param Satisfaction if true is returned, will contain details of the
6859 /// satisfaction, with enough information to diagnose an unsatisfied
6860 /// expression.
6861 /// \returns true if an error occurred and satisfaction could not be checked,
6862 /// false otherwise.
6863 bool CheckConstraintSatisfaction(
6864 const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
6865 ArrayRef<TemplateArgument> TemplateArgs,
6866 SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
6867
6868 /// \brief Check whether the given non-dependent constraint expression is
6869 /// satisfied. Returns false and updates Satisfaction with the satisfaction
6870 /// verdict if successful, emits a diagnostic and returns true if an error
6871 /// occured and satisfaction could not be determined.
6872 ///
6873 /// \returns true if an error occurred, false otherwise.
6874 bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
6875 ConstraintSatisfaction &Satisfaction);
6876
6877 /// Check whether the given function decl's trailing requires clause is
6878 /// satisfied, if any. Returns false and updates Satisfaction with the
6879 /// satisfaction verdict if successful, emits a diagnostic and returns true if
6880 /// an error occured and satisfaction could not be determined.
6881 ///
6882 /// \returns true if an error occurred, false otherwise.
6883 bool CheckFunctionConstraints(const FunctionDecl *FD,
6884 ConstraintSatisfaction &Satisfaction,
6885 SourceLocation UsageLoc = SourceLocation());
6886
6887
6888 /// \brief Ensure that the given template arguments satisfy the constraints
6889 /// associated with the given template, emitting a diagnostic if they do not.
6890 ///
6891 /// \param Template The template to which the template arguments are being
6892 /// provided.
6893 ///
6894 /// \param TemplateArgs The converted, canonicalized template arguments.
6895 ///
6896 /// \param TemplateIDRange The source range of the template id that
6897 /// caused the constraints check.
6898 ///
6899 /// \returns true if the constrains are not satisfied or could not be checked
6900 /// for satisfaction, false if the constraints are satisfied.
6901 bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,
6902 ArrayRef<TemplateArgument> TemplateArgs,
6903 SourceRange TemplateIDRange);
6904
6905 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6906 /// unsatisfied.
6907 /// \param First whether this is the first time an unsatisfied constraint is
6908 /// diagnosed for this error.
6909 void
6910 DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,
6911 bool First = true);
6912
6913 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6914 /// unsatisfied.
6915 void
6916 DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,
6917 bool First = true);
6918
6919 // ParseObjCStringLiteral - Parse Objective-C string literals.
6920 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
6921 ArrayRef<Expr *> Strings);
6922
6923 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
6924
6925 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
6926 /// numeric literal expression. Type of the expression will be "NSNumber *"
6927 /// or "id" if NSNumber is unavailable.
6928 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
6929 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
6930 bool Value);
6931 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
6932
6933 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
6934 /// '@' prefixed parenthesized expression. The type of the expression will
6935 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type
6936 /// of ValueType, which is allowed to be a built-in numeric type, "char *",
6937 /// "const char *" or C structure with attribute 'objc_boxable'.
6938 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
6939
6940 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
6941 Expr *IndexExpr,
6942 ObjCMethodDecl *getterMethod,
6943 ObjCMethodDecl *setterMethod);
6944
6945 ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
6946 MutableArrayRef<ObjCDictionaryElement> Elements);
6947
6948 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
6949 TypeSourceInfo *EncodedTypeInfo,
6950 SourceLocation RParenLoc);
6951 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
6952 CXXConversionDecl *Method,
6953 bool HadMultipleCandidates);
6954
6955 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
6956 SourceLocation EncodeLoc,
6957 SourceLocation LParenLoc,
6958 ParsedType Ty,
6959 SourceLocation RParenLoc);
6960
6961 /// ParseObjCSelectorExpression - Build selector expression for \@selector
6962 ExprResult ParseObjCSelectorExpression(Selector Sel,
6963 SourceLocation AtLoc,
6964 SourceLocation SelLoc,
6965 SourceLocation LParenLoc,
6966 SourceLocation RParenLoc,
6967 bool WarnMultipleSelectors);
6968
6969 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol
6970 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
6971 SourceLocation AtLoc,
6972 SourceLocation ProtoLoc,
6973 SourceLocation LParenLoc,
6974 SourceLocation ProtoIdLoc,
6975 SourceLocation RParenLoc);
6976
6977 //===--------------------------------------------------------------------===//
6978 // C++ Declarations
6979 //
6980 Decl *ActOnStartLinkageSpecification(Scope *S,
6981 SourceLocation ExternLoc,
6982 Expr *LangStr,
6983 SourceLocation LBraceLoc);
6984 Decl *ActOnFinishLinkageSpecification(Scope *S,
6985 Decl *LinkageSpec,
6986 SourceLocation RBraceLoc);
6987
6988
6989 //===--------------------------------------------------------------------===//
6990 // C++ Classes
6991 //
6992 CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS);
6993 bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
6994 const CXXScopeSpec *SS = nullptr);
6995 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);
6996
6997 bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
6998 SourceLocation ColonLoc,
6999 const ParsedAttributesView &Attrs);
7000
7001 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
7002 Declarator &D,
7003 MultiTemplateParamsArg TemplateParameterLists,
7004 Expr *BitfieldWidth, const VirtSpecifiers &VS,
7005 InClassInitStyle InitStyle);
7006
7007 void ActOnStartCXXInClassMemberInitializer();
7008 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
7009 SourceLocation EqualLoc,
7010 Expr *Init);
7011
7012 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7013 Scope *S,
7014 CXXScopeSpec &SS,
7015 IdentifierInfo *MemberOrBase,
7016 ParsedType TemplateTypeTy,
7017 const DeclSpec &DS,
7018 SourceLocation IdLoc,
7019 SourceLocation LParenLoc,
7020 ArrayRef<Expr *> Args,
7021 SourceLocation RParenLoc,
7022 SourceLocation EllipsisLoc);
7023
7024 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7025 Scope *S,
7026 CXXScopeSpec &SS,
7027 IdentifierInfo *MemberOrBase,
7028 ParsedType TemplateTypeTy,
7029 const DeclSpec &DS,
7030 SourceLocation IdLoc,
7031 Expr *InitList,
7032 SourceLocation EllipsisLoc);
7033
7034 MemInitResult BuildMemInitializer(Decl *ConstructorD,
7035 Scope *S,
7036 CXXScopeSpec &SS,
7037 IdentifierInfo *MemberOrBase,
7038 ParsedType TemplateTypeTy,
7039 const DeclSpec &DS,
7040 SourceLocation IdLoc,
7041 Expr *Init,
7042 SourceLocation EllipsisLoc);
7043
7044 MemInitResult BuildMemberInitializer(ValueDecl *Member,
7045 Expr *Init,
7046 SourceLocation IdLoc);
7047
7048 MemInitResult BuildBaseInitializer(QualType BaseType,
7049 TypeSourceInfo *BaseTInfo,
7050 Expr *Init,
7051 CXXRecordDecl *ClassDecl,
7052 SourceLocation EllipsisLoc);
7053
7054 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
7055 Expr *Init,
7056 CXXRecordDecl *ClassDecl);
7057
7058 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
7059 CXXCtorInitializer *Initializer);
7060
7061 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
7062 ArrayRef<CXXCtorInitializer *> Initializers = None);
7063
7064 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
7065
7066
7067 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
7068 /// mark all the non-trivial destructors of its members and bases as
7069 /// referenced.
7070 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
7071 CXXRecordDecl *Record);
7072
7073 /// Mark destructors of virtual bases of this class referenced. In the Itanium
7074 /// C++ ABI, this is done when emitting a destructor for any non-abstract
7075 /// class. In the Microsoft C++ ABI, this is done any time a class's
7076 /// destructor is referenced.
7077 void MarkVirtualBaseDestructorsReferenced(
7078 SourceLocation Location, CXXRecordDecl *ClassDecl,
7079 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr);
7080
7081 /// Do semantic checks to allow the complete destructor variant to be emitted
7082 /// when the destructor is defined in another translation unit. In the Itanium
7083 /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they
7084 /// can be emitted in separate TUs. To emit the complete variant, run a subset
7085 /// of the checks performed when emitting a regular destructor.
7086 void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,
7087 CXXDestructorDecl *Dtor);
7088
7089 /// The list of classes whose vtables have been used within
7090 /// this translation unit, and the source locations at which the
7091 /// first use occurred.
7092 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
7093
7094 /// The list of vtables that are required but have not yet been
7095 /// materialized.
7096 SmallVector<VTableUse, 16> VTableUses;
7097
7098 /// The set of classes whose vtables have been used within
7099 /// this translation unit, and a bit that will be true if the vtable is
7100 /// required to be emitted (otherwise, it should be emitted only if needed
7101 /// by code generation).
7102 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
7103
7104 /// Load any externally-stored vtable uses.
7105 void LoadExternalVTableUses();
7106
7107 /// Note that the vtable for the given class was used at the
7108 /// given location.
7109 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
7110 bool DefinitionRequired = false);
7111
7112 /// Mark the exception specifications of all virtual member functions
7113 /// in the given class as needed.
7114 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
7115 const CXXRecordDecl *RD);
7116
7117 /// MarkVirtualMembersReferenced - Will mark all members of the given
7118 /// CXXRecordDecl referenced.
7119 void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,
7120 bool ConstexprOnly = false);
7121
7122 /// Define all of the vtables that have been used in this
7123 /// translation unit and reference any virtual members used by those
7124 /// vtables.
7125 ///
7126 /// \returns true if any work was done, false otherwise.
7127 bool DefineUsedVTables();
7128
7129 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
7130
7131 void ActOnMemInitializers(Decl *ConstructorDecl,
7132 SourceLocation ColonLoc,
7133 ArrayRef<CXXCtorInitializer*> MemInits,
7134 bool AnyErrors);
7135
7136 /// Check class-level dllimport/dllexport attribute. The caller must
7137 /// ensure that referenceDLLExportedClassMethods is called some point later
7138 /// when all outer classes of Class are complete.
7139 void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
7140 void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);
7141
7142 void referenceDLLExportedClassMethods();
7143
7144 void propagateDLLAttrToBaseClassTemplate(
7145 CXXRecordDecl *Class, Attr *ClassAttr,
7146 ClassTemplateSpecializationDecl *BaseTemplateSpec,
7147 SourceLocation BaseLoc);
7148
7149 /// Add gsl::Pointer attribute to std::container::iterator
7150 /// \param ND The declaration that introduces the name
7151 /// std::container::iterator. \param UnderlyingRecord The record named by ND.
7152 void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord);
7153
7154 /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
7155 void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);
7156
7157 /// Add [[gsl::Pointer]] attributes for std:: types.
7158 void inferGslPointerAttribute(TypedefNameDecl *TD);
7159
7160 void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record);
7161
7162 /// Check that the C++ class annoated with "trivial_abi" satisfies all the
7163 /// conditions that are needed for the attribute to have an effect.
7164 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);
7165
7166 void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,
7167 Decl *TagDecl, SourceLocation LBrac,
7168 SourceLocation RBrac,
7169 const ParsedAttributesView &AttrList);
7170 void ActOnFinishCXXMemberDecls();
7171 void ActOnFinishCXXNonNestedClass();
7172
7173 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);
7174 unsigned ActOnReenterTemplateScope(Decl *Template,
7175 llvm::function_ref<Scope *()> EnterScope);
7176 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);
7177 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7178 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);
7179 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);
7180 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7181 void ActOnFinishDelayedMemberInitializers(Decl *Record);
7182 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
7183 CachedTokens &Toks);
7184 void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
7185 bool IsInsideALocalClassWithinATemplateFunction();
7186
7187 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7188 Expr *AssertExpr,
7189 Expr *AssertMessageExpr,
7190 SourceLocation RParenLoc);
7191 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7192 Expr *AssertExpr,
7193 StringLiteral *AssertMessageExpr,
7194 SourceLocation RParenLoc,
7195 bool Failed);
7196
7197 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
7198 SourceLocation FriendLoc,
7199 TypeSourceInfo *TSInfo);
7200 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
7201 MultiTemplateParamsArg TemplateParams);
7202 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,
7203 MultiTemplateParamsArg TemplateParams);
7204
7205 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
7206 StorageClass& SC);
7207 void CheckConstructor(CXXConstructorDecl *Constructor);
7208 QualType CheckDestructorDeclarator(Declarator &D, QualType R,
7209 StorageClass& SC);
7210 bool CheckDestructor(CXXDestructorDecl *Destructor);
7211 void CheckConversionDeclarator(Declarator &D, QualType &R,
7212 StorageClass& SC);
7213 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
7214 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
7215 StorageClass &SC);
7216 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
7217
7218 void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);
7219
7220 bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
7221 CXXSpecialMember CSM);
7222 void CheckDelayedMemberExceptionSpecs();
7223
7224 bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,
7225 DefaultedComparisonKind DCK);
7226 void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
7227 FunctionDecl *Spaceship);
7228 void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,
7229 DefaultedComparisonKind DCK);
7230
7231 //===--------------------------------------------------------------------===//
7232 // C++ Derived Classes
7233 //
7234
7235 /// ActOnBaseSpecifier - Parsed a base specifier
7236 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
7237 SourceRange SpecifierRange,
7238 bool Virtual, AccessSpecifier Access,
7239 TypeSourceInfo *TInfo,
7240 SourceLocation EllipsisLoc);
7241
7242 BaseResult ActOnBaseSpecifier(Decl *classdecl,
7243 SourceRange SpecifierRange,
7244 ParsedAttributes &Attrs,
7245 bool Virtual, AccessSpecifier Access,
7246 ParsedType basetype,
7247 SourceLocation BaseLoc,
7248 SourceLocation EllipsisLoc);
7249
7250 bool AttachBaseSpecifiers(CXXRecordDecl *Class,
7251 MutableArrayRef<CXXBaseSpecifier *> Bases);
7252 void ActOnBaseSpecifiers(Decl *ClassDecl,
7253 MutableArrayRef<CXXBaseSpecifier *> Bases);
7254
7255 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
7256 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
7257 CXXBasePaths &Paths);
7258
7259 // FIXME: I don't like this name.
7260 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
7261
7262 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7263 SourceLocation Loc, SourceRange Range,
7264 CXXCastPath *BasePath = nullptr,
7265 bool IgnoreAccess = false);
7266 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7267 unsigned InaccessibleBaseID,
7268 unsigned AmbiguousBaseConvID,
7269 SourceLocation Loc, SourceRange Range,
7270 DeclarationName Name,
7271 CXXCastPath *BasePath,
7272 bool IgnoreAccess = false);
7273
7274 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
7275
7276 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
7277 const CXXMethodDecl *Old);
7278
7279 /// CheckOverridingFunctionReturnType - Checks whether the return types are
7280 /// covariant, according to C++ [class.virtual]p5.
7281 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
7282 const CXXMethodDecl *Old);
7283
7284 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
7285 /// spec is a subset of base spec.
7286 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
7287 const CXXMethodDecl *Old);
7288
7289 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
7290
7291 /// CheckOverrideControl - Check C++11 override control semantics.
7292 void CheckOverrideControl(NamedDecl *D);
7293
7294 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
7295 /// not used in the declaration of an overriding method.
7296 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent);
7297
7298 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function
7299 /// overrides a virtual member function marked 'final', according to
7300 /// C++11 [class.virtual]p4.
7301 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
7302 const CXXMethodDecl *Old);
7303
7304
7305 //===--------------------------------------------------------------------===//
7306 // C++ Access Control
7307 //
7308
7309 enum AccessResult {
7310 AR_accessible,
7311 AR_inaccessible,
7312 AR_dependent,
7313 AR_delayed
7314 };
7315
7316 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
7317 NamedDecl *PrevMemberDecl,
7318 AccessSpecifier LexicalAS);
7319
7320 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
7321 DeclAccessPair FoundDecl);
7322 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
7323 DeclAccessPair FoundDecl);
7324 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
7325 SourceRange PlacementRange,
7326 CXXRecordDecl *NamingClass,
7327 DeclAccessPair FoundDecl,
7328 bool Diagnose = true);
7329 AccessResult CheckConstructorAccess(SourceLocation Loc,
7330 CXXConstructorDecl *D,
7331 DeclAccessPair FoundDecl,
7332 const InitializedEntity &Entity,
7333 bool IsCopyBindingRefToTemp = false);
7334 AccessResult CheckConstructorAccess(SourceLocation Loc,
7335 CXXConstructorDecl *D,
7336 DeclAccessPair FoundDecl,
7337 const InitializedEntity &Entity,
7338 const PartialDiagnostic &PDiag);
7339 AccessResult CheckDestructorAccess(SourceLocation Loc,
7340 CXXDestructorDecl *Dtor,
7341 const PartialDiagnostic &PDiag,
7342 QualType objectType = QualType());
7343 AccessResult CheckFriendAccess(NamedDecl *D);
7344 AccessResult CheckMemberAccess(SourceLocation UseLoc,
7345 CXXRecordDecl *NamingClass,
7346 DeclAccessPair Found);
7347 AccessResult
7348 CheckStructuredBindingMemberAccess(SourceLocation UseLoc,
7349 CXXRecordDecl *DecomposedClass,
7350 DeclAccessPair Field);
7351 AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
7352 Expr *ObjectExpr,
7353 Expr *ArgExpr,
7354 DeclAccessPair FoundDecl);
7355 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
7356 DeclAccessPair FoundDecl);
7357 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
7358 QualType Base, QualType Derived,
7359 const CXXBasePath &Path,
7360 unsigned DiagID,
7361 bool ForceCheck = false,
7362 bool ForceUnprivileged = false);
7363 void CheckLookupAccess(const LookupResult &R);
7364 bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass,
7365 QualType BaseType);
7366 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7367 DeclAccessPair Found, QualType ObjectType,
7368 SourceLocation Loc,
7369 const PartialDiagnostic &Diag);
7370 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7371 DeclAccessPair Found,
7372 QualType ObjectType) {
7373 return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,
7374 SourceLocation(), PDiag());
7375 }
7376
7377 void HandleDependentAccessCheck(const DependentDiagnostic &DD,
7378 const MultiLevelTemplateArgumentList &TemplateArgs);
7379 void PerformDependentDiagnostics(const DeclContext *Pattern,
7380 const MultiLevelTemplateArgumentList &TemplateArgs);
7381
7382 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
7383
7384 /// When true, access checking violations are treated as SFINAE
7385 /// failures rather than hard errors.
7386 bool AccessCheckingSFINAE;
7387
7388 enum AbstractDiagSelID {
7389 AbstractNone = -1,
7390 AbstractReturnType,
7391 AbstractParamType,
7392 AbstractVariableType,
7393 AbstractFieldType,
7394 AbstractIvarType,
7395 AbstractSynthesizedIvarType,
7396 AbstractArrayType
7397 };
7398
7399 bool isAbstractType(SourceLocation Loc, QualType T);
7400 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
7401 TypeDiagnoser &Diagnoser);
7402 template <typename... Ts>
7403 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
7404 const Ts &...Args) {
7405 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
7406 return RequireNonAbstractType(Loc, T, Diagnoser);
7407 }
7408
7409 void DiagnoseAbstractType(const CXXRecordDecl *RD);
7410
7411 //===--------------------------------------------------------------------===//
7412 // C++ Overloaded Operators [C++ 13.5]
7413 //
7414
7415 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
7416
7417 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
7418
7419 //===--------------------------------------------------------------------===//
7420 // C++ Templates [C++ 14]
7421 //
7422 void FilterAcceptableTemplateNames(LookupResult &R,
7423 bool AllowFunctionTemplates = true,
7424 bool AllowDependent = true);
7425 bool hasAnyAcceptableTemplateNames(LookupResult &R,
7426 bool AllowFunctionTemplates = true,
7427 bool AllowDependent = true,
7428 bool AllowNonTemplateFunctions = false);
7429 /// Try to interpret the lookup result D as a template-name.
7430 ///
7431 /// \param D A declaration found by name lookup.
7432 /// \param AllowFunctionTemplates Whether function templates should be
7433 /// considered valid results.
7434 /// \param AllowDependent Whether unresolved using declarations (that might
7435 /// name templates) should be considered valid results.
7436 static NamedDecl *getAsTemplateNameDecl(NamedDecl *D,
7437 bool AllowFunctionTemplates = true,
7438 bool AllowDependent = true);
7439
7440 enum TemplateNameIsRequiredTag { TemplateNameIsRequired };
7441 /// Whether and why a template name is required in this lookup.
7442 class RequiredTemplateKind {
7443 public:
7444 /// Template name is required if TemplateKWLoc is valid.
7445 RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation())
7446 : TemplateKW(TemplateKWLoc) {}
7447 /// Template name is unconditionally required.
7448 RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {}
7449
7450 SourceLocation getTemplateKeywordLoc() const {
7451 return TemplateKW.getValueOr(SourceLocation());
7452 }
7453 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
7454 bool isRequired() const { return TemplateKW != SourceLocation(); }
7455 explicit operator bool() const { return isRequired(); }
7456
7457 private:
7458 llvm::Optional<SourceLocation> TemplateKW;
7459 };
7460
7461 enum class AssumedTemplateKind {
7462 /// This is not assumed to be a template name.
7463 None,
7464 /// This is assumed to be a template name because lookup found nothing.
7465 FoundNothing,
7466 /// This is assumed to be a template name because lookup found one or more
7467 /// functions (but no function templates).
7468 FoundFunctions,
7469 };
7470 bool LookupTemplateName(
7471 LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,
7472 bool EnteringContext, bool &MemberOfUnknownSpecialization,
7473 RequiredTemplateKind RequiredTemplate = SourceLocation(),
7474 AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true);
7475
7476 TemplateNameKind isTemplateName(Scope *S,
7477 CXXScopeSpec &SS,
7478 bool hasTemplateKeyword,
7479 const UnqualifiedId &Name,
7480 ParsedType ObjectType,
7481 bool EnteringContext,
7482 TemplateTy &Template,
7483 bool &MemberOfUnknownSpecialization,
7484 bool Disambiguation = false);
7485
7486 /// Try to resolve an undeclared template name as a type template.
7487 ///
7488 /// Sets II to the identifier corresponding to the template name, and updates
7489 /// Name to a corresponding (typo-corrected) type template name and TNK to
7490 /// the corresponding kind, if possible.
7491 void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,
7492 TemplateNameKind &TNK,
7493 SourceLocation NameLoc,
7494 IdentifierInfo *&II);
7495
7496 bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
7497 SourceLocation NameLoc,
7498 bool Diagnose = true);
7499
7500 /// Determine whether a particular identifier might be the name in a C++1z
7501 /// deduction-guide declaration.
7502 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
7503 SourceLocation NameLoc,
7504 ParsedTemplateTy *Template = nullptr);
7505
7506 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
7507 SourceLocation IILoc,
7508 Scope *S,
7509 const CXXScopeSpec *SS,
7510 TemplateTy &SuggestedTemplate,
7511 TemplateNameKind &SuggestedKind);
7512
7513 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
7514 NamedDecl *Instantiation,
7515 bool InstantiatedFromMember,
7516 const NamedDecl *Pattern,
7517 const NamedDecl *PatternDef,
7518 TemplateSpecializationKind TSK,
7519 bool Complain = true);
7520
7521 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
7522 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);
7523
7524 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
7525 SourceLocation EllipsisLoc,
7526 SourceLocation KeyLoc,
7527 IdentifierInfo *ParamName,
7528 SourceLocation ParamNameLoc,
7529 unsigned Depth, unsigned Position,
7530 SourceLocation EqualLoc,
7531 ParsedType DefaultArg, bool HasTypeConstraint);
7532
7533 bool ActOnTypeConstraint(const CXXScopeSpec &SS,
7534 TemplateIdAnnotation *TypeConstraint,
7535 TemplateTypeParmDecl *ConstrainedParameter,
7536 SourceLocation EllipsisLoc);
7537 bool BuildTypeConstraint(const CXXScopeSpec &SS,
7538 TemplateIdAnnotation *TypeConstraint,
7539 TemplateTypeParmDecl *ConstrainedParameter,
7540 SourceLocation EllipsisLoc,
7541 bool AllowUnexpandedPack);
7542
7543 bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
7544 DeclarationNameInfo NameInfo,
7545 ConceptDecl *NamedConcept,
7546 const TemplateArgumentListInfo *TemplateArgs,
7547 TemplateTypeParmDecl *ConstrainedParameter,
7548 SourceLocation EllipsisLoc);
7549
7550 bool AttachTypeConstraint(AutoTypeLoc TL,
7551 NonTypeTemplateParmDecl *ConstrainedParameter,
7552 SourceLocation EllipsisLoc);
7553
7554 bool RequireStructuralType(QualType T, SourceLocation Loc);
7555
7556 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
7557 SourceLocation Loc);
7558 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
7559
7560 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
7561 unsigned Depth,
7562 unsigned Position,
7563 SourceLocation EqualLoc,
7564 Expr *DefaultArg);
7565 NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
7566 SourceLocation TmpLoc,
7567 TemplateParameterList *Params,
7568 SourceLocation EllipsisLoc,
7569 IdentifierInfo *ParamName,
7570 SourceLocation ParamNameLoc,
7571 unsigned Depth,
7572 unsigned Position,
7573 SourceLocation EqualLoc,
7574 ParsedTemplateArgument DefaultArg);
7575
7576 TemplateParameterList *
7577 ActOnTemplateParameterList(unsigned Depth,
7578 SourceLocation ExportLoc,
7579 SourceLocation TemplateLoc,
7580 SourceLocation LAngleLoc,
7581 ArrayRef<NamedDecl *> Params,
7582 SourceLocation RAngleLoc,
7583 Expr *RequiresClause);
7584
7585 /// The context in which we are checking a template parameter list.
7586 enum TemplateParamListContext {
7587 TPC_ClassTemplate,
7588 TPC_VarTemplate,
7589 TPC_FunctionTemplate,
7590 TPC_ClassTemplateMember,
7591 TPC_FriendClassTemplate,
7592 TPC_FriendFunctionTemplate,
7593 TPC_FriendFunctionTemplateDefinition,
7594 TPC_TypeAliasTemplate
7595 };
7596
7597 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
7598 TemplateParameterList *OldParams,
7599 TemplateParamListContext TPC,
7600 SkipBodyInfo *SkipBody = nullptr);
7601 TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
7602 SourceLocation DeclStartLoc, SourceLocation DeclLoc,
7603 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
7604 ArrayRef<TemplateParameterList *> ParamLists,
7605 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,
7606 bool SuppressDiagnostic = false);
7607
7608 DeclResult CheckClassTemplate(
7609 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7610 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
7611 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
7612 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
7613 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
7614 TemplateParameterList **OuterTemplateParamLists,
7615 SkipBodyInfo *SkipBody = nullptr);
7616
7617 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
7618 QualType NTTPType,
7619 SourceLocation Loc);
7620
7621 /// Get a template argument mapping the given template parameter to itself,
7622 /// e.g. for X in \c template<int X>, this would return an expression template
7623 /// argument referencing X.
7624 TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,
7625 SourceLocation Location);
7626
7627 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
7628 TemplateArgumentListInfo &Out);
7629
7630 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
7631
7632 void NoteAllFoundTemplates(TemplateName Name);
7633
7634 QualType CheckTemplateIdType(TemplateName Template,
7635 SourceLocation TemplateLoc,
7636 TemplateArgumentListInfo &TemplateArgs);
7637
7638 TypeResult
7639 ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7640 TemplateTy Template, IdentifierInfo *TemplateII,
7641 SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
7642 ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,
7643 bool IsCtorOrDtorName = false, bool IsClassName = false);
7644
7645 /// Parsed an elaborated-type-specifier that refers to a template-id,
7646 /// such as \c class T::template apply<U>.
7647 TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
7648 TypeSpecifierType TagSpec,
7649 SourceLocation TagLoc,
7650 CXXScopeSpec &SS,
7651 SourceLocation TemplateKWLoc,
7652 TemplateTy TemplateD,
7653 SourceLocation TemplateLoc,
7654 SourceLocation LAngleLoc,
7655 ASTTemplateArgsPtr TemplateArgsIn,
7656 SourceLocation RAngleLoc);
7657
7658 DeclResult ActOnVarTemplateSpecialization(
7659 Scope *S, Declarator &D, TypeSourceInfo *DI,
7660 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
7661 StorageClass SC, bool IsPartialSpecialization);
7662
7663 /// Get the specialization of the given variable template corresponding to
7664 /// the specified argument list, or a null-but-valid result if the arguments
7665 /// are dependent.
7666 DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
7667 SourceLocation TemplateLoc,
7668 SourceLocation TemplateNameLoc,
7669 const TemplateArgumentListInfo &TemplateArgs);
7670
7671 /// Form a reference to the specialization of the given variable template
7672 /// corresponding to the specified argument list, or a null-but-valid result
7673 /// if the arguments are dependent.
7674 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
7675 const DeclarationNameInfo &NameInfo,
7676 VarTemplateDecl *Template,
7677 SourceLocation TemplateLoc,
7678 const TemplateArgumentListInfo *TemplateArgs);
7679
7680 ExprResult
7681 CheckConceptTemplateId(const CXXScopeSpec &SS,
7682 SourceLocation TemplateKWLoc,
7683 const DeclarationNameInfo &ConceptNameInfo,
7684 NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
7685 const TemplateArgumentListInfo *TemplateArgs);
7686
7687 void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);
7688
7689 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
7690 SourceLocation TemplateKWLoc,
7691 LookupResult &R,
7692 bool RequiresADL,
7693 const TemplateArgumentListInfo *TemplateArgs);
7694
7695 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
7696 SourceLocation TemplateKWLoc,
7697 const DeclarationNameInfo &NameInfo,
7698 const TemplateArgumentListInfo *TemplateArgs);
7699
7700 TemplateNameKind ActOnTemplateName(
7701 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7702 const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
7703 TemplateTy &Template, bool AllowInjectedClassName = false);
7704
7705 DeclResult ActOnClassTemplateSpecialization(
7706 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7707 SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
7708 TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,
7709 MultiTemplateParamsArg TemplateParameterLists,
7710 SkipBodyInfo *SkipBody = nullptr);
7711
7712 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
7713 TemplateDecl *PrimaryTemplate,
7714 unsigned NumExplicitArgs,
7715 ArrayRef<TemplateArgument> Args);
7716 void CheckTemplatePartialSpecialization(
7717 ClassTemplatePartialSpecializationDecl *Partial);
7718 void CheckTemplatePartialSpecialization(
7719 VarTemplatePartialSpecializationDecl *Partial);
7720
7721 Decl *ActOnTemplateDeclarator(Scope *S,
7722 MultiTemplateParamsArg TemplateParameterLists,
7723 Declarator &D);
7724
7725 bool
7726 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
7727 TemplateSpecializationKind NewTSK,
7728 NamedDecl *PrevDecl,
7729 TemplateSpecializationKind PrevTSK,
7730 SourceLocation PrevPtOfInstantiation,
7731 bool &SuppressNew);
7732
7733 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
7734 const TemplateArgumentListInfo &ExplicitTemplateArgs,
7735 LookupResult &Previous);
7736
7737 bool CheckFunctionTemplateSpecialization(
7738 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
7739 LookupResult &Previous, bool QualifiedFriend = false);
7740 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7741 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7742
7743 DeclResult ActOnExplicitInstantiation(
7744 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
7745 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
7746 TemplateTy Template, SourceLocation TemplateNameLoc,
7747 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,
7748 SourceLocation RAngleLoc, const ParsedAttributesView &Attr);
7749
7750 DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
7751 SourceLocation TemplateLoc,
7752 unsigned TagSpec, SourceLocation KWLoc,
7753 CXXScopeSpec &SS, IdentifierInfo *Name,
7754 SourceLocation NameLoc,
7755 const ParsedAttributesView &Attr);
7756
7757 DeclResult ActOnExplicitInstantiation(Scope *S,
7758 SourceLocation ExternLoc,
7759 SourceLocation TemplateLoc,
7760 Declarator &D);
7761
7762 TemplateArgumentLoc
7763 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
7764 SourceLocation TemplateLoc,
7765 SourceLocation RAngleLoc,
7766 Decl *Param,
7767 SmallVectorImpl<TemplateArgument>
7768 &Converted,
7769 bool &HasDefaultArg);
7770
7771 /// Specifies the context in which a particular template
7772 /// argument is being checked.
7773 enum CheckTemplateArgumentKind {
7774 /// The template argument was specified in the code or was
7775 /// instantiated with some deduced template arguments.
7776 CTAK_Specified,
7777
7778 /// The template argument was deduced via template argument
7779 /// deduction.
7780 CTAK_Deduced,
7781
7782 /// The template argument was deduced from an array bound
7783 /// via template argument deduction.
7784 CTAK_DeducedFromArrayBound
7785 };
7786
7787 bool CheckTemplateArgument(NamedDecl *Param,
7788 TemplateArgumentLoc &Arg,
7789 NamedDecl *Template,
7790 SourceLocation TemplateLoc,
7791 SourceLocation RAngleLoc,
7792 unsigned ArgumentPackIndex,
7793 SmallVectorImpl<TemplateArgument> &Converted,
7794 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7795
7796 /// Check that the given template arguments can be be provided to
7797 /// the given template, converting the arguments along the way.
7798 ///
7799 /// \param Template The template to which the template arguments are being
7800 /// provided.
7801 ///
7802 /// \param TemplateLoc The location of the template name in the source.
7803 ///
7804 /// \param TemplateArgs The list of template arguments. If the template is
7805 /// a template template parameter, this function may extend the set of
7806 /// template arguments to also include substituted, defaulted template
7807 /// arguments.
7808 ///
7809 /// \param PartialTemplateArgs True if the list of template arguments is
7810 /// intentionally partial, e.g., because we're checking just the initial
7811 /// set of template arguments.
7812 ///
7813 /// \param Converted Will receive the converted, canonicalized template
7814 /// arguments.
7815 ///
7816 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
7817 /// contain the converted forms of the template arguments as written.
7818 /// Otherwise, \p TemplateArgs will not be modified.
7819 ///
7820 /// \param ConstraintsNotSatisfied If provided, and an error occured, will
7821 /// receive true if the cause for the error is the associated constraints of
7822 /// the template not being satisfied by the template arguments.
7823 ///
7824 /// \returns true if an error occurred, false otherwise.
7825 bool CheckTemplateArgumentList(TemplateDecl *Template,
7826 SourceLocation TemplateLoc,
7827 TemplateArgumentListInfo &TemplateArgs,
7828 bool PartialTemplateArgs,
7829 SmallVectorImpl<TemplateArgument> &Converted,
7830 bool UpdateArgsWithConversions = true,
7831 bool *ConstraintsNotSatisfied = nullptr);
7832
7833 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
7834 TemplateArgumentLoc &Arg,
7835 SmallVectorImpl<TemplateArgument> &Converted);
7836
7837 bool CheckTemplateArgument(TypeSourceInfo *Arg);
7838 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
7839 QualType InstantiatedParamType, Expr *Arg,
7840 TemplateArgument &Converted,
7841 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7842 bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
7843 TemplateParameterList *Params,
7844 TemplateArgumentLoc &Arg);
7845
7846 ExprResult
7847 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
7848 QualType ParamType,
7849 SourceLocation Loc);
7850 ExprResult
7851 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
7852 SourceLocation Loc);
7853
7854 /// Enumeration describing how template parameter lists are compared
7855 /// for equality.
7856 enum TemplateParameterListEqualKind {
7857 /// We are matching the template parameter lists of two templates
7858 /// that might be redeclarations.
7859 ///
7860 /// \code
7861 /// template<typename T> struct X;
7862 /// template<typename T> struct X;
7863 /// \endcode
7864 TPL_TemplateMatch,
7865
7866 /// We are matching the template parameter lists of two template
7867 /// template parameters as part of matching the template parameter lists
7868 /// of two templates that might be redeclarations.
7869 ///
7870 /// \code
7871 /// template<template<int I> class TT> struct X;
7872 /// template<template<int Value> class Other> struct X;
7873 /// \endcode
7874 TPL_TemplateTemplateParmMatch,
7875
7876 /// We are matching the template parameter lists of a template
7877 /// template argument against the template parameter lists of a template
7878 /// template parameter.
7879 ///
7880 /// \code
7881 /// template<template<int Value> class Metafun> struct X;
7882 /// template<int Value> struct integer_c;
7883 /// X<integer_c> xic;
7884 /// \endcode
7885 TPL_TemplateTemplateArgumentMatch
7886 };
7887
7888 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
7889 TemplateParameterList *Old,
7890 bool Complain,
7891 TemplateParameterListEqualKind Kind,
7892 SourceLocation TemplateArgLoc
7893 = SourceLocation());
7894
7895 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
7896
7897 /// Called when the parser has parsed a C++ typename
7898 /// specifier, e.g., "typename T::type".
7899 ///
7900 /// \param S The scope in which this typename type occurs.
7901 /// \param TypenameLoc the location of the 'typename' keyword
7902 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7903 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
7904 /// \param IdLoc the location of the identifier.
7905 TypeResult
7906 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7907 const CXXScopeSpec &SS, const IdentifierInfo &II,
7908 SourceLocation IdLoc);
7909
7910 /// Called when the parser has parsed a C++ typename
7911 /// specifier that ends in a template-id, e.g.,
7912 /// "typename MetaFun::template apply<T1, T2>".
7913 ///
7914 /// \param S The scope in which this typename type occurs.
7915 /// \param TypenameLoc the location of the 'typename' keyword
7916 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7917 /// \param TemplateLoc the location of the 'template' keyword, if any.
7918 /// \param TemplateName The template name.
7919 /// \param TemplateII The identifier used to name the template.
7920 /// \param TemplateIILoc The location of the template name.
7921 /// \param LAngleLoc The location of the opening angle bracket ('<').
7922 /// \param TemplateArgs The template arguments.
7923 /// \param RAngleLoc The location of the closing angle bracket ('>').
7924 TypeResult
7925 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7926 const CXXScopeSpec &SS,
7927 SourceLocation TemplateLoc,
7928 TemplateTy TemplateName,
7929 IdentifierInfo *TemplateII,
7930 SourceLocation TemplateIILoc,
7931 SourceLocation LAngleLoc,
7932 ASTTemplateArgsPtr TemplateArgs,
7933 SourceLocation RAngleLoc);
7934
7935 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7936 SourceLocation KeywordLoc,
7937 NestedNameSpecifierLoc QualifierLoc,
7938 const IdentifierInfo &II,
7939 SourceLocation IILoc,
7940 TypeSourceInfo **TSI,
7941 bool DeducedTSTContext);
7942
7943 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7944 SourceLocation KeywordLoc,
7945 NestedNameSpecifierLoc QualifierLoc,
7946 const IdentifierInfo &II,
7947 SourceLocation IILoc,
7948 bool DeducedTSTContext = true);
7949
7950
7951 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
7952 SourceLocation Loc,
7953 DeclarationName Name);
7954 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
7955
7956 ExprResult RebuildExprInCurrentInstantiation(Expr *E);
7957 bool RebuildTemplateParamsInCurrentInstantiation(
7958 TemplateParameterList *Params);
7959
7960 std::string
7961 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7962 const TemplateArgumentList &Args);
7963
7964 std::string
7965 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7966 const TemplateArgument *Args,
7967 unsigned NumArgs);
7968
7969 //===--------------------------------------------------------------------===//
7970 // C++ Concepts
7971 //===--------------------------------------------------------------------===//
7972 Decl *ActOnConceptDefinition(
7973 Scope *S, MultiTemplateParamsArg TemplateParameterLists,
7974 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);
7975
7976 RequiresExprBodyDecl *
7977 ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,
7978 ArrayRef<ParmVarDecl *> LocalParameters,
7979 Scope *BodyScope);
7980 void ActOnFinishRequiresExpr();
7981 concepts::Requirement *ActOnSimpleRequirement(Expr *E);
7982 concepts::Requirement *ActOnTypeRequirement(
7983 SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,
7984 IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId);
7985 concepts::Requirement *ActOnCompoundRequirement(Expr *E,
7986 SourceLocation NoexceptLoc);
7987 concepts::Requirement *
7988 ActOnCompoundRequirement(
7989 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,
7990 TemplateIdAnnotation *TypeConstraint, unsigned Depth);
7991 concepts::Requirement *ActOnNestedRequirement(Expr *Constraint);
7992 concepts::ExprRequirement *
7993 BuildExprRequirement(
7994 Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc,
7995 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7996 concepts::ExprRequirement *
7997 BuildExprRequirement(
7998 concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,
7999 bool IsSatisfied, SourceLocation NoexceptLoc,
8000 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
8001 concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type);
8002 concepts::TypeRequirement *
8003 BuildTypeRequirement(
8004 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
8005 concepts::NestedRequirement *BuildNestedRequirement(Expr *E);
8006 concepts::NestedRequirement *
8007 BuildNestedRequirement(
8008 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
8009 ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,
8010 RequiresExprBodyDecl *Body,
8011 ArrayRef<ParmVarDecl *> LocalParameters,
8012 ArrayRef<concepts::Requirement *> Requirements,
8013 SourceLocation ClosingBraceLoc);
8014
8015 //===--------------------------------------------------------------------===//
8016 // C++ Variadic Templates (C++0x [temp.variadic])
8017 //===--------------------------------------------------------------------===//
8018
8019 /// Determine whether an unexpanded parameter pack might be permitted in this
8020 /// location. Useful for error recovery.
8021 bool isUnexpandedParameterPackPermitted();
8022
8023 /// The context in which an unexpanded parameter pack is
8024 /// being diagnosed.
8025 ///
8026 /// Note that the values of this enumeration line up with the first
8027 /// argument to the \c err_unexpanded_parameter_pack diagnostic.
8028 enum UnexpandedParameterPackContext {
8029 /// An arbitrary expression.
8030 UPPC_Expression = 0,
8031
8032 /// The base type of a class type.
8033 UPPC_BaseType,
8034
8035 /// The type of an arbitrary declaration.
8036 UPPC_DeclarationType,
8037
8038 /// The type of a data member.
8039 UPPC_DataMemberType,
8040
8041 /// The size of a bit-field.
8042 UPPC_BitFieldWidth,
8043
8044 /// The expression in a static assertion.
8045 UPPC_StaticAssertExpression,
8046
8047 /// The fixed underlying type of an enumeration.
8048 UPPC_FixedUnderlyingType,
8049
8050 /// The enumerator value.
8051 UPPC_EnumeratorValue,
8052
8053 /// A using declaration.
8054 UPPC_UsingDeclaration,
8055
8056 /// A friend declaration.
8057 UPPC_FriendDeclaration,
8058
8059 /// A declaration qualifier.
8060 UPPC_DeclarationQualifier,
8061
8062 /// An initializer.
8063 UPPC_Initializer,
8064
8065 /// A default argument.
8066 UPPC_DefaultArgument,
8067
8068 /// The type of a non-type template parameter.
8069 UPPC_NonTypeTemplateParameterType,
8070
8071 /// The type of an exception.
8072 UPPC_ExceptionType,
8073
8074 /// Partial specialization.
8075 UPPC_PartialSpecialization,
8076
8077 /// Microsoft __if_exists.
8078 UPPC_IfExists,
8079
8080 /// Microsoft __if_not_exists.
8081 UPPC_IfNotExists,
8082
8083 /// Lambda expression.
8084 UPPC_Lambda,
8085
8086 /// Block expression.
8087 UPPC_Block,
8088
8089 /// A type constraint.
8090 UPPC_TypeConstraint,
8091
8092 // A requirement in a requires-expression.
8093 UPPC_Requirement,
8094
8095 // A requires-clause.
8096 UPPC_RequiresClause,
8097 };
8098
8099 /// Diagnose unexpanded parameter packs.
8100 ///
8101 /// \param Loc The location at which we should emit the diagnostic.
8102 ///
8103 /// \param UPPC The context in which we are diagnosing unexpanded
8104 /// parameter packs.
8105 ///
8106 /// \param Unexpanded the set of unexpanded parameter packs.
8107 ///
8108 /// \returns true if an error occurred, false otherwise.
8109 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
8110 UnexpandedParameterPackContext UPPC,
8111 ArrayRef<UnexpandedParameterPack> Unexpanded);
8112
8113 /// If the given type contains an unexpanded parameter pack,
8114 /// diagnose the error.
8115 ///
8116 /// \param Loc The source location where a diagnostc should be emitted.
8117 ///
8118 /// \param T The type that is being checked for unexpanded parameter
8119 /// packs.
8120 ///
8121 /// \returns true if an error occurred, false otherwise.
8122 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
8123 UnexpandedParameterPackContext UPPC);
8124
8125 /// If the given expression contains an unexpanded parameter
8126 /// pack, diagnose the error.
8127 ///
8128 /// \param E The expression that is being checked for unexpanded
8129 /// parameter packs.
8130 ///
8131 /// \returns true if an error occurred, false otherwise.
8132 bool DiagnoseUnexpandedParameterPack(Expr *E,
8133 UnexpandedParameterPackContext UPPC = UPPC_Expression);
8134
8135 /// If the given requirees-expression contains an unexpanded reference to one
8136 /// of its own parameter packs, diagnose the error.
8137 ///
8138 /// \param RE The requiress-expression that is being checked for unexpanded
8139 /// parameter packs.
8140 ///
8141 /// \returns true if an error occurred, false otherwise.
8142 bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);
8143
8144 /// If the given nested-name-specifier contains an unexpanded
8145 /// parameter pack, diagnose the error.
8146 ///
8147 /// \param SS The nested-name-specifier that is being checked for
8148 /// unexpanded parameter packs.
8149 ///
8150 /// \returns true if an error occurred, false otherwise.
8151 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
8152 UnexpandedParameterPackContext UPPC);
8153
8154 /// If the given name contains an unexpanded parameter pack,
8155 /// diagnose the error.
8156 ///
8157 /// \param NameInfo The name (with source location information) that
8158 /// is being checked for unexpanded parameter packs.
8159 ///
8160 /// \returns true if an error occurred, false otherwise.
8161 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
8162 UnexpandedParameterPackContext UPPC);
8163
8164 /// If the given template name contains an unexpanded parameter pack,
8165 /// diagnose the error.
8166 ///
8167 /// \param Loc The location of the template name.
8168 ///
8169 /// \param Template The template name that is being checked for unexpanded
8170 /// parameter packs.
8171 ///
8172 /// \returns true if an error occurred, false otherwise.
8173 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
8174 TemplateName Template,
8175 UnexpandedParameterPackContext UPPC);
8176
8177 /// If the given template argument contains an unexpanded parameter
8178 /// pack, diagnose the error.
8179 ///
8180 /// \param Arg The template argument that is being checked for unexpanded
8181 /// parameter packs.
8182 ///
8183 /// \returns true if an error occurred, false otherwise.
8184 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
8185 UnexpandedParameterPackContext UPPC);
8186
8187 /// Collect the set of unexpanded parameter packs within the given
8188 /// template argument.
8189 ///
8190 /// \param Arg The template argument that will be traversed to find
8191 /// unexpanded parameter packs.
8192 void collectUnexpandedParameterPacks(TemplateArgument Arg,
8193 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8194
8195 /// Collect the set of unexpanded parameter packs within the given
8196 /// template argument.
8197 ///
8198 /// \param Arg The template argument that will be traversed to find
8199 /// unexpanded parameter packs.
8200 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
8201 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8202
8203 /// Collect the set of unexpanded parameter packs within the given
8204 /// type.
8205 ///
8206 /// \param T The type that will be traversed to find
8207 /// unexpanded parameter packs.
8208 void collectUnexpandedParameterPacks(QualType T,
8209 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8210
8211 /// Collect the set of unexpanded parameter packs within the given
8212 /// type.
8213 ///
8214 /// \param TL The type that will be traversed to find
8215 /// unexpanded parameter packs.
8216 void collectUnexpandedParameterPacks(TypeLoc TL,
8217 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8218
8219 /// Collect the set of unexpanded parameter packs within the given
8220 /// nested-name-specifier.
8221 ///
8222 /// \param NNS The nested-name-specifier that will be traversed to find
8223 /// unexpanded parameter packs.
8224 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,
8225 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8226
8227 /// Collect the set of unexpanded parameter packs within the given
8228 /// name.
8229 ///
8230 /// \param NameInfo The name that will be traversed to find
8231 /// unexpanded parameter packs.
8232 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
8233 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8234
8235 /// Invoked when parsing a template argument followed by an
8236 /// ellipsis, which creates a pack expansion.
8237 ///
8238 /// \param Arg The template argument preceding the ellipsis, which
8239 /// may already be invalid.
8240 ///
8241 /// \param EllipsisLoc The location of the ellipsis.
8242 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
8243 SourceLocation EllipsisLoc);
8244
8245 /// Invoked when parsing a type followed by an ellipsis, which
8246 /// creates a pack expansion.
8247 ///
8248 /// \param Type The type preceding the ellipsis, which will become
8249 /// the pattern of the pack expansion.
8250 ///
8251 /// \param EllipsisLoc The location of the ellipsis.
8252 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
8253
8254 /// Construct a pack expansion type from the pattern of the pack
8255 /// expansion.
8256 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
8257 SourceLocation EllipsisLoc,
8258 Optional<unsigned> NumExpansions);
8259
8260 /// Construct a pack expansion type from the pattern of the pack
8261 /// expansion.
8262 QualType CheckPackExpansion(QualType Pattern,
8263 SourceRange PatternRange,
8264 SourceLocation EllipsisLoc,
8265 Optional<unsigned> NumExpansions);
8266
8267 /// Invoked when parsing an expression followed by an ellipsis, which
8268 /// creates a pack expansion.
8269 ///
8270 /// \param Pattern The expression preceding the ellipsis, which will become
8271 /// the pattern of the pack expansion.
8272 ///
8273 /// \param EllipsisLoc The location of the ellipsis.
8274 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
8275
8276 /// Invoked when parsing an expression followed by an ellipsis, which
8277 /// creates a pack expansion.
8278 ///
8279 /// \param Pattern The expression preceding the ellipsis, which will become
8280 /// the pattern of the pack expansion.
8281 ///
8282 /// \param EllipsisLoc The location of the ellipsis.
8283 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
8284 Optional<unsigned> NumExpansions);
8285
8286 /// Determine whether we could expand a pack expansion with the
8287 /// given set of parameter packs into separate arguments by repeatedly
8288 /// transforming the pattern.
8289 ///
8290 /// \param EllipsisLoc The location of the ellipsis that identifies the
8291 /// pack expansion.
8292 ///
8293 /// \param PatternRange The source range that covers the entire pattern of
8294 /// the pack expansion.
8295 ///
8296 /// \param Unexpanded The set of unexpanded parameter packs within the
8297 /// pattern.
8298 ///
8299 /// \param ShouldExpand Will be set to \c true if the transformer should
8300 /// expand the corresponding pack expansions into separate arguments. When
8301 /// set, \c NumExpansions must also be set.
8302 ///
8303 /// \param RetainExpansion Whether the caller should add an unexpanded
8304 /// pack expansion after all of the expanded arguments. This is used
8305 /// when extending explicitly-specified template argument packs per
8306 /// C++0x [temp.arg.explicit]p9.
8307 ///
8308 /// \param NumExpansions The number of separate arguments that will be in
8309 /// the expanded form of the corresponding pack expansion. This is both an
8310 /// input and an output parameter, which can be set by the caller if the
8311 /// number of expansions is known a priori (e.g., due to a prior substitution)
8312 /// and will be set by the callee when the number of expansions is known.
8313 /// The callee must set this value when \c ShouldExpand is \c true; it may
8314 /// set this value in other cases.
8315 ///
8316 /// \returns true if an error occurred (e.g., because the parameter packs
8317 /// are to be instantiated with arguments of different lengths), false
8318 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
8319 /// must be set.
8320 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
8321 SourceRange PatternRange,
8322 ArrayRef<UnexpandedParameterPack> Unexpanded,
8323 const MultiLevelTemplateArgumentList &TemplateArgs,
8324 bool &ShouldExpand,
8325 bool &RetainExpansion,
8326 Optional<unsigned> &NumExpansions);
8327
8328 /// Determine the number of arguments in the given pack expansion
8329 /// type.
8330 ///
8331 /// This routine assumes that the number of arguments in the expansion is
8332 /// consistent across all of the unexpanded parameter packs in its pattern.
8333 ///
8334 /// Returns an empty Optional if the type can't be expanded.
8335 Optional<unsigned> getNumArgumentsInExpansion(QualType T,
8336 const MultiLevelTemplateArgumentList &TemplateArgs);
8337
8338 /// Determine whether the given declarator contains any unexpanded
8339 /// parameter packs.
8340 ///
8341 /// This routine is used by the parser to disambiguate function declarators
8342 /// with an ellipsis prior to the ')', e.g.,
8343 ///
8344 /// \code
8345 /// void f(T...);
8346 /// \endcode
8347 ///
8348 /// To determine whether we have an (unnamed) function parameter pack or
8349 /// a variadic function.
8350 ///
8351 /// \returns true if the declarator contains any unexpanded parameter packs,
8352 /// false otherwise.
8353 bool containsUnexpandedParameterPacks(Declarator &D);
8354
8355 /// Returns the pattern of the pack expansion for a template argument.
8356 ///
8357 /// \param OrigLoc The template argument to expand.
8358 ///
8359 /// \param Ellipsis Will be set to the location of the ellipsis.
8360 ///
8361 /// \param NumExpansions Will be set to the number of expansions that will
8362 /// be generated from this pack expansion, if known a priori.
8363 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
8364 TemplateArgumentLoc OrigLoc,
8365 SourceLocation &Ellipsis,
8366 Optional<unsigned> &NumExpansions) const;
8367
8368 /// Given a template argument that contains an unexpanded parameter pack, but
8369 /// which has already been substituted, attempt to determine the number of
8370 /// elements that will be produced once this argument is fully-expanded.
8371 ///
8372 /// This is intended for use when transforming 'sizeof...(Arg)' in order to
8373 /// avoid actually expanding the pack where possible.
8374 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
8375
8376 //===--------------------------------------------------------------------===//
8377 // C++ Template Argument Deduction (C++ [temp.deduct])
8378 //===--------------------------------------------------------------------===//
8379
8380 /// Adjust the type \p ArgFunctionType to match the calling convention,
8381 /// noreturn, and optionally the exception specification of \p FunctionType.
8382 /// Deduction often wants to ignore these properties when matching function
8383 /// types.
8384 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
8385 bool AdjustExceptionSpec = false);
8386
8387 /// Describes the result of template argument deduction.
8388 ///
8389 /// The TemplateDeductionResult enumeration describes the result of
8390 /// template argument deduction, as returned from
8391 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
8392 /// structure provides additional information about the results of
8393 /// template argument deduction, e.g., the deduced template argument
8394 /// list (if successful) or the specific template parameters or
8395 /// deduced arguments that were involved in the failure.
8396 enum TemplateDeductionResult {
8397 /// Template argument deduction was successful.
8398 TDK_Success = 0,
8399 /// The declaration was invalid; do nothing.
8400 TDK_Invalid,
8401 /// Template argument deduction exceeded the maximum template
8402 /// instantiation depth (which has already been diagnosed).
8403 TDK_InstantiationDepth,
8404 /// Template argument deduction did not deduce a value
8405 /// for every template parameter.
8406 TDK_Incomplete,
8407 /// Template argument deduction did not deduce a value for every
8408 /// expansion of an expanded template parameter pack.
8409 TDK_IncompletePack,
8410 /// Template argument deduction produced inconsistent
8411 /// deduced values for the given template parameter.
8412 TDK_Inconsistent,
8413 /// Template argument deduction failed due to inconsistent
8414 /// cv-qualifiers on a template parameter type that would
8415 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
8416 /// but were given a non-const "X".
8417 TDK_Underqualified,
8418 /// Substitution of the deduced template argument values
8419 /// resulted in an error.
8420 TDK_SubstitutionFailure,
8421 /// After substituting deduced template arguments, a dependent
8422 /// parameter type did not match the corresponding argument.
8423 TDK_DeducedMismatch,
8424 /// After substituting deduced template arguments, an element of
8425 /// a dependent parameter type did not match the corresponding element
8426 /// of the corresponding argument (when deducing from an initializer list).
8427 TDK_DeducedMismatchNested,
8428 /// A non-depnedent component of the parameter did not match the
8429 /// corresponding component of the argument.
8430 TDK_NonDeducedMismatch,
8431 /// When performing template argument deduction for a function
8432 /// template, there were too many call arguments.
8433 TDK_TooManyArguments,
8434 /// When performing template argument deduction for a function
8435 /// template, there were too few call arguments.
8436 TDK_TooFewArguments,
8437 /// The explicitly-specified template arguments were not valid
8438 /// template arguments for the given template.
8439 TDK_InvalidExplicitArguments,
8440 /// Checking non-dependent argument conversions failed.
8441 TDK_NonDependentConversionFailure,
8442 /// The deduced arguments did not satisfy the constraints associated
8443 /// with the template.
8444 TDK_ConstraintsNotSatisfied,
8445 /// Deduction failed; that's all we know.
8446 TDK_MiscellaneousDeductionFailure,
8447 /// CUDA Target attributes do not match.
8448 TDK_CUDATargetMismatch
8449 };
8450
8451 TemplateDeductionResult
8452 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
8453 const TemplateArgumentList &TemplateArgs,
8454 sema::TemplateDeductionInfo &Info);
8455
8456 TemplateDeductionResult
8457 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
8458 const TemplateArgumentList &TemplateArgs,
8459 sema::TemplateDeductionInfo &Info);
8460
8461 TemplateDeductionResult SubstituteExplicitTemplateArguments(
8462 FunctionTemplateDecl *FunctionTemplate,
8463 TemplateArgumentListInfo &ExplicitTemplateArgs,
8464 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8465 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
8466 sema::TemplateDeductionInfo &Info);
8467
8468 /// brief A function argument from which we performed template argument
8469 // deduction for a call.
8470 struct OriginalCallArg {
8471 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
8472 unsigned ArgIdx, QualType OriginalArgType)
8473 : OriginalParamType(OriginalParamType),
8474 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
8475 OriginalArgType(OriginalArgType) {}
8476
8477 QualType OriginalParamType;
8478 bool DecomposedParam;
8479 unsigned ArgIdx;
8480 QualType OriginalArgType;
8481 };
8482
8483 TemplateDeductionResult FinishTemplateArgumentDeduction(
8484 FunctionTemplateDecl *FunctionTemplate,
8485 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8486 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
8487 sema::TemplateDeductionInfo &Info,
8488 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
8489 bool PartialOverloading = false,
8490 llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
8491
8492 TemplateDeductionResult DeduceTemplateArguments(
8493 FunctionTemplateDecl *FunctionTemplate,
8494 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
8495 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
8496 bool PartialOverloading,
8497 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
8498
8499 TemplateDeductionResult
8500 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8501 TemplateArgumentListInfo *ExplicitTemplateArgs,
8502 QualType ArgFunctionType,
8503 FunctionDecl *&Specialization,
8504 sema::TemplateDeductionInfo &Info,
8505 bool IsAddressOfFunction = false);
8506
8507 TemplateDeductionResult
8508 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8509 QualType ToType,
8510 CXXConversionDecl *&Specialization,
8511 sema::TemplateDeductionInfo &Info);
8512
8513 TemplateDeductionResult
8514 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8515 TemplateArgumentListInfo *ExplicitTemplateArgs,
8516 FunctionDecl *&Specialization,
8517 sema::TemplateDeductionInfo &Info,
8518 bool IsAddressOfFunction = false);
8519
8520 /// Substitute Replacement for \p auto in \p TypeWithAuto
8521 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
8522 /// Substitute Replacement for auto in TypeWithAuto
8523 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8524 QualType Replacement);
8525 /// Completely replace the \c auto in \p TypeWithAuto by
8526 /// \p Replacement. This does not retain any \c auto type sugar.
8527 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
8528 TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8529 QualType Replacement);
8530
8531 /// Result type of DeduceAutoType.
8532 enum DeduceAutoResult {
8533 DAR_Succeeded,
8534 DAR_Failed,
8535 DAR_FailedAlreadyDiagnosed
8536 };
8537
8538 DeduceAutoResult
8539 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
8540 Optional<unsigned> DependentDeductionDepth = None,
8541 bool IgnoreConstraints = false);
8542 DeduceAutoResult
8543 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
8544 Optional<unsigned> DependentDeductionDepth = None,
8545 bool IgnoreConstraints = false);
8546 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
8547 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
8548 bool Diagnose = true);
8549
8550 /// Declare implicit deduction guides for a class template if we've
8551 /// not already done so.
8552 void DeclareImplicitDeductionGuides(TemplateDecl *Template,
8553 SourceLocation Loc);
8554
8555 QualType DeduceTemplateSpecializationFromInitializer(
8556 TypeSourceInfo *TInfo, const InitializedEntity &Entity,
8557 const InitializationKind &Kind, MultiExprArg Init);
8558
8559 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
8560 QualType Type, TypeSourceInfo *TSI,
8561 SourceRange Range, bool DirectInit,
8562 Expr *Init);
8563
8564 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
8565
8566 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
8567 SourceLocation ReturnLoc,
8568 Expr *&RetExpr, AutoType *AT);
8569
8570 FunctionTemplateDecl *getMoreSpecializedTemplate(
8571 FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,
8572 TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
8573 unsigned NumCallArguments2, bool Reversed = false);
8574 UnresolvedSetIterator
8575 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
8576 TemplateSpecCandidateSet &FailedCandidates,
8577 SourceLocation Loc,
8578 const PartialDiagnostic &NoneDiag,
8579 const PartialDiagnostic &AmbigDiag,
8580 const PartialDiagnostic &CandidateDiag,
8581 bool Complain = true, QualType TargetType = QualType());
8582
8583 ClassTemplatePartialSpecializationDecl *
8584 getMoreSpecializedPartialSpecialization(
8585 ClassTemplatePartialSpecializationDecl *PS1,
8586 ClassTemplatePartialSpecializationDecl *PS2,
8587 SourceLocation Loc);
8588
8589 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
8590 sema::TemplateDeductionInfo &Info);
8591
8592 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
8593 VarTemplatePartialSpecializationDecl *PS1,
8594 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
8595
8596 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
8597 sema::TemplateDeductionInfo &Info);
8598
8599 bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
8600 TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);
8601
8602 void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,
8603 unsigned Depth, llvm::SmallBitVector &Used);
8604
8605 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
8606 bool OnlyDeduced,
8607 unsigned Depth,
8608 llvm::SmallBitVector &Used);
8609 void MarkDeducedTemplateParameters(
8610 const FunctionTemplateDecl *FunctionTemplate,
8611 llvm::SmallBitVector &Deduced) {
8612 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
8613 }
8614 static void MarkDeducedTemplateParameters(ASTContext &Ctx,
8615 const FunctionTemplateDecl *FunctionTemplate,
8616 llvm::SmallBitVector &Deduced);
8617
8618 //===--------------------------------------------------------------------===//
8619 // C++ Template Instantiation
8620 //
8621
8622 MultiLevelTemplateArgumentList
8623 getTemplateInstantiationArgs(NamedDecl *D,
8624 const TemplateArgumentList *Innermost = nullptr,
8625 bool RelativeToPrimary = false,
8626 const FunctionDecl *Pattern = nullptr);
8627
8628 /// A context in which code is being synthesized (where a source location
8629 /// alone is not sufficient to identify the context). This covers template
8630 /// instantiation and various forms of implicitly-generated functions.
8631 struct CodeSynthesisContext {
8632 /// The kind of template instantiation we are performing
8633 enum SynthesisKind {
8634 /// We are instantiating a template declaration. The entity is
8635 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
8636 TemplateInstantiation,
8637
8638 /// We are instantiating a default argument for a template
8639 /// parameter. The Entity is the template parameter whose argument is
8640 /// being instantiated, the Template is the template, and the
8641 /// TemplateArgs/NumTemplateArguments provide the template arguments as
8642 /// specified.
8643 DefaultTemplateArgumentInstantiation,
8644
8645 /// We are instantiating a default argument for a function.
8646 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
8647 /// provides the template arguments as specified.
8648 DefaultFunctionArgumentInstantiation,
8649
8650 /// We are substituting explicit template arguments provided for
8651 /// a function template. The entity is a FunctionTemplateDecl.
8652 ExplicitTemplateArgumentSubstitution,
8653
8654 /// We are substituting template argument determined as part of
8655 /// template argument deduction for either a class template
8656 /// partial specialization or a function template. The
8657 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
8658 /// a TemplateDecl.
8659 DeducedTemplateArgumentSubstitution,
8660
8661 /// We are substituting prior template arguments into a new
8662 /// template parameter. The template parameter itself is either a
8663 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
8664 PriorTemplateArgumentSubstitution,
8665
8666 /// We are checking the validity of a default template argument that
8667 /// has been used when naming a template-id.
8668 DefaultTemplateArgumentChecking,
8669
8670 /// We are computing the exception specification for a defaulted special
8671 /// member function.
8672 ExceptionSpecEvaluation,
8673
8674 /// We are instantiating the exception specification for a function
8675 /// template which was deferred until it was needed.
8676 ExceptionSpecInstantiation,
8677
8678 /// We are instantiating a requirement of a requires expression.
8679 RequirementInstantiation,
8680
8681 /// We are checking the satisfaction of a nested requirement of a requires
8682 /// expression.
8683 NestedRequirementConstraintsCheck,
8684
8685 /// We are declaring an implicit special member function.
8686 DeclaringSpecialMember,
8687
8688 /// We are declaring an implicit 'operator==' for a defaulted
8689 /// 'operator<=>'.
8690 DeclaringImplicitEqualityComparison,
8691
8692 /// We are defining a synthesized function (such as a defaulted special
8693 /// member).
8694 DefiningSynthesizedFunction,
8695
8696 // We are checking the constraints associated with a constrained entity or
8697 // the constraint expression of a concept. This includes the checks that
8698 // atomic constraints have the type 'bool' and that they can be constant
8699 // evaluated.
8700 ConstraintsCheck,
8701
8702 // We are substituting template arguments into a constraint expression.
8703 ConstraintSubstitution,
8704
8705 // We are normalizing a constraint expression.
8706 ConstraintNormalization,
8707
8708 // We are substituting into the parameter mapping of an atomic constraint
8709 // during normalization.
8710 ParameterMappingSubstitution,
8711
8712 /// We are rewriting a comparison operator in terms of an operator<=>.
8713 RewritingOperatorAsSpaceship,
8714
8715 /// We are initializing a structured binding.
8716 InitializingStructuredBinding,
8717
8718 /// We are marking a class as __dllexport.
8719 MarkingClassDllexported,
8720
8721 /// Added for Template instantiation observation.
8722 /// Memoization means we are _not_ instantiating a template because
8723 /// it is already instantiated (but we entered a context where we
8724 /// would have had to if it was not already instantiated).
8725 Memoization
8726 } Kind;
8727
8728 /// Was the enclosing context a non-instantiation SFINAE context?
8729 bool SavedInNonInstantiationSFINAEContext;
8730
8731 /// The point of instantiation or synthesis within the source code.
8732 SourceLocation PointOfInstantiation;
8733
8734 /// The entity that is being synthesized.
8735 Decl *Entity;
8736
8737 /// The template (or partial specialization) in which we are
8738 /// performing the instantiation, for substitutions of prior template
8739 /// arguments.
8740 NamedDecl *Template;
8741
8742 /// The list of template arguments we are substituting, if they
8743 /// are not part of the entity.
8744 const TemplateArgument *TemplateArgs;
8745
8746 // FIXME: Wrap this union around more members, or perhaps store the
8747 // kind-specific members in the RAII object owning the context.
8748 union {
8749 /// The number of template arguments in TemplateArgs.
8750 unsigned NumTemplateArgs;
8751
8752 /// The special member being declared or defined.
8753 CXXSpecialMember SpecialMember;
8754 };
8755
8756 ArrayRef<TemplateArgument> template_arguments() const {
8757 assert(Kind != DeclaringSpecialMember)(static_cast <bool> (Kind != DeclaringSpecialMember) ? void
(0) : __assert_fail ("Kind != DeclaringSpecialMember", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 8757, __extension__ __PRETTY_FUNCTION__))
;
8758 return {TemplateArgs, NumTemplateArgs};
8759 }
8760
8761 /// The template deduction info object associated with the
8762 /// substitution or checking of explicit or deduced template arguments.
8763 sema::TemplateDeductionInfo *DeductionInfo;
8764
8765 /// The source range that covers the construct that cause
8766 /// the instantiation, e.g., the template-id that causes a class
8767 /// template instantiation.
8768 SourceRange InstantiationRange;
8769
8770 CodeSynthesisContext()
8771 : Kind(TemplateInstantiation),
8772 SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),
8773 Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0),
8774 DeductionInfo(nullptr) {}
8775
8776 /// Determines whether this template is an actual instantiation
8777 /// that should be counted toward the maximum instantiation depth.
8778 bool isInstantiationRecord() const;
8779 };
8780
8781 /// List of active code synthesis contexts.
8782 ///
8783 /// This vector is treated as a stack. As synthesis of one entity requires
8784 /// synthesis of another, additional contexts are pushed onto the stack.
8785 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts;
8786
8787 /// Specializations whose definitions are currently being instantiated.
8788 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations;
8789
8790 /// Non-dependent types used in templates that have already been instantiated
8791 /// by some template instantiation.
8792 llvm::DenseSet<QualType> InstantiatedNonDependentTypes;
8793
8794 /// Extra modules inspected when performing a lookup during a template
8795 /// instantiation. Computed lazily.
8796 SmallVector<Module*, 16> CodeSynthesisContextLookupModules;
8797
8798 /// Cache of additional modules that should be used for name lookup
8799 /// within the current template instantiation. Computed lazily; use
8800 /// getLookupModules() to get a complete set.
8801 llvm::DenseSet<Module*> LookupModulesCache;
8802
8803 /// Get the set of additional modules that should be checked during
8804 /// name lookup. A module and its imports become visible when instanting a
8805 /// template defined within it.
8806 llvm::DenseSet<Module*> &getLookupModules();
8807
8808 /// Map from the most recent declaration of a namespace to the most
8809 /// recent visible declaration of that namespace.
8810 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
8811
8812 /// Whether we are in a SFINAE context that is not associated with
8813 /// template instantiation.
8814 ///
8815 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
8816 /// of a template instantiation or template argument deduction.
8817 bool InNonInstantiationSFINAEContext;
8818
8819 /// The number of \p CodeSynthesisContexts that are not template
8820 /// instantiations and, therefore, should not be counted as part of the
8821 /// instantiation depth.
8822 ///
8823 /// When the instantiation depth reaches the user-configurable limit
8824 /// \p LangOptions::InstantiationDepth we will abort instantiation.
8825 // FIXME: Should we have a similar limit for other forms of synthesis?
8826 unsigned NonInstantiationEntries;
8827
8828 /// The depth of the context stack at the point when the most recent
8829 /// error or warning was produced.
8830 ///
8831 /// This value is used to suppress printing of redundant context stacks
8832 /// when there are multiple errors or warnings in the same instantiation.
8833 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
8834 unsigned LastEmittedCodeSynthesisContextDepth = 0;
8835
8836 /// The template instantiation callbacks to trace or track
8837 /// instantiations (objects can be chained).
8838 ///
8839 /// This callbacks is used to print, trace or track template
8840 /// instantiations as they are being constructed.
8841 std::vector<std::unique_ptr<TemplateInstantiationCallback>>
8842 TemplateInstCallbacks;
8843
8844 /// The current index into pack expansion arguments that will be
8845 /// used for substitution of parameter packs.
8846 ///
8847 /// The pack expansion index will be -1 to indicate that parameter packs
8848 /// should be instantiated as themselves. Otherwise, the index specifies
8849 /// which argument within the parameter pack will be used for substitution.
8850 int ArgumentPackSubstitutionIndex;
8851
8852 /// RAII object used to change the argument pack substitution index
8853 /// within a \c Sema object.
8854 ///
8855 /// See \c ArgumentPackSubstitutionIndex for more information.
8856 class ArgumentPackSubstitutionIndexRAII {
8857 Sema &Self;
8858 int OldSubstitutionIndex;
8859
8860 public:
8861 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
8862 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
8863 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
8864 }
8865
8866 ~ArgumentPackSubstitutionIndexRAII() {
8867 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
8868 }
8869 };
8870
8871 friend class ArgumentPackSubstitutionRAII;
8872
8873 /// For each declaration that involved template argument deduction, the
8874 /// set of diagnostics that were suppressed during that template argument
8875 /// deduction.
8876 ///
8877 /// FIXME: Serialize this structure to the AST file.
8878 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
8879 SuppressedDiagnosticsMap;
8880 SuppressedDiagnosticsMap SuppressedDiagnostics;
8881
8882 /// A stack object to be created when performing template
8883 /// instantiation.
8884 ///
8885 /// Construction of an object of type \c InstantiatingTemplate
8886 /// pushes the current instantiation onto the stack of active
8887 /// instantiations. If the size of this stack exceeds the maximum
8888 /// number of recursive template instantiations, construction
8889 /// produces an error and evaluates true.
8890 ///
8891 /// Destruction of this object will pop the named instantiation off
8892 /// the stack.
8893 struct InstantiatingTemplate {
8894 /// Note that we are instantiating a class template,
8895 /// function template, variable template, alias template,
8896 /// or a member thereof.
8897 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8898 Decl *Entity,
8899 SourceRange InstantiationRange = SourceRange());
8900
8901 struct ExceptionSpecification {};
8902 /// Note that we are instantiating an exception specification
8903 /// of a function template.
8904 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8905 FunctionDecl *Entity, ExceptionSpecification,
8906 SourceRange InstantiationRange = SourceRange());
8907
8908 /// Note that we are instantiating a default argument in a
8909 /// template-id.
8910 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8911 TemplateParameter Param, TemplateDecl *Template,
8912 ArrayRef<TemplateArgument> TemplateArgs,
8913 SourceRange InstantiationRange = SourceRange());
8914
8915 /// Note that we are substituting either explicitly-specified or
8916 /// deduced template arguments during function template argument deduction.
8917 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8918 FunctionTemplateDecl *FunctionTemplate,
8919 ArrayRef<TemplateArgument> TemplateArgs,
8920 CodeSynthesisContext::SynthesisKind Kind,
8921 sema::TemplateDeductionInfo &DeductionInfo,
8922 SourceRange InstantiationRange = SourceRange());
8923
8924 /// Note that we are instantiating as part of template
8925 /// argument deduction for a class template declaration.
8926 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8927 TemplateDecl *Template,
8928 ArrayRef<TemplateArgument> TemplateArgs,
8929 sema::TemplateDeductionInfo &DeductionInfo,
8930 SourceRange InstantiationRange = SourceRange());
8931
8932 /// Note that we are instantiating as part of template
8933 /// argument deduction for a class template partial
8934 /// specialization.
8935 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8936 ClassTemplatePartialSpecializationDecl *PartialSpec,
8937 ArrayRef<TemplateArgument> TemplateArgs,
8938 sema::TemplateDeductionInfo &DeductionInfo,
8939 SourceRange InstantiationRange = SourceRange());
8940
8941 /// Note that we are instantiating as part of template
8942 /// argument deduction for a variable template partial
8943 /// specialization.
8944 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8945 VarTemplatePartialSpecializationDecl *PartialSpec,
8946 ArrayRef<TemplateArgument> TemplateArgs,
8947 sema::TemplateDeductionInfo &DeductionInfo,
8948 SourceRange InstantiationRange = SourceRange());
8949
8950 /// Note that we are instantiating a default argument for a function
8951 /// parameter.
8952 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8953 ParmVarDecl *Param,
8954 ArrayRef<TemplateArgument> TemplateArgs,
8955 SourceRange InstantiationRange = SourceRange());
8956
8957 /// Note that we are substituting prior template arguments into a
8958 /// non-type parameter.
8959 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8960 NamedDecl *Template,
8961 NonTypeTemplateParmDecl *Param,
8962 ArrayRef<TemplateArgument> TemplateArgs,
8963 SourceRange InstantiationRange);
8964
8965 /// Note that we are substituting prior template arguments into a
8966 /// template template parameter.
8967 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8968 NamedDecl *Template,
8969 TemplateTemplateParmDecl *Param,
8970 ArrayRef<TemplateArgument> TemplateArgs,
8971 SourceRange InstantiationRange);
8972
8973 /// Note that we are checking the default template argument
8974 /// against the template parameter for a given template-id.
8975 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8976 TemplateDecl *Template,
8977 NamedDecl *Param,
8978 ArrayRef<TemplateArgument> TemplateArgs,
8979 SourceRange InstantiationRange);
8980
8981 struct ConstraintsCheck {};
8982 /// \brief Note that we are checking the constraints associated with some
8983 /// constrained entity (a concept declaration or a template with associated
8984 /// constraints).
8985 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8986 ConstraintsCheck, NamedDecl *Template,
8987 ArrayRef<TemplateArgument> TemplateArgs,
8988 SourceRange InstantiationRange);
8989
8990 struct ConstraintSubstitution {};
8991 /// \brief Note that we are checking a constraint expression associated
8992 /// with a template declaration or as part of the satisfaction check of a
8993 /// concept.
8994 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8995 ConstraintSubstitution, NamedDecl *Template,
8996 sema::TemplateDeductionInfo &DeductionInfo,
8997 SourceRange InstantiationRange);
8998
8999 struct ConstraintNormalization {};
9000 /// \brief Note that we are normalizing a constraint expression.
9001 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9002 ConstraintNormalization, NamedDecl *Template,
9003 SourceRange InstantiationRange);
9004
9005 struct ParameterMappingSubstitution {};
9006 /// \brief Note that we are subtituting into the parameter mapping of an
9007 /// atomic constraint during constraint normalization.
9008 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9009 ParameterMappingSubstitution, NamedDecl *Template,
9010 SourceRange InstantiationRange);
9011
9012 /// \brief Note that we are substituting template arguments into a part of
9013 /// a requirement of a requires expression.
9014 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9015 concepts::Requirement *Req,
9016 sema::TemplateDeductionInfo &DeductionInfo,
9017 SourceRange InstantiationRange = SourceRange());
9018
9019 /// \brief Note that we are checking the satisfaction of the constraint
9020 /// expression inside of a nested requirement.
9021 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9022 concepts::NestedRequirement *Req, ConstraintsCheck,
9023 SourceRange InstantiationRange = SourceRange());
9024
9025 /// Note that we have finished instantiating this template.
9026 void Clear();
9027
9028 ~InstantiatingTemplate() { Clear(); }
9029
9030 /// Determines whether we have exceeded the maximum
9031 /// recursive template instantiations.
9032 bool isInvalid() const { return Invalid; }
48
Returning zero, which participates in a condition later
9033
9034 /// Determine whether we are already instantiating this
9035 /// specialization in some surrounding active instantiation.
9036 bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
9037
9038 private:
9039 Sema &SemaRef;
9040 bool Invalid;
9041 bool AlreadyInstantiating;
9042 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
9043 SourceRange InstantiationRange);
9044
9045 InstantiatingTemplate(
9046 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
9047 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
9048 Decl *Entity, NamedDecl *Template = nullptr,
9049 ArrayRef<TemplateArgument> TemplateArgs = None,
9050 sema::TemplateDeductionInfo *DeductionInfo = nullptr);
9051
9052 InstantiatingTemplate(const InstantiatingTemplate&) = delete;
9053
9054 InstantiatingTemplate&
9055 operator=(const InstantiatingTemplate&) = delete;
9056 };
9057
9058 void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
9059 void popCodeSynthesisContext();
9060
9061 /// Determine whether we are currently performing template instantiation.
9062 bool inTemplateInstantiation() const {
9063 return CodeSynthesisContexts.size() > NonInstantiationEntries;
9064 }
9065
9066 void PrintContextStack() {
9067 if (!CodeSynthesisContexts.empty() &&
9068 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
9069 PrintInstantiationStack();
9070 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
9071 }
9072 if (PragmaAttributeCurrentTargetDecl)
9073 PrintPragmaAttributeInstantiationPoint();
9074 }
9075 void PrintInstantiationStack();
9076
9077 void PrintPragmaAttributeInstantiationPoint();
9078
9079 /// Determines whether we are currently in a context where
9080 /// template argument substitution failures are not considered
9081 /// errors.
9082 ///
9083 /// \returns An empty \c Optional if we're not in a SFINAE context.
9084 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest
9085 /// template-deduction context object, which can be used to capture
9086 /// diagnostics that will be suppressed.
9087 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
9088
9089 /// Determines whether we are currently in a context that
9090 /// is not evaluated as per C++ [expr] p5.
9091 bool isUnevaluatedContext() const {
9092 assert(!ExprEvalContexts.empty() &&(static_cast <bool> (!ExprEvalContexts.empty() &&
"Must be in an expression evaluation context") ? void (0) : __assert_fail
("!ExprEvalContexts.empty() && \"Must be in an expression evaluation context\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9093, __extension__ __PRETTY_FUNCTION__))
9093 "Must be in an expression evaluation context")(static_cast <bool> (!ExprEvalContexts.empty() &&
"Must be in an expression evaluation context") ? void (0) : __assert_fail
("!ExprEvalContexts.empty() && \"Must be in an expression evaluation context\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9093, __extension__ __PRETTY_FUNCTION__))
;
9094 return ExprEvalContexts.back().isUnevaluated();
9095 }
9096
9097 /// RAII class used to determine whether SFINAE has
9098 /// trapped any errors that occur during template argument
9099 /// deduction.
9100 class SFINAETrap {
9101 Sema &SemaRef;
9102 unsigned PrevSFINAEErrors;
9103 bool PrevInNonInstantiationSFINAEContext;
9104 bool PrevAccessCheckingSFINAE;
9105 bool PrevLastDiagnosticIgnored;
9106
9107 public:
9108 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
9109 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
9110 PrevInNonInstantiationSFINAEContext(
9111 SemaRef.InNonInstantiationSFINAEContext),
9112 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
9113 PrevLastDiagnosticIgnored(
9114 SemaRef.getDiagnostics().isLastDiagnosticIgnored())
9115 {
9116 if (!SemaRef.isSFINAEContext())
9117 SemaRef.InNonInstantiationSFINAEContext = true;
9118 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
9119 }
9120
9121 ~SFINAETrap() {
9122 SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
9123 SemaRef.InNonInstantiationSFINAEContext
9124 = PrevInNonInstantiationSFINAEContext;
9125 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
9126 SemaRef.getDiagnostics().setLastDiagnosticIgnored(
9127 PrevLastDiagnosticIgnored);
9128 }
9129
9130 /// Determine whether any SFINAE errors have been trapped.
9131 bool hasErrorOccurred() const {
9132 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
9133 }
9134 };
9135
9136 /// RAII class used to indicate that we are performing provisional
9137 /// semantic analysis to determine the validity of a construct, so
9138 /// typo-correction and diagnostics in the immediate context (not within
9139 /// implicitly-instantiated templates) should be suppressed.
9140 class TentativeAnalysisScope {
9141 Sema &SemaRef;
9142 // FIXME: Using a SFINAETrap for this is a hack.
9143 SFINAETrap Trap;
9144 bool PrevDisableTypoCorrection;
9145 public:
9146 explicit TentativeAnalysisScope(Sema &SemaRef)
9147 : SemaRef(SemaRef), Trap(SemaRef, true),
9148 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
9149 SemaRef.DisableTypoCorrection = true;
9150 }
9151 ~TentativeAnalysisScope() {
9152 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
9153 }
9154 };
9155
9156 /// The current instantiation scope used to store local
9157 /// variables.
9158 LocalInstantiationScope *CurrentInstantiationScope;
9159
9160 /// Tracks whether we are in a context where typo correction is
9161 /// disabled.
9162 bool DisableTypoCorrection;
9163
9164 /// The number of typos corrected by CorrectTypo.
9165 unsigned TyposCorrected;
9166
9167 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;
9168 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
9169
9170 /// A cache containing identifiers for which typo correction failed and
9171 /// their locations, so that repeated attempts to correct an identifier in a
9172 /// given location are ignored if typo correction already failed for it.
9173 IdentifierSourceLocations TypoCorrectionFailures;
9174
9175 /// Worker object for performing CFG-based warnings.
9176 sema::AnalysisBasedWarnings AnalysisWarnings;
9177 threadSafety::BeforeSet *ThreadSafetyDeclCache;
9178
9179 /// An entity for which implicit template instantiation is required.
9180 ///
9181 /// The source location associated with the declaration is the first place in
9182 /// the source code where the declaration was "used". It is not necessarily
9183 /// the point of instantiation (which will be either before or after the
9184 /// namespace-scope declaration that triggered this implicit instantiation),
9185 /// However, it is the location that diagnostics should generally refer to,
9186 /// because users will need to know what code triggered the instantiation.
9187 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
9188
9189 /// The queue of implicit template instantiations that are required
9190 /// but have not yet been performed.
9191 std::deque<PendingImplicitInstantiation> PendingInstantiations;
9192
9193 /// Queue of implicit template instantiations that cannot be performed
9194 /// eagerly.
9195 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations;
9196
9197 class GlobalEagerInstantiationScope {
9198 public:
9199 GlobalEagerInstantiationScope(Sema &S, bool Enabled)
9200 : S(S), Enabled(Enabled) {
9201 if (!Enabled) return;
9202
9203 SavedPendingInstantiations.swap(S.PendingInstantiations);
9204 SavedVTableUses.swap(S.VTableUses);
9205 }
9206
9207 void perform() {
9208 if (Enabled) {
9209 S.DefineUsedVTables();
9210 S.PerformPendingInstantiations();
9211 }
9212 }
9213
9214 ~GlobalEagerInstantiationScope() {
9215 if (!Enabled) return;
9216
9217 // Restore the set of pending vtables.
9218 assert(S.VTableUses.empty() &&(static_cast <bool> (S.VTableUses.empty() && "VTableUses should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.VTableUses.empty() && \"VTableUses should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9219, __extension__ __PRETTY_FUNCTION__))
9219 "VTableUses should be empty before it is discarded.")(static_cast <bool> (S.VTableUses.empty() && "VTableUses should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.VTableUses.empty() && \"VTableUses should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9219, __extension__ __PRETTY_FUNCTION__))
;
9220 S.VTableUses.swap(SavedVTableUses);
9221
9222 // Restore the set of pending implicit instantiations.
9223 if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) {
9224 assert(S.PendingInstantiations.empty() &&(static_cast <bool> (S.PendingInstantiations.empty() &&
"PendingInstantiations should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.PendingInstantiations.empty() && \"PendingInstantiations should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9225, __extension__ __PRETTY_FUNCTION__))
9225 "PendingInstantiations should be empty before it is discarded.")(static_cast <bool> (S.PendingInstantiations.empty() &&
"PendingInstantiations should be empty before it is discarded."
) ? void (0) : __assert_fail ("S.PendingInstantiations.empty() && \"PendingInstantiations should be empty before it is discarded.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9225, __extension__ __PRETTY_FUNCTION__))
;
9226 S.PendingInstantiations.swap(SavedPendingInstantiations);
9227 } else {
9228 // Template instantiations in the PCH may be delayed until the TU.
9229 S.PendingInstantiations.swap(SavedPendingInstantiations);
9230 S.PendingInstantiations.insert(S.PendingInstantiations.end(),
9231 SavedPendingInstantiations.begin(),
9232 SavedPendingInstantiations.end());
9233 }
9234 }
9235
9236 private:
9237 Sema &S;
9238 SmallVector<VTableUse, 16> SavedVTableUses;
9239 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
9240 bool Enabled;
9241 };
9242
9243 /// The queue of implicit template instantiations that are required
9244 /// and must be performed within the current local scope.
9245 ///
9246 /// This queue is only used for member functions of local classes in
9247 /// templates, which must be instantiated in the same scope as their
9248 /// enclosing function, so that they can reference function-local
9249 /// types, static variables, enumerators, etc.
9250 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
9251
9252 class LocalEagerInstantiationScope {
9253 public:
9254 LocalEagerInstantiationScope(Sema &S) : S(S) {
9255 SavedPendingLocalImplicitInstantiations.swap(
9256 S.PendingLocalImplicitInstantiations);
9257 }
9258
9259 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }
9260
9261 ~LocalEagerInstantiationScope() {
9262 assert(S.PendingLocalImplicitInstantiations.empty() &&(static_cast <bool> (S.PendingLocalImplicitInstantiations
.empty() && "there shouldn't be any pending local implicit instantiations"
) ? void (0) : __assert_fail ("S.PendingLocalImplicitInstantiations.empty() && \"there shouldn't be any pending local implicit instantiations\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9263, __extension__ __PRETTY_FUNCTION__))
9263 "there shouldn't be any pending local implicit instantiations")(static_cast <bool> (S.PendingLocalImplicitInstantiations
.empty() && "there shouldn't be any pending local implicit instantiations"
) ? void (0) : __assert_fail ("S.PendingLocalImplicitInstantiations.empty() && \"there shouldn't be any pending local implicit instantiations\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9263, __extension__ __PRETTY_FUNCTION__))
;
9264 SavedPendingLocalImplicitInstantiations.swap(
9265 S.PendingLocalImplicitInstantiations);
9266 }
9267
9268 private:
9269 Sema &S;
9270 std::deque<PendingImplicitInstantiation>
9271 SavedPendingLocalImplicitInstantiations;
9272 };
9273
9274 /// A helper class for building up ExtParameterInfos.
9275 class ExtParameterInfoBuilder {
9276 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos;
9277 bool HasInteresting = false;
9278
9279 public:
9280 /// Set the ExtParameterInfo for the parameter at the given index,
9281 ///
9282 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
9283 assert(Infos.size() <= index)(static_cast <bool> (Infos.size() <= index) ? void (
0) : __assert_fail ("Infos.size() <= index", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 9283, __extension__ __PRETTY_FUNCTION__))
;
9284 Infos.resize(index);
9285 Infos.push_back(info);
9286
9287 if (!HasInteresting)
9288 HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
9289 }
9290
9291 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the
9292 /// ExtParameterInfo array we've built up.
9293 const FunctionProtoType::ExtParameterInfo *
9294 getPointerOrNull(unsigned numParams) {
9295 if (!HasInteresting) return nullptr;
9296 Infos.resize(numParams);
9297 return Infos.data();
9298 }
9299 };
9300
9301 void PerformPendingInstantiations(bool LocalOnly = false);
9302
9303 TypeSourceInfo *SubstType(TypeSourceInfo *T,
9304 const MultiLevelTemplateArgumentList &TemplateArgs,
9305 SourceLocation Loc, DeclarationName Entity,
9306 bool AllowDeducedTST = false);
9307
9308 QualType SubstType(QualType T,
9309 const MultiLevelTemplateArgumentList &TemplateArgs,
9310 SourceLocation Loc, DeclarationName Entity);
9311
9312 TypeSourceInfo *SubstType(TypeLoc TL,
9313 const MultiLevelTemplateArgumentList &TemplateArgs,
9314 SourceLocation Loc, DeclarationName Entity);
9315
9316 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
9317 const MultiLevelTemplateArgumentList &TemplateArgs,
9318 SourceLocation Loc,
9319 DeclarationName Entity,
9320 CXXRecordDecl *ThisContext,
9321 Qualifiers ThisTypeQuals);
9322 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
9323 const MultiLevelTemplateArgumentList &Args);
9324 bool SubstExceptionSpec(SourceLocation Loc,
9325 FunctionProtoType::ExceptionSpecInfo &ESI,
9326 SmallVectorImpl<QualType> &ExceptionStorage,
9327 const MultiLevelTemplateArgumentList &Args);
9328 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
9329 const MultiLevelTemplateArgumentList &TemplateArgs,
9330 int indexAdjustment,
9331 Optional<unsigned> NumExpansions,
9332 bool ExpectParameterPack);
9333 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
9334 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
9335 const MultiLevelTemplateArgumentList &TemplateArgs,
9336 SmallVectorImpl<QualType> &ParamTypes,
9337 SmallVectorImpl<ParmVarDecl *> *OutParams,
9338 ExtParameterInfoBuilder &ParamInfos);
9339 ExprResult SubstExpr(Expr *E,
9340 const MultiLevelTemplateArgumentList &TemplateArgs);
9341
9342 /// Substitute the given template arguments into a list of
9343 /// expressions, expanding pack expansions if required.
9344 ///
9345 /// \param Exprs The list of expressions to substitute into.
9346 ///
9347 /// \param IsCall Whether this is some form of call, in which case
9348 /// default arguments will be dropped.
9349 ///
9350 /// \param TemplateArgs The set of template arguments to substitute.
9351 ///
9352 /// \param Outputs Will receive all of the substituted arguments.
9353 ///
9354 /// \returns true if an error occurred, false otherwise.
9355 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
9356 const MultiLevelTemplateArgumentList &TemplateArgs,
9357 SmallVectorImpl<Expr *> &Outputs);
9358
9359 StmtResult SubstStmt(Stmt *S,
9360 const MultiLevelTemplateArgumentList &TemplateArgs);
9361
9362 TemplateParameterList *
9363 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
9364 const MultiLevelTemplateArgumentList &TemplateArgs);
9365
9366 bool
9367 SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
9368 const MultiLevelTemplateArgumentList &TemplateArgs,
9369 TemplateArgumentListInfo &Outputs);
9370
9371
9372 Decl *SubstDecl(Decl *D, DeclContext *Owner,
9373 const MultiLevelTemplateArgumentList &TemplateArgs);
9374
9375 /// Substitute the name and return type of a defaulted 'operator<=>' to form
9376 /// an implicit 'operator=='.
9377 FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
9378 FunctionDecl *Spaceship);
9379
9380 ExprResult SubstInitializer(Expr *E,
9381 const MultiLevelTemplateArgumentList &TemplateArgs,
9382 bool CXXDirectInit);
9383
9384 bool
9385 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
9386 CXXRecordDecl *Pattern,
9387 const MultiLevelTemplateArgumentList &TemplateArgs);
9388
9389 bool
9390 InstantiateClass(SourceLocation PointOfInstantiation,
9391 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
9392 const MultiLevelTemplateArgumentList &TemplateArgs,
9393 TemplateSpecializationKind TSK,
9394 bool Complain = true);
9395
9396 bool InstantiateEnum(SourceLocation PointOfInstantiation,
9397 EnumDecl *Instantiation, EnumDecl *Pattern,
9398 const MultiLevelTemplateArgumentList &TemplateArgs,
9399 TemplateSpecializationKind TSK);
9400
9401 bool InstantiateInClassInitializer(
9402 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
9403 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
9404
9405 struct LateInstantiatedAttribute {
9406 const Attr *TmplAttr;
9407 LocalInstantiationScope *Scope;
9408 Decl *NewDecl;
9409
9410 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,
9411 Decl *D)
9412 : TmplAttr(A), Scope(S), NewDecl(D)
9413 { }
9414 };
9415 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;
9416
9417 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
9418 const Decl *Pattern, Decl *Inst,
9419 LateInstantiatedAttrVec *LateAttrs = nullptr,
9420 LocalInstantiationScope *OuterMostScope = nullptr);
9421
9422 void
9423 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
9424 const Decl *Pattern, Decl *Inst,
9425 LateInstantiatedAttrVec *LateAttrs = nullptr,
9426 LocalInstantiationScope *OuterMostScope = nullptr);
9427
9428 void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);
9429
9430 bool usesPartialOrExplicitSpecialization(
9431 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
9432
9433 bool
9434 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
9435 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9436 TemplateSpecializationKind TSK,
9437 bool Complain = true);
9438
9439 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
9440 CXXRecordDecl *Instantiation,
9441 const MultiLevelTemplateArgumentList &TemplateArgs,
9442 TemplateSpecializationKind TSK);
9443
9444 void InstantiateClassTemplateSpecializationMembers(
9445 SourceLocation PointOfInstantiation,
9446 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9447 TemplateSpecializationKind TSK);
9448
9449 NestedNameSpecifierLoc
9450 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
9451 const MultiLevelTemplateArgumentList &TemplateArgs);
9452
9453 DeclarationNameInfo
9454 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
9455 const MultiLevelTemplateArgumentList &TemplateArgs);
9456 TemplateName
9457 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
9458 SourceLocation Loc,
9459 const MultiLevelTemplateArgumentList &TemplateArgs);
9460 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
9461 TemplateArgumentListInfo &Result,
9462 const MultiLevelTemplateArgumentList &TemplateArgs);
9463
9464 bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
9465 ParmVarDecl *Param);
9466 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
9467 FunctionDecl *Function);
9468 bool CheckInstantiatedFunctionTemplateConstraints(
9469 SourceLocation PointOfInstantiation, FunctionDecl *Decl,
9470 ArrayRef<TemplateArgument> TemplateArgs,
9471 ConstraintSatisfaction &Satisfaction);
9472 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
9473 const TemplateArgumentList *Args,
9474 SourceLocation Loc);
9475 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
9476 FunctionDecl *Function,
9477 bool Recursive = false,
9478 bool DefinitionRequired = false,
9479 bool AtEndOfTU = false);
9480 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
9481 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
9482 const TemplateArgumentList &TemplateArgList,
9483 const TemplateArgumentListInfo &TemplateArgsInfo,
9484 SmallVectorImpl<TemplateArgument> &Converted,
9485 SourceLocation PointOfInstantiation,
9486 LateInstantiatedAttrVec *LateAttrs = nullptr,
9487 LocalInstantiationScope *StartingScope = nullptr);
9488 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
9489 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
9490 const MultiLevelTemplateArgumentList &TemplateArgs);
9491 void
9492 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
9493 const MultiLevelTemplateArgumentList &TemplateArgs,
9494 LateInstantiatedAttrVec *LateAttrs,
9495 DeclContext *Owner,
9496 LocalInstantiationScope *StartingScope,
9497 bool InstantiatingVarTemplate = false,
9498 VarTemplateSpecializationDecl *PrevVTSD = nullptr);
9499
9500 void InstantiateVariableInitializer(
9501 VarDecl *Var, VarDecl *OldVar,
9502 const MultiLevelTemplateArgumentList &TemplateArgs);
9503 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
9504 VarDecl *Var, bool Recursive = false,
9505 bool DefinitionRequired = false,
9506 bool AtEndOfTU = false);
9507
9508 void InstantiateMemInitializers(CXXConstructorDecl *New,
9509 const CXXConstructorDecl *Tmpl,
9510 const MultiLevelTemplateArgumentList &TemplateArgs);
9511
9512 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
9513 const MultiLevelTemplateArgumentList &TemplateArgs,
9514 bool FindingInstantiatedContext = false);
9515 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
9516 const MultiLevelTemplateArgumentList &TemplateArgs);
9517
9518 // Objective-C declarations.
9519 enum ObjCContainerKind {
9520 OCK_None = -1,
9521 OCK_Interface = 0,
9522 OCK_Protocol,
9523 OCK_Category,
9524 OCK_ClassExtension,
9525 OCK_Implementation,
9526 OCK_CategoryImplementation
9527 };
9528 ObjCContainerKind getObjCContainerKind() const;
9529
9530 DeclResult actOnObjCTypeParam(Scope *S,
9531 ObjCTypeParamVariance variance,
9532 SourceLocation varianceLoc,
9533 unsigned index,
9534 IdentifierInfo *paramName,
9535 SourceLocation paramLoc,
9536 SourceLocation colonLoc,
9537 ParsedType typeBound);
9538
9539 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,
9540 ArrayRef<Decl *> typeParams,
9541 SourceLocation rAngleLoc);
9542 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);
9543
9544 Decl *ActOnStartClassInterface(
9545 Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9546 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9547 IdentifierInfo *SuperName, SourceLocation SuperLoc,
9548 ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,
9549 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9550 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9551 const ParsedAttributesView &AttrList);
9552
9553 void ActOnSuperClassOfClassInterface(Scope *S,
9554 SourceLocation AtInterfaceLoc,
9555 ObjCInterfaceDecl *IDecl,
9556 IdentifierInfo *ClassName,
9557 SourceLocation ClassLoc,
9558 IdentifierInfo *SuperName,
9559 SourceLocation SuperLoc,
9560 ArrayRef<ParsedType> SuperTypeArgs,
9561 SourceRange SuperTypeArgsRange);
9562
9563 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
9564 SmallVectorImpl<SourceLocation> &ProtocolLocs,
9565 IdentifierInfo *SuperName,
9566 SourceLocation SuperLoc);
9567
9568 Decl *ActOnCompatibilityAlias(
9569 SourceLocation AtCompatibilityAliasLoc,
9570 IdentifierInfo *AliasName, SourceLocation AliasLocation,
9571 IdentifierInfo *ClassName, SourceLocation ClassLocation);
9572
9573 bool CheckForwardProtocolDeclarationForCircularDependency(
9574 IdentifierInfo *PName,
9575 SourceLocation &PLoc, SourceLocation PrevLoc,
9576 const ObjCList<ObjCProtocolDecl> &PList);
9577
9578 Decl *ActOnStartProtocolInterface(
9579 SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,
9580 SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,
9581 unsigned NumProtoRefs, const SourceLocation *ProtoLocs,
9582 SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);
9583
9584 Decl *ActOnStartCategoryInterface(
9585 SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9586 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9587 IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
9588 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9589 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9590 const ParsedAttributesView &AttrList);
9591
9592 Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,
9593 IdentifierInfo *ClassName,
9594 SourceLocation ClassLoc,
9595 IdentifierInfo *SuperClassname,
9596 SourceLocation SuperClassLoc,
9597 const ParsedAttributesView &AttrList);
9598
9599 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
9600 IdentifierInfo *ClassName,
9601 SourceLocation ClassLoc,
9602 IdentifierInfo *CatName,
9603 SourceLocation CatLoc,
9604 const ParsedAttributesView &AttrList);
9605
9606 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
9607 ArrayRef<Decl *> Decls);
9608
9609 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
9610 IdentifierInfo **IdentList,
9611 SourceLocation *IdentLocs,
9612 ArrayRef<ObjCTypeParamList *> TypeParamLists,
9613 unsigned NumElts);
9614
9615 DeclGroupPtrTy
9616 ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
9617 ArrayRef<IdentifierLocPair> IdentList,
9618 const ParsedAttributesView &attrList);
9619
9620 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
9621 ArrayRef<IdentifierLocPair> ProtocolId,
9622 SmallVectorImpl<Decl *> &Protocols);
9623
9624 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
9625 SourceLocation ProtocolLoc,
9626 IdentifierInfo *TypeArgId,
9627 SourceLocation TypeArgLoc,
9628 bool SelectProtocolFirst = false);
9629
9630 /// Given a list of identifiers (and their locations), resolve the
9631 /// names to either Objective-C protocol qualifiers or type
9632 /// arguments, as appropriate.
9633 void actOnObjCTypeArgsOrProtocolQualifiers(
9634 Scope *S,
9635 ParsedType baseType,
9636 SourceLocation lAngleLoc,
9637 ArrayRef<IdentifierInfo *> identifiers,
9638 ArrayRef<SourceLocation> identifierLocs,
9639 SourceLocation rAngleLoc,
9640 SourceLocation &typeArgsLAngleLoc,
9641 SmallVectorImpl<ParsedType> &typeArgs,
9642 SourceLocation &typeArgsRAngleLoc,
9643 SourceLocation &protocolLAngleLoc,
9644 SmallVectorImpl<Decl *> &protocols,
9645 SourceLocation &protocolRAngleLoc,
9646 bool warnOnIncompleteProtocols);
9647
9648 /// Build a an Objective-C protocol-qualified 'id' type where no
9649 /// base type was specified.
9650 TypeResult actOnObjCProtocolQualifierType(
9651 SourceLocation lAngleLoc,
9652 ArrayRef<Decl *> protocols,
9653 ArrayRef<SourceLocation> protocolLocs,
9654 SourceLocation rAngleLoc);
9655
9656 /// Build a specialized and/or protocol-qualified Objective-C type.
9657 TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
9658 Scope *S,
9659 SourceLocation Loc,
9660 ParsedType BaseType,
9661 SourceLocation TypeArgsLAngleLoc,
9662 ArrayRef<ParsedType> TypeArgs,
9663 SourceLocation TypeArgsRAngleLoc,
9664 SourceLocation ProtocolLAngleLoc,
9665 ArrayRef<Decl *> Protocols,
9666 ArrayRef<SourceLocation> ProtocolLocs,
9667 SourceLocation ProtocolRAngleLoc);
9668
9669 /// Build an Objective-C type parameter type.
9670 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
9671 SourceLocation ProtocolLAngleLoc,
9672 ArrayRef<ObjCProtocolDecl *> Protocols,
9673 ArrayRef<SourceLocation> ProtocolLocs,
9674 SourceLocation ProtocolRAngleLoc,
9675 bool FailOnError = false);
9676
9677 /// Build an Objective-C object pointer type.
9678 QualType BuildObjCObjectType(QualType BaseType,
9679 SourceLocation Loc,
9680 SourceLocation TypeArgsLAngleLoc,
9681 ArrayRef<TypeSourceInfo *> TypeArgs,
9682 SourceLocation TypeArgsRAngleLoc,
9683 SourceLocation ProtocolLAngleLoc,
9684 ArrayRef<ObjCProtocolDecl *> Protocols,
9685 ArrayRef<SourceLocation> ProtocolLocs,
9686 SourceLocation ProtocolRAngleLoc,
9687 bool FailOnError = false);
9688
9689 /// Ensure attributes are consistent with type.
9690 /// \param [in, out] Attributes The attributes to check; they will
9691 /// be modified to be consistent with \p PropertyTy.
9692 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
9693 SourceLocation Loc,
9694 unsigned &Attributes,
9695 bool propertyInPrimaryClass);
9696
9697 /// Process the specified property declaration and create decls for the
9698 /// setters and getters as needed.
9699 /// \param property The property declaration being processed
9700 void ProcessPropertyDecl(ObjCPropertyDecl *property);
9701
9702
9703 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
9704 ObjCPropertyDecl *SuperProperty,
9705 const IdentifierInfo *Name,
9706 bool OverridingProtocolProperty);
9707
9708 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
9709 ObjCInterfaceDecl *ID);
9710
9711 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,
9712 ArrayRef<Decl *> allMethods = None,
9713 ArrayRef<DeclGroupPtrTy> allTUVars = None);
9714
9715 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
9716 SourceLocation LParenLoc,
9717 FieldDeclarator &FD, ObjCDeclSpec &ODS,
9718 Selector GetterSel, Selector SetterSel,
9719 tok::ObjCKeywordKind MethodImplKind,
9720 DeclContext *lexicalDC = nullptr);
9721
9722 Decl *ActOnPropertyImplDecl(Scope *S,
9723 SourceLocation AtLoc,
9724 SourceLocation PropertyLoc,
9725 bool ImplKind,
9726 IdentifierInfo *PropertyId,
9727 IdentifierInfo *PropertyIvar,
9728 SourceLocation PropertyIvarLoc,
9729 ObjCPropertyQueryKind QueryKind);
9730
9731 enum ObjCSpecialMethodKind {
9732 OSMK_None,
9733 OSMK_Alloc,
9734 OSMK_New,
9735 OSMK_Copy,
9736 OSMK_RetainingInit,
9737 OSMK_NonRetainingInit
9738 };
9739
9740 struct ObjCArgInfo {
9741 IdentifierInfo *Name;
9742 SourceLocation NameLoc;
9743 // The Type is null if no type was specified, and the DeclSpec is invalid
9744 // in this case.
9745 ParsedType Type;
9746 ObjCDeclSpec DeclSpec;
9747
9748 /// ArgAttrs - Attribute list for this argument.
9749 ParsedAttributesView ArgAttrs;
9750 };
9751
9752 Decl *ActOnMethodDeclaration(
9753 Scope *S,
9754 SourceLocation BeginLoc, // location of the + or -.
9755 SourceLocation EndLoc, // location of the ; or {.
9756 tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
9757 ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
9758 // optional arguments. The number of types/arguments is obtained
9759 // from the Sel.getNumArgs().
9760 ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,
9761 unsigned CNumArgs, // c-style args
9762 const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,
9763 bool isVariadic, bool MethodDefinition);
9764
9765 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
9766 const ObjCObjectPointerType *OPT,
9767 bool IsInstance);
9768 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
9769 bool IsInstance);
9770
9771 bool CheckARCMethodDecl(ObjCMethodDecl *method);
9772 bool inferObjCARCLifetime(ValueDecl *decl);
9773
9774 void deduceOpenCLAddressSpace(ValueDecl *decl);
9775
9776 ExprResult
9777 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
9778 Expr *BaseExpr,
9779 SourceLocation OpLoc,
9780 DeclarationName MemberName,
9781 SourceLocation MemberLoc,
9782 SourceLocation SuperLoc, QualType SuperType,
9783 bool Super);
9784
9785 ExprResult
9786 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
9787 IdentifierInfo &propertyName,
9788 SourceLocation receiverNameLoc,
9789 SourceLocation propertyNameLoc);
9790
9791 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
9792
9793 /// Describes the kind of message expression indicated by a message
9794 /// send that starts with an identifier.
9795 enum ObjCMessageKind {
9796 /// The message is sent to 'super'.
9797 ObjCSuperMessage,
9798 /// The message is an instance message.
9799 ObjCInstanceMessage,
9800 /// The message is a class message, and the identifier is a type
9801 /// name.
9802 ObjCClassMessage
9803 };
9804
9805 ObjCMessageKind getObjCMessageKind(Scope *S,
9806 IdentifierInfo *Name,
9807 SourceLocation NameLoc,
9808 bool IsSuper,
9809 bool HasTrailingDot,
9810 ParsedType &ReceiverType);
9811
9812 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
9813 Selector Sel,
9814 SourceLocation LBracLoc,
9815 ArrayRef<SourceLocation> SelectorLocs,
9816 SourceLocation RBracLoc,
9817 MultiExprArg Args);
9818
9819 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
9820 QualType ReceiverType,
9821 SourceLocation SuperLoc,
9822 Selector Sel,
9823 ObjCMethodDecl *Method,
9824 SourceLocation LBracLoc,
9825 ArrayRef<SourceLocation> SelectorLocs,
9826 SourceLocation RBracLoc,
9827 MultiExprArg Args,
9828 bool isImplicit = false);
9829
9830 ExprResult BuildClassMessageImplicit(QualType ReceiverType,
9831 bool isSuperReceiver,
9832 SourceLocation Loc,
9833 Selector Sel,
9834 ObjCMethodDecl *Method,
9835 MultiExprArg Args);
9836
9837 ExprResult ActOnClassMessage(Scope *S,
9838 ParsedType Receiver,
9839 Selector Sel,
9840 SourceLocation LBracLoc,
9841 ArrayRef<SourceLocation> SelectorLocs,
9842 SourceLocation RBracLoc,
9843 MultiExprArg Args);
9844
9845 ExprResult BuildInstanceMessage(Expr *Receiver,
9846 QualType ReceiverType,
9847 SourceLocation SuperLoc,
9848 Selector Sel,
9849 ObjCMethodDecl *Method,
9850 SourceLocation LBracLoc,
9851 ArrayRef<SourceLocation> SelectorLocs,
9852 SourceLocation RBracLoc,
9853 MultiExprArg Args,
9854 bool isImplicit = false);
9855
9856 ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
9857 QualType ReceiverType,
9858 SourceLocation Loc,
9859 Selector Sel,
9860 ObjCMethodDecl *Method,
9861 MultiExprArg Args);
9862
9863 ExprResult ActOnInstanceMessage(Scope *S,
9864 Expr *Receiver,
9865 Selector Sel,
9866 SourceLocation LBracLoc,
9867 ArrayRef<SourceLocation> SelectorLocs,
9868 SourceLocation RBracLoc,
9869 MultiExprArg Args);
9870
9871 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
9872 ObjCBridgeCastKind Kind,
9873 SourceLocation BridgeKeywordLoc,
9874 TypeSourceInfo *TSInfo,
9875 Expr *SubExpr);
9876
9877 ExprResult ActOnObjCBridgedCast(Scope *S,
9878 SourceLocation LParenLoc,
9879 ObjCBridgeCastKind Kind,
9880 SourceLocation BridgeKeywordLoc,
9881 ParsedType Type,
9882 SourceLocation RParenLoc,
9883 Expr *SubExpr);
9884
9885 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
9886
9887 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
9888
9889 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
9890 CastKind &Kind);
9891
9892 bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
9893 QualType DestType, QualType SrcType,
9894 ObjCInterfaceDecl *&RelatedClass,
9895 ObjCMethodDecl *&ClassMethod,
9896 ObjCMethodDecl *&InstanceMethod,
9897 TypedefNameDecl *&TDNDecl,
9898 bool CfToNs, bool Diagnose = true);
9899
9900 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
9901 QualType DestType, QualType SrcType,
9902 Expr *&SrcExpr, bool Diagnose = true);
9903
9904 bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,
9905 bool Diagnose = true);
9906
9907 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
9908
9909 /// Check whether the given new method is a valid override of the
9910 /// given overridden method, and set any properties that should be inherited.
9911 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
9912 const ObjCMethodDecl *Overridden);
9913
9914 /// Describes the compatibility of a result type with its method.
9915 enum ResultTypeCompatibilityKind {
9916 RTC_Compatible,
9917 RTC_Incompatible,
9918 RTC_Unknown
9919 };
9920
9921 void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,
9922 ObjCMethodDecl *overridden);
9923
9924 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
9925 ObjCInterfaceDecl *CurrentClass,
9926 ResultTypeCompatibilityKind RTC);
9927
9928 enum PragmaOptionsAlignKind {
9929 POAK_Native, // #pragma options align=native
9930 POAK_Natural, // #pragma options align=natural
9931 POAK_Packed, // #pragma options align=packed
9932 POAK_Power, // #pragma options align=power
9933 POAK_Mac68k, // #pragma options align=mac68k
9934 POAK_Reset // #pragma options align=reset
9935 };
9936
9937 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section
9938 void ActOnPragmaClangSection(SourceLocation PragmaLoc,
9939 PragmaClangSectionAction Action,
9940 PragmaClangSectionKind SecKind, StringRef SecName);
9941
9942 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
9943 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
9944 SourceLocation PragmaLoc);
9945
9946 /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
9947 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
9948 StringRef SlotLabel, Expr *Alignment);
9949
9950 enum class PragmaAlignPackDiagnoseKind {
9951 NonDefaultStateAtInclude,
9952 ChangedStateAtExit
9953 };
9954
9955 void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
9956 SourceLocation IncludeLoc);
9957 void DiagnoseUnterminatedPragmaAlignPack();
9958
9959 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off].
9960 void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
9961
9962 /// ActOnPragmaMSComment - Called on well formed
9963 /// \#pragma comment(kind, "arg").
9964 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
9965 StringRef Arg);
9966
9967 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
9968 /// pointers_to_members(representation method[, general purpose
9969 /// representation]).
9970 void ActOnPragmaMSPointersToMembers(
9971 LangOptions::PragmaMSPointersToMembersKind Kind,
9972 SourceLocation PragmaLoc);
9973
9974 /// Called on well formed \#pragma vtordisp().
9975 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
9976 SourceLocation PragmaLoc,
9977 MSVtorDispMode Value);
9978
9979 enum PragmaSectionKind {
9980 PSK_DataSeg,
9981 PSK_BSSSeg,
9982 PSK_ConstSeg,
9983 PSK_CodeSeg,
9984 };
9985
9986 bool UnifySection(StringRef SectionName, int SectionFlags,
9987 NamedDecl *TheDecl);
9988 bool UnifySection(StringRef SectionName,
9989 int SectionFlags,
9990 SourceLocation PragmaSectionLocation);
9991
9992 /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
9993 void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
9994 PragmaMsStackAction Action,
9995 llvm::StringRef StackSlotLabel,
9996 StringLiteral *SegmentName,
9997 llvm::StringRef PragmaName);
9998
9999 /// Called on well formed \#pragma section().
10000 void ActOnPragmaMSSection(SourceLocation PragmaLocation,
10001 int SectionFlags, StringLiteral *SegmentName);
10002
10003 /// Called on well-formed \#pragma init_seg().
10004 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
10005 StringLiteral *SegmentName);
10006
10007 /// Called on #pragma clang __debug dump II
10008 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
10009
10010 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
10011 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
10012 StringRef Value);
10013
10014 /// Are precise floating point semantics currently enabled?
10015 bool isPreciseFPEnabled() {
10016 return !CurFPFeatures.getAllowFPReassociate() &&
10017 !CurFPFeatures.getNoSignedZero() &&
10018 !CurFPFeatures.getAllowReciprocal() &&
10019 !CurFPFeatures.getAllowApproxFunc();
10020 }
10021
10022 /// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control
10023 void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,
10024 PragmaFloatControlKind Value);
10025
10026 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
10027 void ActOnPragmaUnused(const Token &Identifier,
10028 Scope *curScope,
10029 SourceLocation PragmaLoc);
10030
10031 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
10032 void ActOnPragmaVisibility(const IdentifierInfo* VisType,
10033 SourceLocation PragmaLoc);
10034
10035 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
10036 SourceLocation Loc);
10037 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
10038
10039 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
10040 void ActOnPragmaWeakID(IdentifierInfo* WeakName,
10041 SourceLocation PragmaLoc,
10042 SourceLocation WeakNameLoc);
10043
10044 /// ActOnPragmaRedefineExtname - Called on well formed
10045 /// \#pragma redefine_extname oldname newname.
10046 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
10047 IdentifierInfo* AliasName,
10048 SourceLocation PragmaLoc,
10049 SourceLocation WeakNameLoc,
10050 SourceLocation AliasNameLoc);
10051
10052 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
10053 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
10054 IdentifierInfo* AliasName,
10055 SourceLocation PragmaLoc,
10056 SourceLocation WeakNameLoc,
10057 SourceLocation AliasNameLoc);
10058
10059 /// ActOnPragmaFPContract - Called on well formed
10060 /// \#pragma {STDC,OPENCL} FP_CONTRACT and
10061 /// \#pragma clang fp contract
10062 void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);
10063
10064 /// Called on well formed
10065 /// \#pragma clang fp reassociate
10066 void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);
10067
10068 /// ActOnPragmaFenvAccess - Called on well formed
10069 /// \#pragma STDC FENV_ACCESS
10070 void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);
10071
10072 /// Called on well formed '\#pragma clang fp' that has option 'exceptions'.
10073 void ActOnPragmaFPExceptions(SourceLocation Loc,
10074 LangOptions::FPExceptionModeKind);
10075
10076 /// Called to set constant rounding mode for floating point operations.
10077 void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);
10078
10079 /// Called to set exception behavior for floating point operations.
10080 void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);
10081
10082 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
10083 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
10084 void AddAlignmentAttributesForRecord(RecordDecl *RD);
10085
10086 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
10087 void AddMsStructLayoutForRecord(RecordDecl *RD);
10088
10089 /// PushNamespaceVisibilityAttr - Note that we've entered a
10090 /// namespace with a visibility attribute.
10091 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
10092 SourceLocation Loc);
10093
10094 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
10095 /// add an appropriate visibility attribute.
10096 void AddPushedVisibilityAttribute(Decl *RD);
10097
10098 /// PopPragmaVisibility - Pop the top element of the visibility stack; used
10099 /// for '\#pragma GCC visibility' and visibility attributes on namespaces.
10100 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
10101
10102 /// FreeVisContext - Deallocate and null out VisContext.
10103 void FreeVisContext();
10104
10105 /// AddCFAuditedAttribute - Check whether we're currently within
10106 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
10107 /// the appropriate attribute.
10108 void AddCFAuditedAttribute(Decl *D);
10109
10110 void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,
10111 SourceLocation PragmaLoc,
10112 attr::ParsedSubjectMatchRuleSet Rules);
10113 void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
10114 const IdentifierInfo *Namespace);
10115
10116 /// Called on well-formed '\#pragma clang attribute pop'.
10117 void ActOnPragmaAttributePop(SourceLocation PragmaLoc,
10118 const IdentifierInfo *Namespace);
10119
10120 /// Adds the attributes that have been specified using the
10121 /// '\#pragma clang attribute push' directives to the given declaration.
10122 void AddPragmaAttributes(Scope *S, Decl *D);
10123
10124 void DiagnoseUnterminatedPragmaAttribute();
10125
10126 /// Called on well formed \#pragma clang optimize.
10127 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
10128
10129 /// Get the location for the currently active "\#pragma clang optimize
10130 /// off". If this location is invalid, then the state of the pragma is "on".
10131 SourceLocation getOptimizeOffPragmaLocation() const {
10132 return OptimizeOffPragmaLocation;
10133 }
10134
10135 /// Only called on function definitions; if there is a pragma in scope
10136 /// with the effect of a range-based optnone, consider marking the function
10137 /// with attribute optnone.
10138 void AddRangeBasedOptnone(FunctionDecl *FD);
10139
10140 /// Adds the 'optnone' attribute to the function declaration if there
10141 /// are no conflicts; Loc represents the location causing the 'optnone'
10142 /// attribute to be added (usually because of a pragma).
10143 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
10144
10145 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
10146 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10147 bool IsPackExpansion);
10148 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,
10149 bool IsPackExpansion);
10150
10151 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
10152 /// declaration.
10153 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10154 Expr *OE);
10155
10156 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
10157 /// declaration.
10158 void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
10159 Expr *ParamExpr);
10160
10161 /// AddAlignValueAttr - Adds an align_value attribute to a particular
10162 /// declaration.
10163 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
10164
10165 /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
10166 void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
10167 StringRef Annot, MutableArrayRef<Expr *> Args);
10168
10169 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
10170 /// declaration.
10171 void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
10172 Expr *MaxThreads, Expr *MinBlocks);
10173
10174 /// AddModeAttr - Adds a mode attribute to a particular declaration.
10175 void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,
10176 bool InInstantiation = false);
10177
10178 void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
10179 ParameterABI ABI);
10180
10181 enum class RetainOwnershipKind {NS, CF, OS};
10182 void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,
10183 RetainOwnershipKind K, bool IsTemplateInstantiation);
10184
10185 /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size
10186 /// attribute to a particular declaration.
10187 void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,
10188 Expr *Min, Expr *Max);
10189
10190 /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a
10191 /// particular declaration.
10192 void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,
10193 Expr *Min, Expr *Max);
10194
10195 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
10196
10197 //===--------------------------------------------------------------------===//
10198 // C++ Coroutines TS
10199 //
10200 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
10201 StringRef Keyword);
10202 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10203 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10204 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
10205
10206 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10207 bool IsImplicit = false);
10208 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10209 UnresolvedLookupExpr* Lookup);
10210 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
10211 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
10212 bool IsImplicit = false);
10213 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
10214 bool buildCoroutineParameterMoves(SourceLocation Loc);
10215 VarDecl *buildCoroutinePromise(SourceLocation Loc);
10216 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
10217 ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
10218 SourceLocation FuncLoc);
10219 /// Check that the expression co_await promise.final_suspend() shall not be
10220 /// potentially-throwing.
10221 bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
10222
10223 //===--------------------------------------------------------------------===//
10224 // OpenMP directives and clauses.
10225 //
10226private:
10227 void *VarDataSharingAttributesStack;
10228
10229 struct DeclareTargetContextInfo {
10230 struct MapInfo {
10231 OMPDeclareTargetDeclAttr::MapTypeTy MT;
10232 SourceLocation Loc;
10233 };
10234 /// Explicitly listed variables and functions in a 'to' or 'link' clause.
10235 llvm::DenseMap<NamedDecl *, MapInfo> ExplicitlyMapped;
10236
10237 /// The 'device_type' as parsed from the clause.
10238 OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any;
10239
10240 /// The directive kind, `begin declare target` or `declare target`.
10241 OpenMPDirectiveKind Kind;
10242
10243 /// The directive location.
10244 SourceLocation Loc;
10245
10246 DeclareTargetContextInfo(OpenMPDirectiveKind Kind, SourceLocation Loc)
10247 : Kind(Kind), Loc(Loc) {}
10248 };
10249
10250 /// Number of nested '#pragma omp declare target' directives.
10251 SmallVector<DeclareTargetContextInfo, 4> DeclareTargetNesting;
10252
10253 /// Initialization of data-sharing attributes stack.
10254 void InitDataSharingAttributesStack();
10255 void DestroyDataSharingAttributesStack();
10256 ExprResult
10257 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
10258 bool StrictlyPositive = true,
10259 bool SuppressExprDiags = false);
10260 /// Returns OpenMP nesting level for current directive.
10261 unsigned getOpenMPNestingLevel() const;
10262
10263 /// Adjusts the function scopes index for the target-based regions.
10264 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
10265 unsigned Level) const;
10266
10267 /// Returns the number of scopes associated with the construct on the given
10268 /// OpenMP level.
10269 int getNumberOfConstructScopes(unsigned Level) const;
10270
10271 /// Push new OpenMP function region for non-capturing function.
10272 void pushOpenMPFunctionRegion();
10273
10274 /// Pop OpenMP function region for non-capturing function.
10275 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
10276
10277 /// Analyzes and checks a loop nest for use by a loop transformation.
10278 ///
10279 /// \param Kind The loop transformation directive kind.
10280 /// \param NumLoops How many nested loops the directive is expecting.
10281 /// \param AStmt Associated statement of the transformation directive.
10282 /// \param LoopHelpers [out] The loop analysis result.
10283 /// \param Body [out] The body code nested in \p NumLoops loop.
10284 /// \param OriginalInits [out] Collection of statements and declarations that
10285 /// must have been executed/declared before entering the
10286 /// loop.
10287 ///
10288 /// \return Whether there was any error.
10289 bool checkTransformableLoopNest(
10290 OpenMPDirectiveKind Kind, Stmt *AStmt, int NumLoops,
10291 SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
10292 Stmt *&Body,
10293 SmallVectorImpl<SmallVector<llvm::PointerUnion<Stmt *, Decl *>, 0>>
10294 &OriginalInits);
10295
10296 /// Helper to keep information about the current `omp begin/end declare
10297 /// variant` nesting.
10298 struct OMPDeclareVariantScope {
10299 /// The associated OpenMP context selector.
10300 OMPTraitInfo *TI;
10301
10302 /// The associated OpenMP context selector mangling.
10303 std::string NameSuffix;
10304
10305 OMPDeclareVariantScope(OMPTraitInfo &TI);
10306 };
10307
10308 /// Return the OMPTraitInfo for the surrounding scope, if any.
10309 OMPTraitInfo *getOMPTraitInfoForSurroundingScope() {
10310 return OMPDeclareVariantScopes.empty() ? nullptr
10311 : OMPDeclareVariantScopes.back().TI;
10312 }
10313
10314 /// The current `omp begin/end declare variant` scopes.
10315 SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes;
10316
10317 /// The current `omp begin/end assumes` scopes.
10318 SmallVector<AssumptionAttr *, 4> OMPAssumeScoped;
10319
10320 /// All `omp assumes` we encountered so far.
10321 SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal;
10322
10323public:
10324 /// The declarator \p D defines a function in the scope \p S which is nested
10325 /// in an `omp begin/end declare variant` scope. In this method we create a
10326 /// declaration for \p D and rename \p D according to the OpenMP context
10327 /// selector of the surrounding scope. Return all base functions in \p Bases.
10328 void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(
10329 Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists,
10330 SmallVectorImpl<FunctionDecl *> &Bases);
10331
10332 /// Register \p D as specialization of all base functions in \p Bases in the
10333 /// current `omp begin/end declare variant` scope.
10334 void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(
10335 Decl *D, SmallVectorImpl<FunctionDecl *> &Bases);
10336
10337 /// Act on \p D, a function definition inside of an `omp [begin/end] assumes`.
10338 void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D);
10339
10340 /// Can we exit an OpenMP declare variant scope at the moment.
10341 bool isInOpenMPDeclareVariantScope() const {
10342 return !OMPDeclareVariantScopes.empty();
10343 }
10344
10345 /// Given the potential call expression \p Call, determine if there is a
10346 /// specialization via the OpenMP declare variant mechanism available. If
10347 /// there is, return the specialized call expression, otherwise return the
10348 /// original \p Call.
10349 ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope,
10350 SourceLocation LParenLoc, MultiExprArg ArgExprs,
10351 SourceLocation RParenLoc, Expr *ExecConfig);
10352
10353 /// Handle a `omp begin declare variant`.
10354 void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI);
10355
10356 /// Handle a `omp end declare variant`.
10357 void ActOnOpenMPEndDeclareVariant();
10358
10359 /// Checks if the variant/multiversion functions are compatible.
10360 bool areMultiversionVariantFunctionsCompatible(
10361 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
10362 const PartialDiagnostic &NoProtoDiagID,
10363 const PartialDiagnosticAt &NoteCausedDiagIDAt,
10364 const PartialDiagnosticAt &NoSupportDiagIDAt,
10365 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,
10366 bool ConstexprSupported, bool CLinkageMayDiffer);
10367
10368 /// Function tries to capture lambda's captured variables in the OpenMP region
10369 /// before the original lambda is captured.
10370 void tryCaptureOpenMPLambdas(ValueDecl *V);
10371
10372 /// Return true if the provided declaration \a VD should be captured by
10373 /// reference.
10374 /// \param Level Relative level of nested OpenMP construct for that the check
10375 /// is performed.
10376 /// \param OpenMPCaptureLevel Capture level within an OpenMP construct.
10377 bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,
10378 unsigned OpenMPCaptureLevel) const;
10379
10380 /// Check if the specified variable is used in one of the private
10381 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
10382 /// constructs.
10383 VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false,
10384 unsigned StopAt = 0);
10385 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
10386 ExprObjectKind OK, SourceLocation Loc);
10387
10388 /// If the current region is a loop-based region, mark the start of the loop
10389 /// construct.
10390 void startOpenMPLoop();
10391
10392 /// If the current region is a range loop-based region, mark the start of the
10393 /// loop construct.
10394 void startOpenMPCXXRangeFor();
10395
10396 /// Check if the specified variable is used in 'private' clause.
10397 /// \param Level Relative level of nested OpenMP construct for that the check
10398 /// is performed.
10399 OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,
10400 unsigned CapLevel) const;
10401
10402 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
10403 /// for \p FD based on DSA for the provided corresponding captured declaration
10404 /// \p D.
10405 void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level);
10406
10407 /// Check if the specified variable is captured by 'target' directive.
10408 /// \param Level Relative level of nested OpenMP construct for that the check
10409 /// is performed.
10410 bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
10411 unsigned CaptureLevel) const;
10412
10413 /// Check if the specified global variable must be captured by outer capture
10414 /// regions.
10415 /// \param Level Relative level of nested OpenMP construct for that
10416 /// the check is performed.
10417 bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,
10418 unsigned CaptureLevel) const;
10419
10420 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
10421 Expr *Op);
10422 /// Called on start of new data sharing attribute block.
10423 void StartOpenMPDSABlock(OpenMPDirectiveKind K,
10424 const DeclarationNameInfo &DirName, Scope *CurScope,
10425 SourceLocation Loc);
10426 /// Start analysis of clauses.
10427 void StartOpenMPClause(OpenMPClauseKind K);
10428 /// End analysis of clauses.
10429 void EndOpenMPClause();
10430 /// Called on end of data sharing attribute block.
10431 void EndOpenMPDSABlock(Stmt *CurDirective);
10432
10433 /// Check if the current region is an OpenMP loop region and if it is,
10434 /// mark loop control variable, used in \p Init for loop initialization, as
10435 /// private by default.
10436 /// \param Init First part of the for loop.
10437 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
10438
10439 // OpenMP directives and clauses.
10440 /// Called on correct id-expression from the '#pragma omp
10441 /// threadprivate'.
10442 ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,
10443 const DeclarationNameInfo &Id,
10444 OpenMPDirectiveKind Kind);
10445 /// Called on well-formed '#pragma omp threadprivate'.
10446 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
10447 SourceLocation Loc,
10448 ArrayRef<Expr *> VarList);
10449 /// Builds a new OpenMPThreadPrivateDecl and checks its correctness.
10450 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc,
10451 ArrayRef<Expr *> VarList);
10452 /// Called on well-formed '#pragma omp allocate'.
10453 DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc,
10454 ArrayRef<Expr *> VarList,
10455 ArrayRef<OMPClause *> Clauses,
10456 DeclContext *Owner = nullptr);
10457
10458 /// Called on well-formed '#pragma omp [begin] assume[s]'.
10459 void ActOnOpenMPAssumesDirective(SourceLocation Loc,
10460 OpenMPDirectiveKind DKind,
10461 ArrayRef<StringRef> Assumptions,
10462 bool SkippedClauses);
10463
10464 /// Check if there is an active global `omp begin assumes` directive.
10465 bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); }
10466
10467 /// Check if there is an active global `omp assumes` directive.
10468 bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); }
10469
10470 /// Called on well-formed '#pragma omp end assumes'.
10471 void ActOnOpenMPEndAssumesDirective();
10472
10473 /// Called on well-formed '#pragma omp requires'.
10474 DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc,
10475 ArrayRef<OMPClause *> ClauseList);
10476 /// Check restrictions on Requires directive
10477 OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc,
10478 ArrayRef<OMPClause *> Clauses);
10479 /// Check if the specified type is allowed to be used in 'omp declare
10480 /// reduction' construct.
10481 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10482 TypeResult ParsedType);
10483 /// Called on start of '#pragma omp declare reduction'.
10484 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
10485 Scope *S, DeclContext *DC, DeclarationName Name,
10486 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10487 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);
10488 /// Initialize declare reduction construct initializer.
10489 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);
10490 /// Finish current declare reduction construct initializer.
10491 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
10492 /// Initialize declare reduction construct initializer.
10493 /// \return omp_priv variable.
10494 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);
10495 /// Finish current declare reduction construct initializer.
10496 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
10497 VarDecl *OmpPrivParm);
10498 /// Called at the end of '#pragma omp declare reduction'.
10499 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
10500 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);
10501
10502 /// Check variable declaration in 'omp declare mapper' construct.
10503 TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);
10504 /// Check if the specified type is allowed to be used in 'omp declare
10505 /// mapper' construct.
10506 QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
10507 TypeResult ParsedType);
10508 /// Called on start of '#pragma omp declare mapper'.
10509 DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(
10510 Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,
10511 SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
10512 Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses,
10513 Decl *PrevDeclInScope = nullptr);
10514 /// Build the mapper variable of '#pragma omp declare mapper'.
10515 ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,
10516 QualType MapperType,
10517 SourceLocation StartLoc,
10518 DeclarationName VN);
10519 bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const;
10520 const ValueDecl *getOpenMPDeclareMapperVarName() const;
10521
10522 /// Called on the start of target region i.e. '#pragma omp declare target'.
10523 bool ActOnStartOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10524
10525 /// Called at the end of target region i.e. '#pragma omp end declare target'.
10526 const DeclareTargetContextInfo ActOnOpenMPEndDeclareTargetDirective();
10527
10528 /// Called once a target context is completed, that can be when a
10529 /// '#pragma omp end declare target' was encountered or when a
10530 /// '#pragma omp declare target' without declaration-definition-seq was
10531 /// encountered.
10532 void ActOnFinishedOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10533
10534 /// Searches for the provided declaration name for OpenMP declare target
10535 /// directive.
10536 NamedDecl *lookupOpenMPDeclareTargetName(Scope *CurScope,
10537 CXXScopeSpec &ScopeSpec,
10538 const DeclarationNameInfo &Id);
10539
10540 /// Called on correct id-expression from the '#pragma omp declare target'.
10541 void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc,
10542 OMPDeclareTargetDeclAttr::MapTypeTy MT,
10543 OMPDeclareTargetDeclAttr::DevTypeTy DT);
10544
10545 /// Check declaration inside target region.
10546 void
10547 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
10548 SourceLocation IdLoc = SourceLocation());
10549 /// Finishes analysis of the deferred functions calls that may be declared as
10550 /// host/nohost during device/host compilation.
10551 void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
10552 const FunctionDecl *Callee,
10553 SourceLocation Loc);
10554 /// Return true inside OpenMP declare target region.
10555 bool isInOpenMPDeclareTargetContext() const {
10556 return !DeclareTargetNesting.empty();
10557 }
10558 /// Return true inside OpenMP target region.
10559 bool isInOpenMPTargetExecutionDirective() const;
10560
10561 /// Return the number of captured regions created for an OpenMP directive.
10562 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
10563
10564 /// Initialization of captured region for OpenMP region.
10565 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
10566
10567 /// Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to
10568 /// an OpenMP loop directive.
10569 StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt);
10570
10571 /// End of OpenMP region.
10572 ///
10573 /// \param S Statement associated with the current OpenMP region.
10574 /// \param Clauses List of clauses for the current OpenMP region.
10575 ///
10576 /// \returns Statement for finished OpenMP region.
10577 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
10578 StmtResult ActOnOpenMPExecutableDirective(
10579 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
10580 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
10581 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
10582 /// Called on well-formed '\#pragma omp parallel' after parsing
10583 /// of the associated statement.
10584 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
10585 Stmt *AStmt,
10586 SourceLocation StartLoc,
10587 SourceLocation EndLoc);
10588 using VarsWithInheritedDSAType =
10589 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
10590 /// Called on well-formed '\#pragma omp simd' after parsing
10591 /// of the associated statement.
10592 StmtResult
10593 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10594 SourceLocation StartLoc, SourceLocation EndLoc,
10595 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10596 /// Called on well-formed '#pragma omp tile' after parsing of its clauses and
10597 /// the associated statement.
10598 StmtResult ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses,
10599 Stmt *AStmt, SourceLocation StartLoc,
10600 SourceLocation EndLoc);
10601 /// Called on well-formed '#pragma omp unroll' after parsing of its clauses
10602 /// and the associated statement.
10603 StmtResult ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses,
10604 Stmt *AStmt, SourceLocation StartLoc,
10605 SourceLocation EndLoc);
10606 /// Called on well-formed '\#pragma omp for' after parsing
10607 /// of the associated statement.
10608 StmtResult
10609 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10610 SourceLocation StartLoc, SourceLocation EndLoc,
10611 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10612 /// Called on well-formed '\#pragma omp for simd' after parsing
10613 /// of the associated statement.
10614 StmtResult
10615 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10616 SourceLocation StartLoc, SourceLocation EndLoc,
10617 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10618 /// Called on well-formed '\#pragma omp sections' after parsing
10619 /// of the associated statement.
10620 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
10621 Stmt *AStmt, SourceLocation StartLoc,
10622 SourceLocation EndLoc);
10623 /// Called on well-formed '\#pragma omp section' after parsing of the
10624 /// associated statement.
10625 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
10626 SourceLocation EndLoc);
10627 /// Called on well-formed '\#pragma omp single' after parsing of the
10628 /// associated statement.
10629 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
10630 Stmt *AStmt, SourceLocation StartLoc,
10631 SourceLocation EndLoc);
10632 /// Called on well-formed '\#pragma omp master' after parsing of the
10633 /// associated statement.
10634 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
10635 SourceLocation EndLoc);
10636 /// Called on well-formed '\#pragma omp critical' after parsing of the
10637 /// associated statement.
10638 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
10639 ArrayRef<OMPClause *> Clauses,
10640 Stmt *AStmt, SourceLocation StartLoc,
10641 SourceLocation EndLoc);
10642 /// Called on well-formed '\#pragma omp parallel for' after parsing
10643 /// of the associated statement.
10644 StmtResult ActOnOpenMPParallelForDirective(
10645 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10646 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10647 /// Called on well-formed '\#pragma omp parallel for simd' after
10648 /// parsing of the associated statement.
10649 StmtResult ActOnOpenMPParallelForSimdDirective(
10650 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10651 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10652 /// Called on well-formed '\#pragma omp parallel master' after
10653 /// parsing of the associated statement.
10654 StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses,
10655 Stmt *AStmt,
10656 SourceLocation StartLoc,
10657 SourceLocation EndLoc);
10658 /// Called on well-formed '\#pragma omp parallel sections' after
10659 /// parsing of the associated statement.
10660 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
10661 Stmt *AStmt,
10662 SourceLocation StartLoc,
10663 SourceLocation EndLoc);
10664 /// Called on well-formed '\#pragma omp task' after parsing of the
10665 /// associated statement.
10666 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
10667 Stmt *AStmt, SourceLocation StartLoc,
10668 SourceLocation EndLoc);
10669 /// Called on well-formed '\#pragma omp taskyield'.
10670 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
10671 SourceLocation EndLoc);
10672 /// Called on well-formed '\#pragma omp barrier'.
10673 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
10674 SourceLocation EndLoc);
10675 /// Called on well-formed '\#pragma omp taskwait'.
10676 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
10677 SourceLocation EndLoc);
10678 /// Called on well-formed '\#pragma omp taskgroup'.
10679 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
10680 Stmt *AStmt, SourceLocation StartLoc,
10681 SourceLocation EndLoc);
10682 /// Called on well-formed '\#pragma omp flush'.
10683 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
10684 SourceLocation StartLoc,
10685 SourceLocation EndLoc);
10686 /// Called on well-formed '\#pragma omp depobj'.
10687 StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses,
10688 SourceLocation StartLoc,
10689 SourceLocation EndLoc);
10690 /// Called on well-formed '\#pragma omp scan'.
10691 StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses,
10692 SourceLocation StartLoc,
10693 SourceLocation EndLoc);
10694 /// Called on well-formed '\#pragma omp ordered' after parsing of the
10695 /// associated statement.
10696 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
10697 Stmt *AStmt, SourceLocation StartLoc,
10698 SourceLocation EndLoc);
10699 /// Called on well-formed '\#pragma omp atomic' after parsing of the
10700 /// associated statement.
10701 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
10702 Stmt *AStmt, SourceLocation StartLoc,
10703 SourceLocation EndLoc);
10704 /// Called on well-formed '\#pragma omp target' after parsing of the
10705 /// associated statement.
10706 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
10707 Stmt *AStmt, SourceLocation StartLoc,
10708 SourceLocation EndLoc);
10709 /// Called on well-formed '\#pragma omp target data' after parsing of
10710 /// the associated statement.
10711 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
10712 Stmt *AStmt, SourceLocation StartLoc,
10713 SourceLocation EndLoc);
10714 /// Called on well-formed '\#pragma omp target enter data' after
10715 /// parsing of the associated statement.
10716 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
10717 SourceLocation StartLoc,
10718 SourceLocation EndLoc,
10719 Stmt *AStmt);
10720 /// Called on well-formed '\#pragma omp target exit data' after
10721 /// parsing of the associated statement.
10722 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
10723 SourceLocation StartLoc,
10724 SourceLocation EndLoc,
10725 Stmt *AStmt);
10726 /// Called on well-formed '\#pragma omp target parallel' after
10727 /// parsing of the associated statement.
10728 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
10729 Stmt *AStmt,
10730 SourceLocation StartLoc,
10731 SourceLocation EndLoc);
10732 /// Called on well-formed '\#pragma omp target parallel for' after
10733 /// parsing of the associated statement.
10734 StmtResult ActOnOpenMPTargetParallelForDirective(
10735 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10736 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10737 /// Called on well-formed '\#pragma omp teams' after parsing of the
10738 /// associated statement.
10739 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
10740 Stmt *AStmt, SourceLocation StartLoc,
10741 SourceLocation EndLoc);
10742 /// Called on well-formed '\#pragma omp cancellation point'.
10743 StmtResult
10744 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
10745 SourceLocation EndLoc,
10746 OpenMPDirectiveKind CancelRegion);
10747 /// Called on well-formed '\#pragma omp cancel'.
10748 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
10749 SourceLocation StartLoc,
10750 SourceLocation EndLoc,
10751 OpenMPDirectiveKind CancelRegion);
10752 /// Called on well-formed '\#pragma omp taskloop' after parsing of the
10753 /// associated statement.
10754 StmtResult
10755 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10756 SourceLocation StartLoc, SourceLocation EndLoc,
10757 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10758 /// Called on well-formed '\#pragma omp taskloop simd' after parsing of
10759 /// the associated statement.
10760 StmtResult ActOnOpenMPTaskLoopSimdDirective(
10761 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10762 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10763 /// Called on well-formed '\#pragma omp master taskloop' after parsing of the
10764 /// associated statement.
10765 StmtResult ActOnOpenMPMasterTaskLoopDirective(
10766 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10767 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10768 /// Called on well-formed '\#pragma omp master taskloop simd' after parsing of
10769 /// the associated statement.
10770 StmtResult ActOnOpenMPMasterTaskLoopSimdDirective(
10771 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10772 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10773 /// Called on well-formed '\#pragma omp parallel master taskloop' after
10774 /// parsing of the associated statement.
10775 StmtResult ActOnOpenMPParallelMasterTaskLoopDirective(
10776 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10777 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10778 /// Called on well-formed '\#pragma omp parallel master taskloop simd' after
10779 /// parsing of the associated statement.
10780 StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective(
10781 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10782 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10783 /// Called on well-formed '\#pragma omp distribute' after parsing
10784 /// of the associated statement.
10785 StmtResult
10786 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10787 SourceLocation StartLoc, SourceLocation EndLoc,
10788 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10789 /// Called on well-formed '\#pragma omp target update'.
10790 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
10791 SourceLocation StartLoc,
10792 SourceLocation EndLoc,
10793 Stmt *AStmt);
10794 /// Called on well-formed '\#pragma omp distribute parallel for' after
10795 /// parsing of the associated statement.
10796 StmtResult ActOnOpenMPDistributeParallelForDirective(
10797 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10798 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10799 /// Called on well-formed '\#pragma omp distribute parallel for simd'
10800 /// after parsing of the associated statement.
10801 StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
10802 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10803 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10804 /// Called on well-formed '\#pragma omp distribute simd' after
10805 /// parsing of the associated statement.
10806 StmtResult ActOnOpenMPDistributeSimdDirective(
10807 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10808 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10809 /// Called on well-formed '\#pragma omp target parallel for simd' after
10810 /// parsing of the associated statement.
10811 StmtResult ActOnOpenMPTargetParallelForSimdDirective(
10812 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10813 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10814 /// Called on well-formed '\#pragma omp target simd' after parsing of
10815 /// the associated statement.
10816 StmtResult
10817 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10818 SourceLocation StartLoc, SourceLocation EndLoc,
10819 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10820 /// Called on well-formed '\#pragma omp teams distribute' after parsing of
10821 /// the associated statement.
10822 StmtResult ActOnOpenMPTeamsDistributeDirective(
10823 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10824 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10825 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing
10826 /// of the associated statement.
10827 StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
10828 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10829 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10830 /// Called on well-formed '\#pragma omp teams distribute parallel for simd'
10831 /// after parsing of the associated statement.
10832 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
10833 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10834 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10835 /// Called on well-formed '\#pragma omp teams distribute parallel for'
10836 /// after parsing of the associated statement.
10837 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
10838 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10839 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10840 /// Called on well-formed '\#pragma omp target teams' after parsing of the
10841 /// associated statement.
10842 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
10843 Stmt *AStmt,
10844 SourceLocation StartLoc,
10845 SourceLocation EndLoc);
10846 /// Called on well-formed '\#pragma omp target teams distribute' after parsing
10847 /// of the associated statement.
10848 StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
10849 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10850 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10851 /// Called on well-formed '\#pragma omp target teams distribute parallel for'
10852 /// after parsing of the associated statement.
10853 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
10854 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10855 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10856 /// Called on well-formed '\#pragma omp target teams distribute parallel for
10857 /// simd' after parsing of the associated statement.
10858 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
10859 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10860 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10861 /// Called on well-formed '\#pragma omp target teams distribute simd' after
10862 /// parsing of the associated statement.
10863 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
10864 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10865 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10866 /// Called on well-formed '\#pragma omp interop'.
10867 StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,
10868 SourceLocation StartLoc,
10869 SourceLocation EndLoc);
10870 /// Called on well-formed '\#pragma omp dispatch' after parsing of the
10871 // /associated statement.
10872 StmtResult ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses,
10873 Stmt *AStmt, SourceLocation StartLoc,
10874 SourceLocation EndLoc);
10875 /// Called on well-formed '\#pragma omp masked' after parsing of the
10876 // /associated statement.
10877 StmtResult ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses,
10878 Stmt *AStmt, SourceLocation StartLoc,
10879 SourceLocation EndLoc);
10880
10881 /// Checks correctness of linear modifiers.
10882 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
10883 SourceLocation LinLoc);
10884 /// Checks that the specified declaration matches requirements for the linear
10885 /// decls.
10886 bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
10887 OpenMPLinearClauseKind LinKind, QualType Type,
10888 bool IsDeclareSimd = false);
10889
10890 /// Called on well-formed '\#pragma omp declare simd' after parsing of
10891 /// the associated method/function.
10892 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
10893 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
10894 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
10895 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
10896 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
10897
10898 /// Checks '\#pragma omp declare variant' variant function and original
10899 /// functions after parsing of the associated method/function.
10900 /// \param DG Function declaration to which declare variant directive is
10901 /// applied to.
10902 /// \param VariantRef Expression that references the variant function, which
10903 /// must be used instead of the original one, specified in \p DG.
10904 /// \param TI The trait info object representing the match clause.
10905 /// \returns None, if the function/variant function are not compatible with
10906 /// the pragma, pair of original function/variant ref expression otherwise.
10907 Optional<std::pair<FunctionDecl *, Expr *>>
10908 checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,
10909 OMPTraitInfo &TI, SourceRange SR);
10910
10911 /// Called on well-formed '\#pragma omp declare variant' after parsing of
10912 /// the associated method/function.
10913 /// \param FD Function declaration to which declare variant directive is
10914 /// applied to.
10915 /// \param VariantRef Expression that references the variant function, which
10916 /// must be used instead of the original one, specified in \p DG.
10917 /// \param TI The context traits associated with the function variant.
10918 void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef,
10919 OMPTraitInfo &TI, SourceRange SR);
10920
10921 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
10922 Expr *Expr,
10923 SourceLocation StartLoc,
10924 SourceLocation LParenLoc,
10925 SourceLocation EndLoc);
10926 /// Called on well-formed 'allocator' clause.
10927 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,
10928 SourceLocation StartLoc,
10929 SourceLocation LParenLoc,
10930 SourceLocation EndLoc);
10931 /// Called on well-formed 'if' clause.
10932 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
10933 Expr *Condition, SourceLocation StartLoc,
10934 SourceLocation LParenLoc,
10935 SourceLocation NameModifierLoc,
10936 SourceLocation ColonLoc,
10937 SourceLocation EndLoc);
10938 /// Called on well-formed 'final' clause.
10939 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
10940 SourceLocation LParenLoc,
10941 SourceLocation EndLoc);
10942 /// Called on well-formed 'num_threads' clause.
10943 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
10944 SourceLocation StartLoc,
10945 SourceLocation LParenLoc,
10946 SourceLocation EndLoc);
10947 /// Called on well-formed 'safelen' clause.
10948 OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
10949 SourceLocation StartLoc,
10950 SourceLocation LParenLoc,
10951 SourceLocation EndLoc);
10952 /// Called on well-formed 'simdlen' clause.
10953 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
10954 SourceLocation LParenLoc,
10955 SourceLocation EndLoc);
10956 /// Called on well-form 'sizes' clause.
10957 OMPClause *ActOnOpenMPSizesClause(ArrayRef<Expr *> SizeExprs,
10958 SourceLocation StartLoc,
10959 SourceLocation LParenLoc,
10960 SourceLocation EndLoc);
10961 /// Called on well-form 'full' clauses.
10962 OMPClause *ActOnOpenMPFullClause(SourceLocation StartLoc,
10963 SourceLocation EndLoc);
10964 /// Called on well-form 'partial' clauses.
10965 OMPClause *ActOnOpenMPPartialClause(Expr *FactorExpr, SourceLocation StartLoc,
10966 SourceLocation LParenLoc,
10967 SourceLocation EndLoc);
10968 /// Called on well-formed 'collapse' clause.
10969 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
10970 SourceLocation StartLoc,
10971 SourceLocation LParenLoc,
10972 SourceLocation EndLoc);
10973 /// Called on well-formed 'ordered' clause.
10974 OMPClause *
10975 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
10976 SourceLocation LParenLoc = SourceLocation(),
10977 Expr *NumForLoops = nullptr);
10978 /// Called on well-formed 'grainsize' clause.
10979 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
10980 SourceLocation LParenLoc,
10981 SourceLocation EndLoc);
10982 /// Called on well-formed 'num_tasks' clause.
10983 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
10984 SourceLocation LParenLoc,
10985 SourceLocation EndLoc);
10986 /// Called on well-formed 'hint' clause.
10987 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
10988 SourceLocation LParenLoc,
10989 SourceLocation EndLoc);
10990 /// Called on well-formed 'detach' clause.
10991 OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc,
10992 SourceLocation LParenLoc,
10993 SourceLocation EndLoc);
10994
10995 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
10996 unsigned Argument,
10997 SourceLocation ArgumentLoc,
10998 SourceLocation StartLoc,
10999 SourceLocation LParenLoc,
11000 SourceLocation EndLoc);
11001 /// Called on well-formed 'default' clause.
11002 OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
11003 SourceLocation KindLoc,
11004 SourceLocation StartLoc,
11005 SourceLocation LParenLoc,
11006 SourceLocation EndLoc);
11007 /// Called on well-formed 'proc_bind' clause.
11008 OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,
11009 SourceLocation KindLoc,
11010 SourceLocation StartLoc,
11011 SourceLocation LParenLoc,
11012 SourceLocation EndLoc);
11013 /// Called on well-formed 'order' clause.
11014 OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind,
11015 SourceLocation KindLoc,
11016 SourceLocation StartLoc,
11017 SourceLocation LParenLoc,
11018 SourceLocation EndLoc);
11019 /// Called on well-formed 'update' clause.
11020 OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,
11021 SourceLocation KindLoc,
11022 SourceLocation StartLoc,
11023 SourceLocation LParenLoc,
11024 SourceLocation EndLoc);
11025
11026 OMPClause *ActOnOpenMPSingleExprWithArgClause(
11027 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
11028 SourceLocation StartLoc, SourceLocation LParenLoc,
11029 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
11030 SourceLocation EndLoc);
11031 /// Called on well-formed 'schedule' clause.
11032 OMPClause *ActOnOpenMPScheduleClause(
11033 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
11034 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11035 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
11036 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
11037
11038 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
11039 SourceLocation EndLoc);
11040 /// Called on well-formed 'nowait' clause.
11041 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
11042 SourceLocation EndLoc);
11043 /// Called on well-formed 'untied' clause.
11044 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
11045 SourceLocation EndLoc);
11046 /// Called on well-formed 'mergeable' clause.
11047 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
11048 SourceLocation EndLoc);
11049 /// Called on well-formed 'read' clause.
11050 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
11051 SourceLocation EndLoc);
11052 /// Called on well-formed 'write' clause.
11053 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
11054 SourceLocation EndLoc);
11055 /// Called on well-formed 'update' clause.
11056 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
11057 SourceLocation EndLoc);
11058 /// Called on well-formed 'capture' clause.
11059 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
11060 SourceLocation EndLoc);
11061 /// Called on well-formed 'seq_cst' clause.
11062 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
11063 SourceLocation EndLoc);
11064 /// Called on well-formed 'acq_rel' clause.
11065 OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
11066 SourceLocation EndLoc);
11067 /// Called on well-formed 'acquire' clause.
11068 OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,
11069 SourceLocation EndLoc);
11070 /// Called on well-formed 'release' clause.
11071 OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc,
11072 SourceLocation EndLoc);
11073 /// Called on well-formed 'relaxed' clause.
11074 OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc,
11075 SourceLocation EndLoc);
11076
11077 /// Called on well-formed 'init' clause.
11078 OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
11079 bool IsTarget, bool IsTargetSync,
11080 SourceLocation StartLoc,
11081 SourceLocation LParenLoc,
11082 SourceLocation VarLoc,
11083 SourceLocation EndLoc);
11084
11085 /// Called on well-formed 'use' clause.
11086 OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
11087 SourceLocation LParenLoc,
11088 SourceLocation VarLoc, SourceLocation EndLoc);
11089
11090 /// Called on well-formed 'destroy' clause.
11091 OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
11092 SourceLocation LParenLoc,
11093 SourceLocation VarLoc,
11094 SourceLocation EndLoc);
11095 /// Called on well-formed 'novariants' clause.
11096 OMPClause *ActOnOpenMPNovariantsClause(Expr *Condition,
11097 SourceLocation StartLoc,
11098 SourceLocation LParenLoc,
11099 SourceLocation EndLoc);
11100 /// Called on well-formed 'nocontext' clause.
11101 OMPClause *ActOnOpenMPNocontextClause(Expr *Condition,
11102 SourceLocation StartLoc,
11103 SourceLocation LParenLoc,
11104 SourceLocation EndLoc);
11105 /// Called on well-formed 'filter' clause.
11106 OMPClause *ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
11107 SourceLocation LParenLoc,
11108 SourceLocation EndLoc);
11109 /// Called on well-formed 'threads' clause.
11110 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
11111 SourceLocation EndLoc);
11112 /// Called on well-formed 'simd' clause.
11113 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
11114 SourceLocation EndLoc);
11115 /// Called on well-formed 'nogroup' clause.
11116 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
11117 SourceLocation EndLoc);
11118 /// Called on well-formed 'unified_address' clause.
11119 OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc,
11120 SourceLocation EndLoc);
11121
11122 /// Called on well-formed 'unified_address' clause.
11123 OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc,
11124 SourceLocation EndLoc);
11125
11126 /// Called on well-formed 'reverse_offload' clause.
11127 OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,
11128 SourceLocation EndLoc);
11129
11130 /// Called on well-formed 'dynamic_allocators' clause.
11131 OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
11132 SourceLocation EndLoc);
11133
11134 /// Called on well-formed 'atomic_default_mem_order' clause.
11135 OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(
11136 OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,
11137 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11138
11139 OMPClause *ActOnOpenMPVarListClause(
11140 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr,
11141 const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
11142 CXXScopeSpec &ReductionOrMapperIdScopeSpec,
11143 DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
11144 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11145 ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
11146 SourceLocation ExtraModifierLoc,
11147 ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11148 ArrayRef<SourceLocation> MotionModifiersLoc);
11149 /// Called on well-formed 'inclusive' clause.
11150 OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,
11151 SourceLocation StartLoc,
11152 SourceLocation LParenLoc,
11153 SourceLocation EndLoc);
11154 /// Called on well-formed 'exclusive' clause.
11155 OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList,
11156 SourceLocation StartLoc,
11157 SourceLocation LParenLoc,
11158 SourceLocation EndLoc);
11159 /// Called on well-formed 'allocate' clause.
11160 OMPClause *
11161 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,
11162 SourceLocation StartLoc, SourceLocation ColonLoc,
11163 SourceLocation LParenLoc, SourceLocation EndLoc);
11164 /// Called on well-formed 'private' clause.
11165 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
11166 SourceLocation StartLoc,
11167 SourceLocation LParenLoc,
11168 SourceLocation EndLoc);
11169 /// Called on well-formed 'firstprivate' clause.
11170 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
11171 SourceLocation StartLoc,
11172 SourceLocation LParenLoc,
11173 SourceLocation EndLoc);
11174 /// Called on well-formed 'lastprivate' clause.
11175 OMPClause *ActOnOpenMPLastprivateClause(
11176 ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind,
11177 SourceLocation LPKindLoc, SourceLocation ColonLoc,
11178 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11179 /// Called on well-formed 'shared' clause.
11180 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
11181 SourceLocation StartLoc,
11182 SourceLocation LParenLoc,
11183 SourceLocation EndLoc);
11184 /// Called on well-formed 'reduction' clause.
11185 OMPClause *ActOnOpenMPReductionClause(
11186 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
11187 SourceLocation StartLoc, SourceLocation LParenLoc,
11188 SourceLocation ModifierLoc, SourceLocation ColonLoc,
11189 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
11190 const DeclarationNameInfo &ReductionId,
11191 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11192 /// Called on well-formed 'task_reduction' clause.
11193 OMPClause *ActOnOpenMPTaskReductionClause(
11194 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11195 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11196 CXXScopeSpec &ReductionIdScopeSpec,
11197 const DeclarationNameInfo &ReductionId,
11198 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11199 /// Called on well-formed 'in_reduction' clause.
11200 OMPClause *ActOnOpenMPInReductionClause(
11201 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11202 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11203 CXXScopeSpec &ReductionIdScopeSpec,
11204 const DeclarationNameInfo &ReductionId,
11205 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11206 /// Called on well-formed 'linear' clause.
11207 OMPClause *
11208 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
11209 SourceLocation StartLoc, SourceLocation LParenLoc,
11210 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
11211 SourceLocation ColonLoc, SourceLocation EndLoc);
11212 /// Called on well-formed 'aligned' clause.
11213 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
11214 Expr *Alignment,
11215 SourceLocation StartLoc,
11216 SourceLocation LParenLoc,
11217 SourceLocation ColonLoc,
11218 SourceLocation EndLoc);
11219 /// Called on well-formed 'copyin' clause.
11220 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
11221 SourceLocation StartLoc,
11222 SourceLocation LParenLoc,
11223 SourceLocation EndLoc);
11224 /// Called on well-formed 'copyprivate' clause.
11225 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
11226 SourceLocation StartLoc,
11227 SourceLocation LParenLoc,
11228 SourceLocation EndLoc);
11229 /// Called on well-formed 'flush' pseudo clause.
11230 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
11231 SourceLocation StartLoc,
11232 SourceLocation LParenLoc,
11233 SourceLocation EndLoc);
11234 /// Called on well-formed 'depobj' pseudo clause.
11235 OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
11236 SourceLocation LParenLoc,
11237 SourceLocation EndLoc);
11238 /// Called on well-formed 'depend' clause.
11239 OMPClause *
11240 ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
11241 SourceLocation DepLoc, SourceLocation ColonLoc,
11242 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11243 SourceLocation LParenLoc, SourceLocation EndLoc);
11244 /// Called on well-formed 'device' clause.
11245 OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
11246 Expr *Device, SourceLocation StartLoc,
11247 SourceLocation LParenLoc,
11248 SourceLocation ModifierLoc,
11249 SourceLocation EndLoc);
11250 /// Called on well-formed 'map' clause.
11251 OMPClause *ActOnOpenMPMapClause(
11252 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11253 ArrayRef<SourceLocation> MapTypeModifiersLoc,
11254 CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId,
11255 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11256 SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
11257 const OMPVarListLocTy &Locs, bool NoDiagnose = false,
11258 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11259 /// Called on well-formed 'num_teams' clause.
11260 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
11261 SourceLocation LParenLoc,
11262 SourceLocation EndLoc);
11263 /// Called on well-formed 'thread_limit' clause.
11264 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11265 SourceLocation StartLoc,
11266 SourceLocation LParenLoc,
11267 SourceLocation EndLoc);
11268 /// Called on well-formed 'priority' clause.
11269 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
11270 SourceLocation LParenLoc,
11271 SourceLocation EndLoc);
11272 /// Called on well-formed 'dist_schedule' clause.
11273 OMPClause *ActOnOpenMPDistScheduleClause(
11274 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
11275 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
11276 SourceLocation CommaLoc, SourceLocation EndLoc);
11277 /// Called on well-formed 'defaultmap' clause.
11278 OMPClause *ActOnOpenMPDefaultmapClause(
11279 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11280 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11281 SourceLocation KindLoc, SourceLocation EndLoc);
11282 /// Called on well-formed 'to' clause.
11283 OMPClause *
11284 ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11285 ArrayRef<SourceLocation> MotionModifiersLoc,
11286 CXXScopeSpec &MapperIdScopeSpec,
11287 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11288 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11289 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11290 /// Called on well-formed 'from' clause.
11291 OMPClause *
11292 ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11293 ArrayRef<SourceLocation> MotionModifiersLoc,
11294 CXXScopeSpec &MapperIdScopeSpec,
11295 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11296 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11297 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11298 /// Called on well-formed 'use_device_ptr' clause.
11299 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11300 const OMPVarListLocTy &Locs);
11301 /// Called on well-formed 'use_device_addr' clause.
11302 OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
11303 const OMPVarListLocTy &Locs);
11304 /// Called on well-formed 'is_device_ptr' clause.
11305 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11306 const OMPVarListLocTy &Locs);
11307 /// Called on well-formed 'nontemporal' clause.
11308 OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList,
11309 SourceLocation StartLoc,
11310 SourceLocation LParenLoc,
11311 SourceLocation EndLoc);
11312
11313 /// Data for list of allocators.
11314 struct UsesAllocatorsData {
11315 /// Allocator.
11316 Expr *Allocator = nullptr;
11317 /// Allocator traits.
11318 Expr *AllocatorTraits = nullptr;
11319 /// Locations of '(' and ')' symbols.
11320 SourceLocation LParenLoc, RParenLoc;
11321 };
11322 /// Called on well-formed 'uses_allocators' clause.
11323 OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc,
11324 SourceLocation LParenLoc,
11325 SourceLocation EndLoc,
11326 ArrayRef<UsesAllocatorsData> Data);
11327 /// Called on well-formed 'affinity' clause.
11328 OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc,
11329 SourceLocation LParenLoc,
11330 SourceLocation ColonLoc,
11331 SourceLocation EndLoc, Expr *Modifier,
11332 ArrayRef<Expr *> Locators);
11333
11334 /// The kind of conversion being performed.
11335 enum CheckedConversionKind {
11336 /// An implicit conversion.
11337 CCK_ImplicitConversion,
11338 /// A C-style cast.
11339 CCK_CStyleCast,
11340 /// A functional-style cast.
11341 CCK_FunctionalCast,
11342 /// A cast other than a C-style cast.
11343 CCK_OtherCast,
11344 /// A conversion for an operand of a builtin overloaded operator.
11345 CCK_ForBuiltinOverloadedOp
11346 };
11347
11348 static bool isCast(CheckedConversionKind CCK) {
11349 return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast ||
11350 CCK == CCK_OtherCast;
11351 }
11352
11353 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
11354 /// cast. If there is already an implicit cast, merge into the existing one.
11355 /// If isLvalue, the result of the cast is an lvalue.
11356 ExprResult
11357 ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
11358 ExprValueKind VK = VK_PRValue,
11359 const CXXCastPath *BasePath = nullptr,
11360 CheckedConversionKind CCK = CCK_ImplicitConversion);
11361
11362 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
11363 /// to the conversion from scalar type ScalarTy to the Boolean type.
11364 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
11365
11366 /// IgnoredValueConversions - Given that an expression's result is
11367 /// syntactically ignored, perform any conversions that are
11368 /// required.
11369 ExprResult IgnoredValueConversions(Expr *E);
11370
11371 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
11372 // functions and arrays to their respective pointers (C99 6.3.2.1).
11373 ExprResult UsualUnaryConversions(Expr *E);
11374
11375 /// CallExprUnaryConversions - a special case of an unary conversion
11376 /// performed on a function designator of a call expression.
11377 ExprResult CallExprUnaryConversions(Expr *E);
11378
11379 // DefaultFunctionArrayConversion - converts functions and arrays
11380 // to their respective pointers (C99 6.3.2.1).
11381 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
11382
11383 // DefaultFunctionArrayLvalueConversion - converts functions and
11384 // arrays to their respective pointers and performs the
11385 // lvalue-to-rvalue conversion.
11386 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
11387 bool Diagnose = true);
11388
11389 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
11390 // the operand. This function is a no-op if the operand has a function type
11391 // or an array type.
11392 ExprResult DefaultLvalueConversion(Expr *E);
11393
11394 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
11395 // do not have a prototype. Integer promotions are performed on each
11396 // argument, and arguments that have type float are promoted to double.
11397 ExprResult DefaultArgumentPromotion(Expr *E);
11398
11399 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize
11400 /// it as an xvalue. In C++98, the result will still be a prvalue, because
11401 /// we don't have xvalues there.
11402 ExprResult TemporaryMaterializationConversion(Expr *E);
11403
11404 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
11405 enum VariadicCallType {
11406 VariadicFunction,
11407 VariadicBlock,
11408 VariadicMethod,
11409 VariadicConstructor,
11410 VariadicDoesNotApply
11411 };
11412
11413 VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
11414 const FunctionProtoType *Proto,
11415 Expr *Fn);
11416
11417 // Used for determining in which context a type is allowed to be passed to a
11418 // vararg function.
11419 enum VarArgKind {
11420 VAK_Valid,
11421 VAK_ValidInCXX11,
11422 VAK_Undefined,
11423 VAK_MSVCUndefined,
11424 VAK_Invalid
11425 };
11426
11427 // Determines which VarArgKind fits an expression.
11428 VarArgKind isValidVarArgType(const QualType &Ty);
11429
11430 /// Check to see if the given expression is a valid argument to a variadic
11431 /// function, issuing a diagnostic if not.
11432 void checkVariadicArgument(const Expr *E, VariadicCallType CT);
11433
11434 /// Check whether the given statement can have musttail applied to it,
11435 /// issuing a diagnostic and returning false if not. In the success case,
11436 /// the statement is rewritten to remove implicit nodes from the return
11437 /// value.
11438 bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA);
11439
11440private:
11441 /// Check whether the given statement can have musttail applied to it,
11442 /// issuing a diagnostic and returning false if not.
11443 bool checkMustTailAttr(const Stmt *St, const Attr &MTA);
11444
11445public:
11446 /// Check to see if a given expression could have '.c_str()' called on it.
11447 bool hasCStrMethod(const Expr *E);
11448
11449 /// GatherArgumentsForCall - Collector argument expressions for various
11450 /// form of call prototypes.
11451 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
11452 const FunctionProtoType *Proto,
11453 unsigned FirstParam, ArrayRef<Expr *> Args,
11454 SmallVectorImpl<Expr *> &AllArgs,
11455 VariadicCallType CallType = VariadicDoesNotApply,
11456 bool AllowExplicit = false,
11457 bool IsListInitialization = false);
11458
11459 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
11460 // will create a runtime trap if the resulting type is not a POD type.
11461 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
11462 FunctionDecl *FDecl);
11463
11464 /// Context in which we're performing a usual arithmetic conversion.
11465 enum ArithConvKind {
11466 /// An arithmetic operation.
11467 ACK_Arithmetic,
11468 /// A bitwise operation.
11469 ACK_BitwiseOp,
11470 /// A comparison.
11471 ACK_Comparison,
11472 /// A conditional (?:) operator.
11473 ACK_Conditional,
11474 /// A compound assignment expression.
11475 ACK_CompAssign,
11476 };
11477
11478 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
11479 // operands and then handles various conversions that are common to binary
11480 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
11481 // routine returns the first non-arithmetic type found. The client is
11482 // responsible for emitting appropriate error diagnostics.
11483 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
11484 SourceLocation Loc, ArithConvKind ACK);
11485
11486 /// AssignConvertType - All of the 'assignment' semantic checks return this
11487 /// enum to indicate whether the assignment was allowed. These checks are
11488 /// done for simple assignments, as well as initialization, return from
11489 /// function, argument passing, etc. The query is phrased in terms of a
11490 /// source and destination type.
11491 enum AssignConvertType {
11492 /// Compatible - the types are compatible according to the standard.
11493 Compatible,
11494
11495 /// PointerToInt - The assignment converts a pointer to an int, which we
11496 /// accept as an extension.
11497 PointerToInt,
11498
11499 /// IntToPointer - The assignment converts an int to a pointer, which we
11500 /// accept as an extension.
11501 IntToPointer,
11502
11503 /// FunctionVoidPointer - The assignment is between a function pointer and
11504 /// void*, which the standard doesn't allow, but we accept as an extension.
11505 FunctionVoidPointer,
11506
11507 /// IncompatiblePointer - The assignment is between two pointers types that
11508 /// are not compatible, but we accept them as an extension.
11509 IncompatiblePointer,
11510
11511 /// IncompatibleFunctionPointer - The assignment is between two function
11512 /// pointers types that are not compatible, but we accept them as an
11513 /// extension.
11514 IncompatibleFunctionPointer,
11515
11516 /// IncompatiblePointerSign - The assignment is between two pointers types
11517 /// which point to integers which have a different sign, but are otherwise
11518 /// identical. This is a subset of the above, but broken out because it's by
11519 /// far the most common case of incompatible pointers.
11520 IncompatiblePointerSign,
11521
11522 /// CompatiblePointerDiscardsQualifiers - The assignment discards
11523 /// c/v/r qualifiers, which we accept as an extension.
11524 CompatiblePointerDiscardsQualifiers,
11525
11526 /// IncompatiblePointerDiscardsQualifiers - The assignment
11527 /// discards qualifiers that we don't permit to be discarded,
11528 /// like address spaces.
11529 IncompatiblePointerDiscardsQualifiers,
11530
11531 /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment
11532 /// changes address spaces in nested pointer types which is not allowed.
11533 /// For instance, converting __private int ** to __generic int ** is
11534 /// illegal even though __private could be converted to __generic.
11535 IncompatibleNestedPointerAddressSpaceMismatch,
11536
11537 /// IncompatibleNestedPointerQualifiers - The assignment is between two
11538 /// nested pointer types, and the qualifiers other than the first two
11539 /// levels differ e.g. char ** -> const char **, but we accept them as an
11540 /// extension.
11541 IncompatibleNestedPointerQualifiers,
11542
11543 /// IncompatibleVectors - The assignment is between two vector types that
11544 /// have the same size, which we accept as an extension.
11545 IncompatibleVectors,
11546
11547 /// IntToBlockPointer - The assignment converts an int to a block
11548 /// pointer. We disallow this.
11549 IntToBlockPointer,
11550
11551 /// IncompatibleBlockPointer - The assignment is between two block
11552 /// pointers types that are not compatible.
11553 IncompatibleBlockPointer,
11554
11555 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
11556 /// id type and something else (that is incompatible with it). For example,
11557 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
11558 IncompatibleObjCQualifiedId,
11559
11560 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
11561 /// object with __weak qualifier.
11562 IncompatibleObjCWeakRef,
11563
11564 /// Incompatible - We reject this conversion outright, it is invalid to
11565 /// represent it in the AST.
11566 Incompatible
11567 };
11568
11569 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
11570 /// assignment conversion type specified by ConvTy. This returns true if the
11571 /// conversion was invalid or false if the conversion was accepted.
11572 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
11573 SourceLocation Loc,
11574 QualType DstType, QualType SrcType,
11575 Expr *SrcExpr, AssignmentAction Action,
11576 bool *Complained = nullptr);
11577
11578 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
11579 /// enum. If AllowMask is true, then we also allow the complement of a valid
11580 /// value, to be used as a mask.
11581 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
11582 bool AllowMask) const;
11583
11584 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
11585 /// integer not in the range of enum values.
11586 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
11587 Expr *SrcExpr);
11588
11589 /// CheckAssignmentConstraints - Perform type checking for assignment,
11590 /// argument passing, variable initialization, and function return values.
11591 /// C99 6.5.16.
11592 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
11593 QualType LHSType,
11594 QualType RHSType);
11595
11596 /// Check assignment constraints and optionally prepare for a conversion of
11597 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
11598 /// is true.
11599 AssignConvertType CheckAssignmentConstraints(QualType LHSType,
11600 ExprResult &RHS,
11601 CastKind &Kind,
11602 bool ConvertRHS = true);
11603
11604 /// Check assignment constraints for an assignment of RHS to LHSType.
11605 ///
11606 /// \param LHSType The destination type for the assignment.
11607 /// \param RHS The source expression for the assignment.
11608 /// \param Diagnose If \c true, diagnostics may be produced when checking
11609 /// for assignability. If a diagnostic is produced, \p RHS will be
11610 /// set to ExprError(). Note that this function may still return
11611 /// without producing a diagnostic, even for an invalid assignment.
11612 /// \param DiagnoseCFAudited If \c true, the target is a function parameter
11613 /// in an audited Core Foundation API and does not need to be checked
11614 /// for ARC retain issues.
11615 /// \param ConvertRHS If \c true, \p RHS will be updated to model the
11616 /// conversions necessary to perform the assignment. If \c false,
11617 /// \p Diagnose must also be \c false.
11618 AssignConvertType CheckSingleAssignmentConstraints(
11619 QualType LHSType, ExprResult &RHS, bool Diagnose = true,
11620 bool DiagnoseCFAudited = false, bool ConvertRHS = true);
11621
11622 // If the lhs type is a transparent union, check whether we
11623 // can initialize the transparent union with the given expression.
11624 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
11625 ExprResult &RHS);
11626
11627 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
11628
11629 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
11630
11631 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11632 AssignmentAction Action,
11633 bool AllowExplicit = false);
11634 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11635 const ImplicitConversionSequence& ICS,
11636 AssignmentAction Action,
11637 CheckedConversionKind CCK
11638 = CCK_ImplicitConversion);
11639 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11640 const StandardConversionSequence& SCS,
11641 AssignmentAction Action,
11642 CheckedConversionKind CCK);
11643
11644 ExprResult PerformQualificationConversion(
11645 Expr *E, QualType Ty, ExprValueKind VK = VK_PRValue,
11646 CheckedConversionKind CCK = CCK_ImplicitConversion);
11647
11648 /// the following "Check" methods will return a valid/converted QualType
11649 /// or a null QualType (indicating an error diagnostic was issued).
11650
11651 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
11652 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
11653 ExprResult &RHS);
11654 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
11655 ExprResult &RHS);
11656 QualType CheckPointerToMemberOperands( // C++ 5.5
11657 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
11658 SourceLocation OpLoc, bool isIndirect);
11659 QualType CheckMultiplyDivideOperands( // C99 6.5.5
11660 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
11661 bool IsDivide);
11662 QualType CheckRemainderOperands( // C99 6.5.5
11663 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11664 bool IsCompAssign = false);
11665 QualType CheckAdditionOperands( // C99 6.5.6
11666 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11667 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
11668 QualType CheckSubtractionOperands( // C99 6.5.6
11669 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11670 QualType* CompLHSTy = nullptr);
11671 QualType CheckShiftOperands( // C99 6.5.7
11672 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11673 BinaryOperatorKind Opc, bool IsCompAssign = false);
11674 void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE);
11675 QualType CheckCompareOperands( // C99 6.5.8/9
11676 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11677 BinaryOperatorKind Opc);
11678 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
11679 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11680 BinaryOperatorKind Opc);
11681 QualType CheckLogicalOperands( // C99 6.5.[13,14]
11682 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11683 BinaryOperatorKind Opc);
11684 // CheckAssignmentOperands is used for both simple and compound assignment.
11685 // For simple assignment, pass both expressions and a null converted type.
11686 // For compound assignment, pass both expressions and the converted type.
11687 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
11688 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
11689
11690 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
11691 UnaryOperatorKind Opcode, Expr *Op);
11692 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
11693 BinaryOperatorKind Opcode,
11694 Expr *LHS, Expr *RHS);
11695 ExprResult checkPseudoObjectRValue(Expr *E);
11696 Expr *recreateSyntacticForm(PseudoObjectExpr *E);
11697
11698 QualType CheckConditionalOperands( // C99 6.5.15
11699 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
11700 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
11701 QualType CXXCheckConditionalOperands( // C++ 5.16
11702 ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
11703 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
11704 QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
11705 ExprResult &RHS,
11706 SourceLocation QuestionLoc);
11707 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
11708 bool ConvertArgs = true);
11709 QualType FindCompositePointerType(SourceLocation Loc,
11710 ExprResult &E1, ExprResult &E2,
11711 bool ConvertArgs = true) {
11712 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
11713 QualType Composite =
11714 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
11715 E1 = E1Tmp;
11716 E2 = E2Tmp;
11717 return Composite;
11718 }
11719
11720 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
11721 SourceLocation QuestionLoc);
11722
11723 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
11724 SourceLocation QuestionLoc);
11725
11726 void DiagnoseAlwaysNonNullPointer(Expr *E,
11727 Expr::NullPointerConstantKind NullType,
11728 bool IsEqual, SourceRange Range);
11729
11730 /// type checking for vector binary operators.
11731 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
11732 SourceLocation Loc, bool IsCompAssign,
11733 bool AllowBothBool, bool AllowBoolConversion);
11734 QualType GetSignedVectorType(QualType V);
11735 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
11736 SourceLocation Loc,
11737 BinaryOperatorKind Opc);
11738 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
11739 SourceLocation Loc);
11740
11741 /// Type checking for matrix binary operators.
11742 QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
11743 SourceLocation Loc,
11744 bool IsCompAssign);
11745 QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
11746 SourceLocation Loc, bool IsCompAssign);
11747
11748 bool isValidSveBitcast(QualType srcType, QualType destType);
11749
11750 bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy);
11751
11752 bool areVectorTypesSameSize(QualType srcType, QualType destType);
11753 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
11754 bool isLaxVectorConversion(QualType srcType, QualType destType);
11755
11756 /// type checking declaration initializers (C99 6.7.8)
11757 bool CheckForConstantInitializer(Expr *e, QualType t);
11758
11759 // type checking C++ declaration initializers (C++ [dcl.init]).
11760
11761 /// ReferenceCompareResult - Expresses the result of comparing two
11762 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
11763 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
11764 enum ReferenceCompareResult {
11765 /// Ref_Incompatible - The two types are incompatible, so direct
11766 /// reference binding is not possible.
11767 Ref_Incompatible = 0,
11768 /// Ref_Related - The two types are reference-related, which means
11769 /// that their unqualified forms (T1 and T2) are either the same
11770 /// or T1 is a base class of T2.
11771 Ref_Related,
11772 /// Ref_Compatible - The two types are reference-compatible.
11773 Ref_Compatible
11774 };
11775
11776 // Fake up a scoped enumeration that still contextually converts to bool.
11777 struct ReferenceConversionsScope {
11778 /// The conversions that would be performed on an lvalue of type T2 when
11779 /// binding a reference of type T1 to it, as determined when evaluating
11780 /// whether T1 is reference-compatible with T2.
11781 enum ReferenceConversions {
11782 Qualification = 0x1,
11783 NestedQualification = 0x2,
11784 Function = 0x4,
11785 DerivedToBase = 0x8,
11786 ObjC = 0x10,
11787 ObjCLifetime = 0x20,
11788
11789 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime)LLVM_BITMASK_LARGEST_ENUMERATOR = ObjCLifetime
11790 };
11791 };
11792 using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions;
11793
11794 ReferenceCompareResult
11795 CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2,
11796 ReferenceConversions *Conv = nullptr);
11797
11798 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
11799 Expr *CastExpr, CastKind &CastKind,
11800 ExprValueKind &VK, CXXCastPath &Path);
11801
11802 /// Force an expression with unknown-type to an expression of the
11803 /// given type.
11804 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
11805
11806 /// Type-check an expression that's being passed to an
11807 /// __unknown_anytype parameter.
11808 ExprResult checkUnknownAnyArg(SourceLocation callLoc,
11809 Expr *result, QualType &paramType);
11810
11811 // CheckMatrixCast - Check type constraints for matrix casts.
11812 // We allow casting between matrixes of the same dimensions i.e. when they
11813 // have the same number of rows and column. Returns true if the cast is
11814 // invalid.
11815 bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
11816 CastKind &Kind);
11817
11818 // CheckVectorCast - check type constraints for vectors.
11819 // Since vectors are an extension, there are no C standard reference for this.
11820 // We allow casting between vectors and integer datatypes of the same size.
11821 // returns true if the cast is invalid
11822 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
11823 CastKind &Kind);
11824
11825 /// Prepare `SplattedExpr` for a vector splat operation, adding
11826 /// implicit casts if necessary.
11827 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
11828
11829 // CheckExtVectorCast - check type constraints for extended vectors.
11830 // Since vectors are an extension, there are no C standard reference for this.
11831 // We allow casting between vectors and integer datatypes of the same size,
11832 // or vectors and the element type of that vector.
11833 // returns the cast expr
11834 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
11835 CastKind &Kind);
11836
11837 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
11838 SourceLocation LParenLoc,
11839 Expr *CastExpr,
11840 SourceLocation RParenLoc);
11841
11842 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
11843
11844 /// Checks for invalid conversions and casts between
11845 /// retainable pointers and other pointer kinds for ARC and Weak.
11846 ARCConversionResult CheckObjCConversion(SourceRange castRange,
11847 QualType castType, Expr *&op,
11848 CheckedConversionKind CCK,
11849 bool Diagnose = true,
11850 bool DiagnoseCFAudited = false,
11851 BinaryOperatorKind Opc = BO_PtrMemD
11852 );
11853
11854 Expr *stripARCUnbridgedCast(Expr *e);
11855 void diagnoseARCUnbridgedCast(Expr *e);
11856
11857 bool CheckObjCARCUnavailableWeakConversion(QualType castType,
11858 QualType ExprType);
11859
11860 /// checkRetainCycles - Check whether an Objective-C message send
11861 /// might create an obvious retain cycle.
11862 void checkRetainCycles(ObjCMessageExpr *msg);
11863 void checkRetainCycles(Expr *receiver, Expr *argument);
11864 void checkRetainCycles(VarDecl *Var, Expr *Init);
11865
11866 /// checkUnsafeAssigns - Check whether +1 expr is being assigned
11867 /// to weak/__unsafe_unretained type.
11868 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
11869
11870 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
11871 /// to weak/__unsafe_unretained expression.
11872 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
11873
11874 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
11875 /// \param Method - May be null.
11876 /// \param [out] ReturnType - The return type of the send.
11877 /// \return true iff there were any incompatible types.
11878 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,
11879 MultiExprArg Args, Selector Sel,
11880 ArrayRef<SourceLocation> SelectorLocs,
11881 ObjCMethodDecl *Method, bool isClassMessage,
11882 bool isSuperMessage, SourceLocation lbrac,
11883 SourceLocation rbrac, SourceRange RecRange,
11884 QualType &ReturnType, ExprValueKind &VK);
11885
11886 /// Determine the result of a message send expression based on
11887 /// the type of the receiver, the method expected to receive the message,
11888 /// and the form of the message send.
11889 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,
11890 ObjCMethodDecl *Method, bool isClassMessage,
11891 bool isSuperMessage);
11892
11893 /// If the given expression involves a message send to a method
11894 /// with a related result type, emit a note describing what happened.
11895 void EmitRelatedResultTypeNote(const Expr *E);
11896
11897 /// Given that we had incompatible pointer types in a return
11898 /// statement, check whether we're in a method with a related result
11899 /// type, and if so, emit a note describing what happened.
11900 void EmitRelatedResultTypeNoteForReturn(QualType destType);
11901
11902 class ConditionResult {
11903 Decl *ConditionVar;
11904 FullExprArg Condition;
11905 bool Invalid;
11906 bool HasKnownValue;
11907 bool KnownValue;
11908
11909 friend class Sema;
11910 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
11911 bool IsConstexpr)
11912 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),
11913 HasKnownValue(IsConstexpr && Condition.get() &&
11914 !Condition.get()->isValueDependent()),
11915 KnownValue(HasKnownValue &&
11916 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
11917 explicit ConditionResult(bool Invalid)
11918 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),
11919 HasKnownValue(false), KnownValue(false) {}
11920
11921 public:
11922 ConditionResult() : ConditionResult(false) {}
11923 bool isInvalid() const { return Invalid; }
11924 std::pair<VarDecl *, Expr *> get() const {
11925 return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
11926 Condition.get());
11927 }
11928 llvm::Optional<bool> getKnownValue() const {
11929 if (!HasKnownValue)
11930 return None;
11931 return KnownValue;
11932 }
11933 };
11934 static ConditionResult ConditionError() { return ConditionResult(true); }
11935
11936 enum class ConditionKind {
11937 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
11938 ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
11939 Switch ///< An integral condition for a 'switch' statement.
11940 };
11941
11942 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
11943 Expr *SubExpr, ConditionKind CK);
11944
11945 ConditionResult ActOnConditionVariable(Decl *ConditionVar,
11946 SourceLocation StmtLoc,
11947 ConditionKind CK);
11948
11949 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
11950
11951 ExprResult CheckConditionVariable(VarDecl *ConditionVar,
11952 SourceLocation StmtLoc,
11953 ConditionKind CK);
11954 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
11955
11956 /// CheckBooleanCondition - Diagnose problems involving the use of
11957 /// the given expression as a boolean condition (e.g. in an if
11958 /// statement). Also performs the standard function and array
11959 /// decays, possibly changing the input variable.
11960 ///
11961 /// \param Loc - A location associated with the condition, e.g. the
11962 /// 'if' keyword.
11963 /// \return true iff there were any errors
11964 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
11965 bool IsConstexpr = false);
11966
11967 /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression
11968 /// found in an explicit(bool) specifier.
11969 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
11970
11971 /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
11972 /// Returns true if the explicit specifier is now resolved.
11973 bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);
11974
11975 /// DiagnoseAssignmentAsCondition - Given that an expression is
11976 /// being used as a boolean condition, warn if it's an assignment.
11977 void DiagnoseAssignmentAsCondition(Expr *E);
11978
11979 /// Redundant parentheses over an equality comparison can indicate
11980 /// that the user intended an assignment used as condition.
11981 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
11982
11983 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
11984 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
11985
11986 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
11987 /// the specified width and sign. If an overflow occurs, detect it and emit
11988 /// the specified diagnostic.
11989 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
11990 unsigned NewWidth, bool NewSign,
11991 SourceLocation Loc, unsigned DiagID);
11992
11993 /// Checks that the Objective-C declaration is declared in the global scope.
11994 /// Emits an error and marks the declaration as invalid if it's not declared
11995 /// in the global scope.
11996 bool CheckObjCDeclScope(Decl *D);
11997
11998 /// Abstract base class used for diagnosing integer constant
11999 /// expression violations.
12000 class VerifyICEDiagnoser {
12001 public:
12002 bool Suppress;
12003
12004 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
12005
12006 virtual SemaDiagnosticBuilder
12007 diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T);
12008 virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
12009 SourceLocation Loc) = 0;
12010 virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc);
12011 virtual ~VerifyICEDiagnoser() {}
12012 };
12013
12014 enum AllowFoldKind {
12015 NoFold,
12016 AllowFold,
12017 };
12018
12019 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
12020 /// and reports the appropriate diagnostics. Returns false on success.
12021 /// Can optionally return the value of the expression.
12022 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12023 VerifyICEDiagnoser &Diagnoser,
12024 AllowFoldKind CanFold = NoFold);
12025 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12026 unsigned DiagID,
12027 AllowFoldKind CanFold = NoFold);
12028 ExprResult VerifyIntegerConstantExpression(Expr *E,
12029 llvm::APSInt *Result = nullptr,
12030 AllowFoldKind CanFold = NoFold);
12031 ExprResult VerifyIntegerConstantExpression(Expr *E,
12032 AllowFoldKind CanFold = NoFold) {
12033 return VerifyIntegerConstantExpression(E, nullptr, CanFold);
12034 }
12035
12036 /// VerifyBitField - verifies that a bit field expression is an ICE and has
12037 /// the correct width, and that the field type is valid.
12038 /// Returns false on success.
12039 /// Can optionally return whether the bit-field is of width 0
12040 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
12041 QualType FieldTy, bool IsMsStruct,
12042 Expr *BitWidth, bool *ZeroWidth = nullptr);
12043
12044private:
12045 unsigned ForceCUDAHostDeviceDepth = 0;
12046
12047public:
12048 /// Increments our count of the number of times we've seen a pragma forcing
12049 /// functions to be __host__ __device__. So long as this count is greater
12050 /// than zero, all functions encountered will be __host__ __device__.
12051 void PushForceCUDAHostDevice();
12052
12053 /// Decrements our count of the number of times we've seen a pragma forcing
12054 /// functions to be __host__ __device__. Returns false if the count is 0
12055 /// before incrementing, so you can emit an error.
12056 bool PopForceCUDAHostDevice();
12057
12058 /// Diagnostics that are emitted only if we discover that the given function
12059 /// must be codegen'ed. Because handling these correctly adds overhead to
12060 /// compilation, this is currently only enabled for CUDA compilations.
12061 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
12062 std::vector<PartialDiagnosticAt>>
12063 DeviceDeferredDiags;
12064
12065 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
12066 /// key in a hashtable, both the FD and location are hashed.
12067 struct FunctionDeclAndLoc {
12068 CanonicalDeclPtr<FunctionDecl> FD;
12069 SourceLocation Loc;
12070 };
12071
12072 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
12073 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
12074 /// same deferred diag twice.
12075 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;
12076
12077 /// An inverse call graph, mapping known-emitted functions to one of their
12078 /// known-emitted callers (plus the location of the call).
12079 ///
12080 /// Functions that we can tell a priori must be emitted aren't added to this
12081 /// map.
12082 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
12083 /* Caller = */ FunctionDeclAndLoc>
12084 DeviceKnownEmittedFns;
12085
12086 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12087 /// context is "used as device code".
12088 ///
12089 /// - If CurContext is a __host__ function, does not emit any diagnostics
12090 /// unless \p EmitOnBothSides is true.
12091 /// - If CurContext is a __device__ or __global__ function, emits the
12092 /// diagnostics immediately.
12093 /// - If CurContext is a __host__ __device__ function and we are compiling for
12094 /// the device, creates a diagnostic which is emitted if and when we realize
12095 /// that the function will be codegen'ed.
12096 ///
12097 /// Example usage:
12098 ///
12099 /// // Variable-length arrays are not allowed in CUDA device code.
12100 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
12101 /// return ExprError();
12102 /// // Otherwise, continue parsing as normal.
12103 SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc,
12104 unsigned DiagID);
12105
12106 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12107 /// context is "used as host code".
12108 ///
12109 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
12110 SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
12111
12112 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12113 /// context is "used as device code".
12114 ///
12115 /// - If CurContext is a `declare target` function or it is known that the
12116 /// function is emitted for the device, emits the diagnostics immediately.
12117 /// - If CurContext is a non-`declare target` function and we are compiling
12118 /// for the device, creates a diagnostic which is emitted if and when we
12119 /// realize that the function will be codegen'ed.
12120 ///
12121 /// Example usage:
12122 ///
12123 /// // Variable-length arrays are not allowed in NVPTX device code.
12124 /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported))
12125 /// return ExprError();
12126 /// // Otherwise, continue parsing as normal.
12127 SemaDiagnosticBuilder
12128 diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD);
12129
12130 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12131 /// context is "used as host code".
12132 ///
12133 /// - If CurContext is a `declare target` function or it is known that the
12134 /// function is emitted for the host, emits the diagnostics immediately.
12135 /// - If CurContext is a non-host function, just ignore it.
12136 ///
12137 /// Example usage:
12138 ///
12139 /// // Variable-length arrays are not allowed in NVPTX device code.
12140 /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported))
12141 /// return ExprError();
12142 /// // Otherwise, continue parsing as normal.
12143 SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc,
12144 unsigned DiagID, FunctionDecl *FD);
12145
12146 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID,
12147 FunctionDecl *FD = nullptr);
12148 SemaDiagnosticBuilder targetDiag(SourceLocation Loc,
12149 const PartialDiagnostic &PD,
12150 FunctionDecl *FD = nullptr) {
12151 return targetDiag(Loc, PD.getDiagID(), FD) << PD;
12152 }
12153
12154 /// Check if the expression is allowed to be used in expressions for the
12155 /// offloading devices.
12156 void checkDeviceDecl(ValueDecl *D, SourceLocation Loc);
12157
12158 enum CUDAFunctionTarget {
12159 CFT_Device,
12160 CFT_Global,
12161 CFT_Host,
12162 CFT_HostDevice,
12163 CFT_InvalidTarget
12164 };
12165
12166 /// Determines whether the given function is a CUDA device/host/kernel/etc.
12167 /// function.
12168 ///
12169 /// Use this rather than examining the function's attributes yourself -- you
12170 /// will get it wrong. Returns CFT_Host if D is null.
12171 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
12172 bool IgnoreImplicitHDAttr = false);
12173 CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs);
12174
12175 enum CUDAVariableTarget {
12176 CVT_Device, /// Emitted on device side with a shadow variable on host side
12177 CVT_Host, /// Emitted on host side only
12178 CVT_Both, /// Emitted on both sides with different addresses
12179 CVT_Unified, /// Emitted as a unified address, e.g. managed variables
12180 };
12181 /// Determines whether the given variable is emitted on host or device side.
12182 CUDAVariableTarget IdentifyCUDATarget(const VarDecl *D);
12183
12184 /// Gets the CUDA target for the current context.
12185 CUDAFunctionTarget CurrentCUDATarget() {
12186 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
12187 }
12188
12189 static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);
12190
12191 // CUDA function call preference. Must be ordered numerically from
12192 // worst to best.
12193 enum CUDAFunctionPreference {
12194 CFP_Never, // Invalid caller/callee combination.
12195 CFP_WrongSide, // Calls from host-device to host or device
12196 // function that do not match current compilation
12197 // mode.
12198 CFP_HostDevice, // Any calls to host/device functions.
12199 CFP_SameSide, // Calls from host-device to host or device
12200 // function matching current compilation mode.
12201 CFP_Native, // host-to-host or device-to-device calls.
12202 };
12203
12204 /// Identifies relative preference of a given Caller/Callee
12205 /// combination, based on their host/device attributes.
12206 /// \param Caller function which needs address of \p Callee.
12207 /// nullptr in case of global context.
12208 /// \param Callee target function
12209 ///
12210 /// \returns preference value for particular Caller/Callee combination.
12211 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
12212 const FunctionDecl *Callee);
12213
12214 /// Determines whether Caller may invoke Callee, based on their CUDA
12215 /// host/device attributes. Returns false if the call is not allowed.
12216 ///
12217 /// Note: Will return true for CFP_WrongSide calls. These may appear in
12218 /// semantically correct CUDA programs, but only if they're never codegen'ed.
12219 bool IsAllowedCUDACall(const FunctionDecl *Caller,
12220 const FunctionDecl *Callee) {
12221 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
12222 }
12223
12224 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
12225 /// depending on FD and the current compilation settings.
12226 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
12227 const LookupResult &Previous);
12228
12229 /// May add implicit CUDAConstantAttr attribute to VD, depending on VD
12230 /// and current compilation settings.
12231 void MaybeAddCUDAConstantAttr(VarDecl *VD);
12232
12233public:
12234 /// Check whether we're allowed to call Callee from the current context.
12235 ///
12236 /// - If the call is never allowed in a semantically-correct program
12237 /// (CFP_Never), emits an error and returns false.
12238 ///
12239 /// - If the call is allowed in semantically-correct programs, but only if
12240 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
12241 /// be emitted if and when the caller is codegen'ed, and returns true.
12242 ///
12243 /// Will only create deferred diagnostics for a given SourceLocation once,
12244 /// so you can safely call this multiple times without generating duplicate
12245 /// deferred errors.
12246 ///
12247 /// - Otherwise, returns true without emitting any diagnostics.
12248 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
12249
12250 void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture);
12251
12252 /// Set __device__ or __host__ __device__ attributes on the given lambda
12253 /// operator() method.
12254 ///
12255 /// CUDA lambdas by default is host device function unless it has explicit
12256 /// host or device attribute.
12257 void CUDASetLambdaAttrs(CXXMethodDecl *Method);
12258
12259 /// Finds a function in \p Matches with highest calling priority
12260 /// from \p Caller context and erases all functions with lower
12261 /// calling priority.
12262 void EraseUnwantedCUDAMatches(
12263 const FunctionDecl *Caller,
12264 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
12265
12266 /// Given a implicit special member, infer its CUDA target from the
12267 /// calls it needs to make to underlying base/field special members.
12268 /// \param ClassDecl the class for which the member is being created.
12269 /// \param CSM the kind of special member.
12270 /// \param MemberDecl the special member itself.
12271 /// \param ConstRHS true if this is a copy operation with a const object on
12272 /// its RHS.
12273 /// \param Diagnose true if this call should emit diagnostics.
12274 /// \return true if there was an error inferring.
12275 /// The result of this call is implicit CUDA target attribute(s) attached to
12276 /// the member declaration.
12277 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
12278 CXXSpecialMember CSM,
12279 CXXMethodDecl *MemberDecl,
12280 bool ConstRHS,
12281 bool Diagnose);
12282
12283 /// \return true if \p CD can be considered empty according to CUDA
12284 /// (E.2.3.1 in CUDA 7.5 Programming guide).
12285 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
12286 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
12287
12288 // \brief Checks that initializers of \p Var satisfy CUDA restrictions. In
12289 // case of error emits appropriate diagnostic and invalidates \p Var.
12290 //
12291 // \details CUDA allows only empty constructors as initializers for global
12292 // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all
12293 // __shared__ variables whether they are local or not (they all are implicitly
12294 // static in CUDA). One exception is that CUDA allows constant initializers
12295 // for __constant__ and __device__ variables.
12296 void checkAllowedCUDAInitializer(VarDecl *VD);
12297
12298 /// Check whether NewFD is a valid overload for CUDA. Emits
12299 /// diagnostics and invalidates NewFD if not.
12300 void checkCUDATargetOverload(FunctionDecl *NewFD,
12301 const LookupResult &Previous);
12302 /// Copies target attributes from the template TD to the function FD.
12303 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);
12304
12305 /// Returns the name of the launch configuration function. This is the name
12306 /// of the function that will be called to configure kernel call, with the
12307 /// parameters specified via <<<>>>.
12308 std::string getCudaConfigureFuncName() const;
12309
12310 /// \name Code completion
12311 //@{
12312 /// Describes the context in which code completion occurs.
12313 enum ParserCompletionContext {
12314 /// Code completion occurs at top-level or namespace context.
12315 PCC_Namespace,
12316 /// Code completion occurs within a class, struct, or union.
12317 PCC_Class,
12318 /// Code completion occurs within an Objective-C interface, protocol,
12319 /// or category.
12320 PCC_ObjCInterface,
12321 /// Code completion occurs within an Objective-C implementation or
12322 /// category implementation
12323 PCC_ObjCImplementation,
12324 /// Code completion occurs within the list of instance variables
12325 /// in an Objective-C interface, protocol, category, or implementation.
12326 PCC_ObjCInstanceVariableList,
12327 /// Code completion occurs following one or more template
12328 /// headers.
12329 PCC_Template,
12330 /// Code completion occurs following one or more template
12331 /// headers within a class.
12332 PCC_MemberTemplate,
12333 /// Code completion occurs within an expression.
12334 PCC_Expression,
12335 /// Code completion occurs within a statement, which may
12336 /// also be an expression or a declaration.
12337 PCC_Statement,
12338 /// Code completion occurs at the beginning of the
12339 /// initialization statement (or expression) in a for loop.
12340 PCC_ForInit,
12341 /// Code completion occurs within the condition of an if,
12342 /// while, switch, or for statement.
12343 PCC_Condition,
12344 /// Code completion occurs within the body of a function on a
12345 /// recovery path, where we do not have a specific handle on our position
12346 /// in the grammar.
12347 PCC_RecoveryInFunction,
12348 /// Code completion occurs where only a type is permitted.
12349 PCC_Type,
12350 /// Code completion occurs in a parenthesized expression, which
12351 /// might also be a type cast.
12352 PCC_ParenthesizedExpression,
12353 /// Code completion occurs within a sequence of declaration
12354 /// specifiers within a function, method, or block.
12355 PCC_LocalDeclarationSpecifiers
12356 };
12357
12358 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
12359 void CodeCompleteOrdinaryName(Scope *S,
12360 ParserCompletionContext CompletionContext);
12361 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
12362 bool AllowNonIdentifiers,
12363 bool AllowNestedNameSpecifiers);
12364
12365 struct CodeCompleteExpressionData;
12366 void CodeCompleteExpression(Scope *S,
12367 const CodeCompleteExpressionData &Data);
12368 void CodeCompleteExpression(Scope *S, QualType PreferredType,
12369 bool IsParenthesized = false);
12370 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
12371 SourceLocation OpLoc, bool IsArrow,
12372 bool IsBaseExprStatement,
12373 QualType PreferredType);
12374 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
12375 QualType PreferredType);
12376 void CodeCompleteTag(Scope *S, unsigned TagSpec);
12377 void CodeCompleteTypeQualifiers(DeclSpec &DS);
12378 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
12379 const VirtSpecifiers *VS = nullptr);
12380 void CodeCompleteBracketDeclarator(Scope *S);
12381 void CodeCompleteCase(Scope *S);
12382 enum class AttributeCompletion {
12383 Attribute,
12384 Scope,
12385 None,
12386 };
12387 void CodeCompleteAttribute(
12388 AttributeCommonInfo::Syntax Syntax,
12389 AttributeCompletion Completion = AttributeCompletion::Attribute,
12390 const IdentifierInfo *Scope = nullptr);
12391 /// Determines the preferred type of the current function argument, by
12392 /// examining the signatures of all possible overloads.
12393 /// Returns null if unknown or ambiguous, or if code completion is off.
12394 ///
12395 /// If the code completion point has been reached, also reports the function
12396 /// signatures that were considered.
12397 ///
12398 /// FIXME: rename to GuessCallArgumentType to reduce confusion.
12399 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
12400 SourceLocation OpenParLoc);
12401 QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,
12402 SourceLocation Loc,
12403 ArrayRef<Expr *> Args,
12404 SourceLocation OpenParLoc);
12405 QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl,
12406 CXXScopeSpec SS,
12407 ParsedType TemplateTypeTy,
12408 ArrayRef<Expr *> ArgExprs,
12409 IdentifierInfo *II,
12410 SourceLocation OpenParLoc);
12411 void CodeCompleteInitializer(Scope *S, Decl *D);
12412 /// Trigger code completion for a record of \p BaseType. \p InitExprs are
12413 /// expressions in the initializer list seen so far and \p D is the current
12414 /// Designation being parsed.
12415 void CodeCompleteDesignator(const QualType BaseType,
12416 llvm::ArrayRef<Expr *> InitExprs,
12417 const Designation &D);
12418 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen);
12419
12420 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext,
12421 bool IsUsingDeclaration, QualType BaseType,
12422 QualType PreferredType);
12423 void CodeCompleteUsing(Scope *S);
12424 void CodeCompleteUsingDirective(Scope *S);
12425 void CodeCompleteNamespaceDecl(Scope *S);
12426 void CodeCompleteNamespaceAliasDecl(Scope *S);
12427 void CodeCompleteOperatorName(Scope *S);
12428 void CodeCompleteConstructorInitializer(
12429 Decl *Constructor,
12430 ArrayRef<CXXCtorInitializer *> Initializers);
12431
12432 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
12433 bool AfterAmpersand);
12434 void CodeCompleteAfterFunctionEquals(Declarator &D);
12435
12436 void CodeCompleteObjCAtDirective(Scope *S);
12437 void CodeCompleteObjCAtVisibility(Scope *S);
12438 void CodeCompleteObjCAtStatement(Scope *S);
12439 void CodeCompleteObjCAtExpression(Scope *S);
12440 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
12441 void CodeCompleteObjCPropertyGetter(Scope *S);
12442 void CodeCompleteObjCPropertySetter(Scope *S);
12443 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
12444 bool IsParameter);
12445 void CodeCompleteObjCMessageReceiver(Scope *S);
12446 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
12447 ArrayRef<IdentifierInfo *> SelIdents,
12448 bool AtArgumentExpression);
12449 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
12450 ArrayRef<IdentifierInfo *> SelIdents,
12451 bool AtArgumentExpression,
12452 bool IsSuper = false);
12453 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
12454 ArrayRef<IdentifierInfo *> SelIdents,
12455 bool AtArgumentExpression,
12456 ObjCInterfaceDecl *Super = nullptr);
12457 void CodeCompleteObjCForCollection(Scope *S,
12458 DeclGroupPtrTy IterationVar);
12459 void CodeCompleteObjCSelector(Scope *S,
12460 ArrayRef<IdentifierInfo *> SelIdents);
12461 void CodeCompleteObjCProtocolReferences(
12462 ArrayRef<IdentifierLocPair> Protocols);
12463 void CodeCompleteObjCProtocolDecl(Scope *S);
12464 void CodeCompleteObjCInterfaceDecl(Scope *S);
12465 void CodeCompleteObjCSuperclass(Scope *S,
12466 IdentifierInfo *ClassName,
12467 SourceLocation ClassNameLoc);
12468 void CodeCompleteObjCImplementationDecl(Scope *S);
12469 void CodeCompleteObjCInterfaceCategory(Scope *S,
12470 IdentifierInfo *ClassName,
12471 SourceLocation ClassNameLoc);
12472 void CodeCompleteObjCImplementationCategory(Scope *S,
12473 IdentifierInfo *ClassName,
12474 SourceLocation ClassNameLoc);
12475 void CodeCompleteObjCPropertyDefinition(Scope *S);
12476 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
12477 IdentifierInfo *PropertyName);
12478 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
12479 ParsedType ReturnType);
12480 void CodeCompleteObjCMethodDeclSelector(Scope *S,
12481 bool IsInstanceMethod,
12482 bool AtParameterName,
12483 ParsedType ReturnType,
12484 ArrayRef<IdentifierInfo *> SelIdents);
12485 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
12486 SourceLocation ClassNameLoc,
12487 bool IsBaseExprStatement);
12488 void CodeCompletePreprocessorDirective(bool InConditional);
12489 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
12490 void CodeCompletePreprocessorMacroName(bool IsDefinition);
12491 void CodeCompletePreprocessorExpression();
12492 void CodeCompletePreprocessorMacroArgument(Scope *S,
12493 IdentifierInfo *Macro,
12494 MacroInfo *MacroInfo,
12495 unsigned Argument);
12496 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
12497 void CodeCompleteNaturalLanguage();
12498 void CodeCompleteAvailabilityPlatformName();
12499 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
12500 CodeCompletionTUInfo &CCTUInfo,
12501 SmallVectorImpl<CodeCompletionResult> &Results);
12502 //@}
12503
12504 //===--------------------------------------------------------------------===//
12505 // Extra semantic analysis beyond the C type system
12506
12507public:
12508 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
12509 unsigned ByteNo) const;
12510
12511private:
12512 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
12513 const ArraySubscriptExpr *ASE=nullptr,
12514 bool AllowOnePastEnd=true, bool IndexNegated=false);
12515 void CheckArrayAccess(const Expr *E);
12516 // Used to grab the relevant information from a FormatAttr and a
12517 // FunctionDeclaration.
12518 struct FormatStringInfo {
12519 unsigned FormatIdx;
12520 unsigned FirstDataArg;
12521 bool HasVAListArg;
12522 };
12523
12524 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
12525 FormatStringInfo *FSI);
12526 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
12527 const FunctionProtoType *Proto);
12528 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
12529 ArrayRef<const Expr *> Args);
12530 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
12531 const FunctionProtoType *Proto);
12532 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
12533 void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
12534 ArrayRef<const Expr *> Args,
12535 const FunctionProtoType *Proto, SourceLocation Loc);
12536
12537 void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
12538 StringRef ParamName, QualType ArgTy, QualType ParamTy);
12539
12540 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
12541 const Expr *ThisArg, ArrayRef<const Expr *> Args,
12542 bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
12543 VariadicCallType CallType);
12544
12545 bool CheckObjCString(Expr *Arg);
12546 ExprResult CheckOSLogFormatStringArg(Expr *Arg);
12547
12548 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
12549 unsigned BuiltinID, CallExpr *TheCall);
12550
12551 bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12552 CallExpr *TheCall);
12553
12554 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall);
12555
12556 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
12557 unsigned MaxWidth);
12558 bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12559 CallExpr *TheCall);
12560 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12561 bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12562 bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12563 CallExpr *TheCall);
12564 bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg,
12565 bool WantCDE);
12566 bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12567 CallExpr *TheCall);
12568
12569 bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12570 CallExpr *TheCall);
12571 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12572 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12573 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12574 bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12575 CallExpr *TheCall);
12576 bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
12577 CallExpr *TheCall);
12578 bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12579 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12580 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
12581 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
12582 bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall);
12583 bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
12584 ArrayRef<int> ArgNums);
12585 bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums);
12586 bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
12587 ArrayRef<int> ArgNums);
12588 bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12589 CallExpr *TheCall);
12590 bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12591 CallExpr *TheCall);
12592 bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12593 bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum);
12594 bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12595 CallExpr *TheCall);
12596
12597 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
12598 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
12599 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
12600 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
12601 bool SemaBuiltinComplex(CallExpr *TheCall);
12602 bool SemaBuiltinVSX(CallExpr *TheCall);
12603 bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
12604 bool SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum);
12605
12606public:
12607 // Used by C++ template instantiation.
12608 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
12609 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
12610 SourceLocation BuiltinLoc,
12611 SourceLocation RParenLoc);
12612
12613private:
12614 bool SemaBuiltinPrefetch(CallExpr *TheCall);
12615 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
12616 bool SemaBuiltinArithmeticFence(CallExpr *TheCall);
12617 bool SemaBuiltinAssume(CallExpr *TheCall);
12618 bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
12619 bool SemaBuiltinLongjmp(CallExpr *TheCall);
12620 bool SemaBuiltinSetjmp(CallExpr *TheCall);
12621 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
12622 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
12623 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
12624 AtomicExpr::AtomicOp Op);
12625 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
12626 bool IsDelete);
12627 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
12628 llvm::APSInt &Result);
12629 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
12630 int High, bool RangeIsError = true);
12631 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
12632 unsigned Multiple);
12633 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum);
12634 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
12635 unsigned ArgBits);
12636 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,
12637 unsigned ArgBits);
12638 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
12639 int ArgNum, unsigned ExpectedFieldNum,
12640 bool AllowName);
12641 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
12642 bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc);
12643
12644 bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);
12645
12646 // Matrix builtin handling.
12647 ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
12648 ExprResult CallResult);
12649 ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
12650 ExprResult CallResult);
12651 ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
12652 ExprResult CallResult);
12653
12654public:
12655 enum FormatStringType {
12656 FST_Scanf,
12657 FST_Printf,
12658 FST_NSString,
12659 FST_Strftime,
12660 FST_Strfmon,
12661 FST_Kprintf,
12662 FST_FreeBSDKPrintf,
12663 FST_OSTrace,
12664 FST_OSLog,
12665 FST_Unknown
12666 };
12667 static FormatStringType GetFormatStringType(const FormatAttr *Format);
12668
12669 bool FormatStringHasSArg(const StringLiteral *FExpr);
12670
12671 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);
12672
12673private:
12674 bool CheckFormatArguments(const FormatAttr *Format,
12675 ArrayRef<const Expr *> Args,
12676 bool IsCXXMember,
12677 VariadicCallType CallType,
12678 SourceLocation Loc, SourceRange Range,
12679 llvm::SmallBitVector &CheckedVarArgs);
12680 bool CheckFormatArguments(ArrayRef<const Expr *> Args,
12681 bool HasVAListArg, unsigned format_idx,
12682 unsigned firstDataArg, FormatStringType Type,
12683 VariadicCallType CallType,
12684 SourceLocation Loc, SourceRange range,
12685 llvm::SmallBitVector &CheckedVarArgs);
12686
12687 void CheckAbsoluteValueFunction(const CallExpr *Call,
12688 const FunctionDecl *FDecl);
12689
12690 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
12691
12692 void CheckMemaccessArguments(const CallExpr *Call,
12693 unsigned BId,
12694 IdentifierInfo *FnName);
12695
12696 void CheckStrlcpycatArguments(const CallExpr *Call,
12697 IdentifierInfo *FnName);
12698
12699 void CheckStrncatArguments(const CallExpr *Call,
12700 IdentifierInfo *FnName);
12701
12702 void CheckFreeArguments(const CallExpr *E);
12703
12704 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
12705 SourceLocation ReturnLoc,
12706 bool isObjCMethod = false,
12707 const AttrVec *Attrs = nullptr,
12708 const FunctionDecl *FD = nullptr);
12709
12710public:
12711 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
12712
12713private:
12714 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
12715 void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
12716 void CheckForIntOverflow(Expr *E);
12717 void CheckUnsequencedOperations(const Expr *E);
12718
12719 /// Perform semantic checks on a completed expression. This will either
12720 /// be a full-expression or a default argument expression.
12721 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
12722 bool IsConstexpr = false);
12723
12724 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
12725 Expr *Init);
12726
12727 /// Check if there is a field shadowing.
12728 void CheckShadowInheritedFields(const SourceLocation &Loc,
12729 DeclarationName FieldName,
12730 const CXXRecordDecl *RD,
12731 bool DeclIsField = true);
12732
12733 /// Check if the given expression contains 'break' or 'continue'
12734 /// statement that produces control flow different from GCC.
12735 void CheckBreakContinueBinding(Expr *E);
12736
12737 /// Check whether receiver is mutable ObjC container which
12738 /// attempts to add itself into the container
12739 void CheckObjCCircularContainer(ObjCMessageExpr *Message);
12740
12741 void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee);
12742
12743 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
12744 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
12745 bool DeleteWasArrayForm);
12746public:
12747 /// Register a magic integral constant to be used as a type tag.
12748 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
12749 uint64_t MagicValue, QualType Type,
12750 bool LayoutCompatible, bool MustBeNull);
12751
12752 struct TypeTagData {
12753 TypeTagData() {}
12754
12755 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
12756 Type(Type), LayoutCompatible(LayoutCompatible),
12757 MustBeNull(MustBeNull)
12758 {}
12759
12760 QualType Type;
12761
12762 /// If true, \c Type should be compared with other expression's types for
12763 /// layout-compatibility.
12764 unsigned LayoutCompatible : 1;
12765 unsigned MustBeNull : 1;
12766 };
12767
12768 /// A pair of ArgumentKind identifier and magic value. This uniquely
12769 /// identifies the magic value.
12770 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
12771
12772private:
12773 /// A map from magic value to type information.
12774 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
12775 TypeTagForDatatypeMagicValues;
12776
12777 /// Peform checks on a call of a function with argument_with_type_tag
12778 /// or pointer_with_type_tag attributes.
12779 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
12780 const ArrayRef<const Expr *> ExprArgs,
12781 SourceLocation CallSiteLoc);
12782
12783 /// Check if we are taking the address of a packed field
12784 /// as this may be a problem if the pointer value is dereferenced.
12785 void CheckAddressOfPackedMember(Expr *rhs);
12786
12787 /// The parser's current scope.
12788 ///
12789 /// The parser maintains this state here.
12790 Scope *CurScope;
12791
12792 mutable IdentifierInfo *Ident_super;
12793 mutable IdentifierInfo *Ident___float128;
12794
12795 /// Nullability type specifiers.
12796 IdentifierInfo *Ident__Nonnull = nullptr;
12797 IdentifierInfo *Ident__Nullable = nullptr;
12798 IdentifierInfo *Ident__Nullable_result = nullptr;
12799 IdentifierInfo *Ident__Null_unspecified = nullptr;
12800
12801 IdentifierInfo *Ident_NSError = nullptr;
12802
12803 /// The handler for the FileChanged preprocessor events.
12804 ///
12805 /// Used for diagnostics that implement custom semantic analysis for #include
12806 /// directives, like -Wpragma-pack.
12807 sema::SemaPPCallbacks *SemaPPCallbackHandler;
12808
12809protected:
12810 friend class Parser;
12811 friend class InitializationSequence;
12812 friend class ASTReader;
12813 friend class ASTDeclReader;
12814 friend class ASTWriter;
12815
12816public:
12817 /// Retrieve the keyword associated
12818 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
12819
12820 /// The struct behind the CFErrorRef pointer.
12821 RecordDecl *CFError = nullptr;
12822 bool isCFError(RecordDecl *D);
12823
12824 /// Retrieve the identifier "NSError".
12825 IdentifierInfo *getNSErrorIdent();
12826
12827 /// Retrieve the parser's current scope.
12828 ///
12829 /// This routine must only be used when it is certain that semantic analysis
12830 /// and the parser are in precisely the same context, which is not the case
12831 /// when, e.g., we are performing any kind of template instantiation.
12832 /// Therefore, the only safe places to use this scope are in the parser
12833 /// itself and in routines directly invoked from the parser and *never* from
12834 /// template substitution or instantiation.
12835 Scope *getCurScope() const { return CurScope; }
12836
12837 void incrementMSManglingNumber() const {
12838 return CurScope->incrementMSManglingNumber();
12839 }
12840
12841 IdentifierInfo *getSuperIdentifier() const;
12842 IdentifierInfo *getFloat128Identifier() const;
12843
12844 Decl *getObjCDeclContext() const;
12845
12846 DeclContext *getCurLexicalContext() const {
12847 return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
12848 }
12849
12850 const DeclContext *getCurObjCLexicalContext() const {
12851 const DeclContext *DC = getCurLexicalContext();
12852 // A category implicitly has the attribute of the interface.
12853 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
12854 DC = CatD->getClassInterface();
12855 return DC;
12856 }
12857
12858 /// Determine the number of levels of enclosing template parameters. This is
12859 /// only usable while parsing. Note that this does not include dependent
12860 /// contexts in which no template parameters have yet been declared, such as
12861 /// in a terse function template or generic lambda before the first 'auto' is
12862 /// encountered.
12863 unsigned getTemplateDepth(Scope *S) const;
12864
12865 /// To be used for checking whether the arguments being passed to
12866 /// function exceeds the number of parameters expected for it.
12867 static bool TooManyArguments(size_t NumParams, size_t NumArgs,
12868 bool PartialOverloading = false) {
12869 // We check whether we're just after a comma in code-completion.
12870 if (NumArgs > 0 && PartialOverloading)
12871 return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
12872 return NumArgs > NumParams;
12873 }
12874
12875 // Emitting members of dllexported classes is delayed until the class
12876 // (including field initializers) is fully parsed.
12877 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
12878 SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions;
12879
12880private:
12881 int ParsingClassDepth = 0;
12882
12883 class SavePendingParsedClassStateRAII {
12884 public:
12885 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
12886
12887 ~SavePendingParsedClassStateRAII() {
12888 assert(S.DelayedOverridingExceptionSpecChecks.empty() &&(static_cast <bool> (S.DelayedOverridingExceptionSpecChecks
.empty() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedOverridingExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 12889, __extension__ __PRETTY_FUNCTION__))
12889 "there shouldn't be any pending delayed exception spec checks")(static_cast <bool> (S.DelayedOverridingExceptionSpecChecks
.empty() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedOverridingExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 12889, __extension__ __PRETTY_FUNCTION__))
;
12890 assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&(static_cast <bool> (S.DelayedEquivalentExceptionSpecChecks
.empty() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedEquivalentExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 12891, __extension__ __PRETTY_FUNCTION__))
12891 "there shouldn't be any pending delayed exception spec checks")(static_cast <bool> (S.DelayedEquivalentExceptionSpecChecks
.empty() && "there shouldn't be any pending delayed exception spec checks"
) ? void (0) : __assert_fail ("S.DelayedEquivalentExceptionSpecChecks.empty() && \"there shouldn't be any pending delayed exception spec checks\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/Sema/Sema.h"
, 12891, __extension__ __PRETTY_FUNCTION__))
;
12892 swapSavedState();
12893 }
12894
12895 private:
12896 Sema &S;
12897 decltype(DelayedOverridingExceptionSpecChecks)
12898 SavedOverridingExceptionSpecChecks;
12899 decltype(DelayedEquivalentExceptionSpecChecks)
12900 SavedEquivalentExceptionSpecChecks;
12901
12902 void swapSavedState() {
12903 SavedOverridingExceptionSpecChecks.swap(
12904 S.DelayedOverridingExceptionSpecChecks);
12905 SavedEquivalentExceptionSpecChecks.swap(
12906 S.DelayedEquivalentExceptionSpecChecks);
12907 }
12908 };
12909
12910 /// Helper class that collects misaligned member designations and
12911 /// their location info for delayed diagnostics.
12912 struct MisalignedMember {
12913 Expr *E;
12914 RecordDecl *RD;
12915 ValueDecl *MD;
12916 CharUnits Alignment;
12917
12918 MisalignedMember() : E(), RD(), MD(), Alignment() {}
12919 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
12920 CharUnits Alignment)
12921 : E(E), RD(RD), MD(MD), Alignment(Alignment) {}
12922 explicit MisalignedMember(Expr *E)
12923 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}
12924
12925 bool operator==(const MisalignedMember &m) { return this->E == m.E; }
12926 };
12927 /// Small set of gathered accesses to potentially misaligned members
12928 /// due to the packed attribute.
12929 SmallVector<MisalignedMember, 4> MisalignedMembers;
12930
12931 /// Adds an expression to the set of gathered misaligned members.
12932 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
12933 CharUnits Alignment);
12934
12935public:
12936 /// Diagnoses the current set of gathered accesses. This typically
12937 /// happens at full expression level. The set is cleared after emitting the
12938 /// diagnostics.
12939 void DiagnoseMisalignedMembers();
12940
12941 /// This function checks if the expression is in the sef of potentially
12942 /// misaligned members and it is converted to some pointer type T with lower
12943 /// or equal alignment requirements. If so it removes it. This is used when
12944 /// we do not want to diagnose such misaligned access (e.g. in conversions to
12945 /// void*).
12946 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
12947
12948 /// This function calls Action when it determines that E designates a
12949 /// misaligned member due to the packed attribute. This is used to emit
12950 /// local diagnostics like in reference binding.
12951 void RefersToMemberWithReducedAlignment(
12952 Expr *E,
12953 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
12954 Action);
12955
12956 /// Describes the reason a calling convention specification was ignored, used
12957 /// for diagnostics.
12958 enum class CallingConventionIgnoredReason {
12959 ForThisTarget = 0,
12960 VariadicFunction,
12961 ConstructorDestructor,
12962 BuiltinFunction
12963 };
12964 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12965 /// context is "used as device code".
12966 ///
12967 /// - If CurLexicalContext is a kernel function or it is known that the
12968 /// function will be emitted for the device, emits the diagnostics
12969 /// immediately.
12970 /// - If CurLexicalContext is a function and we are compiling
12971 /// for the device, but we don't know that this function will be codegen'ed
12972 /// for devive yet, creates a diagnostic which is emitted if and when we
12973 /// realize that the function will be codegen'ed.
12974 ///
12975 /// Example usage:
12976 ///
12977 /// Diagnose __float128 type usage only from SYCL device code if the current
12978 /// target doesn't support it
12979 /// if (!S.Context.getTargetInfo().hasFloat128Type() &&
12980 /// S.getLangOpts().SYCLIsDevice)
12981 /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128";
12982 SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc,
12983 unsigned DiagID);
12984
12985 /// Check whether we're allowed to call Callee from the current context.
12986 ///
12987 /// - If the call is never allowed in a semantically-correct program
12988 /// emits an error and returns false.
12989 ///
12990 /// - If the call is allowed in semantically-correct programs, but only if
12991 /// it's never codegen'ed, creates a deferred diagnostic to be emitted if
12992 /// and when the caller is codegen'ed, and returns true.
12993 ///
12994 /// - Otherwise, returns true without emitting any diagnostics.
12995 ///
12996 /// Adds Callee to DeviceCallGraph if we don't know if its caller will be
12997 /// codegen'ed yet.
12998 bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee);
12999};
13000
13001/// RAII object that enters a new expression evaluation context.
13002class EnterExpressionEvaluationContext {
13003 Sema &Actions;
13004 bool Entered = true;
13005
13006public:
13007 EnterExpressionEvaluationContext(
13008 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
13009 Decl *LambdaContextDecl = nullptr,
13010 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
13011 Sema::ExpressionEvaluationContextRecord::EK_Other,
13012 bool ShouldEnter = true)
13013 : Actions(Actions), Entered(ShouldEnter) {
13014 if (Entered)
13015 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
13016 ExprContext);
13017 }
13018 EnterExpressionEvaluationContext(
13019 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
13020 Sema::ReuseLambdaContextDecl_t,
13021 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
13022 Sema::ExpressionEvaluationContextRecord::EK_Other)
13023 : Actions(Actions) {
13024 Actions.PushExpressionEvaluationContext(
13025 NewContext, Sema::ReuseLambdaContextDecl, ExprContext);
13026 }
13027
13028 enum InitListTag { InitList };
13029 EnterExpressionEvaluationContext(Sema &Actions, InitListTag,
13030 bool ShouldEnter = true)
13031 : Actions(Actions), Entered(false) {
13032 // In C++11 onwards, narrowing checks are performed on the contents of
13033 // braced-init-lists, even when they occur within unevaluated operands.
13034 // Therefore we still need to instantiate constexpr functions used in such
13035 // a context.
13036 if (ShouldEnter && Actions.isUnevaluatedContext() &&
13037 Actions.getLangOpts().CPlusPlus11) {
13038 Actions.PushExpressionEvaluationContext(
13039 Sema::ExpressionEvaluationContext::UnevaluatedList);
13040 Entered = true;
13041 }
13042 }
13043
13044 ~EnterExpressionEvaluationContext() {
13045 if (Entered)
13046 Actions.PopExpressionEvaluationContext();
13047 }
13048};
13049
13050DeductionFailureInfo
13051MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
13052 sema::TemplateDeductionInfo &Info);
13053
13054/// Contains a late templated function.
13055/// Will be parsed at the end of the translation unit, used by Sema & Parser.
13056struct LateParsedTemplate {
13057 CachedTokens Toks;
13058 /// The template function declaration to be late parsed.
13059 Decl *D;
13060};
13061
13062template <>
13063void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
13064 PragmaMsStackAction Action,
13065 llvm::StringRef StackSlotLabel,
13066 AlignPackInfo Value);
13067
13068} // end namespace clang
13069
13070namespace llvm {
13071// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
13072// SourceLocation.
13073template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
13074 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
13075 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;
13076
13077 static FunctionDeclAndLoc getEmptyKey() {
13078 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};
13079 }
13080
13081 static FunctionDeclAndLoc getTombstoneKey() {
13082 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};
13083 }
13084
13085 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
13086 return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
13087 FDL.Loc.getHashValue());
13088 }
13089
13090 static bool isEqual(const FunctionDeclAndLoc &LHS,
13091 const FunctionDeclAndLoc &RHS) {
13092 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
13093 }
13094};
13095} // namespace llvm
13096
13097#endif