contrib/llvm/tools/clang/include/clang/AST/StmtCXX.h

   1 //===--- StmtCXX.h - Classes for representing C++ statements ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the C++ statement AST node classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_STMTCXX_H
  15 #define LLVM_CLANG_AST_STMTCXX_H
  16
  17 #include "clang/AST/DeclarationName.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/NestedNameSpecifier.h"
  20 #include "clang/AST/Stmt.h"
  21 #include "llvm/Support/Compiler.h"
  22
  23 namespace clang {
  24
  25 class VarDecl;
  26
  27 /// CXXCatchStmt - This represents a C++ catch block.
  28 ///
  29 class CXXCatchStmt : public Stmt {
  30   SourceLocation CatchLoc;
  31   /// The exception-declaration of the type.
  32   VarDecl *ExceptionDecl;
  33   /// The handler block.
  34   Stmt *HandlerBlock;
  35
  36 public:
  37   CXXCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock)
  38   : Stmt(CXXCatchStmtClass), CatchLoc(catchLoc), ExceptionDecl(exDecl),
  39     HandlerBlock(handlerBlock) {}
  40
  41   CXXCatchStmt(EmptyShell Empty)
  42   : Stmt(CXXCatchStmtClass), ExceptionDecl(nullptr), HandlerBlock(nullptr) {}
  43
  44   SourceLocation getLocStart() const LLVM_READONLY { return CatchLoc; }
  45   SourceLocation getLocEnd() const LLVM_READONLY {
  46     return HandlerBlock->getLocEnd();
  47   }
  48
  49   SourceLocation getCatchLoc() const { return CatchLoc; }
  50   VarDecl *getExceptionDecl() const { return ExceptionDecl; }
  51   QualType getCaughtType() const;
  52   Stmt *getHandlerBlock() const { return HandlerBlock; }
  53
  54   static bool classof(const Stmt *T) {
  55     return T->getStmtClass() == CXXCatchStmtClass;
  56   }
  57
  58   child_range children() { return child_range(&HandlerBlock, &HandlerBlock+1); }
  59
  60   friend class ASTStmtReader;
  61 };
  62
  63 /// CXXTryStmt - A C++ try block, including all handlers.
  64 ///
  65 class CXXTryStmt : public Stmt {
  66   SourceLocation TryLoc;
  67   unsigned NumHandlers;
  68
  69   CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers);
  70
  71   CXXTryStmt(EmptyShell Empty, unsigned numHandlers)
  72     : Stmt(CXXTryStmtClass), NumHandlers(numHandlers) { }
  73
  74   Stmt const * const *getStmts() const {
  75     return reinterpret_cast<Stmt const * const*>(this + 1);
  76   }
  77   Stmt **getStmts() {
  78     return reinterpret_cast<Stmt **>(this + 1);
  79   }
  80
  81 public:
  82   static CXXTryStmt *Create(const ASTContext &C, SourceLocation tryLoc,
  83                             Stmt *tryBlock, ArrayRef<Stmt*> handlers);
  84
  85   static CXXTryStmt *Create(const ASTContext &C, EmptyShell Empty,
  86                             unsigned numHandlers);
  87
  88   SourceLocation getLocStart() const LLVM_READONLY { return getTryLoc(); }
  89   SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
  90
  91   SourceLocation getTryLoc() const { return TryLoc; }
  92   SourceLocation getEndLoc() const {
  93     return getStmts()[NumHandlers]->getLocEnd();
  94   }
  95
  96   CompoundStmt *getTryBlock() {
  97     return cast<CompoundStmt>(getStmts()[0]);
  98   }
  99   const CompoundStmt *getTryBlock() const {
 100     return cast<CompoundStmt>(getStmts()[0]);
 101   }
 102
 103   unsigned getNumHandlers() const { return NumHandlers; }
 104   CXXCatchStmt *getHandler(unsigned i) {
 105     return cast<CXXCatchStmt>(getStmts()[i + 1]);
 106   }
 107   const CXXCatchStmt *getHandler(unsigned i) const {
 108     return cast<CXXCatchStmt>(getStmts()[i + 1]);
 109   }
 110
 111   static bool classof(const Stmt *T) {
 112     return T->getStmtClass() == CXXTryStmtClass;
 113   }
 114
 115   child_range children() {
 116     return child_range(getStmts(), getStmts() + getNumHandlers() + 1);
 117   }
 118
 119   friend class ASTStmtReader;
 120 };
 121
 122 /// CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for
 123 /// statement, represented as 'for (range-declarator : range-expression)'.
 124 ///
 125 /// This is stored in a partially-desugared form to allow full semantic
 126 /// analysis of the constituent components. The original syntactic components
 127 /// can be extracted using getLoopVariable and getRangeInit.
 128 class CXXForRangeStmt : public Stmt {
 129   SourceLocation ForLoc;
 130   enum { RANGE, BEGINSTMT, ENDSTMT, COND, INC, LOOPVAR, BODY, END };
 131   // SubExprs[RANGE] is an expression or declstmt.
 132   // SubExprs[COND] and SubExprs[INC] are expressions.
 133   Stmt *SubExprs[END];
 134   SourceLocation CoawaitLoc;
 135   SourceLocation ColonLoc;
 136   SourceLocation RParenLoc;
 137
 138   friend class ASTStmtReader;
 139 public:
 140   CXXForRangeStmt(DeclStmt *Range, DeclStmt *Begin, DeclStmt *End,
 141                   Expr *Cond, Expr *Inc, DeclStmt *LoopVar, Stmt *Body,
 142                   SourceLocation FL, SourceLocation CAL, SourceLocation CL,
 143                   SourceLocation RPL);
 144   CXXForRangeStmt(EmptyShell Empty) : Stmt(CXXForRangeStmtClass, Empty) { }
 145
 146
 147   VarDecl *getLoopVariable();
 148   Expr *getRangeInit();
 149
 150   const VarDecl *getLoopVariable() const;
 151   const Expr *getRangeInit() const;
 152
 153
 154   DeclStmt *getRangeStmt() { return cast<DeclStmt>(SubExprs[RANGE]); }
 155   DeclStmt *getBeginStmt() {
 156     return cast_or_null<DeclStmt>(SubExprs[BEGINSTMT]);
 157   }
 158   DeclStmt *getEndStmt() { return cast_or_null<DeclStmt>(SubExprs[ENDSTMT]); }
 159   Expr *getCond() { return cast_or_null<Expr>(SubExprs[COND]); }
 160   Expr *getInc() { return cast_or_null<Expr>(SubExprs[INC]); }
 161   DeclStmt *getLoopVarStmt() { return cast<DeclStmt>(SubExprs[LOOPVAR]); }
 162   Stmt *getBody() { return SubExprs[BODY]; }
 163
 164   const DeclStmt *getRangeStmt() const {
 165     return cast<DeclStmt>(SubExprs[RANGE]);
 166   }
 167   const DeclStmt *getBeginStmt() const {
 168     return cast_or_null<DeclStmt>(SubExprs[BEGINSTMT]);
 169   }
 170   const DeclStmt *getEndStmt() const {
 171     return cast_or_null<DeclStmt>(SubExprs[ENDSTMT]);
 172   }
 173   const Expr *getCond() const {
 174     return cast_or_null<Expr>(SubExprs[COND]);
 175   }
 176   const Expr *getInc() const {
 177     return cast_or_null<Expr>(SubExprs[INC]);
 178   }
 179   const DeclStmt *getLoopVarStmt() const {
 180     return cast<DeclStmt>(SubExprs[LOOPVAR]);
 181   }
 182   const Stmt *getBody() const { return SubExprs[BODY]; }
 183
 184   void setRangeInit(Expr *E) { SubExprs[RANGE] = reinterpret_cast<Stmt*>(E); }
 185   void setRangeStmt(Stmt *S) { SubExprs[RANGE] = S; }
 186   void setBeginStmt(Stmt *S) { SubExprs[BEGINSTMT] = S; }
 187   void setEndStmt(Stmt *S) { SubExprs[ENDSTMT] = S; }
 188   void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
 189   void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); }
 190   void setLoopVarStmt(Stmt *S) { SubExprs[LOOPVAR] = S; }
 191   void setBody(Stmt *S) { SubExprs[BODY] = S; }
 192
 193   SourceLocation getForLoc() const { return ForLoc; }
 194   SourceLocation getCoawaitLoc() const { return CoawaitLoc; }
 195   SourceLocation getColonLoc() const { return ColonLoc; }
 196   SourceLocation getRParenLoc() const { return RParenLoc; }
 197
 198   SourceLocation getLocStart() const LLVM_READONLY { return ForLoc; }
 199   SourceLocation getLocEnd() const LLVM_READONLY {
 200     return SubExprs[BODY]->getLocEnd();
 201   }
 202
 203   static bool classof(const Stmt *T) {
 204     return T->getStmtClass() == CXXForRangeStmtClass;
 205   }
 206
 207   // Iterators
 208   child_range children() {
 209     return child_range(&SubExprs[0], &SubExprs[END]);
 210   }
 211 };
 212
 213 /// \brief Representation of a Microsoft __if_exists or __if_not_exists
 214 /// statement with a dependent name.
 215 ///
 216 /// The __if_exists statement can be used to include a sequence of statements
 217 /// in the program only when a particular dependent name does not exist. For
 218 /// example:
 219 ///
 220 /// \code
 221 /// template<typename T>
 222 /// void call_foo(T &t) {
 223 ///   __if_exists (T::foo) {
 224 ///     t.foo(); // okay: only called when T::foo exists.
 225 ///   }
 226 /// }
 227 /// \endcode
 228 ///
 229 /// Similarly, the __if_not_exists statement can be used to include the
 230 /// statements when a particular name does not exist.
 231 ///
 232 /// Note that this statement only captures __if_exists and __if_not_exists
 233 /// statements whose name is dependent. All non-dependent cases are handled
 234 /// directly in the parser, so that they don't introduce a new scope. Clang
 235 /// introduces scopes in the dependent case to keep names inside the compound
 236 /// statement from leaking out into the surround statements, which would
 237 /// compromise the template instantiation model. This behavior differs from
 238 /// Visual C++ (which never introduces a scope), but is a fairly reasonable
 239 /// approximation of the VC++ behavior.
 240 class MSDependentExistsStmt : public Stmt {
 241   SourceLocation KeywordLoc;
 242   bool IsIfExists;
 243   NestedNameSpecifierLoc QualifierLoc;
 244   DeclarationNameInfo NameInfo;
 245   Stmt *SubStmt;
 246
 247   friend class ASTReader;
 248   friend class ASTStmtReader;
 249
 250 public:
 251   MSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists,
 252                         NestedNameSpecifierLoc QualifierLoc,
 253                         DeclarationNameInfo NameInfo,
 254                         CompoundStmt *SubStmt)
 255   : Stmt(MSDependentExistsStmtClass),
 256     KeywordLoc(KeywordLoc), IsIfExists(IsIfExists),
 257     QualifierLoc(QualifierLoc), NameInfo(NameInfo),
 258     SubStmt(reinterpret_cast<Stmt *>(SubStmt)) { }
 259
 260   /// \brief Retrieve the location of the __if_exists or __if_not_exists
 261   /// keyword.
 262   SourceLocation getKeywordLoc() const { return KeywordLoc; }
 263
 264   /// \brief Determine whether this is an __if_exists statement.
 265   bool isIfExists() const { return IsIfExists; }
 266
 267   /// \brief Determine whether this is an __if_exists statement.
 268   bool isIfNotExists() const { return !IsIfExists; }
 269
 270   /// \brief Retrieve the nested-name-specifier that qualifies this name, if
 271   /// any.
 272   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
 273
 274   /// \brief Retrieve the name of the entity we're testing for, along with
 275   /// location information
 276   DeclarationNameInfo getNameInfo() const { return NameInfo; }
 277
 278   /// \brief Retrieve the compound statement that will be included in the
 279   /// program only if the existence of the symbol matches the initial keyword.
 280   CompoundStmt *getSubStmt() const {
 281     return reinterpret_cast<CompoundStmt *>(SubStmt);
 282   }
 283
 284   SourceLocation getLocStart() const LLVM_READONLY { return KeywordLoc; }
 285   SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();}
 286
 287   child_range children() {
 288     return child_range(&SubStmt, &SubStmt+1);
 289   }
 290
 291   static bool classof(const Stmt *T) {
 292     return T->getStmtClass() == MSDependentExistsStmtClass;
 293   }
 294 };
 295
 296 /// \brief Represents the body of a coroutine. This wraps the normal function
 297 /// body and holds the additional semantic context required to set up and tear
 298 /// down the coroutine frame.
 299 class CoroutineBodyStmt : public Stmt {
 300   enum SubStmt {
 301     Body,          ///< The body of the coroutine.
 302     Promise,       ///< The promise statement.
 303     InitSuspend,   ///< The initial suspend statement, run before the body.
 304     FinalSuspend,  ///< The final suspend statement, run after the body.
 305     OnException,   ///< Handler for exceptions thrown in the body.
 306     OnFallthrough, ///< Handler for control flow falling off the body.
 307     Allocate,      ///< Coroutine frame memory allocation.
 308     Deallocate,    ///< Coroutine frame memory deallocation.
 309     ReturnValue,   ///< Return value for thunk function.
 310     FirstParamMove ///< First offset for move construction of parameter copies.
 311   };
 312   Stmt *SubStmts[SubStmt::FirstParamMove];
 313
 314   friend class ASTStmtReader;
 315 public:
 316   CoroutineBodyStmt(Stmt *Body, Stmt *Promise, Stmt *InitSuspend,
 317                     Stmt *FinalSuspend, Stmt *OnException, Stmt *OnFallthrough,
 318                     Expr *Allocate, Stmt *Deallocate,
 319                     Expr *ReturnValue, ArrayRef<Expr *> ParamMoves)
 320       : Stmt(CoroutineBodyStmtClass) {
 321     SubStmts[CoroutineBodyStmt::Body] = Body;
 322     SubStmts[CoroutineBodyStmt::Promise] = Promise;
 323     SubStmts[CoroutineBodyStmt::InitSuspend] = InitSuspend;
 324     SubStmts[CoroutineBodyStmt::FinalSuspend] = FinalSuspend;
 325     SubStmts[CoroutineBodyStmt::OnException] = OnException;
 326     SubStmts[CoroutineBodyStmt::OnFallthrough] = OnFallthrough;
 327     SubStmts[CoroutineBodyStmt::Allocate] = Allocate;
 328     SubStmts[CoroutineBodyStmt::Deallocate] = Deallocate;
 329     SubStmts[CoroutineBodyStmt::ReturnValue] = ReturnValue;
 330     // FIXME: Tail-allocate space for parameter move expressions and store them.
 331     assert(ParamMoves.empty() && "not implemented yet");
 332   }
 333
 334   /// \brief Retrieve the body of the coroutine as written. This will be either
 335   /// a CompoundStmt or a TryStmt.
 336   Stmt *getBody() const {
 337     return SubStmts[SubStmt::Body];
 338   }
 339
 340   Stmt *getPromiseDeclStmt() const { return SubStmts[SubStmt::Promise]; }
 341   VarDecl *getPromiseDecl() const {
 342     return cast<VarDecl>(cast<DeclStmt>(getPromiseDeclStmt())->getSingleDecl());
 343   }
 344
 345   Stmt *getInitSuspendStmt() const { return SubStmts[SubStmt::InitSuspend]; }
 346   Stmt *getFinalSuspendStmt() const { return SubStmts[SubStmt::FinalSuspend]; }
 347
 348   Stmt *getExceptionHandler() const { return SubStmts[SubStmt::OnException]; }
 349   Stmt *getFallthroughHandler() const {
 350     return SubStmts[SubStmt::OnFallthrough];
 351   }
 352
 353   Expr *getAllocate() const { return cast<Expr>(SubStmts[SubStmt::Allocate]); }
 354   Stmt *getDeallocate() const { return SubStmts[SubStmt::Deallocate]; }
 355
 356   Expr *getReturnValueInit() const {
 357     return cast<Expr>(SubStmts[SubStmt::ReturnValue]);
 358   }
 359
 360   SourceLocation getLocStart() const LLVM_READONLY {
 361     return getBody()->getLocStart();
 362   }
 363   SourceLocation getLocEnd() const LLVM_READONLY {
 364     return getBody()->getLocEnd();
 365   }
 366
 367   child_range children() {
 368     return child_range(SubStmts, SubStmts + SubStmt::FirstParamMove);
 369   }
 370
 371   static bool classof(const Stmt *T) {
 372     return T->getStmtClass() == CoroutineBodyStmtClass;
 373   }
 374 };
 375
 376 /// \brief Represents a 'co_return' statement in the C++ Coroutines TS.
 377 ///
 378 /// This statament models the initialization of the coroutine promise
 379 /// (encapsulating the eventual notional return value) from an expression
 380 /// (or braced-init-list), followed by termination of the coroutine.
 381 ///
 382 /// This initialization is modeled by the evaluation of the operand
 383 /// followed by a call to one of:
 384 ///   <promise>.return_value(<operand>)
 385 ///   <promise>.return_void()
 386 /// which we name the "promise call".
 387 class CoreturnStmt : public Stmt {
 388   SourceLocation CoreturnLoc;
 389
 390   enum SubStmt { Operand, PromiseCall, Count };
 391   Stmt *SubStmts[SubStmt::Count];
 392
 393   friend class ASTStmtReader;
 394 public:
 395   CoreturnStmt(SourceLocation CoreturnLoc, Stmt *Operand, Stmt *PromiseCall)
 396       : Stmt(CoreturnStmtClass), CoreturnLoc(CoreturnLoc) {
 397     SubStmts[SubStmt::Operand] = Operand;
 398     SubStmts[SubStmt::PromiseCall] = PromiseCall;
 399   }
 400
 401   SourceLocation getKeywordLoc() const { return CoreturnLoc; }
 402
 403   /// \brief Retrieve the operand of the 'co_return' statement. Will be nullptr
 404   /// if none was specified.
 405   Expr *getOperand() const { return static_cast<Expr*>(SubStmts[Operand]); }
 406
 407   /// \brief Retrieve the promise call that results from this 'co_return'
 408   /// statement. Will be nullptr if either the coroutine has not yet been
 409   /// finalized or the coroutine has no eventual return type.
 410   Expr *getPromiseCall() const {
 411     return static_cast<Expr*>(SubStmts[PromiseCall]);
 412   }
 413
 414   SourceLocation getLocStart() const LLVM_READONLY { return CoreturnLoc; }
 415   SourceLocation getLocEnd() const LLVM_READONLY {
 416     return getOperand() ? getOperand()->getLocEnd() : getLocStart();
 417   }
 418
 419   child_range children() {
 420     if (!getOperand())
 421       return child_range(SubStmts + SubStmt::PromiseCall,
 422                          SubStmts + SubStmt::Count);
 423     return child_range(SubStmts, SubStmts + SubStmt::Count);
 424   }
 425
 426   static bool classof(const Stmt *T) {
 427     return T->getStmtClass() == CoreturnStmtClass;
 428   }
 429 };
 430
 431 }  // end namespace clang
 432
 433 #endif