Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:line 2694, column 29
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() &&
18
Assuming the condition is false
245 SemaRef.hasUncompilableErrorOccurred()) {
246 Invalid = true;
247 return;
248 }
249 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
19
Calling 'InstantiatingTemplate::CheckInstantiationDepth'
23
Returning from 'InstantiatingTemplate::CheckInstantiationDepth'
250 if (!Invalid
23.1
Field 'Invalid' is false
23.1
Field 'Invalid' is false
) {
24
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
24.1
Field 'Entity' is non-null
24.1
Field 'Entity' is non-null
? false :
25
'?' condition is false
263 !SemaRef.InstantiatingSpecializations
26
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,
17
Calling constructor for 'InstantiatingTemplate'
27
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() -
20
Assuming the condition is true
21
Taking true branch
500 SemaRef.NonInstantiationEntries)
501 <= SemaRef.getLangOpts().InstantiationDepth)
502 return false;
22
Returning zero, which participates in a condition later
503
504 SemaRef.Diag(PointOfInstantiation,
505 diag::err_template_recursion_depth_exceeded)
506 << SemaRef.getLangOpts().InstantiationDepth
507 << InstantiationRange;
508 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
509 << SemaRef.getLangOpts().InstantiationDepth;
510 return true;
511}
512
513/// Prints the current instantiation stack through a series of
514/// notes.
515void Sema::PrintInstantiationStack() {
516 // Determine which template instantiations to skip, if any.
517 unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
518 unsigned Limit = Diags.getTemplateBacktraceLimit();
519 if (Limit && Limit < CodeSynthesisContexts.size()) {
520 SkipStart = Limit / 2 + Limit % 2;
521 SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
522 }
523
524 // FIXME: In all of these cases, we need to show the template arguments
525 unsigned InstantiationIdx = 0;
526 for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
527 Active = CodeSynthesisContexts.rbegin(),
528 ActiveEnd = CodeSynthesisContexts.rend();
529 Active != ActiveEnd;
530 ++Active, ++InstantiationIdx) {
531 // Skip this instantiation?
532 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
533 if (InstantiationIdx == SkipStart) {
534 // Note that we're skipping instantiations.
535 Diags.Report(Active->PointOfInstantiation,
536 diag::note_instantiation_contexts_suppressed)
537 << unsigned(CodeSynthesisContexts.size() - Limit);
538 }
539 continue;
540 }
541
542 switch (Active->Kind) {
543 case CodeSynthesisContext::TemplateInstantiation: {
544 Decl *D = Active->Entity;
545 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
546 unsigned DiagID = diag::note_template_member_class_here;
547 if (isa<ClassTemplateSpecializationDecl>(Record))
548 DiagID = diag::note_template_class_instantiation_here;
549 Diags.Report(Active->PointOfInstantiation, DiagID)
550 << Record << Active->InstantiationRange;
551 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
552 unsigned DiagID;
553 if (Function->getPrimaryTemplate())
554 DiagID = diag::note_function_template_spec_here;
555 else
556 DiagID = diag::note_template_member_function_here;
557 Diags.Report(Active->PointOfInstantiation, DiagID)
558 << Function
559 << Active->InstantiationRange;
560 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
561 Diags.Report(Active->PointOfInstantiation,
562 VD->isStaticDataMember()?
563 diag::note_template_static_data_member_def_here
564 : diag::note_template_variable_def_here)
565 << VD
566 << Active->InstantiationRange;
567 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
568 Diags.Report(Active->PointOfInstantiation,
569 diag::note_template_enum_def_here)
570 << ED
571 << Active->InstantiationRange;
572 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
573 Diags.Report(Active->PointOfInstantiation,
574 diag::note_template_nsdmi_here)
575 << FD << Active->InstantiationRange;
576 } else {
577 Diags.Report(Active->PointOfInstantiation,
578 diag::note_template_type_alias_instantiation_here)
579 << cast<TypeAliasTemplateDecl>(D)
580 << Active->InstantiationRange;
581 }
582 break;
583 }
584
585 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
586 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
587 SmallString<128> TemplateArgsStr;
588 llvm::raw_svector_ostream OS(TemplateArgsStr);
589 Template->printName(OS);
590 printTemplateArgumentList(OS, Active->template_arguments(),
591 getPrintingPolicy());
592 Diags.Report(Active->PointOfInstantiation,
593 diag::note_default_arg_instantiation_here)
594 << OS.str()
595 << Active->InstantiationRange;
596 break;
597 }
598
599 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
600 FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
601 Diags.Report(Active->PointOfInstantiation,
602 diag::note_explicit_template_arg_substitution_here)
603 << FnTmpl
604 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
605 Active->TemplateArgs,
606 Active->NumTemplateArgs)
607 << Active->InstantiationRange;
608 break;
609 }
610
611 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
612 if (FunctionTemplateDecl *FnTmpl =
613 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
614 Diags.Report(Active->PointOfInstantiation,
615 diag::note_function_template_deduction_instantiation_here)
616 << FnTmpl
617 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
618 Active->TemplateArgs,
619 Active->NumTemplateArgs)
620 << Active->InstantiationRange;
621 } else {
622 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
623 isa<VarTemplateSpecializationDecl>(Active->Entity);
624 bool IsTemplate = false;
625 TemplateParameterList *Params;
626 if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
627 IsTemplate = true;
628 Params = D->getTemplateParameters();
629 } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
630 Active->Entity)) {
631 Params = D->getTemplateParameters();
632 } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
633 Active->Entity)) {
634 Params = D->getTemplateParameters();
635 } else {
636 llvm_unreachable("unexpected template kind")__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
8
'PatternDef' initialized to a null pointer value
2631 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
7
Assuming null pointer is passed into cast
2632 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
9
Assuming the condition is false
10
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;
11
Null pointer value stored to 'Pattern'
2646
2647 // Record the point of instantiation.
2648 if (MemberSpecializationInfo *MSInfo
12
Assuming 'MSInfo' is null
13
Taking false branch
2649 = Instantiation->getMemberSpecializationInfo()) {
2650 MSInfo->setTemplateSpecializationKind(TSK);
2651 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2652 } else if (ClassTemplateSpecializationDecl *Spec
14.1
'Spec' is null
14.1
'Spec' is null
15
Taking false branch
2653 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
14
Assuming 'Instantiation' is not a 'ClassTemplateSpecializationDecl'
2654 Spec->setTemplateSpecializationKind(TSK); 2655 Spec->setPointOfInstantiation(PointOfInstantiation); 2656 } 2657 2658 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
16
Calling constructor for 'InstantiatingTemplate'
28
Returning from constructor for 'InstantiatingTemplate'
2659 if (Inst.isInvalid())
29
Calling 'InstantiatingTemplate::isInvalid'
31
Returning from 'InstantiatingTemplate::isInvalid'
32
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());
33
Called C++ object pointer is null
2695 2696 // Do substitution on the base class specifiers. 2697 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs)) 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) 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(), 2786 E = LateAttrs.end(); I != E; ++I) { 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); 2792 CXXRecordDecl *ThisContext = 2793 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()); 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>(
1
The object is a 'ClassTemplateSpecializationDecl'
3197 ClassTemplateSpec->getCanonicalDecl()); 3198 if (ClassTemplateSpec->isInvalidDecl())
2
Assuming the condition is false
3
Taking false branch
3199 return true; 3200 3201 ActionResult<CXXRecordDecl *> Pattern = 3202 getPatternForClassTemplateSpecialization(*this, PointOfInstantiation, 3203 ClassTemplateSpec, TSK); 3204 if (!Pattern.isUsable())
4
Assuming the condition is false
5
Taking false branch
3205 return Pattern.isInvalid(); 3206 3207 return InstantiateClass(
6
Calling 'Sema::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 = dyn_cast<FunctionDecl>(D)) { 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 = dyn_cast<VarDecl>(D)) { 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 = dyn_cast<CXXRecordDecl>(D)) { 3313 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>()) 3314 continue; 3315 3316 // Always skip the injected-class-name, along with any 3317 // redeclarations of nested classes, since both would cause us 3318 // to try to instantiate the members of a class twice. 3319 // Skip closure types; they'll get instantiated when we instantiate 3320 // the corresponding lambda-expression. 3321 if (Record->isInjectedClassName() || Record->getPreviousDecl() || 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() 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, 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()) { 3355 if (!Pattern->getDefinition()) { 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, 3371 TemplateArgs, 3372 TSK); 3373 } else { 3374 if (TSK == TSK_ExplicitInstantiationDefinition && 3375 Record->getTemplateSpecializationKind() == 3376 TSK_ExplicitInstantiationDeclaration) { 3377 Record->setTemplateSpecializationKind(TSK); 3378 MarkVTableUsed(PointOfInstantiation, Record, true); 3379 } 3380 } 3381 3382 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 3383 if (Pattern) 3384 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs, 3385 TSK); 3386 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) { 3387 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo(); 3388 assert(MSInfo && "No member specialization information?")((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, 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; }
30
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