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_PRValue, 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_PRValue, 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_PRValue, 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_PRValue, 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_PRValue, 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(computeDependence(this)); 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_PRValue, 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_PRValue, 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_PRValue, 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 /// This might return None even if isArray() returns true, 2265 /// since there might not be an array size expression. 2266 /// If the result is not-None, it will never wrap a nullptr. 2267 Optional<Expr *> getArraySize() { 2268 if (!isArray()) 2269 return None; 2270 2271 if (auto *Result = 2272 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()])) 2273 return Result; 2274 2275 return None; 2276 } 2277 2278 /// This might return None even if isArray() returns true, 2279 /// since there might not be an array size expression. 2280 /// If the result is not-None, it will never wrap a nullptr. 2281 Optional<const Expr *> getArraySize() const { 2282 if (!isArray()) 2283 return None; 2284 2285 if (auto *Result = 2286 cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()])) 2287 return Result; 2288 2289 return None; 2290 } 2291 2292 unsigned getNumPlacementArgs() const { 2293 return CXXNewExprBits.NumPlacementArgs; 2294 } 2295 2296 Expr **getPlacementArgs() { 2297 return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() + 2298 placementNewArgsOffset()); 2299 } 2300 2301 Expr *getPlacementArg(unsigned I) { 2302 assert((I < getNumPlacementArgs()) && "Index out of range!"); 2303 return getPlacementArgs()[I]; 2304 } 2305 const Expr *getPlacementArg(unsigned I) const { 2306 return const_cast<CXXNewExpr *>(this)->getPlacementArg(I); 2307 } 2308 2309 bool isParenTypeId() const { return CXXNewExprBits.IsParenTypeId; } 2310 SourceRange getTypeIdParens() const { 2311 return isParenTypeId() ? getTrailingObjects<SourceRange>()[0] 2312 : SourceRange(); 2313 } 2314 2315 bool isGlobalNew() const { return CXXNewExprBits.IsGlobalNew; } 2316 2317 /// Whether this new-expression has any initializer at all. 2318 bool hasInitializer() const { 2319 return CXXNewExprBits.StoredInitializationStyle > 0; 2320 } 2321 2322 /// The kind of initializer this new-expression has. 2323 InitializationStyle getInitializationStyle() const { 2324 if (CXXNewExprBits.StoredInitializationStyle == 0) 2325 return NoInit; 2326 return static_cast<InitializationStyle>( 2327 CXXNewExprBits.StoredInitializationStyle - 1); 2328 } 2329 2330 /// The initializer of this new-expression. 2331 Expr *getInitializer() { 2332 return hasInitializer() 2333 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()]) 2334 : nullptr; 2335 } 2336 const Expr *getInitializer() const { 2337 return hasInitializer() 2338 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()]) 2339 : nullptr; 2340 } 2341 2342 /// Returns the CXXConstructExpr from this new-expression, or null. 2343 const CXXConstructExpr *getConstructExpr() const { 2344 return dyn_cast_or_null<CXXConstructExpr>(getInitializer()); 2345 } 2346 2347 /// Indicates whether the required alignment should be implicitly passed to 2348 /// the allocation function. 2349 bool passAlignment() const { return CXXNewExprBits.ShouldPassAlignment; } 2350 2351 /// Answers whether the usual array deallocation function for the 2352 /// allocated type expects the size of the allocation as a 2353 /// parameter. 2354 bool doesUsualArrayDeleteWantSize() const { 2355 return CXXNewExprBits.UsualArrayDeleteWantsSize; 2356 } 2357 2358 using arg_iterator = ExprIterator; 2359 using const_arg_iterator = ConstExprIterator; 2360 2361 llvm::iterator_range<arg_iterator> placement_arguments() { 2362 return llvm::make_range(placement_arg_begin(), placement_arg_end()); 2363 } 2364 2365 llvm::iterator_range<const_arg_iterator> placement_arguments() const { 2366 return llvm::make_range(placement_arg_begin(), placement_arg_end()); 2367 } 2368 2369 arg_iterator placement_arg_begin() { 2370 return getTrailingObjects<Stmt *>() + placementNewArgsOffset(); 2371 } 2372 arg_iterator placement_arg_end() { 2373 return placement_arg_begin() + getNumPlacementArgs(); 2374 } 2375 const_arg_iterator placement_arg_begin() const { 2376 return getTrailingObjects<Stmt *>() + placementNewArgsOffset(); 2377 } 2378 const_arg_iterator placement_arg_end() const { 2379 return placement_arg_begin() + getNumPlacementArgs(); 2380 } 2381 2382 using raw_arg_iterator = Stmt **; 2383 2384 raw_arg_iterator raw_arg_begin() { return getTrailingObjects<Stmt *>(); } 2385 raw_arg_iterator raw_arg_end() { 2386 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>()); 2387 } 2388 const_arg_iterator raw_arg_begin() const { 2389 return getTrailingObjects<Stmt *>(); 2390 } 2391 const_arg_iterator raw_arg_end() const { 2392 return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>()); 2393 } 2394 2395 SourceLocation getBeginLoc() const { return Range.getBegin(); } 2396 SourceLocation getEndLoc() const { return Range.getEnd(); } 2397 2398 SourceRange getDirectInitRange() const { return DirectInitRange; } 2399 SourceRange getSourceRange() const { return Range; } 2400 2401 static bool classof(const Stmt *T) { 2402 return T->getStmtClass() == CXXNewExprClass; 2403 } 2404 2405 // Iterators 2406 child_range children() { return child_range(raw_arg_begin(), raw_arg_end()); } 2407 2408 const_child_range children() const { 2409 return const_child_range(const_cast<CXXNewExpr *>(this)->children()); 2410 } 2411 }; 2412 2413 /// Represents a \c delete expression for memory deallocation and 2414 /// destructor calls, e.g. "delete[] pArray". 2415 class CXXDeleteExpr : public Expr { 2416 friend class ASTStmtReader; 2417 2418 /// Points to the operator delete overload that is used. Could be a member. 2419 FunctionDecl *OperatorDelete = nullptr; 2420 2421 /// The pointer expression to be deleted. 2422 Stmt *Argument = nullptr; 2423 2424 public: 2425 CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm, 2426 bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize, 2427 FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc) 2428 : Expr(CXXDeleteExprClass, Ty, VK_PRValue, OK_Ordinary), 2429 OperatorDelete(OperatorDelete), Argument(Arg) { 2430 CXXDeleteExprBits.GlobalDelete = GlobalDelete; 2431 CXXDeleteExprBits.ArrayForm = ArrayForm; 2432 CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten; 2433 CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize; 2434 CXXDeleteExprBits.Loc = Loc; 2435 setDependence(computeDependence(this)); 2436 } 2437 2438 explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {} 2439 2440 bool isGlobalDelete() const { return CXXDeleteExprBits.GlobalDelete; } 2441 bool isArrayForm() const { return CXXDeleteExprBits.ArrayForm; } 2442 bool isArrayFormAsWritten() const { 2443 return CXXDeleteExprBits.ArrayFormAsWritten; 2444 } 2445 2446 /// Answers whether the usual array deallocation function for the 2447 /// allocated type expects the size of the allocation as a 2448 /// parameter. This can be true even if the actual deallocation 2449 /// function that we're using doesn't want a size. 2450 bool doesUsualArrayDeleteWantSize() const { 2451 return CXXDeleteExprBits.UsualArrayDeleteWantsSize; 2452 } 2453 2454 FunctionDecl *getOperatorDelete() const { return OperatorDelete; } 2455 2456 Expr *getArgument() { return cast<Expr>(Argument); } 2457 const Expr *getArgument() const { return cast<Expr>(Argument); } 2458 2459 /// Retrieve the type being destroyed. 2460 /// 2461 /// If the type being destroyed is a dependent type which may or may not 2462 /// be a pointer, return an invalid type. 2463 QualType getDestroyedType() const; 2464 2465 SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; } 2466 SourceLocation getEndLoc() const LLVM_READONLY { 2467 return Argument->getEndLoc(); 2468 } 2469 2470 static bool classof(const Stmt *T) { 2471 return T->getStmtClass() == CXXDeleteExprClass; 2472 } 2473 2474 // Iterators 2475 child_range children() { return child_range(&Argument, &Argument + 1); } 2476 2477 const_child_range children() const { 2478 return const_child_range(&Argument, &Argument + 1); 2479 } 2480 }; 2481 2482 /// Stores the type being destroyed by a pseudo-destructor expression. 2483 class PseudoDestructorTypeStorage { 2484 /// Either the type source information or the name of the type, if 2485 /// it couldn't be resolved due to type-dependence. 2486 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type; 2487 2488 /// The starting source location of the pseudo-destructor type. 2489 SourceLocation Location; 2490 2491 public: 2492 PseudoDestructorTypeStorage() = default; 2493 2494 PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc) 2495 : Type(II), Location(Loc) {} 2496 2497 PseudoDestructorTypeStorage(TypeSourceInfo *Info); 2498 2499 TypeSourceInfo *getTypeSourceInfo() const { 2500 return Type.dyn_cast<TypeSourceInfo *>(); 2501 } 2502 2503 IdentifierInfo *getIdentifier() const { 2504 return Type.dyn_cast<IdentifierInfo *>(); 2505 } 2506 2507 SourceLocation getLocation() const { return Location; } 2508 }; 2509 2510 /// Represents a C++ pseudo-destructor (C++ [expr.pseudo]). 2511 /// 2512 /// A pseudo-destructor is an expression that looks like a member access to a 2513 /// destructor of a scalar type, except that scalar types don't have 2514 /// destructors. For example: 2515 /// 2516 /// \code 2517 /// typedef int T; 2518 /// void f(int *p) { 2519 /// p->T::~T(); 2520 /// } 2521 /// \endcode 2522 /// 2523 /// Pseudo-destructors typically occur when instantiating templates such as: 2524 /// 2525 /// \code 2526 /// template<typename T> 2527 /// void destroy(T* ptr) { 2528 /// ptr->T::~T(); 2529 /// } 2530 /// \endcode 2531 /// 2532 /// for scalar types. A pseudo-destructor expression has no run-time semantics 2533 /// beyond evaluating the base expression. 2534 class CXXPseudoDestructorExpr : public Expr { 2535 friend class ASTStmtReader; 2536 2537 /// The base expression (that is being destroyed). 2538 Stmt *Base = nullptr; 2539 2540 /// Whether the operator was an arrow ('->'); otherwise, it was a 2541 /// period ('.'). 2542 bool IsArrow : 1; 2543 2544 /// The location of the '.' or '->' operator. 2545 SourceLocation OperatorLoc; 2546 2547 /// The nested-name-specifier that follows the operator, if present. 2548 NestedNameSpecifierLoc QualifierLoc; 2549 2550 /// The type that precedes the '::' in a qualified pseudo-destructor 2551 /// expression. 2552 TypeSourceInfo *ScopeType = nullptr; 2553 2554 /// The location of the '::' in a qualified pseudo-destructor 2555 /// expression. 2556 SourceLocation ColonColonLoc; 2557 2558 /// The location of the '~'. 2559 SourceLocation TildeLoc; 2560 2561 /// The type being destroyed, or its name if we were unable to 2562 /// resolve the name. 2563 PseudoDestructorTypeStorage DestroyedType; 2564 2565 public: 2566 CXXPseudoDestructorExpr(const ASTContext &Context, 2567 Expr *Base, bool isArrow, SourceLocation OperatorLoc, 2568 NestedNameSpecifierLoc QualifierLoc, 2569 TypeSourceInfo *ScopeType, 2570 SourceLocation ColonColonLoc, 2571 SourceLocation TildeLoc, 2572 PseudoDestructorTypeStorage DestroyedType); 2573 2574 explicit CXXPseudoDestructorExpr(EmptyShell Shell) 2575 : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {} 2576 2577 Expr *getBase() const { return cast<Expr>(Base); } 2578 2579 /// Determines whether this member expression actually had 2580 /// a C++ nested-name-specifier prior to the name of the member, e.g., 2581 /// x->Base::foo. 2582 bool hasQualifier() const { return QualifierLoc.hasQualifier(); } 2583 2584 /// Retrieves the nested-name-specifier that qualifies the type name, 2585 /// with source-location information. 2586 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 2587 2588 /// If the member name was qualified, retrieves the 2589 /// nested-name-specifier that precedes the member name. Otherwise, returns 2590 /// null. 2591 NestedNameSpecifier *getQualifier() const { 2592 return QualifierLoc.getNestedNameSpecifier(); 2593 } 2594 2595 /// Determine whether this pseudo-destructor expression was written 2596 /// using an '->' (otherwise, it used a '.'). 2597 bool isArrow() const { return IsArrow; } 2598 2599 /// Retrieve the location of the '.' or '->' operator. 2600 SourceLocation getOperatorLoc() const { return OperatorLoc; } 2601 2602 /// Retrieve the scope type in a qualified pseudo-destructor 2603 /// expression. 2604 /// 2605 /// Pseudo-destructor expressions can have extra qualification within them 2606 /// that is not part of the nested-name-specifier, e.g., \c p->T::~T(). 2607 /// Here, if the object type of the expression is (or may be) a scalar type, 2608 /// \p T may also be a scalar type and, therefore, cannot be part of a 2609 /// nested-name-specifier. It is stored as the "scope type" of the pseudo- 2610 /// destructor expression. 2611 TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; } 2612 2613 /// Retrieve the location of the '::' in a qualified pseudo-destructor 2614 /// expression. 2615 SourceLocation getColonColonLoc() const { return ColonColonLoc; } 2616 2617 /// Retrieve the location of the '~'. 2618 SourceLocation getTildeLoc() const { return TildeLoc; } 2619 2620 /// Retrieve the source location information for the type 2621 /// being destroyed. 2622 /// 2623 /// This type-source information is available for non-dependent 2624 /// pseudo-destructor expressions and some dependent pseudo-destructor 2625 /// expressions. Returns null if we only have the identifier for a 2626 /// dependent pseudo-destructor expression. 2627 TypeSourceInfo *getDestroyedTypeInfo() const { 2628 return DestroyedType.getTypeSourceInfo(); 2629 } 2630 2631 /// In a dependent pseudo-destructor expression for which we do not 2632 /// have full type information on the destroyed type, provides the name 2633 /// of the destroyed type. 2634 IdentifierInfo *getDestroyedTypeIdentifier() const { 2635 return DestroyedType.getIdentifier(); 2636 } 2637 2638 /// Retrieve the type being destroyed. 2639 QualType getDestroyedType() const; 2640 2641 /// Retrieve the starting location of the type being destroyed. 2642 SourceLocation getDestroyedTypeLoc() const { 2643 return DestroyedType.getLocation(); 2644 } 2645 2646 /// Set the name of destroyed type for a dependent pseudo-destructor 2647 /// expression. 2648 void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) { 2649 DestroyedType = PseudoDestructorTypeStorage(II, Loc); 2650 } 2651 2652 /// Set the destroyed type. 2653 void setDestroyedType(TypeSourceInfo *Info) { 2654 DestroyedType = PseudoDestructorTypeStorage(Info); 2655 } 2656 2657 SourceLocation getBeginLoc() const LLVM_READONLY { 2658 return Base->getBeginLoc(); 2659 } 2660 SourceLocation getEndLoc() const LLVM_READONLY; 2661 2662 static bool classof(const Stmt *T) { 2663 return T->getStmtClass() == CXXPseudoDestructorExprClass; 2664 } 2665 2666 // Iterators 2667 child_range children() { return child_range(&Base, &Base + 1); } 2668 2669 const_child_range children() const { 2670 return const_child_range(&Base, &Base + 1); 2671 } 2672 }; 2673 2674 /// A type trait used in the implementation of various C++11 and 2675 /// Library TR1 trait templates. 2676 /// 2677 /// \code 2678 /// __is_pod(int) == true 2679 /// __is_enum(std::string) == false 2680 /// __is_trivially_constructible(vector<int>, int*, int*) 2681 /// \endcode 2682 class TypeTraitExpr final 2683 : public Expr, 2684 private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> { 2685 /// The location of the type trait keyword. 2686 SourceLocation Loc; 2687 2688 /// The location of the closing parenthesis. 2689 SourceLocation RParenLoc; 2690 2691 // Note: The TypeSourceInfos for the arguments are allocated after the 2692 // TypeTraitExpr. 2693 2694 TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind, 2695 ArrayRef<TypeSourceInfo *> Args, 2696 SourceLocation RParenLoc, 2697 bool Value); 2698 2699 TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) {} 2700 2701 size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>) const { 2702 return getNumArgs(); 2703 } 2704 2705 public: 2706 friend class ASTStmtReader; 2707 friend class ASTStmtWriter; 2708 friend TrailingObjects; 2709 2710 /// Create a new type trait expression. 2711 static TypeTraitExpr *Create(const ASTContext &C, QualType T, 2712 SourceLocation Loc, TypeTrait Kind, 2713 ArrayRef<TypeSourceInfo *> Args, 2714 SourceLocation RParenLoc, 2715 bool Value); 2716 2717 static TypeTraitExpr *CreateDeserialized(const ASTContext &C, 2718 unsigned NumArgs); 2719 2720 /// Determine which type trait this expression uses. 2721 TypeTrait getTrait() const { 2722 return static_cast<TypeTrait>(TypeTraitExprBits.Kind); 2723 } 2724 2725 bool getValue() const { 2726 assert(!isValueDependent()); 2727 return TypeTraitExprBits.Value; 2728 } 2729 2730 /// Determine the number of arguments to this type trait. 2731 unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; } 2732 2733 /// Retrieve the Ith argument. 2734 TypeSourceInfo *getArg(unsigned I) const { 2735 assert(I < getNumArgs() && "Argument out-of-range"); 2736 return getArgs()[I]; 2737 } 2738 2739 /// Retrieve the argument types. 2740 ArrayRef<TypeSourceInfo *> getArgs() const { 2741 return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(), 2742 getNumArgs()); 2743 } 2744 2745 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } 2746 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } 2747 2748 static bool classof(const Stmt *T) { 2749 return T->getStmtClass() == TypeTraitExprClass; 2750 } 2751 2752 // Iterators 2753 child_range children() { 2754 return child_range(child_iterator(), child_iterator()); 2755 } 2756 2757 const_child_range children() const { 2758 return const_child_range(const_child_iterator(), const_child_iterator()); 2759 } 2760 }; 2761 2762 /// An Embarcadero array type trait, as used in the implementation of 2763 /// __array_rank and __array_extent. 2764 /// 2765 /// Example: 2766 /// \code 2767 /// __array_rank(int[10][20]) == 2 2768 /// __array_extent(int, 1) == 20 2769 /// \endcode 2770 class ArrayTypeTraitExpr : public Expr { 2771 /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned. 2772 unsigned ATT : 2; 2773 2774 /// The value of the type trait. Unspecified if dependent. 2775 uint64_t Value = 0; 2776 2777 /// The array dimension being queried, or -1 if not used. 2778 Expr *Dimension; 2779 2780 /// The location of the type trait keyword. 2781 SourceLocation Loc; 2782 2783 /// The location of the closing paren. 2784 SourceLocation RParen; 2785 2786 /// The type being queried. 2787 TypeSourceInfo *QueriedType = nullptr; 2788 2789 public: 2790 friend class ASTStmtReader; 2791 2792 ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att, 2793 TypeSourceInfo *queried, uint64_t value, Expr *dimension, 2794 SourceLocation rparen, QualType ty) 2795 : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att), 2796 Value(value), Dimension(dimension), Loc(loc), RParen(rparen), 2797 QueriedType(queried) { 2798 assert(att <= ATT_Last && "invalid enum value!"); 2799 assert(static_cast<unsigned>(att) == ATT && "ATT overflow!"); 2800 setDependence(computeDependence(this)); 2801 } 2802 2803 explicit ArrayTypeTraitExpr(EmptyShell Empty) 2804 : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {} 2805 2806 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } 2807 SourceLocation getEndLoc() const LLVM_READONLY { return RParen; } 2808 2809 ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); } 2810 2811 QualType getQueriedType() const { return QueriedType->getType(); } 2812 2813 TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; } 2814 2815 uint64_t getValue() const { assert(!isTypeDependent()); return Value; } 2816 2817 Expr *getDimensionExpression() const { return Dimension; } 2818 2819 static bool classof(const Stmt *T) { 2820 return T->getStmtClass() == ArrayTypeTraitExprClass; 2821 } 2822 2823 // Iterators 2824 child_range children() { 2825 return child_range(child_iterator(), child_iterator()); 2826 } 2827 2828 const_child_range children() const { 2829 return const_child_range(const_child_iterator(), const_child_iterator()); 2830 } 2831 }; 2832 2833 /// An expression trait intrinsic. 2834 /// 2835 /// Example: 2836 /// \code 2837 /// __is_lvalue_expr(std::cout) == true 2838 /// __is_lvalue_expr(1) == false 2839 /// \endcode 2840 class ExpressionTraitExpr : public Expr { 2841 /// The trait. A ExpressionTrait enum in MSVC compatible unsigned. 2842 unsigned ET : 31; 2843 2844 /// The value of the type trait. Unspecified if dependent. 2845 unsigned Value : 1; 2846 2847 /// The location of the type trait keyword. 2848 SourceLocation Loc; 2849 2850 /// The location of the closing paren. 2851 SourceLocation RParen; 2852 2853 /// The expression being queried. 2854 Expr* QueriedExpression = nullptr; 2855 2856 public: 2857 friend class ASTStmtReader; 2858 2859 ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried, 2860 bool value, SourceLocation rparen, QualType resultType) 2861 : Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary), 2862 ET(et), Value(value), Loc(loc), RParen(rparen), 2863 QueriedExpression(queried) { 2864 assert(et <= ET_Last && "invalid enum value!"); 2865 assert(static_cast<unsigned>(et) == ET && "ET overflow!"); 2866 setDependence(computeDependence(this)); 2867 } 2868 2869 explicit ExpressionTraitExpr(EmptyShell Empty) 2870 : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {} 2871 2872 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } 2873 SourceLocation getEndLoc() const LLVM_READONLY { return RParen; } 2874 2875 ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); } 2876 2877 Expr *getQueriedExpression() const { return QueriedExpression; } 2878 2879 bool getValue() const { return Value; } 2880 2881 static bool classof(const Stmt *T) { 2882 return T->getStmtClass() == ExpressionTraitExprClass; 2883 } 2884 2885 // Iterators 2886 child_range children() { 2887 return child_range(child_iterator(), child_iterator()); 2888 } 2889 2890 const_child_range children() const { 2891 return const_child_range(const_child_iterator(), const_child_iterator()); 2892 } 2893 }; 2894 2895 /// A reference to an overloaded function set, either an 2896 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr. 2897 class OverloadExpr : public Expr { 2898 friend class ASTStmtReader; 2899 friend class ASTStmtWriter; 2900 2901 /// The common name of these declarations. 2902 DeclarationNameInfo NameInfo; 2903 2904 /// The nested-name-specifier that qualifies the name, if any. 2905 NestedNameSpecifierLoc QualifierLoc; 2906 2907 protected: 2908 OverloadExpr(StmtClass SC, const ASTContext &Context, 2909 NestedNameSpecifierLoc QualifierLoc, 2910 SourceLocation TemplateKWLoc, 2911 const DeclarationNameInfo &NameInfo, 2912 const TemplateArgumentListInfo *TemplateArgs, 2913 UnresolvedSetIterator Begin, UnresolvedSetIterator End, 2914 bool KnownDependent, bool KnownInstantiationDependent, 2915 bool KnownContainsUnexpandedParameterPack); 2916 2917 OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults, 2918 bool HasTemplateKWAndArgsInfo); 2919 2920 /// Return the results. Defined after UnresolvedMemberExpr. 2921 inline DeclAccessPair *getTrailingResults(); 2922 const DeclAccessPair *getTrailingResults() const { 2923 return const_cast<OverloadExpr *>(this)->getTrailingResults(); 2924 } 2925 2926 /// Return the optional template keyword and arguments info. 2927 /// Defined after UnresolvedMemberExpr. 2928 inline ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo(); 2929 const ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo() const { 2930 return const_cast<OverloadExpr *>(this) 2931 ->getTrailingASTTemplateKWAndArgsInfo(); 2932 } 2933 2934 /// Return the optional template arguments. Defined after 2935 /// UnresolvedMemberExpr. 2936 inline TemplateArgumentLoc *getTrailingTemplateArgumentLoc(); 2937 const TemplateArgumentLoc *getTrailingTemplateArgumentLoc() const { 2938 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc(); 2939 } 2940 2941 bool hasTemplateKWAndArgsInfo() const { 2942 return OverloadExprBits.HasTemplateKWAndArgsInfo; 2943 } 2944 2945 public: 2946 struct FindResult { 2947 OverloadExpr *Expression; 2948 bool IsAddressOfOperand; 2949 bool HasFormOfMemberPointer; 2950 }; 2951 2952 /// Finds the overloaded expression in the given expression \p E of 2953 /// OverloadTy. 2954 /// 2955 /// \return the expression (which must be there) and true if it has 2956 /// the particular form of a member pointer expression 2957 static FindResult find(Expr *E) { 2958 assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload)); 2959 2960 FindResult Result; 2961 2962 E = E->IgnoreParens(); 2963 if (isa<UnaryOperator>(E)) { 2964 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf); 2965 E = cast<UnaryOperator>(E)->getSubExpr(); 2966 auto *Ovl = cast<OverloadExpr>(E->IgnoreParens()); 2967 2968 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier()); 2969 Result.IsAddressOfOperand = true; 2970 Result.Expression = Ovl; 2971 } else { 2972 Result.HasFormOfMemberPointer = false; 2973 Result.IsAddressOfOperand = false; 2974 Result.Expression = cast<OverloadExpr>(E); 2975 } 2976 2977 return Result; 2978 } 2979 2980 /// Gets the naming class of this lookup, if any. 2981 /// Defined after UnresolvedMemberExpr. 2982 inline CXXRecordDecl *getNamingClass(); 2983 const CXXRecordDecl *getNamingClass() const { 2984 return const_cast<OverloadExpr *>(this)->getNamingClass(); 2985 } 2986 2987 using decls_iterator = UnresolvedSetImpl::iterator; 2988 2989 decls_iterator decls_begin() const { 2990 return UnresolvedSetIterator(getTrailingResults()); 2991 } 2992 decls_iterator decls_end() const { 2993 return UnresolvedSetIterator(getTrailingResults() + getNumDecls()); 2994 } 2995 llvm::iterator_range<decls_iterator> decls() const { 2996 return llvm::make_range(decls_begin(), decls_end()); 2997 } 2998 2999 /// Gets the number of declarations in the unresolved set. 3000 unsigned getNumDecls() const { return OverloadExprBits.NumResults; } 3001 3002 /// Gets the full name info. 3003 const DeclarationNameInfo &getNameInfo() const { return NameInfo; } 3004 3005 /// Gets the name looked up. 3006 DeclarationName getName() const { return NameInfo.getName(); } 3007 3008 /// Gets the location of the name. 3009 SourceLocation getNameLoc() const { return NameInfo.getLoc(); } 3010 3011 /// Fetches the nested-name qualifier, if one was given. 3012 NestedNameSpecifier *getQualifier() const { 3013 return QualifierLoc.getNestedNameSpecifier(); 3014 } 3015 3016 /// Fetches the nested-name qualifier with source-location 3017 /// information, if one was given. 3018 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 3019 3020 /// Retrieve the location of the template keyword preceding 3021 /// this name, if any. 3022 SourceLocation getTemplateKeywordLoc() const { 3023 if (!hasTemplateKWAndArgsInfo()) 3024 return SourceLocation(); 3025 return getTrailingASTTemplateKWAndArgsInfo()->TemplateKWLoc; 3026 } 3027 3028 /// Retrieve the location of the left angle bracket starting the 3029 /// explicit template argument list following the name, if any. 3030 SourceLocation getLAngleLoc() const { 3031 if (!hasTemplateKWAndArgsInfo()) 3032 return SourceLocation(); 3033 return getTrailingASTTemplateKWAndArgsInfo()->LAngleLoc; 3034 } 3035 3036 /// Retrieve the location of the right angle bracket ending the 3037 /// explicit template argument list following the name, if any. 3038 SourceLocation getRAngleLoc() const { 3039 if (!hasTemplateKWAndArgsInfo()) 3040 return SourceLocation(); 3041 return getTrailingASTTemplateKWAndArgsInfo()->RAngleLoc; 3042 } 3043 3044 /// Determines whether the name was preceded by the template keyword. 3045 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } 3046 3047 /// Determines whether this expression had explicit template arguments. 3048 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); } 3049 3050 TemplateArgumentLoc const *getTemplateArgs() const { 3051 if (!hasExplicitTemplateArgs()) 3052 return nullptr; 3053 return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc(); 3054 } 3055 3056 unsigned getNumTemplateArgs() const { 3057 if (!hasExplicitTemplateArgs()) 3058 return 0; 3059 3060 return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs; 3061 } 3062 3063 ArrayRef<TemplateArgumentLoc> template_arguments() const { 3064 return {getTemplateArgs(), getNumTemplateArgs()}; 3065 } 3066 3067 /// Copies the template arguments into the given structure. 3068 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3069 if (hasExplicitTemplateArgs()) 3070 getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List); 3071 } 3072 3073 static bool classof(const Stmt *T) { 3074 return T->getStmtClass() == UnresolvedLookupExprClass || 3075 T->getStmtClass() == UnresolvedMemberExprClass; 3076 } 3077 }; 3078 3079 /// A reference to a name which we were able to look up during 3080 /// parsing but could not resolve to a specific declaration. 3081 /// 3082 /// This arises in several ways: 3083 /// * we might be waiting for argument-dependent lookup; 3084 /// * the name might resolve to an overloaded function; 3085 /// and eventually: 3086 /// * the lookup might have included a function template. 3087 /// 3088 /// These never include UnresolvedUsingValueDecls, which are always class 3089 /// members and therefore appear only in UnresolvedMemberLookupExprs. 3090 class UnresolvedLookupExpr final 3091 : public OverloadExpr, 3092 private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair, 3093 ASTTemplateKWAndArgsInfo, 3094 TemplateArgumentLoc> { 3095 friend class ASTStmtReader; 3096 friend class OverloadExpr; 3097 friend TrailingObjects; 3098 3099 /// The naming class (C++ [class.access.base]p5) of the lookup, if 3100 /// any. This can generally be recalculated from the context chain, 3101 /// but that can be fairly expensive for unqualified lookups. 3102 CXXRecordDecl *NamingClass; 3103 3104 // UnresolvedLookupExpr is followed by several trailing objects. 3105 // They are in order: 3106 // 3107 // * An array of getNumResults() DeclAccessPair for the results. These are 3108 // undesugared, which is to say, they may include UsingShadowDecls. 3109 // Access is relative to the naming class. 3110 // 3111 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3112 // template keyword and arguments. Present if and only if 3113 // hasTemplateKWAndArgsInfo(). 3114 // 3115 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing 3116 // location information for the explicitly specified template arguments. 3117 3118 UnresolvedLookupExpr(const ASTContext &Context, CXXRecordDecl *NamingClass, 3119 NestedNameSpecifierLoc QualifierLoc, 3120 SourceLocation TemplateKWLoc, 3121 const DeclarationNameInfo &NameInfo, bool RequiresADL, 3122 bool Overloaded, 3123 const TemplateArgumentListInfo *TemplateArgs, 3124 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3125 3126 UnresolvedLookupExpr(EmptyShell Empty, unsigned NumResults, 3127 bool HasTemplateKWAndArgsInfo); 3128 3129 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const { 3130 return getNumDecls(); 3131 } 3132 3133 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { 3134 return hasTemplateKWAndArgsInfo(); 3135 } 3136 3137 public: 3138 static UnresolvedLookupExpr * 3139 Create(const ASTContext &Context, CXXRecordDecl *NamingClass, 3140 NestedNameSpecifierLoc QualifierLoc, 3141 const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, 3142 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3143 3144 static UnresolvedLookupExpr * 3145 Create(const ASTContext &Context, CXXRecordDecl *NamingClass, 3146 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, 3147 const DeclarationNameInfo &NameInfo, bool RequiresADL, 3148 const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin, 3149 UnresolvedSetIterator End); 3150 3151 static UnresolvedLookupExpr *CreateEmpty(const ASTContext &Context, 3152 unsigned NumResults, 3153 bool HasTemplateKWAndArgsInfo, 3154 unsigned NumTemplateArgs); 3155 3156 /// True if this declaration should be extended by 3157 /// argument-dependent lookup. 3158 bool requiresADL() const { return UnresolvedLookupExprBits.RequiresADL; } 3159 3160 /// True if this lookup is overloaded. 3161 bool isOverloaded() const { return UnresolvedLookupExprBits.Overloaded; } 3162 3163 /// Gets the 'naming class' (in the sense of C++0x 3164 /// [class.access.base]p5) of the lookup. This is the scope 3165 /// that was looked in to find these results. 3166 CXXRecordDecl *getNamingClass() { return NamingClass; } 3167 const CXXRecordDecl *getNamingClass() const { return NamingClass; } 3168 3169 SourceLocation getBeginLoc() const LLVM_READONLY { 3170 if (NestedNameSpecifierLoc l = getQualifierLoc()) 3171 return l.getBeginLoc(); 3172 return getNameInfo().getBeginLoc(); 3173 } 3174 3175 SourceLocation getEndLoc() const LLVM_READONLY { 3176 if (hasExplicitTemplateArgs()) 3177 return getRAngleLoc(); 3178 return getNameInfo().getEndLoc(); 3179 } 3180 3181 child_range children() { 3182 return child_range(child_iterator(), child_iterator()); 3183 } 3184 3185 const_child_range children() const { 3186 return const_child_range(const_child_iterator(), const_child_iterator()); 3187 } 3188 3189 static bool classof(const Stmt *T) { 3190 return T->getStmtClass() == UnresolvedLookupExprClass; 3191 } 3192 }; 3193 3194 /// A qualified reference to a name whose declaration cannot 3195 /// yet be resolved. 3196 /// 3197 /// DependentScopeDeclRefExpr is similar to DeclRefExpr in that 3198 /// it expresses a reference to a declaration such as 3199 /// X<T>::value. The difference, however, is that an 3200 /// DependentScopeDeclRefExpr node is used only within C++ templates when 3201 /// the qualification (e.g., X<T>::) refers to a dependent type. In 3202 /// this case, X<T>::value cannot resolve to a declaration because the 3203 /// declaration will differ from one instantiation of X<T> to the 3204 /// next. Therefore, DependentScopeDeclRefExpr keeps track of the 3205 /// qualifier (X<T>::) and the name of the entity being referenced 3206 /// ("value"). Such expressions will instantiate to a DeclRefExpr once the 3207 /// declaration can be found. 3208 class DependentScopeDeclRefExpr final 3209 : public Expr, 3210 private llvm::TrailingObjects<DependentScopeDeclRefExpr, 3211 ASTTemplateKWAndArgsInfo, 3212 TemplateArgumentLoc> { 3213 friend class ASTStmtReader; 3214 friend class ASTStmtWriter; 3215 friend TrailingObjects; 3216 3217 /// The nested-name-specifier that qualifies this unresolved 3218 /// declaration name. 3219 NestedNameSpecifierLoc QualifierLoc; 3220 3221 /// The name of the entity we will be referencing. 3222 DeclarationNameInfo NameInfo; 3223 3224 DependentScopeDeclRefExpr(QualType Ty, NestedNameSpecifierLoc QualifierLoc, 3225 SourceLocation TemplateKWLoc, 3226 const DeclarationNameInfo &NameInfo, 3227 const TemplateArgumentListInfo *Args); 3228 3229 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { 3230 return hasTemplateKWAndArgsInfo(); 3231 } 3232 3233 bool hasTemplateKWAndArgsInfo() const { 3234 return DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo; 3235 } 3236 3237 public: 3238 static DependentScopeDeclRefExpr * 3239 Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, 3240 SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, 3241 const TemplateArgumentListInfo *TemplateArgs); 3242 3243 static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &Context, 3244 bool HasTemplateKWAndArgsInfo, 3245 unsigned NumTemplateArgs); 3246 3247 /// Retrieve the name that this expression refers to. 3248 const DeclarationNameInfo &getNameInfo() const { return NameInfo; } 3249 3250 /// Retrieve the name that this expression refers to. 3251 DeclarationName getDeclName() const { return NameInfo.getName(); } 3252 3253 /// Retrieve the location of the name within the expression. 3254 /// 3255 /// For example, in "X<T>::value" this is the location of "value". 3256 SourceLocation getLocation() const { return NameInfo.getLoc(); } 3257 3258 /// Retrieve the nested-name-specifier that qualifies the 3259 /// name, with source location information. 3260 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 3261 3262 /// Retrieve the nested-name-specifier that qualifies this 3263 /// declaration. 3264 NestedNameSpecifier *getQualifier() const { 3265 return QualifierLoc.getNestedNameSpecifier(); 3266 } 3267 3268 /// Retrieve the location of the template keyword preceding 3269 /// this name, if any. 3270 SourceLocation getTemplateKeywordLoc() const { 3271 if (!hasTemplateKWAndArgsInfo()) 3272 return SourceLocation(); 3273 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; 3274 } 3275 3276 /// Retrieve the location of the left angle bracket starting the 3277 /// explicit template argument list following the name, if any. 3278 SourceLocation getLAngleLoc() const { 3279 if (!hasTemplateKWAndArgsInfo()) 3280 return SourceLocation(); 3281 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; 3282 } 3283 3284 /// Retrieve the location of the right angle bracket ending the 3285 /// explicit template argument list following the name, if any. 3286 SourceLocation getRAngleLoc() const { 3287 if (!hasTemplateKWAndArgsInfo()) 3288 return SourceLocation(); 3289 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; 3290 } 3291 3292 /// Determines whether the name was preceded by the template keyword. 3293 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } 3294 3295 /// Determines whether this lookup had explicit template arguments. 3296 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); } 3297 3298 /// Copies the template arguments (if present) into the given 3299 /// structure. 3300 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3301 if (hasExplicitTemplateArgs()) 3302 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( 3303 getTrailingObjects<TemplateArgumentLoc>(), List); 3304 } 3305 3306 TemplateArgumentLoc const *getTemplateArgs() const { 3307 if (!hasExplicitTemplateArgs()) 3308 return nullptr; 3309 3310 return getTrailingObjects<TemplateArgumentLoc>(); 3311 } 3312 3313 unsigned getNumTemplateArgs() const { 3314 if (!hasExplicitTemplateArgs()) 3315 return 0; 3316 3317 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs; 3318 } 3319 3320 ArrayRef<TemplateArgumentLoc> template_arguments() const { 3321 return {getTemplateArgs(), getNumTemplateArgs()}; 3322 } 3323 3324 /// Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr, 3325 /// and differs from getLocation().getStart(). 3326 SourceLocation getBeginLoc() const LLVM_READONLY { 3327 return QualifierLoc.getBeginLoc(); 3328 } 3329 3330 SourceLocation getEndLoc() const LLVM_READONLY { 3331 if (hasExplicitTemplateArgs()) 3332 return getRAngleLoc(); 3333 return getLocation(); 3334 } 3335 3336 static bool classof(const Stmt *T) { 3337 return T->getStmtClass() == DependentScopeDeclRefExprClass; 3338 } 3339 3340 child_range children() { 3341 return child_range(child_iterator(), child_iterator()); 3342 } 3343 3344 const_child_range children() const { 3345 return const_child_range(const_child_iterator(), const_child_iterator()); 3346 } 3347 }; 3348 3349 /// Represents an expression -- generally a full-expression -- that 3350 /// introduces cleanups to be run at the end of the sub-expression's 3351 /// evaluation. The most common source of expression-introduced 3352 /// cleanups is temporary objects in C++, but several other kinds of 3353 /// expressions can create cleanups, including basically every 3354 /// call in ARC that returns an Objective-C pointer. 3355 /// 3356 /// This expression also tracks whether the sub-expression contains a 3357 /// potentially-evaluated block literal. The lifetime of a block 3358 /// literal is the extent of the enclosing scope. 3359 class ExprWithCleanups final 3360 : public FullExpr, 3361 private llvm::TrailingObjects< 3362 ExprWithCleanups, 3363 llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> { 3364 public: 3365 /// The type of objects that are kept in the cleanup. 3366 /// It's useful to remember the set of blocks and block-scoped compound 3367 /// literals; we could also remember the set of temporaries, but there's 3368 /// currently no need. 3369 using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>; 3370 3371 private: 3372 friend class ASTStmtReader; 3373 friend TrailingObjects; 3374 3375 ExprWithCleanups(EmptyShell, unsigned NumObjects); 3376 ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects, 3377 ArrayRef<CleanupObject> Objects); 3378 3379 public: 3380 static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty, 3381 unsigned numObjects); 3382 3383 static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr, 3384 bool CleanupsHaveSideEffects, 3385 ArrayRef<CleanupObject> objects); 3386 3387 ArrayRef<CleanupObject> getObjects() const { 3388 return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(), 3389 getNumObjects()); 3390 } 3391 3392 unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; } 3393 3394 CleanupObject getObject(unsigned i) const { 3395 assert(i < getNumObjects() && "Index out of range"); 3396 return getObjects()[i]; 3397 } 3398 3399 bool cleanupsHaveSideEffects() const { 3400 return ExprWithCleanupsBits.CleanupsHaveSideEffects; 3401 } 3402 3403 SourceLocation getBeginLoc() const LLVM_READONLY { 3404 return SubExpr->getBeginLoc(); 3405 } 3406 3407 SourceLocation getEndLoc() const LLVM_READONLY { 3408 return SubExpr->getEndLoc(); 3409 } 3410 3411 // Implement isa/cast/dyncast/etc. 3412 static bool classof(const Stmt *T) { 3413 return T->getStmtClass() == ExprWithCleanupsClass; 3414 } 3415 3416 // Iterators 3417 child_range children() { return child_range(&SubExpr, &SubExpr + 1); } 3418 3419 const_child_range children() const { 3420 return const_child_range(&SubExpr, &SubExpr + 1); 3421 } 3422 }; 3423 3424 /// Describes an explicit type conversion that uses functional 3425 /// notion but could not be resolved because one or more arguments are 3426 /// type-dependent. 3427 /// 3428 /// The explicit type conversions expressed by 3429 /// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>, 3430 /// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and 3431 /// either \c T is a dependent type or one or more of the <tt>a</tt>'s is 3432 /// type-dependent. For example, this would occur in a template such 3433 /// as: 3434 /// 3435 /// \code 3436 /// template<typename T, typename A1> 3437 /// inline T make_a(const A1& a1) { 3438 /// return T(a1); 3439 /// } 3440 /// \endcode 3441 /// 3442 /// When the returned expression is instantiated, it may resolve to a 3443 /// constructor call, conversion function call, or some kind of type 3444 /// conversion. 3445 class CXXUnresolvedConstructExpr final 3446 : public Expr, 3447 private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> { 3448 friend class ASTStmtReader; 3449 friend TrailingObjects; 3450 3451 /// The type being constructed. 3452 TypeSourceInfo *TSI; 3453 3454 /// The location of the left parentheses ('('). 3455 SourceLocation LParenLoc; 3456 3457 /// The location of the right parentheses (')'). 3458 SourceLocation RParenLoc; 3459 3460 CXXUnresolvedConstructExpr(QualType T, TypeSourceInfo *TSI, 3461 SourceLocation LParenLoc, ArrayRef<Expr *> Args, 3462 SourceLocation RParenLoc); 3463 3464 CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs) 3465 : Expr(CXXUnresolvedConstructExprClass, Empty), TSI(nullptr) { 3466 CXXUnresolvedConstructExprBits.NumArgs = NumArgs; 3467 } 3468 3469 public: 3470 static CXXUnresolvedConstructExpr *Create(const ASTContext &Context, 3471 QualType T, TypeSourceInfo *TSI, 3472 SourceLocation LParenLoc, 3473 ArrayRef<Expr *> Args, 3474 SourceLocation RParenLoc); 3475 3476 static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &Context, 3477 unsigned NumArgs); 3478 3479 /// Retrieve the type that is being constructed, as specified 3480 /// in the source code. 3481 QualType getTypeAsWritten() const { return TSI->getType(); } 3482 3483 /// Retrieve the type source information for the type being 3484 /// constructed. 3485 TypeSourceInfo *getTypeSourceInfo() const { return TSI; } 3486 3487 /// Retrieve the location of the left parentheses ('(') that 3488 /// precedes the argument list. 3489 SourceLocation getLParenLoc() const { return LParenLoc; } 3490 void setLParenLoc(SourceLocation L) { LParenLoc = L; } 3491 3492 /// Retrieve the location of the right parentheses (')') that 3493 /// follows the argument list. 3494 SourceLocation getRParenLoc() const { return RParenLoc; } 3495 void setRParenLoc(SourceLocation L) { RParenLoc = L; } 3496 3497 /// Determine whether this expression models list-initialization. 3498 /// If so, there will be exactly one subexpression, which will be 3499 /// an InitListExpr. 3500 bool isListInitialization() const { return LParenLoc.isInvalid(); } 3501 3502 /// Retrieve the number of arguments. 3503 unsigned getNumArgs() const { return CXXUnresolvedConstructExprBits.NumArgs; } 3504 3505 using arg_iterator = Expr **; 3506 using arg_range = llvm::iterator_range<arg_iterator>; 3507 3508 arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); } 3509 arg_iterator arg_end() { return arg_begin() + getNumArgs(); } 3510 arg_range arguments() { return arg_range(arg_begin(), arg_end()); } 3511 3512 using const_arg_iterator = const Expr* const *; 3513 using const_arg_range = llvm::iterator_range<const_arg_iterator>; 3514 3515 const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); } 3516 const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); } 3517 const_arg_range arguments() const { 3518 return const_arg_range(arg_begin(), arg_end()); 3519 } 3520 3521 Expr *getArg(unsigned I) { 3522 assert(I < getNumArgs() && "Argument index out-of-range"); 3523 return arg_begin()[I]; 3524 } 3525 3526 const Expr *getArg(unsigned I) const { 3527 assert(I < getNumArgs() && "Argument index out-of-range"); 3528 return arg_begin()[I]; 3529 } 3530 3531 void setArg(unsigned I, Expr *E) { 3532 assert(I < getNumArgs() && "Argument index out-of-range"); 3533 arg_begin()[I] = E; 3534 } 3535 3536 SourceLocation getBeginLoc() const LLVM_READONLY; 3537 SourceLocation getEndLoc() const LLVM_READONLY { 3538 if (!RParenLoc.isValid() && getNumArgs() > 0) 3539 return getArg(getNumArgs() - 1)->getEndLoc(); 3540 return RParenLoc; 3541 } 3542 3543 static bool classof(const Stmt *T) { 3544 return T->getStmtClass() == CXXUnresolvedConstructExprClass; 3545 } 3546 3547 // Iterators 3548 child_range children() { 3549 auto **begin = reinterpret_cast<Stmt **>(arg_begin()); 3550 return child_range(begin, begin + getNumArgs()); 3551 } 3552 3553 const_child_range children() const { 3554 auto **begin = reinterpret_cast<Stmt **>( 3555 const_cast<CXXUnresolvedConstructExpr *>(this)->arg_begin()); 3556 return const_child_range(begin, begin + getNumArgs()); 3557 } 3558 }; 3559 3560 /// Represents a C++ member access expression where the actual 3561 /// member referenced could not be resolved because the base 3562 /// expression or the member name was dependent. 3563 /// 3564 /// Like UnresolvedMemberExprs, these can be either implicit or 3565 /// explicit accesses. It is only possible to get one of these with 3566 /// an implicit access if a qualifier is provided. 3567 class CXXDependentScopeMemberExpr final 3568 : public Expr, 3569 private llvm::TrailingObjects<CXXDependentScopeMemberExpr, 3570 ASTTemplateKWAndArgsInfo, 3571 TemplateArgumentLoc, NamedDecl *> { 3572 friend class ASTStmtReader; 3573 friend class ASTStmtWriter; 3574 friend TrailingObjects; 3575 3576 /// The expression for the base pointer or class reference, 3577 /// e.g., the \c x in x.f. Can be null in implicit accesses. 3578 Stmt *Base; 3579 3580 /// The type of the base expression. Never null, even for 3581 /// implicit accesses. 3582 QualType BaseType; 3583 3584 /// The nested-name-specifier that precedes the member name, if any. 3585 /// FIXME: This could be in principle store as a trailing object. 3586 /// However the performance impact of doing so should be investigated first. 3587 NestedNameSpecifierLoc QualifierLoc; 3588 3589 /// The member to which this member expression refers, which 3590 /// can be name, overloaded operator, or destructor. 3591 /// 3592 /// FIXME: could also be a template-id 3593 DeclarationNameInfo MemberNameInfo; 3594 3595 // CXXDependentScopeMemberExpr is followed by several trailing objects, 3596 // some of which optional. They are in order: 3597 // 3598 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3599 // template keyword and arguments. Present if and only if 3600 // hasTemplateKWAndArgsInfo(). 3601 // 3602 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing location 3603 // information for the explicitly specified template arguments. 3604 // 3605 // * An optional NamedDecl *. In a qualified member access expression such 3606 // as t->Base::f, this member stores the resolves of name lookup in the 3607 // context of the member access expression, to be used at instantiation 3608 // time. Present if and only if hasFirstQualifierFoundInScope(). 3609 3610 bool hasTemplateKWAndArgsInfo() const { 3611 return CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo; 3612 } 3613 3614 bool hasFirstQualifierFoundInScope() const { 3615 return CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope; 3616 } 3617 3618 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { 3619 return hasTemplateKWAndArgsInfo(); 3620 } 3621 3622 unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const { 3623 return getNumTemplateArgs(); 3624 } 3625 3626 unsigned numTrailingObjects(OverloadToken<NamedDecl *>) const { 3627 return hasFirstQualifierFoundInScope(); 3628 } 3629 3630 CXXDependentScopeMemberExpr(const ASTContext &Ctx, Expr *Base, 3631 QualType BaseType, bool IsArrow, 3632 SourceLocation OperatorLoc, 3633 NestedNameSpecifierLoc QualifierLoc, 3634 SourceLocation TemplateKWLoc, 3635 NamedDecl *FirstQualifierFoundInScope, 3636 DeclarationNameInfo MemberNameInfo, 3637 const TemplateArgumentListInfo *TemplateArgs); 3638 3639 CXXDependentScopeMemberExpr(EmptyShell Empty, bool HasTemplateKWAndArgsInfo, 3640 bool HasFirstQualifierFoundInScope); 3641 3642 public: 3643 static CXXDependentScopeMemberExpr * 3644 Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, 3645 SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, 3646 SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, 3647 DeclarationNameInfo MemberNameInfo, 3648 const TemplateArgumentListInfo *TemplateArgs); 3649 3650 static CXXDependentScopeMemberExpr * 3651 CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, 3652 unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope); 3653 3654 /// True if this is an implicit access, i.e. one in which the 3655 /// member being accessed was not written in the source. The source 3656 /// location of the operator is invalid in this case. 3657 bool isImplicitAccess() const { 3658 if (!Base) 3659 return true; 3660 return cast<Expr>(Base)->isImplicitCXXThis(); 3661 } 3662 3663 /// Retrieve the base object of this member expressions, 3664 /// e.g., the \c x in \c x.m. 3665 Expr *getBase() const { 3666 assert(!isImplicitAccess()); 3667 return cast<Expr>(Base); 3668 } 3669 3670 QualType getBaseType() const { return BaseType; } 3671 3672 /// Determine whether this member expression used the '->' 3673 /// operator; otherwise, it used the '.' operator. 3674 bool isArrow() const { return CXXDependentScopeMemberExprBits.IsArrow; } 3675 3676 /// Retrieve the location of the '->' or '.' operator. 3677 SourceLocation getOperatorLoc() const { 3678 return CXXDependentScopeMemberExprBits.OperatorLoc; 3679 } 3680 3681 /// Retrieve the nested-name-specifier that qualifies the member name. 3682 NestedNameSpecifier *getQualifier() const { 3683 return QualifierLoc.getNestedNameSpecifier(); 3684 } 3685 3686 /// Retrieve the nested-name-specifier that qualifies the member 3687 /// name, with source location information. 3688 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 3689 3690 /// Retrieve the first part of the nested-name-specifier that was 3691 /// found in the scope of the member access expression when the member access 3692 /// was initially parsed. 3693 /// 3694 /// This function only returns a useful result when member access expression 3695 /// uses a qualified member name, e.g., "x.Base::f". Here, the declaration 3696 /// returned by this function describes what was found by unqualified name 3697 /// lookup for the identifier "Base" within the scope of the member access 3698 /// expression itself. At template instantiation time, this information is 3699 /// combined with the results of name lookup into the type of the object 3700 /// expression itself (the class type of x). 3701 NamedDecl *getFirstQualifierFoundInScope() const { 3702 if (!hasFirstQualifierFoundInScope()) 3703 return nullptr; 3704 return *getTrailingObjects<NamedDecl *>(); 3705 } 3706 3707 /// Retrieve the name of the member that this expression refers to. 3708 const DeclarationNameInfo &getMemberNameInfo() const { 3709 return MemberNameInfo; 3710 } 3711 3712 /// Retrieve the name of the member that this expression refers to. 3713 DeclarationName getMember() const { return MemberNameInfo.getName(); } 3714 3715 // Retrieve the location of the name of the member that this 3716 // expression refers to. 3717 SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); } 3718 3719 /// Retrieve the location of the template keyword preceding the 3720 /// member name, if any. 3721 SourceLocation getTemplateKeywordLoc() const { 3722 if (!hasTemplateKWAndArgsInfo()) 3723 return SourceLocation(); 3724 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; 3725 } 3726 3727 /// Retrieve the location of the left angle bracket starting the 3728 /// explicit template argument list following the member name, if any. 3729 SourceLocation getLAngleLoc() const { 3730 if (!hasTemplateKWAndArgsInfo()) 3731 return SourceLocation(); 3732 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; 3733 } 3734 3735 /// Retrieve the location of the right angle bracket ending the 3736 /// explicit template argument list following the member name, if any. 3737 SourceLocation getRAngleLoc() const { 3738 if (!hasTemplateKWAndArgsInfo()) 3739 return SourceLocation(); 3740 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; 3741 } 3742 3743 /// Determines whether the member name was preceded by the template keyword. 3744 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } 3745 3746 /// Determines whether this member expression actually had a C++ 3747 /// template argument list explicitly specified, e.g., x.f<int>. 3748 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); } 3749 3750 /// Copies the template arguments (if present) into the given 3751 /// structure. 3752 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { 3753 if (hasExplicitTemplateArgs()) 3754 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( 3755 getTrailingObjects<TemplateArgumentLoc>(), List); 3756 } 3757 3758 /// Retrieve the template arguments provided as part of this 3759 /// template-id. 3760 const TemplateArgumentLoc *getTemplateArgs() const { 3761 if (!hasExplicitTemplateArgs()) 3762 return nullptr; 3763 3764 return getTrailingObjects<TemplateArgumentLoc>(); 3765 } 3766 3767 /// Retrieve the number of template arguments provided as part of this 3768 /// template-id. 3769 unsigned getNumTemplateArgs() const { 3770 if (!hasExplicitTemplateArgs()) 3771 return 0; 3772 3773 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs; 3774 } 3775 3776 ArrayRef<TemplateArgumentLoc> template_arguments() const { 3777 return {getTemplateArgs(), getNumTemplateArgs()}; 3778 } 3779 3780 SourceLocation getBeginLoc() const LLVM_READONLY { 3781 if (!isImplicitAccess()) 3782 return Base->getBeginLoc(); 3783 if (getQualifier()) 3784 return getQualifierLoc().getBeginLoc(); 3785 return MemberNameInfo.getBeginLoc(); 3786 } 3787 3788 SourceLocation getEndLoc() const LLVM_READONLY { 3789 if (hasExplicitTemplateArgs()) 3790 return getRAngleLoc(); 3791 return MemberNameInfo.getEndLoc(); 3792 } 3793 3794 static bool classof(const Stmt *T) { 3795 return T->getStmtClass() == CXXDependentScopeMemberExprClass; 3796 } 3797 3798 // Iterators 3799 child_range children() { 3800 if (isImplicitAccess()) 3801 return child_range(child_iterator(), child_iterator()); 3802 return child_range(&Base, &Base + 1); 3803 } 3804 3805 const_child_range children() const { 3806 if (isImplicitAccess()) 3807 return const_child_range(const_child_iterator(), const_child_iterator()); 3808 return const_child_range(&Base, &Base + 1); 3809 } 3810 }; 3811 3812 /// Represents a C++ member access expression for which lookup 3813 /// produced a set of overloaded functions. 3814 /// 3815 /// The member access may be explicit or implicit: 3816 /// \code 3817 /// struct A { 3818 /// int a, b; 3819 /// int explicitAccess() { return this->a + this->A::b; } 3820 /// int implicitAccess() { return a + A::b; } 3821 /// }; 3822 /// \endcode 3823 /// 3824 /// In the final AST, an explicit access always becomes a MemberExpr. 3825 /// An implicit access may become either a MemberExpr or a 3826 /// DeclRefExpr, depending on whether the member is static. 3827 class UnresolvedMemberExpr final 3828 : public OverloadExpr, 3829 private llvm::TrailingObjects<UnresolvedMemberExpr, DeclAccessPair, 3830 ASTTemplateKWAndArgsInfo, 3831 TemplateArgumentLoc> { 3832 friend class ASTStmtReader; 3833 friend class OverloadExpr; 3834 friend TrailingObjects; 3835 3836 /// The expression for the base pointer or class reference, 3837 /// e.g., the \c x in x.f. 3838 /// 3839 /// This can be null if this is an 'unbased' member expression. 3840 Stmt *Base; 3841 3842 /// The type of the base expression; never null. 3843 QualType BaseType; 3844 3845 /// The location of the '->' or '.' operator. 3846 SourceLocation OperatorLoc; 3847 3848 // UnresolvedMemberExpr is followed by several trailing objects. 3849 // They are in order: 3850 // 3851 // * An array of getNumResults() DeclAccessPair for the results. These are 3852 // undesugared, which is to say, they may include UsingShadowDecls. 3853 // Access is relative to the naming class. 3854 // 3855 // * An optional ASTTemplateKWAndArgsInfo for the explicitly specified 3856 // template keyword and arguments. Present if and only if 3857 // hasTemplateKWAndArgsInfo(). 3858 // 3859 // * An array of getNumTemplateArgs() TemplateArgumentLoc containing 3860 // location information for the explicitly specified template arguments. 3861 3862 UnresolvedMemberExpr(const ASTContext &Context, bool HasUnresolvedUsing, 3863 Expr *Base, QualType BaseType, bool IsArrow, 3864 SourceLocation OperatorLoc, 3865 NestedNameSpecifierLoc QualifierLoc, 3866 SourceLocation TemplateKWLoc, 3867 const DeclarationNameInfo &MemberNameInfo, 3868 const TemplateArgumentListInfo *TemplateArgs, 3869 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3870 3871 UnresolvedMemberExpr(EmptyShell Empty, unsigned NumResults, 3872 bool HasTemplateKWAndArgsInfo); 3873 3874 unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const { 3875 return getNumDecls(); 3876 } 3877 3878 unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { 3879 return hasTemplateKWAndArgsInfo(); 3880 } 3881 3882 public: 3883 static UnresolvedMemberExpr * 3884 Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, 3885 QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, 3886 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, 3887 const DeclarationNameInfo &MemberNameInfo, 3888 const TemplateArgumentListInfo *TemplateArgs, 3889 UnresolvedSetIterator Begin, UnresolvedSetIterator End); 3890 3891 static UnresolvedMemberExpr *CreateEmpty(const ASTContext &Context, 3892 unsigned NumResults, 3893 bool HasTemplateKWAndArgsInfo, 3894 unsigned NumTemplateArgs); 3895 3896 /// True if this is an implicit access, i.e., one in which the 3897 /// member being accessed was not written in the source. 3898 /// 3899 /// The source location of the operator is invalid in this case. 3900 bool isImplicitAccess() const; 3901 3902 /// Retrieve the base object of this member expressions, 3903 /// e.g., the \c x in \c x.m. 3904 Expr *getBase() { 3905 assert(!isImplicitAccess()); 3906 return cast<Expr>(Base); 3907 } 3908 const Expr *getBase() const { 3909 assert(!isImplicitAccess()); 3910 return cast<Expr>(Base); 3911 } 3912 3913 QualType getBaseType() const { return BaseType; } 3914 3915 /// Determine whether the lookup results contain an unresolved using 3916 /// declaration. 3917 bool hasUnresolvedUsing() const { 3918 return UnresolvedMemberExprBits.HasUnresolvedUsing; 3919 } 3920 3921 /// Determine whether this member expression used the '->' 3922 /// operator; otherwise, it used the '.' operator. 3923 bool isArrow() const { return UnresolvedMemberExprBits.IsArrow; } 3924 3925 /// Retrieve the location of the '->' or '.' operator. 3926 SourceLocation getOperatorLoc() const { return OperatorLoc; } 3927 3928 /// Retrieve the naming class of this lookup. 3929 CXXRecordDecl *getNamingClass(); 3930 const CXXRecordDecl *getNamingClass() const { 3931 return const_cast<UnresolvedMemberExpr *>(this)->getNamingClass(); 3932 } 3933 3934 /// Retrieve the full name info for the member that this expression 3935 /// refers to. 3936 const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); } 3937 3938 /// Retrieve the name of the member that this expression refers to. 3939 DeclarationName getMemberName() const { return getName(); } 3940 3941 /// Retrieve the location of the name of the member that this 3942 /// expression refers to. 3943 SourceLocation getMemberLoc() const { return getNameLoc(); } 3944 3945 /// Return the preferred location (the member name) for the arrow when 3946 /// diagnosing a problem with this expression. 3947 SourceLocation getExprLoc() const LLVM_READONLY { return getMemberLoc(); } 3948 3949 SourceLocation getBeginLoc() const LLVM_READONLY { 3950 if (!isImplicitAccess()) 3951 return Base->getBeginLoc(); 3952 if (NestedNameSpecifierLoc l = getQualifierLoc()) 3953 return l.getBeginLoc(); 3954 return getMemberNameInfo().getBeginLoc(); 3955 } 3956 3957 SourceLocation getEndLoc() const LLVM_READONLY { 3958 if (hasExplicitTemplateArgs()) 3959 return getRAngleLoc(); 3960 return getMemberNameInfo().getEndLoc(); 3961 } 3962 3963 static bool classof(const Stmt *T) { 3964 return T->getStmtClass() == UnresolvedMemberExprClass; 3965 } 3966 3967 // Iterators 3968 child_range children() { 3969 if (isImplicitAccess()) 3970 return child_range(child_iterator(), child_iterator()); 3971 return child_range(&Base, &Base + 1); 3972 } 3973 3974 const_child_range children() const { 3975 if (isImplicitAccess()) 3976 return const_child_range(const_child_iterator(), const_child_iterator()); 3977 return const_child_range(&Base, &Base + 1); 3978 } 3979 }; 3980 3981 DeclAccessPair *OverloadExpr::getTrailingResults() { 3982 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3983 return ULE->getTrailingObjects<DeclAccessPair>(); 3984 return cast<UnresolvedMemberExpr>(this)->getTrailingObjects<DeclAccessPair>(); 3985 } 3986 3987 ASTTemplateKWAndArgsInfo *OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() { 3988 if (!hasTemplateKWAndArgsInfo()) 3989 return nullptr; 3990 3991 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3992 return ULE->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 3993 return cast<UnresolvedMemberExpr>(this) 3994 ->getTrailingObjects<ASTTemplateKWAndArgsInfo>(); 3995 } 3996 3997 TemplateArgumentLoc *OverloadExpr::getTrailingTemplateArgumentLoc() { 3998 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 3999 return ULE->getTrailingObjects<TemplateArgumentLoc>(); 4000 return cast<UnresolvedMemberExpr>(this) 4001 ->getTrailingObjects<TemplateArgumentLoc>(); 4002 } 4003 4004 CXXRecordDecl *OverloadExpr::getNamingClass() { 4005 if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(this)) 4006 return ULE->getNamingClass(); 4007 return cast<UnresolvedMemberExpr>(this)->getNamingClass(); 4008 } 4009 4010 /// Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]). 4011 /// 4012 /// The noexcept expression tests whether a given expression might throw. Its 4013 /// result is a boolean constant. 4014 class CXXNoexceptExpr : public Expr { 4015 friend class ASTStmtReader; 4016 4017 Stmt *Operand; 4018 SourceRange Range; 4019 4020 public: 4021 CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val, 4022 SourceLocation Keyword, SourceLocation RParen) 4023 : Expr(CXXNoexceptExprClass, Ty, VK_PRValue, OK_Ordinary), 4024 Operand(Operand), Range(Keyword, RParen) { 4025 CXXNoexceptExprBits.Value = Val == CT_Cannot; 4026 setDependence(computeDependence(this, Val)); 4027 } 4028 4029 CXXNoexceptExpr(EmptyShell Empty) : Expr(CXXNoexceptExprClass, Empty) {} 4030 4031 Expr *getOperand() const { return static_cast<Expr *>(Operand); } 4032 4033 SourceLocation getBeginLoc() const { return Range.getBegin(); } 4034 SourceLocation getEndLoc() const { return Range.getEnd(); } 4035 SourceRange getSourceRange() const { return Range; } 4036 4037 bool getValue() const { return CXXNoexceptExprBits.Value; } 4038 4039 static bool classof(const Stmt *T) { 4040 return T->getStmtClass() == CXXNoexceptExprClass; 4041 } 4042 4043 // Iterators 4044 child_range children() { return child_range(&Operand, &Operand + 1); } 4045 4046 const_child_range children() const { 4047 return const_child_range(&Operand, &Operand + 1); 4048 } 4049 }; 4050 4051 /// Represents a C++11 pack expansion that produces a sequence of 4052 /// expressions. 4053 /// 4054 /// A pack expansion expression contains a pattern (which itself is an 4055 /// expression) followed by an ellipsis. For example: 4056 /// 4057 /// \code 4058 /// template<typename F, typename ...Types> 4059 /// void forward(F f, Types &&...args) { 4060 /// f(static_cast<Types&&>(args)...); 4061 /// } 4062 /// \endcode 4063 /// 4064 /// Here, the argument to the function object \c f is a pack expansion whose 4065 /// pattern is \c static_cast<Types&&>(args). When the \c forward function 4066 /// template is instantiated, the pack expansion will instantiate to zero or 4067 /// or more function arguments to the function object \c f. 4068 class PackExpansionExpr : public Expr { 4069 friend class ASTStmtReader; 4070 friend class ASTStmtWriter; 4071 4072 SourceLocation EllipsisLoc; 4073 4074 /// The number of expansions that will be produced by this pack 4075 /// expansion expression, if known. 4076 /// 4077 /// When zero, the number of expansions is not known. Otherwise, this value 4078 /// is the number of expansions + 1. 4079 unsigned NumExpansions; 4080 4081 Stmt *Pattern; 4082 4083 public: 4084 PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, 4085 Optional<unsigned> NumExpansions) 4086 : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), 4087 Pattern->getObjectKind()), 4088 EllipsisLoc(EllipsisLoc), 4089 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), 4090 Pattern(Pattern) { 4091 setDependence(computeDependence(this)); 4092 } 4093 4094 PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) {} 4095 4096 /// Retrieve the pattern of the pack expansion. 4097 Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); } 4098 4099 /// Retrieve the pattern of the pack expansion. 4100 const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); } 4101 4102 /// Retrieve the location of the ellipsis that describes this pack 4103 /// expansion. 4104 SourceLocation getEllipsisLoc() const { return EllipsisLoc; } 4105 4106 /// Determine the number of expansions that will be produced when 4107 /// this pack expansion is instantiated, if already known. 4108 Optional<unsigned> getNumExpansions() const { 4109 if (NumExpansions) 4110 return NumExpansions - 1; 4111 4112 return None; 4113 } 4114 4115 SourceLocation getBeginLoc() const LLVM_READONLY { 4116 return Pattern->getBeginLoc(); 4117 } 4118 4119 SourceLocation getEndLoc() const LLVM_READONLY { return EllipsisLoc; } 4120 4121 static bool classof(const Stmt *T) { 4122 return T->getStmtClass() == PackExpansionExprClass; 4123 } 4124 4125 // Iterators 4126 child_range children() { 4127 return child_range(&Pattern, &Pattern + 1); 4128 } 4129 4130 const_child_range children() const { 4131 return const_child_range(&Pattern, &Pattern + 1); 4132 } 4133 }; 4134 4135 /// Represents an expression that computes the length of a parameter 4136 /// pack. 4137 /// 4138 /// \code 4139 /// template<typename ...Types> 4140 /// struct count { 4141 /// static const unsigned value = sizeof...(Types); 4142 /// }; 4143 /// \endcode 4144 class SizeOfPackExpr final 4145 : public Expr, 4146 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> { 4147 friend class ASTStmtReader; 4148 friend class ASTStmtWriter; 4149 friend TrailingObjects; 4150 4151 /// The location of the \c sizeof keyword. 4152 SourceLocation OperatorLoc; 4153 4154 /// The location of the name of the parameter pack. 4155 SourceLocation PackLoc; 4156 4157 /// The location of the closing parenthesis. 4158 SourceLocation RParenLoc; 4159 4160 /// The length of the parameter pack, if known. 4161 /// 4162 /// When this expression is not value-dependent, this is the length of 4163 /// the pack. When the expression was parsed rather than instantiated 4164 /// (and thus is value-dependent), this is zero. 4165 /// 4166 /// After partial substitution into a sizeof...(X) expression (for instance, 4167 /// within an alias template or during function template argument deduction), 4168 /// we store a trailing array of partially-substituted TemplateArguments, 4169 /// and this is the length of that array. 4170 unsigned Length; 4171 4172 /// The parameter pack. 4173 NamedDecl *Pack = nullptr; 4174 4175 /// Create an expression that computes the length of 4176 /// the given parameter pack. 4177 SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack, 4178 SourceLocation PackLoc, SourceLocation RParenLoc, 4179 Optional<unsigned> Length, 4180 ArrayRef<TemplateArgument> PartialArgs) 4181 : Expr(SizeOfPackExprClass, SizeType, VK_PRValue, OK_Ordinary), 4182 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc), 4183 Length(Length ? *Length : PartialArgs.size()), Pack(Pack) { 4184 assert((!Length || PartialArgs.empty()) && 4185 "have partial args for non-dependent sizeof... expression"); 4186 auto *Args = getTrailingObjects<TemplateArgument>(); 4187 std::uninitialized_copy(PartialArgs.begin(), PartialArgs.end(), Args); 4188 setDependence(Length ? ExprDependence::None 4189 : ExprDependence::ValueInstantiation); 4190 } 4191 4192 /// Create an empty expression. 4193 SizeOfPackExpr(EmptyShell Empty, unsigned NumPartialArgs) 4194 : Expr(SizeOfPackExprClass, Empty), Length(NumPartialArgs) {} 4195 4196 public: 4197 static SizeOfPackExpr *Create(ASTContext &Context, SourceLocation OperatorLoc, 4198 NamedDecl *Pack, SourceLocation PackLoc, 4199 SourceLocation RParenLoc, 4200 Optional<unsigned> Length = None, 4201 ArrayRef<TemplateArgument> PartialArgs = None); 4202 static SizeOfPackExpr *CreateDeserialized(ASTContext &Context, 4203 unsigned NumPartialArgs); 4204 4205 /// Determine the location of the 'sizeof' keyword. 4206 SourceLocation getOperatorLoc() const { return OperatorLoc; } 4207 4208 /// Determine the location of the parameter pack. 4209 SourceLocation getPackLoc() const { return PackLoc; } 4210 4211 /// Determine the location of the right parenthesis. 4212 SourceLocation getRParenLoc() const { return RParenLoc; } 4213 4214 /// Retrieve the parameter pack. 4215 NamedDecl *getPack() const { return Pack; } 4216 4217 /// Retrieve the length of the parameter pack. 4218 /// 4219 /// This routine may only be invoked when the expression is not 4220 /// value-dependent. 4221 unsigned getPackLength() const { 4222 assert(!isValueDependent() && 4223 "Cannot get the length of a value-dependent pack size expression"); 4224 return Length; 4225 } 4226 4227 /// Determine whether this represents a partially-substituted sizeof... 4228 /// expression, such as is produced for: 4229 /// 4230 /// template<typename ...Ts> using X = int[sizeof...(Ts)]; 4231 /// template<typename ...Us> void f(X<Us..., 1, 2, 3, Us...>); 4232 bool isPartiallySubstituted() const { 4233 return isValueDependent() && Length; 4234 } 4235 4236 /// Get 4237 ArrayRef<TemplateArgument> getPartialArguments() const { 4238 assert(isPartiallySubstituted()); 4239 const auto *Args = getTrailingObjects<TemplateArgument>(); 4240 return llvm::makeArrayRef(Args, Args + Length); 4241 } 4242 4243 SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; } 4244 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } 4245 4246 static bool classof(const Stmt *T) { 4247 return T->getStmtClass() == SizeOfPackExprClass; 4248 } 4249 4250 // Iterators 4251 child_range children() { 4252 return child_range(child_iterator(), child_iterator()); 4253 } 4254 4255 const_child_range children() const { 4256 return const_child_range(const_child_iterator(), const_child_iterator()); 4257 } 4258 }; 4259 4260 /// Represents a reference to a non-type template parameter 4261 /// that has been substituted with a template argument. 4262 class SubstNonTypeTemplateParmExpr : public Expr { 4263 friend class ASTReader; 4264 friend class ASTStmtReader; 4265 4266 /// The replaced parameter and a flag indicating if it was a reference 4267 /// parameter. For class NTTPs, we can't determine that based on the value 4268 /// category alone. 4269 llvm::PointerIntPair<NonTypeTemplateParmDecl*, 1, bool> ParamAndRef; 4270 4271 /// The replacement expression. 4272 Stmt *Replacement; 4273 4274 explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty) 4275 : Expr(SubstNonTypeTemplateParmExprClass, Empty) {} 4276 4277 public: 4278 SubstNonTypeTemplateParmExpr(QualType Ty, ExprValueKind ValueKind, 4279 SourceLocation Loc, 4280 NonTypeTemplateParmDecl *Param, bool RefParam, 4281 Expr *Replacement) 4282 : Expr(SubstNonTypeTemplateParmExprClass, Ty, ValueKind, OK_Ordinary), 4283 ParamAndRef(Param, RefParam), Replacement(Replacement) { 4284 SubstNonTypeTemplateParmExprBits.NameLoc = Loc; 4285 setDependence(computeDependence(this)); 4286 } 4287 4288 SourceLocation getNameLoc() const { 4289 return SubstNonTypeTemplateParmExprBits.NameLoc; 4290 } 4291 SourceLocation getBeginLoc() const { return getNameLoc(); } 4292 SourceLocation getEndLoc() const { return getNameLoc(); } 4293 4294 Expr *getReplacement() const { return cast<Expr>(Replacement); } 4295 4296 NonTypeTemplateParmDecl *getParameter() const { 4297 return ParamAndRef.getPointer(); 4298 } 4299 4300 bool isReferenceParameter() const { return ParamAndRef.getInt(); } 4301 4302 /// Determine the substituted type of the template parameter. 4303 QualType getParameterType(const ASTContext &Ctx) const; 4304 4305 static bool classof(const Stmt *s) { 4306 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass; 4307 } 4308 4309 // Iterators 4310 child_range children() { return child_range(&Replacement, &Replacement + 1); } 4311 4312 const_child_range children() const { 4313 return const_child_range(&Replacement, &Replacement + 1); 4314 } 4315 }; 4316 4317 /// Represents a reference to a non-type template parameter pack that 4318 /// has been substituted with a non-template argument pack. 4319 /// 4320 /// When a pack expansion in the source code contains multiple parameter packs 4321 /// and those parameter packs correspond to different levels of template 4322 /// parameter lists, this node is used to represent a non-type template 4323 /// parameter pack from an outer level, which has already had its argument pack 4324 /// substituted but that still lives within a pack expansion that itself 4325 /// could not be instantiated. When actually performing a substitution into 4326 /// that pack expansion (e.g., when all template parameters have corresponding 4327 /// arguments), this type will be replaced with the appropriate underlying 4328 /// expression at the current pack substitution index. 4329 class SubstNonTypeTemplateParmPackExpr : public Expr { 4330 friend class ASTReader; 4331 friend class ASTStmtReader; 4332 4333 /// The non-type template parameter pack itself. 4334 NonTypeTemplateParmDecl *Param; 4335 4336 /// A pointer to the set of template arguments that this 4337 /// parameter pack is instantiated with. 4338 const TemplateArgument *Arguments; 4339 4340 /// The number of template arguments in \c Arguments. 4341 unsigned NumArguments; 4342 4343 /// The location of the non-type template parameter pack reference. 4344 SourceLocation NameLoc; 4345 4346 explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty) 4347 : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) {} 4348 4349 public: 4350 SubstNonTypeTemplateParmPackExpr(QualType T, 4351 ExprValueKind ValueKind, 4352 NonTypeTemplateParmDecl *Param, 4353 SourceLocation NameLoc, 4354 const TemplateArgument &ArgPack); 4355 4356 /// Retrieve the non-type template parameter pack being substituted. 4357 NonTypeTemplateParmDecl *getParameterPack() const { return Param; } 4358 4359 /// Retrieve the location of the parameter pack name. 4360 SourceLocation getParameterPackLocation() const { return NameLoc; } 4361 4362 /// Retrieve the template argument pack containing the substituted 4363 /// template arguments. 4364 TemplateArgument getArgumentPack() const; 4365 4366 SourceLocation getBeginLoc() const LLVM_READONLY { return NameLoc; } 4367 SourceLocation getEndLoc() const LLVM_READONLY { return NameLoc; } 4368 4369 static bool classof(const Stmt *T) { 4370 return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass; 4371 } 4372 4373 // Iterators 4374 child_range children() { 4375 return child_range(child_iterator(), child_iterator()); 4376 } 4377 4378 const_child_range children() const { 4379 return const_child_range(const_child_iterator(), const_child_iterator()); 4380 } 4381 }; 4382 4383 /// Represents a reference to a function parameter pack or init-capture pack 4384 /// that has been substituted but not yet expanded. 4385 /// 4386 /// When a pack expansion contains multiple parameter packs at different levels, 4387 /// this node is used to represent a function parameter pack at an outer level 4388 /// which we have already substituted to refer to expanded parameters, but where 4389 /// the containing pack expansion cannot yet be expanded. 4390 /// 4391 /// \code 4392 /// template<typename...Ts> struct S { 4393 /// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...)); 4394 /// }; 4395 /// template struct S<int, int>; 4396 /// \endcode 4397 class FunctionParmPackExpr final 4398 : public Expr, 4399 private llvm::TrailingObjects<FunctionParmPackExpr, VarDecl *> { 4400 friend class ASTReader; 4401 friend class ASTStmtReader; 4402 friend TrailingObjects; 4403 4404 /// The function parameter pack which was referenced. 4405 VarDecl *ParamPack; 4406 4407 /// The location of the function parameter pack reference. 4408 SourceLocation NameLoc; 4409 4410 /// The number of expansions of this pack. 4411 unsigned NumParameters; 4412 4413 FunctionParmPackExpr(QualType T, VarDecl *ParamPack, 4414 SourceLocation NameLoc, unsigned NumParams, 4415 VarDecl *const *Params); 4416 4417 public: 4418 static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T, 4419 VarDecl *ParamPack, 4420 SourceLocation NameLoc, 4421 ArrayRef<VarDecl *> Params); 4422 static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context, 4423 unsigned NumParams); 4424 4425 /// Get the parameter pack which this expression refers to. 4426 VarDecl *getParameterPack() const { return ParamPack; } 4427 4428 /// Get the location of the parameter pack. 4429 SourceLocation getParameterPackLocation() const { return NameLoc; } 4430 4431 /// Iterators over the parameters which the parameter pack expanded 4432 /// into. 4433 using iterator = VarDecl * const *; 4434 iterator begin() const { return getTrailingObjects<VarDecl *>(); } 4435 iterator end() const { return begin() + NumParameters; } 4436 4437 /// Get the number of parameters in this parameter pack. 4438 unsigned getNumExpansions() const { return NumParameters; } 4439 4440 /// Get an expansion of the parameter pack by index. 4441 VarDecl *getExpansion(unsigned I) const { return begin()[I]; } 4442 4443 SourceLocation getBeginLoc() const LLVM_READONLY { return NameLoc; } 4444 SourceLocation getEndLoc() const LLVM_READONLY { return NameLoc; } 4445 4446 static bool classof(const Stmt *T) { 4447 return T->getStmtClass() == FunctionParmPackExprClass; 4448 } 4449 4450 child_range children() { 4451 return child_range(child_iterator(), child_iterator()); 4452 } 4453 4454 const_child_range children() const { 4455 return const_child_range(const_child_iterator(), const_child_iterator()); 4456 } 4457 }; 4458 4459 /// Represents a prvalue temporary that is written into memory so that 4460 /// a reference can bind to it. 4461 /// 4462 /// Prvalue expressions are materialized when they need to have an address 4463 /// in memory for a reference to bind to. This happens when binding a 4464 /// reference to the result of a conversion, e.g., 4465 /// 4466 /// \code 4467 /// const int &r = 1.0; 4468 /// \endcode 4469 /// 4470 /// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is 4471 /// then materialized via a \c MaterializeTemporaryExpr, and the reference 4472 /// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues 4473 /// (either an lvalue or an xvalue, depending on the kind of reference binding 4474 /// to it), maintaining the invariant that references always bind to glvalues. 4475 /// 4476 /// Reference binding and copy-elision can both extend the lifetime of a 4477 /// temporary. When either happens, the expression will also track the 4478 /// declaration which is responsible for the lifetime extension. 4479 class MaterializeTemporaryExpr : public Expr { 4480 private: 4481 friend class ASTStmtReader; 4482 friend class ASTStmtWriter; 4483 4484 llvm::PointerUnion<Stmt *, LifetimeExtendedTemporaryDecl *> State; 4485 4486 public: 4487 MaterializeTemporaryExpr(QualType T, Expr *Temporary, 4488 bool BoundToLvalueReference, 4489 LifetimeExtendedTemporaryDecl *MTD = nullptr); 4490 4491 MaterializeTemporaryExpr(EmptyShell Empty) 4492 : Expr(MaterializeTemporaryExprClass, Empty) {} 4493 4494 /// Retrieve the temporary-generating subexpression whose value will 4495 /// be materialized into a glvalue. 4496 Expr *getSubExpr() const { 4497 return cast<Expr>( 4498 State.is<Stmt *>() 4499 ? State.get<Stmt *>() 4500 : State.get<LifetimeExtendedTemporaryDecl *>()->getTemporaryExpr()); 4501 } 4502 4503 /// Retrieve the storage duration for the materialized temporary. 4504 StorageDuration getStorageDuration() const { 4505 return State.is<Stmt *>() ? SD_FullExpression 4506 : State.get<LifetimeExtendedTemporaryDecl *>() 4507 ->getStorageDuration(); 4508 } 4509 4510 /// Get the storage for the constant value of a materialized temporary 4511 /// of static storage duration. 4512 APValue *getOrCreateValue(bool MayCreate) const { 4513 assert(State.is<LifetimeExtendedTemporaryDecl *>() && 4514 "the temporary has not been lifetime extended"); 4515 return State.get<LifetimeExtendedTemporaryDecl *>()->getOrCreateValue( 4516 MayCreate); 4517 } 4518 4519 LifetimeExtendedTemporaryDecl *getLifetimeExtendedTemporaryDecl() { 4520 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>(); 4521 } 4522 const LifetimeExtendedTemporaryDecl * 4523 getLifetimeExtendedTemporaryDecl() const { 4524 return State.dyn_cast<LifetimeExtendedTemporaryDecl *>(); 4525 } 4526 4527 /// Get the declaration which triggered the lifetime-extension of this 4528 /// temporary, if any. 4529 ValueDecl *getExtendingDecl() { 4530 return State.is<Stmt *>() ? nullptr 4531 : State.get<LifetimeExtendedTemporaryDecl *>() 4532 ->getExtendingDecl(); 4533 } 4534 const ValueDecl *getExtendingDecl() const { 4535 return const_cast<MaterializeTemporaryExpr *>(this)->getExtendingDecl(); 4536 } 4537 4538 void setExtendingDecl(ValueDecl *ExtendedBy, unsigned ManglingNumber); 4539 4540 unsigned getManglingNumber() const { 4541 return State.is<Stmt *>() ? 0 4542 : State.get<LifetimeExtendedTemporaryDecl *>() 4543 ->getManglingNumber(); 4544 } 4545 4546 /// Determine whether this materialized temporary is bound to an 4547 /// lvalue reference; otherwise, it's bound to an rvalue reference. 4548 bool isBoundToLvalueReference() const { return isLValue(); } 4549 4550 /// Determine whether this temporary object is usable in constant 4551 /// expressions, as specified in C++20 [expr.const]p4. 4552 bool isUsableInConstantExpressions(const ASTContext &Context) const; 4553 4554 SourceLocation getBeginLoc() const LLVM_READONLY { 4555 return getSubExpr()->getBeginLoc(); 4556 } 4557 4558 SourceLocation getEndLoc() const LLVM_READONLY { 4559 return getSubExpr()->getEndLoc(); 4560 } 4561 4562 static bool classof(const Stmt *T) { 4563 return T->getStmtClass() == MaterializeTemporaryExprClass; 4564 } 4565 4566 // Iterators 4567 child_range children() { 4568 return State.is<Stmt *>() 4569 ? child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1) 4570 : State.get<LifetimeExtendedTemporaryDecl *>()->childrenExpr(); 4571 } 4572 4573 const_child_range children() const { 4574 return State.is<Stmt *>() 4575 ? const_child_range(State.getAddrOfPtr1(), 4576 State.getAddrOfPtr1() + 1) 4577 : const_cast<const LifetimeExtendedTemporaryDecl *>( 4578 State.get<LifetimeExtendedTemporaryDecl *>()) 4579 ->childrenExpr(); 4580 } 4581 }; 4582 4583 /// Represents a folding of a pack over an operator. 4584 /// 4585 /// This expression is always dependent and represents a pack expansion of the 4586 /// forms: 4587 /// 4588 /// ( expr op ... ) 4589 /// ( ... op expr ) 4590 /// ( expr op ... op expr ) 4591 class CXXFoldExpr : public Expr { 4592 friend class ASTStmtReader; 4593 friend class ASTStmtWriter; 4594 4595 enum SubExpr { Callee, LHS, RHS, Count }; 4596 4597 SourceLocation LParenLoc; 4598 SourceLocation EllipsisLoc; 4599 SourceLocation RParenLoc; 4600 // When 0, the number of expansions is not known. Otherwise, this is one more 4601 // than the number of expansions. 4602 unsigned NumExpansions; 4603 Stmt *SubExprs[SubExpr::Count]; 4604 BinaryOperatorKind Opcode; 4605 4606 public: 4607 CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee, 4608 SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode, 4609 SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, 4610 Optional<unsigned> NumExpansions) 4611 : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary), 4612 LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc), 4613 NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) { 4614 SubExprs[SubExpr::Callee] = Callee; 4615 SubExprs[SubExpr::LHS] = LHS; 4616 SubExprs[SubExpr::RHS] = RHS; 4617 setDependence(computeDependence(this)); 4618 } 4619 4620 CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {} 4621 4622 UnresolvedLookupExpr *getCallee() const { 4623 return static_cast<UnresolvedLookupExpr *>(SubExprs[SubExpr::Callee]); 4624 } 4625 Expr *getLHS() const { return static_cast<Expr*>(SubExprs[SubExpr::LHS]); } 4626 Expr *getRHS() const { return static_cast<Expr*>(SubExprs[SubExpr::RHS]); } 4627 4628 /// Does this produce a right-associated sequence of operators? 4629 bool isRightFold() const { 4630 return getLHS() && getLHS()->containsUnexpandedParameterPack(); 4631 } 4632 4633 /// Does this produce a left-associated sequence of operators? 4634 bool isLeftFold() const { return !isRightFold(); } 4635 4636 /// Get the pattern, that is, the operand that contains an unexpanded pack. 4637 Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); } 4638 4639 /// Get the operand that doesn't contain a pack, for a binary fold. 4640 Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); } 4641 4642 SourceLocation getLParenLoc() const { return LParenLoc; } 4643 SourceLocation getRParenLoc() const { return RParenLoc; } 4644 SourceLocation getEllipsisLoc() const { return EllipsisLoc; } 4645 BinaryOperatorKind getOperator() const { return Opcode; } 4646 4647 Optional<unsigned> getNumExpansions() const { 4648 if (NumExpansions) 4649 return NumExpansions - 1; 4650 return None; 4651 } 4652 4653 SourceLocation getBeginLoc() const LLVM_READONLY { 4654 if (LParenLoc.isValid()) 4655 return LParenLoc; 4656 if (isLeftFold()) 4657 return getEllipsisLoc(); 4658 return getLHS()->getBeginLoc(); 4659 } 4660 4661 SourceLocation getEndLoc() const LLVM_READONLY { 4662 if (RParenLoc.isValid()) 4663 return RParenLoc; 4664 if (isRightFold()) 4665 return getEllipsisLoc(); 4666 return getRHS()->getEndLoc(); 4667 } 4668 4669 static bool classof(const Stmt *T) { 4670 return T->getStmtClass() == CXXFoldExprClass; 4671 } 4672 4673 // Iterators 4674 child_range children() { 4675 return child_range(SubExprs, SubExprs + SubExpr::Count); 4676 } 4677 4678 const_child_range children() const { 4679 return const_child_range(SubExprs, SubExprs + SubExpr::Count); 4680 } 4681 }; 4682 4683 /// Represents an expression that might suspend coroutine execution; 4684 /// either a co_await or co_yield expression. 4685 /// 4686 /// Evaluation of this expression first evaluates its 'ready' expression. If 4687 /// that returns 'false': 4688 /// -- execution of the coroutine is suspended 4689 /// -- the 'suspend' expression is evaluated 4690 /// -- if the 'suspend' expression returns 'false', the coroutine is 4691 /// resumed 4692 /// -- otherwise, control passes back to the resumer. 4693 /// If the coroutine is not suspended, or when it is resumed, the 'resume' 4694 /// expression is evaluated, and its result is the result of the overall 4695 /// expression. 4696 class CoroutineSuspendExpr : public Expr { 4697 friend class ASTStmtReader; 4698 4699 SourceLocation KeywordLoc; 4700 4701 enum SubExpr { Operand, Common, Ready, Suspend, Resume, Count }; 4702 4703 Stmt *SubExprs[SubExpr::Count]; 4704 OpaqueValueExpr *OpaqueValue = nullptr; 4705 4706 public: 4707 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, Expr *Operand, 4708 Expr *Common, Expr *Ready, Expr *Suspend, Expr *Resume, 4709 OpaqueValueExpr *OpaqueValue) 4710 : Expr(SC, Resume->getType(), Resume->getValueKind(), 4711 Resume->getObjectKind()), 4712 KeywordLoc(KeywordLoc), OpaqueValue(OpaqueValue) { 4713 SubExprs[SubExpr::Operand] = Operand; 4714 SubExprs[SubExpr::Common] = Common; 4715 SubExprs[SubExpr::Ready] = Ready; 4716 SubExprs[SubExpr::Suspend] = Suspend; 4717 SubExprs[SubExpr::Resume] = Resume; 4718 setDependence(computeDependence(this)); 4719 } 4720 4721 CoroutineSuspendExpr(StmtClass SC, SourceLocation KeywordLoc, QualType Ty, 4722 Expr *Operand, Expr *Common) 4723 : Expr(SC, Ty, VK_PRValue, OK_Ordinary), KeywordLoc(KeywordLoc) { 4724 assert(Common->isTypeDependent() && Ty->isDependentType() && 4725 "wrong constructor for non-dependent co_await/co_yield expression"); 4726 SubExprs[SubExpr::Operand] = Operand; 4727 SubExprs[SubExpr::Common] = Common; 4728 SubExprs[SubExpr::Ready] = nullptr; 4729 SubExprs[SubExpr::Suspend] = nullptr; 4730 SubExprs[SubExpr::Resume] = nullptr; 4731 setDependence(computeDependence(this)); 4732 } 4733 4734 CoroutineSuspendExpr(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) { 4735 SubExprs[SubExpr::Operand] = nullptr; 4736 SubExprs[SubExpr::Common] = nullptr; 4737 SubExprs[SubExpr::Ready] = nullptr; 4738 SubExprs[SubExpr::Suspend] = nullptr; 4739 SubExprs[SubExpr::Resume] = nullptr; 4740 } 4741 4742 Expr *getCommonExpr() const { 4743 return static_cast<Expr*>(SubExprs[SubExpr::Common]); 4744 } 4745 4746 /// getOpaqueValue - Return the opaque value placeholder. 4747 OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; } 4748 4749 Expr *getReadyExpr() const { 4750 return static_cast<Expr*>(SubExprs[SubExpr::Ready]); 4751 } 4752 4753 Expr *getSuspendExpr() const { 4754 return static_cast<Expr*>(SubExprs[SubExpr::Suspend]); 4755 } 4756 4757 Expr *getResumeExpr() const { 4758 return static_cast<Expr*>(SubExprs[SubExpr::Resume]); 4759 } 4760 4761 // The syntactic operand written in the code 4762 Expr *getOperand() const { 4763 return static_cast<Expr *>(SubExprs[SubExpr::Operand]); 4764 } 4765 4766 SourceLocation getKeywordLoc() const { return KeywordLoc; } 4767 4768 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; } 4769 4770 SourceLocation getEndLoc() const LLVM_READONLY { 4771 return getOperand()->getEndLoc(); 4772 } 4773 4774 child_range children() { 4775 return child_range(SubExprs, SubExprs + SubExpr::Count); 4776 } 4777 4778 const_child_range children() const { 4779 return const_child_range(SubExprs, SubExprs + SubExpr::Count); 4780 } 4781 4782 static bool classof(const Stmt *T) { 4783 return T->getStmtClass() == CoawaitExprClass || 4784 T->getStmtClass() == CoyieldExprClass; 4785 } 4786 }; 4787 4788 /// Represents a 'co_await' expression. 4789 class CoawaitExpr : public CoroutineSuspendExpr { 4790 friend class ASTStmtReader; 4791 4792 public: 4793 CoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, Expr *Common, 4794 Expr *Ready, Expr *Suspend, Expr *Resume, 4795 OpaqueValueExpr *OpaqueValue, bool IsImplicit = false) 4796 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Operand, Common, 4797 Ready, Suspend, Resume, OpaqueValue) { 4798 CoawaitBits.IsImplicit = IsImplicit; 4799 } 4800 4801 CoawaitExpr(SourceLocation CoawaitLoc, QualType Ty, Expr *Operand, 4802 Expr *Common, bool IsImplicit = false) 4803 : CoroutineSuspendExpr(CoawaitExprClass, CoawaitLoc, Ty, Operand, 4804 Common) { 4805 CoawaitBits.IsImplicit = IsImplicit; 4806 } 4807 4808 CoawaitExpr(EmptyShell Empty) 4809 : CoroutineSuspendExpr(CoawaitExprClass, Empty) {} 4810 4811 bool isImplicit() const { return CoawaitBits.IsImplicit; } 4812 void setIsImplicit(bool value = true) { CoawaitBits.IsImplicit = value; } 4813 4814 static bool classof(const Stmt *T) { 4815 return T->getStmtClass() == CoawaitExprClass; 4816 } 4817 }; 4818 4819 /// Represents a 'co_await' expression while the type of the promise 4820 /// is dependent. 4821 class DependentCoawaitExpr : public Expr { 4822 friend class ASTStmtReader; 4823 4824 SourceLocation KeywordLoc; 4825 Stmt *SubExprs[2]; 4826 4827 public: 4828 DependentCoawaitExpr(SourceLocation KeywordLoc, QualType Ty, Expr *Op, 4829 UnresolvedLookupExpr *OpCoawait) 4830 : Expr(DependentCoawaitExprClass, Ty, VK_PRValue, OK_Ordinary), 4831 KeywordLoc(KeywordLoc) { 4832 // NOTE: A co_await expression is dependent on the coroutines promise 4833 // type and may be dependent even when the `Op` expression is not. 4834 assert(Ty->isDependentType() && 4835 "wrong constructor for non-dependent co_await/co_yield expression"); 4836 SubExprs[0] = Op; 4837 SubExprs[1] = OpCoawait; 4838 setDependence(computeDependence(this)); 4839 } 4840 4841 DependentCoawaitExpr(EmptyShell Empty) 4842 : Expr(DependentCoawaitExprClass, Empty) {} 4843 4844 Expr *getOperand() const { return cast<Expr>(SubExprs[0]); } 4845 4846 UnresolvedLookupExpr *getOperatorCoawaitLookup() const { 4847 return cast<UnresolvedLookupExpr>(SubExprs[1]); 4848 } 4849 4850 SourceLocation getKeywordLoc() const { return KeywordLoc; } 4851 4852 SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; } 4853 4854 SourceLocation getEndLoc() const LLVM_READONLY { 4855 return getOperand()->getEndLoc(); 4856 } 4857 4858 child_range children() { return child_range(SubExprs, SubExprs + 2); } 4859 4860 const_child_range children() const { 4861 return const_child_range(SubExprs, SubExprs + 2); 4862 } 4863 4864 static bool classof(const Stmt *T) { 4865 return T->getStmtClass() == DependentCoawaitExprClass; 4866 } 4867 }; 4868 4869 /// Represents a 'co_yield' expression. 4870 class CoyieldExpr : public CoroutineSuspendExpr { 4871 friend class ASTStmtReader; 4872 4873 public: 4874 CoyieldExpr(SourceLocation CoyieldLoc, Expr *Operand, Expr *Common, 4875 Expr *Ready, Expr *Suspend, Expr *Resume, 4876 OpaqueValueExpr *OpaqueValue) 4877 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Operand, Common, 4878 Ready, Suspend, Resume, OpaqueValue) {} 4879 CoyieldExpr(SourceLocation CoyieldLoc, QualType Ty, Expr *Operand, 4880 Expr *Common) 4881 : CoroutineSuspendExpr(CoyieldExprClass, CoyieldLoc, Ty, Operand, 4882 Common) {} 4883 CoyieldExpr(EmptyShell Empty) 4884 : CoroutineSuspendExpr(CoyieldExprClass, Empty) {} 4885 4886 static bool classof(const Stmt *T) { 4887 return T->getStmtClass() == CoyieldExprClass; 4888 } 4889 }; 4890 4891 /// Represents a C++2a __builtin_bit_cast(T, v) expression. Used to implement 4892 /// std::bit_cast. These can sometimes be evaluated as part of a constant 4893 /// expression, but otherwise CodeGen to a simple memcpy in general. 4894 class BuiltinBitCastExpr final 4895 : public ExplicitCastExpr, 4896 private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> { 4897 friend class ASTStmtReader; 4898 friend class CastExpr; 4899 friend TrailingObjects; 4900 4901 SourceLocation KWLoc; 4902 SourceLocation RParenLoc; 4903 4904 public: 4905 BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr, 4906 TypeSourceInfo *DstType, SourceLocation KWLoc, 4907 SourceLocation RParenLoc) 4908 : ExplicitCastExpr(BuiltinBitCastExprClass, T, VK, CK, SrcExpr, 0, false, 4909 DstType), 4910 KWLoc(KWLoc), RParenLoc(RParenLoc) {} 4911 BuiltinBitCastExpr(EmptyShell Empty) 4912 : ExplicitCastExpr(BuiltinBitCastExprClass, Empty, 0, false) {} 4913 4914 SourceLocation getBeginLoc() const LLVM_READONLY { return KWLoc; } 4915 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } 4916 4917 static bool classof(const Stmt *T) { 4918 return T->getStmtClass() == BuiltinBitCastExprClass; 4919 } 4920 }; 4921 4922 } // namespace clang 4923 4924 #endif // LLVM_CLANG_AST_EXPRCXX_H 4925