1//===- ExprCXX.cpp - (C++) Expression AST Node Implementation -------------===//
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 the subclesses of Expr class declared in ExprCXX.h
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/ExprCXX.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/ComputeDependence.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclAccessPair.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/DeclarationName.h"
23#include "clang/AST/DependenceFlags.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/LambdaCapture.h"
26#include "clang/AST/NestedNameSpecifier.h"
27#include "clang/AST/TemplateBase.h"
28#include "clang/AST/Type.h"
29#include "clang/AST/TypeLoc.h"
30#include "clang/Basic/LLVM.h"
31#include "clang/Basic/OperatorKinds.h"
32#include "clang/Basic/SourceLocation.h"
33#include "clang/Basic/Specifiers.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/Support/ErrorHandling.h"
36#include <cassert>
37#include <cstddef>
38#include <cstring>
39#include <memory>
40#include <optional>
41
42using namespace clang;
43
44//===----------------------------------------------------------------------===//
45// Child Iterators for iterating over subexpressions/substatements
46//===----------------------------------------------------------------------===//
47
48bool CXXOperatorCallExpr::isInfixBinaryOp() const {
49 // An infix binary operator is any operator with two arguments other than
50 // operator() and operator[]. Note that none of these operators can have
51 // default arguments, so it suffices to check the number of argument
52 // expressions.
53 if (getNumArgs() != 2)
54 return false;
55
56 switch (getOperator()) {
57 case OO_Call: case OO_Subscript:
58 return false;
59 default:
60 return true;
61 }
62}
63
64CXXRewrittenBinaryOperator::DecomposedForm
65CXXRewrittenBinaryOperator::getDecomposedForm() const {
66 DecomposedForm Result = {};
67 const Expr *E = getSemanticForm()->IgnoreImplicit();
68
69 // Remove an outer '!' if it exists (only happens for a '!=' rewrite).
70 bool SkippedNot = false;
71 if (auto *NotEq = dyn_cast<UnaryOperator>(Val: E)) {
72 assert(NotEq->getOpcode() == UO_LNot);
73 E = NotEq->getSubExpr()->IgnoreImplicit();
74 SkippedNot = true;
75 }
76
77 // Decompose the outer binary operator.
78 if (auto *BO = dyn_cast<BinaryOperator>(Val: E)) {
79 assert(!SkippedNot || BO->getOpcode() == BO_EQ);
80 Result.Opcode = SkippedNot ? BO_NE : BO->getOpcode();
81 Result.LHS = BO->getLHS();
82 Result.RHS = BO->getRHS();
83 Result.InnerBinOp = BO;
84 } else if (auto *BO = dyn_cast<CXXOperatorCallExpr>(Val: E)) {
85 assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);
86 assert(BO->isInfixBinaryOp());
87 switch (BO->getOperator()) {
88 case OO_Less: Result.Opcode = BO_LT; break;
89 case OO_LessEqual: Result.Opcode = BO_LE; break;
90 case OO_Greater: Result.Opcode = BO_GT; break;
91 case OO_GreaterEqual: Result.Opcode = BO_GE; break;
92 case OO_Spaceship: Result.Opcode = BO_Cmp; break;
93 case OO_EqualEqual: Result.Opcode = SkippedNot ? BO_NE : BO_EQ; break;
94 default: llvm_unreachable("unexpected binop in rewritten operator expr");
95 }
96 Result.LHS = BO->getArg(Arg: 0);
97 Result.RHS = BO->getArg(Arg: 1);
98 Result.InnerBinOp = BO;
99 } else {
100 llvm_unreachable("unexpected rewritten operator form");
101 }
102
103 // Put the operands in the right order for == and !=, and canonicalize the
104 // <=> subexpression onto the LHS for all other forms.
105 if (isReversed())
106 std::swap(a&: Result.LHS, b&: Result.RHS);
107
108 // If this isn't a spaceship rewrite, we're done.
109 if (Result.Opcode == BO_EQ || Result.Opcode == BO_NE)
110 return Result;
111
112 // Otherwise, we expect a <=> to now be on the LHS.
113 E = Result.LHS->IgnoreUnlessSpelledInSource();
114 if (auto *BO = dyn_cast<BinaryOperator>(Val: E)) {
115 assert(BO->getOpcode() == BO_Cmp);
116 Result.LHS = BO->getLHS();
117 Result.RHS = BO->getRHS();
118 Result.InnerBinOp = BO;
119 } else if (auto *BO = dyn_cast<CXXOperatorCallExpr>(Val: E)) {
120 assert(BO->getOperator() == OO_Spaceship);
121 Result.LHS = BO->getArg(Arg: 0);
122 Result.RHS = BO->getArg(Arg: 1);
123 Result.InnerBinOp = BO;
124 } else {
125 llvm_unreachable("unexpected rewritten operator form");
126 }
127
128 // Put the comparison operands in the right order.
129 if (isReversed())
130 std::swap(a&: Result.LHS, b&: Result.RHS);
131 return Result;
132}
133
134bool CXXTypeidExpr::isPotentiallyEvaluated() const {
135 if (isTypeOperand())
136 return false;
137
138 // C++11 [expr.typeid]p3:
139 // When typeid is applied to an expression other than a glvalue of
140 // polymorphic class type, [...] the expression is an unevaluated operand.
141 const Expr *E = getExprOperand();
142 if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl())
143 if (RD->isPolymorphic() && E->isGLValue())
144 return true;
145
146 return false;
147}
148
149bool CXXTypeidExpr::isMostDerived(const ASTContext &Context) const {
150 assert(!isTypeOperand() && "Cannot call isMostDerived for typeid(type)");
151 const Expr *E = getExprOperand()->IgnoreParenNoopCasts(Ctx: Context);
152 if (const auto *DRE = dyn_cast<DeclRefExpr>(Val: E)) {
153 QualType Ty = DRE->getDecl()->getType();
154 if (!Ty->isPointerOrReferenceType())
155 return true;
156 }
157
158 return false;
159}
160
161QualType CXXTypeidExpr::getTypeOperand(const ASTContext &Context) const {
162 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
163 Qualifiers Quals;
164 return Context.getUnqualifiedArrayType(
165 T: cast<TypeSourceInfo *>(Val: Operand)->getType().getNonReferenceType(), Quals);
166}
167
168static bool isGLValueFromPointerDeref(const Expr *E) {
169 E = E->IgnoreParens();
170
171 if (const auto *CE = dyn_cast<CastExpr>(Val: E)) {
172 if (!CE->getSubExpr()->isGLValue())
173 return false;
174 return isGLValueFromPointerDeref(E: CE->getSubExpr());
175 }
176
177 if (const auto *OVE = dyn_cast<OpaqueValueExpr>(Val: E))
178 return isGLValueFromPointerDeref(E: OVE->getSourceExpr());
179
180 if (const auto *BO = dyn_cast<BinaryOperator>(Val: E))
181 if (BO->getOpcode() == BO_Comma)
182 return isGLValueFromPointerDeref(E: BO->getRHS());
183
184 if (const auto *ACO = dyn_cast<AbstractConditionalOperator>(Val: E))
185 return isGLValueFromPointerDeref(E: ACO->getTrueExpr()) ||
186 isGLValueFromPointerDeref(E: ACO->getFalseExpr());
187
188 // C++11 [expr.sub]p1:
189 // The expression E1[E2] is identical (by definition) to *((E1)+(E2))
190 if (isa<ArraySubscriptExpr>(Val: E))
191 return true;
192
193 if (const auto *UO = dyn_cast<UnaryOperator>(Val: E))
194 if (UO->getOpcode() == UO_Deref)
195 return true;
196
197 return false;
198}
199
200bool CXXTypeidExpr::hasNullCheck() const {
201 if (!isPotentiallyEvaluated())
202 return false;
203
204 // C++ [expr.typeid]p2:
205 // If the glvalue expression is obtained by applying the unary * operator to
206 // a pointer and the pointer is a null pointer value, the typeid expression
207 // throws the std::bad_typeid exception.
208 //
209 // However, this paragraph's intent is not clear. We choose a very generous
210 // interpretation which implores us to consider comma operators, conditional
211 // operators, parentheses and other such constructs.
212 return isGLValueFromPointerDeref(E: getExprOperand());
213}
214
215QualType CXXUuidofExpr::getTypeOperand(ASTContext &Context) const {
216 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
217 Qualifiers Quals;
218 return Context.getUnqualifiedArrayType(
219 T: cast<TypeSourceInfo *>(Val: Operand)->getType().getNonReferenceType(), Quals);
220}
221
222// CXXScalarValueInitExpr
223SourceLocation CXXScalarValueInitExpr::getBeginLoc() const {
224 return TypeInfo ? TypeInfo->getTypeLoc().getBeginLoc() : getRParenLoc();
225}
226
227// CXXNewExpr
228CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
229 FunctionDecl *OperatorDelete,
230 const ImplicitAllocationParameters &IAP,
231 bool UsualArrayDeleteWantsSize,
232 ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
233 std::optional<Expr *> ArraySize,
234 CXXNewInitializationStyle InitializationStyle,
235 Expr *Initializer, QualType Ty,
236 TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
237 SourceRange DirectInitRange)
238 : Expr(CXXNewExprClass, Ty, VK_PRValue, OK_Ordinary),
239 OperatorNew(OperatorNew), OperatorDelete(OperatorDelete),
240 AllocatedTypeInfo(AllocatedTypeInfo), Range(Range),
241 DirectInitRange(DirectInitRange) {
242
243 assert((Initializer != nullptr ||
244 InitializationStyle == CXXNewInitializationStyle::None) &&
245 "Only CXXNewInitializationStyle::None can have no initializer!");
246
247 CXXNewExprBits.IsGlobalNew = IsGlobalNew;
248 CXXNewExprBits.IsArray = ArraySize.has_value();
249 CXXNewExprBits.ShouldPassAlignment = isAlignedAllocation(Mode: IAP.PassAlignment);
250 CXXNewExprBits.ShouldPassTypeIdentity =
251 isTypeAwareAllocation(Mode: IAP.PassTypeIdentity);
252 CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
253 CXXNewExprBits.HasInitializer = Initializer != nullptr;
254 CXXNewExprBits.StoredInitializationStyle =
255 llvm::to_underlying(E: InitializationStyle);
256 bool IsParenTypeId = TypeIdParens.isValid();
257 CXXNewExprBits.IsParenTypeId = IsParenTypeId;
258 CXXNewExprBits.NumPlacementArgs = PlacementArgs.size();
259
260 if (ArraySize)
261 getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
262 if (Initializer)
263 getTrailingObjects<Stmt *>()[initExprOffset()] = Initializer;
264 llvm::copy(Range&: PlacementArgs,
265 Out: getTrailingObjects<Stmt *>() + placementNewArgsOffset());
266 if (IsParenTypeId)
267 getTrailingObjects<SourceRange>()[0] = TypeIdParens;
268
269 switch (getInitializationStyle()) {
270 case CXXNewInitializationStyle::Parens:
271 this->Range.setEnd(DirectInitRange.getEnd());
272 break;
273 case CXXNewInitializationStyle::Braces:
274 this->Range.setEnd(getInitializer()->getSourceRange().getEnd());
275 break;
276 default:
277 if (IsParenTypeId)
278 this->Range.setEnd(TypeIdParens.getEnd());
279 break;
280 }
281
282 setDependence(computeDependence(E: this));
283}
284
285CXXNewExpr::CXXNewExpr(EmptyShell Empty, bool IsArray,
286 unsigned NumPlacementArgs, bool IsParenTypeId)
287 : Expr(CXXNewExprClass, Empty) {
288 CXXNewExprBits.IsArray = IsArray;
289 CXXNewExprBits.NumPlacementArgs = NumPlacementArgs;
290 CXXNewExprBits.IsParenTypeId = IsParenTypeId;
291}
292
293CXXNewExpr *CXXNewExpr::Create(
294 const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew,
295 FunctionDecl *OperatorDelete, const ImplicitAllocationParameters &IAP,
296 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
297 SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
298 CXXNewInitializationStyle InitializationStyle, Expr *Initializer,
299 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
300 SourceRange DirectInitRange) {
301 bool IsArray = ArraySize.has_value();
302 bool HasInit = Initializer != nullptr;
303 unsigned NumPlacementArgs = PlacementArgs.size();
304 bool IsParenTypeId = TypeIdParens.isValid();
305 void *Mem =
306 Ctx.Allocate(Size: totalSizeToAlloc<Stmt *, SourceRange>(
307 Counts: IsArray + HasInit + NumPlacementArgs, Counts: IsParenTypeId),
308 Align: alignof(CXXNewExpr));
309 return new (Mem) CXXNewExpr(
310 IsGlobalNew, OperatorNew, OperatorDelete, IAP, UsualArrayDeleteWantsSize,
311 PlacementArgs, TypeIdParens, ArraySize, InitializationStyle, Initializer,
312 Ty, AllocatedTypeInfo, Range, DirectInitRange);
313}
314
315CXXNewExpr *CXXNewExpr::CreateEmpty(const ASTContext &Ctx, bool IsArray,
316 bool HasInit, unsigned NumPlacementArgs,
317 bool IsParenTypeId) {
318 void *Mem =
319 Ctx.Allocate(Size: totalSizeToAlloc<Stmt *, SourceRange>(
320 Counts: IsArray + HasInit + NumPlacementArgs, Counts: IsParenTypeId),
321 Align: alignof(CXXNewExpr));
322 return new (Mem)
323 CXXNewExpr(EmptyShell(), IsArray, NumPlacementArgs, IsParenTypeId);
324}
325
326bool CXXNewExpr::shouldNullCheckAllocation() const {
327 if (getOperatorNew()->getLangOpts().CheckNew)
328 return true;
329 return !getOperatorNew()->hasAttr<ReturnsNonNullAttr>() &&
330 getOperatorNew()
331 ->getType()
332 ->castAs<FunctionProtoType>()
333 ->isNothrow() &&
334 !getOperatorNew()->isReservedGlobalPlacementOperator();
335}
336
337// CXXDeleteExpr
338QualType CXXDeleteExpr::getDestroyedType() const {
339 const Expr *Arg = getArgument();
340
341 // For a destroying operator delete, we may have implicitly converted the
342 // pointer type to the type of the parameter of the 'operator delete'
343 // function.
344 while (const auto *ICE = dyn_cast<ImplicitCastExpr>(Val: Arg)) {
345 if (ICE->getCastKind() == CK_DerivedToBase ||
346 ICE->getCastKind() == CK_UncheckedDerivedToBase ||
347 ICE->getCastKind() == CK_NoOp) {
348 assert((ICE->getCastKind() == CK_NoOp ||
349 getOperatorDelete()->isDestroyingOperatorDelete()) &&
350 "only a destroying operator delete can have a converted arg");
351 Arg = ICE->getSubExpr();
352 } else
353 break;
354 }
355
356 // The type-to-delete may not be a pointer if it's a dependent type.
357 const QualType ArgType = Arg->getType();
358
359 if (ArgType->isDependentType() && !ArgType->isPointerType())
360 return QualType();
361
362 return ArgType->castAs<PointerType>()->getPointeeType();
363}
364
365// CXXPseudoDestructorExpr
366PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
367 : Type(Info) {
368 Location = Info->getTypeLoc().getBeginLoc();
369}
370
371CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(
372 const ASTContext &Context, Expr *Base, bool isArrow,
373 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
374 TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,
375 SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
376 : Expr(CXXPseudoDestructorExprClass, Context.BoundMemberTy, VK_PRValue,
377 OK_Ordinary),
378 Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
379 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
380 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
381 DestroyedType(DestroyedType) {
382 setDependence(computeDependence(E: this));
383}
384
385QualType CXXPseudoDestructorExpr::getDestroyedType() const {
386 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
387 return TInfo->getType();
388
389 return QualType();
390}
391
392SourceLocation CXXPseudoDestructorExpr::getEndLoc() const {
393 SourceLocation End = DestroyedType.getLocation();
394 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
395 End = TInfo->getTypeLoc().getSourceRange().getEnd();
396 return End;
397}
398
399static bool UnresolvedLookupExprIsVariableOrConceptParameterPack(
400 UnresolvedSetIterator Begin, UnresolvedSetIterator End) {
401 if (std::distance(first: Begin, last: End) != 1)
402 return false;
403 NamedDecl *ND = *Begin;
404 if (const auto *TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(Val: ND))
405 return TTP->isParameterPack();
406 return false;
407}
408
409// UnresolvedLookupExpr
410UnresolvedLookupExpr::UnresolvedLookupExpr(
411 const ASTContext &Context, CXXRecordDecl *NamingClass,
412 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
413 const DeclarationNameInfo &NameInfo, bool RequiresADL,
414 const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
415 UnresolvedSetIterator End, bool KnownDependent,
416 bool KnownInstantiationDependent)
417 : OverloadExpr(
418 UnresolvedLookupExprClass, Context, QualifierLoc, TemplateKWLoc,
419 NameInfo, TemplateArgs, Begin, End, KnownDependent,
420 KnownInstantiationDependent,
421 UnresolvedLookupExprIsVariableOrConceptParameterPack(Begin, End)),
422 NamingClass(NamingClass) {
423 UnresolvedLookupExprBits.RequiresADL = RequiresADL;
424}
425
426UnresolvedLookupExpr::UnresolvedLookupExpr(EmptyShell Empty,
427 unsigned NumResults,
428 bool HasTemplateKWAndArgsInfo)
429 : OverloadExpr(UnresolvedLookupExprClass, Empty, NumResults,
430 HasTemplateKWAndArgsInfo) {}
431
432UnresolvedLookupExpr *UnresolvedLookupExpr::Create(
433 const ASTContext &Context, CXXRecordDecl *NamingClass,
434 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
435 bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End,
436 bool KnownDependent, bool KnownInstantiationDependent) {
437 unsigned NumResults = End - Begin;
438 unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
439 TemplateArgumentLoc>(Counts: NumResults, Counts: 0, Counts: 0);
440 void *Mem = Context.Allocate(Size, Align: alignof(UnresolvedLookupExpr));
441 return new (Mem) UnresolvedLookupExpr(
442 Context, NamingClass, QualifierLoc,
443 /*TemplateKWLoc=*/SourceLocation(), NameInfo, RequiresADL,
444 /*TemplateArgs=*/nullptr, Begin, End, KnownDependent,
445 KnownInstantiationDependent);
446}
447
448UnresolvedLookupExpr *UnresolvedLookupExpr::Create(
449 const ASTContext &Context, CXXRecordDecl *NamingClass,
450 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
451 const DeclarationNameInfo &NameInfo, bool RequiresADL,
452 const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,
453 UnresolvedSetIterator End, bool KnownDependent,
454 bool KnownInstantiationDependent) {
455 unsigned NumResults = End - Begin;
456 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.isValid();
457 unsigned NumTemplateArgs = Args ? Args->size() : 0;
458 unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
459 TemplateArgumentLoc>(
460 Counts: NumResults, Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs);
461 void *Mem = Context.Allocate(Size, Align: alignof(UnresolvedLookupExpr));
462 return new (Mem) UnresolvedLookupExpr(
463 Context, NamingClass, QualifierLoc, TemplateKWLoc, NameInfo, RequiresADL,
464 Args, Begin, End, KnownDependent, KnownInstantiationDependent);
465}
466
467UnresolvedLookupExpr *UnresolvedLookupExpr::CreateEmpty(
468 const ASTContext &Context, unsigned NumResults,
469 bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) {
470 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
471 unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
472 TemplateArgumentLoc>(
473 Counts: NumResults, Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs);
474 void *Mem = Context.Allocate(Size, Align: alignof(UnresolvedLookupExpr));
475 return new (Mem)
476 UnresolvedLookupExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo);
477}
478
479OverloadExpr::OverloadExpr(StmtClass SC, const ASTContext &Context,
480 NestedNameSpecifierLoc QualifierLoc,
481 SourceLocation TemplateKWLoc,
482 const DeclarationNameInfo &NameInfo,
483 const TemplateArgumentListInfo *TemplateArgs,
484 UnresolvedSetIterator Begin,
485 UnresolvedSetIterator End, bool KnownDependent,
486 bool KnownInstantiationDependent,
487 bool KnownContainsUnexpandedParameterPack)
488 : Expr(SC, Context.OverloadTy, VK_LValue, OK_Ordinary), NameInfo(NameInfo),
489 QualifierLoc(QualifierLoc) {
490 unsigned NumResults = End - Begin;
491 OverloadExprBits.NumResults = NumResults;
492 OverloadExprBits.HasTemplateKWAndArgsInfo =
493 (TemplateArgs != nullptr ) || TemplateKWLoc.isValid();
494
495 if (NumResults) {
496 // Copy the results to the trailing array past UnresolvedLookupExpr
497 // or UnresolvedMemberExpr.
498 DeclAccessPair *Results = getTrailingResults();
499 memcpy(dest: Results, src: Begin.I, n: NumResults * sizeof(DeclAccessPair));
500 }
501
502 if (TemplateArgs) {
503 auto Deps = TemplateArgumentDependence::None;
504 getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(
505 TemplateKWLoc, List: *TemplateArgs, OutArgArray: getTrailingTemplateArgumentLoc(), Deps);
506 } else if (TemplateKWLoc.isValid()) {
507 getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
508 }
509
510 setDependence(computeDependence(E: this, KnownDependent,
511 KnownInstantiationDependent,
512 KnownContainsUnexpandedParameterPack));
513 if (isTypeDependent())
514 setType(Context.DependentTy);
515}
516
517OverloadExpr::OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults,
518 bool HasTemplateKWAndArgsInfo)
519 : Expr(SC, Empty) {
520 OverloadExprBits.NumResults = NumResults;
521 OverloadExprBits.HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
522}
523
524// DependentScopeDeclRefExpr
525DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(
526 QualType Ty, NestedNameSpecifierLoc QualifierLoc,
527 SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
528 const TemplateArgumentListInfo *Args)
529 : Expr(DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary),
530 QualifierLoc(QualifierLoc), NameInfo(NameInfo) {
531 DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo =
532 (Args != nullptr) || TemplateKWLoc.isValid();
533 if (Args) {
534 auto Deps = TemplateArgumentDependence::None;
535 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
536 TemplateKWLoc, List: *Args, OutArgArray: getTrailingObjects<TemplateArgumentLoc>(), Deps);
537 } else if (TemplateKWLoc.isValid()) {
538 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
539 TemplateKWLoc);
540 }
541 setDependence(computeDependence(E: this));
542}
543
544DependentScopeDeclRefExpr *DependentScopeDeclRefExpr::Create(
545 const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
546 SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
547 const TemplateArgumentListInfo *Args) {
548 assert(QualifierLoc && "should be created for dependent qualifiers");
549 bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.isValid();
550 std::size_t Size =
551 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
552 Counts: HasTemplateKWAndArgsInfo, Counts: Args ? Args->size() : 0);
553 void *Mem = Context.Allocate(Size);
554 return new (Mem) DependentScopeDeclRefExpr(Context.DependentTy, QualifierLoc,
555 TemplateKWLoc, NameInfo, Args);
556}
557
558DependentScopeDeclRefExpr *
559DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &Context,
560 bool HasTemplateKWAndArgsInfo,
561 unsigned NumTemplateArgs) {
562 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
563 std::size_t Size =
564 totalSizeToAlloc<ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
565 Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs);
566 void *Mem = Context.Allocate(Size);
567 auto *E = new (Mem) DependentScopeDeclRefExpr(
568 QualType(), NestedNameSpecifierLoc(), SourceLocation(),
569 DeclarationNameInfo(), nullptr);
570 E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo =
571 HasTemplateKWAndArgsInfo;
572 return E;
573}
574
575SourceLocation CXXConstructExpr::getBeginLoc() const {
576 if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(Val: this))
577 return TOE->getBeginLoc();
578 return getLocation();
579}
580
581SourceLocation CXXConstructExpr::getEndLoc() const {
582 if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(Val: this))
583 return TOE->getEndLoc();
584
585 if (ParenOrBraceRange.isValid())
586 return ParenOrBraceRange.getEnd();
587
588 SourceLocation End = getLocation();
589 for (unsigned I = getNumArgs(); I > 0; --I) {
590 const Expr *Arg = getArg(Arg: I-1);
591 if (!Arg->isDefaultArgument()) {
592 SourceLocation NewEnd = Arg->getEndLoc();
593 if (NewEnd.isValid()) {
594 End = NewEnd;
595 break;
596 }
597 }
598 }
599
600 return End;
601}
602
603CXXOperatorCallExpr::CXXOperatorCallExpr(OverloadedOperatorKind OpKind,
604 Expr *Fn, ArrayRef<Expr *> Args,
605 QualType Ty, ExprValueKind VK,
606 SourceLocation OperatorLoc,
607 FPOptionsOverride FPFeatures,
608 ADLCallKind UsesADL)
609 : CallExpr(CXXOperatorCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
610 OperatorLoc, FPFeatures, /*MinNumArgs=*/0, UsesADL) {
611 CXXOperatorCallExprBits.OperatorKind = OpKind;
612 assert(
613 (CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) &&
614 "OperatorKind overflow!");
615 BeginLoc = getSourceRangeImpl().getBegin();
616}
617
618CXXOperatorCallExpr::CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures,
619 EmptyShell Empty)
620 : CallExpr(CXXOperatorCallExprClass, /*NumPreArgs=*/0, NumArgs,
621 HasFPFeatures, Empty) {}
622
623CXXOperatorCallExpr *
624CXXOperatorCallExpr::Create(const ASTContext &Ctx,
625 OverloadedOperatorKind OpKind, Expr *Fn,
626 ArrayRef<Expr *> Args, QualType Ty,
627 ExprValueKind VK, SourceLocation OperatorLoc,
628 FPOptionsOverride FPFeatures, ADLCallKind UsesADL) {
629 // Allocate storage for the trailing objects of CallExpr.
630 unsigned NumArgs = Args.size();
631 unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
632 /*NumPreArgs=*/0, NumArgs, HasFPFeatures: FPFeatures.requiresTrailingStorage());
633 void *Mem =
634 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CXXOperatorCallExpr>(
635 SizeOfTrailingObjects),
636 Align: alignof(CXXOperatorCallExpr));
637 return new (Mem) CXXOperatorCallExpr(OpKind, Fn, Args, Ty, VK, OperatorLoc,
638 FPFeatures, UsesADL);
639}
640
641CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(const ASTContext &Ctx,
642 unsigned NumArgs,
643 bool HasFPFeatures,
644 EmptyShell Empty) {
645 // Allocate storage for the trailing objects of CallExpr.
646 unsigned SizeOfTrailingObjects =
647 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures);
648 void *Mem =
649 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CXXOperatorCallExpr>(
650 SizeOfTrailingObjects),
651 Align: alignof(CXXOperatorCallExpr));
652 return new (Mem) CXXOperatorCallExpr(NumArgs, HasFPFeatures, Empty);
653}
654
655SourceRange CXXOperatorCallExpr::getSourceRangeImpl() const {
656 OverloadedOperatorKind Kind = getOperator();
657 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
658 if (getNumArgs() == 1)
659 // Prefix operator
660 return SourceRange(getOperatorLoc(), getArg(Arg: 0)->getEndLoc());
661 else
662 // Postfix operator
663 return SourceRange(getArg(Arg: 0)->getBeginLoc(), getOperatorLoc());
664 } else if (Kind == OO_Arrow) {
665 return SourceRange(getArg(Arg: 0)->getBeginLoc(), getOperatorLoc());
666 } else if (Kind == OO_Call) {
667 return SourceRange(getArg(Arg: 0)->getBeginLoc(), getRParenLoc());
668 } else if (Kind == OO_Subscript) {
669 return SourceRange(getArg(Arg: 0)->getBeginLoc(), getRParenLoc());
670 } else if (getNumArgs() == 1) {
671 return SourceRange(getOperatorLoc(), getArg(Arg: 0)->getEndLoc());
672 } else if (getNumArgs() == 2) {
673 return SourceRange(getArg(Arg: 0)->getBeginLoc(), getArg(Arg: 1)->getEndLoc());
674 } else {
675 return getOperatorLoc();
676 }
677}
678
679CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,
680 QualType Ty, ExprValueKind VK,
681 SourceLocation RP,
682 FPOptionsOverride FPOptions,
683 unsigned MinNumArgs)
684 : CallExpr(CXXMemberCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, RP,
685 FPOptions, MinNumArgs, NotADL) {}
686
687CXXMemberCallExpr::CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures,
688 EmptyShell Empty)
689 : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, HasFPFeatures,
690 Empty) {}
691
692CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,
693 ArrayRef<Expr *> Args, QualType Ty,
694 ExprValueKind VK,
695 SourceLocation RP,
696 FPOptionsOverride FPFeatures,
697 unsigned MinNumArgs) {
698 // Allocate storage for the trailing objects of CallExpr.
699 unsigned NumArgs = std::max<unsigned>(a: Args.size(), b: MinNumArgs);
700 unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
701 /*NumPreArgs=*/0, NumArgs, HasFPFeatures: FPFeatures.requiresTrailingStorage());
702 void *Mem = Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CXXMemberCallExpr>(
703 SizeOfTrailingObjects),
704 Align: alignof(CXXMemberCallExpr));
705 return new (Mem)
706 CXXMemberCallExpr(Fn, Args, Ty, VK, RP, FPFeatures, MinNumArgs);
707}
708
709CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(const ASTContext &Ctx,
710 unsigned NumArgs,
711 bool HasFPFeatures,
712 EmptyShell Empty) {
713 // Allocate storage for the trailing objects of CallExpr.
714 unsigned SizeOfTrailingObjects =
715 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures);
716 void *Mem = Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CXXMemberCallExpr>(
717 SizeOfTrailingObjects),
718 Align: alignof(CXXMemberCallExpr));
719 return new (Mem) CXXMemberCallExpr(NumArgs, HasFPFeatures, Empty);
720}
721
722Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
723 const Expr *Callee = getCallee()->IgnoreParens();
724 if (const auto *MemExpr = dyn_cast<MemberExpr>(Val: Callee))
725 return MemExpr->getBase();
726 if (const auto *BO = dyn_cast<BinaryOperator>(Val: Callee))
727 if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)
728 return BO->getLHS();
729
730 // FIXME: Will eventually need to cope with member pointers.
731 return nullptr;
732}
733
734QualType CXXMemberCallExpr::getObjectType() const {
735 QualType Ty = getImplicitObjectArgument()->getType();
736 if (Ty->isPointerType())
737 Ty = Ty->getPointeeType();
738 return Ty;
739}
740
741CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
742 if (const auto *MemExpr = dyn_cast<MemberExpr>(Val: getCallee()->IgnoreParens()))
743 return cast<CXXMethodDecl>(Val: MemExpr->getMemberDecl());
744
745 // FIXME: Will eventually need to cope with member pointers.
746 // NOTE: Update makeTailCallIfSwiftAsync on fixing this.
747 return nullptr;
748}
749
750CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const {
751 Expr* ThisArg = getImplicitObjectArgument();
752 if (!ThisArg)
753 return nullptr;
754
755 if (ThisArg->getType()->isAnyPointerType())
756 return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
757
758 return ThisArg->getType()->getAsCXXRecordDecl();
759}
760
761//===----------------------------------------------------------------------===//
762// Named casts
763//===----------------------------------------------------------------------===//
764
765/// getCastName - Get the name of the C++ cast being used, e.g.,
766/// "static_cast", "dynamic_cast", "reinterpret_cast", or
767/// "const_cast". The returned pointer must not be freed.
768const char *CXXNamedCastExpr::getCastName() const {
769 switch (getStmtClass()) {
770 case CXXStaticCastExprClass: return "static_cast";
771 case CXXDynamicCastExprClass: return "dynamic_cast";
772 case CXXReinterpretCastExprClass: return "reinterpret_cast";
773 case CXXConstCastExprClass: return "const_cast";
774 case CXXAddrspaceCastExprClass: return "addrspace_cast";
775 default: return "<invalid cast>";
776 }
777}
778
779CXXStaticCastExpr *
780CXXStaticCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,
781 CastKind K, Expr *Op, const CXXCastPath *BasePath,
782 TypeSourceInfo *WrittenTy, FPOptionsOverride FPO,
783 SourceLocation L, SourceLocation RParenLoc,
784 SourceRange AngleBrackets) {
785 unsigned PathSize = (BasePath ? BasePath->size() : 0);
786 void *Buffer =
787 C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
788 Counts: PathSize, Counts: FPO.requiresTrailingStorage()));
789 auto *E = new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy,
790 FPO, L, RParenLoc, AngleBrackets);
791 if (PathSize)
792 llvm::uninitialized_copy(Src: *BasePath,
793 Dst: E->getTrailingObjects<CXXBaseSpecifier *>());
794 return E;
795}
796
797CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C,
798 unsigned PathSize,
799 bool HasFPFeatures) {
800 void *Buffer =
801 C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
802 Counts: PathSize, Counts: HasFPFeatures));
803 return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize, HasFPFeatures);
804}
805
806CXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T,
807 ExprValueKind VK,
808 CastKind K, Expr *Op,
809 const CXXCastPath *BasePath,
810 TypeSourceInfo *WrittenTy,
811 SourceLocation L,
812 SourceLocation RParenLoc,
813 SourceRange AngleBrackets) {
814 unsigned PathSize = (BasePath ? BasePath->size() : 0);
815 void *Buffer = C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *>(Counts: PathSize));
816 auto *E =
817 new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
818 RParenLoc, AngleBrackets);
819 if (PathSize)
820 llvm::uninitialized_copy(Src: *BasePath, Dst: E->getTrailingObjects());
821 return E;
822}
823
824CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C,
825 unsigned PathSize) {
826 void *Buffer = C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *>(Counts: PathSize));
827 return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
828}
829
830/// isAlwaysNull - Return whether the result of the dynamic_cast is proven
831/// to always be null. For example:
832///
833/// struct A { };
834/// struct B final : A { };
835/// struct C { };
836///
837/// C *f(B* b) { return dynamic_cast<C*>(b); }
838bool CXXDynamicCastExpr::isAlwaysNull() const {
839 if (isValueDependent() || getCastKind() != CK_Dynamic)
840 return false;
841
842 QualType SrcType = getSubExpr()->getType();
843 QualType DestType = getType();
844
845 if (DestType->isVoidPointerType())
846 return false;
847
848 if (DestType->isPointerType()) {
849 SrcType = SrcType->getPointeeType();
850 DestType = DestType->getPointeeType();
851 }
852
853 const auto *SrcRD = SrcType->getAsCXXRecordDecl();
854 const auto *DestRD = DestType->getAsCXXRecordDecl();
855 assert(SrcRD && DestRD);
856
857 if (SrcRD->isEffectivelyFinal()) {
858 assert(!SrcRD->isDerivedFrom(DestRD) &&
859 "upcasts should not use CK_Dynamic");
860 return true;
861 }
862
863 if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(Base: SrcRD))
864 return true;
865
866 return false;
867}
868
869CXXReinterpretCastExpr *
870CXXReinterpretCastExpr::Create(const ASTContext &C, QualType T,
871 ExprValueKind VK, CastKind K, Expr *Op,
872 const CXXCastPath *BasePath,
873 TypeSourceInfo *WrittenTy, SourceLocation L,
874 SourceLocation RParenLoc,
875 SourceRange AngleBrackets) {
876 unsigned PathSize = (BasePath ? BasePath->size() : 0);
877 void *Buffer = C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *>(Counts: PathSize));
878 auto *E =
879 new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
880 RParenLoc, AngleBrackets);
881 if (PathSize)
882 llvm::uninitialized_copy(Src: *BasePath, Dst: E->getTrailingObjects());
883 return E;
884}
885
886CXXReinterpretCastExpr *
887CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) {
888 void *Buffer = C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *>(Counts: PathSize));
889 return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
890}
891
892CXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T,
893 ExprValueKind VK, Expr *Op,
894 TypeSourceInfo *WrittenTy,
895 SourceLocation L,
896 SourceLocation RParenLoc,
897 SourceRange AngleBrackets) {
898 return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);
899}
900
901CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) {
902 return new (C) CXXConstCastExpr(EmptyShell());
903}
904
905CXXAddrspaceCastExpr *
906CXXAddrspaceCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,
907 CastKind K, Expr *Op, TypeSourceInfo *WrittenTy,
908 SourceLocation L, SourceLocation RParenLoc,
909 SourceRange AngleBrackets) {
910 return new (C) CXXAddrspaceCastExpr(T, VK, K, Op, WrittenTy, L, RParenLoc,
911 AngleBrackets);
912}
913
914CXXAddrspaceCastExpr *CXXAddrspaceCastExpr::CreateEmpty(const ASTContext &C) {
915 return new (C) CXXAddrspaceCastExpr(EmptyShell());
916}
917
918CXXFunctionalCastExpr *CXXFunctionalCastExpr::Create(
919 const ASTContext &C, QualType T, ExprValueKind VK, TypeSourceInfo *Written,
920 CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO,
921 SourceLocation L, SourceLocation R) {
922 unsigned PathSize = (BasePath ? BasePath->size() : 0);
923 void *Buffer =
924 C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
925 Counts: PathSize, Counts: FPO.requiresTrailingStorage()));
926 auto *E = new (Buffer)
927 CXXFunctionalCastExpr(T, VK, Written, K, Op, PathSize, FPO, L, R);
928 if (PathSize)
929 llvm::uninitialized_copy(Src: *BasePath,
930 Dst: E->getTrailingObjects<CXXBaseSpecifier *>());
931 return E;
932}
933
934CXXFunctionalCastExpr *CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C,
935 unsigned PathSize,
936 bool HasFPFeatures) {
937 void *Buffer =
938 C.Allocate(Size: totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
939 Counts: PathSize, Counts: HasFPFeatures));
940 return new (Buffer)
941 CXXFunctionalCastExpr(EmptyShell(), PathSize, HasFPFeatures);
942}
943
944SourceLocation CXXFunctionalCastExpr::getBeginLoc() const {
945 return getTypeInfoAsWritten()->getTypeLoc().getBeginLoc();
946}
947
948SourceLocation CXXFunctionalCastExpr::getEndLoc() const {
949 return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getEndLoc();
950}
951
952UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,
953 QualType Ty, ExprValueKind VK,
954 SourceLocation LitEndLoc,
955 SourceLocation SuffixLoc,
956 FPOptionsOverride FPFeatures)
957 : CallExpr(UserDefinedLiteralClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
958 LitEndLoc, FPFeatures, /*MinNumArgs=*/0, NotADL),
959 UDSuffixLoc(SuffixLoc) {}
960
961UserDefinedLiteral::UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures,
962 EmptyShell Empty)
963 : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs,
964 HasFPFeatures, Empty) {}
965
966UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,
967 ArrayRef<Expr *> Args,
968 QualType Ty, ExprValueKind VK,
969 SourceLocation LitEndLoc,
970 SourceLocation SuffixLoc,
971 FPOptionsOverride FPFeatures) {
972 // Allocate storage for the trailing objects of CallExpr.
973 unsigned NumArgs = Args.size();
974 unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
975 /*NumPreArgs=*/0, NumArgs, HasFPFeatures: FPFeatures.requiresTrailingStorage());
976 void *Mem =
977 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<UserDefinedLiteral>(
978 SizeOfTrailingObjects),
979 Align: alignof(UserDefinedLiteral));
980 return new (Mem)
981 UserDefinedLiteral(Fn, Args, Ty, VK, LitEndLoc, SuffixLoc, FPFeatures);
982}
983
984UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(const ASTContext &Ctx,
985 unsigned NumArgs,
986 bool HasFPOptions,
987 EmptyShell Empty) {
988 // Allocate storage for the trailing objects of CallExpr.
989 unsigned SizeOfTrailingObjects =
990 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures: HasFPOptions);
991 void *Mem =
992 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<UserDefinedLiteral>(
993 SizeOfTrailingObjects),
994 Align: alignof(UserDefinedLiteral));
995 return new (Mem) UserDefinedLiteral(NumArgs, HasFPOptions, Empty);
996}
997
998UserDefinedLiteral::LiteralOperatorKind
999UserDefinedLiteral::getLiteralOperatorKind() const {
1000 if (getNumArgs() == 0)
1001 return LOK_Template;
1002 if (getNumArgs() == 2)
1003 return LOK_String;
1004
1005 assert(getNumArgs() == 1 && "unexpected #args in literal operator call");
1006 QualType ParamTy =
1007 cast<FunctionDecl>(Val: getCalleeDecl())->getParamDecl(i: 0)->getType();
1008 if (ParamTy->isPointerType())
1009 return LOK_Raw;
1010 if (ParamTy->isAnyCharacterType())
1011 return LOK_Character;
1012 if (ParamTy->isIntegerType())
1013 return LOK_Integer;
1014 if (ParamTy->isFloatingType())
1015 return LOK_Floating;
1016
1017 llvm_unreachable("unknown kind of literal operator");
1018}
1019
1020Expr *UserDefinedLiteral::getCookedLiteral() {
1021#ifndef NDEBUG
1022 LiteralOperatorKind LOK = getLiteralOperatorKind();
1023 assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal");
1024#endif
1025 return getArg(Arg: 0);
1026}
1027
1028const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
1029 return cast<FunctionDecl>(Val: getCalleeDecl())->getLiteralIdentifier();
1030}
1031
1032CXXDefaultArgExpr *CXXDefaultArgExpr::CreateEmpty(const ASTContext &C,
1033 bool HasRewrittenInit) {
1034 size_t Size = totalSizeToAlloc<Expr *>(Counts: HasRewrittenInit);
1035 auto *Mem = C.Allocate(Size, Align: alignof(CXXDefaultArgExpr));
1036 return new (Mem) CXXDefaultArgExpr(EmptyShell(), HasRewrittenInit);
1037}
1038
1039CXXDefaultArgExpr *CXXDefaultArgExpr::Create(const ASTContext &C,
1040 SourceLocation Loc,
1041 ParmVarDecl *Param,
1042 Expr *RewrittenExpr,
1043 DeclContext *UsedContext) {
1044 size_t Size = totalSizeToAlloc<Expr *>(Counts: RewrittenExpr != nullptr);
1045 auto *Mem = C.Allocate(Size, Align: alignof(CXXDefaultArgExpr));
1046 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
1047 RewrittenExpr, UsedContext);
1048}
1049
1050Expr *CXXDefaultArgExpr::getExpr() {
1051 return CXXDefaultArgExprBits.HasRewrittenInit ? getAdjustedRewrittenExpr()
1052 : getParam()->getDefaultArg();
1053}
1054
1055Expr *CXXDefaultArgExpr::getAdjustedRewrittenExpr() {
1056 assert(hasRewrittenInit() &&
1057 "expected this CXXDefaultArgExpr to have a rewritten init.");
1058 Expr *Init = getRewrittenExpr();
1059 if (auto *E = dyn_cast_if_present<FullExpr>(Val: Init))
1060 if (!isa<ConstantExpr>(Val: E))
1061 return E->getSubExpr();
1062 return Init;
1063}
1064
1065CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
1066 SourceLocation Loc, FieldDecl *Field,
1067 QualType Ty, DeclContext *UsedContext,
1068 Expr *RewrittenInitExpr)
1069 : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Context: Ctx),
1070 Ty->isLValueReferenceType() ? VK_LValue
1071 : Ty->isRValueReferenceType() ? VK_XValue
1072 : VK_PRValue,
1073 /*FIXME*/ OK_Ordinary),
1074 Field(Field), UsedContext(UsedContext) {
1075 CXXDefaultInitExprBits.Loc = Loc;
1076 CXXDefaultInitExprBits.HasRewrittenInit = RewrittenInitExpr != nullptr;
1077
1078 if (CXXDefaultInitExprBits.HasRewrittenInit)
1079 *getTrailingObjects() = RewrittenInitExpr;
1080
1081 assert(Field->hasInClassInitializer());
1082
1083 setDependence(computeDependence(E: this));
1084}
1085
1086CXXDefaultInitExpr *CXXDefaultInitExpr::CreateEmpty(const ASTContext &C,
1087 bool HasRewrittenInit) {
1088 size_t Size = totalSizeToAlloc<Expr *>(Counts: HasRewrittenInit);
1089 auto *Mem = C.Allocate(Size, Align: alignof(CXXDefaultInitExpr));
1090 return new (Mem) CXXDefaultInitExpr(EmptyShell(), HasRewrittenInit);
1091}
1092
1093CXXDefaultInitExpr *CXXDefaultInitExpr::Create(const ASTContext &Ctx,
1094 SourceLocation Loc,
1095 FieldDecl *Field,
1096 DeclContext *UsedContext,
1097 Expr *RewrittenInitExpr) {
1098
1099 size_t Size = totalSizeToAlloc<Expr *>(Counts: RewrittenInitExpr != nullptr);
1100 auto *Mem = Ctx.Allocate(Size, Align: alignof(CXXDefaultInitExpr));
1101 return new (Mem) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(),
1102 UsedContext, RewrittenInitExpr);
1103}
1104
1105Expr *CXXDefaultInitExpr::getExpr() {
1106 assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
1107 if (hasRewrittenInit())
1108 return getRewrittenExpr();
1109
1110 return Field->getInClassInitializer();
1111}
1112
1113CXXTemporary *CXXTemporary::Create(const ASTContext &C,
1114 const CXXDestructorDecl *Destructor) {
1115 return new (C) CXXTemporary(Destructor);
1116}
1117
1118CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,
1119 CXXTemporary *Temp,
1120 Expr* SubExpr) {
1121 assert((SubExpr->getType()->isRecordType() ||
1122 SubExpr->getType()->isArrayType()) &&
1123 "Expression bound to a temporary must have record or array type!");
1124
1125 return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
1126}
1127
1128CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(
1129 CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI,
1130 ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,
1131 bool HadMultipleCandidates, bool ListInitialization,
1132 bool StdInitListInitialization, bool ZeroInitialization)
1133 : CXXConstructExpr(
1134 CXXTemporaryObjectExprClass, Ty, TSI->getTypeLoc().getBeginLoc(),
1135 Cons, /* Elidable=*/false, Args, HadMultipleCandidates,
1136 ListInitialization, StdInitListInitialization, ZeroInitialization,
1137 CXXConstructionKind::Complete, ParenOrBraceRange),
1138 TSI(TSI) {
1139 setDependence(computeDependence(E: this));
1140}
1141
1142CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(EmptyShell Empty,
1143 unsigned NumArgs)
1144 : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty, NumArgs) {}
1145
1146CXXTemporaryObjectExpr *CXXTemporaryObjectExpr::Create(
1147 const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty,
1148 TypeSourceInfo *TSI, ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,
1149 bool HadMultipleCandidates, bool ListInitialization,
1150 bool StdInitListInitialization, bool ZeroInitialization) {
1151 unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs: Args.size());
1152 void *Mem =
1153 Ctx.Allocate(Size: sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects,
1154 Align: alignof(CXXTemporaryObjectExpr));
1155 return new (Mem) CXXTemporaryObjectExpr(
1156 Cons, Ty, TSI, Args, ParenOrBraceRange, HadMultipleCandidates,
1157 ListInitialization, StdInitListInitialization, ZeroInitialization);
1158}
1159
1160CXXTemporaryObjectExpr *
1161CXXTemporaryObjectExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs) {
1162 unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);
1163 void *Mem =
1164 Ctx.Allocate(Size: sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects,
1165 Align: alignof(CXXTemporaryObjectExpr));
1166 return new (Mem) CXXTemporaryObjectExpr(EmptyShell(), NumArgs);
1167}
1168
1169SourceLocation CXXTemporaryObjectExpr::getBeginLoc() const {
1170 return getTypeSourceInfo()->getTypeLoc().getBeginLoc();
1171}
1172
1173SourceLocation CXXTemporaryObjectExpr::getEndLoc() const {
1174 SourceLocation Loc = getParenOrBraceRange().getEnd();
1175 if (Loc.isInvalid() && getNumArgs())
1176 Loc = getArg(Arg: getNumArgs() - 1)->getEndLoc();
1177 return Loc;
1178}
1179
1180CXXConstructExpr *CXXConstructExpr::Create(
1181 const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
1182 CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
1183 bool HadMultipleCandidates, bool ListInitialization,
1184 bool StdInitListInitialization, bool ZeroInitialization,
1185 CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange) {
1186 unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs: Args.size());
1187 void *Mem = Ctx.Allocate(Size: sizeof(CXXConstructExpr) + SizeOfTrailingObjects,
1188 Align: alignof(CXXConstructExpr));
1189 return new (Mem) CXXConstructExpr(
1190 CXXConstructExprClass, Ty, Loc, Ctor, Elidable, Args,
1191 HadMultipleCandidates, ListInitialization, StdInitListInitialization,
1192 ZeroInitialization, ConstructKind, ParenOrBraceRange);
1193}
1194
1195CXXConstructExpr *CXXConstructExpr::CreateEmpty(const ASTContext &Ctx,
1196 unsigned NumArgs) {
1197 unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);
1198 void *Mem = Ctx.Allocate(Size: sizeof(CXXConstructExpr) + SizeOfTrailingObjects,
1199 Align: alignof(CXXConstructExpr));
1200 return new (Mem)
1201 CXXConstructExpr(CXXConstructExprClass, EmptyShell(), NumArgs);
1202}
1203
1204CXXConstructExpr::CXXConstructExpr(
1205 StmtClass SC, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor,
1206 bool Elidable, ArrayRef<Expr *> Args, bool HadMultipleCandidates,
1207 bool ListInitialization, bool StdInitListInitialization,
1208 bool ZeroInitialization, CXXConstructionKind ConstructKind,
1209 SourceRange ParenOrBraceRange)
1210 : Expr(SC, Ty, VK_PRValue, OK_Ordinary), Constructor(Ctor),
1211 ParenOrBraceRange(ParenOrBraceRange), NumArgs(Args.size()) {
1212 CXXConstructExprBits.Elidable = Elidable;
1213 CXXConstructExprBits.HadMultipleCandidates = HadMultipleCandidates;
1214 CXXConstructExprBits.ListInitialization = ListInitialization;
1215 CXXConstructExprBits.StdInitListInitialization = StdInitListInitialization;
1216 CXXConstructExprBits.ZeroInitialization = ZeroInitialization;
1217 CXXConstructExprBits.ConstructionKind = llvm::to_underlying(E: ConstructKind);
1218 CXXConstructExprBits.IsImmediateEscalating = false;
1219 CXXConstructExprBits.Loc = Loc;
1220
1221 Stmt **TrailingArgs = getTrailingArgs();
1222 llvm::copy(Range&: Args, Out: TrailingArgs);
1223 assert(!llvm::is_contained(Args, nullptr));
1224
1225 // CXXTemporaryObjectExpr does this itself after setting its TypeSourceInfo.
1226 if (SC == CXXConstructExprClass)
1227 setDependence(computeDependence(E: this));
1228}
1229
1230CXXConstructExpr::CXXConstructExpr(StmtClass SC, EmptyShell Empty,
1231 unsigned NumArgs)
1232 : Expr(SC, Empty), NumArgs(NumArgs) {}
1233
1234LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit,
1235 LambdaCaptureKind Kind, ValueDecl *Var,
1236 SourceLocation EllipsisLoc)
1237 : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) {
1238 unsigned Bits = 0;
1239 if (Implicit)
1240 Bits |= Capture_Implicit;
1241
1242 switch (Kind) {
1243 case LCK_StarThis:
1244 Bits |= Capture_ByCopy;
1245 [[fallthrough]];
1246 case LCK_This:
1247 assert(!Var && "'this' capture cannot have a variable!");
1248 Bits |= Capture_This;
1249 break;
1250
1251 case LCK_ByCopy:
1252 Bits |= Capture_ByCopy;
1253 [[fallthrough]];
1254 case LCK_ByRef:
1255 assert(Var && "capture must have a variable!");
1256 break;
1257 case LCK_VLAType:
1258 assert(!Var && "VLA type capture cannot have a variable!");
1259 break;
1260 }
1261 DeclAndBits.setInt(Bits);
1262}
1263
1264LambdaCaptureKind LambdaCapture::getCaptureKind() const {
1265 if (capturesVLAType())
1266 return LCK_VLAType;
1267 bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
1268 if (capturesThis())
1269 return CapByCopy ? LCK_StarThis : LCK_This;
1270 return CapByCopy ? LCK_ByCopy : LCK_ByRef;
1271}
1272
1273LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange,
1274 LambdaCaptureDefault CaptureDefault,
1275 SourceLocation CaptureDefaultLoc, bool ExplicitParams,
1276 bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
1277 SourceLocation ClosingBrace,
1278 bool ContainsUnexpandedParameterPack)
1279 : Expr(LambdaExprClass, T, VK_PRValue, OK_Ordinary),
1280 IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
1281 ClosingBrace(ClosingBrace) {
1282 LambdaExprBits.NumCaptures = CaptureInits.size();
1283 LambdaExprBits.CaptureDefault = CaptureDefault;
1284 LambdaExprBits.ExplicitParams = ExplicitParams;
1285 LambdaExprBits.ExplicitResultType = ExplicitResultType;
1286
1287 CXXRecordDecl *Class = getLambdaClass();
1288 (void)Class;
1289 assert(capture_size() == Class->capture_size() && "Wrong number of captures");
1290 assert(getCaptureDefault() == Class->getLambdaCaptureDefault());
1291
1292 // Copy initialization expressions for the non-static data members.
1293 Stmt **Stored = getStoredStmts();
1294 for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
1295 *Stored++ = CaptureInits[I];
1296
1297 // Copy the body of the lambda.
1298 *Stored++ = getCallOperator()->getBody();
1299
1300 setDependence(computeDependence(E: this, ContainsUnexpandedParameterPack));
1301}
1302
1303LambdaExpr::LambdaExpr(EmptyShell Empty, unsigned NumCaptures)
1304 : Expr(LambdaExprClass, Empty) {
1305 LambdaExprBits.NumCaptures = NumCaptures;
1306
1307 // Initially don't initialize the body of the LambdaExpr. The body will
1308 // be lazily deserialized when needed.
1309 getStoredStmts()[NumCaptures] = nullptr; // Not one past the end.
1310}
1311
1312LambdaExpr *LambdaExpr::Create(const ASTContext &Context, CXXRecordDecl *Class,
1313 SourceRange IntroducerRange,
1314 LambdaCaptureDefault CaptureDefault,
1315 SourceLocation CaptureDefaultLoc,
1316 bool ExplicitParams, bool ExplicitResultType,
1317 ArrayRef<Expr *> CaptureInits,
1318 SourceLocation ClosingBrace,
1319 bool ContainsUnexpandedParameterPack) {
1320 // Determine the type of the expression (i.e., the type of the
1321 // function object we're creating).
1322 CanQualType T = Context.getCanonicalTagType(TD: Class);
1323
1324 unsigned Size = totalSizeToAlloc<Stmt *>(Counts: CaptureInits.size() + 1);
1325 void *Mem = Context.Allocate(Size);
1326 return new (Mem)
1327 LambdaExpr(T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
1328 ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,
1329 ContainsUnexpandedParameterPack);
1330}
1331
1332LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C,
1333 unsigned NumCaptures) {
1334 unsigned Size = totalSizeToAlloc<Stmt *>(Counts: NumCaptures + 1);
1335 void *Mem = C.Allocate(Size);
1336 return new (Mem) LambdaExpr(EmptyShell(), NumCaptures);
1337}
1338
1339void LambdaExpr::initBodyIfNeeded() const {
1340 if (!getStoredStmts()[capture_size()]) {
1341 auto *This = const_cast<LambdaExpr *>(this);
1342 This->getStoredStmts()[capture_size()] = getCallOperator()->getBody();
1343 }
1344}
1345
1346Stmt *LambdaExpr::getBody() const {
1347 initBodyIfNeeded();
1348 return getStoredStmts()[capture_size()];
1349}
1350
1351const CompoundStmt *LambdaExpr::getCompoundStmtBody() const {
1352 Stmt *Body = getBody();
1353 if (const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Val: Body))
1354 return cast<CompoundStmt>(Val: CoroBody->getBody());
1355 return cast<CompoundStmt>(Val: Body);
1356}
1357
1358bool LambdaExpr::isInitCapture(const LambdaCapture *C) const {
1359 return C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
1360 getCallOperator() == C->getCapturedVar()->getDeclContext();
1361}
1362
1363LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
1364 return getLambdaClass()->captures_begin();
1365}
1366
1367LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
1368 return getLambdaClass()->captures_end();
1369}
1370
1371LambdaExpr::capture_range LambdaExpr::captures() const {
1372 return capture_range(capture_begin(), capture_end());
1373}
1374
1375LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const {
1376 return capture_begin();
1377}
1378
1379LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const {
1380 return capture_begin() +
1381 getLambdaClass()->getLambdaData().NumExplicitCaptures;
1382}
1383
1384LambdaExpr::capture_range LambdaExpr::explicit_captures() const {
1385 return capture_range(explicit_capture_begin(), explicit_capture_end());
1386}
1387
1388LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const {
1389 return explicit_capture_end();
1390}
1391
1392LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const {
1393 return capture_end();
1394}
1395
1396LambdaExpr::capture_range LambdaExpr::implicit_captures() const {
1397 return capture_range(implicit_capture_begin(), implicit_capture_end());
1398}
1399
1400CXXRecordDecl *LambdaExpr::getLambdaClass() const {
1401 return getType()->getAsCXXRecordDecl();
1402}
1403
1404CXXMethodDecl *LambdaExpr::getCallOperator() const {
1405 CXXRecordDecl *Record = getLambdaClass();
1406 return Record->getLambdaCallOperator();
1407}
1408
1409FunctionTemplateDecl *LambdaExpr::getDependentCallOperator() const {
1410 CXXRecordDecl *Record = getLambdaClass();
1411 return Record->getDependentLambdaCallOperator();
1412}
1413
1414TemplateParameterList *LambdaExpr::getTemplateParameterList() const {
1415 CXXRecordDecl *Record = getLambdaClass();
1416 return Record->getGenericLambdaTemplateParameterList();
1417}
1418
1419ArrayRef<NamedDecl *> LambdaExpr::getExplicitTemplateParameters() const {
1420 const CXXRecordDecl *Record = getLambdaClass();
1421 return Record->getLambdaExplicitTemplateParameters();
1422}
1423
1424const AssociatedConstraint &LambdaExpr::getTrailingRequiresClause() const {
1425 return getCallOperator()->getTrailingRequiresClause();
1426}
1427
1428bool LambdaExpr::isMutable() const { return !getCallOperator()->isConst(); }
1429
1430LambdaExpr::child_range LambdaExpr::children() {
1431 initBodyIfNeeded();
1432 return child_range(getStoredStmts(), getStoredStmts() + capture_size() + 1);
1433}
1434
1435LambdaExpr::const_child_range LambdaExpr::children() const {
1436 initBodyIfNeeded();
1437 return const_child_range(getStoredStmts(),
1438 getStoredStmts() + capture_size() + 1);
1439}
1440
1441ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
1442 bool CleanupsHaveSideEffects,
1443 ArrayRef<CleanupObject> objects)
1444 : FullExpr(ExprWithCleanupsClass, subexpr) {
1445 ExprWithCleanupsBits.CleanupsHaveSideEffects = CleanupsHaveSideEffects;
1446 ExprWithCleanupsBits.NumObjects = objects.size();
1447 llvm::copy(Range&: objects, Out: getTrailingObjects());
1448}
1449
1450ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr,
1451 bool CleanupsHaveSideEffects,
1452 ArrayRef<CleanupObject> objects) {
1453 void *buffer = C.Allocate(Size: totalSizeToAlloc<CleanupObject>(Counts: objects.size()),
1454 Align: alignof(ExprWithCleanups));
1455 return new (buffer)
1456 ExprWithCleanups(subexpr, CleanupsHaveSideEffects, objects);
1457}
1458
1459ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
1460 : FullExpr(ExprWithCleanupsClass, empty) {
1461 ExprWithCleanupsBits.NumObjects = numObjects;
1462}
1463
1464ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C,
1465 EmptyShell empty,
1466 unsigned numObjects) {
1467 void *buffer = C.Allocate(Size: totalSizeToAlloc<CleanupObject>(Counts: numObjects),
1468 Align: alignof(ExprWithCleanups));
1469 return new (buffer) ExprWithCleanups(empty, numObjects);
1470}
1471
1472CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
1473 QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc,
1474 ArrayRef<Expr *> Args, SourceLocation RParenLoc, bool IsListInit)
1475 : Expr(CXXUnresolvedConstructExprClass, T,
1476 (TSI->getType()->isLValueReferenceType() ? VK_LValue
1477 : TSI->getType()->isRValueReferenceType() ? VK_XValue
1478 : VK_PRValue),
1479 OK_Ordinary),
1480 TypeAndInitForm(TSI, IsListInit), LParenLoc(LParenLoc),
1481 RParenLoc(RParenLoc) {
1482 CXXUnresolvedConstructExprBits.NumArgs = Args.size();
1483 auto **StoredArgs = getTrailingObjects();
1484 llvm::copy(Range&: Args, Out: StoredArgs);
1485 setDependence(computeDependence(E: this));
1486}
1487
1488CXXUnresolvedConstructExpr *CXXUnresolvedConstructExpr::Create(
1489 const ASTContext &Context, QualType T, TypeSourceInfo *TSI,
1490 SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc,
1491 bool IsListInit) {
1492 void *Mem = Context.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: Args.size()));
1493 return new (Mem) CXXUnresolvedConstructExpr(T, TSI, LParenLoc, Args,
1494 RParenLoc, IsListInit);
1495}
1496
1497CXXUnresolvedConstructExpr *
1498CXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &Context,
1499 unsigned NumArgs) {
1500 void *Mem = Context.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: NumArgs));
1501 return new (Mem) CXXUnresolvedConstructExpr(EmptyShell(), NumArgs);
1502}
1503
1504SourceLocation CXXUnresolvedConstructExpr::getBeginLoc() const {
1505 return TypeAndInitForm.getPointer()->getTypeLoc().getBeginLoc();
1506}
1507
1508CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1509 const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
1510 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
1511 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
1512 DeclarationNameInfo MemberNameInfo,
1513 const TemplateArgumentListInfo *TemplateArgs)
1514 : Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy, VK_LValue,
1515 OK_Ordinary),
1516 Base(Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
1517 MemberNameInfo(MemberNameInfo) {
1518 CXXDependentScopeMemberExprBits.IsArrow = IsArrow;
1519 CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo =
1520 (TemplateArgs != nullptr) || TemplateKWLoc.isValid();
1521 CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope =
1522 FirstQualifierFoundInScope != nullptr;
1523 CXXDependentScopeMemberExprBits.OperatorLoc = OperatorLoc;
1524
1525 if (TemplateArgs) {
1526 auto Deps = TemplateArgumentDependence::None;
1527 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1528 TemplateKWLoc, List: *TemplateArgs, OutArgArray: getTrailingObjects<TemplateArgumentLoc>(),
1529 Deps);
1530 } else if (TemplateKWLoc.isValid()) {
1531 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1532 TemplateKWLoc);
1533 }
1534
1535 if (hasFirstQualifierFoundInScope())
1536 *getTrailingObjects<NamedDecl *>() = FirstQualifierFoundInScope;
1537 setDependence(computeDependence(E: this));
1538}
1539
1540CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
1541 EmptyShell Empty, bool HasTemplateKWAndArgsInfo,
1542 bool HasFirstQualifierFoundInScope)
1543 : Expr(CXXDependentScopeMemberExprClass, Empty) {
1544 CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo =
1545 HasTemplateKWAndArgsInfo;
1546 CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope =
1547 HasFirstQualifierFoundInScope;
1548}
1549
1550CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::Create(
1551 const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
1552 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
1553 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
1554 DeclarationNameInfo MemberNameInfo,
1555 const TemplateArgumentListInfo *TemplateArgs) {
1556 bool HasTemplateKWAndArgsInfo =
1557 (TemplateArgs != nullptr) || TemplateKWLoc.isValid();
1558 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
1559 bool HasFirstQualifierFoundInScope = FirstQualifierFoundInScope != nullptr;
1560
1561 unsigned Size = totalSizeToAlloc<ASTTemplateKWAndArgsInfo,
1562 TemplateArgumentLoc, NamedDecl *>(
1563 Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs, Counts: HasFirstQualifierFoundInScope);
1564
1565 void *Mem = Ctx.Allocate(Size, Align: alignof(CXXDependentScopeMemberExpr));
1566 return new (Mem) CXXDependentScopeMemberExpr(
1567 Ctx, Base, BaseType, IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1568 FirstQualifierFoundInScope, MemberNameInfo, TemplateArgs);
1569}
1570
1571CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::CreateEmpty(
1572 const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo,
1573 unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope) {
1574 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1575
1576 unsigned Size = totalSizeToAlloc<ASTTemplateKWAndArgsInfo,
1577 TemplateArgumentLoc, NamedDecl *>(
1578 Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs, Counts: HasFirstQualifierFoundInScope);
1579
1580 void *Mem = Ctx.Allocate(Size, Align: alignof(CXXDependentScopeMemberExpr));
1581 return new (Mem) CXXDependentScopeMemberExpr(
1582 EmptyShell(), HasTemplateKWAndArgsInfo, HasFirstQualifierFoundInScope);
1583}
1584
1585CXXThisExpr *CXXThisExpr::Create(const ASTContext &Ctx, SourceLocation L,
1586 QualType Ty, bool IsImplicit) {
1587 return new (Ctx) CXXThisExpr(L, Ty, IsImplicit,
1588 Ctx.getLangOpts().HLSL ? VK_LValue : VK_PRValue);
1589}
1590
1591CXXThisExpr *CXXThisExpr::CreateEmpty(const ASTContext &Ctx) {
1592 return new (Ctx) CXXThisExpr(EmptyShell());
1593}
1594
1595static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
1596 UnresolvedSetIterator end) {
1597 do {
1598 NamedDecl *decl = *begin;
1599 if (isa<UnresolvedUsingValueDecl>(Val: decl))
1600 return false;
1601
1602 // Unresolved member expressions should only contain methods and
1603 // method templates.
1604 if (cast<CXXMethodDecl>(Val: decl->getUnderlyingDecl()->getAsFunction())
1605 ->isStatic())
1606 return false;
1607 } while (++begin != end);
1608
1609 return true;
1610}
1611
1612UnresolvedMemberExpr::UnresolvedMemberExpr(
1613 const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
1614 QualType BaseType, bool IsArrow, SourceLocation OperatorLoc,
1615 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
1616 const DeclarationNameInfo &MemberNameInfo,
1617 const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
1618 UnresolvedSetIterator End)
1619 : OverloadExpr(
1620 UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,
1621 MemberNameInfo, TemplateArgs, Begin, End,
1622 // Dependent
1623 ((Base && Base->isTypeDependent()) || BaseType->isDependentType()),
1624 ((Base && Base->isInstantiationDependent()) ||
1625 BaseType->isInstantiationDependentType()),
1626 // Contains unexpanded parameter pack
1627 ((Base && Base->containsUnexpandedParameterPack()) ||
1628 BaseType->containsUnexpandedParameterPack())),
1629 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1630 UnresolvedMemberExprBits.IsArrow = IsArrow;
1631 UnresolvedMemberExprBits.HasUnresolvedUsing = HasUnresolvedUsing;
1632
1633 // Check whether all of the members are non-static member functions,
1634 // and if so, mark give this bound-member type instead of overload type.
1635 if (hasOnlyNonStaticMemberFunctions(begin: Begin, end: End))
1636 setType(Context.BoundMemberTy);
1637}
1638
1639UnresolvedMemberExpr::UnresolvedMemberExpr(EmptyShell Empty,
1640 unsigned NumResults,
1641 bool HasTemplateKWAndArgsInfo)
1642 : OverloadExpr(UnresolvedMemberExprClass, Empty, NumResults,
1643 HasTemplateKWAndArgsInfo) {}
1644
1645bool UnresolvedMemberExpr::isImplicitAccess() const {
1646 if (!Base)
1647 return true;
1648
1649 return cast<Expr>(Val: Base)->isImplicitCXXThis();
1650}
1651
1652UnresolvedMemberExpr *UnresolvedMemberExpr::Create(
1653 const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
1654 QualType BaseType, bool IsArrow, SourceLocation OperatorLoc,
1655 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
1656 const DeclarationNameInfo &MemberNameInfo,
1657 const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
1658 UnresolvedSetIterator End) {
1659 unsigned NumResults = End - Begin;
1660 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
1661 unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
1662 unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
1663 TemplateArgumentLoc>(
1664 Counts: NumResults, Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs);
1665 void *Mem = Context.Allocate(Size, Align: alignof(UnresolvedMemberExpr));
1666 return new (Mem) UnresolvedMemberExpr(
1667 Context, HasUnresolvedUsing, Base, BaseType, IsArrow, OperatorLoc,
1668 QualifierLoc, TemplateKWLoc, MemberNameInfo, TemplateArgs, Begin, End);
1669}
1670
1671UnresolvedMemberExpr *UnresolvedMemberExpr::CreateEmpty(
1672 const ASTContext &Context, unsigned NumResults,
1673 bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) {
1674 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
1675 unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
1676 TemplateArgumentLoc>(
1677 Counts: NumResults, Counts: HasTemplateKWAndArgsInfo, Counts: NumTemplateArgs);
1678 void *Mem = Context.Allocate(Size, Align: alignof(UnresolvedMemberExpr));
1679 return new (Mem)
1680 UnresolvedMemberExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo);
1681}
1682
1683CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() {
1684 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
1685
1686 // If there was a nested name specifier, it names the naming class.
1687 // It can't be dependent: after all, we were actually able to do the
1688 // lookup.
1689 CXXRecordDecl *Record = nullptr;
1690 if (NestedNameSpecifier Qualifier = getQualifier();
1691 Qualifier.getKind() == NestedNameSpecifier::Kind::Type) {
1692 const Type *T = getQualifier().getAsType();
1693 Record = T->getAsCXXRecordDecl();
1694 assert(Record && "qualifier in member expression does not name record");
1695 }
1696 // Otherwise the naming class must have been the base class.
1697 else {
1698 QualType BaseType = getBaseType().getNonReferenceType();
1699 if (isArrow())
1700 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
1701
1702 Record = BaseType->getAsCXXRecordDecl();
1703 assert(Record && "base of member expression does not name record");
1704 }
1705
1706 return Record;
1707}
1708
1709SizeOfPackExpr *SizeOfPackExpr::Create(ASTContext &Context,
1710 SourceLocation OperatorLoc,
1711 NamedDecl *Pack, SourceLocation PackLoc,
1712 SourceLocation RParenLoc,
1713 UnsignedOrNone Length,
1714 ArrayRef<TemplateArgument> PartialArgs) {
1715 void *Storage =
1716 Context.Allocate(Size: totalSizeToAlloc<TemplateArgument>(Counts: PartialArgs.size()));
1717 return new (Storage) SizeOfPackExpr(Context.getSizeType(), OperatorLoc, Pack,
1718 PackLoc, RParenLoc, Length, PartialArgs);
1719}
1720
1721SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context,
1722 unsigned NumPartialArgs) {
1723 void *Storage =
1724 Context.Allocate(Size: totalSizeToAlloc<TemplateArgument>(Counts: NumPartialArgs));
1725 return new (Storage) SizeOfPackExpr(EmptyShell(), NumPartialArgs);
1726}
1727
1728NonTypeTemplateParmDecl *SubstNonTypeTemplateParmExpr::getParameter() const {
1729 return cast<NonTypeTemplateParmDecl>(
1730 Val: std::get<0>(t: getReplacedTemplateParameter(D: getAssociatedDecl(), Index)));
1731}
1732
1733PackIndexingExpr *PackIndexingExpr::Create(
1734 ASTContext &Context, SourceLocation EllipsisLoc, SourceLocation RSquareLoc,
1735 Expr *PackIdExpr, Expr *IndexExpr, std::optional<int64_t> Index,
1736 ArrayRef<Expr *> SubstitutedExprs, bool FullySubstituted) {
1737 QualType Type;
1738 if (Index && FullySubstituted && !SubstitutedExprs.empty())
1739 Type = SubstitutedExprs[*Index]->getType();
1740 else
1741 Type = PackIdExpr->getType();
1742
1743 void *Storage =
1744 Context.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: SubstitutedExprs.size()));
1745 return new (Storage)
1746 PackIndexingExpr(Type, EllipsisLoc, RSquareLoc, PackIdExpr, IndexExpr,
1747 SubstitutedExprs, FullySubstituted);
1748}
1749
1750NamedDecl *PackIndexingExpr::getPackDecl() const {
1751 if (auto *D = dyn_cast<DeclRefExpr>(Val: getPackIdExpression()); D) {
1752 NamedDecl *ND = dyn_cast<NamedDecl>(Val: D->getDecl());
1753 assert(ND && "exected a named decl");
1754 return ND;
1755 }
1756 assert(false && "invalid declaration kind in pack indexing expression");
1757 return nullptr;
1758}
1759
1760PackIndexingExpr *
1761PackIndexingExpr::CreateDeserialized(ASTContext &Context,
1762 unsigned NumTransformedExprs) {
1763 void *Storage =
1764 Context.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: NumTransformedExprs));
1765 return new (Storage) PackIndexingExpr(EmptyShell{});
1766}
1767
1768QualType SubstNonTypeTemplateParmExpr::getParameterType(
1769 const ASTContext &Context) const {
1770 // Note that, for a class type NTTP, we will have an lvalue of type 'const
1771 // T', so we can't just compute this from the type and value category.
1772
1773 QualType Type = getType();
1774
1775 if (isReferenceParameter())
1776 return Context.getLValueReferenceType(T: Type);
1777 return Type.getUnqualifiedType();
1778}
1779
1780SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
1781 QualType T, ExprValueKind ValueKind, SourceLocation NameLoc,
1782 const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
1783 bool Final)
1784 : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary),
1785 AssociatedDecl(AssociatedDecl), Arguments(ArgPack.pack_begin()),
1786 NumArguments(ArgPack.pack_size()), Final(Final), Index(Index),
1787 NameLoc(NameLoc) {
1788 assert(AssociatedDecl != nullptr);
1789 setDependence(ExprDependence::TypeValueInstantiation |
1790 ExprDependence::UnexpandedPack);
1791}
1792
1793NonTypeTemplateParmDecl *
1794SubstNonTypeTemplateParmPackExpr::getParameterPack() const {
1795 return cast<NonTypeTemplateParmDecl>(
1796 Val: std::get<0>(t: getReplacedTemplateParameter(D: getAssociatedDecl(), Index)));
1797}
1798
1799TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1800 return TemplateArgument(ArrayRef(Arguments, NumArguments));
1801}
1802
1803FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ValueDecl *ParamPack,
1804 SourceLocation NameLoc,
1805 unsigned NumParams,
1806 ValueDecl *const *Params)
1807 : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary),
1808 ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
1809 if (Params)
1810 std::uninitialized_copy(first: Params, last: Params + NumParams, result: getTrailingObjects());
1811 setDependence(ExprDependence::TypeValueInstantiation |
1812 ExprDependence::UnexpandedPack);
1813}
1814
1815FunctionParmPackExpr *
1816FunctionParmPackExpr::Create(const ASTContext &Context, QualType T,
1817 ValueDecl *ParamPack, SourceLocation NameLoc,
1818 ArrayRef<ValueDecl *> Params) {
1819 return new (Context.Allocate(Size: totalSizeToAlloc<ValueDecl *>(Counts: Params.size())))
1820 FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data());
1821}
1822
1823FunctionParmPackExpr *
1824FunctionParmPackExpr::CreateEmpty(const ASTContext &Context,
1825 unsigned NumParams) {
1826 return new (Context.Allocate(Size: totalSizeToAlloc<ValueDecl *>(Counts: NumParams)))
1827 FunctionParmPackExpr(QualType(), nullptr, SourceLocation(), 0, nullptr);
1828}
1829
1830MaterializeTemporaryExpr::MaterializeTemporaryExpr(
1831 QualType T, Expr *Temporary, bool BoundToLvalueReference,
1832 LifetimeExtendedTemporaryDecl *MTD)
1833 : Expr(MaterializeTemporaryExprClass, T,
1834 BoundToLvalueReference ? VK_LValue : VK_XValue, OK_Ordinary) {
1835 if (MTD) {
1836 State = MTD;
1837 MTD->ExprWithTemporary = Temporary;
1838 return;
1839 }
1840 State = Temporary;
1841 setDependence(computeDependence(E: this));
1842}
1843
1844void MaterializeTemporaryExpr::setExtendingDecl(ValueDecl *ExtendedBy,
1845 unsigned ManglingNumber) {
1846 // We only need extra state if we have to remember more than just the Stmt.
1847 if (!ExtendedBy)
1848 return;
1849
1850 // We may need to allocate extra storage for the mangling number and the
1851 // extended-by ValueDecl.
1852 if (!isa<LifetimeExtendedTemporaryDecl *>(Val: State))
1853 State = LifetimeExtendedTemporaryDecl::Create(
1854 Temp: cast<Expr>(Val: cast<Stmt *>(Val&: State)), EDec: ExtendedBy, Mangling: ManglingNumber);
1855
1856 auto ES = cast<LifetimeExtendedTemporaryDecl *>(Val&: State);
1857 ES->ExtendingDecl = ExtendedBy;
1858 ES->ManglingNumber = ManglingNumber;
1859}
1860
1861bool MaterializeTemporaryExpr::isUsableInConstantExpressions(
1862 const ASTContext &Context) const {
1863 // C++20 [expr.const]p4:
1864 // An object or reference is usable in constant expressions if it is [...]
1865 // a temporary object of non-volatile const-qualified literal type
1866 // whose lifetime is extended to that of a variable that is usable
1867 // in constant expressions
1868 auto *VD = dyn_cast_or_null<VarDecl>(Val: getExtendingDecl());
1869 return VD && getType().isConstant(Ctx: Context) &&
1870 !getType().isVolatileQualified() &&
1871 getType()->isLiteralType(Ctx: Context) &&
1872 VD->isUsableInConstantExpressions(C: Context);
1873}
1874
1875TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
1876 ArrayRef<TypeSourceInfo *> Args,
1877 SourceLocation RParenLoc,
1878 std::variant<bool, APValue> Value)
1879 : Expr(TypeTraitExprClass, T, VK_PRValue, OK_Ordinary), Loc(Loc),
1880 RParenLoc(RParenLoc) {
1881 assert(Kind <= TT_Last && "invalid enum value!");
1882
1883 TypeTraitExprBits.Kind = Kind;
1884 assert(static_cast<unsigned>(Kind) == TypeTraitExprBits.Kind &&
1885 "TypeTraitExprBits.Kind overflow!");
1886
1887 TypeTraitExprBits.IsBooleanTypeTrait = std::holds_alternative<bool>(v: Value);
1888 if (TypeTraitExprBits.IsBooleanTypeTrait)
1889 TypeTraitExprBits.Value = std::get<bool>(v&: Value);
1890 else
1891 ::new (getTrailingObjects<APValue>())
1892 APValue(std::get<APValue>(v: std::move(Value)));
1893
1894 TypeTraitExprBits.NumArgs = Args.size();
1895 assert(Args.size() == TypeTraitExprBits.NumArgs &&
1896 "TypeTraitExprBits.NumArgs overflow!");
1897 auto **ToArgs = getTrailingObjects<TypeSourceInfo *>();
1898 llvm::copy(Range&: Args, Out: ToArgs);
1899
1900 setDependence(computeDependence(E: this));
1901
1902 assert((TypeTraitExprBits.IsBooleanTypeTrait || isValueDependent() ||
1903 getAPValue().isInt() || getAPValue().isAbsent()) &&
1904 "Only int values are supported by clang");
1905}
1906
1907TypeTraitExpr::TypeTraitExpr(EmptyShell Empty, bool IsStoredAsBool)
1908 : Expr(TypeTraitExprClass, Empty) {
1909 TypeTraitExprBits.IsBooleanTypeTrait = IsStoredAsBool;
1910 if (!IsStoredAsBool)
1911 ::new (getTrailingObjects<APValue>()) APValue();
1912}
1913
1914TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T,
1915 SourceLocation Loc,
1916 TypeTrait Kind,
1917 ArrayRef<TypeSourceInfo *> Args,
1918 SourceLocation RParenLoc,
1919 bool Value) {
1920 void *Mem =
1921 C.Allocate(Size: totalSizeToAlloc<APValue, TypeSourceInfo *>(Counts: 0, Counts: Args.size()));
1922 return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value);
1923}
1924
1925TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T,
1926 SourceLocation Loc, TypeTrait Kind,
1927 ArrayRef<TypeSourceInfo *> Args,
1928 SourceLocation RParenLoc, APValue Value) {
1929 void *Mem =
1930 C.Allocate(Size: totalSizeToAlloc<APValue, TypeSourceInfo *>(Counts: 1, Counts: Args.size()));
1931 return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value);
1932}
1933
1934TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C,
1935 bool IsStoredAsBool,
1936 unsigned NumArgs) {
1937 void *Mem = C.Allocate(Size: totalSizeToAlloc<APValue, TypeSourceInfo *>(
1938 Counts: IsStoredAsBool ? 0 : 1, Counts: NumArgs));
1939 return new (Mem) TypeTraitExpr(EmptyShell(), IsStoredAsBool);
1940}
1941
1942CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
1943 ArrayRef<Expr *> Args, QualType Ty,
1944 ExprValueKind VK, SourceLocation RP,
1945 FPOptionsOverride FPFeatures,
1946 unsigned MinNumArgs)
1947 : CallExpr(CUDAKernelCallExprClass, Fn, /*PreArgs=*/Config, Args, Ty, VK,
1948 RP, FPFeatures, MinNumArgs, NotADL) {}
1949
1950CUDAKernelCallExpr::CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures,
1951 EmptyShell Empty)
1952 : CallExpr(CUDAKernelCallExprClass, /*NumPreArgs=*/END_PREARG, NumArgs,
1953 HasFPFeatures, Empty) {}
1954
1955CUDAKernelCallExpr *
1956CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
1957 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
1958 SourceLocation RP, FPOptionsOverride FPFeatures,
1959 unsigned MinNumArgs) {
1960 // Allocate storage for the trailing objects of CallExpr.
1961 unsigned NumArgs = std::max<unsigned>(a: Args.size(), b: MinNumArgs);
1962 unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
1963 /*NumPreArgs=*/END_PREARG, NumArgs, HasFPFeatures: FPFeatures.requiresTrailingStorage());
1964 void *Mem =
1965 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CUDAKernelCallExpr>(
1966 SizeOfTrailingObjects),
1967 Align: alignof(CUDAKernelCallExpr));
1968 return new (Mem)
1969 CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, FPFeatures, MinNumArgs);
1970}
1971
1972CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
1973 unsigned NumArgs,
1974 bool HasFPFeatures,
1975 EmptyShell Empty) {
1976 // Allocate storage for the trailing objects of CallExpr.
1977 unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
1978 /*NumPreArgs=*/END_PREARG, NumArgs, HasFPFeatures);
1979 void *Mem =
1980 Ctx.Allocate(Size: sizeToAllocateForCallExprSubclass<CUDAKernelCallExpr>(
1981 SizeOfTrailingObjects),
1982 Align: alignof(CUDAKernelCallExpr));
1983 return new (Mem) CUDAKernelCallExpr(NumArgs, HasFPFeatures, Empty);
1984}
1985
1986CXXParenListInitExpr *
1987CXXParenListInitExpr::Create(ASTContext &C, ArrayRef<Expr *> Args, QualType T,
1988 unsigned NumUserSpecifiedExprs,
1989 SourceLocation InitLoc, SourceLocation LParenLoc,
1990 SourceLocation RParenLoc) {
1991 void *Mem = C.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: Args.size()));
1992 return new (Mem) CXXParenListInitExpr(Args, T, NumUserSpecifiedExprs, InitLoc,
1993 LParenLoc, RParenLoc);
1994}
1995
1996CXXParenListInitExpr *CXXParenListInitExpr::CreateEmpty(ASTContext &C,
1997 unsigned NumExprs,
1998 EmptyShell Empty) {
1999 void *Mem = C.Allocate(Size: totalSizeToAlloc<Expr *>(Counts: NumExprs),
2000 Align: alignof(CXXParenListInitExpr));
2001 return new (Mem) CXXParenListInitExpr(Empty, NumExprs);
2002}
2003
2004CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
2005 SourceLocation LParenLoc, Expr *LHS,
2006 BinaryOperatorKind Opcode, SourceLocation EllipsisLoc,
2007 Expr *RHS, SourceLocation RParenLoc,
2008 UnsignedOrNone NumExpansions)
2009 : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary), LParenLoc(LParenLoc),
2010 EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
2011 NumExpansions(NumExpansions) {
2012 CXXFoldExprBits.Opcode = Opcode;
2013 // We rely on asserted invariant to distinguish left and right folds.
2014 if (LHS && RHS)
2015 assert(LHS->containsUnexpandedParameterPack() !=
2016 RHS->containsUnexpandedParameterPack() &&
2017 "Exactly one of LHS or RHS should contain an unexpanded pack");
2018 SubExprs[SubExpr::Callee] = Callee;
2019 SubExprs[SubExpr::LHS] = LHS;
2020 SubExprs[SubExpr::RHS] = RHS;
2021 setDependence(computeDependence(E: this));
2022}
2023