Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/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 amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateInstantiate.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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?")((void)0);
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?")((void)0);
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?")((void)0);
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!")__builtin_unreachable();
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() &&
68
Assuming the condition is false
245 SemaRef.hasUncompilableErrorOccurred()) {
246 Invalid = true;
247 return;
248 }
249 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
250 if (!Invalid) {
69
Assuming field 'Invalid' is false, which participates in a condition later
70
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
70.1
Field 'Entity' is non-null
70.1
Field 'Entity' is non-null
? false :
71
'?' condition is false
263 !SemaRef.InstantiatingSpecializations
72
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,
67
Calling constructor for 'InstantiatingTemplate'
73
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(((void)0)
304 Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||((void)0)
305 Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)((void)0);
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)((void)0);
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() >=((void)0)
459 CodeSynthesisContextLookupModules.size() &&((void)0)
460 "forgot to remove a lookup module for a template instantiation")((void)0);
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 <=((void)0)
498 SemaRef.CodeSynthesisContexts.size())((void)0);
499 if ((SemaRef.CodeSynthesisContexts.size() -
500 SemaRef.NonInstantiationEntries)
501 <= SemaRef.getLangOpts().InstantiationDepth)
502 return false;
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")__builtin_unreachable();
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))((void)0);
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")((void)0);
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 &&((void)0)
1018 "should only have multiple expansions for a pack")((void)0);
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)((void)0);
1209 assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())((void)0);
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 &&((void)0)
1234 "Missing argument pack")((void)0);
1235 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1236 }
1237
1238 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
1239 assert(!Template.isNull() && Template.getAsTemplateDecl() &&((void)0)
1240 "Wrong kind of template template argument")((void)0);
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 &&((void)0)
1275 "Missing argument pack")((void)0);
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() &&((void)0)
1376 "unexpected pack arguments in template rewrite")((void)0);
1377 Arg = Arg.pack_begin()->getPackExpansionPattern();
1378 }
1379 assert(Arg.getKind() == TemplateArgument::Template &&((void)0)
1380 "unexpected nontype template argument kind in template rewrite")((void)0);
1381 return Arg.getAsTemplate();
1382 }
1383
1384 if (TTP->isParameterPack()) {
1385 assert(Arg.getKind() == TemplateArgument::Pack &&((void)0)
1386 "Missing argument pack")((void)0);
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")((void)0);
1400 assert(!Template.getAsQualifiedTemplateName() &&((void)0)
1401 "template decl to substitute is qualified?")((void)0);
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() &&((void)0)
1449 "unexpected pack arguments in template rewrite")((void)0);
1450 Arg = Arg.pack_begin()->getPackExpansionPattern();
1451 }
1452 assert(Arg.getKind() == TemplateArgument::Expression &&((void)0)
1453 "unexpected nontype template argument kind in template rewrite")((void)0);
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 &&((void)0)
1461 "Missing argument pack")((void)0);
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")((void)0);
1562 assert(!paramType->isDependentType() && "param type still dependent")((void)0);
1563 result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, paramType, loc);
1564 refParam = paramType->isReferenceType();
1565 } else {
1566 result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1567 assert(result.isInvalid() ||((void)0)
1568 SemaRef.Context.hasSameType(result.get()->getType(),((void)0)
1569 arg.getIntegralType()))((void)0);
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")((void)0);
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())->((void)0)
1732 getDescribedFunctionTemplate() &&((void)0)
1733 "Default arg expressions are never formed in dependent cases.")((void)0);
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() &&((void)0)
1790 "unexpected pack arguments in template rewrite")((void)0);
1791 Arg = Arg.pack_begin()->getPackExpansionPattern();
1792 }
1793 assert(Arg.getKind() == TemplateArgument::Type &&((void)0)
1794 "unexpected nontype template argument kind in template rewrite")((void)0);
1795 QualType NewT = Arg.getAsType();
1796 assert(isa<TemplateTypeParmType>(NewT) &&((void)0)
1797 "type parm not rewritten to type parm")((void)0);
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 &&((void)0)
1805 "Missing argument pack")((void)0);
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 &&((void)0)
1823 "Template argument kind mismatch")((void)0);
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() &&((void)0)
1986 "All code paths leading here must set TransRetReq")((void)0);
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() &&((void)0)
2070 "Cannot perform an instantiation without some context on the "((void)0)
2071 "instantiation stack")((void)0);
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() &&((void)0)
2087 "Cannot perform an instantiation without some context on the "((void)0)
2088 "instantiation stack")((void)0);
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() &&((void)0)
2117 "Cannot perform an instantiation without some context on the "((void)0)
2118 "instantiation stack")((void)0);
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() &&((void)0)
2162 "Cannot perform an instantiation without some context on the "((void)0)
2163 "instantiation stack")((void)0);
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)((void)0);
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() &&((void)0)
2473 "Cannot perform an instantiation without some context on the "((void)0)
2474 "instantiation stack")((void)0);
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());
59
Assuming the object is a 'CXXRecordDecl'
2632 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
60
Assuming the condition is false
61
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
62
Assuming 'MSInfo' is null
63
Taking false branch
2649 = Instantiation->getMemberSpecializationInfo()) {
2650 MSInfo->setTemplateSpecializationKind(TSK);
2651 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2652 } else if (ClassTemplateSpecializationDecl *Spec
64.1
'Spec' is null
64.1
'Spec' is null
65
Taking false branch
2653 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
64
Assuming 'Instantiation' is not a 'ClassTemplateSpecializationDecl'
2654 Spec->setTemplateSpecializationKind(TSK); 2655 Spec->setPointOfInstantiation(PointOfInstantiation); 2656 } 2657 2658 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
66
Calling constructor for 'InstantiatingTemplate'
74
Returning from constructor for 'InstantiatingTemplate'
2659 if (Inst.isInvalid())
75
Calling 'InstantiatingTemplate::isInvalid'
77
Returning from 'InstantiatingTemplate::isInvalid'
78
Taking false branch
2660 return true; 2661 assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")((void)0); 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))
79
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")((void)0); 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)
80
Assuming field 'ParsingClassDepth' is not equal to 0
81
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(),
83
Loop condition is true. Entering loop body
2786 E = LateAttrs.end(); I != E; ++I) {
82
Assuming 'I' is not equal to 'E'
2787 assert(CurrentInstantiationScope == Instantiator.getStartingScope())((void)0); 2788 CurrentInstantiationScope = I->Scope; 2789 2790 // Allow 'this' within late-parsed attributes. 2791 NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
84
Assuming field 'NewDecl' is not a 'NamedDecl'
85
'ND' initialized to a null pointer value
2792 CXXRecordDecl *ThisContext = 2793 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
86
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() ==((void)0) 2957 Pattern->getInClassInitStyle() &&((void)0) 2958 "pattern and instantiation disagree about init style")((void)0); 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")((void)0); 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(((void)0) 3224 (TSK == TSK_ExplicitInstantiationDefinition ||((void)0) 3225 TSK == TSK_ExplicitInstantiationDeclaration ||((void)0) 3226 (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&((void)0) 3227 "Unexpected template specialization kind!")((void)0); 3228 for (auto *D : Instantiation->decls()) { 3229 bool SuppressNew = false; 3230 if (auto *Function
2.1
'Function' is null
22.1
'Function' is null
41.1
'Function' is null
2.1
'Function' is null
22.1
'Function' is null
41.1
'Function' is null
= dyn_cast<FunctionDecl>(D)) {
2
Assuming 'D' is not a 'FunctionDecl'
3
Taking false branch
22
Assuming 'D' is not a 'FunctionDecl'
23
Taking false branch
41
Assuming 'D' is not a 'FunctionDecl'
42
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?")((void)0); 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
4.1
'Var' is null
24.1
'Var' is null
43.1
'Var' is null
4.1
'Var' is null
24.1
'Var' is null
43.1
'Var' is null
= dyn_cast<VarDecl>(D)) {
4
Assuming 'D' is not a 'VarDecl'
5
Taking false branch
24
Assuming 'D' is not a 'VarDecl'
25
Taking false branch
43
Assuming 'D' is not a 'VarDecl'
44
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?")((void)0); 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
6.1
'Record' is non-null
26.1
'Record' is non-null
45.1
'Record' is non-null
6.1
'Record' is non-null
26.1
'Record' is non-null
45.1
'Record' is non-null
= dyn_cast<CXXRecordDecl>(D)) {
6
Assuming 'D' is a 'CXXRecordDecl'
7
Taking true branch
26
Assuming 'D' is a 'CXXRecordDecl'
27
Taking true branch
45
Assuming 'D' is a 'CXXRecordDecl'
46
Taking true branch
3313 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
8
Taking false branch
28
Taking false branch
47
Taking false branch
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() ||
9
Assuming the condition is false
10
Taking false branch
29
Assuming the condition is false
30
Taking false branch
48
Assuming the condition is false
49
Taking false branch
3322 Record->isLambda()) 3323 continue; 3324 3325 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo(); 3326 assert(MSInfo && "No member specialization information?")((void)0); 3327 3328 if (MSInfo->getTemplateSpecializationKind()
11
Assuming the condition is false
12
Taking false branch
31
Assuming the condition is false
32
Taking false branch
50
Assuming the condition is false
51
Taking false branch
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,
13
Assuming the condition is false
14
Assuming the condition is false
15
Taking false branch
33
Assuming the condition is false
34
Assuming the condition is false
35
Taking false branch
52
Assuming the condition is false
53
Assuming the condition is false
54
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")((void)0); 3353 3354 if (!Record->getDefinition()) {
16
Assuming the condition is false
17
Taking false branch
36
Assuming the condition is false
37
Taking false branch
55
Taking true branch
3355 if (!Pattern->getDefinition()) {
56
Assuming the condition is false
57
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,
58
Calling 'Sema::InstantiateClass'
3371 TemplateArgs, 3372 TSK); 3373 } else { 3374 if (TSK
37.1
'TSK' is not equal to TSK_ExplicitInstantiationDefinition
37.1
'TSK' is not equal to TSK_ExplicitInstantiationDefinition
== TSK_ExplicitInstantiationDefinition
&&
18
Assuming 'TSK' is not equal to 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());
19
Assuming the object is a 'CXXRecordDecl'
38
Assuming the object is a 'CXXRecordDecl'
3383 if (Pattern
19.1
'Pattern' is non-null
38.1
'Pattern' is non-null
19.1
'Pattern' is non-null
38.1
'Pattern' is non-null
)
20
Taking true branch
39
Taking true branch
3384 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
21
Calling 'Sema::InstantiateClassMembers'
40
Calling 'Sema::InstantiateClassMembers'
3385 TSK); 3386 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) { 3387 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo(); 3388 assert(MSInfo && "No member specialization information?")((void)0); 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")((void)0); 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)((void)0); 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,
1
Calling 'Sema::InstantiateClassMembers'
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")((void)0); 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 NDEBUG1 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() &&((void)0) 3632 "Instantiated local in inner and outer scopes")((void)0); 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")((void)0); 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 NDEBUG1 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() &&((void)0) 3656 "Creating local pack after instantiation of local")((void)0); 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) &&((void)0) 3677 "Already have a partially-substituted pack")((void)0); 3678 assert((!PartiallySubstitutedPack((void)0) 3679 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&((void)0) 3680 "Wrong number of arguments in partially-substituted pack")((void)0); 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}

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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() &&((void)0)
380 "should not have found a non-externally-declarable previous decl")((void)0);
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 = 29;
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.")((void)0);
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) &&((void)0)
655 "Can only push / pop #pragma stack sentinels!")((void)0);
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)((void)0);
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")((void)0);
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))((void)0);
1056 }
1057
1058 void addContextNote(SourceLocation UseLoc) {
1059 assert(!PushedCodeSynthesisContext)((void)0);
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) : S(S), OldFPFeaturesState(S.CurFPFeatures) {
1506 OldOverrides = S.FpPragmaStack.CurrentValue;
1507 }
1508 ~FPFeaturesStateRAII() {
1509 S.CurFPFeatures = OldFPFeaturesState;
1510 S.FpPragmaStack.CurrentValue = OldOverrides;
1511 }
1512 FPOptionsOverride getOverrides() { return OldOverrides; }
1513
1514 private:
1515 Sema& S;
1516 FPOptions OldFPFeaturesState;
1517 FPOptionsOverride OldOverrides;
1518 };
1519
1520 void addImplicitTypedef(StringRef Name, QualType T);
1521
1522 bool WarnedStackExhausted = false;
1523
1524 /// Increment when we find a reference; decrement when we find an ignored
1525 /// assignment. Ultimately the value is 0 if every reference is an ignored
1526 /// assignment.
1527 llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;
1528
1529 Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1530
1531public:
1532 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1533 TranslationUnitKind TUKind = TU_Complete,
1534 CodeCompleteConsumer *CompletionConsumer = nullptr);
1535 ~Sema();
1536
1537 /// Perform initialization that occurs after the parser has been
1538 /// initialized but before it parses anything.
1539 void Initialize();
1540
1541 /// This virtual key function only exists to limit the emission of debug info
1542 /// describing the Sema class. GCC and Clang only emit debug info for a class
1543 /// with a vtable when the vtable is emitted. Sema is final and not
1544 /// polymorphic, but the debug info size savings are so significant that it is
1545 /// worth adding a vtable just to take advantage of this optimization.
1546 virtual void anchor();
1547
1548 const LangOptions &getLangOpts() const { return LangOpts; }
1549 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1550 FPOptions &getCurFPFeatures() { return CurFPFeatures; }
1551
1552 DiagnosticsEngine &getDiagnostics() const { return Diags; }
1553 SourceManager &getSourceManager() const { return SourceMgr; }
1554 Preprocessor &getPreprocessor() const { return PP; }
1555 ASTContext &getASTContext() const { return Context; }
1556 ASTConsumer &getASTConsumer() const { return Consumer; }
1557 ASTMutationListener *getASTMutationListener() const;
1558 ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1559 DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,
1560 StringRef Platform);
1561
1562 ///Registers an external source. If an external source already exists,
1563 /// creates a multiplex external source and appends to it.
1564 ///
1565 ///\param[in] E - A non-null external sema source.
1566 ///
1567 void addExternalSource(ExternalSemaSource *E);
1568
1569 void PrintStats() const;
1570
1571 /// Warn that the stack is nearly exhausted.
1572 void warnStackExhausted(SourceLocation Loc);
1573
1574 /// Run some code with "sufficient" stack space. (Currently, at least 256K is
1575 /// guaranteed). Produces a warning if we're low on stack space and allocates
1576 /// more in that case. Use this in code that may recurse deeply (for example,
1577 /// in template instantiation) to avoid stack overflow.
1578 void runWithSufficientStackSpace(SourceLocation Loc,
1579 llvm::function_ref<void()> Fn);
1580
1581 /// Helper class that creates diagnostics with optional
1582 /// template instantiation stacks.
1583 ///
1584 /// This class provides a wrapper around the basic DiagnosticBuilder
1585 /// class that emits diagnostics. ImmediateDiagBuilder is
1586 /// responsible for emitting the diagnostic (as DiagnosticBuilder
1587 /// does) and, if the diagnostic comes from inside a template
1588 /// instantiation, printing the template instantiation stack as
1589 /// well.
1590 class ImmediateDiagBuilder : public DiagnosticBuilder {
1591 Sema &SemaRef;
1592 unsigned DiagID;
1593
1594 public:
1595 ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1596 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1597 ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1598 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1599
1600 // This is a cunning lie. DiagnosticBuilder actually performs move
1601 // construction in its copy constructor (but due to varied uses, it's not
1602 // possible to conveniently express this as actual move construction). So
1603 // the default copy ctor here is fine, because the base class disables the
1604 // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1605 // in that case anwyay.
1606 ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1607
1608 ~ImmediateDiagBuilder() {
1609 // If we aren't active, there is nothing to do.
1610 if (!isActive()) return;
1611
1612 // Otherwise, we need to emit the diagnostic. First clear the diagnostic
1613 // builder itself so it won't emit the diagnostic in its own destructor.
1614 //
1615 // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1616 // do its own needless checks to see if the diagnostic needs to be
1617 // emitted. However, because we take care to ensure that the builder
1618 // objects never escape, a sufficiently smart compiler will be able to
1619 // eliminate that code.
1620 Clear();
1621
1622 // Dispatch to Sema to emit the diagnostic.
1623 SemaRef.EmitCurrentDiagnostic(DiagID);
1624 }
1625
1626 /// Teach operator<< to produce an object of the correct type.
1627 template <typename T>
1628 friend const ImmediateDiagBuilder &
1629 operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1630 const DiagnosticBuilder &BaseDiag = Diag;
1631 BaseDiag << Value;
1632 return Diag;
1633 }
1634
1635 // It is necessary to limit this to rvalue reference to avoid calling this
1636 // function with a bitfield lvalue argument since non-const reference to
1637 // bitfield is not allowed.
1638 template <typename T, typename = typename std::enable_if<
1639 !std::is_lvalue_reference<T>::value>::type>
1640 const ImmediateDiagBuilder &operator<<(T &&V) const {
1641 const DiagnosticBuilder &BaseDiag = *this;
1642 BaseDiag << std::move(V);
1643 return *this;
1644 }
1645 };
1646
1647 /// A generic diagnostic builder for errors which may or may not be deferred.
1648 ///
1649 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1650 /// which are not allowed to appear inside __device__ functions and are
1651 /// allowed to appear in __host__ __device__ functions only if the host+device
1652 /// function is never codegen'ed.
1653 ///
1654 /// To handle this, we use the notion of "deferred diagnostics", where we
1655 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1656 ///
1657 /// This class lets you emit either a regular diagnostic, a deferred
1658 /// diagnostic, or no diagnostic at all, according to an argument you pass to
1659 /// its constructor, thus simplifying the process of creating these "maybe
1660 /// deferred" diagnostics.
1661 class SemaDiagnosticBuilder {
1662 public:
1663 enum Kind {
1664 /// Emit no diagnostics.
1665 K_Nop,
1666 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1667 K_Immediate,
1668 /// Emit the diagnostic immediately, and, if it's a warning or error, also
1669 /// emit a call stack showing how this function can be reached by an a
1670 /// priori known-emitted function.
1671 K_ImmediateWithCallStack,
1672 /// Create a deferred diagnostic, which is emitted only if the function
1673 /// it's attached to is codegen'ed. Also emit a call stack as with
1674 /// K_ImmediateWithCallStack.
1675 K_Deferred
1676 };
1677
1678 SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1679 FunctionDecl *Fn, Sema &S);
1680 SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1681 SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1682 ~SemaDiagnosticBuilder();
1683
1684 bool isImmediate() const { return ImmediateDiag.hasValue(); }
1685
1686 /// Convertible to bool: True if we immediately emitted an error, false if
1687 /// we didn't emit an error or we created a deferred error.
1688 ///
1689 /// Example usage:
1690 ///
1691 /// if (SemaDiagnosticBuilder(...) << foo << bar)
1692 /// return ExprError();
1693 ///
1694 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1695 /// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1696 operator bool() const { return isImmediate(); }
1697
1698 template <typename T>
1699 friend const SemaDiagnosticBuilder &
1700 operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1701 if (Diag.ImmediateDiag.hasValue())
1702 *Diag.ImmediateDiag << Value;
1703 else if (Diag.PartialDiagId.hasValue())
1704 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1705 << Value;
1706 return Diag;
1707 }
1708
1709 // It is necessary to limit this to rvalue reference to avoid calling this
1710 // function with a bitfield lvalue argument since non-const reference to
1711 // bitfield is not allowed.
1712 template <typename T, typename = typename std::enable_if<
1713 !std::is_lvalue_reference<T>::value>::type>
1714 const SemaDiagnosticBuilder &operator<<(T &&V) const {
1715 if (ImmediateDiag.hasValue())
1716 *ImmediateDiag << std::move(V);
1717 else if (PartialDiagId.hasValue())
1718 S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V);
1719 return *this;
1720 }
1721
1722 friend const SemaDiagnosticBuilder &
1723 operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {
1724 if (Diag.ImmediateDiag.hasValue())
1725 PD.Emit(*Diag.ImmediateDiag);
1726 else if (Diag.PartialDiagId.hasValue())
1727 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD;
1728 return Diag;
1729 }
1730
1731 void AddFixItHint(const FixItHint &Hint) const {
1732 if (ImmediateDiag.hasValue())
1733 ImmediateDiag->AddFixItHint(Hint);
1734 else if (PartialDiagId.hasValue())
1735 S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint);
1736 }
1737
1738 friend ExprResult ExprError(const SemaDiagnosticBuilder &) {
1739 return ExprError();
1740 }
1741 friend StmtResult StmtError(const SemaDiagnosticBuilder &) {
1742 return StmtError();
1743 }
1744 operator ExprResult() const { return ExprError(); }
1745 operator StmtResult() const { return StmtError(); }
1746 operator TypeResult() const { return TypeError(); }
1747 operator DeclResult() const { return DeclResult(true); }
1748 operator MemInitResult() const { return MemInitResult(true); }
1749
1750 private:
1751 Sema &S;
1752 SourceLocation Loc;
1753 unsigned DiagID;
1754 FunctionDecl *Fn;
1755 bool ShowCallStack;
1756
1757 // Invariant: At most one of these Optionals has a value.
1758 // FIXME: Switch these to a Variant once that exists.
1759 llvm::Optional<ImmediateDiagBuilder> ImmediateDiag;
1760 llvm::Optional<unsigned> PartialDiagId;
1761 };
1762
1763 /// Is the last error level diagnostic immediate. This is used to determined
1764 /// whether the next info diagnostic should be immediate.
1765 bool IsLastErrorImmediate = true;
1766
1767 /// Emit a diagnostic.
1768 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,
1769 bool DeferHint = false);
1770
1771 /// Emit a partial diagnostic.
1772 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
1773 bool DeferHint = false);
1774
1775 /// Build a partial diagnostic.
1776 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1777
1778 /// Whether deferrable diagnostics should be deferred.
1779 bool DeferDiags = false;
1780
1781 /// RAII class to control scope of DeferDiags.
1782 class DeferDiagsRAII {
1783 Sema &S;
1784 bool SavedDeferDiags = false;
1785
1786 public:
1787 DeferDiagsRAII(Sema &S, bool DeferDiags)
1788 : S(S), SavedDeferDiags(S.DeferDiags) {
1789 S.DeferDiags = DeferDiags;
1790 }
1791 ~DeferDiagsRAII() { S.DeferDiags = SavedDeferDiags; }
1792 };
1793
1794 /// Whether uncompilable error has occurred. This includes error happens
1795 /// in deferred diagnostics.
1796 bool hasUncompilableErrorOccurred() const;
1797
1798 bool findMacroSpelling(SourceLocation &loc, StringRef name);
1799
1800 /// Get a string to suggest for zero-initialization of a type.
1801 std::string
1802 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1803 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1804
1805 /// Calls \c Lexer::getLocForEndOfToken()
1806 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1807
1808 /// Retrieve the module loader associated with the preprocessor.
1809 ModuleLoader &getModuleLoader() const;
1810
1811 /// Invent a new identifier for parameters of abbreviated templates.
1812 IdentifierInfo *
1813 InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1814 unsigned Index);
1815
1816 void emitAndClearUnusedLocalTypedefWarnings();
1817
1818 private:
1819 /// Function or variable declarations to be checked for whether the deferred
1820 /// diagnostics should be emitted.
1821 llvm::SmallSetVector<Decl *, 4> DeclsToCheckForDeferredDiags;
1822
1823 public:
1824 // Emit all deferred diagnostics.
1825 void emitDeferredDiags();
1826
1827 enum TUFragmentKind {
1828 /// The global module fragment, between 'module;' and a module-declaration.
1829 Global,
1830 /// A normal translation unit fragment. For a non-module unit, this is the
1831 /// entire translation unit. Otherwise, it runs from the module-declaration
1832 /// to the private-module-fragment (if any) or the end of the TU (if not).
1833 Normal,
1834 /// The private module fragment, between 'module :private;' and the end of
1835 /// the translation unit.
1836 Private
1837 };
1838
1839 void ActOnStartOfTranslationUnit();
1840 void ActOnEndOfTranslationUnit();
1841 void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1842
1843 void CheckDelegatingCtorCycles();
1844
1845 Scope *getScopeForContext(DeclContext *Ctx);
1846
1847 void PushFunctionScope();
1848 void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1849 sema::LambdaScopeInfo *PushLambdaScope();
1850
1851 /// This is used to inform Sema what the current TemplateParameterDepth
1852 /// is during Parsing. Currently it is used to pass on the depth
1853 /// when parsing generic lambda 'auto' parameters.
1854 void RecordParsingTemplateParameterDepth(unsigned Depth);
1855
1856 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1857 RecordDecl *RD, CapturedRegionKind K,
1858 unsigned OpenMPCaptureLevel = 0);
1859
1860 /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1861 /// time after they've been popped.
1862 class PoppedFunctionScopeDeleter {
1863 Sema *Self;
1864
1865 public:
1866 explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1867 void operator()(sema::FunctionScopeInfo *Scope) const;
1868 };
1869
1870 using PoppedFunctionScopePtr =
1871 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1872
1873 PoppedFunctionScopePtr
1874 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1875 const Decl *D = nullptr,
1876 QualType BlockType = QualType());
1877
1878 sema::FunctionScopeInfo *getCurFunction() const {
1879 return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1880 }
1881
1882 sema::FunctionScopeInfo *getEnclosingFunction() const;
1883
1884 void setFunctionHasBranchIntoScope();
1885 void setFunctionHasBranchProtectedScope();
1886 void setFunctionHasIndirectGoto();
1887 void setFunctionHasMustTail();
1888
1889 void PushCompoundScope(bool IsStmtExpr);
1890 void PopCompoundScope();
1891
1892 sema::CompoundScopeInfo &getCurCompoundScope() const;
1893
1894 bool hasAnyUnrecoverableErrorsInThisFunction() const;
1895
1896 /// Retrieve the current block, if any.
1897 sema::BlockScopeInfo *getCurBlock();
1898
1899 /// Get the innermost lambda enclosing the current location, if any. This
1900 /// looks through intervening non-lambda scopes such as local functions and
1901 /// blocks.
1902 sema::LambdaScopeInfo *getEnclosingLambda() const;
1903
1904 /// Retrieve the current lambda scope info, if any.
1905 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1906 /// lambda scope info ignoring all inner capturing scopes that are not
1907 /// lambda scopes.
1908 sema::LambdaScopeInfo *
1909 getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1910
1911 /// Retrieve the current generic lambda info, if any.
1912 sema::LambdaScopeInfo *getCurGenericLambda();
1913
1914 /// Retrieve the current captured region, if any.
1915 sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1916
1917 /// Retrieve the current function, if any, that should be analyzed for
1918 /// potential availability violations.
1919 sema::FunctionScopeInfo *getCurFunctionAvailabilityContext();
1920
1921 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1922 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1923
1924 /// Called before parsing a function declarator belonging to a function
1925 /// declaration.
1926 void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1927 unsigned TemplateParameterDepth);
1928
1929 /// Called after parsing a function declarator belonging to a function
1930 /// declaration.
1931 void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1932
1933 void ActOnComment(SourceRange Comment);
1934
1935 //===--------------------------------------------------------------------===//
1936 // Type Analysis / Processing: SemaType.cpp.
1937 //
1938
1939 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1940 const DeclSpec *DS = nullptr);
1941 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1942 const DeclSpec *DS = nullptr);
1943 QualType BuildPointerType(QualType T,
1944 SourceLocation Loc, DeclarationName Entity);
1945 QualType BuildReferenceType(QualType T, bool LValueRef,
1946 SourceLocation Loc, DeclarationName Entity);
1947 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1948 Expr *ArraySize, unsigned Quals,
1949 SourceRange Brackets, DeclarationName Entity);
1950 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1951 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1952 SourceLocation AttrLoc);
1953 QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns,
1954 SourceLocation AttrLoc);
1955
1956 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1957 SourceLocation AttrLoc);
1958
1959 /// Same as above, but constructs the AddressSpace index if not provided.
1960 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1961 SourceLocation AttrLoc);
1962
1963 bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1964
1965 bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1966
1967 /// Build a function type.
1968 ///
1969 /// This routine checks the function type according to C++ rules and
1970 /// under the assumption that the result type and parameter types have
1971 /// just been instantiated from a template. It therefore duplicates
1972 /// some of the behavior of GetTypeForDeclarator, but in a much
1973 /// simpler form that is only suitable for this narrow use case.
1974 ///
1975 /// \param T The return type of the function.
1976 ///
1977 /// \param ParamTypes The parameter types of the function. This array
1978 /// will be modified to account for adjustments to the types of the
1979 /// function parameters.
1980 ///
1981 /// \param Loc The location of the entity whose type involves this
1982 /// function type or, if there is no such entity, the location of the
1983 /// type that will have function type.
1984 ///
1985 /// \param Entity The name of the entity that involves the function
1986 /// type, if known.
1987 ///
1988 /// \param EPI Extra information about the function type. Usually this will
1989 /// be taken from an existing function with the same prototype.
1990 ///
1991 /// \returns A suitable function type, if there are no errors. The
1992 /// unqualified type will always be a FunctionProtoType.
1993 /// Otherwise, returns a NULL type.
1994 QualType BuildFunctionType(QualType T,
1995 MutableArrayRef<QualType> ParamTypes,
1996 SourceLocation Loc, DeclarationName Entity,
1997 const FunctionProtoType::ExtProtoInfo &EPI);
1998
1999 QualType BuildMemberPointerType(QualType T, QualType Class,
2000 SourceLocation Loc,
2001 DeclarationName Entity);
2002 QualType BuildBlockPointerType(QualType T,
2003 SourceLocation Loc, DeclarationName Entity);
2004 QualType BuildParenType(QualType T);
2005 QualType BuildAtomicType(QualType T, SourceLocation Loc);
2006 QualType BuildReadPipeType(QualType T,
2007 SourceLocation Loc);
2008 QualType BuildWritePipeType(QualType T,
2009 SourceLocation Loc);
2010 QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc);
2011
2012 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
2013 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
2014
2015 /// Package the given type and TSI into a ParsedType.
2016 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
2017 DeclarationNameInfo GetNameForDeclarator(Declarator &D);
2018 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
2019 static QualType GetTypeFromParser(ParsedType Ty,
2020 TypeSourceInfo **TInfo = nullptr);
2021 CanThrowResult canThrow(const Stmt *E);
2022 /// Determine whether the callee of a particular function call can throw.
2023 /// E, D and Loc are all optional.
2024 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D,
2025 SourceLocation Loc = SourceLocation());
2026 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
2027 const FunctionProtoType *FPT);
2028 void UpdateExceptionSpec(FunctionDecl *FD,
2029 const FunctionProtoType::ExceptionSpecInfo &ESI);
2030 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
2031 bool CheckDistantExceptionSpec(QualType T);
2032 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
2033 bool CheckEquivalentExceptionSpec(
2034 const FunctionProtoType *Old, SourceLocation OldLoc,
2035 const FunctionProtoType *New, SourceLocation NewLoc);
2036 bool CheckEquivalentExceptionSpec(
2037 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
2038 const FunctionProtoType *Old, SourceLocation OldLoc,
2039 const FunctionProtoType *New, SourceLocation NewLoc);
2040 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
2041 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
2042 const PartialDiagnostic &NestedDiagID,
2043 const PartialDiagnostic &NoteID,
2044 const PartialDiagnostic &NoThrowDiagID,
2045 const FunctionProtoType *Superset,
2046 SourceLocation SuperLoc,
2047 const FunctionProtoType *Subset,
2048 SourceLocation SubLoc);
2049 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
2050 const PartialDiagnostic &NoteID,
2051 const FunctionProtoType *Target,
2052 SourceLocation TargetLoc,
2053 const FunctionProtoType *Source,
2054 SourceLocation SourceLoc);
2055
2056 TypeResult ActOnTypeName(Scope *S, Declarator &D);
2057
2058 /// The parser has parsed the context-sensitive type 'instancetype'
2059 /// in an Objective-C message declaration. Return the appropriate type.
2060 ParsedType ActOnObjCInstanceType(SourceLocation Loc);
2061
2062 /// Abstract class used to diagnose incomplete types.
2063 struct TypeDiagnoser {
2064 TypeDiagnoser() {}
2065
2066 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
2067 virtual ~TypeDiagnoser() {}
2068 };
2069
2070 static int getPrintable(int I) { return I; }
2071 static unsigned getPrintable(unsigned I) { return I; }
2072 static bool getPrintable(bool B) { return B; }
2073 static const char * getPrintable(const char *S) { return S; }
2074 static StringRef getPrintable(StringRef S) { return S; }
2075 static const std::string &getPrintable(const std::string &S) { return S; }
2076 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
2077 return II;
2078 }
2079 static DeclarationName getPrintable(DeclarationName N) { return N; }
2080 static QualType getPrintable(QualType T) { return T; }
2081 static SourceRange getPrintable(SourceRange R) { return R; }
2082 static SourceRange getPrintable(SourceLocation L) { return L; }
2083 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
2084 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
2085
2086 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
2087 protected:
2088 unsigned DiagID;
2089 std::tuple<const Ts &...> Args;
2090
2091 template <std::size_t... Is>
2092 void emit(const SemaDiagnosticBuilder &DB,
2093 std::index_sequence<Is...>) const {
2094 // Apply all tuple elements to the builder in order.
2095 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
2096 (void)Dummy;
2097 }
2098
2099 public:
2100 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
2101 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
2102 assert(DiagID != 0 && "no diagnostic for type diagnoser")((void)0);
2103 }
2104
2105 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2106 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
2107 emit(DB, std::index_sequence_for<Ts...>());
2108 DB << T;
2109 }
2110 };
2111
2112 /// Do a check to make sure \p Name looks like a legal argument for the
2113 /// swift_name attribute applied to decl \p D. Raise a diagnostic if the name
2114 /// is invalid for the given declaration.
2115 ///
2116 /// \p AL is used to provide caret diagnostics in case of a malformed name.
2117 ///
2118 /// \returns true if the name is a valid swift name for \p D, false otherwise.
2119 bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc,
2120 const ParsedAttr &AL, bool IsAsync);
2121
2122 /// A derivative of BoundTypeDiagnoser for which the diagnostic's type
2123 /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless.
2124 /// For example, a diagnostic with no other parameters would generally have
2125 /// the form "...%select{incomplete|sizeless}0 type %1...".
2126 template <typename... Ts>
2127 class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> {
2128 public:
2129 SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args)
2130 : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {}
2131
2132 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2133 const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID);
2134 this->emit(DB, std::index_sequence_for<Ts...>());
2135 DB << T->isSizelessType() << T;
2136 }
2137 };
2138
2139 enum class CompleteTypeKind {
2140 /// Apply the normal rules for complete types. In particular,
2141 /// treat all sizeless types as incomplete.
2142 Normal,
2143
2144 /// Relax the normal rules for complete types so that they include
2145 /// sizeless built-in types.
2146 AcceptSizeless,
2147
2148 // FIXME: Eventually we should flip the default to Normal and opt in
2149 // to AcceptSizeless rather than opt out of it.
2150 Default = AcceptSizeless
2151 };
2152
2153private:
2154 /// Methods for marking which expressions involve dereferencing a pointer
2155 /// marked with the 'noderef' attribute. Expressions are checked bottom up as
2156 /// they are parsed, meaning that a noderef pointer may not be accessed. For
2157 /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
2158 /// `*p`, but need to check that `address of` is called on it. This requires
2159 /// keeping a container of all pending expressions and checking if the address
2160 /// of them are eventually taken.
2161 void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E);
2162 void CheckAddressOfNoDeref(const Expr *E);
2163 void CheckMemberAccessOfNoDeref(const MemberExpr *E);
2164
2165 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
2166 CompleteTypeKind Kind, TypeDiagnoser *Diagnoser);
2167
2168 struct ModuleScope {
2169 SourceLocation BeginLoc;
2170 clang::Module *Module = nullptr;
2171 bool ModuleInterface = false;
2172 bool ImplicitGlobalModuleFragment = false;
2173 VisibleModuleSet OuterVisibleModules;
2174 };
2175 /// The modules we're currently parsing.
2176 llvm::SmallVector<ModuleScope, 16> ModuleScopes;
2177
2178 /// Namespace definitions that we will export when they finish.
2179 llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
2180
2181 /// Get the module whose scope we are currently within.
2182 Module *getCurrentModule() const {
2183 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2184 }
2185
2186 VisibleModuleSet VisibleModules;
2187
2188public:
2189 /// Get the module owning an entity.
2190 Module *getOwningModule(const Decl *Entity) {
2191 return Entity->getOwningModule();
2192 }
2193
2194 /// Make a merged definition of an existing hidden definition \p ND
2195 /// visible at the specified location.
2196 void makeMergedDefinitionVisible(NamedDecl *ND);
2197
2198 bool isModuleVisible(const Module *M, bool ModulePrivate = false);
2199
2200 // When loading a non-modular PCH files, this is used to restore module
2201 // visibility.
2202 void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) {
2203 VisibleModules.setVisible(Mod, ImportLoc);
2204 }
2205
2206 /// Determine whether a declaration is visible to name lookup.
2207 bool isVisible(const NamedDecl *D) {
2208 return D->isUnconditionallyVisible() || isVisibleSlow(D);
2209 }
2210
2211 /// Determine whether any declaration of an entity is visible.
2212 bool
2213 hasVisibleDeclaration(const NamedDecl *D,
2214 llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
2215 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
2216 }
2217 bool hasVisibleDeclarationSlow(const NamedDecl *D,
2218 llvm::SmallVectorImpl<Module *> *Modules);
2219
2220 bool hasVisibleMergedDefinition(NamedDecl *Def);
2221 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
2222
2223 /// Determine if \p D and \p Suggested have a structurally compatible
2224 /// layout as described in C11 6.2.7/1.
2225 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
2226
2227 /// Determine if \p D has a visible definition. If not, suggest a declaration
2228 /// that should be made visible to expose the definition.
2229 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
2230 bool OnlyNeedComplete = false);
2231 bool hasVisibleDefinition(const NamedDecl *D) {
2232 NamedDecl *Hidden;
2233 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
2234 }
2235
2236 /// Determine if the template parameter \p D has a visible default argument.
2237 bool
2238 hasVisibleDefaultArgument(const NamedDecl *D,
2239 llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2240
2241 /// Determine if there is a visible declaration of \p D that is an explicit
2242 /// specialization declaration for a specialization of a template. (For a
2243 /// member specialization, use hasVisibleMemberSpecialization.)
2244 bool hasVisibleExplicitSpecialization(
2245 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2246
2247 /// Determine if there is a visible declaration of \p D that is a member
2248 /// specialization declaration (as opposed to an instantiated declaration).
2249 bool hasVisibleMemberSpecialization(
2250 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2251
2252 /// Determine if \p A and \p B are equivalent internal linkage declarations
2253 /// from different modules, and thus an ambiguity error can be downgraded to
2254 /// an extension warning.
2255 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
2256 const NamedDecl *B);
2257 void diagnoseEquivalentInternalLinkageDeclarations(
2258 SourceLocation Loc, const NamedDecl *D,
2259 ArrayRef<const NamedDecl *> Equiv);
2260
2261 bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
2262
2263 bool isCompleteType(SourceLocation Loc, QualType T,
2264 CompleteTypeKind Kind = CompleteTypeKind::Default) {
2265 return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
2266 }
2267 bool RequireCompleteType(SourceLocation Loc, QualType T,
2268 CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
2269 bool RequireCompleteType(SourceLocation Loc, QualType T,
2270 CompleteTypeKind Kind, unsigned DiagID);
2271
2272 bool RequireCompleteType(SourceLocation Loc, QualType T,
2273 TypeDiagnoser &Diagnoser) {
2274 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
2275 }
2276 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
2277 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
2278 }
2279
2280 template <typename... Ts>
2281 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
2282 const Ts &...Args) {
2283 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2284 return RequireCompleteType(Loc, T, Diagnoser);
2285 }
2286
2287 template <typename... Ts>
2288 bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
2289 const Ts &... Args) {
2290 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2291 return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
2292 }
2293
2294 /// Get the type of expression E, triggering instantiation to complete the
2295 /// type if necessary -- that is, if the expression refers to a templated
2296 /// static data member of incomplete array type.
2297 ///
2298 /// May still return an incomplete type if instantiation was not possible or
2299 /// if the type is incomplete for a different reason. Use
2300 /// RequireCompleteExprType instead if a diagnostic is expected for an
2301 /// incomplete expression type.
2302 QualType getCompletedType(Expr *E);
2303
2304 void completeExprArrayBound(Expr *E);
2305 bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
2306 TypeDiagnoser &Diagnoser);
2307 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
2308
2309 template <typename... Ts>
2310 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
2311 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2312 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
2313 }
2314
2315 template <typename... Ts>
2316 bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
2317 const Ts &... Args) {
2318 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2319 return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
2320 }
2321
2322 bool RequireLiteralType(SourceLocation Loc, QualType T,
2323 TypeDiagnoser &Diagnoser);
2324 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
2325
2326 template <typename... Ts>
2327 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
2328 const Ts &...Args) {
2329 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2330 return RequireLiteralType(Loc, T, Diagnoser);
2331 }
2332
2333 QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
2334 const CXXScopeSpec &SS, QualType T,
2335 TagDecl *OwnedTagDecl = nullptr);
2336
2337 QualType getDecltypeForParenthesizedExpr(Expr *E);
2338 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
2339 /// If AsUnevaluated is false, E is treated as though it were an evaluated
2340 /// context, such as when building a type for decltype(auto).
2341 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
2342 bool AsUnevaluated = true);
2343 QualType BuildUnaryTransformType(QualType BaseType,
2344 UnaryTransformType::UTTKind UKind,
2345 SourceLocation Loc);
2346
2347 //===--------------------------------------------------------------------===//
2348 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
2349 //
2350
2351 struct SkipBodyInfo {
2352 SkipBodyInfo()
2353 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
2354 New(nullptr) {}
2355 bool ShouldSkip;
2356 bool CheckSameAsPrevious;
2357 NamedDecl *Previous;
2358 NamedDecl *New;
2359 };
2360
2361 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
2362
2363 void DiagnoseUseOfUnimplementedSelectors();
2364
2365 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
2366
2367 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
2368 Scope *S, CXXScopeSpec *SS = nullptr,
2369 bool isClassName = false, bool HasTrailingDot = false,
2370 ParsedType ObjectType = nullptr,
2371 bool IsCtorOrDtorName = false,
2372 bool WantNontrivialTypeSourceInfo = false,
2373 bool IsClassTemplateDeductionContext = true,
2374 IdentifierInfo **CorrectedII = nullptr);
2375 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
2376 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
2377 void DiagnoseUnknownTypeName(IdentifierInfo *&II,
2378 SourceLocation IILoc,
2379 Scope *S,
2380 CXXScopeSpec *SS,
2381 ParsedType &SuggestedType,
2382 bool IsTemplateName = false);
2383
2384 /// Attempt to behave like MSVC in situations where lookup of an unqualified
2385 /// type name has failed in a dependent context. In these situations, we
2386 /// automatically form a DependentTypeName that will retry lookup in a related
2387 /// scope during instantiation.
2388 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
2389 SourceLocation NameLoc,
2390 bool IsTemplateTypeArg);
2391
2392 /// Describes the result of the name lookup and resolution performed
2393 /// by \c ClassifyName().
2394 enum NameClassificationKind {
2395 /// This name is not a type or template in this context, but might be
2396 /// something else.
2397 NC_Unknown,
2398 /// Classification failed; an error has been produced.
2399 NC_Error,
2400 /// The name has been typo-corrected to a keyword.
2401 NC_Keyword,
2402 /// The name was classified as a type.
2403 NC_Type,
2404 /// The name was classified as a specific non-type, non-template
2405 /// declaration. ActOnNameClassifiedAsNonType should be called to
2406 /// convert the declaration to an expression.
2407 NC_NonType,
2408 /// The name was classified as an ADL-only function name.
2409 /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the
2410 /// result to an expression.
2411 NC_UndeclaredNonType,
2412 /// The name denotes a member of a dependent type that could not be
2413 /// resolved. ActOnNameClassifiedAsDependentNonType should be called to
2414 /// convert the result to an expression.
2415 NC_DependentNonType,
2416 /// The name was classified as an overload set, and an expression
2417 /// representing that overload set has been formed.
2418 /// ActOnNameClassifiedAsOverloadSet should be called to form a suitable
2419 /// expression referencing the overload set.
2420 NC_OverloadSet,
2421 /// The name was classified as a template whose specializations are types.
2422 NC_TypeTemplate,
2423 /// The name was classified as a variable template name.
2424 NC_VarTemplate,
2425 /// The name was classified as a function template name.
2426 NC_FunctionTemplate,
2427 /// The name was classified as an ADL-only function template name.
2428 NC_UndeclaredTemplate,
2429 /// The name was classified as a concept name.
2430 NC_Concept,
2431 };
2432
2433 class NameClassification {
2434 NameClassificationKind Kind;
2435 union {
2436 ExprResult Expr;
2437 NamedDecl *NonTypeDecl;
2438 TemplateName Template;
2439 ParsedType Type;
2440 };
2441
2442 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
2443
2444 public:
2445 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
2446
2447 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
2448
2449 static NameClassification Error() {
2450 return NameClassification(NC_Error);
2451 }
2452
2453 static NameClassification Unknown() {
2454 return NameClassification(NC_Unknown);
2455 }
2456
2457 static NameClassification OverloadSet(ExprResult E) {
2458 NameClassification Result(NC_OverloadSet);
2459 Result.Expr = E;
2460 return Result;
2461 }
2462
2463 static NameClassification NonType(NamedDecl *D) {
2464 NameClassification Result(NC_NonType);
2465 Result.NonTypeDecl = D;
2466 return Result;
2467 }
2468
2469 static NameClassification UndeclaredNonType() {
2470 return NameClassification(NC_UndeclaredNonType);
2471 }
2472
2473 static NameClassification DependentNonType() {
2474 return NameClassification(NC_DependentNonType);
2475 }
2476
2477 static NameClassification TypeTemplate(TemplateName Name) {
2478 NameClassification Result(NC_TypeTemplate);
2479 Result.Template = Name;
2480 return Result;
2481 }
2482
2483 static NameClassification VarTemplate(TemplateName Name) {
2484 NameClassification Result(NC_VarTemplate);
2485 Result.Template = Name;
2486 return Result;
2487 }
2488
2489 static NameClassification FunctionTemplate(TemplateName Name) {
2490 NameClassification Result(NC_FunctionTemplate);
2491 Result.Template = Name;
2492 return Result;
2493 }
2494
2495 static NameClassification Concept(TemplateName Name) {
2496 NameClassification Result(NC_Concept);
2497 Result.Template = Name;
2498 return Result;
2499 }
2500
2501 static NameClassification UndeclaredTemplate(TemplateName Name) {
2502 NameClassification Result(NC_UndeclaredTemplate);
2503 Result.Template = Name;
2504 return Result;
2505 }
2506
2507 NameClassificationKind getKind() const { return Kind; }
2508
2509 ExprResult getExpression() const {
2510 assert(Kind == NC_OverloadSet)((void)0);
2511 return Expr;
2512 }
2513
2514 ParsedType getType() const {
2515 assert(Kind == NC_Type)((void)0);
2516 return Type;
2517 }
2518
2519 NamedDecl *getNonTypeDecl() const {
2520 assert(Kind == NC_NonType)((void)0);
2521 return NonTypeDecl;
2522 }
2523
2524 TemplateName getTemplateName() const {
2525 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||((void)0)
2526 Kind == NC_VarTemplate || Kind == NC_Concept ||((void)0)
2527 Kind == NC_UndeclaredTemplate)((void)0);
2528 return Template;
2529 }
2530
2531 TemplateNameKind getTemplateNameKind() const {
2532 switch (Kind) {
2533 case NC_TypeTemplate:
2534 return TNK_Type_template;
2535 case NC_FunctionTemplate:
2536 return TNK_Function_template;
2537 case NC_VarTemplate:
2538 return TNK_Var_template;
2539 case NC_Concept:
2540 return TNK_Concept_template;
2541 case NC_UndeclaredTemplate:
2542 return TNK_Undeclared_template;
2543 default:
2544 llvm_unreachable("unsupported name classification.")__builtin_unreachable();
2545 }
2546 }
2547 };
2548
2549 /// Perform name lookup on the given name, classifying it based on
2550 /// the results of name lookup and the following token.
2551 ///
2552 /// This routine is used by the parser to resolve identifiers and help direct
2553 /// parsing. When the identifier cannot be found, this routine will attempt
2554 /// to correct the typo and classify based on the resulting name.
2555 ///
2556 /// \param S The scope in which we're performing name lookup.
2557 ///
2558 /// \param SS The nested-name-specifier that precedes the name.
2559 ///
2560 /// \param Name The identifier. If typo correction finds an alternative name,
2561 /// this pointer parameter will be updated accordingly.
2562 ///
2563 /// \param NameLoc The location of the identifier.
2564 ///
2565 /// \param NextToken The token following the identifier. Used to help
2566 /// disambiguate the name.
2567 ///
2568 /// \param CCC The correction callback, if typo correction is desired.
2569 NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS,
2570 IdentifierInfo *&Name, SourceLocation NameLoc,
2571 const Token &NextToken,
2572 CorrectionCandidateCallback *CCC = nullptr);
2573
2574 /// Act on the result of classifying a name as an undeclared (ADL-only)
2575 /// non-type declaration.
2576 ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
2577 SourceLocation NameLoc);
2578 /// Act on the result of classifying a name as an undeclared member of a
2579 /// dependent base class.
2580 ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
2581 IdentifierInfo *Name,
2582 SourceLocation NameLoc,
2583 bool IsAddressOfOperand);
2584 /// Act on the result of classifying a name as a specific non-type
2585 /// declaration.
2586 ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
2587 NamedDecl *Found,
2588 SourceLocation NameLoc,
2589 const Token &NextToken);
2590 /// Act on the result of classifying a name as an overload set.
2591 ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet);
2592
2593 /// Describes the detailed kind of a template name. Used in diagnostics.
2594 enum class TemplateNameKindForDiagnostics {
2595 ClassTemplate,
2596 FunctionTemplate,
2597 VarTemplate,
2598 AliasTemplate,
2599 TemplateTemplateParam,
2600 Concept,
2601 DependentTemplate
2602 };
2603 TemplateNameKindForDiagnostics
2604 getTemplateNameKindForDiagnostics(TemplateName Name);
2605
2606 /// Determine whether it's plausible that E was intended to be a
2607 /// template-name.
2608 bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
2609 if (!getLangOpts().CPlusPlus || E.isInvalid())
2610 return false;
2611 Dependent = false;
2612 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
2613 return !DRE->hasExplicitTemplateArgs();
2614 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
2615 return !ME->hasExplicitTemplateArgs();
2616 Dependent = true;
2617 if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get()))
2618 return !DSDRE->hasExplicitTemplateArgs();
2619 if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get()))
2620 return !DSME->hasExplicitTemplateArgs();
2621 // Any additional cases recognized here should also be handled by
2622 // diagnoseExprIntendedAsTemplateName.
2623 return false;
2624 }
2625 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
2626 SourceLocation Less,
2627 SourceLocation Greater);
2628
2629 void warnOnReservedIdentifier(const NamedDecl *D);
2630
2631 Decl *ActOnDeclarator(Scope *S, Declarator &D);
2632
2633 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
2634 MultiTemplateParamsArg TemplateParameterLists);
2635 bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo,
2636 QualType &T, SourceLocation Loc,
2637 unsigned FailedFoldDiagID);
2638 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
2639 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
2640 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
2641 DeclarationName Name, SourceLocation Loc,
2642 bool IsTemplateId);
2643 void
2644 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2645 SourceLocation FallbackLoc,
2646 SourceLocation ConstQualLoc = SourceLocation(),
2647 SourceLocation VolatileQualLoc = SourceLocation(),
2648 SourceLocation RestrictQualLoc = SourceLocation(),
2649 SourceLocation AtomicQualLoc = SourceLocation(),
2650 SourceLocation UnalignedQualLoc = SourceLocation());
2651
2652 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
2653 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
2654 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
2655 const LookupResult &R);
2656 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
2657 NamedDecl *getShadowedDeclaration(const BindingDecl *D,
2658 const LookupResult &R);
2659 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
2660 const LookupResult &R);
2661 void CheckShadow(Scope *S, VarDecl *D);
2662
2663 /// Warn if 'E', which is an expression that is about to be modified, refers
2664 /// to a shadowing declaration.
2665 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2666
2667 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
2668
2669private:
2670 /// Map of current shadowing declarations to shadowed declarations. Warn if
2671 /// it looks like the user is trying to modify the shadowing declaration.
2672 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2673
2674public:
2675 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2676 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
2677 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
2678 TypedefNameDecl *NewTD);
2679 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
2680 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2681 TypeSourceInfo *TInfo,
2682 LookupResult &Previous);
2683 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
2684 LookupResult &Previous, bool &Redeclaration);
2685 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
2686 TypeSourceInfo *TInfo,
2687 LookupResult &Previous,
2688 MultiTemplateParamsArg TemplateParamLists,
2689 bool &AddToScope,
2690 ArrayRef<BindingDecl *> Bindings = None);
2691 NamedDecl *
2692 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
2693 MultiTemplateParamsArg TemplateParamLists);
2694 // Returns true if the variable declaration is a redeclaration
2695 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
2696 void CheckVariableDeclarationType(VarDecl *NewVD);
2697 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
2698 Expr *Init);
2699 void CheckCompleteVariableDeclaration(VarDecl *VD);
2700 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
2701 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
2702
2703 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2704 TypeSourceInfo *TInfo,
2705 LookupResult &Previous,
2706 MultiTemplateParamsArg TemplateParamLists,
2707 bool &AddToScope);
2708 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
2709
2710 enum class CheckConstexprKind {
2711 /// Diagnose issues that are non-constant or that are extensions.
2712 Diagnose,
2713 /// Identify whether this function satisfies the formal rules for constexpr
2714 /// functions in the current lanugage mode (with no extensions).
2715 CheckValid
2716 };
2717
2718 bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,
2719 CheckConstexprKind Kind);
2720
2721 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
2722 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
2723 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2724 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
2725 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2726 // Returns true if the function declaration is a redeclaration
2727 bool CheckFunctionDeclaration(Scope *S,
2728 FunctionDecl *NewFD, LookupResult &Previous,
2729 bool IsMemberSpecialization);
2730 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
2731 bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,
2732 QualType NewT, QualType OldT);
2733 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
2734 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
2735 Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
2736 bool IsDefinition);
2737 void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);
2738 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
2739 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
2740 SourceLocation Loc,
2741 QualType T);
2742 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
2743 SourceLocation NameLoc, IdentifierInfo *Name,
2744 QualType T, TypeSourceInfo *TSInfo,
2745 StorageClass SC);
2746 void ActOnParamDefaultArgument(Decl *param,
2747 SourceLocation EqualLoc,
2748 Expr *defarg);
2749 void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,
2750 SourceLocation ArgLoc);
2751 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
2752 ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2753 SourceLocation EqualLoc);
2754 void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2755 SourceLocation EqualLoc);
2756
2757 // Contexts where using non-trivial C union types can be disallowed. This is
2758 // passed to err_non_trivial_c_union_in_invalid_context.
2759 enum NonTrivialCUnionContext {
2760 // Function parameter.
2761 NTCUC_FunctionParam,
2762 // Function return.
2763 NTCUC_FunctionReturn,
2764 // Default-initialized object.
2765 NTCUC_DefaultInitializedObject,
2766 // Variable with automatic storage duration.
2767 NTCUC_AutoVar,
2768 // Initializer expression that might copy from another object.
2769 NTCUC_CopyInit,
2770 // Assignment.
2771 NTCUC_Assignment,
2772 // Compound literal.
2773 NTCUC_CompoundLiteral,
2774 // Block capture.
2775 NTCUC_BlockCapture,
2776 // lvalue-to-rvalue conversion of volatile type.
2777 NTCUC_LValueToRValueVolatile,
2778 };
2779
2780 /// Emit diagnostics if the initializer or any of its explicit or
2781 /// implicitly-generated subexpressions require copying or
2782 /// default-initializing a type that is or contains a C union type that is
2783 /// non-trivial to copy or default-initialize.
2784 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2785
2786 // These flags are passed to checkNonTrivialCUnion.
2787 enum NonTrivialCUnionKind {
2788 NTCUK_Init = 0x1,
2789 NTCUK_Destruct = 0x2,
2790 NTCUK_Copy = 0x4,
2791 };
2792
2793 /// Emit diagnostics if a non-trivial C union type or a struct that contains
2794 /// a non-trivial C union is used in an invalid context.
2795 void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
2796 NonTrivialCUnionContext UseContext,
2797 unsigned NonTrivialKind);
2798
2799 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
2800 void ActOnUninitializedDecl(Decl *dcl);
2801 void ActOnInitializerError(Decl *Dcl);
2802
2803 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
2804 void ActOnCXXForRangeDecl(Decl *D);
2805 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
2806 IdentifierInfo *Ident,
2807 ParsedAttributes &Attrs,
2808 SourceLocation AttrEnd);
2809 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
2810 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
2811 void CheckStaticLocalForDllExport(VarDecl *VD);
2812 void FinalizeDeclaration(Decl *D);
2813 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
2814 ArrayRef<Decl *> Group);
2815 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
2816
2817 /// Should be called on all declarations that might have attached
2818 /// documentation comments.
2819 void ActOnDocumentableDecl(Decl *D);
2820 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
2821
2822 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2823 SourceLocation LocAfterDecls);
2824 void CheckForFunctionRedefinition(
2825 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
2826 SkipBodyInfo *SkipBody = nullptr);
2827 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
2828 MultiTemplateParamsArg TemplateParamLists,
2829 SkipBodyInfo *SkipBody = nullptr);
2830 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
2831 SkipBodyInfo *SkipBody = nullptr);
2832 void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);
2833 ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);
2834 ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);
2835 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
2836 bool isObjCMethodDecl(Decl *D) {
2837 return D && isa<ObjCMethodDecl>(D);
2838 }
2839
2840 /// Determine whether we can delay parsing the body of a function or
2841 /// function template until it is used, assuming we don't care about emitting
2842 /// code for that function.
2843 ///
2844 /// This will be \c false if we may need the body of the function in the
2845 /// middle of parsing an expression (where it's impractical to switch to
2846 /// parsing a different function), for instance, if it's constexpr in C++11
2847 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2848 bool canDelayFunctionBody(const Declarator &D);
2849
2850 /// Determine whether we can skip parsing the body of a function
2851 /// definition, assuming we don't care about analyzing its body or emitting
2852 /// code for that function.
2853 ///
2854 /// This will be \c false only if we may need the body of the function in
2855 /// order to parse the rest of the program (for instance, if it is
2856 /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2857 bool canSkipFunctionBody(Decl *D);
2858
2859 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2860 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2861 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2862 Decl *ActOnSkippedFunctionBody(Decl *Decl);
2863 void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2864
2865 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2866 /// attribute for which parsing is delayed.
2867 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2868
2869 /// Diagnose any unused parameters in the given sequence of
2870 /// ParmVarDecl pointers.
2871 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2872
2873 /// Diagnose whether the size of parameters or return value of a
2874 /// function or obj-c method definition is pass-by-value and larger than a
2875 /// specified threshold.
2876 void
2877 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2878 QualType ReturnTy, NamedDecl *D);
2879
2880 void DiagnoseInvalidJumps(Stmt *Body);
2881 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2882 SourceLocation AsmLoc,
2883 SourceLocation RParenLoc);
2884
2885 /// Handle a C++11 empty-declaration and attribute-declaration.
2886 Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,
2887 SourceLocation SemiLoc);
2888
2889 enum class ModuleDeclKind {
2890 Interface, ///< 'export module X;'
2891 Implementation, ///< 'module X;'
2892 };
2893
2894 /// The parser has processed a module-declaration that begins the definition
2895 /// of a module interface or implementation.
2896 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2897 SourceLocation ModuleLoc, ModuleDeclKind MDK,
2898 ModuleIdPath Path, bool IsFirstDecl);
2899
2900 /// The parser has processed a global-module-fragment declaration that begins
2901 /// the definition of the global module fragment of the current module unit.
2902 /// \param ModuleLoc The location of the 'module' keyword.
2903 DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
2904
2905 /// The parser has processed a private-module-fragment declaration that begins
2906 /// the definition of the private module fragment of the current module unit.
2907 /// \param ModuleLoc The location of the 'module' keyword.
2908 /// \param PrivateLoc The location of the 'private' keyword.
2909 DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
2910 SourceLocation PrivateLoc);
2911
2912 /// The parser has processed a module import declaration.
2913 ///
2914 /// \param StartLoc The location of the first token in the declaration. This
2915 /// could be the location of an '@', 'export', or 'import'.
2916 /// \param ExportLoc The location of the 'export' keyword, if any.
2917 /// \param ImportLoc The location of the 'import' keyword.
2918 /// \param Path The module access path.
2919 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2920 SourceLocation ExportLoc,
2921 SourceLocation ImportLoc, ModuleIdPath Path);
2922 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2923 SourceLocation ExportLoc,
2924 SourceLocation ImportLoc, Module *M,
2925 ModuleIdPath Path = {});
2926
2927 /// The parser has processed a module import translated from a
2928 /// #include or similar preprocessing directive.
2929 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2930 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2931
2932 /// The parsed has entered a submodule.
2933 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2934 /// The parser has left a submodule.
2935 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2936
2937 /// Create an implicit import of the given module at the given
2938 /// source location, for error recovery, if possible.
2939 ///
2940 /// This routine is typically used when an entity found by name lookup
2941 /// is actually hidden within a module that we know about but the user
2942 /// has forgotten to import.
2943 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2944 Module *Mod);
2945
2946 /// Kinds of missing import. Note, the values of these enumerators correspond
2947 /// to %select values in diagnostics.
2948 enum class MissingImportKind {
2949 Declaration,
2950 Definition,
2951 DefaultArgument,
2952 ExplicitSpecialization,
2953 PartialSpecialization
2954 };
2955
2956 /// Diagnose that the specified declaration needs to be visible but
2957 /// isn't, and suggest a module import that would resolve the problem.
2958 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2959 MissingImportKind MIK, bool Recover = true);
2960 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2961 SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2962 MissingImportKind MIK, bool Recover);
2963
2964 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2965 SourceLocation LBraceLoc);
2966 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2967 SourceLocation RBraceLoc);
2968
2969 /// We've found a use of a templated declaration that would trigger an
2970 /// implicit instantiation. Check that any relevant explicit specializations
2971 /// and partial specializations are visible, and diagnose if not.
2972 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2973
2974 /// Retrieve a suitable printing policy for diagnostics.
2975 PrintingPolicy getPrintingPolicy() const {
2976 return getPrintingPolicy(Context, PP);
2977 }
2978
2979 /// Retrieve a suitable printing policy for diagnostics.
2980 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2981 const Preprocessor &PP);
2982
2983 /// Scope actions.
2984 void ActOnPopScope(SourceLocation Loc, Scope *S);
2985 void ActOnTranslationUnitScope(Scope *S);
2986
2987 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2988 RecordDecl *&AnonRecord);
2989 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2990 MultiTemplateParamsArg TemplateParams,
2991 bool IsExplicitInstantiation,
2992 RecordDecl *&AnonRecord);
2993
2994 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2995 AccessSpecifier AS,
2996 RecordDecl *Record,
2997 const PrintingPolicy &Policy);
2998
2999 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
3000 RecordDecl *Record);
3001
3002 /// Common ways to introduce type names without a tag for use in diagnostics.
3003 /// Keep in sync with err_tag_reference_non_tag.
3004 enum NonTagKind {
3005 NTK_NonStruct,
3006 NTK_NonClass,
3007 NTK_NonUnion,
3008 NTK_NonEnum,
3009 NTK_Typedef,
3010 NTK_TypeAlias,
3011 NTK_Template,
3012 NTK_TypeAliasTemplate,
3013 NTK_TemplateTemplateArgument,
3014 };
3015
3016 /// Given a non-tag type declaration, returns an enum useful for indicating
3017 /// what kind of non-tag type this is.
3018 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
3019
3020 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
3021 TagTypeKind NewTag, bool isDefinition,
3022 SourceLocation NewTagLoc,
3023 const IdentifierInfo *Name);
3024
3025 enum TagUseKind {
3026 TUK_Reference, // Reference to a tag: 'struct foo *X;'
3027 TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
3028 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
3029 TUK_Friend // Friend declaration: 'friend struct foo;'
3030 };
3031
3032 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
3033 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
3034 SourceLocation NameLoc, const ParsedAttributesView &Attr,
3035 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
3036 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
3037 bool &IsDependent, SourceLocation ScopedEnumKWLoc,
3038 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
3039 bool IsTypeSpecifier, bool IsTemplateParamOrArg,
3040 SkipBodyInfo *SkipBody = nullptr);
3041
3042 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
3043 unsigned TagSpec, SourceLocation TagLoc,
3044 CXXScopeSpec &SS, IdentifierInfo *Name,
3045 SourceLocation NameLoc,
3046 const ParsedAttributesView &Attr,
3047 MultiTemplateParamsArg TempParamLists);
3048
3049 TypeResult ActOnDependentTag(Scope *S,
3050 unsigned TagSpec,
3051 TagUseKind TUK,
3052 const CXXScopeSpec &SS,
3053 IdentifierInfo *Name,
3054 SourceLocation TagLoc,
3055 SourceLocation NameLoc);
3056
3057 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
3058 IdentifierInfo *ClassName,
3059 SmallVectorImpl<Decl *> &Decls);
3060 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
3061 Declarator &D, Expr *BitfieldWidth);
3062
3063 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
3064 Declarator &D, Expr *BitfieldWidth,
3065 InClassInitStyle InitStyle,
3066 AccessSpecifier AS);
3067 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
3068 SourceLocation DeclStart, Declarator &D,
3069 Expr *BitfieldWidth,
3070 InClassInitStyle InitStyle,
3071 AccessSpecifier AS,
3072 const ParsedAttr &MSPropertyAttr);
3073
3074 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
3075 TypeSourceInfo *TInfo,
3076 RecordDecl *Record, SourceLocation Loc,
3077 bool Mutable, Expr *BitfieldWidth,
3078 InClassInitStyle InitStyle,
3079 SourceLocation TSSL,
3080 AccessSpecifier AS, NamedDecl *PrevDecl,
3081 Declarator *D = nullptr);
3082
3083 bool CheckNontrivialField(FieldDecl *FD);
3084 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
3085
3086 enum TrivialABIHandling {
3087 /// The triviality of a method unaffected by "trivial_abi".
3088 TAH_IgnoreTrivialABI,
3089
3090 /// The triviality of a method affected by "trivial_abi".
3091 TAH_ConsiderTrivialABI
3092 };
3093
3094 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
3095 TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
3096 bool Diagnose = false);
3097
3098 /// For a defaulted function, the kind of defaulted function that it is.
3099 class DefaultedFunctionKind {
3100 CXXSpecialMember SpecialMember : 8;
3101 DefaultedComparisonKind Comparison : 8;
3102
3103 public:
3104 DefaultedFunctionKind()
3105 : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {
3106 }
3107 DefaultedFunctionKind(CXXSpecialMember CSM)
3108 : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}
3109 DefaultedFunctionKind(DefaultedComparisonKind Comp)
3110 : SpecialMember(CXXInvalid), Comparison(Comp) {}
3111
3112 bool isSpecialMember() const { return SpecialMember != CXXInvalid; }
3113 bool isComparison() const {
3114 return Comparison != DefaultedComparisonKind::None;
3115 }
3116
3117 explicit operator bool() const {
3118 return isSpecialMember() || isComparison();
3119 }
3120
3121 CXXSpecialMember asSpecialMember() const { return SpecialMember; }
3122 DefaultedComparisonKind asComparison() const { return Comparison; }
3123
3124 /// Get the index of this function kind for use in diagnostics.
3125 unsigned getDiagnosticIndex() const {
3126 static_assert(CXXInvalid > CXXDestructor,
3127 "invalid should have highest index");
3128 static_assert((unsigned)DefaultedComparisonKind::None == 0,
3129 "none should be equal to zero");
3130 return SpecialMember + (unsigned)Comparison;
3131 }
3132 };
3133
3134 DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);
3135
3136 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {
3137 return getDefaultedFunctionKind(MD).asSpecialMember();
3138 }
3139 DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {
3140 return getDefaultedFunctionKind(FD).asComparison();
3141 }
3142
3143 void ActOnLastBitfield(SourceLocation DeclStart,
3144 SmallVectorImpl<Decl *> &AllIvarDecls);
3145 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
3146 Declarator &D, Expr *BitfieldWidth,
3147 tok::ObjCKeywordKind visibility);
3148
3149 // This is used for both record definitions and ObjC interface declarations.
3150 void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,
3151 ArrayRef<Decl *> Fields, SourceLocation LBrac,
3152 SourceLocation RBrac, const ParsedAttributesView &AttrList);
3153
3154 /// ActOnTagStartDefinition - Invoked when we have entered the
3155 /// scope of a tag's definition (e.g., for an enumeration, class,
3156 /// struct, or union).
3157 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
3158
3159 /// Perform ODR-like check for C/ObjC when merging tag types from modules.
3160 /// Differently from C++, actually parse the body and reject / error out
3161 /// in case of a structural mismatch.
3162 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
3163 SkipBodyInfo &SkipBody);
3164
3165 typedef void *SkippedDefinitionContext;
3166
3167 /// Invoked when we enter a tag definition that we're skipping.
3168 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
3169
3170 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
3171
3172 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
3173 /// C++ record definition's base-specifiers clause and are starting its
3174 /// member declarations.
3175 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
3176 SourceLocation FinalLoc,
3177 bool IsFinalSpelledSealed,
3178 bool IsAbstract,
3179 SourceLocation LBraceLoc);
3180
3181 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
3182 /// the definition of a tag (enumeration, class, struct, or union).
3183 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
3184 SourceRange BraceRange);
3185
3186 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
3187
3188 void ActOnObjCContainerFinishDefinition();
3189
3190 /// Invoked when we must temporarily exit the objective-c container
3191 /// scope for parsing/looking-up C constructs.
3192 ///
3193 /// Must be followed by a call to \see ActOnObjCReenterContainerContext
3194 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
3195 void ActOnObjCReenterContainerContext(DeclContext *DC);
3196
3197 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
3198 /// error parsing the definition of a tag.
3199 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
3200
3201 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
3202 EnumConstantDecl *LastEnumConst,
3203 SourceLocation IdLoc,
3204 IdentifierInfo *Id,
3205 Expr *val);
3206 bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
3207 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
3208 QualType EnumUnderlyingTy, bool IsFixed,
3209 const EnumDecl *Prev);
3210
3211 /// Determine whether the body of an anonymous enumeration should be skipped.
3212 /// \param II The name of the first enumerator.
3213 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
3214 SourceLocation IILoc);
3215
3216 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
3217 SourceLocation IdLoc, IdentifierInfo *Id,
3218 const ParsedAttributesView &Attrs,
3219 SourceLocation EqualLoc, Expr *Val);
3220 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
3221 Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S,
3222 const ParsedAttributesView &Attr);
3223
3224 /// Set the current declaration context until it gets popped.
3225 void PushDeclContext(Scope *S, DeclContext *DC);
3226 void PopDeclContext();
3227
3228 /// EnterDeclaratorContext - Used when we must lookup names in the context
3229 /// of a declarator's nested name specifier.
3230 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
3231 void ExitDeclaratorContext(Scope *S);
3232
3233 /// Enter a template parameter scope, after it's been associated with a particular
3234 /// DeclContext. Causes lookup within the scope to chain through enclosing contexts
3235 /// in the correct order.
3236 void EnterTemplatedContext(Scope *S, DeclContext *DC);
3237
3238 /// Push the parameters of D, which must be a function, into scope.
3239 void ActOnReenterFunctionContext(Scope* S, Decl* D);
3240 void ActOnExitFunctionContext();
3241
3242 DeclContext *getFunctionLevelDeclContext();
3243
3244 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
3245 /// to the function decl for the function being parsed. If we're currently
3246 /// in a 'block', this returns the containing context.
3247 FunctionDecl *getCurFunctionDecl();
3248
3249 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
3250 /// the method decl for the method being parsed. If we're currently
3251 /// in a 'block', this returns the containing context.
3252 ObjCMethodDecl *getCurMethodDecl();
3253
3254 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
3255 /// or C function we're in, otherwise return null. If we're currently
3256 /// in a 'block', this returns the containing context.
3257 NamedDecl *getCurFunctionOrMethodDecl();
3258
3259 /// Add this decl to the scope shadowed decl chains.
3260 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
3261
3262 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
3263 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
3264 /// true if 'D' belongs to the given declaration context.
3265 ///
3266 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
3267 /// enclosing namespace set of the context, rather than contained
3268 /// directly within it.
3269 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
3270 bool AllowInlineNamespace = false);
3271
3272 /// Finds the scope corresponding to the given decl context, if it
3273 /// happens to be an enclosing scope. Otherwise return NULL.
3274 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
3275
3276 /// Subroutines of ActOnDeclarator().
3277 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
3278 TypeSourceInfo *TInfo);
3279 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
3280
3281 /// Describes the kind of merge to perform for availability
3282 /// attributes (including "deprecated", "unavailable", and "availability").
3283 enum AvailabilityMergeKind {
3284 /// Don't merge availability attributes at all.
3285 AMK_None,
3286 /// Merge availability attributes for a redeclaration, which requires
3287 /// an exact match.
3288 AMK_Redeclaration,
3289 /// Merge availability attributes for an override, which requires
3290 /// an exact match or a weakening of constraints.
3291 AMK_Override,
3292 /// Merge availability attributes for an implementation of
3293 /// a protocol requirement.
3294 AMK_ProtocolImplementation,
3295 /// Merge availability attributes for an implementation of
3296 /// an optional protocol requirement.
3297 AMK_OptionalProtocolImplementation
3298 };
3299
3300 /// Describes the kind of priority given to an availability attribute.
3301 ///
3302 /// The sum of priorities deteremines the final priority of the attribute.
3303 /// The final priority determines how the attribute will be merged.
3304 /// An attribute with a lower priority will always remove higher priority
3305 /// attributes for the specified platform when it is being applied. An
3306 /// attribute with a higher priority will not be applied if the declaration
3307 /// already has an availability attribute with a lower priority for the
3308 /// specified platform. The final prirority values are not expected to match
3309 /// the values in this enumeration, but instead should be treated as a plain
3310 /// integer value. This enumeration just names the priority weights that are
3311 /// used to calculate that final vaue.
3312 enum AvailabilityPriority : int {
3313 /// The availability attribute was specified explicitly next to the
3314 /// declaration.
3315 AP_Explicit = 0,
3316
3317 /// The availability attribute was applied using '#pragma clang attribute'.
3318 AP_PragmaClangAttribute = 1,
3319
3320 /// The availability attribute for a specific platform was inferred from
3321 /// an availability attribute for another platform.
3322 AP_InferredFromOtherPlatform = 2
3323 };
3324
3325 /// Attribute merging methods. Return true if a new attribute was added.
3326 AvailabilityAttr *
3327 mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,
3328 IdentifierInfo *Platform, bool Implicit,
3329 VersionTuple Introduced, VersionTuple Deprecated,
3330 VersionTuple Obsoleted, bool IsUnavailable,
3331 StringRef Message, bool IsStrict, StringRef Replacement,
3332 AvailabilityMergeKind AMK, int Priority);
3333 TypeVisibilityAttr *
3334 mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3335 TypeVisibilityAttr::VisibilityType Vis);
3336 VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3337 VisibilityAttr::VisibilityType Vis);
3338 UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
3339 StringRef UuidAsWritten, MSGuidDecl *GuidDecl);
3340 DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);
3341 DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);
3342 MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,
3343 const AttributeCommonInfo &CI,
3344 bool BestCase,
3345 MSInheritanceModel Model);
3346 FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,
3347 IdentifierInfo *Format, int FormatIdx,
3348 int FirstArg);
3349 SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,
3350 StringRef Name);
3351 CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
3352 StringRef Name);
3353 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,
3354 const AttributeCommonInfo &CI,
3355 const IdentifierInfo *Ident);
3356 MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);
3357 SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,
3358 StringRef Name);
3359 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,
3360 const AttributeCommonInfo &CI);
3361 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);
3362 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,
3363 const InternalLinkageAttr &AL);
3364 WebAssemblyImportNameAttr *mergeImportNameAttr(
3365 Decl *D, const WebAssemblyImportNameAttr &AL);
3366 WebAssemblyImportModuleAttr *mergeImportModuleAttr(
3367 Decl *D, const WebAssemblyImportModuleAttr &AL);
3368 EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL);
3369 EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D,
3370 const EnforceTCBLeafAttr &AL);
3371
3372 void mergeDeclAttributes(NamedDecl *New, Decl *Old,
3373 AvailabilityMergeKind AMK = AMK_Redeclaration);
3374 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
3375 LookupResult &OldDecls);
3376 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
3377 bool MergeTypeWithOld);
3378 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
3379 Scope *S, bool MergeTypeWithOld);
3380 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
3381 void MergeVarDecl(VarDecl *New, LookupResult &Previous);
3382 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
3383 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
3384 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
3385 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
3386 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
3387
3388 // AssignmentAction - This is used by all the assignment diagnostic functions
3389 // to represent what is actually causing the operation
3390 enum AssignmentAction {
3391 AA_Assigning,
3392 AA_Passing,
3393 AA_Returning,
3394 AA_Converting,
3395 AA_Initializing,
3396 AA_Sending,
3397 AA_Casting,
3398 AA_Passing_CFAudited
3399 };
3400
3401 /// C++ Overloading.
3402 enum OverloadKind {
3403 /// This is a legitimate overload: the existing declarations are
3404 /// functions or function templates with different signatures.
3405 Ovl_Overload,
3406
3407 /// This is not an overload because the signature exactly matches
3408 /// an existing declaration.
3409 Ovl_Match,
3410
3411 /// This is not an overload because the lookup results contain a
3412 /// non-function.
3413 Ovl_NonFunction
3414 };
3415 OverloadKind CheckOverload(Scope *S,
3416 FunctionDecl *New,
3417 const LookupResult &OldDecls,
3418 NamedDecl *&OldDecl,
3419 bool IsForUsingDecl);
3420 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
3421 bool ConsiderCudaAttrs = true,
3422 bool ConsiderRequiresClauses = true);
3423
3424 enum class AllowedExplicit {
3425 /// Allow no explicit functions to be used.
3426 None,
3427 /// Allow explicit conversion functions but not explicit constructors.
3428 Conversions,
3429 /// Allow both explicit conversion functions and explicit constructors.
3430 All
3431 };
3432
3433 ImplicitConversionSequence
3434 TryImplicitConversion(Expr *From, QualType ToType,
3435 bool SuppressUserConversions,
3436 AllowedExplicit AllowExplicit,
3437 bool InOverloadResolution,
3438 bool CStyle,
3439 bool AllowObjCWritebackConversion);
3440
3441 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
3442 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
3443 bool IsComplexPromotion(QualType FromType, QualType ToType);
3444 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
3445 bool InOverloadResolution,
3446 QualType& ConvertedType, bool &IncompatibleObjC);
3447 bool isObjCPointerConversion(QualType FromType, QualType ToType,
3448 QualType& ConvertedType, bool &IncompatibleObjC);
3449 bool isObjCWritebackConversion(QualType FromType, QualType ToType,
3450 QualType &ConvertedType);
3451 bool IsBlockPointerConversion(QualType FromType, QualType ToType,
3452 QualType& ConvertedType);
3453 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3454 const FunctionProtoType *NewType,
3455 unsigned *ArgPos = nullptr);
3456 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3457 QualType FromType, QualType ToType);
3458
3459 void maybeExtendBlockObject(ExprResult &E);
3460 CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
3461 bool CheckPointerConversion(Expr *From, QualType ToType,
3462 CastKind &Kind,
3463 CXXCastPath& BasePath,
3464 bool IgnoreBaseAccess,
3465 bool Diagnose = true);
3466 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
3467 bool InOverloadResolution,
3468 QualType &ConvertedType);
3469 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
3470 CastKind &Kind,
3471 CXXCastPath &BasePath,
3472 bool IgnoreBaseAccess);
3473 bool IsQualificationConversion(QualType FromType, QualType ToType,
3474 bool CStyle, bool &ObjCLifetimeConversion);
3475 bool IsFunctionConversion(QualType FromType, QualType ToType,
3476 QualType &ResultTy);
3477 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
3478 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
3479
3480 bool CanPerformAggregateInitializationForOverloadResolution(
3481 const InitializedEntity &Entity, InitListExpr *From);
3482
3483 bool IsStringInit(Expr *Init, const ArrayType *AT);
3484
3485 bool CanPerformCopyInitialization(const InitializedEntity &Entity,
3486 ExprResult Init);
3487 ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
3488 SourceLocation EqualLoc,
3489 ExprResult Init,
3490 bool TopLevelOfInitList = false,
3491 bool AllowExplicit = false);
3492 ExprResult PerformObjectArgumentInitialization(Expr *From,
3493 NestedNameSpecifier *Qualifier,
3494 NamedDecl *FoundDecl,
3495 CXXMethodDecl *Method);
3496
3497 /// Check that the lifetime of the initializer (and its subobjects) is
3498 /// sufficient for initializing the entity, and perform lifetime extension
3499 /// (when permitted) if not.
3500 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
3501
3502 ExprResult PerformContextuallyConvertToBool(Expr *From);
3503 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
3504
3505 /// Contexts in which a converted constant expression is required.
3506 enum CCEKind {
3507 CCEK_CaseValue, ///< Expression in a case label.
3508 CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
3509 CCEK_TemplateArg, ///< Value of a non-type template parameter.
3510 CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.
3511 CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
3512 };
3513 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3514 llvm::APSInt &Value, CCEKind CCE);
3515 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3516 APValue &Value, CCEKind CCE,
3517 NamedDecl *Dest = nullptr);
3518
3519 /// Abstract base class used to perform a contextual implicit
3520 /// conversion from an expression to any type passing a filter.
3521 class ContextualImplicitConverter {
3522 public:
3523 bool Suppress;
3524 bool SuppressConversion;
3525
3526 ContextualImplicitConverter(bool Suppress = false,
3527 bool SuppressConversion = false)
3528 : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
3529
3530 /// Determine whether the specified type is a valid destination type
3531 /// for this conversion.
3532 virtual bool match(QualType T) = 0;
3533
3534 /// Emits a diagnostic complaining that the expression does not have
3535 /// integral or enumeration type.
3536 virtual SemaDiagnosticBuilder
3537 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
3538
3539 /// Emits a diagnostic when the expression has incomplete class type.
3540 virtual SemaDiagnosticBuilder
3541 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
3542
3543 /// Emits a diagnostic when the only matching conversion function
3544 /// is explicit.
3545 virtual SemaDiagnosticBuilder diagnoseExplicitConv(
3546 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3547
3548 /// Emits a note for the explicit conversion function.
3549 virtual SemaDiagnosticBuilder
3550 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3551
3552 /// Emits a diagnostic when there are multiple possible conversion
3553 /// functions.
3554 virtual SemaDiagnosticBuilder
3555 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
3556
3557 /// Emits a note for one of the candidate conversions.
3558 virtual SemaDiagnosticBuilder
3559 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3560
3561 /// Emits a diagnostic when we picked a conversion function
3562 /// (for cases when we are not allowed to pick a conversion function).
3563 virtual SemaDiagnosticBuilder diagnoseConversion(
3564 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3565
3566 virtual ~ContextualImplicitConverter() {}
3567 };
3568
3569 class ICEConvertDiagnoser : public ContextualImplicitConverter {
3570 bool AllowScopedEnumerations;
3571
3572 public:
3573 ICEConvertDiagnoser(bool AllowScopedEnumerations,
3574 bool Suppress, bool SuppressConversion)
3575 : ContextualImplicitConverter(Suppress, SuppressConversion),
3576 AllowScopedEnumerations(AllowScopedEnumerations) {}
3577
3578 /// Match an integral or (possibly scoped) enumeration type.
3579 bool match(QualType T) override;
3580
3581 SemaDiagnosticBuilder
3582 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
3583 return diagnoseNotInt(S, Loc, T);
3584 }
3585
3586 /// Emits a diagnostic complaining that the expression does not have
3587 /// integral or enumeration type.
3588 virtual SemaDiagnosticBuilder
3589 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
3590 };
3591
3592 /// Perform a contextual implicit conversion.
3593 ExprResult PerformContextualImplicitConversion(
3594 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3595
3596
3597 enum ObjCSubscriptKind {
3598 OS_Array,
3599 OS_Dictionary,
3600 OS_Error
3601 };
3602 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3603
3604 // Note that LK_String is intentionally after the other literals, as
3605 // this is used for diagnostics logic.
3606 enum ObjCLiteralKind {
3607 LK_Array,
3608 LK_Dictionary,
3609 LK_Numeric,
3610 LK_Boxed,
3611 LK_String,
3612 LK_Block,
3613 LK_None
3614 };
3615 ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3616
3617 ExprResult PerformObjectMemberConversion(Expr *From,
3618 NestedNameSpecifier *Qualifier,
3619 NamedDecl *FoundDecl,
3620 NamedDecl *Member);
3621
3622 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
3623 // TODO: make this is a typesafe union.
3624 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet;
3625 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
3626
3627 using ADLCallKind = CallExpr::ADLCallKind;
3628
3629 void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
3630 ArrayRef<Expr *> Args,
3631 OverloadCandidateSet &CandidateSet,
3632 bool SuppressUserConversions = false,
3633 bool PartialOverloading = false,
3634 bool AllowExplicit = true,
3635 bool AllowExplicitConversion = false,
3636 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3637 ConversionSequenceList EarlyConversions = None,
3638 OverloadCandidateParamOrder PO = {});
3639 void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
3640 ArrayRef<Expr *> Args,
3641 OverloadCandidateSet &CandidateSet,
3642 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
3643 bool SuppressUserConversions = false,
3644 bool PartialOverloading = false,
3645 bool FirstArgumentIsBase = false);
3646 void AddMethodCandidate(DeclAccessPair FoundDecl,
3647 QualType ObjectType,
3648 Expr::Classification ObjectClassification,
3649 ArrayRef<Expr *> Args,
3650 OverloadCandidateSet& CandidateSet,
3651 bool SuppressUserConversion = false,
3652 OverloadCandidateParamOrder PO = {});
3653 void AddMethodCandidate(CXXMethodDecl *Method,
3654 DeclAccessPair FoundDecl,
3655 CXXRecordDecl *ActingContext, QualType ObjectType,
3656 Expr::Classification ObjectClassification,
3657 ArrayRef<Expr *> Args,
3658 OverloadCandidateSet& CandidateSet,
3659 bool SuppressUserConversions = false,
3660 bool PartialOverloading = false,
3661 ConversionSequenceList EarlyConversions = None,
3662 OverloadCandidateParamOrder PO = {});
3663 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
3664 DeclAccessPair FoundDecl,
3665 CXXRecordDecl *ActingContext,
3666 TemplateArgumentListInfo *ExplicitTemplateArgs,
3667 QualType ObjectType,
3668 Expr::Classification ObjectClassification,
3669 ArrayRef<Expr *> Args,
3670 OverloadCandidateSet& CandidateSet,
3671 bool SuppressUserConversions = false,
3672 bool PartialOverloading = false,
3673 OverloadCandidateParamOrder PO = {});
3674 void AddTemplateOverloadCandidate(
3675 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3676 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3677 OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
3678 bool PartialOverloading = false, bool AllowExplicit = true,
3679 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3680 OverloadCandidateParamOrder PO = {});
3681 bool CheckNonDependentConversions(
3682 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
3683 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3684 ConversionSequenceList &Conversions, bool SuppressUserConversions,
3685 CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),
3686 Expr::Classification ObjectClassification = {},
3687 OverloadCandidateParamOrder PO = {});
3688 void AddConversionCandidate(
3689 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
3690 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3691 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3692 bool AllowExplicit, bool AllowResultConversion = true);
3693 void AddTemplateConversionCandidate(
3694 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3695 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3696 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3697 bool AllowExplicit, bool AllowResultConversion = true);
3698 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
3699 DeclAccessPair FoundDecl,
3700 CXXRecordDecl *ActingContext,
3701 const FunctionProtoType *Proto,
3702 Expr *Object, ArrayRef<Expr *> Args,
3703 OverloadCandidateSet& CandidateSet);
3704 void AddNonMemberOperatorCandidates(
3705 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3706 OverloadCandidateSet &CandidateSet,
3707 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
3708 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3709 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3710 OverloadCandidateSet &CandidateSet,
3711 OverloadCandidateParamOrder PO = {});
3712 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
3713 OverloadCandidateSet& CandidateSet,
3714 bool IsAssignmentOperator = false,
3715 unsigned NumContextualBoolArguments = 0);
3716 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
3717 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3718 OverloadCandidateSet& CandidateSet);
3719 void AddArgumentDependentLookupCandidates(DeclarationName Name,
3720 SourceLocation Loc,
3721 ArrayRef<Expr *> Args,
3722 TemplateArgumentListInfo *ExplicitTemplateArgs,
3723 OverloadCandidateSet& CandidateSet,
3724 bool PartialOverloading = false);
3725
3726 // Emit as a 'note' the specific overload candidate
3727 void NoteOverloadCandidate(
3728 NamedDecl *Found, FunctionDecl *Fn,
3729 OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
3730 QualType DestType = QualType(), bool TakingAddress = false);
3731
3732 // Emit as a series of 'note's all template and non-templates identified by
3733 // the expression Expr
3734 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
3735 bool TakingAddress = false);
3736
3737 /// Check the enable_if expressions on the given function. Returns the first
3738 /// failing attribute, or NULL if they were all successful.
3739 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,
3740 ArrayRef<Expr *> Args,
3741 bool MissingImplicitThis = false);
3742
3743 /// Find the failed Boolean condition within a given Boolean
3744 /// constant expression, and describe it with a string.
3745 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3746
3747 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3748 /// non-ArgDependent DiagnoseIfAttrs.
3749 ///
3750 /// Argument-dependent diagnose_if attributes should be checked each time a
3751 /// function is used as a direct callee of a function call.
3752 ///
3753 /// Returns true if any errors were emitted.
3754 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
3755 const Expr *ThisArg,
3756 ArrayRef<const Expr *> Args,
3757 SourceLocation Loc);
3758
3759 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3760 /// ArgDependent DiagnoseIfAttrs.
3761 ///
3762 /// Argument-independent diagnose_if attributes should be checked on every use
3763 /// of a function.
3764 ///
3765 /// Returns true if any errors were emitted.
3766 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
3767 SourceLocation Loc);
3768
3769 /// Returns whether the given function's address can be taken or not,
3770 /// optionally emitting a diagnostic if the address can't be taken.
3771 ///
3772 /// Returns false if taking the address of the function is illegal.
3773 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
3774 bool Complain = false,
3775 SourceLocation Loc = SourceLocation());
3776
3777 // [PossiblyAFunctionType] --> [Return]
3778 // NonFunctionType --> NonFunctionType
3779 // R (A) --> R(A)
3780 // R (*)(A) --> R (A)
3781 // R (&)(A) --> R (A)
3782 // R (S::*)(A) --> R (A)
3783 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
3784
3785 FunctionDecl *
3786 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3787 QualType TargetType,
3788 bool Complain,
3789 DeclAccessPair &Found,
3790 bool *pHadMultipleCandidates = nullptr);
3791
3792 FunctionDecl *
3793 resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
3794
3795 bool resolveAndFixAddressOfSingleOverloadCandidate(
3796 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
3797
3798 FunctionDecl *
3799 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
3800 bool Complain = false,
3801 DeclAccessPair *Found = nullptr);
3802
3803 bool ResolveAndFixSingleFunctionTemplateSpecialization(
3804 ExprResult &SrcExpr,
3805 bool DoFunctionPointerConverion = false,
3806 bool Complain = false,
3807 SourceRange OpRangeForComplaining = SourceRange(),
3808 QualType DestTypeForComplaining = QualType(),
3809 unsigned DiagIDForComplaining = 0);
3810
3811
3812 Expr *FixOverloadedFunctionReference(Expr *E,
3813 DeclAccessPair FoundDecl,
3814 FunctionDecl *Fn);
3815 ExprResult FixOverloadedFunctionReference(ExprResult,
3816 DeclAccessPair FoundDecl,
3817 FunctionDecl *Fn);
3818
3819 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
3820 ArrayRef<Expr *> Args,
3821 OverloadCandidateSet &CandidateSet,
3822 bool PartialOverloading = false);
3823 void AddOverloadedCallCandidates(
3824 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
3825 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
3826
3827 // An enum used to represent the different possible results of building a
3828 // range-based for loop.
3829 enum ForRangeStatus {
3830 FRS_Success,
3831 FRS_NoViableFunction,
3832 FRS_DiagnosticIssued
3833 };
3834
3835 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
3836 SourceLocation RangeLoc,
3837 const DeclarationNameInfo &NameInfo,
3838 LookupResult &MemberLookup,
3839 OverloadCandidateSet *CandidateSet,
3840 Expr *Range, ExprResult *CallExpr);
3841
3842 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
3843 UnresolvedLookupExpr *ULE,
3844 SourceLocation LParenLoc,
3845 MultiExprArg Args,
3846 SourceLocation RParenLoc,
3847 Expr *ExecConfig,
3848 bool AllowTypoCorrection=true,
3849 bool CalleesAddressIsTaken=false);
3850
3851 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
3852 MultiExprArg Args, SourceLocation RParenLoc,
3853 OverloadCandidateSet *CandidateSet,
3854 ExprResult *Result);
3855
3856 ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
3857 NestedNameSpecifierLoc NNSLoc,
3858 DeclarationNameInfo DNI,
3859 const UnresolvedSetImpl &Fns,
3860 bool PerformADL = true);
3861
3862 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
3863 UnaryOperatorKind Opc,
3864 const UnresolvedSetImpl &Fns,
3865 Expr *input, bool RequiresADL = true);
3866
3867 void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
3868 OverloadedOperatorKind Op,
3869 const UnresolvedSetImpl &Fns,
3870 ArrayRef<Expr *> Args, bool RequiresADL = true);
3871 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
3872 BinaryOperatorKind Opc,
3873 const UnresolvedSetImpl &Fns,
3874 Expr *LHS, Expr *RHS,
3875 bool RequiresADL = true,
3876 bool AllowRewrittenCandidates = true,
3877 FunctionDecl *DefaultedFn = nullptr);
3878 ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
3879 const UnresolvedSetImpl &Fns,
3880 Expr *LHS, Expr *RHS,
3881 FunctionDecl *DefaultedFn);
3882
3883 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
3884 SourceLocation RLoc,
3885 Expr *Base,Expr *Idx);
3886
3887 ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
3888 SourceLocation LParenLoc,
3889 MultiExprArg Args,
3890 SourceLocation RParenLoc,
3891 bool AllowRecovery = false);
3892 ExprResult
3893 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
3894 MultiExprArg Args,
3895 SourceLocation RParenLoc);
3896
3897 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
3898 SourceLocation OpLoc,
3899 bool *NoArrowOperatorFound = nullptr);
3900
3901 /// CheckCallReturnType - Checks that a call expression's return type is
3902 /// complete. Returns true on failure. The location passed in is the location
3903 /// that best represents the call.
3904 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
3905 CallExpr *CE, FunctionDecl *FD);
3906
3907 /// Helpers for dealing with blocks and functions.
3908 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
3909 bool CheckParameterNames);
3910 void CheckCXXDefaultArguments(FunctionDecl *FD);
3911 void CheckExtraCXXDefaultArguments(Declarator &D);
3912 Scope *getNonFieldDeclScope(Scope *S);
3913
3914 /// \name Name lookup
3915 ///
3916 /// These routines provide name lookup that is used during semantic
3917 /// analysis to resolve the various kinds of names (identifiers,
3918 /// overloaded operator names, constructor names, etc.) into zero or
3919 /// more declarations within a particular scope. The major entry
3920 /// points are LookupName, which performs unqualified name lookup,
3921 /// and LookupQualifiedName, which performs qualified name lookup.
3922 ///
3923 /// All name lookup is performed based on some specific criteria,
3924 /// which specify what names will be visible to name lookup and how
3925 /// far name lookup should work. These criteria are important both
3926 /// for capturing language semantics (certain lookups will ignore
3927 /// certain names, for example) and for performance, since name
3928 /// lookup is often a bottleneck in the compilation of C++. Name
3929 /// lookup criteria is specified via the LookupCriteria enumeration.
3930 ///
3931 /// The results of name lookup can vary based on the kind of name
3932 /// lookup performed, the current language, and the translation
3933 /// unit. In C, for example, name lookup will either return nothing
3934 /// (no entity found) or a single declaration. In C++, name lookup
3935 /// can additionally refer to a set of overloaded functions or
3936 /// result in an ambiguity. All of the possible results of name
3937 /// lookup are captured by the LookupResult class, which provides
3938 /// the ability to distinguish among them.
3939 //@{
3940
3941 /// Describes the kind of name lookup to perform.
3942 enum LookupNameKind {
3943 /// Ordinary name lookup, which finds ordinary names (functions,
3944 /// variables, typedefs, etc.) in C and most kinds of names
3945 /// (functions, variables, members, types, etc.) in C++.
3946 LookupOrdinaryName = 0,
3947 /// Tag name lookup, which finds the names of enums, classes,
3948 /// structs, and unions.
3949 LookupTagName,
3950 /// Label name lookup.
3951 LookupLabel,
3952 /// Member name lookup, which finds the names of
3953 /// class/struct/union members.
3954 LookupMemberName,
3955 /// Look up of an operator name (e.g., operator+) for use with
3956 /// operator overloading. This lookup is similar to ordinary name
3957 /// lookup, but will ignore any declarations that are class members.
3958 LookupOperatorName,
3959 /// Look up a name following ~ in a destructor name. This is an ordinary
3960 /// lookup, but prefers tags to typedefs.
3961 LookupDestructorName,
3962 /// Look up of a name that precedes the '::' scope resolution
3963 /// operator in C++. This lookup completely ignores operator, object,
3964 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3965 LookupNestedNameSpecifierName,
3966 /// Look up a namespace name within a C++ using directive or
3967 /// namespace alias definition, ignoring non-namespace names (C++
3968 /// [basic.lookup.udir]p1).
3969 LookupNamespaceName,
3970 /// Look up all declarations in a scope with the given name,
3971 /// including resolved using declarations. This is appropriate
3972 /// for checking redeclarations for a using declaration.
3973 LookupUsingDeclName,
3974 /// Look up an ordinary name that is going to be redeclared as a
3975 /// name with linkage. This lookup ignores any declarations that
3976 /// are outside of the current scope unless they have linkage. See
3977 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3978 LookupRedeclarationWithLinkage,
3979 /// Look up a friend of a local class. This lookup does not look
3980 /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3981 LookupLocalFriendName,
3982 /// Look up the name of an Objective-C protocol.
3983 LookupObjCProtocolName,
3984 /// Look up implicit 'self' parameter of an objective-c method.
3985 LookupObjCImplicitSelfParam,
3986 /// Look up the name of an OpenMP user-defined reduction operation.
3987 LookupOMPReductionName,
3988 /// Look up the name of an OpenMP user-defined mapper.
3989 LookupOMPMapperName,
3990 /// Look up any declaration with any name.
3991 LookupAnyName
3992 };
3993
3994 /// Specifies whether (or how) name lookup is being performed for a
3995 /// redeclaration (vs. a reference).
3996 enum RedeclarationKind {
3997 /// The lookup is a reference to this name that is not for the
3998 /// purpose of redeclaring the name.
3999 NotForRedeclaration = 0,
4000 /// The lookup results will be used for redeclaration of a name,
4001 /// if an entity by that name already exists and is visible.
4002 ForVisibleRedeclaration,
4003 /// The lookup results will be used for redeclaration of a name
4004 /// with external linkage; non-visible lookup results with external linkage
4005 /// may also be found.
4006 ForExternalRedeclaration
4007 };
4008
4009 RedeclarationKind forRedeclarationInCurContext() {
4010 // A declaration with an owning module for linkage can never link against
4011 // anything that is not visible. We don't need to check linkage here; if
4012 // the context has internal linkage, redeclaration lookup won't find things
4013 // from other TUs, and we can't safely compute linkage yet in general.
4014 if (cast<Decl>(CurContext)
4015 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
4016 return ForVisibleRedeclaration;
4017 return ForExternalRedeclaration;
4018 }
4019
4020 /// The possible outcomes of name lookup for a literal operator.
4021 enum LiteralOperatorLookupResult {
4022 /// The lookup resulted in an error.
4023 LOLR_Error,
4024 /// The lookup found no match but no diagnostic was issued.
4025 LOLR_ErrorNoDiagnostic,
4026 /// The lookup found a single 'cooked' literal operator, which
4027 /// expects a normal literal to be built and passed to it.
4028 LOLR_Cooked,
4029 /// The lookup found a single 'raw' literal operator, which expects
4030 /// a string literal containing the spelling of the literal token.
4031 LOLR_Raw,
4032 /// The lookup found an overload set of literal operator templates,
4033 /// which expect the characters of the spelling of the literal token to be
4034 /// passed as a non-type template argument pack.
4035 LOLR_Template,
4036 /// The lookup found an overload set of literal operator templates,
4037 /// which expect the character type and characters of the spelling of the
4038 /// string literal token to be passed as template arguments.
4039 LOLR_StringTemplatePack,
4040 };
4041
4042 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
4043 CXXSpecialMember SM,
4044 bool ConstArg,
4045 bool VolatileArg,
4046 bool RValueThis,
4047 bool ConstThis,
4048 bool VolatileThis);
4049
4050 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
4051 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
4052 TypoRecoveryCallback;
4053
4054private:
4055 bool CppLookupName(LookupResult &R, Scope *S);
4056
4057 struct TypoExprState {
4058 std::unique_ptr<TypoCorrectionConsumer> Consumer;
4059 TypoDiagnosticGenerator DiagHandler;
4060 TypoRecoveryCallback RecoveryHandler;
4061 TypoExprState();
4062 TypoExprState(TypoExprState &&other) noexcept;
4063 TypoExprState &operator=(TypoExprState &&other) noexcept;
4064 };
4065
4066 /// The set of unhandled TypoExprs and their associated state.
4067 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
4068
4069 /// Creates a new TypoExpr AST node.
4070 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
4071 TypoDiagnosticGenerator TDG,
4072 TypoRecoveryCallback TRC, SourceLocation TypoLoc);
4073
4074 // The set of known/encountered (unique, canonicalized) NamespaceDecls.
4075 //
4076 // The boolean value will be true to indicate that the namespace was loaded
4077 // from an AST/PCH file, or false otherwise.
4078 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
4079
4080 /// Whether we have already loaded known namespaces from an extenal
4081 /// source.
4082 bool LoadedExternalKnownNamespaces;
4083
4084 /// Helper for CorrectTypo and CorrectTypoDelayed used to create and
4085 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
4086 /// should be skipped entirely.
4087 std::unique_ptr<TypoCorrectionConsumer>
4088 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
4089 Sema::LookupNameKind LookupKind, Scope *S,
4090 CXXScopeSpec *SS,
4091 CorrectionCandidateCallback &CCC,
4092 DeclContext *MemberContext, bool EnteringContext,
4093 const ObjCObjectPointerType *OPT,
4094 bool ErrorRecovery);
4095
4096public:
4097 const TypoExprState &getTypoExprState(TypoExpr *TE) const;
4098
4099 /// Clears the state of the given TypoExpr.
4100 void clearDelayedTypo(TypoExpr *TE);
4101
4102 /// Look up a name, looking for a single declaration. Return
4103 /// null if the results were absent, ambiguous, or overloaded.
4104 ///
4105 /// It is preferable to use the elaborated form and explicitly handle
4106 /// ambiguity and overloaded.
4107 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
4108 SourceLocation Loc,
4109 LookupNameKind NameKind,
4110 RedeclarationKind Redecl
4111 = NotForRedeclaration);
4112 bool LookupBuiltin(LookupResult &R);
4113 void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID);
4114 bool LookupName(LookupResult &R, Scope *S,
4115 bool AllowBuiltinCreation = false);
4116 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4117 bool InUnqualifiedLookup = false);
4118 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4119 CXXScopeSpec &SS);
4120 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
4121 bool AllowBuiltinCreation = false,
4122 bool EnteringContext = false);
4123 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
4124 RedeclarationKind Redecl
4125 = NotForRedeclaration);
4126 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
4127
4128 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
4129 UnresolvedSetImpl &Functions);
4130
4131 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
4132 SourceLocation GnuLabelLoc = SourceLocation());
4133
4134 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
4135 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
4136 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
4137 unsigned Quals);
4138 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
4139 bool RValueThis, unsigned ThisQuals);
4140 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
4141 unsigned Quals);
4142 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
4143 bool RValueThis, unsigned ThisQuals);
4144 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
4145
4146 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id,
4147 bool IsUDSuffix);
4148 LiteralOperatorLookupResult
4149 LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys,
4150 bool AllowRaw, bool AllowTemplate,
4151 bool AllowStringTemplate, bool DiagnoseMissing,
4152 StringLiteral *StringLit = nullptr);
4153 bool isKnownName(StringRef name);
4154
4155 /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
4156 enum class FunctionEmissionStatus {
4157 Emitted,
4158 CUDADiscarded, // Discarded due to CUDA/HIP hostness
4159 OMPDiscarded, // Discarded due to OpenMP hostness
4160 TemplateDiscarded, // Discarded due to uninstantiated templates
4161 Unknown,
4162 };
4163 FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
4164 bool Final = false);
4165
4166 // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
4167 bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
4168
4169 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
4170 ArrayRef<Expr *> Args, ADLResult &Functions);
4171
4172 void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
4173 VisibleDeclConsumer &Consumer,
4174 bool IncludeGlobalScope = true,
4175 bool LoadExternal = true);
4176 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
4177 VisibleDeclConsumer &Consumer,
4178 bool IncludeGlobalScope = true,
4179 bool IncludeDependentBases = false,
4180 bool LoadExternal = true);
4181
4182 enum CorrectTypoKind {
4183 CTK_NonError, // CorrectTypo used in a non error recovery situation.
4184 CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
4185 };
4186
4187 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
4188 Sema::LookupNameKind LookupKind,
4189 Scope *S, CXXScopeSpec *SS,
4190 CorrectionCandidateCallback &CCC,
4191 CorrectTypoKind Mode,
4192 DeclContext *MemberContext = nullptr,
4193 bool EnteringContext = false,
4194 const ObjCObjectPointerType *OPT = nullptr,
4195 bool RecordFailure = true);
4196
4197 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
4198 Sema::LookupNameKind LookupKind, Scope *S,
4199 CXXScopeSpec *SS,
4200 CorrectionCandidateCallback &CCC,
4201 TypoDiagnosticGenerator TDG,
4202 TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4203 DeclContext *MemberContext = nullptr,
4204 bool EnteringContext = false,
4205 const ObjCObjectPointerType *OPT = nullptr);
4206
4207 /// Process any TypoExprs in the given Expr and its children,
4208 /// generating diagnostics as appropriate and returning a new Expr if there
4209 /// were typos that were all successfully corrected and ExprError if one or
4210 /// more typos could not be corrected.
4211 ///
4212 /// \param E The Expr to check for TypoExprs.
4213 ///
4214 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
4215 /// initializer.
4216 ///
4217 /// \param RecoverUncorrectedTypos If true, when typo correction fails, it
4218 /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.
4219 ///
4220 /// \param Filter A function applied to a newly rebuilt Expr to determine if
4221 /// it is an acceptable/usable result from a single combination of typo
4222 /// corrections. As long as the filter returns ExprError, different
4223 /// combinations of corrections will be tried until all are exhausted.
4224 ExprResult CorrectDelayedTyposInExpr(
4225 Expr *E, VarDecl *InitDecl = nullptr,
4226 bool RecoverUncorrectedTypos = false,
4227 llvm::function_ref<ExprResult(Expr *)> Filter =
4228 [](Expr *E) -> ExprResult { return E; });
4229
4230 ExprResult CorrectDelayedTyposInExpr(
4231 ExprResult ER, VarDecl *InitDecl = nullptr,
4232 bool RecoverUncorrectedTypos = false,
4233 llvm::function_ref<ExprResult(Expr *)> Filter =
4234 [](Expr *E) -> ExprResult { return E; }) {
4235 return ER.isInvalid()
4236 ? ER
4237 : CorrectDelayedTyposInExpr(ER.get(), InitDecl,
4238 RecoverUncorrectedTypos, Filter);
4239 }
4240
4241 void diagnoseTypo(const TypoCorrection &Correction,
4242 const PartialDiagnostic &TypoDiag,
4243 bool ErrorRecovery = true);
4244
4245 void diagnoseTypo(const TypoCorrection &Correction,
4246 const PartialDiagnostic &TypoDiag,
4247 const PartialDiagnostic &PrevNote,
4248 bool ErrorRecovery = true);
4249
4250 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
4251
4252 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
4253 ArrayRef<Expr *> Args,
4254 AssociatedNamespaceSet &AssociatedNamespaces,
4255 AssociatedClassSet &AssociatedClasses);
4256
4257 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
4258 bool ConsiderLinkage, bool AllowInlineNamespace);
4259
4260 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
4261
4262 void DiagnoseAmbiguousLookup(LookupResult &Result);
4263 //@}
4264
4265 /// Attempts to produce a RecoveryExpr after some AST node cannot be created.
4266 ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
4267 ArrayRef<Expr *> SubExprs,
4268 QualType T = QualType());
4269
4270 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
4271 SourceLocation IdLoc,
4272 bool TypoCorrection = false);
4273 FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,
4274 SourceLocation Loc);
4275 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
4276 Scope *S, bool ForRedeclaration,
4277 SourceLocation Loc);
4278 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
4279 Scope *S);
4280 void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
4281 FunctionDecl *FD);
4282 void AddKnownFunctionAttributes(FunctionDecl *FD);
4283
4284 // More parsing and symbol table subroutines.
4285
4286 void ProcessPragmaWeak(Scope *S, Decl *D);
4287 // Decl attributes - this routine is the top level dispatcher.
4288 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
4289 // Helper for delayed processing of attributes.
4290 void ProcessDeclAttributeDelayed(Decl *D,
4291 const ParsedAttributesView &AttrList);
4292 void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
4293 bool IncludeCXX11Attributes = true);
4294 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4295 const ParsedAttributesView &AttrList);
4296
4297 void checkUnusedDeclAttributes(Declarator &D);
4298
4299 /// Handles semantic checking for features that are common to all attributes,
4300 /// such as checking whether a parameter was properly specified, or the
4301 /// correct number of arguments were passed, etc. Returns true if the
4302 /// attribute has been diagnosed.
4303 bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A);
4304 bool checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A);
4305
4306 /// Determine if type T is a valid subject for a nonnull and similar
4307 /// attributes. By default, we look through references (the behavior used by
4308 /// nonnull), but if the second parameter is true, then we treat a reference
4309 /// type as valid.
4310 bool isValidPointerAttrType(QualType T, bool RefOkay = false);
4311
4312 bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);
4313 bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,
4314 const FunctionDecl *FD = nullptr);
4315 bool CheckAttrTarget(const ParsedAttr &CurrAttr);
4316 bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
4317 bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
4318 StringRef &Str,
4319 SourceLocation *ArgLocation = nullptr);
4320 llvm::Error isValidSectionSpecifier(StringRef Str);
4321 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
4322 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
4323 bool checkMSInheritanceAttrOnDefinition(
4324 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
4325 MSInheritanceModel SemanticSpelling);
4326
4327 void CheckAlignasUnderalignment(Decl *D);
4328
4329 /// Adjust the calling convention of a method to be the ABI default if it
4330 /// wasn't specified explicitly. This handles method types formed from
4331 /// function type typedefs and typename template arguments.
4332 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
4333 SourceLocation Loc);
4334
4335 // Check if there is an explicit attribute, but only look through parens.
4336 // The intent is to look for an attribute on the current declarator, but not
4337 // one that came from a typedef.
4338 bool hasExplicitCallingConv(QualType T);
4339
4340 /// Get the outermost AttributedType node that sets a calling convention.
4341 /// Valid types should not have multiple attributes with different CCs.
4342 const AttributedType *getCallingConvAttributedType(QualType T) const;
4343
4344 /// Process the attributes before creating an attributed statement. Returns
4345 /// the semantic attributes that have been processed.
4346 void ProcessStmtAttributes(Stmt *Stmt,
4347 const ParsedAttributesWithRange &InAttrs,
4348 SmallVectorImpl<const Attr *> &OutAttrs);
4349
4350 void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
4351 ObjCMethodDecl *MethodDecl,
4352 bool IsProtocolMethodDecl);
4353
4354 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
4355 ObjCMethodDecl *Overridden,
4356 bool IsProtocolMethodDecl);
4357
4358 /// WarnExactTypedMethods - This routine issues a warning if method
4359 /// implementation declaration matches exactly that of its declaration.
4360 void WarnExactTypedMethods(ObjCMethodDecl *Method,
4361 ObjCMethodDecl *MethodDecl,
4362 bool IsProtocolMethodDecl);
4363
4364 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
4365
4366 /// CheckImplementationIvars - This routine checks if the instance variables
4367 /// listed in the implelementation match those listed in the interface.
4368 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
4369 ObjCIvarDecl **Fields, unsigned nIvars,
4370 SourceLocation Loc);
4371
4372 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
4373 /// remains unimplemented in the class or category \@implementation.
4374 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
4375 ObjCContainerDecl* IDecl,
4376 bool IncompleteImpl = false);
4377
4378 /// DiagnoseUnimplementedProperties - This routine warns on those properties
4379 /// which must be implemented by this implementation.
4380 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
4381 ObjCContainerDecl *CDecl,
4382 bool SynthesizeProperties);
4383
4384 /// Diagnose any null-resettable synthesized setters.
4385 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
4386
4387 /// DefaultSynthesizeProperties - This routine default synthesizes all
4388 /// properties which must be synthesized in the class's \@implementation.
4389 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
4390 ObjCInterfaceDecl *IDecl,
4391 SourceLocation AtEnd);
4392 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);
4393
4394 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
4395 /// an ivar synthesized for 'Method' and 'Method' is a property accessor
4396 /// declared in class 'IFace'.
4397 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
4398 ObjCMethodDecl *Method, ObjCIvarDecl *IV);
4399
4400 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
4401 /// backs the property is not used in the property's accessor.
4402 void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
4403 const ObjCImplementationDecl *ImplD);
4404
4405 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
4406 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
4407 /// It also returns ivar's property on success.
4408 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
4409 const ObjCPropertyDecl *&PDecl) const;
4410
4411 /// Called by ActOnProperty to handle \@property declarations in
4412 /// class extensions.
4413 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,
4414 SourceLocation AtLoc,
4415 SourceLocation LParenLoc,
4416 FieldDeclarator &FD,
4417 Selector GetterSel,
4418 SourceLocation GetterNameLoc,
4419 Selector SetterSel,
4420 SourceLocation SetterNameLoc,
4421 const bool isReadWrite,
4422 unsigned &Attributes,
4423 const unsigned AttributesAsWritten,
4424 QualType T,
4425 TypeSourceInfo *TSI,
4426 tok::ObjCKeywordKind MethodImplKind);
4427
4428 /// Called by ActOnProperty and HandlePropertyInClassExtension to
4429 /// handle creating the ObjcPropertyDecl for a category or \@interface.
4430 ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
4431 ObjCContainerDecl *CDecl,
4432 SourceLocation AtLoc,
4433 SourceLocation LParenLoc,
4434 FieldDeclarator &FD,
4435 Selector GetterSel,
4436 SourceLocation GetterNameLoc,
4437 Selector SetterSel,
4438 SourceLocation SetterNameLoc,
4439 const bool isReadWrite,
4440 const unsigned Attributes,
4441 const unsigned AttributesAsWritten,
4442 QualType T,
4443 TypeSourceInfo *TSI,
4444 tok::ObjCKeywordKind MethodImplKind,
4445 DeclContext *lexicalDC = nullptr);
4446
4447 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
4448 /// warning) when atomic property has one but not the other user-declared
4449 /// setter or getter.
4450 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
4451 ObjCInterfaceDecl* IDecl);
4452
4453 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
4454
4455 void DiagnoseMissingDesignatedInitOverrides(
4456 const ObjCImplementationDecl *ImplD,
4457 const ObjCInterfaceDecl *IFD);
4458
4459 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
4460
4461 enum MethodMatchStrategy {
4462 MMS_loose,
4463 MMS_strict
4464 };
4465
4466 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
4467 /// true, or false, accordingly.
4468 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
4469 const ObjCMethodDecl *PrevMethod,
4470 MethodMatchStrategy strategy = MMS_strict);
4471
4472 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
4473 /// or protocol against those declared in their implementations.
4474 void MatchAllMethodDeclarations(const SelectorSet &InsMap,
4475 const SelectorSet &ClsMap,
4476 SelectorSet &InsMapSeen,
4477 SelectorSet &ClsMapSeen,
4478 ObjCImplDecl* IMPDecl,
4479 ObjCContainerDecl* IDecl,
4480 bool &IncompleteImpl,
4481 bool ImmediateClass,
4482 bool WarnCategoryMethodImpl=false);
4483
4484 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
4485 /// category matches with those implemented in its primary class and
4486 /// warns each time an exact match is found.
4487 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
4488
4489 /// Add the given method to the list of globally-known methods.
4490 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
4491
4492 /// Returns default addr space for method qualifiers.
4493 LangAS getDefaultCXXMethodAddrSpace() const;
4494
4495private:
4496 /// AddMethodToGlobalPool - Add an instance or factory method to the global
4497 /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
4498 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
4499
4500 /// LookupMethodInGlobalPool - Returns the instance or factory method and
4501 /// optionally warns if there are multiple signatures.
4502 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
4503 bool receiverIdOrClass,
4504 bool instance);
4505
4506public:
4507 /// - Returns instance or factory methods in global method pool for
4508 /// given selector. It checks the desired kind first, if none is found, and
4509 /// parameter checkTheOther is set, it then checks the other kind. If no such
4510 /// method or only one method is found, function returns false; otherwise, it
4511 /// returns true.
4512 bool
4513 CollectMultipleMethodsInGlobalPool(Selector Sel,
4514 SmallVectorImpl<ObjCMethodDecl*>& Methods,
4515 bool InstanceFirst, bool CheckTheOther,
4516 const ObjCObjectType *TypeBound = nullptr);
4517
4518 bool
4519 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
4520 SourceRange R, bool receiverIdOrClass,
4521 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4522
4523 void
4524 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
4525 Selector Sel, SourceRange R,
4526 bool receiverIdOrClass);
4527
4528private:
4529 /// - Returns a selector which best matches given argument list or
4530 /// nullptr if none could be found
4531 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
4532 bool IsInstance,
4533 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4534
4535
4536 /// Record the typo correction failure and return an empty correction.
4537 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
4538 bool RecordFailure = true) {
4539 if (RecordFailure)
4540 TypoCorrectionFailures[Typo].insert(TypoLoc);
4541 return TypoCorrection();
4542 }
4543
4544public:
4545 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
4546 /// unit are added to a global pool. This allows us to efficiently associate
4547 /// a selector with a method declaraation for purposes of typechecking
4548 /// messages sent to "id" (where the class of the object is unknown).
4549 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4550 AddMethodToGlobalPool(Method, impl, /*instance*/true);
4551 }
4552
4553 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
4554 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4555 AddMethodToGlobalPool(Method, impl, /*instance*/false);
4556 }
4557
4558 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
4559 /// pool.
4560 void AddAnyMethodToGlobalPool(Decl *D);
4561
4562 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
4563 /// there are multiple signatures.
4564 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
4565 bool receiverIdOrClass=false) {
4566 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4567 /*instance*/true);
4568 }
4569
4570 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
4571 /// there are multiple signatures.
4572 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
4573 bool receiverIdOrClass=false) {
4574 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4575 /*instance*/false);
4576 }
4577
4578 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
4579 QualType ObjectType=QualType());
4580 /// LookupImplementedMethodInGlobalPool - Returns the method which has an
4581 /// implementation.
4582 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
4583
4584 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4585 /// initialization.
4586 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
4587 SmallVectorImpl<ObjCIvarDecl*> &Ivars);
4588
4589 //===--------------------------------------------------------------------===//
4590 // Statement Parsing Callbacks: SemaStmt.cpp.
4591public:
4592 class FullExprArg {
4593 public:
4594 FullExprArg() : E(nullptr) { }
4595 FullExprArg(Sema &actions) : E(nullptr) { }
4596
4597 ExprResult release() {
4598 return E;
4599 }
4600
4601 Expr *get() const { return E; }
4602
4603 Expr *operator->() {
4604 return E;
4605 }
4606
4607 private:
4608 // FIXME: No need to make the entire Sema class a friend when it's just
4609 // Sema::MakeFullExpr that needs access to the constructor below.
4610 friend class Sema;
4611
4612 explicit FullExprArg(Expr *expr) : E(expr) {}
4613
4614 Expr *E;
4615 };
4616
4617 FullExprArg MakeFullExpr(Expr *Arg) {
4618 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
4619 }
4620 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
4621 return FullExprArg(
4622 ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get());
4623 }
4624 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
4625 ExprResult FE =
4626 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),
4627 /*DiscardedValue*/ true);
4628 return FullExprArg(FE.get());
4629 }
4630
4631 StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);
4632 StmtResult ActOnExprStmtError();
4633
4634 StmtResult ActOnNullStmt(SourceLocation SemiLoc,
4635 bool HasLeadingEmptyMacro = false);
4636
4637 void ActOnStartOfCompoundStmt(bool IsStmtExpr);
4638 void ActOnAfterCompoundStatementLeadingPragmas();
4639 void ActOnFinishOfCompoundStmt();
4640 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
4641 ArrayRef<Stmt *> Elts, bool isStmtExpr);
4642
4643 /// A RAII object to enter scope of a compound statement.
4644 class CompoundScopeRAII {
4645 public:
4646 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {
4647 S.ActOnStartOfCompoundStmt(IsStmtExpr);
4648 }
4649
4650 ~CompoundScopeRAII() {
4651 S.ActOnFinishOfCompoundStmt();
4652 }
4653
4654 private:
4655 Sema &S;
4656 };
4657
4658 /// An RAII helper that pops function a function scope on exit.
4659 struct FunctionScopeRAII {
4660 Sema &S;
4661 bool Active;
4662 FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
4663 ~FunctionScopeRAII() {
4664 if (Active)
4665 S.PopFunctionScopeInfo();
4666 }
4667 void disable() { Active = false; }
4668 };
4669
4670 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
4671 SourceLocation StartLoc,
4672 SourceLocation EndLoc);
4673 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
4674 StmtResult ActOnForEachLValueExpr(Expr *E);
4675 ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);
4676 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,
4677 SourceLocation DotDotDotLoc, ExprResult RHS,
4678 SourceLocation ColonLoc);
4679 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
4680
4681 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
4682 SourceLocation ColonLoc,
4683 Stmt *SubStmt, Scope *CurScope);
4684 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
4685 SourceLocation ColonLoc, Stmt *SubStmt);
4686
4687 StmtResult BuildAttributedStmt(SourceLocation AttrsLoc,
4688 ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
4689 StmtResult ActOnAttributedStmt(const ParsedAttributesWithRange &AttrList,
4690 Stmt *SubStmt);
4691
4692 class ConditionResult;
4693 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4694 SourceLocation LParenLoc, Stmt *InitStmt,
4695 ConditionResult Cond, SourceLocation RParenLoc,
4696 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4697 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4698 SourceLocation LParenLoc, Stmt *InitStmt,
4699 ConditionResult Cond, SourceLocation RParenLoc,
4700 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4701 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
4702 SourceLocation LParenLoc, Stmt *InitStmt,
4703 ConditionResult Cond,
4704 SourceLocation RParenLoc);
4705 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
4706 Stmt *Switch, Stmt *Body);
4707 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
4708 ConditionResult Cond, SourceLocation RParenLoc,
4709 Stmt *Body);
4710 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
4711 SourceLocation WhileLoc, SourceLocation CondLParen,
4712 Expr *Cond, SourceLocation CondRParen);
4713
4714 StmtResult ActOnForStmt(SourceLocation ForLoc,
4715 SourceLocation LParenLoc,
4716 Stmt *First,
4717 ConditionResult Second,
4718 FullExprArg Third,
4719 SourceLocation RParenLoc,
4720 Stmt *Body);
4721 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
4722 Expr *collection);
4723 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
4724 Stmt *First, Expr *collection,
4725 SourceLocation RParenLoc);
4726 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
4727
4728 enum BuildForRangeKind {
4729 /// Initial building of a for-range statement.
4730 BFRK_Build,
4731 /// Instantiation or recovery rebuild of a for-range statement. Don't
4732 /// attempt any typo-correction.
4733 BFRK_Rebuild,
4734 /// Determining whether a for-range statement could be built. Avoid any
4735 /// unnecessary or irreversible actions.
4736 BFRK_Check
4737 };
4738
4739 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
4740 SourceLocation CoawaitLoc,
4741 Stmt *InitStmt,
4742 Stmt *LoopVar,
4743 SourceLocation ColonLoc, Expr *Collection,
4744 SourceLocation RParenLoc,
4745 BuildForRangeKind Kind);
4746 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
4747 SourceLocation CoawaitLoc,
4748 Stmt *InitStmt,
4749 SourceLocation ColonLoc,
4750 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4751 Expr *Cond, Expr *Inc,
4752 Stmt *LoopVarDecl,
4753 SourceLocation RParenLoc,
4754 BuildForRangeKind Kind);
4755 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
4756
4757 StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
4758 SourceLocation LabelLoc,
4759 LabelDecl *TheDecl);
4760 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
4761 SourceLocation StarLoc,
4762 Expr *DestExp);
4763 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
4764 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
4765
4766 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4767 CapturedRegionKind Kind, unsigned NumParams);
4768 typedef std::pair<StringRef, QualType> CapturedParamNameType;
4769 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4770 CapturedRegionKind Kind,
4771 ArrayRef<CapturedParamNameType> Params,
4772 unsigned OpenMPCaptureLevel = 0);
4773 StmtResult ActOnCapturedRegionEnd(Stmt *S);
4774 void ActOnCapturedRegionError();
4775 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
4776 SourceLocation Loc,
4777 unsigned NumParams);
4778
4779 struct NamedReturnInfo {
4780 const VarDecl *Candidate;
4781
4782 enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable };
4783 Status S;
4784
4785 bool isMoveEligible() const { return S != None; };
4786 bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
4787 };
4788 enum class SimplerImplicitMoveMode { ForceOff, Normal, ForceOn };
4789 NamedReturnInfo getNamedReturnInfo(
4790 Expr *&E, SimplerImplicitMoveMode Mode = SimplerImplicitMoveMode::Normal);
4791 NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
4792 const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
4793 QualType ReturnType);
4794
4795 ExprResult
4796 PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
4797 const NamedReturnInfo &NRInfo, Expr *Value,
4798 bool SupressSimplerImplicitMoves = false);
4799
4800 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4801 Scope *CurScope);
4802 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4803 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4804 NamedReturnInfo &NRInfo,
4805 bool SupressSimplerImplicitMoves);
4806
4807 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
4808 bool IsVolatile, unsigned NumOutputs,
4809 unsigned NumInputs, IdentifierInfo **Names,
4810 MultiExprArg Constraints, MultiExprArg Exprs,
4811 Expr *AsmString, MultiExprArg Clobbers,
4812 unsigned NumLabels,
4813 SourceLocation RParenLoc);
4814
4815 void FillInlineAsmIdentifierInfo(Expr *Res,
4816 llvm::InlineAsmIdentifierInfo &Info);
4817 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
4818 SourceLocation TemplateKWLoc,
4819 UnqualifiedId &Id,
4820 bool IsUnevaluatedContext);
4821 bool LookupInlineAsmField(StringRef Base, StringRef Member,
4822 unsigned &Offset, SourceLocation AsmLoc);
4823 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
4824 SourceLocation AsmLoc);
4825 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
4826 ArrayRef<Token> AsmToks,
4827 StringRef AsmString,
4828 unsigned NumOutputs, unsigned NumInputs,
4829 ArrayRef<StringRef> Constraints,
4830 ArrayRef<StringRef> Clobbers,
4831 ArrayRef<Expr*> Exprs,
4832 SourceLocation EndLoc);
4833 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
4834 SourceLocation Location,
4835 bool AlwaysCreate);
4836
4837 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
4838 SourceLocation StartLoc,
4839 SourceLocation IdLoc, IdentifierInfo *Id,
4840 bool Invalid = false);
4841
4842 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
4843
4844 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
4845 Decl *Parm, Stmt *Body);
4846
4847 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
4848
4849 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
4850 MultiStmtArg Catch, Stmt *Finally);
4851
4852 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
4853 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
4854 Scope *CurScope);
4855 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
4856 Expr *operand);
4857 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
4858 Expr *SynchExpr,
4859 Stmt *SynchBody);
4860
4861 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
4862
4863 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
4864 SourceLocation StartLoc,
4865 SourceLocation IdLoc,
4866 IdentifierInfo *Id);
4867
4868 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
4869
4870 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
4871 Decl *ExDecl, Stmt *HandlerBlock);
4872 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4873 ArrayRef<Stmt *> Handlers);
4874
4875 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
4876 SourceLocation TryLoc, Stmt *TryBlock,
4877 Stmt *Handler);
4878 StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
4879 Expr *FilterExpr,
4880 Stmt *Block);
4881 void ActOnStartSEHFinallyBlock();
4882 void ActOnAbortSEHFinallyBlock();
4883 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
4884 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
4885
4886 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
4887
4888 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
4889
4890 /// If it's a file scoped decl that must warn if not used, keep track
4891 /// of it.
4892 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
4893
4894 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
4895 /// whose result is unused, warn.
4896 void DiagnoseUnusedExprResult(const Stmt *S);
4897 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
4898 void DiagnoseUnusedDecl(const NamedDecl *ND);
4899
4900 /// If VD is set but not otherwise used, diagnose, for a parameter or a
4901 /// variable.
4902 void DiagnoseUnusedButSetDecl(const VarDecl *VD);
4903
4904 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
4905 /// statement as a \p Body, and it is located on the same line.
4906 ///
4907 /// This helps prevent bugs due to typos, such as:
4908 /// if (condition);
4909 /// do_stuff();
4910 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
4911 const Stmt *Body,
4912 unsigned DiagID);
4913
4914 /// Warn if a for/while loop statement \p S, which is followed by
4915 /// \p PossibleBody, has a suspicious null statement as a body.
4916 void DiagnoseEmptyLoopBody(const Stmt *S,
4917 const Stmt *PossibleBody);
4918
4919 /// Warn if a value is moved to itself.
4920 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
4921 SourceLocation OpLoc);
4922
4923 /// Warn if we're implicitly casting from a _Nullable pointer type to a
4924 /// _Nonnull one.
4925 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
4926 SourceLocation Loc);
4927
4928 /// Warn when implicitly casting 0 to nullptr.
4929 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
4930
4931 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
4932 return DelayedDiagnostics.push(pool);
4933 }
4934 void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
4935
4936 typedef ProcessingContextState ParsingClassState;
4937 ParsingClassState PushParsingClass() {
4938 ParsingClassDepth++;
4939 return DelayedDiagnostics.pushUndelayed();
4940 }
4941 void PopParsingClass(ParsingClassState state) {
4942 ParsingClassDepth--;
4943 DelayedDiagnostics.popUndelayed(state);
4944 }
4945
4946 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
4947
4948 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4949 const ObjCInterfaceDecl *UnknownObjCClass,
4950 bool ObjCPropertyAccess,
4951 bool AvoidPartialAvailabilityChecks = false,
4952 ObjCInterfaceDecl *ClassReceiver = nullptr);
4953
4954 bool makeUnavailableInSystemHeader(SourceLocation loc,
4955 UnavailableAttr::ImplicitReason reason);
4956
4957 /// Issue any -Wunguarded-availability warnings in \c FD
4958 void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
4959
4960 void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
4961
4962 //===--------------------------------------------------------------------===//
4963 // Expression Parsing Callbacks: SemaExpr.cpp.
4964
4965 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
4966 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4967 const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
4968 bool ObjCPropertyAccess = false,
4969 bool AvoidPartialAvailabilityChecks = false,
4970 ObjCInterfaceDecl *ClassReciever = nullptr);
4971 void NoteDeletedFunction(FunctionDecl *FD);
4972 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
4973 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
4974 ObjCMethodDecl *Getter,
4975 SourceLocation Loc);
4976 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
4977 ArrayRef<Expr *> Args);
4978
4979 void PushExpressionEvaluationContext(
4980 ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,
4981 ExpressionEvaluationContextRecord::ExpressionKind Type =
4982 ExpressionEvaluationContextRecord::EK_Other);
4983 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
4984 void PushExpressionEvaluationContext(
4985 ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
4986 ExpressionEvaluationContextRecord::ExpressionKind Type =
4987 ExpressionEvaluationContextRecord::EK_Other);
4988 void PopExpressionEvaluationContext();
4989
4990 void DiscardCleanupsInEvaluationContext();
4991
4992 ExprResult TransformToPotentiallyEvaluated(Expr *E);
4993 ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
4994
4995 ExprResult CheckUnevaluatedOperand(Expr *E);
4996 void CheckUnusedVolatileAssignment(Expr *E);
4997
4998 ExprResult ActOnConstantExpression(ExprResult Res);
4999
5000 // Functions for marking a declaration referenced. These functions also
5001 // contain the relevant logic for marking if a reference to a function or
5002 // variable is an odr-use (in the C++11 sense). There are separate variants
5003 // for expressions referring to a decl; these exist because odr-use marking
5004 // needs to be delayed for some constant variables when we build one of the
5005 // named expressions.
5006 //
5007 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
5008 // should usually be true. This only needs to be set to false if the lack of
5009 // odr-use cannot be determined from the current context (for instance,
5010 // because the name denotes a virtual function and was written without an
5011 // explicit nested-name-specifier).
5012 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
5013 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
5014 bool MightBeOdrUse = true);
5015 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
5016 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
5017 void MarkMemberReferenced(MemberExpr *E);
5018 void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);
5019 void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,
5020 unsigned CapturingScopeIndex);
5021
5022 ExprResult CheckLValueToRValueConversionOperand(Expr *E);
5023 void CleanupVarDeclMarking();
5024
5025 enum TryCaptureKind {
5026 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
5027 };
5028
5029 /// Try to capture the given variable.
5030 ///
5031 /// \param Var The variable to capture.
5032 ///
5033 /// \param Loc The location at which the capture occurs.
5034 ///
5035 /// \param Kind The kind of capture, which may be implicit (for either a
5036 /// block or a lambda), or explicit by-value or by-reference (for a lambda).
5037 ///
5038 /// \param EllipsisLoc The location of the ellipsis, if one is provided in
5039 /// an explicit lambda capture.
5040 ///
5041 /// \param BuildAndDiagnose Whether we are actually supposed to add the
5042 /// captures or diagnose errors. If false, this routine merely check whether
5043 /// the capture can occur without performing the capture itself or complaining
5044 /// if the variable cannot be captured.
5045 ///
5046 /// \param CaptureType Will be set to the type of the field used to capture
5047 /// this variable in the innermost block or lambda. Only valid when the
5048 /// variable can be captured.
5049 ///
5050 /// \param DeclRefType Will be set to the type of a reference to the capture
5051 /// from within the current scope. Only valid when the variable can be
5052 /// captured.
5053 ///
5054 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
5055 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
5056 /// This is useful when enclosing lambdas must speculatively capture
5057 /// variables that may or may not be used in certain specializations of
5058 /// a nested generic lambda.
5059 ///
5060 /// \returns true if an error occurred (i.e., the variable cannot be
5061 /// captured) and false if the capture succeeded.
5062 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
5063 SourceLocation EllipsisLoc, bool BuildAndDiagnose,
5064 QualType &CaptureType,
5065 QualType &DeclRefType,
5066 const unsigned *const FunctionScopeIndexToStopAt);
5067
5068 /// Try to capture the given variable.
5069 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
5070 TryCaptureKind Kind = TryCapture_Implicit,
5071 SourceLocation EllipsisLoc = SourceLocation());
5072
5073 /// Checks if the variable must be captured.
5074 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
5075
5076 /// Given a variable, determine the type that a reference to that
5077 /// variable will have in the given scope.
5078 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
5079
5080 /// Mark all of the declarations referenced within a particular AST node as
5081 /// referenced. Used when template instantiation instantiates a non-dependent
5082 /// type -- entities referenced by the type are now referenced.
5083 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
5084 void MarkDeclarationsReferencedInExpr(Expr *E,
5085 bool SkipLocalVariables = false);
5086
5087 /// Try to recover by turning the given expression into a
5088 /// call. Returns true if recovery was attempted or an error was
5089 /// emitted; this may also leave the ExprResult invalid.
5090 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
5091 bool ForceComplain = false,
5092 bool (*IsPlausibleResult)(QualType) = nullptr);
5093
5094 /// Figure out if an expression could be turned into a call.
5095 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
5096 UnresolvedSetImpl &NonTemplateOverloads);
5097
5098 /// Try to convert an expression \p E to type \p Ty. Returns the result of the
5099 /// conversion.
5100 ExprResult tryConvertExprToType(Expr *E, QualType Ty);
5101
5102 /// Conditionally issue a diagnostic based on the current
5103 /// evaluation context.
5104 ///
5105 /// \param Statement If Statement is non-null, delay reporting the
5106 /// diagnostic until the function body is parsed, and then do a basic
5107 /// reachability analysis to determine if the statement is reachable.
5108 /// If it is unreachable, the diagnostic will not be emitted.
5109 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
5110 const PartialDiagnostic &PD);
5111 /// Similar, but diagnostic is only produced if all the specified statements
5112 /// are reachable.
5113 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
5114 const PartialDiagnostic &PD);
5115
5116 // Primary Expressions.
5117 SourceRange getExprRange(Expr *E) const;
5118
5119 ExprResult ActOnIdExpression(
5120 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5121 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
5122 CorrectionCandidateCallback *CCC = nullptr,
5123 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
5124
5125 void DecomposeUnqualifiedId(const UnqualifiedId &Id,
5126 TemplateArgumentListInfo &Buffer,
5127 DeclarationNameInfo &NameInfo,
5128 const TemplateArgumentListInfo *&TemplateArgs);
5129
5130 bool DiagnoseDependentMemberLookup(LookupResult &R);
5131
5132 bool
5133 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
5134 CorrectionCandidateCallback &CCC,
5135 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
5136 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
5137
5138 DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,
5139 IdentifierInfo *II);
5140 ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV);
5141
5142 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
5143 IdentifierInfo *II,
5144 bool AllowBuiltinCreation=false);
5145
5146 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
5147 SourceLocation TemplateKWLoc,
5148 const DeclarationNameInfo &NameInfo,
5149 bool isAddressOfOperand,
5150 const TemplateArgumentListInfo *TemplateArgs);
5151
5152 /// If \p D cannot be odr-used in the current expression evaluation context,
5153 /// return a reason explaining why. Otherwise, return NOUR_None.
5154 NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);
5155
5156 DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5157 SourceLocation Loc,
5158 const CXXScopeSpec *SS = nullptr);
5159 DeclRefExpr *
5160 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5161 const DeclarationNameInfo &NameInfo,
5162 const CXXScopeSpec *SS = nullptr,
5163 NamedDecl *FoundD = nullptr,
5164 SourceLocation TemplateKWLoc = SourceLocation(),
5165 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5166 DeclRefExpr *
5167 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5168 const DeclarationNameInfo &NameInfo,
5169 NestedNameSpecifierLoc NNS,
5170 NamedDecl *FoundD = nullptr,
5171 SourceLocation TemplateKWLoc = SourceLocation(),
5172 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5173
5174 ExprResult
5175 BuildAnonymousStructUnionMemberReference(
5176 const CXXScopeSpec &SS,
5177 SourceLocation nameLoc,
5178 IndirectFieldDecl *indirectField,
5179 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
5180 Expr *baseObjectExpr = nullptr,
5181 SourceLocation opLoc = SourceLocation());
5182
5183 ExprResult BuildPossibleImplicitMemberExpr(
5184 const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
5185 const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
5186 UnresolvedLookupExpr *AsULE = nullptr);
5187 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
5188 SourceLocation TemplateKWLoc,
5189 LookupResult &R,
5190 const TemplateArgumentListInfo *TemplateArgs,
5191 bool IsDefiniteInstance,
5192 const Scope *S);
5193 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
5194 const LookupResult &R,
5195 bool HasTrailingLParen);
5196
5197 ExprResult
5198 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
5199 const DeclarationNameInfo &NameInfo,
5200 bool IsAddressOfOperand, const Scope *S,
5201 TypeSourceInfo **RecoveryTSI = nullptr);
5202
5203 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
5204 SourceLocation TemplateKWLoc,
5205 const DeclarationNameInfo &NameInfo,
5206 const TemplateArgumentListInfo *TemplateArgs);
5207
5208 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
5209 LookupResult &R,
5210 bool NeedsADL,
5211 bool AcceptInvalidDecl = false);
5212 ExprResult BuildDeclarationNameExpr(
5213 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
5214 NamedDecl *FoundD = nullptr,
5215 const TemplateArgumentListInfo *TemplateArgs = nullptr,
5216 bool AcceptInvalidDecl = false);
5217
5218 ExprResult BuildLiteralOperatorCall(LookupResult &R,
5219 DeclarationNameInfo &SuffixInfo,
5220 ArrayRef<Expr *> Args,
5221 SourceLocation LitEndLoc,
5222 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
5223
5224 ExprResult BuildPredefinedExpr(SourceLocation Loc,
5225 PredefinedExpr::IdentKind IK);
5226 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
5227 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
5228
5229 ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5230 SourceLocation LParen,
5231 SourceLocation RParen,
5232 TypeSourceInfo *TSI);
5233 ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5234 SourceLocation LParen,
5235 SourceLocation RParen,
5236 ParsedType ParsedTy);
5237
5238 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
5239
5240 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
5241 ExprResult ActOnCharacterConstant(const Token &Tok,
5242 Scope *UDLScope = nullptr);
5243 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
5244 ExprResult ActOnParenListExpr(SourceLocation L,
5245 SourceLocation R,
5246 MultiExprArg Val);
5247
5248 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
5249 /// fragments (e.g. "foo" "bar" L"baz").
5250 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
5251 Scope *UDLScope = nullptr);
5252
5253 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
5254 SourceLocation DefaultLoc,
5255 SourceLocation RParenLoc,
5256 Expr *ControllingExpr,
5257 ArrayRef<ParsedType> ArgTypes,
5258 ArrayRef<Expr *> ArgExprs);
5259 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
5260 SourceLocation DefaultLoc,
5261 SourceLocation RParenLoc,
5262 Expr *ControllingExpr,
5263 ArrayRef<TypeSourceInfo *> Types,
5264 ArrayRef<Expr *> Exprs);
5265
5266 // Binary/Unary Operators. 'Tok' is the token for the operator.
5267 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
5268 Expr *InputExpr);
5269 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
5270 UnaryOperatorKind Opc, Expr *Input);
5271 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5272 tok::TokenKind Op, Expr *Input);
5273
5274 bool isQualifiedMemberAccess(Expr *E);
5275 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
5276
5277 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
5278 SourceLocation OpLoc,
5279 UnaryExprOrTypeTrait ExprKind,
5280 SourceRange R);
5281 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
5282 UnaryExprOrTypeTrait ExprKind);
5283 ExprResult
5284 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
5285 UnaryExprOrTypeTrait ExprKind,
5286 bool IsType, void *TyOrEx,
5287 SourceRange ArgRange);
5288
5289 ExprResult CheckPlaceholderExpr(Expr *E);
5290 bool CheckVecStepExpr(Expr *E);
5291
5292 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
5293 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
5294 SourceRange ExprRange,
5295 UnaryExprOrTypeTrait ExprKind);
5296 ExprResult ActOnSizeofParameterPackExpr(Scope *S,
5297 SourceLocation OpLoc,
5298 IdentifierInfo &Name,
5299 SourceLocation NameLoc,
5300 SourceLocation RParenLoc);
5301 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
5302 tok::TokenKind Kind, Expr *Input);
5303
5304 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
5305 Expr *Idx, SourceLocation RLoc);
5306 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
5307 Expr *Idx, SourceLocation RLoc);
5308
5309 ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
5310 Expr *ColumnIdx,
5311 SourceLocation RBLoc);
5312
5313 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
5314 Expr *LowerBound,
5315 SourceLocation ColonLocFirst,
5316 SourceLocation ColonLocSecond,
5317 Expr *Length, Expr *Stride,
5318 SourceLocation RBLoc);
5319 ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
5320 SourceLocation RParenLoc,
5321 ArrayRef<Expr *> Dims,
5322 ArrayRef<SourceRange> Brackets);
5323
5324 /// Data structure for iterator expression.
5325 struct OMPIteratorData {
5326 IdentifierInfo *DeclIdent = nullptr;
5327 SourceLocation DeclIdentLoc;
5328 ParsedType Type;
5329 OMPIteratorExpr::IteratorRange Range;
5330 SourceLocation AssignLoc;
5331 SourceLocation ColonLoc;
5332 SourceLocation SecColonLoc;
5333 };
5334
5335 ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
5336 SourceLocation LLoc, SourceLocation RLoc,
5337 ArrayRef<OMPIteratorData> Data);
5338
5339 // This struct is for use by ActOnMemberAccess to allow
5340 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
5341 // changing the access operator from a '.' to a '->' (to see if that is the
5342 // change needed to fix an error about an unknown member, e.g. when the class
5343 // defines a custom operator->).
5344 struct ActOnMemberAccessExtraArgs {
5345 Scope *S;
5346 UnqualifiedId &Id;
5347 Decl *ObjCImpDecl;
5348 };
5349
5350 ExprResult BuildMemberReferenceExpr(
5351 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
5352 CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5353 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,
5354 const TemplateArgumentListInfo *TemplateArgs,
5355 const Scope *S,
5356 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5357
5358 ExprResult
5359 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
5360 bool IsArrow, const CXXScopeSpec &SS,
5361 SourceLocation TemplateKWLoc,
5362 NamedDecl *FirstQualifierInScope, LookupResult &R,
5363 const TemplateArgumentListInfo *TemplateArgs,
5364 const Scope *S,
5365 bool SuppressQualifierCheck = false,
5366 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5367
5368 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
5369 SourceLocation OpLoc,
5370 const CXXScopeSpec &SS, FieldDecl *Field,
5371 DeclAccessPair FoundDecl,
5372 const DeclarationNameInfo &MemberNameInfo);
5373
5374 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
5375
5376 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
5377 const CXXScopeSpec &SS,
5378 const LookupResult &R);
5379
5380 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
5381 bool IsArrow, SourceLocation OpLoc,
5382 const CXXScopeSpec &SS,
5383 SourceLocation TemplateKWLoc,
5384 NamedDecl *FirstQualifierInScope,
5385 const DeclarationNameInfo &NameInfo,
5386 const TemplateArgumentListInfo *TemplateArgs);
5387
5388 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
5389 SourceLocation OpLoc,
5390 tok::TokenKind OpKind,
5391 CXXScopeSpec &SS,
5392 SourceLocation TemplateKWLoc,
5393 UnqualifiedId &Member,
5394 Decl *ObjCImpDecl);
5395
5396 MemberExpr *
5397 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5398 const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,
5399 ValueDecl *Member, DeclAccessPair FoundDecl,
5400 bool HadMultipleCandidates,
5401 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5402 ExprValueKind VK, ExprObjectKind OK,
5403 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5404 MemberExpr *
5405 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5406 NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
5407 ValueDecl *Member, DeclAccessPair FoundDecl,
5408 bool HadMultipleCandidates,
5409 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5410 ExprValueKind VK, ExprObjectKind OK,
5411 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5412
5413 void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
5414 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
5415 FunctionDecl *FDecl,
5416 const FunctionProtoType *Proto,
5417 ArrayRef<Expr *> Args,
5418 SourceLocation RParenLoc,
5419 bool ExecConfig = false);
5420 void CheckStaticArrayArgument(SourceLocation CallLoc,
5421 ParmVarDecl *Param,
5422 const Expr *ArgExpr);
5423
5424 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
5425 /// This provides the location of the left/right parens and a list of comma
5426 /// locations.
5427 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5428 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5429 Expr *ExecConfig = nullptr);
5430 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5431 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5432 Expr *ExecConfig = nullptr,
5433 bool IsExecConfig = false,
5434 bool AllowRecovery = false);
5435 Expr *BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
5436 MultiExprArg CallArgs);
5437 enum class AtomicArgumentOrder { API, AST };
5438 ExprResult
5439 BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
5440 SourceLocation RParenLoc, MultiExprArg Args,
5441 AtomicExpr::AtomicOp Op,
5442 AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
5443 ExprResult
5444 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
5445 ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
5446 Expr *Config = nullptr, bool IsExecConfig = false,
5447 ADLCallKind UsesADL = ADLCallKind::NotADL);
5448
5449 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
5450 MultiExprArg ExecConfig,
5451 SourceLocation GGGLoc);
5452
5453 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
5454 Declarator &D, ParsedType &Ty,
5455 SourceLocation RParenLoc, Expr *CastExpr);
5456 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
5457 TypeSourceInfo *Ty,
5458 SourceLocation RParenLoc,
5459 Expr *Op);
5460 CastKind PrepareScalarCast(ExprResult &src, QualType destType);
5461
5462 /// Build an altivec or OpenCL literal.
5463 ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
5464 SourceLocation RParenLoc, Expr *E,
5465 TypeSourceInfo *TInfo);
5466
5467 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
5468
5469 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
5470 ParsedType Ty,
5471 SourceLocation RParenLoc,
5472 Expr *InitExpr);
5473
5474 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
5475 TypeSourceInfo *TInfo,
5476 SourceLocation RParenLoc,
5477 Expr *LiteralExpr);
5478
5479 ExprResult ActOnInitList(SourceLocation LBraceLoc,
5480 MultiExprArg InitArgList,
5481 SourceLocation RBraceLoc);
5482
5483 ExprResult BuildInitList(SourceLocation LBraceLoc,
5484 MultiExprArg InitArgList,
5485 SourceLocation RBraceLoc);
5486
5487 ExprResult ActOnDesignatedInitializer(Designation &Desig,
5488 SourceLocation EqualOrColonLoc,
5489 bool GNUSyntax,
5490 ExprResult Init);
5491
5492private:
5493 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
5494
5495public:
5496 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
5497 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
5498 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
5499 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
5500 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
5501 Expr *LHSExpr, Expr *RHSExpr);
5502 void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
5503 UnresolvedSetImpl &Functions);
5504
5505 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
5506
5507 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
5508 /// in the case of a the GNU conditional expr extension.
5509 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
5510 SourceLocation ColonLoc,
5511 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
5512
5513 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
5514 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
5515 LabelDecl *TheDecl);
5516
5517 void ActOnStartStmtExpr();
5518 ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
5519 SourceLocation RPLoc);
5520 ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
5521 SourceLocation RPLoc, unsigned TemplateDepth);
5522 // Handle the final expression in a statement expression.
5523 ExprResult ActOnStmtExprResult(ExprResult E);
5524 void ActOnStmtExprError();
5525
5526 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
5527 struct OffsetOfComponent {
5528 SourceLocation LocStart, LocEnd;
5529 bool isBrackets; // true if [expr], false if .ident
5530 union {
5531 IdentifierInfo *IdentInfo;
5532 Expr *E;
5533 } U;
5534 };
5535
5536 /// __builtin_offsetof(type, a.b[123][456].c)
5537 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
5538 TypeSourceInfo *TInfo,
5539 ArrayRef<OffsetOfComponent> Components,
5540 SourceLocation RParenLoc);
5541 ExprResult ActOnBuiltinOffsetOf(Scope *S,
5542 SourceLocation BuiltinLoc,
5543 SourceLocation TypeLoc,
5544 ParsedType ParsedArgTy,
5545 ArrayRef<OffsetOfComponent> Components,
5546 SourceLocation RParenLoc);
5547
5548 // __builtin_choose_expr(constExpr, expr1, expr2)
5549 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
5550 Expr *CondExpr, Expr *LHSExpr,
5551 Expr *RHSExpr, SourceLocation RPLoc);
5552
5553 // __builtin_va_arg(expr, type)
5554 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
5555 SourceLocation RPLoc);
5556 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
5557 TypeSourceInfo *TInfo, SourceLocation RPLoc);
5558
5559 // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
5560 // __builtin_COLUMN()
5561 ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
5562 SourceLocation BuiltinLoc,
5563 SourceLocation RPLoc);
5564
5565 // Build a potentially resolved SourceLocExpr.
5566 ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
5567 SourceLocation BuiltinLoc, SourceLocation RPLoc,
5568 DeclContext *ParentContext);
5569
5570 // __null
5571 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
5572
5573 bool CheckCaseExpression(Expr *E);
5574
5575 /// Describes the result of an "if-exists" condition check.
5576 enum IfExistsResult {
5577 /// The symbol exists.
5578 IER_Exists,
5579
5580 /// The symbol does not exist.
5581 IER_DoesNotExist,
5582
5583 /// The name is a dependent name, so the results will differ
5584 /// from one instantiation to the next.
5585 IER_Dependent,
5586
5587 /// An error occurred.
5588 IER_Error
5589 };
5590
5591 IfExistsResult
5592 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
5593 const DeclarationNameInfo &TargetNameInfo);
5594
5595 IfExistsResult
5596 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
5597 bool IsIfExists, CXXScopeSpec &SS,
5598 UnqualifiedId &Name);
5599
5600 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
5601 bool IsIfExists,
5602 NestedNameSpecifierLoc QualifierLoc,
5603 DeclarationNameInfo NameInfo,
5604 Stmt *Nested);
5605 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
5606 bool IsIfExists,
5607 CXXScopeSpec &SS, UnqualifiedId &Name,
5608 Stmt *Nested);
5609
5610 //===------------------------- "Block" Extension ------------------------===//
5611
5612 /// ActOnBlockStart - This callback is invoked when a block literal is
5613 /// started.
5614 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
5615
5616 /// ActOnBlockArguments - This callback allows processing of block arguments.
5617 /// If there are no arguments, this is still invoked.
5618 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
5619 Scope *CurScope);
5620
5621 /// ActOnBlockError - If there is an error parsing a block, this callback
5622 /// is invoked to pop the information about the block from the action impl.
5623 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
5624
5625 /// ActOnBlockStmtExpr - This is called when the body of a block statement
5626 /// literal was successfully completed. ^(int x){...}
5627 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
5628 Scope *CurScope);
5629
5630 //===---------------------------- Clang Extensions ----------------------===//
5631
5632 /// __builtin_convertvector(...)
5633 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
5634 SourceLocation BuiltinLoc,
5635 SourceLocation RParenLoc);
5636
5637 //===---------------------------- OpenCL Features -----------------------===//
5638
5639 /// __builtin_astype(...)
5640 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
5641 SourceLocation BuiltinLoc,
5642 SourceLocation RParenLoc);
5643 ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy,
5644 SourceLocation BuiltinLoc,
5645 SourceLocation RParenLoc);
5646
5647 //===---------------------------- C++ Features --------------------------===//
5648
5649 // Act on C++ namespaces
5650 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
5651 SourceLocation NamespaceLoc,
5652 SourceLocation IdentLoc, IdentifierInfo *Ident,
5653 SourceLocation LBrace,
5654 const ParsedAttributesView &AttrList,
5655 UsingDirectiveDecl *&UsingDecl);
5656 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
5657
5658 NamespaceDecl *getStdNamespace() const;
5659 NamespaceDecl *getOrCreateStdNamespace();
5660
5661 NamespaceDecl *lookupStdExperimentalNamespace();
5662
5663 CXXRecordDecl *getStdBadAlloc() const;
5664 EnumDecl *getStdAlignValT() const;
5665
5666private:
5667 // A cache representing if we've fully checked the various comparison category
5668 // types stored in ASTContext. The bit-index corresponds to the integer value
5669 // of a ComparisonCategoryType enumerator.
5670 llvm::SmallBitVector FullyCheckedComparisonCategories;
5671
5672 ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
5673 CXXScopeSpec &SS,
5674 ParsedType TemplateTypeTy,
5675 IdentifierInfo *MemberOrBase);
5676
5677public:
5678 enum class ComparisonCategoryUsage {
5679 /// The '<=>' operator was used in an expression and a builtin operator
5680 /// was selected.
5681 OperatorInExpression,
5682 /// A defaulted 'operator<=>' needed the comparison category. This
5683 /// typically only applies to 'std::strong_ordering', due to the implicit
5684 /// fallback return value.
5685 DefaultedOperator,
5686 };
5687
5688 /// Lookup the specified comparison category types in the standard
5689 /// library, an check the VarDecls possibly returned by the operator<=>
5690 /// builtins for that type.
5691 ///
5692 /// \return The type of the comparison category type corresponding to the
5693 /// specified Kind, or a null type if an error occurs
5694 QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,
5695 SourceLocation Loc,
5696 ComparisonCategoryUsage Usage);
5697
5698 /// Tests whether Ty is an instance of std::initializer_list and, if
5699 /// it is and Element is not NULL, assigns the element type to Element.
5700 bool isStdInitializerList(QualType Ty, QualType *Element);
5701
5702 /// Looks for the std::initializer_list template and instantiates it
5703 /// with Element, or emits an error if it's not found.
5704 ///
5705 /// \returns The instantiated template, or null on error.
5706 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
5707
5708 /// Determine whether Ctor is an initializer-list constructor, as
5709 /// defined in [dcl.init.list]p2.
5710 bool isInitListConstructor(const FunctionDecl *Ctor);
5711
5712 Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc,
5713 SourceLocation NamespcLoc, CXXScopeSpec &SS,
5714 SourceLocation IdentLoc,
5715 IdentifierInfo *NamespcName,
5716 const ParsedAttributesView &AttrList);
5717
5718 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
5719
5720 Decl *ActOnNamespaceAliasDef(Scope *CurScope,
5721 SourceLocation NamespaceLoc,
5722 SourceLocation AliasLoc,
5723 IdentifierInfo *Alias,
5724 CXXScopeSpec &SS,
5725 SourceLocation IdentLoc,
5726 IdentifierInfo *Ident);
5727
5728 void FilterUsingLookup(Scope *S, LookupResult &lookup);
5729 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
5730 bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target,
5731 const LookupResult &PreviousDecls,
5732 UsingShadowDecl *&PrevShadow);
5733 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
5734 NamedDecl *Target,
5735 UsingShadowDecl *PrevDecl);
5736
5737 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
5738 bool HasTypenameKeyword,
5739 const CXXScopeSpec &SS,
5740 SourceLocation NameLoc,
5741 const LookupResult &Previous);
5742 bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
5743 const CXXScopeSpec &SS,
5744 const DeclarationNameInfo &NameInfo,
5745 SourceLocation NameLoc,
5746 const LookupResult *R = nullptr,
5747 const UsingDecl *UD = nullptr);
5748
5749 NamedDecl *BuildUsingDeclaration(
5750 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
5751 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
5752 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
5753 const ParsedAttributesView &AttrList, bool IsInstantiation,
5754 bool IsUsingIfExists);
5755 NamedDecl *BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
5756 SourceLocation UsingLoc,
5757 SourceLocation EnumLoc,
5758 SourceLocation NameLoc, EnumDecl *ED);
5759 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
5760 ArrayRef<NamedDecl *> Expansions);
5761
5762 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
5763
5764 /// Given a derived-class using shadow declaration for a constructor and the
5765 /// correspnding base class constructor, find or create the implicit
5766 /// synthesized derived class constructor to use for this initialization.
5767 CXXConstructorDecl *
5768 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
5769 ConstructorUsingShadowDecl *DerivedShadow);
5770
5771 Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,
5772 SourceLocation UsingLoc,
5773 SourceLocation TypenameLoc, CXXScopeSpec &SS,
5774 UnqualifiedId &Name, SourceLocation EllipsisLoc,
5775 const ParsedAttributesView &AttrList);
5776 Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS,
5777 SourceLocation UsingLoc,
5778 SourceLocation EnumLoc, const DeclSpec &);
5779 Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,
5780 MultiTemplateParamsArg TemplateParams,
5781 SourceLocation UsingLoc, UnqualifiedId &Name,
5782 const ParsedAttributesView &AttrList,
5783 TypeResult Type, Decl *DeclFromDeclSpec);
5784
5785 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
5786 /// including handling of its default argument expressions.
5787 ///
5788 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind
5789 ExprResult
5790 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5791 NamedDecl *FoundDecl,
5792 CXXConstructorDecl *Constructor, MultiExprArg Exprs,
5793 bool HadMultipleCandidates, bool IsListInitialization,
5794 bool IsStdInitListInitialization,
5795 bool RequiresZeroInit, unsigned ConstructKind,
5796 SourceRange ParenRange);
5797
5798 /// Build a CXXConstructExpr whose constructor has already been resolved if
5799 /// it denotes an inherited constructor.
5800 ExprResult
5801 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5802 CXXConstructorDecl *Constructor, bool Elidable,
5803 MultiExprArg Exprs,
5804 bool HadMultipleCandidates, bool IsListInitialization,
5805 bool IsStdInitListInitialization,
5806 bool RequiresZeroInit, unsigned ConstructKind,
5807 SourceRange ParenRange);
5808
5809 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
5810 // the constructor can be elidable?
5811 ExprResult
5812 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5813 NamedDecl *FoundDecl,
5814 CXXConstructorDecl *Constructor, bool Elidable,
5815 MultiExprArg Exprs, bool HadMultipleCandidates,
5816 bool IsListInitialization,
5817 bool IsStdInitListInitialization, bool RequiresZeroInit,
5818 unsigned ConstructKind, SourceRange ParenRange);
5819
5820 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
5821
5822
5823 /// Instantiate or parse a C++ default argument expression as necessary.
5824 /// Return true on error.
5825 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
5826 ParmVarDecl *Param);
5827
5828 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
5829 /// the default expr if needed.
5830 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
5831 FunctionDecl *FD,
5832 ParmVarDecl *Param);
5833
5834 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
5835 /// constructed variable.
5836 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
5837
5838 /// Helper class that collects exception specifications for
5839 /// implicitly-declared special member functions.
5840 class ImplicitExceptionSpecification {
5841 // Pointer to allow copying
5842 Sema *Self;
5843 // We order exception specifications thus:
5844 // noexcept is the most restrictive, but is only used in C++11.
5845 // throw() comes next.
5846 // Then a throw(collected exceptions)
5847 // Finally no specification, which is expressed as noexcept(false).
5848 // throw(...) is used instead if any called function uses it.
5849 ExceptionSpecificationType ComputedEST;
5850 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;
5851 SmallVector<QualType, 4> Exceptions;
5852
5853 void ClearExceptions() {
5854 ExceptionsSeen.clear();
5855 Exceptions.clear();
5856 }
5857
5858 public:
5859 explicit ImplicitExceptionSpecification(Sema &Self)
5860 : Self(&Self), ComputedEST(EST_BasicNoexcept) {
5861 if (!Self.getLangOpts().CPlusPlus11)
5862 ComputedEST = EST_DynamicNone;
5863 }
5864
5865 /// Get the computed exception specification type.
5866 ExceptionSpecificationType getExceptionSpecType() const {
5867 assert(!isComputedNoexcept(ComputedEST) &&((void)0)
5868 "noexcept(expr) should not be a possible result")((void)0);
5869 return ComputedEST;
5870 }
5871
5872 /// The number of exceptions in the exception specification.
5873 unsigned size() const { return Exceptions.size(); }
5874
5875 /// The set of exceptions in the exception specification.
5876 const QualType *data() const { return Exceptions.data(); }
5877
5878 /// Integrate another called method into the collected data.
5879 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
5880
5881 /// Integrate an invoked expression into the collected data.
5882 void CalledExpr(Expr *E) { CalledStmt(E); }
5883
5884 /// Integrate an invoked statement into the collected data.
5885 void CalledStmt(Stmt *S);
5886
5887 /// Overwrite an EPI's exception specification with this
5888 /// computed exception specification.
5889 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {
5890 FunctionProtoType::ExceptionSpecInfo ESI;
5891 ESI.Type = getExceptionSpecType();
5892 if (ESI.Type == EST_Dynamic) {
5893 ESI.Exceptions = Exceptions;
5894 } else if (ESI.Type == EST_None) {
5895 /// C++11 [except.spec]p14:
5896 /// The exception-specification is noexcept(false) if the set of
5897 /// potential exceptions of the special member function contains "any"
5898 ESI.Type = EST_NoexceptFalse;
5899 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),
5900 tok::kw_false).get();
5901 }
5902 return ESI;
5903 }
5904 };
5905
5906 /// Evaluate the implicit exception specification for a defaulted
5907 /// special member function.
5908 void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);
5909
5910 /// Check the given noexcept-specifier, convert its expression, and compute
5911 /// the appropriate ExceptionSpecificationType.
5912 ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,
5913 ExceptionSpecificationType &EST);
5914
5915 /// Check the given exception-specification and update the
5916 /// exception specification information with the results.
5917 void checkExceptionSpecification(bool IsTopLevel,
5918 ExceptionSpecificationType EST,
5919 ArrayRef<ParsedType> DynamicExceptions,
5920 ArrayRef<SourceRange> DynamicExceptionRanges,
5921 Expr *NoexceptExpr,
5922 SmallVectorImpl<QualType> &Exceptions,
5923 FunctionProtoType::ExceptionSpecInfo &ESI);
5924
5925 /// Determine if we're in a case where we need to (incorrectly) eagerly
5926 /// parse an exception specification to work around a libstdc++ bug.
5927 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
5928
5929 /// Add an exception-specification to the given member function
5930 /// (or member function template). The exception-specification was parsed
5931 /// after the method itself was declared.
5932 void actOnDelayedExceptionSpecification(Decl *Method,
5933 ExceptionSpecificationType EST,
5934 SourceRange SpecificationRange,
5935 ArrayRef<ParsedType> DynamicExceptions,
5936 ArrayRef<SourceRange> DynamicExceptionRanges,
5937 Expr *NoexceptExpr);
5938
5939 class InheritedConstructorInfo;
5940
5941 /// Determine if a special member function should have a deleted
5942 /// definition when it is defaulted.
5943 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5944 InheritedConstructorInfo *ICI = nullptr,
5945 bool Diagnose = false);
5946
5947 /// Produce notes explaining why a defaulted function was defined as deleted.
5948 void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);
5949
5950 /// Declare the implicit default constructor for the given class.
5951 ///
5952 /// \param ClassDecl The class declaration into which the implicit
5953 /// default constructor will be added.
5954 ///
5955 /// \returns The implicitly-declared default constructor.
5956 CXXConstructorDecl *DeclareImplicitDefaultConstructor(
5957 CXXRecordDecl *ClassDecl);
5958
5959 /// DefineImplicitDefaultConstructor - Checks for feasibility of
5960 /// defining this constructor as the default constructor.
5961 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
5962 CXXConstructorDecl *Constructor);
5963
5964 /// Declare the implicit destructor for the given class.
5965 ///
5966 /// \param ClassDecl The class declaration into which the implicit
5967 /// destructor will be added.
5968 ///
5969 /// \returns The implicitly-declared destructor.
5970 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);
5971
5972 /// DefineImplicitDestructor - Checks for feasibility of
5973 /// defining this destructor as the default destructor.
5974 void DefineImplicitDestructor(SourceLocation CurrentLocation,
5975 CXXDestructorDecl *Destructor);
5976
5977 /// Build an exception spec for destructors that don't have one.
5978 ///
5979 /// C++11 says that user-defined destructors with no exception spec get one
5980 /// that looks as if the destructor was implicitly declared.
5981 void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);
5982
5983 /// Define the specified inheriting constructor.
5984 void DefineInheritingConstructor(SourceLocation UseLoc,
5985 CXXConstructorDecl *Constructor);
5986
5987 /// Declare the implicit copy constructor for the given class.
5988 ///
5989 /// \param ClassDecl The class declaration into which the implicit
5990 /// copy constructor will be added.
5991 ///
5992 /// \returns The implicitly-declared copy constructor.
5993 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);
5994
5995 /// DefineImplicitCopyConstructor - Checks for feasibility of
5996 /// defining this constructor as the copy constructor.
5997 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
5998 CXXConstructorDecl *Constructor);
5999
6000 /// Declare the implicit move constructor for the given class.
6001 ///
6002 /// \param ClassDecl The Class declaration into which the implicit
6003 /// move constructor will be added.
6004 ///
6005 /// \returns The implicitly-declared move constructor, or NULL if it wasn't
6006 /// declared.
6007 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);
6008
6009 /// DefineImplicitMoveConstructor - Checks for feasibility of
6010 /// defining this constructor as the move constructor.
6011 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
6012 CXXConstructorDecl *Constructor);
6013
6014 /// Declare the implicit copy assignment operator for the given class.
6015 ///
6016 /// \param ClassDecl The class declaration into which the implicit
6017 /// copy assignment operator will be added.
6018 ///
6019 /// \returns The implicitly-declared copy assignment operator.
6020 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);
6021
6022 /// Defines an implicitly-declared copy assignment operator.
6023 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
6024 CXXMethodDecl *MethodDecl);
6025
6026 /// Declare the implicit move assignment operator for the given class.
6027 ///
6028 /// \param ClassDecl The Class declaration into which the implicit
6029 /// move assignment operator will be added.
6030 ///
6031 /// \returns The implicitly-declared move assignment operator, or NULL if it
6032 /// wasn't declared.
6033 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);
6034
6035 /// Defines an implicitly-declared move assignment operator.
6036 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
6037 CXXMethodDecl *MethodDecl);
6038
6039 /// Force the declaration of any implicitly-declared members of this
6040 /// class.
6041 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
6042
6043 /// Check a completed declaration of an implicit special member.
6044 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);
6045
6046 /// Determine whether the given function is an implicitly-deleted
6047 /// special member function.
6048 bool isImplicitlyDeleted(FunctionDecl *FD);
6049
6050 /// Check whether 'this' shows up in the type of a static member
6051 /// function after the (naturally empty) cv-qualifier-seq would be.
6052 ///
6053 /// \returns true if an error occurred.
6054 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
6055
6056 /// Whether this' shows up in the exception specification of a static
6057 /// member function.
6058 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
6059
6060 /// Check whether 'this' shows up in the attributes of the given
6061 /// static member function.
6062 ///
6063 /// \returns true if an error occurred.
6064 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
6065
6066 /// MaybeBindToTemporary - If the passed in expression has a record type with
6067 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
6068 /// it simply returns the passed in expression.
6069 ExprResult MaybeBindToTemporary(Expr *E);
6070
6071 /// Wrap the expression in a ConstantExpr if it is a potential immediate
6072 /// invocation.
6073 ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
6074
6075 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
6076 QualType DeclInitType, MultiExprArg ArgsPtr,
6077 SourceLocation Loc,
6078 SmallVectorImpl<Expr *> &ConvertedArgs,
6079 bool AllowExplicit = false,
6080 bool IsListInitialization = false);
6081
6082 ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
6083 SourceLocation NameLoc,
6084 IdentifierInfo &Name);
6085
6086 ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,
6087 Scope *S, CXXScopeSpec &SS,
6088 bool EnteringContext);
6089 ParsedType getDestructorName(SourceLocation TildeLoc,
6090 IdentifierInfo &II, SourceLocation NameLoc,
6091 Scope *S, CXXScopeSpec &SS,
6092 ParsedType ObjectType,
6093 bool EnteringContext);
6094
6095 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
6096 ParsedType ObjectType);
6097
6098 // Checks that reinterpret casts don't have undefined behavior.
6099 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
6100 bool IsDereference, SourceRange Range);
6101
6102 // Checks that the vector type should be initialized from a scalar
6103 // by splatting the value rather than populating a single element.
6104 // This is the case for AltiVecVector types as well as with
6105 // AltiVecPixel and AltiVecBool when -faltivec-src-compat=xl is specified.
6106 bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy);
6107
6108 /// ActOnCXXNamedCast - Parse
6109 /// {dynamic,static,reinterpret,const,addrspace}_cast's.
6110 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
6111 tok::TokenKind Kind,
6112 SourceLocation LAngleBracketLoc,
6113 Declarator &D,
6114 SourceLocation RAngleBracketLoc,
6115 SourceLocation LParenLoc,
6116 Expr *E,
6117 SourceLocation RParenLoc);
6118
6119 ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
6120 tok::TokenKind Kind,
6121 TypeSourceInfo *Ty,
6122 Expr *E,
6123 SourceRange AngleBrackets,
6124 SourceRange Parens);
6125
6126 ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,
6127 ExprResult Operand,
6128 SourceLocation RParenLoc);
6129
6130 ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,
6131 Expr *Operand, SourceLocation RParenLoc);
6132
6133 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6134 SourceLocation TypeidLoc,
6135 TypeSourceInfo *Operand,
6136 SourceLocation RParenLoc);
6137 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6138 SourceLocation TypeidLoc,
6139 Expr *Operand,
6140 SourceLocation RParenLoc);
6141
6142 /// ActOnCXXTypeid - Parse typeid( something ).
6143 ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
6144 SourceLocation LParenLoc, bool isType,
6145 void *TyOrExpr,
6146 SourceLocation RParenLoc);
6147
6148 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6149 SourceLocation TypeidLoc,
6150 TypeSourceInfo *Operand,
6151 SourceLocation RParenLoc);
6152 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6153 SourceLocation TypeidLoc,
6154 Expr *Operand,
6155 SourceLocation RParenLoc);
6156
6157 /// ActOnCXXUuidof - Parse __uuidof( something ).
6158 ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
6159 SourceLocation LParenLoc, bool isType,
6160 void *TyOrExpr,
6161 SourceLocation RParenLoc);
6162
6163 /// Handle a C++1z fold-expression: ( expr op ... op expr ).
6164 ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,
6165 tok::TokenKind Operator,
6166 SourceLocation EllipsisLoc, Expr *RHS,
6167 SourceLocation RParenLoc);
6168 ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,
6169 SourceLocation LParenLoc, Expr *LHS,
6170 BinaryOperatorKind Operator,
6171 SourceLocation EllipsisLoc, Expr *RHS,
6172 SourceLocation RParenLoc,
6173 Optional<unsigned> NumExpansions);
6174 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
6175 BinaryOperatorKind Operator);
6176
6177 //// ActOnCXXThis - Parse 'this' pointer.
6178 ExprResult ActOnCXXThis(SourceLocation loc);
6179
6180 /// Build a CXXThisExpr and mark it referenced in the current context.
6181 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);
6182 void MarkThisReferenced(CXXThisExpr *This);
6183
6184 /// Try to retrieve the type of the 'this' pointer.
6185 ///
6186 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
6187 QualType getCurrentThisType();
6188
6189 /// When non-NULL, the C++ 'this' expression is allowed despite the
6190 /// current context not being a non-static member function. In such cases,
6191 /// this provides the type used for 'this'.
6192 QualType CXXThisTypeOverride;
6193
6194 /// RAII object used to temporarily allow the C++ 'this' expression
6195 /// to be used, with the given qualifiers on the current class type.
6196 class CXXThisScopeRAII {
6197 Sema &S;
6198 QualType OldCXXThisTypeOverride;
6199 bool Enabled;
6200
6201 public:
6202 /// Introduce a new scope where 'this' may be allowed (when enabled),
6203 /// using the given declaration (which is either a class template or a
6204 /// class) along with the given qualifiers.
6205 /// along with the qualifiers placed on '*this'.
6206 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,
6207 bool Enabled = true);
6208
6209 ~CXXThisScopeRAII();
6210 };
6211
6212 /// Make sure the value of 'this' is actually available in the current
6213 /// context, if it is a potentially evaluated context.
6214 ///
6215 /// \param Loc The location at which the capture of 'this' occurs.
6216 ///
6217 /// \param Explicit Whether 'this' is explicitly captured in a lambda
6218 /// capture list.
6219 ///
6220 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
6221 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
6222 /// This is useful when enclosing lambdas must speculatively capture
6223 /// 'this' that may or may not be used in certain specializations of
6224 /// a nested generic lambda (depending on whether the name resolves to
6225 /// a non-static member function or a static function).
6226 /// \return returns 'true' if failed, 'false' if success.
6227 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
6228 bool BuildAndDiagnose = true,
6229 const unsigned *const FunctionScopeIndexToStopAt = nullptr,
6230 bool ByCopy = false);
6231
6232 /// Determine whether the given type is the type of *this that is used
6233 /// outside of the body of a member function for a type that is currently
6234 /// being defined.
6235 bool isThisOutsideMemberFunctionBody(QualType BaseType);
6236
6237 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
6238 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6239
6240
6241 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
6242 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6243
6244 ExprResult
6245 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
6246 SourceLocation AtLoc, SourceLocation RParen);
6247
6248 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
6249 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
6250
6251 //// ActOnCXXThrow - Parse throw expressions.
6252 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
6253 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
6254 bool IsThrownVarInScope);
6255 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
6256
6257 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
6258 /// Can be interpreted either as function-style casting ("int(x)")
6259 /// or class type construction ("ClassType(x,y,z)")
6260 /// or creation of a value-initialized type ("int()").
6261 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
6262 SourceLocation LParenOrBraceLoc,
6263 MultiExprArg Exprs,
6264 SourceLocation RParenOrBraceLoc,
6265 bool ListInitialization);
6266
6267 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
6268 SourceLocation LParenLoc,
6269 MultiExprArg Exprs,
6270 SourceLocation RParenLoc,
6271 bool ListInitialization);
6272
6273 /// ActOnCXXNew - Parsed a C++ 'new' expression.
6274 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
6275 SourceLocation PlacementLParen,
6276 MultiExprArg PlacementArgs,
6277 SourceLocation PlacementRParen,
6278 SourceRange TypeIdParens, Declarator &D,
6279 Expr *Initializer);
6280 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
6281 SourceLocation PlacementLParen,
6282 MultiExprArg PlacementArgs,
6283 SourceLocation PlacementRParen,
6284 SourceRange TypeIdParens,
6285 QualType AllocType,
6286 TypeSourceInfo *AllocTypeInfo,
6287 Optional<Expr *> ArraySize,
6288 SourceRange DirectInitRange,
6289 Expr *Initializer);
6290
6291 /// Determine whether \p FD is an aligned allocation or deallocation
6292 /// function that is unavailable.
6293 bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;
6294
6295 /// Produce diagnostics if \p FD is an aligned allocation or deallocation
6296 /// function that is unavailable.
6297 void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
6298 SourceLocation Loc);
6299
6300 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
6301 SourceRange R);
6302
6303 /// The scope in which to find allocation functions.
6304 enum AllocationFunctionScope {
6305 /// Only look for allocation functions in the global scope.
6306 AFS_Global,
6307 /// Only look for allocation functions in the scope of the
6308 /// allocated class.
6309 AFS_Class,
6310 /// Look for allocation functions in both the global scope
6311 /// and in the scope of the allocated class.
6312 AFS_Both
6313 };
6314
6315 /// Finds the overloads of operator new and delete that are appropriate
6316 /// for the allocation.
6317 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
6318 AllocationFunctionScope NewScope,
6319 AllocationFunctionScope DeleteScope,
6320 QualType AllocType, bool IsArray,
6321 bool &PassAlignment, MultiExprArg PlaceArgs,
6322 FunctionDecl *&OperatorNew,
6323 FunctionDecl *&OperatorDelete,
6324 bool Diagnose = true);
6325 void DeclareGlobalNewDelete();
6326 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
6327 ArrayRef<QualType> Params);
6328
6329 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
6330 DeclarationName Name, FunctionDecl* &Operator,
6331 bool Diagnose = true);
6332 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
6333 bool CanProvideSize,
6334 bool Overaligned,
6335 DeclarationName Name);
6336 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
6337 CXXRecordDecl *RD);
6338
6339 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
6340 ExprResult ActOnCXXDelete(SourceLocation StartLoc,
6341 bool UseGlobal, bool ArrayForm,
6342 Expr *Operand);
6343 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
6344 bool IsDelete, bool CallCanBeVirtual,
6345 bool WarnOnNonAbstractTypes,
6346 SourceLocation DtorLoc);
6347
6348 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
6349 Expr *Operand, SourceLocation RParen);
6350 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6351 SourceLocation RParen);
6352
6353 /// Parsed one of the type trait support pseudo-functions.
6354 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6355 ArrayRef<ParsedType> Args,
6356 SourceLocation RParenLoc);
6357 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6358 ArrayRef<TypeSourceInfo *> Args,
6359 SourceLocation RParenLoc);
6360
6361 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support
6362 /// pseudo-functions.
6363 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
6364 SourceLocation KWLoc,
6365 ParsedType LhsTy,
6366 Expr *DimExpr,
6367 SourceLocation RParen);
6368
6369 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
6370 SourceLocation KWLoc,
6371 TypeSourceInfo *TSInfo,
6372 Expr *DimExpr,
6373 SourceLocation RParen);
6374
6375 /// ActOnExpressionTrait - Parsed one of the unary type trait support
6376 /// pseudo-functions.
6377 ExprResult ActOnExpressionTrait(ExpressionTrait OET,
6378 SourceLocation KWLoc,
6379 Expr *Queried,
6380 SourceLocation RParen);
6381
6382 ExprResult BuildExpressionTrait(ExpressionTrait OET,
6383 SourceLocation KWLoc,
6384 Expr *Queried,
6385 SourceLocation RParen);
6386
6387 ExprResult ActOnStartCXXMemberReference(Scope *S,
6388 Expr *Base,
6389 SourceLocation OpLoc,
6390 tok::TokenKind OpKind,
6391 ParsedType &ObjectType,
6392 bool &MayBePseudoDestructor);
6393
6394 ExprResult BuildPseudoDestructorExpr(Expr *Base,
6395 SourceLocation OpLoc,
6396 tok::TokenKind OpKind,
6397 const CXXScopeSpec &SS,
6398 TypeSourceInfo *ScopeType,
6399 SourceLocation CCLoc,
6400 SourceLocation TildeLoc,
6401 PseudoDestructorTypeStorage DestroyedType);
6402
6403 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6404 SourceLocation OpLoc,
6405 tok::TokenKind OpKind,
6406 CXXScopeSpec &SS,
6407 UnqualifiedId &FirstTypeName,
6408 SourceLocation CCLoc,
6409 SourceLocation TildeLoc,
6410 UnqualifiedId &SecondTypeName);
6411
6412 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6413 SourceLocation OpLoc,
6414 tok::TokenKind OpKind,
6415 SourceLocation TildeLoc,
6416 const DeclSpec& DS);
6417
6418 /// MaybeCreateExprWithCleanups - If the current full-expression
6419 /// requires any cleanups, surround it with a ExprWithCleanups node.
6420 /// Otherwise, just returns the passed-in expression.
6421 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
6422 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
6423 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
6424
6425 MaterializeTemporaryExpr *
6426 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6427 bool BoundToLvalueReference);
6428
6429 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {
6430 return ActOnFinishFullExpr(
6431 Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue);
6432 }
6433 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
6434 bool DiscardedValue, bool IsConstexpr = false);
6435 StmtResult ActOnFinishFullStmt(Stmt *Stmt);
6436
6437 // Marks SS invalid if it represents an incomplete type.
6438 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
6439 // Complete an enum decl, maybe without a scope spec.
6440 bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L,
6441 CXXScopeSpec *SS = nullptr);
6442
6443 DeclContext *computeDeclContext(QualType T);
6444 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
6445 bool EnteringContext = false);
6446 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
6447 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
6448
6449 /// The parser has parsed a global nested-name-specifier '::'.
6450 ///
6451 /// \param CCLoc The location of the '::'.
6452 ///
6453 /// \param SS The nested-name-specifier, which will be updated in-place
6454 /// to reflect the parsed nested-name-specifier.
6455 ///
6456 /// \returns true if an error occurred, false otherwise.
6457 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
6458
6459 /// The parser has parsed a '__super' nested-name-specifier.
6460 ///
6461 /// \param SuperLoc The location of the '__super' keyword.
6462 ///
6463 /// \param ColonColonLoc The location of the '::'.
6464 ///
6465 /// \param SS The nested-name-specifier, which will be updated in-place
6466 /// to reflect the parsed nested-name-specifier.
6467 ///
6468 /// \returns true if an error occurred, false otherwise.
6469 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
6470 SourceLocation ColonColonLoc, CXXScopeSpec &SS);
6471
6472 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
6473 bool *CanCorrect = nullptr);
6474 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
6475
6476 /// Keeps information about an identifier in a nested-name-spec.
6477 ///
6478 struct NestedNameSpecInfo {
6479 /// The type of the object, if we're parsing nested-name-specifier in
6480 /// a member access expression.
6481 ParsedType ObjectType;
6482
6483 /// The identifier preceding the '::'.
6484 IdentifierInfo *Identifier;
6485
6486 /// The location of the identifier.
6487 SourceLocation IdentifierLoc;
6488
6489 /// The location of the '::'.
6490 SourceLocation CCLoc;
6491
6492 /// Creates info object for the most typical case.
6493 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6494 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())
6495 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),
6496 CCLoc(ColonColonLoc) {
6497 }
6498
6499 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6500 SourceLocation ColonColonLoc, QualType ObjectType)
6501 : ObjectType(ParsedType::make(ObjectType)), Identifier(II),
6502 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {
6503 }
6504 };
6505
6506 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
6507 NestedNameSpecInfo &IdInfo);
6508
6509 bool BuildCXXNestedNameSpecifier(Scope *S,
6510 NestedNameSpecInfo &IdInfo,
6511 bool EnteringContext,
6512 CXXScopeSpec &SS,
6513 NamedDecl *ScopeLookupResult,
6514 bool ErrorRecoveryLookup,
6515 bool *IsCorrectedToColon = nullptr,
6516 bool OnlyNamespace = false);
6517
6518 /// The parser has parsed a nested-name-specifier 'identifier::'.
6519 ///
6520 /// \param S The scope in which this nested-name-specifier occurs.
6521 ///
6522 /// \param IdInfo Parser information about an identifier in the
6523 /// nested-name-spec.
6524 ///
6525 /// \param EnteringContext Whether we're entering the context nominated by
6526 /// this nested-name-specifier.
6527 ///
6528 /// \param SS The nested-name-specifier, which is both an input
6529 /// parameter (the nested-name-specifier before this type) and an
6530 /// output parameter (containing the full nested-name-specifier,
6531 /// including this new type).
6532 ///
6533 /// \param ErrorRecoveryLookup If true, then this method is called to improve
6534 /// error recovery. In this case do not emit error message.
6535 ///
6536 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
6537 /// are allowed. The bool value pointed by this parameter is set to 'true'
6538 /// if the identifier is treated as if it was followed by ':', not '::'.
6539 ///
6540 /// \param OnlyNamespace If true, only considers namespaces in lookup.
6541 ///
6542 /// \returns true if an error occurred, false otherwise.
6543 bool ActOnCXXNestedNameSpecifier(Scope *S,
6544 NestedNameSpecInfo &IdInfo,
6545 bool EnteringContext,
6546 CXXScopeSpec &SS,
6547 bool ErrorRecoveryLookup = false,
6548 bool *IsCorrectedToColon = nullptr,
6549 bool OnlyNamespace = false);
6550
6551 ExprResult ActOnDecltypeExpression(Expr *E);
6552
6553 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
6554 const DeclSpec &DS,
6555 SourceLocation ColonColonLoc);
6556
6557 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
6558 NestedNameSpecInfo &IdInfo,
6559 bool EnteringContext);
6560
6561 /// The parser has parsed a nested-name-specifier
6562 /// 'template[opt] template-name < template-args >::'.
6563 ///
6564 /// \param S The scope in which this nested-name-specifier occurs.
6565 ///
6566 /// \param SS The nested-name-specifier, which is both an input
6567 /// parameter (the nested-name-specifier before this type) and an
6568 /// output parameter (containing the full nested-name-specifier,
6569 /// including this new type).
6570 ///
6571 /// \param TemplateKWLoc the location of the 'template' keyword, if any.
6572 /// \param TemplateName the template name.
6573 /// \param TemplateNameLoc The location of the template name.
6574 /// \param LAngleLoc The location of the opening angle bracket ('<').
6575 /// \param TemplateArgs The template arguments.
6576 /// \param RAngleLoc The location of the closing angle bracket ('>').
6577 /// \param CCLoc The location of the '::'.
6578 ///
6579 /// \param EnteringContext Whether we're entering the context of the
6580 /// nested-name-specifier.
6581 ///
6582 ///
6583 /// \returns true if an error occurred, false otherwise.
6584 bool ActOnCXXNestedNameSpecifier(Scope *S,
6585 CXXScopeSpec &SS,
6586 SourceLocation TemplateKWLoc,
6587 TemplateTy TemplateName,
6588 SourceLocation TemplateNameLoc,
6589 SourceLocation LAngleLoc,
6590 ASTTemplateArgsPtr TemplateArgs,
6591 SourceLocation RAngleLoc,
6592 SourceLocation CCLoc,
6593 bool EnteringContext);
6594
6595 /// Given a C++ nested-name-specifier, produce an annotation value
6596 /// that the parser can use later to reconstruct the given
6597 /// nested-name-specifier.
6598 ///
6599 /// \param SS A nested-name-specifier.
6600 ///
6601 /// \returns A pointer containing all of the information in the
6602 /// nested-name-specifier \p SS.
6603 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
6604
6605 /// Given an annotation pointer for a nested-name-specifier, restore
6606 /// the nested-name-specifier structure.
6607 ///
6608 /// \param Annotation The annotation pointer, produced by
6609 /// \c SaveNestedNameSpecifierAnnotation().
6610 ///
6611 /// \param AnnotationRange The source range corresponding to the annotation.
6612 ///
6613 /// \param SS The nested-name-specifier that will be updated with the contents
6614 /// of the annotation pointer.
6615 void RestoreNestedNameSpecifierAnnotation(void *Annotation,
6616 SourceRange AnnotationRange,
6617 CXXScopeSpec &SS);
6618
6619 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6620
6621 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
6622 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
6623 /// After this method is called, according to [C++ 3.4.3p3], names should be
6624 /// looked up in the declarator-id's scope, until the declarator is parsed and
6625 /// ActOnCXXExitDeclaratorScope is called.
6626 /// The 'SS' should be a non-empty valid CXXScopeSpec.
6627 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
6628
6629 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
6630 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
6631 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
6632 /// Used to indicate that names should revert to being looked up in the
6633 /// defining scope.
6634 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6635
6636 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
6637 /// initializer for the declaration 'Dcl'.
6638 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
6639 /// static data member of class X, names should be looked up in the scope of
6640 /// class X.
6641 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);
6642
6643 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
6644 /// initializer for the declaration 'Dcl'.
6645 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
6646
6647 /// Create a new lambda closure type.
6648 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
6649 TypeSourceInfo *Info,
6650 bool KnownDependent,
6651 LambdaCaptureDefault CaptureDefault);
6652
6653 /// Start the definition of a lambda expression.
6654 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
6655 SourceRange IntroducerRange,
6656 TypeSourceInfo *MethodType,
6657 SourceLocation EndLoc,
6658 ArrayRef<ParmVarDecl *> Params,
6659 ConstexprSpecKind ConstexprKind,
6660 Expr *TrailingRequiresClause);
6661
6662 /// Number lambda for linkage purposes if necessary.
6663 void handleLambdaNumbering(
6664 CXXRecordDecl *Class, CXXMethodDecl *Method,
6665 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
6666
6667 /// Endow the lambda scope info with the relevant properties.
6668 void buildLambdaScope(sema::LambdaScopeInfo *LSI,
6669 CXXMethodDecl *CallOperator,
6670 SourceRange IntroducerRange,
6671 LambdaCaptureDefault CaptureDefault,
6672 SourceLocation CaptureDefaultLoc,
6673 bool ExplicitParams,
6674 bool ExplicitResultType,
6675 bool Mutable);
6676
6677 /// Perform initialization analysis of the init-capture and perform
6678 /// any implicit conversions such as an lvalue-to-rvalue conversion if
6679 /// not being used to initialize a reference.
6680 ParsedType actOnLambdaInitCaptureInitialization(
6681 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6682 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {
6683 return ParsedType::make(buildLambdaInitCaptureInitialization(
6684 Loc, ByRef, EllipsisLoc, None, Id,
6685 InitKind != LambdaCaptureInitKind::CopyInit, Init));
6686 }
6687 QualType buildLambdaInitCaptureInitialization(
6688 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6689 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,
6690 Expr *&Init);
6691
6692 /// Create a dummy variable within the declcontext of the lambda's
6693 /// call operator, for name lookup purposes for a lambda init capture.
6694 ///
6695 /// CodeGen handles emission of lambda captures, ignoring these dummy
6696 /// variables appropriately.
6697 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
6698 QualType InitCaptureType,
6699 SourceLocation EllipsisLoc,
6700 IdentifierInfo *Id,
6701 unsigned InitStyle, Expr *Init);
6702
6703 /// Add an init-capture to a lambda scope.
6704 void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);
6705
6706 /// Note that we have finished the explicit captures for the
6707 /// given lambda.
6708 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
6709
6710 /// \brief This is called after parsing the explicit template parameter list
6711 /// on a lambda (if it exists) in C++2a.
6712 void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
6713 ArrayRef<NamedDecl *> TParams,
6714 SourceLocation RAngleLoc,
6715 ExprResult RequiresClause);
6716
6717 /// Introduce the lambda parameters into scope.
6718 void addLambdaParameters(
6719 ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
6720 CXXMethodDecl *CallOperator, Scope *CurScope);
6721
6722 /// Deduce a block or lambda's return type based on the return
6723 /// statements present in the body.
6724 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
6725
6726 /// ActOnStartOfLambdaDefinition - This is called just before we start
6727 /// parsing the body of a lambda; it analyzes the explicit captures and
6728 /// arguments, and sets up various data-structures for the body of the
6729 /// lambda.
6730 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
6731 Declarator &ParamInfo, Scope *CurScope);
6732
6733 /// ActOnLambdaError - If there is an error parsing a lambda, this callback
6734 /// is invoked to pop the information about the lambda.
6735 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
6736 bool IsInstantiation = false);
6737
6738 /// ActOnLambdaExpr - This is called when the body of a lambda expression
6739 /// was successfully completed.
6740 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
6741 Scope *CurScope);
6742
6743 /// Does copying/destroying the captured variable have side effects?
6744 bool CaptureHasSideEffects(const sema::Capture &From);
6745
6746 /// Diagnose if an explicit lambda capture is unused. Returns true if a
6747 /// diagnostic is emitted.
6748 bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
6749 const sema::Capture &From);
6750
6751 /// Build a FieldDecl suitable to hold the given capture.
6752 FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture);
6753
6754 /// Initialize the given capture with a suitable expression.
6755 ExprResult BuildCaptureInit(const sema::Capture &Capture,
6756 SourceLocation ImplicitCaptureLoc,
6757 bool IsOpenMPMapping = false);
6758
6759 /// Complete a lambda-expression having processed and attached the
6760 /// lambda body.
6761 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
6762 sema::LambdaScopeInfo *LSI);
6763
6764 /// Get the return type to use for a lambda's conversion function(s) to
6765 /// function pointer type, given the type of the call operator.
6766 QualType
6767 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,
6768 CallingConv CC);
6769
6770 /// Define the "body" of the conversion from a lambda object to a
6771 /// function pointer.
6772 ///
6773 /// This routine doesn't actually define a sensible body; rather, it fills
6774 /// in the initialization expression needed to copy the lambda object into
6775 /// the block, and IR generation actually generates the real body of the
6776 /// block pointer conversion.
6777 void DefineImplicitLambdaToFunctionPointerConversion(
6778 SourceLocation CurrentLoc, CXXConversionDecl *Conv);
6779
6780 /// Define the "body" of the conversion from a lambda object to a
6781 /// block pointer.
6782 ///
6783 /// This routine doesn't actually define a sensible body; rather, it fills
6784 /// in the initialization expression needed to copy the lambda object into
6785 /// the block, and IR generation actually generates the real body of the
6786 /// block pointer conversion.
6787 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
6788 CXXConversionDecl *Conv);
6789
6790 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
6791 SourceLocation ConvLocation,
6792 CXXConversionDecl *Conv,
6793 Expr *Src);
6794
6795 /// Check whether the given expression is a valid constraint expression.
6796 /// A diagnostic is emitted if it is not, false is returned, and
6797 /// PossibleNonPrimary will be set to true if the failure might be due to a
6798 /// non-primary expression being used as an atomic constraint.
6799 bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),
6800 bool *PossibleNonPrimary = nullptr,
6801 bool IsTrailingRequiresClause = false);
6802
6803private:
6804 /// Caches pairs of template-like decls whose associated constraints were
6805 /// checked for subsumption and whether or not the first's constraints did in
6806 /// fact subsume the second's.
6807 llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;
6808 /// Caches the normalized associated constraints of declarations (concepts or
6809 /// constrained declarations). If an error occurred while normalizing the
6810 /// associated constraints of the template or concept, nullptr will be cached
6811 /// here.
6812 llvm::DenseMap<NamedDecl *, NormalizedConstraint *>
6813 NormalizationCache;
6814
6815 llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>
6816 SatisfactionCache;
6817
6818public:
6819 const NormalizedConstraint *
6820 getNormalizedAssociatedConstraints(
6821 NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
6822
6823 /// \brief Check whether the given declaration's associated constraints are
6824 /// at least as constrained than another declaration's according to the
6825 /// partial ordering of constraints.
6826 ///
6827 /// \param Result If no error occurred, receives the result of true if D1 is
6828 /// at least constrained than D2, and false otherwise.
6829 ///
6830 /// \returns true if an error occurred, false otherwise.
6831 bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
6832 NamedDecl *D2, ArrayRef<const Expr *> AC2,
6833 bool &Result);
6834
6835 /// If D1 was not at least as constrained as D2, but would've been if a pair
6836 /// of atomic constraints involved had been declared in a concept and not
6837 /// repeated in two separate places in code.
6838 /// \returns true if such a diagnostic was emitted, false otherwise.
6839 bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
6840 ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);
6841
6842 /// \brief Check whether the given list of constraint expressions are
6843 /// satisfied (as if in a 'conjunction') given template arguments.
6844 /// \param Template the template-like entity that triggered the constraints
6845 /// check (either a concept or a constrained entity).
6846 /// \param ConstraintExprs a list of constraint expressions, treated as if
6847 /// they were 'AND'ed together.
6848 /// \param TemplateArgs the list of template arguments to substitute into the
6849 /// constraint expression.
6850 /// \param TemplateIDRange The source range of the template id that
6851 /// caused the constraints check.
6852 /// \param Satisfaction if true is returned, will contain details of the
6853 /// satisfaction, with enough information to diagnose an unsatisfied
6854 /// expression.
6855 /// \returns true if an error occurred and satisfaction could not be checked,
6856 /// false otherwise.
6857 bool CheckConstraintSatisfaction(
6858 const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
6859 ArrayRef<TemplateArgument> TemplateArgs,
6860 SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
6861
6862 /// \brief Check whether the given non-dependent constraint expression is
6863 /// satisfied. Returns false and updates Satisfaction with the satisfaction
6864 /// verdict if successful, emits a diagnostic and returns true if an error
6865 /// occured and satisfaction could not be determined.
6866 ///
6867 /// \returns true if an error occurred, false otherwise.
6868 bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
6869 ConstraintSatisfaction &Satisfaction);
6870
6871 /// Check whether the given function decl's trailing requires clause is
6872 /// satisfied, if any. Returns false and updates Satisfaction with the
6873 /// satisfaction verdict if successful, emits a diagnostic and returns true if
6874 /// an error occured and satisfaction could not be determined.
6875 ///
6876 /// \returns true if an error occurred, false otherwise.
6877 bool CheckFunctionConstraints(const FunctionDecl *FD,
6878 ConstraintSatisfaction &Satisfaction,
6879 SourceLocation UsageLoc = SourceLocation());
6880
6881
6882 /// \brief Ensure that the given template arguments satisfy the constraints
6883 /// associated with the given template, emitting a diagnostic if they do not.
6884 ///
6885 /// \param Template The template to which the template arguments are being
6886 /// provided.
6887 ///
6888 /// \param TemplateArgs The converted, canonicalized template arguments.
6889 ///
6890 /// \param TemplateIDRange The source range of the template id that
6891 /// caused the constraints check.
6892 ///
6893 /// \returns true if the constrains are not satisfied or could not be checked
6894 /// for satisfaction, false if the constraints are satisfied.
6895 bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,
6896 ArrayRef<TemplateArgument> TemplateArgs,
6897 SourceRange TemplateIDRange);
6898
6899 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6900 /// unsatisfied.
6901 /// \param First whether this is the first time an unsatisfied constraint is
6902 /// diagnosed for this error.
6903 void
6904 DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,
6905 bool First = true);
6906
6907 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6908 /// unsatisfied.
6909 void
6910 DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,
6911 bool First = true);
6912
6913 // ParseObjCStringLiteral - Parse Objective-C string literals.
6914 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
6915 ArrayRef<Expr *> Strings);
6916
6917 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
6918
6919 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
6920 /// numeric literal expression. Type of the expression will be "NSNumber *"
6921 /// or "id" if NSNumber is unavailable.
6922 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
6923 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
6924 bool Value);
6925 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
6926
6927 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
6928 /// '@' prefixed parenthesized expression. The type of the expression will
6929 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type
6930 /// of ValueType, which is allowed to be a built-in numeric type, "char *",
6931 /// "const char *" or C structure with attribute 'objc_boxable'.
6932 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
6933
6934 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
6935 Expr *IndexExpr,
6936 ObjCMethodDecl *getterMethod,
6937 ObjCMethodDecl *setterMethod);
6938
6939 ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
6940 MutableArrayRef<ObjCDictionaryElement> Elements);
6941
6942 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
6943 TypeSourceInfo *EncodedTypeInfo,
6944 SourceLocation RParenLoc);
6945 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
6946 CXXConversionDecl *Method,
6947 bool HadMultipleCandidates);
6948
6949 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
6950 SourceLocation EncodeLoc,
6951 SourceLocation LParenLoc,
6952 ParsedType Ty,
6953 SourceLocation RParenLoc);
6954
6955 /// ParseObjCSelectorExpression - Build selector expression for \@selector
6956 ExprResult ParseObjCSelectorExpression(Selector Sel,
6957 SourceLocation AtLoc,
6958 SourceLocation SelLoc,
6959 SourceLocation LParenLoc,
6960 SourceLocation RParenLoc,
6961 bool WarnMultipleSelectors);
6962
6963 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol
6964 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
6965 SourceLocation AtLoc,
6966 SourceLocation ProtoLoc,
6967 SourceLocation LParenLoc,
6968 SourceLocation ProtoIdLoc,
6969 SourceLocation RParenLoc);
6970
6971 //===--------------------------------------------------------------------===//
6972 // C++ Declarations
6973 //
6974 Decl *ActOnStartLinkageSpecification(Scope *S,
6975 SourceLocation ExternLoc,
6976 Expr *LangStr,
6977 SourceLocation LBraceLoc);
6978 Decl *ActOnFinishLinkageSpecification(Scope *S,
6979 Decl *LinkageSpec,
6980 SourceLocation RBraceLoc);
6981
6982
6983 //===--------------------------------------------------------------------===//
6984 // C++ Classes
6985 //
6986 CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS);
6987 bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
6988 const CXXScopeSpec *SS = nullptr);
6989 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);
6990
6991 bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
6992 SourceLocation ColonLoc,
6993 const ParsedAttributesView &Attrs);
6994
6995 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
6996 Declarator &D,
6997 MultiTemplateParamsArg TemplateParameterLists,
6998 Expr *BitfieldWidth, const VirtSpecifiers &VS,
6999 InClassInitStyle InitStyle);
7000
7001 void ActOnStartCXXInClassMemberInitializer();
7002 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
7003 SourceLocation EqualLoc,
7004 Expr *Init);
7005
7006 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7007 Scope *S,
7008 CXXScopeSpec &SS,
7009 IdentifierInfo *MemberOrBase,
7010 ParsedType TemplateTypeTy,
7011 const DeclSpec &DS,
7012 SourceLocation IdLoc,
7013 SourceLocation LParenLoc,
7014 ArrayRef<Expr *> Args,
7015 SourceLocation RParenLoc,
7016 SourceLocation EllipsisLoc);
7017
7018 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7019 Scope *S,
7020 CXXScopeSpec &SS,
7021 IdentifierInfo *MemberOrBase,
7022 ParsedType TemplateTypeTy,
7023 const DeclSpec &DS,
7024 SourceLocation IdLoc,
7025 Expr *InitList,
7026 SourceLocation EllipsisLoc);
7027
7028 MemInitResult BuildMemInitializer(Decl *ConstructorD,
7029 Scope *S,
7030 CXXScopeSpec &SS,
7031 IdentifierInfo *MemberOrBase,
7032 ParsedType TemplateTypeTy,
7033 const DeclSpec &DS,
7034 SourceLocation IdLoc,
7035 Expr *Init,
7036 SourceLocation EllipsisLoc);
7037
7038 MemInitResult BuildMemberInitializer(ValueDecl *Member,
7039 Expr *Init,
7040 SourceLocation IdLoc);
7041
7042 MemInitResult BuildBaseInitializer(QualType BaseType,
7043 TypeSourceInfo *BaseTInfo,
7044 Expr *Init,
7045 CXXRecordDecl *ClassDecl,
7046 SourceLocation EllipsisLoc);
7047
7048 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
7049 Expr *Init,
7050 CXXRecordDecl *ClassDecl);
7051
7052 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
7053 CXXCtorInitializer *Initializer);
7054
7055 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
7056 ArrayRef<CXXCtorInitializer *> Initializers = None);
7057
7058 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
7059
7060
7061 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
7062 /// mark all the non-trivial destructors of its members and bases as
7063 /// referenced.
7064 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
7065 CXXRecordDecl *Record);
7066
7067 /// Mark destructors of virtual bases of this class referenced. In the Itanium
7068 /// C++ ABI, this is done when emitting a destructor for any non-abstract
7069 /// class. In the Microsoft C++ ABI, this is done any time a class's
7070 /// destructor is referenced.
7071 void MarkVirtualBaseDestructorsReferenced(
7072 SourceLocation Location, CXXRecordDecl *ClassDecl,
7073 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr);
7074
7075 /// Do semantic checks to allow the complete destructor variant to be emitted
7076 /// when the destructor is defined in another translation unit. In the Itanium
7077 /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they
7078 /// can be emitted in separate TUs. To emit the complete variant, run a subset
7079 /// of the checks performed when emitting a regular destructor.
7080 void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,
7081 CXXDestructorDecl *Dtor);
7082
7083 /// The list of classes whose vtables have been used within
7084 /// this translation unit, and the source locations at which the
7085 /// first use occurred.
7086 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
7087
7088 /// The list of vtables that are required but have not yet been
7089 /// materialized.
7090 SmallVector<VTableUse, 16> VTableUses;
7091
7092 /// The set of classes whose vtables have been used within
7093 /// this translation unit, and a bit that will be true if the vtable is
7094 /// required to be emitted (otherwise, it should be emitted only if needed
7095 /// by code generation).
7096 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
7097
7098 /// Load any externally-stored vtable uses.
7099 void LoadExternalVTableUses();
7100
7101 /// Note that the vtable for the given class was used at the
7102 /// given location.
7103 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
7104 bool DefinitionRequired = false);
7105
7106 /// Mark the exception specifications of all virtual member functions
7107 /// in the given class as needed.
7108 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
7109 const CXXRecordDecl *RD);
7110
7111 /// MarkVirtualMembersReferenced - Will mark all members of the given
7112 /// CXXRecordDecl referenced.
7113 void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,
7114 bool ConstexprOnly = false);
7115
7116 /// Define all of the vtables that have been used in this
7117 /// translation unit and reference any virtual members used by those
7118 /// vtables.
7119 ///
7120 /// \returns true if any work was done, false otherwise.
7121 bool DefineUsedVTables();
7122
7123 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
7124
7125 void ActOnMemInitializers(Decl *ConstructorDecl,
7126 SourceLocation ColonLoc,
7127 ArrayRef<CXXCtorInitializer*> MemInits,
7128 bool AnyErrors);
7129
7130 /// Check class-level dllimport/dllexport attribute. The caller must
7131 /// ensure that referenceDLLExportedClassMethods is called some point later
7132 /// when all outer classes of Class are complete.
7133 void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
7134 void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);
7135
7136 void referenceDLLExportedClassMethods();
7137
7138 void propagateDLLAttrToBaseClassTemplate(
7139 CXXRecordDecl *Class, Attr *ClassAttr,
7140 ClassTemplateSpecializationDecl *BaseTemplateSpec,
7141 SourceLocation BaseLoc);
7142
7143 /// Add gsl::Pointer attribute to std::container::iterator
7144 /// \param ND The declaration that introduces the name
7145 /// std::container::iterator. \param UnderlyingRecord The record named by ND.
7146 void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord);
7147
7148 /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
7149 void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);
7150
7151 /// Add [[gsl::Pointer]] attributes for std:: types.
7152 void inferGslPointerAttribute(TypedefNameDecl *TD);
7153
7154 void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record);
7155
7156 /// Check that the C++ class annoated with "trivial_abi" satisfies all the
7157 /// conditions that are needed for the attribute to have an effect.
7158 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);
7159
7160 void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,
7161 Decl *TagDecl, SourceLocation LBrac,
7162 SourceLocation RBrac,
7163 const ParsedAttributesView &AttrList);
7164 void ActOnFinishCXXMemberDecls();
7165 void ActOnFinishCXXNonNestedClass();
7166
7167 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);
7168 unsigned ActOnReenterTemplateScope(Decl *Template,
7169 llvm::function_ref<Scope *()> EnterScope);
7170 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);
7171 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7172 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);
7173 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);
7174 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7175 void ActOnFinishDelayedMemberInitializers(Decl *Record);
7176 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
7177 CachedTokens &Toks);
7178 void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
7179 bool IsInsideALocalClassWithinATemplateFunction();
7180
7181 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7182 Expr *AssertExpr,
7183 Expr *AssertMessageExpr,
7184 SourceLocation RParenLoc);
7185 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7186 Expr *AssertExpr,
7187 StringLiteral *AssertMessageExpr,
7188 SourceLocation RParenLoc,
7189 bool Failed);
7190
7191 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
7192 SourceLocation FriendLoc,
7193 TypeSourceInfo *TSInfo);
7194 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
7195 MultiTemplateParamsArg TemplateParams);
7196 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,
7197 MultiTemplateParamsArg TemplateParams);
7198
7199 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
7200 StorageClass& SC);
7201 void CheckConstructor(CXXConstructorDecl *Constructor);
7202 QualType CheckDestructorDeclarator(Declarator &D, QualType R,
7203 StorageClass& SC);
7204 bool CheckDestructor(CXXDestructorDecl *Destructor);
7205 void CheckConversionDeclarator(Declarator &D, QualType &R,
7206 StorageClass& SC);
7207 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
7208 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
7209 StorageClass &SC);
7210 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
7211
7212 void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);
7213
7214 bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
7215 CXXSpecialMember CSM);
7216 void CheckDelayedMemberExceptionSpecs();
7217
7218 bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,
7219 DefaultedComparisonKind DCK);
7220 void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
7221 FunctionDecl *Spaceship);
7222 void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,
7223 DefaultedComparisonKind DCK);
7224
7225 //===--------------------------------------------------------------------===//
7226 // C++ Derived Classes
7227 //
7228
7229 /// ActOnBaseSpecifier - Parsed a base specifier
7230 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
7231 SourceRange SpecifierRange,
7232 bool Virtual, AccessSpecifier Access,
7233 TypeSourceInfo *TInfo,
7234 SourceLocation EllipsisLoc);
7235
7236 BaseResult ActOnBaseSpecifier(Decl *classdecl,
7237 SourceRange SpecifierRange,
7238 ParsedAttributes &Attrs,
7239 bool Virtual, AccessSpecifier Access,
7240 ParsedType basetype,
7241 SourceLocation BaseLoc,
7242 SourceLocation EllipsisLoc);
7243
7244 bool AttachBaseSpecifiers(CXXRecordDecl *Class,
7245 MutableArrayRef<CXXBaseSpecifier *> Bases);
7246 void ActOnBaseSpecifiers(Decl *ClassDecl,
7247 MutableArrayRef<CXXBaseSpecifier *> Bases);
7248
7249 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
7250 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
7251 CXXBasePaths &Paths);
7252
7253 // FIXME: I don't like this name.
7254 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
7255
7256 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7257 SourceLocation Loc, SourceRange Range,
7258 CXXCastPath *BasePath = nullptr,
7259 bool IgnoreAccess = false);
7260 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7261 unsigned InaccessibleBaseID,
7262 unsigned AmbiguousBaseConvID,
7263 SourceLocation Loc, SourceRange Range,
7264 DeclarationName Name,
7265 CXXCastPath *BasePath,
7266 bool IgnoreAccess = false);
7267
7268 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
7269
7270 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
7271 const CXXMethodDecl *Old);
7272
7273 /// CheckOverridingFunctionReturnType - Checks whether the return types are
7274 /// covariant, according to C++ [class.virtual]p5.
7275 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
7276 const CXXMethodDecl *Old);
7277
7278 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
7279 /// spec is a subset of base spec.
7280 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
7281 const CXXMethodDecl *Old);
7282
7283 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
7284
7285 /// CheckOverrideControl - Check C++11 override control semantics.
7286 void CheckOverrideControl(NamedDecl *D);
7287
7288 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
7289 /// not used in the declaration of an overriding method.
7290 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent);
7291
7292 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function
7293 /// overrides a virtual member function marked 'final', according to
7294 /// C++11 [class.virtual]p4.
7295 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
7296 const CXXMethodDecl *Old);
7297
7298
7299 //===--------------------------------------------------------------------===//
7300 // C++ Access Control
7301 //
7302
7303 enum AccessResult {
7304 AR_accessible,
7305 AR_inaccessible,
7306 AR_dependent,
7307 AR_delayed
7308 };
7309
7310 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
7311 NamedDecl *PrevMemberDecl,
7312 AccessSpecifier LexicalAS);
7313
7314 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
7315 DeclAccessPair FoundDecl);
7316 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
7317 DeclAccessPair FoundDecl);
7318 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
7319 SourceRange PlacementRange,
7320 CXXRecordDecl *NamingClass,
7321 DeclAccessPair FoundDecl,
7322 bool Diagnose = true);
7323 AccessResult CheckConstructorAccess(SourceLocation Loc,
7324 CXXConstructorDecl *D,
7325 DeclAccessPair FoundDecl,
7326 const InitializedEntity &Entity,
7327 bool IsCopyBindingRefToTemp = false);
7328 AccessResult CheckConstructorAccess(SourceLocation Loc,
7329 CXXConstructorDecl *D,
7330 DeclAccessPair FoundDecl,
7331 const InitializedEntity &Entity,
7332 const PartialDiagnostic &PDiag);
7333 AccessResult CheckDestructorAccess(SourceLocation Loc,
7334 CXXDestructorDecl *Dtor,
7335 const PartialDiagnostic &PDiag,
7336 QualType objectType = QualType());
7337 AccessResult CheckFriendAccess(NamedDecl *D);
7338 AccessResult CheckMemberAccess(SourceLocation UseLoc,
7339 CXXRecordDecl *NamingClass,
7340 DeclAccessPair Found);
7341 AccessResult
7342 CheckStructuredBindingMemberAccess(SourceLocation UseLoc,
7343 CXXRecordDecl *DecomposedClass,
7344 DeclAccessPair Field);
7345 AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
7346 Expr *ObjectExpr,
7347 Expr *ArgExpr,
7348 DeclAccessPair FoundDecl);
7349 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
7350 DeclAccessPair FoundDecl);
7351 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
7352 QualType Base, QualType Derived,
7353 const CXXBasePath &Path,
7354 unsigned DiagID,
7355 bool ForceCheck = false,
7356 bool ForceUnprivileged = false);
7357 void CheckLookupAccess(const LookupResult &R);
7358 bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass,
7359 QualType BaseType);
7360 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7361 DeclAccessPair Found, QualType ObjectType,
7362 SourceLocation Loc,
7363 const PartialDiagnostic &Diag);
7364 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7365 DeclAccessPair Found,
7366 QualType ObjectType) {
7367 return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,
7368 SourceLocation(), PDiag());
7369 }
7370
7371 void HandleDependentAccessCheck(const DependentDiagnostic &DD,
7372 const MultiLevelTemplateArgumentList &TemplateArgs);
7373 void PerformDependentDiagnostics(const DeclContext *Pattern,
7374 const MultiLevelTemplateArgumentList &TemplateArgs);
7375
7376 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
7377
7378 /// When true, access checking violations are treated as SFINAE
7379 /// failures rather than hard errors.
7380 bool AccessCheckingSFINAE;
7381
7382 enum AbstractDiagSelID {
7383 AbstractNone = -1,
7384 AbstractReturnType,
7385 AbstractParamType,
7386 AbstractVariableType,
7387 AbstractFieldType,
7388 AbstractIvarType,
7389 AbstractSynthesizedIvarType,
7390 AbstractArrayType
7391 };
7392
7393 bool isAbstractType(SourceLocation Loc, QualType T);
7394 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
7395 TypeDiagnoser &Diagnoser);
7396 template <typename... Ts>
7397 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
7398 const Ts &...Args) {
7399 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
7400 return RequireNonAbstractType(Loc, T, Diagnoser);
7401 }
7402
7403 void DiagnoseAbstractType(const CXXRecordDecl *RD);
7404
7405 //===--------------------------------------------------------------------===//
7406 // C++ Overloaded Operators [C++ 13.5]
7407 //
7408
7409 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
7410
7411 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
7412
7413 //===--------------------------------------------------------------------===//
7414 // C++ Templates [C++ 14]
7415 //
7416 void FilterAcceptableTemplateNames(LookupResult &R,
7417 bool AllowFunctionTemplates = true,
7418 bool AllowDependent = true);
7419 bool hasAnyAcceptableTemplateNames(LookupResult &R,
7420 bool AllowFunctionTemplates = true,
7421 bool AllowDependent = true,
7422 bool AllowNonTemplateFunctions = false);
7423 /// Try to interpret the lookup result D as a template-name.
7424 ///
7425 /// \param D A declaration found by name lookup.
7426 /// \param AllowFunctionTemplates Whether function templates should be
7427 /// considered valid results.
7428 /// \param AllowDependent Whether unresolved using declarations (that might
7429 /// name templates) should be considered valid results.
7430 static NamedDecl *getAsTemplateNameDecl(NamedDecl *D,
7431 bool AllowFunctionTemplates = true,
7432 bool AllowDependent = true);
7433
7434 enum TemplateNameIsRequiredTag { TemplateNameIsRequired };
7435 /// Whether and why a template name is required in this lookup.
7436 class RequiredTemplateKind {
7437 public:
7438 /// Template name is required if TemplateKWLoc is valid.
7439 RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation())
7440 : TemplateKW(TemplateKWLoc) {}
7441 /// Template name is unconditionally required.
7442 RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {}
7443
7444 SourceLocation getTemplateKeywordLoc() const {
7445 return TemplateKW.getValueOr(SourceLocation());
7446 }
7447 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
7448 bool isRequired() const { return TemplateKW != SourceLocation(); }
7449 explicit operator bool() const { return isRequired(); }
7450
7451 private:
7452 llvm::Optional<SourceLocation> TemplateKW;
7453 };
7454
7455 enum class AssumedTemplateKind {
7456 /// This is not assumed to be a template name.
7457 None,
7458 /// This is assumed to be a template name because lookup found nothing.
7459 FoundNothing,
7460 /// This is assumed to be a template name because lookup found one or more
7461 /// functions (but no function templates).
7462 FoundFunctions,
7463 };
7464 bool LookupTemplateName(
7465 LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,
7466 bool EnteringContext, bool &MemberOfUnknownSpecialization,
7467 RequiredTemplateKind RequiredTemplate = SourceLocation(),
7468 AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true);
7469
7470 TemplateNameKind isTemplateName(Scope *S,
7471 CXXScopeSpec &SS,
7472 bool hasTemplateKeyword,
7473 const UnqualifiedId &Name,
7474 ParsedType ObjectType,
7475 bool EnteringContext,
7476 TemplateTy &Template,
7477 bool &MemberOfUnknownSpecialization,
7478 bool Disambiguation = false);
7479
7480 /// Try to resolve an undeclared template name as a type template.
7481 ///
7482 /// Sets II to the identifier corresponding to the template name, and updates
7483 /// Name to a corresponding (typo-corrected) type template name and TNK to
7484 /// the corresponding kind, if possible.
7485 void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,
7486 TemplateNameKind &TNK,
7487 SourceLocation NameLoc,
7488 IdentifierInfo *&II);
7489
7490 bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
7491 SourceLocation NameLoc,
7492 bool Diagnose = true);
7493
7494 /// Determine whether a particular identifier might be the name in a C++1z
7495 /// deduction-guide declaration.
7496 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
7497 SourceLocation NameLoc,
7498 ParsedTemplateTy *Template = nullptr);
7499
7500 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
7501 SourceLocation IILoc,
7502 Scope *S,
7503 const CXXScopeSpec *SS,
7504 TemplateTy &SuggestedTemplate,
7505 TemplateNameKind &SuggestedKind);
7506
7507 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
7508 NamedDecl *Instantiation,
7509 bool InstantiatedFromMember,
7510 const NamedDecl *Pattern,
7511 const NamedDecl *PatternDef,
7512 TemplateSpecializationKind TSK,
7513 bool Complain = true);
7514
7515 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
7516 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);
7517
7518 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
7519 SourceLocation EllipsisLoc,
7520 SourceLocation KeyLoc,
7521 IdentifierInfo *ParamName,
7522 SourceLocation ParamNameLoc,
7523 unsigned Depth, unsigned Position,
7524 SourceLocation EqualLoc,
7525 ParsedType DefaultArg, bool HasTypeConstraint);
7526
7527 bool ActOnTypeConstraint(const CXXScopeSpec &SS,
7528 TemplateIdAnnotation *TypeConstraint,
7529 TemplateTypeParmDecl *ConstrainedParameter,
7530 SourceLocation EllipsisLoc);
7531 bool BuildTypeConstraint(const CXXScopeSpec &SS,
7532 TemplateIdAnnotation *TypeConstraint,
7533 TemplateTypeParmDecl *ConstrainedParameter,
7534 SourceLocation EllipsisLoc,
7535 bool AllowUnexpandedPack);
7536
7537 bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
7538 DeclarationNameInfo NameInfo,
7539 ConceptDecl *NamedConcept,
7540 const TemplateArgumentListInfo *TemplateArgs,
7541 TemplateTypeParmDecl *ConstrainedParameter,
7542 SourceLocation EllipsisLoc);
7543
7544 bool AttachTypeConstraint(AutoTypeLoc TL,
7545 NonTypeTemplateParmDecl *ConstrainedParameter,
7546 SourceLocation EllipsisLoc);
7547
7548 bool RequireStructuralType(QualType T, SourceLocation Loc);
7549
7550 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
7551 SourceLocation Loc);
7552 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
7553
7554 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
7555 unsigned Depth,
7556 unsigned Position,
7557 SourceLocation EqualLoc,
7558 Expr *DefaultArg);
7559 NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
7560 SourceLocation TmpLoc,
7561 TemplateParameterList *Params,
7562 SourceLocation EllipsisLoc,
7563 IdentifierInfo *ParamName,
7564 SourceLocation ParamNameLoc,
7565 unsigned Depth,
7566 unsigned Position,
7567 SourceLocation EqualLoc,
7568 ParsedTemplateArgument DefaultArg);
7569
7570 TemplateParameterList *
7571 ActOnTemplateParameterList(unsigned Depth,
7572 SourceLocation ExportLoc,
7573 SourceLocation TemplateLoc,
7574 SourceLocation LAngleLoc,
7575 ArrayRef<NamedDecl *> Params,
7576 SourceLocation RAngleLoc,
7577 Expr *RequiresClause);
7578
7579 /// The context in which we are checking a template parameter list.
7580 enum TemplateParamListContext {
7581 TPC_ClassTemplate,
7582 TPC_VarTemplate,
7583 TPC_FunctionTemplate,
7584 TPC_ClassTemplateMember,
7585 TPC_FriendClassTemplate,
7586 TPC_FriendFunctionTemplate,
7587 TPC_FriendFunctionTemplateDefinition,
7588 TPC_TypeAliasTemplate
7589 };
7590
7591 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
7592 TemplateParameterList *OldParams,
7593 TemplateParamListContext TPC,
7594 SkipBodyInfo *SkipBody = nullptr);
7595 TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
7596 SourceLocation DeclStartLoc, SourceLocation DeclLoc,
7597 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
7598 ArrayRef<TemplateParameterList *> ParamLists,
7599 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,
7600 bool SuppressDiagnostic = false);
7601
7602 DeclResult CheckClassTemplate(
7603 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7604 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
7605 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
7606 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
7607 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
7608 TemplateParameterList **OuterTemplateParamLists,
7609 SkipBodyInfo *SkipBody = nullptr);
7610
7611 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
7612 QualType NTTPType,
7613 SourceLocation Loc);
7614
7615 /// Get a template argument mapping the given template parameter to itself,
7616 /// e.g. for X in \c template<int X>, this would return an expression template
7617 /// argument referencing X.
7618 TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,
7619 SourceLocation Location);
7620
7621 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
7622 TemplateArgumentListInfo &Out);
7623
7624 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
7625
7626 void NoteAllFoundTemplates(TemplateName Name);
7627
7628 QualType CheckTemplateIdType(TemplateName Template,
7629 SourceLocation TemplateLoc,
7630 TemplateArgumentListInfo &TemplateArgs);
7631
7632 TypeResult
7633 ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7634 TemplateTy Template, IdentifierInfo *TemplateII,
7635 SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
7636 ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,
7637 bool IsCtorOrDtorName = false, bool IsClassName = false);
7638
7639 /// Parsed an elaborated-type-specifier that refers to a template-id,
7640 /// such as \c class T::template apply<U>.
7641 TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
7642 TypeSpecifierType TagSpec,
7643 SourceLocation TagLoc,
7644 CXXScopeSpec &SS,
7645 SourceLocation TemplateKWLoc,
7646 TemplateTy TemplateD,
7647 SourceLocation TemplateLoc,
7648 SourceLocation LAngleLoc,
7649 ASTTemplateArgsPtr TemplateArgsIn,
7650 SourceLocation RAngleLoc);
7651
7652 DeclResult ActOnVarTemplateSpecialization(
7653 Scope *S, Declarator &D, TypeSourceInfo *DI,
7654 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
7655 StorageClass SC, bool IsPartialSpecialization);
7656
7657 /// Get the specialization of the given variable template corresponding to
7658 /// the specified argument list, or a null-but-valid result if the arguments
7659 /// are dependent.
7660 DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
7661 SourceLocation TemplateLoc,
7662 SourceLocation TemplateNameLoc,
7663 const TemplateArgumentListInfo &TemplateArgs);
7664
7665 /// Form a reference to the specialization of the given variable template
7666 /// corresponding to the specified argument list, or a null-but-valid result
7667 /// if the arguments are dependent.
7668 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
7669 const DeclarationNameInfo &NameInfo,
7670 VarTemplateDecl *Template,
7671 SourceLocation TemplateLoc,
7672 const TemplateArgumentListInfo *TemplateArgs);
7673
7674 ExprResult
7675 CheckConceptTemplateId(const CXXScopeSpec &SS,
7676 SourceLocation TemplateKWLoc,
7677 const DeclarationNameInfo &ConceptNameInfo,
7678 NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
7679 const TemplateArgumentListInfo *TemplateArgs);
7680
7681 void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);
7682
7683 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
7684 SourceLocation TemplateKWLoc,
7685 LookupResult &R,
7686 bool RequiresADL,
7687 const TemplateArgumentListInfo *TemplateArgs);
7688
7689 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
7690 SourceLocation TemplateKWLoc,
7691 const DeclarationNameInfo &NameInfo,
7692 const TemplateArgumentListInfo *TemplateArgs);
7693
7694 TemplateNameKind ActOnTemplateName(
7695 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7696 const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
7697 TemplateTy &Template, bool AllowInjectedClassName = false);
7698
7699 DeclResult ActOnClassTemplateSpecialization(
7700 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7701 SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
7702 TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,
7703 MultiTemplateParamsArg TemplateParameterLists,
7704 SkipBodyInfo *SkipBody = nullptr);
7705
7706 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
7707 TemplateDecl *PrimaryTemplate,
7708 unsigned NumExplicitArgs,
7709 ArrayRef<TemplateArgument> Args);
7710 void CheckTemplatePartialSpecialization(
7711 ClassTemplatePartialSpecializationDecl *Partial);
7712 void CheckTemplatePartialSpecialization(
7713 VarTemplatePartialSpecializationDecl *Partial);
7714
7715 Decl *ActOnTemplateDeclarator(Scope *S,
7716 MultiTemplateParamsArg TemplateParameterLists,
7717 Declarator &D);
7718
7719 bool
7720 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
7721 TemplateSpecializationKind NewTSK,
7722 NamedDecl *PrevDecl,
7723 TemplateSpecializationKind PrevTSK,
7724 SourceLocation PrevPtOfInstantiation,
7725 bool &SuppressNew);
7726
7727 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
7728 const TemplateArgumentListInfo &ExplicitTemplateArgs,
7729 LookupResult &Previous);
7730
7731 bool CheckFunctionTemplateSpecialization(
7732 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
7733 LookupResult &Previous, bool QualifiedFriend = false);
7734 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7735 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7736
7737 DeclResult ActOnExplicitInstantiation(
7738 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
7739 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
7740 TemplateTy Template, SourceLocation TemplateNameLoc,
7741 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,
7742 SourceLocation RAngleLoc, const ParsedAttributesView &Attr);
7743
7744 DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
7745 SourceLocation TemplateLoc,
7746 unsigned TagSpec, SourceLocation KWLoc,
7747 CXXScopeSpec &SS, IdentifierInfo *Name,
7748 SourceLocation NameLoc,
7749 const ParsedAttributesView &Attr);
7750
7751 DeclResult ActOnExplicitInstantiation(Scope *S,
7752 SourceLocation ExternLoc,
7753 SourceLocation TemplateLoc,
7754 Declarator &D);
7755
7756 TemplateArgumentLoc
7757 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
7758 SourceLocation TemplateLoc,
7759 SourceLocation RAngleLoc,
7760 Decl *Param,
7761 SmallVectorImpl<TemplateArgument>
7762 &Converted,
7763 bool &HasDefaultArg);
7764
7765 /// Specifies the context in which a particular template
7766 /// argument is being checked.
7767 enum CheckTemplateArgumentKind {
7768 /// The template argument was specified in the code or was
7769 /// instantiated with some deduced template arguments.
7770 CTAK_Specified,
7771
7772 /// The template argument was deduced via template argument
7773 /// deduction.
7774 CTAK_Deduced,
7775
7776 /// The template argument was deduced from an array bound
7777 /// via template argument deduction.
7778 CTAK_DeducedFromArrayBound
7779 };
7780
7781 bool CheckTemplateArgument(NamedDecl *Param,
7782 TemplateArgumentLoc &Arg,
7783 NamedDecl *Template,
7784 SourceLocation TemplateLoc,
7785 SourceLocation RAngleLoc,
7786 unsigned ArgumentPackIndex,
7787 SmallVectorImpl<TemplateArgument> &Converted,
7788 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7789
7790 /// Check that the given template arguments can be be provided to
7791 /// the given template, converting the arguments along the way.
7792 ///
7793 /// \param Template The template to which the template arguments are being
7794 /// provided.
7795 ///
7796 /// \param TemplateLoc The location of the template name in the source.
7797 ///
7798 /// \param TemplateArgs The list of template arguments. If the template is
7799 /// a template template parameter, this function may extend the set of
7800 /// template arguments to also include substituted, defaulted template
7801 /// arguments.
7802 ///
7803 /// \param PartialTemplateArgs True if the list of template arguments is
7804 /// intentionally partial, e.g., because we're checking just the initial
7805 /// set of template arguments.
7806 ///
7807 /// \param Converted Will receive the converted, canonicalized template
7808 /// arguments.
7809 ///
7810 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
7811 /// contain the converted forms of the template arguments as written.
7812 /// Otherwise, \p TemplateArgs will not be modified.
7813 ///
7814 /// \param ConstraintsNotSatisfied If provided, and an error occured, will
7815 /// receive true if the cause for the error is the associated constraints of
7816 /// the template not being satisfied by the template arguments.
7817 ///
7818 /// \returns true if an error occurred, false otherwise.
7819 bool CheckTemplateArgumentList(TemplateDecl *Template,
7820 SourceLocation TemplateLoc,
7821 TemplateArgumentListInfo &TemplateArgs,
7822 bool PartialTemplateArgs,
7823 SmallVectorImpl<TemplateArgument> &Converted,
7824 bool UpdateArgsWithConversions = true,
7825 bool *ConstraintsNotSatisfied = nullptr);
7826
7827 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
7828 TemplateArgumentLoc &Arg,
7829 SmallVectorImpl<TemplateArgument> &Converted);
7830
7831 bool CheckTemplateArgument(TypeSourceInfo *Arg);
7832 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
7833 QualType InstantiatedParamType, Expr *Arg,
7834 TemplateArgument &Converted,
7835 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7836 bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
7837 TemplateParameterList *Params,
7838 TemplateArgumentLoc &Arg);
7839
7840 ExprResult
7841 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
7842 QualType ParamType,
7843 SourceLocation Loc);
7844 ExprResult
7845 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
7846 SourceLocation Loc);
7847
7848 /// Enumeration describing how template parameter lists are compared
7849 /// for equality.
7850 enum TemplateParameterListEqualKind {
7851 /// We are matching the template parameter lists of two templates
7852 /// that might be redeclarations.
7853 ///
7854 /// \code
7855 /// template<typename T> struct X;
7856 /// template<typename T> struct X;
7857 /// \endcode
7858 TPL_TemplateMatch,
7859
7860 /// We are matching the template parameter lists of two template
7861 /// template parameters as part of matching the template parameter lists
7862 /// of two templates that might be redeclarations.
7863 ///
7864 /// \code
7865 /// template<template<int I> class TT> struct X;
7866 /// template<template<int Value> class Other> struct X;
7867 /// \endcode
7868 TPL_TemplateTemplateParmMatch,
7869
7870 /// We are matching the template parameter lists of a template
7871 /// template argument against the template parameter lists of a template
7872 /// template parameter.
7873 ///
7874 /// \code
7875 /// template<template<int Value> class Metafun> struct X;
7876 /// template<int Value> struct integer_c;
7877 /// X<integer_c> xic;
7878 /// \endcode
7879 TPL_TemplateTemplateArgumentMatch
7880 };
7881
7882 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
7883 TemplateParameterList *Old,
7884 bool Complain,
7885 TemplateParameterListEqualKind Kind,
7886 SourceLocation TemplateArgLoc
7887 = SourceLocation());
7888
7889 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
7890
7891 /// Called when the parser has parsed a C++ typename
7892 /// specifier, e.g., "typename T::type".
7893 ///
7894 /// \param S The scope in which this typename type occurs.
7895 /// \param TypenameLoc the location of the 'typename' keyword
7896 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7897 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
7898 /// \param IdLoc the location of the identifier.
7899 TypeResult
7900 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7901 const CXXScopeSpec &SS, const IdentifierInfo &II,
7902 SourceLocation IdLoc);
7903
7904 /// Called when the parser has parsed a C++ typename
7905 /// specifier that ends in a template-id, e.g.,
7906 /// "typename MetaFun::template apply<T1, T2>".
7907 ///
7908 /// \param S The scope in which this typename type occurs.
7909 /// \param TypenameLoc the location of the 'typename' keyword
7910 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7911 /// \param TemplateLoc the location of the 'template' keyword, if any.
7912 /// \param TemplateName The template name.
7913 /// \param TemplateII The identifier used to name the template.
7914 /// \param TemplateIILoc The location of the template name.
7915 /// \param LAngleLoc The location of the opening angle bracket ('<').
7916 /// \param TemplateArgs The template arguments.
7917 /// \param RAngleLoc The location of the closing angle bracket ('>').
7918 TypeResult
7919 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7920 const CXXScopeSpec &SS,
7921 SourceLocation TemplateLoc,
7922 TemplateTy TemplateName,
7923 IdentifierInfo *TemplateII,
7924 SourceLocation TemplateIILoc,
7925 SourceLocation LAngleLoc,
7926 ASTTemplateArgsPtr TemplateArgs,
7927 SourceLocation RAngleLoc);
7928
7929 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7930 SourceLocation KeywordLoc,
7931 NestedNameSpecifierLoc QualifierLoc,
7932 const IdentifierInfo &II,
7933 SourceLocation IILoc,
7934 TypeSourceInfo **TSI,
7935 bool DeducedTSTContext);
7936
7937 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7938 SourceLocation KeywordLoc,
7939 NestedNameSpecifierLoc QualifierLoc,
7940 const IdentifierInfo &II,
7941 SourceLocation IILoc,
7942 bool DeducedTSTContext = true);
7943
7944
7945 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
7946 SourceLocation Loc,
7947 DeclarationName Name);
7948 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
7949
7950 ExprResult RebuildExprInCurrentInstantiation(Expr *E);
7951 bool RebuildTemplateParamsInCurrentInstantiation(
7952 TemplateParameterList *Params);
7953
7954 std::string
7955 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7956 const TemplateArgumentList &Args);
7957
7958 std::string
7959 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7960 const TemplateArgument *Args,
7961 unsigned NumArgs);
7962
7963 //===--------------------------------------------------------------------===//
7964 // C++ Concepts
7965 //===--------------------------------------------------------------------===//
7966 Decl *ActOnConceptDefinition(
7967 Scope *S, MultiTemplateParamsArg TemplateParameterLists,
7968 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);
7969
7970 RequiresExprBodyDecl *
7971 ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,
7972 ArrayRef<ParmVarDecl *> LocalParameters,
7973 Scope *BodyScope);
7974 void ActOnFinishRequiresExpr();
7975 concepts::Requirement *ActOnSimpleRequirement(Expr *E);
7976 concepts::Requirement *ActOnTypeRequirement(
7977 SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,
7978 IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId);
7979 concepts::Requirement *ActOnCompoundRequirement(Expr *E,
7980 SourceLocation NoexceptLoc);
7981 concepts::Requirement *
7982 ActOnCompoundRequirement(
7983 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,
7984 TemplateIdAnnotation *TypeConstraint, unsigned Depth);
7985 concepts::Requirement *ActOnNestedRequirement(Expr *Constraint);
7986 concepts::ExprRequirement *
7987 BuildExprRequirement(
7988 Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc,
7989 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7990 concepts::ExprRequirement *
7991 BuildExprRequirement(
7992 concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,
7993 bool IsSatisfied, SourceLocation NoexceptLoc,
7994 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7995 concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type);
7996 concepts::TypeRequirement *
7997 BuildTypeRequirement(
7998 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
7999 concepts::NestedRequirement *BuildNestedRequirement(Expr *E);
8000 concepts::NestedRequirement *
8001 BuildNestedRequirement(
8002 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
8003 ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,
8004 RequiresExprBodyDecl *Body,
8005 ArrayRef<ParmVarDecl *> LocalParameters,
8006 ArrayRef<concepts::Requirement *> Requirements,
8007 SourceLocation ClosingBraceLoc);
8008
8009 //===--------------------------------------------------------------------===//
8010 // C++ Variadic Templates (C++0x [temp.variadic])
8011 //===--------------------------------------------------------------------===//
8012
8013 /// Determine whether an unexpanded parameter pack might be permitted in this
8014 /// location. Useful for error recovery.
8015 bool isUnexpandedParameterPackPermitted();
8016
8017 /// The context in which an unexpanded parameter pack is
8018 /// being diagnosed.
8019 ///
8020 /// Note that the values of this enumeration line up with the first
8021 /// argument to the \c err_unexpanded_parameter_pack diagnostic.
8022 enum UnexpandedParameterPackContext {
8023 /// An arbitrary expression.
8024 UPPC_Expression = 0,
8025
8026 /// The base type of a class type.
8027 UPPC_BaseType,
8028
8029 /// The type of an arbitrary declaration.
8030 UPPC_DeclarationType,
8031
8032 /// The type of a data member.
8033 UPPC_DataMemberType,
8034
8035 /// The size of a bit-field.
8036 UPPC_BitFieldWidth,
8037
8038 /// The expression in a static assertion.
8039 UPPC_StaticAssertExpression,
8040
8041 /// The fixed underlying type of an enumeration.
8042 UPPC_FixedUnderlyingType,
8043
8044 /// The enumerator value.
8045 UPPC_EnumeratorValue,
8046
8047 /// A using declaration.
8048 UPPC_UsingDeclaration,
8049
8050 /// A friend declaration.
8051 UPPC_FriendDeclaration,
8052
8053 /// A declaration qualifier.
8054 UPPC_DeclarationQualifier,
8055
8056 /// An initializer.
8057 UPPC_Initializer,
8058
8059 /// A default argument.
8060 UPPC_DefaultArgument,
8061
8062 /// The type of a non-type template parameter.
8063 UPPC_NonTypeTemplateParameterType,
8064
8065 /// The type of an exception.
8066 UPPC_ExceptionType,
8067
8068 /// Partial specialization.
8069 UPPC_PartialSpecialization,
8070
8071 /// Microsoft __if_exists.
8072 UPPC_IfExists,
8073
8074 /// Microsoft __if_not_exists.
8075 UPPC_IfNotExists,
8076
8077 /// Lambda expression.
8078 UPPC_Lambda,
8079
8080 /// Block expression.
8081 UPPC_Block,
8082
8083 /// A type constraint.
8084 UPPC_TypeConstraint,
8085
8086 // A requirement in a requires-expression.
8087 UPPC_Requirement,
8088
8089 // A requires-clause.
8090 UPPC_RequiresClause,
8091 };
8092
8093 /// Diagnose unexpanded parameter packs.
8094 ///
8095 /// \param Loc The location at which we should emit the diagnostic.
8096 ///
8097 /// \param UPPC The context in which we are diagnosing unexpanded
8098 /// parameter packs.
8099 ///
8100 /// \param Unexpanded the set of unexpanded parameter packs.
8101 ///
8102 /// \returns true if an error occurred, false otherwise.
8103 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
8104 UnexpandedParameterPackContext UPPC,
8105 ArrayRef<UnexpandedParameterPack> Unexpanded);
8106
8107 /// If the given type contains an unexpanded parameter pack,
8108 /// diagnose the error.
8109 ///
8110 /// \param Loc The source location where a diagnostc should be emitted.
8111 ///
8112 /// \param T The type that is being checked for unexpanded parameter
8113 /// packs.
8114 ///
8115 /// \returns true if an error occurred, false otherwise.
8116 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
8117 UnexpandedParameterPackContext UPPC);
8118
8119 /// If the given expression contains an unexpanded parameter
8120 /// pack, diagnose the error.
8121 ///
8122 /// \param E The expression that is being checked for unexpanded
8123 /// parameter packs.
8124 ///
8125 /// \returns true if an error occurred, false otherwise.
8126 bool DiagnoseUnexpandedParameterPack(Expr *E,
8127 UnexpandedParameterPackContext UPPC = UPPC_Expression);
8128
8129 /// If the given requirees-expression contains an unexpanded reference to one
8130 /// of its own parameter packs, diagnose the error.
8131 ///
8132 /// \param RE The requiress-expression that is being checked for unexpanded
8133 /// parameter packs.
8134 ///
8135 /// \returns true if an error occurred, false otherwise.
8136 bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);
8137
8138 /// If the given nested-name-specifier contains an unexpanded
8139 /// parameter pack, diagnose the error.
8140 ///
8141 /// \param SS The nested-name-specifier that is being checked for
8142 /// unexpanded parameter packs.
8143 ///
8144 /// \returns true if an error occurred, false otherwise.
8145 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
8146 UnexpandedParameterPackContext UPPC);
8147
8148 /// If the given name contains an unexpanded parameter pack,
8149 /// diagnose the error.
8150 ///
8151 /// \param NameInfo The name (with source location information) that
8152 /// is being checked for unexpanded parameter packs.
8153 ///
8154 /// \returns true if an error occurred, false otherwise.
8155 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
8156 UnexpandedParameterPackContext UPPC);
8157
8158 /// If the given template name contains an unexpanded parameter pack,
8159 /// diagnose the error.
8160 ///
8161 /// \param Loc The location of the template name.
8162 ///
8163 /// \param Template The template name that is being checked for unexpanded
8164 /// parameter packs.
8165 ///
8166 /// \returns true if an error occurred, false otherwise.
8167 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
8168 TemplateName Template,
8169 UnexpandedParameterPackContext UPPC);
8170
8171 /// If the given template argument contains an unexpanded parameter
8172 /// pack, diagnose the error.
8173 ///
8174 /// \param Arg The template argument that is being checked for unexpanded
8175 /// parameter packs.
8176 ///
8177 /// \returns true if an error occurred, false otherwise.
8178 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
8179 UnexpandedParameterPackContext UPPC);
8180
8181 /// Collect the set of unexpanded parameter packs within the given
8182 /// template argument.
8183 ///
8184 /// \param Arg The template argument that will be traversed to find
8185 /// unexpanded parameter packs.
8186 void collectUnexpandedParameterPacks(TemplateArgument Arg,
8187 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8188
8189 /// Collect the set of unexpanded parameter packs within the given
8190 /// template argument.
8191 ///
8192 /// \param Arg The template argument that will be traversed to find
8193 /// unexpanded parameter packs.
8194 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
8195 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8196
8197 /// Collect the set of unexpanded parameter packs within the given
8198 /// type.
8199 ///
8200 /// \param T The type that will be traversed to find
8201 /// unexpanded parameter packs.
8202 void collectUnexpandedParameterPacks(QualType T,
8203 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8204
8205 /// Collect the set of unexpanded parameter packs within the given
8206 /// type.
8207 ///
8208 /// \param TL The type that will be traversed to find
8209 /// unexpanded parameter packs.
8210 void collectUnexpandedParameterPacks(TypeLoc TL,
8211 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8212
8213 /// Collect the set of unexpanded parameter packs within the given
8214 /// nested-name-specifier.
8215 ///
8216 /// \param NNS The nested-name-specifier that will be traversed to find
8217 /// unexpanded parameter packs.
8218 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,
8219 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8220
8221 /// Collect the set of unexpanded parameter packs within the given
8222 /// name.
8223 ///
8224 /// \param NameInfo The name that will be traversed to find
8225 /// unexpanded parameter packs.
8226 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
8227 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8228
8229 /// Invoked when parsing a template argument followed by an
8230 /// ellipsis, which creates a pack expansion.
8231 ///
8232 /// \param Arg The template argument preceding the ellipsis, which
8233 /// may already be invalid.
8234 ///
8235 /// \param EllipsisLoc The location of the ellipsis.
8236 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
8237 SourceLocation EllipsisLoc);
8238
8239 /// Invoked when parsing a type followed by an ellipsis, which
8240 /// creates a pack expansion.
8241 ///
8242 /// \param Type The type preceding the ellipsis, which will become
8243 /// the pattern of the pack expansion.
8244 ///
8245 /// \param EllipsisLoc The location of the ellipsis.
8246 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
8247
8248 /// Construct a pack expansion type from the pattern of the pack
8249 /// expansion.
8250 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
8251 SourceLocation EllipsisLoc,
8252 Optional<unsigned> NumExpansions);
8253
8254 /// Construct a pack expansion type from the pattern of the pack
8255 /// expansion.
8256 QualType CheckPackExpansion(QualType Pattern,
8257 SourceRange PatternRange,
8258 SourceLocation EllipsisLoc,
8259 Optional<unsigned> NumExpansions);
8260
8261 /// Invoked when parsing an expression followed by an ellipsis, which
8262 /// creates a pack expansion.
8263 ///
8264 /// \param Pattern The expression preceding the ellipsis, which will become
8265 /// the pattern of the pack expansion.
8266 ///
8267 /// \param EllipsisLoc The location of the ellipsis.
8268 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
8269
8270 /// Invoked when parsing an expression followed by an ellipsis, which
8271 /// creates a pack expansion.
8272 ///
8273 /// \param Pattern The expression preceding the ellipsis, which will become
8274 /// the pattern of the pack expansion.
8275 ///
8276 /// \param EllipsisLoc The location of the ellipsis.
8277 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
8278 Optional<unsigned> NumExpansions);
8279
8280 /// Determine whether we could expand a pack expansion with the
8281 /// given set of parameter packs into separate arguments by repeatedly
8282 /// transforming the pattern.
8283 ///
8284 /// \param EllipsisLoc The location of the ellipsis that identifies the
8285 /// pack expansion.
8286 ///
8287 /// \param PatternRange The source range that covers the entire pattern of
8288 /// the pack expansion.
8289 ///
8290 /// \param Unexpanded The set of unexpanded parameter packs within the
8291 /// pattern.
8292 ///
8293 /// \param ShouldExpand Will be set to \c true if the transformer should
8294 /// expand the corresponding pack expansions into separate arguments. When
8295 /// set, \c NumExpansions must also be set.
8296 ///
8297 /// \param RetainExpansion Whether the caller should add an unexpanded
8298 /// pack expansion after all of the expanded arguments. This is used
8299 /// when extending explicitly-specified template argument packs per
8300 /// C++0x [temp.arg.explicit]p9.
8301 ///
8302 /// \param NumExpansions The number of separate arguments that will be in
8303 /// the expanded form of the corresponding pack expansion. This is both an
8304 /// input and an output parameter, which can be set by the caller if the
8305 /// number of expansions is known a priori (e.g., due to a prior substitution)
8306 /// and will be set by the callee when the number of expansions is known.
8307 /// The callee must set this value when \c ShouldExpand is \c true; it may
8308 /// set this value in other cases.
8309 ///
8310 /// \returns true if an error occurred (e.g., because the parameter packs
8311 /// are to be instantiated with arguments of different lengths), false
8312 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
8313 /// must be set.
8314 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
8315 SourceRange PatternRange,
8316 ArrayRef<UnexpandedParameterPack> Unexpanded,
8317 const MultiLevelTemplateArgumentList &TemplateArgs,
8318 bool &ShouldExpand,
8319 bool &RetainExpansion,
8320 Optional<unsigned> &NumExpansions);
8321
8322 /// Determine the number of arguments in the given pack expansion
8323 /// type.
8324 ///
8325 /// This routine assumes that the number of arguments in the expansion is
8326 /// consistent across all of the unexpanded parameter packs in its pattern.
8327 ///
8328 /// Returns an empty Optional if the type can't be expanded.
8329 Optional<unsigned> getNumArgumentsInExpansion(QualType T,
8330 const MultiLevelTemplateArgumentList &TemplateArgs);
8331
8332 /// Determine whether the given declarator contains any unexpanded
8333 /// parameter packs.
8334 ///
8335 /// This routine is used by the parser to disambiguate function declarators
8336 /// with an ellipsis prior to the ')', e.g.,
8337 ///
8338 /// \code
8339 /// void f(T...);
8340 /// \endcode
8341 ///
8342 /// To determine whether we have an (unnamed) function parameter pack or
8343 /// a variadic function.
8344 ///
8345 /// \returns true if the declarator contains any unexpanded parameter packs,
8346 /// false otherwise.
8347 bool containsUnexpandedParameterPacks(Declarator &D);
8348
8349 /// Returns the pattern of the pack expansion for a template argument.
8350 ///
8351 /// \param OrigLoc The template argument to expand.
8352 ///
8353 /// \param Ellipsis Will be set to the location of the ellipsis.
8354 ///
8355 /// \param NumExpansions Will be set to the number of expansions that will
8356 /// be generated from this pack expansion, if known a priori.
8357 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
8358 TemplateArgumentLoc OrigLoc,
8359 SourceLocation &Ellipsis,
8360 Optional<unsigned> &NumExpansions) const;
8361
8362 /// Given a template argument that contains an unexpanded parameter pack, but
8363 /// which has already been substituted, attempt to determine the number of
8364 /// elements that will be produced once this argument is fully-expanded.
8365 ///
8366 /// This is intended for use when transforming 'sizeof...(Arg)' in order to
8367 /// avoid actually expanding the pack where possible.
8368 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
8369
8370 //===--------------------------------------------------------------------===//
8371 // C++ Template Argument Deduction (C++ [temp.deduct])
8372 //===--------------------------------------------------------------------===//
8373
8374 /// Adjust the type \p ArgFunctionType to match the calling convention,
8375 /// noreturn, and optionally the exception specification of \p FunctionType.
8376 /// Deduction often wants to ignore these properties when matching function
8377 /// types.
8378 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
8379 bool AdjustExceptionSpec = false);
8380
8381 /// Describes the result of template argument deduction.
8382 ///
8383 /// The TemplateDeductionResult enumeration describes the result of
8384 /// template argument deduction, as returned from
8385 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
8386 /// structure provides additional information about the results of
8387 /// template argument deduction, e.g., the deduced template argument
8388 /// list (if successful) or the specific template parameters or
8389 /// deduced arguments that were involved in the failure.
8390 enum TemplateDeductionResult {
8391 /// Template argument deduction was successful.
8392 TDK_Success = 0,
8393 /// The declaration was invalid; do nothing.
8394 TDK_Invalid,
8395 /// Template argument deduction exceeded the maximum template
8396 /// instantiation depth (which has already been diagnosed).
8397 TDK_InstantiationDepth,
8398 /// Template argument deduction did not deduce a value
8399 /// for every template parameter.
8400 TDK_Incomplete,
8401 /// Template argument deduction did not deduce a value for every
8402 /// expansion of an expanded template parameter pack.
8403 TDK_IncompletePack,
8404 /// Template argument deduction produced inconsistent
8405 /// deduced values for the given template parameter.
8406 TDK_Inconsistent,
8407 /// Template argument deduction failed due to inconsistent
8408 /// cv-qualifiers on a template parameter type that would
8409 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
8410 /// but were given a non-const "X".
8411 TDK_Underqualified,
8412 /// Substitution of the deduced template argument values
8413 /// resulted in an error.
8414 TDK_SubstitutionFailure,
8415 /// After substituting deduced template arguments, a dependent
8416 /// parameter type did not match the corresponding argument.
8417 TDK_DeducedMismatch,
8418 /// After substituting deduced template arguments, an element of
8419 /// a dependent parameter type did not match the corresponding element
8420 /// of the corresponding argument (when deducing from an initializer list).
8421 TDK_DeducedMismatchNested,
8422 /// A non-depnedent component of the parameter did not match the
8423 /// corresponding component of the argument.
8424 TDK_NonDeducedMismatch,
8425 /// When performing template argument deduction for a function
8426 /// template, there were too many call arguments.
8427 TDK_TooManyArguments,
8428 /// When performing template argument deduction for a function
8429 /// template, there were too few call arguments.
8430 TDK_TooFewArguments,
8431 /// The explicitly-specified template arguments were not valid
8432 /// template arguments for the given template.
8433 TDK_InvalidExplicitArguments,
8434 /// Checking non-dependent argument conversions failed.
8435 TDK_NonDependentConversionFailure,
8436 /// The deduced arguments did not satisfy the constraints associated
8437 /// with the template.
8438 TDK_ConstraintsNotSatisfied,
8439 /// Deduction failed; that's all we know.
8440 TDK_MiscellaneousDeductionFailure,
8441 /// CUDA Target attributes do not match.
8442 TDK_CUDATargetMismatch
8443 };
8444
8445 TemplateDeductionResult
8446 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
8447 const TemplateArgumentList &TemplateArgs,
8448 sema::TemplateDeductionInfo &Info);
8449
8450 TemplateDeductionResult
8451 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
8452 const TemplateArgumentList &TemplateArgs,
8453 sema::TemplateDeductionInfo &Info);
8454
8455 TemplateDeductionResult SubstituteExplicitTemplateArguments(
8456 FunctionTemplateDecl *FunctionTemplate,
8457 TemplateArgumentListInfo &ExplicitTemplateArgs,
8458 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8459 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
8460 sema::TemplateDeductionInfo &Info);
8461
8462 /// brief A function argument from which we performed template argument
8463 // deduction for a call.
8464 struct OriginalCallArg {
8465 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
8466 unsigned ArgIdx, QualType OriginalArgType)
8467 : OriginalParamType(OriginalParamType),
8468 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
8469 OriginalArgType(OriginalArgType) {}
8470
8471 QualType OriginalParamType;
8472 bool DecomposedParam;
8473 unsigned ArgIdx;
8474 QualType OriginalArgType;
8475 };
8476
8477 TemplateDeductionResult FinishTemplateArgumentDeduction(
8478 FunctionTemplateDecl *FunctionTemplate,
8479 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8480 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
8481 sema::TemplateDeductionInfo &Info,
8482 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
8483 bool PartialOverloading = false,
8484 llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
8485
8486 TemplateDeductionResult DeduceTemplateArguments(
8487 FunctionTemplateDecl *FunctionTemplate,
8488 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
8489 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
8490 bool PartialOverloading,
8491 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
8492
8493 TemplateDeductionResult
8494 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8495 TemplateArgumentListInfo *ExplicitTemplateArgs,
8496 QualType ArgFunctionType,
8497 FunctionDecl *&Specialization,
8498 sema::TemplateDeductionInfo &Info,
8499 bool IsAddressOfFunction = false);
8500
8501 TemplateDeductionResult
8502 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8503 QualType ToType,
8504 CXXConversionDecl *&Specialization,
8505 sema::TemplateDeductionInfo &Info);
8506
8507 TemplateDeductionResult
8508 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8509 TemplateArgumentListInfo *ExplicitTemplateArgs,
8510 FunctionDecl *&Specialization,
8511 sema::TemplateDeductionInfo &Info,
8512 bool IsAddressOfFunction = false);
8513
8514 /// Substitute Replacement for \p auto in \p TypeWithAuto
8515 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
8516 /// Substitute Replacement for auto in TypeWithAuto
8517 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8518 QualType Replacement);
8519 /// Completely replace the \c auto in \p TypeWithAuto by
8520 /// \p Replacement. This does not retain any \c auto type sugar.
8521 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
8522 TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8523 QualType Replacement);
8524
8525 /// Result type of DeduceAutoType.
8526 enum DeduceAutoResult {
8527 DAR_Succeeded,
8528 DAR_Failed,
8529 DAR_FailedAlreadyDiagnosed
8530 };
8531
8532 DeduceAutoResult
8533 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
8534 Optional<unsigned> DependentDeductionDepth = None,
8535 bool IgnoreConstraints = false);
8536 DeduceAutoResult
8537 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
8538 Optional<unsigned> DependentDeductionDepth = None,
8539 bool IgnoreConstraints = false);
8540 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
8541 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
8542 bool Diagnose = true);
8543
8544 /// Declare implicit deduction guides for a class template if we've
8545 /// not already done so.
8546 void DeclareImplicitDeductionGuides(TemplateDecl *Template,
8547 SourceLocation Loc);
8548
8549 QualType DeduceTemplateSpecializationFromInitializer(
8550 TypeSourceInfo *TInfo, const InitializedEntity &Entity,
8551 const InitializationKind &Kind, MultiExprArg Init);
8552
8553 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
8554 QualType Type, TypeSourceInfo *TSI,
8555 SourceRange Range, bool DirectInit,
8556 Expr *Init);
8557
8558 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
8559
8560 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
8561 SourceLocation ReturnLoc,
8562 Expr *&RetExpr, AutoType *AT);
8563
8564 FunctionTemplateDecl *getMoreSpecializedTemplate(
8565 FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,
8566 TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
8567 unsigned NumCallArguments2, bool Reversed = false);
8568 UnresolvedSetIterator
8569 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
8570 TemplateSpecCandidateSet &FailedCandidates,
8571 SourceLocation Loc,
8572 const PartialDiagnostic &NoneDiag,
8573 const PartialDiagnostic &AmbigDiag,
8574 const PartialDiagnostic &CandidateDiag,
8575 bool Complain = true, QualType TargetType = QualType());
8576
8577 ClassTemplatePartialSpecializationDecl *
8578 getMoreSpecializedPartialSpecialization(
8579 ClassTemplatePartialSpecializationDecl *PS1,
8580 ClassTemplatePartialSpecializationDecl *PS2,
8581 SourceLocation Loc);
8582
8583 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
8584 sema::TemplateDeductionInfo &Info);
8585
8586 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
8587 VarTemplatePartialSpecializationDecl *PS1,
8588 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
8589
8590 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
8591 sema::TemplateDeductionInfo &Info);
8592
8593 bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
8594 TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);
8595
8596 void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,
8597 unsigned Depth, llvm::SmallBitVector &Used);
8598
8599 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
8600 bool OnlyDeduced,
8601 unsigned Depth,
8602 llvm::SmallBitVector &Used);
8603 void MarkDeducedTemplateParameters(
8604 const FunctionTemplateDecl *FunctionTemplate,
8605 llvm::SmallBitVector &Deduced) {
8606 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
8607 }
8608 static void MarkDeducedTemplateParameters(ASTContext &Ctx,
8609 const FunctionTemplateDecl *FunctionTemplate,
8610 llvm::SmallBitVector &Deduced);
8611
8612 //===--------------------------------------------------------------------===//
8613 // C++ Template Instantiation
8614 //
8615
8616 MultiLevelTemplateArgumentList
8617 getTemplateInstantiationArgs(NamedDecl *D,
8618 const TemplateArgumentList *Innermost = nullptr,
8619 bool RelativeToPrimary = false,
8620 const FunctionDecl *Pattern = nullptr);
8621
8622 /// A context in which code is being synthesized (where a source location
8623 /// alone is not sufficient to identify the context). This covers template
8624 /// instantiation and various forms of implicitly-generated functions.
8625 struct CodeSynthesisContext {
8626 /// The kind of template instantiation we are performing
8627 enum SynthesisKind {
8628 /// We are instantiating a template declaration. The entity is
8629 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
8630 TemplateInstantiation,
8631
8632 /// We are instantiating a default argument for a template
8633 /// parameter. The Entity is the template parameter whose argument is
8634 /// being instantiated, the Template is the template, and the
8635 /// TemplateArgs/NumTemplateArguments provide the template arguments as
8636 /// specified.
8637 DefaultTemplateArgumentInstantiation,
8638
8639 /// We are instantiating a default argument for a function.
8640 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
8641 /// provides the template arguments as specified.
8642 DefaultFunctionArgumentInstantiation,
8643
8644 /// We are substituting explicit template arguments provided for
8645 /// a function template. The entity is a FunctionTemplateDecl.
8646 ExplicitTemplateArgumentSubstitution,
8647
8648 /// We are substituting template argument determined as part of
8649 /// template argument deduction for either a class template
8650 /// partial specialization or a function template. The
8651 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
8652 /// a TemplateDecl.
8653 DeducedTemplateArgumentSubstitution,
8654
8655 /// We are substituting prior template arguments into a new
8656 /// template parameter. The template parameter itself is either a
8657 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
8658 PriorTemplateArgumentSubstitution,
8659
8660 /// We are checking the validity of a default template argument that
8661 /// has been used when naming a template-id.
8662 DefaultTemplateArgumentChecking,
8663
8664 /// We are computing the exception specification for a defaulted special
8665 /// member function.
8666 ExceptionSpecEvaluation,
8667
8668 /// We are instantiating the exception specification for a function
8669 /// template which was deferred until it was needed.
8670 ExceptionSpecInstantiation,
8671
8672 /// We are instantiating a requirement of a requires expression.
8673 RequirementInstantiation,
8674
8675 /// We are checking the satisfaction of a nested requirement of a requires
8676 /// expression.
8677 NestedRequirementConstraintsCheck,
8678
8679 /// We are declaring an implicit special member function.
8680 DeclaringSpecialMember,
8681
8682 /// We are declaring an implicit 'operator==' for a defaulted
8683 /// 'operator<=>'.
8684 DeclaringImplicitEqualityComparison,
8685
8686 /// We are defining a synthesized function (such as a defaulted special
8687 /// member).
8688 DefiningSynthesizedFunction,
8689
8690 // We are checking the constraints associated with a constrained entity or
8691 // the constraint expression of a concept. This includes the checks that
8692 // atomic constraints have the type 'bool' and that they can be constant
8693 // evaluated.
8694 ConstraintsCheck,
8695
8696 // We are substituting template arguments into a constraint expression.
8697 ConstraintSubstitution,
8698
8699 // We are normalizing a constraint expression.
8700 ConstraintNormalization,
8701
8702 // We are substituting into the parameter mapping of an atomic constraint
8703 // during normalization.
8704 ParameterMappingSubstitution,
8705
8706 /// We are rewriting a comparison operator in terms of an operator<=>.
8707 RewritingOperatorAsSpaceship,
8708
8709 /// We are initializing a structured binding.
8710 InitializingStructuredBinding,
8711
8712 /// We are marking a class as __dllexport.
8713 MarkingClassDllexported,
8714
8715 /// Added for Template instantiation observation.
8716 /// Memoization means we are _not_ instantiating a template because
8717 /// it is already instantiated (but we entered a context where we
8718 /// would have had to if it was not already instantiated).
8719 Memoization
8720 } Kind;
8721
8722 /// Was the enclosing context a non-instantiation SFINAE context?
8723 bool SavedInNonInstantiationSFINAEContext;
8724
8725 /// The point of instantiation or synthesis within the source code.
8726 SourceLocation PointOfInstantiation;
8727
8728 /// The entity that is being synthesized.
8729 Decl *Entity;
8730
8731 /// The template (or partial specialization) in which we are
8732 /// performing the instantiation, for substitutions of prior template
8733 /// arguments.
8734 NamedDecl *Template;
8735
8736 /// The list of template arguments we are substituting, if they
8737 /// are not part of the entity.
8738 const TemplateArgument *TemplateArgs;
8739
8740 // FIXME: Wrap this union around more members, or perhaps store the
8741 // kind-specific members in the RAII object owning the context.
8742 union {
8743 /// The number of template arguments in TemplateArgs.
8744 unsigned NumTemplateArgs;
8745
8746 /// The special member being declared or defined.
8747 CXXSpecialMember SpecialMember;
8748 };
8749
8750 ArrayRef<TemplateArgument> template_arguments() const {
8751 assert(Kind != DeclaringSpecialMember)((void)0);
8752 return {TemplateArgs, NumTemplateArgs};
8753 }
8754
8755 /// The template deduction info object associated with the
8756 /// substitution or checking of explicit or deduced template arguments.
8757 sema::TemplateDeductionInfo *DeductionInfo;
8758
8759 /// The source range that covers the construct that cause
8760 /// the instantiation, e.g., the template-id that causes a class
8761 /// template instantiation.
8762 SourceRange InstantiationRange;
8763
8764 CodeSynthesisContext()
8765 : Kind(TemplateInstantiation),
8766 SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),
8767 Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0),
8768 DeductionInfo(nullptr) {}
8769
8770 /// Determines whether this template is an actual instantiation
8771 /// that should be counted toward the maximum instantiation depth.
8772 bool isInstantiationRecord() const;
8773 };
8774
8775 /// List of active code synthesis contexts.
8776 ///
8777 /// This vector is treated as a stack. As synthesis of one entity requires
8778 /// synthesis of another, additional contexts are pushed onto the stack.
8779 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts;
8780
8781 /// Specializations whose definitions are currently being instantiated.
8782 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations;
8783
8784 /// Non-dependent types used in templates that have already been instantiated
8785 /// by some template instantiation.
8786 llvm::DenseSet<QualType> InstantiatedNonDependentTypes;
8787
8788 /// Extra modules inspected when performing a lookup during a template
8789 /// instantiation. Computed lazily.
8790 SmallVector<Module*, 16> CodeSynthesisContextLookupModules;
8791
8792 /// Cache of additional modules that should be used for name lookup
8793 /// within the current template instantiation. Computed lazily; use
8794 /// getLookupModules() to get a complete set.
8795 llvm::DenseSet<Module*> LookupModulesCache;
8796
8797 /// Get the set of additional modules that should be checked during
8798 /// name lookup. A module and its imports become visible when instanting a
8799 /// template defined within it.
8800 llvm::DenseSet<Module*> &getLookupModules();
8801
8802 /// Map from the most recent declaration of a namespace to the most
8803 /// recent visible declaration of that namespace.
8804 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
8805
8806 /// Whether we are in a SFINAE context that is not associated with
8807 /// template instantiation.
8808 ///
8809 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
8810 /// of a template instantiation or template argument deduction.
8811 bool InNonInstantiationSFINAEContext;
8812
8813 /// The number of \p CodeSynthesisContexts that are not template
8814 /// instantiations and, therefore, should not be counted as part of the
8815 /// instantiation depth.
8816 ///
8817 /// When the instantiation depth reaches the user-configurable limit
8818 /// \p LangOptions::InstantiationDepth we will abort instantiation.
8819 // FIXME: Should we have a similar limit for other forms of synthesis?
8820 unsigned NonInstantiationEntries;
8821
8822 /// The depth of the context stack at the point when the most recent
8823 /// error or warning was produced.
8824 ///
8825 /// This value is used to suppress printing of redundant context stacks
8826 /// when there are multiple errors or warnings in the same instantiation.
8827 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
8828 unsigned LastEmittedCodeSynthesisContextDepth = 0;
8829
8830 /// The template instantiation callbacks to trace or track
8831 /// instantiations (objects can be chained).
8832 ///
8833 /// This callbacks is used to print, trace or track template
8834 /// instantiations as they are being constructed.
8835 std::vector<std::unique_ptr<TemplateInstantiationCallback>>
8836 TemplateInstCallbacks;
8837
8838 /// The current index into pack expansion arguments that will be
8839 /// used for substitution of parameter packs.
8840 ///
8841 /// The pack expansion index will be -1 to indicate that parameter packs
8842 /// should be instantiated as themselves. Otherwise, the index specifies
8843 /// which argument within the parameter pack will be used for substitution.
8844 int ArgumentPackSubstitutionIndex;
8845
8846 /// RAII object used to change the argument pack substitution index
8847 /// within a \c Sema object.
8848 ///
8849 /// See \c ArgumentPackSubstitutionIndex for more information.
8850 class ArgumentPackSubstitutionIndexRAII {
8851 Sema &Self;
8852 int OldSubstitutionIndex;
8853
8854 public:
8855 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
8856 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
8857 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
8858 }
8859
8860 ~ArgumentPackSubstitutionIndexRAII() {
8861 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
8862 }
8863 };
8864
8865 friend class ArgumentPackSubstitutionRAII;
8866
8867 /// For each declaration that involved template argument deduction, the
8868 /// set of diagnostics that were suppressed during that template argument
8869 /// deduction.
8870 ///
8871 /// FIXME: Serialize this structure to the AST file.
8872 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
8873 SuppressedDiagnosticsMap;
8874 SuppressedDiagnosticsMap SuppressedDiagnostics;
8875
8876 /// A stack object to be created when performing template
8877 /// instantiation.
8878 ///
8879 /// Construction of an object of type \c InstantiatingTemplate
8880 /// pushes the current instantiation onto the stack of active
8881 /// instantiations. If the size of this stack exceeds the maximum
8882 /// number of recursive template instantiations, construction
8883 /// produces an error and evaluates true.
8884 ///
8885 /// Destruction of this object will pop the named instantiation off
8886 /// the stack.
8887 struct InstantiatingTemplate {
8888 /// Note that we are instantiating a class template,
8889 /// function template, variable template, alias template,
8890 /// or a member thereof.
8891 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8892 Decl *Entity,
8893 SourceRange InstantiationRange = SourceRange());
8894
8895 struct ExceptionSpecification {};
8896 /// Note that we are instantiating an exception specification
8897 /// of a function template.
8898 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8899 FunctionDecl *Entity, ExceptionSpecification,
8900 SourceRange InstantiationRange = SourceRange());
8901
8902 /// Note that we are instantiating a default argument in a
8903 /// template-id.
8904 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8905 TemplateParameter Param, TemplateDecl *Template,
8906 ArrayRef<TemplateArgument> TemplateArgs,
8907 SourceRange InstantiationRange = SourceRange());
8908
8909 /// Note that we are substituting either explicitly-specified or
8910 /// deduced template arguments during function template argument deduction.
8911 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8912 FunctionTemplateDecl *FunctionTemplate,
8913 ArrayRef<TemplateArgument> TemplateArgs,
8914 CodeSynthesisContext::SynthesisKind Kind,
8915 sema::TemplateDeductionInfo &DeductionInfo,
8916 SourceRange InstantiationRange = SourceRange());
8917
8918 /// Note that we are instantiating as part of template
8919 /// argument deduction for a class template declaration.
8920 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8921 TemplateDecl *Template,
8922 ArrayRef<TemplateArgument> TemplateArgs,
8923 sema::TemplateDeductionInfo &DeductionInfo,
8924 SourceRange InstantiationRange = SourceRange());
8925
8926 /// Note that we are instantiating as part of template
8927 /// argument deduction for a class template partial
8928 /// specialization.
8929 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8930 ClassTemplatePartialSpecializationDecl *PartialSpec,
8931 ArrayRef<TemplateArgument> TemplateArgs,
8932 sema::TemplateDeductionInfo &DeductionInfo,
8933 SourceRange InstantiationRange = SourceRange());
8934
8935 /// Note that we are instantiating as part of template
8936 /// argument deduction for a variable template partial
8937 /// specialization.
8938 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8939 VarTemplatePartialSpecializationDecl *PartialSpec,
8940 ArrayRef<TemplateArgument> TemplateArgs,
8941 sema::TemplateDeductionInfo &DeductionInfo,
8942 SourceRange InstantiationRange = SourceRange());
8943
8944 /// Note that we are instantiating a default argument for a function
8945 /// parameter.
8946 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8947 ParmVarDecl *Param,
8948 ArrayRef<TemplateArgument> TemplateArgs,
8949 SourceRange InstantiationRange = SourceRange());
8950
8951 /// Note that we are substituting prior template arguments into a
8952 /// non-type parameter.
8953 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8954 NamedDecl *Template,
8955 NonTypeTemplateParmDecl *Param,
8956 ArrayRef<TemplateArgument> TemplateArgs,
8957 SourceRange InstantiationRange);
8958
8959 /// Note that we are substituting prior template arguments into a
8960 /// template template parameter.
8961 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8962 NamedDecl *Template,
8963 TemplateTemplateParmDecl *Param,
8964 ArrayRef<TemplateArgument> TemplateArgs,
8965 SourceRange InstantiationRange);
8966
8967 /// Note that we are checking the default template argument
8968 /// against the template parameter for a given template-id.
8969 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8970 TemplateDecl *Template,
8971 NamedDecl *Param,
8972 ArrayRef<TemplateArgument> TemplateArgs,
8973 SourceRange InstantiationRange);
8974
8975 struct ConstraintsCheck {};
8976 /// \brief Note that we are checking the constraints associated with some
8977 /// constrained entity (a concept declaration or a template with associated
8978 /// constraints).
8979 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8980 ConstraintsCheck, NamedDecl *Template,
8981 ArrayRef<TemplateArgument> TemplateArgs,
8982 SourceRange InstantiationRange);
8983
8984 struct ConstraintSubstitution {};
8985 /// \brief Note that we are checking a constraint expression associated
8986 /// with a template declaration or as part of the satisfaction check of a
8987 /// concept.
8988 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8989 ConstraintSubstitution, NamedDecl *Template,
8990 sema::TemplateDeductionInfo &DeductionInfo,
8991 SourceRange InstantiationRange);
8992
8993 struct ConstraintNormalization {};
8994 /// \brief Note that we are normalizing a constraint expression.
8995 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8996 ConstraintNormalization, NamedDecl *Template,
8997 SourceRange InstantiationRange);
8998
8999 struct ParameterMappingSubstitution {};
9000 /// \brief Note that we are subtituting into the parameter mapping of an
9001 /// atomic constraint during constraint normalization.
9002 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9003 ParameterMappingSubstitution, NamedDecl *Template,
9004 SourceRange InstantiationRange);
9005
9006 /// \brief Note that we are substituting template arguments into a part of
9007 /// a requirement of a requires expression.
9008 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9009 concepts::Requirement *Req,
9010 sema::TemplateDeductionInfo &DeductionInfo,
9011 SourceRange InstantiationRange = SourceRange());
9012
9013 /// \brief Note that we are checking the satisfaction of the constraint
9014 /// expression inside of a nested requirement.
9015 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9016 concepts::NestedRequirement *Req, ConstraintsCheck,
9017 SourceRange InstantiationRange = SourceRange());
9018
9019 /// Note that we have finished instantiating this template.
9020 void Clear();
9021
9022 ~InstantiatingTemplate() { Clear(); }
9023
9024 /// Determines whether we have exceeded the maximum
9025 /// recursive template instantiations.
9026 bool isInvalid() const { return Invalid; }
76
Returning zero, which participates in a condition later
9027
9028 /// Determine whether we are already instantiating this
9029 /// specialization in some surrounding active instantiation.
9030 bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
9031
9032 private:
9033 Sema &SemaRef;
9034 bool Invalid;
9035 bool AlreadyInstantiating;
9036 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
9037 SourceRange InstantiationRange);
9038
9039 InstantiatingTemplate(
9040 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
9041 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
9042 Decl *Entity, NamedDecl *Template = nullptr,
9043 ArrayRef<TemplateArgument> TemplateArgs = None,
9044 sema::TemplateDeductionInfo *DeductionInfo = nullptr);
9045
9046 InstantiatingTemplate(const InstantiatingTemplate&) = delete;
9047
9048 InstantiatingTemplate&
9049 operator=(const InstantiatingTemplate&) = delete;
9050 };
9051
9052 void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
9053 void popCodeSynthesisContext();
9054
9055 /// Determine whether we are currently performing template instantiation.
9056 bool inTemplateInstantiation() const {
9057 return CodeSynthesisContexts.size() > NonInstantiationEntries;
9058 }
9059
9060 void PrintContextStack() {
9061 if (!CodeSynthesisContexts.empty() &&
9062 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
9063 PrintInstantiationStack();
9064 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
9065 }
9066 if (PragmaAttributeCurrentTargetDecl)
9067 PrintPragmaAttributeInstantiationPoint();
9068 }
9069 void PrintInstantiationStack();
9070
9071 void PrintPragmaAttributeInstantiationPoint();
9072
9073 /// Determines whether we are currently in a context where
9074 /// template argument substitution failures are not considered
9075 /// errors.
9076 ///
9077 /// \returns An empty \c Optional if we're not in a SFINAE context.
9078 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest
9079 /// template-deduction context object, which can be used to capture
9080 /// diagnostics that will be suppressed.
9081 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
9082
9083 /// Determines whether we are currently in a context that
9084 /// is not evaluated as per C++ [expr] p5.
9085 bool isUnevaluatedContext() const {
9086 assert(!ExprEvalContexts.empty() &&((void)0)
9087 "Must be in an expression evaluation context")((void)0);
9088 return ExprEvalContexts.back().isUnevaluated();
9089 }
9090
9091 /// RAII class used to determine whether SFINAE has
9092 /// trapped any errors that occur during template argument
9093 /// deduction.
9094 class SFINAETrap {
9095 Sema &SemaRef;
9096 unsigned PrevSFINAEErrors;
9097 bool PrevInNonInstantiationSFINAEContext;
9098 bool PrevAccessCheckingSFINAE;
9099 bool PrevLastDiagnosticIgnored;
9100
9101 public:
9102 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
9103 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
9104 PrevInNonInstantiationSFINAEContext(
9105 SemaRef.InNonInstantiationSFINAEContext),
9106 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
9107 PrevLastDiagnosticIgnored(
9108 SemaRef.getDiagnostics().isLastDiagnosticIgnored())
9109 {
9110 if (!SemaRef.isSFINAEContext())
9111 SemaRef.InNonInstantiationSFINAEContext = true;
9112 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
9113 }
9114
9115 ~SFINAETrap() {
9116 SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
9117 SemaRef.InNonInstantiationSFINAEContext
9118 = PrevInNonInstantiationSFINAEContext;
9119 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
9120 SemaRef.getDiagnostics().setLastDiagnosticIgnored(
9121 PrevLastDiagnosticIgnored);
9122 }
9123
9124 /// Determine whether any SFINAE errors have been trapped.
9125 bool hasErrorOccurred() const {
9126 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
9127 }
9128 };
9129
9130 /// RAII class used to indicate that we are performing provisional
9131 /// semantic analysis to determine the validity of a construct, so
9132 /// typo-correction and diagnostics in the immediate context (not within
9133 /// implicitly-instantiated templates) should be suppressed.
9134 class TentativeAnalysisScope {
9135 Sema &SemaRef;
9136 // FIXME: Using a SFINAETrap for this is a hack.
9137 SFINAETrap Trap;
9138 bool PrevDisableTypoCorrection;
9139 public:
9140 explicit TentativeAnalysisScope(Sema &SemaRef)
9141 : SemaRef(SemaRef), Trap(SemaRef, true),
9142 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
9143 SemaRef.DisableTypoCorrection = true;
9144 }
9145 ~TentativeAnalysisScope() {
9146 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
9147 }
9148 };
9149
9150 /// The current instantiation scope used to store local
9151 /// variables.
9152 LocalInstantiationScope *CurrentInstantiationScope;
9153
9154 /// Tracks whether we are in a context where typo correction is
9155 /// disabled.
9156 bool DisableTypoCorrection;
9157
9158 /// The number of typos corrected by CorrectTypo.
9159 unsigned TyposCorrected;
9160
9161 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;
9162 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
9163
9164 /// A cache containing identifiers for which typo correction failed and
9165 /// their locations, so that repeated attempts to correct an identifier in a
9166 /// given location are ignored if typo correction already failed for it.
9167 IdentifierSourceLocations TypoCorrectionFailures;
9168
9169 /// Worker object for performing CFG-based warnings.
9170 sema::AnalysisBasedWarnings AnalysisWarnings;
9171 threadSafety::BeforeSet *ThreadSafetyDeclCache;
9172
9173 /// An entity for which implicit template instantiation is required.
9174 ///
9175 /// The source location associated with the declaration is the first place in
9176 /// the source code where the declaration was "used". It is not necessarily
9177 /// the point of instantiation (which will be either before or after the
9178 /// namespace-scope declaration that triggered this implicit instantiation),
9179 /// However, it is the location that diagnostics should generally refer to,
9180 /// because users will need to know what code triggered the instantiation.
9181 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
9182
9183 /// The queue of implicit template instantiations that are required
9184 /// but have not yet been performed.
9185 std::deque<PendingImplicitInstantiation> PendingInstantiations;
9186
9187 /// Queue of implicit template instantiations that cannot be performed
9188 /// eagerly.
9189 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations;
9190
9191 class GlobalEagerInstantiationScope {
9192 public:
9193 GlobalEagerInstantiationScope(Sema &S, bool Enabled)
9194 : S(S), Enabled(Enabled) {
9195 if (!Enabled) return;
9196
9197 SavedPendingInstantiations.swap(S.PendingInstantiations);
9198 SavedVTableUses.swap(S.VTableUses);
9199 }
9200
9201 void perform() {
9202 if (Enabled) {
9203 S.DefineUsedVTables();
9204 S.PerformPendingInstantiations();
9205 }
9206 }
9207
9208 ~GlobalEagerInstantiationScope() {
9209 if (!Enabled) return;
9210
9211 // Restore the set of pending vtables.
9212 assert(S.VTableUses.empty() &&((void)0)
9213 "VTableUses should be empty before it is discarded.")((void)0);
9214 S.VTableUses.swap(SavedVTableUses);
9215
9216 // Restore the set of pending implicit instantiations.
9217 if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) {
9218 assert(S.PendingInstantiations.empty() &&((void)0)
9219 "PendingInstantiations should be empty before it is discarded.")((void)0);
9220 S.PendingInstantiations.swap(SavedPendingInstantiations);
9221 } else {
9222 // Template instantiations in the PCH may be delayed until the TU.
9223 S.PendingInstantiations.swap(SavedPendingInstantiations);
9224 S.PendingInstantiations.insert(S.PendingInstantiations.end(),
9225 SavedPendingInstantiations.begin(),
9226 SavedPendingInstantiations.end());
9227 }
9228 }
9229
9230 private:
9231 Sema &S;
9232 SmallVector<VTableUse, 16> SavedVTableUses;
9233 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
9234 bool Enabled;
9235 };
9236
9237 /// The queue of implicit template instantiations that are required
9238 /// and must be performed within the current local scope.
9239 ///
9240 /// This queue is only used for member functions of local classes in
9241 /// templates, which must be instantiated in the same scope as their
9242 /// enclosing function, so that they can reference function-local
9243 /// types, static variables, enumerators, etc.
9244 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
9245
9246 class LocalEagerInstantiationScope {
9247 public:
9248 LocalEagerInstantiationScope(Sema &S) : S(S) {
9249 SavedPendingLocalImplicitInstantiations.swap(
9250 S.PendingLocalImplicitInstantiations);
9251 }
9252
9253 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }
9254
9255 ~LocalEagerInstantiationScope() {
9256 assert(S.PendingLocalImplicitInstantiations.empty() &&((void)0)
9257 "there shouldn't be any pending local implicit instantiations")((void)0);
9258 SavedPendingLocalImplicitInstantiations.swap(
9259 S.PendingLocalImplicitInstantiations);
9260 }
9261
9262 private:
9263 Sema &S;
9264 std::deque<PendingImplicitInstantiation>
9265 SavedPendingLocalImplicitInstantiations;
9266 };
9267
9268 /// A helper class for building up ExtParameterInfos.
9269 class ExtParameterInfoBuilder {
9270 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos;
9271 bool HasInteresting = false;
9272
9273 public:
9274 /// Set the ExtParameterInfo for the parameter at the given index,
9275 ///
9276 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
9277 assert(Infos.size() <= index)((void)0);
9278 Infos.resize(index);
9279 Infos.push_back(info);
9280
9281 if (!HasInteresting)
9282 HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
9283 }
9284
9285 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the
9286 /// ExtParameterInfo array we've built up.
9287 const FunctionProtoType::ExtParameterInfo *
9288 getPointerOrNull(unsigned numParams) {
9289 if (!HasInteresting) return nullptr;
9290 Infos.resize(numParams);
9291 return Infos.data();
9292 }
9293 };
9294
9295 void PerformPendingInstantiations(bool LocalOnly = false);
9296
9297 TypeSourceInfo *SubstType(TypeSourceInfo *T,
9298 const MultiLevelTemplateArgumentList &TemplateArgs,
9299 SourceLocation Loc, DeclarationName Entity,
9300 bool AllowDeducedTST = false);
9301
9302 QualType SubstType(QualType T,
9303 const MultiLevelTemplateArgumentList &TemplateArgs,
9304 SourceLocation Loc, DeclarationName Entity);
9305
9306 TypeSourceInfo *SubstType(TypeLoc TL,
9307 const MultiLevelTemplateArgumentList &TemplateArgs,
9308 SourceLocation Loc, DeclarationName Entity);
9309
9310 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
9311 const MultiLevelTemplateArgumentList &TemplateArgs,
9312 SourceLocation Loc,
9313 DeclarationName Entity,
9314 CXXRecordDecl *ThisContext,
9315 Qualifiers ThisTypeQuals);
9316 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
9317 const MultiLevelTemplateArgumentList &Args);
9318 bool SubstExceptionSpec(SourceLocation Loc,
9319 FunctionProtoType::ExceptionSpecInfo &ESI,
9320 SmallVectorImpl<QualType> &ExceptionStorage,
9321 const MultiLevelTemplateArgumentList &Args);
9322 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
9323 const MultiLevelTemplateArgumentList &TemplateArgs,
9324 int indexAdjustment,
9325 Optional<unsigned> NumExpansions,
9326 bool ExpectParameterPack);
9327 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
9328 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
9329 const MultiLevelTemplateArgumentList &TemplateArgs,
9330 SmallVectorImpl<QualType> &ParamTypes,
9331 SmallVectorImpl<ParmVarDecl *> *OutParams,
9332 ExtParameterInfoBuilder &ParamInfos);
9333 ExprResult SubstExpr(Expr *E,
9334 const MultiLevelTemplateArgumentList &TemplateArgs);
9335
9336 /// Substitute the given template arguments into a list of
9337 /// expressions, expanding pack expansions if required.
9338 ///
9339 /// \param Exprs The list of expressions to substitute into.
9340 ///
9341 /// \param IsCall Whether this is some form of call, in which case
9342 /// default arguments will be dropped.
9343 ///
9344 /// \param TemplateArgs The set of template arguments to substitute.
9345 ///
9346 /// \param Outputs Will receive all of the substituted arguments.
9347 ///
9348 /// \returns true if an error occurred, false otherwise.
9349 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
9350 const MultiLevelTemplateArgumentList &TemplateArgs,
9351 SmallVectorImpl<Expr *> &Outputs);
9352
9353 StmtResult SubstStmt(Stmt *S,
9354 const MultiLevelTemplateArgumentList &TemplateArgs);
9355
9356 TemplateParameterList *
9357 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
9358 const MultiLevelTemplateArgumentList &TemplateArgs);
9359
9360 bool
9361 SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
9362 const MultiLevelTemplateArgumentList &TemplateArgs,
9363 TemplateArgumentListInfo &Outputs);
9364
9365
9366 Decl *SubstDecl(Decl *D, DeclContext *Owner,
9367 const MultiLevelTemplateArgumentList &TemplateArgs);
9368
9369 /// Substitute the name and return type of a defaulted 'operator<=>' to form
9370 /// an implicit 'operator=='.
9371 FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
9372 FunctionDecl *Spaceship);
9373
9374 ExprResult SubstInitializer(Expr *E,
9375 const MultiLevelTemplateArgumentList &TemplateArgs,
9376 bool CXXDirectInit);
9377
9378 bool
9379 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
9380 CXXRecordDecl *Pattern,
9381 const MultiLevelTemplateArgumentList &TemplateArgs);
9382
9383 bool
9384 InstantiateClass(SourceLocation PointOfInstantiation,
9385 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
9386 const MultiLevelTemplateArgumentList &TemplateArgs,
9387 TemplateSpecializationKind TSK,
9388 bool Complain = true);
9389
9390 bool InstantiateEnum(SourceLocation PointOfInstantiation,
9391 EnumDecl *Instantiation, EnumDecl *Pattern,
9392 const MultiLevelTemplateArgumentList &TemplateArgs,
9393 TemplateSpecializationKind TSK);
9394
9395 bool InstantiateInClassInitializer(
9396 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
9397 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
9398
9399 struct LateInstantiatedAttribute {
9400 const Attr *TmplAttr;
9401 LocalInstantiationScope *Scope;
9402 Decl *NewDecl;
9403
9404 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,
9405 Decl *D)
9406 : TmplAttr(A), Scope(S), NewDecl(D)
9407 { }
9408 };
9409 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;
9410
9411 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
9412 const Decl *Pattern, Decl *Inst,
9413 LateInstantiatedAttrVec *LateAttrs = nullptr,
9414 LocalInstantiationScope *OuterMostScope = nullptr);
9415
9416 void
9417 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
9418 const Decl *Pattern, Decl *Inst,
9419 LateInstantiatedAttrVec *LateAttrs = nullptr,
9420 LocalInstantiationScope *OuterMostScope = nullptr);
9421
9422 void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);
9423
9424 bool usesPartialOrExplicitSpecialization(
9425 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
9426
9427 bool
9428 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
9429 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9430 TemplateSpecializationKind TSK,
9431 bool Complain = true);
9432
9433 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
9434 CXXRecordDecl *Instantiation,
9435 const MultiLevelTemplateArgumentList &TemplateArgs,
9436 TemplateSpecializationKind TSK);
9437
9438 void InstantiateClassTemplateSpecializationMembers(
9439 SourceLocation PointOfInstantiation,
9440 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9441 TemplateSpecializationKind TSK);
9442
9443 NestedNameSpecifierLoc
9444 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
9445 const MultiLevelTemplateArgumentList &TemplateArgs);
9446
9447 DeclarationNameInfo
9448 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
9449 const MultiLevelTemplateArgumentList &TemplateArgs);
9450 TemplateName
9451 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
9452 SourceLocation Loc,
9453 const MultiLevelTemplateArgumentList &TemplateArgs);
9454 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
9455 TemplateArgumentListInfo &Result,
9456 const MultiLevelTemplateArgumentList &TemplateArgs);
9457
9458 bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
9459 ParmVarDecl *Param);
9460 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
9461 FunctionDecl *Function);
9462 bool CheckInstantiatedFunctionTemplateConstraints(
9463 SourceLocation PointOfInstantiation, FunctionDecl *Decl,
9464 ArrayRef<TemplateArgument> TemplateArgs,
9465 ConstraintSatisfaction &Satisfaction);
9466 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
9467 const TemplateArgumentList *Args,
9468 SourceLocation Loc);
9469 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
9470 FunctionDecl *Function,
9471 bool Recursive = false,
9472 bool DefinitionRequired = false,
9473 bool AtEndOfTU = false);
9474 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
9475 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
9476 const TemplateArgumentList &TemplateArgList,
9477 const TemplateArgumentListInfo &TemplateArgsInfo,
9478 SmallVectorImpl<TemplateArgument> &Converted,
9479 SourceLocation PointOfInstantiation,
9480 LateInstantiatedAttrVec *LateAttrs = nullptr,
9481 LocalInstantiationScope *StartingScope = nullptr);
9482 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
9483 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
9484 const MultiLevelTemplateArgumentList &TemplateArgs);
9485 void
9486 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
9487 const MultiLevelTemplateArgumentList &TemplateArgs,
9488 LateInstantiatedAttrVec *LateAttrs,
9489 DeclContext *Owner,
9490 LocalInstantiationScope *StartingScope,
9491 bool InstantiatingVarTemplate = false,
9492 VarTemplateSpecializationDecl *PrevVTSD = nullptr);
9493
9494 void InstantiateVariableInitializer(
9495 VarDecl *Var, VarDecl *OldVar,
9496 const MultiLevelTemplateArgumentList &TemplateArgs);
9497 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
9498 VarDecl *Var, bool Recursive = false,
9499 bool DefinitionRequired = false,
9500 bool AtEndOfTU = false);
9501
9502 void InstantiateMemInitializers(CXXConstructorDecl *New,
9503 const CXXConstructorDecl *Tmpl,
9504 const MultiLevelTemplateArgumentList &TemplateArgs);
9505
9506 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
9507 const MultiLevelTemplateArgumentList &TemplateArgs,
9508 bool FindingInstantiatedContext = false);
9509 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
9510 const MultiLevelTemplateArgumentList &TemplateArgs);
9511
9512 // Objective-C declarations.
9513 enum ObjCContainerKind {
9514 OCK_None = -1,
9515 OCK_Interface = 0,
9516 OCK_Protocol,
9517 OCK_Category,
9518 OCK_ClassExtension,
9519 OCK_Implementation,
9520 OCK_CategoryImplementation
9521 };
9522 ObjCContainerKind getObjCContainerKind() const;
9523
9524 DeclResult actOnObjCTypeParam(Scope *S,
9525 ObjCTypeParamVariance variance,
9526 SourceLocation varianceLoc,
9527 unsigned index,
9528 IdentifierInfo *paramName,
9529 SourceLocation paramLoc,
9530 SourceLocation colonLoc,
9531 ParsedType typeBound);
9532
9533 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,
9534 ArrayRef<Decl *> typeParams,
9535 SourceLocation rAngleLoc);
9536 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);
9537
9538 Decl *ActOnStartClassInterface(
9539 Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9540 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9541 IdentifierInfo *SuperName, SourceLocation SuperLoc,
9542 ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,
9543 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9544 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9545 const ParsedAttributesView &AttrList);
9546
9547 void ActOnSuperClassOfClassInterface(Scope *S,
9548 SourceLocation AtInterfaceLoc,
9549 ObjCInterfaceDecl *IDecl,
9550 IdentifierInfo *ClassName,
9551 SourceLocation ClassLoc,
9552 IdentifierInfo *SuperName,
9553 SourceLocation SuperLoc,
9554 ArrayRef<ParsedType> SuperTypeArgs,
9555 SourceRange SuperTypeArgsRange);
9556
9557 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
9558 SmallVectorImpl<SourceLocation> &ProtocolLocs,
9559 IdentifierInfo *SuperName,
9560 SourceLocation SuperLoc);
9561
9562 Decl *ActOnCompatibilityAlias(
9563 SourceLocation AtCompatibilityAliasLoc,
9564 IdentifierInfo *AliasName, SourceLocation AliasLocation,
9565 IdentifierInfo *ClassName, SourceLocation ClassLocation);
9566
9567 bool CheckForwardProtocolDeclarationForCircularDependency(
9568 IdentifierInfo *PName,
9569 SourceLocation &PLoc, SourceLocation PrevLoc,
9570 const ObjCList<ObjCProtocolDecl> &PList);
9571
9572 Decl *ActOnStartProtocolInterface(
9573 SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,
9574 SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,
9575 unsigned NumProtoRefs, const SourceLocation *ProtoLocs,
9576 SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);
9577
9578 Decl *ActOnStartCategoryInterface(
9579 SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9580 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9581 IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
9582 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9583 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9584 const ParsedAttributesView &AttrList);
9585
9586 Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,
9587 IdentifierInfo *ClassName,
9588 SourceLocation ClassLoc,
9589 IdentifierInfo *SuperClassname,
9590 SourceLocation SuperClassLoc,
9591 const ParsedAttributesView &AttrList);
9592
9593 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
9594 IdentifierInfo *ClassName,
9595 SourceLocation ClassLoc,
9596 IdentifierInfo *CatName,
9597 SourceLocation CatLoc,
9598 const ParsedAttributesView &AttrList);
9599
9600 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
9601 ArrayRef<Decl *> Decls);
9602
9603 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
9604 IdentifierInfo **IdentList,
9605 SourceLocation *IdentLocs,
9606 ArrayRef<ObjCTypeParamList *> TypeParamLists,
9607 unsigned NumElts);
9608
9609 DeclGroupPtrTy
9610 ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
9611 ArrayRef<IdentifierLocPair> IdentList,
9612 const ParsedAttributesView &attrList);
9613
9614 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
9615 ArrayRef<IdentifierLocPair> ProtocolId,
9616 SmallVectorImpl<Decl *> &Protocols);
9617
9618 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
9619 SourceLocation ProtocolLoc,
9620 IdentifierInfo *TypeArgId,
9621 SourceLocation TypeArgLoc,
9622 bool SelectProtocolFirst = false);
9623
9624 /// Given a list of identifiers (and their locations), resolve the
9625 /// names to either Objective-C protocol qualifiers or type
9626 /// arguments, as appropriate.
9627 void actOnObjCTypeArgsOrProtocolQualifiers(
9628 Scope *S,
9629 ParsedType baseType,
9630 SourceLocation lAngleLoc,
9631 ArrayRef<IdentifierInfo *> identifiers,
9632 ArrayRef<SourceLocation> identifierLocs,
9633 SourceLocation rAngleLoc,
9634 SourceLocation &typeArgsLAngleLoc,
9635 SmallVectorImpl<ParsedType> &typeArgs,
9636 SourceLocation &typeArgsRAngleLoc,
9637 SourceLocation &protocolLAngleLoc,
9638 SmallVectorImpl<Decl *> &protocols,
9639 SourceLocation &protocolRAngleLoc,
9640 bool warnOnIncompleteProtocols);
9641
9642 /// Build a an Objective-C protocol-qualified 'id' type where no
9643 /// base type was specified.
9644 TypeResult actOnObjCProtocolQualifierType(
9645 SourceLocation lAngleLoc,
9646 ArrayRef<Decl *> protocols,
9647 ArrayRef<SourceLocation> protocolLocs,
9648 SourceLocation rAngleLoc);
9649
9650 /// Build a specialized and/or protocol-qualified Objective-C type.
9651 TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
9652 Scope *S,
9653 SourceLocation Loc,
9654 ParsedType BaseType,
9655 SourceLocation TypeArgsLAngleLoc,
9656 ArrayRef<ParsedType> TypeArgs,
9657 SourceLocation TypeArgsRAngleLoc,
9658 SourceLocation ProtocolLAngleLoc,
9659 ArrayRef<Decl *> Protocols,
9660 ArrayRef<SourceLocation> ProtocolLocs,
9661 SourceLocation ProtocolRAngleLoc);
9662
9663 /// Build an Objective-C type parameter type.
9664 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
9665 SourceLocation ProtocolLAngleLoc,
9666 ArrayRef<ObjCProtocolDecl *> Protocols,
9667 ArrayRef<SourceLocation> ProtocolLocs,
9668 SourceLocation ProtocolRAngleLoc,
9669 bool FailOnError = false);
9670
9671 /// Build an Objective-C object pointer type.
9672 QualType BuildObjCObjectType(QualType BaseType,
9673 SourceLocation Loc,
9674 SourceLocation TypeArgsLAngleLoc,
9675 ArrayRef<TypeSourceInfo *> TypeArgs,
9676 SourceLocation TypeArgsRAngleLoc,
9677 SourceLocation ProtocolLAngleLoc,
9678 ArrayRef<ObjCProtocolDecl *> Protocols,
9679 ArrayRef<SourceLocation> ProtocolLocs,
9680 SourceLocation ProtocolRAngleLoc,
9681 bool FailOnError = false);
9682
9683 /// Ensure attributes are consistent with type.
9684 /// \param [in, out] Attributes The attributes to check; they will
9685 /// be modified to be consistent with \p PropertyTy.
9686 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
9687 SourceLocation Loc,
9688 unsigned &Attributes,
9689 bool propertyInPrimaryClass);
9690
9691 /// Process the specified property declaration and create decls for the
9692 /// setters and getters as needed.
9693 /// \param property The property declaration being processed
9694 void ProcessPropertyDecl(ObjCPropertyDecl *property);
9695
9696
9697 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
9698 ObjCPropertyDecl *SuperProperty,
9699 const IdentifierInfo *Name,
9700 bool OverridingProtocolProperty);
9701
9702 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
9703 ObjCInterfaceDecl *ID);
9704
9705 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,
9706 ArrayRef<Decl *> allMethods = None,
9707 ArrayRef<DeclGroupPtrTy> allTUVars = None);
9708
9709 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
9710 SourceLocation LParenLoc,
9711 FieldDeclarator &FD, ObjCDeclSpec &ODS,
9712 Selector GetterSel, Selector SetterSel,
9713 tok::ObjCKeywordKind MethodImplKind,
9714 DeclContext *lexicalDC = nullptr);
9715
9716 Decl *ActOnPropertyImplDecl(Scope *S,
9717 SourceLocation AtLoc,
9718 SourceLocation PropertyLoc,
9719 bool ImplKind,
9720 IdentifierInfo *PropertyId,
9721 IdentifierInfo *PropertyIvar,
9722 SourceLocation PropertyIvarLoc,
9723 ObjCPropertyQueryKind QueryKind);
9724
9725 enum ObjCSpecialMethodKind {
9726 OSMK_None,
9727 OSMK_Alloc,
9728 OSMK_New,
9729 OSMK_Copy,
9730 OSMK_RetainingInit,
9731 OSMK_NonRetainingInit
9732 };
9733
9734 struct ObjCArgInfo {
9735 IdentifierInfo *Name;
9736 SourceLocation NameLoc;
9737 // The Type is null if no type was specified, and the DeclSpec is invalid
9738 // in this case.
9739 ParsedType Type;
9740 ObjCDeclSpec DeclSpec;
9741
9742 /// ArgAttrs - Attribute list for this argument.
9743 ParsedAttributesView ArgAttrs;
9744 };
9745
9746 Decl *ActOnMethodDeclaration(
9747 Scope *S,
9748 SourceLocation BeginLoc, // location of the + or -.
9749 SourceLocation EndLoc, // location of the ; or {.
9750 tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
9751 ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
9752 // optional arguments. The number of types/arguments is obtained
9753 // from the Sel.getNumArgs().
9754 ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,
9755 unsigned CNumArgs, // c-style args
9756 const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,
9757 bool isVariadic, bool MethodDefinition);
9758
9759 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
9760 const ObjCObjectPointerType *OPT,
9761 bool IsInstance);
9762 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
9763 bool IsInstance);
9764
9765 bool CheckARCMethodDecl(ObjCMethodDecl *method);
9766 bool inferObjCARCLifetime(ValueDecl *decl);
9767
9768 void deduceOpenCLAddressSpace(ValueDecl *decl);
9769
9770 ExprResult
9771 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
9772 Expr *BaseExpr,
9773 SourceLocation OpLoc,
9774 DeclarationName MemberName,
9775 SourceLocation MemberLoc,
9776 SourceLocation SuperLoc, QualType SuperType,
9777 bool Super);
9778
9779 ExprResult
9780 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
9781 IdentifierInfo &propertyName,
9782 SourceLocation receiverNameLoc,
9783 SourceLocation propertyNameLoc);
9784
9785 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
9786
9787 /// Describes the kind of message expression indicated by a message
9788 /// send that starts with an identifier.
9789 enum ObjCMessageKind {
9790 /// The message is sent to 'super'.
9791 ObjCSuperMessage,
9792 /// The message is an instance message.
9793 ObjCInstanceMessage,
9794 /// The message is a class message, and the identifier is a type
9795 /// name.
9796 ObjCClassMessage
9797 };
9798
9799 ObjCMessageKind getObjCMessageKind(Scope *S,
9800 IdentifierInfo *Name,
9801 SourceLocation NameLoc,
9802 bool IsSuper,
9803 bool HasTrailingDot,
9804 ParsedType &ReceiverType);
9805
9806 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
9807 Selector Sel,
9808 SourceLocation LBracLoc,
9809 ArrayRef<SourceLocation> SelectorLocs,
9810 SourceLocation RBracLoc,
9811 MultiExprArg Args);
9812
9813 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
9814 QualType ReceiverType,
9815 SourceLocation SuperLoc,
9816 Selector Sel,
9817 ObjCMethodDecl *Method,
9818 SourceLocation LBracLoc,
9819 ArrayRef<SourceLocation> SelectorLocs,
9820 SourceLocation RBracLoc,
9821 MultiExprArg Args,
9822 bool isImplicit = false);
9823
9824 ExprResult BuildClassMessageImplicit(QualType ReceiverType,
9825 bool isSuperReceiver,
9826 SourceLocation Loc,
9827 Selector Sel,
9828 ObjCMethodDecl *Method,
9829 MultiExprArg Args);
9830
9831 ExprResult ActOnClassMessage(Scope *S,
9832 ParsedType Receiver,
9833 Selector Sel,
9834 SourceLocation LBracLoc,
9835 ArrayRef<SourceLocation> SelectorLocs,
9836 SourceLocation RBracLoc,
9837 MultiExprArg Args);
9838
9839 ExprResult BuildInstanceMessage(Expr *Receiver,
9840 QualType ReceiverType,
9841 SourceLocation SuperLoc,
9842 Selector Sel,
9843 ObjCMethodDecl *Method,
9844 SourceLocation LBracLoc,
9845 ArrayRef<SourceLocation> SelectorLocs,
9846 SourceLocation RBracLoc,
9847 MultiExprArg Args,
9848 bool isImplicit = false);
9849
9850 ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
9851 QualType ReceiverType,
9852 SourceLocation Loc,
9853 Selector Sel,
9854 ObjCMethodDecl *Method,
9855 MultiExprArg Args);
9856
9857 ExprResult ActOnInstanceMessage(Scope *S,
9858 Expr *Receiver,
9859 Selector Sel,
9860 SourceLocation LBracLoc,
9861 ArrayRef<SourceLocation> SelectorLocs,
9862 SourceLocation RBracLoc,
9863 MultiExprArg Args);
9864
9865 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
9866 ObjCBridgeCastKind Kind,
9867 SourceLocation BridgeKeywordLoc,
9868 TypeSourceInfo *TSInfo,
9869 Expr *SubExpr);
9870
9871 ExprResult ActOnObjCBridgedCast(Scope *S,
9872 SourceLocation LParenLoc,
9873 ObjCBridgeCastKind Kind,
9874 SourceLocation BridgeKeywordLoc,
9875 ParsedType Type,
9876 SourceLocation RParenLoc,
9877 Expr *SubExpr);
9878
9879 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
9880
9881 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
9882
9883 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
9884 CastKind &Kind);
9885
9886 bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
9887 QualType DestType, QualType SrcType,
9888 ObjCInterfaceDecl *&RelatedClass,
9889 ObjCMethodDecl *&ClassMethod,
9890 ObjCMethodDecl *&InstanceMethod,
9891 TypedefNameDecl *&TDNDecl,
9892 bool CfToNs, bool Diagnose = true);
9893
9894 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
9895 QualType DestType, QualType SrcType,
9896 Expr *&SrcExpr, bool Diagnose = true);
9897
9898 bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,
9899 bool Diagnose = true);
9900
9901 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
9902
9903 /// Check whether the given new method is a valid override of the
9904 /// given overridden method, and set any properties that should be inherited.
9905 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
9906 const ObjCMethodDecl *Overridden);
9907
9908 /// Describes the compatibility of a result type with its method.
9909 enum ResultTypeCompatibilityKind {
9910 RTC_Compatible,
9911 RTC_Incompatible,
9912 RTC_Unknown
9913 };
9914
9915 void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,
9916 ObjCMethodDecl *overridden);
9917
9918 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
9919 ObjCInterfaceDecl *CurrentClass,
9920 ResultTypeCompatibilityKind RTC);
9921
9922 enum PragmaOptionsAlignKind {
9923 POAK_Native, // #pragma options align=native
9924 POAK_Natural, // #pragma options align=natural
9925 POAK_Packed, // #pragma options align=packed
9926 POAK_Power, // #pragma options align=power
9927 POAK_Mac68k, // #pragma options align=mac68k
9928 POAK_Reset // #pragma options align=reset
9929 };
9930
9931 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section
9932 void ActOnPragmaClangSection(SourceLocation PragmaLoc,
9933 PragmaClangSectionAction Action,
9934 PragmaClangSectionKind SecKind, StringRef SecName);
9935
9936 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
9937 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
9938 SourceLocation PragmaLoc);
9939
9940 /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
9941 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
9942 StringRef SlotLabel, Expr *Alignment);
9943
9944 enum class PragmaAlignPackDiagnoseKind {
9945 NonDefaultStateAtInclude,
9946 ChangedStateAtExit
9947 };
9948
9949 void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
9950 SourceLocation IncludeLoc);
9951 void DiagnoseUnterminatedPragmaAlignPack();
9952
9953 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off].
9954 void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
9955
9956 /// ActOnPragmaMSComment - Called on well formed
9957 /// \#pragma comment(kind, "arg").
9958 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
9959 StringRef Arg);
9960
9961 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
9962 /// pointers_to_members(representation method[, general purpose
9963 /// representation]).
9964 void ActOnPragmaMSPointersToMembers(
9965 LangOptions::PragmaMSPointersToMembersKind Kind,
9966 SourceLocation PragmaLoc);
9967
9968 /// Called on well formed \#pragma vtordisp().
9969 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
9970 SourceLocation PragmaLoc,
9971 MSVtorDispMode Value);
9972
9973 enum PragmaSectionKind {
9974 PSK_DataSeg,
9975 PSK_BSSSeg,
9976 PSK_ConstSeg,
9977 PSK_CodeSeg,
9978 };
9979
9980 bool UnifySection(StringRef SectionName, int SectionFlags,
9981 NamedDecl *TheDecl);
9982 bool UnifySection(StringRef SectionName,
9983 int SectionFlags,
9984 SourceLocation PragmaSectionLocation);
9985
9986 /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
9987 void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
9988 PragmaMsStackAction Action,
9989 llvm::StringRef StackSlotLabel,
9990 StringLiteral *SegmentName,
9991 llvm::StringRef PragmaName);
9992
9993 /// Called on well formed \#pragma section().
9994 void ActOnPragmaMSSection(SourceLocation PragmaLocation,
9995 int SectionFlags, StringLiteral *SegmentName);
9996
9997 /// Called on well-formed \#pragma init_seg().
9998 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
9999 StringLiteral *SegmentName);
10000
10001 /// Called on #pragma clang __debug dump II
10002 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
10003
10004 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
10005 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
10006 StringRef Value);
10007
10008 /// Are precise floating point semantics currently enabled?
10009 bool isPreciseFPEnabled() {
10010 return !CurFPFeatures.getAllowFPReassociate() &&
10011 !CurFPFeatures.getNoSignedZero() &&
10012 !CurFPFeatures.getAllowReciprocal() &&
10013 !CurFPFeatures.getAllowApproxFunc();
10014 }
10015
10016 /// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control
10017 void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,
10018 PragmaFloatControlKind Value);
10019
10020 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
10021 void ActOnPragmaUnused(const Token &Identifier,
10022 Scope *curScope,
10023 SourceLocation PragmaLoc);
10024
10025 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
10026 void ActOnPragmaVisibility(const IdentifierInfo* VisType,
10027 SourceLocation PragmaLoc);
10028
10029 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
10030 SourceLocation Loc);
10031 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
10032
10033 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
10034 void ActOnPragmaWeakID(IdentifierInfo* WeakName,
10035 SourceLocation PragmaLoc,
10036 SourceLocation WeakNameLoc);
10037
10038 /// ActOnPragmaRedefineExtname - Called on well formed
10039 /// \#pragma redefine_extname oldname newname.
10040 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
10041 IdentifierInfo* AliasName,
10042 SourceLocation PragmaLoc,
10043 SourceLocation WeakNameLoc,
10044 SourceLocation AliasNameLoc);
10045
10046 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
10047 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
10048 IdentifierInfo* AliasName,
10049 SourceLocation PragmaLoc,
10050 SourceLocation WeakNameLoc,
10051 SourceLocation AliasNameLoc);
10052
10053 /// ActOnPragmaFPContract - Called on well formed
10054 /// \#pragma {STDC,OPENCL} FP_CONTRACT and
10055 /// \#pragma clang fp contract
10056 void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);
10057
10058 /// Called on well formed
10059 /// \#pragma clang fp reassociate
10060 void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);
10061
10062 /// ActOnPragmaFenvAccess - Called on well formed
10063 /// \#pragma STDC FENV_ACCESS
10064 void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);
10065
10066 /// Called on well formed '\#pragma clang fp' that has option 'exceptions'.
10067 void ActOnPragmaFPExceptions(SourceLocation Loc,
10068 LangOptions::FPExceptionModeKind);
10069
10070 /// Called to set constant rounding mode for floating point operations.
10071 void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);
10072
10073 /// Called to set exception behavior for floating point operations.
10074 void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);
10075
10076 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
10077 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
10078 void AddAlignmentAttributesForRecord(RecordDecl *RD);
10079
10080 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
10081 void AddMsStructLayoutForRecord(RecordDecl *RD);
10082
10083 /// PushNamespaceVisibilityAttr - Note that we've entered a
10084 /// namespace with a visibility attribute.
10085 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
10086 SourceLocation Loc);
10087
10088 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
10089 /// add an appropriate visibility attribute.
10090 void AddPushedVisibilityAttribute(Decl *RD);
10091
10092 /// PopPragmaVisibility - Pop the top element of the visibility stack; used
10093 /// for '\#pragma GCC visibility' and visibility attributes on namespaces.
10094 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
10095
10096 /// FreeVisContext - Deallocate and null out VisContext.
10097 void FreeVisContext();
10098
10099 /// AddCFAuditedAttribute - Check whether we're currently within
10100 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
10101 /// the appropriate attribute.
10102 void AddCFAuditedAttribute(Decl *D);
10103
10104 void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,
10105 SourceLocation PragmaLoc,
10106 attr::ParsedSubjectMatchRuleSet Rules);
10107 void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
10108 const IdentifierInfo *Namespace);
10109
10110 /// Called on well-formed '\#pragma clang attribute pop'.
10111 void ActOnPragmaAttributePop(SourceLocation PragmaLoc,
10112 const IdentifierInfo *Namespace);
10113
10114 /// Adds the attributes that have been specified using the
10115 /// '\#pragma clang attribute push' directives to the given declaration.
10116 void AddPragmaAttributes(Scope *S, Decl *D);
10117
10118 void DiagnoseUnterminatedPragmaAttribute();
10119
10120 /// Called on well formed \#pragma clang optimize.
10121 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
10122
10123 /// Get the location for the currently active "\#pragma clang optimize
10124 /// off". If this location is invalid, then the state of the pragma is "on".
10125 SourceLocation getOptimizeOffPragmaLocation() const {
10126 return OptimizeOffPragmaLocation;
10127 }
10128
10129 /// Only called on function definitions; if there is a pragma in scope
10130 /// with the effect of a range-based optnone, consider marking the function
10131 /// with attribute optnone.
10132 void AddRangeBasedOptnone(FunctionDecl *FD);
10133
10134 /// Adds the 'optnone' attribute to the function declaration if there
10135 /// are no conflicts; Loc represents the location causing the 'optnone'
10136 /// attribute to be added (usually because of a pragma).
10137 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
10138
10139 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
10140 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10141 bool IsPackExpansion);
10142 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,
10143 bool IsPackExpansion);
10144
10145 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
10146 /// declaration.
10147 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10148 Expr *OE);
10149
10150 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
10151 /// declaration.
10152 void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
10153 Expr *ParamExpr);
10154
10155 /// AddAlignValueAttr - Adds an align_value attribute to a particular
10156 /// declaration.
10157 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
10158
10159 /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
10160 void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
10161 StringRef Annot, MutableArrayRef<Expr *> Args);
10162
10163 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
10164 /// declaration.
10165 void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
10166 Expr *MaxThreads, Expr *MinBlocks);
10167
10168 /// AddModeAttr - Adds a mode attribute to a particular declaration.
10169 void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,
10170 bool InInstantiation = false);
10171
10172 void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
10173 ParameterABI ABI);
10174
10175 enum class RetainOwnershipKind {NS, CF, OS};
10176 void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,
10177 RetainOwnershipKind K, bool IsTemplateInstantiation);
10178
10179 /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size
10180 /// attribute to a particular declaration.
10181 void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,
10182 Expr *Min, Expr *Max);
10183
10184 /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a
10185 /// particular declaration.
10186 void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,
10187 Expr *Min, Expr *Max);
10188
10189 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
10190
10191 //===--------------------------------------------------------------------===//
10192 // C++ Coroutines TS
10193 //
10194 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
10195 StringRef Keyword);
10196 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10197 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10198 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
10199
10200 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10201 bool IsImplicit = false);
10202 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10203 UnresolvedLookupExpr* Lookup);
10204 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
10205 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
10206 bool IsImplicit = false);
10207 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
10208 bool buildCoroutineParameterMoves(SourceLocation Loc);
10209 VarDecl *buildCoroutinePromise(SourceLocation Loc);
10210 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
10211 ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
10212 SourceLocation FuncLoc);
10213 /// Check that the expression co_await promise.final_suspend() shall not be
10214 /// potentially-throwing.
10215 bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
10216
10217 //===--------------------------------------------------------------------===//
10218 // OpenMP directives and clauses.
10219 //
10220private:
10221 void *VarDataSharingAttributesStack;
10222
10223 struct DeclareTargetContextInfo {
10224 struct MapInfo {
10225 OMPDeclareTargetDeclAttr::MapTypeTy MT;
10226 SourceLocation Loc;
10227 };
10228 /// Explicitly listed variables and functions in a 'to' or 'link' clause.
10229 llvm::DenseMap<NamedDecl *, MapInfo> ExplicitlyMapped;
10230
10231 /// The 'device_type' as parsed from the clause.
10232 OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any;
10233
10234 /// The directive kind, `begin declare target` or `declare target`.
10235 OpenMPDirectiveKind Kind;
10236
10237 /// The directive location.
10238 SourceLocation Loc;
10239
10240 DeclareTargetContextInfo(OpenMPDirectiveKind Kind, SourceLocation Loc)
10241 : Kind(Kind), Loc(Loc) {}
10242 };
10243
10244 /// Number of nested '#pragma omp declare target' directives.
10245 SmallVector<DeclareTargetContextInfo, 4> DeclareTargetNesting;
10246
10247 /// Initialization of data-sharing attributes stack.
10248 void InitDataSharingAttributesStack();
10249 void DestroyDataSharingAttributesStack();
10250 ExprResult
10251 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
10252 bool StrictlyPositive = true,
10253 bool SuppressExprDiags = false);
10254 /// Returns OpenMP nesting level for current directive.
10255 unsigned getOpenMPNestingLevel() const;
10256
10257 /// Adjusts the function scopes index for the target-based regions.
10258 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
10259 unsigned Level) const;
10260
10261 /// Returns the number of scopes associated with the construct on the given
10262 /// OpenMP level.
10263 int getNumberOfConstructScopes(unsigned Level) const;
10264
10265 /// Push new OpenMP function region for non-capturing function.
10266 void pushOpenMPFunctionRegion();
10267
10268 /// Pop OpenMP function region for non-capturing function.
10269 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
10270
10271 /// Analyzes and checks a loop nest for use by a loop transformation.
10272 ///
10273 /// \param Kind The loop transformation directive kind.
10274 /// \param NumLoops How many nested loops the directive is expecting.
10275 /// \param AStmt Associated statement of the transformation directive.
10276 /// \param LoopHelpers [out] The loop analysis result.
10277 /// \param Body [out] The body code nested in \p NumLoops loop.
10278 /// \param OriginalInits [out] Collection of statements and declarations that
10279 /// must have been executed/declared before entering the
10280 /// loop.
10281 ///
10282 /// \return Whether there was any error.
10283 bool checkTransformableLoopNest(
10284 OpenMPDirectiveKind Kind, Stmt *AStmt, int NumLoops,
10285 SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
10286 Stmt *&Body,
10287 SmallVectorImpl<SmallVector<llvm::PointerUnion<Stmt *, Decl *>, 0>>
10288 &OriginalInits);
10289
10290 /// Helper to keep information about the current `omp begin/end declare
10291 /// variant` nesting.
10292 struct OMPDeclareVariantScope {
10293 /// The associated OpenMP context selector.
10294 OMPTraitInfo *TI;
10295
10296 /// The associated OpenMP context selector mangling.
10297 std::string NameSuffix;
10298
10299 OMPDeclareVariantScope(OMPTraitInfo &TI);
10300 };
10301
10302 /// Return the OMPTraitInfo for the surrounding scope, if any.
10303 OMPTraitInfo *getOMPTraitInfoForSurroundingScope() {
10304 return OMPDeclareVariantScopes.empty() ? nullptr
10305 : OMPDeclareVariantScopes.back().TI;
10306 }
10307
10308 /// The current `omp begin/end declare variant` scopes.
10309 SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes;
10310
10311 /// The current `omp begin/end assumes` scopes.
10312 SmallVector<AssumptionAttr *, 4> OMPAssumeScoped;
10313
10314 /// All `omp assumes` we encountered so far.
10315 SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal;
10316
10317public:
10318 /// The declarator \p D defines a function in the scope \p S which is nested
10319 /// in an `omp begin/end declare variant` scope. In this method we create a
10320 /// declaration for \p D and rename \p D according to the OpenMP context
10321 /// selector of the surrounding scope. Return all base functions in \p Bases.
10322 void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(
10323 Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists,
10324 SmallVectorImpl<FunctionDecl *> &Bases);
10325
10326 /// Register \p D as specialization of all base functions in \p Bases in the
10327 /// current `omp begin/end declare variant` scope.
10328 void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(
10329 Decl *D, SmallVectorImpl<FunctionDecl *> &Bases);
10330
10331 /// Act on \p D, a function definition inside of an `omp [begin/end] assumes`.
10332 void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D);
10333
10334 /// Can we exit an OpenMP declare variant scope at the moment.
10335 bool isInOpenMPDeclareVariantScope() const {
10336 return !OMPDeclareVariantScopes.empty();
10337 }
10338
10339 /// Given the potential call expression \p Call, determine if there is a
10340 /// specialization via the OpenMP declare variant mechanism available. If
10341 /// there is, return the specialized call expression, otherwise return the
10342 /// original \p Call.
10343 ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope,
10344 SourceLocation LParenLoc, MultiExprArg ArgExprs,
10345 SourceLocation RParenLoc, Expr *ExecConfig);
10346
10347 /// Handle a `omp begin declare variant`.
10348 void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI);
10349
10350 /// Handle a `omp end declare variant`.
10351 void ActOnOpenMPEndDeclareVariant();
10352
10353 /// Checks if the variant/multiversion functions are compatible.
10354 bool areMultiversionVariantFunctionsCompatible(
10355 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
10356 const PartialDiagnostic &NoProtoDiagID,
10357 const PartialDiagnosticAt &NoteCausedDiagIDAt,
10358 const PartialDiagnosticAt &NoSupportDiagIDAt,
10359 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,
10360 bool ConstexprSupported, bool CLinkageMayDiffer);
10361
10362 /// Function tries to capture lambda's captured variables in the OpenMP region
10363 /// before the original lambda is captured.
10364 void tryCaptureOpenMPLambdas(ValueDecl *V);
10365
10366 /// Return true if the provided declaration \a VD should be captured by
10367 /// reference.
10368 /// \param Level Relative level of nested OpenMP construct for that the check
10369 /// is performed.
10370 /// \param OpenMPCaptureLevel Capture level within an OpenMP construct.
10371 bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,
10372 unsigned OpenMPCaptureLevel) const;
10373
10374 /// Check if the specified variable is used in one of the private
10375 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
10376 /// constructs.
10377 VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false,
10378 unsigned StopAt = 0);
10379 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
10380 ExprObjectKind OK, SourceLocation Loc);
10381
10382 /// If the current region is a loop-based region, mark the start of the loop
10383 /// construct.
10384 void startOpenMPLoop();
10385
10386 /// If the current region is a range loop-based region, mark the start of the
10387 /// loop construct.
10388 void startOpenMPCXXRangeFor();
10389
10390 /// Check if the specified variable is used in 'private' clause.
10391 /// \param Level Relative level of nested OpenMP construct for that the check
10392 /// is performed.
10393 OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,
10394 unsigned CapLevel) const;
10395
10396 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
10397 /// for \p FD based on DSA for the provided corresponding captured declaration
10398 /// \p D.
10399 void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level);
10400
10401 /// Check if the specified variable is captured by 'target' directive.
10402 /// \param Level Relative level of nested OpenMP construct for that the check
10403 /// is performed.
10404 bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
10405 unsigned CaptureLevel) const;
10406
10407 /// Check if the specified global variable must be captured by outer capture
10408 /// regions.
10409 /// \param Level Relative level of nested OpenMP construct for that
10410 /// the check is performed.
10411 bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,
10412 unsigned CaptureLevel) const;
10413
10414 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
10415 Expr *Op);
10416 /// Called on start of new data sharing attribute block.
10417 void StartOpenMPDSABlock(OpenMPDirectiveKind K,
10418 const DeclarationNameInfo &DirName, Scope *CurScope,
10419 SourceLocation Loc);
10420 /// Start analysis of clauses.
10421 void StartOpenMPClause(OpenMPClauseKind K);
10422 /// End analysis of clauses.
10423 void EndOpenMPClause();
10424 /// Called on end of data sharing attribute block.
10425 void EndOpenMPDSABlock(Stmt *CurDirective);
10426
10427 /// Check if the current region is an OpenMP loop region and if it is,
10428 /// mark loop control variable, used in \p Init for loop initialization, as
10429 /// private by default.
10430 /// \param Init First part of the for loop.
10431 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
10432
10433 // OpenMP directives and clauses.
10434 /// Called on correct id-expression from the '#pragma omp
10435 /// threadprivate'.
10436 ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,
10437 const DeclarationNameInfo &Id,
10438 OpenMPDirectiveKind Kind);
10439 /// Called on well-formed '#pragma omp threadprivate'.
10440 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
10441 SourceLocation Loc,
10442 ArrayRef<Expr *> VarList);
10443 /// Builds a new OpenMPThreadPrivateDecl and checks its correctness.
10444 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc,
10445 ArrayRef<Expr *> VarList);
10446 /// Called on well-formed '#pragma omp allocate'.
10447 DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc,
10448 ArrayRef<Expr *> VarList,
10449 ArrayRef<OMPClause *> Clauses,
10450 DeclContext *Owner = nullptr);
10451
10452 /// Called on well-formed '#pragma omp [begin] assume[s]'.
10453 void ActOnOpenMPAssumesDirective(SourceLocation Loc,
10454 OpenMPDirectiveKind DKind,
10455 ArrayRef<StringRef> Assumptions,
10456 bool SkippedClauses);
10457
10458 /// Check if there is an active global `omp begin assumes` directive.
10459 bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); }
10460
10461 /// Check if there is an active global `omp assumes` directive.
10462 bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); }
10463
10464 /// Called on well-formed '#pragma omp end assumes'.
10465 void ActOnOpenMPEndAssumesDirective();
10466
10467 /// Called on well-formed '#pragma omp requires'.
10468 DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc,
10469 ArrayRef<OMPClause *> ClauseList);
10470 /// Check restrictions on Requires directive
10471 OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc,
10472 ArrayRef<OMPClause *> Clauses);
10473 /// Check if the specified type is allowed to be used in 'omp declare
10474 /// reduction' construct.
10475 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10476 TypeResult ParsedType);
10477 /// Called on start of '#pragma omp declare reduction'.
10478 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
10479 Scope *S, DeclContext *DC, DeclarationName Name,
10480 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10481 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);
10482 /// Initialize declare reduction construct initializer.
10483 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);
10484 /// Finish current declare reduction construct initializer.
10485 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
10486 /// Initialize declare reduction construct initializer.
10487 /// \return omp_priv variable.
10488 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);
10489 /// Finish current declare reduction construct initializer.
10490 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
10491 VarDecl *OmpPrivParm);
10492 /// Called at the end of '#pragma omp declare reduction'.
10493 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
10494 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);
10495
10496 /// Check variable declaration in 'omp declare mapper' construct.
10497 TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);
10498 /// Check if the specified type is allowed to be used in 'omp declare
10499 /// mapper' construct.
10500 QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
10501 TypeResult ParsedType);
10502 /// Called on start of '#pragma omp declare mapper'.
10503 DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(
10504 Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,
10505 SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
10506 Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses,
10507 Decl *PrevDeclInScope = nullptr);
10508 /// Build the mapper variable of '#pragma omp declare mapper'.
10509 ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,
10510 QualType MapperType,
10511 SourceLocation StartLoc,
10512 DeclarationName VN);
10513 bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const;
10514 const ValueDecl *getOpenMPDeclareMapperVarName() const;
10515
10516 /// Called on the start of target region i.e. '#pragma omp declare target'.
10517 bool ActOnStartOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10518
10519 /// Called at the end of target region i.e. '#pragma omp end declare target'.
10520 const DeclareTargetContextInfo ActOnOpenMPEndDeclareTargetDirective();
10521
10522 /// Called once a target context is completed, that can be when a
10523 /// '#pragma omp end declare target' was encountered or when a
10524 /// '#pragma omp declare target' without declaration-definition-seq was
10525 /// encountered.
10526 void ActOnFinishedOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10527
10528 /// Searches for the provided declaration name for OpenMP declare target
10529 /// directive.
10530 NamedDecl *lookupOpenMPDeclareTargetName(Scope *CurScope,
10531 CXXScopeSpec &ScopeSpec,
10532 const DeclarationNameInfo &Id);
10533
10534 /// Called on correct id-expression from the '#pragma omp declare target'.
10535 void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc,
10536 OMPDeclareTargetDeclAttr::MapTypeTy MT,
10537 OMPDeclareTargetDeclAttr::DevTypeTy DT);
10538
10539 /// Check declaration inside target region.
10540 void
10541 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
10542 SourceLocation IdLoc = SourceLocation());
10543 /// Finishes analysis of the deferred functions calls that may be declared as
10544 /// host/nohost during device/host compilation.
10545 void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
10546 const FunctionDecl *Callee,
10547 SourceLocation Loc);
10548 /// Return true inside OpenMP declare target region.
10549 bool isInOpenMPDeclareTargetContext() const {
10550 return !DeclareTargetNesting.empty();
10551 }
10552 /// Return true inside OpenMP target region.
10553 bool isInOpenMPTargetExecutionDirective() const;
10554
10555 /// Return the number of captured regions created for an OpenMP directive.
10556 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
10557
10558 /// Initialization of captured region for OpenMP region.
10559 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
10560
10561 /// Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to
10562 /// an OpenMP loop directive.
10563 StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt);
10564
10565 /// End of OpenMP region.
10566 ///
10567 /// \param S Statement associated with the current OpenMP region.
10568 /// \param Clauses List of clauses for the current OpenMP region.
10569 ///
10570 /// \returns Statement for finished OpenMP region.
10571 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
10572 StmtResult ActOnOpenMPExecutableDirective(
10573 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
10574 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
10575 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
10576 /// Called on well-formed '\#pragma omp parallel' after parsing
10577 /// of the associated statement.
10578 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
10579 Stmt *AStmt,
10580 SourceLocation StartLoc,
10581 SourceLocation EndLoc);
10582 using VarsWithInheritedDSAType =
10583 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
10584 /// Called on well-formed '\#pragma omp simd' after parsing
10585 /// of the associated statement.
10586 StmtResult
10587 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10588 SourceLocation StartLoc, SourceLocation EndLoc,
10589 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10590 /// Called on well-formed '#pragma omp tile' after parsing of its clauses and
10591 /// the associated statement.
10592 StmtResult ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses,
10593 Stmt *AStmt, SourceLocation StartLoc,
10594 SourceLocation EndLoc);
10595 /// Called on well-formed '#pragma omp unroll' after parsing of its clauses
10596 /// and the associated statement.
10597 StmtResult ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses,
10598 Stmt *AStmt, SourceLocation StartLoc,
10599 SourceLocation EndLoc);
10600 /// Called on well-formed '\#pragma omp for' after parsing
10601 /// of the associated statement.
10602 StmtResult
10603 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10604 SourceLocation StartLoc, SourceLocation EndLoc,
10605 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10606 /// Called on well-formed '\#pragma omp for simd' after parsing
10607 /// of the associated statement.
10608 StmtResult
10609 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10610 SourceLocation StartLoc, SourceLocation EndLoc,
10611 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10612 /// Called on well-formed '\#pragma omp sections' after parsing
10613 /// of the associated statement.
10614 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
10615 Stmt *AStmt, SourceLocation StartLoc,
10616 SourceLocation EndLoc);
10617 /// Called on well-formed '\#pragma omp section' after parsing of the
10618 /// associated statement.
10619 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
10620 SourceLocation EndLoc);
10621 /// Called on well-formed '\#pragma omp single' after parsing of the
10622 /// associated statement.
10623 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
10624 Stmt *AStmt, SourceLocation StartLoc,
10625 SourceLocation EndLoc);
10626 /// Called on well-formed '\#pragma omp master' after parsing of the
10627 /// associated statement.
10628 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
10629 SourceLocation EndLoc);
10630 /// Called on well-formed '\#pragma omp critical' after parsing of the
10631 /// associated statement.
10632 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
10633 ArrayRef<OMPClause *> Clauses,
10634 Stmt *AStmt, SourceLocation StartLoc,
10635 SourceLocation EndLoc);
10636 /// Called on well-formed '\#pragma omp parallel for' after parsing
10637 /// of the associated statement.
10638 StmtResult ActOnOpenMPParallelForDirective(
10639 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10640 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10641 /// Called on well-formed '\#pragma omp parallel for simd' after
10642 /// parsing of the associated statement.
10643 StmtResult ActOnOpenMPParallelForSimdDirective(
10644 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10645 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10646 /// Called on well-formed '\#pragma omp parallel master' after
10647 /// parsing of the associated statement.
10648 StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses,
10649 Stmt *AStmt,
10650 SourceLocation StartLoc,
10651 SourceLocation EndLoc);
10652 /// Called on well-formed '\#pragma omp parallel sections' after
10653 /// parsing of the associated statement.
10654 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
10655 Stmt *AStmt,
10656 SourceLocation StartLoc,
10657 SourceLocation EndLoc);
10658 /// Called on well-formed '\#pragma omp task' after parsing of the
10659 /// associated statement.
10660 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
10661 Stmt *AStmt, SourceLocation StartLoc,
10662 SourceLocation EndLoc);
10663 /// Called on well-formed '\#pragma omp taskyield'.
10664 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
10665 SourceLocation EndLoc);
10666 /// Called on well-formed '\#pragma omp barrier'.
10667 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
10668 SourceLocation EndLoc);
10669 /// Called on well-formed '\#pragma omp taskwait'.
10670 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
10671 SourceLocation EndLoc);
10672 /// Called on well-formed '\#pragma omp taskgroup'.
10673 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
10674 Stmt *AStmt, SourceLocation StartLoc,
10675 SourceLocation EndLoc);
10676 /// Called on well-formed '\#pragma omp flush'.
10677 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
10678 SourceLocation StartLoc,
10679 SourceLocation EndLoc);
10680 /// Called on well-formed '\#pragma omp depobj'.
10681 StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses,
10682 SourceLocation StartLoc,
10683 SourceLocation EndLoc);
10684 /// Called on well-formed '\#pragma omp scan'.
10685 StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses,
10686 SourceLocation StartLoc,
10687 SourceLocation EndLoc);
10688 /// Called on well-formed '\#pragma omp ordered' after parsing of the
10689 /// associated statement.
10690 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
10691 Stmt *AStmt, SourceLocation StartLoc,
10692 SourceLocation EndLoc);
10693 /// Called on well-formed '\#pragma omp atomic' after parsing of the
10694 /// associated statement.
10695 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
10696 Stmt *AStmt, SourceLocation StartLoc,
10697 SourceLocation EndLoc);
10698 /// Called on well-formed '\#pragma omp target' after parsing of the
10699 /// associated statement.
10700 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
10701 Stmt *AStmt, SourceLocation StartLoc,
10702 SourceLocation EndLoc);
10703 /// Called on well-formed '\#pragma omp target data' after parsing of
10704 /// the associated statement.
10705 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
10706 Stmt *AStmt, SourceLocation StartLoc,
10707 SourceLocation EndLoc);
10708 /// Called on well-formed '\#pragma omp target enter data' after
10709 /// parsing of the associated statement.
10710 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
10711 SourceLocation StartLoc,
10712 SourceLocation EndLoc,
10713 Stmt *AStmt);
10714 /// Called on well-formed '\#pragma omp target exit data' after
10715 /// parsing of the associated statement.
10716 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
10717 SourceLocation StartLoc,
10718 SourceLocation EndLoc,
10719 Stmt *AStmt);
10720 /// Called on well-formed '\#pragma omp target parallel' after
10721 /// parsing of the associated statement.
10722 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
10723 Stmt *AStmt,
10724 SourceLocation StartLoc,
10725 SourceLocation EndLoc);
10726 /// Called on well-formed '\#pragma omp target parallel for' after
10727 /// parsing of the associated statement.
10728 StmtResult ActOnOpenMPTargetParallelForDirective(
10729 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10730 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10731 /// Called on well-formed '\#pragma omp teams' after parsing of the
10732 /// associated statement.
10733 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
10734 Stmt *AStmt, SourceLocation StartLoc,
10735 SourceLocation EndLoc);
10736 /// Called on well-formed '\#pragma omp cancellation point'.
10737 StmtResult
10738 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
10739 SourceLocation EndLoc,
10740 OpenMPDirectiveKind CancelRegion);
10741 /// Called on well-formed '\#pragma omp cancel'.
10742 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
10743 SourceLocation StartLoc,
10744 SourceLocation EndLoc,
10745 OpenMPDirectiveKind CancelRegion);
10746 /// Called on well-formed '\#pragma omp taskloop' after parsing of the
10747 /// associated statement.
10748 StmtResult
10749 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10750 SourceLocation StartLoc, SourceLocation EndLoc,
10751 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10752 /// Called on well-formed '\#pragma omp taskloop simd' after parsing of
10753 /// the associated statement.
10754 StmtResult ActOnOpenMPTaskLoopSimdDirective(
10755 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10756 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10757 /// Called on well-formed '\#pragma omp master taskloop' after parsing of the
10758 /// associated statement.
10759 StmtResult ActOnOpenMPMasterTaskLoopDirective(
10760 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10761 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10762 /// Called on well-formed '\#pragma omp master taskloop simd' after parsing of
10763 /// the associated statement.
10764 StmtResult ActOnOpenMPMasterTaskLoopSimdDirective(
10765 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10766 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10767 /// Called on well-formed '\#pragma omp parallel master taskloop' after
10768 /// parsing of the associated statement.
10769 StmtResult ActOnOpenMPParallelMasterTaskLoopDirective(
10770 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10771 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10772 /// Called on well-formed '\#pragma omp parallel master taskloop simd' after
10773 /// parsing of the associated statement.
10774 StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective(
10775 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10776 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10777 /// Called on well-formed '\#pragma omp distribute' after parsing
10778 /// of the associated statement.
10779 StmtResult
10780 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10781 SourceLocation StartLoc, SourceLocation EndLoc,
10782 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10783 /// Called on well-formed '\#pragma omp target update'.
10784 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
10785 SourceLocation StartLoc,
10786 SourceLocation EndLoc,
10787 Stmt *AStmt);
10788 /// Called on well-formed '\#pragma omp distribute parallel for' after
10789 /// parsing of the associated statement.
10790 StmtResult ActOnOpenMPDistributeParallelForDirective(
10791 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10792 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10793 /// Called on well-formed '\#pragma omp distribute parallel for simd'
10794 /// after parsing of the associated statement.
10795 StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
10796 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10797 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10798 /// Called on well-formed '\#pragma omp distribute simd' after
10799 /// parsing of the associated statement.
10800 StmtResult ActOnOpenMPDistributeSimdDirective(
10801 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10802 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10803 /// Called on well-formed '\#pragma omp target parallel for simd' after
10804 /// parsing of the associated statement.
10805 StmtResult ActOnOpenMPTargetParallelForSimdDirective(
10806 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10807 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10808 /// Called on well-formed '\#pragma omp target simd' after parsing of
10809 /// the associated statement.
10810 StmtResult
10811 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10812 SourceLocation StartLoc, SourceLocation EndLoc,
10813 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10814 /// Called on well-formed '\#pragma omp teams distribute' after parsing of
10815 /// the associated statement.
10816 StmtResult ActOnOpenMPTeamsDistributeDirective(
10817 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10818 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10819 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing
10820 /// of the associated statement.
10821 StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
10822 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10823 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10824 /// Called on well-formed '\#pragma omp teams distribute parallel for simd'
10825 /// after parsing of the associated statement.
10826 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
10827 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10828 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10829 /// Called on well-formed '\#pragma omp teams distribute parallel for'
10830 /// after parsing of the associated statement.
10831 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
10832 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10833 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10834 /// Called on well-formed '\#pragma omp target teams' after parsing of the
10835 /// associated statement.
10836 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
10837 Stmt *AStmt,
10838 SourceLocation StartLoc,
10839 SourceLocation EndLoc);
10840 /// Called on well-formed '\#pragma omp target teams distribute' after parsing
10841 /// of the associated statement.
10842 StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
10843 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10844 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10845 /// Called on well-formed '\#pragma omp target teams distribute parallel for'
10846 /// after parsing of the associated statement.
10847 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
10848 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10849 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10850 /// Called on well-formed '\#pragma omp target teams distribute parallel for
10851 /// simd' after parsing of the associated statement.
10852 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
10853 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10854 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10855 /// Called on well-formed '\#pragma omp target teams distribute simd' after
10856 /// parsing of the associated statement.
10857 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
10858 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10859 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10860 /// Called on well-formed '\#pragma omp interop'.
10861 StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,
10862 SourceLocation StartLoc,
10863 SourceLocation EndLoc);
10864 /// Called on well-formed '\#pragma omp dispatch' after parsing of the
10865 // /associated statement.
10866 StmtResult ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses,
10867 Stmt *AStmt, SourceLocation StartLoc,
10868 SourceLocation EndLoc);
10869 /// Called on well-formed '\#pragma omp masked' after parsing of the
10870 // /associated statement.
10871 StmtResult ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses,
10872 Stmt *AStmt, SourceLocation StartLoc,
10873 SourceLocation EndLoc);
10874
10875 /// Checks correctness of linear modifiers.
10876 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
10877 SourceLocation LinLoc);
10878 /// Checks that the specified declaration matches requirements for the linear
10879 /// decls.
10880 bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
10881 OpenMPLinearClauseKind LinKind, QualType Type,
10882 bool IsDeclareSimd = false);
10883
10884 /// Called on well-formed '\#pragma omp declare simd' after parsing of
10885 /// the associated method/function.
10886 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
10887 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
10888 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
10889 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
10890 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
10891
10892 /// Checks '\#pragma omp declare variant' variant function and original
10893 /// functions after parsing of the associated method/function.
10894 /// \param DG Function declaration to which declare variant directive is
10895 /// applied to.
10896 /// \param VariantRef Expression that references the variant function, which
10897 /// must be used instead of the original one, specified in \p DG.
10898 /// \param TI The trait info object representing the match clause.
10899 /// \returns None, if the function/variant function are not compatible with
10900 /// the pragma, pair of original function/variant ref expression otherwise.
10901 Optional<std::pair<FunctionDecl *, Expr *>>
10902 checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,
10903 OMPTraitInfo &TI, SourceRange SR);
10904
10905 /// Called on well-formed '\#pragma omp declare variant' after parsing of
10906 /// the associated method/function.
10907 /// \param FD Function declaration to which declare variant directive is
10908 /// applied to.
10909 /// \param VariantRef Expression that references the variant function, which
10910 /// must be used instead of the original one, specified in \p DG.
10911 /// \param TI The context traits associated with the function variant.
10912 void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef,
10913 OMPTraitInfo &TI, SourceRange SR);
10914
10915 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
10916 Expr *Expr,
10917 SourceLocation StartLoc,
10918 SourceLocation LParenLoc,
10919 SourceLocation EndLoc);
10920 /// Called on well-formed 'allocator' clause.
10921 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,
10922 SourceLocation StartLoc,
10923 SourceLocation LParenLoc,
10924 SourceLocation EndLoc);
10925 /// Called on well-formed 'if' clause.
10926 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
10927 Expr *Condition, SourceLocation StartLoc,
10928 SourceLocation LParenLoc,
10929 SourceLocation NameModifierLoc,
10930 SourceLocation ColonLoc,
10931 SourceLocation EndLoc);
10932 /// Called on well-formed 'final' clause.
10933 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
10934 SourceLocation LParenLoc,
10935 SourceLocation EndLoc);
10936 /// Called on well-formed 'num_threads' clause.
10937 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
10938 SourceLocation StartLoc,
10939 SourceLocation LParenLoc,
10940 SourceLocation EndLoc);
10941 /// Called on well-formed 'safelen' clause.
10942 OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
10943 SourceLocation StartLoc,
10944 SourceLocation LParenLoc,
10945 SourceLocation EndLoc);
10946 /// Called on well-formed 'simdlen' clause.
10947 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
10948 SourceLocation LParenLoc,
10949 SourceLocation EndLoc);
10950 /// Called on well-form 'sizes' clause.
10951 OMPClause *ActOnOpenMPSizesClause(ArrayRef<Expr *> SizeExprs,
10952 SourceLocation StartLoc,
10953 SourceLocation LParenLoc,
10954 SourceLocation EndLoc);
10955 /// Called on well-form 'full' clauses.
10956 OMPClause *ActOnOpenMPFullClause(SourceLocation StartLoc,
10957 SourceLocation EndLoc);
10958 /// Called on well-form 'partial' clauses.
10959 OMPClause *ActOnOpenMPPartialClause(Expr *FactorExpr, SourceLocation StartLoc,
10960 SourceLocation LParenLoc,
10961 SourceLocation EndLoc);
10962 /// Called on well-formed 'collapse' clause.
10963 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
10964 SourceLocation StartLoc,
10965 SourceLocation LParenLoc,
10966 SourceLocation EndLoc);
10967 /// Called on well-formed 'ordered' clause.
10968 OMPClause *
10969 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
10970 SourceLocation LParenLoc = SourceLocation(),
10971 Expr *NumForLoops = nullptr);
10972 /// Called on well-formed 'grainsize' clause.
10973 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
10974 SourceLocation LParenLoc,
10975 SourceLocation EndLoc);
10976 /// Called on well-formed 'num_tasks' clause.
10977 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
10978 SourceLocation LParenLoc,
10979 SourceLocation EndLoc);
10980 /// Called on well-formed 'hint' clause.
10981 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
10982 SourceLocation LParenLoc,
10983 SourceLocation EndLoc);
10984 /// Called on well-formed 'detach' clause.
10985 OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc,
10986 SourceLocation LParenLoc,
10987 SourceLocation EndLoc);
10988
10989 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
10990 unsigned Argument,
10991 SourceLocation ArgumentLoc,
10992 SourceLocation StartLoc,
10993 SourceLocation LParenLoc,
10994 SourceLocation EndLoc);
10995 /// Called on well-formed 'default' clause.
10996 OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
10997 SourceLocation KindLoc,
10998 SourceLocation StartLoc,
10999 SourceLocation LParenLoc,
11000 SourceLocation EndLoc);
11001 /// Called on well-formed 'proc_bind' clause.
11002 OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,
11003 SourceLocation KindLoc,
11004 SourceLocation StartLoc,
11005 SourceLocation LParenLoc,
11006 SourceLocation EndLoc);
11007 /// Called on well-formed 'order' clause.
11008 OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind,
11009 SourceLocation KindLoc,
11010 SourceLocation StartLoc,
11011 SourceLocation LParenLoc,
11012 SourceLocation EndLoc);
11013 /// Called on well-formed 'update' clause.
11014 OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,
11015 SourceLocation KindLoc,
11016 SourceLocation StartLoc,
11017 SourceLocation LParenLoc,
11018 SourceLocation EndLoc);
11019
11020 OMPClause *ActOnOpenMPSingleExprWithArgClause(
11021 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
11022 SourceLocation StartLoc, SourceLocation LParenLoc,
11023 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
11024 SourceLocation EndLoc);
11025 /// Called on well-formed 'schedule' clause.
11026 OMPClause *ActOnOpenMPScheduleClause(
11027 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
11028 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11029 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
11030 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
11031
11032 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
11033 SourceLocation EndLoc);
11034 /// Called on well-formed 'nowait' clause.
11035 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
11036 SourceLocation EndLoc);
11037 /// Called on well-formed 'untied' clause.
11038 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
11039 SourceLocation EndLoc);
11040 /// Called on well-formed 'mergeable' clause.
11041 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
11042 SourceLocation EndLoc);
11043 /// Called on well-formed 'read' clause.
11044 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
11045 SourceLocation EndLoc);
11046 /// Called on well-formed 'write' clause.
11047 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
11048 SourceLocation EndLoc);
11049 /// Called on well-formed 'update' clause.
11050 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
11051 SourceLocation EndLoc);
11052 /// Called on well-formed 'capture' clause.
11053 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
11054 SourceLocation EndLoc);
11055 /// Called on well-formed 'seq_cst' clause.
11056 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
11057 SourceLocation EndLoc);
11058 /// Called on well-formed 'acq_rel' clause.
11059 OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
11060 SourceLocation EndLoc);
11061 /// Called on well-formed 'acquire' clause.
11062 OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,
11063 SourceLocation EndLoc);
11064 /// Called on well-formed 'release' clause.
11065 OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc,
11066 SourceLocation EndLoc);
11067 /// Called on well-formed 'relaxed' clause.
11068 OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc,
11069 SourceLocation EndLoc);
11070
11071 /// Called on well-formed 'init' clause.
11072 OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
11073 bool IsTarget, bool IsTargetSync,
11074 SourceLocation StartLoc,
11075 SourceLocation LParenLoc,
11076 SourceLocation VarLoc,
11077 SourceLocation EndLoc);
11078
11079 /// Called on well-formed 'use' clause.
11080 OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
11081 SourceLocation LParenLoc,
11082 SourceLocation VarLoc, SourceLocation EndLoc);
11083
11084 /// Called on well-formed 'destroy' clause.
11085 OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
11086 SourceLocation LParenLoc,
11087 SourceLocation VarLoc,
11088 SourceLocation EndLoc);
11089 /// Called on well-formed 'novariants' clause.
11090 OMPClause *ActOnOpenMPNovariantsClause(Expr *Condition,
11091 SourceLocation StartLoc,
11092 SourceLocation LParenLoc,
11093 SourceLocation EndLoc);
11094 /// Called on well-formed 'nocontext' clause.
11095 OMPClause *ActOnOpenMPNocontextClause(Expr *Condition,
11096 SourceLocation StartLoc,
11097 SourceLocation LParenLoc,
11098 SourceLocation EndLoc);
11099 /// Called on well-formed 'filter' clause.
11100 OMPClause *ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
11101 SourceLocation LParenLoc,
11102 SourceLocation EndLoc);
11103 /// Called on well-formed 'threads' clause.
11104 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
11105 SourceLocation EndLoc);
11106 /// Called on well-formed 'simd' clause.
11107 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
11108 SourceLocation EndLoc);
11109 /// Called on well-formed 'nogroup' clause.
11110 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
11111 SourceLocation EndLoc);
11112 /// Called on well-formed 'unified_address' clause.
11113 OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc,
11114 SourceLocation EndLoc);
11115
11116 /// Called on well-formed 'unified_address' clause.
11117 OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc,
11118 SourceLocation EndLoc);
11119
11120 /// Called on well-formed 'reverse_offload' clause.
11121 OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,
11122 SourceLocation EndLoc);
11123
11124 /// Called on well-formed 'dynamic_allocators' clause.
11125 OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
11126 SourceLocation EndLoc);
11127
11128 /// Called on well-formed 'atomic_default_mem_order' clause.
11129 OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(
11130 OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,
11131 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11132
11133 OMPClause *ActOnOpenMPVarListClause(
11134 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr,
11135 const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
11136 CXXScopeSpec &ReductionOrMapperIdScopeSpec,
11137 DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
11138 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11139 ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
11140 SourceLocation ExtraModifierLoc,
11141 ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11142 ArrayRef<SourceLocation> MotionModifiersLoc);
11143 /// Called on well-formed 'inclusive' clause.
11144 OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,
11145 SourceLocation StartLoc,
11146 SourceLocation LParenLoc,
11147 SourceLocation EndLoc);
11148 /// Called on well-formed 'exclusive' clause.
11149 OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList,
11150 SourceLocation StartLoc,
11151 SourceLocation LParenLoc,
11152 SourceLocation EndLoc);
11153 /// Called on well-formed 'allocate' clause.
11154 OMPClause *
11155 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,
11156 SourceLocation StartLoc, SourceLocation ColonLoc,
11157 SourceLocation LParenLoc, SourceLocation EndLoc);
11158 /// Called on well-formed 'private' clause.
11159 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
11160 SourceLocation StartLoc,
11161 SourceLocation LParenLoc,
11162 SourceLocation EndLoc);
11163 /// Called on well-formed 'firstprivate' clause.
11164 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
11165 SourceLocation StartLoc,
11166 SourceLocation LParenLoc,
11167 SourceLocation EndLoc);
11168 /// Called on well-formed 'lastprivate' clause.
11169 OMPClause *ActOnOpenMPLastprivateClause(
11170 ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind,
11171 SourceLocation LPKindLoc, SourceLocation ColonLoc,
11172 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11173 /// Called on well-formed 'shared' clause.
11174 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
11175 SourceLocation StartLoc,
11176 SourceLocation LParenLoc,
11177 SourceLocation EndLoc);
11178 /// Called on well-formed 'reduction' clause.
11179 OMPClause *ActOnOpenMPReductionClause(
11180 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
11181 SourceLocation StartLoc, SourceLocation LParenLoc,
11182 SourceLocation ModifierLoc, SourceLocation ColonLoc,
11183 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
11184 const DeclarationNameInfo &ReductionId,
11185 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11186 /// Called on well-formed 'task_reduction' clause.
11187 OMPClause *ActOnOpenMPTaskReductionClause(
11188 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11189 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11190 CXXScopeSpec &ReductionIdScopeSpec,
11191 const DeclarationNameInfo &ReductionId,
11192 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11193 /// Called on well-formed 'in_reduction' clause.
11194 OMPClause *ActOnOpenMPInReductionClause(
11195 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11196 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11197 CXXScopeSpec &ReductionIdScopeSpec,
11198 const DeclarationNameInfo &ReductionId,
11199 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11200 /// Called on well-formed 'linear' clause.
11201 OMPClause *
11202 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
11203 SourceLocation StartLoc, SourceLocation LParenLoc,
11204 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
11205 SourceLocation ColonLoc, SourceLocation EndLoc);
11206 /// Called on well-formed 'aligned' clause.
11207 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
11208 Expr *Alignment,
11209 SourceLocation StartLoc,
11210 SourceLocation LParenLoc,
11211 SourceLocation ColonLoc,
11212 SourceLocation EndLoc);
11213 /// Called on well-formed 'copyin' clause.
11214 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
11215 SourceLocation StartLoc,
11216 SourceLocation LParenLoc,
11217 SourceLocation EndLoc);
11218 /// Called on well-formed 'copyprivate' clause.
11219 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
11220 SourceLocation StartLoc,
11221 SourceLocation LParenLoc,
11222 SourceLocation EndLoc);
11223 /// Called on well-formed 'flush' pseudo clause.
11224 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
11225 SourceLocation StartLoc,
11226 SourceLocation LParenLoc,
11227 SourceLocation EndLoc);
11228 /// Called on well-formed 'depobj' pseudo clause.
11229 OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
11230 SourceLocation LParenLoc,
11231 SourceLocation EndLoc);
11232 /// Called on well-formed 'depend' clause.
11233 OMPClause *
11234 ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
11235 SourceLocation DepLoc, SourceLocation ColonLoc,
11236 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11237 SourceLocation LParenLoc, SourceLocation EndLoc);
11238 /// Called on well-formed 'device' clause.
11239 OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
11240 Expr *Device, SourceLocation StartLoc,
11241 SourceLocation LParenLoc,
11242 SourceLocation ModifierLoc,
11243 SourceLocation EndLoc);
11244 /// Called on well-formed 'map' clause.
11245 OMPClause *
11246 ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11247 ArrayRef<SourceLocation> MapTypeModifiersLoc,
11248 CXXScopeSpec &MapperIdScopeSpec,
11249 DeclarationNameInfo &MapperId,
11250 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11251 SourceLocation MapLoc, SourceLocation ColonLoc,
11252 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11253 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11254 /// Called on well-formed 'num_teams' clause.
11255 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
11256 SourceLocation LParenLoc,
11257 SourceLocation EndLoc);
11258 /// Called on well-formed 'thread_limit' clause.
11259 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11260 SourceLocation StartLoc,
11261 SourceLocation LParenLoc,
11262 SourceLocation EndLoc);
11263 /// Called on well-formed 'priority' clause.
11264 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
11265 SourceLocation LParenLoc,
11266 SourceLocation EndLoc);
11267 /// Called on well-formed 'dist_schedule' clause.
11268 OMPClause *ActOnOpenMPDistScheduleClause(
11269 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
11270 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
11271 SourceLocation CommaLoc, SourceLocation EndLoc);
11272 /// Called on well-formed 'defaultmap' clause.
11273 OMPClause *ActOnOpenMPDefaultmapClause(
11274 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11275 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11276 SourceLocation KindLoc, SourceLocation EndLoc);
11277 /// Called on well-formed 'to' clause.
11278 OMPClause *
11279 ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11280 ArrayRef<SourceLocation> MotionModifiersLoc,
11281 CXXScopeSpec &MapperIdScopeSpec,
11282 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11283 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11284 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11285 /// Called on well-formed 'from' clause.
11286 OMPClause *
11287 ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11288 ArrayRef<SourceLocation> MotionModifiersLoc,
11289 CXXScopeSpec &MapperIdScopeSpec,
11290 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11291 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11292 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11293 /// Called on well-formed 'use_device_ptr' clause.
11294 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11295 const OMPVarListLocTy &Locs);
11296 /// Called on well-formed 'use_device_addr' clause.
11297 OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
11298 const OMPVarListLocTy &Locs);
11299 /// Called on well-formed 'is_device_ptr' clause.
11300 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11301 const OMPVarListLocTy &Locs);
11302 /// Called on well-formed 'nontemporal' clause.
11303 OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList,
11304 SourceLocation StartLoc,
11305 SourceLocation LParenLoc,
11306 SourceLocation EndLoc);
11307
11308 /// Data for list of allocators.
11309 struct UsesAllocatorsData {
11310 /// Allocator.
11311 Expr *Allocator = nullptr;
11312 /// Allocator traits.
11313 Expr *AllocatorTraits = nullptr;
11314 /// Locations of '(' and ')' symbols.
11315 SourceLocation LParenLoc, RParenLoc;
11316 };
11317 /// Called on well-formed 'uses_allocators' clause.
11318 OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc,
11319 SourceLocation LParenLoc,
11320 SourceLocation EndLoc,
11321 ArrayRef<UsesAllocatorsData> Data);
11322 /// Called on well-formed 'affinity' clause.
11323 OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc,
11324 SourceLocation LParenLoc,
11325 SourceLocation ColonLoc,
11326 SourceLocation EndLoc, Expr *Modifier,
11327 ArrayRef<Expr *> Locators);
11328
11329 /// The kind of conversion being performed.
11330 enum CheckedConversionKind {
11331 /// An implicit conversion.
11332 CCK_ImplicitConversion,
11333 /// A C-style cast.
11334 CCK_CStyleCast,
11335 /// A functional-style cast.
11336 CCK_FunctionalCast,
11337 /// A cast other than a C-style cast.
11338 CCK_OtherCast,
11339 /// A conversion for an operand of a builtin overloaded operator.
11340 CCK_ForBuiltinOverloadedOp
11341 };
11342
11343 static bool isCast(CheckedConversionKind CCK) {
11344 return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast ||
11345 CCK == CCK_OtherCast;
11346 }
11347
11348 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
11349 /// cast. If there is already an implicit cast, merge into the existing one.
11350 /// If isLvalue, the result of the cast is an lvalue.
11351 ExprResult
11352 ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
11353 ExprValueKind VK = VK_PRValue,
11354 const CXXCastPath *BasePath = nullptr,
11355 CheckedConversionKind CCK = CCK_ImplicitConversion);
11356
11357 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
11358 /// to the conversion from scalar type ScalarTy to the Boolean type.
11359 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
11360
11361 /// IgnoredValueConversions - Given that an expression's result is
11362 /// syntactically ignored, perform any conversions that are
11363 /// required.
11364 ExprResult IgnoredValueConversions(Expr *E);
11365
11366 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
11367 // functions and arrays to their respective pointers (C99 6.3.2.1).
11368 ExprResult UsualUnaryConversions(Expr *E);
11369
11370 /// CallExprUnaryConversions - a special case of an unary conversion
11371 /// performed on a function designator of a call expression.
11372 ExprResult CallExprUnaryConversions(Expr *E);
11373
11374 // DefaultFunctionArrayConversion - converts functions and arrays
11375 // to their respective pointers (C99 6.3.2.1).
11376 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
11377
11378 // DefaultFunctionArrayLvalueConversion - converts functions and
11379 // arrays to their respective pointers and performs the
11380 // lvalue-to-rvalue conversion.
11381 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
11382 bool Diagnose = true);
11383
11384 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
11385 // the operand. This function is a no-op if the operand has a function type
11386 // or an array type.
11387 ExprResult DefaultLvalueConversion(Expr *E);
11388
11389 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
11390 // do not have a prototype. Integer promotions are performed on each
11391 // argument, and arguments that have type float are promoted to double.
11392 ExprResult DefaultArgumentPromotion(Expr *E);
11393
11394 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize
11395 /// it as an xvalue. In C++98, the result will still be a prvalue, because
11396 /// we don't have xvalues there.
11397 ExprResult TemporaryMaterializationConversion(Expr *E);
11398
11399 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
11400 enum VariadicCallType {
11401 VariadicFunction,
11402 VariadicBlock,
11403 VariadicMethod,
11404 VariadicConstructor,
11405 VariadicDoesNotApply
11406 };
11407
11408 VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
11409 const FunctionProtoType *Proto,
11410 Expr *Fn);
11411
11412 // Used for determining in which context a type is allowed to be passed to a
11413 // vararg function.
11414 enum VarArgKind {
11415 VAK_Valid,
11416 VAK_ValidInCXX11,
11417 VAK_Undefined,
11418 VAK_MSVCUndefined,
11419 VAK_Invalid
11420 };
11421
11422 // Determines which VarArgKind fits an expression.
11423 VarArgKind isValidVarArgType(const QualType &Ty);
11424
11425 /// Check to see if the given expression is a valid argument to a variadic
11426 /// function, issuing a diagnostic if not.
11427 void checkVariadicArgument(const Expr *E, VariadicCallType CT);
11428
11429 /// Check whether the given statement can have musttail applied to it,
11430 /// issuing a diagnostic and returning false if not. In the success case,
11431 /// the statement is rewritten to remove implicit nodes from the return
11432 /// value.
11433 bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA);
11434
11435private:
11436 /// Check whether the given statement can have musttail applied to it,
11437 /// issuing a diagnostic and returning false if not.
11438 bool checkMustTailAttr(const Stmt *St, const Attr &MTA);
11439
11440public:
11441 /// Check to see if a given expression could have '.c_str()' called on it.
11442 bool hasCStrMethod(const Expr *E);
11443
11444 /// GatherArgumentsForCall - Collector argument expressions for various
11445 /// form of call prototypes.
11446 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
11447 const FunctionProtoType *Proto,
11448 unsigned FirstParam, ArrayRef<Expr *> Args,
11449 SmallVectorImpl<Expr *> &AllArgs,
11450 VariadicCallType CallType = VariadicDoesNotApply,
11451 bool AllowExplicit = false,
11452 bool IsListInitialization = false);
11453
11454 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
11455 // will create a runtime trap if the resulting type is not a POD type.
11456 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
11457 FunctionDecl *FDecl);
11458
11459 /// Context in which we're performing a usual arithmetic conversion.
11460 enum ArithConvKind {
11461 /// An arithmetic operation.
11462 ACK_Arithmetic,
11463 /// A bitwise operation.
11464 ACK_BitwiseOp,
11465 /// A comparison.
11466 ACK_Comparison,
11467 /// A conditional (?:) operator.
11468 ACK_Conditional,
11469 /// A compound assignment expression.
11470 ACK_CompAssign,
11471 };
11472
11473 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
11474 // operands and then handles various conversions that are common to binary
11475 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
11476 // routine returns the first non-arithmetic type found. The client is
11477 // responsible for emitting appropriate error diagnostics.
11478 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
11479 SourceLocation Loc, ArithConvKind ACK);
11480
11481 /// AssignConvertType - All of the 'assignment' semantic checks return this
11482 /// enum to indicate whether the assignment was allowed. These checks are
11483 /// done for simple assignments, as well as initialization, return from
11484 /// function, argument passing, etc. The query is phrased in terms of a
11485 /// source and destination type.
11486 enum AssignConvertType {
11487 /// Compatible - the types are compatible according to the standard.
11488 Compatible,
11489
11490 /// PointerToInt - The assignment converts a pointer to an int, which we
11491 /// accept as an extension.
11492 PointerToInt,
11493
11494 /// IntToPointer - The assignment converts an int to a pointer, which we
11495 /// accept as an extension.
11496 IntToPointer,
11497
11498 /// FunctionVoidPointer - The assignment is between a function pointer and
11499 /// void*, which the standard doesn't allow, but we accept as an extension.
11500 FunctionVoidPointer,
11501
11502 /// IncompatiblePointer - The assignment is between two pointers types that
11503 /// are not compatible, but we accept them as an extension.
11504 IncompatiblePointer,
11505
11506 /// IncompatibleFunctionPointer - The assignment is between two function
11507 /// pointers types that are not compatible, but we accept them as an
11508 /// extension.
11509 IncompatibleFunctionPointer,
11510
11511 /// IncompatiblePointerSign - The assignment is between two pointers types
11512 /// which point to integers which have a different sign, but are otherwise
11513 /// identical. This is a subset of the above, but broken out because it's by
11514 /// far the most common case of incompatible pointers.
11515 IncompatiblePointerSign,
11516
11517 /// CompatiblePointerDiscardsQualifiers - The assignment discards
11518 /// c/v/r qualifiers, which we accept as an extension.
11519 CompatiblePointerDiscardsQualifiers,
11520
11521 /// IncompatiblePointerDiscardsQualifiers - The assignment
11522 /// discards qualifiers that we don't permit to be discarded,
11523 /// like address spaces.
11524 IncompatiblePointerDiscardsQualifiers,
11525
11526 /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment
11527 /// changes address spaces in nested pointer types which is not allowed.
11528 /// For instance, converting __private int ** to __generic int ** is
11529 /// illegal even though __private could be converted to __generic.
11530 IncompatibleNestedPointerAddressSpaceMismatch,
11531
11532 /// IncompatibleNestedPointerQualifiers - The assignment is between two
11533 /// nested pointer types, and the qualifiers other than the first two
11534 /// levels differ e.g. char ** -> const char **, but we accept them as an
11535 /// extension.
11536 IncompatibleNestedPointerQualifiers,
11537
11538 /// IncompatibleVectors - The assignment is between two vector types that
11539 /// have the same size, which we accept as an extension.
11540 IncompatibleVectors,
11541
11542 /// IntToBlockPointer - The assignment converts an int to a block
11543 /// pointer. We disallow this.
11544 IntToBlockPointer,
11545
11546 /// IncompatibleBlockPointer - The assignment is between two block
11547 /// pointers types that are not compatible.
11548 IncompatibleBlockPointer,
11549
11550 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
11551 /// id type and something else (that is incompatible with it). For example,
11552 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
11553 IncompatibleObjCQualifiedId,
11554
11555 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
11556 /// object with __weak qualifier.
11557 IncompatibleObjCWeakRef,
11558
11559 /// Incompatible - We reject this conversion outright, it is invalid to
11560 /// represent it in the AST.
11561 Incompatible
11562 };
11563
11564 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
11565 /// assignment conversion type specified by ConvTy. This returns true if the
11566 /// conversion was invalid or false if the conversion was accepted.
11567 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
11568 SourceLocation Loc,
11569 QualType DstType, QualType SrcType,
11570 Expr *SrcExpr, AssignmentAction Action,
11571 bool *Complained = nullptr);
11572
11573 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
11574 /// enum. If AllowMask is true, then we also allow the complement of a valid
11575 /// value, to be used as a mask.
11576 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
11577 bool AllowMask) const;
11578
11579 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
11580 /// integer not in the range of enum values.
11581 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
11582 Expr *SrcExpr);
11583
11584 /// CheckAssignmentConstraints - Perform type checking for assignment,
11585 /// argument passing, variable initialization, and function return values.
11586 /// C99 6.5.16.
11587 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
11588 QualType LHSType,
11589 QualType RHSType);
11590
11591 /// Check assignment constraints and optionally prepare for a conversion of
11592 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
11593 /// is true.
11594 AssignConvertType CheckAssignmentConstraints(QualType LHSType,
11595 ExprResult &RHS,
11596 CastKind &Kind,
11597 bool ConvertRHS = true);
11598
11599 /// Check assignment constraints for an assignment of RHS to LHSType.
11600 ///
11601 /// \param LHSType The destination type for the assignment.
11602 /// \param RHS The source expression for the assignment.
11603 /// \param Diagnose If \c true, diagnostics may be produced when checking
11604 /// for assignability. If a diagnostic is produced, \p RHS will be
11605 /// set to ExprError(). Note that this function may still return
11606 /// without producing a diagnostic, even for an invalid assignment.
11607 /// \param DiagnoseCFAudited If \c true, the target is a function parameter
11608 /// in an audited Core Foundation API and does not need to be checked
11609 /// for ARC retain issues.
11610 /// \param ConvertRHS If \c true, \p RHS will be updated to model the
11611 /// conversions necessary to perform the assignment. If \c false,
11612 /// \p Diagnose must also be \c false.
11613 AssignConvertType CheckSingleAssignmentConstraints(
11614 QualType LHSType, ExprResult &RHS, bool Diagnose = true,
11615 bool DiagnoseCFAudited = false, bool ConvertRHS = true);
11616
11617 // If the lhs type is a transparent union, check whether we
11618 // can initialize the transparent union with the given expression.
11619 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
11620 ExprResult &RHS);
11621
11622 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
11623
11624 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
11625
11626 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11627 AssignmentAction Action,
11628 bool AllowExplicit = false);
11629 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11630 const ImplicitConversionSequence& ICS,
11631 AssignmentAction Action,
11632 CheckedConversionKind CCK
11633 = CCK_ImplicitConversion);
11634 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11635 const StandardConversionSequence& SCS,
11636 AssignmentAction Action,
11637 CheckedConversionKind CCK);
11638
11639 ExprResult PerformQualificationConversion(
11640 Expr *E, QualType Ty, ExprValueKind VK = VK_PRValue,
11641 CheckedConversionKind CCK = CCK_ImplicitConversion);
11642
11643 /// the following "Check" methods will return a valid/converted QualType
11644 /// or a null QualType (indicating an error diagnostic was issued).
11645
11646 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
11647 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
11648 ExprResult &RHS);
11649 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
11650 ExprResult &RHS);
11651 QualType CheckPointerToMemberOperands( // C++ 5.5
11652 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
11653 SourceLocation OpLoc, bool isIndirect);
11654 QualType CheckMultiplyDivideOperands( // C99 6.5.5
11655 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
11656 bool IsDivide);
11657 QualType CheckRemainderOperands( // C99 6.5.5
11658 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11659 bool IsCompAssign = false);
11660 QualType CheckAdditionOperands( // C99 6.5.6
11661 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11662 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
11663 QualType CheckSubtractionOperands( // C99 6.5.6
11664 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11665 QualType* CompLHSTy = nullptr);
11666 QualType CheckShiftOperands( // C99 6.5.7
11667 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11668 BinaryOperatorKind Opc, bool IsCompAssign = false);
11669 void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE);
11670 QualType CheckCompareOperands( // C99 6.5.8/9
11671 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11672 BinaryOperatorKind Opc);
11673 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
11674 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11675 BinaryOperatorKind Opc);
11676 QualType CheckLogicalOperands( // C99 6.5.[13,14]
11677 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11678 BinaryOperatorKind Opc);
11679 // CheckAssignmentOperands is used for both simple and compound assignment.
11680 // For simple assignment, pass both expressions and a null converted type.
11681 // For compound assignment, pass both expressions and the converted type.
11682 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
11683 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
11684
11685 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
11686 UnaryOperatorKind Opcode, Expr *Op);
11687 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
11688 BinaryOperatorKind Opcode,
11689 Expr *LHS, Expr *RHS);
11690 ExprResult checkPseudoObjectRValue(Expr *E);
11691 Expr *recreateSyntacticForm(PseudoObjectExpr *E);
11692
11693 QualType CheckConditionalOperands( // C99 6.5.15
11694 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
11695 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
11696 QualType CXXCheckConditionalOperands( // C++ 5.16
11697 ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
11698 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
11699 QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
11700 ExprResult &RHS,
11701 SourceLocation QuestionLoc);
11702 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
11703 bool ConvertArgs = true);
11704 QualType FindCompositePointerType(SourceLocation Loc,
11705 ExprResult &E1, ExprResult &E2,
11706 bool ConvertArgs = true) {
11707 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
11708 QualType Composite =
11709 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
11710 E1 = E1Tmp;
11711 E2 = E2Tmp;
11712 return Composite;
11713 }
11714
11715 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
11716 SourceLocation QuestionLoc);
11717
11718 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
11719 SourceLocation QuestionLoc);
11720
11721 void DiagnoseAlwaysNonNullPointer(Expr *E,
11722 Expr::NullPointerConstantKind NullType,
11723 bool IsEqual, SourceRange Range);
11724
11725 /// type checking for vector binary operators.
11726 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
11727 SourceLocation Loc, bool IsCompAssign,
11728 bool AllowBothBool, bool AllowBoolConversion);
11729 QualType GetSignedVectorType(QualType V);
11730 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
11731 SourceLocation Loc,
11732 BinaryOperatorKind Opc);
11733 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
11734 SourceLocation Loc);
11735
11736 /// Type checking for matrix binary operators.
11737 QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
11738 SourceLocation Loc,
11739 bool IsCompAssign);
11740 QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
11741 SourceLocation Loc, bool IsCompAssign);
11742
11743 bool isValidSveBitcast(QualType srcType, QualType destType);
11744
11745 bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy);
11746
11747 bool areVectorTypesSameSize(QualType srcType, QualType destType);
11748 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
11749 bool isLaxVectorConversion(QualType srcType, QualType destType);
11750
11751 /// type checking declaration initializers (C99 6.7.8)
11752 bool CheckForConstantInitializer(Expr *e, QualType t);
11753
11754 // type checking C++ declaration initializers (C++ [dcl.init]).
11755
11756 /// ReferenceCompareResult - Expresses the result of comparing two
11757 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
11758 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
11759 enum ReferenceCompareResult {
11760 /// Ref_Incompatible - The two types are incompatible, so direct
11761 /// reference binding is not possible.
11762 Ref_Incompatible = 0,
11763 /// Ref_Related - The two types are reference-related, which means
11764 /// that their unqualified forms (T1 and T2) are either the same
11765 /// or T1 is a base class of T2.
11766 Ref_Related,
11767 /// Ref_Compatible - The two types are reference-compatible.
11768 Ref_Compatible
11769 };
11770
11771 // Fake up a scoped enumeration that still contextually converts to bool.
11772 struct ReferenceConversionsScope {
11773 /// The conversions that would be performed on an lvalue of type T2 when
11774 /// binding a reference of type T1 to it, as determined when evaluating
11775 /// whether T1 is reference-compatible with T2.
11776 enum ReferenceConversions {
11777 Qualification = 0x1,
11778 NestedQualification = 0x2,
11779 Function = 0x4,
11780 DerivedToBase = 0x8,
11781 ObjC = 0x10,
11782 ObjCLifetime = 0x20,
11783
11784 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime)LLVM_BITMASK_LARGEST_ENUMERATOR = ObjCLifetime
11785 };
11786 };
11787 using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions;
11788
11789 ReferenceCompareResult
11790 CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2,
11791 ReferenceConversions *Conv = nullptr);
11792
11793 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
11794 Expr *CastExpr, CastKind &CastKind,
11795 ExprValueKind &VK, CXXCastPath &Path);
11796
11797 /// Force an expression with unknown-type to an expression of the
11798 /// given type.
11799 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
11800
11801 /// Type-check an expression that's being passed to an
11802 /// __unknown_anytype parameter.
11803 ExprResult checkUnknownAnyArg(SourceLocation callLoc,
11804 Expr *result, QualType &paramType);
11805
11806 // CheckMatrixCast - Check type constraints for matrix casts.
11807 // We allow casting between matrixes of the same dimensions i.e. when they
11808 // have the same number of rows and column. Returns true if the cast is
11809 // invalid.
11810 bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
11811 CastKind &Kind);
11812
11813 // CheckVectorCast - check type constraints for vectors.
11814 // Since vectors are an extension, there are no C standard reference for this.
11815 // We allow casting between vectors and integer datatypes of the same size.
11816 // returns true if the cast is invalid
11817 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
11818 CastKind &Kind);
11819
11820 /// Prepare `SplattedExpr` for a vector splat operation, adding
11821 /// implicit casts if necessary.
11822 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
11823
11824 // CheckExtVectorCast - check type constraints for extended vectors.
11825 // Since vectors are an extension, there are no C standard reference for this.
11826 // We allow casting between vectors and integer datatypes of the same size,
11827 // or vectors and the element type of that vector.
11828 // returns the cast expr
11829 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
11830 CastKind &Kind);
11831
11832 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
11833 SourceLocation LParenLoc,
11834 Expr *CastExpr,
11835 SourceLocation RParenLoc);
11836
11837 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
11838
11839 /// Checks for invalid conversions and casts between
11840 /// retainable pointers and other pointer kinds for ARC and Weak.
11841 ARCConversionResult CheckObjCConversion(SourceRange castRange,
11842 QualType castType, Expr *&op,
11843 CheckedConversionKind CCK,
11844 bool Diagnose = true,
11845 bool DiagnoseCFAudited = false,
11846 BinaryOperatorKind Opc = BO_PtrMemD
11847 );
11848
11849 Expr *stripARCUnbridgedCast(Expr *e);
11850 void diagnoseARCUnbridgedCast(Expr *e);
11851
11852 bool CheckObjCARCUnavailableWeakConversion(QualType castType,
11853 QualType ExprType);
11854
11855 /// checkRetainCycles - Check whether an Objective-C message send
11856 /// might create an obvious retain cycle.
11857 void checkRetainCycles(ObjCMessageExpr *msg);
11858 void checkRetainCycles(Expr *receiver, Expr *argument);
11859 void checkRetainCycles(VarDecl *Var, Expr *Init);
11860
11861 /// checkUnsafeAssigns - Check whether +1 expr is being assigned
11862 /// to weak/__unsafe_unretained type.
11863 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
11864
11865 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
11866 /// to weak/__unsafe_unretained expression.
11867 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
11868
11869 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
11870 /// \param Method - May be null.
11871 /// \param [out] ReturnType - The return type of the send.
11872 /// \return true iff there were any incompatible types.
11873 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,
11874 MultiExprArg Args, Selector Sel,
11875 ArrayRef<SourceLocation> SelectorLocs,
11876 ObjCMethodDecl *Method, bool isClassMessage,
11877 bool isSuperMessage, SourceLocation lbrac,
11878 SourceLocation rbrac, SourceRange RecRange,
11879 QualType &ReturnType, ExprValueKind &VK);
11880
11881 /// Determine the result of a message send expression based on
11882 /// the type of the receiver, the method expected to receive the message,
11883 /// and the form of the message send.
11884 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,
11885 ObjCMethodDecl *Method, bool isClassMessage,
11886 bool isSuperMessage);
11887
11888 /// If the given expression involves a message send to a method
11889 /// with a related result type, emit a note describing what happened.
11890 void EmitRelatedResultTypeNote(const Expr *E);
11891
11892 /// Given that we had incompatible pointer types in a return
11893 /// statement, check whether we're in a method with a related result
11894 /// type, and if so, emit a note describing what happened.
11895 void EmitRelatedResultTypeNoteForReturn(QualType destType);
11896
11897 class ConditionResult {
11898 Decl *ConditionVar;
11899 FullExprArg Condition;
11900 bool Invalid;
11901 bool HasKnownValue;
11902 bool KnownValue;
11903
11904 friend class Sema;
11905 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
11906 bool IsConstexpr)
11907 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),
11908 HasKnownValue(IsConstexpr && Condition.get() &&
11909 !Condition.get()->isValueDependent()),
11910 KnownValue(HasKnownValue &&
11911 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
11912 explicit ConditionResult(bool Invalid)
11913 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),
11914 HasKnownValue(false), KnownValue(false) {}
11915
11916 public:
11917 ConditionResult() : ConditionResult(false) {}
11918 bool isInvalid() const { return Invalid; }
11919 std::pair<VarDecl *, Expr *> get() const {
11920 return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
11921 Condition.get());
11922 }
11923 llvm::Optional<bool> getKnownValue() const {
11924 if (!HasKnownValue)
11925 return None;
11926 return KnownValue;
11927 }
11928 };
11929 static ConditionResult ConditionError() { return ConditionResult(true); }
11930
11931 enum class ConditionKind {
11932 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
11933 ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
11934 Switch ///< An integral condition for a 'switch' statement.
11935 };
11936
11937 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
11938 Expr *SubExpr, ConditionKind CK);
11939
11940 ConditionResult ActOnConditionVariable(Decl *ConditionVar,
11941 SourceLocation StmtLoc,
11942 ConditionKind CK);
11943
11944 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
11945
11946 ExprResult CheckConditionVariable(VarDecl *ConditionVar,
11947 SourceLocation StmtLoc,
11948 ConditionKind CK);
11949 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
11950
11951 /// CheckBooleanCondition - Diagnose problems involving the use of
11952 /// the given expression as a boolean condition (e.g. in an if
11953 /// statement). Also performs the standard function and array
11954 /// decays, possibly changing the input variable.
11955 ///
11956 /// \param Loc - A location associated with the condition, e.g. the
11957 /// 'if' keyword.
11958 /// \return true iff there were any errors
11959 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
11960 bool IsConstexpr = false);
11961
11962 /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression
11963 /// found in an explicit(bool) specifier.
11964 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
11965
11966 /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
11967 /// Returns true if the explicit specifier is now resolved.
11968 bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);
11969
11970 /// DiagnoseAssignmentAsCondition - Given that an expression is
11971 /// being used as a boolean condition, warn if it's an assignment.
11972 void DiagnoseAssignmentAsCondition(Expr *E);
11973
11974 /// Redundant parentheses over an equality comparison can indicate
11975 /// that the user intended an assignment used as condition.
11976 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
11977
11978 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
11979 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
11980
11981 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
11982 /// the specified width and sign. If an overflow occurs, detect it and emit
11983 /// the specified diagnostic.
11984 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
11985 unsigned NewWidth, bool NewSign,
11986 SourceLocation Loc, unsigned DiagID);
11987
11988 /// Checks that the Objective-C declaration is declared in the global scope.
11989 /// Emits an error and marks the declaration as invalid if it's not declared
11990 /// in the global scope.
11991 bool CheckObjCDeclScope(Decl *D);
11992
11993 /// Abstract base class used for diagnosing integer constant
11994 /// expression violations.
11995 class VerifyICEDiagnoser {
11996 public:
11997 bool Suppress;
11998
11999 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
12000
12001 virtual SemaDiagnosticBuilder
12002 diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T);
12003 virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
12004 SourceLocation Loc) = 0;
12005 virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc);
12006 virtual ~VerifyICEDiagnoser() {}
12007 };
12008
12009 enum AllowFoldKind {
12010 NoFold,
12011 AllowFold,
12012 };
12013
12014 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
12015 /// and reports the appropriate diagnostics. Returns false on success.
12016 /// Can optionally return the value of the expression.
12017 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12018 VerifyICEDiagnoser &Diagnoser,
12019 AllowFoldKind CanFold = NoFold);
12020 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12021 unsigned DiagID,
12022 AllowFoldKind CanFold = NoFold);
12023 ExprResult VerifyIntegerConstantExpression(Expr *E,
12024 llvm::APSInt *Result = nullptr,
12025 AllowFoldKind CanFold = NoFold);
12026 ExprResult VerifyIntegerConstantExpression(Expr *E,
12027 AllowFoldKind CanFold = NoFold) {
12028 return VerifyIntegerConstantExpression(E, nullptr, CanFold);
12029 }
12030
12031 /// VerifyBitField - verifies that a bit field expression is an ICE and has
12032 /// the correct width, and that the field type is valid.
12033 /// Returns false on success.
12034 /// Can optionally return whether the bit-field is of width 0
12035 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
12036 QualType FieldTy, bool IsMsStruct,
12037 Expr *BitWidth, bool *ZeroWidth = nullptr);
12038
12039private:
12040 unsigned ForceCUDAHostDeviceDepth = 0;
12041
12042public:
12043 /// Increments our count of the number of times we've seen a pragma forcing
12044 /// functions to be __host__ __device__. So long as this count is greater
12045 /// than zero, all functions encountered will be __host__ __device__.
12046 void PushForceCUDAHostDevice();
12047
12048 /// Decrements our count of the number of times we've seen a pragma forcing
12049 /// functions to be __host__ __device__. Returns false if the count is 0
12050 /// before incrementing, so you can emit an error.
12051 bool PopForceCUDAHostDevice();
12052
12053 /// Diagnostics that are emitted only if we discover that the given function
12054 /// must be codegen'ed. Because handling these correctly adds overhead to
12055 /// compilation, this is currently only enabled for CUDA compilations.
12056 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
12057 std::vector<PartialDiagnosticAt>>
12058 DeviceDeferredDiags;
12059
12060 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
12061 /// key in a hashtable, both the FD and location are hashed.
12062 struct FunctionDeclAndLoc {
12063 CanonicalDeclPtr<FunctionDecl> FD;
12064 SourceLocation Loc;
12065 };
12066
12067 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
12068 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
12069 /// same deferred diag twice.
12070 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;
12071
12072 /// An inverse call graph, mapping known-emitted functions to one of their
12073 /// known-emitted callers (plus the location of the call).
12074 ///
12075 /// Functions that we can tell a priori must be emitted aren't added to this
12076 /// map.
12077 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
12078 /* Caller = */ FunctionDeclAndLoc>
12079 DeviceKnownEmittedFns;
12080
12081 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12082 /// context is "used as device code".
12083 ///
12084 /// - If CurContext is a __host__ function, does not emit any diagnostics
12085 /// unless \p EmitOnBothSides is true.
12086 /// - If CurContext is a __device__ or __global__ function, emits the
12087 /// diagnostics immediately.
12088 /// - If CurContext is a __host__ __device__ function and we are compiling for
12089 /// the device, creates a diagnostic which is emitted if and when we realize
12090 /// that the function will be codegen'ed.
12091 ///
12092 /// Example usage:
12093 ///
12094 /// // Variable-length arrays are not allowed in CUDA device code.
12095 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
12096 /// return ExprError();
12097 /// // Otherwise, continue parsing as normal.
12098 SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc,
12099 unsigned DiagID);
12100
12101 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12102 /// context is "used as host code".
12103 ///
12104 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
12105 SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
12106
12107 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12108 /// context is "used as device code".
12109 ///
12110 /// - If CurContext is a `declare target` function or it is known that the
12111 /// function is emitted for the device, emits the diagnostics immediately.
12112 /// - If CurContext is a non-`declare target` function and we are compiling
12113 /// for the device, creates a diagnostic which is emitted if and when we
12114 /// realize that the function will be codegen'ed.
12115 ///
12116 /// Example usage:
12117 ///
12118 /// // Variable-length arrays are not allowed in NVPTX device code.
12119 /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported))
12120 /// return ExprError();
12121 /// // Otherwise, continue parsing as normal.
12122 SemaDiagnosticBuilder
12123 diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD);
12124
12125 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12126 /// context is "used as host code".
12127 ///
12128 /// - If CurContext is a `declare target` function or it is known that the
12129 /// function is emitted for the host, emits the diagnostics immediately.
12130 /// - If CurContext is a non-host function, just ignore it.
12131 ///
12132 /// Example usage:
12133 ///
12134 /// // Variable-length arrays are not allowed in NVPTX device code.
12135 /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported))
12136 /// return ExprError();
12137 /// // Otherwise, continue parsing as normal.
12138 SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc,
12139 unsigned DiagID, FunctionDecl *FD);
12140
12141 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID,
12142 FunctionDecl *FD = nullptr);
12143 SemaDiagnosticBuilder targetDiag(SourceLocation Loc,
12144 const PartialDiagnostic &PD,
12145 FunctionDecl *FD = nullptr) {
12146 return targetDiag(Loc, PD.getDiagID(), FD) << PD;
12147 }
12148
12149 /// Check if the expression is allowed to be used in expressions for the
12150 /// offloading devices.
12151 void checkDeviceDecl(ValueDecl *D, SourceLocation Loc);
12152
12153 enum CUDAFunctionTarget {
12154 CFT_Device,
12155 CFT_Global,
12156 CFT_Host,
12157 CFT_HostDevice,
12158 CFT_InvalidTarget
12159 };
12160
12161 /// Determines whether the given function is a CUDA device/host/kernel/etc.
12162 /// function.
12163 ///
12164 /// Use this rather than examining the function's attributes yourself -- you
12165 /// will get it wrong. Returns CFT_Host if D is null.
12166 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
12167 bool IgnoreImplicitHDAttr = false);
12168 CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs);
12169
12170 enum CUDAVariableTarget {
12171 CVT_Device, /// Emitted on device side with a shadow variable on host side
12172 CVT_Host, /// Emitted on host side only
12173 CVT_Both, /// Emitted on both sides with different addresses
12174 CVT_Unified, /// Emitted as a unified address, e.g. managed variables
12175 };
12176 /// Determines whether the given variable is emitted on host or device side.
12177 CUDAVariableTarget IdentifyCUDATarget(const VarDecl *D);
12178
12179 /// Gets the CUDA target for the current context.
12180 CUDAFunctionTarget CurrentCUDATarget() {
12181 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
12182 }
12183
12184 static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);
12185
12186 // CUDA function call preference. Must be ordered numerically from
12187 // worst to best.
12188 enum CUDAFunctionPreference {
12189 CFP_Never, // Invalid caller/callee combination.
12190 CFP_WrongSide, // Calls from host-device to host or device
12191 // function that do not match current compilation
12192 // mode.
12193 CFP_HostDevice, // Any calls to host/device functions.
12194 CFP_SameSide, // Calls from host-device to host or device
12195 // function matching current compilation mode.
12196 CFP_Native, // host-to-host or device-to-device calls.
12197 };
12198
12199 /// Identifies relative preference of a given Caller/Callee
12200 /// combination, based on their host/device attributes.
12201 /// \param Caller function which needs address of \p Callee.
12202 /// nullptr in case of global context.
12203 /// \param Callee target function
12204 ///
12205 /// \returns preference value for particular Caller/Callee combination.
12206 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
12207 const FunctionDecl *Callee);
12208
12209 /// Determines whether Caller may invoke Callee, based on their CUDA
12210 /// host/device attributes. Returns false if the call is not allowed.
12211 ///
12212 /// Note: Will return true for CFP_WrongSide calls. These may appear in
12213 /// semantically correct CUDA programs, but only if they're never codegen'ed.
12214 bool IsAllowedCUDACall(const FunctionDecl *Caller,
12215 const FunctionDecl *Callee) {
12216 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
12217 }
12218
12219 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
12220 /// depending on FD and the current compilation settings.
12221 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
12222 const LookupResult &Previous);
12223
12224 /// May add implicit CUDAConstantAttr attribute to VD, depending on VD
12225 /// and current compilation settings.
12226 void MaybeAddCUDAConstantAttr(VarDecl *VD);
12227
12228public:
12229 /// Check whether we're allowed to call Callee from the current context.
12230 ///
12231 /// - If the call is never allowed in a semantically-correct program
12232 /// (CFP_Never), emits an error and returns false.
12233 ///
12234 /// - If the call is allowed in semantically-correct programs, but only if
12235 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
12236 /// be emitted if and when the caller is codegen'ed, and returns true.
12237 ///
12238 /// Will only create deferred diagnostics for a given SourceLocation once,
12239 /// so you can safely call this multiple times without generating duplicate
12240 /// deferred errors.
12241 ///
12242 /// - Otherwise, returns true without emitting any diagnostics.
12243 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
12244
12245 void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture);
12246
12247 /// Set __device__ or __host__ __device__ attributes on the given lambda
12248 /// operator() method.
12249 ///
12250 /// CUDA lambdas by default is host device function unless it has explicit
12251 /// host or device attribute.
12252 void CUDASetLambdaAttrs(CXXMethodDecl *Method);
12253
12254 /// Finds a function in \p Matches with highest calling priority
12255 /// from \p Caller context and erases all functions with lower
12256 /// calling priority.
12257 void EraseUnwantedCUDAMatches(
12258 const FunctionDecl *Caller,
12259 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
12260
12261 /// Given a implicit special member, infer its CUDA target from the
12262 /// calls it needs to make to underlying base/field special members.
12263 /// \param ClassDecl the class for which the member is being created.
12264 /// \param CSM the kind of special member.
12265 /// \param MemberDecl the special member itself.
12266 /// \param ConstRHS true if this is a copy operation with a const object on
12267 /// its RHS.
12268 /// \param Diagnose true if this call should emit diagnostics.
12269 /// \return true if there was an error inferring.
12270 /// The result of this call is implicit CUDA target attribute(s) attached to
12271 /// the member declaration.
12272 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
12273 CXXSpecialMember CSM,
12274 CXXMethodDecl *MemberDecl,
12275 bool ConstRHS,
12276 bool Diagnose);
12277
12278 /// \return true if \p CD can be considered empty according to CUDA
12279 /// (E.2.3.1 in CUDA 7.5 Programming guide).
12280 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
12281 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
12282
12283 // \brief Checks that initializers of \p Var satisfy CUDA restrictions. In
12284 // case of error emits appropriate diagnostic and invalidates \p Var.
12285 //
12286 // \details CUDA allows only empty constructors as initializers for global
12287 // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all
12288 // __shared__ variables whether they are local or not (they all are implicitly
12289 // static in CUDA). One exception is that CUDA allows constant initializers
12290 // for __constant__ and __device__ variables.
12291 void checkAllowedCUDAInitializer(VarDecl *VD);
12292
12293 /// Check whether NewFD is a valid overload for CUDA. Emits
12294 /// diagnostics and invalidates NewFD if not.
12295 void checkCUDATargetOverload(FunctionDecl *NewFD,
12296 const LookupResult &Previous);
12297 /// Copies target attributes from the template TD to the function FD.
12298 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);
12299
12300 /// Returns the name of the launch configuration function. This is the name
12301 /// of the function that will be called to configure kernel call, with the
12302 /// parameters specified via <<<>>>.
12303 std::string getCudaConfigureFuncName() const;
12304
12305 /// \name Code completion
12306 //@{
12307 /// Describes the context in which code completion occurs.
12308 enum ParserCompletionContext {
12309 /// Code completion occurs at top-level or namespace context.
12310 PCC_Namespace,
12311 /// Code completion occurs within a class, struct, or union.
12312 PCC_Class,
12313 /// Code completion occurs within an Objective-C interface, protocol,
12314 /// or category.
12315 PCC_ObjCInterface,
12316 /// Code completion occurs within an Objective-C implementation or
12317 /// category implementation
12318 PCC_ObjCImplementation,
12319 /// Code completion occurs within the list of instance variables
12320 /// in an Objective-C interface, protocol, category, or implementation.
12321 PCC_ObjCInstanceVariableList,
12322 /// Code completion occurs following one or more template
12323 /// headers.
12324 PCC_Template,
12325 /// Code completion occurs following one or more template
12326 /// headers within a class.
12327 PCC_MemberTemplate,
12328 /// Code completion occurs within an expression.
12329 PCC_Expression,
12330 /// Code completion occurs within a statement, which may
12331 /// also be an expression or a declaration.
12332 PCC_Statement,
12333 /// Code completion occurs at the beginning of the
12334 /// initialization statement (or expression) in a for loop.
12335 PCC_ForInit,
12336 /// Code completion occurs within the condition of an if,
12337 /// while, switch, or for statement.
12338 PCC_Condition,
12339 /// Code completion occurs within the body of a function on a
12340 /// recovery path, where we do not have a specific handle on our position
12341 /// in the grammar.
12342 PCC_RecoveryInFunction,
12343 /// Code completion occurs where only a type is permitted.
12344 PCC_Type,
12345 /// Code completion occurs in a parenthesized expression, which
12346 /// might also be a type cast.
12347 PCC_ParenthesizedExpression,
12348 /// Code completion occurs within a sequence of declaration
12349 /// specifiers within a function, method, or block.
12350 PCC_LocalDeclarationSpecifiers
12351 };
12352
12353 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
12354 void CodeCompleteOrdinaryName(Scope *S,
12355 ParserCompletionContext CompletionContext);
12356 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
12357 bool AllowNonIdentifiers,
12358 bool AllowNestedNameSpecifiers);
12359
12360 struct CodeCompleteExpressionData;
12361 void CodeCompleteExpression(Scope *S,
12362 const CodeCompleteExpressionData &Data);
12363 void CodeCompleteExpression(Scope *S, QualType PreferredType,
12364 bool IsParenthesized = false);
12365 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
12366 SourceLocation OpLoc, bool IsArrow,
12367 bool IsBaseExprStatement,
12368 QualType PreferredType);
12369 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
12370 QualType PreferredType);
12371 void CodeCompleteTag(Scope *S, unsigned TagSpec);
12372 void CodeCompleteTypeQualifiers(DeclSpec &DS);
12373 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
12374 const VirtSpecifiers *VS = nullptr);
12375 void CodeCompleteBracketDeclarator(Scope *S);
12376 void CodeCompleteCase(Scope *S);
12377 /// Determines the preferred type of the current function argument, by
12378 /// examining the signatures of all possible overloads.
12379 /// Returns null if unknown or ambiguous, or if code completion is off.
12380 ///
12381 /// If the code completion point has been reached, also reports the function
12382 /// signatures that were considered.
12383 ///
12384 /// FIXME: rename to GuessCallArgumentType to reduce confusion.
12385 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
12386 SourceLocation OpenParLoc);
12387 QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,
12388 SourceLocation Loc,
12389 ArrayRef<Expr *> Args,
12390 SourceLocation OpenParLoc);
12391 QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl,
12392 CXXScopeSpec SS,
12393 ParsedType TemplateTypeTy,
12394 ArrayRef<Expr *> ArgExprs,
12395 IdentifierInfo *II,
12396 SourceLocation OpenParLoc);
12397 void CodeCompleteInitializer(Scope *S, Decl *D);
12398 /// Trigger code completion for a record of \p BaseType. \p InitExprs are
12399 /// expressions in the initializer list seen so far and \p D is the current
12400 /// Designation being parsed.
12401 void CodeCompleteDesignator(const QualType BaseType,
12402 llvm::ArrayRef<Expr *> InitExprs,
12403 const Designation &D);
12404 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen);
12405
12406 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext,
12407 bool IsUsingDeclaration, QualType BaseType,
12408 QualType PreferredType);
12409 void CodeCompleteUsing(Scope *S);
12410 void CodeCompleteUsingDirective(Scope *S);
12411 void CodeCompleteNamespaceDecl(Scope *S);
12412 void CodeCompleteNamespaceAliasDecl(Scope *S);
12413 void CodeCompleteOperatorName(Scope *S);
12414 void CodeCompleteConstructorInitializer(
12415 Decl *Constructor,
12416 ArrayRef<CXXCtorInitializer *> Initializers);
12417
12418 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
12419 bool AfterAmpersand);
12420 void CodeCompleteAfterFunctionEquals(Declarator &D);
12421
12422 void CodeCompleteObjCAtDirective(Scope *S);
12423 void CodeCompleteObjCAtVisibility(Scope *S);
12424 void CodeCompleteObjCAtStatement(Scope *S);
12425 void CodeCompleteObjCAtExpression(Scope *S);
12426 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
12427 void CodeCompleteObjCPropertyGetter(Scope *S);
12428 void CodeCompleteObjCPropertySetter(Scope *S);
12429 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
12430 bool IsParameter);
12431 void CodeCompleteObjCMessageReceiver(Scope *S);
12432 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
12433 ArrayRef<IdentifierInfo *> SelIdents,
12434 bool AtArgumentExpression);
12435 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
12436 ArrayRef<IdentifierInfo *> SelIdents,
12437 bool AtArgumentExpression,
12438 bool IsSuper = false);
12439 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
12440 ArrayRef<IdentifierInfo *> SelIdents,
12441 bool AtArgumentExpression,
12442 ObjCInterfaceDecl *Super = nullptr);
12443 void CodeCompleteObjCForCollection(Scope *S,
12444 DeclGroupPtrTy IterationVar);
12445 void CodeCompleteObjCSelector(Scope *S,
12446 ArrayRef<IdentifierInfo *> SelIdents);
12447 void CodeCompleteObjCProtocolReferences(
12448 ArrayRef<IdentifierLocPair> Protocols);
12449 void CodeCompleteObjCProtocolDecl(Scope *S);
12450 void CodeCompleteObjCInterfaceDecl(Scope *S);
12451 void CodeCompleteObjCSuperclass(Scope *S,
12452 IdentifierInfo *ClassName,
12453 SourceLocation ClassNameLoc);
12454 void CodeCompleteObjCImplementationDecl(Scope *S);
12455 void CodeCompleteObjCInterfaceCategory(Scope *S,
12456 IdentifierInfo *ClassName,
12457 SourceLocation ClassNameLoc);
12458 void CodeCompleteObjCImplementationCategory(Scope *S,
12459 IdentifierInfo *ClassName,
12460 SourceLocation ClassNameLoc);
12461 void CodeCompleteObjCPropertyDefinition(Scope *S);
12462 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
12463 IdentifierInfo *PropertyName);
12464 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
12465 ParsedType ReturnType);
12466 void CodeCompleteObjCMethodDeclSelector(Scope *S,
12467 bool IsInstanceMethod,
12468 bool AtParameterName,
12469 ParsedType ReturnType,
12470 ArrayRef<IdentifierInfo *> SelIdents);
12471 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
12472 SourceLocation ClassNameLoc,
12473 bool IsBaseExprStatement);
12474 void CodeCompletePreprocessorDirective(bool InConditional);
12475 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
12476 void CodeCompletePreprocessorMacroName(bool IsDefinition);
12477 void CodeCompletePreprocessorExpression();
12478 void CodeCompletePreprocessorMacroArgument(Scope *S,
12479 IdentifierInfo *Macro,
12480 MacroInfo *MacroInfo,
12481 unsigned Argument);
12482 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
12483 void CodeCompleteNaturalLanguage();
12484 void CodeCompleteAvailabilityPlatformName();
12485 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
12486 CodeCompletionTUInfo &CCTUInfo,
12487 SmallVectorImpl<CodeCompletionResult> &Results);
12488 //@}
12489
12490 //===--------------------------------------------------------------------===//
12491 // Extra semantic analysis beyond the C type system
12492
12493public:
12494 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
12495 unsigned ByteNo) const;
12496
12497private:
12498 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
12499 const ArraySubscriptExpr *ASE=nullptr,
12500 bool AllowOnePastEnd=true, bool IndexNegated=false);
12501 void CheckArrayAccess(const Expr *E);
12502 // Used to grab the relevant information from a FormatAttr and a
12503 // FunctionDeclaration.
12504 struct FormatStringInfo {
12505 unsigned FormatIdx;
12506 unsigned FirstDataArg;
12507 bool HasVAListArg;
12508 };
12509
12510 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
12511 FormatStringInfo *FSI);
12512 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
12513 const FunctionProtoType *Proto);
12514 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
12515 ArrayRef<const Expr *> Args);
12516 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
12517 const FunctionProtoType *Proto);
12518 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
12519 void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
12520 ArrayRef<const Expr *> Args,
12521 const FunctionProtoType *Proto, SourceLocation Loc);
12522
12523 void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
12524 StringRef ParamName, QualType ArgTy, QualType ParamTy);
12525
12526 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
12527 const Expr *ThisArg, ArrayRef<const Expr *> Args,
12528 bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
12529 VariadicCallType CallType);
12530
12531 bool CheckObjCString(Expr *Arg);
12532 ExprResult CheckOSLogFormatStringArg(Expr *Arg);
12533
12534 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
12535 unsigned BuiltinID, CallExpr *TheCall);
12536
12537 bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12538 CallExpr *TheCall);
12539
12540 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall);
12541
12542 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
12543 unsigned MaxWidth);
12544 bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12545 CallExpr *TheCall);
12546 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12547 bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12548 bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12549 CallExpr *TheCall);
12550 bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg,
12551 bool WantCDE);
12552 bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12553 CallExpr *TheCall);
12554
12555 bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12556 CallExpr *TheCall);
12557 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12558 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12559 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12560 bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12561 CallExpr *TheCall);
12562 bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
12563 CallExpr *TheCall);
12564 bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12565 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12566 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
12567 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
12568 bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall);
12569 bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
12570 ArrayRef<int> ArgNums);
12571 bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums);
12572 bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
12573 ArrayRef<int> ArgNums);
12574 bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12575 CallExpr *TheCall);
12576 bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12577 CallExpr *TheCall);
12578 bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12579 bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum);
12580 bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12581 CallExpr *TheCall);
12582
12583 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
12584 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
12585 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
12586 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
12587 bool SemaBuiltinComplex(CallExpr *TheCall);
12588 bool SemaBuiltinVSX(CallExpr *TheCall);
12589 bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
12590 bool SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum);
12591
12592public:
12593 // Used by C++ template instantiation.
12594 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
12595 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
12596 SourceLocation BuiltinLoc,
12597 SourceLocation RParenLoc);
12598
12599private:
12600 bool SemaBuiltinPrefetch(CallExpr *TheCall);
12601 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
12602 bool SemaBuiltinArithmeticFence(CallExpr *TheCall);
12603 bool SemaBuiltinAssume(CallExpr *TheCall);
12604 bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
12605 bool SemaBuiltinLongjmp(CallExpr *TheCall);
12606 bool SemaBuiltinSetjmp(CallExpr *TheCall);
12607 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
12608 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
12609 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
12610 AtomicExpr::AtomicOp Op);
12611 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
12612 bool IsDelete);
12613 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
12614 llvm::APSInt &Result);
12615 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
12616 int High, bool RangeIsError = true);
12617 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
12618 unsigned Multiple);
12619 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum);
12620 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
12621 unsigned ArgBits);
12622 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,
12623 unsigned ArgBits);
12624 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
12625 int ArgNum, unsigned ExpectedFieldNum,
12626 bool AllowName);
12627 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
12628 bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc);
12629
12630 bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);
12631
12632 // Matrix builtin handling.
12633 ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
12634 ExprResult CallResult);
12635 ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
12636 ExprResult CallResult);
12637 ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
12638 ExprResult CallResult);
12639
12640public:
12641 enum FormatStringType {
12642 FST_Scanf,
12643 FST_Printf,
12644 FST_NSString,
12645 FST_Strftime,
12646 FST_Strfmon,
12647 FST_Kprintf,
12648 FST_FreeBSDKPrintf,
12649 FST_OSTrace,
12650 FST_OSLog,
12651 FST_Syslog,
12652 FST_Unknown
12653 };
12654 static FormatStringType GetFormatStringType(const FormatAttr *Format);
12655
12656 bool FormatStringHasSArg(const StringLiteral *FExpr);
12657
12658 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);
12659
12660private:
12661 bool CheckFormatArguments(const FormatAttr *Format,
12662 ArrayRef<const Expr *> Args,
12663 bool IsCXXMember,
12664 VariadicCallType CallType,
12665 SourceLocation Loc, SourceRange Range,
12666 llvm::SmallBitVector &CheckedVarArgs);
12667 bool CheckFormatArguments(ArrayRef<const Expr *> Args,
12668 bool HasVAListArg, unsigned format_idx,
12669 unsigned firstDataArg, FormatStringType Type,
12670 VariadicCallType CallType,
12671 SourceLocation Loc, SourceRange range,
12672 llvm::SmallBitVector &CheckedVarArgs);
12673
12674 void CheckAbsoluteValueFunction(const CallExpr *Call,
12675 const FunctionDecl *FDecl);
12676
12677 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
12678
12679 void CheckMemaccessArguments(const CallExpr *Call,
12680 unsigned BId,
12681 IdentifierInfo *FnName);
12682
12683 void CheckStrlcpycatArguments(const CallExpr *Call,
12684 IdentifierInfo *FnName);
12685
12686 void CheckStrncatArguments(const CallExpr *Call,
12687 IdentifierInfo *FnName);
12688
12689 void CheckFreeArguments(const CallExpr *E);
12690
12691 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
12692 SourceLocation ReturnLoc,
12693 bool isObjCMethod = false,
12694 const AttrVec *Attrs = nullptr,
12695 const FunctionDecl *FD = nullptr);
12696
12697public:
12698 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
12699
12700private:
12701 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
12702 void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
12703 void CheckForIntOverflow(Expr *E);
12704 void CheckUnsequencedOperations(const Expr *E);
12705
12706 /// Perform semantic checks on a completed expression. This will either
12707 /// be a full-expression or a default argument expression.
12708 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
12709 bool IsConstexpr = false);
12710
12711 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
12712 Expr *Init);
12713
12714 /// Check if there is a field shadowing.
12715 void CheckShadowInheritedFields(const SourceLocation &Loc,
12716 DeclarationName FieldName,
12717 const CXXRecordDecl *RD,
12718 bool DeclIsField = true);
12719
12720 /// Check if the given expression contains 'break' or 'continue'
12721 /// statement that produces control flow different from GCC.
12722 void CheckBreakContinueBinding(Expr *E);
12723
12724 /// Check whether receiver is mutable ObjC container which
12725 /// attempts to add itself into the container
12726 void CheckObjCCircularContainer(ObjCMessageExpr *Message);
12727
12728 void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee);
12729
12730 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
12731 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
12732 bool DeleteWasArrayForm);
12733public:
12734 /// Register a magic integral constant to be used as a type tag.
12735 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
12736 uint64_t MagicValue, QualType Type,
12737 bool LayoutCompatible, bool MustBeNull);
12738
12739 struct TypeTagData {
12740 TypeTagData() {}
12741
12742 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
12743 Type(Type), LayoutCompatible(LayoutCompatible),
12744 MustBeNull(MustBeNull)
12745 {}
12746
12747 QualType Type;
12748
12749 /// If true, \c Type should be compared with other expression's types for
12750 /// layout-compatibility.
12751 unsigned LayoutCompatible : 1;
12752 unsigned MustBeNull : 1;
12753 };
12754
12755 /// A pair of ArgumentKind identifier and magic value. This uniquely
12756 /// identifies the magic value.
12757 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
12758
12759private:
12760 /// A map from magic value to type information.
12761 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
12762 TypeTagForDatatypeMagicValues;
12763
12764 /// Peform checks on a call of a function with argument_with_type_tag
12765 /// or pointer_with_type_tag attributes.
12766 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
12767 const ArrayRef<const Expr *> ExprArgs,
12768 SourceLocation CallSiteLoc);
12769
12770 /// Check if we are taking the address of a packed field
12771 /// as this may be a problem if the pointer value is dereferenced.
12772 void CheckAddressOfPackedMember(Expr *rhs);
12773
12774 /// The parser's current scope.
12775 ///
12776 /// The parser maintains this state here.
12777 Scope *CurScope;
12778
12779 mutable IdentifierInfo *Ident_super;
12780 mutable IdentifierInfo *Ident___float128;
12781
12782 /// Nullability type specifiers.
12783 IdentifierInfo *Ident__Nonnull = nullptr;
12784 IdentifierInfo *Ident__Nullable = nullptr;
12785 IdentifierInfo *Ident__Nullable_result = nullptr;
12786 IdentifierInfo *Ident__Null_unspecified = nullptr;
12787
12788 IdentifierInfo *Ident_NSError = nullptr;
12789
12790 /// The handler for the FileChanged preprocessor events.
12791 ///
12792 /// Used for diagnostics that implement custom semantic analysis for #include
12793 /// directives, like -Wpragma-pack.
12794 sema::SemaPPCallbacks *SemaPPCallbackHandler;
12795
12796protected:
12797 friend class Parser;
12798 friend class InitializationSequence;
12799 friend class ASTReader;
12800 friend class ASTDeclReader;
12801 friend class ASTWriter;
12802
12803public:
12804 /// Retrieve the keyword associated
12805 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
12806
12807 /// The struct behind the CFErrorRef pointer.
12808 RecordDecl *CFError = nullptr;
12809 bool isCFError(RecordDecl *D);
12810
12811 /// Retrieve the identifier "NSError".
12812 IdentifierInfo *getNSErrorIdent();
12813
12814 /// Retrieve the parser's current scope.
12815 ///
12816 /// This routine must only be used when it is certain that semantic analysis
12817 /// and the parser are in precisely the same context, which is not the case
12818 /// when, e.g., we are performing any kind of template instantiation.
12819 /// Therefore, the only safe places to use this scope are in the parser
12820 /// itself and in routines directly invoked from the parser and *never* from
12821 /// template substitution or instantiation.
12822 Scope *getCurScope() const { return CurScope; }
12823
12824 void incrementMSManglingNumber() const {
12825 return CurScope->incrementMSManglingNumber();
12826 }
12827
12828 IdentifierInfo *getSuperIdentifier() const;
12829 IdentifierInfo *getFloat128Identifier() const;
12830
12831 Decl *getObjCDeclContext() const;
12832
12833 DeclContext *getCurLexicalContext() const {
12834 return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
12835 }
12836
12837 const DeclContext *getCurObjCLexicalContext() const {
12838 const DeclContext *DC = getCurLexicalContext();
12839 // A category implicitly has the attribute of the interface.
12840 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
12841 DC = CatD->getClassInterface();
12842 return DC;
12843 }
12844
12845 /// Determine the number of levels of enclosing template parameters. This is
12846 /// only usable while parsing. Note that this does not include dependent
12847 /// contexts in which no template parameters have yet been declared, such as
12848 /// in a terse function template or generic lambda before the first 'auto' is
12849 /// encountered.
12850 unsigned getTemplateDepth(Scope *S) const;
12851
12852 /// To be used for checking whether the arguments being passed to
12853 /// function exceeds the number of parameters expected for it.
12854 static bool TooManyArguments(size_t NumParams, size_t NumArgs,
12855 bool PartialOverloading = false) {
12856 // We check whether we're just after a comma in code-completion.
12857 if (NumArgs > 0 && PartialOverloading)
12858 return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
12859 return NumArgs > NumParams;
12860 }
12861
12862 // Emitting members of dllexported classes is delayed until the class
12863 // (including field initializers) is fully parsed.
12864 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
12865 SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions;
12866
12867private:
12868 int ParsingClassDepth = 0;
12869
12870 class SavePendingParsedClassStateRAII {
12871 public:
12872 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
12873
12874 ~SavePendingParsedClassStateRAII() {
12875 assert(S.DelayedOverridingExceptionSpecChecks.empty() &&((void)0)
12876 "there shouldn't be any pending delayed exception spec checks")((void)0);
12877 assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&((void)0)
12878 "there shouldn't be any pending delayed exception spec checks")((void)0);
12879 swapSavedState();
12880 }
12881
12882 private:
12883 Sema &S;
12884 decltype(DelayedOverridingExceptionSpecChecks)
12885 SavedOverridingExceptionSpecChecks;
12886 decltype(DelayedEquivalentExceptionSpecChecks)
12887 SavedEquivalentExceptionSpecChecks;
12888
12889 void swapSavedState() {
12890 SavedOverridingExceptionSpecChecks.swap(
12891 S.DelayedOverridingExceptionSpecChecks);
12892 SavedEquivalentExceptionSpecChecks.swap(
12893 S.DelayedEquivalentExceptionSpecChecks);
12894 }
12895 };
12896
12897 /// Helper class that collects misaligned member designations and
12898 /// their location info for delayed diagnostics.
12899 struct MisalignedMember {
12900 Expr *E;
12901 RecordDecl *RD;
12902 ValueDecl *MD;
12903 CharUnits Alignment;
12904
12905 MisalignedMember() : E(), RD(), MD(), Alignment() {}
12906 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
12907 CharUnits Alignment)
12908 : E(E), RD(RD), MD(MD), Alignment(Alignment) {}
12909 explicit MisalignedMember(Expr *E)
12910 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}
12911
12912 bool operator==(const MisalignedMember &m) { return this->E == m.E; }
12913 };
12914 /// Small set of gathered accesses to potentially misaligned members
12915 /// due to the packed attribute.
12916 SmallVector<MisalignedMember, 4> MisalignedMembers;
12917
12918 /// Adds an expression to the set of gathered misaligned members.
12919 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
12920 CharUnits Alignment);
12921
12922public:
12923 /// Diagnoses the current set of gathered accesses. This typically
12924 /// happens at full expression level. The set is cleared after emitting the
12925 /// diagnostics.
12926 void DiagnoseMisalignedMembers();
12927
12928 /// This function checks if the expression is in the sef of potentially
12929 /// misaligned members and it is converted to some pointer type T with lower
12930 /// or equal alignment requirements. If so it removes it. This is used when
12931 /// we do not want to diagnose such misaligned access (e.g. in conversions to
12932 /// void*).
12933 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
12934
12935 /// This function calls Action when it determines that E designates a
12936 /// misaligned member due to the packed attribute. This is used to emit
12937 /// local diagnostics like in reference binding.
12938 void RefersToMemberWithReducedAlignment(
12939 Expr *E,
12940 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
12941 Action);
12942
12943 /// Describes the reason a calling convention specification was ignored, used
12944 /// for diagnostics.
12945 enum class CallingConventionIgnoredReason {
12946 ForThisTarget = 0,
12947 VariadicFunction,
12948 ConstructorDestructor,
12949 BuiltinFunction
12950 };
12951 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12952 /// context is "used as device code".
12953 ///
12954 /// - If CurLexicalContext is a kernel function or it is known that the
12955 /// function will be emitted for the device, emits the diagnostics
12956 /// immediately.
12957 /// - If CurLexicalContext is a function and we are compiling
12958 /// for the device, but we don't know that this function will be codegen'ed
12959 /// for devive yet, creates a diagnostic which is emitted if and when we
12960 /// realize that the function will be codegen'ed.
12961 ///
12962 /// Example usage:
12963 ///
12964 /// Diagnose __float128 type usage only from SYCL device code if the current
12965 /// target doesn't support it
12966 /// if (!S.Context.getTargetInfo().hasFloat128Type() &&
12967 /// S.getLangOpts().SYCLIsDevice)
12968 /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128";
12969 SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc,
12970 unsigned DiagID);
12971
12972 /// Check whether we're allowed to call Callee from the current context.
12973 ///
12974 /// - If the call is never allowed in a semantically-correct program
12975 /// emits an error and returns false.
12976 ///
12977 /// - If the call is allowed in semantically-correct programs, but only if
12978 /// it's never codegen'ed, creates a deferred diagnostic to be emitted if
12979 /// and when the caller is codegen'ed, and returns true.
12980 ///
12981 /// - Otherwise, returns true without emitting any diagnostics.
12982 ///
12983 /// Adds Callee to DeviceCallGraph if we don't know if its caller will be
12984 /// codegen'ed yet.
12985 bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee);
12986};
12987
12988/// RAII object that enters a new expression evaluation context.
12989class EnterExpressionEvaluationContext {
12990 Sema &Actions;
12991 bool Entered = true;
12992
12993public:
12994 EnterExpressionEvaluationContext(
12995 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
12996 Decl *LambdaContextDecl = nullptr,
12997 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
12998 Sema::ExpressionEvaluationContextRecord::EK_Other,
12999 bool ShouldEnter = true)
13000 : Actions(Actions), Entered(ShouldEnter) {
13001 if (Entered)
13002 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
13003 ExprContext);
13004 }
13005 EnterExpressionEvaluationContext(
13006 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
13007 Sema::ReuseLambdaContextDecl_t,
13008 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
13009 Sema::ExpressionEvaluationContextRecord::EK_Other)
13010 : Actions(Actions) {
13011 Actions.PushExpressionEvaluationContext(
13012 NewContext, Sema::ReuseLambdaContextDecl, ExprContext);
13013 }
13014
13015 enum InitListTag { InitList };
13016 EnterExpressionEvaluationContext(Sema &Actions, InitListTag,
13017 bool ShouldEnter = true)
13018 : Actions(Actions), Entered(false) {
13019 // In C++11 onwards, narrowing checks are performed on the contents of
13020 // braced-init-lists, even when they occur within unevaluated operands.
13021 // Therefore we still need to instantiate constexpr functions used in such
13022 // a context.
13023 if (ShouldEnter && Actions.isUnevaluatedContext() &&
13024 Actions.getLangOpts().CPlusPlus11) {
13025 Actions.PushExpressionEvaluationContext(
13026 Sema::ExpressionEvaluationContext::UnevaluatedList);
13027 Entered = true;
13028 }
13029 }
13030
13031 ~EnterExpressionEvaluationContext() {
13032 if (Entered)
13033 Actions.PopExpressionEvaluationContext();
13034 }
13035};
13036
13037DeductionFailureInfo
13038MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
13039 sema::TemplateDeductionInfo &Info);
13040
13041/// Contains a late templated function.
13042/// Will be parsed at the end of the translation unit, used by Sema & Parser.
13043struct LateParsedTemplate {
13044 CachedTokens Toks;
13045 /// The template function declaration to be late parsed.
13046 Decl *D;
13047};
13048
13049template <>
13050void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
13051 PragmaMsStackAction Action,
13052 llvm::StringRef StackSlotLabel,
13053 AlignPackInfo Value);
13054
13055} // end namespace clang
13056
13057namespace llvm {
13058// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
13059// SourceLocation.
13060template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
13061 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
13062 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;
13063
13064 static FunctionDeclAndLoc getEmptyKey() {
13065 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};
13066 }
13067
13068 static FunctionDeclAndLoc getTombstoneKey() {
13069 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};
13070 }
13071
13072 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
13073 return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
13074 FDL.Loc.getHashValue());
13075 }
13076
13077 static bool isEqual(const FunctionDeclAndLoc &LHS,
13078 const FunctionDeclAndLoc &RHS) {
13079 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
13080 }
13081};
13082} // namespace llvm
13083
13084#endif