1 //===- ExprCXX.h - Classes for representing expressions ---------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 /// \file 10 /// Defines the clang::Expr interface and subclasses for C++ expressions. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_AST_EXPRCXX_H 15 #define LLVM_CLANG_AST_EXPRCXX_H 16 17 #include "clang/AST/ASTConcept.h" 18 #include "clang/AST/ComputeDependence.h" 19 #include "clang/AST/Decl.h" 20 #include "clang/AST/DeclBase.h" 21 #include "clang/AST/DeclCXX.h" 22 #include "clang/AST/DeclTemplate.h" 23 #include "clang/AST/DeclarationName.h" 24 #include "clang/AST/DependenceFlags.h" 25 #include "clang/AST/Expr.h" 26 #include "clang/AST/NestedNameSpecifier.h" 27 #include "clang/AST/OperationKinds.h" 28 #include "clang/AST/Stmt.h" 29 #include "clang/AST/StmtCXX.h" 30 #include "clang/AST/TemplateBase.h" 31 #include "clang/AST/Type.h" 32 #include "clang/AST/UnresolvedSet.h" 33 #include "clang/Basic/ExceptionSpecificationType.h" 34 #include "clang/Basic/ExpressionTraits.h" 35 #include "clang/Basic/LLVM.h" 36 #include "clang/Basic/Lambda.h" 37 #include "clang/Basic/LangOptions.h" 38 #include "clang/Basic/OperatorKinds.h" 39 #include "clang/Basic/SourceLocation.h" 40 #include "clang/Basic/Specifiers.h" 41 #include "clang/Basic/TypeTraits.h" 42 #include "llvm/ADT/ArrayRef.h" 43 #include "llvm/ADT/None.h" 44 #include "llvm/ADT/Optional.h" 45 #include "llvm/ADT/PointerUnion.h" 46 #include "llvm/ADT/StringRef.h" 47 #include "llvm/ADT/iterator_range.h" 48 #include "llvm/Support/Casting.h" 49 #include "llvm/Support/Compiler.h" 50 #include "llvm/Support/TrailingObjects.h" 51 #include <cassert> 52 #include <cstddef> 53 #include <cstdint> 54 #include <memory> 55 56 namespace clang { 57 58 class ASTContext; 59 class DeclAccessPair; 60 class IdentifierInfo; 61 class LambdaCapture; 62 class NonTypeTemplateParmDecl; 63 class TemplateParameterList; 64 65 //===--------------------------------------------------------------------===// 66 // C++ Expressions. 67 //===--------------------------------------------------------------------===// 68 69 /// A call to an overloaded operator written using operator 70 /// syntax. 71 /// 72 /// Represents a call to an overloaded operator written using operator 73 /// syntax, e.g., "x + y" or "*p". While semantically equivalent to a 74 /// normal call, this AST node provides better information about the 75 /// syntactic representation of the call. 76 /// 77 /// In a C++ template, this expression node kind will be used whenever 78 /// any of the arguments are type-dependent. In this case, the 79 /// function itself will be a (possibly empty) set of functions and 80 /// function templates that were found by name lookup at template 81 /// definition time. 82 class CXXOperatorCallExpr final : public CallExpr { 83 friend class ASTStmtReader; 84 friend class ASTStmtWriter; 85 86 SourceRange Range; 87 88 // CXXOperatorCallExpr has some trailing objects belonging 89 // to CallExpr. See CallExpr for the details. 90 91 SourceRange getSourceRangeImpl() const LLVM_READONLY; 92 93 CXXOperatorCallExpr(OverloadedOperatorKind OpKind, Expr *Fn, 94 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, 95 SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, 96 ADLCallKind UsesADL); 97 98 CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty); 99 100 public: 101 static CXXOperatorCallExpr * 102 Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn, 103 ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, 104 SourceLocation OperatorLoc, FPOptionsOverride FPFeatures, 105 ADLCallKind UsesADL = NotADL); 106 107 static CXXOperatorCallExpr *CreateEmpty(const ASTContext &Ctx, 108 unsigned NumArgs, bool HasFPFeatures, 109 EmptyShell Empty); 110 111 /// Returns the kind of overloaded operator that this expression refers to. 112 OverloadedOperatorKind getOperator() const { 113 return static_cast<OverloadedOperatorKind>( 114 CXXOperatorCallExprBits.OperatorKind); 115 } 116 117 static bool isAssignmentOp(OverloadedOperatorKind Opc) { 118 return Opc == OO_Equal || Opc == OO_StarEqual || Opc == OO_SlashEqual || 119 Opc == OO_PercentEqual || Opc == OO_PlusEqual || 120 Opc == OO_MinusEqual || Opc == OO_LessLessEqual || 121 Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual || 122 Opc == OO_CaretEqual || Opc == OO_PipeEqual; 123 } 124 bool isAssignmentOp() const { return isAssignmentOp(getOperator()); } 125 126 static bool isComparisonOp(OverloadedOperatorKind Opc) { 127 switch (Opc) { 128 case OO_EqualEqual: 129 case OO_ExclaimEqual: 130 case OO_Greater: 131 case OO_GreaterEqual: 132 case OO_Less: 133 case OO_LessEqual: 134 case OO_Spaceship: 135 return true; 136 default: 137 return false; 138 } 139 } 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. 150 SourceLocation getOperatorLoc() const { return getRParenLoc(); } 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 181 CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty, 182 ExprValueKind VK, SourceLocation RP, 183 FPOptionsOverride FPOptions, unsigned MinNumArgs); 184 185 CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty); 186 187 public: 188 static CXXMemberCallExpr *Create(const ASTContext &Ctx, Expr *Fn, 189 ArrayRef<Expr *> Args, QualType Ty, 190 ExprValueKind VK, SourceLocation RP, 191 FPOptionsOverride FPFeatures, 192 unsigned MinNumArgs = 0); 193 194 static CXXMemberCallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, 195 bool HasFPFeatures, EmptyShell Empty); 196 197 /// Retrieve the implicit object argument for the member call. 198 /// 199 /// For example, in "x.f(5)", this returns the sub-expression "x". 200 Expr *getImplicitObjectArgument() const; 201 202 /// Retrieve the type of the object argument. 203 /// 204 /// Note that this always returns a non-pointer type. 205 QualType getObjectType() const; 206 207 /// Retrieve the declaration of the called method. 208 CXXMethodDecl *getMethodDecl() const; 209 210 /// Retrieve the CXXRecordDecl for the underlying type of 211 /// the implicit object argument. 212 /// 213 /// Note that this is may not be the same declaration as that of the class 214 /// context of the CXXMethodDecl which this function is calling. 215 /// FIXME: Returns 0 for member pointer call exprs. 216 CXXRecordDecl *getRecordDecl() const; 217 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 240 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args, 241 QualType Ty, ExprValueKind VK, SourceLocation RP, 242 FPOptionsOverride FPFeatures, unsigned MinNumArgs); 243 244 CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty); 245 246 public: 247 static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn, 248 CallExpr *Config, ArrayRef<Expr *> Args, 249 QualType Ty, ExprValueKind VK, 250 SourceLocation RP, 251 FPOptionsOverride FPFeatures, 252 unsigned MinNumArgs = 0); 253 254 static CUDAKernelCallExpr *CreateEmpty(const ASTContext &Ctx, 255 unsigned NumArgs, bool HasFPFeatures, 256 EmptyShell Empty); 257 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. 284 class CXXRewrittenBinaryOperator : public Expr { 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; 296 setDependence(computeDependence(this)); 297 } 298 CXXRewrittenBinaryOperator(EmptyShell Empty) 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. 307 BinaryOperatorKind Opcode; 308 /// The original left-hand side. 309 const Expr *LHS; 310 /// The original right-hand side. 311 const Expr *RHS; 312 /// The inner \c == or \c <=> operator expression. 313 const Expr *InnerBinOp; 314 }; 315 316 /// Decompose this operator into its syntactic form. 317 DecomposedForm getDecomposedForm() const LLVM_READONLY; 318 319 /// Determine whether this expression was rewritten in reverse form. 320 bool isReversed() const { return CXXRewrittenBinaryOperatorBits.IsReversed; } 321 322 BinaryOperatorKind getOperator() const { return getDecomposedForm().Opcode; } 323 BinaryOperatorKind getOpcode() const { return getOperator(); } 324 static StringRef getOpcodeStr(BinaryOperatorKind Op) { 325 return BinaryOperator::getOpcodeStr(Op); 326 } 327 StringRef getOpcodeStr() const { 328 return BinaryOperator::getOpcodeStr(getOpcode()); 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 { 337 return getDecomposedForm().InnerBinOp->getExprLoc(); 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 { 352 DecomposedForm DF = getDecomposedForm(); 353 return SourceRange(DF.LHS->getBeginLoc(), DF.RHS->getEndLoc()); 354 } 355 //@} 356 357 child_range children() { 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). 373 class CXXNamedCastExpr : public ExplicitCastExpr { 374 private: 375 // the location of the casting op 376 SourceLocation Loc; 377 378 // the location of the right parenthesis 379 SourceLocation RParenLoc; 380 381 // range for '<' '>' 382 SourceRange AngleBrackets; 383 384 protected: 385 friend class ASTStmtReader; 386 387 CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK, CastKind kind, 388 Expr *op, unsigned PathSize, bool HasFPFeatures, 389 TypeSourceInfo *writtenTy, SourceLocation l, 390 SourceLocation RParenLoc, SourceRange AngleBrackets) 391 : ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, HasFPFeatures, 392 writtenTy), 393 Loc(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {} 394 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> { 435 CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op, 436 unsigned pathSize, TypeSourceInfo *writtenTy, 437 FPOptionsOverride FPO, SourceLocation l, 438 SourceLocation RParenLoc, SourceRange AngleBrackets) 439 : CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize, 440 FPO.requiresTrailingStorage(), writtenTy, l, RParenLoc, 441 AngleBrackets) { 442 if (hasStoredFPFeatures()) 443 *getTrailingFPFeatures() = FPO; 444 } 445 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; 457 friend TrailingObjects; 458 459 static CXXStaticCastExpr * 460 Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, 461 Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, 462 FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, 463 SourceRange AngleBrackets); 464 static CXXStaticCastExpr *CreateEmpty(const ASTContext &Context, 465 unsigned PathSize, bool hasFPFeatures); 466 467 static bool classof(const Stmt *T) { 468 return T->getStmtClass() == CXXStaticCastExprClass; 469 } 470 }; 471 472 /// A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]). 473 /// 474 /// This expression node represents a dynamic cast, e.g., 475 /// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time 476 /// check to determine how to perform the type conversion. 477 class CXXDynamicCastExpr final 478 : public CXXNamedCastExpr, 479 private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> { 480 CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind, Expr *op, 481 unsigned pathSize, TypeSourceInfo *writtenTy, 482 SourceLocation l, SourceLocation RParenLoc, 483 SourceRange AngleBrackets) 484 : CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize, 485 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc, 486 AngleBrackets) {} 487 488 explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize) 489 : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize, 490 /*HasFPFeatures*/ false) {} 491 492 public: 493 friend class CastExpr; 494 friend TrailingObjects; 495 496 static CXXDynamicCastExpr *Create(const ASTContext &Context, QualType T, 497 ExprValueKind VK, CastKind Kind, Expr *Op, 498 const CXXCastPath *Path, 499 TypeSourceInfo *Written, SourceLocation L, 500 SourceLocation RParenLoc, 501 SourceRange AngleBrackets); 502 503 static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context, 504 unsigned pathSize); 505 506 bool isAlwaysNull() const; 507 508 static bool classof(const Stmt *T) { 509 return T->getStmtClass() == CXXDynamicCastExprClass; 510 } 511 }; 512 513 /// A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]). 514 /// 515 /// This expression node represents a reinterpret cast, e.g., 516 /// @c reinterpret_cast<int>(VoidPtr). 517 /// 518 /// A reinterpret_cast provides a differently-typed view of a value but 519 /// (in Clang, as in most C++ implementations) performs no actual work at 520 /// run time. 521 class CXXReinterpretCastExpr final 522 : public CXXNamedCastExpr, 523 private llvm::TrailingObjects<CXXReinterpretCastExpr, 524 CXXBaseSpecifier *> { 525 CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op, 526 unsigned pathSize, TypeSourceInfo *writtenTy, 527 SourceLocation l, SourceLocation RParenLoc, 528 SourceRange AngleBrackets) 529 : CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op, 530 pathSize, /*HasFPFeatures*/ false, writtenTy, l, 531 RParenLoc, AngleBrackets) {} 532 533 CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize) 534 : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize, 535 /*HasFPFeatures*/ false) {} 536 537 public: 538 friend class CastExpr; 539 friend TrailingObjects; 540 541 static CXXReinterpretCastExpr *Create(const ASTContext &Context, QualType T, 542 ExprValueKind VK, CastKind Kind, 543 Expr *Op, const CXXCastPath *Path, 544 TypeSourceInfo *WrittenTy, SourceLocation L, 545 SourceLocation RParenLoc, 546 SourceRange AngleBrackets); 547 static CXXReinterpretCastExpr *CreateEmpty(const ASTContext &Context, 548 unsigned pathSize); 549 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 *> { 565 CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op, 566 TypeSourceInfo *writtenTy, SourceLocation l, 567 SourceLocation RParenLoc, SourceRange AngleBrackets) 568 : CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op, 0, 569 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc, 570 AngleBrackets) {} 571 572 explicit CXXConstCastExpr(EmptyShell Empty) 573 : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0, 574 /*HasFPFeatures*/ false) {} 575 576 public: 577 friend class CastExpr; 578 friend TrailingObjects; 579 580 static CXXConstCastExpr *Create(const ASTContext &Context, QualType T, 581 ExprValueKind VK, Expr *Op, 582 TypeSourceInfo *WrittenTy, SourceLocation L, 583 SourceLocation RParenLoc, 584 SourceRange AngleBrackets); 585 static CXXConstCastExpr *CreateEmpty(const ASTContext &Context); 586 587 static bool classof(const Stmt *T) { 588 return T->getStmtClass() == CXXConstCastExprClass; 589 } 590 }; 591 592 /// A C++ addrspace_cast expression (currently only enabled for OpenCL). 593 /// 594 /// This expression node represents a cast between pointers to objects in 595 /// different address spaces e.g., 596 /// \c addrspace_cast<global int*>(PtrToGenericInt). 597 /// 598 /// A addrspace_cast can cast address space type qualifiers but does not change 599 /// the underlying value. 600 class CXXAddrspaceCastExpr final 601 : public CXXNamedCastExpr, 602 private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> { 603 CXXAddrspaceCastExpr(QualType ty, ExprValueKind VK, CastKind Kind, Expr *op, 604 TypeSourceInfo *writtenTy, SourceLocation l, 605 SourceLocation RParenLoc, SourceRange AngleBrackets) 606 : CXXNamedCastExpr(CXXAddrspaceCastExprClass, ty, VK, Kind, op, 0, 607 /*HasFPFeatures*/ false, writtenTy, l, RParenLoc, 608 AngleBrackets) {} 609 610 explicit CXXAddrspaceCastExpr(EmptyShell Empty) 611 : CXXNamedCastExpr(CXXAddrspaceCastExprClass, Empty, 0, 612 /*HasFPFeatures*/ false) {} 613 614 public: 615 friend class CastExpr; 616 friend TrailingObjects; 617 618 static CXXAddrspaceCastExpr * 619 Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, 620 Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, 621 SourceLocation RParenLoc, SourceRange AngleBrackets); 622 static CXXAddrspaceCastExpr *CreateEmpty(const ASTContext &Context); 623 624 static bool classof(const Stmt *T) { 625 return T->getStmtClass() == CXXAddrspaceCastExprClass; 626 } 627 }; 628 629 /// A call to a literal operator (C++11 [over.literal]) 630 /// written as a user-defined literal (C++11 [lit.ext]). 631 /// 632 /// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this 633 /// is semantically equivalent to a normal call, this AST node provides better 634 /// information about the syntactic representation of the literal. 635 /// 636 /// Since literal operators are never found by ADL and can only be declared at 637 /// namespace scope, a user-defined literal is never dependent. 638 class UserDefinedLiteral final : public CallExpr { 639 friend class ASTStmtReader; 640 friend class ASTStmtWriter; 641 642 /// The location of a ud-suffix within the literal. 643 SourceLocation UDSuffixLoc; 644 645 // UserDefinedLiteral has some trailing objects belonging 646 // to CallExpr. See CallExpr for the details. 647 648 UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty, 649 ExprValueKind VK, SourceLocation LitEndLoc, 650 SourceLocation SuffixLoc, FPOptionsOverride FPFeatures); 651 652 UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty); 653 654 public: 655 static UserDefinedLiteral *Create(const ASTContext &Ctx, Expr *Fn, 656 ArrayRef<Expr *> Args, QualType Ty, 657 ExprValueKind VK, SourceLocation LitEndLoc, 658 SourceLocation SuffixLoc, 659 FPOptionsOverride FPFeatures); 660 661 static UserDefinedLiteral *CreateEmpty(const ASTContext &Ctx, 662 unsigned NumArgs, bool HasFPOptions, 663 EmptyShell Empty); 664 665 /// The kind of literal operator which is invoked. 666 enum LiteralOperatorKind { 667 /// Raw form: operator "" X (const char *) 668 LOK_Raw, 669 670 /// Raw form: operator "" X<cs...> () 671 LOK_Template, 672 673 /// operator "" X (unsigned long long) 674 LOK_Integer, 675 676 /// operator "" X (long double) 677 LOK_Floating, 678 679 /// operator "" X (const CharT *, size_t) 680 LOK_String, 681 682 /// operator "" X (CharT) 683 LOK_Character 684 }; 685 686 /// Returns the kind of literal operator invocation 687 /// which this expression represents. 688 LiteralOperatorKind getLiteralOperatorKind() const; 689 690 /// If this is not a raw user-defined literal, get the 691 /// underlying cooked literal (representing the literal with the suffix 692 /// removed). 693 Expr *getCookedLiteral(); 694 const Expr *getCookedLiteral() const { 695 return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral(); 696 } 697 698 SourceLocation getBeginLoc() const { 699 if (getLiteralOperatorKind() == LOK_Template) 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: 723 CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc) 724 : Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary) { 725 CXXBoolLiteralExprBits.Value = Val; 726 CXXBoolLiteralExprBits.Loc = Loc; 727 setDependence(ExprDependence::None); 728 } 729 730 explicit CXXBoolLiteralExpr(EmptyShell Empty) 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 739 SourceLocation getLocation() const { return CXXBoolLiteralExprBits.Loc; } 740 void setLocation(SourceLocation L) { CXXBoolLiteralExprBits.Loc = L; } 741 742 static bool classof(const Stmt *T) { 743 return T->getStmtClass() == CXXBoolLiteralExprClass; 744 } 745 746 // Iterators 747 child_range children() { 748 return child_range(child_iterator(), child_iterator()); 749 } 750 751 const_child_range children() const { 752 return const_child_range(const_child_iterator(), const_child_iterator()); 753 } 754 }; 755 756 /// The null pointer literal (C++11 [lex.nullptr]) 757 /// 758 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr. 759 class CXXNullPtrLiteralExpr : public Expr { 760 public: 761 CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc) 762 : Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary) { 763 CXXNullPtrLiteralExprBits.Loc = Loc; 764 setDependence(ExprDependence::None); 765 } 766 767 explicit CXXNullPtrLiteralExpr(EmptyShell Empty) 768 : Expr(CXXNullPtrLiteralExprClass, Empty) {} 769 770 SourceLocation getBeginLoc() const { return getLocation(); } 771 SourceLocation getEndLoc() const { return getLocation(); } 772 773 SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; } 774 void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; } 775 776 static bool classof(const Stmt *T) { 777 return T->getStmtClass() == CXXNullPtrLiteralExprClass; 778 } 779 780 child_range children() { 781 return child_range(child_iterator(), child_iterator()); 782 } 783 784 const_child_range children() const { 785 return const_child_range(const_child_iterator(), const_child_iterator()); 786 } 787 }; 788 789 /// Implicit construction of a std::initializer_list<T> object from an 790 /// array temporary within list-initialization (C++11 [dcl.init.list]p5). 791 class CXXStdInitializerListExpr : public Expr { 792 Stmt *SubExpr = nullptr; 793 794 CXXStdInitializerListExpr(EmptyShell Empty) 795 : Expr(CXXStdInitializerListExprClass, Empty) {} 796 797 public: 798 friend class ASTReader; 799 friend class ASTStmtReader; 800 801 CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr) 802 : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary), 803 SubExpr(SubExpr) { 804 setDependence(computeDependence(this)); 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 829 const_child_range children() const { 830 return const_child_range(&SubExpr, &SubExpr + 1); 831 } 832 }; 833 834 /// A C++ \c typeid expression (C++ [expr.typeid]), which gets 835 /// the \c type_info that corresponds to the supplied type, or the (possibly 836 /// dynamic) type of the supplied expression. 837 /// 838 /// This represents code like \c typeid(int) or \c typeid(*objPtr) 839 class CXXTypeidExpr : public Expr { 840 friend class ASTStmtReader; 841 842 private: 843 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand; 844 SourceRange Range; 845 846 public: 847 CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R) 848 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), 849 Range(R) { 850 setDependence(computeDependence(this)); 851 } 852 853 CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R) 854 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), 855 Range(R) { 856 setDependence(computeDependence(this)); 857 } 858 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. 882 TypeSourceInfo *getTypeOperandSourceInfo() const { 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 901 child_range children() { 902 if (isTypeOperand()) 903 return child_range(child_iterator(), child_iterator()); 904 auto **begin = reinterpret_cast<Stmt **>(&Operand); 905 return child_range(begin, begin + 1); 906 } 907 908 const_child_range children() const { 909 if (isTypeOperand()) 910 return const_child_range(const_child_iterator(), const_child_iterator()); 911 912 auto **begin = 913 reinterpret_cast<Stmt **>(&const_cast<CXXTypeidExpr *>(this)->Operand); 914 return const_child_range(begin, begin + 1); 915 } 916 }; 917 918 /// A member reference to an MSPropertyDecl. 919 /// 920 /// This expression always has pseudo-object type, and therefore it is 921 /// typically not encountered in a fully-typechecked expression except 922 /// within the syntactic form of a PseudoObjectExpr. 923 class MSPropertyRefExpr : public Expr { 924 Expr *BaseExpr; 925 MSPropertyDecl *TheDecl; 926 SourceLocation MemberLoc; 927 bool IsArrow; 928 NestedNameSpecifierLoc QualifierLoc; 929 930 public: 931 friend class ASTStmtReader; 932 933 MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow, 934 QualType ty, ExprValueKind VK, 935 NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc) 936 : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary), BaseExpr(baseExpr), 937 TheDecl(decl), MemberLoc(nameLoc), IsArrow(isArrow), 938 QualifierLoc(qualifierLoc) { 939 setDependence(computeDependence(this)); 940 } 941 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 952 SourceLocation getBeginLoc() const { 953 if (!isImplicitAccess()) 954 return BaseExpr->getBeginLoc(); 955 else if (QualifierLoc) 956 return QualifierLoc.getBeginLoc(); 957 else 958 return MemberLoc; 959 } 960 961 SourceLocation getEndLoc() const { return getMemberLoc(); } 962 963 child_range children() { 964 return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1); 965 } 966 967 const_child_range children() const { 968 auto Children = const_cast<MSPropertyRefExpr *>(this)->children(); 969 return const_child_range(Children.begin(), Children.end()); 970 } 971 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. 994 class MSPropertySubscriptExpr : public Expr { 995 friend class ASTStmtReader; 996 997 enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 }; 998 999 Stmt *SubExprs[NUM_SUBEXPRS]; 1000 SourceLocation RBracketLoc; 1001 1002 void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; } 1003 void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; } 1004 1005 public: 1006 MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK, 1007 ExprObjectKind OK, SourceLocation RBracketLoc) 1008 : Expr(MSPropertySubscriptExprClass, Ty, VK, OK), 1009 RBracketLoc(RBracketLoc) { 1010 SubExprs[BASE_EXPR] = Base; 1011 SubExprs[IDX_EXPR] = Idx; 1012 setDependence(computeDependence(this)); 1013 } 1014 1015 /// Create an empty array subscript expression. 1016 explicit MSPropertySubscriptExpr(EmptyShell Shell) 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 1043 child_range children() { 1044 return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS); 1045 } 1046 1047 const_child_range children() const { 1048 return const_child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS); 1049 } 1050 }; 1051 1052 /// A Microsoft C++ @c __uuidof expression, which gets 1053 /// the _GUID that corresponds to the supplied type or expression. 1054 /// 1055 /// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr) 1056 class CXXUuidofExpr : public Expr { 1057 friend class ASTStmtReader; 1058 1059 private: 1060 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand; 1061 MSGuidDecl *Guid; 1062 SourceRange Range; 1063 1064 public: 1065 CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, MSGuidDecl *Guid, 1066 SourceRange R) 1067 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), 1068 Guid(Guid), Range(R) { 1069 setDependence(computeDependence(this)); 1070 } 1071 1072 CXXUuidofExpr(QualType Ty, Expr *Operand, MSGuidDecl *Guid, SourceRange R) 1073 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand), 1074 Guid(Guid), Range(R) { 1075 setDependence(computeDependence(this)); 1076 } 1077 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. 1093 TypeSourceInfo *getTypeOperandSourceInfo() const { 1094 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)"); 1095 return Operand.get<TypeSourceInfo *>(); 1096 } 1097 Expr *getExprOperand() const { 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 1114 child_range children() { 1115 if (isTypeOperand()) 1116 return child_range(child_iterator(), child_iterator()); 1117 auto **begin = reinterpret_cast<Stmt **>(&Operand); 1118 return child_range(begin, begin + 1); 1119 } 1120 1121 const_child_range children() const { 1122 if (isTypeOperand()) 1123 return const_child_range(const_child_iterator(), const_child_iterator()); 1124 auto **begin = 1125 reinterpret_cast<Stmt **>(&const_cast<CXXUuidofExpr *>(this)->Operand); 1126 return const_child_range(begin, begin + 1); 1127 } 1128 }; 1129 1130 /// Represents the \c this expression in C++. 1131 /// 1132 /// This is a pointer to the object on which the current member function is 1133 /// executing (C++ [expr.prim]p3). Example: 1134 /// 1135 /// \code 1136 /// class Foo { 1137 /// public: 1138 /// void bar(); 1139 /// void test() { this->bar(); } 1140 /// }; 1141 /// \endcode 1142 class CXXThisExpr : public Expr { 1143 public: 1144 CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit) 1145 : Expr(CXXThisExprClass, Ty, VK_RValue, OK_Ordinary) { 1146 CXXThisExprBits.IsImplicit = IsImplicit; 1147 CXXThisExprBits.Loc = L; 1148 setDependence(computeDependence(this)); 1149 } 1150 1151 CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {} 1152 1153 SourceLocation getLocation() const { return CXXThisExprBits.Loc; } 1154 void setLocation(SourceLocation L) { CXXThisExprBits.Loc = L; } 1155 1156 SourceLocation getBeginLoc() const { return getLocation(); } 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 1167 child_range children() { 1168 return child_range(child_iterator(), child_iterator()); 1169 } 1170 1171 const_child_range children() const { 1172 return const_child_range(const_child_iterator(), const_child_iterator()); 1173 } 1174 }; 1175 1176 /// A C++ throw-expression (C++ [except.throw]). 1177 /// 1178 /// This handles 'throw' (for re-throwing the current exception) and 1179 /// 'throw' assignment-expression. When assignment-expression isn't 1180 /// present, Op will be null. 1181 class CXXThrowExpr : public Expr { 1182 friend class ASTStmtReader; 1183 1184 /// The optional expression in the throw statement. 1185 Stmt *Operand; 1186 1187 public: 1188 // \p Ty is the void type which is used as the result type of the 1189 // expression. The \p Loc is the location of the throw keyword. 1190 // \p Operand is the expression in the throw statement, and can be 1191 // null if not present. 1192 CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc, 1193 bool IsThrownVariableInScope) 1194 : Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary), Operand(Operand) { 1195 CXXThrowExprBits.ThrowLoc = Loc; 1196 CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope; 1197 setDependence(computeDependence(this)); 1198 } 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. 1211 bool isThrownVariableInScope() const { 1212 return CXXThrowExprBits.IsThrownVariableInScope; 1213 } 1214 1215 SourceLocation getBeginLoc() const { return getThrowLoc(); } 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 1227 child_range children() { 1228 return child_range(&Operand, Operand ? &Operand + 1 : &Operand); 1229 } 1230 1231 const_child_range children() const { 1232 return const_child_range(&Operand, Operand ? &Operand + 1 : &Operand); 1233 } 1234 }; 1235 1236 /// A default argument (C++ [dcl.fct.default]). 1237 /// 1238 /// This wraps up a function call argument that was created from the 1239 /// corresponding parameter's default argument, when the call did not 1240 /// explicitly supply arguments for all of the parameters. 1241 class CXXDefaultArgExpr final : public Expr { 1242 friend class ASTStmtReader; 1243 1244 /// The parameter whose default is being used. 1245 ParmVarDecl *Param; 1246 1247 /// The context where the default argument expression was used. 1248 DeclContext *UsedContext; 1249 1250 CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param, 1251 DeclContext *UsedContext) 1252 : Expr(SC, 1253 Param->hasUnparsedDefaultArg() 1254 ? Param->getType().getNonReferenceType() 1255 : Param->getDefaultArg()->getType(), 1256 Param->getDefaultArg()->getValueKind(), 1257 Param->getDefaultArg()->getObjectKind()), 1258 Param(Param), UsedContext(UsedContext) { 1259 CXXDefaultArgExprBits.Loc = Loc; 1260 setDependence(ExprDependence::None); 1261 } 1262 1263 public: 1264 CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {} 1265 1266 // \p Param is the parameter whose default argument is used by this 1267 // expression. 1268 static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc, 1269 ParmVarDecl *Param, 1270 DeclContext *UsedContext) { 1271 return new (C) 1272 CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext); 1273 } 1274 1275 // Retrieve the parameter that the argument was created from. 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. 1287 SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; } 1288 1289 /// Default argument expressions have no representation in the 1290 /// source, so they have an empty source range. 1291 SourceLocation getBeginLoc() const { return SourceLocation(); } 1292 SourceLocation getEndLoc() const { return SourceLocation(); } 1293 1294 SourceLocation getExprLoc() const { return getUsedLocation(); } 1295 1296 static bool classof(const Stmt *T) { 1297 return T->getStmtClass() == CXXDefaultArgExprClass; 1298 } 1299 1300 // Iterators 1301 child_range children() { 1302 return child_range(child_iterator(), child_iterator()); 1303 } 1304 1305 const_child_range children() const { 1306 return const_child_range(const_child_iterator(), const_child_iterator()); 1307 } 1308 }; 1309 1310 /// A use of a default initializer in a constructor or in aggregate 1311 /// initialization. 1312 /// 1313 /// This wraps a use of a C++ default initializer (technically, 1314 /// a brace-or-equal-initializer for a non-static data member) when it 1315 /// is implicitly used in a mem-initializer-list in a constructor 1316 /// (C++11 [class.base.init]p8) or in aggregate initialization 1317 /// (C++1y [dcl.init.aggr]p7). 1318 class CXXDefaultInitExpr : public Expr { 1319 friend class ASTReader; 1320 friend class ASTStmtReader; 1321 1322 /// The field whose default is being used. 1323 FieldDecl *Field; 1324 1325 /// The context where the default initializer expression was used. 1326 DeclContext *UsedContext; 1327 1328 CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc, 1329 FieldDecl *Field, QualType Ty, DeclContext *UsedContext); 1330 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. 1336 static CXXDefaultInitExpr *Create(const ASTContext &Ctx, SourceLocation Loc, 1337 FieldDecl *Field, DeclContext *UsedContext) { 1338 return new (Ctx) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(), UsedContext); 1339 } 1340 1341 /// Get the field whose initializer will be used. 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 } 1350 Expr *getExpr() { 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. 1360 SourceLocation getUsedLocation() const { return getBeginLoc(); } 1361 1362 SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; } 1363 SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; } 1364 1365 static bool classof(const Stmt *T) { 1366 return T->getStmtClass() == CXXDefaultInitExprClass; 1367 } 1368 1369 // Iterators 1370 child_range children() { 1371 return child_range(child_iterator(), child_iterator()); 1372 } 1373 1374 const_child_range children() const { 1375 return const_child_range(const_child_iterator(), const_child_iterator()); 1376 } 1377 }; 1378 1379 /// Represents a C++ temporary. 1380 class CXXTemporary { 1381 /// The destructor that needs to be called. 1382 const CXXDestructorDecl *Destructor; 1383 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_RValue, 1418 OK_Ordinary), 1419 Temp(temp), SubExpr(SubExpr) { 1420 setDependence(computeDependence(this)); 1421 } 1422 1423 public: 1424 CXXBindTemporaryExpr(EmptyShell Empty) 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 1454 const_child_range children() const { 1455 return const_child_range(&SubExpr, &SubExpr + 1); 1456 } 1457 }; 1458 1459 /// Represents a call to a C++ constructor. 1460 class CXXConstructExpr : public Expr { 1461 friend class ASTStmtReader; 1462 1463 public: 1464 enum ConstructionKind { 1465 CK_Complete, 1466 CK_NonVirtualBase, 1467 CK_VirtualBase, 1468 CK_Delegating 1469 }; 1470 1471 private: 1472 /// A pointer to the constructor which will be ultimately called. 1473 CXXConstructorDecl *Constructor; 1474 1475 SourceRange ParenOrBraceRange; 1476 1477 /// The number of arguments. 1478 unsigned NumArgs; 1479 1480 // We would like to stash the arguments of the constructor call after 1481 // CXXConstructExpr. However CXXConstructExpr is used as a base class of 1482 // CXXTemporaryObjectExpr which makes the use of llvm::TrailingObjects 1483 // impossible. 1484 // 1485 // Instead we manually stash the trailing object after the full object 1486 // containing CXXConstructExpr (that is either CXXConstructExpr or 1487 // CXXTemporaryObjectExpr). 1488 // 1489 // The trailing objects are: 1490 // 1491 // * An array of getNumArgs() "Stmt *" for the arguments of the 1492 // constructor call. 1493 1494 /// Return a pointer to the start of the trailing arguments. 1495 /// Defined just after CXXTemporaryObjectExpr. 1496 inline Stmt **getTrailingArgs(); 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 1534 SourceLocation getLocation() const { return CXXConstructExprBits.Loc; } 1535 void setLocation(SourceLocation Loc) { CXXConstructExprBits.Loc = Loc; } 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 } 1546 void setHadMultipleCandidates(bool V) { 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 } 1554 void setListInitialization(bool V) { 1555 CXXConstructExprBits.ListInitialization = V; 1556 } 1557 1558 /// Whether this constructor call was written as list-initialization, 1559 /// but was interpreted as forming a std::initializer_list<T> from the list 1560 /// and passing that as a single constructor argument. 1561 /// See C++11 [over.match.list]p1 bullet 1. 1562 bool isStdInitListInitialization() const { 1563 return CXXConstructExprBits.StdInitListInitialization; 1564 } 1565 void setStdInitListInitialization(bool V) { 1566 CXXConstructExprBits.StdInitListInitialization = V; 1567 } 1568 1569 /// Whether this construction first requires 1570 /// zero-initialization before the initializer is called. 1571 bool requiresZeroInitialization() const { 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). 1580 ConstructionKind getConstructionKind() const { 1581 return static_cast<ConstructionKind>(CXXConstructExprBits.ConstructionKind); 1582 } 1583 void setConstructionKind(ConstructionKind CK) { 1584 CXXConstructExprBits.ConstructionKind = CK; 1585 } 1586 1587 using arg_iterator = ExprIterator; 1588 using const_arg_iterator = ConstExprIterator; 1589 using arg_range = llvm::iterator_range<arg_iterator>; 1590 using const_arg_range = llvm::iterator_range<const_arg_iterator>; 1591 1592 arg_range arguments() { return arg_range(arg_begin(), arg_end()); } 1593 const_arg_range arguments() const { 1594 return const_arg_range(arg_begin(), arg_end()); 1595 } 1596 1597 arg_iterator arg_begin() { return getTrailingArgs(); } 1598 arg_iterator arg_end() { return arg_begin() + getNumArgs(); } 1599 const_arg_iterator arg_begin() const { return getTrailingArgs(); } 1600 const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); } 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 1637 child_range children() { 1638 return child_range(getTrailingArgs(), getTrailingArgs() + getNumArgs()); 1639 } 1640 1641 const_child_range children() const { 1642 auto Children = const_cast<CXXConstructExpr *>(this)->children(); 1643 return const_child_range(Children.begin(), Children.end()); 1644 } 1645 }; 1646 1647 /// Represents a call to an inherited base class constructor from an 1648 /// inheriting constructor. This call implicitly forwards the arguments from 1649 /// the enclosing context (an inheriting constructor) to the specified inherited 1650 /// base class constructor. 1651 class CXXInheritedCtorInitExpr : public Expr { 1652 private: 1653 CXXConstructorDecl *Constructor = nullptr; 1654 1655 /// The location of the using declaration. 1656 SourceLocation Loc; 1657 1658 /// Whether this is the construction of a virtual base. 1659 unsigned ConstructsVirtualBase : 1; 1660 1661 /// Whether the constructor is inherited from a virtual base class of the 1662 /// class that we construct. 1663 unsigned InheritedFromVirtualBase : 1; 1664 1665 public: 1666 friend class ASTStmtReader; 1667 1668 /// Construct a C++ inheriting construction expression. 1669 CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T, 1670 CXXConstructorDecl *Ctor, bool ConstructsVirtualBase, 1671 bool InheritedFromVirtualBase) 1672 : Expr(CXXInheritedCtorInitExprClass, T, VK_RValue, OK_Ordinary), 1673 Constructor(Ctor), Loc(Loc), 1674 ConstructsVirtualBase(ConstructsVirtualBase), 1675 InheritedFromVirtualBase(InheritedFromVirtualBase) { 1676 assert(!T->isDependentType()); 1677 setDependence(ExprDependence::None); 1678 } 1679 1680 /// Construct an empty C++ inheriting construction expression. 1681 explicit CXXInheritedCtorInitExpr(EmptyShell Empty) 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; } 1691 CXXConstructExpr::ConstructionKind getConstructionKind() const { 1692 return ConstructsVirtualBase ? CXXConstructExpr::CK_VirtualBase 1693 : CXXConstructExpr::CK_NonVirtualBase; 1694 } 1695 1696 /// Determine whether the inherited constructor is inherited from a 1697 /// virtual base of the object we construct. If so, we are not responsible 1698 /// for calling the inherited constructor (the complete object constructor 1699 /// does that), and so we don't need to pass any arguments. 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 1710 child_range children() { 1711 return child_range(child_iterator(), child_iterator()); 1712 } 1713 1714 const_child_range children() const { 1715 return const_child_range(const_child_iterator(), const_child_iterator()); 1716 } 1717 }; 1718 1719 /// Represents an explicit C++ type conversion that uses "functional" 1720 /// notation (C++ [expr.type.conv]). 1721 /// 1722 /// Example: 1723 /// \code 1724 /// x = int(0.5); 1725 /// \endcode 1726 class CXXFunctionalCastExpr final 1727 : public ExplicitCastExpr, 1728 private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *, 1729 FPOptionsOverride> { 1730 SourceLocation LParenLoc; 1731 SourceLocation RParenLoc; 1732 1733 CXXFunctionalCastExpr(QualType ty, ExprValueKind VK, 1734 TypeSourceInfo *writtenTy, CastKind kind, 1735 Expr *castExpr, unsigned pathSize, 1736 FPOptionsOverride FPO, SourceLocation lParenLoc, 1737 SourceLocation rParenLoc) 1738 : ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind, castExpr, 1739 pathSize, FPO.requiresTrailingStorage(), writtenTy), 1740 LParenLoc(lParenLoc), RParenLoc(rParenLoc) { 1741 if (hasStoredFPFeatures()) 1742 *getTrailingFPFeatures() = FPO; 1743 } 1744 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; 1756 friend TrailingObjects; 1757 1758 static CXXFunctionalCastExpr * 1759 Create(const ASTContext &Context, QualType T, ExprValueKind VK, 1760 TypeSourceInfo *Written, CastKind Kind, Expr *Op, 1761 const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc, 1762 SourceLocation RPLoc); 1763 static CXXFunctionalCastExpr * 1764 CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures); 1765 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 1797 class CXXTemporaryObjectExpr final : public CXXConstructExpr { 1798 friend class ASTStmtReader; 1799 1800 // CXXTemporaryObjectExpr has some trailing objects belonging 1801 // to CXXConstructExpr. See the comment inside CXXConstructExpr 1802 // for more details. 1803 1804 TypeSourceInfo *TSI; 1805 1806 CXXTemporaryObjectExpr(CXXConstructorDecl *Cons, QualType Ty, 1807 TypeSourceInfo *TSI, ArrayRef<Expr *> Args, 1808 SourceRange ParenOrBraceRange, 1809 bool HadMultipleCandidates, bool ListInitialization, 1810 bool StdInitListInitialization, 1811 bool ZeroInitialization); 1812 1813 CXXTemporaryObjectExpr(EmptyShell Empty, unsigned NumArgs); 1814 1815 public: 1816 static CXXTemporaryObjectExpr * 1817 Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, 1818 TypeSourceInfo *TSI, ArrayRef<Expr *> Args, 1819 SourceRange ParenOrBraceRange, bool HadMultipleCandidates, 1820 bool ListInitialization, bool StdInitListInitialization, 1821 bool ZeroInitialization); 1822 1823 static CXXTemporaryObjectExpr *CreateEmpty(const ASTContext &Ctx, 1824 unsigned NumArgs); 1825 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; 1903 friend TrailingObjects; 1904 1905 /// Construct a new lambda expression. 1906 static LambdaExpr * 1907 Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange, 1908 LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc, 1909 bool ExplicitParams, bool ExplicitResultType, 1910 ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace, 1911 bool ContainsUnexpandedParameterPack); 1912 1913 /// Construct a new lambda expression that will be deserialized from 1914 /// an external source. 1915 static LambdaExpr *CreateDeserialized(const ASTContext &C, 1916 unsigned NumCaptures); 1917 1918 /// Determine the default capture kind for this lambda. 1919 LambdaCaptureDefault getCaptureDefault() const { 1920 return static_cast<LambdaCaptureDefault>(LambdaExprBits.CaptureDefault); 1921 } 1922 1923 /// Retrieve the location of this lambda's capture-default, if any. 1924 SourceLocation getCaptureDefaultLoc() const { return CaptureDefaultLoc; } 1925 1926 /// Determine whether one of this lambda's captures is an init-capture. 1927 bool isInitCapture(const LambdaCapture *Capture) const; 1928 1929 /// An iterator that walks over the captures of the lambda, 1930 /// both implicit and explicit. 1931 using capture_iterator = const LambdaCapture *; 1932 1933 /// An iterator over a range of lambda captures. 1934 using capture_range = llvm::iterator_range<capture_iterator>; 1935 1936 /// Retrieve this lambda's captures. 1937 capture_range captures() const; 1938 1939 /// Retrieve an iterator pointing to the first lambda capture. 1940 capture_iterator capture_begin() const; 1941 1942 /// Retrieve an iterator pointing past the end of the 1943 /// sequence of lambda captures. 1944 capture_iterator capture_end() const; 1945 1946 /// Determine the number of captures in this lambda. 1947 unsigned capture_size() const { return LambdaExprBits.NumCaptures; } 1948 1949 /// Retrieve this lambda's explicit captures. 1950 capture_range explicit_captures() const; 1951 1952 /// Retrieve an iterator pointing to the first explicit 1953 /// lambda capture. 1954 capture_iterator explicit_capture_begin() const; 1955 1956 /// Retrieve an iterator pointing past the end of the sequence of 1957 /// explicit lambda captures. 1958 capture_iterator explicit_capture_end() const; 1959 1960 /// Retrieve this lambda's implicit captures. 1961 capture_range implicit_captures() const; 1962 1963 /// Retrieve an iterator pointing to the first implicit 1964 /// lambda capture. 1965 capture_iterator implicit_capture_begin() const; 1966 1967 /// Retrieve an iterator pointing past the end of the sequence of 1968 /// implicit lambda captures. 1969 capture_iterator implicit_capture_end() const; 1970 1971 /// Iterator that walks over the capture initialization 1972 /// arguments. 1973 using capture_init_iterator = Expr **; 1974 1975 /// Const iterator that walks over the capture initialization 1976 /// arguments. 1977 /// FIXME: This interface is prone to being used incorrectly. 1978 using const_capture_init_iterator = Expr *const *; 1979 1980 /// Retrieve the initialization expressions for this lambda's captures. 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). 1992 capture_init_iterator capture_init_begin() { 1993 return reinterpret_cast<Expr **>(getStoredStmts()); 1994 } 1995 1996 /// Retrieve the first initialization argument for this 1997 /// lambda expression (which initializes the first capture field). 1998 const_capture_init_iterator capture_init_begin() const { 1999 return reinterpret_cast<Expr *const *>(getStoredStmts()); 2000 } 2001 2002 /// Retrieve the iterator pointing one past the last 2003 /// initialization argument for this lambda expression. 2004 capture_init_iterator capture_init_end() { 2005 return capture_init_begin() + capture_size(); 2006 } 2007 2008 /// Retrieve the iterator pointing one past the last 2009 /// initialization argument for this lambda expression. 2010 const_capture_init_iterator capture_init_end() const { 2011 return capture_init_begin() + capture_size(); 2012 } 2013 2014 /// Retrieve the source range covering the lambda introducer, 2015 /// which contains the explicit capture list surrounded by square 2016 /// brackets ([...]). 2017 SourceRange getIntroducerRange() const { return IntroducerRange; } 2018 2019 /// Retrieve the class that corresponds to the lambda. 2020 /// 2021 /// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the 2022 /// captures in its fields and provides the various operations permitted 2023 /// on a lambda (copying, calling). 2024 CXXRecordDecl *getLambdaClass() const; 2025 2026 /// Retrieve the function call operator associated with this 2027 /// lambda expression. 2028 CXXMethodDecl *getCallOperator() const; 2029 2030 /// Retrieve the function template call operator associated with this 2031 /// lambda expression. 2032 FunctionTemplateDecl *getDependentCallOperator() const; 2033 2034 /// If this is a generic lambda expression, retrieve the template 2035 /// parameter list associated with it, or else return null. 2036 TemplateParameterList *getTemplateParameterList() const; 2037 2038 /// Get the template parameters were explicitly specified (as opposed to being 2039 /// invented by use of an auto parameter). 2040 ArrayRef<NamedDecl *> getExplicitTemplateParameters() const; 2041 2042 /// Get the trailing requires clause, if any. 2043 Expr *getTrailingRequiresClause() const; 2044 2045 /// Whether this is a generic lambda. 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; 2058 CompoundStmt *getCompoundStmtBody() { 2059 const auto *ConstThis = this; 2060 return const_cast<CompoundStmt *>(ConstThis->getCompoundStmtBody()); 2061 } 2062 2063 /// Determine whether the lambda is mutable, meaning that any 2064 /// captures values can be modified. 2065 bool isMutable() const; 2066 2067 /// Determine whether this lambda has an explicit parameter 2068 /// list vs. an implicit (empty) parameter list. 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. 2087 child_range children(); 2088 const_child_range children() const; 2089 }; 2090 2091 /// An expression "T()" which creates a value-initialized rvalue of type 2092 /// T, which is a non-class type. See (C++98 [5.2.3p2]). 2093 class CXXScalarValueInitExpr : public Expr { 2094 friend class ASTStmtReader; 2095 2096 TypeSourceInfo *TypeInfo; 2097 2098 public: 2099 /// Create an explicitly-written scalar-value initialization 2100 /// expression. 2101 CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo, 2102 SourceLocation RParenLoc) 2103 : Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary), 2104 TypeInfo(TypeInfo) { 2105 CXXScalarValueInitExprBits.RParenLoc = RParenLoc; 2106 setDependence(computeDependence(this)); 2107 } 2108 2109 explicit CXXScalarValueInitExpr(EmptyShell Shell) 2110 : Expr(CXXScalarValueInitExprClass, Shell) {} 2111 2112 TypeSourceInfo *getTypeSourceInfo() const { 2113 return TypeInfo; 2114 } 2115 2116 SourceLocation getRParenLoc() const { 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 2128 child_range children() { 2129 return child_range(child_iterator(), child_iterator()); 2130 } 2131 2132 const_child_range children() const { 2133 return const_child_range(const_child_iterator(), const_child_iterator()); 2134 } 2135 }; 2136 2137 /// Represents a new-expression for memory allocation and constructor 2138 /// calls, e.g: "new CXXNewExpr(foo)". 2139 class CXXNewExpr final 2140 : public Expr, 2141 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> { 2142 friend class ASTStmtReader; 2143 friend class ASTStmtWriter; 2144 friend TrailingObjects; 2145 2146 /// Points to the allocation function used. 2147 FunctionDecl *OperatorNew; 2148 2149 /// Points to the deallocation function used in case of error. May be null. 2150 FunctionDecl *OperatorDelete; 2151 2152 /// The allocated type-source information, as written in the source. 2153 TypeSourceInfo *AllocatedTypeInfo; 2154 2155 /// Range of the entire new expression. 2156 SourceRange Range; 2157 2158 /// Source-range of a paren-delimited initializer. 2159 SourceRange DirectInitRange; 2160 2161 // CXXNewExpr is followed by several optional trailing objects. 2162 // They are in order: 2163 // 2164 // * An optional "Stmt *" for the array size expression. 2165 // Present if and ony if isArray(). 2166 // 2167 // * An optional "Stmt *" for the init expression. 2168 // Present if and only if hasInitializer(). 2169 // 2170 // * An array of getNumPlacementArgs() "Stmt *" for the placement new 2171 // arguments, if any. 2172 // 2173 // * An optional SourceRange for the range covering the parenthesized type-id 2174 // if the allocated type was expressed as a parenthesized type-id. 2175 // Present if and only if isParenTypeId(). 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: 2191 enum InitializationStyle { 2192 /// New-expression has no initializer as written. 2193 NoInit, 2194 2195 /// New-expression has a C++98 paren-delimited initializer. 2196 CallInit, 2197 2198 /// New-expression has a C++11 list-initializer. 2199 ListInit 2200 }; 2201 2202 private: 2203 /// Build a c++ new expression. 2204 CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew, 2205 FunctionDecl *OperatorDelete, bool ShouldPassAlignment, 2206 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs, 2207 SourceRange TypeIdParens, Optional<Expr *> ArraySize, 2208 InitializationStyle InitializationStyle, Expr *Initializer, 2209 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, 2210 SourceRange DirectInitRange); 2211 2212 /// Build an empty c++ new expression. 2213 CXXNewExpr(EmptyShell Empty, bool IsArray, unsigned NumPlacementArgs, 2214 bool IsParenTypeId); 2215 2216 public: 2217 /// Create a c++ new expression. 2218 static CXXNewExpr * 2219 Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew, 2220 FunctionDecl *OperatorDelete, bool ShouldPassAlignment, 2221 bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs, 2222 SourceRange TypeIdParens, Optional<Expr *> ArraySize, 2223 InitializationStyle InitializationStyle, Expr *Initializer, 2224 QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range, 2225 SourceRange DirectInitRange); 2226 2227 /// Create an empty c++ new expression. 2228 static CXXNewExpr *CreateEmpty(const ASTContext &Ctx, bool IsArray, 2229 bool HasInit, unsigned NumPlacementArgs, 2230 bool IsParenTypeId); 2231 2232 QualType getAllocatedType() const { 2233 return getType()->castAs<PointerType>()->getPointeeType(); 2234 } 2235 2236 TypeSourceInfo *getAllocatedTypeSourceInfo() const { 2237 return AllocatedTypeInfo; 2238 } 2239 2240 /// True if the allocation result needs to be null-checked. 2241 /// 2242 /// C++11 [expr.new]p13: 2243 /// If the allocation function returns null, initialization shall 2244 /// not be done, the deallocation function shall not be called, 2245 /// and the value of the new-expression shall be null. 2246 /// 2247 /// C++ DR1748: 2248 /// If the allocation function is a reserved placement allocation 2249 /// function that returns null, the behavior is undefined. 2250 /// 2251 /// An allocation function is not allowed to return null unless it 2252 /// has a non-throwing exception-specification. The '03 rule is 2253 /// identical except that the definition of a non-throwing 2254 /// exception specification is just "is it throw()?". 2255 bool shouldNullCheckAllocation() const; 2256 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 2264 Optional<Expr *> getArraySize() { 2265 if (!isArray()) 2266 return None; 2267 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]); 2268 } 2269 Optional<const Expr *> getArraySize() const { 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 2279 Expr **getPlacementArgs() { 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; } 2293 SourceRange getTypeIdParens() const { 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. 2306 InitializationStyle getInitializationStyle() const { 2307 if (CXXNewExprBits.StoredInitializationStyle == 0) 2308 return NoInit; 2309 return static_cast<InitializationStyle>( 2310 CXXNewExprBits.StoredInitializationStyle - 1); 2311 } 2312 2313 /// The initializer of this new-expression. 2314 Expr *getInitializer() { 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. 2326 const CXXConstructExpr *getConstructExpr() const { 2327 return dyn_cast_or_null<CXXConstructExpr>(getInitializer()); 2328 } 2329 2330 /// Indicates whether the required alignment should be implicitly passed to 2331 /// the allocation function. 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. 2337 bool doesUsualArrayDeleteWantSize() const { 2338 return CXXNewExprBits.UsualArrayDeleteWantsSize; 2339 } 2340 2341 using arg_iterator = ExprIterator; 2342 using const_arg_iterator = ConstExprIterator; 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 2352 arg_iterator placement_arg_begin() { 2353 return getTrailingObjects<Stmt *>() + placementNewArgsOffset(); 2354 } 2355 arg_iterator placement_arg_end() { 2356 return placement_arg_begin() + getNumPlacementArgs(); 2357 } 2358 const_arg_iterator placement_arg_begin() const { 2359 return getTrailingObjects<Stmt *>() + placementNewArgsOffset(); 2360 } 2361 const_arg_iterator placement_arg_end() const { 2362 return placement_arg_begin() + getNumPlacementArgs(); 2363 } 2364 2365 using raw_arg_iterator = Stmt **; 2366 2367 raw_arg_iterator raw_arg_begin() { return getTrailingObjects<Stmt *>(); } 2368 raw_arg_iterator raw_arg_end() { 2369 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>()); 2370 } 2371 const_arg_iterator raw_arg_begin() const { 2372 return getTrailingObjects<Stmt *>(); 2373 } 2374 const_arg_iterator raw_arg_end() const { 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 2389 child_range children() { return child_range(raw_arg_begin(), raw_arg_end()); } 2390 2391 const_child_range children() const { 2392 return const_child_range(const_cast<CXXNewExpr *>(this)->children()); 2393 } 2394 }; 2395 2396 /// Represents a \c delete expression for memory deallocation and 2397 /// destructor calls, e.g. "delete[] pArray". 2398 class CXXDeleteExpr : public Expr { 2399 friend class ASTStmtReader; 2400 2401 /// Points to the operator delete overload that is used. Could be a member. 2402 FunctionDecl *OperatorDelete = nullptr; 2403 2404 /// The pointer expression to be deleted. 2405 Stmt *Argument = nullptr; 2406 2407 public: 2408 CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm, 2409 bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize, 2410 FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc) 2411 : Expr(CXXDeleteExprClass, Ty, VK_RValue, OK_Ordinary), 2412 OperatorDelete(OperatorDelete), Argument(Arg) { 2413 CXXDeleteExprBits.GlobalDelete = GlobalDelete; 2414 CXXDeleteExprBits.ArrayForm = ArrayForm; 2415 CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten; 2416 CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize; 2417 CXXDeleteExprBits.Loc = Loc; 2418 setDependence(computeDependence(this)); 2419 } 2420 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. 2433 bool doesUsualArrayDeleteWantSize() const { 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 2448 SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; } 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 2460 const_child_range children() const { 2461 return const_child_range(&Argument, &Argument + 1); 2462 } 2463 }; 2464 2465 /// Stores the type being destroyed by a pseudo-destructor expression. 2466 class PseudoDestructorTypeStorage { 2467 /// Either the type source information or the name of the type, if 2468 /// it couldn't be resolved due to type-dependence. 2469 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type; 2470 2471 /// The starting source location of the pseudo-destructor type. 2472 SourceLocation Location; 2473 2474 public: 2475 PseudoDestructorTypeStorage() = default; 2476 2477 PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc) 2478 : Type(II), Location(Loc) {} 2479 2480 PseudoDestructorTypeStorage(TypeSourceInfo *Info); 2481 2482 TypeSourceInfo *getTypeSourceInfo() const { 2483 return Type.dyn_cast<TypeSourceInfo *>(); 2484 } 2485 2486 IdentifierInfo *getIdentifier() const { 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. 2517 class CXXPseudoDestructorExpr : public Expr { 2518 friend class ASTStmtReader; 2519 2520 /// The base expression (that is being destroyed). 2521 Stmt *Base = nullptr; 2522 2523 /// Whether the operator was an arrow ('->'); otherwise, it was a 2524 /// period ('.'). 2525 bool IsArrow : 1; 2526 2527 /// The location of the '.' or '->' operator. 2528 SourceLocation OperatorLoc; 2529 2530 /// The nested-name-specifier that follows the operator, if present. 2531 NestedNameSpecifierLoc QualifierLoc; 2532 2533 /// The type that precedes the '::' in a qualified pseudo-destructor 2534 /// expression. 2535 TypeSourceInfo *ScopeType = nullptr; 2536 2537 /// The location of the '::' in a qualified pseudo-destructor 2538 /// expression. 2539 SourceLocation ColonColonLoc; 2540 2541 /// The location of the '~'. 2542 SourceLocation TildeLoc; 2543 2544 /// The type being destroyed, or its name if we were unable to 2545 /// resolve the name. 2546 PseudoDestructorTypeStorage DestroyedType; 2547 2548 public: 2549 CXXPseudoDestructorExpr(const ASTContext &Context, 2550 Expr *Base, bool isArrow, SourceLocation OperatorLoc, 2551 NestedNameSpecifierLoc QualifierLoc, 2552 TypeSourceInfo *ScopeType, 2553 SourceLocation ColonColonLoc, 2554 SourceLocation TildeLoc, 2555 PseudoDestructorTypeStorage DestroyedType); 2556 2557 explicit CXXPseudoDestructorExpr(EmptyShell Shell) 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. 2574 NestedNameSpecifier *getQualifier() const { 2575 return QualifierLoc.getNestedNameSpecifier(); 2576 } 2577 2578 /// Determine whether this pseudo-destructor expression was written 2579 /// using an '->' (otherwise, it used a '.'). 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. 2610 TypeSourceInfo *getDestroyedTypeInfo() const { 2611 return DestroyedType.getTypeSourceInfo(); 2612 } 2613 2614 /// In a dependent pseudo-destructor expression for which we do not 2615 /// have full type information on the destroyed type, provides the name 2616 /// of the destroyed type. 2617 IdentifierInfo *getDestroyedTypeIdentifier() const { 2618 return DestroyedType.getIdentifier(); 2619 } 2620 2621 /// Retrieve the type being destroyed. 2622 QualType getDestroyedType() const; 2623 2624 /// Retrieve the starting location of the type being destroyed. 2625 SourceLocation getDestroyedTypeLoc() const { 2626 return DestroyedType.getLocation(); 2627 } 2628 2629 /// Set the name of destroyed type for a dependent pseudo-destructor 2630 /// expression. 2631 void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) { 2632 DestroyedType = PseudoDestructorTypeStorage(II, Loc); 2633 } 2634 2635 /// Set the destroyed type. 2636 void setDestroyedType(TypeSourceInfo *Info) { 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 2652 const_child_range children() const { 2653 return const_child_range(&Base, &Base + 1); 2654 } 2655 }; 2656 2657 /// A type trait used in the implementation of various C++11 and 2658 /// Library TR1 trait templates. 2659 /// 2660 /// \code 2661 /// __is_pod(int) == true 2662 /// __is_enum(std::string) == false 2663 /// __is_trivially_constructible(vector<int>, int*, int*) 2664 /// \endcode 2665 class TypeTraitExpr final 2666 : public Expr, 2667 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> { 2668 /// The location of the type trait keyword. 2669 SourceLocation Loc; 2670 2671 /// The location of the closing parenthesis. 2672 SourceLocation RParenLoc; 2673 2674 // Note: The TypeSourceInfos for the arguments are allocated after the 2675 // TypeTraitExpr. 2676 2677 TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 2678 ArrayRef<TypeSourceInfo *> Args, 2679 SourceLocation RParenLoc, 2680 bool Value); 2681 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; 2691 friend TrailingObjects; 2692 2693 /// Create a new type trait expression. 2694 static TypeTraitExpr *Create(const ASTContext &C, QualType T, 2695 SourceLocation Loc, TypeTrait Kind, 2696 ArrayRef<TypeSourceInfo *> Args, 2697 SourceLocation RParenLoc, 2698 bool Value); 2699 2700 static TypeTraitExpr *CreateDeserialized(const ASTContext &C, 2701 unsigned NumArgs); 2702 2703 /// Determine which type trait this expression uses. 2704 TypeTrait getTrait() const { 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. 2723 ArrayRef<TypeSourceInfo *> getArgs() const { 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 2736 child_range children() { 2737 return child_range(child_iterator(), child_iterator()); 2738 } 2739 2740 const_child_range children() const { 2741 return const_child_range(const_child_iterator(), const_child_iterator()); 2742 } 2743 }; 2744 2745 /// An Embarcadero array type trait, as used in the implementation of 2746 /// __array_rank and __array_extent. 2747 /// 2748 /// Example: 2749 /// \code 2750 /// __array_rank(int[10][20]) == 2 2751 /// __array_extent(int, 1) == 20 2752 /// \endcode 2753 class ArrayTypeTraitExpr : public Expr { 2754 /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned. 2755 unsigned ATT : 2; 2756 2757 /// The value of the type trait. Unspecified if dependent. 2758 uint64_t Value = 0; 2759 2760 /// The array dimension being queried, or -1 if not used. 2761 Expr *Dimension; 2762 2763 /// The location of the type trait keyword. 2764 SourceLocation Loc; 2765 2766 /// The location of the closing paren. 2767 SourceLocation RParen; 2768 2769 /// The type being queried. 2770 TypeSourceInfo *QueriedType = nullptr; 2771 2772 public: 2773 friend class ASTStmtReader; 2774 2775 ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att, 2776 TypeSourceInfo *queried, uint64_t value, Expr *dimension, 2777 SourceLocation rparen, QualType ty) 2778 : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary), ATT(att), 2779 Value(value), Dimension(dimension), Loc(loc), RParen(rparen), 2780 QueriedType(queried) { 2781 assert(att <= ATT_Last && "invalid enum value!"); 2782 assert(static_cast<unsigned>(att) == ATT && "ATT overflow!"); 2783 setDependence(computeDependence(this)); 2784 } 2785 2786 explicit ArrayTypeTraitExpr(EmptyShell Empty) 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 2807 child_range children() { 2808 return child_range(child_iterator(), child_iterator()); 2809 } 2810 2811 const_child_range children() const { 2812 return const_child_range(const_child_iterator(), const_child_iterator()); 2813 } 2814 }; 2815 2816 /// An expression trait intrinsic. 2817 /// 2818 /// Example: 2819 /// \code 2820 /// __is_lvalue_expr(std::cout) == true 2821 /// __is_lvalue_expr(1) == false 2822 /// \endcode 2823 class ExpressionTraitExpr : public Expr { 2824 /// The trait. A ExpressionTrait enum in MSVC compatible unsigned. 2825 unsigned ET : 31; 2826 2827 /// The value of the type trait. Unspecified if dependent. 2828 unsigned Value : 1; 2829 2830 /// The location of the type trait keyword. 2831 SourceLocation Loc; 2832 2833 /// The location of the closing paren. 2834 SourceLocation RParen; 2835 2836 /// The expression being queried. 2837 Expr* QueriedExpression = nullptr; 2838 2839 public: 2840 friend class ASTStmtReader; 2841 2842 ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried, 2843 bool value, SourceLocation rparen, QualType resultType) 2844 : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary), 2845 ET(et), Value(value), Loc(loc), RParen(rparen), 2846 QueriedExpression(queried) { 2847 assert(et <= ET_Last && "invalid enum value!"); 2848 assert(static_cast<unsigned>(et) == ET && "ET overflow!"); 2849 setDependence(computeDependence(this)); 2850 } 2851 2852 explicit ExpressionTraitExpr(EmptyShell Empty) 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 2869 child_range children() { 2870 return child_range(child_iterator(), child_iterator()); 2871 } 2872 2873 const_child_range children() const { 2874 return const_child_range(const_child_iterator(), const_child_iterator()); 2875 } 2876 }; 2877 2878 /// A reference to an overloaded function set, either an 2879 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr. 2880 class OverloadExpr : public Expr { 2881 friend class ASTStmtReader; 2882 friend class ASTStmtWriter; 2883 2884 /// The common name of these declarations. 2885 DeclarationNameInfo NameInfo; 2886 2887 /// The nested-name-specifier that qualifies the name, if any. 2888 NestedNameSpecifierLoc QualifierLoc; 2889 2890 protected: 2891 OverloadExpr(StmtClass SC, const ASTContext &Context, 2892 NestedNameSpecifierLoc QualifierLoc, 2893 SourceLocation TemplateKWLoc, 2894 const DeclarationNameInfo &NameInfo, 2895 const TemplateArgumentListInfo *TemplateArgs, 2896 UnresolvedSetIterator Begin, UnresolvedSetIterator End, 2897 bool KnownDependent, bool KnownInstantiationDependent, 2898 bool KnownContainsUnexpandedParameterPack); 2899 2900 OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults, 2901 bool HasTemplateKWAndArgsInfo); 2902 2903 /// Return the results. Defined after UnresolvedMemberExpr. 2904 inline DeclAccessPair *getTrailingResults(); 2905 const DeclAccessPair *getTrailingResults() const { 2906 return const_cast<OverloadExpr *>(this)->getTrailingResults(); 2907 } 2908 2909 /// Return the optional template keyword and arguments info. 2910 /// Defined after UnresolvedMemberExpr. 2911 inline ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo(); 2912 const ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo() const { 2913 return const_cast<OverloadExpr *>(this) 2914 ->getTrailingASTTemplateKWAndArgsInfo(); 2915 } 2916 2917 /// Return the optional template arguments. Defined after 2918 /// UnresolvedMemberExpr. 2919 inline TemplateArgumentLoc *getTrailingTemplateArgumentLoc(); 2920 const TemplateArgumentLoc *getTrailingTemplateArgumentLoc() const { 2921 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc(); 2922 } 2923 2924 bool hasTemplateKWAndArgsInfo() const { 2925 return OverloadExprBits.HasTemplateKWAndArgsInfo; 2926 } 2927 2928 public: 2929 struct FindResult { 2930 OverloadExpr *Expression; 2931 bool IsAddressOfOperand; 2932 bool HasFormOfMemberPointer; 2933 }; 2934 2935 /// Finds the overloaded expression in the given expression \p E of 2936 /// OverloadTy. 2937 /// 2938 /// \return the expression (which must be there) and true if it has 2939 /// the particular form of a member pointer expression 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(); 2966 const CXXRecordDecl *getNamingClass() const { 2967 return const_cast<OverloadExpr *>(this)->getNamingClass(); 2968 } 2969 2970 using decls_iterator = UnresolvedSetImpl::iterator; 2971 2972 decls_iterator decls_begin() const { 2973 return UnresolvedSetIterator(getTrailingResults()); 2974 } 2975 decls_iterator decls_end() const { 2976 return UnresolvedSetIterator(getTrailingResults() + getNumDecls()); 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. 2995 NestedNameSpecifier *getQualifier() const { 2996 return QualifierLoc.getNestedNameSpecifier(); 2997 } 2998 2999 /// Fetches the nested-name qualifier with source-location 3000 /// information, if one was given. 3001 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 3002 3003 /// Retrieve the location of the template keyword preceding 3004 /// this name, if any. 3005 SourceLocation getTemplateKeywordLoc() const { 3006 if (!hasTemplateKWAndArgsInfo()) 3007 return SourceLocation(); 3008 return getTrailingASTTemplateKWAndArgsInfo()->TemplateKWLoc; 3009 } 3010 3011 /// Retrieve the location of the left angle bracket starting the 3012 /// explicit template argument list following the name, if any. 3013 SourceLocation getLAngleLoc() const { 3014 if (!hasTemplateKWAndArgsInfo()) 3015 return SourceLocation(); 3016 return getTrailingASTTemplateKWAndArgsInfo()->LAngleLoc; 3017 } 3018 3019 /// Retrieve the location of the right angle bracket ending the 3020 /// explicit template argument list following the name, if any. 3021 SourceLocation getRAngleLoc() const { 3022 if (!hasTemplateKWAndArgsInfo()) 3023 return SourceLocation(); 3024 return getTrailingASTTemplateKWAndArgsInfo()->RAngleLoc; 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 3033 TemplateArgumentLoc const *getTemplateArgs() const { 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 3043 return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs; 3044 } 3045 3046 ArrayRef<TemplateArgumentLoc> template_arguments() const { 3047 return {getTemplateArgs(), getNumTemplateArgs()}; 3048 } 3049 3050 /// Copies the template arguments into the given structure. 3051 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3052 if (hasExplicitTemplateArgs()) 3053 getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List); 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. 3073 class UnresolvedLookupExpr final 3074 : public OverloadExpr, 3075 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair, 3076 ASTTemplateKWAndArgsInfo, 3077 TemplateArgumentLoc> { 3078 friend class ASTStmtReader; 3079 friend class OverloadExpr; 3080 friend TrailingObjects; 3081 3082 /// The naming class (C++ [class.access.base]p5) of the lookup, if 3083 /// any. This can generally be recalculated from the context chain, 3084 /// but that can be fairly expensive for unqualified lookups. 3085 CXXRecordDecl *NamingClass; 3086 3087 // UnresolvedLookupExpr is followed by several trailing objects. 3088 // They are in order: 3089 // 3090 // * An array of getNumResults() DeclAccessPair for the results. These are 3091 // undesugared, which is to say, they may include UsingShadowDecls. 3092 // Access is relative to the naming class. 3093 // 3094 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3095 // template keyword and arguments. Present if and only if 3096 // hasTemplateKWAndArgsInfo(). 3097 // 3098 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing 3099 // location information for the explicitly specified template arguments. 3100 3101 UnresolvedLookupExpr(const ASTContext &Context, CXXRecordDecl *NamingClass, 3102 NestedNameSpecifierLoc QualifierLoc, 3103 SourceLocation TemplateKWLoc, 3104 const DeclarationNameInfo &NameInfo, bool RequiresADL, 3105 bool Overloaded, 3106 const TemplateArgumentListInfo *TemplateArgs, 3107 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3108 3109 UnresolvedLookupExpr(EmptyShell Empty, unsigned NumResults, 3110 bool HasTemplateKWAndArgsInfo); 3111 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 { 3153 if (NestedNameSpecifierLoc l = getQualifierLoc()) 3154 return l.getBeginLoc(); 3155 return getNameInfo().getBeginLoc(); 3156 } 3157 3158 SourceLocation getEndLoc() const LLVM_READONLY { 3159 if (hasExplicitTemplateArgs()) 3160 return getRAngleLoc(); 3161 return getNameInfo().getEndLoc(); 3162 } 3163 3164 child_range children() { 3165 return child_range(child_iterator(), child_iterator()); 3166 } 3167 3168 const_child_range children() const { 3169 return const_child_range(const_child_iterator(), const_child_iterator()); 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. 3191 class DependentScopeDeclRefExpr final 3192 : public Expr, 3193 private llvm::TrailingObjects<DependentScopeDeclRefExpr, 3194 ASTTemplateKWAndArgsInfo, 3195 TemplateArgumentLoc> { 3196 friend class ASTStmtReader; 3197 friend class ASTStmtWriter; 3198 friend TrailingObjects; 3199 3200 /// The nested-name-specifier that qualifies this unresolved 3201 /// declaration name. 3202 NestedNameSpecifierLoc QualifierLoc; 3203 3204 /// The name of the entity we will be referencing. 3205 DeclarationNameInfo NameInfo; 3206 3207 DependentScopeDeclRefExpr(QualType Ty, NestedNameSpecifierLoc QualifierLoc, 3208 SourceLocation TemplateKWLoc, 3209 const DeclarationNameInfo &NameInfo, 3210 const TemplateArgumentListInfo *Args); 3211 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. 3247 NestedNameSpecifier *getQualifier() const { 3248 return QualifierLoc.getNestedNameSpecifier(); 3249 } 3250 3251 /// Retrieve the location of the template keyword preceding 3252 /// this name, if any. 3253 SourceLocation getTemplateKeywordLoc() const { 3254 if (!hasTemplateKWAndArgsInfo()) 3255 return SourceLocation(); 3256 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; 3257 } 3258 3259 /// Retrieve the location of the left angle bracket starting the 3260 /// explicit template argument list following the name, if any. 3261 SourceLocation getLAngleLoc() const { 3262 if (!hasTemplateKWAndArgsInfo()) 3263 return SourceLocation(); 3264 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; 3265 } 3266 3267 /// Retrieve the location of the right angle bracket ending the 3268 /// explicit template argument list following the name, if any. 3269 SourceLocation getRAngleLoc() const { 3270 if (!hasTemplateKWAndArgsInfo()) 3271 return SourceLocation(); 3272 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; 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. 3283 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3284 if (hasExplicitTemplateArgs()) 3285 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( 3286 getTrailingObjects<TemplateArgumentLoc>(), List); 3287 } 3288 3289 TemplateArgumentLoc const *getTemplateArgs() const { 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 3303 ArrayRef<TemplateArgumentLoc> template_arguments() const { 3304 return {getTemplateArgs(), getNumTemplateArgs()}; 3305 } 3306 3307 /// Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr, 3308 /// and differs from getLocation().getStart(). 3309 SourceLocation getBeginLoc() const LLVM_READONLY { 3310 return QualifierLoc.getBeginLoc(); 3311 } 3312 3313 SourceLocation getEndLoc() const LLVM_READONLY { 3314 if (hasExplicitTemplateArgs()) 3315 return getRAngleLoc(); 3316 return getLocation(); 3317 } 3318 3319 static bool classof(const Stmt *T) { 3320 return T->getStmtClass() == DependentScopeDeclRefExprClass; 3321 } 3322 3323 child_range children() { 3324 return child_range(child_iterator(), child_iterator()); 3325 } 3326 3327 const_child_range children() const { 3328 return const_child_range(const_child_iterator(), const_child_iterator()); 3329 } 3330 }; 3331 3332 /// Represents an expression -- generally a full-expression -- that 3333 /// introduces cleanups to be run at the end of the sub-expression's 3334 /// evaluation. The most common source of expression-introduced 3335 /// cleanups is temporary objects in C++, but several other kinds of 3336 /// expressions can create cleanups, including basically every 3337 /// call in ARC that returns an Objective-C pointer. 3338 /// 3339 /// This expression also tracks whether the sub-expression contains a 3340 /// potentially-evaluated block literal. The lifetime of a block 3341 /// literal is the extent of the enclosing scope. 3342 class ExprWithCleanups final 3343 : public FullExpr, 3344 private llvm::TrailingObjects< 3345 ExprWithCleanups, 3346 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> { 3347 public: 3348 /// The type of objects that are kept in the cleanup. 3349 /// It's useful to remember the set of blocks and block-scoped compound 3350 /// literals; we could also remember the set of temporaries, but there's 3351 /// currently no need. 3352 using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>; 3353 3354 private: 3355 friend class ASTStmtReader; 3356 friend TrailingObjects; 3357 3358 ExprWithCleanups(EmptyShell, unsigned NumObjects); 3359 ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects, 3360 ArrayRef<CleanupObject> Objects); 3361 3362 public: 3363 static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty, 3364 unsigned numObjects); 3365 3366 static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr, 3367 bool CleanupsHaveSideEffects, 3368 ArrayRef<CleanupObject> objects); 3369 3370 ArrayRef<CleanupObject> getObjects() const { 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 3382 bool cleanupsHaveSideEffects() const { 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 3400 child_range children() { return child_range(&SubExpr, &SubExpr + 1); } 3401 3402 const_child_range children() const { 3403 return const_child_range(&SubExpr, &SubExpr + 1); 3404 } 3405 }; 3406 3407 /// Describes an explicit type conversion that uses functional 3408 /// notion but could not be resolved because one or more arguments are 3409 /// type-dependent. 3410 /// 3411 /// The explicit type conversions expressed by 3412 /// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>, 3413 /// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and 3414 /// either \c T is a dependent type or one or more of the <tt>a</tt>'s is 3415 /// type-dependent. For example, this would occur in a template such 3416 /// as: 3417 /// 3418 /// \code 3419 /// template<typename T, typename A1> 3420 /// inline T make_a(const A1& a1) { 3421 /// return T(a1); 3422 /// } 3423 /// \endcode 3424 /// 3425 /// When the returned expression is instantiated, it may resolve to a 3426 /// constructor call, conversion function call, or some kind of type 3427 /// conversion. 3428 class CXXUnresolvedConstructExpr final 3429 : public Expr, 3430 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> { 3431 friend class ASTStmtReader; 3432 friend TrailingObjects; 3433 3434 /// The type being constructed. 3435 TypeSourceInfo *TSI; 3436 3437 /// The location of the left parentheses ('('). 3438 SourceLocation LParenLoc; 3439 3440 /// The location of the right parentheses (')'). 3441 SourceLocation RParenLoc; 3442 3443 CXXUnresolvedConstructExpr(QualType T, TypeSourceInfo *TSI, 3444 SourceLocation LParenLoc, ArrayRef<Expr *> Args, 3445 SourceLocation RParenLoc); 3446 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 *>(); } 3492 arg_iterator arg_end() { return arg_begin() + getNumArgs(); } 3493 arg_range arguments() { return arg_range(arg_begin(), arg_end()); } 3494 3495 using const_arg_iterator = const Expr* const *; 3496 using const_arg_range = llvm::iterator_range<const_arg_iterator>; 3497 3498 const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); } 3499 const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); } 3500 const_arg_range arguments() const { 3501 return const_arg_range(arg_begin(), arg_end()); 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 3531 child_range children() { 3532 auto **begin = reinterpret_cast<Stmt **>(arg_begin()); 3533 return child_range(begin, begin + getNumArgs()); 3534 } 3535 3536 const_child_range children() const { 3537 auto **begin = reinterpret_cast<Stmt **>( 3538 const_cast<CXXUnresolvedConstructExpr *>(this)->arg_begin()); 3539 return const_child_range(begin, begin + getNumArgs()); 3540 } 3541 }; 3542 3543 /// Represents a C++ member access expression where the actual 3544 /// member referenced could not be resolved because the base 3545 /// expression or the member name was dependent. 3546 /// 3547 /// Like UnresolvedMemberExprs, these can be either implicit or 3548 /// explicit accesses. It is only possible to get one of these with 3549 /// an implicit access if a qualifier is provided. 3550 class CXXDependentScopeMemberExpr final 3551 : public Expr, 3552 private llvm::TrailingObjects<CXXDependentScopeMemberExpr, 3553 ASTTemplateKWAndArgsInfo, 3554 TemplateArgumentLoc, NamedDecl *> { 3555 friend class ASTStmtReader; 3556 friend class ASTStmtWriter; 3557 friend TrailingObjects; 3558 3559 /// The expression for the base pointer or class reference, 3560 /// e.g., the \c x in x.f. Can be null in implicit accesses. 3561 Stmt *Base; 3562 3563 /// The type of the base expression. Never null, even for 3564 /// implicit accesses. 3565 QualType BaseType; 3566 3567 /// The nested-name-specifier that precedes the member name, if any. 3568 /// FIXME: This could be in principle store as a trailing object. 3569 /// However the performance impact of doing so should be investigated first. 3570 NestedNameSpecifierLoc QualifierLoc; 3571 3572 /// The member to which this member expression refers, which 3573 /// can be name, overloaded operator, or destructor. 3574 /// 3575 /// FIXME: could also be a template-id 3576 DeclarationNameInfo MemberNameInfo; 3577 3578 // CXXDependentScopeMemberExpr is followed by several trailing objects, 3579 // some of which optional. They are in order: 3580 // 3581 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3582 // template keyword and arguments. Present if and only if 3583 // hasTemplateKWAndArgsInfo(). 3584 // 3585 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing location 3586 // information for the explicitly specified template arguments. 3587 // 3588 // * An optional NamedDecl *. In a qualified member access expression such 3589 // as t->Base::f, this member stores the resolves of name lookup in the 3590 // context of the member access expression, to be used at instantiation 3591 // time. Present if and only if hasFirstQualifierFoundInScope(). 3592 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. 3660 SourceLocation getOperatorLoc() const { 3661 return CXXDependentScopeMemberExprBits.OperatorLoc; 3662 } 3663 3664 /// Retrieve the nested-name-specifier that qualifies the member name. 3665 NestedNameSpecifier *getQualifier() const { 3666 return QualifierLoc.getNestedNameSpecifier(); 3667 } 3668 3669 /// Retrieve the nested-name-specifier that qualifies the member 3670 /// name, with source location information. 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). 3684 NamedDecl *getFirstQualifierFoundInScope() const { 3685 if (!hasFirstQualifierFoundInScope()) 3686 return nullptr; 3687 return *getTrailingObjects<NamedDecl *>(); 3688 } 3689 3690 /// Retrieve the name of the member that this expression refers to. 3691 const DeclarationNameInfo &getMemberNameInfo() const { 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. 3704 SourceLocation getTemplateKeywordLoc() const { 3705 if (!hasTemplateKWAndArgsInfo()) 3706 return SourceLocation(); 3707 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; 3708 } 3709 3710 /// Retrieve the location of the left angle bracket starting the 3711 /// explicit template argument list following the member name, if any. 3712 SourceLocation getLAngleLoc() const { 3713 if (!hasTemplateKWAndArgsInfo()) 3714 return SourceLocation(); 3715 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; 3716 } 3717 3718 /// Retrieve the location of the right angle bracket ending the 3719 /// explicit template argument list following the member name, if any. 3720 SourceLocation getRAngleLoc() const { 3721 if (!hasTemplateKWAndArgsInfo()) 3722 return SourceLocation(); 3723 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; 3724 } 3725 3726 /// Determines whether the member name was preceded by the template keyword. 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. 3735 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3736 if (hasExplicitTemplateArgs()) 3737 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( 3738 getTrailingObjects<TemplateArgumentLoc>(), List); 3739 } 3740 3741 /// Retrieve the template arguments provided as part of this 3742 /// template-id. 3743 const TemplateArgumentLoc *getTemplateArgs() const { 3744 if (!hasExplicitTemplateArgs()) 3745 return nullptr; 3746 3747 return getTrailingObjects<TemplateArgumentLoc>(); 3748 } 3749 3750 /// Retrieve the number of template arguments provided as part of this 3751 /// template-id. 3752 unsigned getNumTemplateArgs() const { 3753 if (!hasExplicitTemplateArgs()) 3754 return 0; 3755 3756 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs; 3757 } 3758 3759 ArrayRef<TemplateArgumentLoc> template_arguments() const { 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 { 3772 if (hasExplicitTemplateArgs()) 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 3782 child_range children() { 3783 if (isImplicitAccess()) 3784 return child_range(child_iterator(), child_iterator()); 3785 return child_range(&Base, &Base + 1); 3786 } 3787 3788 const_child_range children() const { 3789 if (isImplicitAccess()) 3790 return const_child_range(const_child_iterator(), const_child_iterator()); 3791 return const_child_range(&Base, &Base + 1); 3792 } 3793 }; 3794 3795 /// Represents a C++ member access expression for which lookup 3796 /// produced a set of overloaded functions. 3797 /// 3798 /// The member access may be explicit or implicit: 3799 /// \code 3800 /// struct A { 3801 /// int a, b; 3802 /// int explicitAccess() { return this->a + this->A::b; } 3803 /// int implicitAccess() { return a + A::b; } 3804 /// }; 3805 /// \endcode 3806 /// 3807 /// In the final AST, an explicit access always becomes a MemberExpr. 3808 /// An implicit access may become either a MemberExpr or a 3809 /// DeclRefExpr, depending on whether the member is static. 3810 class UnresolvedMemberExpr final 3811 : public OverloadExpr, 3812 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair, 3813 ASTTemplateKWAndArgsInfo, 3814 TemplateArgumentLoc> { 3815 friend class ASTStmtReader; 3816 friend class OverloadExpr; 3817 friend TrailingObjects; 3818 3819 /// The expression for the base pointer or class reference, 3820 /// e.g., the \c x in x.f. 3821 /// 3822 /// This can be null if this is an 'unbased' member expression. 3823 Stmt *Base; 3824 3825 /// The type of the base expression; never null. 3826 QualType BaseType; 3827 3828 /// The location of the '->' or '.' operator. 3829 SourceLocation OperatorLoc; 3830 3831 // UnresolvedMemberExpr is followed by several trailing objects. 3832 // They are in order: 3833 // 3834 // * An array of getNumResults() DeclAccessPair for the results. These are 3835 // undesugared, which is to say, they may include UsingShadowDecls. 3836 // Access is relative to the naming class. 3837 // 3838 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3839 // template keyword and arguments. Present if and only if 3840 // hasTemplateKWAndArgsInfo(). 3841 // 3842 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing 3843 // location information for the explicitly specified template arguments. 3844 3845 UnresolvedMemberExpr(const ASTContext &Context, bool HasUnresolvedUsing, 3846 Expr *Base, QualType BaseType, bool IsArrow, 3847 SourceLocation OperatorLoc, 3848 NestedNameSpecifierLoc QualifierLoc, 3849 SourceLocation TemplateKWLoc, 3850 const DeclarationNameInfo &MemberNameInfo, 3851 const TemplateArgumentListInfo *TemplateArgs, 3852 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3853 3854 UnresolvedMemberExpr(EmptyShell Empty, unsigned NumResults, 3855 bool HasTemplateKWAndArgsInfo); 3856 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. 3887 Expr *getBase() { 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. 3912 CXXRecordDecl *getNamingClass(); 3913 const CXXRecordDecl *getNamingClass() const { 3914 return const_cast<UnresolvedMemberExpr *>(this)->getNamingClass(); 3915 } 3916 3917 /// Retrieve the full name info for the member that this expression 3918 /// refers to. 3919 const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); } 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. 3926 SourceLocation getMemberLoc() const { return getNameLoc(); } 3927 3928 /// Return the preferred location (the member name) for the arrow when 3929 /// diagnosing a problem with this expression. 3930 SourceLocation getExprLoc() const LLVM_READONLY { return getMemberLoc(); } 3931 3932 SourceLocation getBeginLoc() const LLVM_READONLY { 3933 if (!isImplicitAccess()) 3934 return Base->getBeginLoc(); 3935 if (NestedNameSpecifierLoc l = getQualifierLoc()) 3936 return l.getBeginLoc(); 3937 return getMemberNameInfo().getBeginLoc(); 3938 } 3939 3940 SourceLocation getEndLoc() const LLVM_READONLY { 3941 if (hasExplicitTemplateArgs()) 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 3951 child_range children() { 3952 if (isImplicitAccess()) 3953 return child_range(child_iterator(), child_iterator()); 3954 return child_range(&Base, &Base + 1); 3955 } 3956 3957 const_child_range children() const { 3958 if (isImplicitAccess()) 3959 return const_child_range(const_child_iterator(), const_child_iterator()); 3960 return const_child_range(&Base, &Base + 1); 3961 } 3962 }; 3963 3964 DeclAccessPair *OverloadExpr::getTrailingResults() { 3965 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3966 return ULE->getTrailingObjects<DeclAccessPair>(); 3967 return cast<UnresolvedMemberExpr>(this)->getTrailingObjects<DeclAccessPair>(); 3968 } 3969 3970 ASTTemplateKWAndArgsInfo *OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() { 3971 if (!hasTemplateKWAndArgsInfo()) 3972 return nullptr; 3973 3974 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3975 return ULE->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 3976 return cast<UnresolvedMemberExpr>(this) 3977 ->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 3978 } 3979 3980 TemplateArgumentLoc *OverloadExpr::getTrailingTemplateArgumentLoc() { 3981 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3982 return ULE->getTrailingObjects<TemplateArgumentLoc>(); 3983 return cast<UnresolvedMemberExpr>(this) 3984 ->getTrailingObjects<TemplateArgumentLoc>(); 3985 } 3986 3987 CXXRecordDecl *OverloadExpr::getNamingClass() { 3988 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3989 return ULE->getNamingClass(); 3990 return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 3991 } 3992 3993 /// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]). 3994 /// 3995 /// The noexcept expression tests whether a given expression might throw. Its 3996 /// result is a boolean constant. 3997 class CXXNoexceptExpr : public Expr { 3998 friend class ASTStmtReader; 3999 4000 Stmt *Operand; 4001 SourceRange Range; 4002 4003 public: 4004 CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val, 4005 SourceLocation Keyword, SourceLocation RParen) 4006 : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary), 4007 Operand(Operand), Range(Keyword, RParen) { 4008 CXXNoexceptExprBits.Value = Val == CT_Cannot; 4009 setDependence(computeDependence(this, Val)); 4010 } 4011 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 4029 const_child_range children() const { 4030 return const_child_range(&Operand, &Operand + 1); 4031 } 4032 }; 4033 4034 /// Represents a C++11 pack expansion that produces a sequence of 4035 /// expressions. 4036 /// 4037 /// A pack expansion expression contains a pattern (which itself is an 4038 /// expression) followed by an ellipsis. For example: 4039 /// 4040 /// \code 4041 /// template<typename F, typename ...Types> 4042 /// void forward(F f, Types &&...args) { 4043 /// f(static_cast<Types&&>(args)...); 4044 /// } 4045 /// \endcode 4046 /// 4047 /// Here, the argument to the function object \c f is a pack expansion whose 4048 /// pattern is \c static_cast<Types&&>(args). When the \c forward function 4049 /// template is instantiated, the pack expansion will instantiate to zero or 4050 /// or more function arguments to the function object \c f. 4051 class PackExpansionExpr : public Expr { 4052 friend class ASTStmtReader; 4053 friend class ASTStmtWriter; 4054 4055 SourceLocation EllipsisLoc; 4056 4057 /// The number of expansions that will be produced by this pack 4058 /// expansion expression, if known. 4059 /// 4060 /// When zero, the number of expansions is not known. Otherwise, this value 4061 /// is the number of expansions + 1. 4062 unsigned NumExpansions; 4063 4064 Stmt *Pattern; 4065 4066 public: 4067 PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, 4068 Optional<unsigned> NumExpansions) 4069 : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), 4070 Pattern->getObjectKind()), 4071 EllipsisLoc(EllipsisLoc), 4072 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), 4073 Pattern(Pattern) { 4074 setDependence(computeDependence(this)); 4075 } 4076 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. 4091 Optional<unsigned> getNumExpansions() const { 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 4109 child_range children() { 4110 return child_range(&Pattern, &Pattern + 1); 4111 } 4112 4113 const_child_range children() const { 4114 return const_child_range(&Pattern, &Pattern + 1); 4115 } 4116 }; 4117 4118 /// Represents an expression that computes the length of a parameter 4119 /// pack. 4120 /// 4121 /// \code 4122 /// template<typename ...Types> 4123 /// struct count { 4124 /// static const unsigned value = sizeof...(Types); 4125 /// }; 4126 /// \endcode 4127 class SizeOfPackExpr final 4128 : public Expr, 4129 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> { 4130 friend class ASTStmtReader; 4131 friend class ASTStmtWriter; 4132 friend TrailingObjects; 4133 4134 /// The location of the \c sizeof keyword. 4135 SourceLocation OperatorLoc; 4136 4137 /// The location of the name of the parameter pack. 4138 SourceLocation PackLoc; 4139 4140 /// The location of the closing parenthesis. 4141 SourceLocation RParenLoc; 4142 4143 /// The length of the parameter pack, if known. 4144 /// 4145 /// When this expression is not value-dependent, this is the length of 4146 /// the pack. When the expression was parsed rather than instantiated 4147 /// (and thus is value-dependent), this is zero. 4148 /// 4149 /// After partial substitution into a sizeof...(X) expression (for instance, 4150 /// within an alias template or during function template argument deduction), 4151 /// we store a trailing array of partially-substituted TemplateArguments, 4152 /// and this is the length of that array. 4153 unsigned Length; 4154 4155 /// The parameter pack. 4156 NamedDecl *Pack = nullptr; 4157 4158 /// Create an expression that computes the length of 4159 /// the given parameter pack. 4160 SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack, 4161 SourceLocation PackLoc, SourceLocation RParenLoc, 4162 Optional<unsigned> Length, 4163 ArrayRef<TemplateArgument> PartialArgs) 4164 : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary), 4165 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc), 4166 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) { 4167 assert((!Length || PartialArgs.empty()) && 4168 "have partial args for non-dependent sizeof... expression"); 4169 auto *Args = getTrailingObjects<TemplateArgument>(); 4170 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args); 4171 setDependence(Length ? ExprDependence::None 4172 : ExprDependence::ValueInstantiation); 4173 } 4174 4175 /// Create an empty expression. 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 4220 ArrayRef<TemplateArgument> getPartialArguments() const { 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 4234 child_range children() { 4235 return child_range(child_iterator(), child_iterator()); 4236 } 4237 4238 const_child_range children() const { 4239 return const_child_range(const_child_iterator(), const_child_iterator()); 4240 } 4241 }; 4242 4243 /// Represents a reference to a non-type template parameter 4244 /// that has been substituted with a template argument. 4245 class SubstNonTypeTemplateParmExpr : public Expr { 4246 friend class ASTReader; 4247 friend class ASTStmtReader; 4248 4249 /// The replaced parameter and a flag indicating if it was a reference 4250 /// parameter. For class NTTPs, we can't determine that based on the value 4251 /// category alone. 4252 llvm::PointerIntPair<NonTypeTemplateParmDecl*, 1, bool> ParamAndRef; 4253 4254 /// The replacement expression. 4255 Stmt *Replacement; 4256 4257 explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty) 4258 : Expr(SubstNonTypeTemplateParmExprClass, Empty) {} 4259 4260 public: 4261 SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind, 4262 SourceLocation Loc, 4263 NonTypeTemplateParmDecl *Param, bool RefParam, 4264 Expr *Replacement) 4265 : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary), 4266 ParamAndRef(Param, RefParam), Replacement(Replacement) { 4267 SubstNonTypeTemplateParmExprBits.NameLoc = Loc; 4268 setDependence(computeDependence(this)); 4269 } 4270 4271 SourceLocation getNameLoc() const { 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 4279 NonTypeTemplateParmDecl *getParameter() const { 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 4295 const_child_range children() const { 4296 return const_child_range(&Replacement, &Replacement + 1); 4297 } 4298 }; 4299 4300 /// Represents a reference to a non-type template parameter pack that 4301 /// has been substituted with a non-template argument pack. 4302 /// 4303 /// When a pack expansion in the source code contains multiple parameter packs 4304 /// and those parameter packs correspond to different levels of template 4305 /// parameter lists, this node is used to represent a non-type template 4306 /// parameter pack from an outer level, which has already had its argument pack 4307 /// substituted but that still lives within a pack expansion that itself 4308 /// could not be instantiated. When actually performing a substitution into 4309 /// that pack expansion (e.g., when all template parameters have corresponding 4310 /// arguments), this type will be replaced with the appropriate underlying 4311 /// expression at the current pack substitution index. 4312 class SubstNonTypeTemplateParmPackExpr : public Expr { 4313 friend class ASTReader; 4314 friend class ASTStmtReader; 4315 4316 /// The non-type template parameter pack itself. 4317 NonTypeTemplateParmDecl *Param; 4318 4319 /// A pointer to the set of template arguments that this 4320 /// parameter pack is instantiated with. 4321 const TemplateArgument *Arguments; 4322 4323 /// The number of template arguments in \c Arguments. 4324 unsigned NumArguments; 4325 4326 /// The location of the non-type template parameter pack reference. 4327 SourceLocation NameLoc; 4328 4329 explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty) 4330 : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {} 4331 4332 public: 4333 SubstNonTypeTemplateParmPackExpr(QualType T, 4334 ExprValueKind ValueKind, 4335 NonTypeTemplateParmDecl *Param, 4336 SourceLocation NameLoc, 4337 const TemplateArgument &ArgPack); 4338 4339 /// Retrieve the non-type template parameter pack being substituted. 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. 4347 TemplateArgument getArgumentPack() const; 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 4357 child_range children() { 4358 return child_range(child_iterator(), child_iterator()); 4359 } 4360 4361 const_child_range children() const { 4362 return const_child_range(const_child_iterator(), const_child_iterator()); 4363 } 4364 }; 4365 4366 /// Represents a reference to a function parameter pack or init-capture pack 4367 /// that has been substituted but not yet expanded. 4368 /// 4369 /// When a pack expansion contains multiple parameter packs at different levels, 4370 /// this node is used to represent a function parameter pack at an outer level 4371 /// which we have already substituted to refer to expanded parameters, but where 4372 /// the containing pack expansion cannot yet be expanded. 4373 /// 4374 /// \code 4375 /// template<typename...Ts> struct S { 4376 /// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...)); 4377 /// }; 4378 /// template struct S<int, int>; 4379 /// \endcode 4380 class FunctionParmPackExpr final 4381 : public Expr, 4382 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> { 4383 friend class ASTReader; 4384 friend class ASTStmtReader; 4385 friend TrailingObjects; 4386 4387 /// The function parameter pack which was referenced. 4388 VarDecl *ParamPack; 4389 4390 /// The location of the function parameter pack reference. 4391 SourceLocation NameLoc; 4392 4393 /// The number of expansions of this pack. 4394 unsigned NumParameters; 4395 4396 FunctionParmPackExpr(QualType T, VarDecl *ParamPack, 4397 SourceLocation NameLoc, unsigned NumParams, 4398 VarDecl *const *Params); 4399 4400 public: 4401 static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T, 4402 VarDecl *ParamPack, 4403 SourceLocation NameLoc, 4404 ArrayRef<VarDecl *> Params); 4405 static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context, 4406 unsigned NumParams); 4407 4408 /// Get the parameter pack which this expression refers to. 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 4433 child_range children() { 4434 return child_range(child_iterator(), child_iterator()); 4435 } 4436 4437 const_child_range children() const { 4438 return const_child_range(const_child_iterator(), const_child_iterator()); 4439 } 4440 }; 4441 4442 /// Represents a prvalue temporary that is written into memory so that 4443 /// a reference can bind to it. 4444 /// 4445 /// Prvalue expressions are materialized when they need to have an address 4446 /// in memory for a reference to bind to. This happens when binding a 4447 /// reference to the result of a conversion, e.g., 4448 /// 4449 /// \code 4450 /// const int &r = 1.0; 4451 /// \endcode 4452 /// 4453 /// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is 4454 /// then materialized via a \c MaterializeTemporaryExpr, and the reference 4455 /// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues 4456 /// (either an lvalue or an xvalue, depending on the kind of reference binding 4457 /// to it), maintaining the invariant that references always bind to glvalues. 4458 /// 4459 /// Reference binding and copy-elision can both extend the lifetime of a 4460 /// temporary. When either happens, the expression will also track the 4461 /// declaration which is responsible for the lifetime extension. 4462 class MaterializeTemporaryExpr : public Expr { 4463 private: 4464 friend class ASTStmtReader; 4465 friend class ASTStmtWriter; 4466 4467 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State; 4468 4469 public: 4470 MaterializeTemporaryExpr(QualType T, Expr *Temporary, 4471 bool BoundToLvalueReference, 4472 LifetimeExtendedTemporaryDecl *MTD = nullptr); 4473 4474 MaterializeTemporaryExpr(EmptyShell Empty) 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 *>() 4483 : State.get<LifetimeExtendedTemporaryDecl *>()->getTemporaryExpr()); 4484 } 4485 4486 /// Retrieve the storage duration for the materialized temporary. 4487 StorageDuration getStorageDuration() const { 4488 return State.is<Stmt *>() ? SD_FullExpression 4489 : State.get<LifetimeExtendedTemporaryDecl *>() 4490 ->getStorageDuration(); 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"); 4498 return State.get<LifetimeExtendedTemporaryDecl *>()->getOrCreateValue( 4499 MayCreate); 4500 } 4501 4502 LifetimeExtendedTemporaryDecl *getLifetimeExtendedTemporaryDecl() { 4503 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>(); 4504 } 4505 const LifetimeExtendedTemporaryDecl * 4506 getLifetimeExtendedTemporaryDecl() const { 4507 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>(); 4508 } 4509 4510 /// Get the declaration which triggered the lifetime-extension of this 4511 /// temporary, if any. 4512 ValueDecl *getExtendingDecl() { 4513 return State.is<Stmt *>() ? nullptr 4514 : State.get<LifetimeExtendedTemporaryDecl *>() 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 4525 : State.get<LifetimeExtendedTemporaryDecl *>() 4526 ->getManglingNumber(); 4527 } 4528 4529 /// Determine whether this materialized temporary is bound to an 4530 /// lvalue reference; otherwise, it's bound to an rvalue reference. 4531 bool isBoundToLvalueReference() const { 4532 return getValueKind() == VK_LValue; 4533 } 4534 4535 /// Determine whether this temporary object is usable in constant 4536 /// expressions, as specified in C++20 [expr.const]p4. 4537 bool isUsableInConstantExpressions(const ASTContext &Context) const; 4538 4539 SourceLocation getBeginLoc() const LLVM_READONLY { 4540 return getSubExpr()->getBeginLoc(); 4541 } 4542 4543 SourceLocation getEndLoc() const LLVM_READONLY { 4544 return getSubExpr()->getEndLoc(); 4545 } 4546 4547 static bool classof(const Stmt *T) { 4548 return T->getStmtClass() == MaterializeTemporaryExprClass; 4549 } 4550 4551 // Iterators 4552 child_range children() { 4553 return State.is<Stmt *>() 4554 ? child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1) 4555 : State.get<LifetimeExtendedTemporaryDecl *>()->childrenExpr(); 4556 } 4557 4558 const_child_range children() const { 4559 return State.is<Stmt *>() 4560 ? const_child_range(State.getAddrOfPtr1(), 4561 State.getAddrOfPtr1() + 1) 4562 : const_cast<const LifetimeExtendedTemporaryDecl *>( 4563 State.get<LifetimeExtendedTemporaryDecl *>()) 4564 ->childrenExpr(); 4565 } 4566 }; 4567 4568 /// Represents a folding of a pack over an operator. 4569 /// 4570 /// This expression is always dependent and represents a pack expansion of the 4571 /// forms: 4572 /// 4573 /// ( expr op ... ) 4574 /// ( ... op expr ) 4575 /// ( expr op ... op expr ) 4576 class CXXFoldExpr : public Expr { 4577 friend class ASTStmtReader; 4578 friend class ASTStmtWriter; 4579 4580 enum SubExpr { Callee, LHS, RHS, Count }; 4581 4582 SourceLocation LParenLoc; 4583 SourceLocation EllipsisLoc; 4584 SourceLocation RParenLoc; 4585 // When 0, the number of expansions is not known. Otherwise, this is one more 4586 // than the number of expansions. 4587 unsigned NumExpansions; 4588 Stmt *SubExprs[SubExpr::Count]; 4589 BinaryOperatorKind Opcode; 4590 4591 public: 4592 CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, 4593 SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, 4594 SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, 4595 Optional<unsigned> NumExpansions) 4596 : Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary), LParenLoc(LParenLoc), 4597 EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc), 4598 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) { 4599 SubExprs[SubExpr::Callee] = Callee; 4600 SubExprs[SubExpr::LHS] = LHS; 4601 SubExprs[SubExpr::RHS] = RHS; 4602 setDependence(computeDependence(this)); 4603 } 4604 4605 CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {} 4606 4607 UnresolvedLookupExpr *getCallee() const { 4608 return static_cast<UnresolvedLookupExpr *>(SubExprs[SubExpr::Callee]); 4609 } 4610 Expr *getLHS() const { return static_cast<Expr*>(SubExprs[SubExpr::LHS]); } 4611 Expr *getRHS() const { return static_cast<Expr*>(SubExprs[SubExpr::RHS]); } 4612 4613 /// Does this produce a right-associated sequence of operators? 4614 bool isRightFold() const { 4615 return getLHS() && getLHS()->containsUnexpandedParameterPack(); 4616 } 4617 4618 /// Does this produce a left-associated sequence of operators? 4619 bool isLeftFold() const { return !isRightFold(); } 4620 4621 /// Get the pattern, that is, the operand that contains an unexpanded pack. 4622 Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); } 4623 4624 /// Get the operand that doesn't contain a pack, for a binary fold. 4625 Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); } 4626 4627 SourceLocation getLParenLoc() const { return LParenLoc; } 4628 SourceLocation getRParenLoc() const { return RParenLoc; } 4629 SourceLocation getEllipsisLoc() const { return EllipsisLoc; } 4630 BinaryOperatorKind getOperator() const { return Opcode; } 4631 4632 Optional<unsigned> getNumExpansions() const { 4633 if (NumExpansions) 4634 return NumExpansions - 1; 4635 return None; 4636 } 4637 4638 SourceLocation getBeginLoc() const LLVM_READONLY { 4639 if (LParenLoc.isValid()) 4640 return LParenLoc; 4641 if (isLeftFold()) 4642 return getEllipsisLoc(); 4643 return getLHS()->getBeginLoc(); 4644 } 4645 4646 SourceLocation getEndLoc() const LLVM_READONLY { 4647 if (RParenLoc.isValid()) 4648 return RParenLoc; 4649 if (isRightFold()) 4650 return getEllipsisLoc(); 4651 return getRHS()->getEndLoc(); 4652 } 4653 4654 static bool classof(const Stmt *T) { 4655 return T->getStmtClass() == CXXFoldExprClass; 4656 } 4657 4658 // Iterators 4659 child_range children() { 4660 return child_range(SubExprs, SubExprs + SubExpr::Count); 4661 } 4662 4663 const_child_range children() const { 4664 return const_child_range(SubExprs, SubExprs + SubExpr::Count); 4665 } 4666 }; 4667 4668 /// Represents an expression that might suspend coroutine execution; 4669 /// either a co_await or co_yield expression. 4670 /// 4671 /// Evaluation of this expression first evaluates its 'ready' expression. If 4672 /// that returns 'false': 4673 /// -- execution of the coroutine is suspended 4674 /// -- the 'suspend' expression is evaluated 4675 /// -- if the 'suspend' expression returns 'false', the coroutine is 4676 /// resumed 4677 /// -- otherwise, control passes back to the resumer. 4678 /// If the coroutine is not suspended, or when it is resumed, the 'resume' 4679 /// expression is evaluated, and its result is the result of the overall 4680 /// expression. 4681 class CoroutineSuspendExpr : public Expr { 4682 friend class ASTStmtReader; 4683 4684 SourceLocation KeywordLoc; 4685 4686 enum SubExpr { Common, Ready, Suspend, Resume, Count }; 4687 4688 Stmt *SubExprs[SubExpr::Count]; 4689 OpaqueValueExpr *OpaqueValue = nullptr; 4690 4691 public: 4692 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Common, 4693 Expr *Ready, Expr *Suspend, Expr *Resume, 4694 OpaqueValueExpr *OpaqueValue) 4695 : Expr(SC, Resume->getType(), Resume->getValueKind(), 4696 Resume->getObjectKind()), 4697 KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) { 4698 SubExprs[SubExpr::Common] = Common; 4699 SubExprs[SubExpr::Ready] = Ready; 4700 SubExprs[SubExpr::Suspend] = Suspend; 4701 SubExprs[SubExpr::Resume] = Resume; 4702 setDependence(computeDependence(this)); 4703 } 4704 4705 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty, 4706 Expr *Common) 4707 : Expr(SC, Ty, VK_RValue, OK_Ordinary), KeywordLoc(KeywordLoc) { 4708 assert(Common->isTypeDependent() && Ty->isDependentType() && 4709 "wrong constructor for non-dependent co_await/co_yield expression"); 4710 SubExprs[SubExpr::Common] = Common; 4711 SubExprs[SubExpr::Ready] = nullptr; 4712 SubExprs[SubExpr::Suspend] = nullptr; 4713 SubExprs[SubExpr::Resume] = nullptr; 4714 setDependence(computeDependence(this)); 4715 } 4716 4717 CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) { 4718 SubExprs[SubExpr::Common] = nullptr; 4719 SubExprs[SubExpr::Ready] = nullptr; 4720 SubExprs[SubExpr::Suspend] = nullptr; 4721 SubExprs[SubExpr::Resume] = nullptr; 4722 } 4723 4724 SourceLocation getKeywordLoc() const { return KeywordLoc; } 4725 4726 Expr *getCommonExpr() const { 4727 return static_cast<Expr*>(SubExprs[SubExpr::Common]); 4728 } 4729 4730 /// getOpaqueValue - Return the opaque value placeholder. 4731 OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; } 4732 4733 Expr *getReadyExpr() const { 4734 return static_cast<Expr*>(SubExprs[SubExpr::Ready]); 4735 } 4736 4737 Expr *getSuspendExpr() const { 4738 return static_cast<Expr*>(SubExprs[SubExpr::Suspend]); 4739 } 4740 4741 Expr *getResumeExpr() const { 4742 return static_cast<Expr*>(SubExprs[SubExpr::Resume]); 4743 } 4744 4745 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; } 4746 4747 SourceLocation getEndLoc() const LLVM_READONLY { 4748 return getCommonExpr()->getEndLoc(); 4749 } 4750 4751 child_range children() { 4752 return child_range(SubExprs, SubExprs + SubExpr::Count); 4753 } 4754 4755 const_child_range children() const { 4756 return const_child_range(SubExprs, SubExprs + SubExpr::Count); 4757 } 4758 4759 static bool classof(const Stmt *T) { 4760 return T->getStmtClass() == CoawaitExprClass || 4761 T->getStmtClass() == CoyieldExprClass; 4762 } 4763 }; 4764 4765 /// Represents a 'co_await' expression. 4766 class CoawaitExpr : public CoroutineSuspendExpr { 4767 friend class ASTStmtReader; 4768 4769 public: 4770 CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Ready, 4771 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue, 4772 bool IsImplicit = false) 4773 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Operand, Ready, 4774 Suspend, Resume, OpaqueValue) { 4775 CoawaitBits.IsImplicit = IsImplicit; 4776 } 4777 4778 CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand, 4779 bool IsImplicit = false) 4780 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Ty, Operand) { 4781 CoawaitBits.IsImplicit = IsImplicit; 4782 } 4783 4784 CoawaitExpr(EmptyShell Empty) 4785 : CoroutineSuspendExpr(CoawaitExprClass, Empty) {} 4786 4787 Expr *getOperand() const { 4788 // FIXME: Dig out the actual operand or store it. 4789 return getCommonExpr(); 4790 } 4791 4792 bool isImplicit() const { return CoawaitBits.IsImplicit; } 4793 void setIsImplicit(bool value = true) { CoawaitBits.IsImplicit = value; } 4794 4795 static bool classof(const Stmt *T) { 4796 return T->getStmtClass() == CoawaitExprClass; 4797 } 4798 }; 4799 4800 /// Represents a 'co_await' expression while the type of the promise 4801 /// is dependent. 4802 class DependentCoawaitExpr : public Expr { 4803 friend class ASTStmtReader; 4804 4805 SourceLocation KeywordLoc; 4806 Stmt *SubExprs[2]; 4807 4808 public: 4809 DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op, 4810 UnresolvedLookupExpr *OpCoawait) 4811 : Expr(DependentCoawaitExprClass, Ty, VK_RValue, OK_Ordinary), 4812 KeywordLoc(KeywordLoc) { 4813 // NOTE: A co_await expression is dependent on the coroutines promise 4814 // type and may be dependent even when the `Op` expression is not. 4815 assert(Ty->isDependentType() && 4816 "wrong constructor for non-dependent co_await/co_yield expression"); 4817 SubExprs[0] = Op; 4818 SubExprs[1] = OpCoawait; 4819 setDependence(computeDependence(this)); 4820 } 4821 4822 DependentCoawaitExpr(EmptyShell Empty) 4823 : Expr(DependentCoawaitExprClass, Empty) {} 4824 4825 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); } 4826 4827 UnresolvedLookupExpr *getOperatorCoawaitLookup() const { 4828 return cast<UnresolvedLookupExpr>(SubExprs[1]); 4829 } 4830 4831 SourceLocation getKeywordLoc() const { return KeywordLoc; } 4832 4833 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; } 4834 4835 SourceLocation getEndLoc() const LLVM_READONLY { 4836 return getOperand()->getEndLoc(); 4837 } 4838 4839 child_range children() { return child_range(SubExprs, SubExprs + 2); } 4840 4841 const_child_range children() const { 4842 return const_child_range(SubExprs, SubExprs + 2); 4843 } 4844 4845 static bool classof(const Stmt *T) { 4846 return T->getStmtClass() == DependentCoawaitExprClass; 4847 } 4848 }; 4849 4850 /// Represents a 'co_yield' expression. 4851 class CoyieldExpr : public CoroutineSuspendExpr { 4852 friend class ASTStmtReader; 4853 4854 public: 4855 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Ready, 4856 Expr *Suspend, Expr *Resume, OpaqueValueExpr *OpaqueValue) 4857 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Operand, Ready, 4858 Suspend, Resume, OpaqueValue) {} 4859 CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand) 4860 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Ty, Operand) {} 4861 CoyieldExpr(EmptyShell Empty) 4862 : CoroutineSuspendExpr(CoyieldExprClass, Empty) {} 4863 4864 Expr *getOperand() const { 4865 // FIXME: Dig out the actual operand or store it. 4866 return getCommonExpr(); 4867 } 4868 4869 static bool classof(const Stmt *T) { 4870 return T->getStmtClass() == CoyieldExprClass; 4871 } 4872 }; 4873 4874 /// Represents a C++2a __builtin_bit_cast(T, v) expression. Used to implement 4875 /// std::bit_cast. These can sometimes be evaluated as part of a constant 4876 /// expression, but otherwise CodeGen to a simple memcpy in general. 4877 class BuiltinBitCastExpr final 4878 : public ExplicitCastExpr, 4879 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> { 4880 friend class ASTStmtReader; 4881 friend class CastExpr; 4882 friend TrailingObjects; 4883 4884 SourceLocation KWLoc; 4885 SourceLocation RParenLoc; 4886 4887 public: 4888 BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr, 4889 TypeSourceInfo *DstType, SourceLocation KWLoc, 4890 SourceLocation RParenLoc) 4891 : ExplicitCastExpr(BuiltinBitCastExprClass, T, VK, CK, SrcExpr, 0, false, 4892 DstType), 4893 KWLoc(KWLoc), RParenLoc(RParenLoc) {} 4894 BuiltinBitCastExpr(EmptyShell Empty) 4895 : ExplicitCastExpr(BuiltinBitCastExprClass, Empty, 0, false) {} 4896 4897 SourceLocation getBeginLoc() const LLVM_READONLY { return KWLoc; } 4898 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } 4899 4900 static bool classof(const Stmt *T) { 4901 return T->getStmtClass() == BuiltinBitCastExprClass; 4902 } 4903 }; 4904 4905 } // namespace clang 4906 4907 #endif // LLVM_CLANG_AST_EXPRCXX_H 4908