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