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