Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 1 | //===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the subclesses of Expr class declared in ExprCXX.h |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Douglas Gregor | b460980 | 2008-11-14 16:09:21 +0000 | [diff] [blame] | 14 | #include "clang/Basic/IdentifierTable.h" |
| 15 | #include "clang/AST/DeclCXX.h" |
Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 16 | #include "clang/AST/ExprCXX.h" |
| 17 | using namespace clang; |
| 18 | |
Argyrios Kyrtzidis | 4189a76 | 2008-09-10 02:14:49 +0000 | [diff] [blame] | 19 | void CXXConditionDeclExpr::Destroy(ASTContext& C) { |
Sebastian Redl | df2d3cf | 2009-02-05 15:12:41 +0000 | [diff] [blame] | 20 | // FIXME: Cannot destroy the decl here, because it is linked into the |
| 21 | // DeclContext's chain. |
| 22 | //getVarDecl()->Destroy(C); |
Ted Kremenek | 8189cde | 2009-02-07 01:47:29 +0000 | [diff] [blame] | 23 | this->~CXXConditionDeclExpr(); |
| 24 | C.Deallocate(this); |
Argyrios Kyrtzidis | 4189a76 | 2008-09-10 02:14:49 +0000 | [diff] [blame] | 25 | } |
Argyrios Kyrtzidis | 9e922b1 | 2008-09-09 23:47:53 +0000 | [diff] [blame] | 26 | |
Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 27 | //===----------------------------------------------------------------------===// |
| 28 | // Child Iterators for iterating over subexpressions/substatements |
| 29 | //===----------------------------------------------------------------------===// |
| 30 | |
Sebastian Redl | c42e118 | 2008-11-11 11:37:55 +0000 | [diff] [blame] | 31 | // CXXTypeidExpr - has child iterators if the operand is an expression |
| 32 | Stmt::child_iterator CXXTypeidExpr::child_begin() { |
Sebastian Redl | d457589 | 2008-12-03 23:17:54 +0000 | [diff] [blame] | 33 | return isTypeOperand() ? child_iterator() : &Operand.Ex; |
Sebastian Redl | c42e118 | 2008-11-11 11:37:55 +0000 | [diff] [blame] | 34 | } |
| 35 | Stmt::child_iterator CXXTypeidExpr::child_end() { |
Sebastian Redl | d457589 | 2008-12-03 23:17:54 +0000 | [diff] [blame] | 36 | return isTypeOperand() ? child_iterator() : &Operand.Ex+1; |
Sebastian Redl | c42e118 | 2008-11-11 11:37:55 +0000 | [diff] [blame] | 37 | } |
Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 38 | |
Ted Kremenek | a758d09 | 2007-08-24 20:21:10 +0000 | [diff] [blame] | 39 | // CXXBoolLiteralExpr |
Ted Kremenek | 9ac5928 | 2007-10-18 23:28:49 +0000 | [diff] [blame] | 40 | Stmt::child_iterator CXXBoolLiteralExpr::child_begin() { |
| 41 | return child_iterator(); |
| 42 | } |
| 43 | Stmt::child_iterator CXXBoolLiteralExpr::child_end() { |
| 44 | return child_iterator(); |
| 45 | } |
Chris Lattner | 50dd289 | 2008-02-26 00:51:44 +0000 | [diff] [blame] | 46 | |
Douglas Gregor | 796da18 | 2008-11-04 14:32:21 +0000 | [diff] [blame] | 47 | // CXXThisExpr |
| 48 | Stmt::child_iterator CXXThisExpr::child_begin() { return child_iterator(); } |
| 49 | Stmt::child_iterator CXXThisExpr::child_end() { return child_iterator(); } |
| 50 | |
Chris Lattner | 50dd289 | 2008-02-26 00:51:44 +0000 | [diff] [blame] | 51 | // CXXThrowExpr |
Ted Kremenek | 1060aff | 2008-06-17 03:11:08 +0000 | [diff] [blame] | 52 | Stmt::child_iterator CXXThrowExpr::child_begin() { return &Op; } |
Chris Lattner | 50dd289 | 2008-02-26 00:51:44 +0000 | [diff] [blame] | 53 | Stmt::child_iterator CXXThrowExpr::child_end() { |
| 54 | // If Op is 0, we are processing throw; which has no children. |
Ted Kremenek | 1060aff | 2008-06-17 03:11:08 +0000 | [diff] [blame] | 55 | return Op ? &Op+1 : &Op; |
Chris Lattner | 50dd289 | 2008-02-26 00:51:44 +0000 | [diff] [blame] | 56 | } |
Chris Lattner | 0442108 | 2008-04-08 04:40:51 +0000 | [diff] [blame] | 57 | |
| 58 | // CXXDefaultArgExpr |
| 59 | Stmt::child_iterator CXXDefaultArgExpr::child_begin() { |
Chris Lattner | 8123a95 | 2008-04-10 02:22:51 +0000 | [diff] [blame] | 60 | return child_iterator(); |
Chris Lattner | 0442108 | 2008-04-08 04:40:51 +0000 | [diff] [blame] | 61 | } |
| 62 | Stmt::child_iterator CXXDefaultArgExpr::child_end() { |
Chris Lattner | 8123a95 | 2008-04-10 02:22:51 +0000 | [diff] [blame] | 63 | return child_iterator(); |
Chris Lattner | 0442108 | 2008-04-08 04:40:51 +0000 | [diff] [blame] | 64 | } |
Argyrios Kyrtzidis | 987a14b | 2008-08-22 15:38:55 +0000 | [diff] [blame] | 65 | |
| 66 | // CXXZeroInitValueExpr |
| 67 | Stmt::child_iterator CXXZeroInitValueExpr::child_begin() { |
| 68 | return child_iterator(); |
| 69 | } |
| 70 | Stmt::child_iterator CXXZeroInitValueExpr::child_end() { |
| 71 | return child_iterator(); |
| 72 | } |
Argyrios Kyrtzidis | 9e922b1 | 2008-09-09 23:47:53 +0000 | [diff] [blame] | 73 | |
| 74 | // CXXConditionDeclExpr |
| 75 | Stmt::child_iterator CXXConditionDeclExpr::child_begin() { |
| 76 | return getVarDecl(); |
| 77 | } |
| 78 | Stmt::child_iterator CXXConditionDeclExpr::child_end() { |
| 79 | return child_iterator(); |
| 80 | } |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 81 | |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 82 | // CXXNewExpr |
| 83 | CXXNewExpr::CXXNewExpr(bool globalNew, FunctionDecl *operatorNew, |
| 84 | Expr **placementArgs, unsigned numPlaceArgs, |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 85 | bool parenTypeId, Expr *arraySize, |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 86 | CXXConstructorDecl *constructor, bool initializer, |
| 87 | Expr **constructorArgs, unsigned numConsArgs, |
| 88 | FunctionDecl *operatorDelete, QualType ty, |
| 89 | SourceLocation startLoc, SourceLocation endLoc) |
Sebastian Redl | 2850784 | 2009-02-26 14:39:58 +0000 | [diff] [blame] | 90 | : Expr(CXXNewExprClass, ty, ty->isDependentType(), ty->isDependentType()), |
| 91 | GlobalNew(globalNew), ParenTypeId(parenTypeId), |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 92 | Initializer(initializer), Array(arraySize), NumPlacementArgs(numPlaceArgs), |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 93 | NumConstructorArgs(numConsArgs), OperatorNew(operatorNew), |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 94 | OperatorDelete(operatorDelete), Constructor(constructor), |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 95 | StartLoc(startLoc), EndLoc(endLoc) |
| 96 | { |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 97 | unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs; |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 98 | SubExprs = new Stmt*[TotalSize]; |
| 99 | unsigned i = 0; |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 100 | if (Array) |
| 101 | SubExprs[i++] = arraySize; |
| 102 | for (unsigned j = 0; j < NumPlacementArgs; ++j) |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 103 | SubExprs[i++] = placementArgs[j]; |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 104 | for (unsigned j = 0; j < NumConstructorArgs; ++j) |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 105 | SubExprs[i++] = constructorArgs[j]; |
| 106 | assert(i == TotalSize); |
| 107 | } |
| 108 | |
| 109 | Stmt::child_iterator CXXNewExpr::child_begin() { return &SubExprs[0]; } |
| 110 | Stmt::child_iterator CXXNewExpr::child_end() { |
Sebastian Redl | cee63fb | 2008-12-02 14:43:59 +0000 | [diff] [blame] | 111 | return &SubExprs[0] + Array + getNumPlacementArgs() + getNumConstructorArgs(); |
Sebastian Redl | 4c5d320 | 2008-11-21 19:14:01 +0000 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | // CXXDeleteExpr |
| 115 | Stmt::child_iterator CXXDeleteExpr::child_begin() { return &Argument; } |
| 116 | Stmt::child_iterator CXXDeleteExpr::child_end() { return &Argument+1; } |
| 117 | |
Douglas Gregor | 1733001 | 2009-02-04 15:01:18 +0000 | [diff] [blame] | 118 | // UnresolvedFunctionNameExpr |
| 119 | Stmt::child_iterator UnresolvedFunctionNameExpr::child_begin() { |
Douglas Gregor | 5c37de7 | 2008-12-06 00:22:45 +0000 | [diff] [blame] | 120 | return child_iterator(); |
| 121 | } |
Douglas Gregor | 1733001 | 2009-02-04 15:01:18 +0000 | [diff] [blame] | 122 | Stmt::child_iterator UnresolvedFunctionNameExpr::child_end() { |
Douglas Gregor | 5c37de7 | 2008-12-06 00:22:45 +0000 | [diff] [blame] | 123 | return child_iterator(); |
| 124 | } |
| 125 | |
Sebastian Redl | 64b45f7 | 2009-01-05 20:52:13 +0000 | [diff] [blame] | 126 | // UnaryTypeTraitExpr |
| 127 | Stmt::child_iterator UnaryTypeTraitExpr::child_begin() { |
| 128 | return child_iterator(); |
| 129 | } |
| 130 | Stmt::child_iterator UnaryTypeTraitExpr::child_end() { |
| 131 | return child_iterator(); |
| 132 | } |
| 133 | |
Douglas Gregor | 5953d8b | 2009-03-19 17:26:29 +0000 | [diff] [blame] | 134 | // UnresolvedDeclRefExpr |
| 135 | StmtIterator UnresolvedDeclRefExpr::child_begin() { |
| 136 | return child_iterator(); |
| 137 | } |
| 138 | |
| 139 | StmtIterator UnresolvedDeclRefExpr::child_end() { |
| 140 | return child_iterator(); |
| 141 | } |
| 142 | |
Daniel Dunbar | c87a282 | 2009-02-17 23:20:26 +0000 | [diff] [blame] | 143 | bool UnaryTypeTraitExpr::EvaluateTrait() const { |
Sebastian Redl | 64b45f7 | 2009-01-05 20:52:13 +0000 | [diff] [blame] | 144 | switch(UTT) { |
| 145 | default: assert(false && "Unknown type trait or not implemented"); |
| 146 | case UTT_IsPOD: return QueriedType->isPODType(); |
| 147 | case UTT_IsClass: // Fallthrough |
| 148 | case UTT_IsUnion: |
| 149 | if (const RecordType *Record = QueriedType->getAsRecordType()) { |
| 150 | bool Union = Record->getDecl()->isUnion(); |
| 151 | return UTT == UTT_IsUnion ? Union : !Union; |
| 152 | } |
| 153 | return false; |
| 154 | case UTT_IsEnum: return QueriedType->isEnumeralType(); |
| 155 | case UTT_IsPolymorphic: |
| 156 | if (const RecordType *Record = QueriedType->getAsRecordType()) { |
| 157 | // Type traits are only parsed in C++, so we've got CXXRecords. |
| 158 | return cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic(); |
| 159 | } |
| 160 | return false; |
Anders Carlsson | 67e4dd2 | 2009-03-22 01:52:17 +0000 | [diff] [blame] | 161 | case UTT_IsAbstract: |
| 162 | if (const RecordType *RT = QueriedType->getAsRecordType()) |
| 163 | return cast<CXXRecordDecl>(RT->getDecl())->isAbstract(); |
| 164 | return false; |
Anders Carlsson | 347ba89 | 2009-04-16 00:08:20 +0000 | [diff] [blame] | 165 | case UTT_HasTrivialConstructor: |
| 166 | if (const RecordType *RT = QueriedType->getAsRecordType()) |
| 167 | return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialConstructor(); |
Anders Carlsson | 072abef | 2009-04-17 02:34:54 +0000 | [diff] [blame] | 168 | return false; |
| 169 | case UTT_HasTrivialDestructor: |
| 170 | if (const RecordType *RT = QueriedType->getAsRecordType()) |
| 171 | return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor(); |
| 172 | return false; |
Sebastian Redl | 64b45f7 | 2009-01-05 20:52:13 +0000 | [diff] [blame] | 173 | } |
| 174 | } |
| 175 | |
Douglas Gregor | b460980 | 2008-11-14 16:09:21 +0000 | [diff] [blame] | 176 | SourceRange CXXOperatorCallExpr::getSourceRange() const { |
| 177 | OverloadedOperatorKind Kind = getOperator(); |
| 178 | if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { |
| 179 | if (getNumArgs() == 1) |
| 180 | // Prefix operator |
| 181 | return SourceRange(getOperatorLoc(), |
| 182 | getArg(0)->getSourceRange().getEnd()); |
| 183 | else |
| 184 | // Postfix operator |
| 185 | return SourceRange(getArg(0)->getSourceRange().getEnd(), |
| 186 | getOperatorLoc()); |
| 187 | } else if (Kind == OO_Call) { |
| 188 | return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc()); |
| 189 | } else if (Kind == OO_Subscript) { |
| 190 | return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc()); |
| 191 | } else if (getNumArgs() == 1) { |
| 192 | return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd()); |
| 193 | } else if (getNumArgs() == 2) { |
| 194 | return SourceRange(getArg(0)->getSourceRange().getBegin(), |
| 195 | getArg(1)->getSourceRange().getEnd()); |
| 196 | } else { |
| 197 | return SourceRange(); |
| 198 | } |
| 199 | } |
| 200 | |
Douglas Gregor | 88a3514 | 2008-12-22 05:46:06 +0000 | [diff] [blame] | 201 | Expr *CXXMemberCallExpr::getImplicitObjectArgument() { |
| 202 | if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens())) |
| 203 | return MemExpr->getBase(); |
| 204 | |
| 205 | // FIXME: Will eventually need to cope with member pointers. |
| 206 | return 0; |
| 207 | } |
| 208 | |
Douglas Gregor | 49badde | 2008-10-27 19:41:14 +0000 | [diff] [blame] | 209 | //===----------------------------------------------------------------------===// |
| 210 | // Named casts |
| 211 | //===----------------------------------------------------------------------===// |
| 212 | |
| 213 | /// getCastName - Get the name of the C++ cast being used, e.g., |
| 214 | /// "static_cast", "dynamic_cast", "reinterpret_cast", or |
| 215 | /// "const_cast". The returned pointer must not be freed. |
| 216 | const char *CXXNamedCastExpr::getCastName() const { |
| 217 | switch (getStmtClass()) { |
| 218 | case CXXStaticCastExprClass: return "static_cast"; |
| 219 | case CXXDynamicCastExprClass: return "dynamic_cast"; |
| 220 | case CXXReinterpretCastExprClass: return "reinterpret_cast"; |
| 221 | case CXXConstCastExprClass: return "const_cast"; |
| 222 | default: return "<invalid cast>"; |
| 223 | } |
| 224 | } |
Douglas Gregor | 506ae41 | 2009-01-16 18:33:17 +0000 | [diff] [blame] | 225 | |
Anders Carlsson | 09c4abb | 2009-04-24 05:44:25 +0000 | [diff] [blame] | 226 | CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C, VarDecl *vd, |
Anders Carlsson | 26de549 | 2009-04-24 05:23:13 +0000 | [diff] [blame] | 227 | CXXConstructorDecl *Cons, |
Douglas Gregor | 506ae41 | 2009-01-16 18:33:17 +0000 | [diff] [blame] | 228 | QualType writtenTy, |
| 229 | SourceLocation tyBeginLoc, |
| 230 | Expr **Args, |
| 231 | unsigned NumArgs, |
| 232 | SourceLocation rParenLoc) |
Anders Carlsson | 524fa13 | 2009-04-24 17:34:38 +0000 | [diff] [blame] | 233 | : CXXConstructExpr(C, CXXTemporaryObjectExprClass, vd, writtenTy, Cons, |
| 234 | false, Args, NumArgs), |
| 235 | TyBeginLoc(tyBeginLoc), RParenLoc(rParenLoc) { |
Douglas Gregor | 506ae41 | 2009-01-16 18:33:17 +0000 | [diff] [blame] | 236 | } |
Anders Carlsson | 19d28a6 | 2009-04-21 02:22:11 +0000 | [diff] [blame] | 237 | |
Anders Carlsson | e349bea | 2009-04-23 02:32:43 +0000 | [diff] [blame] | 238 | CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, VarDecl *VD, |
| 239 | QualType T, CXXConstructorDecl *D, |
| 240 | bool Elidable, |
| 241 | Expr **Args, unsigned NumArgs) { |
Anders Carlsson | bd6734e | 2009-04-24 05:04:04 +0000 | [diff] [blame] | 242 | return new (C) CXXConstructExpr(C, CXXConstructExprClass, VD, T, D, Elidable, |
| 243 | Args, NumArgs); |
Anders Carlsson | e349bea | 2009-04-23 02:32:43 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Anders Carlsson | bd6734e | 2009-04-24 05:04:04 +0000 | [diff] [blame] | 246 | CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, VarDecl *vd, |
Anders Carlsson | e349bea | 2009-04-23 02:32:43 +0000 | [diff] [blame] | 247 | QualType T, CXXConstructorDecl *D, |
| 248 | bool elidable, |
| 249 | Expr **args, unsigned numargs) |
Anders Carlsson | bd6734e | 2009-04-24 05:04:04 +0000 | [diff] [blame] | 250 | : Expr(SC, T, |
Anders Carlsson | e349bea | 2009-04-23 02:32:43 +0000 | [diff] [blame] | 251 | T->isDependentType(), |
| 252 | (T->isDependentType() || |
| 253 | CallExpr::hasAnyValueDependentArguments(args, numargs))), |
| 254 | VD(vd), Constructor(D), Elidable(elidable), Args(0), NumArgs(numargs) { |
| 255 | if (NumArgs > 0) { |
| 256 | Args = new (C) Stmt*[NumArgs]; |
| 257 | for (unsigned i = 0; i < NumArgs; ++i) |
| 258 | Args[i] = args[i]; |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | void CXXConstructExpr::Destroy(ASTContext &C) { |
| 263 | DestroyChildren(C); |
| 264 | if (Args) |
| 265 | C.Deallocate(Args); |
| 266 | this->~CXXConstructExpr(); |
| 267 | C.Deallocate(this); |
| 268 | } |
| 269 | |
Anders Carlsson | 19d28a6 | 2009-04-21 02:22:11 +0000 | [diff] [blame] | 270 | CXXDestroyExpr *CXXDestroyExpr::Create(ASTContext &C, VarDecl *vd) { |
| 271 | assert(vd->getKind() == Decl::CXXTempVar || vd->getKind() == Decl::Var && |
| 272 | "Can only create a destroy expr with a temp var decl or a var decl!"); |
| 273 | |
| 274 | return new (C) CXXDestroyExpr(vd, C.VoidTy); |
| 275 | } |
| 276 | |
Anders Carlsson | 02bbfa3 | 2009-04-24 22:47:04 +0000 | [diff] [blame^] | 277 | CXXExprWithCleanup::CXXExprWithCleanup(Expr *subexpr, CXXTempVarDecl **decls, |
| 278 | unsigned numdecls) |
| 279 | : Expr(CXXExprWithCleanupClass, subexpr->getType(), |
| 280 | subexpr->isTypeDependent(), subexpr->isValueDependent()), |
| 281 | SubExpr(subexpr), Decls(0), NumDecls(numdecls) { |
| 282 | if (NumDecls > 0) { |
| 283 | Decls = new CXXTempVarDecl*[NumDecls]; |
| 284 | for (unsigned i = 0; i < NumDecls; ++i) |
| 285 | Decls[i] = decls[i]; |
| 286 | } |
| 287 | } |
| 288 | |
| 289 | CXXExprWithCleanup::~CXXExprWithCleanup() { |
| 290 | delete[] Decls; |
| 291 | } |
| 292 | |
Anders Carlsson | e349bea | 2009-04-23 02:32:43 +0000 | [diff] [blame] | 293 | // CXXConstructExpr |
| 294 | Stmt::child_iterator CXXConstructExpr::child_begin() { |
| 295 | return &Args[0]; |
| 296 | } |
| 297 | Stmt::child_iterator CXXConstructExpr::child_end() { |
| 298 | return &Args[0]+NumArgs; |
| 299 | } |
| 300 | |
| 301 | // CXXDestroyExpr |
Anders Carlsson | 19d28a6 | 2009-04-21 02:22:11 +0000 | [diff] [blame] | 302 | Stmt::child_iterator CXXDestroyExpr::child_begin() { |
| 303 | return child_iterator(); |
| 304 | } |
| 305 | Stmt::child_iterator CXXDestroyExpr::child_end() { |
| 306 | return child_iterator(); |
| 307 | } |
Anders Carlsson | 02bbfa3 | 2009-04-24 22:47:04 +0000 | [diff] [blame^] | 308 | |
| 309 | // CXXExprWithCleanup |
| 310 | Stmt::child_iterator CXXExprWithCleanup::child_begin() { return &SubExpr; } |
| 311 | Stmt::child_iterator CXXExprWithCleanup::child_end() { return &SubExpr + 1; } |
| 312 | |