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