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