Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/AST/ExprCXX.h
Warning:line 4693, column 18
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 SemaCoroutine.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/SemaCoroutine.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCoroutine.cpp

→
1//===-- SemaCoroutine.cpp - Semantic Analysis for Coroutines --------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for C++ Coroutines.
10//
11// This file contains references to sections of the Coroutines TS, which
12// can be found at http://wg21.link/coroutines.
13//
14//===----------------------------------------------------------------------===//
15
16#include "CoroutineStmtBuilder.h"
17#include "clang/AST/ASTLambda.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/ExprCXX.h"
20#include "clang/AST/StmtCXX.h"
21#include "clang/Basic/Builtins.h"
22#include "clang/Lex/Preprocessor.h"
23#include "clang/Sema/Initialization.h"
24#include "clang/Sema/Overload.h"
25#include "clang/Sema/ScopeInfo.h"
26#include "clang/Sema/SemaInternal.h"
27#include "llvm/ADT/SmallSet.h"
28
29using namespace clang;
30using namespace sema;
31
32static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
33 SourceLocation Loc, bool &Res) {
34 DeclarationName DN = S.PP.getIdentifierInfo(Name);
35 LookupResult LR(S, DN, Loc, Sema::LookupMemberName);
36 // Suppress diagnostics when a private member is selected. The same warnings
37 // will be produced again when building the call.
38 LR.suppressDiagnostics();
39 Res = S.LookupQualifiedName(LR, RD);
40 return LR;
41}
42
43static bool lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
44 SourceLocation Loc) {
45 bool Res;
46 lookupMember(S, Name, RD, Loc, Res);
47 return Res;
48}
49
50/// Look up the std::coroutine_traits<...>::promise_type for the given
51/// function type.
52static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
53 SourceLocation KwLoc) {
54 const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();
55 const SourceLocation FuncLoc = FD->getLocation();
56 // FIXME: Cache std::coroutine_traits once we've found it.
57 NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
58 if (!StdExp) {
59 S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
60 << "std::experimental::coroutine_traits";
61 return QualType();
62 }
63
64 ClassTemplateDecl *CoroTraits = S.lookupCoroutineTraits(KwLoc, FuncLoc);
65 if (!CoroTraits) {
66 return QualType();
67 }
68
69 // Form template argument list for coroutine_traits<R, P1, P2, ...> according
70 // to [dcl.fct.def.coroutine]3
71 TemplateArgumentListInfo Args(KwLoc, KwLoc);
72 auto AddArg = [&](QualType T) {
73 Args.addArgument(TemplateArgumentLoc(
74 TemplateArgument(T), S.Context.getTrivialTypeSourceInfo(T, KwLoc)));
75 };
76 AddArg(FnType->getReturnType());
77 // If the function is a non-static member function, add the type
78 // of the implicit object parameter before the formal parameters.
79 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
80 if (MD->isInstance()) {
81 // [over.match.funcs]4
82 // For non-static member functions, the type of the implicit object
83 // parameter is
84 // -- "lvalue reference to cv X" for functions declared without a
85 // ref-qualifier or with the & ref-qualifier
86 // -- "rvalue reference to cv X" for functions declared with the &&
87 // ref-qualifier
88 QualType T = MD->getThisType()->castAs<PointerType>()->getPointeeType();
89 T = FnType->getRefQualifier() == RQ_RValue
90 ? S.Context.getRValueReferenceType(T)
91 : S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true);
92 AddArg(T);
93 }
94 }
95 for (QualType T : FnType->getParamTypes())
96 AddArg(T);
97
98 // Build the template-id.
99 QualType CoroTrait =
100 S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);
101 if (CoroTrait.isNull())
102 return QualType();
103 if (S.RequireCompleteType(KwLoc, CoroTrait,
104 diag::err_coroutine_type_missing_specialization))
105 return QualType();
106
107 auto *RD = CoroTrait->getAsCXXRecordDecl();
108 assert(RD && "specialization of class template is not a class?")((void)0);
109
110 // Look up the ::promise_type member.
111 LookupResult R(S, &S.PP.getIdentifierTable().get("promise_type"), KwLoc,
112 Sema::LookupOrdinaryName);
113 S.LookupQualifiedName(R, RD);
114 auto *Promise = R.getAsSingle<TypeDecl>();
115 if (!Promise) {
116 S.Diag(FuncLoc,
117 diag::err_implied_std_coroutine_traits_promise_type_not_found)
118 << RD;
119 return QualType();
120 }
121 // The promise type is required to be a class type.
122 QualType PromiseType = S.Context.getTypeDeclType(Promise);
123
124 auto buildElaboratedType = [&]() {
125 auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, StdExp);
126 NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
127 CoroTrait.getTypePtr());
128 return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
129 };
130
131 if (!PromiseType->getAsCXXRecordDecl()) {
132 S.Diag(FuncLoc,
133 diag::err_implied_std_coroutine_traits_promise_type_not_class)
134 << buildElaboratedType();
135 return QualType();
136 }
137 if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
138 diag::err_coroutine_promise_type_incomplete))
139 return QualType();
140
141 return PromiseType;
142}
143
144/// Look up the std::experimental::coroutine_handle<PromiseType>.
145static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
146 SourceLocation Loc) {
147 if (PromiseType.isNull())
148 return QualType();
149
150 NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
151 assert(StdExp && "Should already be diagnosed")((void)0);
152
153 LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),
154 Loc, Sema::LookupOrdinaryName);
155 if (!S.LookupQualifiedName(Result, StdExp)) {
156 S.Diag(Loc, diag::err_implied_coroutine_type_not_found)
157 << "std::experimental::coroutine_handle";
158 return QualType();
159 }
160
161 ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>();
162 if (!CoroHandle) {
163 Result.suppressDiagnostics();
164 // We found something weird. Complain about the first thing we found.
165 NamedDecl *Found = *Result.begin();
166 S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_handle);
167 return QualType();
168 }
169
170 // Form template argument list for coroutine_handle<Promise>.
171 TemplateArgumentListInfo Args(Loc, Loc);
172 Args.addArgument(TemplateArgumentLoc(
173 TemplateArgument(PromiseType),
174 S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));
175
176 // Build the template-id.
177 QualType CoroHandleType =
178 S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);
179 if (CoroHandleType.isNull())
180 return QualType();
181 if (S.RequireCompleteType(Loc, CoroHandleType,
182 diag::err_coroutine_type_missing_specialization))
183 return QualType();
184
185 return CoroHandleType;
186}
187
188static bool isValidCoroutineContext(Sema &S, SourceLocation Loc,
189 StringRef Keyword) {
190 // [expr.await]p2 dictates that 'co_await' and 'co_yield' must be used within
191 // a function body.
192 // FIXME: This also covers [expr.await]p2: "An await-expression shall not
193 // appear in a default argument." But the diagnostic QoI here could be
194 // improved to inform the user that default arguments specifically are not
195 // allowed.
196 auto *FD = dyn_cast<FunctionDecl>(S.CurContext);
9
←
Assuming field 'CurContext' is a 'FunctionDecl'
→
197 if (!FD
9.1
'FD' is non-null
9.1
'FD' is non-null
9.1
'FD' is non-null
9.1
'FD' is non-null
9.1
'FD' is non-null
) {
10
←
Taking false branch
→
198 S.Diag(Loc, isa<ObjCMethodDecl>(S.CurContext)
199 ? diag::err_coroutine_objc_method
200 : diag::err_coroutine_outside_function) << Keyword;
201 return false;
202 }
203
204 // An enumeration for mapping the diagnostic type to the correct diagnostic
205 // selection index.
206 enum InvalidFuncDiag {
207 DiagCtor = 0,
208 DiagDtor,
209 DiagMain,
210 DiagConstexpr,
211 DiagAutoRet,
212 DiagVarargs,
213 DiagConsteval,
214 };
215 bool Diagnosed = false;
216 auto DiagInvalid = [&](InvalidFuncDiag ID) {
217 S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword;
218 Diagnosed = true;
219 return false;
220 };
221
222 // Diagnose when a constructor, destructor
223 // or the function 'main' are declared as a coroutine.
224 auto *MD = dyn_cast<CXXMethodDecl>(FD);
11
←
Assuming 'FD' is not a 'CXXMethodDecl'
→
225 // [class.ctor]p11: "A constructor shall not be a coroutine."
226 if (MD
11.1
'MD' is null
11.1
'MD' is null
11.1
'MD' is null
11.1
'MD' is null
11.1
'MD' is null
 && isa<CXXConstructorDecl>(MD))
227 return DiagInvalid(DiagCtor);
228 // [class.dtor]p17: "A destructor shall not be a coroutine."
229 else if (MD
11.2
'MD' is null
11.2
'MD' is null
11.2
'MD' is null
11.2
'MD' is null
11.2
'MD' is null
 && isa<CXXDestructorDecl>(MD))
230 return DiagInvalid(DiagDtor);
231 // [basic.start.main]p3: "The function main shall not be a coroutine."
232 else if (FD->isMain())
12
←
Assuming the condition is false
→
13
←
Taking false branch
→
233 return DiagInvalid(DiagMain);
234
235 // Emit a diagnostics for each of the following conditions which is not met.
236 // [expr.const]p2: "An expression e is a core constant expression unless the
237 // evaluation of e [...] would evaluate one of the following expressions:
238 // [...] an await-expression [...] a yield-expression."
239 if (FD->isConstexpr())
14
←
Taking false branch
→
240 DiagInvalid(FD->isConsteval() ? DiagConsteval : DiagConstexpr);
241 // [dcl.spec.auto]p15: "A function declared with a return type that uses a
242 // placeholder type shall not be a coroutine."
243 if (FD->getReturnType()->isUndeducedType())
15
←
Taking false branch
→
244 DiagInvalid(DiagAutoRet);
245 // [dcl.fct.def.coroutine]p1: "The parameter-declaration-clause of the
246 // coroutine shall not terminate with an ellipsis that is not part of a
247 // parameter-declaration."
248 if (FD->isVariadic())
16
←
Assuming the condition is false
→
17
←
Taking false branch
→
249 DiagInvalid(DiagVarargs);
250
251 return !Diagnosed;
18
←
Returning the value 1, which participates in a condition later
→
252}
253
254static ExprResult buildOperatorCoawaitLookupExpr(Sema &SemaRef, Scope *S,
255 SourceLocation Loc) {
256 DeclarationName OpName =
257 SemaRef.Context.DeclarationNames.getCXXOperatorName(OO_Coawait);
258 LookupResult Operators(SemaRef, OpName, SourceLocation(),
259 Sema::LookupOperatorName);
260 SemaRef.LookupName(Operators, S);
261
262 assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous")((void)0);
263 const auto &Functions = Operators.asUnresolvedSet();
264 bool IsOverloaded =
265 Functions.size() > 1 ||
266 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
267 Expr *CoawaitOp = UnresolvedLookupExpr::Create(
268 SemaRef.Context, /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),
269 DeclarationNameInfo(OpName, Loc), /*RequiresADL*/ true, IsOverloaded,
270 Functions.begin(), Functions.end());
271 assert(CoawaitOp)((void)0);
272 return CoawaitOp;
273}
274
275/// Build a call to 'operator co_await' if there is a suitable operator for
276/// the given expression.
277static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, SourceLocation Loc,
278 Expr *E,
279 UnresolvedLookupExpr *Lookup) {
280 UnresolvedSet<16> Functions;
281 Functions.append(Lookup->decls_begin(), Lookup->decls_end());
282 return SemaRef.CreateOverloadedUnaryOp(Loc, UO_Coawait, Functions, E);
283}
284
285static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, Scope *S,
286 SourceLocation Loc, Expr *E) {
287 ExprResult R = buildOperatorCoawaitLookupExpr(SemaRef, S, Loc);
288 if (R.isInvalid())
289 return ExprError();
290 return buildOperatorCoawaitCall(SemaRef, Loc, E,
291 cast<UnresolvedLookupExpr>(R.get()));
292}
293
294static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType,
295 SourceLocation Loc) {
296 QualType CoroHandleType = lookupCoroutineHandleType(S, PromiseType, Loc);
297 if (CoroHandleType.isNull())
298 return ExprError();
299
300 DeclContext *LookupCtx = S.computeDeclContext(CoroHandleType);
301 LookupResult Found(S, &S.PP.getIdentifierTable().get("from_address"), Loc,
302 Sema::LookupOrdinaryName);
303 if (!S.LookupQualifiedName(Found, LookupCtx)) {
304 S.Diag(Loc, diag::err_coroutine_handle_missing_member)
305 << "from_address";
306 return ExprError();
307 }
308
309 Expr *FramePtr =
310 S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {});
311
312 CXXScopeSpec SS;
313 ExprResult FromAddr =
314 S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
315 if (FromAddr.isInvalid())
316 return ExprError();
317
318 return S.BuildCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc);
319}
320
321struct ReadySuspendResumeResult {
322 enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume };
323 Expr *Results[3];
324 OpaqueValueExpr *OpaqueValue;
325 bool IsInvalid;
326};
327
328static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc,
329 StringRef Name, MultiExprArg Args) {
330 DeclarationNameInfo NameInfo(&S.PP.getIdentifierTable().get(Name), Loc);
331
332 // FIXME: Fix BuildMemberReferenceExpr to take a const CXXScopeSpec&.
333 CXXScopeSpec SS;
334 ExprResult Result = S.BuildMemberReferenceExpr(
335 Base, Base->getType(), Loc, /*IsPtr=*/false, SS,
336 SourceLocation(), nullptr, NameInfo, /*TemplateArgs=*/nullptr,
337 /*Scope=*/nullptr);
338 if (Result.isInvalid())
339 return ExprError();
340
341 // We meant exactly what we asked for. No need for typo correction.
342 if (auto *TE = dyn_cast<TypoExpr>(Result.get())) {
343 S.clearDelayedTypo(TE);
344 S.Diag(Loc, diag::err_no_member)
345 << NameInfo.getName() << Base->getType()->getAsCXXRecordDecl()
346 << Base->getSourceRange();
347 return ExprError();
348 }
349
350 return S.BuildCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);
351}
352
353// See if return type is coroutine-handle and if so, invoke builtin coro-resume
354// on its address. This is to enable experimental support for coroutine-handle
355// returning await_suspend that results in a guaranteed tail call to the target
356// coroutine.
357static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
358 SourceLocation Loc) {
359 if (RetType->isReferenceType())
360 return nullptr;
361 Type const *T = RetType.getTypePtr();
362 if (!T->isClassType() && !T->isStructureType())
363 return nullptr;
364
365 // FIXME: Add convertability check to coroutine_handle<>. Possibly via
366 // EvaluateBinaryTypeTrait(BTT_IsConvertible, ...) which is at the moment
367 // a private function in SemaExprCXX.cpp
368
369 ExprResult AddressExpr = buildMemberCall(S, E, Loc, "address", None);
370 if (AddressExpr.isInvalid())
371 return nullptr;
372
373 Expr *JustAddress = AddressExpr.get();
374
375 // Check that the type of AddressExpr is void*
376 if (!JustAddress->getType().getTypePtr()->isVoidPointerType())
377 S.Diag(cast<CallExpr>(JustAddress)->getCalleeDecl()->getLocation(),
378 diag::warn_coroutine_handle_address_invalid_return_type)
379 << JustAddress->getType();
380
381 // Clean up temporary objects so that they don't live across suspension points
382 // unnecessarily. We choose to clean up before the call to
383 // __builtin_coro_resume so that the cleanup code are not inserted in-between
384 // the resume call and return instruction, which would interfere with the
385 // musttail call contract.
386 JustAddress = S.MaybeCreateExprWithCleanups(JustAddress);
387 return S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_resume,
388 JustAddress);
389}
390
391/// Build calls to await_ready, await_suspend, and await_resume for a co_await
392/// expression.
393/// The generated AST tries to clean up temporary objects as early as
394/// possible so that they don't live across suspension points if possible.
395/// Having temporary objects living across suspension points unnecessarily can
396/// lead to large frame size, and also lead to memory corruptions if the
397/// coroutine frame is destroyed after coming back from suspension. This is done
398/// by wrapping both the await_ready call and the await_suspend call with
399/// ExprWithCleanups. In the end of this function, we also need to explicitly
400/// set cleanup state so that the CoawaitExpr is also wrapped with an
401/// ExprWithCleanups to clean up the awaiter associated with the co_await
402/// expression.
403static ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise,
404 SourceLocation Loc, Expr *E) {
405 OpaqueValueExpr *Operand = new (S.Context)
406 OpaqueValueExpr(Loc, E->getType(), VK_LValue, E->getObjectKind(), E);
407
408 // Assume valid until we see otherwise.
409 // Further operations are responsible for setting IsInalid to true.
410 ReadySuspendResumeResult Calls = {{}, Operand, /*IsInvalid=*/false};
411
412 using ACT = ReadySuspendResumeResult::AwaitCallType;
413
414 auto BuildSubExpr = [&](ACT CallType, StringRef Func,
415 MultiExprArg Arg) -> Expr * {
416 ExprResult Result = buildMemberCall(S, Operand, Loc, Func, Arg);
417 if (Result.isInvalid()) {
418 Calls.IsInvalid = true;
419 return nullptr;
420 }
421 Calls.Results[CallType] = Result.get();
422 return Result.get();
423 };
424
425 CallExpr *AwaitReady =
426 cast_or_null<CallExpr>(BuildSubExpr(ACT::ACT_Ready, "await_ready", None));
74
←
Assuming null pointer is passed into cast
→
427 if (!AwaitReady
74.1
'AwaitReady' is null
74.1
'AwaitReady' is null
74.1
'AwaitReady' is null
74.1
'AwaitReady' is null
74.1
'AwaitReady' is null
)
75
←
Taking true branch
→
428 return Calls;
76
←
The value 0 is assigned to 'RSS.IsInvalid', which participates in a condition later
→
77
←
Storing null pointer value
→
429 if (!AwaitReady->getType()->isDependentType()) {
430 // [expr.await]p3 [...]
431 // — await-ready is the expression e.await_ready(), contextually converted
432 // to bool.
433 ExprResult Conv = S.PerformContextuallyConvertToBool(AwaitReady);
434 if (Conv.isInvalid()) {
435 S.Diag(AwaitReady->getDirectCallee()->getBeginLoc(),
436 diag::note_await_ready_no_bool_conversion);
437 S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
438 << AwaitReady->getDirectCallee() << E->getSourceRange();
439 Calls.IsInvalid = true;
440 } else
441 Calls.Results[ACT::ACT_Ready] = S.MaybeCreateExprWithCleanups(Conv.get());
442 }
443
444 ExprResult CoroHandleRes =
445 buildCoroutineHandle(S, CoroPromise->getType(), Loc);
446 if (CoroHandleRes.isInvalid()) {
447 Calls.IsInvalid = true;
448 return Calls;
449 }
450 Expr *CoroHandle = CoroHandleRes.get();
451 CallExpr *AwaitSuspend = cast_or_null<CallExpr>(
452 BuildSubExpr(ACT::ACT_Suspend, "await_suspend", CoroHandle));
453 if (!AwaitSuspend)
454 return Calls;
455 if (!AwaitSuspend->getType()->isDependentType()) {
456 // [expr.await]p3 [...]
457 // - await-suspend is the expression e.await_suspend(h), which shall be
458 // a prvalue of type void, bool, or std::coroutine_handle<Z> for some
459 // type Z.
460 QualType RetType = AwaitSuspend->getCallReturnType(S.Context);
461
462 // Experimental support for coroutine_handle returning await_suspend.
463 if (Expr *TailCallSuspend =
464 maybeTailCall(S, RetType, AwaitSuspend, Loc))
465 // Note that we don't wrap the expression with ExprWithCleanups here
466 // because that might interfere with tailcall contract (e.g. inserting
467 // clean up instructions in-between tailcall and return). Instead
468 // ExprWithCleanups is wrapped within maybeTailCall() prior to the resume
469 // call.
470 Calls.Results[ACT::ACT_Suspend] = TailCallSuspend;
471 else {
472 // non-class prvalues always have cv-unqualified types
473 if (RetType->isReferenceType() ||
474 (!RetType->isBooleanType() && !RetType->isVoidType())) {
475 S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(),
476 diag::err_await_suspend_invalid_return_type)
477 << RetType;
478 S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
479 << AwaitSuspend->getDirectCallee();
480 Calls.IsInvalid = true;
481 } else
482 Calls.Results[ACT::ACT_Suspend] =
483 S.MaybeCreateExprWithCleanups(AwaitSuspend);
484 }
485 }
486
487 BuildSubExpr(ACT::ACT_Resume, "await_resume", None);
488
489 // Make sure the awaiter object gets a chance to be cleaned up.
490 S.Cleanup.setExprNeedsCleanups(true);
491
492 return Calls;
493}
494
495static ExprResult buildPromiseCall(Sema &S, VarDecl *Promise,
496 SourceLocation Loc, StringRef Name,
497 MultiExprArg Args) {
498
499 // Form a reference to the promise.
500 ExprResult PromiseRef = S.BuildDeclRefExpr(
501 Promise, Promise->getType().getNonReferenceType(), VK_LValue, Loc);
502 if (PromiseRef.isInvalid())
503 return ExprError();
504
505 return buildMemberCall(S, PromiseRef.get(), Loc, Name, Args);
506}
507
508VarDecl *Sema::buildCoroutinePromise(SourceLocation Loc) {
509 assert(isa<FunctionDecl>(CurContext) && "not in a function scope")((void)0);
510 auto *FD = cast<FunctionDecl>(CurContext);
36
←
Field 'CurContext' is a 'FunctionDecl'
→
511 bool IsThisDependentType = [&] {
512 if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD))
513 return MD->isInstance() && MD->getThisType()->isDependentType();
514 else
515 return false;
516 }();
517
518 QualType T = FD->getType()->isDependentType() || IsThisDependentType
37.1
'IsThisDependentType' is false
37.1
'IsThisDependentType' is false
37.1
'IsThisDependentType' is false
37.1
'IsThisDependentType' is false
37.1
'IsThisDependentType' is false
37
←
Assuming the condition is false
→
38
←
'?' condition is false
→
519 ? Context.DependentTy 520 : lookupPromiseType(*this, FD, Loc); 521 if (T.isNull())
39
←
Calling 'QualType::isNull'
→
45
←
Returning from 'QualType::isNull'
→
46
←
Taking false branch
→
522 return nullptr; 523 524 auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(), 525 &PP.getIdentifierTable().get("__promise"), T, 526 Context.getTrivialTypeSourceInfo(T, Loc), SC_None); 527 VD->setImplicit(); 528 CheckVariableDeclarationType(VD); 529 if (VD->isInvalidDecl())
47
←
Assuming the condition is false
→
48
←
Taking false branch
→
530 return nullptr; 531 532 auto *ScopeInfo = getCurFunction(); 533 534 // Build a list of arguments, based on the coroutine function's arguments, 535 // that if present will be passed to the promise type's constructor. 536 llvm::SmallVector<Expr *, 4> CtorArgExprs; 537 538 // Add implicit object parameter. 539 if (auto *MD
49.1
'MD' is null
49.1
'MD' is null
49.1
'MD' is null
49.1
'MD' is null
49.1
'MD' is null
 = dyn_cast<CXXMethodDecl>(FD)) {
49
←
'FD' is not a 'CXXMethodDecl'
→
50
←
Taking false branch
→
540 if (MD->isInstance() && !isLambdaCallOperator(MD)) { 541 ExprResult ThisExpr = ActOnCXXThis(Loc); 542 if (ThisExpr.isInvalid()) 543 return nullptr; 544 ThisExpr = CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get()); 545 if (ThisExpr.isInvalid()) 546 return nullptr; 547 CtorArgExprs.push_back(ThisExpr.get()); 548 } 549 } 550 551 // Add the coroutine function's parameters. 552 auto &Moves = ScopeInfo->CoroutineParameterMoves; 553 for (auto *PD : FD->parameters()) {
51
←
Assuming '__begin1' is equal to '__end1'
→
554 if (PD->getType()->isDependentType()) 555 continue; 556 557 auto RefExpr = ExprEmpty(); 558 auto Move = Moves.find(PD); 559 assert(Move != Moves.end() &&((void)0) 560 "Coroutine function parameter not inserted into move map")((void)0); 561 // If a reference to the function parameter exists in the coroutine 562 // frame, use that reference. 563 auto *MoveDecl = 564 cast<VarDecl>(cast<DeclStmt>(Move->second)->getSingleDecl()); 565 RefExpr = 566 BuildDeclRefExpr(MoveDecl, MoveDecl->getType().getNonReferenceType(), 567 ExprValueKind::VK_LValue, FD->getLocation()); 568 if (RefExpr.isInvalid()) 569 return nullptr; 570 CtorArgExprs.push_back(RefExpr.get()); 571 } 572 573 // If we have a non-zero number of constructor arguments, try to use them. 574 // Otherwise, fall back to the promise type's default constructor. 575 if (!CtorArgExprs.empty()) {
52
←
Taking true branch
→
576 // Create an initialization sequence for the promise type using the 577 // constructor arguments, wrapped in a parenthesized list expression. 578 Expr *PLE = ParenListExpr::Create(Context, FD->getLocation(), 579 CtorArgExprs, FD->getLocation()); 580 InitializedEntity Entity = InitializedEntity::InitializeVariable(VD); 581 InitializationKind Kind = InitializationKind::CreateForInit( 582 VD->getLocation(), /*DirectInit=*/true, PLE); 583 InitializationSequence InitSeq(*this, Entity, Kind, CtorArgExprs, 584 /*TopLevelOfInitList=*/false, 585 /*TreatUnavailableAsInvalid=*/false); 586 587 // Attempt to initialize the promise type with the arguments. 588 // If that fails, fall back to the promise type's default constructor. 589 if (InitSeq) {
53
←
Taking true branch
→
590 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, CtorArgExprs); 591 if (Result.isInvalid()) {
54
←
Assuming the condition is false
→
55
←
Taking false branch
→
592 VD->setInvalidDecl(); 593 } else if (Result.get()) {
56
←
Assuming the condition is false
→
57
←
Taking false branch
→
594 VD->setInit(MaybeCreateExprWithCleanups(Result.get())); 595 VD->setInitStyle(VarDecl::CallInit); 596 CheckCompleteVariableDeclaration(VD); 597 } 598 } else 599 ActOnUninitializedDecl(VD); 600 } else 601 ActOnUninitializedDecl(VD); 602 603 FD->addDecl(VD); 604 return VD;
58
←
Returning pointer (loaded from 'VD'), which participates in a condition later
→
605} 606 607/// Check that this is a context in which a coroutine suspension can appear. 608static FunctionScopeInfo *checkCoroutineContext(Sema &S, SourceLocation Loc, 609 StringRef Keyword, 610 bool IsImplicit = false) { 611 if (!isValidCoroutineContext(S, Loc, Keyword))
8
←
Calling 'isValidCoroutineContext'
→
19
←
Returning from 'isValidCoroutineContext'
→
20
←
Taking false branch
→
612 return nullptr; 613 614 assert(isa<FunctionDecl>(S.CurContext) && "not in a function scope")((void)0); 615 616 auto *ScopeInfo = S.getCurFunction();
21
←
Calling 'Sema::getCurFunction'
→
24
←
Returning from 'Sema::getCurFunction'
→
617 assert(ScopeInfo && "missing function scope for function")((void)0); 618 619 if (ScopeInfo->FirstCoroutineStmtLoc.isInvalid() && !IsImplicit) 620 ScopeInfo->setFirstCoroutineStmt(Loc, Keyword); 621 622 if (ScopeInfo->CoroutinePromise)
25
←
Assuming field 'CoroutinePromise' is null
→
26
←
Taking false branch
→
623 return ScopeInfo; 624 625 if (!S.buildCoroutineParameterMoves(Loc))
27
←
Calling 'Sema::buildCoroutineParameterMoves'
→
33
←
Returning from 'Sema::buildCoroutineParameterMoves'
→
34
←
Taking false branch
→
626 return nullptr; 627 628 ScopeInfo->CoroutinePromise = S.buildCoroutinePromise(Loc);
35
←
Calling 'Sema::buildCoroutinePromise'
→
59
←
Returning from 'Sema::buildCoroutinePromise'
→
629 if (!ScopeInfo->CoroutinePromise
59.1
Field 'CoroutinePromise' is non-null
59.1
Field 'CoroutinePromise' is non-null
59.1
Field 'CoroutinePromise' is non-null
59.1
Field 'CoroutinePromise' is non-null
59.1
Field 'CoroutinePromise' is non-null
)
60
←
Taking false branch
→
630 return nullptr; 631 632 return ScopeInfo;
61
←
Returning pointer (loaded from 'ScopeInfo'), which participates in a condition later
→
633} 634 635/// Recursively check \p E and all its children to see if any call target 636/// (including constructor call) is declared noexcept. Also any value returned 637/// from the call has a noexcept destructor. 638static void checkNoThrow(Sema &S, const Stmt *E, 639 llvm::SmallPtrSetImpl<const Decl *> &ThrowingDecls) { 640 auto checkDeclNoexcept = [&](const Decl *D, bool IsDtor = false) { 641 // In the case of dtor, the call to dtor is implicit and hence we should 642 // pass nullptr to canCalleeThrow. 643 if (Sema::canCalleeThrow(S, IsDtor ? nullptr : cast<Expr>(E), D)) { 644 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 645 // co_await promise.final_suspend() could end up calling 646 // __builtin_coro_resume for symmetric transfer if await_suspend() 647 // returns a handle. In that case, even __builtin_coro_resume is not 648 // declared as noexcept and may throw, it does not throw _into_ the 649 // coroutine that just suspended, but rather throws back out from 650 // whoever called coroutine_handle::resume(), hence we claim that 651 // logically it does not throw. 652 if (FD->getBuiltinID() == Builtin::BI__builtin_coro_resume) 653 return; 654 } 655 if (ThrowingDecls.empty()) { 656 // First time seeing an error, emit the error message. 657 S.Diag(cast<FunctionDecl>(S.CurContext)->getLocation(), 658 diag::err_coroutine_promise_final_suspend_requires_nothrow); 659 } 660 ThrowingDecls.insert(D); 661 } 662 }; 663 auto SC = E->getStmtClass(); 664 if (SC == Expr::CXXConstructExprClass) { 665 auto const *Ctor = cast<CXXConstructExpr>(E)->getConstructor(); 666 checkDeclNoexcept(Ctor); 667 // Check the corresponding destructor of the constructor. 668 checkDeclNoexcept(Ctor->getParent()->getDestructor(), true); 669 } else if (SC == Expr::CallExprClass || SC == Expr::CXXMemberCallExprClass || 670 SC == Expr::CXXOperatorCallExprClass) { 671 if (!cast<CallExpr>(E)->isTypeDependent()) { 672 checkDeclNoexcept(cast<CallExpr>(E)->getCalleeDecl()); 673 auto ReturnType = cast<CallExpr>(E)->getCallReturnType(S.getASTContext()); 674 // Check the destructor of the call return type, if any. 675 if (ReturnType.isDestructedType() == 676 QualType::DestructionKind::DK_cxx_destructor) { 677 const auto *T = 678 cast<RecordType>(ReturnType.getCanonicalType().getTypePtr()); 679 checkDeclNoexcept( 680 dyn_cast<CXXRecordDecl>(T->getDecl())->getDestructor(), true); 681 } 682 } 683 } 684 for (const auto *Child : E->children()) { 685 if (!Child) 686 continue; 687 checkNoThrow(S, Child, ThrowingDecls); 688 } 689} 690 691bool Sema::checkFinalSuspendNoThrow(const Stmt *FinalSuspend) { 692 llvm::SmallPtrSet<const Decl *, 4> ThrowingDecls; 693 // We first collect all declarations that should not throw but not declared 694 // with noexcept. We then sort them based on the location before printing. 695 // This is to avoid emitting the same note multiple times on the same 696 // declaration, and also provide a deterministic order for the messages. 697 checkNoThrow(*this, FinalSuspend, ThrowingDecls); 698 auto SortedDecls = llvm::SmallVector<const Decl *, 4>{ThrowingDecls.begin(), 699 ThrowingDecls.end()}; 700 sort(SortedDecls, [](const Decl *A, const Decl *B) { 701 return A->getEndLoc() < B->getEndLoc(); 702 }); 703 for (const auto *D : SortedDecls) { 704 Diag(D->getEndLoc(), diag::note_coroutine_function_declare_noexcept); 705 } 706 return ThrowingDecls.empty(); 707} 708 709bool Sema::ActOnCoroutineBodyStart(Scope *SC, SourceLocation KWLoc, 710 StringRef Keyword) { 711 if (!checkCoroutineContext(*this, KWLoc, Keyword)) 712 return false; 713 auto *ScopeInfo = getCurFunction(); 714 assert(ScopeInfo->CoroutinePromise)((void)0); 715 716 // If we have existing coroutine statements then we have already built 717 // the initial and final suspend points. 718 if (!ScopeInfo->NeedsCoroutineSuspends) 719 return true; 720 721 ScopeInfo->setNeedsCoroutineSuspends(false); 722 723 auto *Fn = cast<FunctionDecl>(CurContext); 724 SourceLocation Loc = Fn->getLocation(); 725 // Build the initial suspend point 726 auto buildSuspends = [&](StringRef Name) mutable -> StmtResult { 727 ExprResult Suspend = 728 buildPromiseCall(*this, ScopeInfo->CoroutinePromise, Loc, Name, None); 729 if (Suspend.isInvalid()) 730 return StmtError(); 731 Suspend = buildOperatorCoawaitCall(*this, SC, Loc, Suspend.get()); 732 if (Suspend.isInvalid()) 733 return StmtError(); 734 Suspend = BuildResolvedCoawaitExpr(Loc, Suspend.get(), 735 /*IsImplicit*/ true); 736 Suspend = ActOnFinishFullExpr(Suspend.get(), /*DiscardedValue*/ false); 737 if (Suspend.isInvalid()) { 738 Diag(Loc, diag::note_coroutine_promise_suspend_implicitly_required) 739 << ((Name == "initial_suspend") ? 0 : 1); 740 Diag(KWLoc, diag::note_declared_coroutine_here) << Keyword; 741 return StmtError(); 742 } 743 return cast<Stmt>(Suspend.get()); 744 }; 745 746 StmtResult InitSuspend = buildSuspends("initial_suspend"); 747 if (InitSuspend.isInvalid()) 748 return true; 749 750 StmtResult FinalSuspend = buildSuspends("final_suspend"); 751 if (FinalSuspend.isInvalid() || !checkFinalSuspendNoThrow(FinalSuspend.get())) 752 return true; 753 754 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get()); 755 756 return true; 757} 758 759// Recursively walks up the scope hierarchy until either a 'catch' or a function 760// scope is found, whichever comes first. 761static bool isWithinCatchScope(Scope *S) { 762 // 'co_await' and 'co_yield' keywords are disallowed within catch blocks, but 763 // lambdas that use 'co_await' are allowed. The loop below ends when a 764 // function scope is found in order to ensure the following behavior: 765 // 766 // void foo() { // <- function scope 767 // try { // 768 // co_await x; // <- 'co_await' is OK within a function scope 769 // } catch { // <- catch scope 770 // co_await x; // <- 'co_await' is not OK within a catch scope 771 // []() { // <- function scope 772 // co_await x; // <- 'co_await' is OK within a function scope 773 // }(); 774 // } 775 // } 776 while (S && !(S->getFlags() & Scope::FnScope)) { 777 if (S->getFlags() & Scope::CatchScope) 778 return true; 779 S = S->getParent(); 780 } 781 return false; 782} 783 784// [expr.await]p2, emphasis added: "An await-expression shall appear only in 785// a *potentially evaluated* expression within the compound-statement of a 786// function-body *outside of a handler* [...] A context within a function 787// where an await-expression can appear is called a suspension context of the 788// function." 789static void checkSuspensionContext(Sema &S, SourceLocation Loc, 790 StringRef Keyword) { 791 // First emphasis of [expr.await]p2: must be a potentially evaluated context. 792 // That is, 'co_await' and 'co_yield' cannot appear in subexpressions of 793 // \c sizeof. 794 if (S.isUnevaluatedContext()) 795 S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword; 796 797 // Second emphasis of [expr.await]p2: must be outside of an exception handler. 798 if (isWithinCatchScope(S.getCurScope())) 799 S.Diag(Loc, diag::err_coroutine_within_handler) << Keyword; 800} 801 802ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) { 803 if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) { 804 CorrectDelayedTyposInExpr(E); 805 return ExprError(); 806 } 807 808 checkSuspensionContext(*this, Loc, "co_await"); 809 810 if (E->getType()->isPlaceholderType()) { 811 ExprResult R = CheckPlaceholderExpr(E); 812 if (R.isInvalid()) return ExprError(); 813 E = R.get(); 814 } 815 ExprResult Lookup = buildOperatorCoawaitLookupExpr(*this, S, Loc); 816 if (Lookup.isInvalid()) 817 return ExprError(); 818 return BuildUnresolvedCoawaitExpr(Loc, E, 819 cast<UnresolvedLookupExpr>(Lookup.get())); 820} 821 822ExprResult Sema::BuildUnresolvedCoawaitExpr(SourceLocation Loc, Expr *E, 823 UnresolvedLookupExpr *Lookup) { 824 auto *FSI = checkCoroutineContext(*this, Loc, "co_await"); 825 if (!FSI) 826 return ExprError(); 827 828 if (E->getType()->isPlaceholderType()) { 829 ExprResult R = CheckPlaceholderExpr(E); 830 if (R.isInvalid()) 831 return ExprError(); 832 E = R.get(); 833 } 834 835 auto *Promise = FSI->CoroutinePromise; 836 if (Promise->getType()->isDependentType()) { 837 Expr *Res = 838 new (Context) DependentCoawaitExpr(Loc, Context.DependentTy, E, Lookup); 839 return Res; 840 } 841 842 auto *RD = Promise->getType()->getAsCXXRecordDecl(); 843 if (lookupMember(*this, "await_transform", RD, Loc)) { 844 ExprResult R = buildPromiseCall(*this, Promise, Loc, "await_transform", E); 845 if (R.isInvalid()) { 846 Diag(Loc, 847 diag::note_coroutine_promise_implicit_await_transform_required_here) 848 << E->getSourceRange(); 849 return ExprError(); 850 } 851 E = R.get(); 852 } 853 ExprResult Awaitable = buildOperatorCoawaitCall(*this, Loc, E, Lookup); 854 if (Awaitable.isInvalid()) 855 return ExprError(); 856 857 return BuildResolvedCoawaitExpr(Loc, Awaitable.get()); 858} 859 860ExprResult Sema::BuildResolvedCoawaitExpr(SourceLocation Loc, Expr *E, 861 bool IsImplicit) { 862 auto *Coroutine = checkCoroutineContext(*this, Loc, "co_await", IsImplicit); 863 if (!Coroutine) 864 return ExprError(); 865 866 if (E->getType()->isPlaceholderType()) { 867 ExprResult R = CheckPlaceholderExpr(E); 868 if (R.isInvalid()) return ExprError(); 869 E = R.get(); 870 } 871 872 if (E->getType()->isDependentType()) { 873 Expr *Res = new (Context) 874 CoawaitExpr(Loc, Context.DependentTy, E, IsImplicit); 875 return Res; 876 } 877 878 // If the expression is a temporary, materialize it as an lvalue so that we 879 // can use it multiple times. 880 if (E->isPRValue()) 881 E = CreateMaterializeTemporaryExpr(E->getType(), E, true); 882 883 // The location of the `co_await` token cannot be used when constructing 884 // the member call expressions since it's before the location of `Expr`, which 885 // is used as the start of the member call expression. 886 SourceLocation CallLoc = E->getExprLoc(); 887 888 // Build the await_ready, await_suspend, await_resume calls. 889 ReadySuspendResumeResult RSS = buildCoawaitCalls( 890 *this, Coroutine->CoroutinePromise, CallLoc, E); 891 if (RSS.IsInvalid) 892 return ExprError(); 893 894 Expr *Res = 895 new (Context) CoawaitExpr(Loc, E, RSS.Results[0], RSS.Results[1], 896 RSS.Results[2], RSS.OpaqueValue, IsImplicit); 897 898 return Res; 899} 900 901ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) { 902 if (!ActOnCoroutineBodyStart(S, Loc, "co_yield")) {
1
Taking false branch
→
903 CorrectDelayedTyposInExpr(E); 904 return ExprError(); 905 } 906 907 checkSuspensionContext(*this, Loc, "co_yield"); 908 909 // Build yield_value call. 910 ExprResult Awaitable = buildPromiseCall( 911 *this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E); 912 if (Awaitable.isInvalid())
2
←
Assuming the condition is false
→
3
←
Taking false branch
→
913 return ExprError(); 914 915 // Build 'operator co_await' call. 916 Awaitable = buildOperatorCoawaitCall(*this, S, Loc, Awaitable.get()); 917 if (Awaitable.isInvalid())
4
←
Assuming the condition is false
→
5
←
Taking false branch
→
918 return ExprError(); 919 920 return BuildCoyieldExpr(Loc, Awaitable.get());
6
←
Calling 'Sema::BuildCoyieldExpr'
→
921} 922ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) { 923 auto *Coroutine = checkCoroutineContext(*this, Loc, "co_yield");
7
←
Calling 'checkCoroutineContext'
→
62
←
Returning from 'checkCoroutineContext'
→
924 if (!Coroutine
62.1
'Coroutine' is non-null
62.1
'Coroutine' is non-null
62.1
'Coroutine' is non-null
62.1
'Coroutine' is non-null
62.1
'Coroutine' is non-null
)
63
←
Taking false branch
→
925 return ExprError(); 926 927 if (E->getType()->isPlaceholderType()) {
64
←
Calling 'Type::isPlaceholderType'
→
68
←
Returning from 'Type::isPlaceholderType'
→
69
←
Taking false branch
→
928 ExprResult R = CheckPlaceholderExpr(E); 929 if (R.isInvalid()) return ExprError(); 930 E = R.get(); 931 } 932 933 if (E->getType()->isDependentType()) {
70
←
Assuming the condition is false
→
71
←
Taking false branch
→
934 Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, E); 935 return Res; 936 } 937 938 // If the expression is a temporary, materialize it as an lvalue so that we 939 // can use it multiple times. 940 if (E->isPRValue())
72
←
Taking false branch
→
941 E = CreateMaterializeTemporaryExpr(E->getType(), E, true); 942 943 // Build the await_ready, await_suspend, await_resume calls. 944 ReadySuspendResumeResult RSS = buildCoawaitCalls(
73
←
Calling 'buildCoawaitCalls'
→
78
←
Returning from 'buildCoawaitCalls'
→
945 *this, Coroutine->CoroutinePromise, Loc, E); 946 if (RSS.IsInvalid
78.1
Field 'IsInvalid' is false
78.1
Field 'IsInvalid' is false
78.1
Field 'IsInvalid' is false
78.1
Field 'IsInvalid' is false
78.1
Field 'IsInvalid' is false
)
79
←
Taking false branch
→
947 return ExprError(); 948 949 Expr *Res = 950 new (Context) CoyieldExpr(Loc, E, RSS.Results[0], RSS.Results[1],
81
←
Calling constructor for 'CoyieldExpr'
→
951 RSS.Results[2], RSS.OpaqueValue);
80
←
Passing null pointer value via 5th parameter 'Resume'
→
952 953 return Res; 954} 955 956StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) { 957 if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) { 958 CorrectDelayedTyposInExpr(E); 959 return StmtError(); 960 } 961 return BuildCoreturnStmt(Loc, E); 962} 963 964StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E, 965 bool IsImplicit) { 966 auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit); 967 if (!FSI) 968 return StmtError(); 969 970 if (E && E->getType()->isPlaceholderType() && 971 !E->getType()->isSpecificPlaceholderType(BuiltinType::Overload)) { 972 ExprResult R = CheckPlaceholderExpr(E); 973 if (R.isInvalid()) return StmtError(); 974 E = R.get(); 975 } 976 977 VarDecl *Promise = FSI->CoroutinePromise; 978 ExprResult PC; 979 if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) { 980 getNamedReturnInfo(E, SimplerImplicitMoveMode::ForceOn); 981 PC = buildPromiseCall(*this, Promise, Loc, "return_value", E); 982 } else { 983 E = MakeFullDiscardedValueExpr(E).get(); 984 PC = buildPromiseCall(*this, Promise, Loc, "return_void", None); 985 } 986 if (PC.isInvalid()) 987 return StmtError(); 988 989 Expr *PCE = ActOnFinishFullExpr(PC.get(), /*DiscardedValue*/ false).get(); 990 991 Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit); 992 return Res; 993} 994 995/// Look up the std::nothrow object. 996static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) { 997 NamespaceDecl *Std = S.getStdNamespace(); 998 assert(Std && "Should already be diagnosed")((void)0); 999 1000 LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc, 1001 Sema::LookupOrdinaryName); 1002 if (!S.LookupQualifiedName(Result, Std)) { 1003 // FIXME: <experimental/coroutine> should have been included already. 1004 // If we require it to include <new> then this diagnostic is no longer 1005 // needed. 1006 S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found); 1007 return nullptr; 1008 } 1009 1010 auto *VD = Result.getAsSingle<VarDecl>(); 1011 if (!VD) { 1012 Result.suppressDiagnostics(); 1013 // We found something weird. Complain about the first thing we found. 1014 NamedDecl *Found = *Result.begin(); 1015 S.Diag(Found->getLocation(), diag::err_malformed_std_nothrow); 1016 return nullptr; 1017 } 1018 1019 ExprResult DR = S.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, Loc); 1020 if (DR.isInvalid()) 1021 return nullptr; 1022 1023 return DR.get(); 1024} 1025 1026// Find an appropriate delete for the promise. 1027static FunctionDecl *findDeleteForPromise(Sema &S, SourceLocation Loc, 1028 QualType PromiseType) { 1029 FunctionDecl *OperatorDelete = nullptr; 1030 1031 DeclarationName DeleteName = 1032 S.Context.DeclarationNames.getCXXOperatorName(OO_Delete); 1033 1034 auto *PointeeRD = PromiseType->getAsCXXRecordDecl(); 1035 assert(PointeeRD && "PromiseType must be a CxxRecordDecl type")((void)0); 1036 1037 if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete)) 1038 return nullptr; 1039 1040 if (!OperatorDelete) { 1041 // Look for a global declaration. 1042 const bool CanProvideSize = S.isCompleteType(Loc, PromiseType); 1043 const bool Overaligned = false; 1044 OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize, 1045 Overaligned, DeleteName); 1046 } 1047 S.MarkFunctionReferenced(Loc, OperatorDelete); 1048 return OperatorDelete; 1049} 1050 1051 1052void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) { 1053 FunctionScopeInfo *Fn = getCurFunction(); 1054 assert(Fn && Fn->isCoroutine() && "not a coroutine")((void)0); 1055 if (!Body) { 1056 assert(FD->isInvalidDecl() &&((void)0) 1057 "a null body is only allowed for invalid declarations")((void)0); 1058 return; 1059 } 1060 // We have a function that uses coroutine keywords, but we failed to build 1061 // the promise type. 1062 if (!Fn->CoroutinePromise) 1063 return FD->setInvalidDecl(); 1064 1065 if (isa<CoroutineBodyStmt>(Body)) { 1066 // Nothing todo. the body is already a transformed coroutine body statement. 1067 return; 1068 } 1069 1070 // Coroutines [stmt.return]p1: 1071 // A return statement shall not appear in a coroutine. 1072 if (Fn->FirstReturnLoc.isValid()) { 1073 assert(Fn->FirstCoroutineStmtLoc.isValid() &&((void)0) 1074 "first coroutine location not set")((void)0); 1075 Diag(Fn->FirstReturnLoc, diag::err_return_in_coroutine); 1076 Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) 1077 << Fn->getFirstCoroutineStmtKeyword(); 1078 } 1079 CoroutineStmtBuilder Builder(*this, *FD, *Fn, Body); 1080 if (Builder.isInvalid() || !Builder.buildStatements()) 1081 return FD->setInvalidDecl(); 1082 1083 // Build body for the coroutine wrapper statement. 1084 Body = CoroutineBodyStmt::Create(Context, Builder); 1085} 1086 1087CoroutineStmtBuilder::CoroutineStmtBuilder(Sema &S, FunctionDecl &FD, 1088 sema::FunctionScopeInfo &Fn, 1089 Stmt *Body) 1090 : S(S), FD(FD), Fn(Fn), Loc(FD.getLocation()), 1091 IsPromiseDependentType( 1092 !Fn.CoroutinePromise || 1093 Fn.CoroutinePromise->getType()->isDependentType()) { 1094 this->Body = Body; 1095 1096 for (auto KV : Fn.CoroutineParameterMoves) 1097 this->ParamMovesVector.push_back(KV.second); 1098 this->ParamMoves = this->ParamMovesVector; 1099 1100 if (!IsPromiseDependentType) { 1101 PromiseRecordDecl = Fn.CoroutinePromise->getType()->getAsCXXRecordDecl(); 1102 assert(PromiseRecordDecl && "Type should have already been checked")((void)0); 1103 } 1104 this->IsValid = makePromiseStmt() && makeInitialAndFinalSuspend(); 1105} 1106 1107bool CoroutineStmtBuilder::buildStatements() { 1108 assert(this->IsValid && "coroutine already invalid")((void)0); 1109 this->IsValid = makeReturnObject(); 1110 if (this->IsValid && !IsPromiseDependentType) 1111 buildDependentStatements(); 1112 return this->IsValid; 1113} 1114 1115bool CoroutineStmtBuilder::buildDependentStatements() { 1116 assert(this->IsValid && "coroutine already invalid")((void)0); 1117 assert(!this->IsPromiseDependentType &&((void)0) 1118 "coroutine cannot have a dependent promise type")((void)0); 1119 this->IsValid = makeOnException() && makeOnFallthrough() && 1120 makeGroDeclAndReturnStmt() && makeReturnOnAllocFailure() && 1121 makeNewAndDeleteExpr(); 1122 return this->IsValid; 1123} 1124 1125bool CoroutineStmtBuilder::makePromiseStmt() { 1126 // Form a declaration statement for the promise declaration, so that AST 1127 // visitors can more easily find it. 1128 StmtResult PromiseStmt = 1129 S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(Fn.CoroutinePromise), Loc, Loc); 1130 if (PromiseStmt.isInvalid()) 1131 return false; 1132 1133 this->Promise = PromiseStmt.get(); 1134 return true; 1135} 1136 1137bool CoroutineStmtBuilder::makeInitialAndFinalSuspend() { 1138 if (Fn.hasInvalidCoroutineSuspends()) 1139 return false; 1140 this->InitialSuspend = cast<Expr>(Fn.CoroutineSuspends.first); 1141 this->FinalSuspend = cast<Expr>(Fn.CoroutineSuspends.second); 1142 return true; 1143} 1144 1145static bool diagReturnOnAllocFailure(Sema &S, Expr *E, 1146 CXXRecordDecl *PromiseRecordDecl, 1147 FunctionScopeInfo &Fn) { 1148 auto Loc = E->getExprLoc(); 1149 if (auto *DeclRef = dyn_cast_or_null<DeclRefExpr>(E)) { 1150 auto *Decl = DeclRef->getDecl(); 1151 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(Decl)) { 1152 if (Method->isStatic()) 1153 return true; 1154 else 1155 Loc = Decl->getLocation(); 1156 } 1157 } 1158 1159 S.Diag( 1160 Loc, 1161 diag::err_coroutine_promise_get_return_object_on_allocation_failure) 1162 << PromiseRecordDecl; 1163 S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) 1164 << Fn.getFirstCoroutineStmtKeyword(); 1165 return false; 1166} 1167 1168bool CoroutineStmtBuilder::makeReturnOnAllocFailure() { 1169 assert(!IsPromiseDependentType &&((void)0) 1170 "cannot make statement while the promise type is dependent")((void)0); 1171 1172 // [dcl.fct.def.coroutine]/8 1173 // The unqualified-id get_return_object_on_allocation_failure is looked up in 1174 // the scope of class P by class member access lookup (3.4.5). ... 1175 // If an allocation function returns nullptr, ... the coroutine return value 1176 // is obtained by a call to ... get_return_object_on_allocation_failure(). 1177 1178 DeclarationName DN = 1179 S.PP.getIdentifierInfo("get_return_object_on_allocation_failure"); 1180 LookupResult Found(S, DN, Loc, Sema::LookupMemberName); 1181 if (!S.LookupQualifiedName(Found, PromiseRecordDecl)) 1182 return true; 1183 1184 CXXScopeSpec SS; 1185 ExprResult DeclNameExpr = 1186 S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false); 1187 if (DeclNameExpr.isInvalid()) 1188 return false; 1189 1190 if (!diagReturnOnAllocFailure(S, DeclNameExpr.get(), PromiseRecordDecl, Fn)) 1191 return false; 1192 1193 ExprResult ReturnObjectOnAllocationFailure = 1194 S.BuildCallExpr(nullptr, DeclNameExpr.get(), Loc, {}, Loc); 1195 if (ReturnObjectOnAllocationFailure.isInvalid()) 1196 return false; 1197 1198 StmtResult ReturnStmt = 1199 S.BuildReturnStmt(Loc, ReturnObjectOnAllocationFailure.get()); 1200 if (ReturnStmt.isInvalid()) { 1201 S.Diag(Found.getFoundDecl()->getLocation(), diag::note_member_declared_here) 1202 << DN; 1203 S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) 1204 << Fn.getFirstCoroutineStmtKeyword(); 1205 return false; 1206 } 1207 1208 this->ReturnStmtOnAllocFailure = ReturnStmt.get(); 1209 return true; 1210} 1211 1212bool CoroutineStmtBuilder::makeNewAndDeleteExpr() { 1213 // Form and check allocation and deallocation calls. 1214 assert(!IsPromiseDependentType &&((void)0) 1215 "cannot make statement while the promise type is dependent")((void)0); 1216 QualType PromiseType = Fn.CoroutinePromise->getType(); 1217 1218 if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type)) 1219 return false; 1220 1221 const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr; 1222 1223 // [dcl.fct.def.coroutine]/7 1224 // Lookup allocation functions using a parameter list composed of the 1225 // requested size of the coroutine state being allocated, followed by 1226 // the coroutine function's arguments. If a matching allocation function 1227 // exists, use it. Otherwise, use an allocation function that just takes 1228 // the requested size. 1229 1230 FunctionDecl *OperatorNew = nullptr; 1231 FunctionDecl *OperatorDelete = nullptr; 1232 FunctionDecl *UnusedResult = nullptr; 1233 bool PassAlignment = false; 1234 SmallVector<Expr *, 1> PlacementArgs; 1235 1236 // [dcl.fct.def.coroutine]/7 1237 // "The allocation function’s name is looked up in the scope of P. 1238 // [...] If the lookup finds an allocation function in the scope of P, 1239 // overload resolution is performed on a function call created by assembling 1240 // an argument list. The first argument is the amount of space requested, 1241 // and has type std::size_t. The lvalues p1 ... pn are the succeeding 1242 // arguments." 1243 // 1244 // ...where "p1 ... pn" are defined earlier as: 1245 // 1246 // [dcl.fct.def.coroutine]/3 1247 // "For a coroutine f that is a non-static member function, let P1 denote the 1248 // type of the implicit object parameter (13.3.1) and P2 ... Pn be the types 1249 // of the function parameters; otherwise let P1 ... Pn be the types of the 1250 // function parameters. Let p1 ... pn be lvalues denoting those objects." 1251 if (auto *MD = dyn_cast<CXXMethodDecl>(&FD)) { 1252 if (MD->isInstance() && !isLambdaCallOperator(MD)) { 1253 ExprResult ThisExpr = S.ActOnCXXThis(Loc); 1254 if (ThisExpr.isInvalid()) 1255 return false; 1256 ThisExpr = S.CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get()); 1257 if (ThisExpr.isInvalid()) 1258 return false; 1259 PlacementArgs.push_back(ThisExpr.get()); 1260 } 1261 } 1262 for (auto *PD : FD.parameters()) { 1263 if (PD->getType()->isDependentType()) 1264 continue; 1265 1266 // Build a reference to the parameter. 1267 auto PDLoc = PD->getLocation(); 1268 ExprResult PDRefExpr = 1269 S.BuildDeclRefExpr(PD, PD->getOriginalType().getNonReferenceType(), 1270 ExprValueKind::VK_LValue, PDLoc); 1271 if (PDRefExpr.isInvalid()) 1272 return false; 1273 1274 PlacementArgs.push_back(PDRefExpr.get()); 1275 } 1276 S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class, 1277 /*DeleteScope*/ Sema::AFS_Both, PromiseType, 1278 /*isArray*/ false, PassAlignment, PlacementArgs, 1279 OperatorNew, UnusedResult, /*Diagnose*/ false); 1280 1281 // [dcl.fct.def.coroutine]/7 1282 // "If no matching function is found, overload resolution is performed again 1283 // on a function call created by passing just the amount of space required as 1284 // an argument of type std::size_t." 1285 if (!OperatorNew && !PlacementArgs.empty()) { 1286 PlacementArgs.clear(); 1287 S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class, 1288 /*DeleteScope*/ Sema::AFS_Both, PromiseType, 1289 /*isArray*/ false, PassAlignment, PlacementArgs, 1290 OperatorNew, UnusedResult, /*Diagnose*/ false); 1291 } 1292 1293 // [dcl.fct.def.coroutine]/7 1294 // "The allocation function’s name is looked up in the scope of P. If this 1295 // lookup fails, the allocation function’s name is looked up in the global 1296 // scope." 1297 if (!OperatorNew) { 1298 S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Global, 1299 /*DeleteScope*/ Sema::AFS_Both, PromiseType, 1300 /*isArray*/ false, PassAlignment, PlacementArgs, 1301 OperatorNew, UnusedResult); 1302 } 1303 1304 bool IsGlobalOverload = 1305 OperatorNew && !isa<CXXRecordDecl>(OperatorNew->getDeclContext()); 1306 // If we didn't find a class-local new declaration and non-throwing new 1307 // was is required then we need to lookup the non-throwing global operator 1308 // instead. 1309 if (RequiresNoThrowAlloc && (!OperatorNew || IsGlobalOverload)) { 1310 auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc); 1311 if (!StdNoThrow) 1312 return false; 1313 PlacementArgs = {StdNoThrow}; 1314 OperatorNew = nullptr; 1315 S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Both, 1316 /*DeleteScope*/ Sema::AFS_Both, PromiseType, 1317 /*isArray*/ false, PassAlignment, PlacementArgs, 1318 OperatorNew, UnusedResult); 1319 } 1320 1321 if (!OperatorNew) 1322 return false; 1323 1324 if (RequiresNoThrowAlloc) { 1325 const auto *FT = OperatorNew->getType()->castAs<FunctionProtoType>(); 1326 if (!FT->isNothrow(/*ResultIfDependent*/ false)) { 1327 S.Diag(OperatorNew->getLocation(), 1328 diag::err_coroutine_promise_new_requires_nothrow) 1329 << OperatorNew; 1330 S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required) 1331 << OperatorNew; 1332 return false; 1333 } 1334 } 1335 1336 if ((OperatorDelete = findDeleteForPromise(S, Loc, PromiseType)) == nullptr) 1337 return false; 1338 1339 Expr *FramePtr = 1340 S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {}); 1341 1342 Expr *FrameSize = 1343 S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_size, {}); 1344 1345 // Make new call. 1346 1347 ExprResult NewRef = 1348 S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc); 1349 if (NewRef.isInvalid()) 1350 return false; 1351 1352 SmallVector<Expr *, 2> NewArgs(1, FrameSize); 1353 for (auto Arg : PlacementArgs) 1354 NewArgs.push_back(Arg); 1355 1356 ExprResult NewExpr = 1357 S.BuildCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc); 1358 NewExpr = S.ActOnFinishFullExpr(NewExpr.get(), /*DiscardedValue*/ false); 1359 if (NewExpr.isInvalid()) 1360 return false; 1361 1362 // Make delete call. 1363 1364 QualType OpDeleteQualType = OperatorDelete->getType(); 1365 1366 ExprResult DeleteRef = 1367 S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc); 1368 if (DeleteRef.isInvalid()) 1369 return false; 1370 1371 Expr *CoroFree = 1372 S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_free, {FramePtr}); 1373 1374 SmallVector<Expr *, 2> DeleteArgs{CoroFree}; 1375 1376 // Check if we need to pass the size. 1377 const auto *OpDeleteType = 1378 OpDeleteQualType.getTypePtr()->castAs<FunctionProtoType>(); 1379 if (OpDeleteType->getNumParams() > 1) 1380 DeleteArgs.push_back(FrameSize); 1381 1382 ExprResult DeleteExpr = 1383 S.BuildCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc); 1384 DeleteExpr = 1385 S.ActOnFinishFullExpr(DeleteExpr.get(), /*DiscardedValue*/ false); 1386 if (DeleteExpr.isInvalid()) 1387 return false; 1388 1389 this->Allocate = NewExpr.get(); 1390 this->Deallocate = DeleteExpr.get(); 1391 1392 return true; 1393} 1394 1395bool CoroutineStmtBuilder::makeOnFallthrough() { 1396 assert(!IsPromiseDependentType &&((void)0) 1397 "cannot make statement while the promise type is dependent")((void)0); 1398 1399 // [dcl.fct.def.coroutine]/4 1400 // The unqualified-ids 'return_void' and 'return_value' are looked up in 1401 // the scope of class P. If both are found, the program is ill-formed. 1402 bool HasRVoid, HasRValue; 1403 LookupResult LRVoid = 1404 lookupMember(S, "return_void", PromiseRecordDecl, Loc, HasRVoid); 1405 LookupResult LRValue = 1406 lookupMember(S, "return_value", PromiseRecordDecl, Loc, HasRValue); 1407 1408 StmtResult Fallthrough; 1409 if (HasRVoid && HasRValue) { 1410 // FIXME Improve this diagnostic 1411 S.Diag(FD.getLocation(), 1412 diag::err_coroutine_promise_incompatible_return_functions) 1413 << PromiseRecordDecl; 1414 S.Diag(LRVoid.getRepresentativeDecl()->getLocation(), 1415 diag::note_member_first_declared_here) 1416 << LRVoid.getLookupName(); 1417 S.Diag(LRValue.getRepresentativeDecl()->getLocation(), 1418 diag::note_member_first_declared_here) 1419 << LRValue.getLookupName(); 1420 return false; 1421 } else if (!HasRVoid && !HasRValue) { 1422 // FIXME: The PDTS currently specifies this case as UB, not ill-formed. 1423 // However we still diagnose this as an error since until the PDTS is fixed. 1424 S.Diag(FD.getLocation(), 1425 diag::err_coroutine_promise_requires_return_function) 1426 << PromiseRecordDecl; 1427 S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here) 1428 << PromiseRecordDecl; 1429 return false; 1430 } else if (HasRVoid) { 1431 // If the unqualified-id return_void is found, flowing off the end of a 1432 // coroutine is equivalent to a co_return with no operand. Otherwise, 1433 // flowing off the end of a coroutine results in undefined behavior. 1434 Fallthrough = S.BuildCoreturnStmt(FD.getLocation(), nullptr, 1435 /*IsImplicit*/false); 1436 Fallthrough = S.ActOnFinishFullStmt(Fallthrough.get()); 1437 if (Fallthrough.isInvalid()) 1438 return false; 1439 } 1440 1441 this->OnFallthrough = Fallthrough.get(); 1442 return true; 1443} 1444 1445bool CoroutineStmtBuilder::makeOnException() { 1446 // Try to form 'p.unhandled_exception();' 1447 assert(!IsPromiseDependentType &&((void)0) 1448 "cannot make statement while the promise type is dependent")((void)0); 1449 1450 const bool RequireUnhandledException = S.getLangOpts().CXXExceptions; 1451 1452 if (!lookupMember(S, "unhandled_exception", PromiseRecordDecl, Loc)) { 1453 auto DiagID = 1454 RequireUnhandledException 1455 ? diag::err_coroutine_promise_unhandled_exception_required 1456 : diag:: 1457 warn_coroutine_promise_unhandled_exception_required_with_exceptions; 1458 S.Diag(Loc, DiagID) << PromiseRecordDecl; 1459 S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here) 1460 << PromiseRecordDecl; 1461 return !RequireUnhandledException; 1462 } 1463 1464 // If exceptions are disabled, don't try to build OnException. 1465 if (!S.getLangOpts().CXXExceptions) 1466 return true; 1467 1468 ExprResult UnhandledException = buildPromiseCall(S, Fn.CoroutinePromise, Loc, 1469 "unhandled_exception", None); 1470 UnhandledException = S.ActOnFinishFullExpr(UnhandledException.get(), Loc, 1471 /*DiscardedValue*/ false); 1472 if (UnhandledException.isInvalid()) 1473 return false; 1474 1475 // Since the body of the coroutine will be wrapped in try-catch, it will 1476 // be incompatible with SEH __try if present in a function. 1477 if (!S.getLangOpts().Borland && Fn.FirstSEHTryLoc.isValid()) { 1478 S.Diag(Fn.FirstSEHTryLoc, diag::err_seh_in_a_coroutine_with_cxx_exceptions); 1479 S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) 1480 << Fn.getFirstCoroutineStmtKeyword(); 1481 return false; 1482 } 1483 1484 this->OnException = UnhandledException.get(); 1485 return true; 1486} 1487 1488bool CoroutineStmtBuilder::makeReturnObject() { 1489 // Build implicit 'p.get_return_object()' expression and form initialization 1490 // of return type from it. 1491 ExprResult ReturnObject = 1492 buildPromiseCall(S, Fn.CoroutinePromise, Loc, "get_return_object", None); 1493 if (ReturnObject.isInvalid()) 1494 return false; 1495 1496 this->ReturnValue = ReturnObject.get(); 1497 return true; 1498} 1499 1500static void noteMemberDeclaredHere(Sema &S, Expr *E, FunctionScopeInfo &Fn) { 1501 if (auto *MbrRef = dyn_cast<CXXMemberCallExpr>(E)) { 1502 auto *MethodDecl = MbrRef->getMethodDecl(); 1503 S.Diag(MethodDecl->getLocation(), diag::note_member_declared_here) 1504 << MethodDecl; 1505 } 1506 S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) 1507 << Fn.getFirstCoroutineStmtKeyword(); 1508} 1509 1510bool CoroutineStmtBuilder::makeGroDeclAndReturnStmt() { 1511 assert(!IsPromiseDependentType &&((void)0) 1512 "cannot make statement while the promise type is dependent")((void)0); 1513 assert(this->ReturnValue && "ReturnValue must be already formed")((void)0); 1514 1515 QualType const GroType = this->ReturnValue->getType(); 1516 assert(!GroType->isDependentType() &&((void)0) 1517 "get_return_object type must no longer be dependent")((void)0); 1518 1519 QualType const FnRetType = FD.getReturnType(); 1520 assert(!FnRetType->isDependentType() &&((void)0) 1521 "get_return_object type must no longer be dependent")((void)0); 1522 1523 if (FnRetType->isVoidType()) { 1524 ExprResult Res = 1525 S.ActOnFinishFullExpr(this->ReturnValue, Loc, /*DiscardedValue*/ false); 1526 if (Res.isInvalid()) 1527 return false; 1528 1529 this->ResultDecl = Res.get(); 1530 return true; 1531 } 1532 1533 if (GroType->isVoidType()) { 1534 // Trigger a nice error message. 1535 InitializedEntity Entity = 1536 InitializedEntity::InitializeResult(Loc, FnRetType); 1537 S.PerformCopyInitialization(Entity, SourceLocation(), ReturnValue); 1538 noteMemberDeclaredHere(S, ReturnValue, Fn); 1539 return false; 1540 } 1541 1542 auto *GroDecl = VarDecl::Create( 1543 S.Context, &FD, FD.getLocation(), FD.getLocation(), 1544 &S.PP.getIdentifierTable().get("__coro_gro"), GroType, 1545 S.Context.getTrivialTypeSourceInfo(GroType, Loc), SC_None); 1546 GroDecl->setImplicit(); 1547 1548 S.CheckVariableDeclarationType(GroDecl); 1549 if (GroDecl->isInvalidDecl()) 1550 return false; 1551 1552 InitializedEntity Entity = InitializedEntity::InitializeVariable(GroDecl); 1553 ExprResult Res = 1554 S.PerformCopyInitialization(Entity, SourceLocation(), ReturnValue); 1555 if (Res.isInvalid()) 1556 return false; 1557 1558 Res = S.ActOnFinishFullExpr(Res.get(), /*DiscardedValue*/ false); 1559 if (Res.isInvalid()) 1560 return false; 1561 1562 S.AddInitializerToDecl(GroDecl, Res.get(), 1563 /*DirectInit=*/false); 1564 1565 S.FinalizeDeclaration(GroDecl); 1566 1567 // Form a declaration statement for the return declaration, so that AST 1568 // visitors can more easily find it. 1569 StmtResult GroDeclStmt = 1570 S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(GroDecl), Loc, Loc); 1571 if (GroDeclStmt.isInvalid()) 1572 return false; 1573 1574 this->ResultDecl = GroDeclStmt.get(); 1575 1576 ExprResult declRef = S.BuildDeclRefExpr(GroDecl, GroType, VK_LValue, Loc); 1577 if (declRef.isInvalid()) 1578 return false; 1579 1580 StmtResult ReturnStmt = S.BuildReturnStmt(Loc, declRef.get()); 1581 if (ReturnStmt.isInvalid()) { 1582 noteMemberDeclaredHere(S, ReturnValue, Fn); 1583 return false; 1584 } 1585 if (cast<clang::ReturnStmt>(ReturnStmt.get())->getNRVOCandidate() == GroDecl) 1586 GroDecl->setNRVOVariable(true); 1587 1588 this->ReturnStmt = ReturnStmt.get(); 1589 return true; 1590} 1591 1592// Create a static_cast\<T&&>(expr). 1593static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) { 1594 if (T.isNull()) 1595 T = E->getType(); 1596 QualType TargetType = S.BuildReferenceType( 1597 T, /*SpelledAsLValue*/ false, SourceLocation(), DeclarationName()); 1598 SourceLocation ExprLoc = E->getBeginLoc(); 1599 TypeSourceInfo *TargetLoc = 1600 S.Context.getTrivialTypeSourceInfo(TargetType, ExprLoc); 1601 1602 return S 1603 .BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E, 1604 SourceRange(ExprLoc, ExprLoc), E->getSourceRange()) 1605 .get(); 1606} 1607 1608/// Build a variable declaration for move parameter. 1609static VarDecl *buildVarDecl(Sema &S, SourceLocation Loc, QualType Type, 1610 IdentifierInfo *II) { 1611 TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc); 1612 VarDecl *Decl = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, II, Type, 1613 TInfo, SC_None); 1614 Decl->setImplicit(); 1615 return Decl; 1616} 1617 1618// Build statements that move coroutine function parameters to the coroutine 1619// frame, and store them on the function scope info. 1620bool Sema::buildCoroutineParameterMoves(SourceLocation Loc) { 1621 assert(isa<FunctionDecl>(CurContext) && "not in a function scope")((void)0); 1622 auto *FD = cast<FunctionDecl>(CurContext);
28
←
Field 'CurContext' is a 'FunctionDecl'
→
1623 1624 auto *ScopeInfo = getCurFunction(); 1625 if (!ScopeInfo->CoroutineParameterMoves.empty())
29
←
Assuming the condition is false
→
30
←
Taking false branch
→
1626 return false; 1627 1628 for (auto *PD : FD->parameters()) {
31
←
Assuming '__begin1' is equal to '__end1'
→
1629 if (PD->getType()->isDependentType()) 1630 continue; 1631 1632 ExprResult PDRefExpr = 1633 BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(), 1634 ExprValueKind::VK_LValue, Loc); // FIXME: scope? 1635 if (PDRefExpr.isInvalid()) 1636 return false; 1637 1638 Expr *CExpr = nullptr; 1639 if (PD->getType()->getAsCXXRecordDecl() || 1640 PD->getType()->isRValueReferenceType()) 1641 CExpr = castForMoving(*this, PDRefExpr.get()); 1642 else 1643 CExpr = PDRefExpr.get(); 1644 1645 auto D = buildVarDecl(*this, Loc, PD->getType(), PD->getIdentifier()); 1646 AddInitializerToDecl(D, CExpr, /*DirectInit=*/true); 1647 1648 // Convert decl to a statement. 1649 StmtResult Stmt = ActOnDeclStmt(ConvertDeclToDeclGroup(D), Loc, Loc); 1650 if (Stmt.isInvalid()) 1651 return false; 1652 1653 ScopeInfo->CoroutineParameterMoves.insert(std::make_pair(PD, Stmt.get())); 1654 } 1655 return true;
32
←
Returning the value 1, which participates in a condition later
→
1656} 1657 1658StmtResult Sema::BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) { 1659 CoroutineBodyStmt *Res = CoroutineBodyStmt::Create(Context, Args); 1660 if (!Res) 1661 return StmtError(); 1662 return Res; 1663} 1664 1665ClassTemplateDecl *Sema::lookupCoroutineTraits(SourceLocation KwLoc, 1666 SourceLocation FuncLoc) { 1667 if (!StdCoroutineTraitsCache) { 1668 if (auto StdExp = lookupStdExperimentalNamespace()) { 1669 LookupResult Result(*this, 1670 &PP.getIdentifierTable().get("coroutine_traits"), 1671 FuncLoc, LookupOrdinaryName); 1672 if (!LookupQualifiedName(Result, StdExp)) { 1673 Diag(KwLoc, diag::err_implied_coroutine_type_not_found) 1674 << "std::experimental::coroutine_traits"; 1675 return nullptr; 1676 } 1677 if (!(StdCoroutineTraitsCache = 1678 Result.getAsSingle<ClassTemplateDecl>())) { 1679 Result.suppressDiagnostics(); 1680 NamedDecl *Found = *Result.begin(); 1681 Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits); 1682 return nullptr; 1683 } 1684 } 1685 } 1686 return StdCoroutineTraitsCache; 1687}
←

/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();
22
←
'?' condition is false
→
23
←
Returning pointer, which participates in a condition later
→
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; }
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
←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/AST/Type.h

→
1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H
19
20#include "clang/AST/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>
57
58namespace clang {
59
60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;
66
67enum {
68 TypeAlignmentInBits = 4,
69 TypeAlignment = 1 << TypeAlignmentInBits
70};
71
72namespace serialization {
73 template <class T> class AbstractTypeReader;
74 template <class T> class AbstractTypeWriter;
75}
76
77} // namespace clang
78
79namespace llvm {
80
81 template <typename T>
82 struct PointerLikeTypeTraits;
83 template<>
84 struct PointerLikeTypeTraits< ::clang::Type*> {
85 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
86
87 static inline ::clang::Type *getFromVoidPointer(void *P) {
88 return static_cast< ::clang::Type*>(P);
89 }
90
91 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
92 };
93
94 template<>
95 struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
96 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
97
98 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
99 return static_cast< ::clang::ExtQuals*>(P);
100 }
101
102 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
103 };
104
105} // namespace llvm
106
107namespace clang {
108
109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;
132
133using CanQualType = CanQual<Type>;
134
135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"
138
139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
147 enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
148 Const = 0x1,
149 Restrict = 0x2,
150 Volatile = 0x4,
151 CVRMask = Const | Volatile | Restrict
152 };
153
154 enum GC {
155 GCNone = 0,
156 Weak,
157 Strong
158 };
159
160 enum ObjCLifetime {
161 /// There is no lifetime qualification on this type.
162 OCL_None,
163
164 /// This object can be modified without requiring retains or
165 /// releases.
166 OCL_ExplicitNone,
167
168 /// Assigning into this object requires the old value to be
169 /// released and the new value to be retained. The timing of the
170 /// release of the old value is inexact: it may be moved to
171 /// immediately after the last known point where the value is
172 /// live.
173 OCL_Strong,
174
175 /// Reading or writing from this object requires a barrier call.
176 OCL_Weak,
177
178 /// Assigning into this object requires a lifetime extension.
179 OCL_Autoreleasing
180 };
181
182 enum {
183 /// The maximum supported address space number.
184 /// 23 bits should be enough for anyone.
185 MaxAddressSpace = 0x7fffffu,
186
187 /// The width of the "fast" qualifier mask.
188 FastWidth = 3,
189
190 /// The fast qualifier mask.
191 FastMask = (1 << FastWidth) - 1
192 };
193
194 /// Returns the common set of qualifiers while removing them from
195 /// the given sets.
196 static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
197 // If both are only CVR-qualified, bit operations are sufficient.
198 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
199 Qualifiers Q;
200 Q.Mask = L.Mask & R.Mask;
201 L.Mask &= ~Q.Mask;
202 R.Mask &= ~Q.Mask;
203 return Q;
204 }
205
206 Qualifiers Q;
207 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
208 Q.addCVRQualifiers(CommonCRV);
209 L.removeCVRQualifiers(CommonCRV);
210 R.removeCVRQualifiers(CommonCRV);
211
212 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
213 Q.setObjCGCAttr(L.getObjCGCAttr());
214 L.removeObjCGCAttr();
215 R.removeObjCGCAttr();
216 }
217
218 if (L.getObjCLifetime() == R.getObjCLifetime()) {
219 Q.setObjCLifetime(L.getObjCLifetime());
220 L.removeObjCLifetime();
221 R.removeObjCLifetime();
222 }
223
224 if (L.getAddressSpace() == R.getAddressSpace()) {
225 Q.setAddressSpace(L.getAddressSpace());
226 L.removeAddressSpace();
227 R.removeAddressSpace();
228 }
229 return Q;
230 }
231
232 static Qualifiers fromFastMask(unsigned Mask) {
233 Qualifiers Qs;
234 Qs.addFastQualifiers(Mask);
235 return Qs;
236 }
237
238 static Qualifiers fromCVRMask(unsigned CVR) {
239 Qualifiers Qs;
240 Qs.addCVRQualifiers(CVR);
241 return Qs;
242 }
243
244 static Qualifiers fromCVRUMask(unsigned CVRU) {
245 Qualifiers Qs;
246 Qs.addCVRUQualifiers(CVRU);
247 return Qs;
248 }
249
250 // Deserialize qualifiers from an opaque representation.
251 static Qualifiers fromOpaqueValue(unsigned opaque) {
252 Qualifiers Qs;
253 Qs.Mask = opaque;
254 return Qs;
255 }
256
257 // Serialize these qualifiers into an opaque representation.
258 unsigned getAsOpaqueValue() const {
259 return Mask;
260 }
261
262 bool hasConst() const { return Mask & Const; }
263 bool hasOnlyConst() const { return Mask == Const; }
264 void removeConst() { Mask &= ~Const; }
265 void addConst() { Mask |= Const; }
266
267 bool hasVolatile() const { return Mask & Volatile; }
268 bool hasOnlyVolatile() const { return Mask == Volatile; }
269 void removeVolatile() { Mask &= ~Volatile; }
270 void addVolatile() { Mask |= Volatile; }
271
272 bool hasRestrict() const { return Mask & Restrict; }
273 bool hasOnlyRestrict() const { return Mask == Restrict; }
274 void removeRestrict() { Mask &= ~Restrict; }
275 void addRestrict() { Mask |= Restrict; }
276
277 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
278 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
279 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
280
281 void setCVRQualifiers(unsigned mask) {
282 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
283 Mask = (Mask & ~CVRMask) | mask;
284 }
285 void removeCVRQualifiers(unsigned mask) {
286 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
287 Mask &= ~mask;
288 }
289 void removeCVRQualifiers() {
290 removeCVRQualifiers(CVRMask);
291 }
292 void addCVRQualifiers(unsigned mask) {
293 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
294 Mask |= mask;
295 }
296 void addCVRUQualifiers(unsigned mask) {
297 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((void)0);
298 Mask |= mask;
299 }
300
301 bool hasUnaligned() const { return Mask & UMask; }
302 void setUnaligned(bool flag) {
303 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
304 }
305 void removeUnaligned() { Mask &= ~UMask; }
306 void addUnaligned() { Mask |= UMask; }
307
308 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
309 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
310 void setObjCGCAttr(GC type) {
311 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
312 }
313 void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
314 void addObjCGCAttr(GC type) {
315 assert(type)((void)0);
316 setObjCGCAttr(type);
317 }
318 Qualifiers withoutObjCGCAttr() const {
319 Qualifiers qs = *this;
320 qs.removeObjCGCAttr();
321 return qs;
322 }
323 Qualifiers withoutObjCLifetime() const {
324 Qualifiers qs = *this;
325 qs.removeObjCLifetime();
326 return qs;
327 }
328 Qualifiers withoutAddressSpace() const {
329 Qualifiers qs = *this;
330 qs.removeAddressSpace();
331 return qs;
332 }
333
334 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
335 ObjCLifetime getObjCLifetime() const {
336 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
337 }
338 void setObjCLifetime(ObjCLifetime type) {
339 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
340 }
341 void removeObjCLifetime() { setObjCLifetime(OCL_None); }
342 void addObjCLifetime(ObjCLifetime type) {
343 assert(type)((void)0);
344 assert(!hasObjCLifetime())((void)0);
345 Mask |= (type << LifetimeShift);
346 }
347
348 /// True if the lifetime is neither None or ExplicitNone.
349 bool hasNonTrivialObjCLifetime() const {
350 ObjCLifetime lifetime = getObjCLifetime();
351 return (lifetime > OCL_ExplicitNone);
352 }
353
354 /// True if the lifetime is either strong or weak.
355 bool hasStrongOrWeakObjCLifetime() const {
356 ObjCLifetime lifetime = getObjCLifetime();
357 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
358 }
359
360 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
361 LangAS getAddressSpace() const {
362 return static_cast<LangAS>(Mask >> AddressSpaceShift);
363 }
364 bool hasTargetSpecificAddressSpace() const {
365 return isTargetAddressSpace(getAddressSpace());
366 }
367 /// Get the address space attribute value to be printed by diagnostics.
368 unsigned getAddressSpaceAttributePrintValue() const {
369 auto Addr = getAddressSpace();
370 // This function is not supposed to be used with language specific
371 // address spaces. If that happens, the diagnostic message should consider
372 // printing the QualType instead of the address space value.
373 assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((void)0);
374 if (Addr != LangAS::Default)
375 return toTargetAddressSpace(Addr);
376 // TODO: The diagnostic messages where Addr may be 0 should be fixed
377 // since it cannot differentiate the situation where 0 denotes the default
378 // address space or user specified __attribute__((address_space(0))).
379 return 0;
380 }
381 void setAddressSpace(LangAS space) {
382 assert((unsigned)space <= MaxAddressSpace)((void)0);
383 Mask = (Mask & ~AddressSpaceMask)
384 | (((uint32_t) space) << AddressSpaceShift);
385 }
386 void removeAddressSpace() { setAddressSpace(LangAS::Default); }
387 void addAddressSpace(LangAS space) {
388 assert(space != LangAS::Default)((void)0);
389 setAddressSpace(space);
390 }
391
392 // Fast qualifiers are those that can be allocated directly
393 // on a QualType object.
394 bool hasFastQualifiers() const { return getFastQualifiers(); }
395 unsigned getFastQualifiers() const { return Mask & FastMask; }
396 void setFastQualifiers(unsigned mask) {
397 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
398 Mask = (Mask & ~FastMask) | mask;
399 }
400 void removeFastQualifiers(unsigned mask) {
401 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
402 Mask &= ~mask;
403 }
404 void removeFastQualifiers() {
405 removeFastQualifiers(FastMask);
406 }
407 void addFastQualifiers(unsigned mask) {
408 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
409 Mask |= mask;
410 }
411
412 /// Return true if the set contains any qualifiers which require an ExtQuals
413 /// node to be allocated.
414 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
415 Qualifiers getNonFastQualifiers() const {
416 Qualifiers Quals = *this;
417 Quals.setFastQualifiers(0);
418 return Quals;
419 }
420
421 /// Return true if the set contains any qualifiers.
422 bool hasQualifiers() const { return Mask; }
423 bool empty() const { return !Mask; }
424
425 /// Add the qualifiers from the given set to this set.
426 void addQualifiers(Qualifiers Q) {
427 // If the other set doesn't have any non-boolean qualifiers, just
428 // bit-or it in.
429 if (!(Q.Mask & ~CVRMask))
430 Mask |= Q.Mask;
431 else {
432 Mask |= (Q.Mask & CVRMask);
433 if (Q.hasAddressSpace())
434 addAddressSpace(Q.getAddressSpace());
435 if (Q.hasObjCGCAttr())
436 addObjCGCAttr(Q.getObjCGCAttr());
437 if (Q.hasObjCLifetime())
438 addObjCLifetime(Q.getObjCLifetime());
439 }
440 }
441
442 /// Remove the qualifiers from the given set from this set.
443 void removeQualifiers(Qualifiers Q) {
444 // If the other set doesn't have any non-boolean qualifiers, just
445 // bit-and the inverse in.
446 if (!(Q.Mask & ~CVRMask))
447 Mask &= ~Q.Mask;
448 else {
449 Mask &= ~(Q.Mask & CVRMask);
450 if (getObjCGCAttr() == Q.getObjCGCAttr())
451 removeObjCGCAttr();
452 if (getObjCLifetime() == Q.getObjCLifetime())
453 removeObjCLifetime();
454 if (getAddressSpace() == Q.getAddressSpace())
455 removeAddressSpace();
456 }
457 }
458
459 /// Add the qualifiers from the given set to this set, given that
460 /// they don't conflict.
461 void addConsistentQualifiers(Qualifiers qs) {
462 assert(getAddressSpace() == qs.getAddressSpace() ||((void)0)
463 !hasAddressSpace() || !qs.hasAddressSpace())((void)0);
464 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((void)0)
465 !hasObjCGCAttr() || !qs.hasObjCGCAttr())((void)0);
466 assert(getObjCLifetime() == qs.getObjCLifetime() ||((void)0)
467 !hasObjCLifetime() || !qs.hasObjCLifetime())((void)0);
468 Mask |= qs.Mask;
469 }
470
471 /// Returns true if address space A is equal to or a superset of B.
472 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
473 /// overlapping address spaces.
474 /// CL1.1 or CL1.2:
475 /// every address space is a superset of itself.
476 /// CL2.0 adds:
477 /// __generic is a superset of any address space except for __constant.
478 static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
479 // Address spaces must match exactly.
480 return A == B ||
481 // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
482 // for __constant can be used as __generic.
483 (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
484 // We also define global_device and global_host address spaces,
485 // to distinguish global pointers allocated on host from pointers
486 // allocated on device, which are a subset of __global.
487 (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
488 B == LangAS::opencl_global_host)) ||
489 (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
490 B == LangAS::sycl_global_host)) ||
491 // Consider pointer size address spaces to be equivalent to default.
492 ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
493 (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
494 // Default is a superset of SYCL address spaces.
495 (A == LangAS::Default &&
496 (B == LangAS::sycl_private || B == LangAS::sycl_local ||
497 B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
498 B == LangAS::sycl_global_host));
499 }
500
501 /// Returns true if the address space in these qualifiers is equal to or
502 /// a superset of the address space in the argument qualifiers.
503 bool isAddressSpaceSupersetOf(Qualifiers other) const {
504 return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
505 }
506
507 /// Determines if these qualifiers compatibly include another set.
508 /// Generally this answers the question of whether an object with the other
509 /// qualifiers can be safely used as an object with these qualifiers.
510 bool compatiblyIncludes(Qualifiers other) const {
511 return isAddressSpaceSupersetOf(other) &&
512 // ObjC GC qualifiers can match, be added, or be removed, but can't
513 // be changed.
514 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
515 !other.hasObjCGCAttr()) &&
516 // ObjC lifetime qualifiers must match exactly.
517 getObjCLifetime() == other.getObjCLifetime() &&
518 // CVR qualifiers may subset.
519 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
520 // U qualifier may superset.
521 (!other.hasUnaligned() || hasUnaligned());
522 }
523
524 /// Determines if these qualifiers compatibly include another set of
525 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
526 ///
527 /// One set of Objective-C lifetime qualifiers compatibly includes the other
528 /// if the lifetime qualifiers match, or if both are non-__weak and the
529 /// including set also contains the 'const' qualifier, or both are non-__weak
530 /// and one is None (which can only happen in non-ARC modes).
531 bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
532 if (getObjCLifetime() == other.getObjCLifetime())
533 return true;
534
535 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
536 return false;
537
538 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
539 return true;
540
541 return hasConst();
542 }
543
544 /// Determine whether this set of qualifiers is a strict superset of
545 /// another set of qualifiers, not considering qualifier compatibility.
546 bool isStrictSupersetOf(Qualifiers Other) const;
547
548 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
549 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
550
551 explicit operator bool() const { return hasQualifiers(); }
552
553 Qualifiers &operator+=(Qualifiers R) {
554 addQualifiers(R);
555 return *this;
556 }
557
558 // Union two qualifier sets. If an enumerated qualifier appears
559 // in both sets, use the one from the right.
560 friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
561 L += R;
562 return L;
563 }
564
565 Qualifiers &operator-=(Qualifiers R) {
566 removeQualifiers(R);
567 return *this;
568 }
569
570 /// Compute the difference between two qualifier sets.
571 friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
572 L -= R;
573 return L;
574 }
575
576 std::string getAsString() const;
577 std::string getAsString(const PrintingPolicy &Policy) const;
578
579 static std::string getAddrSpaceAsString(LangAS AS);
580
581 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
582 void print(raw_ostream &OS, const PrintingPolicy &Policy,
583 bool appendSpaceIfNonEmpty = false) const;
584
585 void Profile(llvm::FoldingSetNodeID &ID) const {
586 ID.AddInteger(Mask);
587 }
588
589private:
590 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|
591 // |C R V|U|GCAttr|Lifetime|AddressSpace|
592 uint32_t Mask = 0;
593
594 static const uint32_t UMask = 0x8;
595 static const uint32_t UShift = 3;
596 static const uint32_t GCAttrMask = 0x30;
597 static const uint32_t GCAttrShift = 4;
598 static const uint32_t LifetimeMask = 0x1C0;
599 static const uint32_t LifetimeShift = 6;
600 static const uint32_t AddressSpaceMask =
601 ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
602 static const uint32_t AddressSpaceShift = 9;
603};
604
605/// A std::pair-like structure for storing a qualified type split
606/// into its local qualifiers and its locally-unqualified type.
607struct SplitQualType {
608 /// The locally-unqualified type.
609 const Type *Ty = nullptr;
610
611 /// The local qualifiers.
612 Qualifiers Quals;
613
614 SplitQualType() = default;
615 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
616
617 SplitQualType getSingleStepDesugaredType() const; // end of this file
618
619 // Make std::tie work.
620 std::pair<const Type *,Qualifiers> asPair() const {
621 return std::pair<const Type *, Qualifiers>(Ty, Quals);
622 }
623
624 friend bool operator==(SplitQualType a, SplitQualType b) {
625 return a.Ty == b.Ty && a.Quals == b.Quals;
626 }
627 friend bool operator!=(SplitQualType a, SplitQualType b) {
628 return a.Ty != b.Ty || a.Quals != b.Quals;
629 }
630};
631
632/// The kind of type we are substituting Objective-C type arguments into.
633///
634/// The kind of substitution affects the replacement of type parameters when
635/// no concrete type information is provided, e.g., when dealing with an
636/// unspecialized type.
637enum class ObjCSubstitutionContext {
638 /// An ordinary type.
639 Ordinary,
640
641 /// The result type of a method or function.
642 Result,
643
644 /// The parameter type of a method or function.
645 Parameter,
646
647 /// The type of a property.
648 Property,
649
650 /// The superclass of a type.
651 Superclass,
652};
653
654/// A (possibly-)qualified type.
655///
656/// For efficiency, we don't store CV-qualified types as nodes on their
657/// own: instead each reference to a type stores the qualifiers. This
658/// greatly reduces the number of nodes we need to allocate for types (for
659/// example we only need one for 'int', 'const int', 'volatile int',
660/// 'const volatile int', etc).
661///
662/// As an added efficiency bonus, instead of making this a pair, we
663/// just store the two bits we care about in the low bits of the
664/// pointer. To handle the packing/unpacking, we make QualType be a
665/// simple wrapper class that acts like a smart pointer. A third bit
666/// indicates whether there are extended qualifiers present, in which
667/// case the pointer points to a special structure.
668class QualType {
669 friend class QualifierCollector;
670
671 // Thankfully, these are efficiently composable.
672 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
673 Qualifiers::FastWidth> Value;
674
675 const ExtQuals *getExtQualsUnsafe() const {
676 return Value.getPointer().get<const ExtQuals*>();
677 }
678
679 const Type *getTypePtrUnsafe() const {
680 return Value.getPointer().get<const Type*>();
681 }
682
683 const ExtQualsTypeCommonBase *getCommonPtr() const {
684 assert(!isNull() && "Cannot retrieve a NULL type pointer")((void)0);
685 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
686 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
687 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
688 }
689
690public:
691 QualType() = default;
692 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
693 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
694
695 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
696 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
697
698 /// Retrieves a pointer to the underlying (unqualified) type.
699 ///
700 /// This function requires that the type not be NULL. If the type might be
701 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
702 const Type *getTypePtr() const;
703
704 const Type *getTypePtrOrNull() const;
705
706 /// Retrieves a pointer to the name of the base type.
707 const IdentifierInfo *getBaseTypeIdentifier() const;
708
709 /// Divides a QualType into its unqualified type and a set of local
710 /// qualifiers.
711 SplitQualType split() const;
712
713 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
714
715 static QualType getFromOpaquePtr(const void *Ptr) {
716 QualType T;
717 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
718 return T;
719 }
720
721 const Type &operator*() const {
722 return *getTypePtr();
723 }
724
725 const Type *operator->() const {
726 return getTypePtr();
727 }
728
729 bool isCanonical() const;
730 bool isCanonicalAsParam() const;
731
732 /// Return true if this QualType doesn't point to a type yet.
733 bool isNull() const {
734 return Value.getPointer().isNull();
40
←
Calling 'PointerUnion::isNull'
→
43
←
Returning from 'PointerUnion::isNull'
→
44
←
Returning zero, which participates in a condition later
→
735 }
736
737 /// Determine whether this particular QualType instance has the
738 /// "const" qualifier set, without looking through typedefs that may have
739 /// added "const" at a different level.
740 bool isLocalConstQualified() const {
741 return (getLocalFastQualifiers() & Qualifiers::Const);
742 }
743
744 /// Determine whether this type is const-qualified.
745 bool isConstQualified() const;
746
747 /// Determine whether this particular QualType instance has the
748 /// "restrict" qualifier set, without looking through typedefs that may have
749 /// added "restrict" at a different level.
750 bool isLocalRestrictQualified() const {
751 return (getLocalFastQualifiers() & Qualifiers::Restrict);
752 }
753
754 /// Determine whether this type is restrict-qualified.
755 bool isRestrictQualified() const;
756
757 /// Determine whether this particular QualType instance has the
758 /// "volatile" qualifier set, without looking through typedefs that may have
759 /// added "volatile" at a different level.
760 bool isLocalVolatileQualified() const {
761 return (getLocalFastQualifiers() & Qualifiers::Volatile);
762 }
763
764 /// Determine whether this type is volatile-qualified.
765 bool isVolatileQualified() const;
766
767 /// Determine whether this particular QualType instance has any
768 /// qualifiers, without looking through any typedefs that might add
769 /// qualifiers at a different level.
770 bool hasLocalQualifiers() const {
771 return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
772 }
773
774 /// Determine whether this type has any qualifiers.
775 bool hasQualifiers() const;
776
777 /// Determine whether this particular QualType instance has any
778 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
779 /// instance.
780 bool hasLocalNonFastQualifiers() const {
781 return Value.getPointer().is<const ExtQuals*>();
782 }
783
784 /// Retrieve the set of qualifiers local to this particular QualType
785 /// instance, not including any qualifiers acquired through typedefs or
786 /// other sugar.
787 Qualifiers getLocalQualifiers() const;
788
789 /// Retrieve the set of qualifiers applied to this type.
790 Qualifiers getQualifiers() const;
791
792 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
793 /// local to this particular QualType instance, not including any qualifiers
794 /// acquired through typedefs or other sugar.
795 unsigned getLocalCVRQualifiers() const {
796 return getLocalFastQualifiers();
797 }
798
799 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
800 /// applied to this type.
801 unsigned getCVRQualifiers() const;
802
803 bool isConstant(const ASTContext& Ctx) const {
804 return QualType::isConstant(*this, Ctx);
805 }
806
807 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
808 bool isPODType(const ASTContext &Context) const;
809
810 /// Return true if this is a POD type according to the rules of the C++98
811 /// standard, regardless of the current compilation's language.
812 bool isCXX98PODType(const ASTContext &Context) const;
813
814 /// Return true if this is a POD type according to the more relaxed rules
815 /// of the C++11 standard, regardless of the current compilation's language.
816 /// (C++0x [basic.types]p9). Note that, unlike
817 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
818 bool isCXX11PODType(const ASTContext &Context) const;
819
820 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
821 bool isTrivialType(const ASTContext &Context) const;
822
823 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
824 bool isTriviallyCopyableType(const ASTContext &Context) const;
825
826
827 /// Returns true if it is a class and it might be dynamic.
828 bool mayBeDynamicClass() const;
829
830 /// Returns true if it is not a class or if the class might not be dynamic.
831 bool mayBeNotDynamicClass() const;
832
833 // Don't promise in the API that anything besides 'const' can be
834 // easily added.
835
836 /// Add the `const` type qualifier to this QualType.
837 void addConst() {
838 addFastQualifiers(Qualifiers::Const);
839 }
840 QualType withConst() const {
841 return withFastQualifiers(Qualifiers::Const);
842 }
843
844 /// Add the `volatile` type qualifier to this QualType.
845 void addVolatile() {
846 addFastQualifiers(Qualifiers::Volatile);
847 }
848 QualType withVolatile() const {
849 return withFastQualifiers(Qualifiers::Volatile);
850 }
851
852 /// Add the `restrict` qualifier to this QualType.
853 void addRestrict() {
854 addFastQualifiers(Qualifiers::Restrict);
855 }
856 QualType withRestrict() const {
857 return withFastQualifiers(Qualifiers::Restrict);
858 }
859
860 QualType withCVRQualifiers(unsigned CVR) const {
861 return withFastQualifiers(CVR);
862 }
863
864 void addFastQualifiers(unsigned TQs) {
865 assert(!(TQs & ~Qualifiers::FastMask)((void)0)
866 && "non-fast qualifier bits set in mask!")((void)0);
867 Value.setInt(Value.getInt() | TQs);
868 }
869
870 void removeLocalConst();
871 void removeLocalVolatile();
872 void removeLocalRestrict();
873 void removeLocalCVRQualifiers(unsigned Mask);
874
875 void removeLocalFastQualifiers() { Value.setInt(0); }
876 void removeLocalFastQualifiers(unsigned Mask) {
877 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((void)0);
878 Value.setInt(Value.getInt() & ~Mask);
879 }
880
881 // Creates a type with the given qualifiers in addition to any
882 // qualifiers already on this type.
883 QualType withFastQualifiers(unsigned TQs) const {
884 QualType T = *this;
885 T.addFastQualifiers(TQs);
886 return T;
887 }
888
889 // Creates a type with exactly the given fast qualifiers, removing
890 // any existing fast qualifiers.
891 QualType withExactLocalFastQualifiers(unsigned TQs) const {
892 return withoutLocalFastQualifiers().withFastQualifiers(TQs);
893 }
894
895 // Removes fast qualifiers, but leaves any extended qualifiers in place.
896 QualType withoutLocalFastQualifiers() const {
897 QualType T = *this;
898 T.removeLocalFastQualifiers();
899 return T;
900 }
901
902 QualType getCanonicalType() const;
903
904 /// Return this type with all of the instance-specific qualifiers
905 /// removed, but without removing any qualifiers that may have been applied
906 /// through typedefs.
907 QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
908
909 /// Retrieve the unqualified variant of the given type,
910 /// removing as little sugar as possible.
911 ///
912 /// This routine looks through various kinds of sugar to find the
913 /// least-desugared type that is unqualified. For example, given:
914 ///
915 /// \code
916 /// typedef int Integer;
917 /// typedef const Integer CInteger;
918 /// typedef CInteger DifferenceType;
919 /// \endcode
920 ///
921 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
922 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
923 ///
924 /// The resulting type might still be qualified if it's sugar for an array
925 /// type. To strip qualifiers even from within a sugared array type, use
926 /// ASTContext::getUnqualifiedArrayType.
927 inline QualType getUnqualifiedType() const;
928
929 /// Retrieve the unqualified variant of the given type, removing as little
930 /// sugar as possible.
931 ///
932 /// Like getUnqualifiedType(), but also returns the set of
933 /// qualifiers that were built up.
934 ///
935 /// The resulting type might still be qualified if it's sugar for an array
936 /// type. To strip qualifiers even from within a sugared array type, use
937 /// ASTContext::getUnqualifiedArrayType.
938 inline SplitQualType getSplitUnqualifiedType() const;
939
940 /// Determine whether this type is more qualified than the other
941 /// given type, requiring exact equality for non-CVR qualifiers.
942 bool isMoreQualifiedThan(QualType Other) const;
943
944 /// Determine whether this type is at least as qualified as the other
945 /// given type, requiring exact equality for non-CVR qualifiers.
946 bool isAtLeastAsQualifiedAs(QualType Other) const;
947
948 QualType getNonReferenceType() const;
949
950 /// Determine the type of a (typically non-lvalue) expression with the
951 /// specified result type.
952 ///
953 /// This routine should be used for expressions for which the return type is
954 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
955 /// an lvalue. It removes a top-level reference (since there are no
956 /// expressions of reference type) and deletes top-level cvr-qualifiers
957 /// from non-class types (in C++) or all types (in C).
958 QualType getNonLValueExprType(const ASTContext &Context) const;
959
960 /// Remove an outer pack expansion type (if any) from this type. Used as part
961 /// of converting the type of a declaration to the type of an expression that
962 /// references that expression. It's meaningless for an expression to have a
963 /// pack expansion type.
964 QualType getNonPackExpansionType() const;
965
966 /// Return the specified type with any "sugar" removed from
967 /// the type. This takes off typedefs, typeof's etc. If the outer level of
968 /// the type is already concrete, it returns it unmodified. This is similar
969 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
970 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
971 /// concrete.
972 ///
973 /// Qualifiers are left in place.
974 QualType getDesugaredType(const ASTContext &Context) const {
975 return getDesugaredType(*this, Context);
976 }
977
978 SplitQualType getSplitDesugaredType() const {
979 return getSplitDesugaredType(*this);
980 }
981
982 /// Return the specified type with one level of "sugar" removed from
983 /// the type.
984 ///
985 /// This routine takes off the first typedef, typeof, etc. If the outer level
986 /// of the type is already concrete, it returns it unmodified.
987 QualType getSingleStepDesugaredType(const ASTContext &Context) const {
988 return getSingleStepDesugaredTypeImpl(*this, Context);
989 }
990
991 /// Returns the specified type after dropping any
992 /// outer-level parentheses.
993 QualType IgnoreParens() const {
994 if (isa<ParenType>(*this))
995 return QualType::IgnoreParens(*this);
996 return *this;
997 }
998
999 /// Indicate whether the specified types and qualifiers are identical.
1000 friend bool operator==(const QualType &LHS, const QualType &RHS) {
1001 return LHS.Value == RHS.Value;
1002 }
1003 friend bool operator!=(const QualType &LHS, const QualType &RHS) {
1004 return LHS.Value != RHS.Value;
1005 }
1006 friend bool operator<(const QualType &LHS, const QualType &RHS) {
1007 return LHS.Value < RHS.Value;
1008 }
1009
1010 static std::string getAsString(SplitQualType split,
1011 const PrintingPolicy &Policy) {
1012 return getAsString(split.Ty, split.Quals, Policy);
1013 }
1014 static std::string getAsString(const Type *ty, Qualifiers qs,
1015 const PrintingPolicy &Policy);
1016
1017 std::string getAsString() const;
1018 std::string getAsString(const PrintingPolicy &Policy) const;
1019
1020 void print(raw_ostream &OS, const PrintingPolicy &Policy,
1021 const Twine &PlaceHolder = Twine(),
1022 unsigned Indentation = 0) const;
1023
1024 static void print(SplitQualType split, raw_ostream &OS,
1025 const PrintingPolicy &policy, const Twine &PlaceHolder,
1026 unsigned Indentation = 0) {
1027 return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1028 }
1029
1030 static void print(const Type *ty, Qualifiers qs,
1031 raw_ostream &OS, const PrintingPolicy &policy,
1032 const Twine &PlaceHolder,
1033 unsigned Indentation = 0);
1034
1035 void getAsStringInternal(std::string &Str,
1036 const PrintingPolicy &Policy) const;
1037
1038 static void getAsStringInternal(SplitQualType split, std::string &out,
1039 const PrintingPolicy &policy) {
1040 return getAsStringInternal(split.Ty, split.Quals, out, policy);
1041 }
1042
1043 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1044 std::string &out,
1045 const PrintingPolicy &policy);
1046
1047 class StreamedQualTypeHelper {
1048 const QualType &T;
1049 const PrintingPolicy &Policy;
1050 const Twine &PlaceHolder;
1051 unsigned Indentation;
1052
1053 public:
1054 StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
1055 const Twine &PlaceHolder, unsigned Indentation)
1056 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1057 Indentation(Indentation) {}
1058
1059 friend raw_ostream &operator<<(raw_ostream &OS,
1060 const StreamedQualTypeHelper &SQT) {
1061 SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1062 return OS;
1063 }
1064 };
1065
1066 StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
1067 const Twine &PlaceHolder = Twine(),
1068 unsigned Indentation = 0) const {
1069 return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1070 }
1071
1072 void dump(const char *s) const;
1073 void dump() const;
1074 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
1075
1076 void Profile(llvm::FoldingSetNodeID &ID) const {
1077 ID.AddPointer(getAsOpaquePtr());
1078 }
1079
1080 /// Check if this type has any address space qualifier.
1081 inline bool hasAddressSpace() const;
1082
1083 /// Return the address space of this type.
1084 inline LangAS getAddressSpace() const;
1085
1086 /// Returns true if address space qualifiers overlap with T address space
1087 /// qualifiers.
1088 /// OpenCL C defines conversion rules for pointers to different address spaces
1089 /// and notion of overlapping address spaces.
1090 /// CL1.1 or CL1.2:
1091 /// address spaces overlap iff they are they same.
1092 /// OpenCL C v2.0 s6.5.5 adds:
1093 /// __generic overlaps with any address space except for __constant.
1094 bool isAddressSpaceOverlapping(QualType T) const {
1095 Qualifiers Q = getQualifiers();
1096 Qualifiers TQ = T.getQualifiers();
1097 // Address spaces overlap if at least one of them is a superset of another
1098 return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
1099 }
1100
1101 /// Returns gc attribute of this type.
1102 inline Qualifiers::GC getObjCGCAttr() const;
1103
1104 /// true when Type is objc's weak.
1105 bool isObjCGCWeak() const {
1106 return getObjCGCAttr() == Qualifiers::Weak;
1107 }
1108
1109 /// true when Type is objc's strong.
1110 bool isObjCGCStrong() const {
1111 return getObjCGCAttr() == Qualifiers::Strong;
1112 }
1113
1114 /// Returns lifetime attribute of this type.
1115 Qualifiers::ObjCLifetime getObjCLifetime() const {
1116 return getQualifiers().getObjCLifetime();
1117 }
1118
1119 bool hasNonTrivialObjCLifetime() const {
1120 return getQualifiers().hasNonTrivialObjCLifetime();
1121 }
1122
1123 bool hasStrongOrWeakObjCLifetime() const {
1124 return getQualifiers().hasStrongOrWeakObjCLifetime();
1125 }
1126
1127 // true when Type is objc's weak and weak is enabled but ARC isn't.
1128 bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1129
1130 enum PrimitiveDefaultInitializeKind {
1131 /// The type does not fall into any of the following categories. Note that
1132 /// this case is zero-valued so that values of this enum can be used as a
1133 /// boolean condition for non-triviality.
1134 PDIK_Trivial,
1135
1136 /// The type is an Objective-C retainable pointer type that is qualified
1137 /// with the ARC __strong qualifier.
1138 PDIK_ARCStrong,
1139
1140 /// The type is an Objective-C retainable pointer type that is qualified
1141 /// with the ARC __weak qualifier.
1142 PDIK_ARCWeak,
1143
1144 /// The type is a struct containing a field whose type is not PCK_Trivial.
1145 PDIK_Struct
1146 };
1147
1148 /// Functions to query basic properties of non-trivial C struct types.
1149
1150 /// Check if this is a non-trivial type that would cause a C struct
1151 /// transitively containing this type to be non-trivial to default initialize
1152 /// and return the kind.
1153 PrimitiveDefaultInitializeKind
1154 isNonTrivialToPrimitiveDefaultInitialize() const;
1155
1156 enum PrimitiveCopyKind {
1157 /// The type does not fall into any of the following categories. Note that
1158 /// this case is zero-valued so that values of this enum can be used as a
1159 /// boolean condition for non-triviality.
1160 PCK_Trivial,
1161
1162 /// The type would be trivial except that it is volatile-qualified. Types
1163 /// that fall into one of the other non-trivial cases may additionally be
1164 /// volatile-qualified.
1165 PCK_VolatileTrivial,
1166
1167 /// The type is an Objective-C retainable pointer type that is qualified
1168 /// with the ARC __strong qualifier.
1169 PCK_ARCStrong,
1170
1171 /// The type is an Objective-C retainable pointer type that is qualified
1172 /// with the ARC __weak qualifier.
1173 PCK_ARCWeak,
1174
1175 /// The type is a struct containing a field whose type is neither
1176 /// PCK_Trivial nor PCK_VolatileTrivial.
1177 /// Note that a C++ struct type does not necessarily match this; C++ copying
1178 /// semantics are too complex to express here, in part because they depend
1179 /// on the exact constructor or assignment operator that is chosen by
1180 /// overload resolution to do the copy.
1181 PCK_Struct
1182 };
1183
1184 /// Check if this is a non-trivial type that would cause a C struct
1185 /// transitively containing this type to be non-trivial to copy and return the
1186 /// kind.
1187 PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;
1188
1189 /// Check if this is a non-trivial type that would cause a C struct
1190 /// transitively containing this type to be non-trivial to destructively
1191 /// move and return the kind. Destructive move in this context is a C++-style
1192 /// move in which the source object is placed in a valid but unspecified state
1193 /// after it is moved, as opposed to a truly destructive move in which the
1194 /// source object is placed in an uninitialized state.
1195 PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;
1196
1197 enum DestructionKind {
1198 DK_none,
1199 DK_cxx_destructor,
1200 DK_objc_strong_lifetime,
1201 DK_objc_weak_lifetime,
1202 DK_nontrivial_c_struct
1203 };
1204
1205 /// Returns a nonzero value if objects of this type require
1206 /// non-trivial work to clean up after. Non-zero because it's
1207 /// conceivable that qualifiers (objc_gc(weak)?) could make
1208 /// something require destruction.
1209 DestructionKind isDestructedType() const {
1210 return isDestructedTypeImpl(*this);
1211 }
1212
1213 /// Check if this is or contains a C union that is non-trivial to
1214 /// default-initialize, which is a union that has a member that is non-trivial
1215 /// to default-initialize. If this returns true,
1216 /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1217 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
1218
1219 /// Check if this is or contains a C union that is non-trivial to destruct,
1220 /// which is a union that has a member that is non-trivial to destruct. If
1221 /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1222 bool hasNonTrivialToPrimitiveDestructCUnion() const;
1223
1224 /// Check if this is or contains a C union that is non-trivial to copy, which
1225 /// is a union that has a member that is non-trivial to copy. If this returns
1226 /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1227 bool hasNonTrivialToPrimitiveCopyCUnion() const;
1228
1229 /// Determine whether expressions of the given type are forbidden
1230 /// from being lvalues in C.
1231 ///
1232 /// The expression types that are forbidden to be lvalues are:
1233 /// - 'void', but not qualified void
1234 /// - function types
1235 ///
1236 /// The exact rule here is C99 6.3.2.1:
1237 /// An lvalue is an expression with an object type or an incomplete
1238 /// type other than void.
1239 bool isCForbiddenLValueType() const;
1240
1241 /// Substitute type arguments for the Objective-C type parameters used in the
1242 /// subject type.
1243 ///
1244 /// \param ctx ASTContext in which the type exists.
1245 ///
1246 /// \param typeArgs The type arguments that will be substituted for the
1247 /// Objective-C type parameters in the subject type, which are generally
1248 /// computed via \c Type::getObjCSubstitutions. If empty, the type
1249 /// parameters will be replaced with their bounds or id/Class, as appropriate
1250 /// for the context.
1251 ///
1252 /// \param context The context in which the subject type was written.
1253 ///
1254 /// \returns the resulting type.
1255 QualType substObjCTypeArgs(ASTContext &ctx,
1256 ArrayRef<QualType> typeArgs,
1257 ObjCSubstitutionContext context) const;
1258
1259 /// Substitute type arguments from an object type for the Objective-C type
1260 /// parameters used in the subject type.
1261 ///
1262 /// This operation combines the computation of type arguments for
1263 /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1264 /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1265 /// callers that need to perform a single substitution in isolation.
1266 ///
1267 /// \param objectType The type of the object whose member type we're
1268 /// substituting into. For example, this might be the receiver of a message
1269 /// or the base of a property access.
1270 ///
1271 /// \param dc The declaration context from which the subject type was
1272 /// retrieved, which indicates (for example) which type parameters should
1273 /// be substituted.
1274 ///
1275 /// \param context The context in which the subject type was written.
1276 ///
1277 /// \returns the subject type after replacing all of the Objective-C type
1278 /// parameters with their corresponding arguments.
1279 QualType substObjCMemberType(QualType objectType,
1280 const DeclContext *dc,
1281 ObjCSubstitutionContext context) const;
1282
1283 /// Strip Objective-C "__kindof" types from the given type.
1284 QualType stripObjCKindOfType(const ASTContext &ctx) const;
1285
1286 /// Remove all qualifiers including _Atomic.
1287 QualType getAtomicUnqualifiedType() const;
1288
1289private:
1290 // These methods are implemented in a separate translation unit;
1291 // "static"-ize them to avoid creating temporary QualTypes in the
1292 // caller.
1293 static bool isConstant(QualType T, const ASTContext& Ctx);
1294 static QualType getDesugaredType(QualType T, const ASTContext &Context);
1295 static SplitQualType getSplitDesugaredType(QualType T);
1296 static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1297 static QualType getSingleStepDesugaredTypeImpl(QualType type,
1298 const ASTContext &C);
1299 static QualType IgnoreParens(QualType T);
1300 static DestructionKind isDestructedTypeImpl(QualType type);
1301
1302 /// Check if \param RD is or contains a non-trivial C union.
1303 static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
1304 static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
1305 static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1306};
1307
1308} // namespace clang
1309
1310namespace llvm {
1311
1312/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313/// to a specific Type class.
1314template<> struct simplify_type< ::clang::QualType> {
1315 using SimpleType = const ::clang::Type *;
1316
1317 static SimpleType getSimplifiedValue(::clang::QualType Val) {
1318 return Val.getTypePtr();
1319 }
1320};
1321
1322// Teach SmallPtrSet that QualType is "basically a pointer".
1323template<>
1324struct PointerLikeTypeTraits<clang::QualType> {
1325 static inline void *getAsVoidPointer(clang::QualType P) {
1326 return P.getAsOpaquePtr();
1327 }
1328
1329 static inline clang::QualType getFromVoidPointer(void *P) {
1330 return clang::QualType::getFromOpaquePtr(P);
1331 }
1332
1333 // Various qualifiers go in low bits.
1334 static constexpr int NumLowBitsAvailable = 0;
1335};
1336
1337} // namespace llvm
1338
1339namespace clang {
1340
1341/// Base class that is common to both the \c ExtQuals and \c Type
1342/// classes, which allows \c QualType to access the common fields between the
1343/// two.
1344class ExtQualsTypeCommonBase {
1345 friend class ExtQuals;
1346 friend class QualType;
1347 friend class Type;
1348
1349 /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1350 /// a self-referential pointer (for \c Type).
1351 ///
1352 /// This pointer allows an efficient mapping from a QualType to its
1353 /// underlying type pointer.
1354 const Type *const BaseType;
1355
1356 /// The canonical type of this type. A QualType.
1357 QualType CanonicalType;
1358
1359 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1360 : BaseType(baseType), CanonicalType(canon) {}
1361};
1362
1363/// We can encode up to four bits in the low bits of a
1364/// type pointer, but there are many more type qualifiers that we want
1365/// to be able to apply to an arbitrary type. Therefore we have this
1366/// struct, intended to be heap-allocated and used by QualType to
1367/// store qualifiers.
1368///
1369/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370/// in three low bits on the QualType pointer; a fourth bit records whether
1371/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372/// Objective-C GC attributes) are much more rare.
1373class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1374 // NOTE: changing the fast qualifiers should be straightforward as
1375 // long as you don't make 'const' non-fast.
1376 // 1. Qualifiers:
1377 // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1378 // Fast qualifiers must occupy the low-order bits.
1379 // b) Update Qualifiers::FastWidth and FastMask.
1380 // 2. QualType:
1381 // a) Update is{Volatile,Restrict}Qualified(), defined inline.
1382 // b) Update remove{Volatile,Restrict}, defined near the end of
1383 // this header.
1384 // 3. ASTContext:
1385 // a) Update get{Volatile,Restrict}Type.
1386
1387 /// The immutable set of qualifiers applied by this node. Always contains
1388 /// extended qualifiers.
1389 Qualifiers Quals;
1390
1391 ExtQuals *this_() { return this; }
1392
1393public:
1394 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1395 : ExtQualsTypeCommonBase(baseType,
1396 canon.isNull() ? QualType(this_(), 0) : canon),
1397 Quals(quals) {
1398 assert(Quals.hasNonFastQualifiers()((void)0)
1399 && "ExtQuals created with no fast qualifiers")((void)0);
1400 assert(!Quals.hasFastQualifiers()((void)0)
1401 && "ExtQuals created with fast qualifiers")((void)0);
1402 }
1403
1404 Qualifiers getQualifiers() const { return Quals; }
1405
1406 bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1407 Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1408
1409 bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1410 Qualifiers::ObjCLifetime getObjCLifetime() const {
1411 return Quals.getObjCLifetime();
1412 }
1413
1414 bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1415 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1416
1417 const Type *getBaseType() const { return BaseType; }
1418
1419public:
1420 void Profile(llvm::FoldingSetNodeID &ID) const {
1421 Profile(ID, getBaseType(), Quals);
1422 }
1423
1424 static void Profile(llvm::FoldingSetNodeID &ID,
1425 const Type *BaseType,
1426 Qualifiers Quals) {
1427 assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((void)0);
1428 ID.AddPointer(BaseType);
1429 Quals.Profile(ID);
1430 }
1431};
1432
1433/// The kind of C++11 ref-qualifier associated with a function type.
1434/// This determines whether a member function's "this" object can be an
1435/// lvalue, rvalue, or neither.
1436enum RefQualifierKind {
1437 /// No ref-qualifier was provided.
1438 RQ_None = 0,
1439
1440 /// An lvalue ref-qualifier was provided (\c &).
1441 RQ_LValue,
1442
1443 /// An rvalue ref-qualifier was provided (\c &&).
1444 RQ_RValue
1445};
1446
1447/// Which keyword(s) were used to create an AutoType.
1448enum class AutoTypeKeyword {
1449 /// auto
1450 Auto,
1451
1452 /// decltype(auto)
1453 DecltypeAuto,
1454
1455 /// __auto_type (GNU extension)
1456 GNUAutoType
1457};
1458
1459/// The base class of the type hierarchy.
1460///
1461/// A central concept with types is that each type always has a canonical
1462/// type. A canonical type is the type with any typedef names stripped out
1463/// of it or the types it references. For example, consider:
1464///
1465/// typedef int foo;
1466/// typedef foo* bar;
1467/// 'int *' 'foo *' 'bar'
1468///
1469/// There will be a Type object created for 'int'. Since int is canonical, its
1470/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
1471/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
1472/// there is a PointerType that represents 'int*', which, like 'int', is
1473/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
1474/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475/// is also 'int*'.
1476///
1477/// Non-canonical types are useful for emitting diagnostics, without losing
1478/// information about typedefs being used. Canonical types are useful for type
1479/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480/// about whether something has a particular form (e.g. is a function type),
1481/// because they implicitly, recursively, strip all typedefs out of a type.
1482///
1483/// Types, once created, are immutable.
1484///
1485class alignas(8) Type : public ExtQualsTypeCommonBase {
1486public:
1487 enum TypeClass {
1488#define TYPE(Class, Base) Class,
1489#define LAST_TYPE(Class) TypeLast = Class
1490#define ABSTRACT_TYPE(Class, Base)
1491#include "clang/AST/TypeNodes.inc"
1492 };
1493
1494private:
1495 /// Bitfields required by the Type class.
1496 class TypeBitfields {
1497 friend class Type;
1498 template <class T> friend class TypePropertyCache;
1499
1500 /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1501 unsigned TC : 8;
1502
1503 /// Store information on the type dependency.
1504 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1505
1506 /// True if the cache (i.e. the bitfields here starting with
1507 /// 'Cache') is valid.
1508 mutable unsigned CacheValid : 1;
1509
1510 /// Linkage of this type.
1511 mutable unsigned CachedLinkage : 3;
1512
1513 /// Whether this type involves and local or unnamed types.
1514 mutable unsigned CachedLocalOrUnnamed : 1;
1515
1516 /// Whether this type comes from an AST file.
1517 mutable unsigned FromAST : 1;
1518
1519 bool isCacheValid() const {
1520 return CacheValid;
1521 }
1522
1523 Linkage getLinkage() const {
1524 assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
1525 return static_cast<Linkage>(CachedLinkage);
1526 }
1527
1528 bool hasLocalOrUnnamedType() const {
1529 assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
1530 return CachedLocalOrUnnamed;
1531 }
1532 };
1533 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1534
1535protected:
1536 // These classes allow subclasses to somewhat cleanly pack bitfields
1537 // into Type.
1538
1539 class ArrayTypeBitfields {
1540 friend class ArrayType;
1541
1542 unsigned : NumTypeBits;
1543
1544 /// CVR qualifiers from declarations like
1545 /// 'int X[static restrict 4]'. For function parameters only.
1546 unsigned IndexTypeQuals : 3;
1547
1548 /// Storage class qualifiers from declarations like
1549 /// 'int X[static restrict 4]'. For function parameters only.
1550 /// Actually an ArrayType::ArraySizeModifier.
1551 unsigned SizeModifier : 3;
1552 };
1553
1554 class ConstantArrayTypeBitfields {
1555 friend class ConstantArrayType;
1556
1557 unsigned : NumTypeBits + 3 + 3;
1558
1559 /// Whether we have a stored size expression.
1560 unsigned HasStoredSizeExpr : 1;
1561 };
1562
1563 class BuiltinTypeBitfields {
1564 friend class BuiltinType;
1565
1566 unsigned : NumTypeBits;
1567
1568 /// The kind (BuiltinType::Kind) of builtin type this is.
1569 unsigned Kind : 8;
1570 };
1571
1572 /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1573 /// Only common bits are stored here. Additional uncommon bits are stored
1574 /// in a trailing object after FunctionProtoType.
1575 class FunctionTypeBitfields {
1576 friend class FunctionProtoType;
1577 friend class FunctionType;
1578
1579 unsigned : NumTypeBits;
1580
1581 /// Extra information which affects how the function is called, like
1582 /// regparm and the calling convention.
1583 unsigned ExtInfo : 13;
1584
1585 /// The ref-qualifier associated with a \c FunctionProtoType.
1586 ///
1587 /// This is a value of type \c RefQualifierKind.
1588 unsigned RefQualifier : 2;
1589
1590 /// Used only by FunctionProtoType, put here to pack with the
1591 /// other bitfields.
1592 /// The qualifiers are part of FunctionProtoType because...
1593 ///
1594 /// C++ 8.3.5p4: The return type, the parameter type list and the
1595 /// cv-qualifier-seq, [...], are part of the function type.
1596 unsigned FastTypeQuals : Qualifiers::FastWidth;
1597 /// Whether this function has extended Qualifiers.
1598 unsigned HasExtQuals : 1;
1599
1600 /// The number of parameters this function has, not counting '...'.
1601 /// According to [implimits] 8 bits should be enough here but this is
1602 /// somewhat easy to exceed with metaprogramming and so we would like to
1603 /// keep NumParams as wide as reasonably possible.
1604 unsigned NumParams : 16;
1605
1606 /// The type of exception specification this function has.
1607 unsigned ExceptionSpecType : 4;
1608
1609 /// Whether this function has extended parameter information.
1610 unsigned HasExtParameterInfos : 1;
1611
1612 /// Whether the function is variadic.
1613 unsigned Variadic : 1;
1614
1615 /// Whether this function has a trailing return type.
1616 unsigned HasTrailingReturn : 1;
1617 };
1618
1619 class ObjCObjectTypeBitfields {
1620 friend class ObjCObjectType;
1621
1622 unsigned : NumTypeBits;
1623
1624 /// The number of type arguments stored directly on this object type.
1625 unsigned NumTypeArgs : 7;
1626
1627 /// The number of protocols stored directly on this object type.
1628 unsigned NumProtocols : 6;
1629
1630 /// Whether this is a "kindof" type.
1631 unsigned IsKindOf : 1;
1632 };
1633
1634 class ReferenceTypeBitfields {
1635 friend class ReferenceType;
1636
1637 unsigned : NumTypeBits;
1638
1639 /// True if the type was originally spelled with an lvalue sigil.
1640 /// This is never true of rvalue references but can also be false
1641 /// on lvalue references because of C++0x [dcl.typedef]p9,
1642 /// as follows:
1643 ///
1644 /// typedef int &ref; // lvalue, spelled lvalue
1645 /// typedef int &&rvref; // rvalue
1646 /// ref &a; // lvalue, inner ref, spelled lvalue
1647 /// ref &&a; // lvalue, inner ref
1648 /// rvref &a; // lvalue, inner ref, spelled lvalue
1649 /// rvref &&a; // rvalue, inner ref
1650 unsigned SpelledAsLValue : 1;
1651
1652 /// True if the inner type is a reference type. This only happens
1653 /// in non-canonical forms.
1654 unsigned InnerRef : 1;
1655 };
1656
1657 class TypeWithKeywordBitfields {
1658 friend class TypeWithKeyword;
1659
1660 unsigned : NumTypeBits;
1661
1662 /// An ElaboratedTypeKeyword. 8 bits for efficient access.
1663 unsigned Keyword : 8;
1664 };
1665
1666 enum { NumTypeWithKeywordBits = 8 };
1667
1668 class ElaboratedTypeBitfields {
1669 friend class ElaboratedType;
1670
1671 unsigned : NumTypeBits;
1672 unsigned : NumTypeWithKeywordBits;
1673
1674 /// Whether the ElaboratedType has a trailing OwnedTagDecl.
1675 unsigned HasOwnedTagDecl : 1;
1676 };
1677
1678 class VectorTypeBitfields {
1679 friend class VectorType;
1680 friend class DependentVectorType;
1681
1682 unsigned : NumTypeBits;
1683
1684 /// The kind of vector, either a generic vector type or some
1685 /// target-specific vector type such as for AltiVec or Neon.
1686 unsigned VecKind : 3;
1687 /// The number of elements in the vector.
1688 uint32_t NumElements;
1689 };
1690
1691 class AttributedTypeBitfields {
1692 friend class AttributedType;
1693
1694 unsigned : NumTypeBits;
1695
1696 /// An AttributedType::Kind
1697 unsigned AttrKind : 32 - NumTypeBits;
1698 };
1699
1700 class AutoTypeBitfields {
1701 friend class AutoType;
1702
1703 unsigned : NumTypeBits;
1704
1705 /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
1706 /// or '__auto_type'? AutoTypeKeyword value.
1707 unsigned Keyword : 2;
1708
1709 /// The number of template arguments in the type-constraints, which is
1710 /// expected to be able to hold at least 1024 according to [implimits].
1711 /// However as this limit is somewhat easy to hit with template
1712 /// metaprogramming we'd prefer to keep it as large as possible.
1713 /// At the moment it has been left as a non-bitfield since this type
1714 /// safely fits in 64 bits as an unsigned, so there is no reason to
1715 /// introduce the performance impact of a bitfield.
1716 unsigned NumArgs;
1717 };
1718
1719 class SubstTemplateTypeParmPackTypeBitfields {
1720 friend class SubstTemplateTypeParmPackType;
1721
1722 unsigned : NumTypeBits;
1723
1724 /// The number of template arguments in \c Arguments, which is
1725 /// expected to be able to hold at least 1024 according to [implimits].
1726 /// However as this limit is somewhat easy to hit with template
1727 /// metaprogramming we'd prefer to keep it as large as possible.
1728 /// At the moment it has been left as a non-bitfield since this type
1729 /// safely fits in 64 bits as an unsigned, so there is no reason to
1730 /// introduce the performance impact of a bitfield.
1731 unsigned NumArgs;
1732 };
1733
1734 class TemplateSpecializationTypeBitfields {
1735 friend class TemplateSpecializationType;
1736
1737 unsigned : NumTypeBits;
1738
1739 /// Whether this template specialization type is a substituted type alias.
1740 unsigned TypeAlias : 1;
1741
1742 /// The number of template arguments named in this class template
1743 /// specialization, which is expected to be able to hold at least 1024
1744 /// according to [implimits]. However, as this limit is somewhat easy to
1745 /// hit with template metaprogramming we'd prefer to keep it as large
1746 /// as possible. At the moment it has been left as a non-bitfield since
1747 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1748 /// to introduce the performance impact of a bitfield.
1749 unsigned NumArgs;
1750 };
1751
1752 class DependentTemplateSpecializationTypeBitfields {
1753 friend class DependentTemplateSpecializationType;
1754
1755 unsigned : NumTypeBits;
1756 unsigned : NumTypeWithKeywordBits;
1757
1758 /// The number of template arguments named in this class template
1759 /// specialization, which is expected to be able to hold at least 1024
1760 /// according to [implimits]. However, as this limit is somewhat easy to
1761 /// hit with template metaprogramming we'd prefer to keep it as large
1762 /// as possible. At the moment it has been left as a non-bitfield since
1763 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1764 /// to introduce the performance impact of a bitfield.
1765 unsigned NumArgs;
1766 };
1767
1768 class PackExpansionTypeBitfields {
1769 friend class PackExpansionType;
1770
1771 unsigned : NumTypeBits;
1772
1773 /// The number of expansions that this pack expansion will
1774 /// generate when substituted (+1), which is expected to be able to
1775 /// hold at least 1024 according to [implimits]. However, as this limit
1776 /// is somewhat easy to hit with template metaprogramming we'd prefer to
1777 /// keep it as large as possible. At the moment it has been left as a
1778 /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
1779 /// there is no reason to introduce the performance impact of a bitfield.
1780 ///
1781 /// This field will only have a non-zero value when some of the parameter
1782 /// packs that occur within the pattern have been substituted but others
1783 /// have not.
1784 unsigned NumExpansions;
1785 };
1786
1787 union {
1788 TypeBitfields TypeBits;
1789 ArrayTypeBitfields ArrayTypeBits;
1790 ConstantArrayTypeBitfields ConstantArrayTypeBits;
1791 AttributedTypeBitfields AttributedTypeBits;
1792 AutoTypeBitfields AutoTypeBits;
1793 BuiltinTypeBitfields BuiltinTypeBits;
1794 FunctionTypeBitfields FunctionTypeBits;
1795 ObjCObjectTypeBitfields ObjCObjectTypeBits;
1796 ReferenceTypeBitfields ReferenceTypeBits;
1797 TypeWithKeywordBitfields TypeWithKeywordBits;
1798 ElaboratedTypeBitfields ElaboratedTypeBits;
1799 VectorTypeBitfields VectorTypeBits;
1800 SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
1801 TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
1802 DependentTemplateSpecializationTypeBitfields
1803 DependentTemplateSpecializationTypeBits;
1804 PackExpansionTypeBitfields PackExpansionTypeBits;
1805 };
1806
1807private:
1808 template <class T> friend class TypePropertyCache;
1809
1810 /// Set whether this type comes from an AST file.
1811 void setFromAST(bool V = true) const {
1812 TypeBits.FromAST = V;
1813 }
1814
1815protected:
1816 friend class ASTContext;
1817
1818 Type(TypeClass tc, QualType canon, TypeDependence Dependence)
1819 : ExtQualsTypeCommonBase(this,
1820 canon.isNull() ? QualType(this_(), 0) : canon) {
1821 static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
1822 "changing bitfields changed sizeof(Type)!");
1823 static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
1824 "Insufficient alignment!");
1825 TypeBits.TC = tc;
1826 TypeBits.Dependence = static_cast<unsigned>(Dependence);
1827 TypeBits.CacheValid = false;
1828 TypeBits.CachedLocalOrUnnamed = false;
1829 TypeBits.CachedLinkage = NoLinkage;
1830 TypeBits.FromAST = false;
1831 }
1832
1833 // silence VC++ warning C4355: 'this' : used in base member initializer list
1834 Type *this_() { return this; }
1835
1836 void setDependence(TypeDependence D) {
1837 TypeBits.Dependence = static_cast<unsigned>(D);
1838 }
1839
1840 void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
1841
1842public:
1843 friend class ASTReader;
1844 friend class ASTWriter;
1845 template <class T> friend class serialization::AbstractTypeReader;
1846 template <class T> friend class serialization::AbstractTypeWriter;
1847
1848 Type(const Type &) = delete;
1849 Type(Type &&) = delete;
1850 Type &operator=(const Type &) = delete;
1851 Type &operator=(Type &&) = delete;
1852
1853 TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1854
1855 /// Whether this type comes from an AST file.
1856 bool isFromAST() const { return TypeBits.FromAST; }
1857
1858 /// Whether this type is or contains an unexpanded parameter
1859 /// pack, used to support C++0x variadic templates.
1860 ///
1861 /// A type that contains a parameter pack shall be expanded by the
1862 /// ellipsis operator at some point. For example, the typedef in the
1863 /// following example contains an unexpanded parameter pack 'T':
1864 ///
1865 /// \code
1866 /// template<typename ...T>
1867 /// struct X {
1868 /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
1869 /// };
1870 /// \endcode
1871 ///
1872 /// Note that this routine does not specify which
1873 bool containsUnexpandedParameterPack() const {
1874 return getDependence() & TypeDependence::UnexpandedPack;
1875 }
1876
1877 /// Determines if this type would be canonical if it had no further
1878 /// qualification.
1879 bool isCanonicalUnqualified() const {
1880 return CanonicalType == QualType(this, 0);
1881 }
1882
1883 /// Pull a single level of sugar off of this locally-unqualified type.
1884 /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1885 /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1886 QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1887
1888 /// As an extension, we classify types as one of "sized" or "sizeless";
1889 /// every type is one or the other. Standard types are all sized;
1890 /// sizeless types are purely an extension.
1891 ///
1892 /// Sizeless types contain data with no specified size, alignment,
1893 /// or layout.
1894 bool isSizelessType() const;
1895 bool isSizelessBuiltinType() const;
1896
1897 /// Determines if this is a sizeless type supported by the
1898 /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
1899 /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
1900 bool isVLSTBuiltinType() const;
1901
1902 /// Returns the representative type for the element of an SVE builtin type.
1903 /// This is used to represent fixed-length SVE vectors created with the
1904 /// 'arm_sve_vector_bits' type attribute as VectorType.
1905 QualType getSveEltType(const ASTContext &Ctx) const;
1906
1907 /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1908 /// object types, function types, and incomplete types.
1909
1910 /// Return true if this is an incomplete type.
1911 /// A type that can describe objects, but which lacks information needed to
1912 /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1913 /// routine will need to determine if the size is actually required.
1914 ///
1915 /// Def If non-null, and the type refers to some kind of declaration
1916 /// that can be completed (such as a C struct, C++ class, or Objective-C
1917 /// class), will be set to the declaration.
1918 bool isIncompleteType(NamedDecl **Def = nullptr) const;
1919
1920 /// Return true if this is an incomplete or object
1921 /// type, in other words, not a function type.
1922 bool isIncompleteOrObjectType() const {
1923 return !isFunctionType();
1924 }
1925
1926 /// Determine whether this type is an object type.
1927 bool isObjectType() const {
1928 // C++ [basic.types]p8:
1929 // An object type is a (possibly cv-qualified) type that is not a
1930 // function type, not a reference type, and not a void type.
1931 return !isReferenceType() && !isFunctionType() && !isVoidType();
1932 }
1933
1934 /// Return true if this is a literal type
1935 /// (C++11 [basic.types]p10)
1936 bool isLiteralType(const ASTContext &Ctx) const;
1937
1938 /// Determine if this type is a structural type, per C++20 [temp.param]p7.
1939 bool isStructuralType() const;
1940
1941 /// Test if this type is a standard-layout type.
1942 /// (C++0x [basic.type]p9)
1943 bool isStandardLayoutType() const;
1944
1945 /// Helper methods to distinguish type categories. All type predicates
1946 /// operate on the canonical type, ignoring typedefs and qualifiers.
1947
1948 /// Returns true if the type is a builtin type.
1949 bool isBuiltinType() const;
1950
1951 /// Test for a particular builtin type.
1952 bool isSpecificBuiltinType(unsigned K) const;
1953
1954 /// Test for a type which does not represent an actual type-system type but
1955 /// is instead used as a placeholder for various convenient purposes within
1956 /// Clang. All such types are BuiltinTypes.
1957 bool isPlaceholderType() const;
1958 const BuiltinType *getAsPlaceholderType() const;
1959
1960 /// Test for a specific placeholder type.
1961 bool isSpecificPlaceholderType(unsigned K) const;
1962
1963 /// Test for a placeholder type other than Overload; see
1964 /// BuiltinType::isNonOverloadPlaceholderType.
1965 bool isNonOverloadPlaceholderType() const;
1966
1967 /// isIntegerType() does *not* include complex integers (a GCC extension).
1968 /// isComplexIntegerType() can be used to test for complex integers.
1969 bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
1970 bool isEnumeralType() const;
1971
1972 /// Determine whether this type is a scoped enumeration type.
1973 bool isScopedEnumeralType() const;
1974 bool isBooleanType() const;
1975 bool isCharType() const;
1976 bool isWideCharType() const;
1977 bool isChar8Type() const;
1978 bool isChar16Type() const;
1979 bool isChar32Type() const;
1980 bool isAnyCharacterType() const;
1981 bool isIntegralType(const ASTContext &Ctx) const;
1982
1983 /// Determine whether this type is an integral or enumeration type.
1984 bool isIntegralOrEnumerationType() const;
1985
1986 /// Determine whether this type is an integral or unscoped enumeration type.
1987 bool isIntegralOrUnscopedEnumerationType() const;
1988 bool isUnscopedEnumerationType() const;
1989
1990 /// Floating point categories.
1991 bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1992 /// isComplexType() does *not* include complex integers (a GCC extension).
1993 /// isComplexIntegerType() can be used to test for complex integers.
1994 bool isComplexType() const; // C99 6.2.5p11 (complex)
1995 bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
1996 bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
1997 bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
1998 bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
1999 bool isBFloat16Type() const;
2000 bool isFloat128Type() const;
2001 bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
2002 bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
2003 bool isVoidType() const; // C99 6.2.5p19
2004 bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
2005 bool isAggregateType() const;
2006 bool isFundamentalType() const;
2007 bool isCompoundType() const;
2008
2009 // Type Predicates: Check to see if this type is structurally the specified
2010 // type, ignoring typedefs and qualifiers.
2011 bool isFunctionType() const;
2012 bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
2013 bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
2014 bool isPointerType() const;
2015 bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
2016 bool isBlockPointerType() const;
2017 bool isVoidPointerType() const;
2018 bool isReferenceType() const;
2019 bool isLValueReferenceType() const;
2020 bool isRValueReferenceType() const;
2021 bool isObjectPointerType() const;
2022 bool isFunctionPointerType() const;
2023 bool isFunctionReferenceType() const;
2024 bool isMemberPointerType() const;
2025 bool isMemberFunctionPointerType() const;
2026 bool isMemberDataPointerType() const;
2027 bool isArrayType() const;
2028 bool isConstantArrayType() const;
2029 bool isIncompleteArrayType() const;
2030 bool isVariableArrayType() const;
2031 bool isDependentSizedArrayType() const;
2032 bool isRecordType() const;
2033 bool isClassType() const;
2034 bool isStructureType() const;
2035 bool isObjCBoxableRecordType() const;
2036 bool isInterfaceType() const;
2037 bool isStructureOrClassType() const;
2038 bool isUnionType() const;
2039 bool isComplexIntegerType() const; // GCC _Complex integer type.
2040 bool isVectorType() const; // GCC vector type.
2041 bool isExtVectorType() const; // Extended vector type.
2042 bool isMatrixType() const; // Matrix type.
2043 bool isConstantMatrixType() const; // Constant matrix type.
2044 bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
2045 bool isObjCObjectPointerType() const; // pointer to ObjC object
2046 bool isObjCRetainableType() const; // ObjC object or block pointer
2047 bool isObjCLifetimeType() const; // (array of)* retainable type
2048 bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
2049 bool isObjCNSObjectType() const; // __attribute__((NSObject))
2050 bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
2051 // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2052 // for the common case.
2053 bool isObjCObjectType() const; // NSString or typeof(*(id)0)
2054 bool isObjCQualifiedInterfaceType() const; // NSString<foo>
2055 bool isObjCQualifiedIdType() const; // id<foo>
2056 bool isObjCQualifiedClassType() const; // Class<foo>
2057 bool isObjCObjectOrInterfaceType() const;
2058 bool isObjCIdType() const; // id
2059 bool isDecltypeType() const;
2060 /// Was this type written with the special inert-in-ARC __unsafe_unretained
2061 /// qualifier?
2062 ///
2063 /// This approximates the answer to the following question: if this
2064 /// translation unit were compiled in ARC, would this type be qualified
2065 /// with __unsafe_unretained?
2066 bool isObjCInertUnsafeUnretainedType() const {
2067 return hasAttr(attr::ObjCInertUnsafeUnretained);
2068 }
2069
2070 /// Whether the type is Objective-C 'id' or a __kindof type of an
2071 /// object type, e.g., __kindof NSView * or __kindof id
2072 /// <NSCopying>.
2073 ///
2074 /// \param bound Will be set to the bound on non-id subtype types,
2075 /// which will be (possibly specialized) Objective-C class type, or
2076 /// null for 'id.
2077 bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2078 const ObjCObjectType *&bound) const;
2079
2080 bool isObjCClassType() const; // Class
2081
2082 /// Whether the type is Objective-C 'Class' or a __kindof type of an
2083 /// Class type, e.g., __kindof Class <NSCopying>.
2084 ///
2085 /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2086 /// here because Objective-C's type system cannot express "a class
2087 /// object for a subclass of NSFoo".
2088 bool isObjCClassOrClassKindOfType() const;
2089
2090 bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2091 bool isObjCSelType() const; // Class
2092 bool isObjCBuiltinType() const; // 'id' or 'Class'
2093 bool isObjCARCBridgableType() const;
2094 bool isCARCBridgableType() const;
2095 bool isTemplateTypeParmType() const; // C++ template type parameter
2096 bool isNullPtrType() const; // C++11 std::nullptr_t
2097 bool isNothrowT() const; // C++ std::nothrow_t
2098 bool isAlignValT() const; // C++17 std::align_val_t
2099 bool isStdByteType() const; // C++17 std::byte
2100 bool isAtomicType() const; // C11 _Atomic()
2101 bool isUndeducedAutoType() const; // C++11 auto or
2102 // C++14 decltype(auto)
2103 bool isTypedefNameType() const; // typedef or alias template
2104
2105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2106 bool is##Id##Type() const;
2107#include "clang/Basic/OpenCLImageTypes.def"
2108
2109 bool isImageType() const; // Any OpenCL image type
2110
2111 bool isSamplerT() const; // OpenCL sampler_t
2112 bool isEventT() const; // OpenCL event_t
2113 bool isClkEventT() const; // OpenCL clk_event_t
2114 bool isQueueT() const; // OpenCL queue_t
2115 bool isReserveIDT() const; // OpenCL reserve_id_t
2116
2117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2118 bool is##Id##Type() const;
2119#include "clang/Basic/OpenCLExtensionTypes.def"
2120 // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2121 bool isOCLIntelSubgroupAVCType() const;
2122 bool isOCLExtOpaqueType() const; // Any OpenCL extension type
2123
2124 bool isPipeType() const; // OpenCL pipe type
2125 bool isExtIntType() const; // Extended Int Type
2126 bool isOpenCLSpecificType() const; // Any OpenCL specific type
2127
2128 /// Determines if this type, which must satisfy
2129 /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2130 /// than implicitly __strong.
2131 bool isObjCARCImplicitlyUnretainedType() const;
2132
2133 /// Check if the type is the CUDA device builtin surface type.
2134 bool isCUDADeviceBuiltinSurfaceType() const;
2135 /// Check if the type is the CUDA device builtin texture type.
2136 bool isCUDADeviceBuiltinTextureType() const;
2137
2138 /// Return the implicit lifetime for this type, which must not be dependent.
2139 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2140
2141 enum ScalarTypeKind {
2142 STK_CPointer,
2143 STK_BlockPointer,
2144 STK_ObjCObjectPointer,
2145 STK_MemberPointer,
2146 STK_Bool,
2147 STK_Integral,
2148 STK_Floating,
2149 STK_IntegralComplex,
2150 STK_FloatingComplex,
2151 STK_FixedPoint
2152 };
2153
2154 /// Given that this is a scalar type, classify it.
2155 ScalarTypeKind getScalarTypeKind() const;
2156
2157 TypeDependence getDependence() const {
2158 return static_cast<TypeDependence>(TypeBits.Dependence);
2159 }
2160
2161 /// Whether this type is an error type.
2162 bool containsErrors() const {
2163 return getDependence() & TypeDependence::Error;
2164 }
2165
2166 /// Whether this type is a dependent type, meaning that its definition
2167 /// somehow depends on a template parameter (C++ [temp.dep.type]).
2168 bool isDependentType() const {
2169 return getDependence() & TypeDependence::Dependent;
2170 }
2171
2172 /// Determine whether this type is an instantiation-dependent type,
2173 /// meaning that the type involves a template parameter (even if the
2174 /// definition does not actually depend on the type substituted for that
2175 /// template parameter).
2176 bool isInstantiationDependentType() const {
2177 return getDependence() & TypeDependence::Instantiation;
2178 }
2179
2180 /// Determine whether this type is an undeduced type, meaning that
2181 /// it somehow involves a C++11 'auto' type or similar which has not yet been
2182 /// deduced.
2183 bool isUndeducedType() const;
2184
2185 /// Whether this type is a variably-modified type (C99 6.7.5).
2186 bool isVariablyModifiedType() const {
2187 return getDependence() & TypeDependence::VariablyModified;
2188 }
2189
2190 /// Whether this type involves a variable-length array type
2191 /// with a definite size.
2192 bool hasSizedVLAType() const;
2193
2194 /// Whether this type is or contains a local or unnamed type.
2195 bool hasUnnamedOrLocalType() const;
2196
2197 bool isOverloadableType() const;
2198
2199 /// Determine wither this type is a C++ elaborated-type-specifier.
2200 bool isElaboratedTypeSpecifier() const;
2201
2202 bool canDecayToPointerType() const;
2203
2204 /// Whether this type is represented natively as a pointer. This includes
2205 /// pointers, references, block pointers, and Objective-C interface,
2206 /// qualified id, and qualified interface types, as well as nullptr_t.
2207 bool hasPointerRepresentation() const;
2208
2209 /// Whether this type can represent an objective pointer type for the
2210 /// purpose of GC'ability
2211 bool hasObjCPointerRepresentation() const;
2212
2213 /// Determine whether this type has an integer representation
2214 /// of some sort, e.g., it is an integer type or a vector.
2215 bool hasIntegerRepresentation() const;
2216
2217 /// Determine whether this type has an signed integer representation
2218 /// of some sort, e.g., it is an signed integer type or a vector.
2219 bool hasSignedIntegerRepresentation() const;
2220
2221 /// Determine whether this type has an unsigned integer representation
2222 /// of some sort, e.g., it is an unsigned integer type or a vector.
2223 bool hasUnsignedIntegerRepresentation() const;
2224
2225 /// Determine whether this type has a floating-point representation
2226 /// of some sort, e.g., it is a floating-point type or a vector thereof.
2227 bool hasFloatingRepresentation() const;
2228
2229 // Type Checking Functions: Check to see if this type is structurally the
2230 // specified type, ignoring typedefs and qualifiers, and return a pointer to
2231 // the best type we can.
2232 const RecordType *getAsStructureType() const;
2233 /// NOTE: getAs*ArrayType are methods on ASTContext.
2234 const RecordType *getAsUnionType() const;
2235 const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2236 const ObjCObjectType *getAsObjCInterfaceType() const;
2237
2238 // The following is a convenience method that returns an ObjCObjectPointerType
2239 // for object declared using an interface.
2240 const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2241 const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2242 const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2243 const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2244
2245 /// Retrieves the CXXRecordDecl that this type refers to, either
2246 /// because the type is a RecordType or because it is the injected-class-name
2247 /// type of a class template or class template partial specialization.
2248 CXXRecordDecl *getAsCXXRecordDecl() const;
2249
2250 /// Retrieves the RecordDecl this type refers to.
2251 RecordDecl *getAsRecordDecl() const;
2252
2253 /// Retrieves the TagDecl that this type refers to, either
2254 /// because the type is a TagType or because it is the injected-class-name
2255 /// type of a class template or class template partial specialization.
2256 TagDecl *getAsTagDecl() const;
2257
2258 /// If this is a pointer or reference to a RecordType, return the
2259 /// CXXRecordDecl that the type refers to.
2260 ///
2261 /// If this is not a pointer or reference, or the type being pointed to does
2262 /// not refer to a CXXRecordDecl, returns NULL.
2263 const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2264
2265 /// Get the DeducedType whose type will be deduced for a variable with
2266 /// an initializer of this type. This looks through declarators like pointer
2267 /// types, but not through decltype or typedefs.
2268 DeducedType *getContainedDeducedType() const;
2269
2270 /// Get the AutoType whose type will be deduced for a variable with
2271 /// an initializer of this type. This looks through declarators like pointer
2272 /// types, but not through decltype or typedefs.
2273 AutoType *getContainedAutoType() const {
2274 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2275 }
2276
2277 /// Determine whether this type was written with a leading 'auto'
2278 /// corresponding to a trailing return type (possibly for a nested
2279 /// function type within a pointer to function type or similar).
2280 bool hasAutoForTrailingReturnType() const;
2281
2282 /// Member-template getAs<specific type>'. Look through sugar for
2283 /// an instance of \<specific type>. This scheme will eventually
2284 /// replace the specific getAsXXXX methods above.
2285 ///
2286 /// There are some specializations of this member template listed
2287 /// immediately following this class.
2288 template <typename T> const T *getAs() const;
2289
2290 /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2291 /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
2292 /// This is used when you need to walk over sugar nodes that represent some
2293 /// kind of type adjustment from a type that was written as a \<specific type>
2294 /// to another type that is still canonically a \<specific type>.
2295 template <typename T> const T *getAsAdjusted() const;
2296
2297 /// A variant of getAs<> for array types which silently discards
2298 /// qualifiers from the outermost type.
2299 const ArrayType *getAsArrayTypeUnsafe() const;
2300
2301 /// Member-template castAs<specific type>. Look through sugar for
2302 /// the underlying instance of \<specific type>.
2303 ///
2304 /// This method has the same relationship to getAs<T> as cast<T> has
2305 /// to dyn_cast<T>; which is to say, the underlying type *must*
2306 /// have the intended type, and this method will never return null.
2307 template <typename T> const T *castAs() const;
2308
2309 /// A variant of castAs<> for array type which silently discards
2310 /// qualifiers from the outermost type.
2311 const ArrayType *castAsArrayTypeUnsafe() const;
2312
2313 /// Determine whether this type had the specified attribute applied to it
2314 /// (looking through top-level type sugar).
2315 bool hasAttr(attr::Kind AK) const;
2316
2317 /// Get the base element type of this type, potentially discarding type
2318 /// qualifiers. This should never be used when type qualifiers
2319 /// are meaningful.
2320 const Type *getBaseElementTypeUnsafe() const;
2321
2322 /// If this is an array type, return the element type of the array,
2323 /// potentially with type qualifiers missing.
2324 /// This should never be used when type qualifiers are meaningful.
2325 const Type *getArrayElementTypeNoTypeQual() const;
2326
2327 /// If this is a pointer type, return the pointee type.
2328 /// If this is an array type, return the array element type.
2329 /// This should never be used when type qualifiers are meaningful.
2330 const Type *getPointeeOrArrayElementType() const;
2331
2332 /// If this is a pointer, ObjC object pointer, or block
2333 /// pointer, this returns the respective pointee.
2334 QualType getPointeeType() const;
2335
2336 /// Return the specified type with any "sugar" removed from the type,
2337 /// removing any typedefs, typeofs, etc., as well as any qualifiers.
2338 const Type *getUnqualifiedDesugaredType() const;
2339
2340 /// More type predicates useful for type checking/promotion
2341 bool isPromotableIntegerType() const; // C99 6.3.1.1p2
2342
2343 /// Return true if this is an integer type that is
2344 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2345 /// or an enum decl which has a signed representation.
2346 bool isSignedIntegerType() const;
2347
2348 /// Return true if this is an integer type that is
2349 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
2350 /// or an enum decl which has an unsigned representation.
2351 bool isUnsignedIntegerType() const;
2352
2353 /// Determines whether this is an integer type that is signed or an
2354 /// enumeration types whose underlying type is a signed integer type.
2355 bool isSignedIntegerOrEnumerationType() const;
2356
2357 /// Determines whether this is an integer type that is unsigned or an
2358 /// enumeration types whose underlying type is a unsigned integer type.
2359 bool isUnsignedIntegerOrEnumerationType() const;
2360
2361 /// Return true if this is a fixed point type according to
2362 /// ISO/IEC JTC1 SC22 WG14 N1169.
2363 bool isFixedPointType() const;
2364
2365 /// Return true if this is a fixed point or integer type.
2366 bool isFixedPointOrIntegerType() const;
2367
2368 /// Return true if this is a saturated fixed point type according to
2369 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2370 bool isSaturatedFixedPointType() const;
2371
2372 /// Return true if this is a saturated fixed point type according to
2373 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2374 bool isUnsaturatedFixedPointType() const;
2375
2376 /// Return true if this is a fixed point type that is signed according
2377 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2378 bool isSignedFixedPointType() const;
2379
2380 /// Return true if this is a fixed point type that is unsigned according
2381 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2382 bool isUnsignedFixedPointType() const;
2383
2384 /// Return true if this is not a variable sized type,
2385 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2386 /// incomplete types.
2387 bool isConstantSizeType() const;
2388
2389 /// Returns true if this type can be represented by some
2390 /// set of type specifiers.
2391 bool isSpecifierType() const;
2392
2393 /// Determine the linkage of this type.
2394 Linkage getLinkage() const;
2395
2396 /// Determine the visibility of this type.
2397 Visibility getVisibility() const {
2398 return getLinkageAndVisibility().getVisibility();
2399 }
2400
2401 /// Return true if the visibility was explicitly set is the code.
2402 bool isVisibilityExplicit() const {
2403 return getLinkageAndVisibility().isVisibilityExplicit();
2404 }
2405
2406 /// Determine the linkage and visibility of this type.
2407 LinkageInfo getLinkageAndVisibility() const;
2408
2409 /// True if the computed linkage is valid. Used for consistency
2410 /// checking. Should always return true.
2411 bool isLinkageValid() const;
2412
2413 /// Determine the nullability of the given type.
2414 ///
2415 /// Note that nullability is only captured as sugar within the type
2416 /// system, not as part of the canonical type, so nullability will
2417 /// be lost by canonicalization and desugaring.
2418 Optional<NullabilityKind> getNullability(const ASTContext &context) const;
2419
2420 /// Determine whether the given type can have a nullability
2421 /// specifier applied to it, i.e., if it is any kind of pointer type.
2422 ///
2423 /// \param ResultIfUnknown The value to return if we don't yet know whether
2424 /// this type can have nullability because it is dependent.
2425 bool canHaveNullability(bool ResultIfUnknown = true) const;
2426
2427 /// Retrieve the set of substitutions required when accessing a member
2428 /// of the Objective-C receiver type that is declared in the given context.
2429 ///
2430 /// \c *this is the type of the object we're operating on, e.g., the
2431 /// receiver for a message send or the base of a property access, and is
2432 /// expected to be of some object or object pointer type.
2433 ///
2434 /// \param dc The declaration context for which we are building up a
2435 /// substitution mapping, which should be an Objective-C class, extension,
2436 /// category, or method within.
2437 ///
2438 /// \returns an array of type arguments that can be substituted for
2439 /// the type parameters of the given declaration context in any type described
2440 /// within that context, or an empty optional to indicate that no
2441 /// substitution is required.
2442 Optional<ArrayRef<QualType>>
2443 getObjCSubstitutions(const DeclContext *dc) const;
2444
2445 /// Determines if this is an ObjC interface type that may accept type
2446 /// parameters.
2447 bool acceptsObjCTypeParams() const;
2448
2449 const char *getTypeClassName() const;
2450
2451 QualType getCanonicalTypeInternal() const {
2452 return CanonicalType;
2453 }
2454
2455 CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
2456 void dump() const;
2457 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2458};
2459
2460/// This will check for a TypedefType by removing any existing sugar
2461/// until it reaches a TypedefType or a non-sugared type.
2462template <> const TypedefType *Type::getAs() const;
2463
2464/// This will check for a TemplateSpecializationType by removing any
2465/// existing sugar until it reaches a TemplateSpecializationType or a
2466/// non-sugared type.
2467template <> const TemplateSpecializationType *Type::getAs() const;
2468
2469/// This will check for an AttributedType by removing any existing sugar
2470/// until it reaches an AttributedType or a non-sugared type.
2471template <> const AttributedType *Type::getAs() const;
2472
2473// We can do canonical leaf types faster, because we don't have to
2474// worry about preserving child type decoration.
2475#define TYPE(Class, Base)
2476#define LEAF_TYPE(Class) \
2477template <> inline const Class##Type *Type::getAs() const { \
2478 return dyn_cast<Class##Type>(CanonicalType); \
2479} \
2480template <> inline const Class##Type *Type::castAs() const { \
2481 return cast<Class##Type>(CanonicalType); \
2482}
2483#include "clang/AST/TypeNodes.inc"
2484
2485/// This class is used for builtin types like 'int'. Builtin
2486/// types are always canonical and have a literal name field.
2487class BuiltinType : public Type {
2488public:
2489 enum Kind {
2490// OpenCL image types
2491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492#include "clang/Basic/OpenCLImageTypes.def"
2493// OpenCL extension types
2494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495#include "clang/Basic/OpenCLExtensionTypes.def"
2496// SVE Types
2497#define SVE_TYPE(Name, Id, SingletonId) Id,
2498#include "clang/Basic/AArch64SVEACLETypes.def"
2499// PPC MMA Types
2500#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501#include "clang/Basic/PPCTypes.def"
2502// RVV Types
2503#define RVV_TYPE(Name, Id, SingletonId) Id,
2504#include "clang/Basic/RISCVVTypes.def"
2505// All other builtin types
2506#define BUILTIN_TYPE(Id, SingletonId) Id,
2507#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508#include "clang/AST/BuiltinTypes.def"
2509 };
2510
2511private:
2512 friend class ASTContext; // ASTContext creates these.
2513
2514 BuiltinType(Kind K)
2515 : Type(Builtin, QualType(),
2516 K == Dependent ? TypeDependence::DependentInstantiation
2517 : TypeDependence::None) {
2518 BuiltinTypeBits.Kind = K;
2519 }
2520
2521public:
2522 Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
2523 StringRef getName(const PrintingPolicy &Policy) const;
2524
2525 const char *getNameAsCString(const PrintingPolicy &Policy) const {
2526 // The StringRef is null-terminated.
2527 StringRef str = getName(Policy);
2528 assert(!str.empty() && str.data()[str.size()] == '\0')((void)0);
2529 return str.data();
2530 }
2531
2532 bool isSugared() const { return false; }
2533 QualType desugar() const { return QualType(this, 0); }
2534
2535 bool isInteger() const {
2536 return getKind() >= Bool && getKind() <= Int128;
2537 }
2538
2539 bool isSignedInteger() const {
2540 return getKind() >= Char_S && getKind() <= Int128;
2541 }
2542
2543 bool isUnsignedInteger() const {
2544 return getKind() >= Bool && getKind() <= UInt128;
2545 }
2546
2547 bool isFloatingPoint() const {
2548 return getKind() >= Half && getKind() <= Float128;
2549 }
2550
2551 /// Determines whether the given kind corresponds to a placeholder type.
2552 static bool isPlaceholderTypeKind(Kind K) {
2553 return K >= Overload;
2554 }
2555
2556 /// Determines whether this type is a placeholder type, i.e. a type
2557 /// which cannot appear in arbitrary positions in a fully-formed
2558 /// expression.
2559 bool isPlaceholderType() const {
2560 return isPlaceholderTypeKind(getKind());
2561 }
2562
2563 /// Determines whether this type is a placeholder type other than
2564 /// Overload. Most placeholder types require only syntactic
2565 /// information about their context in order to be resolved (e.g.
2566 /// whether it is a call expression), which means they can (and
2567 /// should) be resolved in an earlier "phase" of analysis.
2568 /// Overload expressions sometimes pick up further information
2569 /// from their context, like whether the context expects a
2570 /// specific function-pointer type, and so frequently need
2571 /// special treatment.
2572 bool isNonOverloadPlaceholderType() const {
2573 return getKind() > Overload;
2574 }
2575
2576 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2577};
2578
2579/// Complex values, per C99 6.2.5p11. This supports the C99 complex
2580/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581class ComplexType : public Type, public llvm::FoldingSetNode {
2582 friend class ASTContext; // ASTContext creates these.
2583
2584 QualType ElementType;
2585
2586 ComplexType(QualType Element, QualType CanonicalPtr)
2587 : Type(Complex, CanonicalPtr, Element->getDependence()),
2588 ElementType(Element) {}
2589
2590public:
2591 QualType getElementType() const { return ElementType; }
2592
2593 bool isSugared() const { return false; }
2594 QualType desugar() const { return QualType(this, 0); }
2595
2596 void Profile(llvm::FoldingSetNodeID &ID) {
2597 Profile(ID, getElementType());
2598 }
2599
2600 static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
2601 ID.AddPointer(Element.getAsOpaquePtr());
2602 }
2603
2604 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2605};
2606
2607/// Sugar for parentheses used when specifying types.
2608class ParenType : public Type, public llvm::FoldingSetNode {
2609 friend class ASTContext; // ASTContext creates these.
2610
2611 QualType Inner;
2612
2613 ParenType(QualType InnerType, QualType CanonType)
2614 : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
2615
2616public:
2617 QualType getInnerType() const { return Inner; }
2618
2619 bool isSugared() const { return true; }
2620 QualType desugar() const { return getInnerType(); }
2621
2622 void Profile(llvm::FoldingSetNodeID &ID) {
2623 Profile(ID, getInnerType());
2624 }
2625
2626 static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
2627 Inner.Profile(ID);
2628 }
2629
2630 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2631};
2632
2633/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634class PointerType : public Type, public llvm::FoldingSetNode {
2635 friend class ASTContext; // ASTContext creates these.
2636
2637 QualType PointeeType;
2638
2639 PointerType(QualType Pointee, QualType CanonicalPtr)
2640 : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
2641 PointeeType(Pointee) {}
2642
2643public:
2644 QualType getPointeeType() const { return PointeeType; }
2645
2646 bool isSugared() const { return false; }
2647 QualType desugar() const { return QualType(this, 0); }
2648
2649 void Profile(llvm::FoldingSetNodeID &ID) {
2650 Profile(ID, getPointeeType());
2651 }
2652
2653 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2654 ID.AddPointer(Pointee.getAsOpaquePtr());
2655 }
2656
2657 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2658};
2659
2660/// Represents a type which was implicitly adjusted by the semantic
2661/// engine for arbitrary reasons. For example, array and function types can
2662/// decay, and function types can have their calling conventions adjusted.
2663class AdjustedType : public Type, public llvm::FoldingSetNode {
2664 QualType OriginalTy;
2665 QualType AdjustedTy;
2666
2667protected:
2668 friend class ASTContext; // ASTContext creates these.
2669
2670 AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
2671 QualType CanonicalPtr)
2672 : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
2673 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2674
2675public:
2676 QualType getOriginalType() const { return OriginalTy; }
2677 QualType getAdjustedType() const { return AdjustedTy; }
2678
2679 bool isSugared() const { return true; }
2680 QualType desugar() const { return AdjustedTy; }
2681
2682 void Profile(llvm::FoldingSetNodeID &ID) {
2683 Profile(ID, OriginalTy, AdjustedTy);
2684 }
2685
2686 static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
2687 ID.AddPointer(Orig.getAsOpaquePtr());
2688 ID.AddPointer(New.getAsOpaquePtr());
2689 }
2690
2691 static bool classof(const Type *T) {
2692 return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
2693 }
2694};
2695
2696/// Represents a pointer type decayed from an array or function type.
2697class DecayedType : public AdjustedType {
2698 friend class ASTContext; // ASTContext creates these.
2699
2700 inline
2701 DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
2702
2703public:
2704 QualType getDecayedType() const { return getAdjustedType(); }
2705
2706 inline QualType getPointeeType() const;
2707
2708 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709};
2710
2711/// Pointer to a block type.
2712/// This type is to represent types syntactically represented as
2713/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714class BlockPointerType : public Type, public llvm::FoldingSetNode {
2715 friend class ASTContext; // ASTContext creates these.
2716
2717 // Block is some kind of pointer type
2718 QualType PointeeType;
2719
2720 BlockPointerType(QualType Pointee, QualType CanonicalCls)
2721 : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
2722 PointeeType(Pointee) {}
2723
2724public:
2725 // Get the pointee type. Pointee is required to always be a function type.
2726 QualType getPointeeType() const { return PointeeType; }
2727
2728 bool isSugared() const { return false; }
2729 QualType desugar() const { return QualType(this, 0); }
2730
2731 void Profile(llvm::FoldingSetNodeID &ID) {
2732 Profile(ID, getPointeeType());
2733 }
2734
2735 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2736 ID.AddPointer(Pointee.getAsOpaquePtr());
2737 }
2738
2739 static bool classof(const Type *T) {
2740 return T->getTypeClass() == BlockPointer;
2741 }
2742};
2743
2744/// Base for LValueReferenceType and RValueReferenceType
2745class ReferenceType : public Type, public llvm::FoldingSetNode {
2746 QualType PointeeType;
2747
2748protected:
2749 ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2750 bool SpelledAsLValue)
2751 : Type(tc, CanonicalRef, Referencee->getDependence()),
2752 PointeeType(Referencee) {
2753 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2754 ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2755 }
2756
2757public:
2758 bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2759 bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2760
2761 QualType getPointeeTypeAsWritten() const { return PointeeType; }
2762
2763 QualType getPointeeType() const {
2764 // FIXME: this might strip inner qualifiers; okay?
2765 const ReferenceType *T = this;
2766 while (T->isInnerRef())
2767 T = T->PointeeType->castAs<ReferenceType>();
2768 return T->PointeeType;
2769 }
2770
2771 void Profile(llvm::FoldingSetNodeID &ID) {
2772 Profile(ID, PointeeType, isSpelledAsLValue());
2773 }
2774
2775 static void Profile(llvm::FoldingSetNodeID &ID,
2776 QualType Referencee,
2777 bool SpelledAsLValue) {
2778 ID.AddPointer(Referencee.getAsOpaquePtr());
2779 ID.AddBoolean(SpelledAsLValue);
2780 }
2781
2782 static bool classof(const Type *T) {
2783 return T->getTypeClass() == LValueReference ||
2784 T->getTypeClass() == RValueReference;
2785 }
2786};
2787
2788/// An lvalue reference type, per C++11 [dcl.ref].
2789class LValueReferenceType : public ReferenceType {
2790 friend class ASTContext; // ASTContext creates these
2791
2792 LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2793 bool SpelledAsLValue)
2794 : ReferenceType(LValueReference, Referencee, CanonicalRef,
2795 SpelledAsLValue) {}
2796
2797public:
2798 bool isSugared() const { return false; }
2799 QualType desugar() const { return QualType(this, 0); }
2800
2801 static bool classof(const Type *T) {
2802 return T->getTypeClass() == LValueReference;
2803 }
2804};
2805
2806/// An rvalue reference type, per C++11 [dcl.ref].
2807class RValueReferenceType : public ReferenceType {
2808 friend class ASTContext; // ASTContext creates these
2809
2810 RValueReferenceType(QualType Referencee, QualType CanonicalRef)
2811 : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
2812
2813public:
2814 bool isSugared() const { return false; }
2815 QualType desugar() const { return QualType(this, 0); }
2816
2817 static bool classof(const Type *T) {
2818 return T->getTypeClass() == RValueReference;
2819 }
2820};
2821
2822/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823///
2824/// This includes both pointers to data members and pointer to member functions.
2825class MemberPointerType : public Type, public llvm::FoldingSetNode {
2826 friend class ASTContext; // ASTContext creates these.
2827
2828 QualType PointeeType;
2829
2830 /// The class of which the pointee is a member. Must ultimately be a
2831 /// RecordType, but could be a typedef or a template parameter too.
2832 const Type *Class;
2833
2834 MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2835 : Type(MemberPointer, CanonicalPtr,
2836 (Cls->getDependence() & ~TypeDependence::VariablyModified) |
2837 Pointee->getDependence()),
2838 PointeeType(Pointee), Class(Cls) {}
2839
2840public:
2841 QualType getPointeeType() const { return PointeeType; }
2842
2843 /// Returns true if the member type (i.e. the pointee type) is a
2844 /// function type rather than a data-member type.
2845 bool isMemberFunctionPointer() const {
2846 return PointeeType->isFunctionProtoType();
2847 }
2848
2849 /// Returns true if the member type (i.e. the pointee type) is a
2850 /// data type rather than a function type.
2851 bool isMemberDataPointer() const {
2852 return !PointeeType->isFunctionProtoType();
2853 }
2854
2855 const Type *getClass() const { return Class; }
2856 CXXRecordDecl *getMostRecentCXXRecordDecl() const;
2857
2858 bool isSugared() const { return false; }
2859 QualType desugar() const { return QualType(this, 0); }
2860
2861 void Profile(llvm::FoldingSetNodeID &ID) {
2862 Profile(ID, getPointeeType(), getClass());
2863 }
2864
2865 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2866 const Type *Class) {
2867 ID.AddPointer(Pointee.getAsOpaquePtr());
2868 ID.AddPointer(Class);
2869 }
2870
2871 static bool classof(const Type *T) {
2872 return T->getTypeClass() == MemberPointer;
2873 }
2874};
2875
2876/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877class ArrayType : public Type, public llvm::FoldingSetNode {
2878public:
2879 /// Capture whether this is a normal array (e.g. int X[4])
2880 /// an array with a static size (e.g. int X[static 4]), or an array
2881 /// with a star size (e.g. int X[*]).
2882 /// 'static' is only allowed on function parameters.
2883 enum ArraySizeModifier {
2884 Normal, Static, Star
2885 };
2886
2887private:
2888 /// The element type of the array.
2889 QualType ElementType;
2890
2891protected:
2892 friend class ASTContext; // ASTContext creates these.
2893
2894 ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
2895 unsigned tq, const Expr *sz = nullptr);
2896
2897public:
2898 QualType getElementType() const { return ElementType; }
2899
2900 ArraySizeModifier getSizeModifier() const {
2901 return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2902 }
2903
2904 Qualifiers getIndexTypeQualifiers() const {
2905 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2906 }
2907
2908 unsigned getIndexTypeCVRQualifiers() const {
2909 return ArrayTypeBits.IndexTypeQuals;
2910 }
2911
2912 static bool classof(const Type *T) {
2913 return T->getTypeClass() == ConstantArray ||
2914 T->getTypeClass() == VariableArray ||
2915 T->getTypeClass() == IncompleteArray ||
2916 T->getTypeClass() == DependentSizedArray;
2917 }
2918};
2919
2920/// Represents the canonical version of C arrays with a specified constant size.
2921/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922/// ConstantArrayType where the element type is 'int' and the size is 404.
2923class ConstantArrayType final
2924 : public ArrayType,
2925 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2926 friend class ASTContext; // ASTContext creates these.
2927 friend TrailingObjects;
2928
2929 llvm::APInt Size; // Allows us to unique the type.
2930
2931 ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2932 const Expr *sz, ArraySizeModifier sm, unsigned tq)
2933 : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
2934 ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
2935 if (ConstantArrayTypeBits.HasStoredSizeExpr) {
2936 assert(!can.isNull() && "canonical constant array should not have size")((void)0);
2937 *getTrailingObjects<const Expr*>() = sz;
2938 }
2939 }
2940
2941 unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2942 return ConstantArrayTypeBits.HasStoredSizeExpr;
2943 }
2944
2945public:
2946 const llvm::APInt &getSize() const { return Size; }
2947 const Expr *getSizeExpr() const {
2948 return ConstantArrayTypeBits.HasStoredSizeExpr
2949 ? *getTrailingObjects<const Expr *>()
2950 : nullptr;
2951 }
2952 bool isSugared() const { return false; }
2953 QualType desugar() const { return QualType(this, 0); }
2954
2955 /// Determine the number of bits required to address a member of
2956 // an array with the given element type and number of elements.
2957 static unsigned getNumAddressingBits(const ASTContext &Context,
2958 QualType ElementType,
2959 const llvm::APInt &NumElements);
2960
2961 /// Determine the maximum number of active bits that an array's size
2962 /// can require, which limits the maximum size of the array.
2963 static unsigned getMaxSizeBits(const ASTContext &Context);
2964
2965 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
2966 Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
2967 getSizeModifier(), getIndexTypeCVRQualifiers());
2968 }
2969
2970 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
2971 QualType ET, const llvm::APInt &ArraySize,
2972 const Expr *SizeExpr, ArraySizeModifier SizeMod,
2973 unsigned TypeQuals);
2974
2975 static bool classof(const Type *T) {
2976 return T->getTypeClass() == ConstantArray;
2977 }
2978};
2979
2980/// Represents a C array with an unspecified size. For example 'int A[]' has
2981/// an IncompleteArrayType where the element type is 'int' and the size is
2982/// unspecified.
2983class IncompleteArrayType : public ArrayType {
2984 friend class ASTContext; // ASTContext creates these.
2985
2986 IncompleteArrayType(QualType et, QualType can,
2987 ArraySizeModifier sm, unsigned tq)
2988 : ArrayType(IncompleteArray, et, can, sm, tq) {}
2989
2990public:
2991 friend class StmtIteratorBase;
2992
2993 bool isSugared() const { return false; }
2994 QualType desugar() const { return QualType(this, 0); }
2995
2996 static bool classof(const Type *T) {
2997 return T->getTypeClass() == IncompleteArray;
2998 }
2999
3000 void Profile(llvm::FoldingSetNodeID &ID) {
3001 Profile(ID, getElementType(), getSizeModifier(),
3002 getIndexTypeCVRQualifiers());
3003 }
3004
3005 static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3006 ArraySizeModifier SizeMod, unsigned TypeQuals) {
3007 ID.AddPointer(ET.getAsOpaquePtr());
3008 ID.AddInteger(SizeMod);
3009 ID.AddInteger(TypeQuals);
3010 }
3011};
3012
3013/// Represents a C array with a specified size that is not an
3014/// integer-constant-expression. For example, 'int s[x+foo()]'.
3015/// Since the size expression is an arbitrary expression, we store it as such.
3016///
3017/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018/// should not be: two lexically equivalent variable array types could mean
3019/// different things, for example, these variables do not have the same type
3020/// dynamically:
3021///
3022/// void foo(int x) {
3023/// int Y[x];
3024/// ++x;
3025/// int Z[x];
3026/// }
3027class VariableArrayType : public ArrayType {
3028 friend class ASTContext; // ASTContext creates these.
3029
3030 /// An assignment-expression. VLA's are only permitted within
3031 /// a function block.
3032 Stmt *SizeExpr;
3033
3034 /// The range spanned by the left and right array brackets.
3035 SourceRange Brackets;
3036
3037 VariableArrayType(QualType et, QualType can, Expr *e,
3038 ArraySizeModifier sm, unsigned tq,
3039 SourceRange brackets)
3040 : ArrayType(VariableArray, et, can, sm, tq, e),
3041 SizeExpr((Stmt*) e), Brackets(brackets) {}
3042
3043public:
3044 friend class StmtIteratorBase;
3045
3046 Expr *getSizeExpr() const {
3047 // We use C-style casts instead of cast<> here because we do not wish
3048 // to have a dependency of Type.h on Stmt.h/Expr.h.
3049 return (Expr*) SizeExpr;
3050 }
3051
3052 SourceRange getBracketsRange() const { return Brackets; }
3053 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3054 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3055
3056 bool isSugared() const { return false; }
3057 QualType desugar() const { return QualType(this, 0); }
3058
3059 static bool classof(const Type *T) {
3060 return T->getTypeClass() == VariableArray;
3061 }
3062
3063 void Profile(llvm::FoldingSetNodeID &ID) {
3064 llvm_unreachable("Cannot unique VariableArrayTypes.")__builtin_unreachable();
3065 }
3066};
3067
3068/// Represents an array type in C++ whose size is a value-dependent expression.
3069///
3070/// For example:
3071/// \code
3072/// template<typename T, int Size>
3073/// class array {
3074/// T data[Size];
3075/// };
3076/// \endcode
3077///
3078/// For these types, we won't actually know what the array bound is
3079/// until template instantiation occurs, at which point this will
3080/// become either a ConstantArrayType or a VariableArrayType.
3081class DependentSizedArrayType : public ArrayType {
3082 friend class ASTContext; // ASTContext creates these.
3083
3084 const ASTContext &Context;
3085
3086 /// An assignment expression that will instantiate to the
3087 /// size of the array.
3088 ///
3089 /// The expression itself might be null, in which case the array
3090 /// type will have its size deduced from an initializer.
3091 Stmt *SizeExpr;
3092
3093 /// The range spanned by the left and right array brackets.
3094 SourceRange Brackets;
3095
3096 DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
3097 Expr *e, ArraySizeModifier sm, unsigned tq,
3098 SourceRange brackets);
3099
3100public:
3101 friend class StmtIteratorBase;
3102
3103 Expr *getSizeExpr() const {
3104 // We use C-style casts instead of cast<> here because we do not wish
3105 // to have a dependency of Type.h on Stmt.h/Expr.h.
3106 return (Expr*) SizeExpr;
3107 }
3108
3109 SourceRange getBracketsRange() const { return Brackets; }
3110 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3111 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3112
3113 bool isSugared() const { return false; }
3114 QualType desugar() const { return QualType(this, 0); }
3115
3116 static bool classof(const Type *T) {
3117 return T->getTypeClass() == DependentSizedArray;
3118 }
3119
3120 void Profile(llvm::FoldingSetNodeID &ID) {
3121 Profile(ID, Context, getElementType(),
3122 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3123 }
3124
3125 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3126 QualType ET, ArraySizeModifier SizeMod,
3127 unsigned TypeQuals, Expr *E);
3128};
3129
3130/// Represents an extended address space qualifier where the input address space
3131/// value is dependent. Non-dependent address spaces are not represented with a
3132/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133///
3134/// For example:
3135/// \code
3136/// template<typename T, int AddrSpace>
3137/// class AddressSpace {
3138/// typedef T __attribute__((address_space(AddrSpace))) type;
3139/// }
3140/// \endcode
3141class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3142 friend class ASTContext;
3143
3144 const ASTContext &Context;
3145 Expr *AddrSpaceExpr;
3146 QualType PointeeType;
3147 SourceLocation loc;
3148
3149 DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
3150 QualType can, Expr *AddrSpaceExpr,
3151 SourceLocation loc);
3152
3153public:
3154 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3155 QualType getPointeeType() const { return PointeeType; }
3156 SourceLocation getAttributeLoc() const { return loc; }
3157
3158 bool isSugared() const { return false; }
3159 QualType desugar() const { return QualType(this, 0); }
3160
3161 static bool classof(const Type *T) {
3162 return T->getTypeClass() == DependentAddressSpace;
3163 }
3164
3165 void Profile(llvm::FoldingSetNodeID &ID) {
3166 Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
3167 }
3168
3169 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3170 QualType PointeeType, Expr *AddrSpaceExpr);
3171};
3172
3173/// Represents an extended vector type where either the type or size is
3174/// dependent.
3175///
3176/// For example:
3177/// \code
3178/// template<typename T, int Size>
3179/// class vector {
3180/// typedef T __attribute__((ext_vector_type(Size))) type;
3181/// }
3182/// \endcode
3183class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3184 friend class ASTContext;
3185
3186 const ASTContext &Context;
3187 Expr *SizeExpr;
3188
3189 /// The element type of the array.
3190 QualType ElementType;
3191
3192 SourceLocation loc;
3193
3194 DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
3195 QualType can, Expr *SizeExpr, SourceLocation loc);
3196
3197public:
3198 Expr *getSizeExpr() const { return SizeExpr; }
3199 QualType getElementType() const { return ElementType; }
3200 SourceLocation getAttributeLoc() const { return loc; }
3201
3202 bool isSugared() const { return false; }
3203 QualType desugar() const { return QualType(this, 0); }
3204
3205 static bool classof(const Type *T) {
3206 return T->getTypeClass() == DependentSizedExtVector;
3207 }
3208
3209 void Profile(llvm::FoldingSetNodeID &ID) {
3210 Profile(ID, Context, getElementType(), getSizeExpr());
3211 }
3212
3213 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3214 QualType ElementType, Expr *SizeExpr);
3215};
3216
3217
3218/// Represents a GCC generic vector type. This type is created using
3219/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220/// bytes; or from an Altivec __vector or vector declaration.
3221/// Since the constructor takes the number of vector elements, the
3222/// client is responsible for converting the size into the number of elements.
3223class VectorType : public Type, public llvm::FoldingSetNode {
3224public:
3225 enum VectorKind {
3226 /// not a target-specific vector type
3227 GenericVector,
3228
3229 /// is AltiVec vector
3230 AltiVecVector,
3231
3232 /// is AltiVec 'vector Pixel'
3233 AltiVecPixel,
3234
3235 /// is AltiVec 'vector bool ...'
3236 AltiVecBool,
3237
3238 /// is ARM Neon vector
3239 NeonVector,
3240
3241 /// is ARM Neon polynomial vector
3242 NeonPolyVector,
3243
3244 /// is AArch64 SVE fixed-length data vector
3245 SveFixedLengthDataVector,
3246
3247 /// is AArch64 SVE fixed-length predicate vector
3248 SveFixedLengthPredicateVector
3249 };
3250
3251protected:
3252 friend class ASTContext; // ASTContext creates these.
3253
3254 /// The element type of the vector.
3255 QualType ElementType;
3256
3257 VectorType(QualType vecType, unsigned nElements, QualType canonType,
3258 VectorKind vecKind);
3259
3260 VectorType(TypeClass tc, QualType vecType, unsigned nElements,
3261 QualType canonType, VectorKind vecKind);
3262
3263public:
3264 QualType getElementType() const { return ElementType; }
3265 unsigned getNumElements() const { return VectorTypeBits.NumElements; }
3266
3267 bool isSugared() const { return false; }
3268 QualType desugar() const { return QualType(this, 0); }
3269
3270 VectorKind getVectorKind() const {
3271 return VectorKind(VectorTypeBits.VecKind);
3272 }
3273
3274 void Profile(llvm::FoldingSetNodeID &ID) {
3275 Profile(ID, getElementType(), getNumElements(),
3276 getTypeClass(), getVectorKind());
3277 }
3278
3279 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3280 unsigned NumElements, TypeClass TypeClass,
3281 VectorKind VecKind) {
3282 ID.AddPointer(ElementType.getAsOpaquePtr());
3283 ID.AddInteger(NumElements);
3284 ID.AddInteger(TypeClass);
3285 ID.AddInteger(VecKind);
3286 }
3287
3288 static bool classof(const Type *T) {
3289 return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
3290 }
3291};
3292
3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299/// typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class DependentVectorType : public Type, public llvm::FoldingSetNode {
3303 friend class ASTContext;
3304
3305 const ASTContext &Context;
3306 QualType ElementType;
3307 Expr *SizeExpr;
3308 SourceLocation Loc;
3309
3310 DependentVectorType(const ASTContext &Context, QualType ElementType,
3311 QualType CanonType, Expr *SizeExpr,
3312 SourceLocation Loc, VectorType::VectorKind vecKind);
3313
3314public:
3315 Expr *getSizeExpr() const { return SizeExpr; }
3316 QualType getElementType() const { return ElementType; }
3317 SourceLocation getAttributeLoc() const { return Loc; }
3318 VectorType::VectorKind getVectorKind() const {
3319 return VectorType::VectorKind(VectorTypeBits.VecKind);
3320 }
3321
3322 bool isSugared() const { return false; }
3323 QualType desugar() const { return QualType(this, 0); }
3324
3325 static bool classof(const Type *T) {
3326 return T->getTypeClass() == DependentVector;
3327 }
3328
3329 void Profile(llvm::FoldingSetNodeID &ID) {
3330 Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
3331 }
3332
3333 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3334 QualType ElementType, const Expr *SizeExpr,
3335 VectorType::VectorKind VecKind);
3336};
3337
3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
3345 friend class ASTContext; // ASTContext creates these.
3346
3347 ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
3348 : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
3349
3350public:
3351 static int getPointAccessorIdx(char c) {
3352 switch (c) {
3353 default: return -1;
3354 case 'x': case 'r': return 0;
3355 case 'y': case 'g': return 1;
3356 case 'z': case 'b': return 2;
3357 case 'w': case 'a': return 3;
3358 }
3359 }
3360
3361 static int getNumericAccessorIdx(char c) {
3362 switch (c) {
3363 default: return -1;
3364 case '0': return 0;
3365 case '1': return 1;
3366 case '2': return 2;
3367 case '3': return 3;
3368 case '4': return 4;
3369 case '5': return 5;
3370 case '6': return 6;
3371 case '7': return 7;
3372 case '8': return 8;
3373 case '9': return 9;
3374 case 'A':
3375 case 'a': return 10;
3376 case 'B':
3377 case 'b': return 11;
3378 case 'C':
3379 case 'c': return 12;
3380 case 'D':
3381 case 'd': return 13;
3382 case 'E':
3383 case 'e': return 14;
3384 case 'F':
3385 case 'f': return 15;
3386 }
3387 }
3388
3389 static int getAccessorIdx(char c, bool isNumericAccessor) {
3390 if (isNumericAccessor)
3391 return getNumericAccessorIdx(c);
3392 else
3393 return getPointAccessorIdx(c);
3394 }
3395
3396 bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
3397 if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
3398 return unsigned(idx-1) < getNumElements();
3399 return false;
3400 }
3401
3402 bool isSugared() const { return false; }
3403 QualType desugar() const { return QualType(this, 0); }
3404
3405 static bool classof(const Type *T) {
3406 return T->getTypeClass() == ExtVector;
3407 }
3408};
3409
3410/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412/// number of rows and "columns" specifies the number of columns.
3413class MatrixType : public Type, public llvm::FoldingSetNode {
3414protected:
3415 friend class ASTContext;
3416
3417 /// The element type of the matrix.
3418 QualType ElementType;
3419
3420 MatrixType(QualType ElementTy, QualType CanonElementTy);
3421
3422 MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
3423 const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);
3424
3425public:
3426 /// Returns type of the elements being stored in the matrix
3427 QualType getElementType() const { return ElementType; }
3428
3429 /// Valid elements types are the following:
3430 /// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
3431 /// and _Bool
3432 /// * the standard floating types float or double
3433 /// * a half-precision floating point type, if one is supported on the target
3434 static bool isValidElementType(QualType T) {
3435 return T->isDependentType() ||
3436 (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
3437 }
3438
3439 bool isSugared() const { return false; }
3440 QualType desugar() const { return QualType(this, 0); }
3441
3442 static bool classof(const Type *T) {
3443 return T->getTypeClass() == ConstantMatrix ||
3444 T->getTypeClass() == DependentSizedMatrix;
3445 }
3446};
3447
3448/// Represents a concrete matrix type with constant number of rows and columns
3449class ConstantMatrixType final : public MatrixType {
3450protected:
3451 friend class ASTContext;
3452
3453 /// The element type of the matrix.
3454 // FIXME: Appears to be unused? There is also MatrixType::ElementType...
3455 QualType ElementType;
3456
3457 /// Number of rows and columns.
3458 unsigned NumRows;
3459 unsigned NumColumns;
3460
3461 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
3462
3463 ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
3464 unsigned NColumns, QualType CanonElementType);
3465
3466 ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
3467 unsigned NColumns, QualType CanonElementType);
3468
3469public:
3470 /// Returns the number of rows in the matrix.
3471 unsigned getNumRows() const { return NumRows; }
3472
3473 /// Returns the number of columns in the matrix.
3474 unsigned getNumColumns() const { return NumColumns; }
3475
3476 /// Returns the number of elements required to embed the matrix into a vector.
3477 unsigned getNumElementsFlattened() const {
3478 return getNumRows() * getNumColumns();
3479 }
3480
3481 /// Returns true if \p NumElements is a valid matrix dimension.
3482 static constexpr bool isDimensionValid(size_t NumElements) {
3483 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
3484 }
3485
3486 /// Returns the maximum number of elements per dimension.
3487 static constexpr unsigned getMaxElementsPerDimension() {
3488 return MaxElementsPerDimension;
3489 }
3490
3491 void Profile(llvm::FoldingSetNodeID &ID) {
3492 Profile(ID, getElementType(), getNumRows(), getNumColumns(),
3493 getTypeClass());
3494 }
3495
3496 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3497 unsigned NumRows, unsigned NumColumns,
3498 TypeClass TypeClass) {
3499 ID.AddPointer(ElementType.getAsOpaquePtr());
3500 ID.AddInteger(NumRows);
3501 ID.AddInteger(NumColumns);
3502 ID.AddInteger(TypeClass);
3503 }
3504
3505 static bool classof(const Type *T) {
3506 return T->getTypeClass() == ConstantMatrix;
3507 }
3508};
3509
3510/// Represents a matrix type where the type and the number of rows and columns
3511/// is dependent on a template.
3512class DependentSizedMatrixType final : public MatrixType {
3513 friend class ASTContext;
3514
3515 const ASTContext &Context;
3516 Expr *RowExpr;
3517 Expr *ColumnExpr;
3518
3519 SourceLocation loc;
3520
3521 DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
3522 QualType CanonicalType, Expr *RowExpr,
3523 Expr *ColumnExpr, SourceLocation loc);
3524
3525public:
3526 QualType getElementType() const { return ElementType; }
3527 Expr *getRowExpr() const { return RowExpr; }
3528 Expr *getColumnExpr() const { return ColumnExpr; }
3529 SourceLocation getAttributeLoc() const { return loc; }
3530
3531 bool isSugared() const { return false; }
3532 QualType desugar() const { return QualType(this, 0); }
3533
3534 static bool classof(const Type *T) {
3535 return T->getTypeClass() == DependentSizedMatrix;
3536 }
3537
3538 void Profile(llvm::FoldingSetNodeID &ID) {
3539 Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
3540 }
3541
3542 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3543 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3544};
3545
3546/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
3547/// class of FunctionNoProtoType and FunctionProtoType.
3548class FunctionType : public Type {
3549 // The type returned by the function.
3550 QualType ResultType;
3551
3552public:
3553 /// Interesting information about a specific parameter that can't simply
3554 /// be reflected in parameter's type. This is only used by FunctionProtoType
3555 /// but is in FunctionType to make this class available during the
3556 /// specification of the bases of FunctionProtoType.
3557 ///
3558 /// It makes sense to model language features this way when there's some
3559 /// sort of parameter-specific override (such as an attribute) that
3560 /// affects how the function is called. For example, the ARC ns_consumed
3561 /// attribute changes whether a parameter is passed at +0 (the default)
3562 /// or +1 (ns_consumed). This must be reflected in the function type,
3563 /// but isn't really a change to the parameter type.
3564 ///
3565 /// One serious disadvantage of modelling language features this way is
3566 /// that they generally do not work with language features that attempt
3567 /// to destructure types. For example, template argument deduction will
3568 /// not be able to match a parameter declared as
3569 /// T (*)(U)
3570 /// against an argument of type
3571 /// void (*)(__attribute__((ns_consumed)) id)
3572 /// because the substitution of T=void, U=id into the former will
3573 /// not produce the latter.
3574 class ExtParameterInfo {
3575 enum {
3576 ABIMask = 0x0F,
3577 IsConsumed = 0x10,
3578 HasPassObjSize = 0x20,
3579 IsNoEscape = 0x40,
3580 };
3581 unsigned char Data = 0;
3582
3583 public:
3584 ExtParameterInfo() = default;
3585
3586 /// Return the ABI treatment of this parameter.
3587 ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
3588 ExtParameterInfo withABI(ParameterABI kind) const {
3589 ExtParameterInfo copy = *this;
3590 copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
3591 return copy;
3592 }
3593
3594 /// Is this parameter considered "consumed" by Objective-C ARC?
3595 /// Consumed parameters must have retainable object type.
3596 bool isConsumed() const { return (Data & IsConsumed); }
3597 ExtParameterInfo withIsConsumed(bool consumed) const {
3598 ExtParameterInfo copy = *this;
3599 if (consumed)
3600 copy.Data |= IsConsumed;
3601 else
3602 copy.Data &= ~IsConsumed;
3603 return copy;
3604 }
3605
3606 bool hasPassObjectSize() const { return Data & HasPassObjSize; }
3607 ExtParameterInfo withHasPassObjectSize() const {
3608 ExtParameterInfo Copy = *this;
3609 Copy.Data |= HasPassObjSize;
3610 return Copy;
3611 }
3612
3613 bool isNoEscape() const { return Data & IsNoEscape; }
3614 ExtParameterInfo withIsNoEscape(bool NoEscape) const {
3615 ExtParameterInfo Copy = *this;
3616 if (NoEscape)
3617 Copy.Data |= IsNoEscape;
3618 else
3619 Copy.Data &= ~IsNoEscape;
3620 return Copy;
3621 }
3622
3623 unsigned char getOpaqueValue() const { return Data; }
3624 static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
3625 ExtParameterInfo result;
3626 result.Data = data;
3627 return result;
3628 }
3629
3630 friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3631 return lhs.Data == rhs.Data;
3632 }
3633
3634 friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3635 return lhs.Data != rhs.Data;
3636 }
3637 };
3638
3639 /// A class which abstracts out some details necessary for
3640 /// making a call.
3641 ///
3642 /// It is not actually used directly for storing this information in
3643 /// a FunctionType, although FunctionType does currently use the
3644 /// same bit-pattern.
3645 ///
3646 // If you add a field (say Foo), other than the obvious places (both,
3647 // constructors, compile failures), what you need to update is
3648 // * Operator==
3649 // * getFoo
3650 // * withFoo
3651 // * functionType. Add Foo, getFoo.
3652 // * ASTContext::getFooType
3653 // * ASTContext::mergeFunctionTypes
3654 // * FunctionNoProtoType::Profile
3655 // * FunctionProtoType::Profile
3656 // * TypePrinter::PrintFunctionProto
3657 // * AST read and write
3658 // * Codegen
3659 class ExtInfo {
3660 friend class FunctionType;
3661
3662 // Feel free to rearrange or add bits, but if you go over 16, you'll need to
3663 // adjust the Bits field below, and if you add bits, you'll need to adjust
3664 // Type::FunctionTypeBitfields::ExtInfo as well.
3665
3666 // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
3667 // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 | 12 |
3668 //
3669 // regparm is either 0 (no regparm attribute) or the regparm value+1.
3670 enum { CallConvMask = 0x1F };
3671 enum { NoReturnMask = 0x20 };
3672 enum { ProducesResultMask = 0x40 };
3673 enum { NoCallerSavedRegsMask = 0x80 };
3674 enum {
3675 RegParmMask = 0x700,
3676 RegParmOffset = 8
3677 };
3678 enum { NoCfCheckMask = 0x800 };
3679 enum { CmseNSCallMask = 0x1000 };
3680 uint16_t Bits = CC_C;
3681
3682 ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3683
3684 public:
3685 // Constructor with no defaults. Use this when you know that you
3686 // have all the elements (when reading an AST file for example).
3687 ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
3688 bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
3689 bool cmseNSCall) {
3690 assert((!hasRegParm || regParm < 7) && "Invalid regparm value")((void)0);
3691 Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3692 (producesResult ? ProducesResultMask : 0) |
3693 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3694 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3695 (NoCfCheck ? NoCfCheckMask : 0) |
3696 (cmseNSCall ? CmseNSCallMask : 0);
3697 }
3698
3699 // Constructor with all defaults. Use when for example creating a
3700 // function known to use defaults.
3701 ExtInfo() = default;
3702
3703 // Constructor with just the calling convention, which is an important part
3704 // of the canonical type.
3705 ExtInfo(CallingConv CC) : Bits(CC) {}
3706
3707 bool getNoReturn() const { return Bits & NoReturnMask; }
3708 bool getProducesResult() const { return Bits & ProducesResultMask; }
3709 bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
3710 bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
3711 bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
3712 bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3713
3714 unsigned getRegParm() const {
3715 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3716 if (RegParm > 0)
3717 --RegParm;
3718 return RegParm;
3719 }
3720
3721 CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
3722
3723 bool operator==(ExtInfo Other) const {
3724 return Bits == Other.Bits;
3725 }
3726 bool operator!=(ExtInfo Other) const {
3727 return Bits != Other.Bits;
3728 }
3729
3730 // Note that we don't have setters. That is by design, use
3731 // the following with methods instead of mutating these objects.
3732
3733 ExtInfo withNoReturn(bool noReturn) const {
3734 if (noReturn)
3735 return ExtInfo(Bits | NoReturnMask);
3736 else
3737 return ExtInfo(Bits & ~NoReturnMask);
3738 }
3739
3740 ExtInfo withProducesResult(bool producesResult) const {
3741 if (producesResult)
3742 return ExtInfo(Bits | ProducesResultMask);
3743 else
3744 return ExtInfo(Bits & ~ProducesResultMask);
3745 }
3746
3747 ExtInfo withCmseNSCall(bool cmseNSCall) const {
3748 if (cmseNSCall)
3749 return ExtInfo(Bits | CmseNSCallMask);
3750 else
3751 return ExtInfo(Bits & ~CmseNSCallMask);
3752 }
3753
3754 ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
3755 if (noCallerSavedRegs)
3756 return ExtInfo(Bits | NoCallerSavedRegsMask);
3757 else
3758 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3759 }
3760
3761 ExtInfo withNoCfCheck(bool noCfCheck) const {
3762 if (noCfCheck)
3763 return ExtInfo(Bits | NoCfCheckMask);
3764 else
3765 return ExtInfo(Bits & ~NoCfCheckMask);
3766 }
3767
3768 ExtInfo withRegParm(unsigned RegParm) const {
3769 assert(RegParm < 7 && "Invalid regparm value")((void)0);
3770 return ExtInfo((Bits & ~RegParmMask) |
3771 ((RegParm + 1) << RegParmOffset));
3772 }
3773
3774 ExtInfo withCallingConv(CallingConv cc) const {
3775 return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
3776 }
3777
3778 void Profile(llvm::FoldingSetNodeID &ID) const {
3779 ID.AddInteger(Bits);
3780 }
3781 };
3782
3783 /// A simple holder for a QualType representing a type in an
3784 /// exception specification. Unfortunately needed by FunctionProtoType
3785 /// because TrailingObjects cannot handle repeated types.
3786 struct ExceptionType { QualType Type; };
3787
3788 /// A simple holder for various uncommon bits which do not fit in
3789 /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
3790 /// alignment of subsequent objects in TrailingObjects. You must update
3791 /// hasExtraBitfields in FunctionProtoType after adding extra data here.
3792 struct alignas(void *) FunctionTypeExtraBitfields {
3793 /// The number of types in the exception specification.
3794 /// A whole unsigned is not needed here and according to
3795 /// [implimits] 8 bits would be enough here.
3796 unsigned NumExceptionType;
3797 };
3798
3799protected:
3800 FunctionType(TypeClass tc, QualType res, QualType Canonical,
3801 TypeDependence Dependence, ExtInfo Info)
3802 : Type(tc, Canonical, Dependence), ResultType(res) {
3803 FunctionTypeBits.ExtInfo = Info.Bits;
3804 }
3805
3806 Qualifiers getFastTypeQuals() const {
3807 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
3808 }
3809
3810public:
3811 QualType getReturnType() const { return ResultType; }
3812
3813 bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
3814 unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
3815
3816 /// Determine whether this function type includes the GNU noreturn
3817 /// attribute. The C++11 [[noreturn]] attribute does not affect the function
3818 /// type.
3819 bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
3820
3821 bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
3822 CallingConv getCallConv() const { return getExtInfo().getCC(); }
3823 ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
3824
3825 static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
3826 "Const, volatile and restrict are assumed to be a subset of "
3827 "the fast qualifiers.");
3828
3829 bool isConst() const { return getFastTypeQuals().hasConst(); }
3830 bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
3831 bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
3832
3833 /// Determine the type of an expression that calls a function of
3834 /// this type.
3835 QualType getCallResultType(const ASTContext &Context) const {
3836 return getReturnType().getNonLValueExprType(Context);
3837 }
3838
3839 static StringRef getNameForCallConv(CallingConv CC);
3840
3841 static bool classof(const Type *T) {
3842 return T->getTypeClass() == FunctionNoProto ||
3843 T->getTypeClass() == FunctionProto;
3844 }
3845};
3846
3847/// Represents a K&R-style 'int foo()' function, which has
3848/// no information available about its arguments.
3849class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
3850 friend class ASTContext; // ASTContext creates these.
3851
3852 FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
3853 : FunctionType(FunctionNoProto, Result, Canonical,
3854 Result->getDependence() &
3855 ~(TypeDependence::DependentInstantiation |
3856 TypeDependence::UnexpandedPack),
3857 Info) {}
3858
3859public:
3860 // No additional state past what FunctionType provides.
3861
3862 bool isSugared() const { return false; }
3863 QualType desugar() const { return QualType(this, 0); }
3864
3865 void Profile(llvm::FoldingSetNodeID &ID) {
3866 Profile(ID, getReturnType(), getExtInfo());
3867 }
3868
3869 static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
3870 ExtInfo Info) {
3871 Info.Profile(ID);
3872 ID.AddPointer(ResultType.getAsOpaquePtr());
3873 }
3874
3875 static bool classof(const Type *T) {
3876 return T->getTypeClass() == FunctionNoProto;
3877 }
3878};
3879
3880/// Represents a prototype with parameter type info, e.g.
3881/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
3882/// parameters, not as having a single void parameter. Such a type can have
3883/// an exception specification, but this specification is not part of the
3884/// canonical type. FunctionProtoType has several trailing objects, some of
3885/// which optional. For more information about the trailing objects see
3886/// the first comment inside FunctionProtoType.
3887class FunctionProtoType final
3888 : public FunctionType,
3889 public llvm::FoldingSetNode,
3890 private llvm::TrailingObjects<
3891 FunctionProtoType, QualType, SourceLocation,
3892 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3893 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3894 friend class ASTContext; // ASTContext creates these.
3895 friend TrailingObjects;
3896
3897 // FunctionProtoType is followed by several trailing objects, some of
3898 // which optional. They are in order:
3899 //
3900 // * An array of getNumParams() QualType holding the parameter types.
3901 // Always present. Note that for the vast majority of FunctionProtoType,
3902 // these will be the only trailing objects.
3903 //
3904 // * Optionally if the function is variadic, the SourceLocation of the
3905 // ellipsis.
3906 //
3907 // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
3908 // (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
3909 // a single FunctionTypeExtraBitfields. Present if and only if
3910 // hasExtraBitfields() is true.
3911 //
3912 // * Optionally exactly one of:
3913 // * an array of getNumExceptions() ExceptionType,
3914 // * a single Expr *,
3915 // * a pair of FunctionDecl *,
3916 // * a single FunctionDecl *
3917 // used to store information about the various types of exception
3918 // specification. See getExceptionSpecSize for the details.
3919 //
3920 // * Optionally an array of getNumParams() ExtParameterInfo holding
3921 // an ExtParameterInfo for each of the parameters. Present if and
3922 // only if hasExtParameterInfos() is true.
3923 //
3924 // * Optionally a Qualifiers object to represent extra qualifiers that can't
3925 // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
3926 // if hasExtQualifiers() is true.
3927 //
3928 // The optional FunctionTypeExtraBitfields has to be before the data
3929 // related to the exception specification since it contains the number
3930 // of exception types.
3931 //
3932 // We put the ExtParameterInfos last. If all were equal, it would make
3933 // more sense to put these before the exception specification, because
3934 // it's much easier to skip past them compared to the elaborate switch
3935 // required to skip the exception specification. However, all is not
3936 // equal; ExtParameterInfos are used to model very uncommon features,
3937 // and it's better not to burden the more common paths.
3938
3939public:
3940 /// Holds information about the various types of exception specification.
3941 /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
3942 /// used to group together the various bits of information about the
3943 /// exception specification.
3944 struct ExceptionSpecInfo {
3945 /// The kind of exception specification this is.
3946 ExceptionSpecificationType Type = EST_None;
3947
3948 /// Explicitly-specified list of exception types.
3949 ArrayRef<QualType> Exceptions;
3950
3951 /// Noexcept expression, if this is a computed noexcept specification.
3952 Expr *NoexceptExpr = nullptr;
3953
3954 /// The function whose exception specification this is, for
3955 /// EST_Unevaluated and EST_Uninstantiated.
3956 FunctionDecl *SourceDecl = nullptr;
3957
3958 /// The function template whose exception specification this is instantiated
3959 /// from, for EST_Uninstantiated.
3960 FunctionDecl *SourceTemplate = nullptr;
3961
3962 ExceptionSpecInfo() = default;
3963
3964 ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
3965 };
3966
3967 /// Extra information about a function prototype. ExtProtoInfo is not
3968 /// stored as such in FunctionProtoType but is used to group together
3969 /// the various bits of extra information about a function prototype.
3970 struct ExtProtoInfo {
3971 FunctionType::ExtInfo ExtInfo;
3972 bool Variadic : 1;
3973 bool HasTrailingReturn : 1;
3974 Qualifiers TypeQuals;
3975 RefQualifierKind RefQualifier = RQ_None;
3976 ExceptionSpecInfo ExceptionSpec;
3977 const ExtParameterInfo *ExtParameterInfos = nullptr;
3978 SourceLocation EllipsisLoc;
3979
3980 ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}
3981
3982 ExtProtoInfo(CallingConv CC)
3983 : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}
3984
3985 ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
3986 ExtProtoInfo Result(*this);
3987 Result.ExceptionSpec = ESI;
3988 return Result;
3989 }
3990 };
3991
3992private:
3993 unsigned numTrailingObjects(OverloadToken<QualType>) const {
3994 return getNumParams();
3995 }
3996
3997 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
3998 return isVariadic();
3999 }
4000
4001 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
4002 return hasExtraBitfields();
4003 }
4004
4005 unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
4006 return getExceptionSpecSize().NumExceptionType;
4007 }
4008
4009 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
4010 return getExceptionSpecSize().NumExprPtr;
4011 }
4012
4013 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
4014 return getExceptionSpecSize().NumFunctionDeclPtr;
4015 }
4016
4017 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
4018 return hasExtParameterInfos() ? getNumParams() : 0;
4019 }
4020
4021 /// Determine whether there are any argument types that
4022 /// contain an unexpanded parameter pack.
4023 static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
4024 unsigned numArgs) {
4025 for (unsigned Idx = 0; Idx < numArgs; ++Idx)
4026 if (ArgArray[Idx]->containsUnexpandedParameterPack())
4027 return true;
4028
4029 return false;
4030 }
4031
4032 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4033 QualType canonical, const ExtProtoInfo &epi);
4034
4035 /// This struct is returned by getExceptionSpecSize and is used to
4036 /// translate an ExceptionSpecificationType to the number and kind
4037 /// of trailing objects related to the exception specification.
4038 struct ExceptionSpecSizeHolder {
4039 unsigned NumExceptionType;
4040 unsigned NumExprPtr;
4041 unsigned NumFunctionDeclPtr;
4042 };
4043
4044 /// Return the number and kind of trailing objects
4045 /// related to the exception specification.
4046 static ExceptionSpecSizeHolder
4047 getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
4048 switch (EST) {
4049 case EST_None:
4050 case EST_DynamicNone:
4051 case EST_MSAny:
4052 case EST_BasicNoexcept:
4053 case EST_Unparsed:
4054 case EST_NoThrow:
4055 return {0, 0, 0};
4056
4057 case EST_Dynamic:
4058 return {NumExceptions, 0, 0};
4059
4060 case EST_DependentNoexcept:
4061 case EST_NoexceptFalse:
4062 case EST_NoexceptTrue:
4063 return {0, 1, 0};
4064
4065 case EST_Uninstantiated:
4066 return {0, 0, 2};
4067
4068 case EST_Unevaluated:
4069 return {0, 0, 1};
4070 }
4071 llvm_unreachable("bad exception specification kind")__builtin_unreachable();
4072 }
4073
4074 /// Return the number and kind of trailing objects
4075 /// related to the exception specification.
4076 ExceptionSpecSizeHolder getExceptionSpecSize() const {
4077 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4078 }
4079
4080 /// Whether the trailing FunctionTypeExtraBitfields is present.
4081 static bool hasExtraBitfields(ExceptionSpecificationType EST) {
4082 // If the exception spec type is EST_Dynamic then we have > 0 exception
4083 // types and the exact number is stored in FunctionTypeExtraBitfields.
4084 return EST == EST_Dynamic;
4085 }
4086
4087 /// Whether the trailing FunctionTypeExtraBitfields is present.
4088 bool hasExtraBitfields() const {
4089 return hasExtraBitfields(getExceptionSpecType());
4090 }
4091
4092 bool hasExtQualifiers() const {
4093 return FunctionTypeBits.HasExtQuals;
4094 }
4095
4096public:
4097 unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
4098
4099 QualType getParamType(unsigned i) const {
4100 assert(i < getNumParams() && "invalid parameter index")((void)0);
4101 return param_type_begin()[i];
4102 }
4103
4104 ArrayRef<QualType> getParamTypes() const {
4105 return llvm::makeArrayRef(param_type_begin(), param_type_end());
4106 }
4107
4108 ExtProtoInfo getExtProtoInfo() const {
4109 ExtProtoInfo EPI;
4110 EPI.ExtInfo = getExtInfo();
4111 EPI.Variadic = isVariadic();
4112 EPI.EllipsisLoc = getEllipsisLoc();
4113 EPI.HasTrailingReturn = hasTrailingReturn();
4114 EPI.ExceptionSpec = getExceptionSpecInfo();
4115 EPI.TypeQuals = getMethodQuals();
4116 EPI.RefQualifier = getRefQualifier();
4117 EPI.ExtParameterInfos = getExtParameterInfosOrNull();
4118 return EPI;
4119 }
4120
4121 /// Get the kind of exception specification on this function.
4122 ExceptionSpecificationType getExceptionSpecType() const {
4123 return static_cast<ExceptionSpecificationType>(
4124 FunctionTypeBits.ExceptionSpecType);
4125 }
4126
4127 /// Return whether this function has any kind of exception spec.
4128 bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
4129
4130 /// Return whether this function has a dynamic (throw) exception spec.
4131 bool hasDynamicExceptionSpec() const {
4132 return isDynamicExceptionSpec(getExceptionSpecType());
4133 }
4134
4135 /// Return whether this function has a noexcept exception spec.
4136 bool hasNoexceptExceptionSpec() const {
4137 return isNoexceptExceptionSpec(getExceptionSpecType());
4138 }
4139
4140 /// Return whether this function has a dependent exception spec.
4141 bool hasDependentExceptionSpec() const;
4142
4143 /// Return whether this function has an instantiation-dependent exception
4144 /// spec.
4145 bool hasInstantiationDependentExceptionSpec() const;
4146
4147 /// Return all the available information about this type's exception spec.
4148 ExceptionSpecInfo getExceptionSpecInfo() const {
4149 ExceptionSpecInfo Result;
4150 Result.Type = getExceptionSpecType();
4151 if (Result.Type == EST_Dynamic) {
4152 Result.Exceptions = exceptions();
4153 } else if (isComputedNoexcept(Result.Type)) {
4154 Result.NoexceptExpr = getNoexceptExpr();
4155 } else if (Result.Type == EST_Uninstantiated) {
4156 Result.SourceDecl = getExceptionSpecDecl();
4157 Result.SourceTemplate = getExceptionSpecTemplate();
4158 } else if (Result.Type == EST_Unevaluated) {
4159 Result.SourceDecl = getExceptionSpecDecl();
4160 }
4161 return Result;
4162 }
4163
4164 /// Return the number of types in the exception specification.
4165 unsigned getNumExceptions() const {
4166 return getExceptionSpecType() == EST_Dynamic
4167 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4168 ->NumExceptionType
4169 : 0;
4170 }
4171
4172 /// Return the ith exception type, where 0 <= i < getNumExceptions().
4173 QualType getExceptionType(unsigned i) const {
4174 assert(i < getNumExceptions() && "Invalid exception number!")((void)0);
4175 return exception_begin()[i];
4176 }
4177
4178 /// Return the expression inside noexcept(expression), or a null pointer
4179 /// if there is none (because the exception spec is not of this form).
4180 Expr *getNoexceptExpr() const {
4181 if (!isComputedNoexcept(getExceptionSpecType()))
4182 return nullptr;
4183 return *getTrailingObjects<Expr *>();
4184 }
4185
4186 /// If this function type has an exception specification which hasn't
4187 /// been determined yet (either because it has not been evaluated or because
4188 /// it has not been instantiated), this is the function whose exception
4189 /// specification is represented by this type.
4190 FunctionDecl *getExceptionSpecDecl() const {
4191 if (getExceptionSpecType() != EST_Uninstantiated &&
4192 getExceptionSpecType() != EST_Unevaluated)
4193 return nullptr;
4194 return getTrailingObjects<FunctionDecl *>()[0];
4195 }
4196
4197 /// If this function type has an uninstantiated exception
4198 /// specification, this is the function whose exception specification
4199 /// should be instantiated to find the exception specification for
4200 /// this type.
4201 FunctionDecl *getExceptionSpecTemplate() const {
4202 if (getExceptionSpecType() != EST_Uninstantiated)
4203 return nullptr;
4204 return getTrailingObjects<FunctionDecl *>()[1];
4205 }
4206
4207 /// Determine whether this function type has a non-throwing exception
4208 /// specification.
4209 CanThrowResult canThrow() const;
4210
4211 /// Determine whether this function type has a non-throwing exception
4212 /// specification. If this depends on template arguments, returns
4213 /// \c ResultIfDependent.
4214 bool isNothrow(bool ResultIfDependent = false) const {
4215 return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
4216 }
4217
4218 /// Whether this function prototype is variadic.
4219 bool isVariadic() const { return FunctionTypeBits.Variadic; }
4220
4221 SourceLocation getEllipsisLoc() const {
4222 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4223 : SourceLocation();
4224 }
4225
4226 /// Determines whether this function prototype contains a
4227 /// parameter pack at the end.
4228 ///
4229 /// A function template whose last parameter is a parameter pack can be
4230 /// called with an arbitrary number of arguments, much like a variadic
4231 /// function.
4232 bool isTemplateVariadic() const;
4233
4234 /// Whether this function prototype has a trailing return type.
4235 bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
4236
4237 Qualifiers getMethodQuals() const {
4238 if (hasExtQualifiers())
4239 return *getTrailingObjects<Qualifiers>();
4240 else
4241 return getFastTypeQuals();
4242 }
4243
4244 /// Retrieve the ref-qualifier associated with this function type.
4245 RefQualifierKind getRefQualifier() const {
4246 return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
4247 }
4248
4249 using param_type_iterator = const QualType *;
4250 using param_type_range = llvm::iterator_range<param_type_iterator>;
4251
4252 param_type_range param_types() const {
4253 return param_type_range(param_type_begin(), param_type_end());
4254 }
4255
4256 param_type_iterator param_type_begin() const {
4257 return getTrailingObjects<QualType>();
4258 }
4259
4260 param_type_iterator param_type_end() const {
4261 return param_type_begin() + getNumParams();
4262 }
4263
4264 using exception_iterator = const QualType *;
4265
4266 ArrayRef<QualType> exceptions() const {
4267 return llvm::makeArrayRef(exception_begin(), exception_end());
4268 }
4269
4270 exception_iterator exception_begin() const {
4271 return reinterpret_cast<exception_iterator>(
4272 getTrailingObjects<ExceptionType>());
4273 }
4274
4275 exception_iterator exception_end() const {
4276 return exception_begin() + getNumExceptions();
4277 }
4278
4279 /// Is there any interesting extra information for any of the parameters
4280 /// of this function type?
4281 bool hasExtParameterInfos() const {
4282 return FunctionTypeBits.HasExtParameterInfos;
4283 }
4284
4285 ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
4286 assert(hasExtParameterInfos())((void)0);
4287 return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
4288 getNumParams());
4289 }
4290
4291 /// Return a pointer to the beginning of the array of extra parameter
4292 /// information, if present, or else null if none of the parameters
4293 /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos.
4294 const ExtParameterInfo *getExtParameterInfosOrNull() const {
4295 if (!hasExtParameterInfos())
4296 return nullptr;
4297 return getTrailingObjects<ExtParameterInfo>();
4298 }
4299
4300 ExtParameterInfo getExtParameterInfo(unsigned I) const {
4301 assert(I < getNumParams() && "parameter index out of range")((void)0);
4302 if (hasExtParameterInfos())
4303 return getTrailingObjects<ExtParameterInfo>()[I];
4304 return ExtParameterInfo();
4305 }
4306
4307 ParameterABI getParameterABI(unsigned I) const {
4308 assert(I < getNumParams() && "parameter index out of range")((void)0);
4309 if (hasExtParameterInfos())
4310 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4311 return ParameterABI::Ordinary;
4312 }
4313
4314 bool isParamConsumed(unsigned I) const {
4315 assert(I < getNumParams() && "parameter index out of range")((void)0);
4316 if (hasExtParameterInfos())
4317 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4318 return false;
4319 }
4320
4321 bool isSugared() const { return false; }
4322 QualType desugar() const { return QualType(this, 0); }
4323
4324 void printExceptionSpecification(raw_ostream &OS,
4325 const PrintingPolicy &Policy) const;
4326
4327 static bool classof(const Type *T) {
4328 return T->getTypeClass() == FunctionProto;
4329 }
4330
4331 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
4332 static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
4333 param_type_iterator ArgTys, unsigned NumArgs,
4334 const ExtProtoInfo &EPI, const ASTContext &Context,
4335 bool Canonical);
4336};
4337
4338/// Represents the dependent type named by a dependently-scoped
4339/// typename using declaration, e.g.
4340/// using typename Base<T>::foo;
4341///
4342/// Template instantiation turns these into the underlying type.
4343class UnresolvedUsingType : public Type {
4344 friend class ASTContext; // ASTContext creates these.
4345
4346 UnresolvedUsingTypenameDecl *Decl;
4347
4348 UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
4349 : Type(UnresolvedUsing, QualType(),
4350 TypeDependence::DependentInstantiation),
4351 Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}
4352
4353public:
4354 UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
4355
4356 bool isSugared() const { return false; }
4357 QualType desugar() const { return QualType(this, 0); }
4358
4359 static bool classof(const Type *T) {
4360 return T->getTypeClass() == UnresolvedUsing;
4361 }
4362
4363 void Profile(llvm::FoldingSetNodeID &ID) {
4364 return Profile(ID, Decl);
4365 }
4366
4367 static void Profile(llvm::FoldingSetNodeID &ID,
4368 UnresolvedUsingTypenameDecl *D) {
4369 ID.AddPointer(D);
4370 }
4371};
4372
4373class TypedefType : public Type {
4374 TypedefNameDecl *Decl;
4375
4376private:
4377 friend class ASTContext; // ASTContext creates these.
4378
4379 TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
4380 QualType can);
4381
4382public:
4383 TypedefNameDecl *getDecl() const { return Decl; }
4384
4385 bool isSugared() const { return true; }
4386 QualType desugar() const;
4387
4388 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389};
4390
4391/// Sugar type that represents a type that was qualified by a qualifier written
4392/// as a macro invocation.
4393class MacroQualifiedType : public Type {
4394 friend class ASTContext; // ASTContext creates these.
4395
4396 QualType UnderlyingTy;
4397 const IdentifierInfo *MacroII;
4398
4399 MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
4400 const IdentifierInfo *MacroII)
4401 : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
4402 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4403 assert(isa<AttributedType>(UnderlyingTy) &&((void)0)
4404 "Expected a macro qualified type to only wrap attributed types.")((void)0);
4405 }
4406
4407public:
4408 const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
4409 QualType getUnderlyingType() const { return UnderlyingTy; }
4410
4411 /// Return this attributed type's modified type with no qualifiers attached to
4412 /// it.
4413 QualType getModifiedType() const;
4414
4415 bool isSugared() const { return true; }
4416 QualType desugar() const;
4417
4418 static bool classof(const Type *T) {
4419 return T->getTypeClass() == MacroQualified;
4420 }
4421};
4422
4423/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424class TypeOfExprType : public Type {
4425 Expr *TOExpr;
4426
4427protected:
4428 friend class ASTContext; // ASTContext creates these.
4429
4430 TypeOfExprType(Expr *E, QualType can = QualType());
4431
4432public:
4433 Expr *getUnderlyingExpr() const { return TOExpr; }
4434
4435 /// Remove a single level of sugar.
4436 QualType desugar() const;
4437
4438 /// Returns whether this type directly provides sugar.
4439 bool isSugared() const;
4440
4441 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4442};
4443
4444/// Internal representation of canonical, dependent
4445/// `typeof(expr)` types.
4446///
4447/// This class is used internally by the ASTContext to manage
4448/// canonical, dependent types, only. Clients will only see instances
4449/// of this class via TypeOfExprType nodes.
4450class DependentTypeOfExprType
4451 : public TypeOfExprType, public llvm::FoldingSetNode {
4452 const ASTContext &Context;
4453
4454public:
4455 DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4456 : TypeOfExprType(E), Context(Context) {}
4457
4458 void Profile(llvm::FoldingSetNodeID &ID) {
4459 Profile(ID, Context, getUnderlyingExpr());
4460 }
4461
4462 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4463 Expr *E);
4464};
4465
4466/// Represents `typeof(type)`, a GCC extension.
4467class TypeOfType : public Type {
4468 friend class ASTContext; // ASTContext creates these.
4469
4470 QualType TOType;
4471
4472 TypeOfType(QualType T, QualType can)
4473 : Type(TypeOf, can, T->getDependence()), TOType(T) {
4474 assert(!isa<TypedefType>(can) && "Invalid canonical type")((void)0);
4475 }
4476
4477public:
4478 QualType getUnderlyingType() const { return TOType; }
4479
4480 /// Remove a single level of sugar.
4481 QualType desugar() const { return getUnderlyingType(); }
4482
4483 /// Returns whether this type directly provides sugar.
4484 bool isSugared() const { return true; }
4485
4486 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4487};
4488
4489/// Represents the type `decltype(expr)` (C++11).
4490class DecltypeType : public Type {
4491 Expr *E;
4492 QualType UnderlyingType;
4493
4494protected:
4495 friend class ASTContext; // ASTContext creates these.
4496
4497 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4498
4499public:
4500 Expr *getUnderlyingExpr() const { return E; }
4501 QualType getUnderlyingType() const { return UnderlyingType; }
4502
4503 /// Remove a single level of sugar.
4504 QualType desugar() const;
4505
4506 /// Returns whether this type directly provides sugar.
4507 bool isSugared() const;
4508
4509 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4510};
4511
4512/// Internal representation of canonical, dependent
4513/// decltype(expr) types.
4514///
4515/// This class is used internally by the ASTContext to manage
4516/// canonical, dependent types, only. Clients will only see instances
4517/// of this class via DecltypeType nodes.
4518class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
4519 const ASTContext &Context;
4520
4521public:
4522 DependentDecltypeType(const ASTContext &Context, Expr *E);
4523
4524 void Profile(llvm::FoldingSetNodeID &ID) {
4525 Profile(ID, Context, getUnderlyingExpr());
4526 }
4527
4528 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4529 Expr *E);
4530};
4531
4532/// A unary type transform, which is a type constructed from another.
4533class UnaryTransformType : public Type {
4534public:
4535 enum UTTKind {
4536 EnumUnderlyingType
4537 };
4538
4539private:
4540 /// The untransformed type.
4541 QualType BaseType;
4542
4543 /// The transformed type if not dependent, otherwise the same as BaseType.
4544 QualType UnderlyingType;
4545
4546 UTTKind UKind;
4547
4548protected:
4549 friend class ASTContext;
4550
4551 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
4552 QualType CanonicalTy);
4553
4554public:
4555 bool isSugared() const { return !isDependentType(); }
4556 QualType desugar() const { return UnderlyingType; }
4557
4558 QualType getUnderlyingType() const { return UnderlyingType; }
4559 QualType getBaseType() const { return BaseType; }
4560
4561 UTTKind getUTTKind() const { return UKind; }
4562
4563 static bool classof(const Type *T) {
4564 return T->getTypeClass() == UnaryTransform;
4565 }
4566};
4567
4568/// Internal representation of canonical, dependent
4569/// __underlying_type(type) types.
4570///
4571/// This class is used internally by the ASTContext to manage
4572/// canonical, dependent types, only. Clients will only see instances
4573/// of this class via UnaryTransformType nodes.
4574class DependentUnaryTransformType : public UnaryTransformType,
4575 public llvm::FoldingSetNode {
4576public:
4577 DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
4578 UTTKind UKind);
4579
4580 void Profile(llvm::FoldingSetNodeID &ID) {
4581 Profile(ID, getBaseType(), getUTTKind());
4582 }
4583
4584 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4585 UTTKind UKind) {
4586 ID.AddPointer(BaseType.getAsOpaquePtr());
4587 ID.AddInteger((unsigned)UKind);
4588 }
4589};
4590
4591class TagType : public Type {
4592 friend class ASTReader;
4593 template <class T> friend class serialization::AbstractTypeReader;
4594
4595 /// Stores the TagDecl associated with this type. The decl may point to any
4596 /// TagDecl that declares the entity.
4597 TagDecl *decl;
4598
4599protected:
4600 TagType(TypeClass TC, const TagDecl *D, QualType can);
4601
4602public:
4603 TagDecl *getDecl() const;
4604
4605 /// Determines whether this type is in the process of being defined.
4606 bool isBeingDefined() const;
4607
4608 static bool classof(const Type *T) {
4609 return T->getTypeClass() == Enum || T->getTypeClass() == Record;
4610 }
4611};
4612
4613/// A helper class that allows the use of isa/cast/dyncast
4614/// to detect TagType objects of structs/unions/classes.
4615class RecordType : public TagType {
4616protected:
4617 friend class ASTContext; // ASTContext creates these.
4618
4619 explicit RecordType(const RecordDecl *D)
4620 : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4621 explicit RecordType(TypeClass TC, RecordDecl *D)
4622 : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4623
4624public:
4625 RecordDecl *getDecl() const {
4626 return reinterpret_cast<RecordDecl*>(TagType::getDecl());
4627 }
4628
4629 /// Recursively check all fields in the record for const-ness. If any field
4630 /// is declared const, return true. Otherwise, return false.
4631 bool hasConstFields() const;
4632
4633 bool isSugared() const { return false; }
4634 QualType desugar() const { return QualType(this, 0); }
4635
4636 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4637};
4638
4639/// A helper class that allows the use of isa/cast/dyncast
4640/// to detect TagType objects of enums.
4641class EnumType : public TagType {
4642 friend class ASTContext; // ASTContext creates these.
4643
4644 explicit EnumType(const EnumDecl *D)
4645 : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4646
4647public:
4648 EnumDecl *getDecl() const {
4649 return reinterpret_cast<EnumDecl*>(TagType::getDecl());
4650 }
4651
4652 bool isSugared() const { return false; }
4653 QualType desugar() const { return QualType(this, 0); }
4654
4655 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4656};
4657
4658/// An attributed type is a type to which a type attribute has been applied.
4659///
4660/// The "modified type" is the fully-sugared type to which the attributed
4661/// type was applied; generally it is not canonically equivalent to the
4662/// attributed type. The "equivalent type" is the minimally-desugared type
4663/// which the type is canonically equivalent to.
4664///
4665/// For example, in the following attributed type:
4666/// int32_t __attribute__((vector_size(16)))
4667/// - the modified type is the TypedefType for int32_t
4668/// - the equivalent type is VectorType(16, int32_t)
4669/// - the canonical type is VectorType(16, int)
4670class AttributedType : public Type, public llvm::FoldingSetNode {
4671public:
4672 using Kind = attr::Kind;
4673
4674private:
4675 friend class ASTContext; // ASTContext creates these
4676
4677 QualType ModifiedType;
4678 QualType EquivalentType;
4679
4680 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
4681 QualType equivalent)
4682 : Type(Attributed, canon, equivalent->getDependence()),
4683 ModifiedType(modified), EquivalentType(equivalent) {
4684 AttributedTypeBits.AttrKind = attrKind;
4685 }
4686
4687public:
4688 Kind getAttrKind() const {
4689 return static_cast<Kind>(AttributedTypeBits.AttrKind);
4690 }
4691
4692 QualType getModifiedType() const { return ModifiedType; }
4693 QualType getEquivalentType() const { return EquivalentType; }
4694
4695 bool isSugared() const { return true; }
4696 QualType desugar() const { return getEquivalentType(); }
4697
4698 /// Does this attribute behave like a type qualifier?
4699 ///
4700 /// A type qualifier adjusts a type to provide specialized rules for
4701 /// a specific object, like the standard const and volatile qualifiers.
4702 /// This includes attributes controlling things like nullability,
4703 /// address spaces, and ARC ownership. The value of the object is still
4704 /// largely described by the modified type.
4705 ///
4706 /// In contrast, many type attributes "rewrite" their modified type to
4707 /// produce a fundamentally different type, not necessarily related in any
4708 /// formalizable way to the original type. For example, calling convention
4709 /// and vector attributes are not simple type qualifiers.
4710 ///
4711 /// Type qualifiers are often, but not always, reflected in the canonical
4712 /// type.
4713 bool isQualifier() const;
4714
4715 bool isMSTypeSpec() const;
4716
4717 bool isCallingConv() const;
4718
4719 llvm::Optional<NullabilityKind> getImmediateNullability() const;
4720
4721 /// Retrieve the attribute kind corresponding to the given
4722 /// nullability kind.
4723 static Kind getNullabilityAttrKind(NullabilityKind kind) {
4724 switch (kind) {
4725 case NullabilityKind::NonNull:
4726 return attr::TypeNonNull;
4727
4728 case NullabilityKind::Nullable:
4729 return attr::TypeNullable;
4730
4731 case NullabilityKind::NullableResult:
4732 return attr::TypeNullableResult;
4733
4734 case NullabilityKind::Unspecified:
4735 return attr::TypeNullUnspecified;
4736 }
4737 llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
4738 }
4739
4740 /// Strip off the top-level nullability annotation on the given
4741 /// type, if it's there.
4742 ///
4743 /// \param T The type to strip. If the type is exactly an
4744 /// AttributedType specifying nullability (without looking through
4745 /// type sugar), the nullability is returned and this type changed
4746 /// to the underlying modified type.
4747 ///
4748 /// \returns the top-level nullability, if present.
4749 static Optional<NullabilityKind> stripOuterNullability(QualType &T);
4750
4751 void Profile(llvm::FoldingSetNodeID &ID) {
4752 Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
4753 }
4754
4755 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
4756 QualType modified, QualType equivalent) {
4757 ID.AddInteger(attrKind);
4758 ID.AddPointer(modified.getAsOpaquePtr());
4759 ID.AddPointer(equivalent.getAsOpaquePtr());
4760 }
4761
4762 static bool classof(const Type *T) {
4763 return T->getTypeClass() == Attributed;
4764 }
4765};
4766
4767class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4768 friend class ASTContext; // ASTContext creates these
4769
4770 // Helper data collector for canonical types.
4771 struct CanonicalTTPTInfo {
4772 unsigned Depth : 15;
4773 unsigned ParameterPack : 1;
4774 unsigned Index : 16;
4775 };
4776
4777 union {
4778 // Info for the canonical type.
4779 CanonicalTTPTInfo CanTTPTInfo;
4780
4781 // Info for the non-canonical type.
4782 TemplateTypeParmDecl *TTPDecl;
4783 };
4784
4785 /// Build a non-canonical type.
4786 TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
4787 : Type(TemplateTypeParm, Canon,
4788 TypeDependence::DependentInstantiation |
4789 (Canon->getDependence() & TypeDependence::UnexpandedPack)),
4790 TTPDecl(TTPDecl) {}
4791
4792 /// Build the canonical type.
4793 TemplateTypeParmType(unsigned D, unsigned I, bool PP)
4794 : Type(TemplateTypeParm, QualType(this, 0),
4795 TypeDependence::DependentInstantiation |
4796 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
4797 CanTTPTInfo.Depth = D;
4798 CanTTPTInfo.Index = I;
4799 CanTTPTInfo.ParameterPack = PP;
4800 }
4801
4802 const CanonicalTTPTInfo& getCanTTPTInfo() const {
4803 QualType Can = getCanonicalTypeInternal();
4804 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
4805 }
4806
4807public:
4808 unsigned getDepth() const { return getCanTTPTInfo().Depth; }
4809 unsigned getIndex() const { return getCanTTPTInfo().Index; }
4810 bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
4811
4812 TemplateTypeParmDecl *getDecl() const {
4813 return isCanonicalUnqualified() ? nullptr : TTPDecl;
4814 }
4815
4816 IdentifierInfo *getIdentifier() const;
4817
4818 bool isSugared() const { return false; }
4819 QualType desugar() const { return QualType(this, 0); }
4820
4821 void Profile(llvm::FoldingSetNodeID &ID) {
4822 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
4823 }
4824
4825 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
4826 unsigned Index, bool ParameterPack,
4827 TemplateTypeParmDecl *TTPDecl) {
4828 ID.AddInteger(Depth);
4829 ID.AddInteger(Index);
4830 ID.AddBoolean(ParameterPack);
4831 ID.AddPointer(TTPDecl);
4832 }
4833
4834 static bool classof(const Type *T) {
4835 return T->getTypeClass() == TemplateTypeParm;
4836 }
4837};
4838
4839/// Represents the result of substituting a type for a template
4840/// type parameter.
4841///
4842/// Within an instantiated template, all template type parameters have
4843/// been replaced with these. They are used solely to record that a
4844/// type was originally written as a template type parameter;
4845/// therefore they are never canonical.
4846class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4847 friend class ASTContext;
4848
4849 // The original type parameter.
4850 const TemplateTypeParmType *Replaced;
4851
4852 SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
4853 : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
4854 Replaced(Param) {}
4855
4856public:
4857 /// Gets the template parameter that was substituted for.
4858 const TemplateTypeParmType *getReplacedParameter() const {
4859 return Replaced;
4860 }
4861
4862 /// Gets the type that was substituted for the template
4863 /// parameter.
4864 QualType getReplacementType() const {
4865 return getCanonicalTypeInternal();
4866 }
4867
4868 bool isSugared() const { return true; }
4869 QualType desugar() const { return getReplacementType(); }
4870
4871 void Profile(llvm::FoldingSetNodeID &ID) {
4872 Profile(ID, getReplacedParameter(), getReplacementType());
4873 }
4874
4875 static void Profile(llvm::FoldingSetNodeID &ID,
4876 const TemplateTypeParmType *Replaced,
4877 QualType Replacement) {
4878 ID.AddPointer(Replaced);
4879 ID.AddPointer(Replacement.getAsOpaquePtr());
4880 }
4881
4882 static bool classof(const Type *T) {
4883 return T->getTypeClass() == SubstTemplateTypeParm;
4884 }
4885};
4886
4887/// Represents the result of substituting a set of types for a template
4888/// type parameter pack.
4889///
4890/// When a pack expansion in the source code contains multiple parameter packs
4891/// and those parameter packs correspond to different levels of template
4892/// parameter lists, this type node is used to represent a template type
4893/// parameter pack from an outer level, which has already had its argument pack
4894/// substituted but that still lives within a pack expansion that itself
4895/// could not be instantiated. When actually performing a substitution into
4896/// that pack expansion (e.g., when all template parameters have corresponding
4897/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898/// at the current pack substitution index.
4899class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4900 friend class ASTContext;
4901
4902 /// The original type parameter.
4903 const TemplateTypeParmType *Replaced;
4904
4905 /// A pointer to the set of template arguments that this
4906 /// parameter pack is instantiated with.
4907 const TemplateArgument *Arguments;
4908
4909 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
4910 QualType Canon,
4911 const TemplateArgument &ArgPack);
4912
4913public:
4914 IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
4915
4916 /// Gets the template parameter that was substituted for.
4917 const TemplateTypeParmType *getReplacedParameter() const {
4918 return Replaced;
4919 }
4920
4921 unsigned getNumArgs() const {
4922 return SubstTemplateTypeParmPackTypeBits.NumArgs;
4923 }
4924
4925 bool isSugared() const { return false; }
4926 QualType desugar() const { return QualType(this, 0); }
4927
4928 TemplateArgument getArgumentPack() const;
4929
4930 void Profile(llvm::FoldingSetNodeID &ID);
4931 static void Profile(llvm::FoldingSetNodeID &ID,
4932 const TemplateTypeParmType *Replaced,
4933 const TemplateArgument &ArgPack);
4934
4935 static bool classof(const Type *T) {
4936 return T->getTypeClass() == SubstTemplateTypeParmPack;
4937 }
4938};
4939
4940/// Common base class for placeholders for types that get replaced by
4941/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942/// class template types, and constrained type names.
4943///
4944/// These types are usually a placeholder for a deduced type. However, before
4945/// the initializer is attached, or (usually) if the initializer is
4946/// type-dependent, there is no deduced type and the type is canonical. In
4947/// the latter case, it is also a dependent type.
4948class DeducedType : public Type {
4949protected:
4950 DeducedType(TypeClass TC, QualType DeducedAsType,
4951 TypeDependence ExtraDependence)
4952 : Type(TC,
4953 // FIXME: Retain the sugared deduced type?
4954 DeducedAsType.isNull() ? QualType(this, 0)
4955 : DeducedAsType.getCanonicalType(),
4956 ExtraDependence | (DeducedAsType.isNull()
4957 ? TypeDependence::None
4958 : DeducedAsType->getDependence() &
4959 ~TypeDependence::VariablyModified)) {}
4960
4961public:
4962 bool isSugared() const { return !isCanonicalUnqualified(); }
4963 QualType desugar() const { return getCanonicalTypeInternal(); }
4964
4965 /// Get the type deduced for this placeholder type, or null if it's
4966 /// either not been deduced or was deduced to a dependent type.
4967 QualType getDeducedType() const {
4968 return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
4969 }
4970 bool isDeduced() const {
4971 return !isCanonicalUnqualified() || isDependentType();
4972 }
4973
4974 static bool classof(const Type *T) {
4975 return T->getTypeClass() == Auto ||
4976 T->getTypeClass() == DeducedTemplateSpecialization;
4977 }
4978};
4979
4980/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981/// by a type-constraint.
4982class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
4983 friend class ASTContext; // ASTContext creates these
4984
4985 ConceptDecl *TypeConstraintConcept;
4986
4987 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4988 TypeDependence ExtraDependence, ConceptDecl *CD,
4989 ArrayRef<TemplateArgument> TypeConstraintArgs);
4990
4991 const TemplateArgument *getArgBuffer() const {
4992 return reinterpret_cast<const TemplateArgument*>(this+1);
4993 }
4994
4995 TemplateArgument *getArgBuffer() {
4996 return reinterpret_cast<TemplateArgument*>(this+1);
4997 }
4998
4999public:
5000 /// Retrieve the template arguments.
5001 const TemplateArgument *getArgs() const {
5002 return getArgBuffer();
5003 }
5004
5005 /// Retrieve the number of template arguments.
5006 unsigned getNumArgs() const {
5007 return AutoTypeBits.NumArgs;
5008 }
5009
5010 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5011
5012 ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
5013 return {getArgs(), getNumArgs()};
5014 }
5015
5016 ConceptDecl *getTypeConstraintConcept() const {
5017 return TypeConstraintConcept;
5018 }
5019
5020 bool isConstrained() const {
5021 return TypeConstraintConcept != nullptr;
5022 }
5023
5024 bool isDecltypeAuto() const {
5025 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
5026 }
5027
5028 AutoTypeKeyword getKeyword() const {
5029 return (AutoTypeKeyword)AutoTypeBits.Keyword;
5030 }
5031
5032 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5033 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5034 getTypeConstraintConcept(), getTypeConstraintArguments());
5035 }
5036
5037 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
5038 QualType Deduced, AutoTypeKeyword Keyword,
5039 bool IsDependent, ConceptDecl *CD,
5040 ArrayRef<TemplateArgument> Arguments);
5041
5042 static bool classof(const Type *T) {
5043 return T->getTypeClass() == Auto;
5044 }
5045};
5046
5047/// Represents a C++17 deduced template specialization type.
5048class DeducedTemplateSpecializationType : public DeducedType,
5049 public llvm::FoldingSetNode {
5050 friend class ASTContext; // ASTContext creates these
5051
5052 /// The name of the template whose arguments will be deduced.
5053 TemplateName Template;
5054
5055 DeducedTemplateSpecializationType(TemplateName Template,
5056 QualType DeducedAsType,
5057 bool IsDeducedAsDependent)
5058 : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
5059 toTypeDependence(Template.getDependence()) |
5060 (IsDeducedAsDependent
5061 ? TypeDependence::DependentInstantiation
5062 : TypeDependence::None)),
5063 Template(Template) {}
5064
5065public:
5066 /// Retrieve the name of the template that we are deducing.
5067 TemplateName getTemplateName() const { return Template;}
5068
5069 void Profile(llvm::FoldingSetNodeID &ID) {
5070 Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
5071 }
5072
5073 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
5074 QualType Deduced, bool IsDependent) {
5075 Template.Profile(ID);
5076 ID.AddPointer(Deduced.getAsOpaquePtr());
5077 ID.AddBoolean(IsDependent);
5078 }
5079
5080 static bool classof(const Type *T) {
5081 return T->getTypeClass() == DeducedTemplateSpecialization;
5082 }
5083};
5084
5085/// Represents a type template specialization; the template
5086/// must be a class template, a type alias template, or a template
5087/// template parameter. A template which cannot be resolved to one of
5088/// these, e.g. because it is written with a dependent scope
5089/// specifier, is instead represented as a
5090/// @c DependentTemplateSpecializationType.
5091///
5092/// A non-dependent template specialization type is always "sugar",
5093/// typically for a \c RecordType. For example, a class template
5094/// specialization type of \c vector<int> will refer to a tag type for
5095/// the instantiation \c std::vector<int, std::allocator<int>>
5096///
5097/// Template specializations are dependent if either the template or
5098/// any of the template arguments are dependent, in which case the
5099/// type may also be canonical.
5100///
5101/// Instances of this type are allocated with a trailing array of
5102/// TemplateArguments, followed by a QualType representing the
5103/// non-canonical aliased type when the template is a type alias
5104/// template.
5105class alignas(8) TemplateSpecializationType
5106 : public Type,
5107 public llvm::FoldingSetNode {
5108 friend class ASTContext; // ASTContext creates these
5109
5110 /// The name of the template being specialized. This is
5111 /// either a TemplateName::Template (in which case it is a
5112 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
5113 /// TypeAliasTemplateDecl*), a
5114 /// TemplateName::SubstTemplateTemplateParmPack, or a
5115 /// TemplateName::SubstTemplateTemplateParm (in which case the
5116 /// replacement must, recursively, be one of these).
5117 TemplateName Template;
5118
5119 TemplateSpecializationType(TemplateName T,
5120 ArrayRef<TemplateArgument> Args,
5121 QualType Canon,
5122 QualType Aliased);
5123
5124public:
5125 /// Determine whether any of the given template arguments are dependent.
5126 ///
5127 /// The converted arguments should be supplied when known; whether an
5128 /// argument is dependent can depend on the conversions performed on it
5129 /// (for example, a 'const int' passed as a template argument might be
5130 /// dependent if the parameter is a reference but non-dependent if the
5131 /// parameter is an int).
5132 ///
5133 /// Note that the \p Args parameter is unused: this is intentional, to remind
5134 /// the caller that they need to pass in the converted arguments, not the
5135 /// specified arguments.
5136 static bool
5137 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
5138 ArrayRef<TemplateArgument> Converted);
5139 static bool
5140 anyDependentTemplateArguments(const TemplateArgumentListInfo &,
5141 ArrayRef<TemplateArgument> Converted);
5142 static bool anyInstantiationDependentTemplateArguments(
5143 ArrayRef<TemplateArgumentLoc> Args);
5144
5145 /// True if this template specialization type matches a current
5146 /// instantiation in the context in which it is found.
5147 bool isCurrentInstantiation() const {
5148 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
5149 }
5150
5151 /// Determine if this template specialization type is for a type alias
5152 /// template that has been substituted.
5153 ///
5154 /// Nearly every template specialization type whose template is an alias
5155 /// template will be substituted. However, this is not the case when
5156 /// the specialization contains a pack expansion but the template alias
5157 /// does not have a corresponding parameter pack, e.g.,
5158 ///
5159 /// \code
5160 /// template<typename T, typename U, typename V> struct S;
5161 /// template<typename T, typename U> using A = S<T, int, U>;
5162 /// template<typename... Ts> struct X {
5163 /// typedef A<Ts...> type; // not a type alias
5164 /// };
5165 /// \endcode
5166 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
5167
5168 /// Get the aliased type, if this is a specialization of a type alias
5169 /// template.
5170 QualType getAliasedType() const {
5171 assert(isTypeAlias() && "not a type alias template specialization")((void)0);
5172 return *reinterpret_cast<const QualType*>(end());
5173 }
5174
5175 using iterator = const TemplateArgument *;
5176
5177 iterator begin() const { return getArgs(); }
5178 iterator end() const; // defined inline in TemplateBase.h
5179
5180 /// Retrieve the name of the template that we are specializing.
5181 TemplateName getTemplateName() const { return Template; }
5182
5183 /// Retrieve the template arguments.
5184 const TemplateArgument *getArgs() const {
5185 return reinterpret_cast<const TemplateArgument *>(this + 1);
5186 }
5187
5188 /// Retrieve the number of template arguments.
5189 unsigned getNumArgs() const {
5190 return TemplateSpecializationTypeBits.NumArgs;
5191 }
5192
5193 /// Retrieve a specific template argument as a type.
5194 /// \pre \c isArgType(Arg)
5195 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5196
5197 ArrayRef<TemplateArgument> template_arguments() const {
5198 return {getArgs(), getNumArgs()};
5199 }
5200
5201 bool isSugared() const {
5202 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
5203 }
5204
5205 QualType desugar() const {
5206 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
5207 }
5208
5209 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
5210 Profile(ID, Template, template_arguments(), Ctx);
5211 if (isTypeAlias())
5212 getAliasedType().Profile(ID);
5213 }
5214
5215 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
5216 ArrayRef<TemplateArgument> Args,
5217 const ASTContext &Context);
5218
5219 static bool classof(const Type *T) {
5220 return T->getTypeClass() == TemplateSpecialization;
5221 }
5222};
5223
5224/// Print a template argument list, including the '<' and '>'
5225/// enclosing the template arguments.
5226void printTemplateArgumentList(raw_ostream &OS,
5227 ArrayRef<TemplateArgument> Args,
5228 const PrintingPolicy &Policy,
5229 const TemplateParameterList *TPL = nullptr);
5230
5231void printTemplateArgumentList(raw_ostream &OS,
5232 ArrayRef<TemplateArgumentLoc> Args,
5233 const PrintingPolicy &Policy,
5234 const TemplateParameterList *TPL = nullptr);
5235
5236void printTemplateArgumentList(raw_ostream &OS,
5237 const TemplateArgumentListInfo &Args,
5238 const PrintingPolicy &Policy,
5239 const TemplateParameterList *TPL = nullptr);
5240
5241/// The injected class name of a C++ class template or class
5242/// template partial specialization. Used to record that a type was
5243/// spelled with a bare identifier rather than as a template-id; the
5244/// equivalent for non-templated classes is just RecordType.
5245///
5246/// Injected class name types are always dependent. Template
5247/// instantiation turns these into RecordTypes.
5248///
5249/// Injected class name types are always canonical. This works
5250/// because it is impossible to compare an injected class name type
5251/// with the corresponding non-injected template type, for the same
5252/// reason that it is impossible to directly compare template
5253/// parameters from different dependent contexts: injected class name
5254/// types can only occur within the scope of a particular templated
5255/// declaration, and within that scope every template specialization
5256/// will canonicalize to the injected class name (when appropriate
5257/// according to the rules of the language).
5258class InjectedClassNameType : public Type {
5259 friend class ASTContext; // ASTContext creates these.
5260 friend class ASTNodeImporter;
5261 friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
5262 // currently suitable for AST reading, too much
5263 // interdependencies.
5264 template <class T> friend class serialization::AbstractTypeReader;
5265
5266 CXXRecordDecl *Decl;
5267
5268 /// The template specialization which this type represents.
5269 /// For example, in
5270 /// template <class T> class A { ... };
5271 /// this is A<T>, whereas in
5272 /// template <class X, class Y> class A<B<X,Y> > { ... };
5273 /// this is A<B<X,Y> >.
5274 ///
5275 /// It is always unqualified, always a template specialization type,
5276 /// and always dependent.
5277 QualType InjectedType;
5278
5279 InjectedClassNameType(CXXRecordDecl *D, QualType TST)
5280 : Type(InjectedClassName, QualType(),
5281 TypeDependence::DependentInstantiation),
5282 Decl(D), InjectedType(TST) {
5283 assert(isa<TemplateSpecializationType>(TST))((void)0);
5284 assert(!TST.hasQualifiers())((void)0);
5285 assert(TST->isDependentType())((void)0);
5286 }
5287
5288public:
5289 QualType getInjectedSpecializationType() const { return InjectedType; }
5290
5291 const TemplateSpecializationType *getInjectedTST() const {
5292 return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
5293 }
5294
5295 TemplateName getTemplateName() const {
5296 return getInjectedTST()->getTemplateName();
5297 }
5298
5299 CXXRecordDecl *getDecl() const;
5300
5301 bool isSugared() const { return false; }
5302 QualType desugar() const { return QualType(this, 0); }
5303
5304 static bool classof(const Type *T) {
5305 return T->getTypeClass() == InjectedClassName;
5306 }
5307};
5308
5309/// The kind of a tag type.
5310enum TagTypeKind {
5311 /// The "struct" keyword.
5312 TTK_Struct,
5313
5314 /// The "__interface" keyword.
5315 TTK_Interface,
5316
5317 /// The "union" keyword.
5318 TTK_Union,
5319
5320 /// The "class" keyword.
5321 TTK_Class,
5322
5323 /// The "enum" keyword.
5324 TTK_Enum
5325};
5326
5327/// The elaboration keyword that precedes a qualified type name or
5328/// introduces an elaborated-type-specifier.
5329enum ElaboratedTypeKeyword {
5330 /// The "struct" keyword introduces the elaborated-type-specifier.
5331 ETK_Struct,
5332
5333 /// The "__interface" keyword introduces the elaborated-type-specifier.
5334 ETK_Interface,
5335
5336 /// The "union" keyword introduces the elaborated-type-specifier.
5337 ETK_Union,
5338
5339 /// The "class" keyword introduces the elaborated-type-specifier.
5340 ETK_Class,
5341
5342 /// The "enum" keyword introduces the elaborated-type-specifier.
5343 ETK_Enum,
5344
5345 /// The "typename" keyword precedes the qualified type name, e.g.,
5346 /// \c typename T::type.
5347 ETK_Typename,
5348
5349 /// No keyword precedes the qualified type name.
5350 ETK_None
5351};
5352
5353/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354/// The keyword in stored in the free bits of the base class.
5355/// Also provides a few static helpers for converting and printing
5356/// elaborated type keyword and tag type kind enumerations.
5357class TypeWithKeyword : public Type {
5358protected:
5359 TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
5360 QualType Canonical, TypeDependence Dependence)
5361 : Type(tc, Canonical, Dependence) {
5362 TypeWithKeywordBits.Keyword = Keyword;
5363 }
5364
5365public:
5366 ElaboratedTypeKeyword getKeyword() const {
5367 return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
5368 }
5369
5370 /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5371 static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5372
5373 /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5374 /// It is an error to provide a type specifier which *isn't* a tag kind here.
5375 static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5376
5377 /// Converts a TagTypeKind into an elaborated type keyword.
5378 static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
5379
5380 /// Converts an elaborated type keyword into a TagTypeKind.
5381 /// It is an error to provide an elaborated type keyword
5382 /// which *isn't* a tag kind here.
5383 static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);
5384
5385 static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);
5386
5387 static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);
5388
5389 static StringRef getTagTypeKindName(TagTypeKind Kind) {
5390 return getKeywordName(getKeywordForTagTypeKind(Kind));
5391 }
5392
5393 class CannotCastToThisType {};
5394 static CannotCastToThisType classof(const Type *);
5395};
5396
5397/// Represents a type that was referred to using an elaborated type
5398/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5399/// or both.
5400///
5401/// This type is used to keep track of a type name as written in the
5402/// source code, including tag keywords and any nested-name-specifiers.
5403/// The type itself is always "sugar", used to express what was written
5404/// in the source code but containing no additional semantic information.
5405class ElaboratedType final
5406 : public TypeWithKeyword,
5407 public llvm::FoldingSetNode,
5408 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
5409 friend class ASTContext; // ASTContext creates these
5410 friend TrailingObjects;
5411
5412 /// The nested name specifier containing the qualifier.
5413 NestedNameSpecifier *NNS;
5414
5415 /// The type that this qualified name refers to.
5416 QualType NamedType;
5417
5418 /// The (re)declaration of this tag type owned by this occurrence is stored
5419 /// as a trailing object if there is one. Use getOwnedTagDecl to obtain
5420 /// it, or obtain a null pointer if there is none.
5421
5422 ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5423 QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
5424 : TypeWithKeyword(Keyword, Elaborated, CanonType,
5425 // Any semantic dependence on the qualifier will have
5426 // been incorporated into NamedType. We still need to
5427 // track syntactic (instantiation / error / pack)
5428 // dependence on the qualifier.
5429 NamedType->getDependence() |
5430 (NNS ? toSyntacticDependence(
5431 toTypeDependence(NNS->getDependence()))
5432 : TypeDependence::None)),
5433 NNS(NNS), NamedType(NamedType) {
5434 ElaboratedTypeBits.HasOwnedTagDecl = false;
5435 if (OwnedTagDecl) {
5436 ElaboratedTypeBits.HasOwnedTagDecl = true;
5437 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
5438 }
5439 assert(!(Keyword == ETK_None && NNS == nullptr) &&((void)0)
5440 "ElaboratedType cannot have elaborated type keyword "((void)0)
5441 "and name qualifier both null.")((void)0);
5442 }
5443
5444public:
5445 /// Retrieve the qualification on this type.
5446 NestedNameSpecifier *getQualifier() const { return NNS; }
5447
5448 /// Retrieve the type named by the qualified-id.
5449 QualType getNamedType() const { return NamedType; }
5450
5451 /// Remove a single level of sugar.
5452 QualType desugar() const { return getNamedType(); }
5453
5454 /// Returns whether this type directly provides sugar.
5455 bool isSugared() const { return true; }
5456
5457 /// Return the (re)declaration of this type owned by this occurrence of this
5458 /// type, or nullptr if there is none.
5459 TagDecl *getOwnedTagDecl() const {
5460 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
5461 : nullptr;
5462 }
5463
5464 void Profile(llvm::FoldingSetNodeID &ID) {
5465 Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
5466 }
5467
5468 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5469 NestedNameSpecifier *NNS, QualType NamedType,
5470 TagDecl *OwnedTagDecl) {
5471 ID.AddInteger(Keyword);
5472 ID.AddPointer(NNS);
5473 NamedType.Profile(ID);
5474 ID.AddPointer(OwnedTagDecl);
5475 }
5476
5477 static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5478};
5479
5480/// Represents a qualified type name for which the type name is
5481/// dependent.
5482///
5483/// DependentNameType represents a class of dependent types that involve a
5484/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5485/// name of a type. The DependentNameType may start with a "typename" (for a
5486/// typename-specifier), "class", "struct", "union", or "enum" (for a
5487/// dependent elaborated-type-specifier), or nothing (in contexts where we
5488/// know that we must be referring to a type, e.g., in a base class specifier).
5489/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5490/// mode, this type is used with non-dependent names to delay name lookup until
5491/// instantiation.
5492class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
5493 friend class ASTContext; // ASTContext creates these
5494
5495 /// The nested name specifier containing the qualifier.
5496 NestedNameSpecifier *NNS;
5497
5498 /// The type that this typename specifier refers to.
5499 const IdentifierInfo *Name;
5500
5501 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5502 const IdentifierInfo *Name, QualType CanonType)
5503 : TypeWithKeyword(Keyword, DependentName, CanonType,
5504 TypeDependence::DependentInstantiation |
5505 toTypeDependence(NNS->getDependence())),
5506 NNS(NNS), Name(Name) {}
5507
5508public:
5509 /// Retrieve the qualification on this type.
5510 NestedNameSpecifier *getQualifier() const { return NNS; }
5511
5512 /// Retrieve the type named by the typename specifier as an identifier.
5513 ///
5514 /// This routine will return a non-NULL identifier pointer when the
5515 /// form of the original typename was terminated by an identifier,
5516 /// e.g., "typename T::type".
5517 const IdentifierInfo *getIdentifier() const {
5518 return Name;
5519 }
5520
5521 bool isSugared() const { return false; }
5522 QualType desugar() const { return QualType(this, 0); }
5523
5524 void Profile(llvm::FoldingSetNodeID &ID) {
5525 Profile(ID, getKeyword(), NNS, Name);
5526 }
5527
5528 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5529 NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
5530 ID.AddInteger(Keyword);
5531 ID.AddPointer(NNS);
5532 ID.AddPointer(Name);
5533 }
5534
5535 static bool classof(const Type *T) {
5536 return T->getTypeClass() == DependentName;
5537 }
5538};
5539
5540/// Represents a template specialization type whose template cannot be
5541/// resolved, e.g.
5542/// A<T>::template B<T>
5543class alignas(8) DependentTemplateSpecializationType
5544 : public TypeWithKeyword,
5545 public llvm::FoldingSetNode {
5546 friend class ASTContext; // ASTContext creates these
5547
5548 /// The nested name specifier containing the qualifier.
5549 NestedNameSpecifier *NNS;
5550
5551 /// The identifier of the template.
5552 const IdentifierInfo *Name;
5553
5554 DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
5555 NestedNameSpecifier *NNS,
5556 const IdentifierInfo *Name,
5557 ArrayRef<TemplateArgument> Args,
5558 QualType Canon);
5559
5560 const TemplateArgument *getArgBuffer() const {
5561 return reinterpret_cast<const TemplateArgument*>(this+1);
5562 }
5563
5564 TemplateArgument *getArgBuffer() {
5565 return reinterpret_cast<TemplateArgument*>(this+1);
5566 }
5567
5568public:
5569 NestedNameSpecifier *getQualifier() const { return NNS; }
5570 const IdentifierInfo *getIdentifier() const { return Name; }
5571
5572 /// Retrieve the template arguments.
5573 const TemplateArgument *getArgs() const {
5574 return getArgBuffer();
5575 }
5576
5577 /// Retrieve the number of template arguments.
5578 unsigned getNumArgs() const {
5579 return DependentTemplateSpecializationTypeBits.NumArgs;
5580 }
5581
5582 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5583
5584 ArrayRef<TemplateArgument> template_arguments() const {
5585 return {getArgs(), getNumArgs()};
5586 }
5587
5588 using iterator = const TemplateArgument *;
5589
5590 iterator begin() const { return getArgs(); }
5591 iterator end() const; // inline in TemplateBase.h
5592
5593 bool isSugared() const { return false; }
5594 QualType desugar() const { return QualType(this, 0); }
5595
5596 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5597 Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
5598 }
5599
5600 static void Profile(llvm::FoldingSetNodeID &ID,
5601 const ASTContext &Context,
5602 ElaboratedTypeKeyword Keyword,
5603 NestedNameSpecifier *Qualifier,
5604 const IdentifierInfo *Name,
5605 ArrayRef<TemplateArgument> Args);
5606
5607 static bool classof(const Type *T) {
5608 return T->getTypeClass() == DependentTemplateSpecialization;
5609 }
5610};
5611
5612/// Represents a pack expansion of types.
5613///
5614/// Pack expansions are part of C++11 variadic templates. A pack
5615/// expansion contains a pattern, which itself contains one or more
5616/// "unexpanded" parameter packs. When instantiated, a pack expansion
5617/// produces a series of types, each instantiated from the pattern of
5618/// the expansion, where the Ith instantiation of the pattern uses the
5619/// Ith arguments bound to each of the unexpanded parameter packs. The
5620/// pack expansion is considered to "expand" these unexpanded
5621/// parameter packs.
5622///
5623/// \code
5624/// template<typename ...Types> struct tuple;
5625///
5626/// template<typename ...Types>
5627/// struct tuple_of_references {
5628/// typedef tuple<Types&...> type;
5629/// };
5630/// \endcode
5631///
5632/// Here, the pack expansion \c Types&... is represented via a
5633/// PackExpansionType whose pattern is Types&.
5634class PackExpansionType : public Type, public llvm::FoldingSetNode {
5635 friend class ASTContext; // ASTContext creates these
5636
5637 /// The pattern of the pack expansion.
5638 QualType Pattern;
5639
5640 PackExpansionType(QualType Pattern, QualType Canon,
5641 Optional<unsigned> NumExpansions)
5642 : Type(PackExpansion, Canon,
5643 (Pattern->getDependence() | TypeDependence::Dependent |
5644 TypeDependence::Instantiation) &
5645 ~TypeDependence::UnexpandedPack),
5646 Pattern(Pattern) {
5647 PackExpansionTypeBits.NumExpansions =
5648 NumExpansions ? *NumExpansions + 1 : 0;
5649 }
5650
5651public:
5652 /// Retrieve the pattern of this pack expansion, which is the
5653 /// type that will be repeatedly instantiated when instantiating the
5654 /// pack expansion itself.
5655 QualType getPattern() const { return Pattern; }
5656
5657 /// Retrieve the number of expansions that this pack expansion will
5658 /// generate, if known.
5659 Optional<unsigned> getNumExpansions() const {
5660 if (PackExpansionTypeBits.NumExpansions)
5661 return PackExpansionTypeBits.NumExpansions - 1;
5662 return None;
5663 }
5664
5665 bool isSugared() const { return false; }
5666 QualType desugar() const { return QualType(this, 0); }
5667
5668 void Profile(llvm::FoldingSetNodeID &ID) {
5669 Profile(ID, getPattern(), getNumExpansions());
5670 }
5671
5672 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
5673 Optional<unsigned> NumExpansions) {
5674 ID.AddPointer(Pattern.getAsOpaquePtr());
5675 ID.AddBoolean(NumExpansions.hasValue());
5676 if (NumExpansions)
5677 ID.AddInteger(*NumExpansions);
5678 }
5679
5680 static bool classof(const Type *T) {
5681 return T->getTypeClass() == PackExpansion;
5682 }
5683};
5684
5685/// This class wraps the list of protocol qualifiers. For types that can
5686/// take ObjC protocol qualifers, they can subclass this class.
5687template <class T>
5688class ObjCProtocolQualifiers {
5689protected:
5690 ObjCProtocolQualifiers() = default;
5691
5692 ObjCProtocolDecl * const *getProtocolStorage() const {
5693 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
5694 }
5695
5696 ObjCProtocolDecl **getProtocolStorage() {
5697 return static_cast<T*>(this)->getProtocolStorageImpl();
5698 }
5699
5700 void setNumProtocols(unsigned N) {
5701 static_cast<T*>(this)->setNumProtocolsImpl(N);
5702 }
5703
5704 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
5705 setNumProtocols(protocols.size());
5706 assert(getNumProtocols() == protocols.size() &&((void)0)
5707 "bitfield overflow in protocol count")((void)0);
5708 if (!protocols.empty())
5709 memcpy(getProtocolStorage(), protocols.data(),
5710 protocols.size() * sizeof(ObjCProtocolDecl*));
5711 }
5712
5713public:
5714 using qual_iterator = ObjCProtocolDecl * const *;
5715 using qual_range = llvm::iterator_range<qual_iterator>;
5716
5717 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
5718 qual_iterator qual_begin() const { return getProtocolStorage(); }
5719 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
5720
5721 bool qual_empty() const { return getNumProtocols() == 0; }
5722
5723 /// Return the number of qualifying protocols in this type, or 0 if
5724 /// there are none.
5725 unsigned getNumProtocols() const {
5726 return static_cast<const T*>(this)->getNumProtocolsImpl();
5727 }
5728
5729 /// Fetch a protocol by index.
5730 ObjCProtocolDecl *getProtocol(unsigned I) const {
5731 assert(I < getNumProtocols() && "Out-of-range protocol access")((void)0);
5732 return qual_begin()[I];
5733 }
5734
5735 /// Retrieve all of the protocol qualifiers.
5736 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
5737 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
5738 }
5739};
5740
5741/// Represents a type parameter type in Objective C. It can take
5742/// a list of protocols.
5743class ObjCTypeParamType : public Type,
5744 public ObjCProtocolQualifiers<ObjCTypeParamType>,
5745 public llvm::FoldingSetNode {
5746 friend class ASTContext;
5747 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
5748
5749 /// The number of protocols stored on this type.
5750 unsigned NumProtocols : 6;
5751
5752 ObjCTypeParamDecl *OTPDecl;
5753
5754 /// The protocols are stored after the ObjCTypeParamType node. In the
5755 /// canonical type, the list of protocols are sorted alphabetically
5756 /// and uniqued.
5757 ObjCProtocolDecl **getProtocolStorageImpl();
5758
5759 /// Return the number of qualifying protocols in this interface type,
5760 /// or 0 if there are none.
5761 unsigned getNumProtocolsImpl() const {
5762 return NumProtocols;
5763 }
5764
5765 void setNumProtocolsImpl(unsigned N) {
5766 NumProtocols = N;
5767 }
5768
5769 ObjCTypeParamType(const ObjCTypeParamDecl *D,
5770 QualType can,
5771 ArrayRef<ObjCProtocolDecl *> protocols);
5772
5773public:
5774 bool isSugared() const { return true; }
5775 QualType desugar() const { return getCanonicalTypeInternal(); }
5776
5777 static bool classof(const Type *T) {
5778 return T->getTypeClass() == ObjCTypeParam;
5779 }
5780
5781 void Profile(llvm::FoldingSetNodeID &ID);
5782 static void Profile(llvm::FoldingSetNodeID &ID,
5783 const ObjCTypeParamDecl *OTPDecl,
5784 QualType CanonicalType,
5785 ArrayRef<ObjCProtocolDecl *> protocols);
5786
5787 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5788};
5789
5790/// Represents a class type in Objective C.
5791///
5792/// Every Objective C type is a combination of a base type, a set of
5793/// type arguments (optional, for parameterized classes) and a list of
5794/// protocols.
5795///
5796/// Given the following declarations:
5797/// \code
5798/// \@class C<T>;
5799/// \@protocol P;
5800/// \endcode
5801///
5802/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
5803/// with base C and no protocols.
5804///
5805/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5806/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5807/// protocol list.
5808/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5809/// and protocol list [P].
5810///
5811/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5812/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5813/// and no protocols.
5814///
5815/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5816/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
5817/// this should get its own sugar class to better represent the source.
5818class ObjCObjectType : public Type,
5819 public ObjCProtocolQualifiers<ObjCObjectType> {
5820 friend class ObjCProtocolQualifiers<ObjCObjectType>;
5821
5822 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
5823 // after the ObjCObjectPointerType node.
5824 // ObjCObjectType.NumProtocols - the number of protocols stored
5825 // after the type arguments of ObjCObjectPointerType node.
5826 //
5827 // These protocols are those written directly on the type. If
5828 // protocol qualifiers ever become additive, the iterators will need
5829 // to get kindof complicated.
5830 //
5831 // In the canonical object type, these are sorted alphabetically
5832 // and uniqued.
5833
5834 /// Either a BuiltinType or an InterfaceType or sugar for either.
5835 QualType BaseType;
5836
5837 /// Cached superclass type.
5838 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
5839 CachedSuperClassType;
5840
5841 QualType *getTypeArgStorage();
5842 const QualType *getTypeArgStorage() const {
5843 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
5844 }
5845
5846 ObjCProtocolDecl **getProtocolStorageImpl();
5847 /// Return the number of qualifying protocols in this interface type,
5848 /// or 0 if there are none.
5849 unsigned getNumProtocolsImpl() const {
5850 return ObjCObjectTypeBits.NumProtocols;
5851 }
5852 void setNumProtocolsImpl(unsigned N) {
5853 ObjCObjectTypeBits.NumProtocols = N;
5854 }
5855
5856protected:
5857 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
5858
5859 ObjCObjectType(QualType Canonical, QualType Base,
5860 ArrayRef<QualType> typeArgs,
5861 ArrayRef<ObjCProtocolDecl *> protocols,
5862 bool isKindOf);
5863
5864 ObjCObjectType(enum Nonce_ObjCInterface)
5865 : Type(ObjCInterface, QualType(), TypeDependence::None),
5866 BaseType(QualType(this_(), 0)) {
5867 ObjCObjectTypeBits.NumProtocols = 0;
5868 ObjCObjectTypeBits.NumTypeArgs = 0;
5869 ObjCObjectTypeBits.IsKindOf = 0;
5870 }
5871
5872 void computeSuperClassTypeSlow() const;
5873
5874public:
5875 /// Gets the base type of this object type. This is always (possibly
5876 /// sugar for) one of:
5877 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
5878 /// user, which is a typedef for an ObjCObjectPointerType)
5879 /// - the 'Class' builtin type (same caveat)
5880 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
5881 QualType getBaseType() const { return BaseType; }
5882
5883 bool isObjCId() const {
5884 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
5885 }
5886
5887 bool isObjCClass() const {
5888 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
5889 }
5890
5891 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
5892 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
5893 bool isObjCUnqualifiedIdOrClass() const {
5894 if (!qual_empty()) return false;
5895 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
5896 return T->getKind() == BuiltinType::ObjCId ||
5897 T->getKind() == BuiltinType::ObjCClass;
5898 return false;
5899 }
5900 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
5901 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
5902
5903 /// Gets the interface declaration for this object type, if the base type
5904 /// really is an interface.
5905 ObjCInterfaceDecl *getInterface() const;
5906
5907 /// Determine whether this object type is "specialized", meaning
5908 /// that it has type arguments.
5909 bool isSpecialized() const;
5910
5911 /// Determine whether this object type was written with type arguments.
5912 bool isSpecializedAsWritten() const {
5913 return ObjCObjectTypeBits.NumTypeArgs > 0;
5914 }
5915
5916 /// Determine whether this object type is "unspecialized", meaning
5917 /// that it has no type arguments.
5918 bool isUnspecialized() const { return !isSpecialized(); }
5919
5920 /// Determine whether this object type is "unspecialized" as
5921 /// written, meaning that it has no type arguments.
5922 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
5923
5924 /// Retrieve the type arguments of this object type (semantically).
5925 ArrayRef<QualType> getTypeArgs() const;
5926
5927 /// Retrieve the type arguments of this object type as they were
5928 /// written.
5929 ArrayRef<QualType> getTypeArgsAsWritten() const {
5930 return llvm::makeArrayRef(getTypeArgStorage(),
5931 ObjCObjectTypeBits.NumTypeArgs);
5932 }
5933
5934 /// Whether this is a "__kindof" type as written.
5935 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
5936
5937 /// Whether this ia a "__kindof" type (semantically).
5938 bool isKindOfType() const;
5939
5940 /// Retrieve the type of the superclass of this object type.
5941 ///
5942 /// This operation substitutes any type arguments into the
5943 /// superclass of the current class type, potentially producing a
5944 /// specialization of the superclass type. Produces a null type if
5945 /// there is no superclass.
5946 QualType getSuperClassType() const {
5947 if (!CachedSuperClassType.getInt())
5948 computeSuperClassTypeSlow();
5949
5950 assert(CachedSuperClassType.getInt() && "Superclass not set?")((void)0);
5951 return QualType(CachedSuperClassType.getPointer(), 0);
5952 }
5953
5954 /// Strip off the Objective-C "kindof" type and (with it) any
5955 /// protocol qualifiers.
5956 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
5957
5958 bool isSugared() const { return false; }
5959 QualType desugar() const { return QualType(this, 0); }
5960
5961 static bool classof(const Type *T) {
5962 return T->getTypeClass() == ObjCObject ||
5963 T->getTypeClass() == ObjCInterface;
5964 }
5965};
5966
5967/// A class providing a concrete implementation
5968/// of ObjCObjectType, so as to not increase the footprint of
5969/// ObjCInterfaceType. Code outside of ASTContext and the core type
5970/// system should not reference this type.
5971class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
5972 friend class ASTContext;
5973
5974 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
5975 // will need to be modified.
5976
5977 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
5978 ArrayRef<QualType> typeArgs,
5979 ArrayRef<ObjCProtocolDecl *> protocols,
5980 bool isKindOf)
5981 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
5982
5983public:
5984 void Profile(llvm::FoldingSetNodeID &ID);
5985 static void Profile(llvm::FoldingSetNodeID &ID,
5986 QualType Base,
5987 ArrayRef<QualType> typeArgs,
5988 ArrayRef<ObjCProtocolDecl *> protocols,
5989 bool isKindOf);
5990};
5991
5992inline QualType *ObjCObjectType::getTypeArgStorage() {
5993 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5994}
5995
5996inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
5997 return reinterpret_cast<ObjCProtocolDecl**>(
5998 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5999}
6000
6001inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
6002 return reinterpret_cast<ObjCProtocolDecl**>(
6003 static_cast<ObjCTypeParamType*>(this)+1);
6004}
6005
6006/// Interfaces are the core concept in Objective-C for object oriented design.
6007/// They basically correspond to C++ classes. There are two kinds of interface
6008/// types: normal interfaces like `NSString`, and qualified interfaces, which
6009/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6010///
6011/// ObjCInterfaceType guarantees the following properties when considered
6012/// as a subtype of its superclass, ObjCObjectType:
6013/// - There are no protocol qualifiers. To reinforce this, code which
6014/// tries to invoke the protocol methods via an ObjCInterfaceType will
6015/// fail to compile.
6016/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
6017/// T->getBaseType() == QualType(T, 0).
6018class ObjCInterfaceType : public ObjCObjectType {
6019 friend class ASTContext; // ASTContext creates these.
6020 friend class ASTReader;
6021 friend class ObjCInterfaceDecl;
6022 template <class T> friend class serialization::AbstractTypeReader;
6023
6024 mutable ObjCInterfaceDecl *Decl;
6025
6026 ObjCInterfaceType(const ObjCInterfaceDecl *D)
6027 : ObjCObjectType(Nonce_ObjCInterface),
6028 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
6029
6030public:
6031 /// Get the declaration of this interface.
6032 ObjCInterfaceDecl *getDecl() const { return Decl; }
6033
6034 bool isSugared() const { return false; }
6035 QualType desugar() const { return QualType(this, 0); }
6036
6037 static bool classof(const Type *T) {
6038 return T->getTypeClass() == ObjCInterface;
6039 }
6040
6041 // Nonsense to "hide" certain members of ObjCObjectType within this
6042 // class. People asking for protocols on an ObjCInterfaceType are
6043 // not going to get what they want: ObjCInterfaceTypes are
6044 // guaranteed to have no protocols.
6045 enum {
6046 qual_iterator,
6047 qual_begin,
6048 qual_end,
6049 getNumProtocols,
6050 getProtocol
6051 };
6052};
6053
6054inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
6055 QualType baseType = getBaseType();
6056 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
6057 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
6058 return T->getDecl();
6059
6060 baseType = ObjT->getBaseType();
6061 }
6062
6063 return nullptr;
6064}
6065
6066/// Represents a pointer to an Objective C object.
6067///
6068/// These are constructed from pointer declarators when the pointee type is
6069/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
6070/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6071/// and 'Class<P>' are translated into these.
6072///
6073/// Pointers to pointers to Objective C objects are still PointerTypes;
6074/// only the first level of pointer gets it own type implementation.
6075class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
6076 friend class ASTContext; // ASTContext creates these.
6077
6078 QualType PointeeType;
6079
6080 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
6081 : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
6082 PointeeType(Pointee) {}
6083
6084public:
6085 /// Gets the type pointed to by this ObjC pointer.
6086 /// The result will always be an ObjCObjectType or sugar thereof.
6087 QualType getPointeeType() const { return PointeeType; }
6088
6089 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
6090 ///
6091 /// This method is equivalent to getPointeeType() except that
6092 /// it discards any typedefs (or other sugar) between this
6093 /// type and the "outermost" object type. So for:
6094 /// \code
6095 /// \@class A; \@protocol P; \@protocol Q;
6096 /// typedef A<P> AP;
6097 /// typedef A A1;
6098 /// typedef A1<P> A1P;
6099 /// typedef A1P<Q> A1PQ;
6100 /// \endcode
6101 /// For 'A*', getObjectType() will return 'A'.
6102 /// For 'A<P>*', getObjectType() will return 'A<P>'.
6103 /// For 'AP*', getObjectType() will return 'A<P>'.
6104 /// For 'A1*', getObjectType() will return 'A'.
6105 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
6106 /// For 'A1P*', getObjectType() will return 'A1<P>'.
6107 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
6108 /// adding protocols to a protocol-qualified base discards the
6109 /// old qualifiers (for now). But if it didn't, getObjectType()
6110 /// would return 'A1P<Q>' (and we'd have to make iterating over
6111 /// qualifiers more complicated).
6112 const ObjCObjectType *getObjectType() const {
6113 return PointeeType->castAs<ObjCObjectType>();
6114 }
6115
6116 /// If this pointer points to an Objective C
6117 /// \@interface type, gets the type for that interface. Any protocol
6118 /// qualifiers on the interface are ignored.
6119 ///
6120 /// \return null if the base type for this pointer is 'id' or 'Class'
6121 const ObjCInterfaceType *getInterfaceType() const;
6122
6123 /// If this pointer points to an Objective \@interface
6124 /// type, gets the declaration for that interface.
6125 ///
6126 /// \return null if the base type for this pointer is 'id' or 'Class'
6127 ObjCInterfaceDecl *getInterfaceDecl() const {
6128 return getObjectType()->getInterface();
6129 }
6130
6131 /// True if this is equivalent to the 'id' type, i.e. if
6132 /// its object type is the primitive 'id' type with no protocols.
6133 bool isObjCIdType() const {
6134 return getObjectType()->isObjCUnqualifiedId();
6135 }
6136
6137 /// True if this is equivalent to the 'Class' type,
6138 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
6139 bool isObjCClassType() const {
6140 return getObjectType()->isObjCUnqualifiedClass();
6141 }
6142
6143 /// True if this is equivalent to the 'id' or 'Class' type,
6144 bool isObjCIdOrClassType() const {
6145 return getObjectType()->isObjCUnqualifiedIdOrClass();
6146 }
6147
6148 /// True if this is equivalent to 'id<P>' for some non-empty set of
6149 /// protocols.
6150 bool isObjCQualifiedIdType() const {
6151 return getObjectType()->isObjCQualifiedId();
6152 }
6153
6154 /// True if this is equivalent to 'Class<P>' for some non-empty set of
6155 /// protocols.
6156 bool isObjCQualifiedClassType() const {
6157 return getObjectType()->isObjCQualifiedClass();
6158 }
6159
6160 /// Whether this is a "__kindof" type.
6161 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
6162
6163 /// Whether this type is specialized, meaning that it has type arguments.
6164 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
6165
6166 /// Whether this type is specialized, meaning that it has type arguments.
6167 bool isSpecializedAsWritten() const {
6168 return getObjectType()->isSpecializedAsWritten();
6169 }
6170
6171 /// Whether this type is unspecialized, meaning that is has no type arguments.
6172 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
6173
6174 /// Determine whether this object type is "unspecialized" as
6175 /// written, meaning that it has no type arguments.
6176 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
6177
6178 /// Retrieve the type arguments for this type.
6179 ArrayRef<QualType> getTypeArgs() const {
6180 return getObjectType()->getTypeArgs();
6181 }
6182
6183 /// Retrieve the type arguments for this type.
6184 ArrayRef<QualType> getTypeArgsAsWritten() const {
6185 return getObjectType()->getTypeArgsAsWritten();
6186 }
6187
6188 /// An iterator over the qualifiers on the object type. Provided
6189 /// for convenience. This will always iterate over the full set of
6190 /// protocols on a type, not just those provided directly.
6191 using qual_iterator = ObjCObjectType::qual_iterator;
6192 using qual_range = llvm::iterator_range<qual_iterator>;
6193
6194 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
6195
6196 qual_iterator qual_begin() const {
6197 return getObjectType()->qual_begin();
6198 }
6199
6200 qual_iterator qual_end() const {
6201 return getObjectType()->qual_end();
6202 }
6203
6204 bool qual_empty() const { return getObjectType()->qual_empty(); }
6205
6206 /// Return the number of qualifying protocols on the object type.
6207 unsigned getNumProtocols() const {
6208 return getObjectType()->getNumProtocols();
6209 }
6210
6211 /// Retrieve a qualifying protocol by index on the object type.
6212 ObjCProtocolDecl *getProtocol(unsigned I) const {
6213 return getObjectType()->getProtocol(I);
6214 }
6215
6216 bool isSugared() const { return false; }
6217 QualType desugar() const { return QualType(this, 0); }
6218
6219 /// Retrieve the type of the superclass of this object pointer type.
6220 ///
6221 /// This operation substitutes any type arguments into the
6222 /// superclass of the current class type, potentially producing a
6223 /// pointer to a specialization of the superclass type. Produces a
6224 /// null type if there is no superclass.
6225 QualType getSuperClassType() const;
6226
6227 /// Strip off the Objective-C "kindof" type and (with it) any
6228 /// protocol qualifiers.
6229 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
6230 const ASTContext &ctx) const;
6231
6232 void Profile(llvm::FoldingSetNodeID &ID) {
6233 Profile(ID, getPointeeType());
6234 }
6235
6236 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6237 ID.AddPointer(T.getAsOpaquePtr());
6238 }
6239
6240 static bool classof(const Type *T) {
6241 return T->getTypeClass() == ObjCObjectPointer;
6242 }
6243};
6244
6245class AtomicType : public Type, public llvm::FoldingSetNode {
6246 friend class ASTContext; // ASTContext creates these.
6247
6248 QualType ValueType;
6249
6250 AtomicType(QualType ValTy, QualType Canonical)
6251 : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
6252
6253public:
6254 /// Gets the type contained by this atomic type, i.e.
6255 /// the type returned by performing an atomic load of this atomic type.
6256 QualType getValueType() const { return ValueType; }
6257
6258 bool isSugared() const { return false; }
6259 QualType desugar() const { return QualType(this, 0); }
6260
6261 void Profile(llvm::FoldingSetNodeID &ID) {
6262 Profile(ID, getValueType());
6263 }
6264
6265 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6266 ID.AddPointer(T.getAsOpaquePtr());
6267 }
6268
6269 static bool classof(const Type *T) {
6270 return T->getTypeClass() == Atomic;
6271 }
6272};
6273
6274/// PipeType - OpenCL20.
6275class PipeType : public Type, public llvm::FoldingSetNode {
6276 friend class ASTContext; // ASTContext creates these.
6277
6278 QualType ElementType;
6279 bool isRead;
6280
6281 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
6282 : Type(Pipe, CanonicalPtr, elemType->getDependence()),
6283 ElementType(elemType), isRead(isRead) {}
6284
6285public:
6286 QualType getElementType() const { return ElementType; }
6287
6288 bool isSugared() const { return false; }
6289
6290 QualType desugar() const { return QualType(this, 0); }
6291
6292 void Profile(llvm::FoldingSetNodeID &ID) {
6293 Profile(ID, getElementType(), isReadOnly());
6294 }
6295
6296 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
6297 ID.AddPointer(T.getAsOpaquePtr());
6298 ID.AddBoolean(isRead);
6299 }
6300
6301 static bool classof(const Type *T) {
6302 return T->getTypeClass() == Pipe;
6303 }
6304
6305 bool isReadOnly() const { return isRead; }
6306};
6307
6308/// A fixed int type of a specified bitwidth.
6309class ExtIntType final : public Type, public llvm::FoldingSetNode {
6310 friend class ASTContext;
6311 unsigned IsUnsigned : 1;
6312 unsigned NumBits : 24;
6313
6314protected:
6315 ExtIntType(bool isUnsigned, unsigned NumBits);
6316
6317public:
6318 bool isUnsigned() const { return IsUnsigned; }
6319 bool isSigned() const { return !IsUnsigned; }
6320 unsigned getNumBits() const { return NumBits; }
6321
6322 bool isSugared() const { return false; }
6323 QualType desugar() const { return QualType(this, 0); }
6324
6325 void Profile(llvm::FoldingSetNodeID &ID) {
6326 Profile(ID, isUnsigned(), getNumBits());
6327 }
6328
6329 static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
6330 unsigned NumBits) {
6331 ID.AddBoolean(IsUnsigned);
6332 ID.AddInteger(NumBits);
6333 }
6334
6335 static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6336};
6337
6338class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
6339 friend class ASTContext;
6340 const ASTContext &Context;
6341 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
6342
6343protected:
6344 DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
6345 Expr *NumBits);
6346
6347public:
6348 bool isUnsigned() const;
6349 bool isSigned() const { return !isUnsigned(); }
6350 Expr *getNumBitsExpr() const;
6351
6352 bool isSugared() const { return false; }
6353 QualType desugar() const { return QualType(this, 0); }
6354
6355 void Profile(llvm::FoldingSetNodeID &ID) {
6356 Profile(ID, Context, isUnsigned(), getNumBitsExpr());
6357 }
6358 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6359 bool IsUnsigned, Expr *NumBitsExpr);
6360
6361 static bool classof(const Type *T) {
6362 return T->getTypeClass() == DependentExtInt;
6363 }
6364};
6365
6366/// A qualifier set is used to build a set of qualifiers.
6367class QualifierCollector : public Qualifiers {
6368public:
6369 QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
6370
6371 /// Collect any qualifiers on the given type and return an
6372 /// unqualified type. The qualifiers are assumed to be consistent
6373 /// with those already in the type.
6374 const Type *strip(QualType type) {
6375 addFastQualifiers(type.getLocalFastQualifiers());
6376 if (!type.hasLocalNonFastQualifiers())
6377 return type.getTypePtrUnsafe();
6378
6379 const ExtQuals *extQuals = type.getExtQualsUnsafe();
6380 addConsistentQualifiers(extQuals->getQualifiers());
6381 return extQuals->getBaseType();
6382 }
6383
6384 /// Apply the collected qualifiers to the given type.
6385 QualType apply(const ASTContext &Context, QualType QT) const;
6386
6387 /// Apply the collected qualifiers to the given type.
6388 QualType apply(const ASTContext &Context, const Type* T) const;
6389};
6390
6391/// A container of type source information.
6392///
6393/// A client can read the relevant info using TypeLoc wrappers, e.g:
6394/// @code
6395/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6396/// TL.getBeginLoc().print(OS, SrcMgr);
6397/// @endcode
6398class alignas(8) TypeSourceInfo {
6399 // Contains a memory block after the class, used for type source information,
6400 // allocated by ASTContext.
6401 friend class ASTContext;
6402
6403 QualType Ty;
6404
6405 TypeSourceInfo(QualType ty) : Ty(ty) {}
6406
6407public:
6408 /// Return the type wrapped by this type source info.
6409 QualType getType() const { return Ty; }
6410
6411 /// Return the TypeLoc wrapper for the type source info.
6412 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
6413
6414 /// Override the type stored in this TypeSourceInfo. Use with caution!
6415 void overrideType(QualType T) { Ty = T; }
6416};
6417
6418// Inline function definitions.
6419
6420inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
6421 SplitQualType desugar =
6422 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
6423 desugar.Quals.addConsistentQualifiers(Quals);
6424 return desugar;
6425}
6426
6427inline const Type *QualType::getTypePtr() const {
6428 return getCommonPtr()->BaseType;
6429}
6430
6431inline const Type *QualType::getTypePtrOrNull() const {
6432 return (isNull() ? nullptr : getCommonPtr()->BaseType);
6433}
6434
6435inline SplitQualType QualType::split() const {
6436 if (!hasLocalNonFastQualifiers())
6437 return SplitQualType(getTypePtrUnsafe(),
6438 Qualifiers::fromFastMask(getLocalFastQualifiers()));
6439
6440 const ExtQuals *eq = getExtQualsUnsafe();
6441 Qualifiers qs = eq->getQualifiers();
6442 qs.addFastQualifiers(getLocalFastQualifiers());
6443 return SplitQualType(eq->getBaseType(), qs);
6444}
6445
6446inline Qualifiers QualType::getLocalQualifiers() const {
6447 Qualifiers Quals;
6448 if (hasLocalNonFastQualifiers())
6449 Quals = getExtQualsUnsafe()->getQualifiers();
6450 Quals.addFastQualifiers(getLocalFastQualifiers());
6451 return Quals;
6452}
6453
6454inline Qualifiers QualType::getQualifiers() const {
6455 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
6456 quals.addFastQualifiers(getLocalFastQualifiers());
6457 return quals;
6458}
6459
6460inline unsigned QualType::getCVRQualifiers() const {
6461 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
6462 cvr |= getLocalCVRQualifiers();
6463 return cvr;
6464}
6465
6466inline QualType QualType::getCanonicalType() const {
6467 QualType canon = getCommonPtr()->CanonicalType;
6468 return canon.withFastQualifiers(getLocalFastQualifiers());
6469}
6470
6471inline bool QualType::isCanonical() const {
6472 return getTypePtr()->isCanonicalUnqualified();
6473}
6474
6475inline bool QualType::isCanonicalAsParam() const {
6476 if (!isCanonical()) return false;
6477 if (hasLocalQualifiers()) return false;
6478
6479 const Type *T = getTypePtr();
6480 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
6481 return false;
6482
6483 return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6484}
6485
6486inline bool QualType::isConstQualified() const {
6487 return isLocalConstQualified() ||
6488 getCommonPtr()->CanonicalType.isLocalConstQualified();
6489}
6490
6491inline bool QualType::isRestrictQualified() const {
6492 return isLocalRestrictQualified() ||
6493 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6494}
6495
6496
6497inline bool QualType::isVolatileQualified() const {
6498 return isLocalVolatileQualified() ||
6499 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6500}
6501
6502inline bool QualType::hasQualifiers() const {
6503 return hasLocalQualifiers() ||
6504 getCommonPtr()->CanonicalType.hasLocalQualifiers();
6505}
6506
6507inline QualType QualType::getUnqualifiedType() const {
6508 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6509 return QualType(getTypePtr(), 0);
6510
6511 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6512}
6513
6514inline SplitQualType QualType::getSplitUnqualifiedType() const {
6515 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6516 return split();
6517
6518 return getSplitUnqualifiedTypeImpl(*this);
6519}
6520
6521inline void QualType::removeLocalConst() {
6522 removeLocalFastQualifiers(Qualifiers::Const);
6523}
6524
6525inline void QualType::removeLocalRestrict() {
6526 removeLocalFastQualifiers(Qualifiers::Restrict);
6527}
6528
6529inline void QualType::removeLocalVolatile() {
6530 removeLocalFastQualifiers(Qualifiers::Volatile);
6531}
6532
6533inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
6534 assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((void)0);
6535 static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
6536 "Fast bits differ from CVR bits!");
6537
6538 // Fast path: we don't need to touch the slow qualifiers.
6539 removeLocalFastQualifiers(Mask);
6540}
6541
6542/// Check if this type has any address space qualifier.
6543inline bool QualType::hasAddressSpace() const {
6544 return getQualifiers().hasAddressSpace();
6545}
6546
6547/// Return the address space of this type.
6548inline LangAS QualType::getAddressSpace() const {
6549 return getQualifiers().getAddressSpace();
6550}
6551
6552/// Return the gc attribute of this type.
6553inline Qualifiers::GC QualType::getObjCGCAttr() const {
6554 return getQualifiers().getObjCGCAttr();
6555}
6556
6557inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
6558 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6559 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
6560 return false;
6561}
6562
6563inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
6564 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6565 return hasNonTrivialToPrimitiveDestructCUnion(RD);
6566 return false;
6567}
6568
6569inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
6570 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6571 return hasNonTrivialToPrimitiveCopyCUnion(RD);
6572 return false;
6573}
6574
6575inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
6576 if (const auto *PT = t.getAs<PointerType>()) {
6577 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
6578 return FT->getExtInfo();
6579 } else if (const auto *FT = t.getAs<FunctionType>())
6580 return FT->getExtInfo();
6581
6582 return FunctionType::ExtInfo();
6583}
6584
6585inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
6586 return getFunctionExtInfo(*t);
6587}
6588
6589/// Determine whether this type is more
6590/// qualified than the Other type. For example, "const volatile int"
6591/// is more qualified than "const int", "volatile int", and
6592/// "int". However, it is not more qualified than "const volatile
6593/// int".
6594inline bool QualType::isMoreQualifiedThan(QualType other) const {
6595 Qualifiers MyQuals = getQualifiers();
6596 Qualifiers OtherQuals = other.getQualifiers();
6597 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6598}
6599
6600/// Determine whether this type is at last
6601/// as qualified as the Other type. For example, "const volatile
6602/// int" is at least as qualified as "const int", "volatile int",
6603/// "int", and "const volatile int".
6604inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
6605 Qualifiers OtherQuals = other.getQualifiers();
6606
6607 // Ignore __unaligned qualifier if this type is a void.
6608 if (getUnqualifiedType()->isVoidType())
6609 OtherQuals.removeUnaligned();
6610
6611 return getQualifiers().compatiblyIncludes(OtherQuals);
6612}
6613
6614/// If Type is a reference type (e.g., const
6615/// int&), returns the type that the reference refers to ("const
6616/// int"). Otherwise, returns the type itself. This routine is used
6617/// throughout Sema to implement C++ 5p6:
6618///
6619/// If an expression initially has the type "reference to T" (8.3.2,
6620/// 8.5.3), the type is adjusted to "T" prior to any further
6621/// analysis, the expression designates the object or function
6622/// denoted by the reference, and the expression is an lvalue.
6623inline QualType QualType::getNonReferenceType() const {
6624 if (const auto *RefType = (*this)->getAs<ReferenceType>())
6625 return RefType->getPointeeType();
6626 else
6627 return *this;
6628}
6629
6630inline bool QualType::isCForbiddenLValueType() const {
6631 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
6632 getTypePtr()->isFunctionType());
6633}
6634
6635/// Tests whether the type is categorized as a fundamental type.
6636///
6637/// \returns True for types specified in C++0x [basic.fundamental].
6638inline bool Type::isFundamentalType() const {
6639 return isVoidType() ||
6640 isNullPtrType() ||
6641 // FIXME: It's really annoying that we don't have an
6642 // 'isArithmeticType()' which agrees with the standard definition.
6643 (isArithmeticType() && !isEnumeralType());
6644}
6645
6646/// Tests whether the type is categorized as a compound type.
6647///
6648/// \returns True for types specified in C++0x [basic.compound].
6649inline bool Type::isCompoundType() const {
6650 // C++0x [basic.compound]p1:
6651 // Compound types can be constructed in the following ways:
6652 // -- arrays of objects of a given type [...];
6653 return isArrayType() ||
6654 // -- functions, which have parameters of given types [...];
6655 isFunctionType() ||
6656 // -- pointers to void or objects or functions [...];
6657 isPointerType() ||
6658 // -- references to objects or functions of a given type. [...]
6659 isReferenceType() ||
6660 // -- classes containing a sequence of objects of various types, [...];
6661 isRecordType() ||
6662 // -- unions, which are classes capable of containing objects of different
6663 // types at different times;
6664 isUnionType() ||
6665 // -- enumerations, which comprise a set of named constant values. [...];
6666 isEnumeralType() ||
6667 // -- pointers to non-static class members, [...].
6668 isMemberPointerType();
6669}
6670
6671inline bool Type::isFunctionType() const {
6672 return isa<FunctionType>(CanonicalType);
6673}
6674
6675inline bool Type::isPointerType() const {
6676 return isa<PointerType>(CanonicalType);
6677}
6678
6679inline bool Type::isAnyPointerType() const {
6680 return isPointerType() || isObjCObjectPointerType();
6681}
6682
6683inline bool Type::isBlockPointerType() const {
6684 return isa<BlockPointerType>(CanonicalType);
6685}
6686
6687inline bool Type::isReferenceType() const {
6688 return isa<ReferenceType>(CanonicalType);
6689}
6690
6691inline bool Type::isLValueReferenceType() const {
6692 return isa<LValueReferenceType>(CanonicalType);
6693}
6694
6695inline bool Type::isRValueReferenceType() const {
6696 return isa<RValueReferenceType>(CanonicalType);
6697}
6698
6699inline bool Type::isObjectPointerType() const {
6700 // Note: an "object pointer type" is not the same thing as a pointer to an
6701 // object type; rather, it is a pointer to an object type or a pointer to cv
6702 // void.
6703 if (const auto *T = getAs<PointerType>())
6704 return !T->getPointeeType()->isFunctionType();
6705 else
6706 return false;
6707}
6708
6709inline bool Type::isFunctionPointerType() const {
6710 if (const auto *T = getAs<PointerType>())
6711 return T->getPointeeType()->isFunctionType();
6712 else
6713 return false;
6714}
6715
6716inline bool Type::isFunctionReferenceType() const {
6717 if (const auto *T = getAs<ReferenceType>())
6718 return T->getPointeeType()->isFunctionType();
6719 else
6720 return false;
6721}
6722
6723inline bool Type::isMemberPointerType() const {
6724 return isa<MemberPointerType>(CanonicalType);
6725}
6726
6727inline bool Type::isMemberFunctionPointerType() const {
6728 if (const auto *T = getAs<MemberPointerType>())
6729 return T->isMemberFunctionPointer();
6730 else
6731 return false;
6732}
6733
6734inline bool Type::isMemberDataPointerType() const {
6735 if (const auto *T = getAs<MemberPointerType>())
6736 return T->isMemberDataPointer();
6737 else
6738 return false;
6739}
6740
6741inline bool Type::isArrayType() const {
6742 return isa<ArrayType>(CanonicalType);
6743}
6744
6745inline bool Type::isConstantArrayType() const {
6746 return isa<ConstantArrayType>(CanonicalType);
6747}
6748
6749inline bool Type::isIncompleteArrayType() const {
6750 return isa<IncompleteArrayType>(CanonicalType);
6751}
6752
6753inline bool Type::isVariableArrayType() const {
6754 return isa<VariableArrayType>(CanonicalType);
6755}
6756
6757inline bool Type::isDependentSizedArrayType() const {
6758 return isa<DependentSizedArrayType>(CanonicalType);
6759}
6760
6761inline bool Type::isBuiltinType() const {
6762 return isa<BuiltinType>(CanonicalType);
6763}
6764
6765inline bool Type::isRecordType() const {
6766 return isa<RecordType>(CanonicalType);
6767}
6768
6769inline bool Type::isEnumeralType() const {
6770 return isa<EnumType>(CanonicalType);
6771}
6772
6773inline bool Type::isAnyComplexType() const {
6774 return isa<ComplexType>(CanonicalType);
6775}
6776
6777inline bool Type::isVectorType() const {
6778 return isa<VectorType>(CanonicalType);
6779}
6780
6781inline bool Type::isExtVectorType() const {
6782 return isa<ExtVectorType>(CanonicalType);
6783}
6784
6785inline bool Type::isMatrixType() const {
6786 return isa<MatrixType>(CanonicalType);
6787}
6788
6789inline bool Type::isConstantMatrixType() const {
6790 return isa<ConstantMatrixType>(CanonicalType);
6791}
6792
6793inline bool Type::isDependentAddressSpaceType() const {
6794 return isa<DependentAddressSpaceType>(CanonicalType);
6795}
6796
6797inline bool Type::isObjCObjectPointerType() const {
6798 return isa<ObjCObjectPointerType>(CanonicalType);
6799}
6800
6801inline bool Type::isObjCObjectType() const {
6802 return isa<ObjCObjectType>(CanonicalType);
6803}
6804
6805inline bool Type::isObjCObjectOrInterfaceType() const {
6806 return isa<ObjCInterfaceType>(CanonicalType) ||
6807 isa<ObjCObjectType>(CanonicalType);
6808}
6809
6810inline bool Type::isAtomicType() const {
6811 return isa<AtomicType>(CanonicalType);
6812}
6813
6814inline bool Type::isUndeducedAutoType() const {
6815 return isa<AutoType>(CanonicalType);
6816}
6817
6818inline bool Type::isObjCQualifiedIdType() const {
6819 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6820 return OPT->isObjCQualifiedIdType();
6821 return false;
6822}
6823
6824inline bool Type::isObjCQualifiedClassType() const {
6825 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6826 return OPT->isObjCQualifiedClassType();
6827 return false;
6828}
6829
6830inline bool Type::isObjCIdType() const {
6831 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6832 return OPT->isObjCIdType();
6833 return false;
6834}
6835
6836inline bool Type::isObjCClassType() const {
6837 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6838 return OPT->isObjCClassType();
6839 return false;
6840}
6841
6842inline bool Type::isObjCSelType() const {
6843 if (const auto *OPT = getAs<PointerType>())
6844 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
6845 return false;
6846}
6847
6848inline bool Type::isObjCBuiltinType() const {
6849 return isObjCIdType() || isObjCClassType() || isObjCSelType();
6850}
6851
6852inline bool Type::isDecltypeType() const {
6853 return isa<DecltypeType>(this);
6854}
6855
6856#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6857 inline bool Type::is##Id##Type() const { \
6858 return isSpecificBuiltinType(BuiltinType::Id); \
6859 }
6860#include "clang/Basic/OpenCLImageTypes.def"
6861
6862inline bool Type::isSamplerT() const {
6863 return isSpecificBuiltinType(BuiltinType::OCLSampler);
6864}
6865
6866inline bool Type::isEventT() const {
6867 return isSpecificBuiltinType(BuiltinType::OCLEvent);
6868}
6869
6870inline bool Type::isClkEventT() const {
6871 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6872}
6873
6874inline bool Type::isQueueT() const {
6875 return isSpecificBuiltinType(BuiltinType::OCLQueue);
6876}
6877
6878inline bool Type::isReserveIDT() const {
6879 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6880}
6881
6882inline bool Type::isImageType() const {
6883#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
6884 return
6885#include "clang/Basic/OpenCLImageTypes.def"
6886 false; // end boolean or operation
6887}
6888
6889inline bool Type::isPipeType() const {
6890 return isa<PipeType>(CanonicalType);
6891}
6892
6893inline bool Type::isExtIntType() const {
6894 return isa<ExtIntType>(CanonicalType);
6895}
6896
6897#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6898 inline bool Type::is##Id##Type() const { \
6899 return isSpecificBuiltinType(BuiltinType::Id); \
6900 }
6901#include "clang/Basic/OpenCLExtensionTypes.def"
6902
6903inline bool Type::isOCLIntelSubgroupAVCType() const {
6904#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
6905 isOCLIntelSubgroupAVC##Id##Type() ||
6906 return
6907#include "clang/Basic/OpenCLExtensionTypes.def"
6908 false; // end of boolean or operation
6909}
6910
6911inline bool Type::isOCLExtOpaqueType() const {
6912#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
6913 return
6914#include "clang/Basic/OpenCLExtensionTypes.def"
6915 false; // end of boolean or operation
6916}
6917
6918inline bool Type::isOpenCLSpecificType() const {
6919 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
6920 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6921}
6922
6923inline bool Type::isTemplateTypeParmType() const {
6924 return isa<TemplateTypeParmType>(CanonicalType);
6925}
6926
6927inline bool Type::isSpecificBuiltinType(unsigned K) const {
6928 if (const BuiltinType *BT = getAs<BuiltinType>()) {
6929 return BT->getKind() == static_cast<BuiltinType::Kind>(K);
6930 }
6931 return false;
6932}
6933
6934inline bool Type::isPlaceholderType() const {
6935 if (const auto *BT
65.1
'BT' is null
65.1
'BT' is null
65.1
'BT' is null
65.1
'BT' is null
65.1
'BT' is null
 = dyn_cast<BuiltinType>(this))
65
←
Assuming the object is not a 'BuiltinType'
→
66
←
Taking false branch
→
6936 return BT->isPlaceholderType();
6937 return false;
67
←
Returning zero, which participates in a condition later
→
6938}
6939
6940inline const BuiltinType *Type::getAsPlaceholderType() const {
6941 if (const auto *BT = dyn_cast<BuiltinType>(this))
6942 if (BT->isPlaceholderType())
6943 return BT;
6944 return nullptr;
6945}
6946
6947inline bool Type::isSpecificPlaceholderType(unsigned K) const {
6948 assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((void)0);
6949 return isSpecificBuiltinType(K);
6950}
6951
6952inline bool Type::isNonOverloadPlaceholderType() const {
6953 if (const auto *BT = dyn_cast<BuiltinType>(this))
6954 return BT->isNonOverloadPlaceholderType();
6955 return false;
6956}
6957
6958inline bool Type::isVoidType() const {
6959 return isSpecificBuiltinType(BuiltinType::Void);
6960}
6961
6962inline bool Type::isHalfType() const {
6963 // FIXME: Should we allow complex __fp16? Probably not.
6964 return isSpecificBuiltinType(BuiltinType::Half);
6965}
6966
6967inline bool Type::isFloat16Type() const {
6968 return isSpecificBuiltinType(BuiltinType::Float16);
6969}
6970
6971inline bool Type::isBFloat16Type() const {
6972 return isSpecificBuiltinType(BuiltinType::BFloat16);
6973}
6974
6975inline bool Type::isFloat128Type() const {
6976 return isSpecificBuiltinType(BuiltinType::Float128);
6977}
6978
6979inline bool Type::isNullPtrType() const {
6980 return isSpecificBuiltinType(BuiltinType::NullPtr);
6981}
6982
6983bool IsEnumDeclComplete(EnumDecl *);
6984bool IsEnumDeclScoped(EnumDecl *);
6985
6986inline bool Type::isIntegerType() const {
6987 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6988 return BT->getKind() >= BuiltinType::Bool &&
6989 BT->getKind() <= BuiltinType::Int128;
6990 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
6991 // Incomplete enum types are not treated as integer types.
6992 // FIXME: In C++, enum types are never integer types.
6993 return IsEnumDeclComplete(ET->getDecl()) &&
6994 !IsEnumDeclScoped(ET->getDecl());
6995 }
6996 return isExtIntType();
6997}
6998
6999inline bool Type::isFixedPointType() const {
7000 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7001 return BT->getKind() >= BuiltinType::ShortAccum &&
7002 BT->getKind() <= BuiltinType::SatULongFract;
7003 }
7004 return false;
7005}
7006
7007inline bool Type::isFixedPointOrIntegerType() const {
7008 return isFixedPointType() || isIntegerType();
7009}
7010
7011inline bool Type::isSaturatedFixedPointType() const {
7012 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7013 return BT->getKind() >= BuiltinType::SatShortAccum &&
7014 BT->getKind() <= BuiltinType::SatULongFract;
7015 }
7016 return false;
7017}
7018
7019inline bool Type::isUnsaturatedFixedPointType() const {
7020 return isFixedPointType() && !isSaturatedFixedPointType();
7021}
7022
7023inline bool Type::isSignedFixedPointType() const {
7024 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7025 return ((BT->getKind() >= BuiltinType::ShortAccum &&
7026 BT->getKind() <= BuiltinType::LongAccum) ||
7027 (BT->getKind() >= BuiltinType::ShortFract &&
7028 BT->getKind() <= BuiltinType::LongFract) ||
7029 (BT->getKind() >= BuiltinType::SatShortAccum &&
7030 BT->getKind() <= BuiltinType::SatLongAccum) ||
7031 (BT->getKind() >= BuiltinType::SatShortFract &&
7032 BT->getKind() <= BuiltinType::SatLongFract));
7033 }
7034 return false;
7035}
7036
7037inline bool Type::isUnsignedFixedPointType() const {
7038 return isFixedPointType() && !isSignedFixedPointType();
7039}
7040
7041inline bool Type::isScalarType() const {
7042 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7043 return BT->getKind() > BuiltinType::Void &&
7044 BT->getKind() <= BuiltinType::NullPtr;
7045 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
7046 // Enums are scalar types, but only if they are defined. Incomplete enums
7047 // are not treated as scalar types.
7048 return IsEnumDeclComplete(ET->getDecl());
7049 return isa<PointerType>(CanonicalType) ||
7050 isa<BlockPointerType>(CanonicalType) ||
7051 isa<MemberPointerType>(CanonicalType) ||
7052 isa<ComplexType>(CanonicalType) ||
7053 isa<ObjCObjectPointerType>(CanonicalType) ||
7054 isExtIntType();
7055}
7056
7057inline bool Type::isIntegralOrEnumerationType() const {
7058 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7059 return BT->getKind() >= BuiltinType::Bool &&
7060 BT->getKind() <= BuiltinType::Int128;
7061
7062 // Check for a complete enum type; incomplete enum types are not properly an
7063 // enumeration type in the sense required here.
7064 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
7065 return IsEnumDeclComplete(ET->getDecl());
7066
7067 return isExtIntType();
7068}
7069
7070inline bool Type::isBooleanType() const {
7071 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7072 return BT->getKind() == BuiltinType::Bool;
7073 return false;
7074}
7075
7076inline bool Type::isUndeducedType() const {
7077 auto *DT = getContainedDeducedType();
7078 return DT && !DT->isDeduced();
7079}
7080
7081/// Determines whether this is a type for which one can define
7082/// an overloaded operator.
7083inline bool Type::isOverloadableType() const {
7084 return isDependentType() || isRecordType() || isEnumeralType();
7085}
7086
7087/// Determines whether this type is written as a typedef-name.
7088inline bool Type::isTypedefNameType() const {
7089 if (getAs<TypedefType>())
7090 return true;
7091 if (auto *TST = getAs<TemplateSpecializationType>())
7092 return TST->isTypeAlias();
7093 return false;
7094}
7095
7096/// Determines whether this type can decay to a pointer type.
7097inline bool Type::canDecayToPointerType() const {
7098 return isFunctionType() || isArrayType();
7099}
7100
7101inline bool Type::hasPointerRepresentation() const {
7102 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
7103 isObjCObjectPointerType() || isNullPtrType());
7104}
7105
7106inline bool Type::hasObjCPointerRepresentation() const {
7107 return isObjCObjectPointerType();
7108}
7109
7110inline const Type *Type::getBaseElementTypeUnsafe() const {
7111 const Type *type = this;
7112 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
7113 type = arrayType->getElementType().getTypePtr();
7114 return type;
7115}
7116
7117inline const Type *Type::getPointeeOrArrayElementType() const {
7118 const Type *type = this;
7119 if (type->isAnyPointerType())
7120 return type->getPointeeType().getTypePtr();
7121 else if (type->isArrayType())
7122 return type->getBaseElementTypeUnsafe();
7123 return type;
7124}
7125/// Insertion operator for partial diagnostics. This allows sending adress
7126/// spaces into a diagnostic with <<.
7127inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7128 LangAS AS) {
7129 PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
7130 DiagnosticsEngine::ArgumentKind::ak_addrspace);
7131 return PD;
7132}
7133
7134/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7135/// into a diagnostic with <<.
7136inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7137 Qualifiers Q) {
7138 PD.AddTaggedVal(Q.getAsOpaqueValue(),
7139 DiagnosticsEngine::ArgumentKind::ak_qual);
7140 return PD;
7141}
7142
7143/// Insertion operator for partial diagnostics. This allows sending QualType's
7144/// into a diagnostic with <<.
7145inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7146 QualType T) {
7147 PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
7148 DiagnosticsEngine::ak_qualtype);
7149 return PD;
7150}
7151
7152// Helper class template that is used by Type::getAs to ensure that one does
7153// not try to look through a qualified type to get to an array type.
7154template <typename T>
7155using TypeIsArrayType =
7156 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
7157 std::is_base_of<ArrayType, T>::value>;
7158
7159// Member-template getAs<specific type>'.
7160template <typename T> const T *Type::getAs() const {
7161 static_assert(!TypeIsArrayType<T>::value,
7162 "ArrayType cannot be used with getAs!");
7163
7164 // If this is directly a T type, return it.
7165 if (const auto *Ty = dyn_cast<T>(this))
7166 return Ty;
7167
7168 // If the canonical form of this type isn't the right kind, reject it.
7169 if (!isa<T>(CanonicalType))
7170 return nullptr;
7171
7172 // If this is a typedef for the type, strip the typedef off without
7173 // losing all typedef information.
7174 return cast<T>(getUnqualifiedDesugaredType());
7175}
7176
7177template <typename T> const T *Type::getAsAdjusted() const {
7178 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
7179
7180 // If this is directly a T type, return it.
7181 if (const auto *Ty = dyn_cast<T>(this))
7182 return Ty;
7183
7184 // If the canonical form of this type isn't the right kind, reject it.
7185 if (!isa<T>(CanonicalType))
7186 return nullptr;
7187
7188 // Strip off type adjustments that do not modify the underlying nature of the
7189 // type.
7190 const Type *Ty = this;
7191 while (Ty) {
7192 if (const auto *A = dyn_cast<AttributedType>(Ty))
7193 Ty = A->getModifiedType().getTypePtr();
7194 else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
7195 Ty = E->desugar().getTypePtr();
7196 else if (const auto *P = dyn_cast<ParenType>(Ty))
7197 Ty = P->desugar().getTypePtr();
7198 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
7199 Ty = A->desugar().getTypePtr();
7200 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
7201 Ty = M->desugar().getTypePtr();
7202 else
7203 break;
7204 }
7205
7206 // Just because the canonical type is correct does not mean we can use cast<>,
7207 // since we may not have stripped off all the sugar down to the base type.
7208 return dyn_cast<T>(Ty);
7209}
7210
7211inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
7212 // If this is directly an array type, return it.
7213 if (const auto *arr = dyn_cast<ArrayType>(this))
7214 return arr;
7215
7216 // If the canonical form of this type isn't the right kind, reject it.
7217 if (!isa<ArrayType>(CanonicalType))
7218 return nullptr;
7219
7220 // If this is a typedef for the type, strip the typedef off without
7221 // losing all typedef information.
7222 return cast<ArrayType>(getUnqualifiedDesugaredType());
7223}
7224
7225template <typename T> const T *Type::castAs() const {
7226 static_assert(!TypeIsArrayType<T>::value,
7227 "ArrayType cannot be used with castAs!");
7228
7229 if (const auto *ty = dyn_cast<T>(this)) return ty;
7230 assert(isa<T>(CanonicalType))((void)0);
7231 return cast<T>(getUnqualifiedDesugaredType());
7232}
7233
7234inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
7235 assert(isa<ArrayType>(CanonicalType))((void)0);
7236 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
7237 return cast<ArrayType>(getUnqualifiedDesugaredType());
7238}
7239
7240DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
7241 QualType CanonicalPtr)
7242 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7243#ifndef NDEBUG1
7244 QualType Adjusted = getAdjustedType();
7245 (void)AttributedType::stripOuterNullability(Adjusted);
7246 assert(isa<PointerType>(Adjusted))((void)0);
7247#endif
7248}
7249
7250QualType DecayedType::getPointeeType() const {
7251 QualType Decayed = getDecayedType();
7252 (void)AttributedType::stripOuterNullability(Decayed);
7253 return cast<PointerType>(Decayed)->getPointeeType();
7254}
7255
7256// Get the decimal string representation of a fixed point type, represented
7257// as a scaled integer.
7258// TODO: At some point, we should change the arguments to instead just accept an
7259// APFixedPoint instead of APSInt and scale.
7260void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
7261 unsigned Scale);
7262
7263} // namespace clang
7264
7265#endif // LLVM_CLANG_AST_TYPE_H
←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include/llvm/ADT/PointerUnion.h

→
1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- 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 PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23
24namespace llvm {
25
26template <typename T> struct PointerUnionTypeSelectorReturn {
27 using Return = T;
28};
29
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35/// using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41 using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46 using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51 PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52 using Return =
53 typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55
56namespace pointer_union_detail {
57 /// Determine the number of bits required to store integers with values < n.
58 /// This is ceil(log2(n)).
59 constexpr int bitsRequired(unsigned n) {
60 return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61 }
62
63 template <typename... Ts> constexpr int lowBitsAvailable() {
64 return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65 }
66
67 /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68 /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69 /// list.
70 template <typename T, typename ...Us> struct TypeIndex;
71 template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72 static constexpr int Index = 0;
73 };
74 template <typename T, typename U, typename... Us>
75 struct TypeIndex<T, U, Us...> {
76 static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77 };
78 template <typename T> struct TypeIndex<T> {
79 static constexpr int Index = 0;
80 };
81
82 /// Find the first type in a list of types.
83 template <typename T, typename...> struct GetFirstType {
84 using type = T;
85 };
86
87 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88 /// for the template arguments.
89 template <typename ...PTs> class PointerUnionUIntTraits {
90 public:
91 static inline void *getAsVoidPointer(void *P) { return P; }
92 static inline void *getFromVoidPointer(void *P) { return P; }
93 static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94 };
95
96 template <typename Derived, typename ValTy, int I, typename ...Types>
97 class PointerUnionMembers;
98
99 template <typename Derived, typename ValTy, int I>
100 class PointerUnionMembers<Derived, ValTy, I> {
101 protected:
102 ValTy Val;
103 PointerUnionMembers() = default;
104 PointerUnionMembers(ValTy Val) : Val(Val) {}
105
106 friend struct PointerLikeTypeTraits<Derived>;
107 };
108
109 template <typename Derived, typename ValTy, int I, typename Type,
110 typename ...Types>
111 class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
112 : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
113 using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
114 public:
115 using Base::Base;
116 PointerUnionMembers() = default;
117 PointerUnionMembers(Type V)
118 : Base(ValTy(const_cast<void *>(
119 PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
120 I)) {}
121
122 using Base::operator=;
123 Derived &operator=(Type V) {
124 this->Val = ValTy(
125 const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
126 I);
127 return static_cast<Derived &>(*this);
128 };
129 };
130}
131
132/// A discriminated union of two or more pointer types, with the discriminator
133/// in the low bit of the pointer.
134///
135/// This implementation is extremely efficient in space due to leveraging the
136/// low bits of the pointer, while exposing a natural and type-safe API.
137///
138/// Common use patterns would be something like this:
139/// PointerUnion<int*, float*> P;
140/// P = (int*)0;
141/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"
142/// X = P.get<int*>(); // ok.
143/// Y = P.get<float*>(); // runtime assertion failure.
144/// Z = P.get<double*>(); // compile time failure.
145/// P = (float*)0;
146/// Y = P.get<float*>(); // ok.
147/// X = P.get<int*>(); // runtime assertion failure.
148template <typename... PTs>
149class PointerUnion
150 : public pointer_union_detail::PointerUnionMembers<
151 PointerUnion<PTs...>,
152 PointerIntPair<
153 void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
154 pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
155 0, PTs...> {
156 // The first type is special because we want to directly cast a pointer to a
157 // default-initialized union to a pointer to the first type. But we don't
158 // want PointerUnion to be a 'template <typename First, typename ...Rest>'
159 // because it's much more convenient to have a name for the whole pack. So
160 // split off the first type here.
161 using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
162 using Base = typename PointerUnion::PointerUnionMembers;
163
164public:
165 PointerUnion() = default;
166
167 PointerUnion(std::nullptr_t) : PointerUnion() {}
168 using Base::Base;
169
170 /// Test if the pointer held in the union is null, regardless of
171 /// which type it is.
172 bool isNull() const { return !this->Val.getPointer(); }
41
←
Assuming the condition is false
→
42
←
Returning zero, which participates in a condition later
→
173
174 explicit operator bool() const { return !isNull(); }
175
176 /// Test if the Union currently holds the type matching T.
177 template <typename T> bool is() const {
178 constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
179 static_assert(Index < sizeof...(PTs),
180 "PointerUnion::is<T> given type not in the union");
181 return this->Val.getInt() == Index;
182 }
183
184 /// Returns the value of the specified pointer type.
185 ///
186 /// If the specified pointer type is incorrect, assert.
187 template <typename T> T get() const {
188 assert(is<T>() && "Invalid accessor called")((void)0);
189 return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
190 }
191
192 /// Returns the current pointer if it is of the specified pointer type,
193 /// otherwise returns null.
194 template <typename T> T dyn_cast() const {
195 if (is<T>())
196 return get<T>();
197 return T();
198 }
199
200 /// If the union is set to the first pointer type get an address pointing to
201 /// it.
202 First const *getAddrOfPtr1() const {
203 return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
204 }
205
206 /// If the union is set to the first pointer type get an address pointing to
207 /// it.
208 First *getAddrOfPtr1() {
209 assert(is<First>() && "Val is not the first pointer")((void)0);
210 assert(((void)0)
211 PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((void)0)
212 this->Val.getPointer() &&((void)0)
213 "Can't get the address because PointerLikeTypeTraits changes the ptr")((void)0);
214 return const_cast<First *>(
215 reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
216 }
217
218 /// Assignment from nullptr which just clears the union.
219 const PointerUnion &operator=(std::nullptr_t) {
220 this->Val.initWithPointer(nullptr);
221 return *this;
222 }
223
224 /// Assignment from elements of the union.
225 using Base::operator=;
226
227 void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
228 static inline PointerUnion getFromOpaqueValue(void *VP) {
229 PointerUnion V;
230 V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
231 return V;
232 }
233};
234
235template <typename ...PTs>
236bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
237 return lhs.getOpaqueValue() == rhs.getOpaqueValue();
238}
239
240template <typename ...PTs>
241bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
242 return lhs.getOpaqueValue() != rhs.getOpaqueValue();
243}
244
245template <typename ...PTs>
246bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
247 return lhs.getOpaqueValue() < rhs.getOpaqueValue();
248}
249
250// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
251// # low bits available = min(PT1bits,PT2bits)-1.
252template <typename ...PTs>
253struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
254 static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
255 return P.getOpaqueValue();
256 }
257
258 static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
259 return PointerUnion<PTs...>::getFromOpaqueValue(P);
260 }
261
262 // The number of bits available are the min of the pointer types minus the
263 // bits needed for the discriminator.
264 static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
265 PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
266};
267
268// Teach DenseMap how to use PointerUnions as keys.
269template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
270 using Union = PointerUnion<PTs...>;
271 using FirstInfo =
272 DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
273
274 static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
275
276 static inline Union getTombstoneKey() {
277 return Union(FirstInfo::getTombstoneKey());
278 }
279
280 static unsigned getHashValue(const Union &UnionVal) {
281 intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
282 return DenseMapInfo<intptr_t>::getHashValue(key);
283 }
284
285 static bool isEqual(const Union &LHS, const Union &RHS) {
286 return LHS == RHS;
287 }
288};
289
290} // end namespace llvm
291
292#endif // LLVM_ADT_POINTERUNION_H
←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/AST/ExprCXX.h

1//===- ExprCXX.h - Classes for representing expressions ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::Expr interface and subclasses for C++ expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_AST_EXPRCXX_H
15#define LLVM_CLANG_AST_EXPRCXX_H
16
17#include "clang/AST/ASTConcept.h"
18#include "clang/AST/ComputeDependence.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclTemplate.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/DependenceFlags.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/NestedNameSpecifier.h"
27#include "clang/AST/OperationKinds.h"
28#include "clang/AST/Stmt.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/TemplateBase.h"
31#include "clang/AST/Type.h"
32#include "clang/AST/UnresolvedSet.h"
33#include "clang/Basic/ExceptionSpecificationType.h"
34#include "clang/Basic/ExpressionTraits.h"
35#include "clang/Basic/LLVM.h"
36#include "clang/Basic/Lambda.h"
37#include "clang/Basic/LangOptions.h"
38#include "clang/Basic/OperatorKinds.h"
39#include "clang/Basic/SourceLocation.h"
40#include "clang/Basic/Specifiers.h"
41#include "clang/Basic/TypeTraits.h"
42#include "llvm/ADT/ArrayRef.h"
43#include "llvm/ADT/None.h"
44#include "llvm/ADT/Optional.h"
45#include "llvm/ADT/PointerUnion.h"
46#include "llvm/ADT/StringRef.h"
47#include "llvm/ADT/iterator_range.h"
48#include "llvm/Support/Casting.h"
49#include "llvm/Support/Compiler.h"
50#include "llvm/Support/TrailingObjects.h"
51#include <cassert>
52#include <cstddef>
53#include <cstdint>
54#include <memory>
55
56namespace clang {
57
58class ASTContext;
59class DeclAccessPair;
60class IdentifierInfo;
61class LambdaCapture;
62class NonTypeTemplateParmDecl;
63class TemplateParameterList;
64
65//===--------------------------------------------------------------------===//
66// C++ Expressions.
67//===--------------------------------------------------------------------===//
68
69/// A call to an overloaded operator written using operator
70/// syntax.
71///
72/// Represents a call to an overloaded operator written using operator
73/// syntax, e.g., "x + y" or "*p". While semantically equivalent to a
74/// normal call, this AST node provides better information about the
75/// syntactic representation of the call.
76///
77/// In a C++ template, this expression node kind will be used whenever
78/// any of the arguments are type-dependent. In this case, the
79/// function itself will be a (possibly empty) set of functions and
80/// function templates that were found by name lookup at template
81/// definition time.
82class CXXOperatorCallExpr final : public CallExpr {
83 friend class ASTStmtReader;
84 friend class ASTStmtWriter;
85
86 SourceRange Range;
87
88 // CXXOperatorCallExpr has some trailing objects belonging
89 // to CallExpr. See CallExpr for the details.
90
91 SourceRange getSourceRangeImpl() const LLVM_READONLY__attribute__((__pure__));
92
93 CXXOperatorCallExpr(OverloadedOperatorKind OpKind, Expr *Fn,
94 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
95 SourceLocation OperatorLoc, FPOptionsOverride FPFeatures,
96 ADLCallKind UsesADL);
97
98 CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
99
100public:
101 static CXXOperatorCallExpr *
102 Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
103 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
104 SourceLocation OperatorLoc, FPOptionsOverride FPFeatures,
105 ADLCallKind UsesADL = NotADL);
106
107 static CXXOperatorCallExpr *CreateEmpty(const ASTContext &Ctx,
108 unsigned NumArgs, bool HasFPFeatures,
109 EmptyShell Empty);
110
111 /// Returns the kind of overloaded operator that this expression refers to.
112 OverloadedOperatorKind getOperator() const {
113 return static_cast<OverloadedOperatorKind>(
114 CXXOperatorCallExprBits.OperatorKind);
115 }
116
117 static bool isAssignmentOp(OverloadedOperatorKind Opc) {
118 return Opc == OO_Equal || Opc == OO_StarEqual || Opc == OO_SlashEqual ||
119 Opc == OO_PercentEqual || Opc == OO_PlusEqual ||
120 Opc == OO_MinusEqual || Opc == OO_LessLessEqual ||
121 Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||
122 Opc == OO_CaretEqual || Opc == OO_PipeEqual;
123 }
124 bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }
125
126 static bool isComparisonOp(OverloadedOperatorKind Opc) {
127 switch (Opc) {
128 case OO_EqualEqual:
129 case OO_ExclaimEqual:
130 case OO_Greater:
131 case OO_GreaterEqual:
132 case OO_Less:
133 case OO_LessEqual:
134 case OO_Spaceship:
135 return true;
136 default:
137 return false;
138 }
139 }
140 bool isComparisonOp() const { return isComparisonOp(getOperator()); }
141
142 /// Is this written as an infix binary operator?
143 bool isInfixBinaryOp() const;
144
145 /// Returns the location of the operator symbol in the expression.
146 ///
147 /// When \c getOperator()==OO_Call, this is the location of the right
148 /// parentheses; when \c getOperator()==OO_Subscript, this is the location
149 /// of the right bracket.
150 SourceLocation getOperatorLoc() const { return getRParenLoc(); }
151
152 SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
153 OverloadedOperatorKind Operator = getOperator();
154 return (Operator < OO_Plus || Operator >= OO_Arrow ||
155 Operator == OO_PlusPlus || Operator == OO_MinusMinus)
156 ? getBeginLoc()
157 : getOperatorLoc();
158 }
159
160 SourceLocation getBeginLoc() const { return Range.getBegin(); }
161 SourceLocation getEndLoc() const { return Range.getEnd(); }
162 SourceRange getSourceRange() const { return Range; }
163
164 static bool classof(const Stmt *T) {
165 return T->getStmtClass() == CXXOperatorCallExprClass;
166 }
167};
168
169/// Represents a call to a member function that
170/// may be written either with member call syntax (e.g., "obj.func()"
171/// or "objptr->func()") or with normal function-call syntax
172/// ("func()") within a member function that ends up calling a member
173/// function. The callee in either case is a MemberExpr that contains
174/// both the object argument and the member function, while the
175/// arguments are the arguments within the parentheses (not including
176/// the object argument).
177class CXXMemberCallExpr final : public CallExpr {
178 // CXXMemberCallExpr has some trailing objects belonging
179 // to CallExpr. See CallExpr for the details.
180
181 CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
182 ExprValueKind VK, SourceLocation RP,
183 FPOptionsOverride FPOptions, unsigned MinNumArgs);
184
185 CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
186
187public:
188 static CXXMemberCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
189 ArrayRef<Expr *> Args, QualType Ty,
190 ExprValueKind VK, SourceLocation RP,
191 FPOptionsOverride FPFeatures,
192 unsigned MinNumArgs = 0);
193
194 static CXXMemberCallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
195 bool HasFPFeatures, EmptyShell Empty);
196
197 /// Retrieve the implicit object argument for the member call.
198 ///
199 /// For example, in "x.f(5)", this returns the sub-expression "x".
200 Expr *getImplicitObjectArgument() const;
201
202 /// Retrieve the type of the object argument.
203 ///
204 /// Note that this always returns a non-pointer type.
205 QualType getObjectType() const;
206
207 /// Retrieve the declaration of the called method.
208 CXXMethodDecl *getMethodDecl() const;
209
210 /// Retrieve the CXXRecordDecl for the underlying type of
211 /// the implicit object argument.
212 ///
213 /// Note that this is may not be the same declaration as that of the class
214 /// context of the CXXMethodDecl which this function is calling.
215 /// FIXME: Returns 0 for member pointer call exprs.
216 CXXRecordDecl *getRecordDecl() const;
217
218 SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
219 SourceLocation CLoc = getCallee()->getExprLoc();
220 if (CLoc.isValid())
221 return CLoc;
222
223 return getBeginLoc();
224 }
225
226 static bool classof(const Stmt *T) {
227 return T->getStmtClass() == CXXMemberCallExprClass;
228 }
229};
230
231/// Represents a call to a CUDA kernel function.
232class CUDAKernelCallExpr final : public CallExpr {
233 friend class ASTStmtReader;
234
235 enum { CONFIG, END_PREARG };
236
237 // CUDAKernelCallExpr has some trailing objects belonging
238 // to CallExpr. See CallExpr for the details.
239
240 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
241 QualType Ty, ExprValueKind VK, SourceLocation RP,
242 FPOptionsOverride FPFeatures, unsigned MinNumArgs);
243
244 CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
245
246public:
247 static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
248 CallExpr *Config, ArrayRef<Expr *> Args,
249 QualType Ty, ExprValueKind VK,
250 SourceLocation RP,
251 FPOptionsOverride FPFeatures,
252 unsigned MinNumArgs = 0);
253
254 static CUDAKernelCallExpr *CreateEmpty(const ASTContext &Ctx,
255 unsigned NumArgs, bool HasFPFeatures,
256 EmptyShell Empty);
257
258 const CallExpr *getConfig() const {
259 return cast_or_null<CallExpr>(getPreArg(CONFIG));
260 }
261 CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
262
263 static bool classof(const Stmt *T) {
264 return T->getStmtClass() == CUDAKernelCallExprClass;
265 }
266};
267
268/// A rewritten comparison expression that was originally written using
269/// operator syntax.
270///
271/// In C++20, the following rewrites are performed:
272/// - <tt>a == b</tt> -> <tt>b == a</tt>
273/// - <tt>a != b</tt> -> <tt>!(a == b)</tt>
274/// - <tt>a != b</tt> -> <tt>!(b == a)</tt>
275/// - For \c \@ in \c <, \c <=, \c >, \c >=, \c <=>:
276/// - <tt>a @ b</tt> -> <tt>(a <=> b) @ 0</tt>
277/// - <tt>a @ b</tt> -> <tt>0 @ (b <=> a)</tt>
278///
279/// This expression provides access to both the original syntax and the
280/// rewritten expression.
281///
282/// Note that the rewritten calls to \c ==, \c <=>, and \c \@ are typically
283/// \c CXXOperatorCallExprs, but could theoretically be \c BinaryOperators.
284class CXXRewrittenBinaryOperator : public Expr {
285 friend class ASTStmtReader;
286
287 /// The rewritten semantic form.
288 Stmt *SemanticForm;
289
290public:
291 CXXRewrittenBinaryOperator(Expr *SemanticForm, bool IsReversed)
292 : Expr(CXXRewrittenBinaryOperatorClass, SemanticForm->getType(),
293 SemanticForm->getValueKind(), SemanticForm->getObjectKind()),
294 SemanticForm(SemanticForm) {
295 CXXRewrittenBinaryOperatorBits.IsReversed = IsReversed;
296 setDependence(computeDependence(this));
297 }
298 CXXRewrittenBinaryOperator(EmptyShell Empty)
299 : Expr(CXXRewrittenBinaryOperatorClass, Empty), SemanticForm() {}
300
301 /// Get an equivalent semantic form for this expression.
302 Expr *getSemanticForm() { return cast<Expr>(SemanticForm); }
303 const Expr *getSemanticForm() const { return cast<Expr>(SemanticForm); }
304
305 struct DecomposedForm {
306 /// The original opcode, prior to rewriting.
307 BinaryOperatorKind Opcode;
308 /// The original left-hand side.
309 const Expr *LHS;
310 /// The original right-hand side.
311 const Expr *RHS;
312 /// The inner \c == or \c <=> operator expression.
313 const Expr *InnerBinOp;
314 };
315
316 /// Decompose this operator into its syntactic form.
317 DecomposedForm getDecomposedForm() const LLVM_READONLY__attribute__((__pure__));
318
319 /// Determine whether this expression was rewritten in reverse form.
320 bool isReversed() const { return CXXRewrittenBinaryOperatorBits.IsReversed; }
321
322 BinaryOperatorKind getOperator() const { return getDecomposedForm().Opcode; }
323 BinaryOperatorKind getOpcode() const { return getOperator(); }
324 static StringRef getOpcodeStr(BinaryOperatorKind Op) {
325 return BinaryOperator::getOpcodeStr(Op);
326 }
327 StringRef getOpcodeStr() const {
328 return BinaryOperator::getOpcodeStr(getOpcode());
329 }
330 bool isComparisonOp() const { return true; }
331 bool isAssignmentOp() const { return false; }
332
333 const Expr *getLHS() const { return getDecomposedForm().LHS; }
334 const Expr *getRHS() const { return getDecomposedForm().RHS; }
335
336 SourceLocation getOperatorLoc() const LLVM_READONLY__attribute__((__pure__)) {
337 return getDecomposedForm().InnerBinOp->getExprLoc();
338 }
339 SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return getOperatorLoc(); }
340
341 /// Compute the begin and end locations from the decomposed form.
342 /// The locations of the semantic form are not reliable if this is
343 /// a reversed expression.
344 //@{
345 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
346 return getDecomposedForm().LHS->getBeginLoc();
347 }
348 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
349 return getDecomposedForm().RHS->getEndLoc();
350 }
351 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
352 DecomposedForm DF = getDecomposedForm();
353 return SourceRange(DF.LHS->getBeginLoc(), DF.RHS->getEndLoc());
354 }
355 //@}
356
357 child_range children() {
358 return child_range(&SemanticForm, &SemanticForm + 1);
359 }
360
361 static bool classof(const Stmt *T) {
362 return T->getStmtClass() == CXXRewrittenBinaryOperatorClass;
363 }
364};
365
366/// Abstract class common to all of the C++ "named"/"keyword" casts.
367///
368/// This abstract class is inherited by all of the classes
369/// representing "named" casts: CXXStaticCastExpr for \c static_cast,
370/// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
371/// reinterpret_cast, CXXConstCastExpr for \c const_cast and
372/// CXXAddrspaceCastExpr for addrspace_cast (in OpenCL).
373class CXXNamedCastExpr : public ExplicitCastExpr {
374private:
375 // the location of the casting op
376 SourceLocation Loc;
377
378 // the location of the right parenthesis
379 SourceLocation RParenLoc;
380
381 // range for '<' '>'
382 SourceRange AngleBrackets;
383
384protected:
385 friend class ASTStmtReader;
386
387 CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK, CastKind kind,
388 Expr *op, unsigned PathSize, bool HasFPFeatures,
389 TypeSourceInfo *writtenTy, SourceLocation l,
390 SourceLocation RParenLoc, SourceRange AngleBrackets)
391 : ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, HasFPFeatures,
392 writtenTy),
393 Loc(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}
394
395 explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize,
396 bool HasFPFeatures)
397 : ExplicitCastExpr(SC, Shell, PathSize, HasFPFeatures) {}
398
399public:
400 const char *getCastName() const;
401
402 /// Retrieve the location of the cast operator keyword, e.g.,
403 /// \c static_cast.
404 SourceLocation getOperatorLoc() const { return Loc; }
405
406 /// Retrieve the location of the closing parenthesis.
407 SourceLocation getRParenLoc() const { return RParenLoc; }
408
409 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
410 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
411 SourceRange getAngleBrackets() const LLVM_READONLY__attribute__((__pure__)) { return AngleBrackets; }
412
413 static bool classof(const Stmt *T) {
414 switch (T->getStmtClass()) {
415 case CXXStaticCastExprClass:
416 case CXXDynamicCastExprClass:
417 case CXXReinterpretCastExprClass:
418 case CXXConstCastExprClass:
419 case CXXAddrspaceCastExprClass:
420 return true;
421 default:
422 return false;
423 }
424 }
425};
426
427/// A C++ \c static_cast expression (C++ [expr.static.cast]).
428///
429/// This expression node represents a C++ static cast, e.g.,
430/// \c static_cast<int>(1.0).
431class CXXStaticCastExpr final
432 : public CXXNamedCastExpr,
433 private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,
434 FPOptionsOverride> {
435 CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
436 unsigned pathSize, TypeSourceInfo *writtenTy,
437 FPOptionsOverride FPO, SourceLocation l,
438 SourceLocation RParenLoc, SourceRange AngleBrackets)
439 : CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize,
440 FPO.requiresTrailingStorage(), writtenTy, l, RParenLoc,
441 AngleBrackets) {
442 if (hasStoredFPFeatures())
443 *getTrailingFPFeatures() = FPO;
444 }
445
446 explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize,
447 bool HasFPFeatures)
448 : CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize,
449 HasFPFeatures) {}
450
451 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
452 return path_size();
453 }
454
455public:
456 friend class CastExpr;
457 friend TrailingObjects;
458
459 static CXXStaticCastExpr *
460 Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K,
461 Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written,
462 FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc,
463 SourceRange AngleBrackets);
464 static CXXStaticCastExpr *CreateEmpty(const ASTContext &Context,
465 unsigned PathSize, bool hasFPFeatures);
466
467 static bool classof(const Stmt *T) {
468 return T->getStmtClass() == CXXStaticCastExprClass;
469 }
470};
471
472/// A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
473///
474/// This expression node represents a dynamic cast, e.g.,
475/// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
476/// check to determine how to perform the type conversion.
477class CXXDynamicCastExpr final
478 : public CXXNamedCastExpr,
479 private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
480 CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind, Expr *op,
481 unsigned pathSize, TypeSourceInfo *writtenTy,
482 SourceLocation l, SourceLocation RParenLoc,
483 SourceRange AngleBrackets)
484 : CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize,
485 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
486 AngleBrackets) {}
487
488 explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
489 : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize,
490 /*HasFPFeatures*/ false) {}
491
492public:
493 friend class CastExpr;
494 friend TrailingObjects;
495
496 static CXXDynamicCastExpr *Create(const ASTContext &Context, QualType T,
497 ExprValueKind VK, CastKind Kind, Expr *Op,
498 const CXXCastPath *Path,
499 TypeSourceInfo *Written, SourceLocation L,
500 SourceLocation RParenLoc,
501 SourceRange AngleBrackets);
502
503 static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context,
504 unsigned pathSize);
505
506 bool isAlwaysNull() const;
507
508 static bool classof(const Stmt *T) {
509 return T->getStmtClass() == CXXDynamicCastExprClass;
510 }
511};
512
513/// A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
514///
515/// This expression node represents a reinterpret cast, e.g.,
516/// @c reinterpret_cast<int>(VoidPtr).
517///
518/// A reinterpret_cast provides a differently-typed view of a value but
519/// (in Clang, as in most C++ implementations) performs no actual work at
520/// run time.
521class CXXReinterpretCastExpr final
522 : public CXXNamedCastExpr,
523 private llvm::TrailingObjects<CXXReinterpretCastExpr,
524 CXXBaseSpecifier *> {
525 CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
526 unsigned pathSize, TypeSourceInfo *writtenTy,
527 SourceLocation l, SourceLocation RParenLoc,
528 SourceRange AngleBrackets)
529 : CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op,
530 pathSize, /*HasFPFeatures*/ false, writtenTy, l,
531 RParenLoc, AngleBrackets) {}
532
533 CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
534 : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize,
535 /*HasFPFeatures*/ false) {}
536
537public:
538 friend class CastExpr;
539 friend TrailingObjects;
540
541 static CXXReinterpretCastExpr *Create(const ASTContext &Context, QualType T,
542 ExprValueKind VK, CastKind Kind,
543 Expr *Op, const CXXCastPath *Path,
544 TypeSourceInfo *WrittenTy, SourceLocation L,
545 SourceLocation RParenLoc,
546 SourceRange AngleBrackets);
547 static CXXReinterpretCastExpr *CreateEmpty(const ASTContext &Context,
548 unsigned pathSize);
549
550 static bool classof(const Stmt *T) {
551 return T->getStmtClass() == CXXReinterpretCastExprClass;
552 }
553};
554
555/// A C++ \c const_cast expression (C++ [expr.const.cast]).
556///
557/// This expression node represents a const cast, e.g.,
558/// \c const_cast<char*>(PtrToConstChar).
559///
560/// A const_cast can remove type qualifiers but does not change the underlying
561/// value.
562class CXXConstCastExpr final
563 : public CXXNamedCastExpr,
564 private llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {
565 CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
566 TypeSourceInfo *writtenTy, SourceLocation l,
567 SourceLocation RParenLoc, SourceRange AngleBrackets)
568 : CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op, 0,
569 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
570 AngleBrackets) {}
571
572 explicit CXXConstCastExpr(EmptyShell Empty)
573 : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0,
574 /*HasFPFeatures*/ false) {}
575
576public:
577 friend class CastExpr;
578 friend TrailingObjects;
579
580 static CXXConstCastExpr *Create(const ASTContext &Context, QualType T,
581 ExprValueKind VK, Expr *Op,
582 TypeSourceInfo *WrittenTy, SourceLocation L,
583 SourceLocation RParenLoc,
584 SourceRange AngleBrackets);
585 static CXXConstCastExpr *CreateEmpty(const ASTContext &Context);
586
587 static bool classof(const Stmt *T) {
588 return T->getStmtClass() == CXXConstCastExprClass;
589 }
590};
591
592/// A C++ addrspace_cast expression (currently only enabled for OpenCL).
593///
594/// This expression node represents a cast between pointers to objects in
595/// different address spaces e.g.,
596/// \c addrspace_cast<global int*>(PtrToGenericInt).
597///
598/// A addrspace_cast can cast address space type qualifiers but does not change
599/// the underlying value.
600class CXXAddrspaceCastExpr final
601 : public CXXNamedCastExpr,
602 private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {
603 CXXAddrspaceCastExpr(QualType ty, ExprValueKind VK, CastKind Kind, Expr *op,
604 TypeSourceInfo *writtenTy, SourceLocation l,
605 SourceLocation RParenLoc, SourceRange AngleBrackets)
606 : CXXNamedCastExpr(CXXAddrspaceCastExprClass, ty, VK, Kind, op, 0,
607 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
608 AngleBrackets) {}
609
610 explicit CXXAddrspaceCastExpr(EmptyShell Empty)
611 : CXXNamedCastExpr(CXXAddrspaceCastExprClass, Empty, 0,
612 /*HasFPFeatures*/ false) {}
613
614public:
615 friend class CastExpr;
616 friend TrailingObjects;
617
618 static CXXAddrspaceCastExpr *
619 Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind,
620 Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L,
621 SourceLocation RParenLoc, SourceRange AngleBrackets);
622 static CXXAddrspaceCastExpr *CreateEmpty(const ASTContext &Context);
623
624 static bool classof(const Stmt *T) {
625 return T->getStmtClass() == CXXAddrspaceCastExprClass;
626 }
627};
628
629/// A call to a literal operator (C++11 [over.literal])
630/// written as a user-defined literal (C++11 [lit.ext]).
631///
632/// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this
633/// is semantically equivalent to a normal call, this AST node provides better
634/// information about the syntactic representation of the literal.
635///
636/// Since literal operators are never found by ADL and can only be declared at
637/// namespace scope, a user-defined literal is never dependent.
638class UserDefinedLiteral final : public CallExpr {
639 friend class ASTStmtReader;
640 friend class ASTStmtWriter;
641
642 /// The location of a ud-suffix within the literal.
643 SourceLocation UDSuffixLoc;
644
645 // UserDefinedLiteral has some trailing objects belonging
646 // to CallExpr. See CallExpr for the details.
647
648 UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
649 ExprValueKind VK, SourceLocation LitEndLoc,
650 SourceLocation SuffixLoc, FPOptionsOverride FPFeatures);
651
652 UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
653
654public:
655 static UserDefinedLiteral *Create(const ASTContext &Ctx, Expr *Fn,
656 ArrayRef<Expr *> Args, QualType Ty,
657 ExprValueKind VK, SourceLocation LitEndLoc,
658 SourceLocation SuffixLoc,
659 FPOptionsOverride FPFeatures);
660
661 static UserDefinedLiteral *CreateEmpty(const ASTContext &Ctx,
662 unsigned NumArgs, bool HasFPOptions,
663 EmptyShell Empty);
664
665 /// The kind of literal operator which is invoked.
666 enum LiteralOperatorKind {
667 /// Raw form: operator "" X (const char *)
668 LOK_Raw,
669
670 /// Raw form: operator "" X<cs...> ()
671 LOK_Template,
672
673 /// operator "" X (unsigned long long)
674 LOK_Integer,
675
676 /// operator "" X (long double)
677 LOK_Floating,
678
679 /// operator "" X (const CharT *, size_t)
680 LOK_String,
681
682 /// operator "" X (CharT)
683 LOK_Character
684 };
685
686 /// Returns the kind of literal operator invocation
687 /// which this expression represents.
688 LiteralOperatorKind getLiteralOperatorKind() const;
689
690 /// If this is not a raw user-defined literal, get the
691 /// underlying cooked literal (representing the literal with the suffix
692 /// removed).
693 Expr *getCookedLiteral();
694 const Expr *getCookedLiteral() const {
695 return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
696 }
697
698 SourceLocation getBeginLoc() const {
699 if (getLiteralOperatorKind() == LOK_Template)
700 return getRParenLoc();
701 return getArg(0)->getBeginLoc();
702 }
703
704 SourceLocation getEndLoc() const { return getRParenLoc(); }
705
706 /// Returns the location of a ud-suffix in the expression.
707 ///
708 /// For a string literal, there may be multiple identical suffixes. This
709 /// returns the first.
710 SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }
711
712 /// Returns the ud-suffix specified for this literal.
713 const IdentifierInfo *getUDSuffix() const;
714
715 static bool classof(const Stmt *S) {
716 return S->getStmtClass() == UserDefinedLiteralClass;
717 }
718};
719
720/// A boolean literal, per ([C++ lex.bool] Boolean literals).
721class CXXBoolLiteralExpr : public Expr {
722public:
723 CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)
724 : Expr(CXXBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
725 CXXBoolLiteralExprBits.Value = Val;
726 CXXBoolLiteralExprBits.Loc = Loc;
727 setDependence(ExprDependence::None);
728 }
729
730 explicit CXXBoolLiteralExpr(EmptyShell Empty)
731 : Expr(CXXBoolLiteralExprClass, Empty) {}
732
733 bool getValue() const { return CXXBoolLiteralExprBits.Value; }
734 void setValue(bool V) { CXXBoolLiteralExprBits.Value = V; }
735
736 SourceLocation getBeginLoc() const { return getLocation(); }
737 SourceLocation getEndLoc() const { return getLocation(); }
738
739 SourceLocation getLocation() const { return CXXBoolLiteralExprBits.Loc; }
740 void setLocation(SourceLocation L) { CXXBoolLiteralExprBits.Loc = L; }
741
742 static bool classof(const Stmt *T) {
743 return T->getStmtClass() == CXXBoolLiteralExprClass;
744 }
745
746 // Iterators
747 child_range children() {
748 return child_range(child_iterator(), child_iterator());
749 }
750
751 const_child_range children() const {
752 return const_child_range(const_child_iterator(), const_child_iterator());
753 }
754};
755
756/// The null pointer literal (C++11 [lex.nullptr])
757///
758/// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
759class CXXNullPtrLiteralExpr : public Expr {
760public:
761 CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
762 : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
763 CXXNullPtrLiteralExprBits.Loc = Loc;
764 setDependence(ExprDependence::None);
765 }
766
767 explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
768 : Expr(CXXNullPtrLiteralExprClass, Empty) {}
769
770 SourceLocation getBeginLoc() const { return getLocation(); }
771 SourceLocation getEndLoc() const { return getLocation(); }
772
773 SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; }
774 void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; }
775
776 static bool classof(const Stmt *T) {
777 return T->getStmtClass() == CXXNullPtrLiteralExprClass;
778 }
779
780 child_range children() {
781 return child_range(child_iterator(), child_iterator());
782 }
783
784 const_child_range children() const {
785 return const_child_range(const_child_iterator(), const_child_iterator());
786 }
787};
788
789/// Implicit construction of a std::initializer_list<T> object from an
790/// array temporary within list-initialization (C++11 [dcl.init.list]p5).
791class CXXStdInitializerListExpr : public Expr {
792 Stmt *SubExpr = nullptr;
793
794 CXXStdInitializerListExpr(EmptyShell Empty)
795 : Expr(CXXStdInitializerListExprClass, Empty) {}
796
797public:
798 friend class ASTReader;
799 friend class ASTStmtReader;
800
801 CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
802 : Expr(CXXStdInitializerListExprClass, Ty, VK_PRValue, OK_Ordinary),
803 SubExpr(SubExpr) {
804 setDependence(computeDependence(this));
805 }
806
807 Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
808 const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }
809
810 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
811 return SubExpr->getBeginLoc();
812 }
813
814 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
815 return SubExpr->getEndLoc();
816 }
817
818 /// Retrieve the source range of the expression.
819 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
820 return SubExpr->getSourceRange();
821 }
822
823 static bool classof(const Stmt *S) {
824 return S->getStmtClass() == CXXStdInitializerListExprClass;
825 }
826
827 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
828
829 const_child_range children() const {
830 return const_child_range(&SubExpr, &SubExpr + 1);
831 }
832};
833
834/// A C++ \c typeid expression (C++ [expr.typeid]), which gets
835/// the \c type_info that corresponds to the supplied type, or the (possibly
836/// dynamic) type of the supplied expression.
837///
838/// This represents code like \c typeid(int) or \c typeid(*objPtr)
839class CXXTypeidExpr : public Expr {
840 friend class ASTStmtReader;
841
842private:
843 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
844 SourceRange Range;
845
846public:
847 CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
848 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
849 Range(R) {
850 setDependence(computeDependence(this));
851 }
852
853 CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
854 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
855 Range(R) {
856 setDependence(computeDependence(this));
857 }
858
859 CXXTypeidExpr(EmptyShell Empty, bool isExpr)
860 : Expr(CXXTypeidExprClass, Empty) {
861 if (isExpr)
862 Operand = (Expr*)nullptr;
863 else
864 Operand = (TypeSourceInfo*)nullptr;
865 }
866
867 /// Determine whether this typeid has a type operand which is potentially
868 /// evaluated, per C++11 [expr.typeid]p3.
869 bool isPotentiallyEvaluated() const;
870
871 /// Best-effort check if the expression operand refers to a most derived
872 /// object. This is not a strong guarantee.
873 bool isMostDerived(ASTContext &Context) const;
874
875 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
876
877 /// Retrieves the type operand of this typeid() expression after
878 /// various required adjustments (removing reference types, cv-qualifiers).
879 QualType getTypeOperand(ASTContext &Context) const;
880
881 /// Retrieve source information for the type operand.
882 TypeSourceInfo *getTypeOperandSourceInfo() const {
883 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")((void)0);
884 return Operand.get<TypeSourceInfo *>();
885 }
886 Expr *getExprOperand() const {
887 assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)")((void)0);
888 return static_cast<Expr*>(Operand.get<Stmt *>());
889 }
890
891 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
892 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
893 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
894 void setSourceRange(SourceRange R) { Range = R; }
895
896 static bool classof(const Stmt *T) {
897 return T->getStmtClass() == CXXTypeidExprClass;
898 }
899
900 // Iterators
901 child_range children() {
902 if (isTypeOperand())
903 return child_range(child_iterator(), child_iterator());
904 auto **begin = reinterpret_cast<Stmt **>(&Operand);
905 return child_range(begin, begin + 1);
906 }
907
908 const_child_range children() const {
909 if (isTypeOperand())
910 return const_child_range(const_child_iterator(), const_child_iterator());
911
912 auto **begin =
913 reinterpret_cast<Stmt **>(&const_cast<CXXTypeidExpr *>(this)->Operand);
914 return const_child_range(begin, begin + 1);
915 }
916};
917
918/// A member reference to an MSPropertyDecl.
919///
920/// This expression always has pseudo-object type, and therefore it is
921/// typically not encountered in a fully-typechecked expression except
922/// within the syntactic form of a PseudoObjectExpr.
923class MSPropertyRefExpr : public Expr {
924 Expr *BaseExpr;
925 MSPropertyDecl *TheDecl;
926 SourceLocation MemberLoc;
927 bool IsArrow;
928 NestedNameSpecifierLoc QualifierLoc;
929
930public:
931 friend class ASTStmtReader;
932
933 MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
934 QualType ty, ExprValueKind VK,
935 NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc)
936 : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary), BaseExpr(baseExpr),
937 TheDecl(decl), MemberLoc(nameLoc), IsArrow(isArrow),
938 QualifierLoc(qualifierLoc) {
939 setDependence(computeDependence(this));
940 }
941
942 MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}
943
944 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
945 return SourceRange(getBeginLoc(), getEndLoc());
946 }
947
948 bool isImplicitAccess() const {
949 return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
950 }
951
952 SourceLocation getBeginLoc() const {
953 if (!isImplicitAccess())
954 return BaseExpr->getBeginLoc();
955 else if (QualifierLoc)
956 return QualifierLoc.getBeginLoc();
957 else
958 return MemberLoc;
959 }
960
961 SourceLocation getEndLoc() const { return getMemberLoc(); }
962
963 child_range children() {
964 return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
965 }
966
967 const_child_range children() const {
968 auto Children = const_cast<MSPropertyRefExpr *>(this)->children();
969 return const_child_range(Children.begin(), Children.end());
970 }
971
972 static bool classof(const Stmt *T) {
973 return T->getStmtClass() == MSPropertyRefExprClass;
974 }
975
976 Expr *getBaseExpr() const { return BaseExpr; }
977 MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
978 bool isArrow() const { return IsArrow; }
979 SourceLocation getMemberLoc() const { return MemberLoc; }
980 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
981};
982
983/// MS property subscript expression.
984/// MSVC supports 'property' attribute and allows to apply it to the
985/// declaration of an empty array in a class or structure definition.
986/// For example:
987/// \code
988/// __declspec(property(get=GetX, put=PutX)) int x[];
989/// \endcode
990/// The above statement indicates that x[] can be used with one or more array
991/// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and
992/// p->x[a][b] = i will be turned into p->PutX(a, b, i).
993/// This is a syntactic pseudo-object expression.
994class MSPropertySubscriptExpr : public Expr {
995 friend class ASTStmtReader;
996
997 enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };
998
999 Stmt *SubExprs[NUM_SUBEXPRS];
1000 SourceLocation RBracketLoc;
1001
1002 void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
1003 void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }
1004
1005public:
1006 MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
1007 ExprObjectKind OK, SourceLocation RBracketLoc)
1008 : Expr(MSPropertySubscriptExprClass, Ty, VK, OK),
1009 RBracketLoc(RBracketLoc) {
1010 SubExprs[BASE_EXPR] = Base;
1011 SubExprs[IDX_EXPR] = Idx;
1012 setDependence(computeDependence(this));
1013 }
1014
1015 /// Create an empty array subscript expression.
1016 explicit MSPropertySubscriptExpr(EmptyShell Shell)
1017 : Expr(MSPropertySubscriptExprClass, Shell) {}
1018
1019 Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
1020 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }
1021
1022 Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
1023 const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }
1024
1025 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
1026 return getBase()->getBeginLoc();
1027 }
1028
1029 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RBracketLoc; }
1030
1031 SourceLocation getRBracketLoc() const { return RBracketLoc; }
1032 void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
1033
1034 SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
1035 return getBase()->getExprLoc();
1036 }
1037
1038 static bool classof(const Stmt *T) {
1039 return T->getStmtClass() == MSPropertySubscriptExprClass;
1040 }
1041
1042 // Iterators
1043 child_range children() {
1044 return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
1045 }
1046
1047 const_child_range children() const {
1048 return const_child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
1049 }
1050};
1051
1052/// A Microsoft C++ @c __uuidof expression, which gets
1053/// the _GUID that corresponds to the supplied type or expression.
1054///
1055/// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
1056class CXXUuidofExpr : public Expr {
1057 friend class ASTStmtReader;
1058
1059private:
1060 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
1061 MSGuidDecl *Guid;
1062 SourceRange Range;
1063
1064public:
1065 CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, MSGuidDecl *Guid,
1066 SourceRange R)
1067 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
1068 Guid(Guid), Range(R) {
1069 setDependence(computeDependence(this));
1070 }
1071
1072 CXXUuidofExpr(QualType Ty, Expr *Operand, MSGuidDecl *Guid, SourceRange R)
1073 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
1074 Guid(Guid), Range(R) {
1075 setDependence(computeDependence(this));
1076 }
1077
1078 CXXUuidofExpr(EmptyShell Empty, bool isExpr)
1079 : Expr(CXXUuidofExprClass, Empty) {
1080 if (isExpr)
1081 Operand = (Expr*)nullptr;
1082 else
1083 Operand = (TypeSourceInfo*)nullptr;
1084 }
1085
1086 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
1087
1088 /// Retrieves the type operand of this __uuidof() expression after
1089 /// various required adjustments (removing reference types, cv-qualifiers).
1090 QualType getTypeOperand(ASTContext &Context) const;
1091
1092 /// Retrieve source information for the type operand.
1093 TypeSourceInfo *getTypeOperandSourceInfo() const {
1094 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")((void)0);
1095 return Operand.get<TypeSourceInfo *>();
1096 }
1097 Expr *getExprOperand() const {
1098 assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)")((void)0);
1099 return static_cast<Expr*>(Operand.get<Stmt *>());
1100 }
1101
1102 MSGuidDecl *getGuidDecl() const { return Guid; }
1103
1104 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
1105 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
1106 SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
1107 void setSourceRange(SourceRange R) { Range = R; }
1108
1109 static bool classof(const Stmt *T) {
1110 return T->getStmtClass() == CXXUuidofExprClass;
1111 }
1112
1113 // Iterators
1114 child_range children() {
1115 if (isTypeOperand())
1116 return child_range(child_iterator(), child_iterator());
1117 auto **begin = reinterpret_cast<Stmt **>(&Operand);
1118 return child_range(begin, begin + 1);
1119 }
1120
1121 const_child_range children() const {
1122 if (isTypeOperand())
1123 return const_child_range(const_child_iterator(), const_child_iterator());
1124 auto **begin =
1125 reinterpret_cast<Stmt **>(&const_cast<CXXUuidofExpr *>(this)->Operand);
1126 return const_child_range(begin, begin + 1);
1127 }
1128};
1129
1130/// Represents the \c this expression in C++.
1131///
1132/// This is a pointer to the object on which the current member function is
1133/// executing (C++ [expr.prim]p3). Example:
1134///
1135/// \code
1136/// class Foo {
1137/// public:
1138/// void bar();
1139/// void test() { this->bar(); }
1140/// };
1141/// \endcode
1142class CXXThisExpr : public Expr {
1143public:
1144 CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit)
1145 : Expr(CXXThisExprClass, Ty, VK_PRValue, OK_Ordinary) {
1146 CXXThisExprBits.IsImplicit = IsImplicit;
1147 CXXThisExprBits.Loc = L;
1148 setDependence(computeDependence(this));
1149 }
1150
1151 CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
1152
1153 SourceLocation getLocation() const { return CXXThisExprBits.Loc; }
1154 void setLocation(SourceLocation L) { CXXThisExprBits.Loc = L; }
1155
1156 SourceLocation getBeginLoc() const { return getLocation(); }
1157 SourceLocation getEndLoc() const { return getLocation(); }
1158
1159 bool isImplicit() const { return CXXThisExprBits.IsImplicit; }
1160 void setImplicit(bool I) { CXXThisExprBits.IsImplicit = I; }
1161
1162 static bool classof(const Stmt *T) {
1163 return T->getStmtClass() == CXXThisExprClass;
1164 }
1165
1166 // Iterators
1167 child_range children() {
1168 return child_range(child_iterator(), child_iterator());
1169 }
1170
1171 const_child_range children() const {
1172 return const_child_range(const_child_iterator(), const_child_iterator());
1173 }
1174};
1175
1176/// A C++ throw-expression (C++ [except.throw]).
1177///
1178/// This handles 'throw' (for re-throwing the current exception) and
1179/// 'throw' assignment-expression. When assignment-expression isn't
1180/// present, Op will be null.
1181class CXXThrowExpr : public Expr {
1182 friend class ASTStmtReader;
1183
1184 /// The optional expression in the throw statement.
1185 Stmt *Operand;
1186
1187public:
1188 // \p Ty is the void type which is used as the result type of the
1189 // expression. The \p Loc is the location of the throw keyword.
1190 // \p Operand is the expression in the throw statement, and can be
1191 // null if not present.
1192 CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc,
1193 bool IsThrownVariableInScope)
1194 : Expr(CXXThrowExprClass, Ty, VK_PRValue, OK_Ordinary), Operand(Operand) {
1195 CXXThrowExprBits.ThrowLoc = Loc;
1196 CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope;
1197 setDependence(computeDependence(this));
1198 }
1199 CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
1200
1201 const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
1202 Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }
1203
1204 SourceLocation getThrowLoc() const { return CXXThrowExprBits.ThrowLoc; }
1205
1206 /// Determines whether the variable thrown by this expression (if any!)
1207 /// is within the innermost try block.
1208 ///
1209 /// This information is required to determine whether the NRVO can apply to
1210 /// this variable.
1211 bool isThrownVariableInScope() const {
1212 return CXXThrowExprBits.IsThrownVariableInScope;
1213 }
1214
1215 SourceLocation getBeginLoc() const { return getThrowLoc(); }
1216 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
1217 if (!getSubExpr())
1218 return getThrowLoc();
1219 return getSubExpr()->getEndLoc();
1220 }
1221
1222 static bool classof(const Stmt *T) {
1223 return T->getStmtClass() == CXXThrowExprClass;
1224 }
1225
1226 // Iterators
1227 child_range children() {
1228 return child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1229 }
1230
1231 const_child_range children() const {
1232 return const_child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1233 }
1234};
1235
1236/// A default argument (C++ [dcl.fct.default]).
1237///
1238/// This wraps up a function call argument that was created from the
1239/// corresponding parameter's default argument, when the call did not
1240/// explicitly supply arguments for all of the parameters.
1241class CXXDefaultArgExpr final : public Expr {
1242 friend class ASTStmtReader;
1243
1244 /// The parameter whose default is being used.
1245 ParmVarDecl *Param;
1246
1247 /// The context where the default argument expression was used.
1248 DeclContext *UsedContext;
1249
1250 CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
1251 DeclContext *UsedContext)
1252 : Expr(SC,
1253 Param->hasUnparsedDefaultArg()
1254 ? Param->getType().getNonReferenceType()
1255 : Param->getDefaultArg()->getType(),
1256 Param->getDefaultArg()->getValueKind(),
1257 Param->getDefaultArg()->getObjectKind()),
1258 Param(Param), UsedContext(UsedContext) {
1259 CXXDefaultArgExprBits.Loc = Loc;
1260 setDependence(computeDependence(this));
1261 }
1262
1263public:
1264 CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
1265
1266 // \p Param is the parameter whose default argument is used by this
1267 // expression.
1268 static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
1269 ParmVarDecl *Param,
1270 DeclContext *UsedContext) {
1271 return new (C)
1272 CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
1273 }
1274
1275 // Retrieve the parameter that the argument was created from.
1276 const ParmVarDecl *getParam() const { return Param; }
1277 ParmVarDecl *getParam() { return Param; }
1278
1279 // Retrieve the actual argument to the function call.
1280 const Expr *getExpr() const { return getParam()->getDefaultArg(); }
1281 Expr *getExpr() { return getParam()->getDefaultArg(); }
1282
1283 const DeclContext *getUsedContext() const { return UsedContext; }
1284 DeclContext *getUsedContext() { return UsedContext; }
1285
1286 /// Retrieve the location where this default argument was actually used.
1287 SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
1288
1289 /// Default argument expressions have no representation in the
1290 /// source, so they have an empty source range.
1291 SourceLocation getBeginLoc() const { return SourceLocation(); }
1292 SourceLocation getEndLoc() const { return SourceLocation(); }
1293
1294 SourceLocation getExprLoc() const { return getUsedLocation(); }
1295
1296 static bool classof(const Stmt *T) {
1297 return T->getStmtClass() == CXXDefaultArgExprClass;
1298 }
1299
1300 // Iterators
1301 child_range children() {
1302 return child_range(child_iterator(), child_iterator());
1303 }
1304
1305 const_child_range children() const {
1306 return const_child_range(const_child_iterator(), const_child_iterator());
1307 }
1308};
1309
1310/// A use of a default initializer in a constructor or in aggregate
1311/// initialization.
1312///
1313/// This wraps a use of a C++ default initializer (technically,
1314/// a brace-or-equal-initializer for a non-static data member) when it
1315/// is implicitly used in a mem-initializer-list in a constructor
1316/// (C++11 [class.base.init]p8) or in aggregate initialization
1317/// (C++1y [dcl.init.aggr]p7).
1318class CXXDefaultInitExpr : public Expr {
1319 friend class ASTReader;
1320 friend class ASTStmtReader;
1321
1322 /// The field whose default is being used.
1323 FieldDecl *Field;
1324
1325 /// The context where the default initializer expression was used.
1326 DeclContext *UsedContext;
1327
1328 CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
1329 FieldDecl *Field, QualType Ty, DeclContext *UsedContext);
1330
1331 CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
1332
1333public:
1334 /// \p Field is the non-static data member whose default initializer is used
1335 /// by this expression.
1336 static CXXDefaultInitExpr *Create(const ASTContext &Ctx, SourceLocation Loc,
1337 FieldDecl *Field, DeclContext *UsedContext) {
1338 return new (Ctx) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(), UsedContext);
1339 }
1340
1341 /// Get the field whose initializer will be used.
1342 FieldDecl *getField() { return Field; }
1343 const FieldDecl *getField() const { return Field; }
1344
1345 /// Get the initialization expression that will be used.
1346 const Expr *getExpr() const {
1347 assert(Field->getInClassInitializer() && "initializer hasn't been parsed")((void)0);
1348 return Field->getInClassInitializer();
1349 }
1350 Expr *getExpr() {
1351 assert(Field->getInClassInitializer() && "initializer hasn't been parsed")((void)0);
1352 return Field->getInClassInitializer();
1353 }
1354
1355 const DeclContext *getUsedContext() const { return UsedContext; }
1356 DeclContext *getUsedContext() { return UsedContext; }
1357
1358 /// Retrieve the location where this default initializer expression was
1359 /// actually used.
1360 SourceLocation getUsedLocation() const { return getBeginLoc(); }
1361
1362 SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; }
1363 SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; }
1364
1365 static bool classof(const Stmt *T) {
1366 return T->getStmtClass() == CXXDefaultInitExprClass;
1367 }
1368
1369 // Iterators
1370 child_range children() {
1371 return child_range(child_iterator(), child_iterator());
1372 }
1373
1374 const_child_range children() const {
1375 return const_child_range(const_child_iterator(), const_child_iterator());
1376 }
1377};
1378
1379/// Represents a C++ temporary.
1380class CXXTemporary {
1381 /// The destructor that needs to be called.
1382 const CXXDestructorDecl *Destructor;
1383
1384 explicit CXXTemporary(const CXXDestructorDecl *destructor)
1385 : Destructor(destructor) {}
1386
1387public:
1388 static CXXTemporary *Create(const ASTContext &C,
1389 const CXXDestructorDecl *Destructor);
1390
1391 const CXXDestructorDecl *getDestructor() const { return Destructor; }
1392
1393 void setDestructor(const CXXDestructorDecl *Dtor) {
1394 Destructor = Dtor;
1395 }
1396};
1397
1398/// Represents binding an expression to a temporary.
1399///
1400/// This ensures the destructor is called for the temporary. It should only be
1401/// needed for non-POD, non-trivially destructable class types. For example:
1402///
1403/// \code
1404/// struct S {
1405/// S() { } // User defined constructor makes S non-POD.
1406/// ~S() { } // User defined destructor makes it non-trivial.
1407/// };
1408/// void test() {
1409/// const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
1410/// }
1411/// \endcode
1412class CXXBindTemporaryExpr : public Expr {
1413 CXXTemporary *Temp = nullptr;
1414 Stmt *SubExpr = nullptr;
1415
1416 CXXBindTemporaryExpr(CXXTemporary *temp, Expr *SubExpr)
1417 : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_PRValue,
1418 OK_Ordinary),
1419 Temp(temp), SubExpr(SubExpr) {
1420 setDependence(computeDependence(this));
1421 }
1422
1423public:
1424 CXXBindTemporaryExpr(EmptyShell Empty)
1425 : Expr(CXXBindTemporaryExprClass, Empty) {}
1426
1427 static CXXBindTemporaryExpr *Create(const ASTContext &C, CXXTemporary *Temp,
1428 Expr* SubExpr);
1429
1430 CXXTemporary *getTemporary() { return Temp; }
1431 const CXXTemporary *getTemporary() const { return Temp; }
1432 void setTemporary(CXXTemporary *T) { Temp = T; }
1433
1434 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
1435 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
1436 void setSubExpr(Expr *E) { SubExpr = E; }
1437
1438 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
1439 return SubExpr->getBeginLoc();
1440 }
1441
1442 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
1443 return SubExpr->getEndLoc();
1444 }
1445
1446 // Implement isa/cast/dyncast/etc.
1447 static bool classof(const Stmt *T) {
1448 return T->getStmtClass() == CXXBindTemporaryExprClass;
1449 }
1450
1451 // Iterators
1452 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
1453
1454 const_child_range children() const {
1455 return const_child_range(&SubExpr, &SubExpr + 1);
1456 }
1457};
1458
1459/// Represents a call to a C++ constructor.
1460class CXXConstructExpr : public Expr {
1461 friend class ASTStmtReader;
1462
1463public:
1464 enum ConstructionKind {
1465 CK_Complete,
1466 CK_NonVirtualBase,
1467 CK_VirtualBase,
1468 CK_Delegating
1469 };
1470
1471private:
1472 /// A pointer to the constructor which will be ultimately called.
1473 CXXConstructorDecl *Constructor;
1474
1475 SourceRange ParenOrBraceRange;
1476
1477 /// The number of arguments.
1478 unsigned NumArgs;
1479
1480 // We would like to stash the arguments of the constructor call after
1481 // CXXConstructExpr. However CXXConstructExpr is used as a base class of
1482 // CXXTemporaryObjectExpr which makes the use of llvm::TrailingObjects
1483 // impossible.
1484 //
1485 // Instead we manually stash the trailing object after the full object
1486 // containing CXXConstructExpr (that is either CXXConstructExpr or
1487 // CXXTemporaryObjectExpr).
1488 //
1489 // The trailing objects are:
1490 //
1491 // * An array of getNumArgs() "Stmt *" for the arguments of the
1492 // constructor call.
1493
1494 /// Return a pointer to the start of the trailing arguments.
1495 /// Defined just after CXXTemporaryObjectExpr.
1496 inline Stmt **getTrailingArgs();
1497 const Stmt *const *getTrailingArgs() const {
1498 return const_cast<CXXConstructExpr *>(this)->getTrailingArgs();
1499 }
1500
1501protected:
1502 /// Build a C++ construction expression.
1503 CXXConstructExpr(StmtClass SC, QualType Ty, SourceLocation Loc,
1504 CXXConstructorDecl *Ctor, bool Elidable,
1505 ArrayRef<Expr *> Args, bool HadMultipleCandidates,
1506 bool ListInitialization, bool StdInitListInitialization,
1507 bool ZeroInitialization, ConstructionKind ConstructKind,
1508 SourceRange ParenOrBraceRange);
1509
1510 /// Build an empty C++ construction expression.
1511 CXXConstructExpr(StmtClass SC, EmptyShell Empty, unsigned NumArgs);
1512
1513 /// Return the size in bytes of the trailing objects. Used by
1514 /// CXXTemporaryObjectExpr to allocate the right amount of storage.
1515 static unsigned sizeOfTrailingObjects(unsigned NumArgs) {
1516 return NumArgs * sizeof(Stmt *);
1517 }
1518
1519public:
1520 /// Create a C++ construction expression.
1521 static CXXConstructExpr *
1522 Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
1523 CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
1524 bool HadMultipleCandidates, bool ListInitialization,
1525 bool StdInitListInitialization, bool ZeroInitialization,
1526 ConstructionKind ConstructKind, SourceRange ParenOrBraceRange);
1527
1528 /// Create an empty C++ construction expression.
1529 static CXXConstructExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs);
1530
1531 /// Get the constructor that this expression will (ultimately) call.
1532 CXXConstructorDecl *getConstructor() const { return Constructor; }
1533
1534 SourceLocation getLocation() const { return CXXConstructExprBits.Loc; }
1535 void setLocation(SourceLocation Loc) { CXXConstructExprBits.Loc = Loc; }
1536
1537 /// Whether this construction is elidable.
1538 bool isElidable() const { return CXXConstructExprBits.Elidable; }
1539 void setElidable(bool E) { CXXConstructExprBits.Elidable = E; }
1540
1541 /// Whether the referred constructor was resolved from
1542 /// an overloaded set having size greater than 1.
1543 bool hadMultipleCandidates() const {
1544 return CXXConstructExprBits.HadMultipleCandidates;
1545 }
1546 void setHadMultipleCandidates(bool V) {
1547 CXXConstructExprBits.HadMultipleCandidates = V;
1548 }
1549
1550 /// Whether this constructor call was written as list-initialization.
1551 bool isListInitialization() const {
1552 return CXXConstructExprBits.ListInitialization;
1553 }
1554 void setListInitialization(bool V) {
1555 CXXConstructExprBits.ListInitialization = V;
1556 }
1557
1558 /// Whether this constructor call was written as list-initialization,
1559 /// but was interpreted as forming a std::initializer_list<T> from the list
1560 /// and passing that as a single constructor argument.
1561 /// See C++11 [over.match.list]p1 bullet 1.
1562 bool isStdInitListInitialization() const {
1563 return CXXConstructExprBits.StdInitListInitialization;
1564 }
1565 void setStdInitListInitialization(bool V) {
1566 CXXConstructExprBits.StdInitListInitialization = V;
1567 }
1568
1569 /// Whether this construction first requires
1570 /// zero-initialization before the initializer is called.
1571 bool requiresZeroInitialization() const {
1572 return CXXConstructExprBits.ZeroInitialization;
1573 }
1574 void setRequiresZeroInitialization(bool ZeroInit) {
1575 CXXConstructExprBits.ZeroInitialization = ZeroInit;
1576 }
1577
1578 /// Determine whether this constructor is actually constructing
1579 /// a base class (rather than a complete object).
1580 ConstructionKind getConstructionKind() const {
1581 return static_cast<ConstructionKind>(CXXConstructExprBits.ConstructionKind);
1582 }
1583 void setConstructionKind(ConstructionKind CK) {
1584 CXXConstructExprBits.ConstructionKind = CK;
1585 }
1586
1587 using arg_iterator = ExprIterator;
1588 using const_arg_iterator = ConstExprIterator;
1589 using arg_range = llvm::iterator_range<arg_iterator>;
1590 using const_arg_range = llvm::iterator_range<const_arg_iterator>;
1591
1592 arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
1593 const_arg_range arguments() const {
1594 return const_arg_range(arg_begin(), arg_end());
1595 }
1596
1597 arg_iterator arg_begin() { return getTrailingArgs(); }
1598 arg_iterator arg_end() { return arg_begin() + getNumArgs(); }
1599 const_arg_iterator arg_begin() const { return getTrailingArgs(); }
1600 const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }
1601
1602 Expr **getArgs() { return reinterpret_cast<Expr **>(getTrailingArgs()); }
1603 const Expr *const *getArgs() const {
1604 return reinterpret_cast<const Expr *const *>(getTrailingArgs());
1605 }
1606
1607 /// Return the number of arguments to the constructor call.
1608 unsigned getNumArgs() const { return NumArgs; }
1609
1610 /// Return the specified argument.
1611 Expr *getArg(unsigned Arg) {
1612 assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
1613 return getArgs()[Arg];
1614 }
1615 const Expr *getArg(unsigned Arg) const {
1616 assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
1617 return getArgs()[Arg];
1618 }
1619
1620 /// Set the specified argument.
1621 void setArg(unsigned Arg, Expr *ArgExpr) {
1622 assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
1623 getArgs()[Arg] = ArgExpr;
1624 }
1625
1626 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
1627 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
1628 SourceRange getParenOrBraceRange() const { return ParenOrBraceRange; }
1629 void setParenOrBraceRange(SourceRange Range) { ParenOrBraceRange = Range; }
1630
1631 static bool classof(const Stmt *T) {
1632 return T->getStmtClass() == CXXConstructExprClass ||
1633 T->getStmtClass() == CXXTemporaryObjectExprClass;
1634 }
1635
1636 // Iterators
1637 child_range children() {
1638 return child_range(getTrailingArgs(), getTrailingArgs() + getNumArgs());
1639 }
1640
1641 const_child_range children() const {
1642 auto Children = const_cast<CXXConstructExpr *>(this)->children();
1643 return const_child_range(Children.begin(), Children.end());
1644 }
1645};
1646
1647/// Represents a call to an inherited base class constructor from an
1648/// inheriting constructor. This call implicitly forwards the arguments from
1649/// the enclosing context (an inheriting constructor) to the specified inherited
1650/// base class constructor.
1651class CXXInheritedCtorInitExpr : public Expr {
1652private:
1653 CXXConstructorDecl *Constructor = nullptr;
1654
1655 /// The location of the using declaration.
1656 SourceLocation Loc;
1657
1658 /// Whether this is the construction of a virtual base.
1659 unsigned ConstructsVirtualBase : 1;
1660
1661 /// Whether the constructor is inherited from a virtual base class of the
1662 /// class that we construct.
1663 unsigned InheritedFromVirtualBase : 1;
1664
1665public:
1666 friend class ASTStmtReader;
1667
1668 /// Construct a C++ inheriting construction expression.
1669 CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T,
1670 CXXConstructorDecl *Ctor, bool ConstructsVirtualBase,
1671 bool InheritedFromVirtualBase)
1672 : Expr(CXXInheritedCtorInitExprClass, T, VK_PRValue, OK_Ordinary),
1673 Constructor(Ctor), Loc(Loc),
1674 ConstructsVirtualBase(ConstructsVirtualBase),
1675 InheritedFromVirtualBase(InheritedFromVirtualBase) {
1676 assert(!T->isDependentType())((void)0);
1677 setDependence(ExprDependence::None);
1678 }
1679
1680 /// Construct an empty C++ inheriting construction expression.
1681 explicit CXXInheritedCtorInitExpr(EmptyShell Empty)
1682 : Expr(CXXInheritedCtorInitExprClass, Empty),
1683 ConstructsVirtualBase(false), InheritedFromVirtualBase(false) {}
1684
1685 /// Get the constructor that this expression will call.
1686 CXXConstructorDecl *getConstructor() const { return Constructor; }
1687
1688 /// Determine whether this constructor is actually constructing
1689 /// a base class (rather than a complete object).
1690 bool constructsVBase() const { return ConstructsVirtualBase; }
1691 CXXConstructExpr::ConstructionKind getConstructionKind() const {
1692 return ConstructsVirtualBase ? CXXConstructExpr::CK_VirtualBase
1693 : CXXConstructExpr::CK_NonVirtualBase;
1694 }
1695
1696 /// Determine whether the inherited constructor is inherited from a
1697 /// virtual base of the object we construct. If so, we are not responsible
1698 /// for calling the inherited constructor (the complete object constructor
1699 /// does that), and so we don't need to pass any arguments.
1700 bool inheritedFromVBase() const { return InheritedFromVirtualBase; }
1701
1702 SourceLocation getLocation() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
1703 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
1704 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
1705
1706 static bool classof(const Stmt *T) {
1707 return T->getStmtClass() == CXXInheritedCtorInitExprClass;
1708 }
1709
1710 child_range children() {
1711 return child_range(child_iterator(), child_iterator());
1712 }
1713
1714 const_child_range children() const {
1715 return const_child_range(const_child_iterator(), const_child_iterator());
1716 }
1717};
1718
1719/// Represents an explicit C++ type conversion that uses "functional"
1720/// notation (C++ [expr.type.conv]).
1721///
1722/// Example:
1723/// \code
1724/// x = int(0.5);
1725/// \endcode
1726class CXXFunctionalCastExpr final
1727 : public ExplicitCastExpr,
1728 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
1729 FPOptionsOverride> {
1730 SourceLocation LParenLoc;
1731 SourceLocation RParenLoc;
1732
1733 CXXFunctionalCastExpr(QualType ty, ExprValueKind VK,
1734 TypeSourceInfo *writtenTy, CastKind kind,
1735 Expr *castExpr, unsigned pathSize,
1736 FPOptionsOverride FPO, SourceLocation lParenLoc,
1737 SourceLocation rParenLoc)
1738 : ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind, castExpr,
1739 pathSize, FPO.requiresTrailingStorage(), writtenTy),
1740 LParenLoc(lParenLoc), RParenLoc(rParenLoc) {
1741 if (hasStoredFPFeatures())
1742 *getTrailingFPFeatures() = FPO;
1743 }
1744
1745 explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize,
1746 bool HasFPFeatures)
1747 : ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize,
1748 HasFPFeatures) {}
1749
1750 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
1751 return path_size();
1752 }
1753
1754public:
1755 friend class CastExpr;
1756 friend TrailingObjects;
1757
1758 static CXXFunctionalCastExpr *
1759 Create(const ASTContext &Context, QualType T, ExprValueKind VK,
1760 TypeSourceInfo *Written, CastKind Kind, Expr *Op,
1761 const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc,
1762 SourceLocation RPLoc);
1763 static CXXFunctionalCastExpr *
1764 CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures);
1765
1766 SourceLocation getLParenLoc() const { return LParenLoc; }
1767 void setLParenLoc(SourceLocation L) { LParenLoc = L; }
1768 SourceLocation getRParenLoc() const { return RParenLoc; }
1769 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
1770
1771 /// Determine whether this expression models list-initialization.
1772 bool isListInitialization() const { return LParenLoc.isInvalid(); }
1773
1774 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
1775 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
1776
1777 static bool classof(const Stmt *T) {
1778 return T->getStmtClass() == CXXFunctionalCastExprClass;
1779 }
1780};
1781
1782/// Represents a C++ functional cast expression that builds a
1783/// temporary object.
1784///
1785/// This expression type represents a C++ "functional" cast
1786/// (C++[expr.type.conv]) with N != 1 arguments that invokes a
1787/// constructor to build a temporary object. With N == 1 arguments the
1788/// functional cast expression will be represented by CXXFunctionalCastExpr.
1789/// Example:
1790/// \code
1791/// struct X { X(int, float); }
1792///
1793/// X create_X() {
1794/// return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
1795/// };
1796/// \endcode
1797class CXXTemporaryObjectExpr final : public CXXConstructExpr {
1798 friend class ASTStmtReader;
1799
1800 // CXXTemporaryObjectExpr has some trailing objects belonging
1801 // to CXXConstructExpr. See the comment inside CXXConstructExpr
1802 // for more details.
1803
1804 TypeSourceInfo *TSI;
1805
1806 CXXTemporaryObjectExpr(CXXConstructorDecl *Cons, QualType Ty,
1807 TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
1808 SourceRange ParenOrBraceRange,
1809 bool HadMultipleCandidates, bool ListInitialization,
1810 bool StdInitListInitialization,
1811 bool ZeroInitialization);
1812
1813 CXXTemporaryObjectExpr(EmptyShell Empty, unsigned NumArgs);
1814
1815public:
1816 static CXXTemporaryObjectExpr *
1817 Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty,
1818 TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
1819 SourceRange ParenOrBraceRange, bool HadMultipleCandidates,
1820 bool ListInitialization, bool StdInitListInitialization,
1821 bool ZeroInitialization);
1822
1823 static CXXTemporaryObjectExpr *CreateEmpty(const ASTContext &Ctx,
1824 unsigned NumArgs);
1825
1826 TypeSourceInfo *getTypeSourceInfo() const { return TSI; }
1827
1828 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
1829 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
1830
1831 static bool classof(const Stmt *T) {
1832 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1833 }
1834};
1835
1836Stmt **CXXConstructExpr::getTrailingArgs() {
1837 if (auto *E = dyn_cast<CXXTemporaryObjectExpr>(this))
1838 return reinterpret_cast<Stmt **>(E + 1);
1839 assert((getStmtClass() == CXXConstructExprClass) &&((void)0)
1840 "Unexpected class deriving from CXXConstructExpr!")((void)0);
1841 return reinterpret_cast<Stmt **>(this + 1);
1842}
1843
1844/// A C++ lambda expression, which produces a function object
1845/// (of unspecified type) that can be invoked later.
1846///
1847/// Example:
1848/// \code
1849/// void low_pass_filter(std::vector<double> &values, double cutoff) {
1850/// values.erase(std::remove_if(values.begin(), values.end(),
1851/// [=](double value) { return value > cutoff; });
1852/// }
1853/// \endcode
1854///
1855/// C++11 lambda expressions can capture local variables, either by copying
1856/// the values of those local variables at the time the function
1857/// object is constructed (not when it is called!) or by holding a
1858/// reference to the local variable. These captures can occur either
1859/// implicitly or can be written explicitly between the square
1860/// brackets ([...]) that start the lambda expression.
1861///
1862/// C++1y introduces a new form of "capture" called an init-capture that
1863/// includes an initializing expression (rather than capturing a variable),
1864/// and which can never occur implicitly.
1865class LambdaExpr final : public Expr,
1866 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1867 // LambdaExpr has some data stored in LambdaExprBits.
1868
1869 /// The source range that covers the lambda introducer ([...]).
1870 SourceRange IntroducerRange;
1871
1872 /// The source location of this lambda's capture-default ('=' or '&').
1873 SourceLocation CaptureDefaultLoc;
1874
1875 /// The location of the closing brace ('}') that completes
1876 /// the lambda.
1877 ///
1878 /// The location of the brace is also available by looking up the
1879 /// function call operator in the lambda class. However, it is
1880 /// stored here to improve the performance of getSourceRange(), and
1881 /// to avoid having to deserialize the function call operator from a
1882 /// module file just to determine the source range.
1883 SourceLocation ClosingBrace;
1884
1885 /// Construct a lambda expression.
1886 LambdaExpr(QualType T, SourceRange IntroducerRange,
1887 LambdaCaptureDefault CaptureDefault,
1888 SourceLocation CaptureDefaultLoc, bool ExplicitParams,
1889 bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
1890 SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack);
1891
1892 /// Construct an empty lambda expression.
1893 LambdaExpr(EmptyShell Empty, unsigned NumCaptures);
1894
1895 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
1896 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
1897
1898 void initBodyIfNeeded() const;
1899
1900public:
1901 friend class ASTStmtReader;
1902 friend class ASTStmtWriter;
1903 friend TrailingObjects;
1904
1905 /// Construct a new lambda expression.
1906 static LambdaExpr *
1907 Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange,
1908 LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc,
1909 bool ExplicitParams, bool ExplicitResultType,
1910 ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace,
1911 bool ContainsUnexpandedParameterPack);
1912
1913 /// Construct a new lambda expression that will be deserialized from
1914 /// an external source.
1915 static LambdaExpr *CreateDeserialized(const ASTContext &C,
1916 unsigned NumCaptures);
1917
1918 /// Determine the default capture kind for this lambda.
1919 LambdaCaptureDefault getCaptureDefault() const {
1920 return static_cast<LambdaCaptureDefault>(LambdaExprBits.CaptureDefault);
1921 }
1922
1923 /// Retrieve the location of this lambda's capture-default, if any.
1924 SourceLocation getCaptureDefaultLoc() const { return CaptureDefaultLoc; }
1925
1926 /// Determine whether one of this lambda's captures is an init-capture.
1927 bool isInitCapture(const LambdaCapture *Capture) const;
1928
1929 /// An iterator that walks over the captures of the lambda,
1930 /// both implicit and explicit.
1931 using capture_iterator = const LambdaCapture *;
1932
1933 /// An iterator over a range of lambda captures.
1934 using capture_range = llvm::iterator_range<capture_iterator>;
1935
1936 /// Retrieve this lambda's captures.
1937 capture_range captures() const;
1938
1939 /// Retrieve an iterator pointing to the first lambda capture.
1940 capture_iterator capture_begin() const;
1941
1942 /// Retrieve an iterator pointing past the end of the
1943 /// sequence of lambda captures.
1944 capture_iterator capture_end() const;
1945
1946 /// Determine the number of captures in this lambda.
1947 unsigned capture_size() const { return LambdaExprBits.NumCaptures; }
1948
1949 /// Retrieve this lambda's explicit captures.
1950 capture_range explicit_captures() const;
1951
1952 /// Retrieve an iterator pointing to the first explicit
1953 /// lambda capture.
1954 capture_iterator explicit_capture_begin() const;
1955
1956 /// Retrieve an iterator pointing past the end of the sequence of
1957 /// explicit lambda captures.
1958 capture_iterator explicit_capture_end() const;
1959
1960 /// Retrieve this lambda's implicit captures.
1961 capture_range implicit_captures() const;
1962
1963 /// Retrieve an iterator pointing to the first implicit
1964 /// lambda capture.
1965 capture_iterator implicit_capture_begin() const;
1966
1967 /// Retrieve an iterator pointing past the end of the sequence of
1968 /// implicit lambda captures.
1969 capture_iterator implicit_capture_end() const;
1970
1971 /// Iterator that walks over the capture initialization
1972 /// arguments.
1973 using capture_init_iterator = Expr **;
1974
1975 /// Const iterator that walks over the capture initialization
1976 /// arguments.
1977 /// FIXME: This interface is prone to being used incorrectly.
1978 using const_capture_init_iterator = Expr *const *;
1979
1980 /// Retrieve the initialization expressions for this lambda's captures.
1981 llvm::iterator_range<capture_init_iterator> capture_inits() {
1982 return llvm::make_range(capture_init_begin(), capture_init_end());
1983 }
1984
1985 /// Retrieve the initialization expressions for this lambda's captures.
1986 llvm::iterator_range<const_capture_init_iterator> capture_inits() const {
1987 return llvm::make_range(capture_init_begin(), capture_init_end());
1988 }
1989
1990 /// Retrieve the first initialization argument for this
1991 /// lambda expression (which initializes the first capture field).
1992 capture_init_iterator capture_init_begin() {
1993 return reinterpret_cast<Expr **>(getStoredStmts());
1994 }
1995
1996 /// Retrieve the first initialization argument for this
1997 /// lambda expression (which initializes the first capture field).
1998 const_capture_init_iterator capture_init_begin() const {
1999 return reinterpret_cast<Expr *const *>(getStoredStmts());
2000 }
2001
2002 /// Retrieve the iterator pointing one past the last
2003 /// initialization argument for this lambda expression.
2004 capture_init_iterator capture_init_end() {
2005 return capture_init_begin() + capture_size();
2006 }
2007
2008 /// Retrieve the iterator pointing one past the last
2009 /// initialization argument for this lambda expression.
2010 const_capture_init_iterator capture_init_end() const {
2011 return capture_init_begin() + capture_size();
2012 }
2013
2014 /// Retrieve the source range covering the lambda introducer,
2015 /// which contains the explicit capture list surrounded by square
2016 /// brackets ([...]).
2017 SourceRange getIntroducerRange() const { return IntroducerRange; }
2018
2019 /// Retrieve the class that corresponds to the lambda.
2020 ///
2021 /// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the
2022 /// captures in its fields and provides the various operations permitted
2023 /// on a lambda (copying, calling).
2024 CXXRecordDecl *getLambdaClass() const;
2025
2026 /// Retrieve the function call operator associated with this
2027 /// lambda expression.
2028 CXXMethodDecl *getCallOperator() const;
2029
2030 /// Retrieve the function template call operator associated with this
2031 /// lambda expression.
2032 FunctionTemplateDecl *getDependentCallOperator() const;
2033
2034 /// If this is a generic lambda expression, retrieve the template
2035 /// parameter list associated with it, or else return null.
2036 TemplateParameterList *getTemplateParameterList() const;
2037
2038 /// Get the template parameters were explicitly specified (as opposed to being
2039 /// invented by use of an auto parameter).
2040 ArrayRef<NamedDecl *> getExplicitTemplateParameters() const;
2041
2042 /// Get the trailing requires clause, if any.
2043 Expr *getTrailingRequiresClause() const;
2044
2045 /// Whether this is a generic lambda.
2046 bool isGenericLambda() const { return getTemplateParameterList(); }
2047
2048 /// Retrieve the body of the lambda. This will be most of the time
2049 /// a \p CompoundStmt, but can also be \p CoroutineBodyStmt wrapping
2050 /// a \p CompoundStmt. Note that unlike functions, lambda-expressions
2051 /// cannot have a function-try-block.
2052 Stmt *getBody() const;
2053
2054 /// Retrieve the \p CompoundStmt representing the body of the lambda.
2055 /// This is a convenience function for callers who do not need
2056 /// to handle node(s) which may wrap a \p CompoundStmt.
2057 const CompoundStmt *getCompoundStmtBody() const;
2058 CompoundStmt *getCompoundStmtBody() {
2059 const auto *ConstThis = this;
2060 return const_cast<CompoundStmt *>(ConstThis->getCompoundStmtBody());
2061 }
2062
2063 /// Determine whether the lambda is mutable, meaning that any
2064 /// captures values can be modified.
2065 bool isMutable() const;
2066
2067 /// Determine whether this lambda has an explicit parameter
2068 /// list vs. an implicit (empty) parameter list.
2069 bool hasExplicitParameters() const { return LambdaExprBits.ExplicitParams; }
2070
2071 /// Whether this lambda had its result type explicitly specified.
2072 bool hasExplicitResultType() const {
2073 return LambdaExprBits.ExplicitResultType;
2074 }
2075
2076 static bool classof(const Stmt *T) {
2077 return T->getStmtClass() == LambdaExprClass;
2078 }
2079
2080 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
2081 return IntroducerRange.getBegin();
2082 }
2083
2084 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return ClosingBrace; }
2085
2086 /// Includes the captures and the body of the lambda.
2087 child_range children();
2088 const_child_range children() const;
2089};
2090
2091/// An expression "T()" which creates a value-initialized rvalue of type
2092/// T, which is a non-class type. See (C++98 [5.2.3p2]).
2093class CXXScalarValueInitExpr : public Expr {
2094 friend class ASTStmtReader;
2095
2096 TypeSourceInfo *TypeInfo;
2097
2098public:
2099 /// Create an explicitly-written scalar-value initialization
2100 /// expression.
2101 CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
2102 SourceLocation RParenLoc)
2103 : Expr(CXXScalarValueInitExprClass, Type, VK_PRValue, OK_Ordinary),
2104 TypeInfo(TypeInfo) {
2105 CXXScalarValueInitExprBits.RParenLoc = RParenLoc;
2106 setDependence(computeDependence(this));
2107 }
2108
2109 explicit CXXScalarValueInitExpr(EmptyShell Shell)
2110 : Expr(CXXScalarValueInitExprClass, Shell) {}
2111
2112 TypeSourceInfo *getTypeSourceInfo() const {
2113 return TypeInfo;
2114 }
2115
2116 SourceLocation getRParenLoc() const {
2117 return CXXScalarValueInitExprBits.RParenLoc;
2118 }
2119
2120 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
2121 SourceLocation getEndLoc() const { return getRParenLoc(); }
2122
2123 static bool classof(const Stmt *T) {
2124 return T->getStmtClass() == CXXScalarValueInitExprClass;
2125 }
2126
2127 // Iterators
2128 child_range children() {
2129 return child_range(child_iterator(), child_iterator());
2130 }
2131
2132 const_child_range children() const {
2133 return const_child_range(const_child_iterator(), const_child_iterator());
2134 }
2135};
2136
2137/// Represents a new-expression for memory allocation and constructor
2138/// calls, e.g: "new CXXNewExpr(foo)".
2139class CXXNewExpr final
2140 : public Expr,
2141 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2142 friend class ASTStmtReader;
2143 friend class ASTStmtWriter;
2144 friend TrailingObjects;
2145
2146 /// Points to the allocation function used.
2147 FunctionDecl *OperatorNew;
2148
2149 /// Points to the deallocation function used in case of error. May be null.
2150 FunctionDecl *OperatorDelete;
2151
2152 /// The allocated type-source information, as written in the source.
2153 TypeSourceInfo *AllocatedTypeInfo;
2154
2155 /// Range of the entire new expression.
2156 SourceRange Range;
2157
2158 /// Source-range of a paren-delimited initializer.
2159 SourceRange DirectInitRange;
2160
2161 // CXXNewExpr is followed by several optional trailing objects.
2162 // They are in order:
2163 //
2164 // * An optional "Stmt *" for the array size expression.
2165 // Present if and ony if isArray().
2166 //
2167 // * An optional "Stmt *" for the init expression.
2168 // Present if and only if hasInitializer().
2169 //
2170 // * An array of getNumPlacementArgs() "Stmt *" for the placement new
2171 // arguments, if any.
2172 //
2173 // * An optional SourceRange for the range covering the parenthesized type-id
2174 // if the allocated type was expressed as a parenthesized type-id.
2175 // Present if and only if isParenTypeId().
2176 unsigned arraySizeOffset() const { return 0; }
2177 unsigned initExprOffset() const { return arraySizeOffset() + isArray(); }
2178 unsigned placementNewArgsOffset() const {
2179 return initExprOffset() + hasInitializer();
2180 }
2181
2182 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
2183 return isArray() + hasInitializer() + getNumPlacementArgs();
2184 }
2185
2186 unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
2187 return isParenTypeId();
2188 }
2189
2190public:
2191 enum InitializationStyle {
2192 /// New-expression has no initializer as written.
2193 NoInit,
2194
2195 /// New-expression has a C++98 paren-delimited initializer.
2196 CallInit,
2197
2198 /// New-expression has a C++11 list-initializer.
2199 ListInit
2200 };
2201
2202private:
2203 /// Build a c++ new expression.
2204 CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
2205 FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
2206 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2207 SourceRange TypeIdParens, Optional<Expr *> ArraySize,
2208 InitializationStyle InitializationStyle, Expr *Initializer,
2209 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2210 SourceRange DirectInitRange);
2211
2212 /// Build an empty c++ new expression.
2213 CXXNewExpr(EmptyShell Empty, bool IsArray, unsigned NumPlacementArgs,
2214 bool IsParenTypeId);
2215
2216public:
2217 /// Create a c++ new expression.
2218 static CXXNewExpr *
2219 Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew,
2220 FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
2221 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
2222 SourceRange TypeIdParens, Optional<Expr *> ArraySize,
2223 InitializationStyle InitializationStyle, Expr *Initializer,
2224 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
2225 SourceRange DirectInitRange);
2226
2227 /// Create an empty c++ new expression.
2228 static CXXNewExpr *CreateEmpty(const ASTContext &Ctx, bool IsArray,
2229 bool HasInit, unsigned NumPlacementArgs,
2230 bool IsParenTypeId);
2231
2232 QualType getAllocatedType() const {
2233 return getType()->castAs<PointerType>()->getPointeeType();
2234 }
2235
2236 TypeSourceInfo *getAllocatedTypeSourceInfo() const {
2237 return AllocatedTypeInfo;
2238 }
2239
2240 /// True if the allocation result needs to be null-checked.
2241 ///
2242 /// C++11 [expr.new]p13:
2243 /// If the allocation function returns null, initialization shall
2244 /// not be done, the deallocation function shall not be called,
2245 /// and the value of the new-expression shall be null.
2246 ///
2247 /// C++ DR1748:
2248 /// If the allocation function is a reserved placement allocation
2249 /// function that returns null, the behavior is undefined.
2250 ///
2251 /// An allocation function is not allowed to return null unless it
2252 /// has a non-throwing exception-specification. The '03 rule is
2253 /// identical except that the definition of a non-throwing
2254 /// exception specification is just "is it throw()?".
2255 bool shouldNullCheckAllocation() const;
2256
2257 FunctionDecl *getOperatorNew() const { return OperatorNew; }
2258 void setOperatorNew(FunctionDecl *D) { OperatorNew = D; }
2259 FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
2260 void setOperatorDelete(FunctionDecl *D) { OperatorDelete = D; }
2261
2262 bool isArray() const { return CXXNewExprBits.IsArray; }
2263
2264 Optional<Expr *> getArraySize() {
2265 if (!isArray())
2266 return None;
2267 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2268 }
2269 Optional<const Expr *> getArraySize() const {
2270 if (!isArray())
2271 return None;
2272 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2273 }
2274
2275 unsigned getNumPlacementArgs() const {
2276 return CXXNewExprBits.NumPlacementArgs;
2277 }
2278
2279 Expr **getPlacementArgs() {
2280 return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() +
2281 placementNewArgsOffset());
2282 }
2283
2284 Expr *getPlacementArg(unsigned I) {
2285 assert((I < getNumPlacementArgs()) && "Index out of range!")((void)0);
2286 return getPlacementArgs()[I];
2287 }
2288 const Expr *getPlacementArg(unsigned I) const {
2289 return const_cast<CXXNewExpr *>(this)->getPlacementArg(I);
2290 }
2291
2292 bool isParenTypeId() const { return CXXNewExprBits.IsParenTypeId; }
2293 SourceRange getTypeIdParens() const {
2294 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
2295 : SourceRange();
2296 }
2297
2298 bool isGlobalNew() const { return CXXNewExprBits.IsGlobalNew; }
2299
2300 /// Whether this new-expression has any initializer at all.
2301 bool hasInitializer() const {
2302 return CXXNewExprBits.StoredInitializationStyle > 0;
2303 }
2304
2305 /// The kind of initializer this new-expression has.
2306 InitializationStyle getInitializationStyle() const {
2307 if (CXXNewExprBits.StoredInitializationStyle == 0)
2308 return NoInit;
2309 return static_cast<InitializationStyle>(
2310 CXXNewExprBits.StoredInitializationStyle - 1);
2311 }
2312
2313 /// The initializer of this new-expression.
2314 Expr *getInitializer() {
2315 return hasInitializer()
2316 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2317 : nullptr;
2318 }
2319 const Expr *getInitializer() const {
2320 return hasInitializer()
2321 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2322 : nullptr;
2323 }
2324
2325 /// Returns the CXXConstructExpr from this new-expression, or null.
2326 const CXXConstructExpr *getConstructExpr() const {
2327 return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
2328 }
2329
2330 /// Indicates whether the required alignment should be implicitly passed to
2331 /// the allocation function.
2332 bool passAlignment() const { return CXXNewExprBits.ShouldPassAlignment; }
2333
2334 /// Answers whether the usual array deallocation function for the
2335 /// allocated type expects the size of the allocation as a
2336 /// parameter.
2337 bool doesUsualArrayDeleteWantSize() const {
2338 return CXXNewExprBits.UsualArrayDeleteWantsSize;
2339 }
2340
2341 using arg_iterator = ExprIterator;
2342 using const_arg_iterator = ConstExprIterator;
2343
2344 llvm::iterator_range<arg_iterator> placement_arguments() {
2345 return llvm::make_range(placement_arg_begin(), placement_arg_end());
2346 }
2347
2348 llvm::iterator_range<const_arg_iterator> placement_arguments() const {
2349 return llvm::make_range(placement_arg_begin(), placement_arg_end());
2350 }
2351
2352 arg_iterator placement_arg_begin() {
2353 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2354 }
2355 arg_iterator placement_arg_end() {
2356 return placement_arg_begin() + getNumPlacementArgs();
2357 }
2358 const_arg_iterator placement_arg_begin() const {
2359 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2360 }
2361 const_arg_iterator placement_arg_end() const {
2362 return placement_arg_begin() + getNumPlacementArgs();
2363 }
2364
2365 using raw_arg_iterator = Stmt **;
2366
2367 raw_arg_iterator raw_arg_begin() { return getTrailingObjects<Stmt *>(); }
2368 raw_arg_iterator raw_arg_end() {
2369 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2370 }
2371 const_arg_iterator raw_arg_begin() const {
2372 return getTrailingObjects<Stmt *>();
2373 }
2374 const_arg_iterator raw_arg_end() const {
2375 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2376 }
2377
2378 SourceLocation getBeginLoc() const { return Range.getBegin(); }
2379 SourceLocation getEndLoc() const { return Range.getEnd(); }
2380
2381 SourceRange getDirectInitRange() const { return DirectInitRange; }
2382 SourceRange getSourceRange() const { return Range; }
2383
2384 static bool classof(const Stmt *T) {
2385 return T->getStmtClass() == CXXNewExprClass;
2386 }
2387
2388 // Iterators
2389 child_range children() { return child_range(raw_arg_begin(), raw_arg_end()); }
2390
2391 const_child_range children() const {
2392 return const_child_range(const_cast<CXXNewExpr *>(this)->children());
2393 }
2394};
2395
2396/// Represents a \c delete expression for memory deallocation and
2397/// destructor calls, e.g. "delete[] pArray".
2398class CXXDeleteExpr : public Expr {
2399 friend class ASTStmtReader;
2400
2401 /// Points to the operator delete overload that is used. Could be a member.
2402 FunctionDecl *OperatorDelete = nullptr;
2403
2404 /// The pointer expression to be deleted.
2405 Stmt *Argument = nullptr;
2406
2407public:
2408 CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm,
2409 bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize,
2410 FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)
2411 : Expr(CXXDeleteExprClass, Ty, VK_PRValue, OK_Ordinary),
2412 OperatorDelete(OperatorDelete), Argument(Arg) {
2413 CXXDeleteExprBits.GlobalDelete = GlobalDelete;
2414 CXXDeleteExprBits.ArrayForm = ArrayForm;
2415 CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten;
2416 CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
2417 CXXDeleteExprBits.Loc = Loc;
2418 setDependence(computeDependence(this));
2419 }
2420
2421 explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {}
2422
2423 bool isGlobalDelete() const { return CXXDeleteExprBits.GlobalDelete; }
2424 bool isArrayForm() const { return CXXDeleteExprBits.ArrayForm; }
2425 bool isArrayFormAsWritten() const {
2426 return CXXDeleteExprBits.ArrayFormAsWritten;
2427 }
2428
2429 /// Answers whether the usual array deallocation function for the
2430 /// allocated type expects the size of the allocation as a
2431 /// parameter. This can be true even if the actual deallocation
2432 /// function that we're using doesn't want a size.
2433 bool doesUsualArrayDeleteWantSize() const {
2434 return CXXDeleteExprBits.UsualArrayDeleteWantsSize;
2435 }
2436
2437 FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
2438
2439 Expr *getArgument() { return cast<Expr>(Argument); }
2440 const Expr *getArgument() const { return cast<Expr>(Argument); }
2441
2442 /// Retrieve the type being destroyed.
2443 ///
2444 /// If the type being destroyed is a dependent type which may or may not
2445 /// be a pointer, return an invalid type.
2446 QualType getDestroyedType() const;
2447
2448 SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; }
2449 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
2450 return Argument->getEndLoc();
2451 }
2452
2453 static bool classof(const Stmt *T) {
2454 return T->getStmtClass() == CXXDeleteExprClass;
2455 }
2456
2457 // Iterators
2458 child_range children() { return child_range(&Argument, &Argument + 1); }
2459
2460 const_child_range children() const {
2461 return const_child_range(&Argument, &Argument + 1);
2462 }
2463};
2464
2465/// Stores the type being destroyed by a pseudo-destructor expression.
2466class PseudoDestructorTypeStorage {
2467 /// Either the type source information or the name of the type, if
2468 /// it couldn't be resolved due to type-dependence.
2469 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;
2470
2471 /// The starting source location of the pseudo-destructor type.
2472 SourceLocation Location;
2473
2474public:
2475 PseudoDestructorTypeStorage() = default;
2476
2477 PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
2478 : Type(II), Location(Loc) {}
2479
2480 PseudoDestructorTypeStorage(TypeSourceInfo *Info);
2481
2482 TypeSourceInfo *getTypeSourceInfo() const {
2483 return Type.dyn_cast<TypeSourceInfo *>();
2484 }
2485
2486 IdentifierInfo *getIdentifier() const {
2487 return Type.dyn_cast<IdentifierInfo *>();
2488 }
2489
2490 SourceLocation getLocation() const { return Location; }
2491};
2492
2493/// Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
2494///
2495/// A pseudo-destructor is an expression that looks like a member access to a
2496/// destructor of a scalar type, except that scalar types don't have
2497/// destructors. For example:
2498///
2499/// \code
2500/// typedef int T;
2501/// void f(int *p) {
2502/// p->T::~T();
2503/// }
2504/// \endcode
2505///
2506/// Pseudo-destructors typically occur when instantiating templates such as:
2507///
2508/// \code
2509/// template<typename T>
2510/// void destroy(T* ptr) {
2511/// ptr->T::~T();
2512/// }
2513/// \endcode
2514///
2515/// for scalar types. A pseudo-destructor expression has no run-time semantics
2516/// beyond evaluating the base expression.
2517class CXXPseudoDestructorExpr : public Expr {
2518 friend class ASTStmtReader;
2519
2520 /// The base expression (that is being destroyed).
2521 Stmt *Base = nullptr;
2522
2523 /// Whether the operator was an arrow ('->'); otherwise, it was a
2524 /// period ('.').
2525 bool IsArrow : 1;
2526
2527 /// The location of the '.' or '->' operator.
2528 SourceLocation OperatorLoc;
2529
2530 /// The nested-name-specifier that follows the operator, if present.
2531 NestedNameSpecifierLoc QualifierLoc;
2532
2533 /// The type that precedes the '::' in a qualified pseudo-destructor
2534 /// expression.
2535 TypeSourceInfo *ScopeType = nullptr;
2536
2537 /// The location of the '::' in a qualified pseudo-destructor
2538 /// expression.
2539 SourceLocation ColonColonLoc;
2540
2541 /// The location of the '~'.
2542 SourceLocation TildeLoc;
2543
2544 /// The type being destroyed, or its name if we were unable to
2545 /// resolve the name.
2546 PseudoDestructorTypeStorage DestroyedType;
2547
2548public:
2549 CXXPseudoDestructorExpr(const ASTContext &Context,
2550 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
2551 NestedNameSpecifierLoc QualifierLoc,
2552 TypeSourceInfo *ScopeType,
2553 SourceLocation ColonColonLoc,
2554 SourceLocation TildeLoc,
2555 PseudoDestructorTypeStorage DestroyedType);
2556
2557 explicit CXXPseudoDestructorExpr(EmptyShell Shell)
2558 : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {}
2559
2560 Expr *getBase() const { return cast<Expr>(Base); }
2561
2562 /// Determines whether this member expression actually had
2563 /// a C++ nested-name-specifier prior to the name of the member, e.g.,
2564 /// x->Base::foo.
2565 bool hasQualifier() const { return QualifierLoc.hasQualifier(); }
2566
2567 /// Retrieves the nested-name-specifier that qualifies the type name,
2568 /// with source-location information.
2569 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2570
2571 /// If the member name was qualified, retrieves the
2572 /// nested-name-specifier that precedes the member name. Otherwise, returns
2573 /// null.
2574 NestedNameSpecifier *getQualifier() const {
2575 return QualifierLoc.getNestedNameSpecifier();
2576 }
2577
2578 /// Determine whether this pseudo-destructor expression was written
2579 /// using an '->' (otherwise, it used a '.').
2580 bool isArrow() const { return IsArrow; }
2581
2582 /// Retrieve the location of the '.' or '->' operator.
2583 SourceLocation getOperatorLoc() const { return OperatorLoc; }
2584
2585 /// Retrieve the scope type in a qualified pseudo-destructor
2586 /// expression.
2587 ///
2588 /// Pseudo-destructor expressions can have extra qualification within them
2589 /// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
2590 /// Here, if the object type of the expression is (or may be) a scalar type,
2591 /// \p T may also be a scalar type and, therefore, cannot be part of a
2592 /// nested-name-specifier. It is stored as the "scope type" of the pseudo-
2593 /// destructor expression.
2594 TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; }
2595
2596 /// Retrieve the location of the '::' in a qualified pseudo-destructor
2597 /// expression.
2598 SourceLocation getColonColonLoc() const { return ColonColonLoc; }
2599
2600 /// Retrieve the location of the '~'.
2601 SourceLocation getTildeLoc() const { return TildeLoc; }
2602
2603 /// Retrieve the source location information for the type
2604 /// being destroyed.
2605 ///
2606 /// This type-source information is available for non-dependent
2607 /// pseudo-destructor expressions and some dependent pseudo-destructor
2608 /// expressions. Returns null if we only have the identifier for a
2609 /// dependent pseudo-destructor expression.
2610 TypeSourceInfo *getDestroyedTypeInfo() const {
2611 return DestroyedType.getTypeSourceInfo();
2612 }
2613
2614 /// In a dependent pseudo-destructor expression for which we do not
2615 /// have full type information on the destroyed type, provides the name
2616 /// of the destroyed type.
2617 IdentifierInfo *getDestroyedTypeIdentifier() const {
2618 return DestroyedType.getIdentifier();
2619 }
2620
2621 /// Retrieve the type being destroyed.
2622 QualType getDestroyedType() const;
2623
2624 /// Retrieve the starting location of the type being destroyed.
2625 SourceLocation getDestroyedTypeLoc() const {
2626 return DestroyedType.getLocation();
2627 }
2628
2629 /// Set the name of destroyed type for a dependent pseudo-destructor
2630 /// expression.
2631 void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
2632 DestroyedType = PseudoDestructorTypeStorage(II, Loc);
2633 }
2634
2635 /// Set the destroyed type.
2636 void setDestroyedType(TypeSourceInfo *Info) {
2637 DestroyedType = PseudoDestructorTypeStorage(Info);
2638 }
2639
2640 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
2641 return Base->getBeginLoc();
2642 }
2643 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
2644
2645 static bool classof(const Stmt *T) {
2646 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2647 }
2648
2649 // Iterators
2650 child_range children() { return child_range(&Base, &Base + 1); }
2651
2652 const_child_range children() const {
2653 return const_child_range(&Base, &Base + 1);
2654 }
2655};
2656
2657/// A type trait used in the implementation of various C++11 and
2658/// Library TR1 trait templates.
2659///
2660/// \code
2661/// __is_pod(int) == true
2662/// __is_enum(std::string) == false
2663/// __is_trivially_constructible(vector<int>, int*, int*)
2664/// \endcode
2665class TypeTraitExpr final
2666 : public Expr,
2667 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
2668 /// The location of the type trait keyword.
2669 SourceLocation Loc;
2670
2671 /// The location of the closing parenthesis.
2672 SourceLocation RParenLoc;
2673
2674 // Note: The TypeSourceInfos for the arguments are allocated after the
2675 // TypeTraitExpr.
2676
2677 TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
2678 ArrayRef<TypeSourceInfo *> Args,
2679 SourceLocation RParenLoc,
2680 bool Value);
2681
2682 TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) {}
2683
2684 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
2685 return getNumArgs();
2686 }
2687
2688public:
2689 friend class ASTStmtReader;
2690 friend class ASTStmtWriter;
2691 friend TrailingObjects;
2692
2693 /// Create a new type trait expression.
2694 static TypeTraitExpr *Create(const ASTContext &C, QualType T,
2695 SourceLocation Loc, TypeTrait Kind,
2696 ArrayRef<TypeSourceInfo *> Args,
2697 SourceLocation RParenLoc,
2698 bool Value);
2699
2700 static TypeTraitExpr *CreateDeserialized(const ASTContext &C,
2701 unsigned NumArgs);
2702
2703 /// Determine which type trait this expression uses.
2704 TypeTrait getTrait() const {
2705 return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
2706 }
2707
2708 bool getValue() const {
2709 assert(!isValueDependent())((void)0);
2710 return TypeTraitExprBits.Value;
2711 }
2712
2713 /// Determine the number of arguments to this type trait.
2714 unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }
2715
2716 /// Retrieve the Ith argument.
2717 TypeSourceInfo *getArg(unsigned I) const {
2718 assert(I < getNumArgs() && "Argument out-of-range")((void)0);
2719 return getArgs()[I];
2720 }
2721
2722 /// Retrieve the argument types.
2723 ArrayRef<TypeSourceInfo *> getArgs() const {
2724 return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(),
2725 getNumArgs());
2726 }
2727
2728 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
2729 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
2730
2731 static bool classof(const Stmt *T) {
2732 return T->getStmtClass() == TypeTraitExprClass;
2733 }
2734
2735 // Iterators
2736 child_range children() {
2737 return child_range(child_iterator(), child_iterator());
2738 }
2739
2740 const_child_range children() const {
2741 return const_child_range(const_child_iterator(), const_child_iterator());
2742 }
2743};
2744
2745/// An Embarcadero array type trait, as used in the implementation of
2746/// __array_rank and __array_extent.
2747///
2748/// Example:
2749/// \code
2750/// __array_rank(int[10][20]) == 2
2751/// __array_extent(int, 1) == 20
2752/// \endcode
2753class ArrayTypeTraitExpr : public Expr {
2754 /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
2755 unsigned ATT : 2;
2756
2757 /// The value of the type trait. Unspecified if dependent.
2758 uint64_t Value = 0;
2759
2760 /// The array dimension being queried, or -1 if not used.
2761 Expr *Dimension;
2762
2763 /// The location of the type trait keyword.
2764 SourceLocation Loc;
2765
2766 /// The location of the closing paren.
2767 SourceLocation RParen;
2768
2769 /// The type being queried.
2770 TypeSourceInfo *QueriedType = nullptr;
2771
2772public:
2773 friend class ASTStmtReader;
2774
2775 ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
2776 TypeSourceInfo *queried, uint64_t value, Expr *dimension,
2777 SourceLocation rparen, QualType ty)
2778 : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att),
2779 Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
2780 QueriedType(queried) {
2781 assert(att <= ATT_Last && "invalid enum value!")((void)0);
2782 assert(static_cast<unsigned>(att) == ATT && "ATT overflow!")((void)0);
2783 setDependence(computeDependence(this));
2784 }
2785
2786 explicit ArrayTypeTraitExpr(EmptyShell Empty)
2787 : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
2788
2789 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
2790 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }
2791
2792 ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
2793
2794 QualType getQueriedType() const { return QueriedType->getType(); }
2795
2796 TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
2797
2798 uint64_t getValue() const { assert(!isTypeDependent())((void)0); return Value; }
2799
2800 Expr *getDimensionExpression() const { return Dimension; }
2801
2802 static bool classof(const Stmt *T) {
2803 return T->getStmtClass() == ArrayTypeTraitExprClass;
2804 }
2805
2806 // Iterators
2807 child_range children() {
2808 return child_range(child_iterator(), child_iterator());
2809 }
2810
2811 const_child_range children() const {
2812 return const_child_range(const_child_iterator(), const_child_iterator());
2813 }
2814};
2815
2816/// An expression trait intrinsic.
2817///
2818/// Example:
2819/// \code
2820/// __is_lvalue_expr(std::cout) == true
2821/// __is_lvalue_expr(1) == false
2822/// \endcode
2823class ExpressionTraitExpr : public Expr {
2824 /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
2825 unsigned ET : 31;
2826
2827 /// The value of the type trait. Unspecified if dependent.
2828 unsigned Value : 1;
2829
2830 /// The location of the type trait keyword.
2831 SourceLocation Loc;
2832
2833 /// The location of the closing paren.
2834 SourceLocation RParen;
2835
2836 /// The expression being queried.
2837 Expr* QueriedExpression = nullptr;
2838
2839public:
2840 friend class ASTStmtReader;
2841
2842 ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried,
2843 bool value, SourceLocation rparen, QualType resultType)
2844 : Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
2845 ET(et), Value(value), Loc(loc), RParen(rparen),
2846 QueriedExpression(queried) {
2847 assert(et <= ET_Last && "invalid enum value!")((void)0);
2848 assert(static_cast<unsigned>(et) == ET && "ET overflow!")((void)0);
2849 setDependence(computeDependence(this));
2850 }
2851
2852 explicit ExpressionTraitExpr(EmptyShell Empty)
2853 : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}
2854
2855 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
2856 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }
2857
2858 ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
2859
2860 Expr *getQueriedExpression() const { return QueriedExpression; }
2861
2862 bool getValue() const { return Value; }
2863
2864 static bool classof(const Stmt *T) {
2865 return T->getStmtClass() == ExpressionTraitExprClass;
2866 }
2867
2868 // Iterators
2869 child_range children() {
2870 return child_range(child_iterator(), child_iterator());
2871 }
2872
2873 const_child_range children() const {
2874 return const_child_range(const_child_iterator(), const_child_iterator());
2875 }
2876};
2877
2878/// A reference to an overloaded function set, either an
2879/// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
2880class OverloadExpr : public Expr {
2881 friend class ASTStmtReader;
2882 friend class ASTStmtWriter;
2883
2884 /// The common name of these declarations.
2885 DeclarationNameInfo NameInfo;
2886
2887 /// The nested-name-specifier that qualifies the name, if any.
2888 NestedNameSpecifierLoc QualifierLoc;
2889
2890protected:
2891 OverloadExpr(StmtClass SC, const ASTContext &Context,
2892 NestedNameSpecifierLoc QualifierLoc,
2893 SourceLocation TemplateKWLoc,
2894 const DeclarationNameInfo &NameInfo,
2895 const TemplateArgumentListInfo *TemplateArgs,
2896 UnresolvedSetIterator Begin, UnresolvedSetIterator End,
2897 bool KnownDependent, bool KnownInstantiationDependent,
2898 bool KnownContainsUnexpandedParameterPack);
2899
2900 OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults,
2901 bool HasTemplateKWAndArgsInfo);
2902
2903 /// Return the results. Defined after UnresolvedMemberExpr.
2904 inline DeclAccessPair *getTrailingResults();
2905 const DeclAccessPair *getTrailingResults() const {
2906 return const_cast<OverloadExpr *>(this)->getTrailingResults();
2907 }
2908
2909 /// Return the optional template keyword and arguments info.
2910 /// Defined after UnresolvedMemberExpr.
2911 inline ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo();
2912 const ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo() const {
2913 return const_cast<OverloadExpr *>(this)
2914 ->getTrailingASTTemplateKWAndArgsInfo();
2915 }
2916
2917 /// Return the optional template arguments. Defined after
2918 /// UnresolvedMemberExpr.
2919 inline TemplateArgumentLoc *getTrailingTemplateArgumentLoc();
2920 const TemplateArgumentLoc *getTrailingTemplateArgumentLoc() const {
2921 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
2922 }
2923
2924 bool hasTemplateKWAndArgsInfo() const {
2925 return OverloadExprBits.HasTemplateKWAndArgsInfo;
2926 }
2927
2928public:
2929 struct FindResult {
2930 OverloadExpr *Expression;
2931 bool IsAddressOfOperand;
2932 bool HasFormOfMemberPointer;
2933 };
2934
2935 /// Finds the overloaded expression in the given expression \p E of
2936 /// OverloadTy.
2937 ///
2938 /// \return the expression (which must be there) and true if it has
2939 /// the particular form of a member pointer expression
2940 static FindResult find(Expr *E) {
2941 assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload))((void)0);
2942
2943 FindResult Result;
2944
2945 E = E->IgnoreParens();
2946 if (isa<UnaryOperator>(E)) {
2947 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf)((void)0);
2948 E = cast<UnaryOperator>(E)->getSubExpr();
2949 auto *Ovl = cast<OverloadExpr>(E->IgnoreParens());
2950
2951 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
2952 Result.IsAddressOfOperand = true;
2953 Result.Expression = Ovl;
2954 } else {
2955 Result.HasFormOfMemberPointer = false;
2956 Result.IsAddressOfOperand = false;
2957 Result.Expression = cast<OverloadExpr>(E);
2958 }
2959
2960 return Result;
2961 }
2962
2963 /// Gets the naming class of this lookup, if any.
2964 /// Defined after UnresolvedMemberExpr.
2965 inline CXXRecordDecl *getNamingClass();
2966 const CXXRecordDecl *getNamingClass() const {
2967 return const_cast<OverloadExpr *>(this)->getNamingClass();
2968 }
2969
2970 using decls_iterator = UnresolvedSetImpl::iterator;
2971
2972 decls_iterator decls_begin() const {
2973 return UnresolvedSetIterator(getTrailingResults());
2974 }
2975 decls_iterator decls_end() const {
2976 return UnresolvedSetIterator(getTrailingResults() + getNumDecls());
2977 }
2978 llvm::iterator_range<decls_iterator> decls() const {
2979 return llvm::make_range(decls_begin(), decls_end());
2980 }
2981
2982 /// Gets the number of declarations in the unresolved set.
2983 unsigned getNumDecls() const { return OverloadExprBits.NumResults; }
2984
2985 /// Gets the full name info.
2986 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2987
2988 /// Gets the name looked up.
2989 DeclarationName getName() const { return NameInfo.getName(); }
2990
2991 /// Gets the location of the name.
2992 SourceLocation getNameLoc() const { return NameInfo.getLoc(); }
2993
2994 /// Fetches the nested-name qualifier, if one was given.
2995 NestedNameSpecifier *getQualifier() const {
2996 return QualifierLoc.getNestedNameSpecifier();
2997 }
2998
2999 /// Fetches the nested-name qualifier with source-location
3000 /// information, if one was given.
3001 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3002
3003 /// Retrieve the location of the template keyword preceding
3004 /// this name, if any.
3005 SourceLocation getTemplateKeywordLoc() const {
3006 if (!hasTemplateKWAndArgsInfo())
3007 return SourceLocation();
3008 return getTrailingASTTemplateKWAndArgsInfo()->TemplateKWLoc;
3009 }
3010
3011 /// Retrieve the location of the left angle bracket starting the
3012 /// explicit template argument list following the name, if any.
3013 SourceLocation getLAngleLoc() const {
3014 if (!hasTemplateKWAndArgsInfo())
3015 return SourceLocation();
3016 return getTrailingASTTemplateKWAndArgsInfo()->LAngleLoc;
3017 }
3018
3019 /// Retrieve the location of the right angle bracket ending the
3020 /// explicit template argument list following the name, if any.
3021 SourceLocation getRAngleLoc() const {
3022 if (!hasTemplateKWAndArgsInfo())
3023 return SourceLocation();
3024 return getTrailingASTTemplateKWAndArgsInfo()->RAngleLoc;
3025 }
3026
3027 /// Determines whether the name was preceded by the template keyword.
3028 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3029
3030 /// Determines whether this expression had explicit template arguments.
3031 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3032
3033 TemplateArgumentLoc const *getTemplateArgs() const {
3034 if (!hasExplicitTemplateArgs())
3035 return nullptr;
3036 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
3037 }
3038
3039 unsigned getNumTemplateArgs() const {
3040 if (!hasExplicitTemplateArgs())
3041 return 0;
3042
3043 return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs;
3044 }
3045
3046 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3047 return {getTemplateArgs(), getNumTemplateArgs()};
3048 }
3049
3050 /// Copies the template arguments into the given structure.
3051 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3052 if (hasExplicitTemplateArgs())
3053 getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List);
3054 }
3055
3056 static bool classof(const Stmt *T) {
3057 return T->getStmtClass() == UnresolvedLookupExprClass ||
3058 T->getStmtClass() == UnresolvedMemberExprClass;
3059 }
3060};
3061
3062/// A reference to a name which we were able to look up during
3063/// parsing but could not resolve to a specific declaration.
3064///
3065/// This arises in several ways:
3066/// * we might be waiting for argument-dependent lookup;
3067/// * the name might resolve to an overloaded function;
3068/// and eventually:
3069/// * the lookup might have included a function template.
3070///
3071/// These never include UnresolvedUsingValueDecls, which are always class
3072/// members and therefore appear only in UnresolvedMemberLookupExprs.
3073class UnresolvedLookupExpr final
3074 : public OverloadExpr,
3075 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
3076 ASTTemplateKWAndArgsInfo,
3077 TemplateArgumentLoc> {
3078 friend class ASTStmtReader;
3079 friend class OverloadExpr;
3080 friend TrailingObjects;
3081
3082 /// The naming class (C++ [class.access.base]p5) of the lookup, if
3083 /// any. This can generally be recalculated from the context chain,
3084 /// but that can be fairly expensive for unqualified lookups.
3085 CXXRecordDecl *NamingClass;
3086
3087 // UnresolvedLookupExpr is followed by several trailing objects.
3088 // They are in order:
3089 //
3090 // * An array of getNumResults() DeclAccessPair for the results. These are
3091 // undesugared, which is to say, they may include UsingShadowDecls.
3092 // Access is relative to the naming class.
3093 //
3094 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3095 // template keyword and arguments. Present if and only if
3096 // hasTemplateKWAndArgsInfo().
3097 //
3098 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing
3099 // location information for the explicitly specified template arguments.
3100
3101 UnresolvedLookupExpr(const ASTContext &Context, CXXRecordDecl *NamingClass,
3102 NestedNameSpecifierLoc QualifierLoc,
3103 SourceLocation TemplateKWLoc,
3104 const DeclarationNameInfo &NameInfo, bool RequiresADL,
3105 bool Overloaded,
3106 const TemplateArgumentListInfo *TemplateArgs,
3107 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3108
3109 UnresolvedLookupExpr(EmptyShell Empty, unsigned NumResults,
3110 bool HasTemplateKWAndArgsInfo);
3111
3112 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const {
3113 return getNumDecls();
3114 }
3115
3116 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3117 return hasTemplateKWAndArgsInfo();
3118 }
3119
3120public:
3121 static UnresolvedLookupExpr *
3122 Create(const ASTContext &Context, CXXRecordDecl *NamingClass,
3123 NestedNameSpecifierLoc QualifierLoc,
3124 const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded,
3125 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3126
3127 static UnresolvedLookupExpr *
3128 Create(const ASTContext &Context, CXXRecordDecl *NamingClass,
3129 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3130 const DeclarationNameInfo &NameInfo, bool RequiresADL,
3131 const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,
3132 UnresolvedSetIterator End);
3133
3134 static UnresolvedLookupExpr *CreateEmpty(const ASTContext &Context,
3135 unsigned NumResults,
3136 bool HasTemplateKWAndArgsInfo,
3137 unsigned NumTemplateArgs);
3138
3139 /// True if this declaration should be extended by
3140 /// argument-dependent lookup.
3141 bool requiresADL() const { return UnresolvedLookupExprBits.RequiresADL; }
3142
3143 /// True if this lookup is overloaded.
3144 bool isOverloaded() const { return UnresolvedLookupExprBits.Overloaded; }
3145
3146 /// Gets the 'naming class' (in the sense of C++0x
3147 /// [class.access.base]p5) of the lookup. This is the scope
3148 /// that was looked in to find these results.
3149 CXXRecordDecl *getNamingClass() { return NamingClass; }
3150 const CXXRecordDecl *getNamingClass() const { return NamingClass; }
3151
3152 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
3153 if (NestedNameSpecifierLoc l = getQualifierLoc())
3154 return l.getBeginLoc();
3155 return getNameInfo().getBeginLoc();
3156 }
3157
3158 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3159 if (hasExplicitTemplateArgs())
3160 return getRAngleLoc();
3161 return getNameInfo().getEndLoc();
3162 }
3163
3164 child_range children() {
3165 return child_range(child_iterator(), child_iterator());
3166 }
3167
3168 const_child_range children() const {
3169 return const_child_range(const_child_iterator(), const_child_iterator());
3170 }
3171
3172 static bool classof(const Stmt *T) {
3173 return T->getStmtClass() == UnresolvedLookupExprClass;
3174 }
3175};
3176
3177/// A qualified reference to a name whose declaration cannot
3178/// yet be resolved.
3179///
3180/// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
3181/// it expresses a reference to a declaration such as
3182/// X<T>::value. The difference, however, is that an
3183/// DependentScopeDeclRefExpr node is used only within C++ templates when
3184/// the qualification (e.g., X<T>::) refers to a dependent type. In
3185/// this case, X<T>::value cannot resolve to a declaration because the
3186/// declaration will differ from one instantiation of X<T> to the
3187/// next. Therefore, DependentScopeDeclRefExpr keeps track of the
3188/// qualifier (X<T>::) and the name of the entity being referenced
3189/// ("value"). Such expressions will instantiate to a DeclRefExpr once the
3190/// declaration can be found.
3191class DependentScopeDeclRefExpr final
3192 : public Expr,
3193 private llvm::TrailingObjects<DependentScopeDeclRefExpr,
3194 ASTTemplateKWAndArgsInfo,
3195 TemplateArgumentLoc> {
3196 friend class ASTStmtReader;
3197 friend class ASTStmtWriter;
3198 friend TrailingObjects;
3199
3200 /// The nested-name-specifier that qualifies this unresolved
3201 /// declaration name.
3202 NestedNameSpecifierLoc QualifierLoc;
3203
3204 /// The name of the entity we will be referencing.
3205 DeclarationNameInfo NameInfo;
3206
3207 DependentScopeDeclRefExpr(QualType Ty, NestedNameSpecifierLoc QualifierLoc,
3208 SourceLocation TemplateKWLoc,
3209 const DeclarationNameInfo &NameInfo,
3210 const TemplateArgumentListInfo *Args);
3211
3212 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3213 return hasTemplateKWAndArgsInfo();
3214 }
3215
3216 bool hasTemplateKWAndArgsInfo() const {
3217 return DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo;
3218 }
3219
3220public:
3221 static DependentScopeDeclRefExpr *
3222 Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
3223 SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
3224 const TemplateArgumentListInfo *TemplateArgs);
3225
3226 static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &Context,
3227 bool HasTemplateKWAndArgsInfo,
3228 unsigned NumTemplateArgs);
3229
3230 /// Retrieve the name that this expression refers to.
3231 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3232
3233 /// Retrieve the name that this expression refers to.
3234 DeclarationName getDeclName() const { return NameInfo.getName(); }
3235
3236 /// Retrieve the location of the name within the expression.
3237 ///
3238 /// For example, in "X<T>::value" this is the location of "value".
3239 SourceLocation getLocation() const { return NameInfo.getLoc(); }
3240
3241 /// Retrieve the nested-name-specifier that qualifies the
3242 /// name, with source location information.
3243 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3244
3245 /// Retrieve the nested-name-specifier that qualifies this
3246 /// declaration.
3247 NestedNameSpecifier *getQualifier() const {
3248 return QualifierLoc.getNestedNameSpecifier();
3249 }
3250
3251 /// Retrieve the location of the template keyword preceding
3252 /// this name, if any.
3253 SourceLocation getTemplateKeywordLoc() const {
3254 if (!hasTemplateKWAndArgsInfo())
3255 return SourceLocation();
3256 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3257 }
3258
3259 /// Retrieve the location of the left angle bracket starting the
3260 /// explicit template argument list following the name, if any.
3261 SourceLocation getLAngleLoc() const {
3262 if (!hasTemplateKWAndArgsInfo())
3263 return SourceLocation();
3264 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3265 }
3266
3267 /// Retrieve the location of the right angle bracket ending the
3268 /// explicit template argument list following the name, if any.
3269 SourceLocation getRAngleLoc() const {
3270 if (!hasTemplateKWAndArgsInfo())
3271 return SourceLocation();
3272 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3273 }
3274
3275 /// Determines whether the name was preceded by the template keyword.
3276 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3277
3278 /// Determines whether this lookup had explicit template arguments.
3279 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3280
3281 /// Copies the template arguments (if present) into the given
3282 /// structure.
3283 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3284 if (hasExplicitTemplateArgs())
3285 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3286 getTrailingObjects<TemplateArgumentLoc>(), List);
3287 }
3288
3289 TemplateArgumentLoc const *getTemplateArgs() const {
3290 if (!hasExplicitTemplateArgs())
3291 return nullptr;
3292
3293 return getTrailingObjects<TemplateArgumentLoc>();
3294 }
3295
3296 unsigned getNumTemplateArgs() const {
3297 if (!hasExplicitTemplateArgs())
3298 return 0;
3299
3300 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3301 }
3302
3303 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3304 return {getTemplateArgs(), getNumTemplateArgs()};
3305 }
3306
3307 /// Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr,
3308 /// and differs from getLocation().getStart().
3309 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
3310 return QualifierLoc.getBeginLoc();
3311 }
3312
3313 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3314 if (hasExplicitTemplateArgs())
3315 return getRAngleLoc();
3316 return getLocation();
3317 }
3318
3319 static bool classof(const Stmt *T) {
3320 return T->getStmtClass() == DependentScopeDeclRefExprClass;
3321 }
3322
3323 child_range children() {
3324 return child_range(child_iterator(), child_iterator());
3325 }
3326
3327 const_child_range children() const {
3328 return const_child_range(const_child_iterator(), const_child_iterator());
3329 }
3330};
3331
3332/// Represents an expression -- generally a full-expression -- that
3333/// introduces cleanups to be run at the end of the sub-expression's
3334/// evaluation. The most common source of expression-introduced
3335/// cleanups is temporary objects in C++, but several other kinds of
3336/// expressions can create cleanups, including basically every
3337/// call in ARC that returns an Objective-C pointer.
3338///
3339/// This expression also tracks whether the sub-expression contains a
3340/// potentially-evaluated block literal. The lifetime of a block
3341/// literal is the extent of the enclosing scope.
3342class ExprWithCleanups final
3343 : public FullExpr,
3344 private llvm::TrailingObjects<
3345 ExprWithCleanups,
3346 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
3347public:
3348 /// The type of objects that are kept in the cleanup.
3349 /// It's useful to remember the set of blocks and block-scoped compound
3350 /// literals; we could also remember the set of temporaries, but there's
3351 /// currently no need.
3352 using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>;
3353
3354private:
3355 friend class ASTStmtReader;
3356 friend TrailingObjects;
3357
3358 ExprWithCleanups(EmptyShell, unsigned NumObjects);
3359 ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
3360 ArrayRef<CleanupObject> Objects);
3361
3362public:
3363 static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty,
3364 unsigned numObjects);
3365
3366 static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
3367 bool CleanupsHaveSideEffects,
3368 ArrayRef<CleanupObject> objects);
3369
3370 ArrayRef<CleanupObject> getObjects() const {
3371 return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(),
3372 getNumObjects());
3373 }
3374
3375 unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
3376
3377 CleanupObject getObject(unsigned i) const {
3378 assert(i < getNumObjects() && "Index out of range")((void)0);
3379 return getObjects()[i];
3380 }
3381
3382 bool cleanupsHaveSideEffects() const {
3383 return ExprWithCleanupsBits.CleanupsHaveSideEffects;
3384 }
3385
3386 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
3387 return SubExpr->getBeginLoc();
3388 }
3389
3390 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3391 return SubExpr->getEndLoc();
3392 }
3393
3394 // Implement isa/cast/dyncast/etc.
3395 static bool classof(const Stmt *T) {
3396 return T->getStmtClass() == ExprWithCleanupsClass;
3397 }
3398
3399 // Iterators
3400 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
3401
3402 const_child_range children() const {
3403 return const_child_range(&SubExpr, &SubExpr + 1);
3404 }
3405};
3406
3407/// Describes an explicit type conversion that uses functional
3408/// notion but could not be resolved because one or more arguments are
3409/// type-dependent.
3410///
3411/// The explicit type conversions expressed by
3412/// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
3413/// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
3414/// either \c T is a dependent type or one or more of the <tt>a</tt>'s is
3415/// type-dependent. For example, this would occur in a template such
3416/// as:
3417///
3418/// \code
3419/// template<typename T, typename A1>
3420/// inline T make_a(const A1& a1) {
3421/// return T(a1);
3422/// }
3423/// \endcode
3424///
3425/// When the returned expression is instantiated, it may resolve to a
3426/// constructor call, conversion function call, or some kind of type
3427/// conversion.
3428class CXXUnresolvedConstructExpr final
3429 : public Expr,
3430 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3431 friend class ASTStmtReader;
3432 friend TrailingObjects;
3433
3434 /// The type being constructed.
3435 TypeSourceInfo *TSI;
3436
3437 /// The location of the left parentheses ('(').
3438 SourceLocation LParenLoc;
3439
3440 /// The location of the right parentheses (')').
3441 SourceLocation RParenLoc;
3442
3443 CXXUnresolvedConstructExpr(QualType T, TypeSourceInfo *TSI,
3444 SourceLocation LParenLoc, ArrayRef<Expr *> Args,
3445 SourceLocation RParenLoc);
3446
3447 CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
3448 : Expr(CXXUnresolvedConstructExprClass, Empty), TSI(nullptr) {
3449 CXXUnresolvedConstructExprBits.NumArgs = NumArgs;
3450 }
3451
3452public:
3453 static CXXUnresolvedConstructExpr *Create(const ASTContext &Context,
3454 QualType T, TypeSourceInfo *TSI,
3455 SourceLocation LParenLoc,
3456 ArrayRef<Expr *> Args,
3457 SourceLocation RParenLoc);
3458
3459 static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &Context,
3460 unsigned NumArgs);
3461
3462 /// Retrieve the type that is being constructed, as specified
3463 /// in the source code.
3464 QualType getTypeAsWritten() const { return TSI->getType(); }
3465
3466 /// Retrieve the type source information for the type being
3467 /// constructed.
3468 TypeSourceInfo *getTypeSourceInfo() const { return TSI; }
3469
3470 /// Retrieve the location of the left parentheses ('(') that
3471 /// precedes the argument list.
3472 SourceLocation getLParenLoc() const { return LParenLoc; }
3473 void setLParenLoc(SourceLocation L) { LParenLoc = L; }
3474
3475 /// Retrieve the location of the right parentheses (')') that
3476 /// follows the argument list.
3477 SourceLocation getRParenLoc() const { return RParenLoc; }
3478 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3479
3480 /// Determine whether this expression models list-initialization.
3481 /// If so, there will be exactly one subexpression, which will be
3482 /// an InitListExpr.
3483 bool isListInitialization() const { return LParenLoc.isInvalid(); }
3484
3485 /// Retrieve the number of arguments.
3486 unsigned getNumArgs() const { return CXXUnresolvedConstructExprBits.NumArgs; }
3487
3488 using arg_iterator = Expr **;
3489 using arg_range = llvm::iterator_range<arg_iterator>;
3490
3491 arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); }
3492 arg_iterator arg_end() { return arg_begin() + getNumArgs(); }
3493 arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
3494
3495 using const_arg_iterator = const Expr* const *;
3496 using const_arg_range = llvm::iterator_range<const_arg_iterator>;
3497
3498 const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); }
3499 const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }
3500 const_arg_range arguments() const {
3501 return const_arg_range(arg_begin(), arg_end());
3502 }
3503
3504 Expr *getArg(unsigned I) {
3505 assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
3506 return arg_begin()[I];
3507 }
3508
3509 const Expr *getArg(unsigned I) const {
3510 assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
3511 return arg_begin()[I];
3512 }
3513
3514 void setArg(unsigned I, Expr *E) {
3515 assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
3516 arg_begin()[I] = E;
3517 }
3518
3519 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
3520 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3521 if (!RParenLoc.isValid() && getNumArgs() > 0)
3522 return getArg(getNumArgs() - 1)->getEndLoc();
3523 return RParenLoc;
3524 }
3525
3526 static bool classof(const Stmt *T) {
3527 return T->getStmtClass() == CXXUnresolvedConstructExprClass;
3528 }
3529
3530 // Iterators
3531 child_range children() {
3532 auto **begin = reinterpret_cast<Stmt **>(arg_begin());
3533 return child_range(begin, begin + getNumArgs());
3534 }
3535
3536 const_child_range children() const {
3537 auto **begin = reinterpret_cast<Stmt **>(
3538 const_cast<CXXUnresolvedConstructExpr *>(this)->arg_begin());
3539 return const_child_range(begin, begin + getNumArgs());
3540 }
3541};
3542
3543/// Represents a C++ member access expression where the actual
3544/// member referenced could not be resolved because the base
3545/// expression or the member name was dependent.
3546///
3547/// Like UnresolvedMemberExprs, these can be either implicit or
3548/// explicit accesses. It is only possible to get one of these with
3549/// an implicit access if a qualifier is provided.
3550class CXXDependentScopeMemberExpr final
3551 : public Expr,
3552 private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
3553 ASTTemplateKWAndArgsInfo,
3554 TemplateArgumentLoc, NamedDecl *> {
3555 friend class ASTStmtReader;
3556 friend class ASTStmtWriter;
3557 friend TrailingObjects;
3558
3559 /// The expression for the base pointer or class reference,
3560 /// e.g., the \c x in x.f. Can be null in implicit accesses.
3561 Stmt *Base;
3562
3563 /// The type of the base expression. Never null, even for
3564 /// implicit accesses.
3565 QualType BaseType;
3566
3567 /// The nested-name-specifier that precedes the member name, if any.
3568 /// FIXME: This could be in principle store as a trailing object.
3569 /// However the performance impact of doing so should be investigated first.
3570 NestedNameSpecifierLoc QualifierLoc;
3571
3572 /// The member to which this member expression refers, which
3573 /// can be name, overloaded operator, or destructor.
3574 ///
3575 /// FIXME: could also be a template-id
3576 DeclarationNameInfo MemberNameInfo;
3577
3578 // CXXDependentScopeMemberExpr is followed by several trailing objects,
3579 // some of which optional. They are in order:
3580 //
3581 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3582 // template keyword and arguments. Present if and only if
3583 // hasTemplateKWAndArgsInfo().
3584 //
3585 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing location
3586 // information for the explicitly specified template arguments.
3587 //
3588 // * An optional NamedDecl *. In a qualified member access expression such
3589 // as t->Base::f, this member stores the resolves of name lookup in the
3590 // context of the member access expression, to be used at instantiation
3591 // time. Present if and only if hasFirstQualifierFoundInScope().
3592
3593 bool hasTemplateKWAndArgsInfo() const {
3594 return CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo;
3595 }
3596
3597 bool hasFirstQualifierFoundInScope() const {
3598 return CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope;
3599 }
3600
3601 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3602 return hasTemplateKWAndArgsInfo();
3603 }
3604
3605 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
3606 return getNumTemplateArgs();
3607 }
3608
3609 unsigned numTrailingObjects(OverloadToken<NamedDecl *>) const {
3610 return hasFirstQualifierFoundInScope();
3611 }
3612
3613 CXXDependentScopeMemberExpr(const ASTContext &Ctx, Expr *Base,
3614 QualType BaseType, bool IsArrow,
3615 SourceLocation OperatorLoc,
3616 NestedNameSpecifierLoc QualifierLoc,
3617 SourceLocation TemplateKWLoc,
3618 NamedDecl *FirstQualifierFoundInScope,
3619 DeclarationNameInfo MemberNameInfo,
3620 const TemplateArgumentListInfo *TemplateArgs);
3621
3622 CXXDependentScopeMemberExpr(EmptyShell Empty, bool HasTemplateKWAndArgsInfo,
3623 bool HasFirstQualifierFoundInScope);
3624
3625public:
3626 static CXXDependentScopeMemberExpr *
3627 Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
3628 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
3629 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
3630 DeclarationNameInfo MemberNameInfo,
3631 const TemplateArgumentListInfo *TemplateArgs);
3632
3633 static CXXDependentScopeMemberExpr *
3634 CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo,
3635 unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope);
3636
3637 /// True if this is an implicit access, i.e. one in which the
3638 /// member being accessed was not written in the source. The source
3639 /// location of the operator is invalid in this case.
3640 bool isImplicitAccess() const {
3641 if (!Base)
3642 return true;
3643 return cast<Expr>(Base)->isImplicitCXXThis();
3644 }
3645
3646 /// Retrieve the base object of this member expressions,
3647 /// e.g., the \c x in \c x.m.
3648 Expr *getBase() const {
3649 assert(!isImplicitAccess())((void)0);
3650 return cast<Expr>(Base);
3651 }
3652
3653 QualType getBaseType() const { return BaseType; }
3654
3655 /// Determine whether this member expression used the '->'
3656 /// operator; otherwise, it used the '.' operator.
3657 bool isArrow() const { return CXXDependentScopeMemberExprBits.IsArrow; }
3658
3659 /// Retrieve the location of the '->' or '.' operator.
3660 SourceLocation getOperatorLoc() const {
3661 return CXXDependentScopeMemberExprBits.OperatorLoc;
3662 }
3663
3664 /// Retrieve the nested-name-specifier that qualifies the member name.
3665 NestedNameSpecifier *getQualifier() const {
3666 return QualifierLoc.getNestedNameSpecifier();
3667 }
3668
3669 /// Retrieve the nested-name-specifier that qualifies the member
3670 /// name, with source location information.
3671 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3672
3673 /// Retrieve the first part of the nested-name-specifier that was
3674 /// found in the scope of the member access expression when the member access
3675 /// was initially parsed.
3676 ///
3677 /// This function only returns a useful result when member access expression
3678 /// uses a qualified member name, e.g., "x.Base::f". Here, the declaration
3679 /// returned by this function describes what was found by unqualified name
3680 /// lookup for the identifier "Base" within the scope of the member access
3681 /// expression itself. At template instantiation time, this information is
3682 /// combined with the results of name lookup into the type of the object
3683 /// expression itself (the class type of x).
3684 NamedDecl *getFirstQualifierFoundInScope() const {
3685 if (!hasFirstQualifierFoundInScope())
3686 return nullptr;
3687 return *getTrailingObjects<NamedDecl *>();
3688 }
3689
3690 /// Retrieve the name of the member that this expression refers to.
3691 const DeclarationNameInfo &getMemberNameInfo() const {
3692 return MemberNameInfo;
3693 }
3694
3695 /// Retrieve the name of the member that this expression refers to.
3696 DeclarationName getMember() const { return MemberNameInfo.getName(); }
3697
3698 // Retrieve the location of the name of the member that this
3699 // expression refers to.
3700 SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); }
3701
3702 /// Retrieve the location of the template keyword preceding the
3703 /// member name, if any.
3704 SourceLocation getTemplateKeywordLoc() const {
3705 if (!hasTemplateKWAndArgsInfo())
3706 return SourceLocation();
3707 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3708 }
3709
3710 /// Retrieve the location of the left angle bracket starting the
3711 /// explicit template argument list following the member name, if any.
3712 SourceLocation getLAngleLoc() const {
3713 if (!hasTemplateKWAndArgsInfo())
3714 return SourceLocation();
3715 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3716 }
3717
3718 /// Retrieve the location of the right angle bracket ending the
3719 /// explicit template argument list following the member name, if any.
3720 SourceLocation getRAngleLoc() const {
3721 if (!hasTemplateKWAndArgsInfo())
3722 return SourceLocation();
3723 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3724 }
3725
3726 /// Determines whether the member name was preceded by the template keyword.
3727 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3728
3729 /// Determines whether this member expression actually had a C++
3730 /// template argument list explicitly specified, e.g., x.f<int>.
3731 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3732
3733 /// Copies the template arguments (if present) into the given
3734 /// structure.
3735 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3736 if (hasExplicitTemplateArgs())
3737 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3738 getTrailingObjects<TemplateArgumentLoc>(), List);
3739 }
3740
3741 /// Retrieve the template arguments provided as part of this
3742 /// template-id.
3743 const TemplateArgumentLoc *getTemplateArgs() const {
3744 if (!hasExplicitTemplateArgs())
3745 return nullptr;
3746
3747 return getTrailingObjects<TemplateArgumentLoc>();
3748 }
3749
3750 /// Retrieve the number of template arguments provided as part of this
3751 /// template-id.
3752 unsigned getNumTemplateArgs() const {
3753 if (!hasExplicitTemplateArgs())
3754 return 0;
3755
3756 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3757 }
3758
3759 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3760 return {getTemplateArgs(), getNumTemplateArgs()};
3761 }
3762
3763 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
3764 if (!isImplicitAccess())
3765 return Base->getBeginLoc();
3766 if (getQualifier())
3767 return getQualifierLoc().getBeginLoc();
3768 return MemberNameInfo.getBeginLoc();
3769 }
3770
3771 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3772 if (hasExplicitTemplateArgs())
3773 return getRAngleLoc();
3774 return MemberNameInfo.getEndLoc();
3775 }
3776
3777 static bool classof(const Stmt *T) {
3778 return T->getStmtClass() == CXXDependentScopeMemberExprClass;
3779 }
3780
3781 // Iterators
3782 child_range children() {
3783 if (isImplicitAccess())
3784 return child_range(child_iterator(), child_iterator());
3785 return child_range(&Base, &Base + 1);
3786 }
3787
3788 const_child_range children() const {
3789 if (isImplicitAccess())
3790 return const_child_range(const_child_iterator(), const_child_iterator());
3791 return const_child_range(&Base, &Base + 1);
3792 }
3793};
3794
3795/// Represents a C++ member access expression for which lookup
3796/// produced a set of overloaded functions.
3797///
3798/// The member access may be explicit or implicit:
3799/// \code
3800/// struct A {
3801/// int a, b;
3802/// int explicitAccess() { return this->a + this->A::b; }
3803/// int implicitAccess() { return a + A::b; }
3804/// };
3805/// \endcode
3806///
3807/// In the final AST, an explicit access always becomes a MemberExpr.
3808/// An implicit access may become either a MemberExpr or a
3809/// DeclRefExpr, depending on whether the member is static.
3810class UnresolvedMemberExpr final
3811 : public OverloadExpr,
3812 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair,
3813 ASTTemplateKWAndArgsInfo,
3814 TemplateArgumentLoc> {
3815 friend class ASTStmtReader;
3816 friend class OverloadExpr;
3817 friend TrailingObjects;
3818
3819 /// The expression for the base pointer or class reference,
3820 /// e.g., the \c x in x.f.
3821 ///
3822 /// This can be null if this is an 'unbased' member expression.
3823 Stmt *Base;
3824
3825 /// The type of the base expression; never null.
3826 QualType BaseType;
3827
3828 /// The location of the '->' or '.' operator.
3829 SourceLocation OperatorLoc;
3830
3831 // UnresolvedMemberExpr is followed by several trailing objects.
3832 // They are in order:
3833 //
3834 // * An array of getNumResults() DeclAccessPair for the results. These are
3835 // undesugared, which is to say, they may include UsingShadowDecls.
3836 // Access is relative to the naming class.
3837 //
3838 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3839 // template keyword and arguments. Present if and only if
3840 // hasTemplateKWAndArgsInfo().
3841 //
3842 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing
3843 // location information for the explicitly specified template arguments.
3844
3845 UnresolvedMemberExpr(const ASTContext &Context, bool HasUnresolvedUsing,
3846 Expr *Base, QualType BaseType, bool IsArrow,
3847 SourceLocation OperatorLoc,
3848 NestedNameSpecifierLoc QualifierLoc,
3849 SourceLocation TemplateKWLoc,
3850 const DeclarationNameInfo &MemberNameInfo,
3851 const TemplateArgumentListInfo *TemplateArgs,
3852 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3853
3854 UnresolvedMemberExpr(EmptyShell Empty, unsigned NumResults,
3855 bool HasTemplateKWAndArgsInfo);
3856
3857 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const {
3858 return getNumDecls();
3859 }
3860
3861 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3862 return hasTemplateKWAndArgsInfo();
3863 }
3864
3865public:
3866 static UnresolvedMemberExpr *
3867 Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
3868 QualType BaseType, bool IsArrow, SourceLocation OperatorLoc,
3869 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3870 const DeclarationNameInfo &MemberNameInfo,
3871 const TemplateArgumentListInfo *TemplateArgs,
3872 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3873
3874 static UnresolvedMemberExpr *CreateEmpty(const ASTContext &Context,
3875 unsigned NumResults,
3876 bool HasTemplateKWAndArgsInfo,
3877 unsigned NumTemplateArgs);
3878
3879 /// True if this is an implicit access, i.e., one in which the
3880 /// member being accessed was not written in the source.
3881 ///
3882 /// The source location of the operator is invalid in this case.
3883 bool isImplicitAccess() const;
3884
3885 /// Retrieve the base object of this member expressions,
3886 /// e.g., the \c x in \c x.m.
3887 Expr *getBase() {
3888 assert(!isImplicitAccess())((void)0);
3889 return cast<Expr>(Base);
3890 }
3891 const Expr *getBase() const {
3892 assert(!isImplicitAccess())((void)0);
3893 return cast<Expr>(Base);
3894 }
3895
3896 QualType getBaseType() const { return BaseType; }
3897
3898 /// Determine whether the lookup results contain an unresolved using
3899 /// declaration.
3900 bool hasUnresolvedUsing() const {
3901 return UnresolvedMemberExprBits.HasUnresolvedUsing;
3902 }
3903
3904 /// Determine whether this member expression used the '->'
3905 /// operator; otherwise, it used the '.' operator.
3906 bool isArrow() const { return UnresolvedMemberExprBits.IsArrow; }
3907
3908 /// Retrieve the location of the '->' or '.' operator.
3909 SourceLocation getOperatorLoc() const { return OperatorLoc; }
3910
3911 /// Retrieve the naming class of this lookup.
3912 CXXRecordDecl *getNamingClass();
3913 const CXXRecordDecl *getNamingClass() const {
3914 return const_cast<UnresolvedMemberExpr *>(this)->getNamingClass();
3915 }
3916
3917 /// Retrieve the full name info for the member that this expression
3918 /// refers to.
3919 const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); }
3920
3921 /// Retrieve the name of the member that this expression refers to.
3922 DeclarationName getMemberName() const { return getName(); }
3923
3924 /// Retrieve the location of the name of the member that this
3925 /// expression refers to.
3926 SourceLocation getMemberLoc() const { return getNameLoc(); }
3927
3928 /// Return the preferred location (the member name) for the arrow when
3929 /// diagnosing a problem with this expression.
3930 SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return getMemberLoc(); }
3931
3932 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
3933 if (!isImplicitAccess())
3934 return Base->getBeginLoc();
3935 if (NestedNameSpecifierLoc l = getQualifierLoc())
3936 return l.getBeginLoc();
3937 return getMemberNameInfo().getBeginLoc();
3938 }
3939
3940 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
3941 if (hasExplicitTemplateArgs())
3942 return getRAngleLoc();
3943 return getMemberNameInfo().getEndLoc();
3944 }
3945
3946 static bool classof(const Stmt *T) {
3947 return T->getStmtClass() == UnresolvedMemberExprClass;
3948 }
3949
3950 // Iterators
3951 child_range children() {
3952 if (isImplicitAccess())
3953 return child_range(child_iterator(), child_iterator());
3954 return child_range(&Base, &Base + 1);
3955 }
3956
3957 const_child_range children() const {
3958 if (isImplicitAccess())
3959 return const_child_range(const_child_iterator(), const_child_iterator());
3960 return const_child_range(&Base, &Base + 1);
3961 }
3962};
3963
3964DeclAccessPair *OverloadExpr::getTrailingResults() {
3965 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3966 return ULE->getTrailingObjects<DeclAccessPair>();
3967 return cast<UnresolvedMemberExpr>(this)->getTrailingObjects<DeclAccessPair>();
3968}
3969
3970ASTTemplateKWAndArgsInfo *OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() {
3971 if (!hasTemplateKWAndArgsInfo())
3972 return nullptr;
3973
3974 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3975 return ULE->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
3976 return cast<UnresolvedMemberExpr>(this)
3977 ->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
3978}
3979
3980TemplateArgumentLoc *OverloadExpr::getTrailingTemplateArgumentLoc() {
3981 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3982 return ULE->getTrailingObjects<TemplateArgumentLoc>();
3983 return cast<UnresolvedMemberExpr>(this)
3984 ->getTrailingObjects<TemplateArgumentLoc>();
3985}
3986
3987CXXRecordDecl *OverloadExpr::getNamingClass() {
3988 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3989 return ULE->getNamingClass();
3990 return cast<UnresolvedMemberExpr>(this)->getNamingClass();
3991}
3992
3993/// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
3994///
3995/// The noexcept expression tests whether a given expression might throw. Its
3996/// result is a boolean constant.
3997class CXXNoexceptExpr : public Expr {
3998 friend class ASTStmtReader;
3999
4000 Stmt *Operand;
4001 SourceRange Range;
4002
4003public:
4004 CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
4005 SourceLocation Keyword, SourceLocation RParen)
4006 : Expr(CXXNoexceptExprClass, Ty, VK_PRValue, OK_Ordinary),
4007 Operand(Operand), Range(Keyword, RParen) {
4008 CXXNoexceptExprBits.Value = Val == CT_Cannot;
4009 setDependence(computeDependence(this, Val));
4010 }
4011
4012 CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {}
4013
4014 Expr *getOperand() const { return static_cast<Expr *>(Operand); }
4015
4016 SourceLocation getBeginLoc() const { return Range.getBegin(); }
4017 SourceLocation getEndLoc() const { return Range.getEnd(); }
4018 SourceRange getSourceRange() const { return Range; }
4019
4020 bool getValue() const { return CXXNoexceptExprBits.Value; }
4021
4022 static bool classof(const Stmt *T) {
4023 return T->getStmtClass() == CXXNoexceptExprClass;
4024 }
4025
4026 // Iterators
4027 child_range children() { return child_range(&Operand, &Operand + 1); }
4028
4029 const_child_range children() const {
4030 return const_child_range(&Operand, &Operand + 1);
4031 }
4032};
4033
4034/// Represents a C++11 pack expansion that produces a sequence of
4035/// expressions.
4036///
4037/// A pack expansion expression contains a pattern (which itself is an
4038/// expression) followed by an ellipsis. For example:
4039///
4040/// \code
4041/// template<typename F, typename ...Types>
4042/// void forward(F f, Types &&...args) {
4043/// f(static_cast<Types&&>(args)...);
4044/// }
4045/// \endcode
4046///
4047/// Here, the argument to the function object \c f is a pack expansion whose
4048/// pattern is \c static_cast<Types&&>(args). When the \c forward function
4049/// template is instantiated, the pack expansion will instantiate to zero or
4050/// or more function arguments to the function object \c f.
4051class PackExpansionExpr : public Expr {
4052 friend class ASTStmtReader;
4053 friend class ASTStmtWriter;
4054
4055 SourceLocation EllipsisLoc;
4056
4057 /// The number of expansions that will be produced by this pack
4058 /// expansion expression, if known.
4059 ///
4060 /// When zero, the number of expansions is not known. Otherwise, this value
4061 /// is the number of expansions + 1.
4062 unsigned NumExpansions;
4063
4064 Stmt *Pattern;
4065
4066public:
4067 PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc,
4068 Optional<unsigned> NumExpansions)
4069 : Expr(PackExpansionExprClass, T, Pattern->getValueKind(),
4070 Pattern->getObjectKind()),
4071 EllipsisLoc(EllipsisLoc),
4072 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0),
4073 Pattern(Pattern) {
4074 setDependence(computeDependence(this));
4075 }
4076
4077 PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) {}
4078
4079 /// Retrieve the pattern of the pack expansion.
4080 Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }
4081
4082 /// Retrieve the pattern of the pack expansion.
4083 const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }
4084
4085 /// Retrieve the location of the ellipsis that describes this pack
4086 /// expansion.
4087 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
4088
4089 /// Determine the number of expansions that will be produced when
4090 /// this pack expansion is instantiated, if already known.
4091 Optional<unsigned> getNumExpansions() const {
4092 if (NumExpansions)
4093 return NumExpansions - 1;
4094
4095 return None;
4096 }
4097
4098 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
4099 return Pattern->getBeginLoc();
4100 }
4101
4102 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return EllipsisLoc; }
4103
4104 static bool classof(const Stmt *T) {
4105 return T->getStmtClass() == PackExpansionExprClass;
4106 }
4107
4108 // Iterators
4109 child_range children() {
4110 return child_range(&Pattern, &Pattern + 1);
4111 }
4112
4113 const_child_range children() const {
4114 return const_child_range(&Pattern, &Pattern + 1);
4115 }
4116};
4117
4118/// Represents an expression that computes the length of a parameter
4119/// pack.
4120///
4121/// \code
4122/// template<typename ...Types>
4123/// struct count {
4124/// static const unsigned value = sizeof...(Types);
4125/// };
4126/// \endcode
4127class SizeOfPackExpr final
4128 : public Expr,
4129 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4130 friend class ASTStmtReader;
4131 friend class ASTStmtWriter;
4132 friend TrailingObjects;
4133
4134 /// The location of the \c sizeof keyword.
4135 SourceLocation OperatorLoc;
4136
4137 /// The location of the name of the parameter pack.
4138 SourceLocation PackLoc;
4139
4140 /// The location of the closing parenthesis.
4141 SourceLocation RParenLoc;
4142
4143 /// The length of the parameter pack, if known.
4144 ///
4145 /// When this expression is not value-dependent, this is the length of
4146 /// the pack. When the expression was parsed rather than instantiated
4147 /// (and thus is value-dependent), this is zero.
4148 ///
4149 /// After partial substitution into a sizeof...(X) expression (for instance,
4150 /// within an alias template or during function template argument deduction),
4151 /// we store a trailing array of partially-substituted TemplateArguments,
4152 /// and this is the length of that array.
4153 unsigned Length;
4154
4155 /// The parameter pack.
4156 NamedDecl *Pack = nullptr;
4157
4158 /// Create an expression that computes the length of
4159 /// the given parameter pack.
4160 SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
4161 SourceLocation PackLoc, SourceLocation RParenLoc,
4162 Optional<unsigned> Length,
4163 ArrayRef<TemplateArgument> PartialArgs)
4164 : Expr(SizeOfPackExprClass, SizeType, VK_PRValue, OK_Ordinary),
4165 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
4166 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
4167 assert((!Length || PartialArgs.empty()) &&((void)0)
4168 "have partial args for non-dependent sizeof... expression")((void)0);
4169 auto *Args = getTrailingObjects<TemplateArgument>();
4170 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
4171 setDependence(Length ? ExprDependence::None
4172 : ExprDependence::ValueInstantiation);
4173 }
4174
4175 /// Create an empty expression.
4176 SizeOfPackExpr(EmptyShell Empty, unsigned NumPartialArgs)
4177 : Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}
4178
4179public:
4180 static SizeOfPackExpr *Create(ASTContext &Context, SourceLocation OperatorLoc,
4181 NamedDecl *Pack, SourceLocation PackLoc,
4182 SourceLocation RParenLoc,
4183 Optional<unsigned> Length = None,
4184 ArrayRef<TemplateArgument> PartialArgs = None);
4185 static SizeOfPackExpr *CreateDeserialized(ASTContext &Context,
4186 unsigned NumPartialArgs);
4187
4188 /// Determine the location of the 'sizeof' keyword.
4189 SourceLocation getOperatorLoc() const { return OperatorLoc; }
4190
4191 /// Determine the location of the parameter pack.
4192 SourceLocation getPackLoc() const { return PackLoc; }
4193
4194 /// Determine the location of the right parenthesis.
4195 SourceLocation getRParenLoc() const { return RParenLoc; }
4196
4197 /// Retrieve the parameter pack.
4198 NamedDecl *getPack() const { return Pack; }
4199
4200 /// Retrieve the length of the parameter pack.
4201 ///
4202 /// This routine may only be invoked when the expression is not
4203 /// value-dependent.
4204 unsigned getPackLength() const {
4205 assert(!isValueDependent() &&((void)0)
4206 "Cannot get the length of a value-dependent pack size expression")((void)0);
4207 return Length;
4208 }
4209
4210 /// Determine whether this represents a partially-substituted sizeof...
4211 /// expression, such as is produced for:
4212 ///
4213 /// template<typename ...Ts> using X = int[sizeof...(Ts)];
4214 /// template<typename ...Us> void f(X<Us..., 1, 2, 3, Us...>);
4215 bool isPartiallySubstituted() const {
4216 return isValueDependent() && Length;
4217 }
4218
4219 /// Get
4220 ArrayRef<TemplateArgument> getPartialArguments() const {
4221 assert(isPartiallySubstituted())((void)0);
4222 const auto *Args = getTrailingObjects<TemplateArgument>();
4223 return llvm::makeArrayRef(Args, Args + Length);
4224 }
4225
4226 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return OperatorLoc; }
4227 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
4228
4229 static bool classof(const Stmt *T) {
4230 return T->getStmtClass() == SizeOfPackExprClass;
4231 }
4232
4233 // Iterators
4234 child_range children() {
4235 return child_range(child_iterator(), child_iterator());
4236 }
4237
4238 const_child_range children() const {
4239 return const_child_range(const_child_iterator(), const_child_iterator());
4240 }
4241};
4242
4243/// Represents a reference to a non-type template parameter
4244/// that has been substituted with a template argument.
4245class SubstNonTypeTemplateParmExpr : public Expr {
4246 friend class ASTReader;
4247 friend class ASTStmtReader;
4248
4249 /// The replaced parameter and a flag indicating if it was a reference
4250 /// parameter. For class NTTPs, we can't determine that based on the value
4251 /// category alone.
4252 llvm::PointerIntPair<NonTypeTemplateParmDecl*, 1, bool> ParamAndRef;
4253
4254 /// The replacement expression.
4255 Stmt *Replacement;
4256
4257 explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
4258 : Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
4259
4260public:
4261 SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
4262 SourceLocation Loc,
4263 NonTypeTemplateParmDecl *Param, bool RefParam,
4264 Expr *Replacement)
4265 : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
4266 ParamAndRef(Param, RefParam), Replacement(Replacement) {
4267 SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
4268 setDependence(computeDependence(this));
4269 }
4270
4271 SourceLocation getNameLoc() const {
4272 return SubstNonTypeTemplateParmExprBits.NameLoc;
4273 }
4274 SourceLocation getBeginLoc() const { return getNameLoc(); }
4275 SourceLocation getEndLoc() const { return getNameLoc(); }
4276
4277 Expr *getReplacement() const { return cast<Expr>(Replacement); }
4278
4279 NonTypeTemplateParmDecl *getParameter() const {
4280 return ParamAndRef.getPointer();
4281 }
4282
4283 bool isReferenceParameter() const { return ParamAndRef.getInt(); }
4284
4285 /// Determine the substituted type of the template parameter.
4286 QualType getParameterType(const ASTContext &Ctx) const;
4287
4288 static bool classof(const Stmt *s) {
4289 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
4290 }
4291
4292 // Iterators
4293 child_range children() { return child_range(&Replacement, &Replacement + 1); }
4294
4295 const_child_range children() const {
4296 return const_child_range(&Replacement, &Replacement + 1);
4297 }
4298};
4299
4300/// Represents a reference to a non-type template parameter pack that
4301/// has been substituted with a non-template argument pack.
4302///
4303/// When a pack expansion in the source code contains multiple parameter packs
4304/// and those parameter packs correspond to different levels of template
4305/// parameter lists, this node is used to represent a non-type template
4306/// parameter pack from an outer level, which has already had its argument pack
4307/// substituted but that still lives within a pack expansion that itself
4308/// could not be instantiated. When actually performing a substitution into
4309/// that pack expansion (e.g., when all template parameters have corresponding
4310/// arguments), this type will be replaced with the appropriate underlying
4311/// expression at the current pack substitution index.
4312class SubstNonTypeTemplateParmPackExpr : public Expr {
4313 friend class ASTReader;
4314 friend class ASTStmtReader;
4315
4316 /// The non-type template parameter pack itself.
4317 NonTypeTemplateParmDecl *Param;
4318
4319 /// A pointer to the set of template arguments that this
4320 /// parameter pack is instantiated with.
4321 const TemplateArgument *Arguments;
4322
4323 /// The number of template arguments in \c Arguments.
4324 unsigned NumArguments;
4325
4326 /// The location of the non-type template parameter pack reference.
4327 SourceLocation NameLoc;
4328
4329 explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)
4330 : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}
4331
4332public:
4333 SubstNonTypeTemplateParmPackExpr(QualType T,
4334 ExprValueKind ValueKind,
4335 NonTypeTemplateParmDecl *Param,
4336 SourceLocation NameLoc,
4337 const TemplateArgument &ArgPack);
4338
4339 /// Retrieve the non-type template parameter pack being substituted.
4340 NonTypeTemplateParmDecl *getParameterPack() const { return Param; }
4341
4342 /// Retrieve the location of the parameter pack name.
4343 SourceLocation getParameterPackLocation() const { return NameLoc; }
4344
4345 /// Retrieve the template argument pack containing the substituted
4346 /// template arguments.
4347 TemplateArgument getArgumentPack() const;
4348
4349 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
4350 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
4351
4352 static bool classof(const Stmt *T) {
4353 return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
4354 }
4355
4356 // Iterators
4357 child_range children() {
4358 return child_range(child_iterator(), child_iterator());
4359 }
4360
4361 const_child_range children() const {
4362 return const_child_range(const_child_iterator(), const_child_iterator());
4363 }
4364};
4365
4366/// Represents a reference to a function parameter pack or init-capture pack
4367/// that has been substituted but not yet expanded.
4368///
4369/// When a pack expansion contains multiple parameter packs at different levels,
4370/// this node is used to represent a function parameter pack at an outer level
4371/// which we have already substituted to refer to expanded parameters, but where
4372/// the containing pack expansion cannot yet be expanded.
4373///
4374/// \code
4375/// template<typename...Ts> struct S {
4376/// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...));
4377/// };
4378/// template struct S<int, int>;
4379/// \endcode
4380class FunctionParmPackExpr final
4381 : public Expr,
4382 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
4383 friend class ASTReader;
4384 friend class ASTStmtReader;
4385 friend TrailingObjects;
4386
4387 /// The function parameter pack which was referenced.
4388 VarDecl *ParamPack;
4389
4390 /// The location of the function parameter pack reference.
4391 SourceLocation NameLoc;
4392
4393 /// The number of expansions of this pack.
4394 unsigned NumParameters;
4395
4396 FunctionParmPackExpr(QualType T, VarDecl *ParamPack,
4397 SourceLocation NameLoc, unsigned NumParams,
4398 VarDecl *const *Params);
4399
4400public:
4401 static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T,
4402 VarDecl *ParamPack,
4403 SourceLocation NameLoc,
4404 ArrayRef<VarDecl *> Params);
4405 static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context,
4406 unsigned NumParams);
4407
4408 /// Get the parameter pack which this expression refers to.
4409 VarDecl *getParameterPack() const { return ParamPack; }
4410
4411 /// Get the location of the parameter pack.
4412 SourceLocation getParameterPackLocation() const { return NameLoc; }
4413
4414 /// Iterators over the parameters which the parameter pack expanded
4415 /// into.
4416 using iterator = VarDecl * const *;
4417 iterator begin() const { return getTrailingObjects<VarDecl *>(); }
4418 iterator end() const { return begin() + NumParameters; }
4419
4420 /// Get the number of parameters in this parameter pack.
4421 unsigned getNumExpansions() const { return NumParameters; }
4422
4423 /// Get an expansion of the parameter pack by index.
4424 VarDecl *getExpansion(unsigned I) const { return begin()[I]; }
4425
4426 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
4427 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return NameLoc; }
4428
4429 static bool classof(const Stmt *T) {
4430 return T->getStmtClass() == FunctionParmPackExprClass;
4431 }
4432
4433 child_range children() {
4434 return child_range(child_iterator(), child_iterator());
4435 }
4436
4437 const_child_range children() const {
4438 return const_child_range(const_child_iterator(), const_child_iterator());
4439 }
4440};
4441
4442/// Represents a prvalue temporary that is written into memory so that
4443/// a reference can bind to it.
4444///
4445/// Prvalue expressions are materialized when they need to have an address
4446/// in memory for a reference to bind to. This happens when binding a
4447/// reference to the result of a conversion, e.g.,
4448///
4449/// \code
4450/// const int &r = 1.0;
4451/// \endcode
4452///
4453/// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is
4454/// then materialized via a \c MaterializeTemporaryExpr, and the reference
4455/// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues
4456/// (either an lvalue or an xvalue, depending on the kind of reference binding
4457/// to it), maintaining the invariant that references always bind to glvalues.
4458///
4459/// Reference binding and copy-elision can both extend the lifetime of a
4460/// temporary. When either happens, the expression will also track the
4461/// declaration which is responsible for the lifetime extension.
4462class MaterializeTemporaryExpr : public Expr {
4463private:
4464 friend class ASTStmtReader;
4465 friend class ASTStmtWriter;
4466
4467 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State;
4468
4469public:
4470 MaterializeTemporaryExpr(QualType T, Expr *Temporary,
4471 bool BoundToLvalueReference,
4472 LifetimeExtendedTemporaryDecl *MTD = nullptr);
4473
4474 MaterializeTemporaryExpr(EmptyShell Empty)
4475 : Expr(MaterializeTemporaryExprClass, Empty) {}
4476
4477 /// Retrieve the temporary-generating subexpression whose value will
4478 /// be materialized into a glvalue.
4479 Expr *getSubExpr() const {
4480 return cast<Expr>(
4481 State.is<Stmt *>()
4482 ? State.get<Stmt *>()
4483 : State.get<LifetimeExtendedTemporaryDecl *>()->getTemporaryExpr());
4484 }
4485
4486 /// Retrieve the storage duration for the materialized temporary.
4487 StorageDuration getStorageDuration() const {
4488 return State.is<Stmt *>() ? SD_FullExpression
4489 : State.get<LifetimeExtendedTemporaryDecl *>()
4490 ->getStorageDuration();
4491 }
4492
4493 /// Get the storage for the constant value of a materialized temporary
4494 /// of static storage duration.
4495 APValue *getOrCreateValue(bool MayCreate) const {
4496 assert(State.is<LifetimeExtendedTemporaryDecl *>() &&((void)0)
4497 "the temporary has not been lifetime extended")((void)0);
4498 return State.get<LifetimeExtendedTemporaryDecl *>()->getOrCreateValue(
4499 MayCreate);
4500 }
4501
4502 LifetimeExtendedTemporaryDecl *getLifetimeExtendedTemporaryDecl() {
4503 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>();
4504 }
4505 const LifetimeExtendedTemporaryDecl *
4506 getLifetimeExtendedTemporaryDecl() const {
4507 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>();
4508 }
4509
4510 /// Get the declaration which triggered the lifetime-extension of this
4511 /// temporary, if any.
4512 ValueDecl *getExtendingDecl() {
4513 return State.is<Stmt *>() ? nullptr
4514 : State.get<LifetimeExtendedTemporaryDecl *>()
4515 ->getExtendingDecl();
4516 }
4517 const ValueDecl *getExtendingDecl() const {
4518 return const_cast<MaterializeTemporaryExpr *>(this)->getExtendingDecl();
4519 }
4520
4521 void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber);
4522
4523 unsigned getManglingNumber() const {
4524 return State.is<Stmt *>() ? 0
4525 : State.get<LifetimeExtendedTemporaryDecl *>()
4526 ->getManglingNumber();
4527 }
4528
4529 /// Determine whether this materialized temporary is bound to an
4530 /// lvalue reference; otherwise, it's bound to an rvalue reference.
4531 bool isBoundToLvalueReference() const { return isLValue(); }
4532
4533 /// Determine whether this temporary object is usable in constant
4534 /// expressions, as specified in C++20 [expr.const]p4.
4535 bool isUsableInConstantExpressions(const ASTContext &Context) const;
4536
4537 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
4538 return getSubExpr()->getBeginLoc();
4539 }
4540
4541 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4542 return getSubExpr()->getEndLoc();
4543 }
4544
4545 static bool classof(const Stmt *T) {
4546 return T->getStmtClass() == MaterializeTemporaryExprClass;
4547 }
4548
4549 // Iterators
4550 child_range children() {
4551 return State.is<Stmt *>()
4552 ? child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1)
4553 : State.get<LifetimeExtendedTemporaryDecl *>()->childrenExpr();
4554 }
4555
4556 const_child_range children() const {
4557 return State.is<Stmt *>()
4558 ? const_child_range(State.getAddrOfPtr1(),
4559 State.getAddrOfPtr1() + 1)
4560 : const_cast<const LifetimeExtendedTemporaryDecl *>(
4561 State.get<LifetimeExtendedTemporaryDecl *>())
4562 ->childrenExpr();
4563 }
4564};
4565
4566/// Represents a folding of a pack over an operator.
4567///
4568/// This expression is always dependent and represents a pack expansion of the
4569/// forms:
4570///
4571/// ( expr op ... )
4572/// ( ... op expr )
4573/// ( expr op ... op expr )
4574class CXXFoldExpr : public Expr {
4575 friend class ASTStmtReader;
4576 friend class ASTStmtWriter;
4577
4578 enum SubExpr { Callee, LHS, RHS, Count };
4579
4580 SourceLocation LParenLoc;
4581 SourceLocation EllipsisLoc;
4582 SourceLocation RParenLoc;
4583 // When 0, the number of expansions is not known. Otherwise, this is one more
4584 // than the number of expansions.
4585 unsigned NumExpansions;
4586 Stmt *SubExprs[SubExpr::Count];
4587 BinaryOperatorKind Opcode;
4588
4589public:
4590 CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
4591 SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode,
4592 SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc,
4593 Optional<unsigned> NumExpansions)
4594 : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary),
4595 LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
4596 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
4597 SubExprs[SubExpr::Callee] = Callee;
4598 SubExprs[SubExpr::LHS] = LHS;
4599 SubExprs[SubExpr::RHS] = RHS;
4600 setDependence(computeDependence(this));
4601 }
4602
4603 CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
4604
4605 UnresolvedLookupExpr *getCallee() const {
4606 return static_cast<UnresolvedLookupExpr *>(SubExprs[SubExpr::Callee]);
4607 }
4608 Expr *getLHS() const { return static_cast<Expr*>(SubExprs[SubExpr::LHS]); }
4609 Expr *getRHS() const { return static_cast<Expr*>(SubExprs[SubExpr::RHS]); }
4610
4611 /// Does this produce a right-associated sequence of operators?
4612 bool isRightFold() const {
4613 return getLHS() && getLHS()->containsUnexpandedParameterPack();
4614 }
4615
4616 /// Does this produce a left-associated sequence of operators?
4617 bool isLeftFold() const { return !isRightFold(); }
4618
4619 /// Get the pattern, that is, the operand that contains an unexpanded pack.
4620 Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }
4621
4622 /// Get the operand that doesn't contain a pack, for a binary fold.
4623 Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }
4624
4625 SourceLocation getLParenLoc() const { return LParenLoc; }
4626 SourceLocation getRParenLoc() const { return RParenLoc; }
4627 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
4628 BinaryOperatorKind getOperator() const { return Opcode; }
4629
4630 Optional<unsigned> getNumExpansions() const {
4631 if (NumExpansions)
4632 return NumExpansions - 1;
4633 return None;
4634 }
4635
4636 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
4637 if (LParenLoc.isValid())
4638 return LParenLoc;
4639 if (isLeftFold())
4640 return getEllipsisLoc();
4641 return getLHS()->getBeginLoc();
4642 }
4643
4644 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4645 if (RParenLoc.isValid())
4646 return RParenLoc;
4647 if (isRightFold())
4648 return getEllipsisLoc();
4649 return getRHS()->getEndLoc();
4650 }
4651
4652 static bool classof(const Stmt *T) {
4653 return T->getStmtClass() == CXXFoldExprClass;
4654 }
4655
4656 // Iterators
4657 child_range children() {
4658 return child_range(SubExprs, SubExprs + SubExpr::Count);
4659 }
4660
4661 const_child_range children() const {
4662 return const_child_range(SubExprs, SubExprs + SubExpr::Count);
4663 }
4664};
4665
4666/// Represents an expression that might suspend coroutine execution;
4667/// either a co_await or co_yield expression.
4668///
4669/// Evaluation of this expression first evaluates its 'ready' expression. If
4670/// that returns 'false':
4671/// -- execution of the coroutine is suspended
4672/// -- the 'suspend' expression is evaluated
4673/// -- if the 'suspend' expression returns 'false', the coroutine is
4674/// resumed
4675/// -- otherwise, control passes back to the resumer.
4676/// If the coroutine is not suspended, or when it is resumed, the 'resume'
4677/// expression is evaluated, and its result is the result of the overall
4678/// expression.
4679class CoroutineSuspendExpr : public Expr {
4680 friend class ASTStmtReader;
4681
4682 SourceLocation KeywordLoc;
4683
4684 enum SubExpr { Common, Ready, Suspend, Resume, Count };
4685
4686 Stmt *SubExprs[SubExpr::Count];
4687 OpaqueValueExpr *OpaqueValue = nullptr;
4688
4689public:
4690 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Common,
4691 Expr *Ready, Expr *Suspend, Expr *Resume,
4692 OpaqueValueExpr *OpaqueValue)
4693 : Expr(SC, Resume->getType(), Resume->getValueKind(),
84
←
Called C++ object pointer is null
4694 Resume->getObjectKind()),
4695 KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) {
4696 SubExprs[SubExpr::Common] = Common;
4697 SubExprs[SubExpr::Ready] = Ready;
4698 SubExprs[SubExpr::Suspend] = Suspend;
4699 SubExprs[SubExpr::Resume] = Resume;
4700 setDependence(computeDependence(this));
4701 }
4702
4703 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty,
4704 Expr *Common)
4705 : Expr(SC, Ty, VK_PRValue, OK_Ordinary), KeywordLoc(KeywordLoc) {
4706 assert(Common->isTypeDependent() && Ty->isDependentType() &&((void)0)
4707 "wrong constructor for non-dependent co_await/co_yield expression")((void)0);
4708 SubExprs[SubExpr::Common] = Common;
4709 SubExprs[SubExpr::Ready] = nullptr;
4710 SubExprs[SubExpr::Suspend] = nullptr;
4711 SubExprs[SubExpr::Resume] = nullptr;
4712 setDependence(computeDependence(this));
4713 }
4714
4715 CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {
4716 SubExprs[SubExpr::Common] = nullptr;
4717 SubExprs[SubExpr::Ready] = nullptr;
4718 SubExprs[SubExpr::Suspend] = nullptr;
4719 SubExprs[SubExpr::Resume] = nullptr;
4720 }
4721
4722 SourceLocation getKeywordLoc() const { return KeywordLoc; }
4723
4724 Expr *getCommonExpr() const {
4725 return static_cast<Expr*>(SubExprs[SubExpr::Common]);
4726 }
4727
4728 /// getOpaqueValue - Return the opaque value placeholder.
4729 OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }
4730
4731 Expr *getReadyExpr() const {
4732 return static_cast<Expr*>(SubExprs[SubExpr::Ready]);
4733 }
4734
4735 Expr *getSuspendExpr() const {
4736 return static_cast<Expr*>(SubExprs[SubExpr::Suspend]);
4737 }
4738
4739 Expr *getResumeExpr() const {
4740 return static_cast<Expr*>(SubExprs[SubExpr::Resume]);
4741 }
4742
4743 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return KeywordLoc; }
4744
4745 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4746 return getCommonExpr()->getEndLoc();
4747 }
4748
4749 child_range children() {
4750 return child_range(SubExprs, SubExprs + SubExpr::Count);
4751 }
4752
4753 const_child_range children() const {
4754 return const_child_range(SubExprs, SubExprs + SubExpr::Count);
4755 }
4756
4757 static bool classof(const Stmt *T) {
4758 return T->getStmtClass() == CoawaitExprClass ||
4759 T->getStmtClass() == CoyieldExprClass;
4760 }
4761};
4762
4763/// Represents a 'co_await' expression.
4764class CoawaitExpr : public CoroutineSuspendExpr {
4765 friend class ASTStmtReader;
4766
4767public:
4768 CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Ready,
4769 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue,
4770 bool IsImplicit = false)
4771 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Operand, Ready,
4772 Suspend, Resume, OpaqueValue) {
4773 CoawaitBits.IsImplicit = IsImplicit;
4774 }
4775
4776 CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand,
4777 bool IsImplicit = false)
4778 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Ty, Operand) {
4779 CoawaitBits.IsImplicit = IsImplicit;
4780 }
4781
4782 CoawaitExpr(EmptyShell Empty)
4783 : CoroutineSuspendExpr(CoawaitExprClass, Empty) {}
4784
4785 Expr *getOperand() const {
4786 // FIXME: Dig out the actual operand or store it.
4787 return getCommonExpr();
4788 }
4789
4790 bool isImplicit() const { return CoawaitBits.IsImplicit; }
4791 void setIsImplicit(bool value = true) { CoawaitBits.IsImplicit = value; }
4792
4793 static bool classof(const Stmt *T) {
4794 return T->getStmtClass() == CoawaitExprClass;
4795 }
4796};
4797
4798/// Represents a 'co_await' expression while the type of the promise
4799/// is dependent.
4800class DependentCoawaitExpr : public Expr {
4801 friend class ASTStmtReader;
4802
4803 SourceLocation KeywordLoc;
4804 Stmt *SubExprs[2];
4805
4806public:
4807 DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op,
4808 UnresolvedLookupExpr *OpCoawait)
4809 : Expr(DependentCoawaitExprClass, Ty, VK_PRValue, OK_Ordinary),
4810 KeywordLoc(KeywordLoc) {
4811 // NOTE: A co_await expression is dependent on the coroutines promise
4812 // type and may be dependent even when the `Op` expression is not.
4813 assert(Ty->isDependentType() &&((void)0)
4814 "wrong constructor for non-dependent co_await/co_yield expression")((void)0);
4815 SubExprs[0] = Op;
4816 SubExprs[1] = OpCoawait;
4817 setDependence(computeDependence(this));
4818 }
4819
4820 DependentCoawaitExpr(EmptyShell Empty)
4821 : Expr(DependentCoawaitExprClass, Empty) {}
4822
4823 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }
4824
4825 UnresolvedLookupExpr *getOperatorCoawaitLookup() const {
4826 return cast<UnresolvedLookupExpr>(SubExprs[1]);
4827 }
4828
4829 SourceLocation getKeywordLoc() const { return KeywordLoc; }
4830
4831 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return KeywordLoc; }
4832
4833 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4834 return getOperand()->getEndLoc();
4835 }
4836
4837 child_range children() { return child_range(SubExprs, SubExprs + 2); }
4838
4839 const_child_range children() const {
4840 return const_child_range(SubExprs, SubExprs + 2);
4841 }
4842
4843 static bool classof(const Stmt *T) {
4844 return T->getStmtClass() == DependentCoawaitExprClass;
4845 }
4846};
4847
4848/// Represents a 'co_yield' expression.
4849class CoyieldExpr : public CoroutineSuspendExpr {
4850 friend class ASTStmtReader;
4851
4852public:
4853 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready,
4854 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)
4855 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Operand, Ready,
83
←
Calling constructor for 'CoroutineSuspendExpr'
→
4856 Suspend, Resume, OpaqueValue) {}
82
←
Passing null pointer value via 6th parameter 'Resume'
→
4857 CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand)
4858 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Ty, Operand) {}
4859 CoyieldExpr(EmptyShell Empty)
4860 : CoroutineSuspendExpr(CoyieldExprClass, Empty) {}
4861
4862 Expr *getOperand() const {
4863 // FIXME: Dig out the actual operand or store it.
4864 return getCommonExpr();
4865 }
4866
4867 static bool classof(const Stmt *T) {
4868 return T->getStmtClass() == CoyieldExprClass;
4869 }
4870};
4871
4872/// Represents a C++2a __builtin_bit_cast(T, v) expression. Used to implement
4873/// std::bit_cast. These can sometimes be evaluated as part of a constant
4874/// expression, but otherwise CodeGen to a simple memcpy in general.
4875class BuiltinBitCastExpr final
4876 : public ExplicitCastExpr,
4877 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
4878 friend class ASTStmtReader;
4879 friend class CastExpr;
4880 friend TrailingObjects;
4881
4882 SourceLocation KWLoc;
4883 SourceLocation RParenLoc;
4884
4885public:
4886 BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr,
4887 TypeSourceInfo *DstType, SourceLocation KWLoc,
4888 SourceLocation RParenLoc)
4889 : ExplicitCastExpr(BuiltinBitCastExprClass, T, VK, CK, SrcExpr, 0, false,
4890 DstType),
4891 KWLoc(KWLoc), RParenLoc(RParenLoc) {}
4892 BuiltinBitCastExpr(EmptyShell Empty)
4893 : ExplicitCastExpr(BuiltinBitCastExprClass, Empty, 0, false) {}
4894
4895 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return KWLoc; }
4896 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
4897
4898 static bool classof(const Stmt *T) {
4899 return T->getStmtClass() == BuiltinBitCastExprClass;
4900 }
4901};
4902
4903} // namespace clang
4904
4905#endif // LLVM_CLANG_AST_EXPRCXX_H