1 //===--- ExprCXX.h - Classes for representing expressions -------*- 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 /// \file
11 /// \brief Defines the clang::Expr interface and subclasses for C++ expressions.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_AST_EXPRCXX_H
16 #define LLVM_CLANG_AST_EXPRCXX_H
17
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/TemplateBase.h"
21 #include "clang/AST/UnresolvedSet.h"
22 #include "clang/Basic/ExpressionTraits.h"
23 #include "clang/Basic/Lambda.h"
24 #include "clang/Basic/TypeTraits.h"
25 #include "llvm/Support/Compiler.h"
26
27 namespace clang {
28
29 class CXXConstructorDecl;
30 class CXXDestructorDecl;
31 class CXXMethodDecl;
32 class CXXTemporary;
33 class MSPropertyDecl;
34 class TemplateArgumentListInfo;
35 class UuidAttr;
36
37 //===--------------------------------------------------------------------===//
38 // C++ Expressions.
39 //===--------------------------------------------------------------------===//
40
41 /// \brief A call to an overloaded operator written using operator
42 /// syntax.
43 ///
44 /// Represents a call to an overloaded operator written using operator
45 /// syntax, e.g., "x + y" or "*p". While semantically equivalent to a
46 /// normal call, this AST node provides better information about the
47 /// syntactic representation of the call.
48 ///
49 /// In a C++ template, this expression node kind will be used whenever
50 /// any of the arguments are type-dependent. In this case, the
51 /// function itself will be a (possibly empty) set of functions and
52 /// function templates that were found by name lookup at template
53 /// definition time.
54 class CXXOperatorCallExpr : public CallExpr {
55 /// \brief The overloaded operator.
56 OverloadedOperatorKind Operator;
57 SourceRange Range;
58
59 // Record the FP_CONTRACT state that applies to this operator call. Only
60 // meaningful for floating point types. For other types this value can be
61 // set to false.
62 unsigned FPContractable : 1;
63
64 SourceRange getSourceRangeImpl() const LLVM_READONLY;
65 public:
CXXOperatorCallExpr(ASTContext & C,OverloadedOperatorKind Op,Expr * fn,ArrayRef<Expr * > args,QualType t,ExprValueKind VK,SourceLocation operatorloc,bool fpContractable)66 CXXOperatorCallExpr(ASTContext& C, OverloadedOperatorKind Op, Expr *fn,
67 ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
68 SourceLocation operatorloc, bool fpContractable)
69 : CallExpr(C, CXXOperatorCallExprClass, fn, 0, args, t, VK,
70 operatorloc),
71 Operator(Op), FPContractable(fpContractable) {
72 Range = getSourceRangeImpl();
73 }
CXXOperatorCallExpr(ASTContext & C,EmptyShell Empty)74 explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty) :
75 CallExpr(C, CXXOperatorCallExprClass, Empty) { }
76
77
78 /// \brief Returns the kind of overloaded operator that this
79 /// expression refers to.
getOperator()80 OverloadedOperatorKind getOperator() const { return Operator; }
81
82 /// \brief Returns the location of the operator symbol in the expression.
83 ///
84 /// When \c getOperator()==OO_Call, this is the location of the right
85 /// parentheses; when \c getOperator()==OO_Subscript, this is the location
86 /// of the right bracket.
getOperatorLoc()87 SourceLocation getOperatorLoc() const { return getRParenLoc(); }
88
getLocStart()89 SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
getLocEnd()90 SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
getSourceRange()91 SourceRange getSourceRange() const { return Range; }
92
classof(const Stmt * T)93 static bool classof(const Stmt *T) {
94 return T->getStmtClass() == CXXOperatorCallExprClass;
95 }
96
97 // Set the FP contractability status of this operator. Only meaningful for
98 // operations on floating point types.
setFPContractable(bool FPC)99 void setFPContractable(bool FPC) { FPContractable = FPC; }
100
101 // Get the FP contractability status of this operator. Only meaningful for
102 // operations on floating point types.
isFPContractable()103 bool isFPContractable() const { return FPContractable; }
104
105 friend class ASTStmtReader;
106 friend class ASTStmtWriter;
107 };
108
109 /// Represents a call to a member function that
110 /// may be written either with member call syntax (e.g., "obj.func()"
111 /// or "objptr->func()") or with normal function-call syntax
112 /// ("func()") within a member function that ends up calling a member
113 /// function. The callee in either case is a MemberExpr that contains
114 /// both the object argument and the member function, while the
115 /// arguments are the arguments within the parentheses (not including
116 /// the object argument).
117 class CXXMemberCallExpr : public CallExpr {
118 public:
CXXMemberCallExpr(ASTContext & C,Expr * fn,ArrayRef<Expr * > args,QualType t,ExprValueKind VK,SourceLocation RP)119 CXXMemberCallExpr(ASTContext &C, Expr *fn, ArrayRef<Expr*> args,
120 QualType t, ExprValueKind VK, SourceLocation RP)
121 : CallExpr(C, CXXMemberCallExprClass, fn, 0, args, t, VK, RP) {}
122
CXXMemberCallExpr(ASTContext & C,EmptyShell Empty)123 CXXMemberCallExpr(ASTContext &C, EmptyShell Empty)
124 : CallExpr(C, CXXMemberCallExprClass, Empty) { }
125
126 /// \brief Retrieves the implicit object argument for the member call.
127 ///
128 /// For example, in "x.f(5)", this returns the sub-expression "x".
129 Expr *getImplicitObjectArgument() const;
130
131 /// \brief Retrieves the declaration of the called method.
132 CXXMethodDecl *getMethodDecl() const;
133
134 /// \brief Retrieves the CXXRecordDecl for the underlying type of
135 /// the implicit object argument.
136 ///
137 /// Note that this is may not be the same declaration as that of the class
138 /// context of the CXXMethodDecl which this function is calling.
139 /// FIXME: Returns 0 for member pointer call exprs.
140 CXXRecordDecl *getRecordDecl() const;
141
classof(const Stmt * T)142 static bool classof(const Stmt *T) {
143 return T->getStmtClass() == CXXMemberCallExprClass;
144 }
145 };
146
147 /// \brief Represents a call to a CUDA kernel function.
148 class CUDAKernelCallExpr : public CallExpr {
149 private:
150 enum { CONFIG, END_PREARG };
151
152 public:
CUDAKernelCallExpr(ASTContext & C,Expr * fn,CallExpr * Config,ArrayRef<Expr * > args,QualType t,ExprValueKind VK,SourceLocation RP)153 CUDAKernelCallExpr(ASTContext &C, Expr *fn, CallExpr *Config,
154 ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
155 SourceLocation RP)
156 : CallExpr(C, CUDAKernelCallExprClass, fn, END_PREARG, args, t, VK, RP) {
157 setConfig(Config);
158 }
159
CUDAKernelCallExpr(ASTContext & C,EmptyShell Empty)160 CUDAKernelCallExpr(ASTContext &C, EmptyShell Empty)
161 : CallExpr(C, CUDAKernelCallExprClass, END_PREARG, Empty) { }
162
getConfig()163 const CallExpr *getConfig() const {
164 return cast_or_null<CallExpr>(getPreArg(CONFIG));
165 }
getConfig()166 CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
setConfig(CallExpr * E)167 void setConfig(CallExpr *E) { setPreArg(CONFIG, E); }
168
classof(const Stmt * T)169 static bool classof(const Stmt *T) {
170 return T->getStmtClass() == CUDAKernelCallExprClass;
171 }
172 };
173
174 /// \brief Abstract class common to all of the C++ "named"/"keyword" casts.
175 ///
176 /// This abstract class is inherited by all of the classes
177 /// representing "named" casts: CXXStaticCastExpr for \c static_cast,
178 /// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
179 /// reinterpret_cast, and CXXConstCastExpr for \c const_cast.
180 class CXXNamedCastExpr : public ExplicitCastExpr {
181 private:
182 SourceLocation Loc; // the location of the casting op
183 SourceLocation RParenLoc; // the location of the right parenthesis
184 SourceRange AngleBrackets; // range for '<' '>'
185
186 protected:
CXXNamedCastExpr(StmtClass SC,QualType ty,ExprValueKind VK,CastKind kind,Expr * op,unsigned PathSize,TypeSourceInfo * writtenTy,SourceLocation l,SourceLocation RParenLoc,SourceRange AngleBrackets)187 CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK,
188 CastKind kind, Expr *op, unsigned PathSize,
189 TypeSourceInfo *writtenTy, SourceLocation l,
190 SourceLocation RParenLoc,
191 SourceRange AngleBrackets)
192 : ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, writtenTy), Loc(l),
193 RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}
194
CXXNamedCastExpr(StmtClass SC,EmptyShell Shell,unsigned PathSize)195 explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
196 : ExplicitCastExpr(SC, Shell, PathSize) { }
197
198 friend class ASTStmtReader;
199
200 public:
201 const char *getCastName() const;
202
203 /// \brief Retrieve the location of the cast operator keyword, e.g.,
204 /// \c static_cast.
getOperatorLoc()205 SourceLocation getOperatorLoc() const { return Loc; }
206
207 /// \brief Retrieve the location of the closing parenthesis.
getRParenLoc()208 SourceLocation getRParenLoc() const { return RParenLoc; }
209
getLocStart()210 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()211 SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
getAngleBrackets()212 SourceRange getAngleBrackets() const LLVM_READONLY { return AngleBrackets; }
213
classof(const Stmt * T)214 static bool classof(const Stmt *T) {
215 switch (T->getStmtClass()) {
216 case CXXStaticCastExprClass:
217 case CXXDynamicCastExprClass:
218 case CXXReinterpretCastExprClass:
219 case CXXConstCastExprClass:
220 return true;
221 default:
222 return false;
223 }
224 }
225 };
226
227 /// \brief A C++ \c static_cast expression (C++ [expr.static.cast]).
228 ///
229 /// This expression node represents a C++ static cast, e.g.,
230 /// \c static_cast<int>(1.0).
231 class CXXStaticCastExpr : public CXXNamedCastExpr {
CXXStaticCastExpr(QualType ty,ExprValueKind vk,CastKind kind,Expr * op,unsigned pathSize,TypeSourceInfo * writtenTy,SourceLocation l,SourceLocation RParenLoc,SourceRange AngleBrackets)232 CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
233 unsigned pathSize, TypeSourceInfo *writtenTy,
234 SourceLocation l, SourceLocation RParenLoc,
235 SourceRange AngleBrackets)
236 : CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize,
237 writtenTy, l, RParenLoc, AngleBrackets) {}
238
CXXStaticCastExpr(EmptyShell Empty,unsigned PathSize)239 explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize)
240 : CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize) { }
241
242 public:
243 static CXXStaticCastExpr *Create(ASTContext &Context, QualType T,
244 ExprValueKind VK, CastKind K, Expr *Op,
245 const CXXCastPath *Path,
246 TypeSourceInfo *Written, SourceLocation L,
247 SourceLocation RParenLoc,
248 SourceRange AngleBrackets);
249 static CXXStaticCastExpr *CreateEmpty(ASTContext &Context,
250 unsigned PathSize);
251
classof(const Stmt * T)252 static bool classof(const Stmt *T) {
253 return T->getStmtClass() == CXXStaticCastExprClass;
254 }
255 };
256
257 /// \brief A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
258 ///
259 /// This expression node represents a dynamic cast, e.g.,
260 /// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
261 /// check to determine how to perform the type conversion.
262 class CXXDynamicCastExpr : public CXXNamedCastExpr {
CXXDynamicCastExpr(QualType ty,ExprValueKind VK,CastKind kind,Expr * op,unsigned pathSize,TypeSourceInfo * writtenTy,SourceLocation l,SourceLocation RParenLoc,SourceRange AngleBrackets)263 CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind,
264 Expr *op, unsigned pathSize, TypeSourceInfo *writtenTy,
265 SourceLocation l, SourceLocation RParenLoc,
266 SourceRange AngleBrackets)
267 : CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize,
268 writtenTy, l, RParenLoc, AngleBrackets) {}
269
CXXDynamicCastExpr(EmptyShell Empty,unsigned pathSize)270 explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
271 : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize) { }
272
273 public:
274 static CXXDynamicCastExpr *Create(ASTContext &Context, QualType T,
275 ExprValueKind VK, CastKind Kind, Expr *Op,
276 const CXXCastPath *Path,
277 TypeSourceInfo *Written, SourceLocation L,
278 SourceLocation RParenLoc,
279 SourceRange AngleBrackets);
280
281 static CXXDynamicCastExpr *CreateEmpty(ASTContext &Context,
282 unsigned pathSize);
283
284 bool isAlwaysNull() const;
285
classof(const Stmt * T)286 static bool classof(const Stmt *T) {
287 return T->getStmtClass() == CXXDynamicCastExprClass;
288 }
289 };
290
291 /// \brief A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
292 ///
293 /// This expression node represents a reinterpret cast, e.g.,
294 /// @c reinterpret_cast<int>(VoidPtr).
295 ///
296 /// A reinterpret_cast provides a differently-typed view of a value but
297 /// (in Clang, as in most C++ implementations) performs no actual work at
298 /// run time.
299 class CXXReinterpretCastExpr : public CXXNamedCastExpr {
CXXReinterpretCastExpr(QualType ty,ExprValueKind vk,CastKind kind,Expr * op,unsigned pathSize,TypeSourceInfo * writtenTy,SourceLocation l,SourceLocation RParenLoc,SourceRange AngleBrackets)300 CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind,
301 Expr *op, unsigned pathSize,
302 TypeSourceInfo *writtenTy, SourceLocation l,
303 SourceLocation RParenLoc,
304 SourceRange AngleBrackets)
305 : CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op,
306 pathSize, writtenTy, l, RParenLoc, AngleBrackets) {}
307
CXXReinterpretCastExpr(EmptyShell Empty,unsigned pathSize)308 CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
309 : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize) { }
310
311 public:
312 static CXXReinterpretCastExpr *Create(ASTContext &Context, QualType T,
313 ExprValueKind VK, CastKind Kind,
314 Expr *Op, const CXXCastPath *Path,
315 TypeSourceInfo *WrittenTy, SourceLocation L,
316 SourceLocation RParenLoc,
317 SourceRange AngleBrackets);
318 static CXXReinterpretCastExpr *CreateEmpty(ASTContext &Context,
319 unsigned pathSize);
320
classof(const Stmt * T)321 static bool classof(const Stmt *T) {
322 return T->getStmtClass() == CXXReinterpretCastExprClass;
323 }
324 };
325
326 /// \brief A C++ \c const_cast expression (C++ [expr.const.cast]).
327 ///
328 /// This expression node represents a const cast, e.g.,
329 /// \c const_cast<char*>(PtrToConstChar).
330 ///
331 /// A const_cast can remove type qualifiers but does not change the underlying
332 /// value.
333 class CXXConstCastExpr : public CXXNamedCastExpr {
CXXConstCastExpr(QualType ty,ExprValueKind VK,Expr * op,TypeSourceInfo * writtenTy,SourceLocation l,SourceLocation RParenLoc,SourceRange AngleBrackets)334 CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
335 TypeSourceInfo *writtenTy, SourceLocation l,
336 SourceLocation RParenLoc, SourceRange AngleBrackets)
337 : CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op,
338 0, writtenTy, l, RParenLoc, AngleBrackets) {}
339
CXXConstCastExpr(EmptyShell Empty)340 explicit CXXConstCastExpr(EmptyShell Empty)
341 : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0) { }
342
343 public:
344 static CXXConstCastExpr *Create(ASTContext &Context, QualType T,
345 ExprValueKind VK, Expr *Op,
346 TypeSourceInfo *WrittenTy, SourceLocation L,
347 SourceLocation RParenLoc,
348 SourceRange AngleBrackets);
349 static CXXConstCastExpr *CreateEmpty(ASTContext &Context);
350
classof(const Stmt * T)351 static bool classof(const Stmt *T) {
352 return T->getStmtClass() == CXXConstCastExprClass;
353 }
354 };
355
356 /// \brief A call to a literal operator (C++11 [over.literal])
357 /// written as a user-defined literal (C++11 [lit.ext]).
358 ///
359 /// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this
360 /// is semantically equivalent to a normal call, this AST node provides better
361 /// information about the syntactic representation of the literal.
362 ///
363 /// Since literal operators are never found by ADL and can only be declared at
364 /// namespace scope, a user-defined literal is never dependent.
365 class UserDefinedLiteral : public CallExpr {
366 /// \brief The location of a ud-suffix within the literal.
367 SourceLocation UDSuffixLoc;
368
369 public:
UserDefinedLiteral(ASTContext & C,Expr * Fn,ArrayRef<Expr * > Args,QualType T,ExprValueKind VK,SourceLocation LitEndLoc,SourceLocation SuffixLoc)370 UserDefinedLiteral(ASTContext &C, Expr *Fn, ArrayRef<Expr*> Args,
371 QualType T, ExprValueKind VK, SourceLocation LitEndLoc,
372 SourceLocation SuffixLoc)
373 : CallExpr(C, UserDefinedLiteralClass, Fn, 0, Args, T, VK, LitEndLoc),
374 UDSuffixLoc(SuffixLoc) {}
UserDefinedLiteral(ASTContext & C,EmptyShell Empty)375 explicit UserDefinedLiteral(ASTContext &C, EmptyShell Empty)
376 : CallExpr(C, UserDefinedLiteralClass, Empty) {}
377
378 /// The kind of literal operator which is invoked.
379 enum LiteralOperatorKind {
380 LOK_Raw, ///< Raw form: operator "" X (const char *)
381 LOK_Template, ///< Raw form: operator "" X<cs...> ()
382 LOK_Integer, ///< operator "" X (unsigned long long)
383 LOK_Floating, ///< operator "" X (long double)
384 LOK_String, ///< operator "" X (const CharT *, size_t)
385 LOK_Character ///< operator "" X (CharT)
386 };
387
388 /// \brief Returns the kind of literal operator invocation
389 /// which this expression represents.
390 LiteralOperatorKind getLiteralOperatorKind() const;
391
392 /// \brief If this is not a raw user-defined literal, get the
393 /// underlying cooked literal (representing the literal with the suffix
394 /// removed).
395 Expr *getCookedLiteral();
getCookedLiteral()396 const Expr *getCookedLiteral() const {
397 return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
398 }
399
getLocStart()400 SourceLocation getLocStart() const {
401 if (getLiteralOperatorKind() == LOK_Template)
402 return getRParenLoc();
403 return getArg(0)->getLocStart();
404 }
getLocEnd()405 SourceLocation getLocEnd() const { return getRParenLoc(); }
406
407
408 /// \brief Returns the location of a ud-suffix in the expression.
409 ///
410 /// For a string literal, there may be multiple identical suffixes. This
411 /// returns the first.
getUDSuffixLoc()412 SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }
413
414 /// \brief Returns the ud-suffix specified for this literal.
415 const IdentifierInfo *getUDSuffix() const;
416
classof(const Stmt * S)417 static bool classof(const Stmt *S) {
418 return S->getStmtClass() == UserDefinedLiteralClass;
419 }
420
421 friend class ASTStmtReader;
422 friend class ASTStmtWriter;
423 };
424
425 /// \brief A boolean literal, per ([C++ lex.bool] Boolean literals).
426 ///
427 class CXXBoolLiteralExpr : public Expr {
428 bool Value;
429 SourceLocation Loc;
430 public:
CXXBoolLiteralExpr(bool val,QualType Ty,SourceLocation l)431 CXXBoolLiteralExpr(bool val, QualType Ty, SourceLocation l) :
432 Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
433 false, false),
434 Value(val), Loc(l) {}
435
CXXBoolLiteralExpr(EmptyShell Empty)436 explicit CXXBoolLiteralExpr(EmptyShell Empty)
437 : Expr(CXXBoolLiteralExprClass, Empty) { }
438
getValue()439 bool getValue() const { return Value; }
setValue(bool V)440 void setValue(bool V) { Value = V; }
441
getLocStart()442 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()443 SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
444
getLocation()445 SourceLocation getLocation() const { return Loc; }
setLocation(SourceLocation L)446 void setLocation(SourceLocation L) { Loc = L; }
447
classof(const Stmt * T)448 static bool classof(const Stmt *T) {
449 return T->getStmtClass() == CXXBoolLiteralExprClass;
450 }
451
452 // Iterators
children()453 child_range children() { return child_range(); }
454 };
455
456 /// \brief The null pointer literal (C++11 [lex.nullptr])
457 ///
458 /// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
459 class CXXNullPtrLiteralExpr : public Expr {
460 SourceLocation Loc;
461 public:
CXXNullPtrLiteralExpr(QualType Ty,SourceLocation l)462 CXXNullPtrLiteralExpr(QualType Ty, SourceLocation l) :
463 Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
464 false, false),
465 Loc(l) {}
466
CXXNullPtrLiteralExpr(EmptyShell Empty)467 explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
468 : Expr(CXXNullPtrLiteralExprClass, Empty) { }
469
getLocStart()470 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()471 SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
472
getLocation()473 SourceLocation getLocation() const { return Loc; }
setLocation(SourceLocation L)474 void setLocation(SourceLocation L) { Loc = L; }
475
classof(const Stmt * T)476 static bool classof(const Stmt *T) {
477 return T->getStmtClass() == CXXNullPtrLiteralExprClass;
478 }
479
children()480 child_range children() { return child_range(); }
481 };
482
483 /// \brief Implicit construction of a std::initializer_list<T> object from an
484 /// array temporary within list-initialization (C++11 [dcl.init.list]p5).
485 class CXXStdInitializerListExpr : public Expr {
486 Stmt *SubExpr;
487
CXXStdInitializerListExpr(EmptyShell Empty)488 CXXStdInitializerListExpr(EmptyShell Empty)
489 : Expr(CXXStdInitializerListExprClass, Empty), SubExpr(0) {}
490
491 public:
CXXStdInitializerListExpr(QualType Ty,Expr * SubExpr)492 CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
493 : Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary,
494 Ty->isDependentType(), SubExpr->isValueDependent(),
495 SubExpr->isInstantiationDependent(),
496 SubExpr->containsUnexpandedParameterPack()),
497 SubExpr(SubExpr) {}
498
getSubExpr()499 Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
getSubExpr()500 const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }
501
getLocStart()502 SourceLocation getLocStart() const LLVM_READONLY {
503 return SubExpr->getLocStart();
504 }
getLocEnd()505 SourceLocation getLocEnd() const LLVM_READONLY {
506 return SubExpr->getLocEnd();
507 }
getSourceRange()508 SourceRange getSourceRange() const LLVM_READONLY {
509 return SubExpr->getSourceRange();
510 }
511
classof(const Stmt * S)512 static bool classof(const Stmt *S) {
513 return S->getStmtClass() == CXXStdInitializerListExprClass;
514 }
515
children()516 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
517
518 friend class ASTReader;
519 friend class ASTStmtReader;
520 };
521
522 /// A C++ \c typeid expression (C++ [expr.typeid]), which gets
523 /// the \c type_info that corresponds to the supplied type, or the (possibly
524 /// dynamic) type of the supplied expression.
525 ///
526 /// This represents code like \c typeid(int) or \c typeid(*objPtr)
527 class CXXTypeidExpr : public Expr {
528 private:
529 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
530 SourceRange Range;
531
532 public:
CXXTypeidExpr(QualType Ty,TypeSourceInfo * Operand,SourceRange R)533 CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
534 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
535 // typeid is never type-dependent (C++ [temp.dep.expr]p4)
536 false,
537 // typeid is value-dependent if the type or expression are dependent
538 Operand->getType()->isDependentType(),
539 Operand->getType()->isInstantiationDependentType(),
540 Operand->getType()->containsUnexpandedParameterPack()),
541 Operand(Operand), Range(R) { }
542
CXXTypeidExpr(QualType Ty,Expr * Operand,SourceRange R)543 CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
544 : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
545 // typeid is never type-dependent (C++ [temp.dep.expr]p4)
546 false,
547 // typeid is value-dependent if the type or expression are dependent
548 Operand->isTypeDependent() || Operand->isValueDependent(),
549 Operand->isInstantiationDependent(),
550 Operand->containsUnexpandedParameterPack()),
551 Operand(Operand), Range(R) { }
552
CXXTypeidExpr(EmptyShell Empty,bool isExpr)553 CXXTypeidExpr(EmptyShell Empty, bool isExpr)
554 : Expr(CXXTypeidExprClass, Empty) {
555 if (isExpr)
556 Operand = (Expr*)0;
557 else
558 Operand = (TypeSourceInfo*)0;
559 }
560
561 /// Determine whether this typeid has a type operand which is potentially
562 /// evaluated, per C++11 [expr.typeid]p3.
563 bool isPotentiallyEvaluated() const;
564
isTypeOperand()565 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
566
567 /// \brief Retrieves the type operand of this typeid() expression after
568 /// various required adjustments (removing reference types, cv-qualifiers).
569 QualType getTypeOperand() const;
570
571 /// \brief Retrieve source information for the type operand.
getTypeOperandSourceInfo()572 TypeSourceInfo *getTypeOperandSourceInfo() const {
573 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
574 return Operand.get<TypeSourceInfo *>();
575 }
576
setTypeOperandSourceInfo(TypeSourceInfo * TSI)577 void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
578 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
579 Operand = TSI;
580 }
581
getExprOperand()582 Expr *getExprOperand() const {
583 assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)");
584 return static_cast<Expr*>(Operand.get<Stmt *>());
585 }
586
setExprOperand(Expr * E)587 void setExprOperand(Expr *E) {
588 assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)");
589 Operand = E;
590 }
591
getLocStart()592 SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
getLocEnd()593 SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
getSourceRange()594 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
setSourceRange(SourceRange R)595 void setSourceRange(SourceRange R) { Range = R; }
596
classof(const Stmt * T)597 static bool classof(const Stmt *T) {
598 return T->getStmtClass() == CXXTypeidExprClass;
599 }
600
601 // Iterators
children()602 child_range children() {
603 if (isTypeOperand()) return child_range();
604 Stmt **begin = reinterpret_cast<Stmt**>(&Operand);
605 return child_range(begin, begin + 1);
606 }
607 };
608
609 /// \brief A member reference to an MSPropertyDecl.
610 ///
611 /// This expression always has pseudo-object type, and therefore it is
612 /// typically not encountered in a fully-typechecked expression except
613 /// within the syntactic form of a PseudoObjectExpr.
614 class MSPropertyRefExpr : public Expr {
615 Expr *BaseExpr;
616 MSPropertyDecl *TheDecl;
617 SourceLocation MemberLoc;
618 bool IsArrow;
619 NestedNameSpecifierLoc QualifierLoc;
620
621 public:
MSPropertyRefExpr(Expr * baseExpr,MSPropertyDecl * decl,bool isArrow,QualType ty,ExprValueKind VK,NestedNameSpecifierLoc qualifierLoc,SourceLocation nameLoc)622 MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
623 QualType ty, ExprValueKind VK,
624 NestedNameSpecifierLoc qualifierLoc,
625 SourceLocation nameLoc)
626 : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary,
627 /*type-dependent*/ false, baseExpr->isValueDependent(),
628 baseExpr->isInstantiationDependent(),
629 baseExpr->containsUnexpandedParameterPack()),
630 BaseExpr(baseExpr), TheDecl(decl),
631 MemberLoc(nameLoc), IsArrow(isArrow),
632 QualifierLoc(qualifierLoc) {}
633
MSPropertyRefExpr(EmptyShell Empty)634 MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}
635
getSourceRange()636 SourceRange getSourceRange() const LLVM_READONLY {
637 return SourceRange(getLocStart(), getLocEnd());
638 }
isImplicitAccess()639 bool isImplicitAccess() const {
640 return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
641 }
getLocStart()642 SourceLocation getLocStart() const {
643 if (!isImplicitAccess())
644 return BaseExpr->getLocStart();
645 else if (QualifierLoc)
646 return QualifierLoc.getBeginLoc();
647 else
648 return MemberLoc;
649 }
getLocEnd()650 SourceLocation getLocEnd() const { return getMemberLoc(); }
651
children()652 child_range children() {
653 return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
654 }
classof(const Stmt * T)655 static bool classof(const Stmt *T) {
656 return T->getStmtClass() == MSPropertyRefExprClass;
657 }
658
getBaseExpr()659 Expr *getBaseExpr() const { return BaseExpr; }
getPropertyDecl()660 MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
isArrow()661 bool isArrow() const { return IsArrow; }
getMemberLoc()662 SourceLocation getMemberLoc() const { return MemberLoc; }
getQualifierLoc()663 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
664
665 friend class ASTStmtReader;
666 };
667
668 /// A Microsoft C++ @c __uuidof expression, which gets
669 /// the _GUID that corresponds to the supplied type or expression.
670 ///
671 /// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
672 class CXXUuidofExpr : public Expr {
673 private:
674 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
675 SourceRange Range;
676
677 public:
CXXUuidofExpr(QualType Ty,TypeSourceInfo * Operand,SourceRange R)678 CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
679 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary,
680 false, Operand->getType()->isDependentType(),
681 Operand->getType()->isInstantiationDependentType(),
682 Operand->getType()->containsUnexpandedParameterPack()),
683 Operand(Operand), Range(R) { }
684
CXXUuidofExpr(QualType Ty,Expr * Operand,SourceRange R)685 CXXUuidofExpr(QualType Ty, Expr *Operand, SourceRange R)
686 : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary,
687 false, Operand->isTypeDependent(),
688 Operand->isInstantiationDependent(),
689 Operand->containsUnexpandedParameterPack()),
690 Operand(Operand), Range(R) { }
691
CXXUuidofExpr(EmptyShell Empty,bool isExpr)692 CXXUuidofExpr(EmptyShell Empty, bool isExpr)
693 : Expr(CXXUuidofExprClass, Empty) {
694 if (isExpr)
695 Operand = (Expr*)0;
696 else
697 Operand = (TypeSourceInfo*)0;
698 }
699
isTypeOperand()700 bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
701
702 /// \brief Retrieves the type operand of this __uuidof() expression after
703 /// various required adjustments (removing reference types, cv-qualifiers).
704 QualType getTypeOperand() const;
705
706 /// \brief Retrieve source information for the type operand.
getTypeOperandSourceInfo()707 TypeSourceInfo *getTypeOperandSourceInfo() const {
708 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
709 return Operand.get<TypeSourceInfo *>();
710 }
711
setTypeOperandSourceInfo(TypeSourceInfo * TSI)712 void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
713 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
714 Operand = TSI;
715 }
716
getExprOperand()717 Expr *getExprOperand() const {
718 assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)");
719 return static_cast<Expr*>(Operand.get<Stmt *>());
720 }
721
setExprOperand(Expr * E)722 void setExprOperand(Expr *E) {
723 assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)");
724 Operand = E;
725 }
726
getLocStart()727 SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
getLocEnd()728 SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
getSourceRange()729 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
setSourceRange(SourceRange R)730 void setSourceRange(SourceRange R) { Range = R; }
731
classof(const Stmt * T)732 static bool classof(const Stmt *T) {
733 return T->getStmtClass() == CXXUuidofExprClass;
734 }
735
736 /// Grabs __declspec(uuid()) off a type, or returns 0 if there is none.
737 static UuidAttr *GetUuidAttrOfType(QualType QT);
738
739 // Iterators
children()740 child_range children() {
741 if (isTypeOperand()) return child_range();
742 Stmt **begin = reinterpret_cast<Stmt**>(&Operand);
743 return child_range(begin, begin + 1);
744 }
745 };
746
747 /// \brief Represents the \c this expression in C++.
748 ///
749 /// This is a pointer to the object on which the current member function is
750 /// executing (C++ [expr.prim]p3). Example:
751 ///
752 /// \code
753 /// class Foo {
754 /// public:
755 /// void bar();
756 /// void test() { this->bar(); }
757 /// };
758 /// \endcode
759 class CXXThisExpr : public Expr {
760 SourceLocation Loc;
761 bool Implicit : 1;
762
763 public:
CXXThisExpr(SourceLocation L,QualType Type,bool isImplicit)764 CXXThisExpr(SourceLocation L, QualType Type, bool isImplicit)
765 : Expr(CXXThisExprClass, Type, VK_RValue, OK_Ordinary,
766 // 'this' is type-dependent if the class type of the enclosing
767 // member function is dependent (C++ [temp.dep.expr]p2)
768 Type->isDependentType(), Type->isDependentType(),
769 Type->isInstantiationDependentType(),
770 /*ContainsUnexpandedParameterPack=*/false),
771 Loc(L), Implicit(isImplicit) { }
772
CXXThisExpr(EmptyShell Empty)773 CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
774
getLocation()775 SourceLocation getLocation() const { return Loc; }
setLocation(SourceLocation L)776 void setLocation(SourceLocation L) { Loc = L; }
777
getLocStart()778 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()779 SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
780
isImplicit()781 bool isImplicit() const { return Implicit; }
setImplicit(bool I)782 void setImplicit(bool I) { Implicit = I; }
783
classof(const Stmt * T)784 static bool classof(const Stmt *T) {
785 return T->getStmtClass() == CXXThisExprClass;
786 }
787
788 // Iterators
children()789 child_range children() { return child_range(); }
790 };
791
792 /// \brief A C++ throw-expression (C++ [except.throw]).
793 ///
794 /// This handles 'throw' (for re-throwing the current exception) and
795 /// 'throw' assignment-expression. When assignment-expression isn't
796 /// present, Op will be null.
797 class CXXThrowExpr : public Expr {
798 Stmt *Op;
799 SourceLocation ThrowLoc;
800 /// \brief Whether the thrown variable (if any) is in scope.
801 unsigned IsThrownVariableInScope : 1;
802
803 friend class ASTStmtReader;
804
805 public:
806 // \p Ty is the void type which is used as the result type of the
807 // expression. The \p l is the location of the throw keyword. \p expr
808 // can by null, if the optional expression to throw isn't present.
CXXThrowExpr(Expr * expr,QualType Ty,SourceLocation l,bool IsThrownVariableInScope)809 CXXThrowExpr(Expr *expr, QualType Ty, SourceLocation l,
810 bool IsThrownVariableInScope) :
811 Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
812 expr && expr->isInstantiationDependent(),
813 expr && expr->containsUnexpandedParameterPack()),
814 Op(expr), ThrowLoc(l), IsThrownVariableInScope(IsThrownVariableInScope) {}
CXXThrowExpr(EmptyShell Empty)815 CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
816
getSubExpr()817 const Expr *getSubExpr() const { return cast_or_null<Expr>(Op); }
getSubExpr()818 Expr *getSubExpr() { return cast_or_null<Expr>(Op); }
819
getThrowLoc()820 SourceLocation getThrowLoc() const { return ThrowLoc; }
821
822 /// \brief Determines whether the variable thrown by this expression (if any!)
823 /// is within the innermost try block.
824 ///
825 /// This information is required to determine whether the NRVO can apply to
826 /// this variable.
isThrownVariableInScope()827 bool isThrownVariableInScope() const { return IsThrownVariableInScope; }
828
getLocStart()829 SourceLocation getLocStart() const LLVM_READONLY { return ThrowLoc; }
getLocEnd()830 SourceLocation getLocEnd() const LLVM_READONLY {
831 if (getSubExpr() == 0)
832 return ThrowLoc;
833 return getSubExpr()->getLocEnd();
834 }
835
classof(const Stmt * T)836 static bool classof(const Stmt *T) {
837 return T->getStmtClass() == CXXThrowExprClass;
838 }
839
840 // Iterators
children()841 child_range children() {
842 return child_range(&Op, Op ? &Op+1 : &Op);
843 }
844 };
845
846 /// \brief A default argument (C++ [dcl.fct.default]).
847 ///
848 /// This wraps up a function call argument that was created from the
849 /// corresponding parameter's default argument, when the call did not
850 /// explicitly supply arguments for all of the parameters.
851 class CXXDefaultArgExpr : public Expr {
852 /// \brief The parameter whose default is being used.
853 ///
854 /// When the bit is set, the subexpression is stored after the
855 /// CXXDefaultArgExpr itself. When the bit is clear, the parameter's
856 /// actual default expression is the subexpression.
857 llvm::PointerIntPair<ParmVarDecl *, 1, bool> Param;
858
859 /// \brief The location where the default argument expression was used.
860 SourceLocation Loc;
861
CXXDefaultArgExpr(StmtClass SC,SourceLocation Loc,ParmVarDecl * param)862 CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param)
863 : Expr(SC,
864 param->hasUnparsedDefaultArg()
865 ? param->getType().getNonReferenceType()
866 : param->getDefaultArg()->getType(),
867 param->getDefaultArg()->getValueKind(),
868 param->getDefaultArg()->getObjectKind(), false, false, false, false),
869 Param(param, false), Loc(Loc) { }
870
CXXDefaultArgExpr(StmtClass SC,SourceLocation Loc,ParmVarDecl * param,Expr * SubExpr)871 CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param,
872 Expr *SubExpr)
873 : Expr(SC, SubExpr->getType(),
874 SubExpr->getValueKind(), SubExpr->getObjectKind(),
875 false, false, false, false),
876 Param(param, true), Loc(Loc) {
877 *reinterpret_cast<Expr **>(this + 1) = SubExpr;
878 }
879
880 public:
CXXDefaultArgExpr(EmptyShell Empty)881 CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
882
883 // \p Param is the parameter whose default argument is used by this
884 // expression.
Create(ASTContext & C,SourceLocation Loc,ParmVarDecl * Param)885 static CXXDefaultArgExpr *Create(ASTContext &C, SourceLocation Loc,
886 ParmVarDecl *Param) {
887 return new (C) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param);
888 }
889
890 // \p Param is the parameter whose default argument is used by this
891 // expression, and \p SubExpr is the expression that will actually be used.
892 static CXXDefaultArgExpr *Create(ASTContext &C,
893 SourceLocation Loc,
894 ParmVarDecl *Param,
895 Expr *SubExpr);
896
897 // Retrieve the parameter that the argument was created from.
getParam()898 const ParmVarDecl *getParam() const { return Param.getPointer(); }
getParam()899 ParmVarDecl *getParam() { return Param.getPointer(); }
900
901 // Retrieve the actual argument to the function call.
getExpr()902 const Expr *getExpr() const {
903 if (Param.getInt())
904 return *reinterpret_cast<Expr const * const*> (this + 1);
905 return getParam()->getDefaultArg();
906 }
getExpr()907 Expr *getExpr() {
908 if (Param.getInt())
909 return *reinterpret_cast<Expr **> (this + 1);
910 return getParam()->getDefaultArg();
911 }
912
913 /// \brief Retrieve the location where this default argument was actually
914 /// used.
getUsedLocation()915 SourceLocation getUsedLocation() const { return Loc; }
916
917 /// Default argument expressions have no representation in the
918 /// source, so they have an empty source range.
getLocStart()919 SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); }
getLocEnd()920 SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); }
921
getExprLoc()922 SourceLocation getExprLoc() const LLVM_READONLY { return Loc; }
923
classof(const Stmt * T)924 static bool classof(const Stmt *T) {
925 return T->getStmtClass() == CXXDefaultArgExprClass;
926 }
927
928 // Iterators
children()929 child_range children() { return child_range(); }
930
931 friend class ASTStmtReader;
932 friend class ASTStmtWriter;
933 };
934
935 /// \brief A use of a default initializer in a constructor or in aggregate
936 /// initialization.
937 ///
938 /// This wraps a use of a C++ default initializer (technically,
939 /// a brace-or-equal-initializer for a non-static data member) when it
940 /// is implicitly used in a mem-initializer-list in a constructor
941 /// (C++11 [class.base.init]p8) or in aggregate initialization
942 /// (C++1y [dcl.init.aggr]p7).
943 class CXXDefaultInitExpr : public Expr {
944 /// \brief The field whose default is being used.
945 FieldDecl *Field;
946
947 /// \brief The location where the default initializer expression was used.
948 SourceLocation Loc;
949
950 CXXDefaultInitExpr(ASTContext &C, SourceLocation Loc, FieldDecl *Field,
951 QualType T);
952
CXXDefaultInitExpr(EmptyShell Empty)953 CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
954
955 public:
956 /// \p Field is the non-static data member whose default initializer is used
957 /// by this expression.
Create(ASTContext & C,SourceLocation Loc,FieldDecl * Field)958 static CXXDefaultInitExpr *Create(ASTContext &C, SourceLocation Loc,
959 FieldDecl *Field) {
960 return new (C) CXXDefaultInitExpr(C, Loc, Field, Field->getType());
961 }
962
963 /// \brief Get the field whose initializer will be used.
getField()964 FieldDecl *getField() { return Field; }
getField()965 const FieldDecl *getField() const { return Field; }
966
967 /// \brief Get the initialization expression that will be used.
getExpr()968 const Expr *getExpr() const { return Field->getInClassInitializer(); }
getExpr()969 Expr *getExpr() { return Field->getInClassInitializer(); }
970
getLocStart()971 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()972 SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
973
classof(const Stmt * T)974 static bool classof(const Stmt *T) {
975 return T->getStmtClass() == CXXDefaultInitExprClass;
976 }
977
978 // Iterators
children()979 child_range children() { return child_range(); }
980
981 friend class ASTReader;
982 friend class ASTStmtReader;
983 };
984
985 /// \brief Represents a C++ temporary.
986 class CXXTemporary {
987 /// \brief The destructor that needs to be called.
988 const CXXDestructorDecl *Destructor;
989
CXXTemporary(const CXXDestructorDecl * destructor)990 explicit CXXTemporary(const CXXDestructorDecl *destructor)
991 : Destructor(destructor) { }
992
993 public:
994 static CXXTemporary *Create(ASTContext &C,
995 const CXXDestructorDecl *Destructor);
996
getDestructor()997 const CXXDestructorDecl *getDestructor() const { return Destructor; }
setDestructor(const CXXDestructorDecl * Dtor)998 void setDestructor(const CXXDestructorDecl *Dtor) {
999 Destructor = Dtor;
1000 }
1001 };
1002
1003 /// \brief Represents binding an expression to a temporary.
1004 ///
1005 /// This ensures the destructor is called for the temporary. It should only be
1006 /// needed for non-POD, non-trivially destructable class types. For example:
1007 ///
1008 /// \code
1009 /// struct S {
1010 /// S() { } // User defined constructor makes S non-POD.
1011 /// ~S() { } // User defined destructor makes it non-trivial.
1012 /// };
1013 /// void test() {
1014 /// const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
1015 /// }
1016 /// \endcode
1017 class CXXBindTemporaryExpr : public Expr {
1018 CXXTemporary *Temp;
1019
1020 Stmt *SubExpr;
1021
CXXBindTemporaryExpr(CXXTemporary * temp,Expr * SubExpr)1022 CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr)
1023 : Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
1024 VK_RValue, OK_Ordinary, SubExpr->isTypeDependent(),
1025 SubExpr->isValueDependent(),
1026 SubExpr->isInstantiationDependent(),
1027 SubExpr->containsUnexpandedParameterPack()),
1028 Temp(temp), SubExpr(SubExpr) { }
1029
1030 public:
CXXBindTemporaryExpr(EmptyShell Empty)1031 CXXBindTemporaryExpr(EmptyShell Empty)
1032 : Expr(CXXBindTemporaryExprClass, Empty), Temp(0), SubExpr(0) {}
1033
1034 static CXXBindTemporaryExpr *Create(ASTContext &C, CXXTemporary *Temp,
1035 Expr* SubExpr);
1036
getTemporary()1037 CXXTemporary *getTemporary() { return Temp; }
getTemporary()1038 const CXXTemporary *getTemporary() const { return Temp; }
setTemporary(CXXTemporary * T)1039 void setTemporary(CXXTemporary *T) { Temp = T; }
1040
getSubExpr()1041 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
getSubExpr()1042 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
setSubExpr(Expr * E)1043 void setSubExpr(Expr *E) { SubExpr = E; }
1044
getLocStart()1045 SourceLocation getLocStart() const LLVM_READONLY {
1046 return SubExpr->getLocStart();
1047 }
getLocEnd()1048 SourceLocation getLocEnd() const LLVM_READONLY { return SubExpr->getLocEnd();}
1049
1050 // Implement isa/cast/dyncast/etc.
classof(const Stmt * T)1051 static bool classof(const Stmt *T) {
1052 return T->getStmtClass() == CXXBindTemporaryExprClass;
1053 }
1054
1055 // Iterators
children()1056 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
1057 };
1058
1059 /// \brief Represents a call to a C++ constructor.
1060 class CXXConstructExpr : public Expr {
1061 public:
1062 enum ConstructionKind {
1063 CK_Complete,
1064 CK_NonVirtualBase,
1065 CK_VirtualBase,
1066 CK_Delegating
1067 };
1068
1069 private:
1070 CXXConstructorDecl *Constructor;
1071
1072 SourceLocation Loc;
1073 SourceRange ParenRange;
1074 unsigned NumArgs : 16;
1075 bool Elidable : 1;
1076 bool HadMultipleCandidates : 1;
1077 bool ListInitialization : 1;
1078 bool ZeroInitialization : 1;
1079 unsigned ConstructKind : 2;
1080 Stmt **Args;
1081
1082 protected:
1083 CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
1084 SourceLocation Loc,
1085 CXXConstructorDecl *d, bool elidable,
1086 ArrayRef<Expr *> Args,
1087 bool HadMultipleCandidates,
1088 bool ListInitialization,
1089 bool ZeroInitialization,
1090 ConstructionKind ConstructKind,
1091 SourceRange ParenRange);
1092
1093 /// \brief Construct an empty C++ construction expression.
CXXConstructExpr(StmtClass SC,EmptyShell Empty)1094 CXXConstructExpr(StmtClass SC, EmptyShell Empty)
1095 : Expr(SC, Empty), Constructor(0), NumArgs(0), Elidable(false),
1096 HadMultipleCandidates(false), ListInitialization(false),
1097 ZeroInitialization(false), ConstructKind(0), Args(0)
1098 { }
1099
1100 public:
1101 /// \brief Construct an empty C++ construction expression.
CXXConstructExpr(EmptyShell Empty)1102 explicit CXXConstructExpr(EmptyShell Empty)
1103 : Expr(CXXConstructExprClass, Empty), Constructor(0),
1104 NumArgs(0), Elidable(false), HadMultipleCandidates(false),
1105 ListInitialization(false), ZeroInitialization(false),
1106 ConstructKind(0), Args(0)
1107 { }
1108
1109 static CXXConstructExpr *Create(ASTContext &C, QualType T,
1110 SourceLocation Loc,
1111 CXXConstructorDecl *D, bool Elidable,
1112 ArrayRef<Expr *> Args,
1113 bool HadMultipleCandidates,
1114 bool ListInitialization,
1115 bool ZeroInitialization,
1116 ConstructionKind ConstructKind,
1117 SourceRange ParenRange);
1118
getConstructor()1119 CXXConstructorDecl* getConstructor() const { return Constructor; }
setConstructor(CXXConstructorDecl * C)1120 void setConstructor(CXXConstructorDecl *C) { Constructor = C; }
1121
getLocation()1122 SourceLocation getLocation() const { return Loc; }
setLocation(SourceLocation Loc)1123 void setLocation(SourceLocation Loc) { this->Loc = Loc; }
1124
1125 /// \brief Whether this construction is elidable.
isElidable()1126 bool isElidable() const { return Elidable; }
setElidable(bool E)1127 void setElidable(bool E) { Elidable = E; }
1128
1129 /// \brief Whether the referred constructor was resolved from
1130 /// an overloaded set having size greater than 1.
hadMultipleCandidates()1131 bool hadMultipleCandidates() const { return HadMultipleCandidates; }
setHadMultipleCandidates(bool V)1132 void setHadMultipleCandidates(bool V) { HadMultipleCandidates = V; }
1133
1134 /// \brief Whether this constructor call was written as list-initialization.
isListInitialization()1135 bool isListInitialization() const { return ListInitialization; }
setListInitialization(bool V)1136 void setListInitialization(bool V) { ListInitialization = V; }
1137
1138 /// \brief Whether this construction first requires
1139 /// zero-initialization before the initializer is called.
requiresZeroInitialization()1140 bool requiresZeroInitialization() const { return ZeroInitialization; }
setRequiresZeroInitialization(bool ZeroInit)1141 void setRequiresZeroInitialization(bool ZeroInit) {
1142 ZeroInitialization = ZeroInit;
1143 }
1144
1145 /// \brief Determine whether this constructor is actually constructing
1146 /// a base class (rather than a complete object).
getConstructionKind()1147 ConstructionKind getConstructionKind() const {
1148 return (ConstructionKind)ConstructKind;
1149 }
setConstructionKind(ConstructionKind CK)1150 void setConstructionKind(ConstructionKind CK) {
1151 ConstructKind = CK;
1152 }
1153
1154 typedef ExprIterator arg_iterator;
1155 typedef ConstExprIterator const_arg_iterator;
1156
arg_begin()1157 arg_iterator arg_begin() { return Args; }
arg_end()1158 arg_iterator arg_end() { return Args + NumArgs; }
arg_begin()1159 const_arg_iterator arg_begin() const { return Args; }
arg_end()1160 const_arg_iterator arg_end() const { return Args + NumArgs; }
1161
getArgs()1162 Expr **getArgs() const { return reinterpret_cast<Expr **>(Args); }
getNumArgs()1163 unsigned getNumArgs() const { return NumArgs; }
1164
1165 /// \brief Return the specified argument.
getArg(unsigned Arg)1166 Expr *getArg(unsigned Arg) {
1167 assert(Arg < NumArgs && "Arg access out of range!");
1168 return cast<Expr>(Args[Arg]);
1169 }
getArg(unsigned Arg)1170 const Expr *getArg(unsigned Arg) const {
1171 assert(Arg < NumArgs && "Arg access out of range!");
1172 return cast<Expr>(Args[Arg]);
1173 }
1174
1175 /// \brief Set the specified argument.
setArg(unsigned Arg,Expr * ArgExpr)1176 void setArg(unsigned Arg, Expr *ArgExpr) {
1177 assert(Arg < NumArgs && "Arg access out of range!");
1178 Args[Arg] = ArgExpr;
1179 }
1180
1181 SourceLocation getLocStart() const LLVM_READONLY;
1182 SourceLocation getLocEnd() const LLVM_READONLY;
getParenRange()1183 SourceRange getParenRange() const { return ParenRange; }
setParenRange(SourceRange Range)1184 void setParenRange(SourceRange Range) { ParenRange = Range; }
1185
classof(const Stmt * T)1186 static bool classof(const Stmt *T) {
1187 return T->getStmtClass() == CXXConstructExprClass ||
1188 T->getStmtClass() == CXXTemporaryObjectExprClass;
1189 }
1190
1191 // Iterators
children()1192 child_range children() {
1193 return child_range(&Args[0], &Args[0]+NumArgs);
1194 }
1195
1196 friend class ASTStmtReader;
1197 };
1198
1199 /// \brief Represents an explicit C++ type conversion that uses "functional"
1200 /// notation (C++ [expr.type.conv]).
1201 ///
1202 /// Example:
1203 /// \code
1204 /// x = int(0.5);
1205 /// \endcode
1206 class CXXFunctionalCastExpr : public ExplicitCastExpr {
1207 SourceLocation TyBeginLoc;
1208 SourceLocation RParenLoc;
1209
CXXFunctionalCastExpr(QualType ty,ExprValueKind VK,TypeSourceInfo * writtenTy,SourceLocation tyBeginLoc,CastKind kind,Expr * castExpr,unsigned pathSize,SourceLocation rParenLoc)1210 CXXFunctionalCastExpr(QualType ty, ExprValueKind VK,
1211 TypeSourceInfo *writtenTy,
1212 SourceLocation tyBeginLoc, CastKind kind,
1213 Expr *castExpr, unsigned pathSize,
1214 SourceLocation rParenLoc)
1215 : ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind,
1216 castExpr, pathSize, writtenTy),
1217 TyBeginLoc(tyBeginLoc), RParenLoc(rParenLoc) {}
1218
CXXFunctionalCastExpr(EmptyShell Shell,unsigned PathSize)1219 explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize)
1220 : ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize) { }
1221
1222 public:
1223 static CXXFunctionalCastExpr *Create(ASTContext &Context, QualType T,
1224 ExprValueKind VK,
1225 TypeSourceInfo *Written,
1226 SourceLocation TyBeginLoc,
1227 CastKind Kind, Expr *Op,
1228 const CXXCastPath *Path,
1229 SourceLocation RPLoc);
1230 static CXXFunctionalCastExpr *CreateEmpty(ASTContext &Context,
1231 unsigned PathSize);
1232
getTypeBeginLoc()1233 SourceLocation getTypeBeginLoc() const { return TyBeginLoc; }
setTypeBeginLoc(SourceLocation L)1234 void setTypeBeginLoc(SourceLocation L) { TyBeginLoc = L; }
getRParenLoc()1235 SourceLocation getRParenLoc() const { return RParenLoc; }
setRParenLoc(SourceLocation L)1236 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
1237
getLocStart()1238 SourceLocation getLocStart() const LLVM_READONLY { return TyBeginLoc; }
getLocEnd()1239 SourceLocation getLocEnd() const LLVM_READONLY {
1240 return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getLocEnd();
1241 }
1242
classof(const Stmt * T)1243 static bool classof(const Stmt *T) {
1244 return T->getStmtClass() == CXXFunctionalCastExprClass;
1245 }
1246 };
1247
1248 /// @brief Represents a C++ functional cast expression that builds a
1249 /// temporary object.
1250 ///
1251 /// This expression type represents a C++ "functional" cast
1252 /// (C++[expr.type.conv]) with N != 1 arguments that invokes a
1253 /// constructor to build a temporary object. With N == 1 arguments the
1254 /// functional cast expression will be represented by CXXFunctionalCastExpr.
1255 /// Example:
1256 /// \code
1257 /// struct X { X(int, float); }
1258 ///
1259 /// X create_X() {
1260 /// return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
1261 /// };
1262 /// \endcode
1263 class CXXTemporaryObjectExpr : public CXXConstructExpr {
1264 TypeSourceInfo *Type;
1265
1266 public:
1267 CXXTemporaryObjectExpr(ASTContext &C, CXXConstructorDecl *Cons,
1268 TypeSourceInfo *Type,
1269 ArrayRef<Expr *> Args,
1270 SourceRange parenRange,
1271 bool HadMultipleCandidates,
1272 bool ListInitialization,
1273 bool ZeroInitialization);
CXXTemporaryObjectExpr(EmptyShell Empty)1274 explicit CXXTemporaryObjectExpr(EmptyShell Empty)
1275 : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty), Type() { }
1276
getTypeSourceInfo()1277 TypeSourceInfo *getTypeSourceInfo() const { return Type; }
1278
1279 SourceLocation getLocStart() const LLVM_READONLY;
1280 SourceLocation getLocEnd() const LLVM_READONLY;
1281
classof(const Stmt * T)1282 static bool classof(const Stmt *T) {
1283 return T->getStmtClass() == CXXTemporaryObjectExprClass;
1284 }
1285
1286 friend class ASTStmtReader;
1287 };
1288
1289 /// \brief A C++ lambda expression, which produces a function object
1290 /// (of unspecified type) that can be invoked later.
1291 ///
1292 /// Example:
1293 /// \code
1294 /// void low_pass_filter(std::vector<double> &values, double cutoff) {
1295 /// values.erase(std::remove_if(values.begin(), values.end(),
1296 /// [=](double value) { return value > cutoff; });
1297 /// }
1298 /// \endcode
1299 ///
1300 /// C++11 lambda expressions can capture local variables, either by copying
1301 /// the values of those local variables at the time the function
1302 /// object is constructed (not when it is called!) or by holding a
1303 /// reference to the local variable. These captures can occur either
1304 /// implicitly or can be written explicitly between the square
1305 /// brackets ([...]) that start the lambda expression.
1306 ///
1307 /// C++1y introduces a new form of "capture" called an init-capture that
1308 /// includes an initializing expression (rather than capturing a variable),
1309 /// and which can never occur implicitly.
1310 class LambdaExpr : public Expr {
1311 enum {
1312 /// \brief Flag used by the Capture class to indicate that the given
1313 /// capture was implicit.
1314 Capture_Implicit = 0x01,
1315
1316 /// \brief Flag used by the Capture class to indicate that the
1317 /// given capture was by-copy.
1318 ///
1319 /// This includes the case of a non-reference init-capture.
1320 Capture_ByCopy = 0x02
1321 };
1322
1323 /// \brief The source range that covers the lambda introducer ([...]).
1324 SourceRange IntroducerRange;
1325
1326 /// \brief The number of captures.
1327 unsigned NumCaptures : 16;
1328
1329 /// \brief The default capture kind, which is a value of type
1330 /// LambdaCaptureDefault.
1331 unsigned CaptureDefault : 2;
1332
1333 /// \brief Whether this lambda had an explicit parameter list vs. an
1334 /// implicit (and empty) parameter list.
1335 unsigned ExplicitParams : 1;
1336
1337 /// \brief Whether this lambda had the result type explicitly specified.
1338 unsigned ExplicitResultType : 1;
1339
1340 /// \brief Whether there are any array index variables stored at the end of
1341 /// this lambda expression.
1342 unsigned HasArrayIndexVars : 1;
1343
1344 /// \brief The location of the closing brace ('}') that completes
1345 /// the lambda.
1346 ///
1347 /// The location of the brace is also available by looking up the
1348 /// function call operator in the lambda class. However, it is
1349 /// stored here to improve the performance of getSourceRange(), and
1350 /// to avoid having to deserialize the function call operator from a
1351 /// module file just to determine the source range.
1352 SourceLocation ClosingBrace;
1353
1354 // Note: The capture initializers are stored directly after the lambda
1355 // expression, along with the index variables used to initialize by-copy
1356 // array captures.
1357
1358 public:
1359 /// \brief Describes the capture of a variable or of \c this, or of a
1360 /// C++1y init-capture.
1361 class Capture {
1362 llvm::PointerIntPair<Decl *, 2> DeclAndBits;
1363 SourceLocation Loc;
1364 SourceLocation EllipsisLoc;
1365
1366 friend class ASTStmtReader;
1367 friend class ASTStmtWriter;
1368
1369 public:
1370 /// \brief Create a new capture of a variable or of \c this.
1371 ///
1372 /// \param Loc The source location associated with this capture.
1373 ///
1374 /// \param Kind The kind of capture (this, byref, bycopy), which must
1375 /// not be init-capture.
1376 ///
1377 /// \param Implicit Whether the capture was implicit or explicit.
1378 ///
1379 /// \param Var The local variable being captured, or null if capturing
1380 /// \c this.
1381 ///
1382 /// \param EllipsisLoc The location of the ellipsis (...) for a
1383 /// capture that is a pack expansion, or an invalid source
1384 /// location to indicate that this is not a pack expansion.
1385 Capture(SourceLocation Loc, bool Implicit,
1386 LambdaCaptureKind Kind, VarDecl *Var = 0,
1387 SourceLocation EllipsisLoc = SourceLocation());
1388
1389 /// \brief Create a new init-capture.
1390 Capture(FieldDecl *Field);
1391
1392 /// \brief Determine the kind of capture.
1393 LambdaCaptureKind getCaptureKind() const;
1394
1395 /// \brief Determine whether this capture handles the C++ \c this
1396 /// pointer.
capturesThis()1397 bool capturesThis() const { return DeclAndBits.getPointer() == 0; }
1398
1399 /// \brief Determine whether this capture handles a variable.
capturesVariable()1400 bool capturesVariable() const {
1401 return dyn_cast_or_null<VarDecl>(DeclAndBits.getPointer());
1402 }
1403
1404 /// \brief Determine whether this is an init-capture.
isInitCapture()1405 bool isInitCapture() const { return getCaptureKind() == LCK_Init; }
1406
1407 /// \brief Retrieve the declaration of the local variable being
1408 /// captured.
1409 ///
1410 /// This operation is only valid if this capture is a variable capture
1411 /// (other than a capture of \c this).
getCapturedVar()1412 VarDecl *getCapturedVar() const {
1413 assert(capturesVariable() && "No variable available for 'this' capture");
1414 return cast<VarDecl>(DeclAndBits.getPointer());
1415 }
1416
1417 /// \brief Retrieve the field for an init-capture.
1418 ///
1419 /// This works only for an init-capture. To retrieve the FieldDecl for
1420 /// a captured variable or for a capture of \c this, use
1421 /// LambdaExpr::getLambdaClass and CXXRecordDecl::getCaptureFields.
getInitCaptureField()1422 FieldDecl *getInitCaptureField() const {
1423 assert(getCaptureKind() == LCK_Init && "no field for non-init-capture");
1424 return cast<FieldDecl>(DeclAndBits.getPointer());
1425 }
1426
1427 /// \brief Determine whether this was an implicit capture (not
1428 /// written between the square brackets introducing the lambda).
isImplicit()1429 bool isImplicit() const { return DeclAndBits.getInt() & Capture_Implicit; }
1430
1431 /// \brief Determine whether this was an explicit capture (written
1432 /// between the square brackets introducing the lambda).
isExplicit()1433 bool isExplicit() const { return !isImplicit(); }
1434
1435 /// \brief Retrieve the source location of the capture.
1436 ///
1437 /// For an explicit capture, this returns the location of the
1438 /// explicit capture in the source. For an implicit capture, this
1439 /// returns the location at which the variable or \c this was first
1440 /// used.
getLocation()1441 SourceLocation getLocation() const { return Loc; }
1442
1443 /// \brief Determine whether this capture is a pack expansion,
1444 /// which captures a function parameter pack.
isPackExpansion()1445 bool isPackExpansion() const { return EllipsisLoc.isValid(); }
1446
1447 /// \brief Retrieve the location of the ellipsis for a capture
1448 /// that is a pack expansion.
getEllipsisLoc()1449 SourceLocation getEllipsisLoc() const {
1450 assert(isPackExpansion() && "No ellipsis location for a non-expansion");
1451 return EllipsisLoc;
1452 }
1453 };
1454
1455 private:
1456 /// \brief Construct a lambda expression.
1457 LambdaExpr(QualType T, SourceRange IntroducerRange,
1458 LambdaCaptureDefault CaptureDefault,
1459 ArrayRef<Capture> Captures,
1460 bool ExplicitParams,
1461 bool ExplicitResultType,
1462 ArrayRef<Expr *> CaptureInits,
1463 ArrayRef<VarDecl *> ArrayIndexVars,
1464 ArrayRef<unsigned> ArrayIndexStarts,
1465 SourceLocation ClosingBrace,
1466 bool ContainsUnexpandedParameterPack);
1467
1468 /// \brief Construct an empty lambda expression.
LambdaExpr(EmptyShell Empty,unsigned NumCaptures,bool HasArrayIndexVars)1469 LambdaExpr(EmptyShell Empty, unsigned NumCaptures, bool HasArrayIndexVars)
1470 : Expr(LambdaExprClass, Empty),
1471 NumCaptures(NumCaptures), CaptureDefault(LCD_None), ExplicitParams(false),
1472 ExplicitResultType(false), HasArrayIndexVars(true) {
1473 getStoredStmts()[NumCaptures] = 0;
1474 }
1475
getStoredStmts()1476 Stmt **getStoredStmts() const {
1477 return reinterpret_cast<Stmt **>(const_cast<LambdaExpr *>(this) + 1);
1478 }
1479
1480 /// \brief Retrieve the mapping from captures to the first array index
1481 /// variable.
getArrayIndexStarts()1482 unsigned *getArrayIndexStarts() const {
1483 return reinterpret_cast<unsigned *>(getStoredStmts() + NumCaptures + 1);
1484 }
1485
1486 /// \brief Retrieve the complete set of array-index variables.
getArrayIndexVars()1487 VarDecl **getArrayIndexVars() const {
1488 unsigned ArrayIndexSize =
1489 llvm::RoundUpToAlignment(sizeof(unsigned) * (NumCaptures + 1),
1490 llvm::alignOf<VarDecl*>());
1491 return reinterpret_cast<VarDecl **>(
1492 reinterpret_cast<char*>(getArrayIndexStarts()) + ArrayIndexSize);
1493 }
1494
1495 public:
1496 /// \brief Construct a new lambda expression.
1497 static LambdaExpr *Create(ASTContext &C,
1498 CXXRecordDecl *Class,
1499 SourceRange IntroducerRange,
1500 LambdaCaptureDefault CaptureDefault,
1501 ArrayRef<Capture> Captures,
1502 bool ExplicitParams,
1503 bool ExplicitResultType,
1504 ArrayRef<Expr *> CaptureInits,
1505 ArrayRef<VarDecl *> ArrayIndexVars,
1506 ArrayRef<unsigned> ArrayIndexStarts,
1507 SourceLocation ClosingBrace,
1508 bool ContainsUnexpandedParameterPack);
1509
1510 /// \brief Construct a new lambda expression that will be deserialized from
1511 /// an external source.
1512 static LambdaExpr *CreateDeserialized(ASTContext &C, unsigned NumCaptures,
1513 unsigned NumArrayIndexVars);
1514
1515 /// \brief Determine the default capture kind for this lambda.
getCaptureDefault()1516 LambdaCaptureDefault getCaptureDefault() const {
1517 return static_cast<LambdaCaptureDefault>(CaptureDefault);
1518 }
1519
1520 /// \brief An iterator that walks over the captures of the lambda,
1521 /// both implicit and explicit.
1522 typedef const Capture *capture_iterator;
1523
1524 /// \brief Retrieve an iterator pointing to the first lambda capture.
1525 capture_iterator capture_begin() const;
1526
1527 /// \brief Retrieve an iterator pointing past the end of the
1528 /// sequence of lambda captures.
1529 capture_iterator capture_end() const;
1530
1531 /// \brief Determine the number of captures in this lambda.
capture_size()1532 unsigned capture_size() const { return NumCaptures; }
1533
1534 /// \brief Retrieve an iterator pointing to the first explicit
1535 /// lambda capture.
1536 capture_iterator explicit_capture_begin() const;
1537
1538 /// \brief Retrieve an iterator pointing past the end of the sequence of
1539 /// explicit lambda captures.
1540 capture_iterator explicit_capture_end() const;
1541
1542 /// \brief Retrieve an iterator pointing to the first implicit
1543 /// lambda capture.
1544 capture_iterator implicit_capture_begin() const;
1545
1546 /// \brief Retrieve an iterator pointing past the end of the sequence of
1547 /// implicit lambda captures.
1548 capture_iterator implicit_capture_end() const;
1549
1550 /// \brief Iterator that walks over the capture initialization
1551 /// arguments.
1552 typedef Expr **capture_init_iterator;
1553
1554 /// \brief Retrieve the first initialization argument for this
1555 /// lambda expression (which initializes the first capture field).
capture_init_begin()1556 capture_init_iterator capture_init_begin() const {
1557 return reinterpret_cast<Expr **>(getStoredStmts());
1558 }
1559
1560 /// \brief Retrieve the iterator pointing one past the last
1561 /// initialization argument for this lambda expression.
capture_init_end()1562 capture_init_iterator capture_init_end() const {
1563 return capture_init_begin() + NumCaptures;
1564 }
1565
1566 /// \brief Retrieve the initializer for an init-capture.
getInitCaptureInit(capture_iterator Capture)1567 Expr *getInitCaptureInit(capture_iterator Capture) {
1568 assert(Capture >= explicit_capture_begin() &&
1569 Capture <= explicit_capture_end() && Capture->isInitCapture());
1570 return capture_init_begin()[Capture - capture_begin()];
1571 }
getInitCaptureInit(capture_iterator Capture)1572 const Expr *getInitCaptureInit(capture_iterator Capture) const {
1573 return const_cast<LambdaExpr*>(this)->getInitCaptureInit(Capture);
1574 }
1575
1576 /// \brief Retrieve the set of index variables used in the capture
1577 /// initializer of an array captured by copy.
1578 ///
1579 /// \param Iter The iterator that points at the capture initializer for
1580 /// which we are extracting the corresponding index variables.
1581 ArrayRef<VarDecl *> getCaptureInitIndexVars(capture_init_iterator Iter) const;
1582
1583 /// \brief Retrieve the source range covering the lambda introducer,
1584 /// which contains the explicit capture list surrounded by square
1585 /// brackets ([...]).
getIntroducerRange()1586 SourceRange getIntroducerRange() const { return IntroducerRange; }
1587
1588 /// \brief Retrieve the class that corresponds to the lambda.
1589 ///
1590 /// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the
1591 /// captures in its fields and provides the various operations permitted
1592 /// on a lambda (copying, calling).
1593 CXXRecordDecl *getLambdaClass() const;
1594
1595 /// \brief Retrieve the function call operator associated with this
1596 /// lambda expression.
1597 CXXMethodDecl *getCallOperator() const;
1598
1599 /// \brief Retrieve the body of the lambda.
1600 CompoundStmt *getBody() const;
1601
1602 /// \brief Determine whether the lambda is mutable, meaning that any
1603 /// captures values can be modified.
1604 bool isMutable() const;
1605
1606 /// \brief Determine whether this lambda has an explicit parameter
1607 /// list vs. an implicit (empty) parameter list.
hasExplicitParameters()1608 bool hasExplicitParameters() const { return ExplicitParams; }
1609
1610 /// \brief Whether this lambda had its result type explicitly specified.
hasExplicitResultType()1611 bool hasExplicitResultType() const { return ExplicitResultType; }
1612
classof(const Stmt * T)1613 static bool classof(const Stmt *T) {
1614 return T->getStmtClass() == LambdaExprClass;
1615 }
1616
getLocStart()1617 SourceLocation getLocStart() const LLVM_READONLY {
1618 return IntroducerRange.getBegin();
1619 }
getLocEnd()1620 SourceLocation getLocEnd() const LLVM_READONLY { return ClosingBrace; }
1621
children()1622 child_range children() {
1623 return child_range(getStoredStmts(), getStoredStmts() + NumCaptures + 1);
1624 }
1625
1626 friend class ASTStmtReader;
1627 friend class ASTStmtWriter;
1628 };
1629
1630 /// An expression "T()" which creates a value-initialized rvalue of type
1631 /// T, which is a non-class type. See (C++98 [5.2.3p2]).
1632 class CXXScalarValueInitExpr : public Expr {
1633 SourceLocation RParenLoc;
1634 TypeSourceInfo *TypeInfo;
1635
1636 friend class ASTStmtReader;
1637
1638 public:
1639 /// \brief Create an explicitly-written scalar-value initialization
1640 /// expression.
CXXScalarValueInitExpr(QualType Type,TypeSourceInfo * TypeInfo,SourceLocation rParenLoc)1641 CXXScalarValueInitExpr(QualType Type,
1642 TypeSourceInfo *TypeInfo,
1643 SourceLocation rParenLoc ) :
1644 Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary,
1645 false, false, Type->isInstantiationDependentType(), false),
1646 RParenLoc(rParenLoc), TypeInfo(TypeInfo) {}
1647
CXXScalarValueInitExpr(EmptyShell Shell)1648 explicit CXXScalarValueInitExpr(EmptyShell Shell)
1649 : Expr(CXXScalarValueInitExprClass, Shell) { }
1650
getTypeSourceInfo()1651 TypeSourceInfo *getTypeSourceInfo() const {
1652 return TypeInfo;
1653 }
1654
getRParenLoc()1655 SourceLocation getRParenLoc() const { return RParenLoc; }
1656
1657 SourceLocation getLocStart() const LLVM_READONLY;
getLocEnd()1658 SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
1659
classof(const Stmt * T)1660 static bool classof(const Stmt *T) {
1661 return T->getStmtClass() == CXXScalarValueInitExprClass;
1662 }
1663
1664 // Iterators
children()1665 child_range children() { return child_range(); }
1666 };
1667
1668 /// \brief Represents a new-expression for memory allocation and constructor
1669 /// calls, e.g: "new CXXNewExpr(foo)".
1670 class CXXNewExpr : public Expr {
1671 /// Contains an optional array size expression, an optional initialization
1672 /// expression, and any number of optional placement arguments, in that order.
1673 Stmt **SubExprs;
1674 /// \brief Points to the allocation function used.
1675 FunctionDecl *OperatorNew;
1676 /// \brief Points to the deallocation function used in case of error. May be
1677 /// null.
1678 FunctionDecl *OperatorDelete;
1679
1680 /// \brief The allocated type-source information, as written in the source.
1681 TypeSourceInfo *AllocatedTypeInfo;
1682
1683 /// \brief If the allocated type was expressed as a parenthesized type-id,
1684 /// the source range covering the parenthesized type-id.
1685 SourceRange TypeIdParens;
1686
1687 /// \brief Range of the entire new expression.
1688 SourceRange Range;
1689
1690 /// \brief Source-range of a paren-delimited initializer.
1691 SourceRange DirectInitRange;
1692
1693 /// Was the usage ::new, i.e. is the global new to be used?
1694 bool GlobalNew : 1;
1695 /// Do we allocate an array? If so, the first SubExpr is the size expression.
1696 bool Array : 1;
1697 /// If this is an array allocation, does the usual deallocation
1698 /// function for the allocated type want to know the allocated size?
1699 bool UsualArrayDeleteWantsSize : 1;
1700 /// The number of placement new arguments.
1701 unsigned NumPlacementArgs : 13;
1702 /// What kind of initializer do we have? Could be none, parens, or braces.
1703 /// In storage, we distinguish between "none, and no initializer expr", and
1704 /// "none, but an implicit initializer expr".
1705 unsigned StoredInitializationStyle : 2;
1706
1707 friend class ASTStmtReader;
1708 friend class ASTStmtWriter;
1709 public:
1710 enum InitializationStyle {
1711 NoInit, ///< New-expression has no initializer as written.
1712 CallInit, ///< New-expression has a C++98 paren-delimited initializer.
1713 ListInit ///< New-expression has a C++11 list-initializer.
1714 };
1715
1716 CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
1717 FunctionDecl *operatorDelete, bool usualArrayDeleteWantsSize,
1718 ArrayRef<Expr*> placementArgs,
1719 SourceRange typeIdParens, Expr *arraySize,
1720 InitializationStyle initializationStyle, Expr *initializer,
1721 QualType ty, TypeSourceInfo *AllocatedTypeInfo,
1722 SourceRange Range, SourceRange directInitRange);
CXXNewExpr(EmptyShell Shell)1723 explicit CXXNewExpr(EmptyShell Shell)
1724 : Expr(CXXNewExprClass, Shell), SubExprs(0) { }
1725
1726 void AllocateArgsArray(ASTContext &C, bool isArray, unsigned numPlaceArgs,
1727 bool hasInitializer);
1728
getAllocatedType()1729 QualType getAllocatedType() const {
1730 assert(getType()->isPointerType());
1731 return getType()->getAs<PointerType>()->getPointeeType();
1732 }
1733
getAllocatedTypeSourceInfo()1734 TypeSourceInfo *getAllocatedTypeSourceInfo() const {
1735 return AllocatedTypeInfo;
1736 }
1737
1738 /// \brief True if the allocation result needs to be null-checked.
1739 ///
1740 /// C++11 [expr.new]p13:
1741 /// If the allocation function returns null, initialization shall
1742 /// not be done, the deallocation function shall not be called,
1743 /// and the value of the new-expression shall be null.
1744 ///
1745 /// An allocation function is not allowed to return null unless it
1746 /// has a non-throwing exception-specification. The '03 rule is
1747 /// identical except that the definition of a non-throwing
1748 /// exception specification is just "is it throw()?".
1749 bool shouldNullCheckAllocation(ASTContext &Ctx) const;
1750
getOperatorNew()1751 FunctionDecl *getOperatorNew() const { return OperatorNew; }
setOperatorNew(FunctionDecl * D)1752 void setOperatorNew(FunctionDecl *D) { OperatorNew = D; }
getOperatorDelete()1753 FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
setOperatorDelete(FunctionDecl * D)1754 void setOperatorDelete(FunctionDecl *D) { OperatorDelete = D; }
1755
isArray()1756 bool isArray() const { return Array; }
getArraySize()1757 Expr *getArraySize() {
1758 return Array ? cast<Expr>(SubExprs[0]) : 0;
1759 }
getArraySize()1760 const Expr *getArraySize() const {
1761 return Array ? cast<Expr>(SubExprs[0]) : 0;
1762 }
1763
getNumPlacementArgs()1764 unsigned getNumPlacementArgs() const { return NumPlacementArgs; }
getPlacementArgs()1765 Expr **getPlacementArgs() {
1766 return reinterpret_cast<Expr **>(SubExprs + Array + hasInitializer());
1767 }
1768
getPlacementArg(unsigned i)1769 Expr *getPlacementArg(unsigned i) {
1770 assert(i < NumPlacementArgs && "Index out of range");
1771 return getPlacementArgs()[i];
1772 }
getPlacementArg(unsigned i)1773 const Expr *getPlacementArg(unsigned i) const {
1774 assert(i < NumPlacementArgs && "Index out of range");
1775 return const_cast<CXXNewExpr*>(this)->getPlacementArg(i);
1776 }
1777
isParenTypeId()1778 bool isParenTypeId() const { return TypeIdParens.isValid(); }
getTypeIdParens()1779 SourceRange getTypeIdParens() const { return TypeIdParens; }
1780
isGlobalNew()1781 bool isGlobalNew() const { return GlobalNew; }
1782
1783 /// \brief Whether this new-expression has any initializer at all.
hasInitializer()1784 bool hasInitializer() const { return StoredInitializationStyle > 0; }
1785
1786 /// \brief The kind of initializer this new-expression has.
getInitializationStyle()1787 InitializationStyle getInitializationStyle() const {
1788 if (StoredInitializationStyle == 0)
1789 return NoInit;
1790 return static_cast<InitializationStyle>(StoredInitializationStyle-1);
1791 }
1792
1793 /// \brief The initializer of this new-expression.
getInitializer()1794 Expr *getInitializer() {
1795 return hasInitializer() ? cast<Expr>(SubExprs[Array]) : 0;
1796 }
getInitializer()1797 const Expr *getInitializer() const {
1798 return hasInitializer() ? cast<Expr>(SubExprs[Array]) : 0;
1799 }
1800
1801 /// \brief Returns the CXXConstructExpr from this new-expression, or null.
getConstructExpr()1802 const CXXConstructExpr* getConstructExpr() const {
1803 return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
1804 }
1805
1806 /// Answers whether the usual array deallocation function for the
1807 /// allocated type expects the size of the allocation as a
1808 /// parameter.
doesUsualArrayDeleteWantSize()1809 bool doesUsualArrayDeleteWantSize() const {
1810 return UsualArrayDeleteWantsSize;
1811 }
1812
1813 typedef ExprIterator arg_iterator;
1814 typedef ConstExprIterator const_arg_iterator;
1815
placement_arg_begin()1816 arg_iterator placement_arg_begin() {
1817 return SubExprs + Array + hasInitializer();
1818 }
placement_arg_end()1819 arg_iterator placement_arg_end() {
1820 return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
1821 }
placement_arg_begin()1822 const_arg_iterator placement_arg_begin() const {
1823 return SubExprs + Array + hasInitializer();
1824 }
placement_arg_end()1825 const_arg_iterator placement_arg_end() const {
1826 return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
1827 }
1828
1829 typedef Stmt **raw_arg_iterator;
raw_arg_begin()1830 raw_arg_iterator raw_arg_begin() { return SubExprs; }
raw_arg_end()1831 raw_arg_iterator raw_arg_end() {
1832 return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
1833 }
raw_arg_begin()1834 const_arg_iterator raw_arg_begin() const { return SubExprs; }
raw_arg_end()1835 const_arg_iterator raw_arg_end() const {
1836 return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
1837 }
1838
getStartLoc()1839 SourceLocation getStartLoc() const { return Range.getBegin(); }
getEndLoc()1840 SourceLocation getEndLoc() const { return Range.getEnd(); }
1841
getDirectInitRange()1842 SourceRange getDirectInitRange() const { return DirectInitRange; }
1843
getSourceRange()1844 SourceRange getSourceRange() const LLVM_READONLY {
1845 return Range;
1846 }
getLocStart()1847 SourceLocation getLocStart() const LLVM_READONLY { return getStartLoc(); }
getLocEnd()1848 SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
1849
classof(const Stmt * T)1850 static bool classof(const Stmt *T) {
1851 return T->getStmtClass() == CXXNewExprClass;
1852 }
1853
1854 // Iterators
children()1855 child_range children() {
1856 return child_range(raw_arg_begin(), raw_arg_end());
1857 }
1858 };
1859
1860 /// \brief Represents a \c delete expression for memory deallocation and
1861 /// destructor calls, e.g. "delete[] pArray".
1862 class CXXDeleteExpr : public Expr {
1863 /// Points to the operator delete overload that is used. Could be a member.
1864 FunctionDecl *OperatorDelete;
1865 /// The pointer expression to be deleted.
1866 Stmt *Argument;
1867 /// Location of the expression.
1868 SourceLocation Loc;
1869 /// Is this a forced global delete, i.e. "::delete"?
1870 bool GlobalDelete : 1;
1871 /// Is this the array form of delete, i.e. "delete[]"?
1872 bool ArrayForm : 1;
1873 /// ArrayFormAsWritten can be different from ArrayForm if 'delete' is applied
1874 /// to pointer-to-array type (ArrayFormAsWritten will be false while ArrayForm
1875 /// will be true).
1876 bool ArrayFormAsWritten : 1;
1877 /// Does the usual deallocation function for the element type require
1878 /// a size_t argument?
1879 bool UsualArrayDeleteWantsSize : 1;
1880 public:
CXXDeleteExpr(QualType ty,bool globalDelete,bool arrayForm,bool arrayFormAsWritten,bool usualArrayDeleteWantsSize,FunctionDecl * operatorDelete,Expr * arg,SourceLocation loc)1881 CXXDeleteExpr(QualType ty, bool globalDelete, bool arrayForm,
1882 bool arrayFormAsWritten, bool usualArrayDeleteWantsSize,
1883 FunctionDecl *operatorDelete, Expr *arg, SourceLocation loc)
1884 : Expr(CXXDeleteExprClass, ty, VK_RValue, OK_Ordinary, false, false,
1885 arg->isInstantiationDependent(),
1886 arg->containsUnexpandedParameterPack()),
1887 OperatorDelete(operatorDelete), Argument(arg), Loc(loc),
1888 GlobalDelete(globalDelete),
1889 ArrayForm(arrayForm), ArrayFormAsWritten(arrayFormAsWritten),
1890 UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { }
CXXDeleteExpr(EmptyShell Shell)1891 explicit CXXDeleteExpr(EmptyShell Shell)
1892 : Expr(CXXDeleteExprClass, Shell), OperatorDelete(0), Argument(0) { }
1893
isGlobalDelete()1894 bool isGlobalDelete() const { return GlobalDelete; }
isArrayForm()1895 bool isArrayForm() const { return ArrayForm; }
isArrayFormAsWritten()1896 bool isArrayFormAsWritten() const { return ArrayFormAsWritten; }
1897
1898 /// Answers whether the usual array deallocation function for the
1899 /// allocated type expects the size of the allocation as a
1900 /// parameter. This can be true even if the actual deallocation
1901 /// function that we're using doesn't want a size.
doesUsualArrayDeleteWantSize()1902 bool doesUsualArrayDeleteWantSize() const {
1903 return UsualArrayDeleteWantsSize;
1904 }
1905
getOperatorDelete()1906 FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
1907
getArgument()1908 Expr *getArgument() { return cast<Expr>(Argument); }
getArgument()1909 const Expr *getArgument() const { return cast<Expr>(Argument); }
1910
1911 /// \brief Retrieve the type being destroyed.
1912 ///
1913 /// If the type being destroyed is a dependent type which may or may not
1914 /// be a pointer, return an invalid type.
1915 QualType getDestroyedType() const;
1916
getLocStart()1917 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()1918 SourceLocation getLocEnd() const LLVM_READONLY {return Argument->getLocEnd();}
1919
classof(const Stmt * T)1920 static bool classof(const Stmt *T) {
1921 return T->getStmtClass() == CXXDeleteExprClass;
1922 }
1923
1924 // Iterators
children()1925 child_range children() { return child_range(&Argument, &Argument+1); }
1926
1927 friend class ASTStmtReader;
1928 };
1929
1930 /// \brief Stores the type being destroyed by a pseudo-destructor expression.
1931 class PseudoDestructorTypeStorage {
1932 /// \brief Either the type source information or the name of the type, if
1933 /// it couldn't be resolved due to type-dependence.
1934 llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;
1935
1936 /// \brief The starting source location of the pseudo-destructor type.
1937 SourceLocation Location;
1938
1939 public:
PseudoDestructorTypeStorage()1940 PseudoDestructorTypeStorage() { }
1941
PseudoDestructorTypeStorage(IdentifierInfo * II,SourceLocation Loc)1942 PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
1943 : Type(II), Location(Loc) { }
1944
1945 PseudoDestructorTypeStorage(TypeSourceInfo *Info);
1946
getTypeSourceInfo()1947 TypeSourceInfo *getTypeSourceInfo() const {
1948 return Type.dyn_cast<TypeSourceInfo *>();
1949 }
1950
getIdentifier()1951 IdentifierInfo *getIdentifier() const {
1952 return Type.dyn_cast<IdentifierInfo *>();
1953 }
1954
getLocation()1955 SourceLocation getLocation() const { return Location; }
1956 };
1957
1958 /// \brief Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
1959 ///
1960 /// A pseudo-destructor is an expression that looks like a member access to a
1961 /// destructor of a scalar type, except that scalar types don't have
1962 /// destructors. For example:
1963 ///
1964 /// \code
1965 /// typedef int T;
1966 /// void f(int *p) {
1967 /// p->T::~T();
1968 /// }
1969 /// \endcode
1970 ///
1971 /// Pseudo-destructors typically occur when instantiating templates such as:
1972 ///
1973 /// \code
1974 /// template<typename T>
1975 /// void destroy(T* ptr) {
1976 /// ptr->T::~T();
1977 /// }
1978 /// \endcode
1979 ///
1980 /// for scalar types. A pseudo-destructor expression has no run-time semantics
1981 /// beyond evaluating the base expression.
1982 class CXXPseudoDestructorExpr : public Expr {
1983 /// \brief The base expression (that is being destroyed).
1984 Stmt *Base;
1985
1986 /// \brief Whether the operator was an arrow ('->'); otherwise, it was a
1987 /// period ('.').
1988 bool IsArrow : 1;
1989
1990 /// \brief The location of the '.' or '->' operator.
1991 SourceLocation OperatorLoc;
1992
1993 /// \brief The nested-name-specifier that follows the operator, if present.
1994 NestedNameSpecifierLoc QualifierLoc;
1995
1996 /// \brief The type that precedes the '::' in a qualified pseudo-destructor
1997 /// expression.
1998 TypeSourceInfo *ScopeType;
1999
2000 /// \brief The location of the '::' in a qualified pseudo-destructor
2001 /// expression.
2002 SourceLocation ColonColonLoc;
2003
2004 /// \brief The location of the '~'.
2005 SourceLocation TildeLoc;
2006
2007 /// \brief The type being destroyed, or its name if we were unable to
2008 /// resolve the name.
2009 PseudoDestructorTypeStorage DestroyedType;
2010
2011 friend class ASTStmtReader;
2012
2013 public:
2014 CXXPseudoDestructorExpr(ASTContext &Context,
2015 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
2016 NestedNameSpecifierLoc QualifierLoc,
2017 TypeSourceInfo *ScopeType,
2018 SourceLocation ColonColonLoc,
2019 SourceLocation TildeLoc,
2020 PseudoDestructorTypeStorage DestroyedType);
2021
CXXPseudoDestructorExpr(EmptyShell Shell)2022 explicit CXXPseudoDestructorExpr(EmptyShell Shell)
2023 : Expr(CXXPseudoDestructorExprClass, Shell),
2024 Base(0), IsArrow(false), QualifierLoc(), ScopeType(0) { }
2025
getBase()2026 Expr *getBase() const { return cast<Expr>(Base); }
2027
2028 /// \brief Determines whether this member expression actually had
2029 /// a C++ nested-name-specifier prior to the name of the member, e.g.,
2030 /// x->Base::foo.
hasQualifier()2031 bool hasQualifier() const { return QualifierLoc.hasQualifier(); }
2032
2033 /// \brief Retrieves the nested-name-specifier that qualifies the type name,
2034 /// with source-location information.
getQualifierLoc()2035 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2036
2037 /// \brief If the member name was qualified, retrieves the
2038 /// nested-name-specifier that precedes the member name. Otherwise, returns
2039 /// null.
getQualifier()2040 NestedNameSpecifier *getQualifier() const {
2041 return QualifierLoc.getNestedNameSpecifier();
2042 }
2043
2044 /// \brief Determine whether this pseudo-destructor expression was written
2045 /// using an '->' (otherwise, it used a '.').
isArrow()2046 bool isArrow() const { return IsArrow; }
2047
2048 /// \brief Retrieve the location of the '.' or '->' operator.
getOperatorLoc()2049 SourceLocation getOperatorLoc() const { return OperatorLoc; }
2050
2051 /// \brief Retrieve the scope type in a qualified pseudo-destructor
2052 /// expression.
2053 ///
2054 /// Pseudo-destructor expressions can have extra qualification within them
2055 /// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
2056 /// Here, if the object type of the expression is (or may be) a scalar type,
2057 /// \p T may also be a scalar type and, therefore, cannot be part of a
2058 /// nested-name-specifier. It is stored as the "scope type" of the pseudo-
2059 /// destructor expression.
getScopeTypeInfo()2060 TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; }
2061
2062 /// \brief Retrieve the location of the '::' in a qualified pseudo-destructor
2063 /// expression.
getColonColonLoc()2064 SourceLocation getColonColonLoc() const { return ColonColonLoc; }
2065
2066 /// \brief Retrieve the location of the '~'.
getTildeLoc()2067 SourceLocation getTildeLoc() const { return TildeLoc; }
2068
2069 /// \brief Retrieve the source location information for the type
2070 /// being destroyed.
2071 ///
2072 /// This type-source information is available for non-dependent
2073 /// pseudo-destructor expressions and some dependent pseudo-destructor
2074 /// expressions. Returns null if we only have the identifier for a
2075 /// dependent pseudo-destructor expression.
getDestroyedTypeInfo()2076 TypeSourceInfo *getDestroyedTypeInfo() const {
2077 return DestroyedType.getTypeSourceInfo();
2078 }
2079
2080 /// \brief In a dependent pseudo-destructor expression for which we do not
2081 /// have full type information on the destroyed type, provides the name
2082 /// of the destroyed type.
getDestroyedTypeIdentifier()2083 IdentifierInfo *getDestroyedTypeIdentifier() const {
2084 return DestroyedType.getIdentifier();
2085 }
2086
2087 /// \brief Retrieve the type being destroyed.
2088 QualType getDestroyedType() const;
2089
2090 /// \brief Retrieve the starting location of the type being destroyed.
getDestroyedTypeLoc()2091 SourceLocation getDestroyedTypeLoc() const {
2092 return DestroyedType.getLocation();
2093 }
2094
2095 /// \brief Set the name of destroyed type for a dependent pseudo-destructor
2096 /// expression.
setDestroyedType(IdentifierInfo * II,SourceLocation Loc)2097 void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
2098 DestroyedType = PseudoDestructorTypeStorage(II, Loc);
2099 }
2100
2101 /// \brief Set the destroyed type.
setDestroyedType(TypeSourceInfo * Info)2102 void setDestroyedType(TypeSourceInfo *Info) {
2103 DestroyedType = PseudoDestructorTypeStorage(Info);
2104 }
2105
getLocStart()2106 SourceLocation getLocStart() const LLVM_READONLY {return Base->getLocStart();}
2107 SourceLocation getLocEnd() const LLVM_READONLY;
2108
classof(const Stmt * T)2109 static bool classof(const Stmt *T) {
2110 return T->getStmtClass() == CXXPseudoDestructorExprClass;
2111 }
2112
2113 // Iterators
children()2114 child_range children() { return child_range(&Base, &Base + 1); }
2115 };
2116
2117 /// \brief Represents a GCC or MS unary type trait, as used in the
2118 /// implementation of TR1/C++11 type trait templates.
2119 ///
2120 /// Example:
2121 /// \code
2122 /// __is_pod(int) == true
2123 /// __is_enum(std::string) == false
2124 /// \endcode
2125 class UnaryTypeTraitExpr : public Expr {
2126 /// \brief The trait. A UnaryTypeTrait enum in MSVC compatible unsigned.
2127 unsigned UTT : 31;
2128 /// The value of the type trait. Unspecified if dependent.
2129 bool Value : 1;
2130
2131 /// \brief The location of the type trait keyword.
2132 SourceLocation Loc;
2133
2134 /// \brief The location of the closing paren.
2135 SourceLocation RParen;
2136
2137 /// \brief The type being queried.
2138 TypeSourceInfo *QueriedType;
2139
2140 public:
UnaryTypeTraitExpr(SourceLocation loc,UnaryTypeTrait utt,TypeSourceInfo * queried,bool value,SourceLocation rparen,QualType ty)2141 UnaryTypeTraitExpr(SourceLocation loc, UnaryTypeTrait utt,
2142 TypeSourceInfo *queried, bool value,
2143 SourceLocation rparen, QualType ty)
2144 : Expr(UnaryTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
2145 false, queried->getType()->isDependentType(),
2146 queried->getType()->isInstantiationDependentType(),
2147 queried->getType()->containsUnexpandedParameterPack()),
2148 UTT(utt), Value(value), Loc(loc), RParen(rparen), QueriedType(queried) { }
2149
UnaryTypeTraitExpr(EmptyShell Empty)2150 explicit UnaryTypeTraitExpr(EmptyShell Empty)
2151 : Expr(UnaryTypeTraitExprClass, Empty), UTT(0), Value(false),
2152 QueriedType() { }
2153
getLocStart()2154 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()2155 SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
2156
getTrait()2157 UnaryTypeTrait getTrait() const { return static_cast<UnaryTypeTrait>(UTT); }
2158
getQueriedType()2159 QualType getQueriedType() const { return QueriedType->getType(); }
2160
getQueriedTypeSourceInfo()2161 TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
2162
getValue()2163 bool getValue() const { return Value; }
2164
classof(const Stmt * T)2165 static bool classof(const Stmt *T) {
2166 return T->getStmtClass() == UnaryTypeTraitExprClass;
2167 }
2168
2169 // Iterators
children()2170 child_range children() { return child_range(); }
2171
2172 friend class ASTStmtReader;
2173 };
2174
2175 /// \brief Represents a GCC or MS binary type trait, as used in the
2176 /// implementation of TR1/C++11 type trait templates.
2177 ///
2178 /// Example:
2179 /// \code
2180 /// __is_base_of(Base, Derived) == true
2181 /// \endcode
2182 class BinaryTypeTraitExpr : public Expr {
2183 /// \brief The trait. A BinaryTypeTrait enum in MSVC compatible unsigned.
2184 unsigned BTT : 8;
2185
2186 /// The value of the type trait. Unspecified if dependent.
2187 bool Value : 1;
2188
2189 /// \brief The location of the type trait keyword.
2190 SourceLocation Loc;
2191
2192 /// \brief The location of the closing paren.
2193 SourceLocation RParen;
2194
2195 /// \brief The lhs type being queried.
2196 TypeSourceInfo *LhsType;
2197
2198 /// \brief The rhs type being queried.
2199 TypeSourceInfo *RhsType;
2200
2201 public:
BinaryTypeTraitExpr(SourceLocation loc,BinaryTypeTrait btt,TypeSourceInfo * lhsType,TypeSourceInfo * rhsType,bool value,SourceLocation rparen,QualType ty)2202 BinaryTypeTraitExpr(SourceLocation loc, BinaryTypeTrait btt,
2203 TypeSourceInfo *lhsType, TypeSourceInfo *rhsType,
2204 bool value, SourceLocation rparen, QualType ty)
2205 : Expr(BinaryTypeTraitExprClass, ty, VK_RValue, OK_Ordinary, false,
2206 lhsType->getType()->isDependentType() ||
2207 rhsType->getType()->isDependentType(),
2208 (lhsType->getType()->isInstantiationDependentType() ||
2209 rhsType->getType()->isInstantiationDependentType()),
2210 (lhsType->getType()->containsUnexpandedParameterPack() ||
2211 rhsType->getType()->containsUnexpandedParameterPack())),
2212 BTT(btt), Value(value), Loc(loc), RParen(rparen),
2213 LhsType(lhsType), RhsType(rhsType) { }
2214
2215
BinaryTypeTraitExpr(EmptyShell Empty)2216 explicit BinaryTypeTraitExpr(EmptyShell Empty)
2217 : Expr(BinaryTypeTraitExprClass, Empty), BTT(0), Value(false),
2218 LhsType(), RhsType() { }
2219
getLocStart()2220 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()2221 SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
2222
getTrait()2223 BinaryTypeTrait getTrait() const {
2224 return static_cast<BinaryTypeTrait>(BTT);
2225 }
2226
getLhsType()2227 QualType getLhsType() const { return LhsType->getType(); }
getRhsType()2228 QualType getRhsType() const { return RhsType->getType(); }
2229
getLhsTypeSourceInfo()2230 TypeSourceInfo *getLhsTypeSourceInfo() const { return LhsType; }
getRhsTypeSourceInfo()2231 TypeSourceInfo *getRhsTypeSourceInfo() const { return RhsType; }
2232
getValue()2233 bool getValue() const { assert(!isTypeDependent()); return Value; }
2234
classof(const Stmt * T)2235 static bool classof(const Stmt *T) {
2236 return T->getStmtClass() == BinaryTypeTraitExprClass;
2237 }
2238
2239 // Iterators
children()2240 child_range children() { return child_range(); }
2241
2242 friend class ASTStmtReader;
2243 };
2244
2245 /// \brief A type trait used in the implementation of various C++11 and
2246 /// Library TR1 trait templates.
2247 ///
2248 /// \code
2249 /// __is_trivially_constructible(vector<int>, int*, int*)
2250 /// \endcode
2251 class TypeTraitExpr : public Expr {
2252 /// \brief The location of the type trait keyword.
2253 SourceLocation Loc;
2254
2255 /// \brief The location of the closing parenthesis.
2256 SourceLocation RParenLoc;
2257
2258 // Note: The TypeSourceInfos for the arguments are allocated after the
2259 // TypeTraitExpr.
2260
2261 TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
2262 ArrayRef<TypeSourceInfo *> Args,
2263 SourceLocation RParenLoc,
2264 bool Value);
2265
TypeTraitExpr(EmptyShell Empty)2266 TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) { }
2267
2268 /// \brief Retrieve the argument types.
getTypeSourceInfos()2269 TypeSourceInfo **getTypeSourceInfos() {
2270 return reinterpret_cast<TypeSourceInfo **>(this+1);
2271 }
2272
2273 /// \brief Retrieve the argument types.
getTypeSourceInfos()2274 TypeSourceInfo * const *getTypeSourceInfos() const {
2275 return reinterpret_cast<TypeSourceInfo * const*>(this+1);
2276 }
2277
2278 public:
2279 /// \brief Create a new type trait expression.
2280 static TypeTraitExpr *Create(ASTContext &C, QualType T, SourceLocation Loc,
2281 TypeTrait Kind,
2282 ArrayRef<TypeSourceInfo *> Args,
2283 SourceLocation RParenLoc,
2284 bool Value);
2285
2286 static TypeTraitExpr *CreateDeserialized(ASTContext &C, unsigned NumArgs);
2287
2288 /// \brief Determine which type trait this expression uses.
getTrait()2289 TypeTrait getTrait() const {
2290 return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
2291 }
2292
getValue()2293 bool getValue() const {
2294 assert(!isValueDependent());
2295 return TypeTraitExprBits.Value;
2296 }
2297
2298 /// \brief Determine the number of arguments to this type trait.
getNumArgs()2299 unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }
2300
2301 /// \brief Retrieve the Ith argument.
getArg(unsigned I)2302 TypeSourceInfo *getArg(unsigned I) const {
2303 assert(I < getNumArgs() && "Argument out-of-range");
2304 return getArgs()[I];
2305 }
2306
2307 /// \brief Retrieve the argument types.
getArgs()2308 ArrayRef<TypeSourceInfo *> getArgs() const {
2309 return ArrayRef<TypeSourceInfo *>(getTypeSourceInfos(), getNumArgs());
2310 }
2311
2312 typedef TypeSourceInfo **arg_iterator;
arg_begin()2313 arg_iterator arg_begin() {
2314 return getTypeSourceInfos();
2315 }
arg_end()2316 arg_iterator arg_end() {
2317 return getTypeSourceInfos() + getNumArgs();
2318 }
2319
2320 typedef TypeSourceInfo const * const *arg_const_iterator;
arg_begin()2321 arg_const_iterator arg_begin() const { return getTypeSourceInfos(); }
arg_end()2322 arg_const_iterator arg_end() const {
2323 return getTypeSourceInfos() + getNumArgs();
2324 }
2325
getLocStart()2326 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()2327 SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
2328
classof(const Stmt * T)2329 static bool classof(const Stmt *T) {
2330 return T->getStmtClass() == TypeTraitExprClass;
2331 }
2332
2333 // Iterators
children()2334 child_range children() { return child_range(); }
2335
2336 friend class ASTStmtReader;
2337 friend class ASTStmtWriter;
2338
2339 };
2340
2341 /// \brief An Embarcadero array type trait, as used in the implementation of
2342 /// __array_rank and __array_extent.
2343 ///
2344 /// Example:
2345 /// \code
2346 /// __array_rank(int[10][20]) == 2
2347 /// __array_extent(int, 1) == 20
2348 /// \endcode
2349 class ArrayTypeTraitExpr : public Expr {
2350 virtual void anchor();
2351
2352 /// \brief The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
2353 unsigned ATT : 2;
2354
2355 /// \brief The value of the type trait. Unspecified if dependent.
2356 uint64_t Value;
2357
2358 /// \brief The array dimension being queried, or -1 if not used.
2359 Expr *Dimension;
2360
2361 /// \brief The location of the type trait keyword.
2362 SourceLocation Loc;
2363
2364 /// \brief The location of the closing paren.
2365 SourceLocation RParen;
2366
2367 /// \brief The type being queried.
2368 TypeSourceInfo *QueriedType;
2369
2370 public:
ArrayTypeTraitExpr(SourceLocation loc,ArrayTypeTrait att,TypeSourceInfo * queried,uint64_t value,Expr * dimension,SourceLocation rparen,QualType ty)2371 ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
2372 TypeSourceInfo *queried, uint64_t value,
2373 Expr *dimension, SourceLocation rparen, QualType ty)
2374 : Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
2375 false, queried->getType()->isDependentType(),
2376 (queried->getType()->isInstantiationDependentType() ||
2377 (dimension && dimension->isInstantiationDependent())),
2378 queried->getType()->containsUnexpandedParameterPack()),
2379 ATT(att), Value(value), Dimension(dimension),
2380 Loc(loc), RParen(rparen), QueriedType(queried) { }
2381
2382
ArrayTypeTraitExpr(EmptyShell Empty)2383 explicit ArrayTypeTraitExpr(EmptyShell Empty)
2384 : Expr(ArrayTypeTraitExprClass, Empty), ATT(0), Value(false),
2385 QueriedType() { }
2386
~ArrayTypeTraitExpr()2387 virtual ~ArrayTypeTraitExpr() { }
2388
getLocStart()2389 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()2390 SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
2391
getTrait()2392 ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
2393
getQueriedType()2394 QualType getQueriedType() const { return QueriedType->getType(); }
2395
getQueriedTypeSourceInfo()2396 TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
2397
getValue()2398 uint64_t getValue() const { assert(!isTypeDependent()); return Value; }
2399
getDimensionExpression()2400 Expr *getDimensionExpression() const { return Dimension; }
2401
classof(const Stmt * T)2402 static bool classof(const Stmt *T) {
2403 return T->getStmtClass() == ArrayTypeTraitExprClass;
2404 }
2405
2406 // Iterators
children()2407 child_range children() { return child_range(); }
2408
2409 friend class ASTStmtReader;
2410 };
2411
2412 /// \brief An expression trait intrinsic.
2413 ///
2414 /// Example:
2415 /// \code
2416 /// __is_lvalue_expr(std::cout) == true
2417 /// __is_lvalue_expr(1) == false
2418 /// \endcode
2419 class ExpressionTraitExpr : public Expr {
2420 /// \brief The trait. A ExpressionTrait enum in MSVC compatible unsigned.
2421 unsigned ET : 31;
2422 /// \brief The value of the type trait. Unspecified if dependent.
2423 bool Value : 1;
2424
2425 /// \brief The location of the type trait keyword.
2426 SourceLocation Loc;
2427
2428 /// \brief The location of the closing paren.
2429 SourceLocation RParen;
2430
2431 /// \brief The expression being queried.
2432 Expr* QueriedExpression;
2433 public:
ExpressionTraitExpr(SourceLocation loc,ExpressionTrait et,Expr * queried,bool value,SourceLocation rparen,QualType resultType)2434 ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et,
2435 Expr *queried, bool value,
2436 SourceLocation rparen, QualType resultType)
2437 : Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary,
2438 false, // Not type-dependent
2439 // Value-dependent if the argument is type-dependent.
2440 queried->isTypeDependent(),
2441 queried->isInstantiationDependent(),
2442 queried->containsUnexpandedParameterPack()),
2443 ET(et), Value(value), Loc(loc), RParen(rparen),
2444 QueriedExpression(queried) { }
2445
ExpressionTraitExpr(EmptyShell Empty)2446 explicit ExpressionTraitExpr(EmptyShell Empty)
2447 : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false),
2448 QueriedExpression() { }
2449
getLocStart()2450 SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
getLocEnd()2451 SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
2452
getTrait()2453 ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
2454
getQueriedExpression()2455 Expr *getQueriedExpression() const { return QueriedExpression; }
2456
getValue()2457 bool getValue() const { return Value; }
2458
classof(const Stmt * T)2459 static bool classof(const Stmt *T) {
2460 return T->getStmtClass() == ExpressionTraitExprClass;
2461 }
2462
2463 // Iterators
children()2464 child_range children() { return child_range(); }
2465
2466 friend class ASTStmtReader;
2467 };
2468
2469
2470 /// \brief A reference to an overloaded function set, either an
2471 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
2472 class OverloadExpr : public Expr {
2473 /// \brief The common name of these declarations.
2474 DeclarationNameInfo NameInfo;
2475
2476 /// \brief The nested-name-specifier that qualifies the name, if any.
2477 NestedNameSpecifierLoc QualifierLoc;
2478
2479 /// The results. These are undesugared, which is to say, they may
2480 /// include UsingShadowDecls. Access is relative to the naming
2481 /// class.
2482 // FIXME: Allocate this data after the OverloadExpr subclass.
2483 DeclAccessPair *Results;
2484 unsigned NumResults;
2485
2486 protected:
2487 /// \brief Whether the name includes info for explicit template
2488 /// keyword and arguments.
2489 bool HasTemplateKWAndArgsInfo;
2490
2491 /// \brief Return the optional template keyword and arguments info.
2492 ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo(); // defined far below.
2493
2494 /// \brief Return the optional template keyword and arguments info.
getTemplateKWAndArgsInfo()2495 const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
2496 return const_cast<OverloadExpr*>(this)->getTemplateKWAndArgsInfo();
2497 }
2498
2499 OverloadExpr(StmtClass K, ASTContext &C,
2500 NestedNameSpecifierLoc QualifierLoc,
2501 SourceLocation TemplateKWLoc,
2502 const DeclarationNameInfo &NameInfo,
2503 const TemplateArgumentListInfo *TemplateArgs,
2504 UnresolvedSetIterator Begin, UnresolvedSetIterator End,
2505 bool KnownDependent,
2506 bool KnownInstantiationDependent,
2507 bool KnownContainsUnexpandedParameterPack);
2508
OverloadExpr(StmtClass K,EmptyShell Empty)2509 OverloadExpr(StmtClass K, EmptyShell Empty)
2510 : Expr(K, Empty), QualifierLoc(), Results(0), NumResults(0),
2511 HasTemplateKWAndArgsInfo(false) { }
2512
2513 void initializeResults(ASTContext &C,
2514 UnresolvedSetIterator Begin,
2515 UnresolvedSetIterator End);
2516
2517 public:
2518 struct FindResult {
2519 OverloadExpr *Expression;
2520 bool IsAddressOfOperand;
2521 bool HasFormOfMemberPointer;
2522 };
2523
2524 /// \brief Finds the overloaded expression in the given expression \p E of
2525 /// OverloadTy.
2526 ///
2527 /// \return the expression (which must be there) and true if it has
2528 /// the particular form of a member pointer expression
find(Expr * E)2529 static FindResult find(Expr *E) {
2530 assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload));
2531
2532 FindResult Result;
2533
2534 E = E->IgnoreParens();
2535 if (isa<UnaryOperator>(E)) {
2536 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
2537 E = cast<UnaryOperator>(E)->getSubExpr();
2538 OverloadExpr *Ovl = cast<OverloadExpr>(E->IgnoreParens());
2539
2540 Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
2541 Result.IsAddressOfOperand = true;
2542 Result.Expression = Ovl;
2543 } else {
2544 Result.HasFormOfMemberPointer = false;
2545 Result.IsAddressOfOperand = false;
2546 Result.Expression = cast<OverloadExpr>(E);
2547 }
2548
2549 return Result;
2550 }
2551
2552 /// \brief Gets the naming class of this lookup, if any.
2553 CXXRecordDecl *getNamingClass() const;
2554
2555 typedef UnresolvedSetImpl::iterator decls_iterator;
decls_begin()2556 decls_iterator decls_begin() const { return UnresolvedSetIterator(Results); }
decls_end()2557 decls_iterator decls_end() const {
2558 return UnresolvedSetIterator(Results + NumResults);
2559 }
2560
2561 /// \brief Gets the number of declarations in the unresolved set.
getNumDecls()2562 unsigned getNumDecls() const { return NumResults; }
2563
2564 /// \brief Gets the full name info.
getNameInfo()2565 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2566
2567 /// \brief Gets the name looked up.
getName()2568 DeclarationName getName() const { return NameInfo.getName(); }
2569
2570 /// \brief Gets the location of the name.
getNameLoc()2571 SourceLocation getNameLoc() const { return NameInfo.getLoc(); }
2572
2573 /// \brief Fetches the nested-name qualifier, if one was given.
getQualifier()2574 NestedNameSpecifier *getQualifier() const {
2575 return QualifierLoc.getNestedNameSpecifier();
2576 }
2577
2578 /// \brief Fetches the nested-name qualifier with source-location
2579 /// information, if one was given.
getQualifierLoc()2580 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2581
2582 /// \brief Retrieve the location of the template keyword preceding
2583 /// this name, if any.
getTemplateKeywordLoc()2584 SourceLocation getTemplateKeywordLoc() const {
2585 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2586 return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
2587 }
2588
2589 /// \brief Retrieve the location of the left angle bracket starting the
2590 /// explicit template argument list following the name, if any.
getLAngleLoc()2591 SourceLocation getLAngleLoc() const {
2592 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2593 return getTemplateKWAndArgsInfo()->LAngleLoc;
2594 }
2595
2596 /// \brief Retrieve the location of the right angle bracket ending the
2597 /// explicit template argument list following the name, if any.
getRAngleLoc()2598 SourceLocation getRAngleLoc() const {
2599 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2600 return getTemplateKWAndArgsInfo()->RAngleLoc;
2601 }
2602
2603 /// \brief Determines whether the name was preceded by the template keyword.
hasTemplateKeyword()2604 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
2605
2606 /// \brief Determines whether this expression had explicit template arguments.
hasExplicitTemplateArgs()2607 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
2608
2609 // Note that, inconsistently with the explicit-template-argument AST
2610 // nodes, users are *forbidden* from calling these methods on objects
2611 // without explicit template arguments.
2612
getExplicitTemplateArgs()2613 ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
2614 assert(hasExplicitTemplateArgs());
2615 return *getTemplateKWAndArgsInfo();
2616 }
2617
getExplicitTemplateArgs()2618 const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
2619 return const_cast<OverloadExpr*>(this)->getExplicitTemplateArgs();
2620 }
2621
getTemplateArgs()2622 TemplateArgumentLoc const *getTemplateArgs() const {
2623 return getExplicitTemplateArgs().getTemplateArgs();
2624 }
2625
getNumTemplateArgs()2626 unsigned getNumTemplateArgs() const {
2627 return getExplicitTemplateArgs().NumTemplateArgs;
2628 }
2629
2630 /// \brief Copies the template arguments into the given structure.
copyTemplateArgumentsInto(TemplateArgumentListInfo & List)2631 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
2632 getExplicitTemplateArgs().copyInto(List);
2633 }
2634
2635 /// \brief Retrieves the optional explicit template arguments.
2636 ///
2637 /// This points to the same data as getExplicitTemplateArgs(), but
2638 /// returns null if there are no explicit template arguments.
getOptionalExplicitTemplateArgs()2639 const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
2640 if (!hasExplicitTemplateArgs()) return 0;
2641 return &getExplicitTemplateArgs();
2642 }
2643
classof(const Stmt * T)2644 static bool classof(const Stmt *T) {
2645 return T->getStmtClass() == UnresolvedLookupExprClass ||
2646 T->getStmtClass() == UnresolvedMemberExprClass;
2647 }
2648
2649 friend class ASTStmtReader;
2650 friend class ASTStmtWriter;
2651 };
2652
2653 /// \brief A reference to a name which we were able to look up during
2654 /// parsing but could not resolve to a specific declaration.
2655 ///
2656 /// This arises in several ways:
2657 /// * we might be waiting for argument-dependent lookup;
2658 /// * the name might resolve to an overloaded function;
2659 /// and eventually:
2660 /// * the lookup might have included a function template.
2661 ///
2662 /// These never include UnresolvedUsingValueDecls, which are always class
2663 /// members and therefore appear only in UnresolvedMemberLookupExprs.
2664 class UnresolvedLookupExpr : public OverloadExpr {
2665 /// True if these lookup results should be extended by
2666 /// argument-dependent lookup if this is the operand of a function
2667 /// call.
2668 bool RequiresADL;
2669
2670 /// True if these lookup results are overloaded. This is pretty
2671 /// trivially rederivable if we urgently need to kill this field.
2672 bool Overloaded;
2673
2674 /// The naming class (C++ [class.access.base]p5) of the lookup, if
2675 /// any. This can generally be recalculated from the context chain,
2676 /// but that can be fairly expensive for unqualified lookups. If we
2677 /// want to improve memory use here, this could go in a union
2678 /// against the qualified-lookup bits.
2679 CXXRecordDecl *NamingClass;
2680
UnresolvedLookupExpr(ASTContext & C,CXXRecordDecl * NamingClass,NestedNameSpecifierLoc QualifierLoc,SourceLocation TemplateKWLoc,const DeclarationNameInfo & NameInfo,bool RequiresADL,bool Overloaded,const TemplateArgumentListInfo * TemplateArgs,UnresolvedSetIterator Begin,UnresolvedSetIterator End)2681 UnresolvedLookupExpr(ASTContext &C,
2682 CXXRecordDecl *NamingClass,
2683 NestedNameSpecifierLoc QualifierLoc,
2684 SourceLocation TemplateKWLoc,
2685 const DeclarationNameInfo &NameInfo,
2686 bool RequiresADL, bool Overloaded,
2687 const TemplateArgumentListInfo *TemplateArgs,
2688 UnresolvedSetIterator Begin, UnresolvedSetIterator End)
2689 : OverloadExpr(UnresolvedLookupExprClass, C, QualifierLoc, TemplateKWLoc,
2690 NameInfo, TemplateArgs, Begin, End, false, false, false),
2691 RequiresADL(RequiresADL),
2692 Overloaded(Overloaded), NamingClass(NamingClass)
2693 {}
2694
UnresolvedLookupExpr(EmptyShell Empty)2695 UnresolvedLookupExpr(EmptyShell Empty)
2696 : OverloadExpr(UnresolvedLookupExprClass, Empty),
2697 RequiresADL(false), Overloaded(false), NamingClass(0)
2698 {}
2699
2700 friend class ASTStmtReader;
2701
2702 public:
Create(ASTContext & C,CXXRecordDecl * NamingClass,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,bool ADL,bool Overloaded,UnresolvedSetIterator Begin,UnresolvedSetIterator End)2703 static UnresolvedLookupExpr *Create(ASTContext &C,
2704 CXXRecordDecl *NamingClass,
2705 NestedNameSpecifierLoc QualifierLoc,
2706 const DeclarationNameInfo &NameInfo,
2707 bool ADL, bool Overloaded,
2708 UnresolvedSetIterator Begin,
2709 UnresolvedSetIterator End) {
2710 return new(C) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
2711 SourceLocation(), NameInfo,
2712 ADL, Overloaded, 0, Begin, End);
2713 }
2714
2715 static UnresolvedLookupExpr *Create(ASTContext &C,
2716 CXXRecordDecl *NamingClass,
2717 NestedNameSpecifierLoc QualifierLoc,
2718 SourceLocation TemplateKWLoc,
2719 const DeclarationNameInfo &NameInfo,
2720 bool ADL,
2721 const TemplateArgumentListInfo *Args,
2722 UnresolvedSetIterator Begin,
2723 UnresolvedSetIterator End);
2724
2725 static UnresolvedLookupExpr *CreateEmpty(ASTContext &C,
2726 bool HasTemplateKWAndArgsInfo,
2727 unsigned NumTemplateArgs);
2728
2729 /// True if this declaration should be extended by
2730 /// argument-dependent lookup.
requiresADL()2731 bool requiresADL() const { return RequiresADL; }
2732
2733 /// True if this lookup is overloaded.
isOverloaded()2734 bool isOverloaded() const { return Overloaded; }
2735
2736 /// Gets the 'naming class' (in the sense of C++0x
2737 /// [class.access.base]p5) of the lookup. This is the scope
2738 /// that was looked in to find these results.
getNamingClass()2739 CXXRecordDecl *getNamingClass() const { return NamingClass; }
2740
getLocStart()2741 SourceLocation getLocStart() const LLVM_READONLY {
2742 if (NestedNameSpecifierLoc l = getQualifierLoc())
2743 return l.getBeginLoc();
2744 return getNameInfo().getLocStart();
2745 }
getLocEnd()2746 SourceLocation getLocEnd() const LLVM_READONLY {
2747 if (hasExplicitTemplateArgs())
2748 return getRAngleLoc();
2749 return getNameInfo().getLocEnd();
2750 }
2751
children()2752 child_range children() { return child_range(); }
2753
classof(const Stmt * T)2754 static bool classof(const Stmt *T) {
2755 return T->getStmtClass() == UnresolvedLookupExprClass;
2756 }
2757 };
2758
2759 /// \brief A qualified reference to a name whose declaration cannot
2760 /// yet be resolved.
2761 ///
2762 /// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
2763 /// it expresses a reference to a declaration such as
2764 /// X<T>::value. The difference, however, is that an
2765 /// DependentScopeDeclRefExpr node is used only within C++ templates when
2766 /// the qualification (e.g., X<T>::) refers to a dependent type. In
2767 /// this case, X<T>::value cannot resolve to a declaration because the
2768 /// declaration will differ from on instantiation of X<T> to the
2769 /// next. Therefore, DependentScopeDeclRefExpr keeps track of the
2770 /// qualifier (X<T>::) and the name of the entity being referenced
2771 /// ("value"). Such expressions will instantiate to a DeclRefExpr once the
2772 /// declaration can be found.
2773 class DependentScopeDeclRefExpr : public Expr {
2774 /// \brief The nested-name-specifier that qualifies this unresolved
2775 /// declaration name.
2776 NestedNameSpecifierLoc QualifierLoc;
2777
2778 /// \brief The name of the entity we will be referencing.
2779 DeclarationNameInfo NameInfo;
2780
2781 /// \brief Whether the name includes info for explicit template
2782 /// keyword and arguments.
2783 bool HasTemplateKWAndArgsInfo;
2784
2785 /// \brief Return the optional template keyword and arguments info.
getTemplateKWAndArgsInfo()2786 ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() {
2787 if (!HasTemplateKWAndArgsInfo) return 0;
2788 return reinterpret_cast<ASTTemplateKWAndArgsInfo*>(this + 1);
2789 }
2790 /// \brief Return the optional template keyword and arguments info.
getTemplateKWAndArgsInfo()2791 const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
2792 return const_cast<DependentScopeDeclRefExpr*>(this)
2793 ->getTemplateKWAndArgsInfo();
2794 }
2795
2796 DependentScopeDeclRefExpr(QualType T,
2797 NestedNameSpecifierLoc QualifierLoc,
2798 SourceLocation TemplateKWLoc,
2799 const DeclarationNameInfo &NameInfo,
2800 const TemplateArgumentListInfo *Args);
2801
2802 public:
2803 static DependentScopeDeclRefExpr *Create(ASTContext &C,
2804 NestedNameSpecifierLoc QualifierLoc,
2805 SourceLocation TemplateKWLoc,
2806 const DeclarationNameInfo &NameInfo,
2807 const TemplateArgumentListInfo *TemplateArgs);
2808
2809 static DependentScopeDeclRefExpr *CreateEmpty(ASTContext &C,
2810 bool HasTemplateKWAndArgsInfo,
2811 unsigned NumTemplateArgs);
2812
2813 /// \brief Retrieve the name that this expression refers to.
getNameInfo()2814 const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2815
2816 /// \brief Retrieve the name that this expression refers to.
getDeclName()2817 DeclarationName getDeclName() const { return NameInfo.getName(); }
2818
2819 /// \brief Retrieve the location of the name within the expression.
getLocation()2820 SourceLocation getLocation() const { return NameInfo.getLoc(); }
2821
2822 /// \brief Retrieve the nested-name-specifier that qualifies the
2823 /// name, with source location information.
getQualifierLoc()2824 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2825
2826
2827 /// \brief Retrieve the nested-name-specifier that qualifies this
2828 /// declaration.
getQualifier()2829 NestedNameSpecifier *getQualifier() const {
2830 return QualifierLoc.getNestedNameSpecifier();
2831 }
2832
2833 /// \brief Retrieve the location of the template keyword preceding
2834 /// this name, if any.
getTemplateKeywordLoc()2835 SourceLocation getTemplateKeywordLoc() const {
2836 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2837 return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
2838 }
2839
2840 /// \brief Retrieve the location of the left angle bracket starting the
2841 /// explicit template argument list following the name, if any.
getLAngleLoc()2842 SourceLocation getLAngleLoc() const {
2843 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2844 return getTemplateKWAndArgsInfo()->LAngleLoc;
2845 }
2846
2847 /// \brief Retrieve the location of the right angle bracket ending the
2848 /// explicit template argument list following the name, if any.
getRAngleLoc()2849 SourceLocation getRAngleLoc() const {
2850 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
2851 return getTemplateKWAndArgsInfo()->RAngleLoc;
2852 }
2853
2854 /// Determines whether the name was preceded by the template keyword.
hasTemplateKeyword()2855 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
2856
2857 /// Determines whether this lookup had explicit template arguments.
hasExplicitTemplateArgs()2858 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
2859
2860 // Note that, inconsistently with the explicit-template-argument AST
2861 // nodes, users are *forbidden* from calling these methods on objects
2862 // without explicit template arguments.
2863
getExplicitTemplateArgs()2864 ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
2865 assert(hasExplicitTemplateArgs());
2866 return *reinterpret_cast<ASTTemplateArgumentListInfo*>(this + 1);
2867 }
2868
2869 /// Gets a reference to the explicit template argument list.
getExplicitTemplateArgs()2870 const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
2871 assert(hasExplicitTemplateArgs());
2872 return *reinterpret_cast<const ASTTemplateArgumentListInfo*>(this + 1);
2873 }
2874
2875 /// \brief Retrieves the optional explicit template arguments.
2876 ///
2877 /// This points to the same data as getExplicitTemplateArgs(), but
2878 /// returns null if there are no explicit template arguments.
getOptionalExplicitTemplateArgs()2879 const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
2880 if (!hasExplicitTemplateArgs()) return 0;
2881 return &getExplicitTemplateArgs();
2882 }
2883
2884 /// \brief Copies the template arguments (if present) into the given
2885 /// structure.
copyTemplateArgumentsInto(TemplateArgumentListInfo & List)2886 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
2887 getExplicitTemplateArgs().copyInto(List);
2888 }
2889
getTemplateArgs()2890 TemplateArgumentLoc const *getTemplateArgs() const {
2891 return getExplicitTemplateArgs().getTemplateArgs();
2892 }
2893
getNumTemplateArgs()2894 unsigned getNumTemplateArgs() const {
2895 return getExplicitTemplateArgs().NumTemplateArgs;
2896 }
2897
getLocStart()2898 SourceLocation getLocStart() const LLVM_READONLY {
2899 return QualifierLoc.getBeginLoc();
2900 }
getLocEnd()2901 SourceLocation getLocEnd() const LLVM_READONLY {
2902 if (hasExplicitTemplateArgs())
2903 return getRAngleLoc();
2904 return getLocation();
2905 }
2906
classof(const Stmt * T)2907 static bool classof(const Stmt *T) {
2908 return T->getStmtClass() == DependentScopeDeclRefExprClass;
2909 }
2910
children()2911 child_range children() { return child_range(); }
2912
2913 friend class ASTStmtReader;
2914 friend class ASTStmtWriter;
2915 };
2916
2917 /// Represents an expression -- generally a full-expression -- that
2918 /// introduces cleanups to be run at the end of the sub-expression's
2919 /// evaluation. The most common source of expression-introduced
2920 /// cleanups is temporary objects in C++, but several other kinds of
2921 /// expressions can create cleanups, including basically every
2922 /// call in ARC that returns an Objective-C pointer.
2923 ///
2924 /// This expression also tracks whether the sub-expression contains a
2925 /// potentially-evaluated block literal. The lifetime of a block
2926 /// literal is the extent of the enclosing scope.
2927 class ExprWithCleanups : public Expr {
2928 public:
2929 /// The type of objects that are kept in the cleanup.
2930 /// It's useful to remember the set of blocks; we could also
2931 /// remember the set of temporaries, but there's currently
2932 /// no need.
2933 typedef BlockDecl *CleanupObject;
2934
2935 private:
2936 Stmt *SubExpr;
2937
2938 ExprWithCleanups(EmptyShell, unsigned NumObjects);
2939 ExprWithCleanups(Expr *SubExpr, ArrayRef<CleanupObject> Objects);
2940
getObjectsBuffer()2941 CleanupObject *getObjectsBuffer() {
2942 return reinterpret_cast<CleanupObject*>(this + 1);
2943 }
getObjectsBuffer()2944 const CleanupObject *getObjectsBuffer() const {
2945 return reinterpret_cast<const CleanupObject*>(this + 1);
2946 }
2947 friend class ASTStmtReader;
2948
2949 public:
2950 static ExprWithCleanups *Create(ASTContext &C, EmptyShell empty,
2951 unsigned numObjects);
2952
2953 static ExprWithCleanups *Create(ASTContext &C, Expr *subexpr,
2954 ArrayRef<CleanupObject> objects);
2955
getObjects()2956 ArrayRef<CleanupObject> getObjects() const {
2957 return ArrayRef<CleanupObject>(getObjectsBuffer(), getNumObjects());
2958 }
2959
getNumObjects()2960 unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
2961
getObject(unsigned i)2962 CleanupObject getObject(unsigned i) const {
2963 assert(i < getNumObjects() && "Index out of range");
2964 return getObjects()[i];
2965 }
2966
getSubExpr()2967 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
getSubExpr()2968 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
2969
2970 /// As with any mutator of the AST, be very careful
2971 /// when modifying an existing AST to preserve its invariants.
setSubExpr(Expr * E)2972 void setSubExpr(Expr *E) { SubExpr = E; }
2973
getLocStart()2974 SourceLocation getLocStart() const LLVM_READONLY {
2975 return SubExpr->getLocStart();
2976 }
getLocEnd()2977 SourceLocation getLocEnd() const LLVM_READONLY { return SubExpr->getLocEnd();}
2978
2979 // Implement isa/cast/dyncast/etc.
classof(const Stmt * T)2980 static bool classof(const Stmt *T) {
2981 return T->getStmtClass() == ExprWithCleanupsClass;
2982 }
2983
2984 // Iterators
children()2985 child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
2986 };
2987
2988 /// \brief Describes an explicit type conversion that uses functional
2989 /// notion but could not be resolved because one or more arguments are
2990 /// type-dependent.
2991 ///
2992 /// The explicit type conversions expressed by
2993 /// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
2994 /// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
2995 /// either \c T is a dependent type or one or more of the <tt>a</tt>'s is
2996 /// type-dependent. For example, this would occur in a template such
2997 /// as:
2998 ///
2999 /// \code
3000 /// template<typename T, typename A1>
3001 /// inline T make_a(const A1& a1) {
3002 /// return T(a1);
3003 /// }
3004 /// \endcode
3005 ///
3006 /// When the returned expression is instantiated, it may resolve to a
3007 /// constructor call, conversion function call, or some kind of type
3008 /// conversion.
3009 class CXXUnresolvedConstructExpr : public Expr {
3010 /// \brief The type being constructed.
3011 TypeSourceInfo *Type;
3012
3013 /// \brief The location of the left parentheses ('(').
3014 SourceLocation LParenLoc;
3015
3016 /// \brief The location of the right parentheses (')').
3017 SourceLocation RParenLoc;
3018
3019 /// \brief The number of arguments used to construct the type.
3020 unsigned NumArgs;
3021
3022 CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
3023 SourceLocation LParenLoc,
3024 ArrayRef<Expr*> Args,
3025 SourceLocation RParenLoc);
3026
CXXUnresolvedConstructExpr(EmptyShell Empty,unsigned NumArgs)3027 CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
3028 : Expr(CXXUnresolvedConstructExprClass, Empty), Type(), NumArgs(NumArgs) { }
3029
3030 friend class ASTStmtReader;
3031
3032 public:
3033 static CXXUnresolvedConstructExpr *Create(ASTContext &C,
3034 TypeSourceInfo *Type,
3035 SourceLocation LParenLoc,
3036 ArrayRef<Expr*> Args,
3037 SourceLocation RParenLoc);
3038
3039 static CXXUnresolvedConstructExpr *CreateEmpty(ASTContext &C,
3040 unsigned NumArgs);
3041
3042 /// \brief Retrieve the type that is being constructed, as specified
3043 /// in the source code.
getTypeAsWritten()3044 QualType getTypeAsWritten() const { return Type->getType(); }
3045
3046 /// \brief Retrieve the type source information for the type being
3047 /// constructed.
getTypeSourceInfo()3048 TypeSourceInfo *getTypeSourceInfo() const { return Type; }
3049
3050 /// \brief Retrieve the location of the left parentheses ('(') that
3051 /// precedes the argument list.
getLParenLoc()3052 SourceLocation getLParenLoc() const { return LParenLoc; }
setLParenLoc(SourceLocation L)3053 void setLParenLoc(SourceLocation L) { LParenLoc = L; }
3054
3055 /// \brief Retrieve the location of the right parentheses (')') that
3056 /// follows the argument list.
getRParenLoc()3057 SourceLocation getRParenLoc() const { return RParenLoc; }
setRParenLoc(SourceLocation L)3058 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3059
3060 /// \brief Retrieve the number of arguments.
arg_size()3061 unsigned arg_size() const { return NumArgs; }
3062
3063 typedef Expr** arg_iterator;
arg_begin()3064 arg_iterator arg_begin() { return reinterpret_cast<Expr**>(this + 1); }
arg_end()3065 arg_iterator arg_end() { return arg_begin() + NumArgs; }
3066
3067 typedef const Expr* const * const_arg_iterator;
arg_begin()3068 const_arg_iterator arg_begin() const {
3069 return reinterpret_cast<const Expr* const *>(this + 1);
3070 }
arg_end()3071 const_arg_iterator arg_end() const {
3072 return arg_begin() + NumArgs;
3073 }
3074
getArg(unsigned I)3075 Expr *getArg(unsigned I) {
3076 assert(I < NumArgs && "Argument index out-of-range");
3077 return *(arg_begin() + I);
3078 }
3079
getArg(unsigned I)3080 const Expr *getArg(unsigned I) const {
3081 assert(I < NumArgs && "Argument index out-of-range");
3082 return *(arg_begin() + I);
3083 }
3084
setArg(unsigned I,Expr * E)3085 void setArg(unsigned I, Expr *E) {
3086 assert(I < NumArgs && "Argument index out-of-range");
3087 *(arg_begin() + I) = E;
3088 }
3089
3090 SourceLocation getLocStart() const LLVM_READONLY;
getLocEnd()3091 SourceLocation getLocEnd() const LLVM_READONLY {
3092 assert(RParenLoc.isValid() || NumArgs == 1);
3093 return RParenLoc.isValid() ? RParenLoc : getArg(0)->getLocEnd();
3094 }
3095
classof(const Stmt * T)3096 static bool classof(const Stmt *T) {
3097 return T->getStmtClass() == CXXUnresolvedConstructExprClass;
3098 }
3099
3100 // Iterators
children()3101 child_range children() {
3102 Stmt **begin = reinterpret_cast<Stmt**>(this+1);
3103 return child_range(begin, begin + NumArgs);
3104 }
3105 };
3106
3107 /// \brief Represents a C++ member access expression where the actual
3108 /// member referenced could not be resolved because the base
3109 /// expression or the member name was dependent.
3110 ///
3111 /// Like UnresolvedMemberExprs, these can be either implicit or
3112 /// explicit accesses. It is only possible to get one of these with
3113 /// an implicit access if a qualifier is provided.
3114 class CXXDependentScopeMemberExpr : public Expr {
3115 /// \brief The expression for the base pointer or class reference,
3116 /// e.g., the \c x in x.f. Can be null in implicit accesses.
3117 Stmt *Base;
3118
3119 /// \brief The type of the base expression. Never null, even for
3120 /// implicit accesses.
3121 QualType BaseType;
3122
3123 /// \brief Whether this member expression used the '->' operator or
3124 /// the '.' operator.
3125 bool IsArrow : 1;
3126
3127 /// \brief Whether this member expression has info for explicit template
3128 /// keyword and arguments.
3129 bool HasTemplateKWAndArgsInfo : 1;
3130
3131 /// \brief The location of the '->' or '.' operator.
3132 SourceLocation OperatorLoc;
3133
3134 /// \brief The nested-name-specifier that precedes the member name, if any.
3135 NestedNameSpecifierLoc QualifierLoc;
3136
3137 /// \brief In a qualified member access expression such as t->Base::f, this
3138 /// member stores the resolves of name lookup in the context of the member
3139 /// access expression, to be used at instantiation time.
3140 ///
3141 /// FIXME: This member, along with the QualifierLoc, could
3142 /// be stuck into a structure that is optionally allocated at the end of
3143 /// the CXXDependentScopeMemberExpr, to save space in the common case.
3144 NamedDecl *FirstQualifierFoundInScope;
3145
3146 /// \brief The member to which this member expression refers, which
3147 /// can be name, overloaded operator, or destructor.
3148 ///
3149 /// FIXME: could also be a template-id
3150 DeclarationNameInfo MemberNameInfo;
3151
3152 /// \brief Return the optional template keyword and arguments info.
getTemplateKWAndArgsInfo()3153 ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() {
3154 if (!HasTemplateKWAndArgsInfo) return 0;
3155 return reinterpret_cast<ASTTemplateKWAndArgsInfo*>(this + 1);
3156 }
3157 /// \brief Return the optional template keyword and arguments info.
getTemplateKWAndArgsInfo()3158 const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
3159 return const_cast<CXXDependentScopeMemberExpr*>(this)
3160 ->getTemplateKWAndArgsInfo();
3161 }
3162
3163 CXXDependentScopeMemberExpr(ASTContext &C,
3164 Expr *Base, QualType BaseType, bool IsArrow,
3165 SourceLocation OperatorLoc,
3166 NestedNameSpecifierLoc QualifierLoc,
3167 SourceLocation TemplateKWLoc,
3168 NamedDecl *FirstQualifierFoundInScope,
3169 DeclarationNameInfo MemberNameInfo,
3170 const TemplateArgumentListInfo *TemplateArgs);
3171
3172 public:
3173 CXXDependentScopeMemberExpr(ASTContext &C,
3174 Expr *Base, QualType BaseType,
3175 bool IsArrow,
3176 SourceLocation OperatorLoc,
3177 NestedNameSpecifierLoc QualifierLoc,
3178 NamedDecl *FirstQualifierFoundInScope,
3179 DeclarationNameInfo MemberNameInfo);
3180
3181 static CXXDependentScopeMemberExpr *
3182 Create(ASTContext &C,
3183 Expr *Base, QualType BaseType, bool IsArrow,
3184 SourceLocation OperatorLoc,
3185 NestedNameSpecifierLoc QualifierLoc,
3186 SourceLocation TemplateKWLoc,
3187 NamedDecl *FirstQualifierFoundInScope,
3188 DeclarationNameInfo MemberNameInfo,
3189 const TemplateArgumentListInfo *TemplateArgs);
3190
3191 static CXXDependentScopeMemberExpr *
3192 CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo,
3193 unsigned NumTemplateArgs);
3194
3195 /// \brief True if this is an implicit access, i.e. one in which the
3196 /// member being accessed was not written in the source. The source
3197 /// location of the operator is invalid in this case.
3198 bool isImplicitAccess() const;
3199
3200 /// \brief Retrieve the base object of this member expressions,
3201 /// e.g., the \c x in \c x.m.
getBase()3202 Expr *getBase() const {
3203 assert(!isImplicitAccess());
3204 return cast<Expr>(Base);
3205 }
3206
getBaseType()3207 QualType getBaseType() const { return BaseType; }
3208
3209 /// \brief Determine whether this member expression used the '->'
3210 /// operator; otherwise, it used the '.' operator.
isArrow()3211 bool isArrow() const { return IsArrow; }
3212
3213 /// \brief Retrieve the location of the '->' or '.' operator.
getOperatorLoc()3214 SourceLocation getOperatorLoc() const { return OperatorLoc; }
3215
3216 /// \brief Retrieve the nested-name-specifier that qualifies the member
3217 /// name.
getQualifier()3218 NestedNameSpecifier *getQualifier() const {
3219 return QualifierLoc.getNestedNameSpecifier();
3220 }
3221
3222 /// \brief Retrieve the nested-name-specifier that qualifies the member
3223 /// name, with source location information.
getQualifierLoc()3224 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3225
3226
3227 /// \brief Retrieve the first part of the nested-name-specifier that was
3228 /// found in the scope of the member access expression when the member access
3229 /// was initially parsed.
3230 ///
3231 /// This function only returns a useful result when member access expression
3232 /// uses a qualified member name, e.g., "x.Base::f". Here, the declaration
3233 /// returned by this function describes what was found by unqualified name
3234 /// lookup for the identifier "Base" within the scope of the member access
3235 /// expression itself. At template instantiation time, this information is
3236 /// combined with the results of name lookup into the type of the object
3237 /// expression itself (the class type of x).
getFirstQualifierFoundInScope()3238 NamedDecl *getFirstQualifierFoundInScope() const {
3239 return FirstQualifierFoundInScope;
3240 }
3241
3242 /// \brief Retrieve the name of the member that this expression
3243 /// refers to.
getMemberNameInfo()3244 const DeclarationNameInfo &getMemberNameInfo() const {
3245 return MemberNameInfo;
3246 }
3247
3248 /// \brief Retrieve the name of the member that this expression
3249 /// refers to.
getMember()3250 DeclarationName getMember() const { return MemberNameInfo.getName(); }
3251
3252 // \brief Retrieve the location of the name of the member that this
3253 // expression refers to.
getMemberLoc()3254 SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); }
3255
3256 /// \brief Retrieve the location of the template keyword preceding the
3257 /// member name, if any.
getTemplateKeywordLoc()3258 SourceLocation getTemplateKeywordLoc() const {
3259 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
3260 return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
3261 }
3262
3263 /// \brief Retrieve the location of the left angle bracket starting the
3264 /// explicit template argument list following the member name, if any.
getLAngleLoc()3265 SourceLocation getLAngleLoc() const {
3266 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
3267 return getTemplateKWAndArgsInfo()->LAngleLoc;
3268 }
3269
3270 /// \brief Retrieve the location of the right angle bracket ending the
3271 /// explicit template argument list following the member name, if any.
getRAngleLoc()3272 SourceLocation getRAngleLoc() const {
3273 if (!HasTemplateKWAndArgsInfo) return SourceLocation();
3274 return getTemplateKWAndArgsInfo()->RAngleLoc;
3275 }
3276
3277 /// Determines whether the member name was preceded by the template keyword.
hasTemplateKeyword()3278 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
3279
3280 /// \brief Determines whether this member expression actually had a C++
3281 /// template argument list explicitly specified, e.g., x.f<int>.
hasExplicitTemplateArgs()3282 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3283
3284 /// \brief Retrieve the explicit template argument list that followed the
3285 /// member template name, if any.
getExplicitTemplateArgs()3286 ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
3287 assert(hasExplicitTemplateArgs());
3288 return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
3289 }
3290
3291 /// \brief Retrieve the explicit template argument list that followed the
3292 /// member template name, if any.
getExplicitTemplateArgs()3293 const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
3294 return const_cast<CXXDependentScopeMemberExpr *>(this)
3295 ->getExplicitTemplateArgs();
3296 }
3297
3298 /// \brief Retrieves the optional explicit template arguments.
3299 ///
3300 /// This points to the same data as getExplicitTemplateArgs(), but
3301 /// returns null if there are no explicit template arguments.
getOptionalExplicitTemplateArgs()3302 const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
3303 if (!hasExplicitTemplateArgs()) return 0;
3304 return &getExplicitTemplateArgs();
3305 }
3306
3307 /// \brief Copies the template arguments (if present) into the given
3308 /// structure.
copyTemplateArgumentsInto(TemplateArgumentListInfo & List)3309 void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
3310 getExplicitTemplateArgs().copyInto(List);
3311 }
3312
3313 /// \brief Initializes the template arguments using the given structure.
initializeTemplateArgumentsFrom(const TemplateArgumentListInfo & List)3314 void initializeTemplateArgumentsFrom(const TemplateArgumentListInfo &List) {
3315 getExplicitTemplateArgs().initializeFrom(List);
3316 }
3317
3318 /// \brief Retrieve the template arguments provided as part of this
3319 /// template-id.
getTemplateArgs()3320 const TemplateArgumentLoc *getTemplateArgs() const {
3321 return getExplicitTemplateArgs().getTemplateArgs();
3322 }
3323
3324 /// \brief Retrieve the number of template arguments provided as part of this
3325 /// template-id.
getNumTemplateArgs()3326 unsigned getNumTemplateArgs() const {
3327 return getExplicitTemplateArgs().NumTemplateArgs;
3328 }
3329
getLocStart()3330 SourceLocation getLocStart() const LLVM_READONLY {
3331 if (!isImplicitAccess())
3332 return Base->getLocStart();
3333 if (getQualifier())
3334 return getQualifierLoc().getBeginLoc();
3335 return MemberNameInfo.getBeginLoc();
3336
3337 }
getLocEnd()3338 SourceLocation getLocEnd() const LLVM_READONLY {
3339 if (hasExplicitTemplateArgs())
3340 return getRAngleLoc();
3341 return MemberNameInfo.getEndLoc();
3342 }
3343
classof(const Stmt * T)3344 static bool classof(const Stmt *T) {
3345 return T->getStmtClass() == CXXDependentScopeMemberExprClass;
3346 }
3347
3348 // Iterators
children()3349 child_range children() {
3350 if (isImplicitAccess()) return child_range();
3351 return child_range(&Base, &Base + 1);
3352 }
3353
3354 friend class ASTStmtReader;
3355 friend class ASTStmtWriter;
3356 };
3357
3358 /// \brief Represents a C++ member access expression for which lookup
3359 /// produced a set of overloaded functions.
3360 ///
3361 /// The member access may be explicit or implicit:
3362 /// \code
3363 /// struct A {
3364 /// int a, b;
3365 /// int explicitAccess() { return this->a + this->A::b; }
3366 /// int implicitAccess() { return a + A::b; }
3367 /// };
3368 /// \endcode
3369 ///
3370 /// In the final AST, an explicit access always becomes a MemberExpr.
3371 /// An implicit access may become either a MemberExpr or a
3372 /// DeclRefExpr, depending on whether the member is static.
3373 class UnresolvedMemberExpr : public OverloadExpr {
3374 /// \brief Whether this member expression used the '->' operator or
3375 /// the '.' operator.
3376 bool IsArrow : 1;
3377
3378 /// \brief Whether the lookup results contain an unresolved using
3379 /// declaration.
3380 bool HasUnresolvedUsing : 1;
3381
3382 /// \brief The expression for the base pointer or class reference,
3383 /// e.g., the \c x in x.f.
3384 ///
3385 /// This can be null if this is an 'unbased' member expression.
3386 Stmt *Base;
3387
3388 /// \brief The type of the base expression; never null.
3389 QualType BaseType;
3390
3391 /// \brief The location of the '->' or '.' operator.
3392 SourceLocation OperatorLoc;
3393
3394 UnresolvedMemberExpr(ASTContext &C, bool HasUnresolvedUsing,
3395 Expr *Base, QualType BaseType, bool IsArrow,
3396 SourceLocation OperatorLoc,
3397 NestedNameSpecifierLoc QualifierLoc,
3398 SourceLocation TemplateKWLoc,
3399 const DeclarationNameInfo &MemberNameInfo,
3400 const TemplateArgumentListInfo *TemplateArgs,
3401 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3402
UnresolvedMemberExpr(EmptyShell Empty)3403 UnresolvedMemberExpr(EmptyShell Empty)
3404 : OverloadExpr(UnresolvedMemberExprClass, Empty), IsArrow(false),
3405 HasUnresolvedUsing(false), Base(0) { }
3406
3407 friend class ASTStmtReader;
3408
3409 public:
3410 static UnresolvedMemberExpr *
3411 Create(ASTContext &C, bool HasUnresolvedUsing,
3412 Expr *Base, QualType BaseType, bool IsArrow,
3413 SourceLocation OperatorLoc,
3414 NestedNameSpecifierLoc QualifierLoc,
3415 SourceLocation TemplateKWLoc,
3416 const DeclarationNameInfo &MemberNameInfo,
3417 const TemplateArgumentListInfo *TemplateArgs,
3418 UnresolvedSetIterator Begin, UnresolvedSetIterator End);
3419
3420 static UnresolvedMemberExpr *
3421 CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo,
3422 unsigned NumTemplateArgs);
3423
3424 /// \brief True if this is an implicit access, i.e., one in which the
3425 /// member being accessed was not written in the source.
3426 ///
3427 /// The source location of the operator is invalid in this case.
3428 bool isImplicitAccess() const;
3429
3430 /// \brief Retrieve the base object of this member expressions,
3431 /// e.g., the \c x in \c x.m.
getBase()3432 Expr *getBase() {
3433 assert(!isImplicitAccess());
3434 return cast<Expr>(Base);
3435 }
getBase()3436 const Expr *getBase() const {
3437 assert(!isImplicitAccess());
3438 return cast<Expr>(Base);
3439 }
3440
getBaseType()3441 QualType getBaseType() const { return BaseType; }
3442
3443 /// \brief Determine whether the lookup results contain an unresolved using
3444 /// declaration.
hasUnresolvedUsing()3445 bool hasUnresolvedUsing() const { return HasUnresolvedUsing; }
3446
3447 /// \brief Determine whether this member expression used the '->'
3448 /// operator; otherwise, it used the '.' operator.
isArrow()3449 bool isArrow() const { return IsArrow; }
3450
3451 /// \brief Retrieve the location of the '->' or '.' operator.
getOperatorLoc()3452 SourceLocation getOperatorLoc() const { return OperatorLoc; }
3453
3454 /// \brief Retrieve the naming class of this lookup.
3455 CXXRecordDecl *getNamingClass() const;
3456
3457 /// \brief Retrieve the full name info for the member that this expression
3458 /// refers to.
getMemberNameInfo()3459 const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); }
3460
3461 /// \brief Retrieve the name of the member that this expression
3462 /// refers to.
getMemberName()3463 DeclarationName getMemberName() const { return getName(); }
3464
3465 // \brief Retrieve the location of the name of the member that this
3466 // expression refers to.
getMemberLoc()3467 SourceLocation getMemberLoc() const { return getNameLoc(); }
3468
3469 // \brief Return the preferred location (the member name) for the arrow when
3470 // diagnosing a problem with this expression.
getExprLoc()3471 SourceLocation getExprLoc() const LLVM_READONLY { return getMemberLoc(); }
3472
getLocStart()3473 SourceLocation getLocStart() const LLVM_READONLY {
3474 if (!isImplicitAccess())
3475 return Base->getLocStart();
3476 if (NestedNameSpecifierLoc l = getQualifierLoc())
3477 return l.getBeginLoc();
3478 return getMemberNameInfo().getLocStart();
3479 }
getLocEnd()3480 SourceLocation getLocEnd() const LLVM_READONLY {
3481 if (hasExplicitTemplateArgs())
3482 return getRAngleLoc();
3483 return getMemberNameInfo().getLocEnd();
3484 }
3485
classof(const Stmt * T)3486 static bool classof(const Stmt *T) {
3487 return T->getStmtClass() == UnresolvedMemberExprClass;
3488 }
3489
3490 // Iterators
children()3491 child_range children() {
3492 if (isImplicitAccess()) return child_range();
3493 return child_range(&Base, &Base + 1);
3494 }
3495 };
3496
3497 /// \brief Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
3498 ///
3499 /// The noexcept expression tests whether a given expression might throw. Its
3500 /// result is a boolean constant.
3501 class CXXNoexceptExpr : public Expr {
3502 bool Value : 1;
3503 Stmt *Operand;
3504 SourceRange Range;
3505
3506 friend class ASTStmtReader;
3507
3508 public:
CXXNoexceptExpr(QualType Ty,Expr * Operand,CanThrowResult Val,SourceLocation Keyword,SourceLocation RParen)3509 CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
3510 SourceLocation Keyword, SourceLocation RParen)
3511 : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary,
3512 /*TypeDependent*/false,
3513 /*ValueDependent*/Val == CT_Dependent,
3514 Val == CT_Dependent || Operand->isInstantiationDependent(),
3515 Operand->containsUnexpandedParameterPack()),
3516 Value(Val == CT_Cannot), Operand(Operand), Range(Keyword, RParen)
3517 { }
3518
CXXNoexceptExpr(EmptyShell Empty)3519 CXXNoexceptExpr(EmptyShell Empty)
3520 : Expr(CXXNoexceptExprClass, Empty)
3521 { }
3522
getOperand()3523 Expr *getOperand() const { return static_cast<Expr*>(Operand); }
3524
getLocStart()3525 SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
getLocEnd()3526 SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
getSourceRange()3527 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
3528
getValue()3529 bool getValue() const { return Value; }
3530
classof(const Stmt * T)3531 static bool classof(const Stmt *T) {
3532 return T->getStmtClass() == CXXNoexceptExprClass;
3533 }
3534
3535 // Iterators
children()3536 child_range children() { return child_range(&Operand, &Operand + 1); }
3537 };
3538
3539 /// \brief Represents a C++11 pack expansion that produces a sequence of
3540 /// expressions.
3541 ///
3542 /// A pack expansion expression contains a pattern (which itself is an
3543 /// expression) followed by an ellipsis. For example:
3544 ///
3545 /// \code
3546 /// template<typename F, typename ...Types>
3547 /// void forward(F f, Types &&...args) {
3548 /// f(static_cast<Types&&>(args)...);
3549 /// }
3550 /// \endcode
3551 ///
3552 /// Here, the argument to the function object \c f is a pack expansion whose
3553 /// pattern is \c static_cast<Types&&>(args). When the \c forward function
3554 /// template is instantiated, the pack expansion will instantiate to zero or
3555 /// or more function arguments to the function object \c f.
3556 class PackExpansionExpr : public Expr {
3557 SourceLocation EllipsisLoc;
3558
3559 /// \brief The number of expansions that will be produced by this pack
3560 /// expansion expression, if known.
3561 ///
3562 /// When zero, the number of expansions is not known. Otherwise, this value
3563 /// is the number of expansions + 1.
3564 unsigned NumExpansions;
3565
3566 Stmt *Pattern;
3567
3568 friend class ASTStmtReader;
3569 friend class ASTStmtWriter;
3570
3571 public:
PackExpansionExpr(QualType T,Expr * Pattern,SourceLocation EllipsisLoc,Optional<unsigned> NumExpansions)3572 PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc,
3573 Optional<unsigned> NumExpansions)
3574 : Expr(PackExpansionExprClass, T, Pattern->getValueKind(),
3575 Pattern->getObjectKind(), /*TypeDependent=*/true,
3576 /*ValueDependent=*/true, /*InstantiationDependent=*/true,
3577 /*ContainsUnexpandedParameterPack=*/false),
3578 EllipsisLoc(EllipsisLoc),
3579 NumExpansions(NumExpansions? *NumExpansions + 1 : 0),
3580 Pattern(Pattern) { }
3581
PackExpansionExpr(EmptyShell Empty)3582 PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) { }
3583
3584 /// \brief Retrieve the pattern of the pack expansion.
getPattern()3585 Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }
3586
3587 /// \brief Retrieve the pattern of the pack expansion.
getPattern()3588 const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }
3589
3590 /// \brief Retrieve the location of the ellipsis that describes this pack
3591 /// expansion.
getEllipsisLoc()3592 SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
3593
3594 /// \brief Determine the number of expansions that will be produced when
3595 /// this pack expansion is instantiated, if already known.
getNumExpansions()3596 Optional<unsigned> getNumExpansions() const {
3597 if (NumExpansions)
3598 return NumExpansions - 1;
3599
3600 return None;
3601 }
3602
getLocStart()3603 SourceLocation getLocStart() const LLVM_READONLY {
3604 return Pattern->getLocStart();
3605 }
getLocEnd()3606 SourceLocation getLocEnd() const LLVM_READONLY { return EllipsisLoc; }
3607
classof(const Stmt * T)3608 static bool classof(const Stmt *T) {
3609 return T->getStmtClass() == PackExpansionExprClass;
3610 }
3611
3612 // Iterators
children()3613 child_range children() {
3614 return child_range(&Pattern, &Pattern + 1);
3615 }
3616 };
3617
getTemplateKWAndArgsInfo()3618 inline ASTTemplateKWAndArgsInfo *OverloadExpr::getTemplateKWAndArgsInfo() {
3619 if (!HasTemplateKWAndArgsInfo) return 0;
3620 if (isa<UnresolvedLookupExpr>(this))
3621 return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
3622 (cast<UnresolvedLookupExpr>(this) + 1);
3623 else
3624 return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
3625 (cast<UnresolvedMemberExpr>(this) + 1);
3626 }
3627
3628 /// \brief Represents an expression that computes the length of a parameter
3629 /// pack.
3630 ///
3631 /// \code
3632 /// template<typename ...Types>
3633 /// struct count {
3634 /// static const unsigned value = sizeof...(Types);
3635 /// };
3636 /// \endcode
3637 class SizeOfPackExpr : public Expr {
3638 /// \brief The location of the \c sizeof keyword.
3639 SourceLocation OperatorLoc;
3640
3641 /// \brief The location of the name of the parameter pack.
3642 SourceLocation PackLoc;
3643
3644 /// \brief The location of the closing parenthesis.
3645 SourceLocation RParenLoc;
3646
3647 /// \brief The length of the parameter pack, if known.
3648 ///
3649 /// When this expression is value-dependent, the length of the parameter pack
3650 /// is unknown. When this expression is not value-dependent, the length is
3651 /// known.
3652 unsigned Length;
3653
3654 /// \brief The parameter pack itself.
3655 NamedDecl *Pack;
3656
3657 friend class ASTStmtReader;
3658 friend class ASTStmtWriter;
3659
3660 public:
3661 /// \brief Create a value-dependent expression that computes the length of
3662 /// the given parameter pack.
SizeOfPackExpr(QualType SizeType,SourceLocation OperatorLoc,NamedDecl * Pack,SourceLocation PackLoc,SourceLocation RParenLoc)3663 SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
3664 SourceLocation PackLoc, SourceLocation RParenLoc)
3665 : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary,
3666 /*TypeDependent=*/false, /*ValueDependent=*/true,
3667 /*InstantiationDependent=*/true,
3668 /*ContainsUnexpandedParameterPack=*/false),
3669 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
3670 Length(0), Pack(Pack) { }
3671
3672 /// \brief Create an expression that computes the length of
3673 /// the given parameter pack, which is already known.
SizeOfPackExpr(QualType SizeType,SourceLocation OperatorLoc,NamedDecl * Pack,SourceLocation PackLoc,SourceLocation RParenLoc,unsigned Length)3674 SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
3675 SourceLocation PackLoc, SourceLocation RParenLoc,
3676 unsigned Length)
3677 : Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary,
3678 /*TypeDependent=*/false, /*ValueDependent=*/false,
3679 /*InstantiationDependent=*/false,
3680 /*ContainsUnexpandedParameterPack=*/false),
3681 OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
3682 Length(Length), Pack(Pack) { }
3683
3684 /// \brief Create an empty expression.
SizeOfPackExpr(EmptyShell Empty)3685 SizeOfPackExpr(EmptyShell Empty) : Expr(SizeOfPackExprClass, Empty) { }
3686
3687 /// \brief Determine the location of the 'sizeof' keyword.
getOperatorLoc()3688 SourceLocation getOperatorLoc() const { return OperatorLoc; }
3689
3690 /// \brief Determine the location of the parameter pack.
getPackLoc()3691 SourceLocation getPackLoc() const { return PackLoc; }
3692
3693 /// \brief Determine the location of the right parenthesis.
getRParenLoc()3694 SourceLocation getRParenLoc() const { return RParenLoc; }
3695
3696 /// \brief Retrieve the parameter pack.
getPack()3697 NamedDecl *getPack() const { return Pack; }
3698
3699 /// \brief Retrieve the length of the parameter pack.
3700 ///
3701 /// This routine may only be invoked when the expression is not
3702 /// value-dependent.
getPackLength()3703 unsigned getPackLength() const {
3704 assert(!isValueDependent() &&
3705 "Cannot get the length of a value-dependent pack size expression");
3706 return Length;
3707 }
3708
getLocStart()3709 SourceLocation getLocStart() const LLVM_READONLY { return OperatorLoc; }
getLocEnd()3710 SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
3711
classof(const Stmt * T)3712 static bool classof(const Stmt *T) {
3713 return T->getStmtClass() == SizeOfPackExprClass;
3714 }
3715
3716 // Iterators
children()3717 child_range children() { return child_range(); }
3718 };
3719
3720 /// \brief Represents a reference to a non-type template parameter
3721 /// that has been substituted with a template argument.
3722 class SubstNonTypeTemplateParmExpr : public Expr {
3723 /// \brief The replaced parameter.
3724 NonTypeTemplateParmDecl *Param;
3725
3726 /// \brief The replacement expression.
3727 Stmt *Replacement;
3728
3729 /// \brief The location of the non-type template parameter reference.
3730 SourceLocation NameLoc;
3731
3732 friend class ASTReader;
3733 friend class ASTStmtReader;
SubstNonTypeTemplateParmExpr(EmptyShell Empty)3734 explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
3735 : Expr(SubstNonTypeTemplateParmExprClass, Empty) { }
3736
3737 public:
SubstNonTypeTemplateParmExpr(QualType type,ExprValueKind valueKind,SourceLocation loc,NonTypeTemplateParmDecl * param,Expr * replacement)3738 SubstNonTypeTemplateParmExpr(QualType type,
3739 ExprValueKind valueKind,
3740 SourceLocation loc,
3741 NonTypeTemplateParmDecl *param,
3742 Expr *replacement)
3743 : Expr(SubstNonTypeTemplateParmExprClass, type, valueKind, OK_Ordinary,
3744 replacement->isTypeDependent(), replacement->isValueDependent(),
3745 replacement->isInstantiationDependent(),
3746 replacement->containsUnexpandedParameterPack()),
3747 Param(param), Replacement(replacement), NameLoc(loc) {}
3748
getNameLoc()3749 SourceLocation getNameLoc() const { return NameLoc; }
getLocStart()3750 SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
getLocEnd()3751 SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
3752
getReplacement()3753 Expr *getReplacement() const { return cast<Expr>(Replacement); }
3754
getParameter()3755 NonTypeTemplateParmDecl *getParameter() const { return Param; }
3756
classof(const Stmt * s)3757 static bool classof(const Stmt *s) {
3758 return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
3759 }
3760
3761 // Iterators
children()3762 child_range children() { return child_range(&Replacement, &Replacement+1); }
3763 };
3764
3765 /// \brief Represents a reference to a non-type template parameter pack that
3766 /// has been substituted with a non-template argument pack.
3767 ///
3768 /// When a pack expansion in the source code contains multiple parameter packs
3769 /// and those parameter packs correspond to different levels of template
3770 /// parameter lists, this node is used to represent a non-type template
3771 /// parameter pack from an outer level, which has already had its argument pack
3772 /// substituted but that still lives within a pack expansion that itself
3773 /// could not be instantiated. When actually performing a substitution into
3774 /// that pack expansion (e.g., when all template parameters have corresponding
3775 /// arguments), this type will be replaced with the appropriate underlying
3776 /// expression at the current pack substitution index.
3777 class SubstNonTypeTemplateParmPackExpr : public Expr {
3778 /// \brief The non-type template parameter pack itself.
3779 NonTypeTemplateParmDecl *Param;
3780
3781 /// \brief A pointer to the set of template arguments that this
3782 /// parameter pack is instantiated with.
3783 const TemplateArgument *Arguments;
3784
3785 /// \brief The number of template arguments in \c Arguments.
3786 unsigned NumArguments;
3787
3788 /// \brief The location of the non-type template parameter pack reference.
3789 SourceLocation NameLoc;
3790
3791 friend class ASTReader;
3792 friend class ASTStmtReader;
SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)3793 explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)
3794 : Expr(SubstNonTypeTemplateParmPackExprClass, Empty) { }
3795
3796 public:
3797 SubstNonTypeTemplateParmPackExpr(QualType T,
3798 NonTypeTemplateParmDecl *Param,
3799 SourceLocation NameLoc,
3800 const TemplateArgument &ArgPack);
3801
3802 /// \brief Retrieve the non-type template parameter pack being substituted.
getParameterPack()3803 NonTypeTemplateParmDecl *getParameterPack() const { return Param; }
3804
3805 /// \brief Retrieve the location of the parameter pack name.
getParameterPackLocation()3806 SourceLocation getParameterPackLocation() const { return NameLoc; }
3807
3808 /// \brief Retrieve the template argument pack containing the substituted
3809 /// template arguments.
3810 TemplateArgument getArgumentPack() const;
3811
getLocStart()3812 SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
getLocEnd()3813 SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
3814
classof(const Stmt * T)3815 static bool classof(const Stmt *T) {
3816 return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
3817 }
3818
3819 // Iterators
children()3820 child_range children() { return child_range(); }
3821 };
3822
3823 /// \brief Represents a reference to a function parameter pack that has been
3824 /// substituted but not yet expanded.
3825 ///
3826 /// When a pack expansion contains multiple parameter packs at different levels,
3827 /// this node is used to represent a function parameter pack at an outer level
3828 /// which we have already substituted to refer to expanded parameters, but where
3829 /// the containing pack expansion cannot yet be expanded.
3830 ///
3831 /// \code
3832 /// template<typename...Ts> struct S {
3833 /// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...));
3834 /// };
3835 /// template struct S<int, int>;
3836 /// \endcode
3837 class FunctionParmPackExpr : public Expr {
3838 /// \brief The function parameter pack which was referenced.
3839 ParmVarDecl *ParamPack;
3840
3841 /// \brief The location of the function parameter pack reference.
3842 SourceLocation NameLoc;
3843
3844 /// \brief The number of expansions of this pack.
3845 unsigned NumParameters;
3846
3847 FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack,
3848 SourceLocation NameLoc, unsigned NumParams,
3849 Decl * const *Params);
3850
3851 friend class ASTReader;
3852 friend class ASTStmtReader;
3853
3854 public:
3855 static FunctionParmPackExpr *Create(ASTContext &Context, QualType T,
3856 ParmVarDecl *ParamPack,
3857 SourceLocation NameLoc,
3858 ArrayRef<Decl *> Params);
3859 static FunctionParmPackExpr *CreateEmpty(ASTContext &Context,
3860 unsigned NumParams);
3861
3862 /// \brief Get the parameter pack which this expression refers to.
getParameterPack()3863 ParmVarDecl *getParameterPack() const { return ParamPack; }
3864
3865 /// \brief Get the location of the parameter pack.
getParameterPackLocation()3866 SourceLocation getParameterPackLocation() const { return NameLoc; }
3867
3868 /// \brief Iterators over the parameters which the parameter pack expanded
3869 /// into.
3870 typedef ParmVarDecl * const *iterator;
begin()3871 iterator begin() const { return reinterpret_cast<iterator>(this+1); }
end()3872 iterator end() const { return begin() + NumParameters; }
3873
3874 /// \brief Get the number of parameters in this parameter pack.
getNumExpansions()3875 unsigned getNumExpansions() const { return NumParameters; }
3876
3877 /// \brief Get an expansion of the parameter pack by index.
getExpansion(unsigned I)3878 ParmVarDecl *getExpansion(unsigned I) const { return begin()[I]; }
3879
getLocStart()3880 SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
getLocEnd()3881 SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
3882
classof(const Stmt * T)3883 static bool classof(const Stmt *T) {
3884 return T->getStmtClass() == FunctionParmPackExprClass;
3885 }
3886
children()3887 child_range children() { return child_range(); }
3888 };
3889
3890 /// \brief Represents a prvalue temporary that is written into memory so that
3891 /// a reference can bind to it.
3892 ///
3893 /// Prvalue expressions are materialized when they need to have an address
3894 /// in memory for a reference to bind to. This happens when binding a
3895 /// reference to the result of a conversion, e.g.,
3896 ///
3897 /// \code
3898 /// const int &r = 1.0;
3899 /// \endcode
3900 ///
3901 /// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is
3902 /// then materialized via a \c MaterializeTemporaryExpr, and the reference
3903 /// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues
3904 /// (either an lvalue or an xvalue, depending on the kind of reference binding
3905 /// to it), maintaining the invariant that references always bind to glvalues.
3906 ///
3907 /// Reference binding and copy-elision can both extend the lifetime of a
3908 /// temporary. When either happens, the expression will also track the
3909 /// declaration which is responsible for the lifetime extension.
3910 class MaterializeTemporaryExpr : public Expr {
3911 public:
3912 /// \brief The temporary-generating expression whose value will be
3913 /// materialized.
3914 Stmt *Temporary;
3915
3916 /// \brief The declaration which lifetime-extended this reference, if any.
3917 /// Either a VarDecl, or (for a ctor-initializer) a FieldDecl.
3918 const ValueDecl *ExtendingDecl;
3919
3920 friend class ASTStmtReader;
3921 friend class ASTStmtWriter;
3922
3923 public:
MaterializeTemporaryExpr(QualType T,Expr * Temporary,bool BoundToLvalueReference,const ValueDecl * ExtendedBy)3924 MaterializeTemporaryExpr(QualType T, Expr *Temporary,
3925 bool BoundToLvalueReference,
3926 const ValueDecl *ExtendedBy)
3927 : Expr(MaterializeTemporaryExprClass, T,
3928 BoundToLvalueReference? VK_LValue : VK_XValue, OK_Ordinary,
3929 Temporary->isTypeDependent(), Temporary->isValueDependent(),
3930 Temporary->isInstantiationDependent(),
3931 Temporary->containsUnexpandedParameterPack()),
3932 Temporary(Temporary), ExtendingDecl(ExtendedBy) {
3933 }
3934
MaterializeTemporaryExpr(EmptyShell Empty)3935 MaterializeTemporaryExpr(EmptyShell Empty)
3936 : Expr(MaterializeTemporaryExprClass, Empty) { }
3937
3938 /// \brief Retrieve the temporary-generating subexpression whose value will
3939 /// be materialized into a glvalue.
GetTemporaryExpr()3940 Expr *GetTemporaryExpr() const { return static_cast<Expr *>(Temporary); }
3941
3942 /// \brief Retrieve the storage duration for the materialized temporary.
getStorageDuration()3943 StorageDuration getStorageDuration() const {
3944 if (!ExtendingDecl)
3945 return SD_FullExpression;
3946 // FIXME: This is not necessarily correct for a temporary materialized
3947 // within a default initializer.
3948 if (isa<FieldDecl>(ExtendingDecl))
3949 return SD_Automatic;
3950 return cast<VarDecl>(ExtendingDecl)->getStorageDuration();
3951 }
3952
3953 /// \brief Get the declaration which triggered the lifetime-extension of this
3954 /// temporary, if any.
getExtendingDecl()3955 const ValueDecl *getExtendingDecl() const { return ExtendingDecl; }
3956
setExtendingDecl(const ValueDecl * ExtendedBy)3957 void setExtendingDecl(const ValueDecl *ExtendedBy) {
3958 ExtendingDecl = ExtendedBy;
3959 }
3960
3961 /// \brief Determine whether this materialized temporary is bound to an
3962 /// lvalue reference; otherwise, it's bound to an rvalue reference.
isBoundToLvalueReference()3963 bool isBoundToLvalueReference() const {
3964 return getValueKind() == VK_LValue;
3965 }
3966
getLocStart()3967 SourceLocation getLocStart() const LLVM_READONLY {
3968 return Temporary->getLocStart();
3969 }
getLocEnd()3970 SourceLocation getLocEnd() const LLVM_READONLY {
3971 return Temporary->getLocEnd();
3972 }
3973
classof(const Stmt * T)3974 static bool classof(const Stmt *T) {
3975 return T->getStmtClass() == MaterializeTemporaryExprClass;
3976 }
3977
3978 // Iterators
children()3979 child_range children() { return child_range(&Temporary, &Temporary + 1); }
3980 };
3981
3982 } // end namespace clang
3983
3984 #endif
3985