WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/clang/AST/ExprCXX.h

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

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/clang/AST/ExprCXX.h – Rev 14