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