1 //===- ExprCXX.h - Classes for representing expressions ---------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
10 /// Defines the clang::Expr interface and subclasses for C++ expressions.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_EXPRCXX_H
15 #define LLVM_CLANG_AST_EXPRCXX_H
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"
62 class NonTypeTemplateParmDecl;
63 class TemplateParameterList;
65 //===--------------------------------------------------------------------===//
67 //===--------------------------------------------------------------------===//
69 /// A call to an overloaded operator written using operator
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.
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
82 class CXXOperatorCallExpr final : public CallExpr {
83 friend class ASTStmtReader;
84 friend class ASTStmtWriter;
88 // CXXOperatorCallExpr has some trailing objects belonging
89 // to CallExpr. See CallExpr for the details.
91 SourceRange getSourceRangeImpl() const LLVM_READONLY;
93 CXXOperatorCallExpr(OverloadedOperatorKind OpKind, Expr *Fn,
94 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
95 SourceLocation OperatorLoc, FPOptionsOverride FPFeatures,
98 CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
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);
107 static CXXOperatorCallExpr *CreateEmpty(const ASTContext &Ctx,
108 unsigned NumArgs, bool HasFPFeatures,
111 /// Returns the kind of overloaded operator that this expression refers to.
112 OverloadedOperatorKind getOperator() const {
113 return static_cast<OverloadedOperatorKind>(
114 CXXOperatorCallExprBits.OperatorKind);
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;
124 bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }
126 static bool isComparisonOp(OverloadedOperatorKind Opc) {
129 case OO_ExclaimEqual:
131 case OO_GreaterEqual:
140 bool isComparisonOp() const { return isComparisonOp(getOperator()); }
142 /// Is this written as an infix binary operator?
143 bool isInfixBinaryOp() const;
145 /// Returns the location of the operator symbol in the expression.
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(); }
152 SourceLocation getExprLoc() const LLVM_READONLY {
153 OverloadedOperatorKind Operator = getOperator();
154 return (Operator < OO_Plus || Operator >= OO_Arrow ||
155 Operator == OO_PlusPlus || Operator == OO_MinusMinus)
160 SourceLocation getBeginLoc() const { return Range.getBegin(); }
161 SourceLocation getEndLoc() const { return Range.getEnd(); }
162 SourceRange getSourceRange() const { return Range; }
164 static bool classof(const Stmt *T) {
165 return T->getStmtClass() == CXXOperatorCallExprClass;
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).
177 class CXXMemberCallExpr final : public CallExpr {
178 // CXXMemberCallExpr has some trailing objects belonging
179 // to CallExpr. See CallExpr for the details.
181 CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
182 ExprValueKind VK, SourceLocation RP,
183 FPOptionsOverride FPOptions, unsigned MinNumArgs);
185 CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
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);
194 static CXXMemberCallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
195 bool HasFPFeatures, EmptyShell Empty);
197 /// Retrieve the implicit object argument for the member call.
199 /// For example, in "x.f(5)", this returns the sub-expression "x".
200 Expr *getImplicitObjectArgument() const;
202 /// Retrieve the type of the object argument.
204 /// Note that this always returns a non-pointer type.
205 QualType getObjectType() const;
207 /// Retrieve the declaration of the called method.
208 CXXMethodDecl *getMethodDecl() const;
210 /// Retrieve the CXXRecordDecl for the underlying type of
211 /// the implicit object argument.
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;
218 SourceLocation getExprLoc() const LLVM_READONLY {
219 SourceLocation CLoc = getCallee()->getExprLoc();
223 return getBeginLoc();
226 static bool classof(const Stmt *T) {
227 return T->getStmtClass() == CXXMemberCallExprClass;
231 /// Represents a call to a CUDA kernel function.
232 class CUDAKernelCallExpr final : public CallExpr {
233 friend class ASTStmtReader;
235 enum { CONFIG, END_PREARG };
237 // CUDAKernelCallExpr has some trailing objects belonging
238 // to CallExpr. See CallExpr for the details.
240 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
241 QualType Ty, ExprValueKind VK, SourceLocation RP,
242 FPOptionsOverride FPFeatures, unsigned MinNumArgs);
244 CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
247 static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
248 CallExpr *Config, ArrayRef<Expr *> Args,
249 QualType Ty, ExprValueKind VK,
251 FPOptionsOverride FPFeatures,
252 unsigned MinNumArgs = 0);
254 static CUDAKernelCallExpr *CreateEmpty(const ASTContext &Ctx,
255 unsigned NumArgs, bool HasFPFeatures,
258 const CallExpr *getConfig() const {
259 return cast_or_null<CallExpr>(getPreArg(CONFIG));
261 CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
263 static bool classof(const Stmt *T) {
264 return T->getStmtClass() == CUDAKernelCallExprClass;
268 /// A rewritten comparison expression that was originally written using
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>
279 /// This expression provides access to both the original syntax and the
280 /// rewritten expression.
282 /// Note that the rewritten calls to \c ==, \c <=>, and \c \@ are typically
283 /// \c CXXOperatorCallExprs, but could theoretically be \c BinaryOperators.
284 class CXXRewrittenBinaryOperator : public Expr {
285 friend class ASTStmtReader;
287 /// The rewritten semantic form.
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));
298 CXXRewrittenBinaryOperator(EmptyShell Empty)
299 : Expr(CXXRewrittenBinaryOperatorClass, Empty), SemanticForm() {}
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); }
305 struct DecomposedForm {
306 /// The original opcode, prior to rewriting.
307 BinaryOperatorKind Opcode;
308 /// The original left-hand side.
310 /// The original right-hand side.
312 /// The inner \c == or \c <=> operator expression.
313 const Expr *InnerBinOp;
316 /// Decompose this operator into its syntactic form.
317 DecomposedForm getDecomposedForm() const LLVM_READONLY;
319 /// Determine whether this expression was rewritten in reverse form.
320 bool isReversed() const { return CXXRewrittenBinaryOperatorBits.IsReversed; }
322 BinaryOperatorKind getOperator() const { return getDecomposedForm().Opcode; }
323 BinaryOperatorKind getOpcode() const { return getOperator(); }
324 static StringRef getOpcodeStr(BinaryOperatorKind Op) {
325 return BinaryOperator::getOpcodeStr(Op);
327 StringRef getOpcodeStr() const {
328 return BinaryOperator::getOpcodeStr(getOpcode());
330 bool isComparisonOp() const { return true; }
331 bool isAssignmentOp() const { return false; }
333 const Expr *getLHS() const { return getDecomposedForm().LHS; }
334 const Expr *getRHS() const { return getDecomposedForm().RHS; }
336 SourceLocation getOperatorLoc() const LLVM_READONLY {
337 return getDecomposedForm().InnerBinOp->getExprLoc();
339 SourceLocation getExprLoc() const LLVM_READONLY { return getOperatorLoc(); }
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.
345 SourceLocation getBeginLoc() const LLVM_READONLY {
346 return getDecomposedForm().LHS->getBeginLoc();
348 SourceLocation getEndLoc() const LLVM_READONLY {
349 return getDecomposedForm().RHS->getEndLoc();
351 SourceRange getSourceRange() const LLVM_READONLY {
352 DecomposedForm DF = getDecomposedForm();
353 return SourceRange(DF.LHS->getBeginLoc(), DF.RHS->getEndLoc());
357 child_range children() {
358 return child_range(&SemanticForm, &SemanticForm + 1);
361 static bool classof(const Stmt *T) {
362 return T->getStmtClass() == CXXRewrittenBinaryOperatorClass;
366 /// Abstract class common to all of the C++ "named"/"keyword" casts.
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).
373 class CXXNamedCastExpr : public ExplicitCastExpr {
375 // the location of the casting op
378 // the location of the right parenthesis
379 SourceLocation RParenLoc;
382 SourceRange AngleBrackets;
385 friend class ASTStmtReader;
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,
393 Loc(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}
395 explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize,
397 : ExplicitCastExpr(SC, Shell, PathSize, HasFPFeatures) {}
400 const char *getCastName() const;
402 /// Retrieve the location of the cast operator keyword, e.g.,
404 SourceLocation getOperatorLoc() const { return Loc; }
406 /// Retrieve the location of the closing parenthesis.
407 SourceLocation getRParenLoc() const { return RParenLoc; }
409 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
410 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
411 SourceRange getAngleBrackets() const LLVM_READONLY { return AngleBrackets; }
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:
427 /// A C++ \c static_cast expression (C++ [expr.static.cast]).
429 /// This expression node represents a C++ static cast, e.g.,
430 /// \c static_cast<int>(1.0).
431 class CXXStaticCastExpr final
432 : public CXXNamedCastExpr,
433 private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,
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,
442 if (hasStoredFPFeatures())
443 *getTrailingFPFeatures() = FPO;
446 explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize,
448 : CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize,
451 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
456 friend class CastExpr;
457 friend TrailingObjects;
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);
467 static bool classof(const Stmt *T) {
468 return T->getStmtClass() == CXXStaticCastExprClass;
472 /// A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
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.
477 class 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,
488 explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
489 : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize,
490 /*HasFPFeatures*/ false) {}
493 friend class CastExpr;
494 friend TrailingObjects;
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);
503 static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context,
506 bool isAlwaysNull() const;
508 static bool classof(const Stmt *T) {
509 return T->getStmtClass() == CXXDynamicCastExprClass;
513 /// A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
515 /// This expression node represents a reinterpret cast, e.g.,
516 /// @c reinterpret_cast<int>(VoidPtr).
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
521 class 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) {}
533 CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
534 : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize,
535 /*HasFPFeatures*/ false) {}
538 friend class CastExpr;
539 friend TrailingObjects;
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,
550 static bool classof(const Stmt *T) {
551 return T->getStmtClass() == CXXReinterpretCastExprClass;
555 /// A C++ \c const_cast expression (C++ [expr.const.cast]).
557 /// This expression node represents a const cast, e.g.,
558 /// \c const_cast<char*>(PtrToConstChar).
560 /// A const_cast can remove type qualifiers but does not change the underlying
562 class 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,
572 explicit CXXConstCastExpr(EmptyShell Empty)
573 : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0,
574 /*HasFPFeatures*/ false) {}
577 friend class CastExpr;
578 friend TrailingObjects;
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);
587 static bool classof(const Stmt *T) {
588 return T->getStmtClass() == CXXConstCastExprClass;
592 /// A C++ addrspace_cast expression (currently only enabled for OpenCL).
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).
598 /// A addrspace_cast can cast address space type qualifiers but does not change
599 /// the underlying value.
600 class 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,
610 explicit CXXAddrspaceCastExpr(EmptyShell Empty)
611 : CXXNamedCastExpr(CXXAddrspaceCastExprClass, Empty, 0,
612 /*HasFPFeatures*/ false) {}
615 friend class CastExpr;
616 friend TrailingObjects;
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);
624 static bool classof(const Stmt *T) {
625 return T->getStmtClass() == CXXAddrspaceCastExprClass;
629 /// A call to a literal operator (C++11 [over.literal])
630 /// written as a user-defined literal (C++11 [lit.ext]).
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.
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.
638 class UserDefinedLiteral final : public CallExpr {
639 friend class ASTStmtReader;
640 friend class ASTStmtWriter;
642 /// The location of a ud-suffix within the literal.
643 SourceLocation UDSuffixLoc;
645 // UserDefinedLiteral has some trailing objects belonging
646 // to CallExpr. See CallExpr for the details.
648 UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
649 ExprValueKind VK, SourceLocation LitEndLoc,
650 SourceLocation SuffixLoc, FPOptionsOverride FPFeatures);
652 UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
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);
661 static UserDefinedLiteral *CreateEmpty(const ASTContext &Ctx,
662 unsigned NumArgs, bool HasFPOptions,
665 /// The kind of literal operator which is invoked.
666 enum LiteralOperatorKind {
667 /// Raw form: operator "" X (const char *)
670 /// Raw form: operator "" X<cs...> ()
673 /// operator "" X (unsigned long long)
676 /// operator "" X (long double)
679 /// operator "" X (const CharT *, size_t)
682 /// operator "" X (CharT)
686 /// Returns the kind of literal operator invocation
687 /// which this expression represents.
688 LiteralOperatorKind getLiteralOperatorKind() const;
690 /// If this is not a raw user-defined literal, get the
691 /// underlying cooked literal (representing the literal with the suffix
693 Expr *getCookedLiteral();
694 const Expr *getCookedLiteral() const {
695 return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
698 SourceLocation getBeginLoc() const {
699 if (getLiteralOperatorKind() == LOK_Template)
700 return getRParenLoc();
701 return getArg(0)->getBeginLoc();
704 SourceLocation getEndLoc() const { return getRParenLoc(); }
706 /// Returns the location of a ud-suffix in the expression.
708 /// For a string literal, there may be multiple identical suffixes. This
709 /// returns the first.
710 SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }
712 /// Returns the ud-suffix specified for this literal.
713 const IdentifierInfo *getUDSuffix() const;
715 static bool classof(const Stmt *S) {
716 return S->getStmtClass() == UserDefinedLiteralClass;
720 /// A boolean literal, per ([C++ lex.bool] Boolean literals).
721 class CXXBoolLiteralExpr : public Expr {
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);
730 explicit CXXBoolLiteralExpr(EmptyShell Empty)
731 : Expr(CXXBoolLiteralExprClass, Empty) {}
733 bool getValue() const { return CXXBoolLiteralExprBits.Value; }
734 void setValue(bool V) { CXXBoolLiteralExprBits.Value = V; }
736 SourceLocation getBeginLoc() const { return getLocation(); }
737 SourceLocation getEndLoc() const { return getLocation(); }
739 SourceLocation getLocation() const { return CXXBoolLiteralExprBits.Loc; }
740 void setLocation(SourceLocation L) { CXXBoolLiteralExprBits.Loc = L; }
742 static bool classof(const Stmt *T) {
743 return T->getStmtClass() == CXXBoolLiteralExprClass;
747 child_range children() {
748 return child_range(child_iterator(), child_iterator());
751 const_child_range children() const {
752 return const_child_range(const_child_iterator(), const_child_iterator());
756 /// The null pointer literal (C++11 [lex.nullptr])
758 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
759 class CXXNullPtrLiteralExpr : public Expr {
761 CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
762 : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
763 CXXNullPtrLiteralExprBits.Loc = Loc;
764 setDependence(ExprDependence::None);
767 explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
768 : Expr(CXXNullPtrLiteralExprClass, Empty) {}
770 SourceLocation getBeginLoc() const { return getLocation(); }
771 SourceLocation getEndLoc() const { return getLocation(); }
773 SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; }
774 void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; }
776 static bool classof(const Stmt *T) {
777 return T->getStmtClass() == CXXNullPtrLiteralExprClass;
780 child_range children() {
781 return child_range(child_iterator(), child_iterator());
784 const_child_range children() const {
785 return const_child_range(const_child_iterator(), const_child_iterator());
789 /// Implicit construction of a std::initializer_list<T> object from an
790 /// array temporary within list-initialization (C++11 [dcl.init.list]p5).
791 class CXXStdInitializerListExpr : public Expr {
792 Stmt *SubExpr = nullptr;
794 CXXStdInitializerListExpr(EmptyShell Empty)
795 : Expr(CXXStdInitializerListExprClass, Empty) {}
798 friend class ASTReader;
799 friend class ASTStmtReader;
801 CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
802 : Expr(CXXStdInitializerListExprClass, Ty, VK_PRValue, OK_Ordinary),
804 setDependence(computeDependence(this));
807 Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
808 const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }
810 SourceLocation getBeginLoc() const LLVM_READONLY {
811 return SubExpr->getBeginLoc();
814 SourceLocation getEndLoc() const LLVM_READONLY {
815 return SubExpr->getEndLoc();
818 /// Retrieve the source range of the expression.
819 SourceRange getSourceRange() const LLVM_READONLY {
820 return SubExpr->getSourceRange();
823 static bool classof(const Stmt *S) {
824 return S->getStmtClass() == CXXStdInitializerListExprClass;
827 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
829 const_child_range children() const {
830 return const_child_range(&SubExpr, &SubExpr + 1);
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.
838 /// This represents code like \c typeid(int) or \c typeid(*objPtr)
839 class CXXTypeidExpr : public Expr {
840 friend class ASTStmtReader;
843 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
847 CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
848 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
850 setDependence(computeDependence(this));
853 CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
854 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
856 setDependence(computeDependence(this));
859 CXXTypeidExpr(EmptyShell Empty, bool isExpr)
860 : Expr(CXXTypeidExprClass, Empty) {
862 Operand = (Expr*)nullptr;
864 Operand = (TypeSourceInfo*)nullptr;
867 /// Determine whether this typeid has a type operand which is potentially
868 /// evaluated, per C++11 [expr.typeid]p3.
869 bool isPotentiallyEvaluated() const;
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;
875 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
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;
881 /// Retrieve source information for the type operand.
882 TypeSourceInfo *getTypeOperandSourceInfo() const {
883 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
884 return Operand.get<TypeSourceInfo *>();
886 Expr *getExprOperand() const {
887 assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)");
888 return static_cast<Expr*>(Operand.get<Stmt *>());
891 SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
892 SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
893 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
894 void setSourceRange(SourceRange R) { Range = R; }
896 static bool classof(const Stmt *T) {
897 return T->getStmtClass() == CXXTypeidExprClass;
901 child_range children() {
903 return child_range(child_iterator(), child_iterator());
904 auto **begin = reinterpret_cast<Stmt **>(&Operand);
905 return child_range(begin, begin + 1);
908 const_child_range children() const {
910 return const_child_range(const_child_iterator(), const_child_iterator());
913 reinterpret_cast<Stmt **>(&const_cast<CXXTypeidExpr *>(this)->Operand);
914 return const_child_range(begin, begin + 1);
918 /// A member reference to an MSPropertyDecl.
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.
923 class MSPropertyRefExpr : public Expr {
925 MSPropertyDecl *TheDecl;
926 SourceLocation MemberLoc;
928 NestedNameSpecifierLoc QualifierLoc;
931 friend class ASTStmtReader;
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));
942 MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}
944 SourceRange getSourceRange() const LLVM_READONLY {
945 return SourceRange(getBeginLoc(), getEndLoc());
948 bool isImplicitAccess() const {
949 return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
952 SourceLocation getBeginLoc() const {
953 if (!isImplicitAccess())
954 return BaseExpr->getBeginLoc();
955 else if (QualifierLoc)
956 return QualifierLoc.getBeginLoc();
961 SourceLocation getEndLoc() const { return getMemberLoc(); }
963 child_range children() {
964 return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
967 const_child_range children() const {
968 auto Children = const_cast<MSPropertyRefExpr *>(this)->children();
969 return const_child_range(Children.begin(), Children.end());
972 static bool classof(const Stmt *T) {
973 return T->getStmtClass() == MSPropertyRefExprClass;
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; }
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.
988 /// __declspec(property(get=GetX, put=PutX)) int x[];
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.
994 class MSPropertySubscriptExpr : public Expr {
995 friend class ASTStmtReader;
997 enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };
999 Stmt *SubExprs[NUM_SUBEXPRS];
1000 SourceLocation RBracketLoc;
1002 void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
1003 void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }
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));
1015 /// Create an empty array subscript expression.
1016 explicit MSPropertySubscriptExpr(EmptyShell Shell)
1017 : Expr(MSPropertySubscriptExprClass, Shell) {}
1019 Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
1020 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }
1022 Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
1023 const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }
1025 SourceLocation getBeginLoc() const LLVM_READONLY {
1026 return getBase()->getBeginLoc();
1029 SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }
1031 SourceLocation getRBracketLoc() const { return RBracketLoc; }
1032 void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
1034 SourceLocation getExprLoc() const LLVM_READONLY {
1035 return getBase()->getExprLoc();
1038 static bool classof(const Stmt *T) {
1039 return T->getStmtClass() == MSPropertySubscriptExprClass;
1043 child_range children() {
1044 return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
1047 const_child_range children() const {
1048 return const_child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
1052 /// A Microsoft C++ @c __uuidof expression, which gets
1053 /// the _GUID that corresponds to the supplied type or expression.
1055 /// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
1056 class CXXUuidofExpr : public Expr {
1057 friend class ASTStmtReader;
1060 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
1065 CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, MSGuidDecl *Guid,
1067 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
1068 Guid(Guid), Range(R) {
1069 setDependence(computeDependence(this));
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));
1078 CXXUuidofExpr(EmptyShell Empty, bool isExpr)
1079 : Expr(CXXUuidofExprClass, Empty) {
1081 Operand = (Expr*)nullptr;
1083 Operand = (TypeSourceInfo*)nullptr;
1086 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
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;
1092 /// Retrieve source information for the type operand.
1093 TypeSourceInfo *getTypeOperandSourceInfo() const {
1094 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
1095 return Operand.get<TypeSourceInfo *>();
1097 Expr *getExprOperand() const {
1098 assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)");
1099 return static_cast<Expr*>(Operand.get<Stmt *>());
1102 MSGuidDecl *getGuidDecl() const { return Guid; }
1104 SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
1105 SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
1106 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
1107 void setSourceRange(SourceRange R) { Range = R; }
1109 static bool classof(const Stmt *T) {
1110 return T->getStmtClass() == CXXUuidofExprClass;
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);
1121 const_child_range children() const {
1122 if (isTypeOperand())
1123 return const_child_range(const_child_iterator(), const_child_iterator());
1125 reinterpret_cast<Stmt **>(&const_cast<CXXUuidofExpr *>(this)->Operand);
1126 return const_child_range(begin, begin + 1);
1130 /// Represents the \c this expression in C++.
1132 /// This is a pointer to the object on which the current member function is
1133 /// executing (C++ [expr.prim]p3). Example:
1139 /// void test() { this->bar(); }
1142 class CXXThisExpr : public Expr {
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));
1151 CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
1153 SourceLocation getLocation() const { return CXXThisExprBits.Loc; }
1154 void setLocation(SourceLocation L) { CXXThisExprBits.Loc = L; }
1156 SourceLocation getBeginLoc() const { return getLocation(); }
1157 SourceLocation getEndLoc() const { return getLocation(); }
1159 bool isImplicit() const { return CXXThisExprBits.IsImplicit; }
1160 void setImplicit(bool I) { CXXThisExprBits.IsImplicit = I; }
1162 static bool classof(const Stmt *T) {
1163 return T->getStmtClass() == CXXThisExprClass;
1167 child_range children() {
1168 return child_range(child_iterator(), child_iterator());
1171 const_child_range children() const {
1172 return const_child_range(const_child_iterator(), const_child_iterator());
1176 /// A C++ throw-expression (C++ [except.throw]).
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.
1181 class CXXThrowExpr : public Expr {
1182 friend class ASTStmtReader;
1184 /// The optional expression in the throw statement.
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));
1199 CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
1201 const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
1202 Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }
1204 SourceLocation getThrowLoc() const { return CXXThrowExprBits.ThrowLoc; }
1206 /// Determines whether the variable thrown by this expression (if any!)
1207 /// is within the innermost try block.
1209 /// This information is required to determine whether the NRVO can apply to
1211 bool isThrownVariableInScope() const {
1212 return CXXThrowExprBits.IsThrownVariableInScope;
1215 SourceLocation getBeginLoc() const { return getThrowLoc(); }
1216 SourceLocation getEndLoc() const LLVM_READONLY {
1218 return getThrowLoc();
1219 return getSubExpr()->getEndLoc();
1222 static bool classof(const Stmt *T) {
1223 return T->getStmtClass() == CXXThrowExprClass;
1227 child_range children() {
1228 return child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1231 const_child_range children() const {
1232 return const_child_range(&Operand, Operand ? &Operand + 1 : &Operand);
1236 /// A default argument (C++ [dcl.fct.default]).
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.
1241 class CXXDefaultArgExpr final : public Expr {
1242 friend class ASTStmtReader;
1244 /// The parameter whose default is being used.
1247 /// The context where the default argument expression was used.
1248 DeclContext *UsedContext;
1250 CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
1251 DeclContext *UsedContext)
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));
1264 CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
1266 // \p Param is the parameter whose default argument is used by this
1268 static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
1270 DeclContext *UsedContext) {
1272 CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
1275 // Retrieve the parameter that the argument was created from.
1276 const ParmVarDecl *getParam() const { return Param; }
1277 ParmVarDecl *getParam() { return Param; }
1279 // Retrieve the actual argument to the function call.
1280 const Expr *getExpr() const { return getParam()->getDefaultArg(); }
1281 Expr *getExpr() { return getParam()->getDefaultArg(); }
1283 const DeclContext *getUsedContext() const { return UsedContext; }
1284 DeclContext *getUsedContext() { return UsedContext; }
1286 /// Retrieve the location where this default argument was actually used.
1287 SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }
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(); }
1294 SourceLocation getExprLoc() const { return getUsedLocation(); }
1296 static bool classof(const Stmt *T) {
1297 return T->getStmtClass() == CXXDefaultArgExprClass;
1301 child_range children() {
1302 return child_range(child_iterator(), child_iterator());
1305 const_child_range children() const {
1306 return const_child_range(const_child_iterator(), const_child_iterator());
1310 /// A use of a default initializer in a constructor or in aggregate
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).
1318 class CXXDefaultInitExpr : public Expr {
1319 friend class ASTReader;
1320 friend class ASTStmtReader;
1322 /// The field whose default is being used.
1325 /// The context where the default initializer expression was used.
1326 DeclContext *UsedContext;
1328 CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
1329 FieldDecl *Field, QualType Ty, DeclContext *UsedContext);
1331 CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
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);
1341 /// Get the field whose initializer will be used.
1342 FieldDecl *getField() { return Field; }
1343 const FieldDecl *getField() const { return Field; }
1345 /// Get the initialization expression that will be used.
1346 const Expr *getExpr() const {
1347 assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
1348 return Field->getInClassInitializer();
1351 assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
1352 return Field->getInClassInitializer();
1355 const DeclContext *getUsedContext() const { return UsedContext; }
1356 DeclContext *getUsedContext() { return UsedContext; }
1358 /// Retrieve the location where this default initializer expression was
1360 SourceLocation getUsedLocation() const { return getBeginLoc(); }
1362 SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; }
1363 SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; }
1365 static bool classof(const Stmt *T) {
1366 return T->getStmtClass() == CXXDefaultInitExprClass;
1370 child_range children() {
1371 return child_range(child_iterator(), child_iterator());
1374 const_child_range children() const {
1375 return const_child_range(const_child_iterator(), const_child_iterator());
1379 /// Represents a C++ temporary.
1380 class CXXTemporary {
1381 /// The destructor that needs to be called.
1382 const CXXDestructorDecl *Destructor;
1384 explicit CXXTemporary(const CXXDestructorDecl *destructor)
1385 : Destructor(destructor) {}
1388 static CXXTemporary *Create(const ASTContext &C,
1389 const CXXDestructorDecl *Destructor);
1391 const CXXDestructorDecl *getDestructor() const { return Destructor; }
1393 void setDestructor(const CXXDestructorDecl *Dtor) {
1398 /// Represents binding an expression to a temporary.
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:
1405 /// S() { } // User defined constructor makes S non-POD.
1406 /// ~S() { } // User defined destructor makes it non-trivial.
1409 /// const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
1412 class CXXBindTemporaryExpr : public Expr {
1413 CXXTemporary *Temp = nullptr;
1414 Stmt *SubExpr = nullptr;
1416 CXXBindTemporaryExpr(CXXTemporary *temp, Expr *SubExpr)
1417 : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_PRValue,
1419 Temp(temp), SubExpr(SubExpr) {
1420 setDependence(computeDependence(this));
1424 CXXBindTemporaryExpr(EmptyShell Empty)
1425 : Expr(CXXBindTemporaryExprClass, Empty) {}
1427 static CXXBindTemporaryExpr *Create(const ASTContext &C, CXXTemporary *Temp,
1430 CXXTemporary *getTemporary() { return Temp; }
1431 const CXXTemporary *getTemporary() const { return Temp; }
1432 void setTemporary(CXXTemporary *T) { Temp = T; }
1434 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
1435 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
1436 void setSubExpr(Expr *E) { SubExpr = E; }
1438 SourceLocation getBeginLoc() const LLVM_READONLY {
1439 return SubExpr->getBeginLoc();
1442 SourceLocation getEndLoc() const LLVM_READONLY {
1443 return SubExpr->getEndLoc();
1446 // Implement isa/cast/dyncast/etc.
1447 static bool classof(const Stmt *T) {
1448 return T->getStmtClass() == CXXBindTemporaryExprClass;
1452 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
1454 const_child_range children() const {
1455 return const_child_range(&SubExpr, &SubExpr + 1);
1459 /// Represents a call to a C++ constructor.
1460 class CXXConstructExpr : public Expr {
1461 friend class ASTStmtReader;
1464 enum ConstructionKind {
1472 /// A pointer to the constructor which will be ultimately called.
1473 CXXConstructorDecl *Constructor;
1475 SourceRange ParenOrBraceRange;
1477 /// The number of arguments.
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
1485 // Instead we manually stash the trailing object after the full object
1486 // containing CXXConstructExpr (that is either CXXConstructExpr or
1487 // CXXTemporaryObjectExpr).
1489 // The trailing objects are:
1491 // * An array of getNumArgs() "Stmt *" for the arguments of the
1492 // constructor call.
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();
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);
1510 /// Build an empty C++ construction expression.
1511 CXXConstructExpr(StmtClass SC, EmptyShell Empty, unsigned NumArgs);
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 *);
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);
1528 /// Create an empty C++ construction expression.
1529 static CXXConstructExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs);
1531 /// Get the constructor that this expression will (ultimately) call.
1532 CXXConstructorDecl *getConstructor() const { return Constructor; }
1534 SourceLocation getLocation() const { return CXXConstructExprBits.Loc; }
1535 void setLocation(SourceLocation Loc) { CXXConstructExprBits.Loc = Loc; }
1537 /// Whether this construction is elidable.
1538 bool isElidable() const { return CXXConstructExprBits.Elidable; }
1539 void setElidable(bool E) { CXXConstructExprBits.Elidable = E; }
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;
1546 void setHadMultipleCandidates(bool V) {
1547 CXXConstructExprBits.HadMultipleCandidates = V;
1550 /// Whether this constructor call was written as list-initialization.
1551 bool isListInitialization() const {
1552 return CXXConstructExprBits.ListInitialization;
1554 void setListInitialization(bool V) {
1555 CXXConstructExprBits.ListInitialization = V;
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;
1565 void setStdInitListInitialization(bool V) {
1566 CXXConstructExprBits.StdInitListInitialization = V;
1569 /// Whether this construction first requires
1570 /// zero-initialization before the initializer is called.
1571 bool requiresZeroInitialization() const {
1572 return CXXConstructExprBits.ZeroInitialization;
1574 void setRequiresZeroInitialization(bool ZeroInit) {
1575 CXXConstructExprBits.ZeroInitialization = ZeroInit;
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);
1583 void setConstructionKind(ConstructionKind CK) {
1584 CXXConstructExprBits.ConstructionKind = CK;
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>;
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());
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(); }
1602 Expr **getArgs() { return reinterpret_cast<Expr **>(getTrailingArgs()); }
1603 const Expr *const *getArgs() const {
1604 return reinterpret_cast<const Expr *const *>(getTrailingArgs());
1607 /// Return the number of arguments to the constructor call.
1608 unsigned getNumArgs() const { return NumArgs; }
1610 /// Return the specified argument.
1611 Expr *getArg(unsigned Arg) {
1612 assert(Arg < getNumArgs() && "Arg access out of range!");
1613 return getArgs()[Arg];
1615 const Expr *getArg(unsigned Arg) const {
1616 assert(Arg < getNumArgs() && "Arg access out of range!");
1617 return getArgs()[Arg];
1620 /// Set the specified argument.
1621 void setArg(unsigned Arg, Expr *ArgExpr) {
1622 assert(Arg < getNumArgs() && "Arg access out of range!");
1623 getArgs()[Arg] = ArgExpr;
1626 SourceLocation getBeginLoc() const LLVM_READONLY;
1627 SourceLocation getEndLoc() const LLVM_READONLY;
1628 SourceRange getParenOrBraceRange() const { return ParenOrBraceRange; }
1629 void setParenOrBraceRange(SourceRange Range) { ParenOrBraceRange = Range; }
1631 static bool classof(const Stmt *T) {
1632 return T->getStmtClass() == CXXConstructExprClass ||
1633 T->getStmtClass() == CXXTemporaryObjectExprClass;
1637 child_range children() {
1638 return child_range(getTrailingArgs(), getTrailingArgs() + getNumArgs());
1641 const_child_range children() const {
1642 auto Children = const_cast<CXXConstructExpr *>(this)->children();
1643 return const_child_range(Children.begin(), Children.end());
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.
1651 class CXXInheritedCtorInitExpr : public Expr {
1653 CXXConstructorDecl *Constructor = nullptr;
1655 /// The location of the using declaration.
1658 /// Whether this is the construction of a virtual base.
1659 unsigned ConstructsVirtualBase : 1;
1661 /// Whether the constructor is inherited from a virtual base class of the
1662 /// class that we construct.
1663 unsigned InheritedFromVirtualBase : 1;
1666 friend class ASTStmtReader;
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());
1677 setDependence(ExprDependence::None);
1680 /// Construct an empty C++ inheriting construction expression.
1681 explicit CXXInheritedCtorInitExpr(EmptyShell Empty)
1682 : Expr(CXXInheritedCtorInitExprClass, Empty),
1683 ConstructsVirtualBase(false), InheritedFromVirtualBase(false) {}
1685 /// Get the constructor that this expression will call.
1686 CXXConstructorDecl *getConstructor() const { return Constructor; }
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;
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; }
1702 SourceLocation getLocation() const LLVM_READONLY { return Loc; }
1703 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
1704 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
1706 static bool classof(const Stmt *T) {
1707 return T->getStmtClass() == CXXInheritedCtorInitExprClass;
1710 child_range children() {
1711 return child_range(child_iterator(), child_iterator());
1714 const_child_range children() const {
1715 return const_child_range(const_child_iterator(), const_child_iterator());
1719 /// Represents an explicit C++ type conversion that uses "functional"
1720 /// notation (C++ [expr.type.conv]).
1726 class CXXFunctionalCastExpr final
1727 : public ExplicitCastExpr,
1728 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
1729 FPOptionsOverride> {
1730 SourceLocation LParenLoc;
1731 SourceLocation RParenLoc;
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;
1745 explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize,
1747 : ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize,
1750 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
1755 friend class CastExpr;
1756 friend TrailingObjects;
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);
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; }
1771 /// Determine whether this expression models list-initialization.
1772 bool isListInitialization() const { return LParenLoc.isInvalid(); }
1774 SourceLocation getBeginLoc() const LLVM_READONLY;
1775 SourceLocation getEndLoc() const LLVM_READONLY;
1777 static bool classof(const Stmt *T) {
1778 return T->getStmtClass() == CXXFunctionalCastExprClass;
1782 /// Represents a C++ functional cast expression that builds a
1783 /// temporary object.
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.
1791 /// struct X { X(int, float); }
1794 /// return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
1797 class CXXTemporaryObjectExpr final : public CXXConstructExpr {
1798 friend class ASTStmtReader;
1800 // CXXTemporaryObjectExpr has some trailing objects belonging
1801 // to CXXConstructExpr. See the comment inside CXXConstructExpr
1802 // for more details.
1804 TypeSourceInfo *TSI;
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);
1813 CXXTemporaryObjectExpr(EmptyShell Empty, unsigned NumArgs);
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);
1823 static CXXTemporaryObjectExpr *CreateEmpty(const ASTContext &Ctx,
1826 TypeSourceInfo *getTypeSourceInfo() const { return TSI; }
1828 SourceLocation getBeginLoc() const LLVM_READONLY;
1829 SourceLocation getEndLoc() const LLVM_READONLY;
1831 static bool classof(const Stmt *T) {
1832 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1836 Stmt **CXXConstructExpr::getTrailingArgs() {
1837 if (auto *E = dyn_cast<CXXTemporaryObjectExpr>(this))
1838 return reinterpret_cast<Stmt **>(E + 1);
1839 assert((getStmtClass() == CXXConstructExprClass) &&
1840 "Unexpected class deriving from CXXConstructExpr!");
1841 return reinterpret_cast<Stmt **>(this + 1);
1844 /// A C++ lambda expression, which produces a function object
1845 /// (of unspecified type) that can be invoked later.
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; });
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.
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.
1865 class LambdaExpr final : public Expr,
1866 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1867 // LambdaExpr has some data stored in LambdaExprBits.
1869 /// The source range that covers the lambda introducer ([...]).
1870 SourceRange IntroducerRange;
1872 /// The source location of this lambda's capture-default ('=' or '&').
1873 SourceLocation CaptureDefaultLoc;
1875 /// The location of the closing brace ('}') that completes
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;
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);
1892 /// Construct an empty lambda expression.
1893 LambdaExpr(EmptyShell Empty, unsigned NumCaptures);
1895 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
1896 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
1898 void initBodyIfNeeded() const;
1901 friend class ASTStmtReader;
1902 friend class ASTStmtWriter;
1903 friend TrailingObjects;
1905 /// Construct a new lambda expression.
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);
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);
1918 /// Determine the default capture kind for this lambda.
1919 LambdaCaptureDefault getCaptureDefault() const {
1920 return static_cast<LambdaCaptureDefault>(LambdaExprBits.CaptureDefault);
1923 /// Retrieve the location of this lambda's capture-default, if any.
1924 SourceLocation getCaptureDefaultLoc() const { return CaptureDefaultLoc; }
1926 /// Determine whether one of this lambda's captures is an init-capture.
1927 bool isInitCapture(const LambdaCapture *Capture) const;
1929 /// An iterator that walks over the captures of the lambda,
1930 /// both implicit and explicit.
1931 using capture_iterator = const LambdaCapture *;
1933 /// An iterator over a range of lambda captures.
1934 using capture_range = llvm::iterator_range<capture_iterator>;
1936 /// Retrieve this lambda's captures.
1937 capture_range captures() const;
1939 /// Retrieve an iterator pointing to the first lambda capture.
1940 capture_iterator capture_begin() const;
1942 /// Retrieve an iterator pointing past the end of the
1943 /// sequence of lambda captures.
1944 capture_iterator capture_end() const;
1946 /// Determine the number of captures in this lambda.
1947 unsigned capture_size() const { return LambdaExprBits.NumCaptures; }
1949 /// Retrieve this lambda's explicit captures.
1950 capture_range explicit_captures() const;
1952 /// Retrieve an iterator pointing to the first explicit
1954 capture_iterator explicit_capture_begin() const;
1956 /// Retrieve an iterator pointing past the end of the sequence of
1957 /// explicit lambda captures.
1958 capture_iterator explicit_capture_end() const;
1960 /// Retrieve this lambda's implicit captures.
1961 capture_range implicit_captures() const;
1963 /// Retrieve an iterator pointing to the first implicit
1965 capture_iterator implicit_capture_begin() const;
1967 /// Retrieve an iterator pointing past the end of the sequence of
1968 /// implicit lambda captures.
1969 capture_iterator implicit_capture_end() const;
1971 /// Iterator that walks over the capture initialization
1973 using capture_init_iterator = Expr **;
1975 /// Const iterator that walks over the capture initialization
1977 /// FIXME: This interface is prone to being used incorrectly.
1978 using const_capture_init_iterator = Expr *const *;
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());
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());
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());
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());
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();
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();
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; }
2019 /// Retrieve the class that corresponds to the lambda.
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;
2026 /// Retrieve the function call operator associated with this
2027 /// lambda expression.
2028 CXXMethodDecl *getCallOperator() const;
2030 /// Retrieve the function template call operator associated with this
2031 /// lambda expression.
2032 FunctionTemplateDecl *getDependentCallOperator() const;
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;
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;
2042 /// Get the trailing requires clause, if any.
2043 Expr *getTrailingRequiresClause() const;
2045 /// Whether this is a generic lambda.
2046 bool isGenericLambda() const { return getTemplateParameterList(); }
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;
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());
2063 /// Determine whether the lambda is mutable, meaning that any
2064 /// captures values can be modified.
2065 bool isMutable() const;
2067 /// Determine whether this lambda has an explicit parameter
2068 /// list vs. an implicit (empty) parameter list.
2069 bool hasExplicitParameters() const { return LambdaExprBits.ExplicitParams; }
2071 /// Whether this lambda had its result type explicitly specified.
2072 bool hasExplicitResultType() const {
2073 return LambdaExprBits.ExplicitResultType;
2076 static bool classof(const Stmt *T) {
2077 return T->getStmtClass() == LambdaExprClass;
2080 SourceLocation getBeginLoc() const LLVM_READONLY {
2081 return IntroducerRange.getBegin();
2084 SourceLocation getEndLoc() const LLVM_READONLY { return ClosingBrace; }
2086 /// Includes the captures and the body of the lambda.
2087 child_range children();
2088 const_child_range children() const;
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]).
2093 class CXXScalarValueInitExpr : public Expr {
2094 friend class ASTStmtReader;
2096 TypeSourceInfo *TypeInfo;
2099 /// Create an explicitly-written scalar-value initialization
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));
2109 explicit CXXScalarValueInitExpr(EmptyShell Shell)
2110 : Expr(CXXScalarValueInitExprClass, Shell) {}
2112 TypeSourceInfo *getTypeSourceInfo() const {
2116 SourceLocation getRParenLoc() const {
2117 return CXXScalarValueInitExprBits.RParenLoc;
2120 SourceLocation getBeginLoc() const LLVM_READONLY;
2121 SourceLocation getEndLoc() const { return getRParenLoc(); }
2123 static bool classof(const Stmt *T) {
2124 return T->getStmtClass() == CXXScalarValueInitExprClass;
2128 child_range children() {
2129 return child_range(child_iterator(), child_iterator());
2132 const_child_range children() const {
2133 return const_child_range(const_child_iterator(), const_child_iterator());
2137 /// Represents a new-expression for memory allocation and constructor
2138 /// calls, e.g: "new CXXNewExpr(foo)".
2139 class CXXNewExpr final
2141 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2142 friend class ASTStmtReader;
2143 friend class ASTStmtWriter;
2144 friend TrailingObjects;
2146 /// Points to the allocation function used.
2147 FunctionDecl *OperatorNew;
2149 /// Points to the deallocation function used in case of error. May be null.
2150 FunctionDecl *OperatorDelete;
2152 /// The allocated type-source information, as written in the source.
2153 TypeSourceInfo *AllocatedTypeInfo;
2155 /// Range of the entire new expression.
2158 /// Source-range of a paren-delimited initializer.
2159 SourceRange DirectInitRange;
2161 // CXXNewExpr is followed by several optional trailing objects.
2162 // They are in order:
2164 // * An optional "Stmt *" for the array size expression.
2165 // Present if and ony if isArray().
2167 // * An optional "Stmt *" for the init expression.
2168 // Present if and only if hasInitializer().
2170 // * An array of getNumPlacementArgs() "Stmt *" for the placement new
2171 // arguments, if any.
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();
2182 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
2183 return isArray() + hasInitializer() + getNumPlacementArgs();
2186 unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
2187 return isParenTypeId();
2191 enum InitializationStyle {
2192 /// New-expression has no initializer as written.
2195 /// New-expression has a C++98 paren-delimited initializer.
2198 /// New-expression has a C++11 list-initializer.
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);
2212 /// Build an empty c++ new expression.
2213 CXXNewExpr(EmptyShell Empty, bool IsArray, unsigned NumPlacementArgs,
2214 bool IsParenTypeId);
2217 /// Create a c++ new expression.
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);
2227 /// Create an empty c++ new expression.
2228 static CXXNewExpr *CreateEmpty(const ASTContext &Ctx, bool IsArray,
2229 bool HasInit, unsigned NumPlacementArgs,
2230 bool IsParenTypeId);
2232 QualType getAllocatedType() const {
2233 return getType()->castAs<PointerType>()->getPointeeType();
2236 TypeSourceInfo *getAllocatedTypeSourceInfo() const {
2237 return AllocatedTypeInfo;
2240 /// True if the allocation result needs to be null-checked.
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.
2248 /// If the allocation function is a reserved placement allocation
2249 /// function that returns null, the behavior is undefined.
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;
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; }
2262 bool isArray() const { return CXXNewExprBits.IsArray; }
2264 Optional<Expr *> getArraySize() {
2267 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2269 Optional<const Expr *> getArraySize() const {
2272 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2275 unsigned getNumPlacementArgs() const {
2276 return CXXNewExprBits.NumPlacementArgs;
2279 Expr **getPlacementArgs() {
2280 return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() +
2281 placementNewArgsOffset());
2284 Expr *getPlacementArg(unsigned I) {
2285 assert((I < getNumPlacementArgs()) && "Index out of range!");
2286 return getPlacementArgs()[I];
2288 const Expr *getPlacementArg(unsigned I) const {
2289 return const_cast<CXXNewExpr *>(this)->getPlacementArg(I);
2292 bool isParenTypeId() const { return CXXNewExprBits.IsParenTypeId; }
2293 SourceRange getTypeIdParens() const {
2294 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
2298 bool isGlobalNew() const { return CXXNewExprBits.IsGlobalNew; }
2300 /// Whether this new-expression has any initializer at all.
2301 bool hasInitializer() const {
2302 return CXXNewExprBits.StoredInitializationStyle > 0;
2305 /// The kind of initializer this new-expression has.
2306 InitializationStyle getInitializationStyle() const {
2307 if (CXXNewExprBits.StoredInitializationStyle == 0)
2309 return static_cast<InitializationStyle>(
2310 CXXNewExprBits.StoredInitializationStyle - 1);
2313 /// The initializer of this new-expression.
2314 Expr *getInitializer() {
2315 return hasInitializer()
2316 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2319 const Expr *getInitializer() const {
2320 return hasInitializer()
2321 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2325 /// Returns the CXXConstructExpr from this new-expression, or null.
2326 const CXXConstructExpr *getConstructExpr() const {
2327 return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
2330 /// Indicates whether the required alignment should be implicitly passed to
2331 /// the allocation function.
2332 bool passAlignment() const { return CXXNewExprBits.ShouldPassAlignment; }
2334 /// Answers whether the usual array deallocation function for the
2335 /// allocated type expects the size of the allocation as a
2337 bool doesUsualArrayDeleteWantSize() const {
2338 return CXXNewExprBits.UsualArrayDeleteWantsSize;
2341 using arg_iterator = ExprIterator;
2342 using const_arg_iterator = ConstExprIterator;
2344 llvm::iterator_range<arg_iterator> placement_arguments() {
2345 return llvm::make_range(placement_arg_begin(), placement_arg_end());
2348 llvm::iterator_range<const_arg_iterator> placement_arguments() const {
2349 return llvm::make_range(placement_arg_begin(), placement_arg_end());
2352 arg_iterator placement_arg_begin() {
2353 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2355 arg_iterator placement_arg_end() {
2356 return placement_arg_begin() + getNumPlacementArgs();
2358 const_arg_iterator placement_arg_begin() const {
2359 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2361 const_arg_iterator placement_arg_end() const {
2362 return placement_arg_begin() + getNumPlacementArgs();
2365 using raw_arg_iterator = Stmt **;
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 *>());
2371 const_arg_iterator raw_arg_begin() const {
2372 return getTrailingObjects<Stmt *>();
2374 const_arg_iterator raw_arg_end() const {
2375 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
2378 SourceLocation getBeginLoc() const { return Range.getBegin(); }
2379 SourceLocation getEndLoc() const { return Range.getEnd(); }
2381 SourceRange getDirectInitRange() const { return DirectInitRange; }
2382 SourceRange getSourceRange() const { return Range; }
2384 static bool classof(const Stmt *T) {
2385 return T->getStmtClass() == CXXNewExprClass;
2389 child_range children() { return child_range(raw_arg_begin(), raw_arg_end()); }
2391 const_child_range children() const {
2392 return const_child_range(const_cast<CXXNewExpr *>(this)->children());
2396 /// Represents a \c delete expression for memory deallocation and
2397 /// destructor calls, e.g. "delete[] pArray".
2398 class CXXDeleteExpr : public Expr {
2399 friend class ASTStmtReader;
2401 /// Points to the operator delete overload that is used. Could be a member.
2402 FunctionDecl *OperatorDelete = nullptr;
2404 /// The pointer expression to be deleted.
2405 Stmt *Argument = nullptr;
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));
2421 explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {}
2423 bool isGlobalDelete() const { return CXXDeleteExprBits.GlobalDelete; }
2424 bool isArrayForm() const { return CXXDeleteExprBits.ArrayForm; }
2425 bool isArrayFormAsWritten() const {
2426 return CXXDeleteExprBits.ArrayFormAsWritten;
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;
2437 FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
2439 Expr *getArgument() { return cast<Expr>(Argument); }
2440 const Expr *getArgument() const { return cast<Expr>(Argument); }
2442 /// Retrieve the type being destroyed.
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;
2448 SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; }
2449 SourceLocation getEndLoc() const LLVM_READONLY {
2450 return Argument->getEndLoc();
2453 static bool classof(const Stmt *T) {
2454 return T->getStmtClass() == CXXDeleteExprClass;
2458 child_range children() { return child_range(&Argument, &Argument + 1); }
2460 const_child_range children() const {
2461 return const_child_range(&Argument, &Argument + 1);
2465 /// Stores the type being destroyed by a pseudo-destructor expression.
2466 class 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;
2471 /// The starting source location of the pseudo-destructor type.
2472 SourceLocation Location;
2475 PseudoDestructorTypeStorage() = default;
2477 PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
2478 : Type(II), Location(Loc) {}
2480 PseudoDestructorTypeStorage(TypeSourceInfo *Info);
2482 TypeSourceInfo *getTypeSourceInfo() const {
2483 return Type.dyn_cast<TypeSourceInfo *>();
2486 IdentifierInfo *getIdentifier() const {
2487 return Type.dyn_cast<IdentifierInfo *>();
2490 SourceLocation getLocation() const { return Location; }
2493 /// Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
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:
2501 /// void f(int *p) {
2506 /// Pseudo-destructors typically occur when instantiating templates such as:
2509 /// template<typename T>
2510 /// void destroy(T* ptr) {
2515 /// for scalar types. A pseudo-destructor expression has no run-time semantics
2516 /// beyond evaluating the base expression.
2517 class CXXPseudoDestructorExpr : public Expr {
2518 friend class ASTStmtReader;
2520 /// The base expression (that is being destroyed).
2521 Stmt *Base = nullptr;
2523 /// Whether the operator was an arrow ('->'); otherwise, it was a
2527 /// The location of the '.' or '->' operator.
2528 SourceLocation OperatorLoc;
2530 /// The nested-name-specifier that follows the operator, if present.
2531 NestedNameSpecifierLoc QualifierLoc;
2533 /// The type that precedes the '::' in a qualified pseudo-destructor
2535 TypeSourceInfo *ScopeType = nullptr;
2537 /// The location of the '::' in a qualified pseudo-destructor
2539 SourceLocation ColonColonLoc;
2541 /// The location of the '~'.
2542 SourceLocation TildeLoc;
2544 /// The type being destroyed, or its name if we were unable to
2545 /// resolve the name.
2546 PseudoDestructorTypeStorage DestroyedType;
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);
2557 explicit CXXPseudoDestructorExpr(EmptyShell Shell)
2558 : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {}
2560 Expr *getBase() const { return cast<Expr>(Base); }
2562 /// Determines whether this member expression actually had
2563 /// a C++ nested-name-specifier prior to the name of the member, e.g.,
2565 bool hasQualifier() const { return QualifierLoc.hasQualifier(); }
2567 /// Retrieves the nested-name-specifier that qualifies the type name,
2568 /// with source-location information.
2569 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2571 /// If the member name was qualified, retrieves the
2572 /// nested-name-specifier that precedes the member name. Otherwise, returns
2574 NestedNameSpecifier *getQualifier() const {
2575 return QualifierLoc.getNestedNameSpecifier();
2578 /// Determine whether this pseudo-destructor expression was written
2579 /// using an '->' (otherwise, it used a '.').
2580 bool isArrow() const { return IsArrow; }
2582 /// Retrieve the location of the '.' or '->' operator.
2583 SourceLocation getOperatorLoc() const { return OperatorLoc; }
2585 /// Retrieve the scope type in a qualified pseudo-destructor
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; }
2596 /// Retrieve the location of the '::' in a qualified pseudo-destructor
2598 SourceLocation getColonColonLoc() const { return ColonColonLoc; }
2600 /// Retrieve the location of the '~'.
2601 SourceLocation getTildeLoc() const { return TildeLoc; }
2603 /// Retrieve the source location information for the type
2604 /// being destroyed.
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();
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();
2621 /// Retrieve the type being destroyed.
2622 QualType getDestroyedType() const;
2624 /// Retrieve the starting location of the type being destroyed.
2625 SourceLocation getDestroyedTypeLoc() const {
2626 return DestroyedType.getLocation();
2629 /// Set the name of destroyed type for a dependent pseudo-destructor
2631 void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
2632 DestroyedType = PseudoDestructorTypeStorage(II, Loc);
2635 /// Set the destroyed type.
2636 void setDestroyedType(TypeSourceInfo *Info) {
2637 DestroyedType = PseudoDestructorTypeStorage(Info);
2640 SourceLocation getBeginLoc() const LLVM_READONLY {
2641 return Base->getBeginLoc();
2643 SourceLocation getEndLoc() const LLVM_READONLY;
2645 static bool classof(const Stmt *T) {
2646 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2650 child_range children() { return child_range(&Base, &Base + 1); }
2652 const_child_range children() const {
2653 return const_child_range(&Base, &Base + 1);
2657 /// A type trait used in the implementation of various C++11 and
2658 /// Library TR1 trait templates.
2661 /// __is_pod(int) == true
2662 /// __is_enum(std::string) == false
2663 /// __is_trivially_constructible(vector<int>, int*, int*)
2665 class TypeTraitExpr final
2667 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
2668 /// The location of the type trait keyword.
2671 /// The location of the closing parenthesis.
2672 SourceLocation RParenLoc;
2674 // Note: The TypeSourceInfos for the arguments are allocated after the
2677 TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
2678 ArrayRef<TypeSourceInfo *> Args,
2679 SourceLocation RParenLoc,
2682 TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) {}
2684 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
2685 return getNumArgs();
2689 friend class ASTStmtReader;
2690 friend class ASTStmtWriter;
2691 friend TrailingObjects;
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,
2700 static TypeTraitExpr *CreateDeserialized(const ASTContext &C,
2703 /// Determine which type trait this expression uses.
2704 TypeTrait getTrait() const {
2705 return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
2708 bool getValue() const {
2709 assert(!isValueDependent());
2710 return TypeTraitExprBits.Value;
2713 /// Determine the number of arguments to this type trait.
2714 unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }
2716 /// Retrieve the Ith argument.
2717 TypeSourceInfo *getArg(unsigned I) const {
2718 assert(I < getNumArgs() && "Argument out-of-range");
2719 return getArgs()[I];
2722 /// Retrieve the argument types.
2723 ArrayRef<TypeSourceInfo *> getArgs() const {
2724 return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(),
2728 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
2729 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
2731 static bool classof(const Stmt *T) {
2732 return T->getStmtClass() == TypeTraitExprClass;
2736 child_range children() {
2737 return child_range(child_iterator(), child_iterator());
2740 const_child_range children() const {
2741 return const_child_range(const_child_iterator(), const_child_iterator());
2745 /// An Embarcadero array type trait, as used in the implementation of
2746 /// __array_rank and __array_extent.
2750 /// __array_rank(int[10][20]) == 2
2751 /// __array_extent(int, 1) == 20
2753 class ArrayTypeTraitExpr : public Expr {
2754 /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
2757 /// The value of the type trait. Unspecified if dependent.
2760 /// The array dimension being queried, or -1 if not used.
2763 /// The location of the type trait keyword.
2766 /// The location of the closing paren.
2767 SourceLocation RParen;
2769 /// The type being queried.
2770 TypeSourceInfo *QueriedType = nullptr;
2773 friend class ASTStmtReader;
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!");
2782 assert(static_cast<unsigned>(att) == ATT && "ATT overflow!");
2783 setDependence(computeDependence(this));
2786 explicit ArrayTypeTraitExpr(EmptyShell Empty)
2787 : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
2789 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
2790 SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
2792 ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
2794 QualType getQueriedType() const { return QueriedType->getType(); }
2796 TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
2798 uint64_t getValue() const { assert(!isTypeDependent()); return Value; }
2800 Expr *getDimensionExpression() const { return Dimension; }
2802 static bool classof(const Stmt *T) {
2803 return T->getStmtClass() == ArrayTypeTraitExprClass;
2807 child_range children() {
2808 return child_range(child_iterator(), child_iterator());
2811 const_child_range children() const {
2812 return const_child_range(const_child_iterator(), const_child_iterator());
2816 /// An expression trait intrinsic.
2820 /// __is_lvalue_expr(std::cout) == true
2821 /// __is_lvalue_expr(1) == false
2823 class ExpressionTraitExpr : public Expr {
2824 /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
2827 /// The value of the type trait. Unspecified if dependent.
2830 /// The location of the type trait keyword.
2833 /// The location of the closing paren.
2834 SourceLocation RParen;
2836 /// The expression being queried.
2837 Expr* QueriedExpression = nullptr;
2840 friend class ASTStmtReader;
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!");
2848 assert(static_cast<unsigned>(et) == ET && "ET overflow!");
2849 setDependence(computeDependence(this));
2852 explicit ExpressionTraitExpr(EmptyShell Empty)
2853 : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}
2855 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
2856 SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
2858 ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
2860 Expr *getQueriedExpression() const { return QueriedExpression; }
2862 bool getValue() const { return Value; }
2864 static bool classof(const Stmt *T) {
2865 return T->getStmtClass() == ExpressionTraitExprClass;
2869 child_range children() {
2870 return child_range(child_iterator(), child_iterator());
2873 const_child_range children() const {
2874 return const_child_range(const_child_iterator(), const_child_iterator());
2878 /// A reference to an overloaded function set, either an
2879 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
2880 class OverloadExpr : public Expr {
2881 friend class ASTStmtReader;
2882 friend class ASTStmtWriter;
2884 /// The common name of these declarations.
2885 DeclarationNameInfo NameInfo;
2887 /// The nested-name-specifier that qualifies the name, if any.
2888 NestedNameSpecifierLoc QualifierLoc;
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);
2900 OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults,
2901 bool HasTemplateKWAndArgsInfo);
2903 /// Return the results. Defined after UnresolvedMemberExpr.
2904 inline DeclAccessPair *getTrailingResults();
2905 const DeclAccessPair *getTrailingResults() const {
2906 return const_cast<OverloadExpr *>(this)->getTrailingResults();
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();
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();
2924 bool hasTemplateKWAndArgsInfo() const {
2925 return OverloadExprBits.HasTemplateKWAndArgsInfo;
2930 OverloadExpr *Expression;
2931 bool IsAddressOfOperand;
2932 bool HasFormOfMemberPointer;
2935 /// Finds the overloaded expression in the given expression \p E of
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));
2945 E = E->IgnoreParens();
2946 if (isa<UnaryOperator>(E)) {
2947 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
2948 E = cast<UnaryOperator>(E)->getSubExpr();
2949 auto *Ovl = cast<OverloadExpr>(E->IgnoreParens());
2951 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
2952 Result.IsAddressOfOperand = true;
2953 Result.Expression = Ovl;
2955 Result.HasFormOfMemberPointer = false;
2956 Result.IsAddressOfOperand = false;
2957 Result.Expression = cast<OverloadExpr>(E);
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();
2970 using decls_iterator = UnresolvedSetImpl::iterator;
2972 decls_iterator decls_begin() const {
2973 return UnresolvedSetIterator(getTrailingResults());
2975 decls_iterator decls_end() const {
2976 return UnresolvedSetIterator(getTrailingResults() + getNumDecls());
2978 llvm::iterator_range<decls_iterator> decls() const {
2979 return llvm::make_range(decls_begin(), decls_end());
2982 /// Gets the number of declarations in the unresolved set.
2983 unsigned getNumDecls() const { return OverloadExprBits.NumResults; }
2985 /// Gets the full name info.
2986 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2988 /// Gets the name looked up.
2989 DeclarationName getName() const { return NameInfo.getName(); }
2991 /// Gets the location of the name.
2992 SourceLocation getNameLoc() const { return NameInfo.getLoc(); }
2994 /// Fetches the nested-name qualifier, if one was given.
2995 NestedNameSpecifier *getQualifier() const {
2996 return QualifierLoc.getNestedNameSpecifier();
2999 /// Fetches the nested-name qualifier with source-location
3000 /// information, if one was given.
3001 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
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;
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;
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;
3027 /// Determines whether the name was preceded by the template keyword.
3028 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3030 /// Determines whether this expression had explicit template arguments.
3031 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3033 TemplateArgumentLoc const *getTemplateArgs() const {
3034 if (!hasExplicitTemplateArgs())
3036 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
3039 unsigned getNumTemplateArgs() const {
3040 if (!hasExplicitTemplateArgs())
3043 return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs;
3046 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3047 return {getTemplateArgs(), getNumTemplateArgs()};
3050 /// Copies the template arguments into the given structure.
3051 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3052 if (hasExplicitTemplateArgs())
3053 getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List);
3056 static bool classof(const Stmt *T) {
3057 return T->getStmtClass() == UnresolvedLookupExprClass ||
3058 T->getStmtClass() == UnresolvedMemberExprClass;
3062 /// A reference to a name which we were able to look up during
3063 /// parsing but could not resolve to a specific declaration.
3065 /// This arises in several ways:
3066 /// * we might be waiting for argument-dependent lookup;
3067 /// * the name might resolve to an overloaded function;
3069 /// * the lookup might have included a function template.
3071 /// These never include UnresolvedUsingValueDecls, which are always class
3072 /// members and therefore appear only in UnresolvedMemberLookupExprs.
3073 class 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;
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;
3087 // UnresolvedLookupExpr is followed by several trailing objects.
3088 // They are in order:
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.
3094 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3095 // template keyword and arguments. Present if and only if
3096 // hasTemplateKWAndArgsInfo().
3098 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing
3099 // location information for the explicitly specified template arguments.
3101 UnresolvedLookupExpr(const ASTContext &Context, CXXRecordDecl *NamingClass,
3102 NestedNameSpecifierLoc QualifierLoc,
3103 SourceLocation TemplateKWLoc,
3104 const DeclarationNameInfo &NameInfo, bool RequiresADL,
3106 const TemplateArgumentListInfo *TemplateArgs,
3107 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3109 UnresolvedLookupExpr(EmptyShell Empty, unsigned NumResults,
3110 bool HasTemplateKWAndArgsInfo);
3112 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const {
3113 return getNumDecls();
3116 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3117 return hasTemplateKWAndArgsInfo();
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);
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);
3134 static UnresolvedLookupExpr *CreateEmpty(const ASTContext &Context,
3135 unsigned NumResults,
3136 bool HasTemplateKWAndArgsInfo,
3137 unsigned NumTemplateArgs);
3139 /// True if this declaration should be extended by
3140 /// argument-dependent lookup.
3141 bool requiresADL() const { return UnresolvedLookupExprBits.RequiresADL; }
3143 /// True if this lookup is overloaded.
3144 bool isOverloaded() const { return UnresolvedLookupExprBits.Overloaded; }
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; }
3152 SourceLocation getBeginLoc() const LLVM_READONLY {
3153 if (NestedNameSpecifierLoc l = getQualifierLoc())
3154 return l.getBeginLoc();
3155 return getNameInfo().getBeginLoc();
3158 SourceLocation getEndLoc() const LLVM_READONLY {
3159 if (hasExplicitTemplateArgs())
3160 return getRAngleLoc();
3161 return getNameInfo().getEndLoc();
3164 child_range children() {
3165 return child_range(child_iterator(), child_iterator());
3168 const_child_range children() const {
3169 return const_child_range(const_child_iterator(), const_child_iterator());
3172 static bool classof(const Stmt *T) {
3173 return T->getStmtClass() == UnresolvedLookupExprClass;
3177 /// A qualified reference to a name whose declaration cannot
3178 /// yet be resolved.
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.
3191 class DependentScopeDeclRefExpr final
3193 private llvm::TrailingObjects<DependentScopeDeclRefExpr,
3194 ASTTemplateKWAndArgsInfo,
3195 TemplateArgumentLoc> {
3196 friend class ASTStmtReader;
3197 friend class ASTStmtWriter;
3198 friend TrailingObjects;
3200 /// The nested-name-specifier that qualifies this unresolved
3201 /// declaration name.
3202 NestedNameSpecifierLoc QualifierLoc;
3204 /// The name of the entity we will be referencing.
3205 DeclarationNameInfo NameInfo;
3207 DependentScopeDeclRefExpr(QualType Ty, NestedNameSpecifierLoc QualifierLoc,
3208 SourceLocation TemplateKWLoc,
3209 const DeclarationNameInfo &NameInfo,
3210 const TemplateArgumentListInfo *Args);
3212 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3213 return hasTemplateKWAndArgsInfo();
3216 bool hasTemplateKWAndArgsInfo() const {
3217 return DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo;
3221 static DependentScopeDeclRefExpr *
3222 Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
3223 SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
3224 const TemplateArgumentListInfo *TemplateArgs);
3226 static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &Context,
3227 bool HasTemplateKWAndArgsInfo,
3228 unsigned NumTemplateArgs);
3230 /// Retrieve the name that this expression refers to.
3231 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3233 /// Retrieve the name that this expression refers to.
3234 DeclarationName getDeclName() const { return NameInfo.getName(); }
3236 /// Retrieve the location of the name within the expression.
3238 /// For example, in "X<T>::value" this is the location of "value".
3239 SourceLocation getLocation() const { return NameInfo.getLoc(); }
3241 /// Retrieve the nested-name-specifier that qualifies the
3242 /// name, with source location information.
3243 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3245 /// Retrieve the nested-name-specifier that qualifies this
3247 NestedNameSpecifier *getQualifier() const {
3248 return QualifierLoc.getNestedNameSpecifier();
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;
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;
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;
3275 /// Determines whether the name was preceded by the template keyword.
3276 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3278 /// Determines whether this lookup had explicit template arguments.
3279 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3281 /// Copies the template arguments (if present) into the given
3283 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3284 if (hasExplicitTemplateArgs())
3285 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3286 getTrailingObjects<TemplateArgumentLoc>(), List);
3289 TemplateArgumentLoc const *getTemplateArgs() const {
3290 if (!hasExplicitTemplateArgs())
3293 return getTrailingObjects<TemplateArgumentLoc>();
3296 unsigned getNumTemplateArgs() const {
3297 if (!hasExplicitTemplateArgs())
3300 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3303 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3304 return {getTemplateArgs(), getNumTemplateArgs()};
3307 /// Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr,
3308 /// and differs from getLocation().getStart().
3309 SourceLocation getBeginLoc() const LLVM_READONLY {
3310 return QualifierLoc.getBeginLoc();
3313 SourceLocation getEndLoc() const LLVM_READONLY {
3314 if (hasExplicitTemplateArgs())
3315 return getRAngleLoc();
3316 return getLocation();
3319 static bool classof(const Stmt *T) {
3320 return T->getStmtClass() == DependentScopeDeclRefExprClass;
3323 child_range children() {
3324 return child_range(child_iterator(), child_iterator());
3327 const_child_range children() const {
3328 return const_child_range(const_child_iterator(), const_child_iterator());
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.
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.
3342 class ExprWithCleanups final
3344 private llvm::TrailingObjects<
3346 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
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 *>;
3355 friend class ASTStmtReader;
3356 friend TrailingObjects;
3358 ExprWithCleanups(EmptyShell, unsigned NumObjects);
3359 ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
3360 ArrayRef<CleanupObject> Objects);
3363 static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty,
3364 unsigned numObjects);
3366 static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
3367 bool CleanupsHaveSideEffects,
3368 ArrayRef<CleanupObject> objects);
3370 ArrayRef<CleanupObject> getObjects() const {
3371 return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(),
3375 unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
3377 CleanupObject getObject(unsigned i) const {
3378 assert(i < getNumObjects() && "Index out of range");
3379 return getObjects()[i];
3382 bool cleanupsHaveSideEffects() const {
3383 return ExprWithCleanupsBits.CleanupsHaveSideEffects;
3386 SourceLocation getBeginLoc() const LLVM_READONLY {
3387 return SubExpr->getBeginLoc();
3390 SourceLocation getEndLoc() const LLVM_READONLY {
3391 return SubExpr->getEndLoc();
3394 // Implement isa/cast/dyncast/etc.
3395 static bool classof(const Stmt *T) {
3396 return T->getStmtClass() == ExprWithCleanupsClass;
3400 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
3402 const_child_range children() const {
3403 return const_child_range(&SubExpr, &SubExpr + 1);
3407 /// Describes an explicit type conversion that uses functional
3408 /// notion but could not be resolved because one or more arguments are
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
3419 /// template<typename T, typename A1>
3420 /// inline T make_a(const A1& a1) {
3425 /// When the returned expression is instantiated, it may resolve to a
3426 /// constructor call, conversion function call, or some kind of type
3428 class CXXUnresolvedConstructExpr final
3430 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
3431 friend class ASTStmtReader;
3432 friend TrailingObjects;
3434 /// The type being constructed.
3435 TypeSourceInfo *TSI;
3437 /// The location of the left parentheses ('(').
3438 SourceLocation LParenLoc;
3440 /// The location of the right parentheses (')').
3441 SourceLocation RParenLoc;
3443 CXXUnresolvedConstructExpr(QualType T, TypeSourceInfo *TSI,
3444 SourceLocation LParenLoc, ArrayRef<Expr *> Args,
3445 SourceLocation RParenLoc);
3447 CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
3448 : Expr(CXXUnresolvedConstructExprClass, Empty), TSI(nullptr) {
3449 CXXUnresolvedConstructExprBits.NumArgs = NumArgs;
3453 static CXXUnresolvedConstructExpr *Create(const ASTContext &Context,
3454 QualType T, TypeSourceInfo *TSI,
3455 SourceLocation LParenLoc,
3456 ArrayRef<Expr *> Args,
3457 SourceLocation RParenLoc);
3459 static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &Context,
3462 /// Retrieve the type that is being constructed, as specified
3463 /// in the source code.
3464 QualType getTypeAsWritten() const { return TSI->getType(); }
3466 /// Retrieve the type source information for the type being
3468 TypeSourceInfo *getTypeSourceInfo() const { return TSI; }
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; }
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; }
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(); }
3485 /// Retrieve the number of arguments.
3486 unsigned getNumArgs() const { return CXXUnresolvedConstructExprBits.NumArgs; }
3488 using arg_iterator = Expr **;
3489 using arg_range = llvm::iterator_range<arg_iterator>;
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()); }
3495 using const_arg_iterator = const Expr* const *;
3496 using const_arg_range = llvm::iterator_range<const_arg_iterator>;
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());
3504 Expr *getArg(unsigned I) {
3505 assert(I < getNumArgs() && "Argument index out-of-range");
3506 return arg_begin()[I];
3509 const Expr *getArg(unsigned I) const {
3510 assert(I < getNumArgs() && "Argument index out-of-range");
3511 return arg_begin()[I];
3514 void setArg(unsigned I, Expr *E) {
3515 assert(I < getNumArgs() && "Argument index out-of-range");
3519 SourceLocation getBeginLoc() const LLVM_READONLY;
3520 SourceLocation getEndLoc() const LLVM_READONLY {
3521 if (!RParenLoc.isValid() && getNumArgs() > 0)
3522 return getArg(getNumArgs() - 1)->getEndLoc();
3526 static bool classof(const Stmt *T) {
3527 return T->getStmtClass() == CXXUnresolvedConstructExprClass;
3531 child_range children() {
3532 auto **begin = reinterpret_cast<Stmt **>(arg_begin());
3533 return child_range(begin, begin + getNumArgs());
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());
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.
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.
3550 class CXXDependentScopeMemberExpr final
3552 private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
3553 ASTTemplateKWAndArgsInfo,
3554 TemplateArgumentLoc, NamedDecl *> {
3555 friend class ASTStmtReader;
3556 friend class ASTStmtWriter;
3557 friend TrailingObjects;
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.
3563 /// The type of the base expression. Never null, even for
3564 /// implicit accesses.
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;
3572 /// The member to which this member expression refers, which
3573 /// can be name, overloaded operator, or destructor.
3575 /// FIXME: could also be a template-id
3576 DeclarationNameInfo MemberNameInfo;
3578 // CXXDependentScopeMemberExpr is followed by several trailing objects,
3579 // some of which optional. They are in order:
3581 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3582 // template keyword and arguments. Present if and only if
3583 // hasTemplateKWAndArgsInfo().
3585 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing location
3586 // information for the explicitly specified template arguments.
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().
3593 bool hasTemplateKWAndArgsInfo() const {
3594 return CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo;
3597 bool hasFirstQualifierFoundInScope() const {
3598 return CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope;
3601 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3602 return hasTemplateKWAndArgsInfo();
3605 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
3606 return getNumTemplateArgs();
3609 unsigned numTrailingObjects(OverloadToken<NamedDecl *>) const {
3610 return hasFirstQualifierFoundInScope();
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);
3622 CXXDependentScopeMemberExpr(EmptyShell Empty, bool HasTemplateKWAndArgsInfo,
3623 bool HasFirstQualifierFoundInScope);
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);
3633 static CXXDependentScopeMemberExpr *
3634 CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo,
3635 unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope);
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 {
3643 return cast<Expr>(Base)->isImplicitCXXThis();
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());
3650 return cast<Expr>(Base);
3653 QualType getBaseType() const { return BaseType; }
3655 /// Determine whether this member expression used the '->'
3656 /// operator; otherwise, it used the '.' operator.
3657 bool isArrow() const { return CXXDependentScopeMemberExprBits.IsArrow; }
3659 /// Retrieve the location of the '->' or '.' operator.
3660 SourceLocation getOperatorLoc() const {
3661 return CXXDependentScopeMemberExprBits.OperatorLoc;
3664 /// Retrieve the nested-name-specifier that qualifies the member name.
3665 NestedNameSpecifier *getQualifier() const {
3666 return QualifierLoc.getNestedNameSpecifier();
3669 /// Retrieve the nested-name-specifier that qualifies the member
3670 /// name, with source location information.
3671 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
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.
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())
3687 return *getTrailingObjects<NamedDecl *>();
3690 /// Retrieve the name of the member that this expression refers to.
3691 const DeclarationNameInfo &getMemberNameInfo() const {
3692 return MemberNameInfo;
3695 /// Retrieve the name of the member that this expression refers to.
3696 DeclarationName getMember() const { return MemberNameInfo.getName(); }
3698 // Retrieve the location of the name of the member that this
3699 // expression refers to.
3700 SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); }
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;
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;
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;
3726 /// Determines whether the member name was preceded by the template keyword.
3727 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
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(); }
3733 /// Copies the template arguments (if present) into the given
3735 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3736 if (hasExplicitTemplateArgs())
3737 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3738 getTrailingObjects<TemplateArgumentLoc>(), List);
3741 /// Retrieve the template arguments provided as part of this
3743 const TemplateArgumentLoc *getTemplateArgs() const {
3744 if (!hasExplicitTemplateArgs())
3747 return getTrailingObjects<TemplateArgumentLoc>();
3750 /// Retrieve the number of template arguments provided as part of this
3752 unsigned getNumTemplateArgs() const {
3753 if (!hasExplicitTemplateArgs())
3756 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3759 ArrayRef<TemplateArgumentLoc> template_arguments() const {
3760 return {getTemplateArgs(), getNumTemplateArgs()};
3763 SourceLocation getBeginLoc() const LLVM_READONLY {
3764 if (!isImplicitAccess())
3765 return Base->getBeginLoc();
3767 return getQualifierLoc().getBeginLoc();
3768 return MemberNameInfo.getBeginLoc();
3771 SourceLocation getEndLoc() const LLVM_READONLY {
3772 if (hasExplicitTemplateArgs())
3773 return getRAngleLoc();
3774 return MemberNameInfo.getEndLoc();
3777 static bool classof(const Stmt *T) {
3778 return T->getStmtClass() == CXXDependentScopeMemberExprClass;
3782 child_range children() {
3783 if (isImplicitAccess())
3784 return child_range(child_iterator(), child_iterator());
3785 return child_range(&Base, &Base + 1);
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);
3795 /// Represents a C++ member access expression for which lookup
3796 /// produced a set of overloaded functions.
3798 /// The member access may be explicit or implicit:
3802 /// int explicitAccess() { return this->a + this->A::b; }
3803 /// int implicitAccess() { return a + A::b; }
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.
3810 class 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;
3819 /// The expression for the base pointer or class reference,
3820 /// e.g., the \c x in x.f.
3822 /// This can be null if this is an 'unbased' member expression.
3825 /// The type of the base expression; never null.
3828 /// The location of the '->' or '.' operator.
3829 SourceLocation OperatorLoc;
3831 // UnresolvedMemberExpr is followed by several trailing objects.
3832 // They are in order:
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.
3838 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
3839 // template keyword and arguments. Present if and only if
3840 // hasTemplateKWAndArgsInfo().
3842 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing
3843 // location information for the explicitly specified template arguments.
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);
3854 UnresolvedMemberExpr(EmptyShell Empty, unsigned NumResults,
3855 bool HasTemplateKWAndArgsInfo);
3857 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const {
3858 return getNumDecls();
3861 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3862 return hasTemplateKWAndArgsInfo();
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);
3874 static UnresolvedMemberExpr *CreateEmpty(const ASTContext &Context,
3875 unsigned NumResults,
3876 bool HasTemplateKWAndArgsInfo,
3877 unsigned NumTemplateArgs);
3879 /// True if this is an implicit access, i.e., one in which the
3880 /// member being accessed was not written in the source.
3882 /// The source location of the operator is invalid in this case.
3883 bool isImplicitAccess() const;
3885 /// Retrieve the base object of this member expressions,
3886 /// e.g., the \c x in \c x.m.
3888 assert(!isImplicitAccess());
3889 return cast<Expr>(Base);
3891 const Expr *getBase() const {
3892 assert(!isImplicitAccess());
3893 return cast<Expr>(Base);
3896 QualType getBaseType() const { return BaseType; }
3898 /// Determine whether the lookup results contain an unresolved using
3900 bool hasUnresolvedUsing() const {
3901 return UnresolvedMemberExprBits.HasUnresolvedUsing;
3904 /// Determine whether this member expression used the '->'
3905 /// operator; otherwise, it used the '.' operator.
3906 bool isArrow() const { return UnresolvedMemberExprBits.IsArrow; }
3908 /// Retrieve the location of the '->' or '.' operator.
3909 SourceLocation getOperatorLoc() const { return OperatorLoc; }
3911 /// Retrieve the naming class of this lookup.
3912 CXXRecordDecl *getNamingClass();
3913 const CXXRecordDecl *getNamingClass() const {
3914 return const_cast<UnresolvedMemberExpr *>(this)->getNamingClass();
3917 /// Retrieve the full name info for the member that this expression
3919 const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); }
3921 /// Retrieve the name of the member that this expression refers to.
3922 DeclarationName getMemberName() const { return getName(); }
3924 /// Retrieve the location of the name of the member that this
3925 /// expression refers to.
3926 SourceLocation getMemberLoc() const { return getNameLoc(); }
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 { return getMemberLoc(); }
3932 SourceLocation getBeginLoc() const LLVM_READONLY {
3933 if (!isImplicitAccess())
3934 return Base->getBeginLoc();
3935 if (NestedNameSpecifierLoc l = getQualifierLoc())
3936 return l.getBeginLoc();
3937 return getMemberNameInfo().getBeginLoc();
3940 SourceLocation getEndLoc() const LLVM_READONLY {
3941 if (hasExplicitTemplateArgs())
3942 return getRAngleLoc();
3943 return getMemberNameInfo().getEndLoc();
3946 static bool classof(const Stmt *T) {
3947 return T->getStmtClass() == UnresolvedMemberExprClass;
3951 child_range children() {
3952 if (isImplicitAccess())
3953 return child_range(child_iterator(), child_iterator());
3954 return child_range(&Base, &Base + 1);
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);
3964 DeclAccessPair *OverloadExpr::getTrailingResults() {
3965 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3966 return ULE->getTrailingObjects<DeclAccessPair>();
3967 return cast<UnresolvedMemberExpr>(this)->getTrailingObjects<DeclAccessPair>();
3970 ASTTemplateKWAndArgsInfo *OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() {
3971 if (!hasTemplateKWAndArgsInfo())
3974 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3975 return ULE->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
3976 return cast<UnresolvedMemberExpr>(this)
3977 ->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
3980 TemplateArgumentLoc *OverloadExpr::getTrailingTemplateArgumentLoc() {
3981 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3982 return ULE->getTrailingObjects<TemplateArgumentLoc>();
3983 return cast<UnresolvedMemberExpr>(this)
3984 ->getTrailingObjects<TemplateArgumentLoc>();
3987 CXXRecordDecl *OverloadExpr::getNamingClass() {
3988 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this))
3989 return ULE->getNamingClass();
3990 return cast<UnresolvedMemberExpr>(this)->getNamingClass();
3993 /// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
3995 /// The noexcept expression tests whether a given expression might throw. Its
3996 /// result is a boolean constant.
3997 class CXXNoexceptExpr : public Expr {
3998 friend class ASTStmtReader;
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));
4012 CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {}
4014 Expr *getOperand() const { return static_cast<Expr *>(Operand); }
4016 SourceLocation getBeginLoc() const { return Range.getBegin(); }
4017 SourceLocation getEndLoc() const { return Range.getEnd(); }
4018 SourceRange getSourceRange() const { return Range; }
4020 bool getValue() const { return CXXNoexceptExprBits.Value; }
4022 static bool classof(const Stmt *T) {
4023 return T->getStmtClass() == CXXNoexceptExprClass;
4027 child_range children() { return child_range(&Operand, &Operand + 1); }
4029 const_child_range children() const {
4030 return const_child_range(&Operand, &Operand + 1);
4034 /// Represents a C++11 pack expansion that produces a sequence of
4037 /// A pack expansion expression contains a pattern (which itself is an
4038 /// expression) followed by an ellipsis. For example:
4041 /// template<typename F, typename ...Types>
4042 /// void forward(F f, Types &&...args) {
4043 /// f(static_cast<Types&&>(args)...);
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.
4051 class PackExpansionExpr : public Expr {
4052 friend class ASTStmtReader;
4053 friend class ASTStmtWriter;
4055 SourceLocation EllipsisLoc;
4057 /// The number of expansions that will be produced by this pack
4058 /// expansion expression, if known.
4060 /// When zero, the number of expansions is not known. Otherwise, this value
4061 /// is the number of expansions + 1.
4062 unsigned NumExpansions;
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),
4074 setDependence(computeDependence(this));
4077 PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) {}
4079 /// Retrieve the pattern of the pack expansion.
4080 Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }
4082 /// Retrieve the pattern of the pack expansion.
4083 const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }
4085 /// Retrieve the location of the ellipsis that describes this pack
4087 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
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 {
4093 return NumExpansions - 1;
4098 SourceLocation getBeginLoc() const LLVM_READONLY {
4099 return Pattern->getBeginLoc();
4102 SourceLocation getEndLoc() const LLVM_READONLY { return EllipsisLoc; }
4104 static bool classof(const Stmt *T) {
4105 return T->getStmtClass() == PackExpansionExprClass;
4109 child_range children() {
4110 return child_range(&Pattern, &Pattern + 1);
4113 const_child_range children() const {
4114 return const_child_range(&Pattern, &Pattern + 1);
4118 /// Represents an expression that computes the length of a parameter
4122 /// template<typename ...Types>
4124 /// static const unsigned value = sizeof...(Types);
4127 class SizeOfPackExpr final
4129 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4130 friend class ASTStmtReader;
4131 friend class ASTStmtWriter;
4132 friend TrailingObjects;
4134 /// The location of the \c sizeof keyword.
4135 SourceLocation OperatorLoc;
4137 /// The location of the name of the parameter pack.
4138 SourceLocation PackLoc;
4140 /// The location of the closing parenthesis.
4141 SourceLocation RParenLoc;
4143 /// The length of the parameter pack, if known.
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.
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.
4155 /// The parameter pack.
4156 NamedDecl *Pack = nullptr;
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()) &&
4168 "have partial args for non-dependent sizeof... expression");
4169 auto *Args = getTrailingObjects<TemplateArgument>();
4170 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args);
4171 setDependence(Length ? ExprDependence::None
4172 : ExprDependence::ValueInstantiation);
4175 /// Create an empty expression.
4176 SizeOfPackExpr(EmptyShell Empty, unsigned NumPartialArgs)
4177 : Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {}
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);
4188 /// Determine the location of the 'sizeof' keyword.
4189 SourceLocation getOperatorLoc() const { return OperatorLoc; }
4191 /// Determine the location of the parameter pack.
4192 SourceLocation getPackLoc() const { return PackLoc; }
4194 /// Determine the location of the right parenthesis.
4195 SourceLocation getRParenLoc() const { return RParenLoc; }
4197 /// Retrieve the parameter pack.
4198 NamedDecl *getPack() const { return Pack; }
4200 /// Retrieve the length of the parameter pack.
4202 /// This routine may only be invoked when the expression is not
4203 /// value-dependent.
4204 unsigned getPackLength() const {
4205 assert(!isValueDependent() &&
4206 "Cannot get the length of a value-dependent pack size expression");
4210 /// Determine whether this represents a partially-substituted sizeof...
4211 /// expression, such as is produced for:
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;
4220 ArrayRef<TemplateArgument> getPartialArguments() const {
4221 assert(isPartiallySubstituted());
4222 const auto *Args = getTrailingObjects<TemplateArgument>();
4223 return llvm::makeArrayRef(Args, Args + Length);
4226 SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
4227 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
4229 static bool classof(const Stmt *T) {
4230 return T->getStmtClass() == SizeOfPackExprClass;
4234 child_range children() {
4235 return child_range(child_iterator(), child_iterator());
4238 const_child_range children() const {
4239 return const_child_range(const_child_iterator(), const_child_iterator());
4243 /// Represents a reference to a non-type template parameter
4244 /// that has been substituted with a template argument.
4245 class SubstNonTypeTemplateParmExpr : public Expr {
4246 friend class ASTReader;
4247 friend class ASTStmtReader;
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
4252 llvm::PointerIntPair<NonTypeTemplateParmDecl*, 1, bool> ParamAndRef;
4254 /// The replacement expression.
4257 explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
4258 : Expr(SubstNonTypeTemplateParmExprClass, Empty) {}
4261 SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind,
4263 NonTypeTemplateParmDecl *Param, bool RefParam,
4265 : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary),
4266 ParamAndRef(Param, RefParam), Replacement(Replacement) {
4267 SubstNonTypeTemplateParmExprBits.NameLoc = Loc;
4268 setDependence(computeDependence(this));
4271 SourceLocation getNameLoc() const {
4272 return SubstNonTypeTemplateParmExprBits.NameLoc;
4274 SourceLocation getBeginLoc() const { return getNameLoc(); }
4275 SourceLocation getEndLoc() const { return getNameLoc(); }
4277 Expr *getReplacement() const { return cast<Expr>(Replacement); }
4279 NonTypeTemplateParmDecl *getParameter() const {
4280 return ParamAndRef.getPointer();
4283 bool isReferenceParameter() const { return ParamAndRef.getInt(); }
4285 /// Determine the substituted type of the template parameter.
4286 QualType getParameterType(const ASTContext &Ctx) const;
4288 static bool classof(const Stmt *s) {
4289 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
4293 child_range children() { return child_range(&Replacement, &Replacement + 1); }
4295 const_child_range children() const {
4296 return const_child_range(&Replacement, &Replacement + 1);
4300 /// Represents a reference to a non-type template parameter pack that
4301 /// has been substituted with a non-template argument pack.
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.
4312 class SubstNonTypeTemplateParmPackExpr : public Expr {
4313 friend class ASTReader;
4314 friend class ASTStmtReader;
4316 /// The non-type template parameter pack itself.
4317 NonTypeTemplateParmDecl *Param;
4319 /// A pointer to the set of template arguments that this
4320 /// parameter pack is instantiated with.
4321 const TemplateArgument *Arguments;
4323 /// The number of template arguments in \c Arguments.
4324 unsigned NumArguments;
4326 /// The location of the non-type template parameter pack reference.
4327 SourceLocation NameLoc;
4329 explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)
4330 : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {}
4333 SubstNonTypeTemplateParmPackExpr(QualType T,
4334 ExprValueKind ValueKind,
4335 NonTypeTemplateParmDecl *Param,
4336 SourceLocation NameLoc,
4337 const TemplateArgument &ArgPack);
4339 /// Retrieve the non-type template parameter pack being substituted.
4340 NonTypeTemplateParmDecl *getParameterPack() const { return Param; }
4342 /// Retrieve the location of the parameter pack name.
4343 SourceLocation getParameterPackLocation() const { return NameLoc; }
4345 /// Retrieve the template argument pack containing the substituted
4346 /// template arguments.
4347 TemplateArgument getArgumentPack() const;
4349 SourceLocation getBeginLoc() const LLVM_READONLY { return NameLoc; }
4350 SourceLocation getEndLoc() const LLVM_READONLY { return NameLoc; }
4352 static bool classof(const Stmt *T) {
4353 return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
4357 child_range children() {
4358 return child_range(child_iterator(), child_iterator());
4361 const_child_range children() const {
4362 return const_child_range(const_child_iterator(), const_child_iterator());
4366 /// Represents a reference to a function parameter pack or init-capture pack
4367 /// that has been substituted but not yet expanded.
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.
4375 /// template<typename...Ts> struct S {
4376 /// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...));
4378 /// template struct S<int, int>;
4380 class FunctionParmPackExpr final
4382 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> {
4383 friend class ASTReader;
4384 friend class ASTStmtReader;
4385 friend TrailingObjects;
4387 /// The function parameter pack which was referenced.
4390 /// The location of the function parameter pack reference.
4391 SourceLocation NameLoc;
4393 /// The number of expansions of this pack.
4394 unsigned NumParameters;
4396 FunctionParmPackExpr(QualType T, VarDecl *ParamPack,
4397 SourceLocation NameLoc, unsigned NumParams,
4398 VarDecl *const *Params);
4401 static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T,
4403 SourceLocation NameLoc,
4404 ArrayRef<VarDecl *> Params);
4405 static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context,
4406 unsigned NumParams);
4408 /// Get the parameter pack which this expression refers to.
4409 VarDecl *getParameterPack() const { return ParamPack; }
4411 /// Get the location of the parameter pack.
4412 SourceLocation getParameterPackLocation() const { return NameLoc; }
4414 /// Iterators over the parameters which the parameter pack expanded
4416 using iterator = VarDecl * const *;
4417 iterator begin() const { return getTrailingObjects<VarDecl *>(); }
4418 iterator end() const { return begin() + NumParameters; }
4420 /// Get the number of parameters in this parameter pack.
4421 unsigned getNumExpansions() const { return NumParameters; }
4423 /// Get an expansion of the parameter pack by index.
4424 VarDecl *getExpansion(unsigned I) const { return begin()[I]; }
4426 SourceLocation getBeginLoc() const LLVM_READONLY { return NameLoc; }
4427 SourceLocation getEndLoc() const LLVM_READONLY { return NameLoc; }
4429 static bool classof(const Stmt *T) {
4430 return T->getStmtClass() == FunctionParmPackExprClass;
4433 child_range children() {
4434 return child_range(child_iterator(), child_iterator());
4437 const_child_range children() const {
4438 return const_child_range(const_child_iterator(), const_child_iterator());
4442 /// Represents a prvalue temporary that is written into memory so that
4443 /// a reference can bind to it.
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.,
4450 /// const int &r = 1.0;
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.
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.
4462 class MaterializeTemporaryExpr : public Expr {
4464 friend class ASTStmtReader;
4465 friend class ASTStmtWriter;
4467 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State;
4470 MaterializeTemporaryExpr(QualType T, Expr *Temporary,
4471 bool BoundToLvalueReference,
4472 LifetimeExtendedTemporaryDecl *MTD = nullptr);
4474 MaterializeTemporaryExpr(EmptyShell Empty)
4475 : Expr(MaterializeTemporaryExprClass, Empty) {}
4477 /// Retrieve the temporary-generating subexpression whose value will
4478 /// be materialized into a glvalue.
4479 Expr *getSubExpr() const {
4482 ? State.get<Stmt *>()
4483 : State.get<LifetimeExtendedTemporaryDecl *>()->getTemporaryExpr());
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();
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 *>() &&
4497 "the temporary has not been lifetime extended");
4498 return State.get<LifetimeExtendedTemporaryDecl *>()->getOrCreateValue(
4502 LifetimeExtendedTemporaryDecl *getLifetimeExtendedTemporaryDecl() {
4503 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>();
4505 const LifetimeExtendedTemporaryDecl *
4506 getLifetimeExtendedTemporaryDecl() const {
4507 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>();
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();
4517 const ValueDecl *getExtendingDecl() const {
4518 return const_cast<MaterializeTemporaryExpr *>(this)->getExtendingDecl();
4521 void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber);
4523 unsigned getManglingNumber() const {
4524 return State.is<Stmt *>() ? 0
4525 : State.get<LifetimeExtendedTemporaryDecl *>()
4526 ->getManglingNumber();
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(); }
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;
4537 SourceLocation getBeginLoc() const LLVM_READONLY {
4538 return getSubExpr()->getBeginLoc();
4541 SourceLocation getEndLoc() const LLVM_READONLY {
4542 return getSubExpr()->getEndLoc();
4545 static bool classof(const Stmt *T) {
4546 return T->getStmtClass() == MaterializeTemporaryExprClass;
4550 child_range children() {
4551 return State.is<Stmt *>()
4552 ? child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1)
4553 : State.get<LifetimeExtendedTemporaryDecl *>()->childrenExpr();
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 *>())
4566 /// Represents a folding of a pack over an operator.
4568 /// This expression is always dependent and represents a pack expansion of the
4573 /// ( expr op ... op expr )
4574 class CXXFoldExpr : public Expr {
4575 friend class ASTStmtReader;
4576 friend class ASTStmtWriter;
4578 enum SubExpr { Callee, LHS, RHS, Count };
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;
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));
4603 CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
4605 UnresolvedLookupExpr *getCallee() const {
4606 return static_cast<UnresolvedLookupExpr *>(SubExprs[SubExpr::Callee]);
4608 Expr *getLHS() const { return static_cast<Expr*>(SubExprs[SubExpr::LHS]); }
4609 Expr *getRHS() const { return static_cast<Expr*>(SubExprs[SubExpr::RHS]); }
4611 /// Does this produce a right-associated sequence of operators?
4612 bool isRightFold() const {
4613 return getLHS() && getLHS()->containsUnexpandedParameterPack();
4616 /// Does this produce a left-associated sequence of operators?
4617 bool isLeftFold() const { return !isRightFold(); }
4619 /// Get the pattern, that is, the operand that contains an unexpanded pack.
4620 Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }
4622 /// Get the operand that doesn't contain a pack, for a binary fold.
4623 Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }
4625 SourceLocation getLParenLoc() const { return LParenLoc; }
4626 SourceLocation getRParenLoc() const { return RParenLoc; }
4627 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
4628 BinaryOperatorKind getOperator() const { return Opcode; }
4630 Optional<unsigned> getNumExpansions() const {
4632 return NumExpansions - 1;
4636 SourceLocation getBeginLoc() const LLVM_READONLY {
4637 if (LParenLoc.isValid())
4640 return getEllipsisLoc();
4641 return getLHS()->getBeginLoc();
4644 SourceLocation getEndLoc() const LLVM_READONLY {
4645 if (RParenLoc.isValid())
4648 return getEllipsisLoc();
4649 return getRHS()->getEndLoc();
4652 static bool classof(const Stmt *T) {
4653 return T->getStmtClass() == CXXFoldExprClass;
4657 child_range children() {
4658 return child_range(SubExprs, SubExprs + SubExpr::Count);
4661 const_child_range children() const {
4662 return const_child_range(SubExprs, SubExprs + SubExpr::Count);
4666 /// Represents an expression that might suspend coroutine execution;
4667 /// either a co_await or co_yield expression.
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
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
4679 class CoroutineSuspendExpr : public Expr {
4680 friend class ASTStmtReader;
4682 SourceLocation KeywordLoc;
4684 enum SubExpr { Common, Ready, Suspend, Resume, Count };
4686 Stmt *SubExprs[SubExpr::Count];
4687 OpaqueValueExpr *OpaqueValue = nullptr;
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(),
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));
4703 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty,
4705 : Expr(SC, Ty, VK_PRValue, OK_Ordinary), KeywordLoc(KeywordLoc) {
4706 assert(Common->isTypeDependent() && Ty->isDependentType() &&
4707 "wrong constructor for non-dependent co_await/co_yield expression");
4708 SubExprs[SubExpr::Common] = Common;
4709 SubExprs[SubExpr::Ready] = nullptr;
4710 SubExprs[SubExpr::Suspend] = nullptr;
4711 SubExprs[SubExpr::Resume] = nullptr;
4712 setDependence(computeDependence(this));
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;
4722 SourceLocation getKeywordLoc() const { return KeywordLoc; }
4724 Expr *getCommonExpr() const {
4725 return static_cast<Expr*>(SubExprs[SubExpr::Common]);
4728 /// getOpaqueValue - Return the opaque value placeholder.
4729 OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }
4731 Expr *getReadyExpr() const {
4732 return static_cast<Expr*>(SubExprs[SubExpr::Ready]);
4735 Expr *getSuspendExpr() const {
4736 return static_cast<Expr*>(SubExprs[SubExpr::Suspend]);
4739 Expr *getResumeExpr() const {
4740 return static_cast<Expr*>(SubExprs[SubExpr::Resume]);
4743 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
4745 SourceLocation getEndLoc() const LLVM_READONLY {
4746 return getCommonExpr()->getEndLoc();
4749 child_range children() {
4750 return child_range(SubExprs, SubExprs + SubExpr::Count);
4753 const_child_range children() const {
4754 return const_child_range(SubExprs, SubExprs + SubExpr::Count);
4757 static bool classof(const Stmt *T) {
4758 return T->getStmtClass() == CoawaitExprClass ||
4759 T->getStmtClass() == CoyieldExprClass;
4763 /// Represents a 'co_await' expression.
4764 class CoawaitExpr : public CoroutineSuspendExpr {
4765 friend class ASTStmtReader;
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;
4776 CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand,
4777 bool IsImplicit = false)
4778 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Ty, Operand) {
4779 CoawaitBits.IsImplicit = IsImplicit;
4782 CoawaitExpr(EmptyShell Empty)
4783 : CoroutineSuspendExpr(CoawaitExprClass, Empty) {}
4785 Expr *getOperand() const {
4786 // FIXME: Dig out the actual operand or store it.
4787 return getCommonExpr();
4790 bool isImplicit() const { return CoawaitBits.IsImplicit; }
4791 void setIsImplicit(bool value = true) { CoawaitBits.IsImplicit = value; }
4793 static bool classof(const Stmt *T) {
4794 return T->getStmtClass() == CoawaitExprClass;
4798 /// Represents a 'co_await' expression while the type of the promise
4800 class DependentCoawaitExpr : public Expr {
4801 friend class ASTStmtReader;
4803 SourceLocation KeywordLoc;
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() &&
4814 "wrong constructor for non-dependent co_await/co_yield expression");
4816 SubExprs[1] = OpCoawait;
4817 setDependence(computeDependence(this));
4820 DependentCoawaitExpr(EmptyShell Empty)
4821 : Expr(DependentCoawaitExprClass, Empty) {}
4823 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); }
4825 UnresolvedLookupExpr *getOperatorCoawaitLookup() const {
4826 return cast<UnresolvedLookupExpr>(SubExprs[1]);
4829 SourceLocation getKeywordLoc() const { return KeywordLoc; }
4831 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
4833 SourceLocation getEndLoc() const LLVM_READONLY {
4834 return getOperand()->getEndLoc();
4837 child_range children() { return child_range(SubExprs, SubExprs + 2); }
4839 const_child_range children() const {
4840 return const_child_range(SubExprs, SubExprs + 2);
4843 static bool classof(const Stmt *T) {
4844 return T->getStmtClass() == DependentCoawaitExprClass;
4848 /// Represents a 'co_yield' expression.
4849 class CoyieldExpr : public CoroutineSuspendExpr {
4850 friend class ASTStmtReader;
4853 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready,
4854 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue)
4855 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Operand, Ready,
4856 Suspend, Resume, OpaqueValue) {}
4857 CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand)
4858 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Ty, Operand) {}
4859 CoyieldExpr(EmptyShell Empty)
4860 : CoroutineSuspendExpr(CoyieldExprClass, Empty) {}
4862 Expr *getOperand() const {
4863 // FIXME: Dig out the actual operand or store it.
4864 return getCommonExpr();
4867 static bool classof(const Stmt *T) {
4868 return T->getStmtClass() == CoyieldExprClass;
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.
4875 class BuiltinBitCastExpr final
4876 : public ExplicitCastExpr,
4877 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
4878 friend class ASTStmtReader;
4879 friend class CastExpr;
4880 friend TrailingObjects;
4882 SourceLocation KWLoc;
4883 SourceLocation RParenLoc;
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,
4891 KWLoc(KWLoc), RParenLoc(RParenLoc) {}
4892 BuiltinBitCastExpr(EmptyShell Empty)
4893 : ExplicitCastExpr(BuiltinBitCastExprClass, Empty, 0, false) {}
4895 SourceLocation getBeginLoc() const LLVM_READONLY { return KWLoc; }
4896 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
4898 static bool classof(const Stmt *T) {
4899 return T->getStmtClass() == BuiltinBitCastExprClass;
4903 } // namespace clang
4905 #endif // LLVM_CLANG_AST_EXPRCXX_H