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